description: Moamen has an array of n distinct integers. He wants to sort that array in non-decreasing order by doing the following operations in order exactly once:
  
    1. Split the array into exactly k non-empty subarrays such that each element belongs to exactly one subarray. 
    2. Reorder these subarrays arbitrary. 
    3. Merge the subarrays in their new order. 
  
  
  
  A sequence a is a subarray of a sequence b if a can be obtained from b by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
  
  Can you tell Moamen if there is a way to sort the array in non-decreasing order using the operations written above?
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 10^3) — the number of test cases. The description of the test cases follows.
  
  The first line of each test case contains two integers n and k (1 ≤ k ≤ n ≤ 10^5).
  
  The second line contains n integers a_1, a_2, …, a_n (0 ≤ |a_i| ≤ 10^9). It is guaranteed that all numbers are distinct.
  
  It is guaranteed that the sum of n over all test cases does not exceed 3⋅10^5.
  
  Output
  
  For each test case, you should output a single string.
  
  If Moamen can sort the array in non-decreasing order, output "YES" (without quotes). Otherwise, output "NO" (without quotes).
  
  You can print each letter of "YES" and "NO" in any case (upper or lower).
  
  Example
  
  Input
  
  
  3
  5 4
  6 3 4 2 1
  4 2
  1 -4 0 -2
  5 1
  1 2 3 4 5
  
  
  Output
  
  
  Yes
  No
  Yes
  
  Note
  
  In the first test case, a = [6, 3, 4, 2, 1], and k = 4, so we can do the operations as follows: 
  
    1. Split a into \{ [6], [3, 4], [2], [1] \}. 
    2. Reorder them: \{ [1], [2], [3,4], [6] \}. 
    3. Merge them: [1, 2, 3, 4, 6], so now the array is sorted. 
  
  
  
  In the second test case, there is no way to sort the array by splitting it into only 2 subarrays.
  
  As an example, if we split it into \{ [1, -4], [0, -2] \}, we can reorder them into \{ [1, -4], [0, -2] \} or \{ [0, -2], [1, -4] \}. However, after merging the subarrays, it is impossible to get a sorted array.
solution: ////solution at bottom 
  import java.util.*;
  import java.lang.*;
  import java.io.*;
  import java.math.*;
  
    public class test
  {
           
      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[][] tdiarr(int m , int n){
              int[][] a = new int[m][n];
              for(int i=0;i<m;i++){
                  for(int j=0;j<n;j++){
                      a[i][j]=Integer.parseInt(next());
                  }
              }
              return a;
          }
          long[][] tdlarr(int m , int n){
              long[][] a = new long[m][n];
              for(int i=0;i<m;i++){
                  for(int j=0;j<n;j++){
                      a[i][j]=Long.parseLong(next());
                  }
              }
              return a;
          }
   
          int[] niarr(int n)
          {
              int[] a = new int[n];
              for(int i=0;i<n;i++)a[i]=Integer.parseInt(next());
              return a;
          }
          long[] nlarr(int n)
          {
              long[] a = new long[n];
              for(int i=0;i<n;i++)a[i]=Long.parseLong(next());
              return a;
          }
          char[] ncarr(){
              return next().trim().toCharArray();
              
              
          }
          
    
          int ni() 
          { 
              return Integer.parseInt(next()); 
          } 
    
          long nl() 
          { 
              return Long.parseLong(next()); 
          } 
    
          double nd() 
          { 
              return Double.parseDouble(next()); 
          } 
    
          String nstr() 
          { 
              String str = ""; 
              try
              { 
                  str = br.readLine(); 
              } 
              catch (IOException e) 
              { 
                  e.printStackTrace(); 
              } 
              return str; 
          } 
      }
       
      
       
      static FastReader br=new FastReader();
  /*
   
  */
  ///////////////////////////////////////////////////////////
   
   
   
   
   
      public static void main (String[] args) throws java.lang.Exception
      {
           try{
               System.setIn(new FileInputStream("input.txt"));
               System.setOut(new PrintStream(new FileOutputStream("output.txt")));
          }
          catch(Exception e){
               }
   long start__time = System.currentTimeMillis();
   
           
          int t=1;
          br=new FastReader();
                                 t=br.ni();
          
    
       in1 :   for(int TC = 1; TC <= t ; TC++)
          {
               
                  solve();
   
   
       
          }
            
               
          System.out.println(sb);
  long end__time = System.currentTimeMillis();
  long elapsed__time = end__time - start__time;
  System.err.println(elapsed__time);
  
      }
      ///end main
       static StringBuilder sb = new StringBuilder();
      
      static void solve() throws Exception{
                     int n = br.ni();
                  int k = br.ni();
                  int[] a = br.niarr(n);
                  int[] b = new int[n];
                  for(int i=0;i<n;i++)b[i] = a[i];
                      Arrays.sort(b);
                  HashMap<Integer , Integer> hm = new HashMap<>();
                  for(int i=0;i<n;i++)hm.put(b[i] , i);
                      int count = 0;
                   int i = 0 , j = 0;
                   while(i<n){
                        j = hm.get(a[i]);
                      while(i<n && j<n && a[i] == b[j]){i++;j++;}
                      count++;
                   }
                   
                                   if(count <= k)sb.append("Yes\n");
                  else sb.append("No\n");
  
               }
      //end solve
  
  
                  
                        
      }
      //end class  
   
      /* stuff you should look for
      * int overflow, array bounds
      * special cases (n=1?)
      * do smth instead of nothing and stay organized
      * WRITE STUFF DOWN
      * DON'T GET STUCK ON ONE APPROACH
    
   TC:
     
   
   
        */