最大化最小值

POJ3258

题意：

有一堆牛要过河，河的长度是 L，河中间有N个石头，牛只能踩着石头过河，问去掉M个石头后（去掉这M个石头的方式是随机的），牛能走的石头间距最小值中，最大的那一个是多少，输出距离。

开始和最后的两块石头不能搬走。

解法：

最大化石头间距的最小值

二分距离，从左到右遍历所有的石头（包括首尾），在判断距离之内不停的搬走石头，当石头总数大于M的时候即是错误。

代码如下：

int L, M, N;
int pos[MAXN];

bool C(int x) {
    int sum = 0, last = 0;
    for (int i = 1; i <= N + 1; i++) {
        if (pos[i] - pos[last] < x) {
            sum++;
            if (sum > M) {
                return false;
            }
        } else {
            last = i;
        }
    }
    return true;
}

void jojo() {
    sort(pos, pos + N + 1);
    int lb = 0, ub = L + 1;
    while (ub - lb > 1) {
        int mid = (ub + lb) / 2;
        if (C(mid)) {
            // cout << "true: " << mid << endl;
            lb = mid;
        } else {
            // cout << "false: " << mid << endl;
            ub = mid;
        }
    }
    cout << lb << endl;
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif  // !ONLINE_JUDGE
    L = READ(), N = READ(), M = READ();
    for (int i = 1; i <= N; i++) pos[i] = READ();
    pos[0] = 0;
    pos[N + 1] = L;
    jojo();
    return 0;
}

---

POJ3273

题意：

有N个数，要求按顺序划分成M组，使得这M组数的和的最大值最小。

解法：

最小化最大值

二分M组数的和，遍历所有的数，累加，当其大于二分值的时候将计数器加1，当最后如果计数器的值大于M，则为非法。

这里其实有两种情况，假如要准确划分7组：

1. 那么假如前面的划分成 3 组之后，后面一共3个数，每个都小于二分值，但不够分成 4 组怎么办？

2. 或者前面已经划分成了 6 组，后面还有3个数，每个都超过了二分值，怎么办？

对于第一种情况：我们判定的是真，那么说明二分值可以进一步缩小。

对于第二种情况：那么肯定超过了M-1，所以返回false

还有一点注意的是，对于二分的值，如果我们想要缩小范围，那么请把上下界的范围扩大1，这样可以避免WA。

啧啧，简直了。

int N, M;
int d[MAXN];
int mx, mn;

bool C(int x) {
    int last = 0, num = 0, sum = 0;
    for (int i = 0; i < N; i++) {
        if (sum + d[i] <= x) {
            sum += d[i];
        } else {
            num++;
            sum = d[i];
        }
    }
    if (num + 1 > M) {
        return false;
    } else {
        return true;
    }
}

void solve() {
    int ub = mx + 1, lb = mn;
    while (ub - lb > 1) {
        int mid = (ub + lb) >> 1;
        if (C(mid)) {
            ub = mid;
        } else {
            lb = mid;
        }
    }
    cout << ub << endl;
    return;
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif  // !ONLINE_JUDGE
    while (scanf("%d%d", &N, &M) != EOF) {
        mx = 0, mn = 0;
        for (int i = 0; i < N; i++) {
            scanf("%d", &d[i]);
            mx += d[i];
            mn = min(mn, d[i]);
        }
        solve();
    }
    return 0;
}

---

POJ3104

题意：

每件衣服都有一定单位水分，在不适用烘干器的情况下，每件衣服每分钟自然流失1个单位水分，但如果使用了烘干机则每分钟流失K个单位水分，但是遗憾是只有1台烘干机，每台烘干机同时只能烘干1件衣服,请问要想烘干N件衣服最少需要多长时间？

解法：

二分首先要先考虑是不是有单调关系，就是越怎么样就越怎么样。

这题，时间越多，就越可以烘干，所以二分时间。

先对水量排个序，每次二分时间 t，也就是说在没有烘干机的情况下，每件衣服可以减少 t 水分。那么比 t 小的衣服就不用烘干，比 t 大的就一定要烘干。

计算每一件衣服要烘干的时间，也就是$frac{a[i]-t}{k-1}$，因为这一分钟选择了烘干，意味着在原来基础上减去 k-1水分，然后有余数就要再多烘干一分钟。最后统计一下烘干时间是不是大于t就行了。

二分复杂度是log1e9，每次遍历是O(n)，可过。

这题的锅：首先要用LL，因为最坏的情况k为2，水量全都1e9。然后特判一下k=1时，不然除0会re

LL N, K;
LL a[MAXN];
LL mx = -1;

bool C(LL t) {
    int i = lower_bound(a, a + N, t) - a;
    LL sum = 0;
    for (; i < N; i++) {
        if ((a[i] - t) % (K - 1) == 0) {
            sum += (a[i] - t) / (K - 1);
        } else {
            sum += ((a[i] - t) / (K - 1) + 1);
        }
    }
    if (sum > t) {
        return false;
    } else {
        return true;
    }
}

void solve() {
    sort(a, a + N);
    if (K == 1) {
        printf("%lld
", mx);
        return;
    }
    LL ub = LLINF, lb = 0;
    while (ub - lb > 1) {
        LL mid = (ub + lb) >> 1;
        if (C(mid)) {
            ub = mid;
        } else {
            lb = mid;
        }
    }
    printf("%lld
", ub);
    return;
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif  // !ONLINE_JUDGE
    scanf("%lld", &N);
    for (int i = 0; i < N; i++) {
        scanf("%lld", &a[i]);
        mx = max(a[i], mx);
    }
    scanf("%lld", &K);
    solve();
    return 0;
}