Codeforces 830A, Binary Search

题意：

简单并抽象的说，现在有一根直线，上面某个坐标 p 标记了办公室所在的位置，同时有 n 个坐标标记了 n 个人的位置，以及 k 个标记了钥匙的位置。现在这 n 个人都想进入这个办公室，但是进入的前提是需要有钥匙，但每个人只能有一把钥匙，所以如果某个人的位置没有钥匙的话，他需要走到某个有钥匙的位置拿到以后进入办公室。所有的人可以同时行动，数量上满足如下关系： 1≤n≤103 ， n≤k≤2000 ， 1≤p≤109 。假设每个人移动一个坐标单位耗时为1，请计算最小耗时是多少？（输入过程中，所有的点坐标都是乱序的）

Solution

这样想，因为钥匙的数量总是够的，假设人在的点是 personPosi ，钥匙在的点是 keyPosj ，那么人拿到钥匙同时进入办公室的时间可以描述为：

ti=|personPosi−keyPosj|+|keyPosj−p|

考虑 n 个人同时行动，那么耗时应当是：

cost(personPos,keyPos)=max{ti|i=1…n}

容易知道这个函数的取值范围是： [0,2×109] 。最小化目标函数，那么可将问题转化为求解 ti 的最小值。先把钥匙和人的位置按照从小到大的顺序排列（天然的操作，不要问为什么），但是问题在于不知道具体要选择哪个点，虽然我们凭直觉知道需要选择附近的某个点，那么不妨遍历一遍找到合适的那个点，因为目前问题的规模不算大。假设当前允许的最大耗时为 T ，那么

i:=1
Foreach j:=1→k {
​     if ti≤T {
​         i++
​         if i>n:break
​     }
}

这一部分的复杂度为 O(k)​ ，因为知道耗时的取值范围，那么可以通过二分搜索来找到合适的 T​ ，那么该解法的复杂度为 O(k⋅logn)​ 。代码如下：

#include 
#include 
#include 
#include 

using namespace std;
const long long int maxn = 2e9 + 5;

long long int personPos[1002];
long long int keyPos[2002];

long long int n, k, p;

bool judge(long long int t) {
    int j = 1;
    for (int i = 1; i <= k; i++) {
        if (abs(personPos[j] - keyPos[i]) + abs(p - keyPos[i]) <= t) {
            j++;
            if (j > n) return true;
        }
    }
    return false;
}

void solve() {
    long long l = 0, r = maxn, mid = 0, ans = 0;
    while (l <= r) {
        mid = (l + r) >> 1;
        if (judge(mid)) {
            ans = mid;
            r = mid - 1;
        } else l = mid + 1;
    }
    cout << ans << endl;
}

int main() {
    scanf("%I64d %I64d %I64d", &n, &k, &p);
    for (int i = 1; i <= n; i++) {
        scanf("%I64d", personPos + i);
    }
    for (int i = 1; i <= k; i++) {
        scanf("%I64d", keyPos + i);
    }
    sort(personPos + 1, personPos + n + 1);
    sort(keyPos + 1, keyPos + k + 1);
    solve();
    return 0;
}

还有一种方法可以通过动态规划来做，但复杂度比这个高，为 O(k⋅n) ，这里就不写了，其实道理差不多。