2024 湖南省赛（HNCPC 2024）

1|0C - easy math

Π a_{i} \leq 2024^{b} \log_{2} (Π 2^{k_{i}}) \leq \log_{2} (2024^{b}) \sum k_{i} \leq b \log_{2} 2024

$\Pi a_i \le 2024^b\\ \log_2 (\Pi 2^{k_i}) \le \log_2(2024^b)\\ \sum k_i\le b\log_2 2024$

因此答案就是 $b = \frac{\sum k_i}{\log_2 2024}$

#include <bits/stdc++.h>

using namespace std;


using i32 = int32_t;
using i64 = long long;
using ui32 = unsigned int;

#define int i64

using pii = pair<int,int>;
using vi = vector<int>;

 
i32 main() {
	ios::sync_with_stdio(false), cin.tie(nullptr);
    int n;
    cin >> n;

    int sum = 0;
    for(int i = 0, x; i < n; i ++) {
    	cin >> x;
    	sum += log2(x);
    }

    cout << ceil(sum / log2(2024));
    return 0;
}

2|0E - 拼接串

考虑值域只有 $18$ ，因此我们可以用 $f[i]$ 表示状态 $i$ 对应的最长区间。其中 $i$ 是一个 $18$ 位二进制整数

我们可以先用双指针统计出每个 $l$ 对应的合法区间的最大右端点 $r$ 。并且更新 $f$ 。

然后我们可以在做一次dp，状态为 $g[i]$ 表示 $i$ 的子集对应的最场区间。

此时答案就可以表示为 $\max(g[i]+g[(2^{18} - 1) \oplus i])$ 。

#include <bits/stdc++.h>

using namespace std;


using i32 = int32_t;
using i64 = long long;
using ui32 = unsigned int;

#define int i64

using pii = pair<int,int>;
using vi = vector<int>;

 
i32 main() {
    ios::sync_with_stdio(false), cin.tie(nullptr);
    int n;
    cin >> n;

    vi a(n + 1);
    for(int i = 1; i <= n; i ++) 
        cin >> a[i], a[i] = (1 << (a[i] - 1));

    int N = (1 << 18) - 1;
    
    vi f(N + 1);
    for(int l = 1, r = 0, t = 0; l <= n; l ++) {
        while(r + 1<= n and (t & a[r + 1]) == 0)
            r ++, t |= a[r];
        f[t] = max(f[t], r - l + 1);
        t ^= a[l]; 
    }

    for(int i = 0; i < N; i ++) {
        for(int j = 1; j <= N; j <<= 1){
            if((i & j) == 0)
                f[i | j] = max(f[i | j], f[i]);
        }
    }

    int res = 0;
    for(int i = 0; i <= N; i ++)
        res = max(res, f[i] + f[N ^ i]);
    cout << res;
    return 0;
}

3|0H. 经文

$f[i][j][l]$ 表示前 $i$ 位，且已经匹配了 $j$ 个完整的串，当前串匹配到了 $l$ 的方案数。然后我们可以枚举下一位放什么，这里面如果失配，下一位不一定需要从头开始匹配，我们可以用 $kmp$ 的前缀数组进行计算下一位可能匹配到哪一位。

#include <bits/stdc++.h>

using namespace std;


using i32 = int32_t;
using i64 = long long;
using ui32 = unsigned int;

#define int i64

using pii = pair<int,int>;
using vi = vector<int>;

vector<int> prefix_function(const string &s) {
    vector<int> pi(s.size());
    for (int i = 2, j = 0; i < s.size(); i++) {
        while (j > 0 && s[i] != s[j + 1]) j = pi[j];
        if (s[i] == s[j + 1]) j++;
        pi[i] = j;
    }
    return pi;
}
const int mod = 998244353;
 
struct mint {
    int x;

    mint(int x = 0) : x(x) {}

    int val() {
        return x = (x % mod + mod) % mod;
    }

    mint &operator=(int o) { return x = o, *this; }

    mint &operator+=(mint o) { return (x += o.x) >= mod && (x -= mod), *this; }

    mint &operator-=(mint o) { return (x -= o.x) < 0 && (x += mod), *this; }

    mint &operator*=(mint o) { return x = (i64) x * o.x % mod, *this; }

    mint &operator^=(int b) {
        mint w = *this;
        mint ret(1);
        for (; b; b >>= 1, w *= w) if (b & 1) ret *= w;
        return x = ret.x, *this;
    }

    mint &operator/=(mint o) { return *this *= (o ^= (mod - 2)); }

    friend mint operator+(mint a, mint b) { return a += b; }

    friend mint operator-(mint a, mint b) { return a -= b; }

    friend mint operator*(mint a, mint b) { return a *= b; }

    friend mint operator/(mint a, mint b) { return a /= b; }

    friend mint operator^(mint a, int b) { return a ^= b; }
};

i32 main() {
	ios::sync_with_stdio(false), cin.tie(nullptr);
    int n, k;
    cin >> n >> k;

    string s;
    cin >> s;
    int m = s.size();
    s = " " + s;

    auto pi = prefix_function(s);

    vector f(n + 1, vector(k + 2, vector<mint>(m + 1)));
    f[0][0][0] = 1;
    for(int i = 0; i < n; i ++) {
        for(int j = 0; j <= k; j ++) {
            for(int l = 0; l < m; l ++){
                for(char c = 'a'; c <= 'z'; c ++) { // 枚举 i+1 位放什么字母
                    bool ok = false;// 有没有匹配成功过
                    for(int pre = l; ok == false; pre = pi[pre]) {
                        if(s[pre + 1] == c) { // 匹配
                            if(pre == m - 1){
                                f[i + 1][j + 1][0] += f[i][j][l];
                            } else {
                                f[i + 1][j][pre + 1] += f[i][j][l];
                            }
                            ok = true;
                        }
                        if(pre == 0) break;
                    }
                    if(ok) continue;
                    f[i + 1][j][0] += f[i][j][l];
                }
            }
        }
    }
    mint res = 0;
    for(int i = 0; i < m; i ++)
        res += f[n][k][i];
    cout << res.val();
    return 0;
}

4|0I - 数据检索系统

按照题目模拟

#include <bits/stdc++.h>

using namespace std;


using i32 = int32_t;
using i64 = long long;
using ui32 = unsigned int;

#define int i64

using pii = pair<int,int>;
using vi = vector<int>;

 
i32 main() {
	ios::sync_with_stdio(false), cin.tie(nullptr);
    int mod, k, n, q;
    cin >> mod >> k >> n >> q;

    vi vis(mod);
    for(int x; n; n --) {
        cin >> x;
        for(int i = 1, y = 1; i <= k; i ++) {
            y = y * x % mod;
            vis[y] |= 1;
        }
    }

    for(int x, f; q; q --) {
        cin >> x, f = 1;
        for(int i = 1, y = 1; i <= k; i ++) {
            y = y * x % mod;
            f &= vis[y];
        }
        cout << f << " ";
    }
    return 0;
}

5|0J - Beautiful Sequence

对于数组 $a[i]$ 我们记 $A$ 表示数字 $a[i]$ 出现在了下标 $A[a[i]]$ 的位置。对于 $b$ 有类似的 $B$

对于题目的要求，可以转换为对于值域 $[l,r]$ ，如果值域内的数都选就是 beautifu 序列。

很容想到一个性质，对于值域 $[l,r]$ 的子序列，如果 $a,b$ 相同，则一定满足值域 $[l,r-1]$ 的子序列 $a,b$ 也一定相同。

因此我们可以用双指针求出对于每一个 $l$ 符合条件的最大的 $r$ 。

现在我们考虑如何快速判断出值域 $[l,r]$ 的子序列在 $a,b$ 出现的顺序相同。此时应满足

\forall x, y \in [l, r], (A [x] > A [y]) = (B [x] > B [y])

$\forall x,y \in [l, r], (A[x] > A[y]) = (B[x] > B[y])$

我们如果暴力的判断实际是 $O(N^2)$ 的，加上双指针的复杂度，肯定无法通过。

我们可以考虑，如何在已知 $[l,r - 1]$ 满足的情况下，判断 $[l,r]$ 是否满足？

我们可以用两个std::set<int>分别维护 $A[l,r-1],B[l,r-1]$ 。当我们插入 $A[r],B[r]$ ，可以在set中找到前后的第一个数字，并判断是否相等，这样的复杂度是 $O(\log N)$ 。所以总体复杂度就是 $O(N\log N)$ 。

#include <bits/stdc++.h>

using namespace std;


using i32 = int32_t;
using i64 = long long;
using ui32 = unsigned int;

#define int i64

using pii = pair<int,int>;
using vi = vector<int>;

const int inf = LLONG_MAX / 2;


i32 main() {
    ios::sync_with_stdio(false), cin.tie(nullptr);
    
    int n, m;
    cin >> n;

    vi a(n + 1), b(n + 1), A(n + 1), B(n + 1);

    for(int i = 1; i <= n; i ++){
        cin >> a[i];
        A[a[i]] = i;
    }

    for(int i = 1; i <= n; i ++) {
        cin >> b[i];
        B[b[i]] = i;
    }

    int res = 0;
    set<int> pa , pb;
    for(int l = 1, r = 0; l <= n; l ++ ){
        
        auto check = [&](int i) -> bool {
            int x = A[i], y = B[i];

            auto rx = pa.upper_bound(x), ry = pb.upper_bound(y);

            if((rx == pa.end()) != (ry == pb.end())) return false;
            

            if(rx != pa.end()) {
                if(a[*rx] != b[*ry]) return false;
            }

            if((rx == pa.begin()) != (ry == pb.begin())) return false;

            if(rx == pa.begin()) return true;

            auto lx = prev(rx), ly = prev(ry);

            if(a[*lx] != b[*ly]) return false;

            return true;
        };

        while(r + 1 <= n and check(r + 1)){
            r ++;
            pa.insert(A[r]), pb.insert(B[r]);
        }
        
        res += r - l + 1;

        pa.erase(A[l]), pb.erase(B[l]);
    }

    cout << res;

}

6|0K - 渡劫

我们可以建立分层图，这样的话一次免费的机会就是层与层之间的单向边。然后建立一个超级终点，然后从每一个点到超级终端的单向边权就是点权。

然后就是要求所有点到终点的最短路，实际上我们从终点反向建边求单源最短路。

答案就是最短路的最大值。

#include <bits/stdc++.h>

using namespace std;


using i32 = int32_t;
using i64 = long long;
using ui32 = unsigned int;

#define int i64

using pii = pair<int,int>;
using vi = vector<int>;

const int inf = LLONG_MAX / 2;


i32 main() {
	ios::sync_with_stdio(false), cin.tie(nullptr);
    
    int n, m;
    cin >> n >> m;

    int N = 2 * n;

    vector<vector<pii>> e(N + 1);
    for(int u, v, w; m; m --) {
        cin >> u >> v >> w;
        e[u].emplace_back(v, w);
        e[v].emplace_back(u, w);
        e[u].emplace_back(v + n, 0);
        e[v].emplace_back(u + n, 0);
        e[u + n].emplace_back(v + n, w);
        e[v + n].emplace_back(u + n, w);
    }

    for(int i = 1, x; i <= n; i ++) {
        cin >> x;
        e[0].emplace_back(i, x);
        e[0].emplace_back(i + n, x);
    }

    vi dis(N + 1, inf), vis(N + 1);
    dis[0] = 0;

    priority_queue<pii,vector<pii>, greater<>> heap;
    heap.emplace(0, 0);
    while(not heap.empty()) {
        auto [d, u] = heap.top();
        heap.pop();

        if(vis[u]) continue;
        vis[u] = 1;
        for(auto [v, w] : e[u]) {
            if(vis[v] or dis[v] <= d + w) continue;
            dis[v] = d + w;
            heap.emplace(dis[v], v);
        }
    }
    
    int res = -1;
    for(int i = 1; i <= n; i ++)
        res = max(res, min(dis[i], dis[i + n]));
    cout << res;
	return 0;
}