2019 google kickstart round A

第一题：

n我的，每一个人有一个对应的技能值s，如今要从n我的中选出p我的，使得他们的技能值相同。

显然，若是存在p我的的技能值是相同的，输出0就能够了。若是不存在，就要找出p我的，对他们进行训练，治他们的技能值相同。

训练一个小时，技能值增长1，只有一个教练，也就是只能同时训练一个 人。找出最佳的p我的的方案，输出最小的训练时间。

AC的代码：

#include <stdio.h>
#include <stdlib.h>
#include <algorithm>

using namespace std;
int s[100010]; // skill score
long long int t[100010];
int e[100010];

int main()
{
    int tg;
    scanf("%d", &tg);
    int n, p;

    int ca=1;
    while(tg--) {
        scanf("%d %d", &n, &p);
        s[0] = 0;
        for(int i=1; i<=n; i++) {
            scanf("%d", &s[i]);
        }
        sort(s+1, s+n+1);

        t[0] = 0;
        for(int i=1; i<=n; i++) {
            t[i] = t[i-1] + s[i];
        }

        for(int i=p; i<=n; i++) {
            e[i] = t[i] - t[i-p];
        }

        int ans = s[p]*p - e[p];
        int cur;

        for(int i=p; i<=n; i++) {
            cur = s[i]*p - e[i];
            if(cur < ans)
                ans = cur;
        }
        printf("Case #%d: %d\n", ca, ans);
        ca++;
    }
    return 0;
}

　

第二题：

每次给你一个R*C的矩阵，矩阵的元素不是1就是0。1表明此处是一个邮局，0表明此处一个邮局，或者理解成是一个须要邮寄的用户。

咱们最多能够在某个为0的节点上再创建一个邮局，要输出的是每种方案中全部的用户到最近邮局的曼哈顿距离的最大值的最小值。

显然，若是矩阵中都是1，都是邮局，输出0就能够了（家门口就是邮局）。若是矩阵中存在0，显然“最多能够建一次邮局”的机会必

需要用上，再多创建一个邮局，必定能够减少或者不变当前邮局布局下的曼哈顿的最大值中的最小值。

那这个邮局选择在那个0的位置呢？最直接的方法就是枚举，枚举每一个是0的位置，由于R和C的最大值是250。

但我写的代码貌似没过较大的数据量的case。第一次参加kickstart，每台搞明白。

代码：

#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
#include <vector>
#include <math.h>

using namespace std;

struct node
{
    int x, y;
    int w;
}cur;

int main()
{
    int tg;
    scanf("%d", &tg);
    int r, c;
    int man_dis;
    int ca=1;
    vector<node>que1;
    vector<node>que0;

    while(tg--) {
        que0.clear();
        que1.clear();
        scanf("%d %d", &r, &c);
        char q[300][300];
        for(int i=1; i<=r; i++) {

            scanf("%s", q[i]);
            for(int j=0; j<c; j++) {
                cur.x = i;
                cur.y = j+1;
                if(q[i][j] == '1') {
                    que1.push_back(cur);
                } else {
                    que0.push_back(cur);
                }
            }
        }

        int ans1 = 0;
        for(int i=0; i<que0.size(); i++) {

            int cur, mm=r+c+1;
            for(int j=0; j<que1.size(); j++) {
                cur = abs(que0[i].x - que1[j].x) + abs(que0[i].y - que1[j].y);
                if(cur < mm)
                    mm = cur;
            }
            que0[i].w = mm;
            if(mm > ans1)
                ans1 = mm;
        } // 找出全部普通节点的最小man距离, 找出这些距离里面的最大距离

        if(que0.size() == 0) {
            //
            printf("Case #%d: 0\n", ca);
            ca++;
        } else {

            int ans2 = 0;
            int ans = r+c+1;

            for(int i=0; i<que0.size(); i++) {
                int x1 = que0[i].x;
                int y1 = que0[i].y;
                // 假设当前节点是邮局 更新最大的man距离
                vector<int>mandis;
                mandis.clear();
                for(int j=0; j<que0.size(); j++) {

                    int x2 = que0[j].x;
                    int y2 = que0[j].y;

                    // int dis = abs(que0[i].x - que0[j].x) + abs(que0[i].y - que0[j].y);
                    int dis = abs(x1 - x2) + abs(y1 - y2);

                    if(dis < que0[j].w) {
                        mandis.push_back(dis);
                    } else {
                        mandis.push_back(que0[j].w);
                    }
                }
                ans2 = 0;
                for(int j=0; j<mandis.size(); j++) {
                    if(i!=j && mandis[j] > ans2)
                        ans2 = mandis[j];
                }
                if(ans2 < ans)
                    ans = ans2;
            }
            printf("Case #%d: %d\n", ca, ans);
            ca++;
        }
    }
    return 0;
}

第三题：

n个座位，编号1---n，如今有q个预约，每次预约都是（L, R），如（1， 3）表示预约了一、二、3的位置。

因为每次的座位预约可能会存在重复的座位预约而致使冲突，如今让你经过一种算法来实现保证每一个预约的人

都能分到相同数量的k个座位，并保证这个k是最大的。没想到好的算法，故没有提交。（不太小数据量的状况下

暴力应该好过。依次枚举每一个座位，轮流分给有预约的人）。

没有代码！