AtCoder Beginner Contest 431

A - Robot Balance

思路

如果 \(head\) 比 \(bady\) 重，答案就是二者之差，反之不需要补充，输出0

AC Code

    int n, m;

    void solve(){
        cin >> n >> m;
        cout << max(0ll, n - m )<< endl;
        return ;
    }

B - Robot Weight

思路

按照题意模拟即可，如果没有安装，则安装上，反之卸下

AC Code

    int x, n, q;
    int a[N];
    bool st[N];

    void solve(){
        cin >> x >> n;
        for(int i = 1; i <= n ; i ++ ){
            cin >> a[i];
        }
        cin >> q;
        while(q -- ){
            int op;
            cin >> op;
            if(!st[op]){
                x += a[op];
                st[op] = true;
            }
            else{
                x -= a[op];
                st[op] = false;
            }
            cout << x << endl ;
        }
        return ;
    }

C - Robot Factory

思路

首先对两个数组排序，对于 \(bady\) 我们去找 \(head\) ，由于要越多越好，所以我们有先从最重的 \(bady\) 找，二分查找第一个符合要求的 \(head\) 即是最好的策略

AC Code

    int n, m, k;
    int b[N];
    set<int, greater<int>> st;
    map<int, int> num;

    void solve(){
        cin >> n >> m >> k;
        for(int i = 1; i <= n ; i ++ ){
            int a;
            cin >> a;
            st.insert(a);
            num[a] ++;
        }
        for(int i = 1; i <= m ; i ++ ){
            cin >> b[i];
        }
        sort(b + 1, b + 1 + m, greater<> ());
        for(int i = 1; i <= m ; i ++ ){
            auto it = st.lower_bound(b[i]);
            if(it == st.end())break;
            int p = (*it);
            num[p] --;
            k --;
            if(num[p] <= 0)st.erase(p);
            //cout << b[i]  << " " << p << " " << num[p]<< endl;
        }
        cout << (k <= 0  ? "Yes" : "No") << endl;
        return ;
    }

D - Robot Customize

思路

假设先将所有部件安装到 \(head\) 上，问题转化为对于每个部件，代价 \(W_i\) 价值为 \(H_i - B_i\) 的01背包问题，用滚动数组优化,最后在代价不大于 \(\sum_{i=1}^{n} W_i / 2\) 中找答案

AC Code

    int n;
    int w[M];
    int h[M];
    int b[M];
    int dp[N]; 
    int ans = INF;

    void solve(){
        cin >> n;
        int W = 0;
        for(int i = 1; i <= n; i ++ ){
            cin >> w[i] >> h[i] >> b[i];
            W += w[i];
        }
        
        for(int i = 1; i <= n ; i ++ ){
            for(int j = W; j >= w[i]; j -- ){
                dp[j] = max(dp[j], dp[j - w[i]] + (h[i] - b[i]));
            }
        }
        for(int i = 0; i <= W / 2 ; i ++ ){
            ans = max(ans, dp[i]);
        }
        for(int i = 1; i <= n ; i ++ ){
            ans += b[i];
        }
        cout << ans << endl;
        return ;
    }

E - Reflection on Grid

思路

典型的BFS求最小步数模型，需要转变类型代价为1，反之为0，属于只有01权重的最短路问题，用双端队列BFS即可

AC Code

    struct Node {
        int x, y, f;
    };

    string dir = "ABC";
    string s[N];
    vector<int> d[4][N];

    int dx[] = {0, 1, 0, -1};
    int dy[] = {1, 0, -1, 0};

    void nxt(int x, int y, int f, char c, int &nx, int &ny, int &nf) {
        if (c == 'A') nf = f;
        else if (c == 'B') nf = (5 - f) % 4;
        else nf = 3 - f;
        nx = x + dx[nf];
        ny = y + dy[nf];
    }

    void solve(int cs) {
        int n, m;
        cin >> n >> m;
        for (int i = 1; i <= n; i++) {
            cin >> s[i];
            s[i] = ' ' + s[i];
        }
        for (int i = 0; i <= n + 1; i++) {
            for (int k = 0; k <= 3; k++) {
                d[k][i].assign(m + 2, INF);
            }
        }
        d[0][1][1] = 0;
        deque<Node> q;
        q.clear();
        q.push_back({1, 1, 0});
        int ans = INF;
        while (q.size()) {
            auto [x, y, f] = q.front();
            q.pop_front();
            int nx, ny, nf, dis;
            for (auto c : dir) {
                nxt(x, y, f, c, nx, ny, nf);
                if (s[x][y] == c) dis = d[f][x][y];
                else dis = d[f][x][y] + 1;
                if (nx == n && ny == m + 1 && nf == 0) ans = min(ans, dis);
                if (nx == 0 || ny == 0 || nx > n || ny > m) continue;
                if (dis < d[nf][nx][ny]) {
                    d[nf][nx][ny] = dis;
                    if (s[x][y] == c) q.push_front({nx, ny, nf});
                    else q.push_back({nx, ny, nf});
                }
            }
        }
        cout << ans << endl;
        return ;
    }