1084

1084 - Winter

PDF (English)

Statistics

Forum

Time Limit: 2 second(s)

Memory Limit: 32 MB

Winter is coming. In a land far away, N men are spending the nights in a valley in a largest field. The valley is so narrow that it can be considered to be a straight line running east-to-west.

Although standing in the valley does shield them from the wind, the group still shivers during the cold nights. They, like anyone else, would like to gather together for warmth.

Near the end of each day, each man i finds himself somewhere in the valley at a unique location L_i. The men want to gather into groups of three or more persons since two persons just aren't warm enough. They want to be in groups before sunset, so the distance K each man can walk to form a group is limited. Determine the smallest number of groups the men can form.

Input

Input starts with an integer T (≤ 15), denoting the number of test cases.

Each case starts with two integers N (1 ≤ N ≤ 10⁵) and K (1 ≤ K ≤ 10⁶). Each of the next N line contains an integer L_i (1 ≤ L_i ≤ 10⁸).

Output

For each case, print the case number and smallest number of groups the men can gather into. If there is no way for all the men to gather into groups of at least size three, output -1.

Sample Input	Output for Sample Input
2 6 10 2 10 15 13 28 9 3 1 1 10 20	Case 1: 2 Case 2: -1

Note

Dataset is huge, use faster I/O methods.

---

Special Thanks: Jane Alam Jan (Description, Solution, Dataset)

思路：dp

首先我们可以想到N*N的方法，dp[i]=min(dp[i]，dp[j]+1)，（j<=i-2;）并且这个j还需满足ans[i]-ans[j+1]<=k;

dp[i]表示前i个点合法分配的最小值,我们将所有的dp先赋值无穷大，那么先将所有的数先按照升序排。我们可以知道当前面的一些状态不能够达到最优时也必然不能使后面的点达最优，所以前面的点可以不考虑，所以我们维护一个队列，如果一些点可以确定不能使后面的达最优，就出队。

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<stdlib.h>
#include<string.h>
#include<queue>
using namespace std;
typedef long long LL;
int dp[100005];
typedef struct pp
{
        int x;
        int id;
} ss;
int ans[100005];
ss ask[100005];
int flag[100005];
int main(void)
{
        int i,j,k;
        scanf("%d",&k);
        int s;
        for(s=1; s<=k; s++)
        {
                queue<ss>que;
                memset(flag,0,sizeof(flag));
                int n,m;
                scanf("%d %d",&n,&m);
                for(i=1; i<=n; i++)
                {
                        scanf("%d",&ans[i]);
                }
                sort(ans+1,ans+n+1);
                for(i=1; i<=n; i++)
                {
                        ask[i].id=i;
                        ask[i].x=ans[i];
                }
                int as=0;
                dp[0]=0;
                if(n<=2)
                        as=-1;
                else
                {
                        que.push(ask[1]);
                        que.push(ask[2]);
                        flag[1]=1;
                        flag[2]=1;
                        for(i=1; i<=n; i++)
                                dp[i]=1e9;
                        int f=0;
                        for(i=3; i<=n; i++)
                        {
                                while(!que.empty())
                                {
                                        f=1;
                                        ss cc=que.front();
                                        int vv=(cc.x+ask[i].x+1)/2;
                                        int uu=vv-cc.x;

                                        if(uu>m)
                                        {
                                                que.pop();
                                        }
                                        else
                                        {
                                                if(i-cc.id>=2)
                                                {
                                                        dp[i]=min(dp[i],dp[cc.id-1]+1);
                                                        if(dp[i]<1e9)
                                                                break;
                                                        else que.pop();
                                                }
                                                else break;
                                        }

                                }
                                que.push(ask[i]);
                                if(!f)
                                        break;
                        }
                        if(dp[n]==1e9)
                        {
                                as=-1;
                        }
                        else as=dp[n];
                }
                printf("Case %d: %d
",s,as);
        }
        return 0;
}