AtCoder ABC 206

比赛链接：Here

AB水题，跳过

C - Swappable

在数组中找到满足条件的数对 $(i, j)$

$1 \leq i < j \leq N (N \in [2, 3 e 5])$
$A_{i} \neq A_{j}$

一道经典利用 map 减少搜索规模的题，

先假设每个数互不相同：ans = n * (n - 1) / 2

map 存每个数出现的次数，然后减去相同的情况 ans -= x * (x - 1) / 2

【AC Code】

void solve() {
    ll n;
    cin >> n;
    ll ans = n * (n - 1) / 2;
    map<ll, ll>mp;
    for (int i = 1; i <= n; ++i) {
        ll x; cin >> x;
        mp[x]++;
    }
    for (auto x : mp) 
        ans -= x.second * (x.second - 1) / 2;
    cout << ans;
}

D - KAIBUNsyo

在数组 $A$ 中有 $n$ 个正整数，给定一种操作：

选择 $x$ 和 $y$ ，将数组中全部 $x$ 替换为 $y$

请问最少次数是多少可以使得数组 $A$ 回文

首先一个重要的点：

对于每一个 $A_{i} \neq A_{N + 1 - i}$ 的数对，最终都会被某一个相同的数替代

让我们将其视为连接无向图中顶点 $A_{i}, A_{N + 1 - i}$ 之间的边。

然后，我们可以看到以下事实：

对于每个整数对 $(i, j)$ ，如果 $i$ 和 $j$ 属于图的同一个连通分量，则 $i$ 和 $j$ 都应该用相同的整数代替。

现在，我们如何最小化操作次数以使连通分量中的所有整数都相同？

如果一个连通分量有 $k$ 个整数，显然我们需要 $k - 1$ 次或更多次操作才能使它们成为相同的整数。即目标可以在 $k - 1$ 次替换中实现，如下所述：

在连通分量中固定一个整数，并将连通分量中的所有其他整数更改为固定整数。

因此，该问题的解决方案是（ $A$ 中不同整数的数量）-（图的连通分量的数量）。

有几种方法可以找到这个值；两种典型的方法是：

对每个连接的组件执行 DFS 或 BFS。 $O (N)$
使用并查集。 $O (N l o g N)$

这里采用 DFS 解决问题

【AC Code】

using G = vector<vector<int>>;
void dfs(int u, vector<bool> &f, G &g) {
    if (!f[u]) {return;}
    f[u] = false;
    for (auto &v : g[u]) dfs(v, f, g);
}

void solve() {
    int n; cin >> n;
    vector<int>a(n);
    vector<bool>f(2e5 + 10, false);
    G g(2e5 + 10);
    int cnt = 0;

    for (auto &x : a) {
        cin >> x;
        if (!f[x]) {f[x] = true, cnt++;}
    }

    int p = 0, q = n - 1;
    while (p < q) {
        g[a[p]].emplace_back(a[q]);
        g[a[q]].emplace_back(a[p]);
        p++, q--;
    }

    for (int i = 1; i <= 2e5; ++i) 
        if (f[i]) { cnt--; dfs(i, f, g); }
    
    cout << cnt << "\n";
}

F - Interval Game 2

Alice 和 Bob 又在玩游戏了，

他们有 $N$ 个半开区间 $[L_{i}, R_{i})$ 来进行 Game：

Alice 和 Bob 交替进行以下操作，Alice 先行。

从 $N$ 个间隔中，选择一个不与任何已选择的间隔相交的间隔。

无法进行操作的玩家失败，其他玩家获胜。

如果两个玩家都以最佳操作，哪个玩家会获胜？

https://drken1215.hatenablog.com/entry/2021/06/19/224100

const int N = 100;
int n;
vector<int>L, R;
vector<vector<int>>dp;

int solve(int l = 0, int r = N) {
    if (l == r) return 0;
    if (dp[l][r] != -1)return dp[l][r];

    set<int>s;
    for (int i = 0; i < n; ++i) {
        if (l <= L[i] and R[i] <= r) {
            int tmp = solve(l, L[i]) ^ solve(R[i], r);
            s.insert(tmp);
        }
    }

    int grundy = 0;
    while (s.count(grundy)) ++grundy;
    return dp[l][r] = grundy;
}

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    int _; for (cin >> _; _--;) {
        cin >> n;
        L.resize(n), R.resize(n);
        for (int i = 0; i < n; ++i) {
            cin >> L[i] >> R[i];
            L[i]--, R[i]--;
        }
        dp.assign(N, vector<int>(N + 1, -1));
        cout << (solve() > 0 ? "Alice\n" : "Bob\n");
    }
}