Educational Codeforces Round 71 (Rated for Div. 2)

传送门

A.There Are Two Types Of Burgers

签到。

B.Square Filling

签到

C.Gas Pipeline

每个位置只有“高、低”两种状态，所以直接根据条件来\(dp\)即可。

Code

#include <bits/stdc++.h>
#define MP make_pair
#define INF 0x3f3f3f3f3f3f3f3f
using namespace std;
typedef long long ll;
const int N = 2e5 + 5;
ll n, a, b;
int T;
char s[N];
ll dp[N][2];
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    cin >> T;
    while(T--) {
        cin >> n >> a >> b;
        cin >> s;
        for(int i = 0; i <= n; i++) dp[i][0] = dp[i][1] = INF;
        dp[0][0] = b;
        for(int i = 1; i <= n; i++) {
            if(s[i - 1] == '1' || s[i] == '1') dp[i][1] = min(dp[i - 1][0] + 2 * (a + b), dp[i - 1][1] + a + 2 * b);
            else {
                dp[i][0] = min(dp[i - 1][1] + 2 * a + b, dp[i - 1][0] + a + b);
                dp[i][1] = min(dp[i - 1][1] + a + 2 * b, dp[i - 1][0] + 2 * (a + b));
            }
        }
        cout << dp[n][0] << '\n';
    }
    return 0;
}

### D.Number Of Permutations

题意：

给出\(n\)个二元组\((a_i,b_i)\)，定义一个坏的序列为：序列中按第一关键字或者按第二关键字是非递减的。

相反，好的序列的定义就与之相反。

现在问有多少种打乱方式，能够得到好的序列。

思路：

• 考虑直接来求，发现过于复杂。
• 所以考虑利用容斥的思想来做，先分别求出按第一关键字、第二关键字非递减的方案数，最后求出同时非递减的方案数，加加减减即可。
• 同时非递减这种情况怎么处理呢？
• 观察可以发现此时\(a_i,b_i\)分别非递减，所以我们就暴力扫一遍找共同部分就行了。
• 那一个非递减，另一个不是呢？这种我们上面会计算到，此时答案为1，包含在上面计算中了。

注意还有特殊情况的判断：

Code

#include <bits/stdc++.h>
#define MP make_pair
#define INF 0x3f3f3f3f3f3f3f3f
#define fi first
#define se second
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int N = 3e5 + 5, MOD = 998244353;
int n;
pii p[N];
ll fac[N];
ll gao1() {
    ll res = 1;
    for(int i = 1, j; i <= n; i = j) {
        for(j = i; j <= n + 1; j++) {
            if(p[i].fi != p[j].fi) break;
        }
        int cnt = 1;
        for(int k = i + 1; k < j; k++) {
            if(p[k].se == p[k - 1].se) ++cnt;
            else {
                res = res * fac[cnt] % MOD;
                cnt = 1;
            }
        }
        res = res * fac[cnt] % MOD;
    }
    return res;
}
ll gao2() {
    ll res = 1;
    for(int i = 1, j; i <= n; i = j) {
        for(j = i; j <= n + 1; j++) {
            if(p[i].se != p[j].se) break;
        }
        int cnt = 1;
        for(int k = i + 1; k < j; k++) {
            if(p[k].fi == p[k - 1].fi) ++cnt;
            else {
                res = res * fac[cnt] % MOD;
                cnt = 1;
            }
        }
        res = res * fac[cnt] % MOD;
    }
    return res;
}
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    cin >> n;
    for(int i = 1; i <= n; i++) {
        cin >> p[i].fi >> p[i].se;
    }
    sort(p + 1, p + n + 1);
    fac[0] = 1;
    for(int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % MOD;
    ll ans = fac[n];
    ll sum1 = 1, sum2 = 1;
    for(int i = 1, j; i <= n; i = j) {
        for(j = i; j <= n + 1; j++) {
            if(p[i].fi != p[j].fi) break;
        }
        sum1 = sum1 * fac[j - i] % MOD;
    }
    sort(p + 1, p + n + 1, [&](pii A, pii B) {
        return A.se < B.se;
    });
    for(int i = 1, j; i <= n; i = j) {
        for(j = i; j <= n + 1; j++) {
            if(p[i].se != p[j].se) break;
        }
        sum2 = sum2 * fac[j - i] % MOD;
    }
    ans -= sum1 + sum2;
    ans %= MOD; if(ans < 0) ans += MOD;
    bool f = 1;
    for(int i = 2; i <= n; i++) {
        if(p[i].fi < p[i - 1].fi) f = 0;
    }
    if(f) ans += gao1();
    else {
        f = 1;
        sort(p + 1, p + n + 1);
        for(int i = 2; i <= n; i++) {
            if(p[i].se < p[i - 1].se) f = 0;
        }
        if(f) ans += gao2();
    }
    cout << ans % MOD;
    return 0;
}

E. XOR Guessing

题意：

交互题。

先有一个数大小不超过\(2^{14}-1\)，给你两次机会，每次询问100个数，对方会告诉你这个数与从100个中随机一个数的异或值。注意所有询问的数都不能重复。

最后输出此答案。

思路：

设答案为\(ans\)。

• 如果二进制一位全都是1，那么此时询问是不是很容易知道\(ans\)？
• 因为不能有重复，并且结合题目，我们就一次询问出一半的情况即可。

Code

#include <bits/stdc++.h>
#define MP make_pair
#define INF 0x3f3f3f3f3f3f3f3f
using namespace std;
typedef long long ll;
const int N = 105;
int a[N], b[N];
int main() {
    //ios::sync_with_stdio(false); cin.tie(0);
    int now = 0;
    for(int i = 7; i <= 13; i++) {
        now += (1 << i);
    }
    for(int i = 1; i <= 100; i++) a[i] = i + now;
    now = 0;
    for(int i = 0; i <= 6; i++) {
        now += (1 << i);
    }
    int cnt = 0;
    for(int s = 0; s < 1 << 7; s++) {
        b[++cnt] = (s << 7) + now;
        if(cnt == 100) break;
    }
    int x, y;
    cout << "? ";
    for(int i = 1; i <= 100; i++) cout << a[i] << ' ';
    cout << '\n';
    cin >> x;
    fflush(stdout);
    cout << "? ";
    for(int i = 1; i <= 100; i++) cout << b[i] << ' ';
    cout << '\n';
    cin >> y;
    int ans = 0;
    for(int i = 7; i < 14; i++) {
        if(x >> i & 1) {}
        else ans += (1 << i);
    }
    for(int i = 0; i < 7; i++) {
        if(y >> i & 1) {}
        else ans += (1 << i);
    }
    cout << '!' << ' ' << ans;
    return 0;
}

F.F. Remainder Problem

题意：

现在数轴上有\(500000\)个位置，先有两个操作：

• \(1\ x\ y:\)表示\(a[x]\)加上\(y\)；
• \(2\ x\ y:\)表示对所有满足条件的位置的\(a_i\)求和，这里的满足条件是\(i\% x=y\)。

有\(500000\)次询问，对每次\(2\)操作输出答案。

思路：

• 注意到如果\(x\)比较大，那么我们可以直接暴力的，所以考虑分块。
• 修改的话直接暴力修改，如果\(x>E\)，我们就直接暴力询问；否则，直接输出预处理的值。
• 怎么预处理呢？我们首先让\(E=\sqrt{500000}=750\)，注意到\(E,y\)都很小，那么我们就开一个数组\(pos[x][y]\)表示模\(x\)余\(y\)所有位置数的和。
• 修改的话同时修改\(pos\)数组即可。

详见代码：

Code

#include <bits/stdc++.h>
#define MP make_pair
#define INF 0x3f3f3f3f3f3f3f3f
#define fi first
#define se second
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int N = 500005, E = 750;
int q;
int pos[E][E]; // % x = y
int a[N];
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    cin >> q;
    while(q--) {
        int op, x, y; cin >> op >> x >> y;
        if(op == 1) {
            a[x] += y;
            for(int i = 1; i < E; i++) {
                pos[i][x % i] += y;
            }
        } else {
            if(y < 0) y += x;
            if(x < E) {
                cout << pos[x][y] << '\n';
            } else {
                int ans = 0;
                for(int i = y; i < N; i += x) ans += a[i];
                cout << ans << '\n';
            }
        }
    }
    return 0;
}

G.Indie Album

题意：

现有两种操作：

• \(1\ c:\)表示以\(c\)开头，重新建立一个字符串；
• \(2\ j\ c:\)表示在第\(j\)个版本后面加上一个字符\(c\)，注意每次操作版本都会更新。

同时有多组询问，每组询问如：\("i\ t"\)的格式，询问\(t\)这个字符串在第\(i\)个版本的字符串中出现了多少次。

思路：

类似于阿狸的打字机，考虑离线处理问题。

• 对于1操作，注意到其实并不用重新建立自动机，我们只用关注每个版本的\(end\)位置就好，所以直接拿一个数组记录每个版本的\(end\)位置即可。
• 同时处理出每个询问串所在AC自动机上面的位置。
• 之后就类似于阿狸打字机的套路，将\(fail\)树建出来，跑出\(dfs\)序，用树状数组维护前缀链即可。
• 啥，为啥是前缀链？
• 不就是\(fail\)树求子子串个数的套路么？若\(x\)串在\(y\)串中，那么\(y\)的前缀链肯定存在一个点其\(fail\)是指向\(x\)的，即在\(fail\)树上点\(x\)的子树中。那问题不就是子树求和么。

思路就是这样，但注意一个细节，最后dfs的时候会走错点！！因为我们建fail的时候改变了儿子信息。所以可以事先拿个数组保存一下。

Code

#include <bits/stdc++.h>
#define MP make_pair
using namespace std;
typedef long long ll;
const int N = 1e6 + 5, MAX = 26;
queue <int> q;
int nd[N], in[N], out[N], T;
int res[N], c[N];
vector <pair<int, int> > v[N];
int lowbit(int x){return x & (-x);}
void upd(int x, int v) {
    for(; x < N; x += lowbit(x)) c[x] += v;
}
int query(int x) {
    int ans = 0;
    for(; x; x -= lowbit(x)) ans += c[x];
    return ans;
}
int query(int l, int r) {
    return query(r) - query(l - 1);
}
struct ACAM{
    int sz;
    int ch[N][MAX], ch2[N][MAX];
    int fail[N];
    vector <int> g[N];
    int newnode() {
        memset(ch[++sz], 0, sizeof(ch[sz]));
        fail[sz] = 0;
        return sz;
    }
    void init() {
        sz = -1;
        newnode();
    }
    int insert(int u, char *s) {
        int len = strlen(s);
        for(int i = 0; i < len; i++) {
            if(!ch[u][s[i] - 'a']) ch[u][s[i] - 'a'] = newnode();
            u = ch[u][s[i] - 'a'];
        }
        return u;
    }
    void build() {
        for(int i = 0; i <= sz; i++) {
            for(int j = 0; j < 26; j++) {
                ch2[i][j] = ch[i][j];
            }
        }
        for(int i = 0; i < 26; i++) {
            if(ch[0][i]) q.push(ch[0][i]);
        }
        while(!q.empty()) {
            int cur = q.front(); q.pop();
            g[fail[cur]].push_back(cur);
            for(int i = 0; i < 26; i++) {
                if(ch[cur][i]) {
                    fail[ch[cur][i]] = ch[fail[cur]][i];
                    q.push(ch[cur][i]);
                } else {
                    ch[cur][i] = ch[fail[cur]][i];
                }
            }
        }
    }
    void pre(int u) {
        in[u] = ++T;
        for(auto it : g[u]) pre(it);
        out[u] = T;
    }
    void dfs(int u) {
        upd(in[u], 1);
        for(auto it : v[u]) {
            res[it.second] = query(in[it.first], out[it.first]);
        }
        for(int i = 0; i < 26; i++) {
            if(ch2[u][i]) dfs(ch2[u][i]);
        }
        upd(in[u], -1);
    }
}ac;
int n;
char s[2], str[N];
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    cin >> n;
    ac.init();
    for(int i = 1; i <= n; i++) {
        int op; cin >> op;
        if(op == 1) {
            cin >> s;
            nd[i] = ac.insert(0, s);
        } else {
            int x; cin >> x >> s;
            nd[i] = ac.insert(nd[x], s);
        }
    }
    int q; cin >> q;
    for(int i = 1; i <= q; i++) {
        int x; cin >> x >> str;
        v[nd[x]].push_back(MP(ac.insert(0, str), i));
    }
    ac.build();
    ac.pre(0);
    ac.dfs(0);
    for(int i = 1; i <= q; i++) cout << res[i] << '\n';
    return 0;
}