POJ-3258 River Hopscotch 二分法

题目

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
25 5 2
2
14
11
21
17

Sample Output

4

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).

题目大意就是有一个母牛跳石头过河的比赛，John觉得其他家的母牛太弱，想给比赛增加点难度，让自家母牛更快胜利，所以移走几块石头让一些母牛跳不过去，但要保证自家母牛可以跳过，求移走石头后，相邻两块石头间的最短距离。先给你三个数字，第一个数字表示终点石头距离，第二个数字表示总石头个数，第三个数字表示去掉石头的个数。

这道题按照一般思维来做的话大概就是每次都遍历数组找出其中距离最短的两块石头，把后面一块删除，然后更新数组，在进行下一次遍历，这样的算法时间复杂度大概都有O(n*m)了，铁定超时，而且这道题他的最终答案的最大值与最小值我们也都有一定的把握，不难想到利用二分解决。

主要思想就是从0 到 初始距离最大值进行二分，mid表示最后输出的最短距离，
要求对所有到上一个点的距离小于mid的(小于最短距离的石头都要去掉)，number++，最终number>m说明距离太大(能去掉的太多)所以令max=mid，反之则反。从最初点开始，a[i]-a[start]和mid比较，如果大于等于mid则需更新start的值为i，将此时的i作为新的起点

AC代码如下：

#include <iostream>
#include <stdio.h>
#include <algorithm>
using namespace std;
int a[500001];
int main(){
	int l,n,m;//n是中间石头个数，m是要去除的石头个数;
	scanf("%d %d %d",&l,&n,&m);
	int min=0,max,mid,number=0,ans;
	n=n+1;
	a[0]=0;
	for(int i=1;i<n;i++){
		scanf("%d",&a[i]);
	} 
	a[n]=l; 
	sort(a,a+n);
	max=l;
	while(max>=min){//int型变量无需设置精度
		number=0;
		mid=(max+min)/2;
		int start=0;
		for(int i=1;i<=n;i++){
			if(a[i]-a[start]<mid){
				number++;
			}
			else
			    start=i;
		}
		if(number>m){
		    max=mid-1;
		}
		else{
		    min=mid+1;
		    ans=mid;//ans存储最终正确的mid，这里不能直接输出min或是mid，有可能min+1后number又>m,然后又跳出了会导致错误的mid被输出
		}
	}
	printf("%d\n",ans); 
	return 0;
}