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: from __future__ import division, print_function
  import threading,bisect,math,heapq,sys,random
  # threading.stack_size(2**27)
  # sys.setrecursionlimit(10**4)
  from sys import stdin, stdout
  i_m=9223372036854775807    
  def cin():
      return map(int,sin().split())
  def ain():                           #takes array as input
      return list(map(int,sin().split()))
  def sin():
      return input()
  def inin():
      return int(input()) 
  
  
  """**************************MAIN*****************************"""
  def main():
      t=inin()
      for _ in range(t):
          n,k=cin()
          b=[]
          a=ain()
          for i in range(n):
              b.append((a[i],i))
          b.sort()
          ans=0
          for i in range(1,n):
              if b[i][1]-b[i-1][1]==1:
                  continue
              ans+=1
          if k>ans:
              print("Yes")
          else:
              print("No")
          # print(ans)
      
      
  
  """*******************************************************"""
  
  ######## Python 2 and 3 footer by Pajenegod and c1729
  fac=[]
  def fact(n,mod):
      global fac
      fac.append(1)
      for i in range(1,n+1):
          fac.append((fac[i-1]*i)%mod)
      f=fac[:]
      return f
  def nCr(n,r,mod):
      global fac
      x=fac[n]
      y=fac[n-r]
      z=fac[r]
      x=moddiv(x,y,mod)
      return moddiv(x,z,mod)
  def moddiv(m,n,p):
      x=pow(n,p-2,p)
      return (m*x)%p
  def GCD(x, y): 
      x=abs(x)
      y=abs(y)
      if(min(x,y)==0):
          return max(x,y)
      while(y): 
          x, y = y, x % y 
      return x 
  def Divisors(n) : 
      l = []  
      ll=[]
      for i in range(1, int(math.sqrt(n) + 1)) :
          if (n % i == 0) : 
              if (n // i == i) : 
                  l.append(i) 
              else : 
                  l.append(i)
                  ll.append(n//i)
      l.extend(ll[::-1])
      return l
  def SieveOfEratosthenes(n): 
      global prime
      prime = [True for i in range(n+1)] 
      p = 2
      while (p * p <= n): 
          if (prime[p] == True): 
              for i in range(p * p, n+1, p): 
                  prime[i] = False
          p += 1
      f=[]
      for p in range(2, n): 
          if prime[p]: 
              f.append(p)
      return f
  def primeFactors(n): 
      a=[]
      while n % 2 == 0: 
          a.append(2) 
          n = n // 2 
      for i in range(3,int(math.sqrt(n))+1,2):  
          while n % i== 0: 
              a.append(i) 
              n = n // i  
      if n > 2: 
          a.append(n)
      return a
  """*******************************************************"""
  py2 = round(0.5)
  if py2:
      from future_builtins import ascii, filter, hex, map, oct, zip
      range = xrange
  import os
  from io import IOBase, BytesIO
  BUFSIZE = 8192
  class FastIO(BytesIO):
      newlines = 0
   
      def __init__(self, file):
          self._file = file
          self._fd = file.fileno()
          self.writable = "x" in file.mode or "w" in file.mode
          self.write = super(FastIO, self).write if self.writable else None
   
      def _fill(self):
          s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
          self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
          return s
   
      def read(self):
          while self._fill(): pass
          return super(FastIO,self).read()
   
      def readline(self):
          while self.newlines == 0:
              s = self._fill(); self.newlines = s.count(b"\n") + (not s)
          self.newlines -= 1
          return super(FastIO, self).readline()
   
      def flush(self):
          if self.writable:
              os.write(self._fd, self.getvalue())
              self.truncate(0), self.seek(0)
   
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          if py2:
              self.write = self.buffer.write
              self.read = self.buffer.read
              self.readline = self.buffer.readline
          else:
              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')
   
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip('\r\n') 
  # Cout implemented in Python
  class ostream:
      def __lshift__(self,a):
          sys.stdout.write(str(a))
          return self
  cout = ostream()
  endl = '\n'
   
  # Read all remaining integers in stdin, type is given by optional argument, this is fast
  def readnumbers(zero = 0):
      conv = ord if py2 else lambda x:x
      A = []; numb = zero; sign = 1; i = 0; s = sys.stdin.buffer.read()
      try:
          while True:
              if s[i] >= b'R' [0]:
                  numb = 10 * numb + conv(s[i]) - 48
              elif s[i] == b'-' [0]: sign = -1
              elif s[i] != b'\r' [0]:
                  A.append(sign*numb)
                  numb = zero; sign = 1
              i += 1
      except:pass
      if s and s[-1] >= b'R' [0]:
          A.append(sign*numb)
      return A
   
  # threading.Thread(target=main).start()
  if __name__== "__main__":
    main()
  