CF_484B Maximum Value(二分)

B. Maximum Value

time limit per test
1 second

memory limit per test
256 megabytes

input
standard input

output
standard output

You are given a sequence a consisting of n integers.
Find the maximum possible value of 

 (integer
remainder of ai divided
by aj),
where 1 ≤ i, j ≤ n and ai ≥ aj.

Input

The first line contains integer n — the length of the sequence (1 ≤ n ≤ 2·105).

The second line contains n space-separated integers ai (1 ≤ ai ≤ 106).

Output

Print the answer to the problem.

Sample test(s)

input

3
3 4 5

output

2

题意：

题目好短，但是这道题还是很有意思的。给n个数，求从里面找两个数使大数对小数取余的值最大。

题解：

暴力枚举肯定是不可取的，O(n*n)肯定会超时。能想到的思路就是大框架二分求余数，每次进行判断是否符合。关键在于怎样去进行判断而不超时。刚开始一直在纠结，想使用两个for循环剪枝，但是究竟要把分子还是分母放外面不确定。后来还是根据具体样例想到了好的方法。

假设当前传入预想余数为x，目的为判断是否能找到这么大的余数：

1.首先二分找分母，分母一定大于x，二分找到x在数组中的对应下标(不存在x的话找大于x的第一个)；

2.首先应该明确求余数的话，因为是递增数组，应该在x整数倍左一位寻找。比如24，可能出现的最大余数一定是在48左边，如果 47存在的话，则最大余数就是23，不可能
再大。

3.二分寻找x的整数倍在数组中的对应下标，得到余数，更新余数；

4.二分查找时有用到lower_bound()&upper_bound()函数，函数查找原理还是二分，附上一个链接，可以参考一下使用方法：http://blog.csdn.net/jack_incredible/article/details/7377035

代码实现：

<span style="font-size:14px;">#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <cstring>
#include <algorithm>
#define INF 200005
#define MAX 1000006

using namespace std;

int num[INF];//存储数字
void solve();//主solve函数
bool ifMod(int);//判断是否能找到这么大的余数
int n,result,max_num;
int show[MAX];//判断一个数是否出现过，剪枝
int main()
{
scanf("%d",&n);
result=0;max_num=MAX;
memset(num,0,sizeof(num));
for(int i=0;i<n;i++)
scanf("%d",&num[i]);
sort(num,num+n);
max_num=num[n-1];
solve();
return 0;
}
void solve()
{
//二分找余数，边界如此初始化，是第一次就从最大开始判断
double lb=1,ub=2*(max_num)-1;
for(int i=0;i<100;i++)
{
int mid=(int)((lb+ub)/2);
if(ifMod(mid)) lb=mid;
else ub=mid;
if(ub==lb)//剪
break;
}
printf("%d\n",result);
return ;
}
bool ifMod(int x)
{
if(x<=result)
return true;
memset(show,0,sizeof(show));
//调用函数找到上界
int i=upper_bound(num,num+n,x)-num;
int lb,mod;
for(;i<n;i++)
{
if(num[i]==1)
continue;
//如果出现过就直接continue
if(show[num[i]]==1)
continue;
show[num[i]]=1;
for(int j=2;;j++)
{
//找到比整数倍左侧一位的数
lb=lower_bound(num,num+n,num[i]*j)-num-1;
mod=num[lb]%num[i];
if(mod>=x)
{
result=max(result,mod);
return true;
}
//超过最大数或者余数已经等于最大值，剪枝
if(num[i]*j>max_num||mod==num[i]-1)
break;
}
}
return false;
}</span>