import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Pranay2516
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskB solver = new TaskB();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskB {
        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int t = in.nextInt();
            while (t-- > 0) {
                int n = in.nextInt(), k = in.nextInt();
                int a[] = in.readIntArray(n);
                int f[] = new int[n];
                for (int i = 1; i < n - 1; ++i) {
                    if (a[i] > a[i - 1] && a[i] > a[i + 1]) f[i] = 1;
                }
                int cnt = 0, j = 0, max = 0, ind = 0, q = 0;
                for (int i = 0; i < n; ++i) {
                    if (j < k-1) {
                        if (j != 0 && j != k-1) if (f[i] == 1) cnt++;
                    }
                    if (j == k-1) {
                        if (max < cnt) {
                            max = cnt;
                            ind = q + 1;
                        }
                        cnt = 0;
                        j = 0;
                        q++;
                        i = q;
                    }
                    j++;
                }
                out.println((max + 1) + " " + ind);
            }
        }

    }

    static class FastReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private FastReader.SpaceCharFilter filter;

        public FastReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {

            if (numChars == -1)
                throw new InputMismatchException();

            if (curChar >= numChars) {

                curChar = 0;

                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }

                if (numChars <= 0)
                    return -1;
            }

            return buf[curChar++];
        }

        public int nextInt() {

            int c = read();

            while (isSpaceChar(c))
                c = read();

            int sgn = 1;

            if (c == '-') {
                sgn = -1;
                c = read();
            }

            int res = 0;

            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();

                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));

            return res * sgn;
        }

        public boolean isSpaceChar(int c) {

            if (filter != null)
                return filter.isSpaceChar(c);

            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public int[] readIntArray(int size) {
            int[] array = new int[size];
            for (int i = 0; i < size; i++) {
                array[i] = nextInt();
            }
            return array;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Pranay2516
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskB solver = new TaskB();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskB {
        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int t = in.nextInt();
            while (t-- > 0) {
                int n = in.nextInt(), k = in.nextInt();
                int a[] = in.readIntArray(n);
                int f[] = new int[n];
                for (int i = 1; i < n - 1; ++i) {
                    if (a[i] > a[i - 1] && a[i] > a[i + 1]) f[i] = 1;
                }
                long cnt = 0, j = 0, max = 0, ind = 0, q = 0;
                for (int i = 0; i < n; ++i) {
                    if (j < k-1) {
                        if (j != 0 && j != k-1) if (f[i] == 1) cnt++;
                    }
                    if (j == k-1) {
                        if (max < cnt) {
                            max = cnt;
                            ind = q + 1;
                        }
                        cnt = 0;
                        j = 0;
                        q++;
                        i = (int)q;
                    }
                    j++;
                }
                if(max==0) out.println(0+" "+0);
                else out.println((max + 1) + " " + ind);
            }
        }

    }

    static class FastReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private FastReader.SpaceCharFilter filter;

        public FastReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {

            if (numChars == -1)
                throw new InputMismatchException();

            if (curChar >= numChars) {

                curChar = 0;

                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }

                if (numChars <= 0)
                    return -1;
            }

            return buf[curChar++];
        }

        public int nextInt() {

            int c = read();

            while (isSpaceChar(c))
                c = read();

            int sgn = 1;

            if (c == '-') {
                sgn = -1;
                c = read();
            }

            int res = 0;

            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();

                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));

            return res * sgn;
        }

        public boolean isSpaceChar(int c) {

            if (filter != null)
                return filter.isSpaceChar(c);

            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public int[] readIntArray(int size) {
            int[] array = new int[size];
            for (int i = 0; i < size; i++) {
                array[i] = nextInt();
            }
            return array;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Pranay2516
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskB solver = new TaskB();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskB {
        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int t = in.nextInt();
            while (t-- > 0) {
                int n = in.nextInt(), k = in.nextInt();
                int a[] = in.readIntArray(n);
                int f[] = new int[n];
                Arrays.fill(f, 0);
                int max = -1, ind = 0;
                for (int i = 1; i < n - 1; ++i) if (a[i] > a[i + 1] && a[i] > a[i - 1]) f[i]++;
                for (int i = 1; i < n; ++i) f[i] = f[i] + f[i - 1];
                for (int i = 0; i < n - k + 2; ++i) {
                    if (max < f[i + k - 2] - f[i]) {
                        max = f[i + k - 2] - f[i];
                        ind = i;
                    }
                }
                out.println((max + 1) + " " + (ind + 1));
            }
        }

    }

    static class FastReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private FastReader.SpaceCharFilter filter;

        public FastReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {

            if (numChars == -1)
                throw new InputMismatchException();

            if (curChar >= numChars) {

                curChar = 0;

                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }

                if (numChars <= 0)
                    return -1;
            }

            return buf[curChar++];
        }

        public int nextInt() {

            int c = read();

            while (isSpaceChar(c))
                c = read();

            int sgn = 1;

            if (c == '-') {
                sgn = -1;
                c = read();
            }

            int res = 0;

            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();

                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));

            return res * sgn;
        }

        public boolean isSpaceChar(int c) {

            if (filter != null)
                return filter.isSpaceChar(c);

            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public int[] readIntArray(int size) {
            int[] array = new int[size];
            for (int i = 0; i < size; i++) {
                array[i] = nextInt();
            }
            return array;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}


import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;

public class B implements Runnable {

    public void run() {

        InputReader sc = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);

		int t = sc.nextInt();
		int n = 0, k = 0;
		int a[],p[];
		while(t--!=0)
		{
			n=sc.nextInt();
			k = sc.nextInt();
			p = new int[n+1];
			a = new int[n];
			sa(a,sc);

			for(int i=1;i<n-1;i++)
			{
				if(a[i]>a[i-1] && a[i]>a[i+1])
				{
					p[i]=1;
				}
				p[i]+=p[i-1];
			}

			p[n]+=p[n-1];

			int maxp=0,l=0;

			//for(int i=0;i<n;i++)out.print(p[i]+" ");
			//out.println();

			for(int i=0;i+k<=n;i++)
			{
				int aa=i;
				int b=i+k-2;

				int sum=p[b]-p[aa];

			//  out.println(++aa+" "+b+" "+sum);

				if(sum>maxp)
				{
					l=aa+1;
					maxp=sum;
				}
			}
			out.println((maxp+1)+" "+l);
		}

        out.close();
    }

//========================================================

	static class Pair
	{
		int a,b;
		Pair(int aa,int bb)
		{
			a=aa;
			b=bb;
		}
	}

	static void sa(int a[],InputReader sc)
	{
		for(int i=0;i<a.length;i++)
		{
			a[i]=sc.nextInt();
		}
	}

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;
        private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars==-1)
                throw new InputMismatchException();

            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                }
                catch (IOException e) {
                    throw new InputMismatchException();
                }

                if(numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        public int nextInt() {
            int c = read();

            while(isSpaceChar(c))
                c = read();

            int sgn = 1;

            if (c == '-') {
                sgn = -1;
                c = read();
            }

            int res = 0;
            do {
                if(c<'0'||c>'9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));

            return res * sgn;
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;

            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));
                return res * sgn;
        }

        public double nextDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

        public String readString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            }
            while (!isSpaceChar(c));

            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next() {
            return readString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }

    public static void main(String args[]) throws Exception {
        new Thread(null, new B(),"Main",1<<27).start();
    }
}


import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;

public class B implements Runnable {

    public void run() {

        InputReader sc = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);

		int t = sc.nextInt();
		int n = 0, k = 0;
		int a[],p[];
		while(t--!=0)
		{
			n=sc.nextInt();
			k = sc.nextInt()-2;
			p = new int[n+1];
			a = new int[n];
			sa(a,sc);

			for(int i=1;i<n-1;i++)
			{
				if(a[i]>a[i-1] && a[i]>a[i+1])
				{
					p[i+1]=1;
				}
				p[i+1]+=p[i];
			}

			p[n]+=p[n-1];

			int maxp=0,l=0;

			//for(int i=0;i<=n;i++)out.print(p[i]+" ");
			//out.println();

			for(int i=0;i+k<n;i++)
			{
				int aa=i+1;
				int b=i+k+1;

				int sum=p[b]-p[aa];

				//out.println(aa+" "+b+" "+sum);

				if(sum>maxp)
				{
					l=aa;
					maxp=sum;
				}
			}
			out.println((maxp+1)+" "+l);
		}

        out.close();
    }

//========================================================

	static class Pair
	{
		int a,b;
		Pair(int aa,int bb)
		{
			a=aa;
			b=bb;
		}
	}

	static void sa(int a[],InputReader sc)
	{
		for(int i=0;i<a.length;i++)
		{
			a[i]=sc.nextInt();
		}
	}

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;
        private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars==-1)
                throw new InputMismatchException();

            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                }
                catch (IOException e) {
                    throw new InputMismatchException();
                }

                if(numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        public int nextInt() {
            int c = read();

            while(isSpaceChar(c))
                c = read();

            int sgn = 1;

            if (c == '-') {
                sgn = -1;
                c = read();
            }

            int res = 0;
            do {
                if(c<'0'||c>'9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));

            return res * sgn;
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;

            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));
                return res * sgn;
        }

        public double nextDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

        public String readString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            }
            while (!isSpaceChar(c));

            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next() {
            return readString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }

    public static void main(String args[]) throws Exception {
        new Thread(null, new B(),"Main",1<<27).start();
    }
}


import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;

public class F implements Runnable {

    public void run() {

        InputReader sc = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);

		int t = sc.nextInt();
		int n = 0, k = 0;
		int a[],p[];
		while(t--!=0)
		{
			n=sc.nextInt();
			k = sc.nextInt()-2;
			p = new int[n+1];
			a = new int[n];
			sa(a,sc);

			for(int i=1;i<n-1;i++)
			{
				if(a[i]>a[i-1] && a[i]>a[i+1])
				{
					p[i+1]=1;
				}
				p[i+1]+=p[i];
			}

			p[n]+=p[n-1];

			int maxp=0,l=0;

			//for(int i=0;i<=n;i++)out.print(p[i]+" ");
			//out.println();

			for(int i=0;i+k<n;i++)
			{
				int aa=i+1;
				int b=i+k+1;

				int sum=p[b]-p[aa];

				//out.println(aa+" "+b+" "+sum);

				if(sum>maxp)
				{
					l=aa;
					maxp=sum;
				}
			}
			if(l==0)l++;
			out.println((maxp+1)+" "+l);
		}

        out.close();
    }

//========================================================

	static class Pair
	{
		int a,b;
		Pair(int aa,int bb)
		{
			a=aa;
			b=bb;
		}
	}

	static void sa(int a[],InputReader sc)
	{
		for(int i=0;i<a.length;i++)
		{
			a[i]=sc.nextInt();
		}
	}

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;
        private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars==-1)
                throw new InputMismatchException();

            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                }
                catch (IOException e) {
                    throw new InputMismatchException();
                }

                if(numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        public int nextInt() {
            int c = read();

            while(isSpaceChar(c))
                c = read();

            int sgn = 1;

            if (c == '-') {
                sgn = -1;
                c = read();
            }

            int res = 0;
            do {
                if(c<'0'||c>'9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));

            return res * sgn;
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;

            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));
                return res * sgn;
        }

        public double nextDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

        public String readString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            }
            while (!isSpaceChar(c));

            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next() {
            return readString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }

    public static void main(String args[]) throws Exception {
        new Thread(null, new F(),"Main",1<<27).start();
    }
}


import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;

public class B implements Runnable {

    public void run() {

        InputReader sc = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);

		int t = sc.nextInt();
		int n = 0, k = 0;
		int a[],p[];
		while(t--!=0)
		{
			n=sc.nextInt();
			k = sc.nextInt()-2;
			p = new int[n+1];
			a = new int[n];
			sa(a,sc);

			for(int i=1;i<n-1;i++)
			{
				if(a[i]>a[i-1] && a[i]>a[i+1])
				{
					p[i+1]=1;
				}
				p[i+1]+=p[i];
			}

			p[n]+=p[n-1];

			int maxp=0,l=0;

			//for(int i=0;i<=n;i++)out.print(p[i]+" ");
			//out.println();

			for(int i=0;i+k<n;i++)
			{
				int aa=i;
				int b=i+k+1;

				int sum=p[b]-p[aa];

				if(sum>maxp)
				{
					l=aa+1;
					maxp=sum;
				}
			}
			out.println((maxp+1)+" "+l);
		}

        out.close();
    }

//========================================================

	static class Pair
	{
		int a,b;
		Pair(int aa,int bb)
		{
			a=aa;
			b=bb;
		}
	}

	static void sa(int a[],InputReader sc)
	{
		for(int i=0;i<a.length;i++)
		{
			a[i]=sc.nextInt();
		}
	}

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;
        private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars==-1)
                throw new InputMismatchException();

            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                }
                catch (IOException e) {
                    throw new InputMismatchException();
                }

                if(numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        public int nextInt() {
            int c = read();

            while(isSpaceChar(c))
                c = read();

            int sgn = 1;

            if (c == '-') {
                sgn = -1;
                c = read();
            }

            int res = 0;
            do {
                if(c<'0'||c>'9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));

            return res * sgn;
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;

            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));
                return res * sgn;
        }

        public double nextDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

        public String readString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            }
            while (!isSpaceChar(c));

            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next() {
            return readString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }

    public static void main(String args[]) throws Exception {
        new Thread(null, new B(),"Main",1<<27).start();
    }
}


import java.io.*;
import java.util.*;
import java.math.*;

public class Solution {
	static FastReader sc=new FastReader();

	void run() {
	    int t=sc.nextInt();

	    while(t-->0){
			int n=sc.nextInt();
			int k=sc.nextInt();
			long a[]=new long[n];
			long pre[]=new long[n];
			for(int i=0;i<n;i++){
				a[i]=sc.nextLong();
			}

			long sum=0;
			for(int i=1;i<n-1;i++){
				if(a[i]>a[i-1] && a[i]>a[i+1]){
					sum++;
					pre[i]=sum;
					continue;
				}
				pre[i]=sum;
			}
			pre[n-1]=sum;

			/*for(int i=0;i<n;i++){
				System.out.print(pre[i]+" ");
			}
			System.out.println();*/
			if(sum==0){
				System.out.println(sum+1);
				continue;
			}

			long maxp=0,pos=-1;
			for(int i=0;i<n-(k-1);i++){
				long peaks=pre[i+k-2]-pre[i];
				//System.out.println(i+" "+" "+pre[i+k-2]+" "+pre[i]+" "+peaks+" "+maxp);
				if(maxp<peaks){
					maxp=peaks;
					pos=i+1;
				}
			}

			System.out.println((maxp+1)+" "+pos);

	    }
	}

	public static void main(String args[]) throws IOException {
		new  Solution().run();
	}

	static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                     InputStreamReader(System.in));
        }

            String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }

}


import java.io.*;
import java.util.*;
import java.math.*;

public class Solution {
	static FastReader sc=new FastReader();

	void run() {
	    int t=sc.nextInt();

	    while(t-->0){
			int n=sc.nextInt();
			int k=sc.nextInt();
			long a[]=new long[n];
			long pre[]=new long[n];
			for(int i=0;i<n;i++){
				a[i]=sc.nextLong();
			}

			long sum=0;
			for(int i=1;i<n-1;i++){
				if(a[i]>a[i-1] && a[i]>a[i+1]){
					sum++;
					pre[i]=sum;
					continue;
				}
				pre[i]=sum;
			}
			pre[n-1]=sum;

			/*for(int i=0;i<n;i++){
				System.out.print(pre[i]+" ");
			}
			System.out.println();*/
			if(sum==0){
				System.out.println("1 1");
				continue;
			}

			long maxp=0,pos=-1;
			for(int i=0;i<n-(k-1);i++){
				long peaks=pre[i+k-2]-pre[i];
				//System.out.println(i+" "+" "+pre[i+k-2]+" "+pre[i]+" "+peaks+" "+maxp);
				if(maxp<peaks){
					maxp=peaks;
					pos=i+1;
				}
			}

			System.out.println((maxp+1)+" "+pos);

	    }
	}

	public static void main(String args[]) throws IOException {
		new  Solution().run();
	}

	static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                     InputStreamReader(System.in));
        }

            String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }

}


import java.io.*;
import java.util.*;
import java.math.*;

public class Solution {
	static FastReader sc=new FastReader();

	void run() {
	    int t=sc.nextInt();

	    while(t-->0){
			int n=sc.nextInt();
			int k=sc.nextInt();
			long a[]=new long[n];
			long pre[]=new long[n];
			for(int i=0;i<n;i++){
				a[i]=sc.nextLong();
			}

			long sum=0;
			for(int i=1;i<n-1;i++){
				if(a[i]>a[i-1] && a[i]>a[i+1]){
					sum++;
					pre[i]=sum;
					continue;
				}
				pre[i]=sum;
			}
			pre[n-1]=sum;

			/*for(int i=0;i<n;i++){
				System.out.print(pre[i]+" ");
			}
			System.out.println();*/
			if(sum==0){
				System.out.println("0 0");
				continue;
			}

			long maxp=0,pos=-1;
			for(int i=0;i<n-(k-1);i++){
				long peaks=pre[i+k-2]-pre[i];
				//System.out.println(i+" "+" "+pre[i+k-2]+" "+pre[i]+" "+peaks+" "+maxp);
				if(maxp<peaks){
					maxp=peaks;
					pos=i+1;
				}
			}

			System.out.println((maxp+1)+" "+pos);

	    }
	}

	public static void main(String args[]) throws IOException {
		new  Solution().run();
	}

	static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                     InputStreamReader(System.in));
        }

            String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }

}


import java.io.*;
import java.util.*;

public class B {

	static long m = (long) (1e9 + 7);

	public static void main(String[] args) throws IOException {
		Scanner scn = new Scanner(System.in);
		StringBuilder sb = new StringBuilder();
		int T = scn.nextInt(), tcs = 0;
		B: while (tcs++ < T) {
			int n = scn.nextInt(), k = scn.nextInt();
			int v[] = new int[n];
			for (int i = 0; i < n; i++)
				v[i] = scn.nextInt();

			int ps[] = new int[n + 1];
			for (int i = 1; i < n - 1; i++) {
				if (v[i] > v[i - 1] && v[i] > v[i + 1])
					ps[i + 1] = ps[i] + 1;
				else
					ps[i + 1] = ps[i];
			}
			ps[n] = ps[n - 1];
			int mv = 0, l = 1;
			for (int i = 1; i <= n; ++i) {
				int j = i + k - 1;
				if (j > n)
					break;
				int s = ps[j] - ps[i - 1];
				if (ps[i] > ps[i - 1])
					s -= 1;
				if (ps[j] > ps[j - 1])
					s -= 1;
				if (s > mv) {
					mv = s;
					l = i;
				}
			}
			sb.append(++mv + " " + l + "\n");
		}
		System.out.print(sb);
	}

	static class Scanner {

		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}
	}
}


import java.io.*;
import java.util.*;

public class B {

	static long m = (long) (1e9 + 7);

	public static void main(String[] args) throws IOException {
		Scanner scn = new Scanner(System.in);
		StringBuilder sb = new StringBuilder();
		int T = scn.nextInt(), tcs = 0;
		B: while (tcs++ < T) {
			int n = scn.nextInt(), k = scn.nextInt();
			int a[] = new int[n + 1];
			for (int i = 1; i <= n; i++)
				a[i] = scn.nextInt();

			int ps[] = new int[n + 1];
			for (int i = 3; i <= n; i++) {
				ps[i] += ps[i - 1];
				if (a[i - 1] > a[i - 2] && a[i - 1] > a[i])
					ps[i]++;
			}
			int mx = 0, l = 0;
			for (int i = 1; i + k - 1 <= n; i++) {
				int c = ps[i + k - 1] - ps[i];
				if (c > mx) {
					mx = c;
					l = i;
				}
			}
			mx++;
			sb.append(mx + " " + l + "\n");
		}
		System.out.print(sb);
	}

	static class Scanner {

		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}
	}
}


import java.io.*;
import java.util.*;

public class B {

	static long m = (long) (1e9 + 7);

	public static void main(String[] args) throws IOException {
		Scanner scn = new Scanner(System.in);
		StringBuilder sb = new StringBuilder();
		int T = scn.nextInt(), tcs = 0;
		B: while (tcs++ < T) {
			int n = scn.nextInt(), k = scn.nextInt();
			int a[] = new int[n + 1];
			for (int i = 1; i <= n; i++)
				a[i] = scn.nextInt();

			int ps[] = new int[n + 1];
			for (int i = 3; i <= n; i++) {
				ps[i] += ps[i - 1];
				if (a[i - 1] > a[i - 2] && a[i - 1] > a[i])
					ps[i]++;
			}
			int mx = 0, l = 1;
			for (int i = 1; i + k - 1 <= n; i++) {
				int c = ps[i + k - 1] - ps[i];
				if (c > mx) {
					mx = c;
					l = i;
				}
			}
			mx++;
			sb.append(mx + " " + l + "\n");
		}
		System.out.print(sb);
	}

	static class Scanner {

		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}
	}
}


import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;

public class B {
	public static class pair implements Comparable<pair> {
		int id;
		int ans;

		pair(int x, int y) {

			id = x;
			ans = y;

		}

		public pair() {

		}

		public int compareTo(pair o) {
			// TODO Auto-generated method stub

			return this.id - o.id;
		}
	}

	static int mod = (int) 1e9 + 7;
	static ArrayList<Integer> gr[];
	static int ar[];
	static Scanner sc = new Scanner(System.in);
	static int pri[] = new int[(int) 1e6 + 5];
	static StringBuilder out = new StringBuilder();

	static int dp[];

		public static void main(String[] args) throws IOException {
		int t =  sc.nextInt();
		int a=0;
		while (t-- > 0) {

			int n=sc.nextInt();
			int k=sc.nextInt();
			ar=new int [n];
			for(int i=0;i<n;i++) {
				ar[i]=sc.nextInt();

			}
			int max=0;
			int l=1;

			HashMap<Integer,Integer>hm=new HashMap<>();
			dp=new int [n+1];

			int j=0;
			 dp[0]=0;
			 dp[n-1]=0;
			for(int i=1;i<n;i++) {
				if(i==n-1) {
					dp[i]=dp[i-1];
					continue;
				}
				if(ar[i]>ar[i-1] && ar[i]>ar[i+1])
			dp[i]=dp[i-1]+1;
				else dp[i]=dp[i-1];
			}

			dp[n]=dp[n-1];
			for(int i=k-1;i<n;i++) {
				if( i==k-1) {
					if(dp[i-1]>max) {max=dp[i-1];l=i-k+1;

					}
					continue;
				}
				if(dp[i-1]-dp[i-k+1]>max) {
					max=dp[i-1]-dp[i-k+1];
					l=i-k+1;
				}
			}

			out.append((max+1)+" "+(l+1)+"\n");

		}

		System.out.println(out);

	}

}


import java.util.*;
import java.io.*;

public class NastyaAndDoor {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        int T = sc.nextInt();
        while(T-- > 0){
            int n = sc.nextInt();
            int k = sc.nextInt();
            StringBuilder sb = new StringBuilder("");
            int A[] = new int[n + 1];
            for(int i = 1; i <= n; i++)
                A[i] = sc.nextInt();

            sb.append('0');
            for(int i = 2; i < n; i++){
                if(A[i] > A[i - 1] && A[i] > A[i + 1])
                    sb.append('1');
                else
                    sb.append('0');
            }

            int prefixSum[] = new int[n + 1];
            for(int i = 0; i < sb.length(); i++){
                char c = sb.charAt(i);
                prefixSum[i + 1] = prefixSum[i] + (c - 48);
            }

            int l = 1;
            int index = 0;
            int ans = 0;
            int max = Integer.MIN_VALUE;
            while(l <= n - k + 1){
                int t = prefixSum[l + k - 2] - prefixSum[l];
                if(t > max){
                    max = Math.max(max, t);
                    ans = t + 1;
                    index = l;
                }
                l++;
            }

            System.out.println(ans + " " + index);
        }
    }
}


import java.util.*;
import java.io.*;

public class NastyaAndDoor {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        int T = sc.nextInt();
        while(T-- > 0){
            int n = sc.nextInt();
            int k = sc.nextInt();
            StringBuilder sb = new StringBuilder("");
            int A[] = new int[n + 1];
            for(int i = 1; i <= n; i++)
                A[i] = sc.nextInt();

            sb.append('0');
            for(int i = 2; i < n; i++){
                if(A[i] > A[i - 1] && A[i] > A[i + 1])
                    sb.append('1');
                else
                    sb.append('0');
            }
            sb.append('0');

            int prefixSum[] = new int[n + 1];
            for(int i = 0; i < sb.length(); i++){
                char c = sb.charAt(i);
                prefixSum[i + 1] = prefixSum[i] + (c - 48);
            }

            int l = 1;
            int index = 0;
            int ans = 0;
            int max = Integer.MIN_VALUE;
            while(l <= n - k + 1){
                int t = prefixSum[l + k - 2] - prefixSum[l];
                if(t > max){
                    max = Math.max(max, t);
                    ans = t + 1;
                    index = l;
                }
                l++;
            }

            System.out.println(ans + " " + index);
        }
    }
}


import java.io.*;
import java.util.*;
public class NEWS
{
    static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        Scanner scan = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;
        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }
        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }
        public String nextString() throws IOException
        {
            String str00 = scan.next();
            return str00;
        }
        public String readLine() throws IOException
        {
            byte[] buf = new byte[64];
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }
        String next() throws IOException
        {
            int c;
            for (c = read(); c <= 32; c = read());
            StringBuilder sb = new StringBuilder();
            for (; c > 32; c = read())
            {
                sb.append((char) c);
            }
            return sb.toString();
        }
        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }
        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }
        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }
            if (neg)
                return -ret;
            return ret;
        }
        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }
        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }
        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
        public int[] nextArray(int n) throws IOException
        {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
            {
                a[i] = nextInt();
            }
            return a;
        }
    }
    public static void main(String args[])throws IOException
    {
        Reader r=new Reader();
        int t=r.nextInt();
        while(t-->0)
        {
            int n=r.nextInt();
            int k=r.nextInt();
            int a[]=r.nextArray(n);
            List<Integer> list=new ArrayList<>();
            int i,val=0;
            for(i=1;i<n-1;i++)
            {
                if(a[i]>a[i-1] && a[i]>a[i+1])
                {
                    list.add(i+1);
                }
            }
            Collections.sort(list);
            int l=list.get(0)-1;
            long p=1;
            for(i=0;i<list.size();i++)
            {
                if(list.get(i)>(l+k-1))
                {
                    break;
                }
                p++;
                val=list.get(i);
            }
            int y=l+k-2-val;
            l=l-y;
            if(l<1)
            {
                l=1;
            }
            System.out.println(p+" "+l);
        }
    }
}


import java.io.*;
import java.util.*;
public class NEWS
{
    static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        Scanner scan = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;
        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }
        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }
        public String nextString() throws IOException
        {
            String str00 = scan.next();
            return str00;
        }
        public String readLine() throws IOException
        {
            byte[] buf = new byte[64];
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }
        String next() throws IOException
        {
            int c;
            for (c = read(); c <= 32; c = read());
            StringBuilder sb = new StringBuilder();
            for (; c > 32; c = read())
            {
                sb.append((char) c);
            }
            return sb.toString();
        }
        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }
        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }
        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }
            if (neg)
                return -ret;
            return ret;
        }
        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }
        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }
        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
        public int[] nextArray(int n) throws IOException
        {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
            {
                a[i] = nextInt();
            }
            return a;
        }
    }
    public static void main(String args[])throws IOException
    {
        Reader r=new Reader();
        int t=r.nextInt();
        while(t-->0)
        {
            int n=r.nextInt();
            int k=r.nextInt();
            int a[]=r.nextArray(n);
            int ans[]=new int[n+1];
            int l=-1;
            long p=0,max=0;
            for(int i=1;i<n-1;i++)
            {
                if(a[i]>a[i-1] && a[i]>a[i+1])
                {
                    ans[i+1]=1;
                }
            }
            for(int i=2;i<k;i++)
            {
                if(ans[i]==1)
                {
                    p++;
                }
            }
            max=p;
            l=1;
            for(int i=3;i<=n;i++)
            {
                if((i+k-3)>n-1)
                {
                    break;
                }
                p=p-ans[i-1]+ans[i+k-3];
                if(max<p)
                {
                    max=p;
                    l=i-1;
                }
            }
            System.out.println((max+1)+" "+l);
        }
    }
}


import java.io.*;
import java.util.*;
public class NEWS
{
    static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        Scanner scan = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;
        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }
        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }
        public String nextString() throws IOException
        {
            String str00 = scan.next();
            return str00;
        }
        public String readLine() throws IOException
        {
            byte[] buf = new byte[64];
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }
        String next() throws IOException
        {
            int c;
            for (c = read(); c <= 32; c = read());
            StringBuilder sb = new StringBuilder();
            for (; c > 32; c = read())
            {
                sb.append((char) c);
            }
            return sb.toString();
        }
        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }
        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }
        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }
            if (neg)
                return -ret;
            return ret;
        }
        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }
        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }
        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
        public int[] nextArray(int n) throws IOException
        {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
            {
                a[i] = nextInt();
            }
            return a;
        }
    }
    public static void main(String args[])throws IOException
    {
        Reader r=new Reader();
        int t=r.nextInt();
        while(t-->0)
        {
            int n=r.nextInt();
            int k=r.nextInt();
            int a[]=r.nextArray(n);
            List<Integer> list=new ArrayList<>();
            int i,val=0;
            for(i=1;i<n-1;i++)
            {
                if(a[i]>a[i-1] && a[i]>a[i+1])
                {
                    list.add(i+1);
                }
            }
            Collections.sort(list);
            if(list.size()==0)
            {
                System.out.println("1 1");
                continue;
            }
            int l=list.get(0)-1;
            long p=1;
            for(i=0;i<list.size();i++)
            {
                if(list.get(i)>(l+k-1))
                {
                    break;
                }
                p++;
                val=list.get(i);
            }
            int y=l+k-2-val;
            l=l-y;
            if(l<1)
            {
                l=1;
            }
            System.out.println(p+" "+l);
        }
    }
}


import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;

public class Main {
    public static void main(String args[] ) throws Exception {
        int test = GetInput.getInt();
        while (test-->0){
            int []ins = GetInput.getArrayInt();
            int n = ins[0];
            int k = ins[1];
            int[] array = GetInput.getArrayInt();
            int l= 0;
            int currMax = 0;
            int peakCount = 0;
            boolean[] peaks = new boolean[n];
            for (int i = 1; i < n-1; i++) {
                if (array[i] > array[i - 1] && array[i] > array[i + 1]) {
                    peaks[i] = true;
                    if (i < k-1){
                        currMax++;
                    }
                }
            }
            l = 1;
            peakCount = currMax;
            for (int i = k-1; i<n-1; i++){
                if (peaks[i]){
                    peakCount++;
                }
                if (peaks[i-k+2]){
                    peakCount--;
                }
                if (peakCount>currMax){
                    currMax=peakCount;
                    l = i-k+2+1;
                }
            }
            System.out.println(currMax+1+" "+l);
        }
    }
}

class GetInput {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

    static char[] getCharArray() {
        char[] charArray;
        try {
            StringBuilder string = getInputString();
            charArray = new char[string.length()];
            for (int i = 0; i < string.length(); i++) {
                charArray[i] = string.charAt(i);
            }
            return charArray;
        } catch (Exception e) {
            e.printStackTrace();
        }
        charArray = new char[0];
        return charArray;
    }

    static int[] getArrayInt() {
        String[] string;
        int[] array;
        try {
            string = bufferedReader.readLine().split("\\s+");
            array = new int[string.length];
            for (int i = 0; i < string.length; i++) {
                array[i] = Integer.parseInt(string[i]);
            }
            return array;
        } catch (IOException e) {
            e.printStackTrace();
        }

        int[] arra = new int[2];
        return arra;
    }

    static int getInt() {
        try {
            String string = bufferedReader.readLine();
            return Integer.parseInt(string);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return 0;
    }

    static StringBuilder getInputString() {
        try {
            StringBuilder string = new StringBuilder();
            string.append(bufferedReader.readLine());
            return string;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return new StringBuilder();
    }

    static long getLongInput() {
        try {
            String string = bufferedReader.readLine();
            return Long.parseLong(string);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return 0;
    }

    static long[] getLongArrayInput() {
        String[] string;
        long[] array;
        try {
            string = bufferedReader.readLine().split("\\s+");
            array = new long[string.length];
            for (int i = 0; i < string.length; i++) {
                array[i] = Long.parseLong(string[i]);
            }
            return array;
        } catch (IOException e) {
            e.printStackTrace();
        }

        long[] arra = new long[2];
        return arra;
    }
}


import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;

public class Main {
    public static void main(String args[] ) throws Exception {
        int test = GetInput.getInt();
        while (test-->0){
            int []ins = GetInput.getArrayInt();
            int n = ins[0];
            int k = ins[1];
            int[] array = GetInput.getArrayInt();
            int l= 1;
            int noOfPeaks = 0;
            int currMax = 0;
//            boolean[] peaks = new boolean[n];
//            for (int i = 1; i < n-1; i++){
//                if (array[i]>array[i-1] && array[i]>array[i+1]){
//                    peaks[i] = true;
//                    noOfPeaks++;
//                }
//                if (i == k-1){
//                    currMax = noOfPeaks;
//                    l = i;
//                    continue;
//                }
//                if (i>k-1) {
//                    if (peaks[i - k + 1]) {
//                        noOfPeaks--;
//                    }
//                    if (noOfPeaks>currMax){
//                        currMax = noOfPeaks;
//                        l = i;
//                    }
//                }
//            }
//            System.out.println((currMax+1)+" "+(l+2-k));
//
            for (int i = 0; i < n-k+1; i++){
                for (int j = i+1; j<=i+k-2; j++){

                    if (array[j]>array[j-1] && array[j]>array[j+1]){
                        noOfPeaks++;
                        j++;
                    }

                }
                if (noOfPeaks>currMax){
                    currMax=noOfPeaks;
                    l = i+1;
                }
                noOfPeaks = 0;

            }
            if (currMax == 0 ){
                currMax--;
            }
            System.out.println(currMax+1+" "+(l));

        }
    }
}

class GetInput {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

    static char[] getCharArray() {
        char[] charArray;
        try {
            StringBuilder string = getInputString();
            charArray = new char[string.length()];
            for (int i = 0; i < string.length(); i++) {
                charArray[i] = string.charAt(i);
            }
            return charArray;
        } catch (Exception e) {
            e.printStackTrace();
        }
        charArray = new char[0];
        return charArray;
    }

    static int[] getArrayInt() {
        String[] string;
        int[] array;
        try {
            string = bufferedReader.readLine().split("\\s+");
            array = new int[string.length];
            for (int i = 0; i < string.length; i++) {
                array[i] = Integer.parseInt(string[i]);
            }
            return array;
        } catch (IOException e) {
            e.printStackTrace();
        }

        int[] arra = new int[2];
        return arra;
    }

    static int getInt() {
        try {
            String string = bufferedReader.readLine();
            return Integer.parseInt(string);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return 0;
    }

    static StringBuilder getInputString() {
        try {
            StringBuilder string = new StringBuilder();
            string.append(bufferedReader.readLine());
            return string;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return new StringBuilder();
    }

    static long getLongInput() {
        try {
            String string = bufferedReader.readLine();
            return Long.parseLong(string);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return 0;
    }

    static long[] getLongArrayInput() {
        String[] string;
        long[] array;
        try {
            string = bufferedReader.readLine().split("\\s+");
            array = new long[string.length];
            for (int i = 0; i < string.length; i++) {
                array[i] = Long.parseLong(string[i]);
            }
            return array;
        } catch (IOException e) {
            e.printStackTrace();
        }

        long[] arra = new long[2];
        return arra;
    }
}


import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;

public class Main {
    public static void main(String args[] ) throws Exception {
        int test = GetInput.getInt();
        while (test-->0){
            int []ins = GetInput.getArrayInt();
            int n = ins[0];
            int k = ins[1];
            int[] array = GetInput.getArrayInt();
            int l= 0;
            int currMax = 0;
            boolean[] peaks = new boolean[n];
            for (int i = 1; i < n-1; i++) {
                if (array[i] > array[i - 1] && array[i] > array[i + 1]) {
                    peaks[i] = true;
                }
            }
            for (int i = 1; i <= n-k; i++){
                int count = 0;
                for (int j = 0; j <=k-2; j++){
                    if (peaks[i+j]){
                        count++;
                    }
                }
                if (count>currMax){
                    currMax = count;
                    l = i;
                }
            }
            System.out.println((currMax+1)+" "+(l+1));

        }
    }
}

class GetInput {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

    static char[] getCharArray() {
        char[] charArray;
        try {
            StringBuilder string = getInputString();
            charArray = new char[string.length()];
            for (int i = 0; i < string.length(); i++) {
                charArray[i] = string.charAt(i);
            }
            return charArray;
        } catch (Exception e) {
            e.printStackTrace();
        }
        charArray = new char[0];
        return charArray;
    }

    static int[] getArrayInt() {
        String[] string;
        int[] array;
        try {
            string = bufferedReader.readLine().split("\\s+");
            array = new int[string.length];
            for (int i = 0; i < string.length; i++) {
                array[i] = Integer.parseInt(string[i]);
            }
            return array;
        } catch (IOException e) {
            e.printStackTrace();
        }

        int[] arra = new int[2];
        return arra;
    }

    static int getInt() {
        try {
            String string = bufferedReader.readLine();
            return Integer.parseInt(string);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return 0;
    }

    static StringBuilder getInputString() {
        try {
            StringBuilder string = new StringBuilder();
            string.append(bufferedReader.readLine());
            return string;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return new StringBuilder();
    }

    static long getLongInput() {
        try {
            String string = bufferedReader.readLine();
            return Long.parseLong(string);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return 0;
    }

    static long[] getLongArrayInput() {
        String[] string;
        long[] array;
        try {
            string = bufferedReader.readLine().split("\\s+");
            array = new long[string.length];
            for (int i = 0; i < string.length; i++) {
                array[i] = Long.parseLong(string[i]);
            }
            return array;
        } catch (IOException e) {
            e.printStackTrace();
        }

        long[] arra = new long[2];
        return arra;
    }
}


import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;

public class Main {
    public static void main(String args[] ) throws Exception {
        int test = GetInput.getInt();
        while (test-->0){
            int []ins = GetInput.getArrayInt();
            int n = ins[0];
            int k = ins[1];
            int[] array = GetInput.getArrayInt();
            int l= 0;
            int noOfPeaks = 0;
            int currMax = 0;

            for (int i = 0; i < n-k+1; i++){
                for (int j = i+1; j<i+k-1; j++){

                    if (array[j]>array[j-1] && array[j]>array[j+1]){
                        noOfPeaks++;
                        j++;
                    }

                }
                if (noOfPeaks>currMax){
                    currMax=noOfPeaks;
                    l = i+1;
                }
                noOfPeaks = 0;

            }
            if (currMax == 0 ){
                currMax--;
            }
            System.out.println(currMax+1+" "+(l));
//            int peakCountMax = 0;
//            for (int i = 0; i < k+1;i++){
//                if (peak[i])
//                peakCountMax++;
//            }
//            noOfPeaks = peakCountMax;
//            for (int i = k+1; i < n; i++){
//                int
//                noOfPeaks = peakCountMax +
//            }
        }
    }
}

class GetInput {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

    static char[] getCharArray() {
        char[] charArray;
        try {
            StringBuilder string = getInputString();
            charArray = new char[string.length()];
            for (int i = 0; i < string.length(); i++) {
                charArray[i] = string.charAt(i);
            }
            return charArray;
        } catch (Exception e) {
            e.printStackTrace();
        }
        charArray = new char[0];
        return charArray;
    }

    static int[] getArrayInt() {
        String[] string;
        int[] array;
        try {
            string = bufferedReader.readLine().split("\\s+");
            array = new int[string.length];
            for (int i = 0; i < string.length; i++) {
                array[i] = Integer.parseInt(string[i]);
            }
            return array;
        } catch (IOException e) {
            e.printStackTrace();
        }

        int[] arra = new int[2];
        return arra;
    }

    static int getInt() {
        try {
            String string = bufferedReader.readLine();
            return Integer.parseInt(string);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return 0;
    }

    static StringBuilder getInputString() {
        try {
            StringBuilder string = new StringBuilder();
            string.append(bufferedReader.readLine());
            return string;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return new StringBuilder();
    }

    static long getLongInput() {
        try {
            String string = bufferedReader.readLine();
            return Long.parseLong(string);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return 0;
    }

    static long[] getLongArrayInput() {
        String[] string;
        long[] array;
        try {
            string = bufferedReader.readLine().split("\\s+");
            array = new long[string.length];
            for (int i = 0; i < string.length; i++) {
                array[i] = Long.parseLong(string[i]);
            }
            return array;
        } catch (IOException e) {
            e.printStackTrace();
        }

        long[] arra = new long[2];
        return arra;
    }
}


import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;

public class Main {
    public static void main(String args[] ) throws Exception {
        int test = GetInput.getInt();
        while (test-->0){
            int []ins = GetInput.getArrayInt();
            int n = ins[0];
            int k = ins[1];
            int[] array = GetInput.getArrayInt();
            int l= 0;
            int noOfPeaks = 0;
            int currMax = 0;
//            boolean[] peaks = new boolean[n];
//            for (int i = 1; i < n-1; i++){
//                if (array[i]>array[i-1] && array[i]>array[i+1]){
//                    peaks[i] = true;
//                    noOfPeaks++;
//                }
//                if (i == k-1){
//                    currMax = noOfPeaks;
//                    l = i;
//                    continue;
//                }
//                if (i>k-1) {
//                    if (peaks[i - k + 1]) {
//                        noOfPeaks--;
//                    }
//                    if (noOfPeaks>currMax){
//                        currMax = noOfPeaks;
//                        l = i;
//                    }
//                }
//            }
//            System.out.println((currMax+1)+" "+(l+2-k));
//
            for (int i = 0; i < n-k+1; i++){
                for (int j = i+1; j<=i+k-2; j++){

                    if (array[j]>array[j-1] && array[j]>array[j+1]){
                        noOfPeaks++;
                        j++;
                    }

                }
                if (noOfPeaks>currMax){
                    currMax=noOfPeaks;
                    l = i+1;
                }
                noOfPeaks = 0;

            }

            System.out.println(currMax+1+" "+(l));

        }
    }
}

class GetInput {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

    static char[] getCharArray() {
        char[] charArray;
        try {
            StringBuilder string = getInputString();
            charArray = new char[string.length()];
            for (int i = 0; i < string.length(); i++) {
                charArray[i] = string.charAt(i);
            }
            return charArray;
        } catch (Exception e) {
            e.printStackTrace();
        }
        charArray = new char[0];
        return charArray;
    }

    static int[] getArrayInt() {
        String[] string;
        int[] array;
        try {
            string = bufferedReader.readLine().split("\\s+");
            array = new int[string.length];
            for (int i = 0; i < string.length; i++) {
                array[i] = Integer.parseInt(string[i]);
            }
            return array;
        } catch (IOException e) {
            e.printStackTrace();
        }

        int[] arra = new int[2];
        return arra;
    }

    static int getInt() {
        try {
            String string = bufferedReader.readLine();
            return Integer.parseInt(string);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return 0;
    }

    static StringBuilder getInputString() {
        try {
            StringBuilder string = new StringBuilder();
            string.append(bufferedReader.readLine());
            return string;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return new StringBuilder();
    }

    static long getLongInput() {
        try {
            String string = bufferedReader.readLine();
            return Long.parseLong(string);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return 0;
    }

    static long[] getLongArrayInput() {
        String[] string;
        long[] array;
        try {
            string = bufferedReader.readLine().split("\\s+");
            array = new long[string.length];
            for (int i = 0; i < string.length; i++) {
                array[i] = Long.parseLong(string[i]);
            }
            return array;
        } catch (IOException e) {
            e.printStackTrace();
        }

        long[] arra = new long[2];
        return arra;
    }
}


import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;

public class Main {
    public static void main(String args[] ) throws Exception {
        int test = GetInput.getInt();
        while (test-->0){
            int []ins = GetInput.getArrayInt();
            int n = ins[0];
            int k = ins[1];
            int[] array = GetInput.getArrayInt();
            int l= 0;
            int noOfPeaks = 0;
            int currMax = 0;
            boolean []peak = new boolean[n];
//            for (int i = 1 ; i<n-1; i++){
//                if (array[i]>array[i-1] && array[i]>array[i+1]){
//                    peak[i] = true;
//                    noOfPeaks++;
//                }
//                if (i  == k-1){
//                    currMax = noOfPeaks;
//                    l=i-k+1;
//                }
//                if (i>=k){
//                    if (peak[i] == false){
//                        noOfPeaks--;
//                    }
//                    if (peak[i-k] ==true){
//                        noOfPeaks--;
//                    }
//                }
//                if (currMax<noOfPeaks){
//                    l=i;
//                }
//            }

            for (int i = 0; i < n-k+1; i++){
                for (int j = i+1; j<i+k-1; j++){
                    if (j>=n-1){
                        break;
                    }
                    if (array[j]>array[j-1] && array[j]>array[j+1]){
                        noOfPeaks++;
                        j++;
                    }

                }
                if (noOfPeaks>currMax){
                    currMax=noOfPeaks;
//                    System.out.println(i+1);
                    l = i+1;
                }
                noOfPeaks = 0;

            }
            System.out.println(currMax+1+" "+(l));
//            int peakCountMax = 0;
//            for (int i = 0; i < k+1;i++){
//                if (peak[i])
//                peakCountMax++;
//            }
//            noOfPeaks = peakCountMax;
//            for (int i = k+1; i < n; i++){
//                int
//                noOfPeaks = peakCountMax +
//            }
        }
    }
}

class GetInput {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

    static char[] getCharArray() {
        char[] charArray;
        try {
            StringBuilder string = getInputString();
            charArray = new char[string.length()];
            for (int i = 0; i < string.length(); i++) {
                charArray[i] = string.charAt(i);
            }
            return charArray;
        } catch (Exception e) {
            e.printStackTrace();
        }
        charArray = new char[0];
        return charArray;
    }

    static int[] getArrayInt() {
        String[] string;
        int[] array;
        try {
            string = bufferedReader.readLine().split("\\s+");
            array = new int[string.length];
            for (int i = 0; i < string.length; i++) {
                array[i] = Integer.parseInt(string[i]);
            }
            return array;
        } catch (IOException e) {
            e.printStackTrace();
        }

        int[] arra = new int[2];
        return arra;
    }

    static int getInt() {
        try {
            String string = bufferedReader.readLine();
            return Integer.parseInt(string);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return 0;
    }

    static StringBuilder getInputString() {
        try {
            StringBuilder string = new StringBuilder();
            string.append(bufferedReader.readLine());
            return string;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return new StringBuilder();
    }

    static long getLongInput() {
        try {
            String string = bufferedReader.readLine();
            return Long.parseLong(string);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return 0;
    }

    static long[] getLongArrayInput() {
        String[] string;
        long[] array;
        try {
            string = bufferedReader.readLine().split("\\s+");
            array = new long[string.length];
            for (int i = 0; i < string.length; i++) {
                array[i] = Long.parseLong(string[i]);
            }
            return array;
        } catch (IOException e) {
            e.printStackTrace();
        }

        long[] arra = new long[2];
        return arra;
    }
}


import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;

public class Main {
    public static void main(String args[] ) throws Exception {
        int test = GetInput.getInt();
        while (test-->0){
            int []ins = GetInput.getArrayInt();
            int n = ins[0];
            int k = ins[1];
            int[] array = GetInput.getArrayInt();
            int l= 0;
            int noOfPeaks = 0;
            int currMax = 0;
//            boolean[] peaks = new boolean[n];
//            for (int i = 1; i < n-1; i++){
//                if (array[i]>array[i-1] && array[i]>array[i+1]){
//                    peaks[i] = true;
//                    noOfPeaks++;
//                }
//                if (i == k-1){
//                    currMax = noOfPeaks;
//                    l = i;
//                    continue;
//                }
//                if (i>k-1) {
//                    if (peaks[i - k + 1]) {
//                        noOfPeaks--;
//                    }
//                    if (noOfPeaks>currMax){
//                        currMax = noOfPeaks;
//                        l = i;
//                    }
//                }
//            }
//            System.out.println((currMax+1)+" "+(l+2-k));
//
            for (int i = 0; i < n-k+1; i++){
                for (int j = i+1; j<=i+k-2; j++){

                    if (array[j]>array[j-1] && array[j]>array[j+1]){
                        noOfPeaks++;
                        j++;
                    }

                }
                if (noOfPeaks>currMax){
                    currMax=noOfPeaks;
                    l = i+1;
                }
                noOfPeaks = 0;

            }
            if (currMax == 0 ){
                currMax--;
            }
            System.out.println(currMax+1+" "+(l));

        }
    }
}

class GetInput {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

    static char[] getCharArray() {
        char[] charArray;
        try {
            StringBuilder string = getInputString();
            charArray = new char[string.length()];
            for (int i = 0; i < string.length(); i++) {
                charArray[i] = string.charAt(i);
            }
            return charArray;
        } catch (Exception e) {
            e.printStackTrace();
        }
        charArray = new char[0];
        return charArray;
    }

    static int[] getArrayInt() {
        String[] string;
        int[] array;
        try {
            string = bufferedReader.readLine().split("\\s+");
            array = new int[string.length];
            for (int i = 0; i < string.length; i++) {
                array[i] = Integer.parseInt(string[i]);
            }
            return array;
        } catch (IOException e) {
            e.printStackTrace();
        }

        int[] arra = new int[2];
        return arra;
    }

    static int getInt() {
        try {
            String string = bufferedReader.readLine();
            return Integer.parseInt(string);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return 0;
    }

    static StringBuilder getInputString() {
        try {
            StringBuilder string = new StringBuilder();
            string.append(bufferedReader.readLine());
            return string;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return new StringBuilder();
    }

    static long getLongInput() {
        try {
            String string = bufferedReader.readLine();
            return Long.parseLong(string);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return 0;
    }

    static long[] getLongArrayInput() {
        String[] string;
        long[] array;
        try {
            string = bufferedReader.readLine().split("\\s+");
            array = new long[string.length];
            for (int i = 0; i < string.length; i++) {
                array[i] = Long.parseLong(string[i]);
            }
            return array;
        } catch (IOException e) {
            e.printStackTrace();
        }

        long[] arra = new long[2];
        return arra;
    }
}


import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;

public class Main {
    public static void main(String args[] ) throws Exception {
        int test = GetInput.getInt();
        while (test-->0){
            int []ins = GetInput.getArrayInt();
            int n = ins[0];
            int k = ins[1];
            int[] array = GetInput.getArrayInt();
            int l= 0;
            int currMax = -1;
            boolean[] peaks = new boolean[n];
            for (int i = 1; i < n-1; i++) {
                if (array[i] > array[i - 1] && array[i] > array[i + 1]) {
                    peaks[i] = true;
                }
            }

            for (int i = 0; i <= n-k; i++){
                int count = 0;
                for (int j = 1; j <=k-2; j++){
                    if (peaks[i+j]){
                        count++;
                    }
                }
                if (count>currMax){
                    currMax = count;
                    l = i;
                }
            }
            System.out.println((currMax+1)+" "+(l+1));

        }
    }
}

class GetInput {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

    static char[] getCharArray() {
        char[] charArray;
        try {
            StringBuilder string = getInputString();
            charArray = new char[string.length()];
            for (int i = 0; i < string.length(); i++) {
                charArray[i] = string.charAt(i);
            }
            return charArray;
        } catch (Exception e) {
            e.printStackTrace();
        }
        charArray = new char[0];
        return charArray;
    }

    static int[] getArrayInt() {
        String[] string;
        int[] array;
        try {
            string = bufferedReader.readLine().split("\\s+");
            array = new int[string.length];
            for (int i = 0; i < string.length; i++) {
                array[i] = Integer.parseInt(string[i]);
            }
            return array;
        } catch (IOException e) {
            e.printStackTrace();
        }

        int[] arra = new int[2];
        return arra;
    }

    static int getInt() {
        try {
            String string = bufferedReader.readLine();
            return Integer.parseInt(string);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return 0;
    }

    static StringBuilder getInputString() {
        try {
            StringBuilder string = new StringBuilder();
            string.append(bufferedReader.readLine());
            return string;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return new StringBuilder();
    }

    static long getLongInput() {
        try {
            String string = bufferedReader.readLine();
            return Long.parseLong(string);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return 0;
    }

    static long[] getLongArrayInput() {
        String[] string;
        long[] array;
        try {
            string = bufferedReader.readLine().split("\\s+");
            array = new long[string.length];
            for (int i = 0; i < string.length; i++) {
                array[i] = Long.parseLong(string[i]);
            }
            return array;
        } catch (IOException e) {
            e.printStackTrace();
        }

        long[] arra = new long[2];
        return arra;
    }
}


import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;

public class Main {
    public static void main(String args[] ) throws Exception {
        int test = GetInput.getInt();
        while (test-->0){
            int []ins = GetInput.getArrayInt();
            int n = ins[0];
            int k = ins[1];
            int[] array = GetInput.getArrayInt();
            int l= 0;
            int noOfPeaks = 0;
            int currMax = 0;
            boolean []peak = new boolean[n];
//            for (int i = 1 ; i<n-1; i++){
//                if (array[i]>array[i-1] && array[i]>array[i+1]){
//                    peak[i] = true;
//                    noOfPeaks++;
//                }
//                if (i  == k-1){
//                    currMax = noOfPeaks;
//                    l=i-k+1;
//                }
//                if (i>=k){
//                    if (peak[i] == false){
//                        noOfPeaks--;
//                    }
//                    if (peak[i-k] ==true){
//                        noOfPeaks--;
//                    }
//                }
//                if (currMax<noOfPeaks){
//                    l=i;
//                }
//            }

            for (int i = 0; i < n; i++){
                for (int j = i+1; j<i+k-1; j++){
                    if (j>=n-1){
                        break;
                    }
                    if (array[j]>array[j-1] && array[j]>array[j+1]){
                        noOfPeaks++;
                        j++;
                    }

                }
                if (noOfPeaks>currMax){
                    currMax=noOfPeaks;
//                    System.out.println(i+1);
                    l = i+1;
                }
                noOfPeaks = 0;

            }
            System.out.println(currMax+1+" "+(l));
//            int peakCountMax = 0;
//            for (int i = 0; i < k+1;i++){
//                if (peak[i])
//                peakCountMax++;
//            }
//            noOfPeaks = peakCountMax;
//            for (int i = k+1; i < n; i++){
//                int
//                noOfPeaks = peakCountMax +
//            }
        }
    }
}

class GetInput {
    static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

    static char[] getCharArray() {
        char[] charArray;
        try {
            StringBuilder string = getInputString();
            charArray = new char[string.length()];
            for (int i = 0; i < string.length(); i++) {
                charArray[i] = string.charAt(i);
            }
            return charArray;
        } catch (Exception e) {
            e.printStackTrace();
        }
        charArray = new char[0];
        return charArray;
    }

    static int[] getArrayInt() {
        String[] string;
        int[] array;
        try {
            string = bufferedReader.readLine().split("\\s+");
            array = new int[string.length];
            for (int i = 0; i < string.length; i++) {
                array[i] = Integer.parseInt(string[i]);
            }
            return array;
        } catch (IOException e) {
            e.printStackTrace();
        }

        int[] arra = new int[2];
        return arra;
    }

    static int getInt() {
        try {
            String string = bufferedReader.readLine();
            return Integer.parseInt(string);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return 0;
    }

    static StringBuilder getInputString() {
        try {
            StringBuilder string = new StringBuilder();
            string.append(bufferedReader.readLine());
            return string;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return new StringBuilder();
    }

    static long getLongInput() {
        try {
            String string = bufferedReader.readLine();
            return Long.parseLong(string);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return 0;
    }

    static long[] getLongArrayInput() {
        String[] string;
        long[] array;
        try {
            string = bufferedReader.readLine().split("\\s+");
            array = new long[string.length];
            for (int i = 0; i < string.length; i++) {
                array[i] = Long.parseLong(string[i]);
            }
            return array;
        } catch (IOException e) {
            e.printStackTrace();
        }

        long[] arra = new long[2];
        return arra;
    }
}