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:  import java.util.*;
   import java.lang.*;
   import java.io.*;
   
   /* Name of the class has to be "Main" only if the class is public. */
   public class B_Moamen_and_k_subarrays
   {
       static int M = 1_000_000_007;
       static final PrintWriter out =new PrintWriter(System.out);
       static final FastReader fs = new FastReader();
       public static void main (String[] args) throws java.lang.Exception
       {
             
             int t= fs.nextInt();
             for(int i=0;i<t;i++)
             {
                 int n= fs.nextInt();
                 int k= fs.nextInt();
                 int a[]=fs.arrayIn(n);
                 int x=0;
                 int b[]=new int[n];
                 b=a.clone();
                 Arrays.sort(b);
                 HashMap<Integer, Integer>hm=new HashMap<Integer, Integer>();
                 for(int j=0;j<n;j++)
                 hm.put(b[j],j);
                 int max=a[0];
                 int min=a[0];
                // int x=0;
                 for(int j=0;j<n;j++){ 
                    
                        while(j!=n-1&&hm.get(a[j])!=n-1&&a[j+1]==b[hm.get(a[j])+1])
                         j++;
                        
                        x++;
                    
                 }
                // System.out.println(x);
                 if(x<=k)
                 out.println("Yes");
                 else
                 out.println("No");
           
                 
             }
             out.flush();
    }
           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;
           }
   int [] arrayIn(int n) throws IOException
       {
           int  arr[] = new int[n];
           for(int i=0; i<n; i++)
           {
               arr[i] = nextInt();
           }
           return arr;
       }
       }
       
       public static class Pairs implements Comparable<Pairs>
       {
           int value,index;
           Pairs(int value, int index)
           {
               this.value = value;
               this.index = index;
           }
           public int compareTo(Pairs p)
           {
               return Integer.compare(this.value, p.value);
           }
       }
       static final Random random = new Random();
    
       static void ruffleSort(int arr[])
       {
           int n = arr.length;
           for(int i=0; i<n; i++)
           {
               int j = random.nextInt(n),temp = arr[j];
               arr[j] = arr[i];
               arr[i] = temp;
           }
           Arrays.sort(arr);
       }
       static long nCk(int n, int k) {
           return (modMult(fact(n),fastexp(modMult(fact(n-k),fact(k)),M-2)));
       }
    
       static long fact (long n) {
    
           long fact =1;
           for(int i=1; i<=n; i++) {
               fact = modMult(fact,i);
           }
           return fact%M;
       }
    
       static long modMult(long a,long b) {
           return a*b%M;
       }
    
       static long fastexp(long x, int y){
           if(y==1) return x;
    
           long ans = fastexp(x,y/2);
           if(y%2 == 0) return modMult(ans,ans);
           else return modMult(ans,modMult(ans,x));
       }
   }