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.util.*;
  import java.io.*;
  
  public class Solution
  {
      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') {
                      if (cnt != 0) {
                          break;
                      }
                      else {
                          continue;
                      }
                  }
                  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 int parent(int a , int p[])
    {
        if(a == p[a])
        return a;
        
        return p[a] = parent(p[a],p);
    }
    
    static void union(int a , int b , int p[] , int size[])
    {
        a = parent(a,p);
        b = parent(b,p);
        
        if(a == b)
        return;
        
        if(size[a] < size[b])
        {
            int temp = a;
            a = b;
            b = temp;
        }
        
        p[b] = a;
        size[a] += size[b];
    }
    
    
    
    
   static long getSum(int index , long BITree[])
      {
          long sum = 0; // Iniialize result
        
          // index in BITree[] is 1 more than
          // the index in arr[]
         // index = index + 1;
        
          // Traverse ancestors of BITree[index]
          while(index>0)
          {
              // Add current element of BITree 
              // to sum
              sum += BITree[index];
        
              // Move index to parent node in 
              // getSum View
              index -= index & (-index);
          }
          return sum;
      }
    
      // Updates a node in Binary Index Tree (BITree)
      // at given index in BITree. The given value 
      // 'val' is added to BITree[i] and all of 
      // its ancestors in tree.
      public static void updateBIT(int n, int index, 
                                          long val , long BITree[])
      {
          // index in BITree[] is 1 more than 
          // the index in arr[]
        //  index = index + 1;
        
          // Traverse all ancestors and add 'val'
          while(index <= n)
          {
          // Add 'val' to current node of BIT Tree
          BITree[index] += val;
        
          // Update index to that of parent 
          // in update View
          index += index & (-index);
          }
      }
      
      
     static int gcd(int a, int b)
  {
      if (a == 0)
          return b;
      return gcd(b % a, a);
  }
  
  static int dp[][];
  
  
  static int f(int pos , int take , int arr[])
  {
      if(pos == -1)
      {
          if(take == 0)
      return 0;
      
      return -10000000;
      
      }
      
      
      if(dp[pos][take] != -1)
      return dp[pos][take];
      
      
      if(pos+1-take == arr[pos])
      dp[pos][take] = Math.max(dp[pos][take],1 + f(pos-1,take,arr));
      
      
      dp[pos][take] = Math.max(dp[pos][take],f(pos-1,take,arr));
      
      
      if(take > 0)
      dp[pos][take] = Math.max(dp[pos][take],f(pos-1,take-1,arr));
      
      return dp[pos][take];
  }
      public static void main(String []args) throws IOException
      {
          Reader sc = new Reader();
          int t = sc.nextInt();
         // sc.nextLine();
          while(t-- > 0)
          {
              int n = sc.nextInt();
              int k = sc.nextInt();
              int arr[] = new int[n];
              for(int i = 0 ; i< n ; i++)
              {
                  arr[i] = sc.nextInt();
              }
              
              int dp[][] = new int[n+1][n+1];
              for(int i = 1 ; i <= n ; i++)
              {
                  dp[0][i] = -1000000;
              }
              
              for(int i = 1 ; i <= n ; i++)
              {
                  for(int j = 0 ; j < i ; j++)
                  {
                      dp[i][j] = -1000000;
                      
                      if(i-j == arr[i-1])
                      dp[i][j] = 1+dp[i-1][j];
                      
                      dp[i][j] = Math.max(dp[i][j],dp[i-1][j]);
                      
                      if(j != 0)
                      dp[i][j] = Math.max(dp[i][j],dp[i-1][j-1]);
                  }
              }
              
              int ans = -1;
              for(int i = 0 ; i <= n ; i++)
              {
                  if(dp[n][i] >= k)
                  {
                      ans = i;
                      break;
                  }
              }
              System.out.println(ans);
          }
      }
  }