description: Consider a sequence of integers a_1, a_2, …, a_n. In one move, you can select any element of the sequence and delete it. After an element is deleted, all elements to the right are shifted to the left by 1 position, so there are no empty spaces in the sequence. So after you make a move, the sequence's length decreases by 1. The indices of the elements after the move are recalculated.
  
  E. g. let the sequence be a=[3, 2, 2, 1, 5]. Let's select the element a_3=2 in a move. Then after the move the sequence will be equal to a=[3, 2, 1, 5], so the 3-rd element of the new sequence will be a_3=1 and the 4-th element will be a_4=5.
  
  You are given a sequence a_1, a_2, …, a_n and a number k. You need to find the minimum number of moves you have to make so that in the resulting sequence there will be at least k elements that are equal to their indices, i. e. the resulting sequence b_1, b_2, …, b_m will contain at least k indices i such that b_i = i.
  
  Input
  
  The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
  
  Each test case consists of two consecutive lines. The first line contains two integers n and k (1 ≤ k ≤ n ≤ 2000). The second line contains a sequence of integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n). The numbers in the sequence are not necessarily different.
  
  It is guaranteed that the sum of n over all test cases doesn't exceed 2000.
  
  Output
  
  For each test case output in a single line:
  
    * -1 if there's no desired move sequence; 
    * otherwise, the integer x (0 ≤ x ≤ n) — the minimum number of the moves to be made so that the resulting sequence will contain at least k elements that are equal to their indices. 
  
  Example
  
  Input
  
  
  4
  7 6
  1 1 2 3 4 5 6
  5 2
  5 1 3 2 3
  5 2
  5 5 5 5 4
  8 4
  1 2 3 3 2 2 5 5
  
  
  Output
  
  
  1
  2
  -1
  2
  
  Note
  
  In the first test case the sequence doesn't satisfy the desired condition, but it can be provided by deleting the first element, hence the sequence will be [1, 2, 3, 4, 5, 6] and 6 elements will be equal to their indices.
  
  In the second test case there are two ways to get the desired result in 2 moves: the first one is to delete the 1-st and the 3-rd elements so that the sequence will be [1, 2, 3] and have 3 elements equal to their indices; the second way is to delete the 2-nd and the 3-rd elements to get the sequence [5, 2, 3] with 2 desired elements.
solution: import java.io.*;
  import java.util.*;
  public class Main
  {
      static class Reader
      {
          final private int BUFFER_SIZE = 1 << 16;
          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 readLine() throws IOException
          {
              byte[] buf = new byte[64]; // line length
              int cnt = 0, c;
              while ((c = read()) != -1)
              {
                  if (c == '\n')
                      break;
                  buf[cnt++] = (byte) c;
              }
              return new String(buf, 0, cnt);
          }
          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();
          }
      }
      static Reader sc=new Reader();
      static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
      static void debug(Object... obj) {
          System.err.println(Arrays.deepToString(obj));
      }
      static int getmax(int index,int deleted,int maxdeletes,int[] arr,int[][] dp){
          if(index>=arr.length) return 0;
          if(dp[index][deleted]!=-1) return dp[index][deleted];
          int actualidx=index-deleted;
          int op1=getmax(index+1,deleted,maxdeletes,arr,dp);
          if(arr[index]==actualidx) op1+=1;
          int op2=0;
          if(deleted<maxdeletes){
              op2=getmax(index+1,deleted+1,maxdeletes,arr,dp);
          }
          return dp[index][deleted]=Math.max(op1,op2);
      }
      public static void main(String args[])throws IOException
      {
          /*
           * For integer input: int n=inputInt();
           * For long input: long n=inputLong();
           * For double input: double n=inputDouble();
           * For String input: String s=inputString();
           * Logic goes here
           * For printing without space: print(a+""); where a is a variable of any datatype
           * For printing with space: printSp(a+""); where a is a variable of any datatype
           * For printing with new line: println(a+""); where a is a variable of any datatype
           */
          int tc=inputInt();
          while(tc-->0){
              int n=inputInt();
              int k=inputInt();
              int[] arr=new int[n];
              for(int i=0;i<n;i++) arr[i]=inputInt()-1;
              int l=0,r=n,mid,ans=-1,cs;
              while(l<=r){
                  mid=(l+r)/2;
  
                  int[][] dp=new int[n][mid+1];
  
                  for(int[] sub:dp) Arrays.fill(sub,-1);
                  cs=getmax(0,0,mid,arr,dp);
                  //debug("Arr",arr,"dp",dp);
                  if(cs>=k){
                      ans=mid;
                      r=mid-1;
                  }else{
                      l=mid+1;
                  }
              }
              println(ans+"");
          }
          bw.flush();
          bw.close();
      }
      public static int inputInt()throws IOException
      {
          return sc.nextInt();
      }
      public static long inputLong()throws IOException
      {
          return sc.nextLong();
      }
      public static double inputDouble()throws IOException
      {
          return sc.nextDouble();
      }
      public static String inputString()throws IOException
      {
          return sc.readLine();
      }
      public static void print(String a)throws IOException
      {
          bw.write(a);
      }
      public static void printSp(String a)throws IOException
      {
          bw.write(a+" ");
      }
      public static void println(String a)throws IOException
      {
          bw.write(a+"\n");
      }
  }