CodeForces Gym 101221 | 2014 World Finals | A Baggage | K Surveillance

A: Baggage

题目大意

一开始坐标$[-2n+1..2n]$中，$[1..2n]$按顺序放BABABA...BA，一共$n$个BA，坐标$[-2n+1,0]$是空的。每次可以移动连续2个字母到空的位置上，问最少多少步操作可以使得最后的序列变成AA..ABB..B（位置不一定要在$[1..n]$）。

题解

首先，我们只需要2个空位置就可以满足调整的要求了（使用更多的格子没有意义，参考交换变量使用2个临时变量和1个临时变量）。然后坐标范围变为$[-1..n]$。对于BABA...BA，我们可以优先调整2边，调整后使得中间一段仍是BABA..BA，这样就可以递归求解了。我们可以这么做：

__BABABABABABA
ABBABABABAB__A
ABBA__BABABBAA
    |    | // 递归求解__BABA
ABBAAABB__BBAA
A__AAABBBBBBAA
AAAAAABBBBBB__

因此每次我们都将规模缩小4，我们需要对小于4的情况特殊处理，实际上我们必须直接对4~7的子问题特殊处理（否则不优）。特殊处理的方法暴力出来即可。对于n=3的情况要特殊处理。

#include <iostream>
using namespace std;

void step(int from, int to, int offset) {
    printf("%d to %d\n", from + offset, to + offset);
}

void solve(int n, int offset) {
    switch (n) {
        case 4:
            step(6, -1, offset);
            step(3, 6, offset);
            step(0, 3, offset);
            step(7, 0, offset);
            break;
        case 5:
            step(8, -1, offset);
            step(3, 8, offset);
            step(6, 3, offset);
            step(0, 6, offset);
            step(9, 0, offset);
            break;
        case 6:
            step(10, -1, offset);
            step(7, 10, offset);
            step(2, 7, offset);
            step(6, 2, offset);
            step(0, 6, offset);
            step(11, 0, offset);
            break;
        case 7:
            step(8, -1, offset);
            step(5, 8, offset);
            step(12, 5, offset);
            step(3, 12, offset);
            step(9, 3, offset);
            step(0, 9, offset);
            step(13, 0, offset);
            break;
        default:
            step(2 * n - 2, -1, offset);
            step(3, 2 * n - 2, offset);
            solve(n - 4, offset + 4);
            step(0, 2 * n - 5, offset);
            step(2 * n - 1, 0, offset);
            break;
    }
}

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

    if (n == 3) {
        step(2, -1, 0);
        step(5, 2, 0);
        step(3, -3, 0);
    } else
        solve(n, 0);

    return 0;
}

K: Surveillance

题目大意

给出一些线段，这些线段可以覆盖$[l,r]$或者$[1..r]\cup[l..n]$，问最少多少线段可以覆盖整个区间。

题解

按右端点排序，对于重叠/联结的线段，我们可以将这两个线段连接起来，最后可以做成森林。只要找出森林中的一条链使得点数最少且能覆盖即可。

#include <bits/stdc++.h>
using namespace std;
#define FOR(i,j,k) for(i=j;i<=k;++i)
#define rep(i,j,k) for(i=j;i<k;++i)
#define FORD(i,j,k) for(i=j;i>=k;--i)
const int inf = 0x7FFFFFFF;
typedef long long ll;
const int N = (int) 1e6 + 5;

int fa[N][20], dep[N];

struct Camera {
    int l, r;
    bool operator< (const Camera &b) const {
        return r < b.r;
    }
} c[N];

int main() {
    int i, j, n, k, ans = inf, now;
    scanf("%d%d", &n, &k);
    FOR(i,1,k) {
        scanf("%d%d", &c[i].l, &c[i].r);
        if (c[i].l > c[i].r) c[i].r += n;
    }
    sort(c + 1, c + 1 + k);

    now = k;
    FORD(i,k,1) {
        while (now && c[now].r == c[i].r) --now;
        while (now && c[now].r >= c[i].l - 1) {
            fa[now][0] = i;
            --now;
        }
    }

    FORD(i,k,1)  {
        if (!fa[i][0]) dep[i] = 1;
        else dep[i] = dep[fa[i][0]] + 1;
    }

    FOR(j,1,19) FOR(i,1,k) fa[i][j] = fa[fa[i][j - 1]][j - 1];

    FOR(i,1,k) {
        if (c[i].l + n - 1 <= c[i].r) {
            ans = 1;
            break;
        }
        int x = i;
        FORD(j,19,0)
            if (fa[x][j] && c[fa[x][j]].r < c[i].l + n - 1)
                x = fa[x][j];

        if (c[i].l + n - 1 <= c[fa[x][0]].r)
            ans = min(ans, dep[i] - dep[fa[x][0]] + 1);
    }

    if (ans == inf)
        puts("impossible");
    else
        printf("%d\n", ans);

    return 0;
}