【解题报告】Intel Code Challenge Elimination Round

本文链接：https://blog.youkuaiyun.com/TRiddle/article/details/52741358

题目链接

A. Broken Clock（Codeforces 722A）

思路

解决这个问题有两种方法。

第一种方法。分类讨论。

第二种方法。将所有合法的情况枚举出来放到集合中，然后从集合中查找是否有匹配的情况。

下面的代码采用第一种方法。

代码

#include <bits/stdc++.h>
using namespace std;

int a, h, m;

int main() {
    scanf("%d\n%d:%d", &a, &h, &m);
    if(a == 12) {
        if(h == 0) {
            h = 1;
        }
        else if(h > 12) {
            if(h < 20) {
                h = 12;
            }
            else if(h % 10 <= 2) {
                h = 10 + h % 10;
            }
            else {
                h = h % 10;
            }
        }
    }
    else {
        if(h > 23) {
            if(h < 30) {
                h = 23;
            }
            else if(h % 10 <= 3) {
                h = 20 + h % 10;
            }
            else {
                h = h % 10;
            }
        }
    }
    if(m > 59) {
        m = m % 10;
    }
    if(h / 10 == 0) {
        putchar('0');
    }
    printf("%d:", h);
    if(m / 10 == 0) {
        putchar('0');
    }
    printf("%d\n", m);
    return 0;
}

B. Verse Pattern（Codeforces 722B）

思路

每输入一行字符串就统计该行内有多少个元音字母就能解决该题了。

代码

#include <bits/stdc++.h>
using namespace std;

const int maxn = 110;
bool flag = true;
char b[maxn];
int n, cnt, len, a[maxn];
set <char> s;

int main() {
    s.insert('a');
    s.insert('e');
    s.insert('i');
    s.insert('o');
    s.insert('u');
    s.insert('y');
    scanf("%d", &n);
    for(int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }
    getchar();
    for(int i = 0; i < n; i++) {
        gets(b);
        len = strlen(b);
        cnt = 0;
        for(int j = 0; j < len; j++) {
            if(s.count(b[j])) {
                cnt++;
            }
        }
        if(cnt != a[i]) {
            flag = false;
        }
    }
    puts(flag ? "YES" : "NO");
    return 0;
}

C. Destroying Array（Codeforces 722C）

思路1

我们可以用一系列离散的点来代表被分裂的区间。例如 $0, 3, n + 1$ 。这三个点代表区间 $[1, n]$ 已经被分割成区间 $[1, 2]$ 和区间 $[4, n]$ 。然后我们建立一个映射 $data[]$ ，其中 $data[x]$ 表示在被分裂的区间中，以 $x$ 为区间左端点的区间的长度。当 $y$ 不为某个区间的左端点时 $data[y] = 0$ 。然后每当读入一个区间分裂信息 $q$ 的时候，我们先在离散点中找到 $q$ 的位置（也就是找到 $q$ 所在的区间），设其为 $[l, r]$ ，然后将区间分裂成 $[l, q - 1]$ 和 $[q + 1, r]$ 。同时更新表示被分裂区间的离散点, $data[l]$ 和 $data[q+1]$ 即可。
实现上，代表被分裂区间的离散点可以用 $set$ 来维护，而 $data[]$ 可以用线段树来维护（因为需要敏捷的修改和查找操作）。在 $set$ 中查找 $q$ 可以用二分查找来做。

代码1

#include <bits/stdc++.h>
using namespace std;

#define lch (k << 1)
#define rch (k << 1 | 1)
#define mid ((l + r) >> 1)

typedef long long ll;
const int maxn = 1e5 + 5;

struct Tree {
    ll data[maxn<<2];
    void pushUp(int k) {
        data[k] = max(data[lch], data[rch]);
    }
    void build() {
        memset(data, 0, sizeof(data));
    }
    void update(int a, ll v, int k, int l, int r) {
        if(l == r) {
            data[k] = v;
            return;
        }
        if(a <= mid) {
            update(a, v, lch, l, mid);
        }
        else {
            update(a, v, rch, mid + 1, r);
        }
        pushUp(k);
    }
}o;

int n, q, l, r;
ll a[maxn], sum[maxn];
set <int> :: iterator it;
set <int> s;

int main() {
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) {
        scanf("%I64d", &a[i]);
        sum[i] = sum[i-1] + a[i];
    }
    s.insert(0);
    s.insert(n + 1);
    o.build();
    o.update(1, sum[n], 1, 1, n);
    for(int i = 1; i <= n; i++) {
        scanf("%d", &q);
        it = s.upper_bound(q);
        r = *it - 1;
        it--;
        l = *it + 1;
        if(l == r) {
            o.update(l, 0, 1, 1, n);
            printf("%I64d\n", o.data[1]);
        }
        else {
            if(l == q) {
                o.update(l, 0, 1, 1, n);
            }
            else {
                o.update(l, sum[q-1] - sum[l-1], 1, 1, n);
            }
            if(r != q) {
                o.update(q + 1, sum[r] - sum[q], 1, 1, n);
            }
            printf("%I64d\n", o.data[1]);
        }
        s.insert(q);
    }
    return 0;
}

思路2

其实可以直接用 $set$ 维护区间集合，另外用 $multiset$ 维护区间长度集合。唯一的问题就是怎么在 $set$ 中快速查找到 $q$ 所在的区间。我们可以用 $STL$ 中的 $pair$ 来表示一个区间（下文用 $p$ 来表示 $pair$ ），然后把区间 $[l, r]$ 表示成 $p(r, l)$ ，这样就能通过 $lower$ _ $bound$ 函数快速查找 $p(q, 1)$ 的方法来快速定位 $q$ 所在的区间了。

代码2

#include <bits/stdc++.h>
using namespace std;

typedef pair <int, int> p;
typedef long long ll;
const int maxn = 1e5 + 10;
int n, q, l, r, a;
ll sum[maxn];
set <p> :: iterator it;
set <p> s;
multiset <ll> ms;

int main() {
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) {
        scanf("%d", &a);
        sum[i] = sum[i-1] + a;
    }
    s.insert(p(n, 1));
    ms.insert(sum[n]);
    for(int i = 1; i <= n; i++) {
        scanf("%d", &q);
        it = s.lower_bound(p(q, 1));
        l = it->second;
        r = it->first;
        s.erase(it);
        s.insert(p(q - 1, l));
        s.insert(p(r, q + 1));
        ms.erase(ms.find(sum[r] - sum[l-1]));
        ms.insert(sum[q-1] - sum[l-1]);
        ms.insert(sum[r] - sum[q]);
        printf("%I64d\n", *(ms.rbegin()));
    }
    return 0;
}

思路3

如果用不相交集合的角度来看待被分裂的区间，那么就可以用并查集来维护区间。因为并查集支持“并”的操作而不是“裂”的操作，因此要将分裂操作离线下来，逆序访问这些操作，使之成为合并的操作。
我们对数组的所有元素都建立一个节点，设其权值为相应的数组元素。设刚开始数组中没有元素，在枚举中每出现一个合并操作 $q$ 都说明此时 $q$ 出现了，与此同时检查 $q - 1$ 和 $q + 1$ 位置的元素是否出现，若出现的话合并这几个元素所在的集合，合并的同时将权值也合并到该集合所在的祖先节点下。最后将合并后祖先节点的权值更新到答案中。
将答案保存下来逆序输出则可得到正确输出。

代码3

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
const int maxn = 1e5 + 5;
bool vis[maxn];
int n, b[maxn], p[maxn];
ll res, ans, a[maxn];
stack <ll> s;

void init() {
    for(int i = 0; i <= n + 1; i++) {
        p[i] = i;
    }
}

int Find(int x) {
    return x == p[x] ? x : p[x] = Find(p[x]);
}

void Union(int x, int y) {
    x = Find(x);
    y = Find(y);
    if(x == y) {
        return;
    }
    p[y] = x;
    a[x] += a[y];
}

int main() {
    scanf("%d", &n);
    init();
    for(int i = 1; i <= n; i++) {
        scanf("%I64d", &a[i]);
    }
    for(int i = 1; i <= n; i++) {
        scanf("%d", &b[i]);
    }
    s.push(0);
    for(int i = n; i > 1; i--) {
        vis[b[i]] = true;
        if(vis[b[i]-1]) {
            Union(b[i] - 1, b[i]);
        }
        if(vis[b[i]+1]) {
            Union(b[i], b[i] + 1);
        }
        res = a[Find(b[i])];
        s.push(ans = max(ans, res));
    }
    while(!s.empty()) {
        printf("%I64d\n", s.top());
        s.pop();
    }
    return 0;
}

（其它题目略）