Google Code Jam Round 1A 2015 解题报告

题目链接：https://code.google.com/codejam/contest/4224486/

Problem A. Mushroom Monster

这题题意就是，有N个时间点，每个时间点，Kaylin可以吃掉一定数量的mushroom，Bartholomew可以放入任意数量的mushroom。

现在给出N个时间点分别有多少mushroom。

问：若Kaylin每个时间点可以吃任意数量的mushroom，那为了配合每个时间点的mushroom，Kaylin最少要吃掉多少蘑菇。

问：若Kaylin已恒定速度吃mushroom（即在每个时间点间吃的数量相同，若盘子空了则暂停进食），那为了配合每个时间点的mushroom，Kaylin最少要吃掉多少蘑菇。

看懂题目就是水题，第一问，只要吃掉下一个时间点相对于当前时间点减少的mushroom数量。

第二问，只要保证吃的速度要大于等于所有时间点mushroom减少的数量，即取需求速度最大值。

代码：

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <iostream>
#include <numeric>
#include <queue>
using namespace std;

const int MAXN = 1010;
const int INF = 0x3f3f3f3f;

int a[MAXN], maxr[MAXN];
int T, n;

int solve1() {
    int res = 0;
    for(int i = 0; i < n - 1; ++i)
        res += max(0, a[i] - a[i + 1]);
    return res;
}

int solve2() {
    int spd = 0;
    for(int i = 0; i < n - 1; ++i)
        spd = max(spd, a[i] - a[i + 1]);
    int res = 0;
    for(int i = 0; i < n - 1; ++i)
        res += min(a[i], spd);
    return res;
}

int main() {
    freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
    scanf("%d", &T);
    for(int t = 1; t <= T; ++t) {
        scanf("%d", &n);
        for(int i = 0; i < n; ++i)
            scanf("%d", &a[i]);
        maxr[n] = 0;
        for(int i = n - 1; i >= 0; --i)
            maxr[i] = max(maxr[i + 1], a[i]);
        printf("Case #%d: %d %d
", t, solve1(), solve2());
    }
}

Problem B. Haircut

题目大意：已知有B个理发师，和B个理发师给任意一个人理发所需要的时间。现在有N个人在排队，若处于队首，会找当前不是正在理发的编号最小的理发师理发。

问：处于队列第N个的人会找第几个理发师。

思路：二分时间 time，计算在time个单位时间里，有sum人已经或正在理发，又有cnt个理发师恰好没有正在理发的人。

那么，若sum + cnt ≥ N，那么第N个人在前 time 个单位时间里，一定有机会开始理发。

如此二分可以得到第N个人开始理发的时间，再由上述的sum、cnt可以得到第N个人让第几个理发师理发。

代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
typedef long long LL;

const int MAXN = 1010;

int a[MAXN];
int T, n, b;

bool check(LL k) {
    LL sum = 0, cnt = 0;
    for(int i = 0; i < b; ++i) {
        cnt += (k % a[i] == 0);
        sum += (k - 1) / a[i] + 1;
    }
    return sum + cnt >= n;
}

int solve() {
    LL l = 0, r = LL(n) * *max_element(a, a + b);//1000000;//
    while(l < r) {
        LL mid = (l + r) >> 1;
        if(!check(mid)) l = mid + 1;
        else r = mid;
    }
    LL sum = 0, p = 0;
    for(int i = 0; i < b; ++i)
        sum += (l - 1) / a[i] + 1;
    for(int i = 0; i < b; ++i)
        if(l % a[i] == 0 && sum + ++p == n) return i + 1;
    return -1;
}

int main() {
    freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
    scanf("%d", &T);
    for(int t = 1; t <= T; ++t) {
        scanf("%d%d", &b, &n);
        for(int i = 0; i < b; ++i)
            scanf("%d", &a[i]);
        printf("Case #%d: %d
", t, solve());
    }
}

Problem C. Logging

给N个点，分别问对于每个点来说，至少删掉多少个点，能使该点在剩下的点的凸包的边上。

思路1：因为凸包的边的性质是：对于一条边，每个点都在其同侧。那么，O(n^2)枚举所有边，O(n)枚举所有点，看要删掉那些点。复杂度O(n^3)，可以跑过小数据，牛叉的电脑可以过大数据（RMB玩家与贫民玩家的区别就体现在这里了！）

代码：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
using namespace std;
typedef long long LL;

const int MAXN = 3010;

struct Point {
    int x, y, id;
    Point() {}
    Point(int x, int y): x(x), y(y) {}
    void read(int i) {
        id = i;
        scanf("%d%d", &x, &y);
    }
    Point operator - (const Point &rhs) const {
        return Point(x - rhs.x, y - rhs.y);
    }
    bool operator < (const Point &rhs) const {
        if(y != rhs.y) return y < rhs.y;
        return x < rhs.x;
    }
};

LL cross(const Point &a, const Point &b) {
    return (LL)a.x * b.y - (LL)a.y * b.x;
}
//ret >= 0 means turn right
LL cross(const Point &op, const Point &sp, const Point &ed) {
    return cross(sp - op, ed - op);
}

Point p[MAXN];
int ans[MAXN];
int n, top, T;

void update_min(int &a, int b) {
    if(a > b) a = b;
}

void solve() {
    for(int i = 0; i < n; ++i) for(int j = i + 1; j < n; ++j) {
        int lsum = 0, rsum = 0;
        for(int k = 0; k < n; ++k) {
            LL t = cross(p[i], p[j], p[k]);
            if(t > 0) lsum++;
            if(t < 0) rsum++;
        }
        update_min(ans[i], min(lsum, rsum));
        update_min(ans[j], min(lsum, rsum));
    }
}

int main() {
    freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
    scanf("%d", &T);
    for(int t = 1; t <= T; ++t) {
        scanf("%d", &n);
        for(int i = 0; i < n; ++i)
            p[i].read(i), ans[i] = n - 1;
        solve();
        printf("Case #%d:
", t);
        for(int i = 0; i < n; ++i)
            printf("%d
", ans[i]);
    }
}

思路2：枚举每一个点，其他点绕枚举点排序，用一条过枚举点的直线旋转，计算要删掉的最少点。复杂度O(n^2logn)。

代码：

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <iostream>
#include <cmath>
using namespace std;
typedef long long LL;

struct Point {
    int x, y;
    Point() {}
    Point(int x, int y): x(x), y(y) {}
    Point operator - (const Point &rhs) const {
        return Point(x - rhs.x, y - rhs.y);
    }
    double ang() const {
        return atan2(y, x);
    }
    bool type() const {
        if(y != 0) return y > 0;
        return x < 0;
    }
};

LL cross(const Point &a, const Point &b) {
    return (LL)a.x * b.y - (LL)a.y * b.x;
}

const int MAXN = 3010;

Point p[MAXN], v[MAXN << 1];
int n, T;

bool cmp(const Point &a, const Point &b) {
    if(a.type() != b.type()) return a.type() < b.type();
    return cross(a, b) > 0;
}

void solve(int n) {
    for(int i = 1; i < n; ++i)
        v[i - 1] = p[i] - p[0];
    n--;
    sort(v, v + n, cmp);
    copy(v, v + n, v + n);
    int res = 0;
    for(int i = 0, j = 0; i < n; ++i) {
        if(i == j) j++;
        while(j < i + n && cross(v[i], v[j]) >= 0) ++j;
        res = max(res, j - i);
    }
    printf("%d
", n - res);
}

int main() {
    freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
    scanf("%d", &T);
    for(int t = 1; t <= T; ++t) {
        scanf("%d", &n);
        for(int i = 0; i < n; ++i)
            scanf("%d%d", &p[i].x, &p[i].y);
        printf("Case #%d:
", t);
        for(int i = 0; i < n; ++i) {
            swap(p[0], p[i]);
            solve(n);
            swap(p[0], p[i]);
        }
    }
}