AtCoder Regular Contest 103

传送门

C - /\/\/\/

题意：
给出一个序列\(\{a_i\}\)，先要求其满足以下条件：

• \(a_i=a_{i+2}\)
• 共有两个不同的数

你现在可以修改任意个数，现问最少修改个数为多少。

思路：

• 很明显奇偶分类。
• 记录奇数位置、偶数位置的最大值和最大出现次数的情况；
• 因为要求两个数不相同，所以还要维护次大。

注意以下细节就是了。

Code

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5 + 5;
int n;
int a[N], c[N];
int mx[4], mxv[4];
void add(int x, int p) {
    ++c[x];
    if(c[x] > mx[p]) {
        mx[p] = c[x];
        mxv[p] = x;
    } else if(c[x] > mx[p + 1]) {
        mx[p + 1] = c[x];
        mxv[p + 1] = x;
    }
}
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    cin >> n;
    for(int i = 1; i <= n; i++) cin >> a[i];
    for(int i = 1; i <= n; i += 2) add(a[i], 0);
    for(int i = 1; i < N; i++) c[i] = 0;
    for(int i = 2; i <= n; i += 2) add(a[i], 2);
    int ans = n;
    if(mxv[0] == mxv[2]) {
        if(mx[1] > mx[3]) {
            ans -= mx[1] + mx[2];
        } else if(mx[1] < mx[3]){
            ans -= mx[0] + mx[3];
        } else if(mx[1] == mx[3] && !mx[1]) {
            ans -= n / 2;
        } else {
            ans -= mx[0] + mx[3];
        }
    } else {
        ans -= mx[0] + mx[2];
    }
    cout << ans;
    return 0;
}

D - Robot Arms

题意：
给出平面直角坐标系下的\(n\)个坐标点\((x_i,y_i)\)，现要求你确定\(m\)个数\((m\leq 40)\)，并且\(n\)种方案。在第\(i\)种方案中，确定一个行走方向的序列\(s\)，使得每一步走\(a_i\)的长度能够到达\((x_i,y_i)\)。

思路：

• 考虑二进制拆分。
• 因为所有\(a_i\)和的奇偶性不变，即合法情况中，\(x_i+y_i\)的奇偶性也得相同。
• 但是怎么确定方向？直接来拆显然不行，比如遇到\(0\)的情况。
• 观察到对于\(a=1\)时，能走的范围是一个斜放的正方形；同理，当\(a=1,2\)时，形状没有变只是边长什么的增加了。
• 所以对于\(2^0,2^1,\cdots,2^i\)，能走的区域有一个限制；如果达到\(2^{i+1}\)，这个限制可以被突破，但依然有限制。
• 但怎么才能有一种方案能走到目标点？
• 考虑对称操作，即如果让目标点走到原点，从原点出发对称走，也能走到目标点。
• 所以只要从目标点往回走，每步保证合法（在限制之内）即可。可以证明，最后一定能走回原点。

上面分析的只是\(x_i+y_i\)为奇数的情况，为偶数的话我们先让其往右边走一格，以\((1,0)\)为原点来搞即可。

Code

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1005;

int n, m;
int X[N], Y[N];
ll d[N];

const int dx[5] = {-1, 1, 0, 0}, dy[4] = {0, 0, -1, 1};
const char dc[5] = {'R', 'L', 'U', 'D'};

void getp(ll x, ll y) {
    for(int i = m; i; i--) {
        int now = d[i];
        for(int j = 0; j < 4; j++) {
            ll curx = x + d[i] * dx[j], cury = y + d[i] * dy[j];
            if(abs(curx) + abs(cury) < now) {
                cout << dc[j];
                x = curx, y = cury;
                break;
            }
        }
    }
}

int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    cin >> n;
    int sign = 1, mx = 0;
    for(int i = 1; i <= n; i++) cin >> X[i] >> Y[i];
    for(int i = 2; i <= n; i++) {
        if((abs(X[i] + Y[i]) & 1) != (abs(X[i - 1] + Y[i - 1]) & 1))
            sign = 0;
        mx = max(mx, abs(X[i]) + abs(Y[i]));
    }
    if(!sign) {cout << -1; return 0;}
    for(d[m = 1] = 1; d[m] << 1 <= mx; ++m, d[m] = d[m - 1] << 1);
    if(abs(X[1] + Y[1]) & 1) sign = 0;
    cout << m + sign << '\n';
    if(sign) cout << 1 << ' ';
    for(int i = m; i; i--) cout << d[i] << " \n"[i == 1];
    for(int i = 1; i <= n; i++) {
        if(sign) cout << 'R';
        getp(X[i] - sign, Y[i]);
        cout << '\n';
    }
    return 0;
}

E - Tr/ee

题意：
给出一个\(01\)序列\(s\)，现要你构造一棵树满足：若第\(i\)个位置为\(1\)，即表示这棵树能够通过去掉一条边得到size为\(i\)的子树；否则为\(0\)则表示不能。

思路：
不合法情况的判断：

• \(s_1\)一定为\(1\)，\(s_n\)一定为\(0\);
• \(s_i=s_{n-i}\)。

若不满足上面条件则为不合法。
否则，注意到\(s_1\)一定为\(1\)，并且\(s_i=s_{n-i}\)，那么就可以构造出一颗类似"毛毛虫"的树，存在一条路径作为"body"，路径上面的每个结点可能有若干"root"这样的树。
这棵树满足，无论割哪条边，都可以满足条件，具体构造可以看代码。

Code

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5 + 5;

int n;
char s[N];

int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    cin >> s + 1;
    n = strlen(s + 1);
    if(s[1] == '0' || s[n] == '1') {cout << -1; return 0;}
    for(int i = 1; i < n; i++) if(s[i] != s[n - i]) {
        cout << -1; return 0;
    }
    s[n] = '1';
    int rt = 1;
    for(int i = 2; i <= n; i++) if(s[i] == '1') {
        cout << i << ' ' << rt << '\n';
        for(int j = rt + 1; j < i; j++) cout << i << ' ' << j << '\n';
        rt = i;
    }
    return 0;
}

F - Distance Sums

题意：
构造一颗有\(n\)个结点的树，并且给出\(D_i\)，这棵树要满足第\(i\)个结点与其它结点距离的累和为\(D_i\)。
如果可以构造，输出方案；否则输出\(-1\)。

思路：
很显然且很重要的一个观察：

• 叶子结点的\(D\)肯定最大，也就是说，如果从树的底部向上进行拓扑，肯定结点的\(D\)会不断减小。

对于儿子和父亲来说，它们之间满足：\(D_{fa}=D_{son}-sz_{fa}+sz_{son}=D_{son}+2sz_{son}-n\)。
之后按\(D\)值从大到小搞即可，并且合并结点。
那么我们就能判断对于\(i=2,3,\cdots,n\)，\(D_i\)是否合法，我们还不能判断\(D_1\)是否合法。
所以最后再暴力\(dfs\)判以下即可。

Code

#include <bits/stdc++.h>
#define MP make_pair
#define fi first
#define se second
using namespace std;
typedef long long ll;
typedef pair<ll, int> pli;
const int N = 1e5 + 5;

int n;
ll D[N];
pli a[N];
int sz[N];

vector <int> g[N];

void add(int x, int y) {
    sz[x] += sz[y];
    g[x].push_back(y);
}

ll res;

void dfs(int u, int fa, ll d) {
    res += d;
    for(auto v : g[u]) {
        if(v != fa) dfs(v, u, d + 1);
    }
}

int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    cin >> n;
    for(int i = 1; i <= n; i++) cin >> D[i];
    for(int i = 1; i <= n; i++) {
        a[i] = MP(D[i], i); sz[i] = 1;
    }
    sort(a + 1, a + n + 1);
    int f = 1;
    for(int i = n; i > 1 && f; i--) {
        ll t = a[i].fi + 2ll * sz[a[i].se] - n;
        int x = lower_bound(a + 1, a + i, MP(t, 0)) - a;
        if(a[x].fi != t) f = 0;
        add(a[x].se, a[i].se);
    }
    if(f == 0) {cout << -1; return 0;}
    dfs(a[1].se, 0, 0);
    if(res != a[1].fi) {cout << -1; return 0;}
    for(int i = 1; i <= n; i++) {
        for(auto it : g[i]) cout << i << ' ' << it << '\n';
    }
    return 0;
}