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.*;
  import java.math.*;
  
  
  
  public class Codechef {
  	  static class FR{
  		  
  			BufferedReader br;
  			StringTokenizer st;
  			public FR() {
  				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()); 
  		    } 
  
              int[] intArray(int n){
                  int a[] = new int[n];
                  for(int i=0; i<n; i++){
                      a[i] = Integer.parseInt(next());
                  }
                  return a;
              }
  
              long[] longArray(int n){
                  long a[] = new long[n];
                  for(int i=0; i<n; i++){
                      a[i] = Long.parseLong(next());
                  }
                  return a;
              }
  
              String[] stringArray(int n){
                  String a[] = new String[n];
                  for(int i=0; i<n; i++){
                      a[i] = next();
                  }
                  return a;
              }
  
              void printArry(int a[]){
                  for(int i=0; i<a.length; i++){
                      System.out.print(a[i] + " ");
                  }
                  System.out.println();
              }
  
              void printArry(long a[]){
                  for(int i=0; i<a.length; i++){
                      System.out.print(a[i] + " ");
                  }
                  System.out.println();
              }
  
              void printArry(String a[]){
                  for(int i=0; i<a.length; i++){
                      System.out.print(a[i] + " ");
                  }
                  System.out.println();
              }
  
  		    String nextLine() 
  		    { 
  		        String str = ""; 
  		        try
  		        { 
  		            str = br.readLine(); 
  		        } 
  		        catch (IOException e) 
  		        { 
  		            e.printStackTrace(); 
  		        } 
  		        return str; 
  		    } 
  		}
  	 
  	  static long mod = (long)(1e9 + 7);
  	 
  	static void sort(long[] arr ) {
  		 ArrayList<Long> al = new ArrayList<>();
  		 for(long e:arr) al.add(e);
  		 Collections.sort(al);
  		 for(int i = 0 ; i<al.size(); i++) arr[i] = al.get(i);
  	 }
  	static void sort(int[] arr ) {
  		 ArrayList<Integer> al = new ArrayList<>();
  		 for(int e:arr) al.add(e);
  		 Collections.sort(al);
  		 for(int i = 0 ; i<al.size(); i++) arr[i] = al.get(i);
  	 }
  	static int UB(long[] arr , long find , int l , int r) {
  		while(l<=r) {
  			int m = (l+r)/2;
  			if(arr[m]<find) l = m+1;
  			else r = m-1;
  		}
  		return l;
  	}
  	static int LB(long[] arr , long find,int l ,int r ) {
  		while(l<=r) {
  			int m = (l+r)/2;
  			if(arr[m] > find) r = m-1;
  			else l = m+1;
  		}
  		return r;
  	}
  	static int UB(int[] arr , long find , int l , int r) {
  		while(l<=r) {
  			int m = (l+r)/2;
  			if(arr[m]<find) l = m+1;
  			else r = m-1;
  		}
  		return l;
  	}
  	static int LB(int[] arr , long find,int l ,int r ) {
  		while(l<=r) {
  			int m = (l+r)/2;
  			if(arr[m] > find) r = m-1;
  			else l = m+1;
  		}
  		return r;
  	}
  	 static long gcd(long a, long b)
  	  {      
  	     if (b == 0)
  	        return a;
  	     return gcd(b, a % b); 
  	  }
  
  	static long lcm(long a, long b)
      {
          return (a / gcd(a, b)) * b;
      }
  
  	 static boolean[] prime(int num) {
  			boolean[] bool = new boolean[num];
  		     
  		      for (int i = 0; i< bool.length; i++) {
  		         bool[i] = true;
  		      }
  		      for (int i = 2; i< Math.sqrt(num); i++) {
  		         if(bool[i] == true) {
  		            for(int j = (i*i); j<num; j = j+i) {
  		               bool[j] = false;
  		            }
  		         }
  		      }
  		      if(num >= 0) {
  		    	  bool[0] = false;
  		    	  bool[1] = false;
  		      }
  		      
  		      return bool;
  		}
  	 static void sort(char[] arr) {
  		 ArrayList<Character> al = new ArrayList<Character>();
  		 for(char cc:arr) al.add(cc);
  		 Collections.sort(al);
  		 for(int i = 0 ;i<arr.length ;i++) arr[i] = al.get(i);
  		 
  	 }
  	 static long[][] ncr(int n, int k)
  	    {
  	        long C[][] = new long[n + 1][k + 1];
  	        int i, j;
  	 
  	        // Calculate  value of Binomial
  	        // Coefficient in bottom up manner
  	        for (i = 0; i <= n; i++) {
  	            for (j = 0; j <= Math.min(i, k); j++) {
  	                // Base Cases
  	                if (j == 0 || j == i)
  	                    C[i][j] = 1;
  	 
  	                // Calculate value using
  	                // previously stored values
  	                else
  	                    C[i][j] = (C[i - 1][j - 1] + C[i - 1][j])%mod;
  	            }
  	        }
  	 
  	        return C;
  	    }
  	 static long modInverse(long a, long m)
  	    {
  	        long g = gcd(a, m);
  	       
  	          return   power(a, m - 2, m);
  	        
  	    }
  	   
  	      static long power(long x, long y, long m)
  	    {
  	        if (y == 0)
  	            return 1;
  	        long p = power(x, y / 2, m) % m;
  	        p = (int)((p * (long)p) % m);
  	        if (y % 2 == 0)
  	            return p;
  	        else
  	            return (int)((x * (long)p) % m);
  	    }
  
  /* ***************************************************************************************************************************************************/	 
  	 
  	      static FR sc = new FR();
  	 static StringBuilder sb = new StringBuilder();
  	 public static void main(String args[]) {
  		
  		 int tc = 1;
  		  tc = sc.nextInt();
  		 
  		 
  		 while(tc-->0) {
  			int n = sc.nextInt();
  			int k = sc.nextInt();
  			long a[] = new long[n];
  			a = sc.longArray(n);
  
  			solve(a, n, k);
  		 }
  		 
  	    System.out.println(sb);
  	 } 
  
  	public static void solve(long[] a, int n, int k){
  		long res = 0;
  		long temp[] = new long[n];
  		for(int i=0; i<n; i++){
  			temp[i] = a[i];
  		}
  		sort(temp);
  		HashMap<Long, Integer> map = new HashMap<>();
  		for(int i=0; i<n; i++){
  			map.put(temp[i], i);
  		}
  		for(int i=0; i<n-1; i++){
  			if(a[i]>a[i+1]){
  				res++;
  			}
  			else{
  				if(temp[map.get(a[i])+1]<a[i+1]){
  					res++;
  				}
  			}
  		}
  
  		// for(int i=0; i<n; i++){
  		// 	if(map.get(a[i])>0 && i>0 && temp[map.get(a[i])-1]==a[i-1]){
  		// 		continue;
  		// 	}
  		// 	res++;
  		// }
  		if(res+1<=k){
  			sb.append("YES\n");
  		}
  		else{
  			sb.append("NO\n");
  		}
  	}
  }
  
  
  
  