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 codeforceb
  {
  	static Map<Integer,ArrayList<Integer>> hm=new HashMap<Integer,ArrayList<Integer>>();
  	
  	public static void binSearch(int arr[],int a)
  	{
  		int l=0,r=arr.length-1;
  		while(l<=r)
  		{
  			int mid=(l+r)/2;
  			//System.out.println(arr[mid]);
  			if(arr[mid]<a)
  				l=mid+1;
  			else if(arr[mid]>a)
  				r=mid-1;
  			else
  			{
  				break;
  			}
  		}
  		System.out.println(arr[(l+r)/2]);
  	}
  		
  	public static void main (String[] args) throws java.lang.Exception
      {
  		 /*Arrays.sort(time,new Comparator<Pair>(){
   			public int compare(Pair p1,Pair p2){
   				if(p1.a==p2.a)
   					return p1.b-p2.b;
   				return p1.a-p2.a;
   			}
   		});*/
  		//Set<Integer> st1=new HashSet<Integer>();
  		//ArrayList<Integer> arr2=new ArrayList<Integer>();
  		//ArrayList<Integer> arr1=new ArrayList<Integer>();
          
        Map<Integer,Integer> hm=new HashMap<Integer,Integer>();
  		PrintWriter out=new PrintWriter(System.out);
  		FastReader sc = new FastReader();
          int t=sc.nextInt();
          int i,j,a,b,c,d,n,k,m;
          long count=0,sum1=1,sum=0,min,max;
          String s="",s1="",s2="";
         // Map<Integer,PriorityQueue<Integer>> hm=new HashMap<>();
          
          for(;t>0;t--) 
          {
          	n=sc.nextInt();
          	k=sc.nextInt();
          	int arr[]=sc.readArray(n);
          	int brr[]=new int[n];
          		 count=0;
          		for(i=0;i<n;i++) {
          			brr[i]=arr[i];
          		}
          	Arrays.sort(brr);
          	hm.clear();
          	for(i=0;i<n-1;i++)
          		hm.put(brr[i],brr[i+1]);
          	for(i=0;i<n-1;i++) {
          		if(hm.containsKey(arr[i])&& hm.get(arr[i])==arr[i+1])
          		{}
          		else
          			count++;
          	}
          	if(count<k)
          		out.println("YES");
          	else
          		out.println("NO");
          }
          out.close();
      }
  	
  	
  	
  	
  	
  	
  	static class Pair{
      	int a;
      	int b;
      	Pair(int x, int y)
          {
              this.a = x;
              this.b = y;
          }
      }
      static class FastReader 
      { 
          BufferedReader br; 
          StringTokenizer st; 
    
          public FastReader() 
          { 
              br = new BufferedReader(new
                       InputStreamReader(System.in)); 
          } 
          int[] readArray(int n) {
  			int[] a=new int[n];
  			for (int i=0; i<n; i++) a[i]=nextInt();
  			return a;
  		}
          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; 
          } 
      } 
  	public static int gcd(int a, int b)
  	{
  		if (b == 0)
  	        return a;
  	    return gcd(b, a % b);
  	}
  }