AtCoder Beginner Contest 344 A~G

A.Spoiler（字符串）

题意：

给定一个由小写英文字母和|组成的字符串$S$。

$S$保证只包含两个|。

删除两个“|”之间的字符，以及“|”本身，输出处理后的字符串。

分析：

遍历一遍字符串，找到|的下标，输出两侧的字符串即可。

代码：

#include<bits/stdc++.h>

using namespace std;

int main() {
    string s;
    cin >> s;
    int Lindex = 0, Rindex = 0;
    bool check = true;
    int l = s.size();
    for (int i = 0; i < l; i++) {
        if (s[i] == '|' && check) {
            Lindex = i;
            check = false;
        } else if (s[i] == '|' && !check) {
            Rindex = i;
        }
    }
    for (int i = 0; i < Lindex; i++)
        cout << s[i];
    for (int i = Rindex + 1; i < l; i++)
        cout << s[i];
    cout << endl << endl;
    return 0;
}

B.Delimiter（模拟）

题意：

给出$N$个整数$A_1,A_2,\dots ,A_N$，每行一个，共$N$行。$N$未在输入中给出。

此外，还保证：

• $A_i\ne 0$($1\le i\le N-1$)

• $A_N=0$

按此顺序输出$A_N,A_{N-1},\dots ,A_1$。

分析：

判断读入的数是否为$0$，为$0$就停止读入。

代码：

#include<bits/stdc++.h>

using namespace std;

int main() {
    vector<int> a;
    int temp;
    while (cin >> temp) {
        a.push_back(temp);
    }
    reverse(a.begin(), a.end());
    for (auto i: a) {
        cout << i << endl;
    }
    return 0;
} 

C.A+B+C（二分）

题意：

给出三个序列$A=(A_1,\dots ,A_N)$、$B=(B_1,\dots ,B_M)$和$C=(C_1,\dots ,C_L)$。

此外，还给出了序列$X=(X_1,\dots ,X_Q)$。对于每个$i=1,\dots ,Q$，解决以下问题：

• 是否可以从$A$、$B$和$C$中各选择一个元素，使它们的和为$X_i$？

分析：

由于每个数组的个数不超过$100$，事先预处理其所有可能的和并排序。

对于每组询问，通过二分查找$x$是否存在即可。

代码：

#include<bits/stdc++.h>

using namespace std;

int main() {
    int n, m, l;
    cin >> n;
    vector<int> a(n);
    for (auto &x: a)
        cin >> x;
    cin >> m;
    vector<int> b(m);
    for (auto &x: b)
        cin >> x;
    cin >> l;
    vector<int> c(l);
    for (auto &x: c)
        cin >> x;
    vector<int> sum;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            sum.push_back(a[i] + b[j]);
        }
    }
    sort(sum.begin(), sum.end());
    int q;
    cin >> q;
    while (q--) {
        int x;
        cin >> x;
        bool ok = false;
        for (int i = 0; i < l; i++) {
            auto it = lower_bound(sum.begin(), sum.end(), x - c[i]);
            if (it != sum.end() && *it == x - c[i]) {
                ok = true;
                break;
            }
        }
        if (ok)
            cout << "Yes" << endl;
        else {
            cout << "No" << endl;
        }
    }
    return 0;
}

D.String Bags（动态规划）

题意：

您最初有一个空字符串$S$。

此外，还有包$1,2,\dots ,N$，每个包都包含一些字符串。

包$i$包含$A_i$个字符串$S_{i,1},S_{i,2},\dots ,S_{i,A_i}$。对$i=1,2,\dots ,N$重复以下步骤：

选择并执行以下两个操作之一：

• 支付$1$日元，从包$i$中选择一个字符串，并将其连接到$S$的末尾。
• 什么都不做。

给定一个字符串$T$，找出使最终的$S$等于$T$所需的最小金额。

如果无法使最后的$S$等于$T$，则输出-1。

分析：

考虑所处的状态，即：

• 当前第几个袋子
• 当前匹配到了目标字符$T$的前几位

通过以上两个状态，就可以从当前的包选$1$个字符串，判断能否匹配，并转移到下一个状态。

设$dp[i][j]$表示前$i$个包拼接目标字符串$T$的前$j$位的最小金额。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;
const LL inf = 1e9 + 7;

int main() {
    string s;
    cin >> s;
    vector<int> dp(s.size() + 1, inf);
    dp[0] = 0;
    int n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        vector<int> dp2 = dp;
        int m;
        cin >> m;
        while (m--) {
            string t;
            cin >> t;
            for (int j = 0; j < s.size(); j++) {
                if (j + t.size() <= s.size() && s.substr(j, t.size()) == t) {
                    dp2[j + t.size()] = min(dp2[j + t.size()], dp[j] + 1);
                }
            }
        }
        dp.swap(dp2);
    }
    if (dp.back() == inf) {
        dp.back() = -1;
    }
    cout << dp.back() << endl;
    return 0;
}

E.Insert or Erase（链表）

题意：

给定一个长度为$N$的序列$A=(A_1,\dots ,A_N)$。$A$的元素是不同的。

按给定的顺序处理$Q$个查询。

每个查询都属于以下两种类型之一：

-1 X y：在$A$中的元素$x$之后立即插入$y$。当给定此查询时，保证$x$存在于$A$中。

-2 X：从$A$中删除元素$x$。当给定此查询时，保证$x$存在于$A$中。

可以保证在处理每个查询后，$A$不会为空，并且其元素是不同的。

处理完所有查询后输出$A$。

分析：

使用链表实现在较小的时间内完成对元素的插入，用$map$帮助定位链表中数的位置，然后进行插入和删除。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;

struct Node {
    int val;
    Node *l, *r;
};

int main() {
    map<int, Node *> pos;
    Node *L = new Node();
    Node *R = new Node();
    L->r = R;
    R->l = L;
    int n;
    cin >> n;
    Node *la = L;
    auto insert = [](Node *p, Node *x) {
        x->l = p;
        x->r = p->r;
        p->r->l = x;
        p->r = x;
    };
    auto remove = [](Node *x) {
        x->l->r = x->r;
        x->r->l = x->l;
    };
    for (int i = 0; i < n; i++) {
        LL x;
        cin >> x;
        Node *X = new Node();
        X->val = x;
        insert(la, X);
        la = X;
        pos[x] = X;
    }
    int q;
    cin >> q;
    while (q--) {
        int op;
        cin >> op;
        if (op == 1) {
            LL x, y;
            cin >> x >> y;
            Node *Y = new Node();
            Y->val = y;
            insert(pos[x], Y);
            pos[y] = Y;
        } else if (op == 2) {
            LL x;
            cin >> x;
            remove(pos[x]);
        }
    }
    for (auto i = L->r; i != R; i = i->r) {
        cout << i->val << " ";
    }
    cout << endl;
    return 0;
}

F.Earn to Advance（dp）

题意：

有一个包含$N$行和$N$列的网格。

设$(i,j)$表示从上往下第$i$行、从左往下第$j$列的正方形。

高桥最初在$(1,1)$，资金为零。

当高桥位于$(i,j)$时，他可以在一个动作中执行以下操作之一：

• 停留在同一方格并将他的钱增加$P_{i,j}$。

• 从他的钱中支付$R_{i,j}$并移动到$(i,j+1)$。

• 从他的钱中支付$D_{i,j}$并移动到$(i+1,j)$。

他不能做出会让他的钱变成负数的举动，也不能让他离开网格。

如果高桥采取最优行动，他需要多少次动作才能达到$(N,N)$？

分析：

考虑枚举最后一个停留的位置$(x,y)$，假设我们已经知道了从$(1,1)$走到$(x,y)$的最优路径（步数$s$与剩的钱$c$），就可以简单的算出来需要在$(x,y)$停留多久才能直接走到$(N,N)$。

之前的操作，即从$(1,1)$走到$(x,y)$的最优路径是一个子问题，对此进行$dp$即可。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;
const LL mod = 998244353;
const LL N = 85;

int n;
LL p[N][N], r[N][N], d[N][N], b[N][N];
pair<LL, LL> f[N][N];

int main() {
    cin >> n;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            cin >> p[i][j];
        }
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j < n; j++) {
            cin >> r[i][j];
        }
    }
    for (int i = 1; i < n; i++) {
        for (int j = 1; j <= n; j++) {
            cin >> d[i][j];
        }
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            f[i][j] = {1e18, 0};
        }
    }
    f[1][1] = {0, 0};
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (i == 1 && j == 1) {
                continue;
            }
            for (int x = 1; x <= i + 1; x++) {
                for (int y = 1; y <= j + 1; y++) {
                    b[x][y] = 1e18;
                }
            }
            b[i][j] = 0;
            for (int x = i; x >= 1; x--) {
                for (int y = j; y >= 1; y--) {
                    if (x == i && y == j) {
                        continue;
                    }
                    b[x][y] = min(b[x][y + 1] + r[x][y], b[x + 1][y] + d[x][y]);
                }
            }
            for (int x = 1; x <= i; x++) {
                for (int y = 1; y <= j; y++) {
                    if (x == i && y == j) {
                        continue;
                    }
                    LL c = f[x][y].second, v = max(0LL, (b[x][y] + c + p[x][y] - 1) / p[x][y]);
                    f[i][j] = min(f[i][j], {f[x][y].first + v + (i - x) + (j - y), b[x][y] + c - p[x][y] * v});
                }
            }
        }
    }
    cout << f[n][n].first << endl;
    return 0;
}

G - Points and Comparison（数学）

题意：

在一个二维平面中有$n$个点$x_i,y_i$，给出$Q$对整数$a_j,b_j$，定义$f(a_j,b_j)$，为满足$y_i\ge a_j\times x_i+b_j$的$i$的数量。求${\sum }_{j=1}^{Q}f(a_j,b_j)$

分析：

设$K=A,b=B$，那么$(a_j,b_j)$表示一条直线，$(x_i,y_i)$表示一个点。考虑$y_i\ge k\times x_i+b$，表示点在直线上方或是刚在直线上。保持$y_i-k\times x_i$递增，就可以通过二分查找$b$。
假设$tmp$是一个排列，并保持$y_i-k\times x_i$递增。考虑$tmp$排列上$(x_l,y_l),(x_r,y_r)$这两个点。对于一个$k$，如果$x_l=x_r$，那么$l,r$位置不变。如果$l,r$两点的斜率大于$k$，则交换$l,r$。考虑到每两个点之间至多只需要交换一次，所以把询问按照$k$从小到大排序，对于每对关系，如果交换了一次，后面也总是满足$tmp$排列的规则。再将相邻点的斜率值放到优先队列中，如果某个$k$大于其中的斜率，就将对应两个点交换，继续维护。当得到了满足一个$k$的排列$tmp$，就在$tmp$上进行二分查找答案。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
#define PII pair<LL, LL>
const LL mod = (1ll << 31) - 1;

struct Line {
    LL up, dn;
    int pre, nxt;

    Line(LL _up, LL _dn, int _pre, int _nxt) {
        if (dn < 0)
            up = -up, dn = -dn;
        up = _up, dn = _dn, pre = _pre, nxt = _nxt;
    }

    bool operator<(const Line &rhs) const {
        return up * rhs.dn > dn * rhs.up;
    }

    bool operator==(const Line &rhs) const {
        return up == rhs.up && dn == rhs.dn && pre == rhs.pre && nxt == rhs.nxt;
    }
};

int main() {
    int n;
    cin >> n;
    vector<PII > a(n + 1);
    for (int i = 1; i <= n; i++) {
        auto &[k, b] = a[i];
        cin >> k >> b;
    }
    sort(a.begin() + 1, a.end());
    LL Q;
    cin >> Q;
    LL G0, Ra, Rb;
    cin >> G0 >> Ra >> Rb;
    vector<PII > q(Q + 1);
    vector<LL> G(3 * Q + 1);
    G[0] = G0;
    for (int i = 1; i <= 3 * Q; i++)
        G[i] = (48271 * G[i - 1]) % mod;
    for (int i = 1; i <= Q; i++) {
        auto &[A, B] = q[i];
        A = -Ra + (G[3 * i - 2] % (2 * Ra + 1));
        B = -Rb + ((G[3 * i - 1] * mod + G[3 * i]) % (2 * Rb + 1));
    }
    sort(q.begin() + 1, q.end());
    auto make_line = [&](int i, int j) {
        return Line(a[j].second - a[i].second, a[j].first - a[i].first, i, j);
    };
    priority_queue<Line> s;
    for (int i = 1; i < n; i++)
        if (a[i].first < a[i + 1].first)
            s.push(make_line(i, i + 1));
    LL ans = 0;
    for (int i = 1; i <= Q; i++) {
        auto [k, b] = q[i];
        while (s.size() > 0) {
            auto it = s.top();
            LL dn = it.dn, up = it.up, pre = it.pre, nxt = it.nxt;
            if (!(make_line(pre, nxt) == it)) {
                s.pop();
                continue;
            }
            if (k * dn < up)
                break;
            s.pop();
            swap(a[pre], a[nxt]);
            if (pre > 1 && a[pre - 1].first < a[pre].first)
                s.push(make_line(pre - 1, pre));
            if (nxt < n && a[nxt].first < a[nxt + 1].first)
                s.push(make_line(nxt, nxt + 1));
        }
        LL l = 1, r = n;
        while (l <= r) {
            LL mid = (l + r) >> 1;
            auto [X, Y] = a[mid];
            if (-k * X + Y >= b)
                r = mid - 1;
            else
                l = mid + 1;
        }
        ans += n - r;
    }
    cout << ans << endl;
    return 0;
}

赛后交流

在比赛结束后，会在交流群中给出比赛题解，同学们可以在赛后查看题解进行补题。

群号： 704572101，赛后大家可以一起交流做题思路，分享做题技巧，欢迎大家的加入。