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.util.Map.Entry;
  import java.io.*;
  import java.util.regex.Pattern;
  
  
  public class KSubArray {
  				
  		 static FastReader sc=new FastReader();
  		  public static void main(String[] args)
  		    {
  		        int t = sc.nextInt();
  		       while(t-->0) {
  		    	   int n = sc.nextInt();
  		    	   int k = sc.nextInt();
  		    	   int a[] = new int[n];
  		    	   int b[] = new int[n];
  		    	   for (int i = 0; i < a.length; i++) {
  					a[i]= sc.nextInt();
  					b[i]= a[i];
  				}
  		    	   Arrays.sort(b);
  		    	   int count =0;
  		    	   for (int i =1; i < b.length; i++) {
  					if(a[i-1]>a[i]) {
  						count++;
  					}else {
  						int idx = Arrays.binarySearch(b,a[i-1]);
  						if(idx==n-1||b[idx+1]!=a[i]) {
  							count++;
  						}
  					}
  				}
  		    	   if(count>k-1) {
  		    		   System.out.println("No");
  		    	   }else {
  		    		   System.out.println("Yes");
  		    	   }
  
  		       }
  		   
  		        
  		      
  		    }
  		
  		
  		
  		static long mod = (long) 1e+9+7;
  		// Array Input
  		static void REP(int arr[], int a, int b) {
  			for ( int i = a; i <=b; i++){
  				arr[i]= sc.nextInt();
  			}
  		}
  		// Array Display
  		static void display(int arr[], int a, int b) {
  			for ( int i = a; i <=b; i++){
  				System.out.println(arr[i]);
  			}
  		}
  		
  		//linear Search
  		static int search(int arr[],int x) {
  			for (int i = 0; i < arr.length; i++) {
  				if(arr[i]==x) {
  					return i;
  				}
  			}
  			return -1;
  		}
  		//return boolean
  		static boolean search2(int arr[],int x) {
  			for (int i = 0; i < arr.length; i++) {
  				if(arr[i]==x) {
  					return true;
  				}
  			}
  			return false;
  		}
  		//binary Search
  		static int binarySearch(int arr[],int x) {
  			int i=0;
  			int j=arr.length-1;
  			while(i<j) {
  				int mid =i-(i+j)/2;
  				if(arr[mid]==x) {
  					return mid;
  				}else if(arr[mid]<x) {
  					i=mid+1;
  				}else {
  					j=mid-1;
  				}
  			}
  			return -1;
  		}
  		
  		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;
  	        }
  	    }
  	 
  	  
  	}
  
  
  