Codeforces Round #417 (Div. 2)——ABCE

题目链接

题面有点长需耐心读题。

A.一个人行道上的人被撞有4种情况

1.所在车道有车驶出

2.右边车道有左转车

3.左边车道有右转车

4.对面车道有直行车

#include <bits/stdc++.h>

#define rep(i, j, k) for(int i = j;i <= k;i ++)

#define rev(i, j, k) for(int i = j;i >= k;i --)

using namespace std;

typedef long long ll;

int a[][];

int main() {
    ios::sync_with_stdio(false);
    rep(i, , ) rep(j, , ) cin >> a[i][j];
    rep(i, , ) {
        if(a[i][]) {
            rep(j, , )
                if(a[i][j]) {
                    puts("YES");
                    return ;
                }
            if(a[(i + ) % ][] | a[(i + ) % ][] | a[(i + ) % ][]) {
                puts("YES");
                return ;
            }
        }
    }
    puts("NO");
    return ;
}

B.从下往上，每层楼有两种选择——

左边结束 or 右边结束

所以有 2^n 种决策

坑点( Pretest 里有):如果第 k + 1 层到第 n 层楼都已关灯

那么到第 k 层楼结束就好了

#include <bits/stdc++.h>

#define rep(i, j, k) for(int i = j;i <= k;i ++)

#define rev(i, j, k) for(int i = j;i >= k;i --)

using namespace std;

typedef long long ll;

int n, m, ans = ;

char s[][];

void dfs(int k, int d, int c) {
    if(k >= n) {
        if(d) {
            int t = m;
            rev(i, m - , )
                if(s[k][i] == '') t = i;
            ans = min(ans, c + m - t);
        }
        else {
            int t = ;
            rep(i, , m)
                if(s[k][i] == '') t = i;
            ans = min(ans, c + t - );
        }
    }
    else {
        if(d) {
            int t = m;
            rev(i, m - , )
                if(s[k][i] == '') t = i;
            dfs(k + , , c +  * (m - t) + );
            dfs(k + , , c + m);
        }
        else {
            int t = ;
            rep(i, , m)
                if(s[k][i] == '') t = i;
            dfs(k + , , c +  * (t - ) + );
            dfs(k + , , c + m);
        }
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin >> n >> m, m += ;
    rep(i, , n) cin >> (s[n +  - i] + );
    rev(i, n, ) {
        int flag = ;
        rep(j, , m) {
            if(s[i][j] == '') {
                flag = ;
                break;
            }
        }
        if(flag) n --;
        else break;
    }
    if(!n) cout << "";
    else dfs(, , ), cout << ans;
    return ;
}

C.显然 T 随 k 单调递增

所以直接二分 k 就好了 (蠢了多写了个cmp

O(nlog^2n) cf 的评测机还是很稳的

#include <bits/stdc++.h>

#define rep(i, j, k) for(int i = j;i <= k;i ++)

#define rev(i, j, k) for(int i = j;i >= k;i --)

using namespace std;

typedef long long ll;

int n, m, ans = ;

char s[][];

void dfs(int k, int d, int c) {
    if(k >= n) {
        if(d) {
            int t = m;
            rev(i, m - , )
                if(s[k][i] == '') t = i;
            ans = min(ans, c + m - t);
        }
        else {
            int t = ;
            rep(i, , m)
                if(s[k][i] == '') t = i;
            ans = min(ans, c + t - );
        }
    }
    else {
        if(d) {
            int t = m;
            rev(i, m - , )
                if(s[k][i] == '') t = i;
            dfs(k + , , c +  * (m - t) + );
            dfs(k + , , c + m);
        }
        else {
            int t = ;
            rep(i, , m)
                if(s[k][i] == '') t = i;
            dfs(k + , , c +  * (t - ) + );
            dfs(k + , , c + m);
        }
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin >> n >> m, m += ;
    rep(i, , n) cin >> (s[n +  - i] + );
    rev(i, n, ) {
        int flag = ;
        rep(j, , m) {
            if(s[i][j] == '') {
                flag = ;
                break;
            }
        }
        if(flag) n --;
        else break;
    }
    if(!n) cout << "";
    else dfs(, , ), cout << ans;
    return ;
}

E.(题解说的比较清楚了其实，学习了已一发题解)

我们很熟悉最基础的求异或和的Nim游戏

现在我们添加一条规则，对于当前将要操作的玩家

他任选一堆除了拿走正数数量的石子外

他还可以在这堆上添加正数数量的石子

对于这个变种游戏，可以考虑它可以直接转化为最基础的Nim游戏

因为原来的胜者在对方选择添加石子的操作后

他可以再把对方添加的石子拿走...

各操作一轮下来相当于啥也没干...

把这些啥也没干的过程去掉就是原始的Nim游戏

我们考虑这个E题

把所有叶子节点染成蓝色

蓝点的父亲染红，红点的父亲染蓝

(为防止矛盾所以保证了所有叶节点与树根距离同奇偶)

我们可以发现，蓝点就是我们的Nim游戏

而红点可以传递苹果给蓝点

就是我们上面新加的不影响结果的规则

(也可以考虑为，红点的苹果传递到叶子节点需要奇数次传递

然后再被后手玩家一次吃光，总共经历了偶数步，不影响结果

而对于蓝色的叶子节点，就只有被拿走的选择

蓝色的非叶子节点，传递给下面的红点等价于被拿走，因为那不再影响结果

所以这已经是Nim游戏，每个蓝色节点即为一堆)

这样我们计算蓝点的异或和 sum

sum = 0，初始局面后手稳赢

那他就随便蓝蓝互换，红红互换

红蓝互换当且仅当两个节点苹果数相同

sum != 0，需交换蓝 u 和红 v

当且仅当 sum ^ apple[u] ^ apple[v] = 0

#include <bits/stdc++.h>

#define rep(i, j, k) for(int i = j;i < (k + 1);i ++)

using namespace std;

long long ans, c0, c1;

int n, md, ret, d[], a[], f[], c[];

vector <int> e[];

void dfs(int u, int dep) {
    d[u] = dep, md = max(md, dep);
    rep(i, , e[u].size() - )
        dfs(e[u][i], dep + );
}

int main() {
    ios::sync_with_stdio(false);
    cin >> n;
    rep(i, , n) cin >> a[i];
    rep(i, , n) cin >> f[i], e[f[i]].push_back(i);
    dfs(, );
    rep(i, , n) {
        if((md - d[i]) & ) c1 ++;
        else c0 ++, c[a[i]] ++, ret ^= a[i];
    }
    if(ret) {
        rep(i, , n)
            if(((md - d[i]) & ) && (ret ^ a[i]) <= )
                ans += c[ret ^ a[i]];
    }
    else {
        ans = c0 * (c0 - ) + c1 * (c1 - ), ans >>= ;
        rep(i, , n)
            if((md - d[i]) & )
                ans += c[a[i]];
    }
    cout << ans;
    return ;
}