Moamen and XOR

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≤103) — 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≤105).

The second line contains n integers a1,a2,…,an (0≤|ai|≤109). It is guaranteed that all numbers are distinct.

It is guaranteed that the sum of n over all test cases does not exceed 3⋅105.

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

Copy

3
5 4
6 3 4 2 1
4 2
1 -4 0 -2
5 1
1 2 3 4 5

output

Copy

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.

思路：题目说要把原来的数组拆开，看过题之后很容易得到的思路是所给数组最少能分成几个子序列，只要拆分的个数小于k那么我们就能组成非递减序列。那么问题来了如何得到最少序列个数呢（如遇到 [ -4,0,-2]，该拆成几个呢？）我们可以用vector数组来存（vector<pair<int,int>>v(n)),让v数组以键值来排序，值为下标i，这时遍历的时候就可以记录需要子序列的个数，这要键相邻，并且值相邻，便让它们组合成一个子序列。

#include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>
#include <bits/stdc++.h>

using namespace std;

const int N=1e5+10;
int a[N],st[N];

int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        int n,k;
        cin>>n>>k;
        //int x,sum=1;

        vector<pair<int,int>>v(n);
        for(int i=0;i<n;i++)
        {
            cin>>v[i].first;
            v[i].second=i;
        }

        sort(v.begin(),v.end());
        int ans=1;
        for(int i=1;i<n;i++)
        {
            if(v[i-1].second+1!=v[i].second)
            {
                ans++;
            }
        }


        if(ans<=k)
        {
            cout<<"YES"<<endl;
        }
        else
        {
            cout<<"NO"<<endl;
        }
    }
    return 0;
}