AtCoder Beginner Contest 395

AtCoder Beginner Contest 395

AtCoder Beginner Contest 395 - AtCoder

A - Strictly Increasing?

AC code:

void solve() {   
    int n; cin >> n;
    int t; cin >> t;
    bool flag = true;
    for (int i = 1; i < n; i ++) {
        int x; cin >> x;
        if (x <= t) flag = false;
        t = x;
    }
    cout << (flag ? "Yes" : "No") << endl;
} 

B - Make Target

题意：

模拟

思路：

首先初始化所有格为黑色，之后每隔两行/两列对称更新白色点即可

AC code:

void solve() {   
    int n; cin >> n;
    char g[n + 1][n + 1];
    for (int i = 1; i <= n; i ++) for (int j = 1; j <= n; j ++) 
        g[i][j] = '#';
    for (int i = 2; i < n; i += 2) {
        for (int j = i; j < max(n - i + 2, i); j ++) g[i][j] = '.';
    }
    for (int j = 2; j < n; j += 2) {
        for (int i = j; i < max(n - j + 2, j); i ++) g[i][j] = '.';
    }   
    
    for (int i = 1; i <= n; i ++) {
        for (int j = 1; j <= n; j ++) {
            if (g[n - i + 1][n - j + 1] == '.') g[i][j] = '.';
        }
    }
    for (int i = 1; i <= n; i ++) {
        for (int j = 1; j <= n; j ++) cout << g[i][j];
        cout << endl;
    }
} 

C - Shortest Duplicate Subarray

题意：

找到序列n中长度最短的，包含重复元素的连续子序列

思路：

记录每个元素的位置，对每个元素的位置用set存取，顺序寻找每组相同元素位置的距离更新最小值即可

AC code：

void solve() {   
    int n; cin >> n;
    vector<int> v(n + 1);
    map<int, set<int>> mp;
    for (int i = 1; i <= n; i ++) {
        cin >> v[i];
        mp[v[i]].insert(i);
    }
    int ans = INF;
    for (auto [x, y] : mp) {
        if (y.size() > 1) {
            int last = -1;
            for (auto t : y) {
                if (last == -1) last = t;
                else {
                    ans = min(ans, t - last + 1);
                    last = t;
                }
            }
        }
    }
    if (ans == INF) cout << "-1" << endl;
    else cout << ans << endl;
} 

D - Pigeon Swap

题意：

1到n号鸽子分别在1到n号笼子中，现在有三种操作需要回答：

• 将鸽子a移动到笼子b中
• 将笼子a中的鸽子移动到笼子b中，将笼子b中的鸽子移动到笼子a中（英语不好真不行）
• 找出鸽子a所在笼子的位置

思路：

主要问题在操作二，直接暴力移动会与查询次数冲突超时；

所以我们不再移动鸽子，而是移动鸽子笼，假设每个笼子有门牌号的话，即交换ab笼的门牌号；

即我们不仅需要记录鸽子初始在的位置，每只鸽子所属的笼子，还需要额外开一个数组来记录溯源后的笼子编号是多少；

AC code：

void solve() {   
    int n, q; cin >> n >> q;
    vector<int> nest(n + 1), real(n + 1), pos(n + 1);
    for (int i = 1; i <= n; i ++) {
        pos[i] = i;
        real[i] = i;
        nest[real[i]] = i;
    }
    while (q --) {
        int op; cin >> op;
        if (op == 1) {
            int a, b; cin >> a >> b;
            pos[a] = real[b];
        } else if (op == 2) {
            int a, b; cin >> a >> b;
            swap(nest[real[a]], nest[real[b]]);
            swap(real[a], real[b]);
        } else {
            int a; cin >> a;
            cout << nest[pos[a]] << endl;
        }
    }
} 

E - Flip Edge

题意：
存在一张有n个点m条边的有向图，计算从顶点1到顶点n的最小代价；

从当前有向边的顺序移动一次的代价是1，或者将图的所有有向边反转一次的代价为x；

思路：

首先可以看出当我们处在一个点时有移动和反转操作的决策，当进行反转操作后当前图会变成一张新的图；

所以我们可以直接将反转后的图与原图存在一张图中，只不过点的编号需要进行+n操作以跟原图进行区分；

将原图的点视为i，则新图的点为i+n，对应两点之间可以视为一条无向边，移动一次的代价为x；

而单独在新/原图中移动的代价依然为1；

现在我们建立起了一张全新的图，直接采用dijstra从1号点开始更新全图每个点距离起点的最短距离即可；

注意最后无论是到达n号点，还是到达n+n号点均视为到达终点，所以最终的答案在这两点中取最小。

AC code：

vector<PII> g[2*N];
int dis[2*N], st[2*N];

void solve() {   
    int n, m, x; cin >> n >> m >> x;
    for (int i = 0; i < m; i ++) {
        int u, v; cin >> u >> v;
        g[u].push_back({v, 1});
        g[v + n].push_back({u + n, 1});
    }
    for (int i = 1; i <= n; i ++) {
        g[i].push_back({i + n, x});
        g[i + n].push_back({i, x});
    }
    memset(dis, 0x3f, sizeof dis);
    priority_queue<PII, vector<PII>, greater<PII>> pq;
    pq.push({0, 1});
    dis[1] = 0;
    while (!pq.empty()) {
        auto [len, pos] = pq.top();
        pq.pop();
        if (st[pos]) continue;
        st[pos] = 1;
        for (auto [npos, nlen] : g[pos]) {
            if (dis[pos] + nlen < dis[npos]) {
                dis[npos] = dis[pos] + nlen;
                pq.push({dis[npos], npos});
            }
        }
    }
    cout << min(dis[n], dis[2*n]) << endl;
}