AtCoder ABC201

最新推荐文章于 2024-07-08 22:12:26 发布

rag_doll

最新推荐文章于 2024-07-08 22:12:26 发布

阅读量840

点赞数 21

分类专栏： Atcoder 文章标签：算法 Atcoder

本文链接：https://blog.csdn.net/acrux1985/article/details/135784722

版权

Atcoder 专栏收录该内容

44 篇文章 0 订阅

订阅专栏

本期很有难度，D E F都不是一眼能看出的题目

C - Secret Number

遍历0-10000的数字即可

# -*- coding: utf-8 -*-
# @time     : 2023/6/2 13:30
# @file     : atcoder.py
# @software : PyCharm

import bisect
import copy
import sys
from itertools import permutations
from sortedcontainers import SortedList
from collections import defaultdict, Counter, deque
from functools import lru_cache, cmp_to_key
import heapq
import math
sys.setrecursionlimit(100010)


def main():
    items = sys.version.split()
    fp = open("in.txt") if items[0] == "3.10.6" else sys.stdin
    ans = 0
    ss = fp.readline().strip()
    for i in range(10000):
        t = i
        s = set()
        for j in range(4):
            s.add(t % 10)
            t //= 10

        flag = 1
        for j in range(10):
            if ss[j] == 'o':
                if j not in s:
                    flag = 0
            elif ss[j] == 'x':
                if j in s:
                    flag = 0
        ans += flag
    print(ans)


if __name__ == "__main__":
    main()

D - Game in Momotetsu World

想了几个dp的方案都不是很好
比较好的方法是：
设 $f (i, j)$ 为从 $(i, j)$ 点出发的T分数-A分数差的最优解
对于T来说，要使这个解最大
对于A来说，要使这个解最小
注意A在某步达到+，那么该步对于最优解的贡献score是-2
转移很简单，见题解

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <string>
#include <cstring>
#include <climits>
#include <cstdlib>
#include <map>
#include <set>
#include <vector>
#include <queue>
#include <unordered_map>
#include <algorithm>
#define LT(x) (x * 2)
#define RT(x) (x * 2 + 1)

using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;

int n, m;
char w[2020][2020];

int mem[2020][2020];

int get(int r, int c, int turn) {
    if (mem[r][c] != -1) {
        return mem[r][c];
    }
    int& res = mem[r][c];
    int nr, nc;
    if (turn == 0) {
        res = -(1 << 28);
        nr = r + 1, nc = c;
        if (nr < n && nc < m) {
            res = max(res, get(nr, nc, 1) + (w[nr][nc] == '+' ? 2 : -2));
        }
        nr = r, nc = c + 1;
        if (nr < n && nc < m) {
            res = max(res, get(nr, nc, 1) + (w[nr][nc] == '+' ? 2 : -2));
        }
    }
    else {
        res = 1 << 28;
        nr = r + 1, nc = c;
        if (nr < n && nc < m) {
            res = min(res, get(nr, nc, 0) + (w[nr][nc] == '+' ? -2 : 2));
        }
        nr = r, nc = c + 1;
        if (nr < n && nc < m) {
            res = min(res, get(nr, nc, 0) + (w[nr][nc] == '+' ? -2 : 2));
        }
    }
    return res;
}


int main() {
    //freopen("in.txt", "r", stdin);
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; ++i) {
        scanf("%s", w[i]);
    }
    
    memset(mem, 0xff, sizeof(mem));
    mem[n - 1][m - 1] = 0;
    int ans = get(0, 0, 0);
    if (ans > 0) {
        printf("Takahashi\n");
    }
    else if (ans < 0) {
        printf("Aoki\n");
    }
    else {
        printf("Draw\n");
    }
    return 0;
}

E - Xor Distances

一开始想的过于直接，写了一个在树上dfs遍历转移dp的方法。
可以看到，每一位的数字都是互相独立的，所以拆成61张图，每张图代表一位。
设f0(i)代表以i为根，到某个点路径异或和为0的路径总数，f1(i)自然是异或和为1的路径总数，dfs推一下并不是很难。要求的是f1(i)，代表i为根时能贡献的数量，即i到其他点的贡献。
再进行一遍dfs，转移根节点的时候要注意根节点和子节点数量的加和减，然后以不同的点为根对f1求和。
问题是比较难写而且容易TLE。好在最后总算AC了。
但是不推荐这个写法，因为比较笨。

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <string>
#include <cstring>
#include <climits>
#include <cstdlib>
#include <map>
#include <set>
#include <vector>
#include <queue>
#include <unordered_map>
#include <algorithm>
#define LT(x) (x * 2)
#define RT(x) (x * 2 + 1)

using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;

int n;
const ll mod = (ll)(1e9 + 7);
vector<pair<int, ll>> g[200020];

ll f0[200020][61], f1[200020][61];
ll temp[61];

void dfs(int u, int fa) {
    for (int p = 0; p < 61; ++p) {
        f0[u][p] = 1, f1[u][p] = 0;
    }
    for (auto& pr : g[u]) {
        int v = pr.first;
        if (v == fa) continue;
        ll c = pr.second;
        dfs(v, u);
        for (int p = 0; p < 61; ++p) {
            ll b = (c >> p) & 1;
            if (b) {
                f0[u][p] += f1[v][p];
                f0[u][p] %= mod;
                f1[u][p] += f0[v][p];
                f1[u][p] %= mod;
            }
            else {
                f0[u][p] += f0[v][p];
                f0[u][p] %= mod;
                f1[u][p] += f1[v][p];
                f1[u][p] %= mod;
            }
        }
    }
    
}


void dfs2(int u, int fa) {
    for (int p = 0; p < 61; ++p) {
        temp[p] += f1[u][p];
        temp[p] %= mod;
    }
        
    ll l1u[61], l1v[61], l0u[61], l0v[61];
    for (auto& pr : g[u]) {
        int v = pr.first;
        if (v == fa) continue;
        for (int p = 0; p < 61; ++p) {
            ll b = (pr.second >> p) & 1;
            l1u[p] = f1[u][p], l1v[p] = f1[v][p], l0u[p] = f0[u][p], l0v[p] = f0[v][p];
            if (!b) {
                ll rem_u1 = (f1[u][p] - f1[v][p]) % mod;
                ll rem_u0 = (f0[u][p] - f0[v][p]) % mod;
                f1[v][p] = (f1[v][p] + rem_u1) % mod;
                f0[v][p] = (f0[v][p] + rem_u0) % mod;
                f1[u][p] = rem_u1;
                f0[u][p] = rem_u0;
            }
            else {
                ll rem_u1 = (f1[u][p] - f0[v][p]) % mod;
                ll rem_u0 = (f0[u][p] - f1[v][p]) % mod;
                f1[v][p] = (f1[v][p] + rem_u0) % mod;
                f0[v][p] = (f0[v][p] + rem_u1) % mod;
                f1[u][p] = rem_u1;
                f0[u][p] = rem_u0;
            }
        }
        dfs2(v, u);
        for (int p = 0; p < 61; ++p) {
            f1[u][p] = l1u[p], f1[v][p] = l1v[p];
            f0[u][p] = l0u[p], f0[v][p] = l0v[p];
        }
    }
}


ll qpow(ll a, ll x) {
    if (x == 0) return 1ll;
    ll t = qpow(a, x >> 1);
    if (x & 1) {
        return t * t % mod * a % mod;
    }
    else {
        return t * t % mod;
    }
}


int main() {
    //freopen("in.txt", "r", stdin);
    scanf("%d", &n);
    for (int i = 0; i < n - 1; ++i) {
        int u, v;
        ll c;
        scanf("%d%d%lld", &u, &v, &c);
        u--, v--;
        g[u].push_back({ v, c });
        g[v].push_back({ u, c });
    }
    ll ans = 0;
    dfs(0, -1);
    dfs2(0, -1);
    for (int p = 0; p < 61; ++p) {
        ans += (1LL << p) % mod * temp[p] % mod;
        ans %= mod;
    }
    ans = ans * qpow(2, mod - 2) % mod;
    printf("%lld\n", ans);
    return 0;
}

本题的正解需要用到异或和的性质
以0为根，
$f (i)$ 代表0-i的路径中的异或和
那么 $\oplus f(j)$
那么：同样考虑第 $b$ 位下的0-1图
有贡献的 $(i, j)$ 对的 $f (i), f (j)$ 一定有着不同的值，一个为0，一个为1。总的组合数即为 $f (u) = 0$ 的个数乘 $f (u) = 1$ 的个数。最后再乘以位 $b$ 代表的值 $2^b$ 。

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <string>
#include <cstring>
#include <climits>
#include <cstdlib>
#include <map>
#include <set>
#include <vector>
#include <queue>
#include <unordered_map>
#include <algorithm>
#define LT(x) (x * 2)
#define RT(x) (x * 2 + 1)

using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;

vector<pair<int, ll>> g[200020];
const ll mod = ll(1e9 + 7);
int n;
ll x[200200];


void dfs(int u, int fa, ll cur) {
    x[u] = cur;
    for (auto &pr : g[u]) {
        int v = pr.first;
        ll c = pr.second;
        if (v == fa) continue;
        dfs(v, u, cur ^ c);
    }
}


int main() {
    //freopen("in.txt", "r", stdin);
    scanf("%d", &n);
    for (int i = 0; i < n - 1; ++i) {
        int u, v;
        ll c;
        scanf("%d%d%lld", &u, &v, &c);
        u--, v--;
        g[u].push_back({ v, c });
        g[v].push_back({ u, c });
    }
    dfs(0, -1, 0);
    ll f0[61] = {}, f1[61] = {};
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < 61; ++j) {
            if ((x[i] >> j) & 1) {
                f1[j] ++;
            }
            else {
                f0[j] ++;
            }
        }
    }
    ll ans = 0;
    ll p = 1;
    for (int i = 0; i < 61; ++i) {
        ll t = f0[i] * f1[i] % mod * p % mod;
        ans = (ans + t) % mod;
        p = p * 2 % mod;
    }
    printf("%lld\n", ans);
    return 0;
}

F - Insertion Sort

精彩的DP题,题解来自于这位同学
首先要看到：在43521这样的序列进行insertion sort，最优解必然存在一系列在原序列中有序的点是不动的。
如可以让1不动，然后2345移到右边；或者3不动，12移到左边，45移到右边；或者35不动（3和5在原序列中是有序的），12移到左边，4任意插入。
但是无论如何不可能32不动，这样就违反有序规则了。
实际上，这种按照数字从小到大依次遍历，找不动点的过程就是DP过程。
我们设当前遍历到的不动点为 $i$ ，前面 $1... i$ 已经完成排序后最小的代价为 $f (i)$ 。答案等于 $f (i)$ 加上后面的数全部移到右边的代价。
由于不动点序列是有序的，我们遍历在 $i$ 位置左边的 $f (j)$ 作为上一个不动点，在 $i$ 与 $j$ 中间的数需要任意插入，就如例子中的35不动4任意插入一样。转移方程为：
$f(i)=\min_{1 \le j <i,p[j]<p[i]} \bigg( f(j)+\sum_{k=j+1}^{i-1}a_k \bigg)$
这里的 $p [j]$ 表示数字 $j$ 在原序列中的位置。
但是这个东西是 $O(N^2)$ 的，如何优化？
注意到这个 $\sum_{k=j+1}^{i-1}a_k$
是一个前缀和，可以改写为 $S (i - 1) - S (j)$
这样 $j$ 就提出来了。要求的 $\min$ 变成 $f (j) - S (j)$ ，设其为 $T (j)$
现在需要维护一个数据结构，能
1.动态更新 $T (j)$
2.查询 $p [j] < p [i]$ 的所有 $j$ 中的 $T (j)$ 最小值
为了维护数据，我们建立线段树，将 $T (j)$ 插入到 $p [j]$ 的位置，并在求 $f (i)$ 时求从 $1$ 到 $p [i] - 1$ 的最小值
最后求答案时再加上右边的一部分。不要忘记 $f (i)$ 可以采用 $i$ 作为第一个不动点，前面比 $i$ 小的数都移到左边。

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <string>
#include <cstring>
#include <climits>
#include <cstdlib>
#include <map>
#include <set>
#include <vector>
#include <queue>
#include <unordered_map>
#include <algorithm>
#define LT(x) (x * 2)
#define RT(x) (x * 2 + 1)

using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;


ll a[200020], b[200020], c[200020];
int n;
int pos[200020];
int rid[200020];
ll f[200020];
ll sl[200020];
ll sr[200020];
ll sa[200020];

struct Smt {
    ll a[200020 << 2];
    void init() {
        memset(a, 0x3f, sizeof(a));
    }

    void push_up(int idx) {
        a[idx] = min(a[LT(idx)], a[RT(idx)]);
    }

    void update(int l, int r, int pos, int idx, ll v) {
        if (l == r) {
            a[idx] = v;
            return;
        }
        int mi = (l + r) / 2;
        if (pos <= mi) {
            update(l, mi, pos, LT(idx), v);
        }
        else {
            update(mi + 1, r, pos, RT(idx), v);
        }
        push_up(idx);
    }

    ll query(int l, int r, int L, int R, int idx) {
        ll ret = 1ll << 60;
        if (L <= l && r <= R) {
            return a[idx];
        }
        int mi = (l + r) / 2;
        if (mi >= L) {
            ret = min(ret, query(l, mi, L, R, LT(idx)));
        }
        if (mi < R) {
            ret = min(ret, query(mi + 1, r, L, R, RT(idx)));
        }
        return ret;
    }
};


int main() {
    //freopen("in.txt", "r", stdin);
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &pos[i]);
        rid[pos[i]] = i;  
    }
    for (int i = 1; i <= n; ++i) {
        scanf("%lld%lld%lld", &a[i], &b[i], &c[i]);
        sa[i] = sa[i - 1] + a[i];
        sl[i] = sl[i - 1] + min(a[i], b[i]);
    }
    for (int i = n; i >= 1; --i) {
        ll r = min(a[i], c[i]);
        sr[i] = sr[i + 1] + r;
    }
    ll ans = ll(1e18);
    Smt smt;
    smt.init();
    for (int i = 1; i <= n; ++i) {
        int p = rid[i];
        f[i] = sl[i - 1];
        if (p > 1) {
            f[i] = min(sl[i - 1], sa[i - 1] + smt.query(1, n, 1, p - 1, 1));
        }
        
        ll v = f[i] - sa[i];
        smt.update(1, n, p, 1, v);
        ans = min(ans, f[i] + sr[i + 1]);
    }
    printf("%lld\n", ans);
    return 0;
}