贪心初步 POJ 3258 River Hopscotch

苯上的甲基

于 2018-08-14 15:32:49 发布

阅读量156

点赞数 1

文章标签：贪心二分

本文链接：https://blog.csdn.net/qq_40620465/article/details/81667684

版权

Every year the cows hold an event featuring a peculiar version of hopscotch that involves carefully jumping from rock to rock in a river. The excitement takes place on a long, straight river with a rock at the start and another rock at the end, L units away from the start (1 ≤ L ≤ 1,000,000,000). Along the river between the starting and ending rocks, N (0 ≤ N ≤ 50,000) more rocks appear, each at an integral distance Di from the start (0 < Di < L).

To play the game, each cow in turn starts at the starting rock and tries to reach the finish at the ending rock, jumping only from rock to rock. Of course, less agile cows never make it to the final rock, ending up instead in the river.

Farmer John is proud of his cows and watches this event each year. But as time goes by, he tires of watching the timid cows of the other farmers limp across the short distances between rocks placed too closely together. He plans to remove several rocks in order to increase the shortest distance a cow will have to jump to reach the end. He knows he cannot remove the starting and ending rocks, but he calculates that he has enough resources to remove up to M rocks (0 ≤ M ≤ N).

FJ wants to know exactly how much he can increase the shortest distance *before* he starts removing the rocks. Help Farmer John determine the greatest possible shortest distance a cow has to jump after removing the optimal set of M rocks.

Input

Line 1: Three space-separated integers: L, N, and M
Lines 2..N+1: Each line contains a single integer indicating how far some rock is away from the starting rock. No two rocks share the same position.

Output

Line 1: A single integer that is the maximum of the shortest distance a cow has to jump after removing M rocks

Sample Input

Sample Output

Hint

Before removing any rocks, the shortest jump was a jump of 2 from 0 (the start) to 2. After removing the rocks at 2 and 14, the shortest required jump is a jump of 4 (from 17 to 21 or from 21 to 25).

这道题目呢，其实和poj中“pie”这道题是差不多的。我刚开始以为只要把距离数组排个序就可以了，然后去掉前面两个石头，结果发现中间的石头连着两边都有距离，后面只能二分了。

这种贪心+二分的一般都是在二分中要加上个循环，把每个条件都要判断一次。

我们先看题，题目要求我们求出最小间隔的最大值，我们就要找出最小间隔和最大间隔作为二分的上下界。最大间隔不用找，就是一个石头都不要（0-L）样例就是25.我们找出最小间隔即可。

找出最小间隔后，求出中间值mid，此时把每个石头的间隔与mid比较，大于mid的我们继续寻找，小于mid证明我们可以将这个石头去掉，cot++，右边界++，左边界不动。全部走完后比较cot和m 若cot>m，意思是我们在当前mid的间隔下要去掉的石头数目大于我们需要的，说明此时间隔过大。反之也是一样。

AC代码

#include <iostream>
#include <algorithm>
#include<cstdio>
using namespace std;
int di[51000],k[51000];
int main()
{
    int l,n,m;
    while(~scanf("%d%d%d",&l,&n,&m))
    {
        int low;
        di[0]=0;
        di[n+1]=l;
        low=(1<<25);
        for(int i=1; i<=n; i++) scanf("%d",&di[i]);
        n=n+2;
        sort(di,di+n);
        for(int i=1; i<n; i++)
            low=min(low,di[i]-di[i-1]);
        int high=l,mid;
        while(high>=low)
        {
            int cot=0;
            mid=(high+low)/2;
            
            int s=0,e=1;
            while(e<n)
            {

                if(di[e]-di[s]>=mid)
                    s=e,e++;
                else
                {
                    cot++,e++;

                }
            }
            if(cot>m) high=mid-1;
            else low=mid+1;


        }
        printf("%d\n",high);

    }
    return 0;
}
/*25 5 2 1 10 9 15 16*/

一定要搞懂二分中 while循环 e，s是怎么动的！！