The 2023 ICPC Asia Macau Regional Contest (2023澳门区域赛ADIJ)

关注

原创最新推荐文章于 2026-04-10 10:05:38 发布 548 阅读 AI 写同款· GEO 优化 ›

2023 ICPC 网络赛第一场部分题解（待完善） ch1 即上一层所有字符的方案数 - 上一层ch1的方案数。2.所有连通块都是满连通块。阅读详情

J. Teleportation

分析：发现这是一个最短路问题之后，想办法把边构造出来，这个题目的核心就是认识到，0是一个特殊点，这个点只能有出边，而不能有入边，应该要引入新的点n来代替0这个点，同时i 到 i + 1的距离都是1，以及i到i + a[i] 的距离都是1是一个很自然的事情，跑最短路就可以了。

#include<bits/stdc++.h>
using namespace std;
#define x first
#define y second
#define PII pair<int , int>
// 0 和 n 都必须考虑到 ，n是引入的虚拟起点
// 区别就是 0可以当出边但是不能当出边 
// 因为本身上0只能出去一次就不会再回来了
// 终点是 0 的都应该转换成 n , 这是 n 的入边，同时 n 本身和 0 能够到达的点是一样的 ，这是 n 的出边
int main(){
    int n, x;
    cin >> n >> x;
    vector<int> a(n + 1 , 0 );
    vector<int> dist(n + 1, 1e9);
    vector<int> st(n + 1 , 0);
    vector<vector<PII>> adj(n + 1);
    auto add = [&](int u , int v , int w) ->void{
        if(u == v)
            return;
        adj[u].push_back({v, w});
    };
    for (int i = 0; i <= n; i ++){
        cin >> a[i];
        if(i)add(i, (i + 1) == n + 1 ? 1 : i + 1 , 1);
        add(i, (i + a[i % n]) % n == 0 ? n : (i + a[i % n]) % n, 1); 
        
    }
    dist[0] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> q;
    q.push({0, 0});  // 起点
    while(q.size()){
        auto [w , v] = q.top();
        q.pop();
        if(st[v]){
            continue;
        }
        st[v] = 1;
        for(auto [u , w] : adj[v]){
            if( dist[v] + w < dist[u]){
                dist[u] = dist[v] + w;
                q.push({dist[v] + w , u});
            }
        }
    }
    cout << dist[x] << endl;
    return 0;
}

I. Refresher into Midas

分析：注意到时间是有限的，所以可以考虑线性dp动态转移，dp[j]代表第j秒最后一次使用刷新球拥有的爆金币次数，然后在这一秒可以去动态转移下一次刷新球好的两种状态，一种是球好了直接用，一种是等待二者都好了再一起用，不存在第三种情况。

#include<bits/stdc++.h>
using namespace std;

void solve(){
    int a, b, m;
    cin >> a >> b >> m;
    vector<int> f(m + 1, 0);   
    // 假设 f[i]代表前i秒最后一次用刷新球的时候的总攻击次数
    f[0] = 2;
    int ans = 2;
    for (int i = 0; i<= m ; i++)
    {
        if(f[i] == 0)
            continue;
        ans = max(ans, f[i] + (m - i) / a); 
        if(i + b <=m)
        {                          
            // 策略一：不一定必须同步 刷新CD好了直接使用
            f[i + b] = max(f[i + b], f[i] + (1 + b / a));
        }
        int time = (b + a - 1) / a * a;  
        //策略二 ： 同步CD缓冲好需要的时间 ， 二者都CD缓冲好了再用
        if(i + time <= m ){
            f[i + time] = max(f[i + time], f[i] + 1 + time / a);
        }
    }
    cout << ans * 160 << endl;
}

int main(){
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int t;
    cin >> t;
    while(t --)
        solve();
    return 0;
}

如果我们先把所有的-1都删除，所有的1都保留（反过来类似）。我们会得到行和列的分别的总和，然后我们就会发现这个时候我们在途中翻转任何一个点的效果都是相同的，都是吧这个点的列和行的总和去减1，所以我们现在只需要求出我们需要修正的行分别需要修正多少，以及每一列需要修正多少，然后贪心的给行排序去修正，再给列排序去修正，看最后能不能修正出一个正确的结果，这样可以保证我们不会从一个比较好的情况到一个更坏的情况如果这种情况都满足不了说明其他所有情况更加满足不了。

#include<bits/stdc++.h>
#define endl "\n"
using namespace std;
// 保留全部的 1 然后计算出来需要进行翻转的数量，删除全部的-1，那么不管什么翻转都是对行和列进行-1 
// 现在我们目的是看能不能找出修正的方案
// 策略的话从大到小贪心 先找出最需要修正的行 再在行里面找出最需要修正的列 这样可以保证我们不会从一个比较好的情况到一个更坏的情况 如果这种情况都满足不了 说明其他所有情况更加满足不了
int main(){
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int n ;
    cin >> n ;
    vector<vector<int>> g(n, vector<int>(n));
    vector<vector<int>> ans(n, vector<int>(n , 0));
    vector<int> row(n), col(n);
    vector<int> row_now(n), col_now(n);
    vector<int> nd_row(n), nd_col(n);
    for (int i = 0; i < n ; i++){
        for (int j = 0; j < n; j ++){
            char c;
            cin >> c;
            if( c == '+'){
                g[i][j] = 1;
                ans[i][j] = 1; // 代表没有擦除
            }else{
                g[i][j] = -1;
            }
        }
    }
    for (int i = 0; i < n; i ++)
        cin >> row[i];
    for (int i = 0; i < n; i ++)
        cin >> col[i];
    
    for (int i = 0; i < n; i ++){
        for (int j = 0; j < n; j++){
            if(g[i][j] == 1){
                row_now[i]++;
                col_now[j]++;
            }
        }
    }
    for(int i= 0 ; i < n ; i++){
        nd_row[i] = row_now[i] - row[i];
        nd_col[i] = col_now[i] - col[i];
        if(nd_row[i] < 0 || nd_col[i] < 0)
        { // 然后计算需要减去的-1的数量是多少
            cout << "No" << endl;
            return 0;
        }
    }
    vector<int> vc_row(n), vc_col(n);
    for (int i = 0; i < n; i++)
    {
        vc_row[i] = i;
        vc_col[i] = i;
    }
    sort(vc_row.begin(), vc_row.end(), [&](auto lx, auto ly)
         { return nd_row[lx] > nd_row[ly]; });

    auto correct = [&](int x, int y) -> void{
        // 这个如果翻转的话 就代表两个都进行减1 的操作
        nd_row[x]--, nd_col[y]--;
        ans[x][y] ^= 1;
    };
    for(auto rr : vc_row){
        //现在需要操作的行
        sort(vc_col.begin(), vc_col.end(), [&](auto lx, auto ly)
             { return nd_col[lx] > nd_col[ly]; });
        for(auto cc : vc_col){
            if(nd_col[cc] > 0 && nd_row[rr] > 0){
                correct(rr, cc);
            }
        }
    }
    // 最后判断 nd数组清零了吗
    int fg = 1;
    for (int i = 0; i < n; i++){
        if(nd_row[i] != 0 || nd_col[i] != 0){
            fg = 0;
            break;
        }
    }
    if(!fg)
        cout << "No" << endl;   
    else{
        cout << "Yes" << endl;
        for (int i = 0; i < n; i ++){
            for (int j = 0; j < n; j ++){
                cout << ans[i][j];
            }
            cout << endl;
        }
    }
    return 0;
}

D. Graph of Maximum Degree 3

分析：思维图论题。

有些诈骗的意味，题目上的998244353完全就是幌子。我们知道每个点的度数不超过3的话，一个连通图的最大的度数就是3n / 2 ，同时我们还知道一个符合题目要求的连通图的至少包含的点是2*（n - 1），因为题目要求的是对于一个连通图，去掉一种颜色的边，剩下的边构成的图仍然连通，这就告诉我们，每种颜色在一个合法的图中至少是一棵树（这样需要的边是最少的n - 1），所以我们得到了一个先决条件： 3n / 2 >= 2 * (n - 1) ，解出这个式子得到 n <= 4，这就代表我们只需要去找小于等于4的连通块就可以了。

Case1：对于大小为1的连通块，显然就是点的数量。

Case2：对于大小为2且好的连通块，显然是双色边的数量。

Case3：对于大小为3且好的连通块，画了几个图可以知道，就是在Case2双色边的基础上连一个点，这个点满足和双色边的两个点分别有一条边，且边的颜色不想吐。

Case4：对于大小为4且好的连通块，且当大小为4的连通块是好的时候一定是一个独立的块，因为每种颜色的边都至少要形成一颗树，一种颜色需要三条边，两种颜色就需要6条边，则内部的点的度数就是12，所以这个块必须是独立的，因此我们对于所有连通的大小为4的独立块，去检查两种颜色是否让四个点连通即可，非常基础的并查集。

#include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define ll long long
#define PII pair<int, int>
#define x first
#define y second
const int N = 100010;
vector<PII> adj[N];     // 邻接表
set<PII> edges[2];      // 根据颜色存边
bool vis[N]; // 还没有遍历到过
set<PII> st2;
int p1[N], p0[N];
void init()
{
    for (int i = 1; i < N; i++)
        p1[i] = i, p0[i] = i;
}
int find(int p[], int x)
{
    if (x == p[x])
        return x;
    return p[x] = find(p, p[x]);
}
void merge(int p[], int x, int y)
{
    int rtx = find(p, x), rty = find(p, y);
    if (rtx != rty)
    {
        p[rty] = rtx;
    }
}
void solve()
{
    int n, m;
    cin >> n >> m;
    for (int i = 0; i < m; i++)
    {
        int u, v, c;
        cin >> u >> v >> c;
        edges[c].insert({u, v});
        edges[c].insert({v, u});
        if (c == 1)
        {
            merge(p1, u, v);
        }
        else
        {
            merge(p0, u, v);
        }
        adj[u].push_back({v, c});
        adj[v].push_back({u, c});
    }
    int ans = 0;
    for (auto [u, v] : edges[1])
    {
        if (edges[0].count({v, u}))
        {
            ans++;
            st2.insert({u, v});
        }
    }
    ans /= 2;  // 双色边的数量
    ans += n;  // 加上顶点的数量
    int cnt = 0;
    for (auto [u, v] : st2)
    {
        // 寻找包含 3 个点的连通块
        for (auto [w, c] : adj[v])
        {
            // 看是否和两个点都有连边并且都不相同
            if (edges[1].count({u, w}) && edges[0].count({v, w}) || edges[0].count({u, w}) && edges[1].count({v, w}))
            {
                cnt++; // 同一个块会被搜到两遍
            }
        }
    }
    ans += cnt / 2;
    // 最后找连通块大小为4的进行判断
    auto dfs = [&](auto &&dfs, int u, vector<int> &points) -> void  
    {
        vis[u] = 1;
        points.push_back(u);
        for (auto [v, c] : adj[u])
        {
            if (!vis[v])
            {
                dfs(dfs, v, points);
            }
        }
    };
    auto check = [&](vector<int> &pots) -> bool
    {
        for (int i = 1; i < 4; i++)
        {
            int u = pots[i - 1], v = pots[i];
            if (find(p1, u) != find(p1, v))
            {
                return false;
            }
            if (find(p0, u) != find(p0, v))
            {
                return false;
            }
        }
        return true;
    };
    for (int i = 1; i <= n; i++)
    {
        if (vis[i])
            continue;
        vector<int> points;
        dfs(dfs, i, points);
        if (points.size() != 4)
            continue;
        if (check(points))
        {
            ans++;
        }
    }
    cout << ans << endl;
}
int main()
{
    init();
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    solve();
    return 0;
}

收录于