E. Fixed Points(思维,构造）

题目：

传送门：

Consider a sequence of integers a1,a2,…,an In one move, you can select any element of the sequence and delete it. After an element is deleted, all elements to the right are shifted to the left by 1 position, so there are no empty spaces in the sequence. So after you make a move, the sequence's length decreases by 1. The indices of the elements after the move are recalculated.

E. g. let the sequence be a=[3,2,2,1,5]. Let's select the element a3=2 in a move. Then after the move the sequence will be equal to a=[3,2,1,5], so the 3-rd element of the new sequence will be a3=1 and the 4-th element will be a4=5.

You are given a sequence a1,a2,…,an and a number k. You need to find the minimum number of moves you have to make so that in the resulting sequence there will be at least k elements that are equal to their indices, i. e. the resulting sequence b1,b2,…,bm will contain at least kk indices ii such that bi=i.

Input

The first line contains one integer tt (1≤t≤100) — the number of test cases. Then tt test cases follow.

Each test case consists of two consecutive lines. The first line contains two integers nn and kk (1≤k≤n≤2000). The second line contains a sequence of integers a1,a2,…,an (1≤ai≤n). The numbers in the sequence are not necessarily different.

It is guaranteed that the sum of nn over all test cases doesn't exceed 2000.

Output

For each test case output in a single line:

• −1 if there's no desired move sequence;
• otherwise, the integer xx (0≤x≤n) — the minimum number of the moves to be made so that the resulting sequence will contain at least kk elements that are equal to their indices.

Example

 

4
7 6
1 1 2 3 4 5 6
5 2
5 1 3 2 3
5 2
5 5 5 5 4
8 4
1 2 3 3 2 2 5 5

 

1
2
-1
2

Note

In the first test case the sequence doesn't satisfy the desired condition, but it can be provided by deleting the first element, hence the sequence will be [1,2,3,4,5,6][1,2,3,4,5,6] and 66 elements will be equal to their indices.

In the second test case there are two ways to get the desired result in 22 moves: the first one is to delete the 11-st and the 33-rd elements so that the sequence will be [1,2,3][1,2,3] and have 33 elements equal to their indices; the second way is to delete the 22-nd and the 33-rd elements to get the sequence [5,2,3][5,2,3] with 22 desired elements.

 

题目大意：

就是给你一个数组a1,a2,a3----an,然后你可以删除一个元素，删除一个元素后，所有右边的元素向左移动1个位置，序列的长度会减少1，并且重新计算移动后元素的下标

就是问你最少的操作次数，使得操作完的序列中至少有k个b[i]=i

题解：

对于这个题我们维护一个save[i].a=i-save[i].b，这个代表的是要想让a[i]这个数变到i，前面最少要删除几个数，如果save[i].a小于0，那么这个数一定是不能符合条件的。然后我们对save[i].a排序,然后对save[i].b求递增子序列，如果大于m就更新答案ans=min(ans,save[i].a)

代码：

#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=1e6+1000;
typedef long long ll; 
ll n,m;
struct node{
    int a,b;
    bool friend operator<(node a,node b){
        if(a.a == b.a) return a.b<b.b;
        return a.a<b.a;
    }
}save[maxn];
int st[maxn];
int s = 0;
int main(){
    int T;scanf("%d",&T);
    while(T--){
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++){
            scanf("%d",&save[i].b);
            save[i].a = i-save[i].b;
        }
        sort(save+1,save+1+n);
        int ans = 1e9+7,s = 0;
        int i;
        for(i=1;i<=n;i++)
            if(save[i].a>=0) break;
        for(int k=i;k<=n;k++){
                if(!s || save[k].b>st[s]) st[++s] = save[k].b;
                else{
                    int pos = lower_bound(st+1,st+1+s,save[k].b)-st;
                    st[pos] = save[k].b;
                }
                if(s>=m) ans = min(ans,save[k].a);
        }
        if(ans == 1e9+7) printf("-1\n");
        else printf("%d\n",ans);
    }
  return 0;
}
/**
5 5
1 1
2 1
3 1
4 1
5 1
**/