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.io.*;
  
  public class Main {
  	 static boolean check = false;
  	 public static void main(String[] args) throws IOException  {
  			FastReader sc = new FastReader();
  			PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
  			int t = sc.nextInt();
  			while( t-- > 0 ) {
  				int n  = sc.nextInt();
  				int k = sc.nextInt();
  				int arr[] = new int[n];
  				int a[] = new int[n];
  				int temp = 0;
  				for( int i = 0 ;i< n ;i++) {
  					int loc = sc.nextInt();
  					arr[i] = loc;
  					a[i] = loc;
  				}
  				Arrays.sort(a);
  				HashMap<Integer,Integer> hm = new HashMap<>();
  				for( int i= 0 ;i < n-1 ; i++) {
  					hm.put( a[i], a[i+1]);
  				}
  				for( int i= 0 ;i < n ;i++) {
  					while( i <=  n-2 && arr[i+1] > arr[i] && arr[i+1] == hm.get(arr[i]) ) {
  						i++;
  					}
  					temp++;
  				}
  				//out.println(temp);
  				if( temp <= k) {
  					out.println("YES");
  				}
  				else {
  					out.println("NO");
  				}
  			}
  			out.flush();
  	}
  
  		static int gcd(int a, int b) {
  		      if (b == 0)
  		        return a;
  		      return gcd(b, a % b);
  		    }
  	 
  	 	 static HashMap<Long,Long> primefactor( long n){
  	 		 HashMap<Long ,Long> hm = new HashMap<>();
  	 		 long temp = 0;
  	 		 while( n%2 == 0) {
  	 			 temp++;
  	 			 n/=2;
  	 		 }
  	 		 if( temp!= 0) {
  	 			 hm.put( 2L, temp);
  	 		 }
  	 		 long c = (long)Math.sqrt(n);
  	 		 for( long i = 3 ; i <= c ; i+=2) {
  	 			 temp = 0;
  	 			 while( n% i == 0) {
  	 				 temp++;
  	 				 n/=i;
  	 			 }
  	 			 if( temp!= 0) {
  	 				 hm.put( i, temp);
  	 			 }
  	 		 }
  	 		 if( n!= 1) {
  	 			 hm.put( n , 1L);
  	 		 }
  	 		 return hm;
  	 		// this is the link where i found this method
  	 		 // https://www.geeksforgeeks.org/print-all-prime-factors-of-a-given-number/
  	 	 }
  	 
  		 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;
  		        }
  		    }
  		
  }