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 sys, os
  from io import BytesIO, IOBase
  from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log
  from collections import defaultdict as dd, deque
  from heapq import merge, heapify, heappop, heappush, nsmallest
  from bisect import bisect_left as bl, bisect_right as br, bisect
  
  # region fastio
  BUFSIZE = 8192
   
  class FastIO(IOBase):
      newlines = 0
   
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
   
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
   
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
   
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
   
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  stdin, stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout) 
  
  mod = pow(10, 9) + 7
  mod2 = 998244353
          
  def inp(): return stdin.readline().strip()
  def iinp(): return int(inp())
  def out(var, end="\n"): stdout.write(str(var)+"\n")
  def outa(*var, end="\n"): stdout.write(' '.join(map(str, var)) + end)
  def lmp(): return list(mp())
  def mp(): return map(int, inp().split())
  def l1d(n, val=0): return [val for i in range(n)]
  def l2d(n, m, val=0): return [l1d(m, val) for j in range(n)]
  def ceil(a, b): return (a+b-1)//b
  S1 = 'abcdefghijklmnopqrstuvwxyz'
  S2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  def isprime(x):
      if x<=1: return False
      if x in (2, 3): return True
      if x%2 == 0: return False
      for i in range(3, int(sqrt(x))+1, 2):
          if x%i == 0: return False
      return True
   
  for _ in range(iinp()):
      n, k = mp()
      arr = lmp()
      sarr = sorted(arr)
      inds = {}
      for i in range(n):
          inds[sarr[i]] = i
      x = 1
      for i in range(1, n):
          if inds[arr[i]] != inds[arr[i-1]]+1:
              x += 1
      print("Yes" if k>=x else "No")