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 Solution {
  		static FastScanner scr=new FastScanner();
  //		static Scanner scr=new Scanner(System.in);
  		static PrintStream out=new PrintStream(System.out);
  		static StringBuilder sb=new StringBuilder();
  		
  		
  		
  		
  		static class pair{
  			long x;long y;
  			pair(long x,long y){ 
  				this.x=x;this.y=y;
  				
  			}
  		}
  		static class triplet{
  			long x;
  			int y;
  			int z;
  			triplet(long x,int y,int z){
  				this.x=x;
  				this.y=y;
  				this.z=z;
  			}
  		}static class DSU{
  			int []a=new int[26];
  			int []rank=new int[26];
  			 void start() {
  				for(int i=0;i<26;i++) {
  					a[i]=i;
  				}
  			}
  			  int find(int x) {
  				 
  				 if(a[x]==x) {
  					 return x;
  				 }
  				 return find(a[x]);
  			 }
  			  void union(int x,int y) {
  				  int xx=find(x);
  				  int yy=find(y);
  				  a[xx]=yy;
  			  }
  		}
  		static class FastScanner {
  			 BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  			StringTokenizer st=new StringTokenizer("");
  		 	String next() {
  		 		while (!st.hasMoreTokens())
  		 			try {
  		 				st=new StringTokenizer(br.readLine());
  		 			} catch (IOException e) {
  		 				e.printStackTrace();
  		 			}
  		 			return st.nextToken();
  			} int gcd(int a,int b){
  				if(b==0) {
  					return a;
  				}
  					
  				return gcd(b,a%b);
  			}
  		 	int[]  sort(int a[]) {
  				 
  		        int multiplier = 1, len = a.length, max = Integer.MIN_VALUE;
  		        int b[] = new int[len];
  		        int bucket[];
  		        for (int i = 0; i < len; i++) if (max < a[i]) max = a[i];
  		        while (max / multiplier > 0) {
  		            bucket = new int[10];
  		            for (int i = 0; i < len; i++) bucket[(a[i] / multiplier) % 10]++;
  		            for (int i = 1; i < 10; i++) bucket[i] += (bucket[i - 1]);
  		            for (int i = len - 1; i >= 0; i--) b[--bucket[(a[i] / multiplier) % 10]] = a[i];
  		            for (int i = 0; i < len; i++) a[i] = b[i];
  		            multiplier *= 10;
  		        }
  		        return a;
  		    }
  		 	 long modPow(long base,long exp) {
  				if(exp==0) {
  					return 1;
  				}
  				if(exp%2==0) {
  					long res=(modPow(base,exp/2));
  					return (res*res);
  				}
  				return (base*modPow(base,exp-1));
  			}
  			int []reverse(int a[]){
  				int b[]=new int[a.length];
  				int index=0;
  				for(int i=a.length-1;i>=0;i--) {
  					b[index]=a[i];
  				}
  				return b;
  			}
  			int nextInt() {
  				return Integer.parseInt(next());
  			}
  			int[] readArray(int n) {
  				int[] a=new int[n];
  				for (int i=0; i<n; i++) a[i]=nextInt();
  				return a;
  			}
  			long[] readLongArray(int n) {
  				long  [] a=new long  [n];
  				for (int i=0; i<n; i++) a[i]=nextLong();
  				return a;
  			}
  			long nextLong() {
  				return Long.parseLong(next());
  			}
  		}
  		
  		static ArrayList<Integer>list[];
  		static void solve() {
  			int n=scr.nextInt();
  			int k=scr.nextInt();
  			
  			int cnt=1;
  			int []a=scr.readArray(n);
  			int []b=Arrays.copyOf(a, n);
  			Arrays.sort(b);
  			HashMap<Integer,Integer>hm=new HashMap<>();
  			for(int i=0;i<n-1;i++) {
  				hm.put(b[i],b[i+1]);
  			}
  			hm.put(b[n-1], MIN);
  			for(int i=1;i<n;i++) {
  				if(a[i]!=hm.get(a[i-1])) {
  					cnt++;
  				}
  			}
  			if(cnt>k) {
  				out.println("NO");
  			}else {
  				out.println("YES");
  			}
  		}
  		static int count[];
  		static int  MAX = Integer.MAX_VALUE;
  		static int  MIN = Integer.MIN_VALUE;
  		public static void main(String []args) {
  			int t=scr.nextInt();
  			while(t-->0) {
  				solve();
  			}
  //			solve();
  			out.println(sb);
  		}
  	}	
   		