AtCoder Beginner Contest 375 (A-F)

写在前面：感觉越来越菜了

vp链接Panasonic Programming Contest 2024（AtCoder Beginner Contest 375） - AtCoder

A - Seats

思路

按照题意模拟过程就可以

代码 

void solve() {
    ll n;
    string s;
    cin >> n >> s;
    s = ' ' + s;
    ll ans = 0;
    for (int i = 1; i <= n - 2; i++) {
        if (s[i + 1] == '.' && s[i + 2] == '#' && s[i] == '#') {
            ans++;
        }
    }
    cout << ans;
}

B- Traveling Takahashi Problem

 思路

也是按照题意模拟就行，因为要从原点出发，所以从下标0遍历到n即可

代码

void solve() {
    ll n;
    cin >> n;
    vector<vector<ll>>arr(n + 4, vector<ll>(3));
    double ans = 0;
    for (int i = 1; i <= n; i++) {
        cin >> arr[i][1] >> arr[i][2];
    }
    
    for (int i = 0; i <= n; i++) {
        ans = ans + sqrtl((arr[i][1] - arr[i + 1][1]) * (arr[i][1] - arr[i + 1][1]) + (arr[i + 1][2] - arr[i][2]) * (arr[i + 1][2] - arr[i][2]));
    }
    cout << fixed << setprecision(20) << ans;
}

C-Spiral Rotation

思路 

这个题我采取了一个比较笨的方法，我们在自己打表的过程中会发现一个特点，就是最外层的边旋转了90度，往里一层就又旋转了一层，那么我是暴力求出旋转4次的答案，判断在第几层就输出哪个答案就可以了

代码 

void solve() {
    ll n;
    cin >> n;
    vector<vector<char>>arr(n + 4, vector<char>(n+2));
    vector<vector<char>>brr(n + 4, vector<char>(n + 2));
    vector<vector<char>>crr(n + 4, vector<char>(n + 2));
    vector<vector<char>>drr(n + 4, vector<char>(n + 2));
    
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            cin >> arr[i][j];
            brr[j][n - i + 1] = arr[i][j];//1
            
        }
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            crr[j][n - i + 1] = brr[i][j];//2
        }
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            drr[j][n - i + 1] = crr[i][j];//3
        }
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            ll minn = min(i, j);
            minn = min(minn, n - i + 1);
            minn = min(minn, n - j + 1);
            if (minn % 4 == 1) {
                cout << brr[i][j];
            }
            else if (minn % 4 == 2) {
                cout << crr[i][j];
            }
            else if (minn % 4 == 3) {
                cout << drr[i][j];
            }
            else {
                cout << arr[i][j];
            }
        }
        cout << endl;
    }
    
}

D-ABA

思路

一个非常板子的计数题，我们用map去储存每个相同的字符出现的位置，那么我们从头到尾去查找位置的过程中，我们实际上就是去判断每个相同的字符去当边上的两个A，中间有多少B就是答案，但是暴力明显会爆时，我们去找每个数字出现的答案，发现对于当前的A，假设当前序列为AAA，中间的A的价值是前面A的数量去乘以后面A的数量，对于区间来说也是相同的

代码

void solve() {
    
    map<char, vector<ll>>arr;
    string s;
    cin >> s;
    s = ' ' + s;
    for (int i = 1; i <= s.length()-1; i++) {
        arr[s[i]].push_back(i);
    }
    ll ans = 0;
    for (auto now : arr) {
        vector<ll>brr(now.second.size() + 3);
        ll a = now.second.size();
        ll top = 0;
        for (auto now2 : arr[now.first]) {
            brr[++top] = now2;
        }
        for (int i = 1; i < top; i++) {
            ans = ans + (brr[i + 1] - brr[i]-1) * (i)*(top-i);
            ans = ans + (i - 1) * (top - i);
        }
        
    }
    
    cout << ans;
}

 E-3 Team Division

思路

比较明显的一道dp题，但是赛时不会，破防，

首先如果sum%3！=0是一定没有答案的，对于其他的，我们实际上去实现让a和b这两组都能够到sum/3的答案就可以了，问题也就转化成dp[sum/3][sum/3]的最小值，如果能知道这个思路的转化，剩下的问题就简单了，跑一边0-1背包就可以了

代码

void solve() {
    ll sum = 0;
    ll n;
    cin >> n;
    vector<vector<ll>>arr(n + 2, vector<ll>(4));
    for (int i = 1; i <= n; i++) {
        cin >> arr[i][2] >> arr[i][1];
        sum = sum + arr[i][1];
    }
    if (sum % 3 != 0) {
        cout << "-1";
        return;
    }
    vector<vector<ll>>dp(sum / 3 + 2, vector<ll>(sum / 3 + 2));
    sum = sum / 3;
    for (int i = 0; i <= sum; i++) {
        for (int j = 0; j <= sum; j++) {
            dp[i][j] = 1e18;
        }
    }
    dp[0][0] = 0;
    for (int i = 1; i <= n; i++) {
        for (int j = sum; j >= 0; j--) {
            for (int k = sum; k >= 0; k--) {
                dp[j][k] = min((ll)1e18, dp[j][k] + (arr[i][2] != 3));
                if (j >= arr[i][1]) {
                    dp[j][k] = min(dp[j][k], dp[j - arr[i][1]][k] + (arr[i][2] != 1));
                }
                if (k >= arr[i][1]) {
                    dp[j][k] = min(dp[j][k], dp[j][k - arr[i][1]] + (arr[i][2] != 2));
                }
            }
        }
    }
    if (dp[sum][sum] >= 1e18) {
        cout << "-1";
    }
    else {
        cout << dp[sum][sum];
    }

}

 F-Road Blocked

思路 

一道图论题，需要用到Warshall-Floyd 求全源最短路的算法，首先我们将所有的查询进行离线化，现在就是一个有很多条边的无相不一定连通图，我们用n3的算法求出所有点的相关的最短路，然后我们倒着去查询，也就是进行加边（x.y）的操作，对于每一次加边，我们需要更新所有点的最短路，对于点i，j而言，加边之后的最短路只有三种情况

1-原来的路径

2-从i-x再从y到j

3-从i-y再从x到i

就可以得出最后的答案

代码比较繁琐

代码

void solve() {
    ll n, m, q;
    cin >> n >> m >> q;
    vector<vector<ll>>arr(m + 2, vector<ll>(6));
    vector<vector<ll>>dp(n + 2, vector<ll>(n + 2));
    for (int i = 1; i <= m; i++) {
        ll a, b, c;
        cin >> a >> b >> c;
        arr[i][1] = a;
        arr[i][2] = b;
        arr[i][3] = c;
        arr[i][4] = 1;
    }
    vector<vector<ll>>ans(q + 2, vector<ll>(8));
    for (int i = 1; i <= q; i++) {
        cin >> ans[i][1];
        if (ans[i][1] == 2) {
            cin >> ans[i][2] >> ans[i][3];
        }
        else {
            cin >> ans[i][2];
            arr[ans[i][2]][4] = 0;
        }
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            dp[i][j] = 1e17;
        }
    }
    for (int i = 1; i <= n; i++) {
        dp[i][i] = 0;
    }
    for (int i = 1; i <= m; i++) {
        if (arr[i][4] == 1) {
            dp[arr[i][1]][arr[i][2]] = min(dp[arr[i][1]][arr[i][2]], arr[i][3]);
            dp[arr[i][2]][arr[i][1]] = min(dp[arr[i][1]][arr[i][2]], arr[i][3]);// 建立双向边
        }
    }
    for (int k = 1; k <= n; k++) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j]);
            }
        }
    }
    
    for (int i = q; i >= 1; i--) {
        if (ans[i][1] == 2) {
            ans[i][5] = dp[ans[i][2]][ans[i][3]];
        }
        else {
            ll a = ans[i][2];
            ll x = arr[a][1];
            ll y = arr[a][2];
            ll z = arr[a][3];
            dp[x][y] = min(dp[x][y], z);
            dp[y][x] = min(dp[y][x], z);
            for (int j = 1; j <= n; j++) {
                for (int k = 1; k <= n; k++) {
                    dp[j][k] = min(dp[j][k], dp[j][x] + z + dp[y][k]);
                    dp[j][k] = min(dp[j][k], dp[j][y] + z + dp[x][k]);
                }
            }
            
        }
    }
    for (int i = 1; i <= q; i++) {
        if (ans[i][1] == 2) {
            //debug;
            if (ans[i][5] >= 1e16) {
                cout << "-1" << endl;
                continue;
            }
            cout << ans[i][5] << endl;
        }
        
    }
}

g不是很会