Jerry's blog

安吉D19 T1

Thu, 20 Aug 2026 00:00:00 GMT

原题呈现

排列数#

题目描述#

排列数的符号为 AjiA_j^iAji，意为从 jjj 个物品中任选 iii 个，并按照任意顺序排成一列的方案数．和组合数不同，排列数与选出物品的顺序有关．

以琪露诺的智商当然学不明白排列数的含义，所以她把公式背了下来：

Aji=j!(j−i)!A_j^i = \frac{j!}{(j-i)!}Aji=(j−i)!j!

幸运的是，期末考试的压轴大题刚好考了排列数．题目是这样的：求有多少对 (i,j)(i, j)(i,j)，满足 1≤i≤j≤n1 \le i \le j \le n1≤i≤j≤n 且 AjiA_j^iAji 为 kkk 的倍数．

可惜只背公式当然是没什么用的，琪露诺完全不会这个题目，你能帮帮她吗？

输入格式#

输入仅一行，包含两个整数 n,kn, kn,k，表示排列数的大小限制与倍数限制．

输出格式#

输出仅一个整数，表示满足 1≤i≤j≤n1 \le i \le j \le n1≤i≤j≤n 且 AjiA_j^iAji 为 kkk 的倍数的有序数对 {i,j}\{i, j\}{i,j} 的数量．

样例#

输入 #1#

1
10 1

输出 #1#

1
55

输入 #2#

1
10 6

输出 #2#

1
43

输入 #3#

1
100 66

输出 #3#

1
4540

样例解释#

样例一中，满足 1≤i≤j≤101 \le i \le j \le 101≤i≤j≤10 的任意 AjiA_j^iAji 都是 111 的倍数，共 (10+12)=55\binom{10+1}{2}=55(210+1)=55 个．
样例二中，符合范围条件但是不是 666 的倍数的排列数有：

A11, A21, A22, A31, A41, A51, A52, A71, A81, A82, A91, A101 A_1^1,\ A_2^1,\ A_2^2,\ A_3^1,\ A_4^1,\ A_5^1,\ A_5^2,\ A_7^1,\ A_8^1,\ A_8^2,\ A_9^1,\ A_{10}^1A11, A21, A22, A31, A41, A51, A52, A71, A81, A82, A91, A101

共 121212 个．因此符合条件的为 55−12=4355 - 12 = 4355−12=43 个．

数据范围#

数据包	分数	n≤n \len≤	k≤k \lek≤	特殊性质
1	30	1010010^{100}10100	101010	无
2	10	300300300	10610^6106	无
3	10	300030003000	10610^6106	无
4	10	10610^6106	222	无
5	10	10610^6106	100100100	无
6	10	10610^6106	10910^9109	A
7	20	10610^6106	10910^9109	无

特殊性质 A：保证 kkk 为质数．

对于所有数据：

1≤n≤1061 \le n \le 10^61≤n≤106
1≤k≤1091 \le k \le 10^91≤k≤109

我们可以将排列数的公式变一下形，为：

Aji=(j−i+1)(j−i+2)⋯jA^i_j=(j-i+1)(j-i+2)\cdots jAji=(j−i+1)(j−i+2)⋯j

那么只需要求所有乘积是 kkk 的倍数的区间数量．显然，若一个区间乘积已经是 kkk 的倍数了，后面不管加多少数，都是 kkk 的倍数．因此，对于所有增加一个数之后恰好可以满足条件的区间，其贡献是这个区间后面数的数量 +1，因为可以增加任意数量（可以为 0）的后面的数．（为什么不加前面的数？加上前面的数的区间会在前面被计算过一次，再增加一次会导致重复）、

具体的，使用双指针来维护．一个指针 iii 指向当前区间的起点，一个指针 jjj 指向当前区间的终点．若当前区间积还不是 kkk 的倍数，那么尝试增加一个数满足限制，让指针 jjj 前进，直到满足要求．此时这个区间的贡献是区间后面还有多少不在区间内的数，再 +1．那么这样以 iii 开头的区间全部统计完成了，让 iii 前进一步．

还有一些问题：如何判断一个区间的区间积是 kkk 的倍数？

如果强行计算进行比较的话 __int128 都存不下，实际上，记录区间中所有数字乘积的分解质因数的结果，再和 kkk 分解之后的结果进行比较即可．

那问题又来了，kkk 的值域限制是 k≤109k \leq 10^9k≤109，这无法对 kkk 进行质因数分解，怎么办呢？实际上，有一个小观察：若 kkk 拥有一个质因数 ppp 满足 p>np>np>n，则答案为 0．这也很好理解，如果 kkk 拥有这样的 ppp，则无论如何，乘积都不可能有大于每个数本身的质因数．对 kkk 花费 k\sqrt{k}k 的时间复杂度预处理一下即可．

分解质因数

实践中常常需要我们对于一个数进行分解质因数操作，这该如何实现呢？

分解质因数，首先需要知道质数．这里重点介绍线性筛质数这一种方法．

对于一个未确定的数，我们进行以下流程：

若这个数未被标记过，则这个数是质数．
接下来，无论这个数是否被标记过，都用它乘上所有已知的质数 ppp，设所得结果为 xxx，则将 xxx 标记．可以证明，ppp 是 xxx 的最小质因数．

以下程序在记录质数的同时，记录了每一个数的最小质因数（spfspfspf）．

1
void calPrime() {
2
    for (int i = 2; i <= N; i++) {
3
        if (spf[i] == 0) {
4
            primes.push_back(i);
5
        }
6
        for (int j = 0; j < primes.size(); j++) {
7
            int pr = primes[j];
8
            if (pr * i > N)
9
                break;
10
            spf[pr * i] = pr;
11
        }
12
    }
13
}

知道了每一个数的最小质因数之后，就可以快速对一个数分解质因数．

具体来说，当想要分解一个数 xxx 时，将其除以其最小质因数 ppp，这样在将 ppp 作为贡献之后，原问题就转化为了规模更小的子问题：分解 xp\frac{x}{p}px，直到 spfx=0spf_x=0spfx=0 时，就是该问题的边界，此时 xxx 也是质数（或 0），加入贡献．

以下程序在上面程序的基础上，计算了 xxx 的质因数：

1
typedef pair<int, int> pii;
2
vector<pii> ans;
3
while (true) {
4
  if (spf[x] == 0) {
5
    if (x != 1)
6
      ans.push_back({x, 1});
7
    break;
8
  }
9
  int pr = spf[x];
10
  pii rd = {pr, 0};
11
  while (true) {
12
    if (x % pr)
13
      break;
14
    rd.second++;
15
    x /= pr;
16
  }
17
  ans.push_back(rd);
18
}
19
return ans;

展开收起

标程

1
#include <bits/stdc++.h>
2
using namespace std;
3
typedef long long ll;
4
typedef pair<int, int> pii;
5
const int N = 1e6 + 100;
6
int n, k;
7
ll ans;
8
vector<int> primes;
9
vector<pii> stdpr;
10
int spf[N];
11
unordered_map<int, int> um;
12

13
void calPrime() {
14
    for (int i = 2; i <= N - 10; i++) {
15
        if (spf[i] == 0) {
16
            primes.push_back(i);
17
        }
18
        for (int j = 0; j < primes.size(); j++) {
19
            int pr = primes[j];
20
            if (pr * i > N - 10)
21
                break;
22
            spf[pr * i] = pr;
23
        }
24
    }
25
}
26

27
vector<pii> calpr(int x) {
28
    vector<pii> ans;
29
    while (true) {
30
        if (spf[x] == 0) {
31
            if (x != 1)
32
                ans.push_back({x, 1});
33
            break;
34
        }
35
        int pr = spf[x];
36
        pii rd = {pr, 0};
37
        while (true) {
38
            if (x % pr)
39
                break;
40
            rd.second++;
41
            x /= pr;
42
        }
43
        ans.push_back(rd);
44
    }
45
    return ans;
46
}
47

48
bool isAllow() {
49
    for (int i = 0; i < stdpr.size(); i++) {
50
        int pr = stdpr[i].first;
51
        if (um[pr] < stdpr[i].second) {
52
            return false;
53
        }
54
    }
55
    return true;
56
}
57

58
void insert(int x) {
59
    vector<pii> vec = calpr(x);
60
    for (int i = 0; i < vec.size(); i++) {
61
        int pr = vec[i].first;
62
        um[pr] += vec[i].second;
63
    }
64
}
65

66
void remove(int x) {
67
    vector<pii> vec = calpr(x);
68
    for (int i = 0; i < vec.size(); i++) {
69
        int pr = vec[i].first;
70
        um[pr] -= vec[i].second;
71
    }
72
}
73

74
signed main() {
75
    ios::sync_with_stdio(false);
76
    cin.tie(0);
77
    cout.tie(0);
78
    freopen("num.in", "r", stdin);
79
    freopen("num.out", "w", stdout);
80
    cin >> n >> k;
81
    calPrime();
82
    if (k == 1) {
83
        cout << 1ll * (1 + n) * n / 2;
84
        return 0;
85
    }
86
    for (int i = 0; i < primes.size(); i++) {
87
        if (k % primes[i] == 0) {
88
            pii t = {primes[i], 0};
89
            while (k % primes[i] == 0) {
90
                k /= primes[i];
91
                t.second++;
92
            }
93
            if (t.second != 0)
94
                stdpr.push_back(t);
95
        }
96
    }
97
    if (k != 1) {
98
        cout << 0;
99
        return 0;
100
    }
101
    int i = 1, j = 1;
102
    while (i <= n) {
103
        if (isAllow()) {
104
            ans += 0ll + n - i + 1;
105
            remove(j);
106
            j++;
107
            if (i < j) {
108
                i++;
109
                insert(i);
110
            }
111
        } else {
112
            i++;
113
            insert(i);
114
        }
115
    }
116
    cout << ans;
117
}

展开收起

安吉D19 T3

Thu, 20 Aug 2026 00:00:00 GMT

原题呈现

P9310 [EGOI 2021] Luna likes Love / 卢娜爱磕 cp#

题目描述#

卢娜想出了一个不同寻常的点子．她让 2n2n2n 个朋友排成一条长队，并给他们每人一个 1∼n1\sim n1∼n 的整数．每个整数恰好出现两次．每一对有相同数字的朋友组成一对情侣．

卢娜希望让每一对情侣去一次约会．然而，并没有这么简单．为了让一对情侣去约会，双方在队伍中必须互相紧挨着，也就是说不能有任何人站在他们中间．

卢娜可以进行两种操作：

她可以让任意两个紧挨着的人交换位置．
如果一对情侣互相紧挨着，卢娜可以让他们去约会．这一对情侣将从队伍中离开，后面的人会补上他们的位置．

所有操作可以以任意的顺序进行．例如，她可以交换几次，然后让几对情侣去约会，再交换几次．

请求出让所有人去约会的最少操作次数．

输入格式#

第一行一个整数 nnn．

第二行 2n2n2n 个整数 aia_iai，依次表示队伍中朋友拿到的数字．

输出格式#

一行，一个整数，表示最少操作次数．

输入输出样例 #1#

输入 #1#

1
3
2
3 1 2 1 2 3

输出 #1#

1
4

输入输出样例 #2#

输入 #2#

1
5
2
5 1 2 3 2 3 1 4 5 4

输出 #2#

1
7

说明/提示#

样例 111 解释

卢娜先让第三个人和第四个人交换位置，得到 3,1,1,2,2,33,1,1,2,2,33,1,1,2,2,3．

然后她可以让数字 111 和 222 的情侣去约会．之后，数字 333 的情侣会互相紧挨着，卢娜可以让他们也去约会．

综上，共需要 444 次操作：一次交换和三次让情侣去约会．

数据范围

对于全部数据，1≤n≤5×1051\le n\le 5\times 10^51≤n≤5×105，1≤ai≤n1\le a_i\le n1≤ai≤n．

子任务一（777 分）：任意一对情侣都紧挨着，n≤100n\le 100n≤100．
子任务二（888 分）：任意一对情侣之间至多有一个人，n≤100n\le 100n≤100．
子任务三（111111 分）：前 nnn 个人的数字构成一个 1∼n1\sim n1∼n 的排列，n≤3×103n\le 3\times 10^3n≤3×103．
子任务四（161616 分）：前 nnn 个人的数字构成一个 1∼n1\sim n1∼n 的排列．
子任务五（222222 分）：n≤3×103n\le 3\times 10^3n≤3×103．
子任务六（363636 分）：无特殊限制．

题意就是给你一个序列，保证每种数都只有两个，你可以交换相邻的两个数，或是使得相邻的两个相同的数被删除．求让整个序列全被删除的最小操作数．

先考虑子任务三和四，若前 nnn 个人是一个 [1,n][1,n][1,n] 的排列，那么很简单，每一次都贪心地选取距离最小的一对，去尝试进行交换．通过观察，我们可以发现，对每一对的消除是不影响其余数字的相对位置的，

安吉D20 模考12总结

Thu, 20 Aug 2026 00:00:00 GMT

得分情况#

预期得分：100+100+30+0

实际得分：100+80+0+0

Time Line#

8<30>~8<50> 看题
8<50>~9<10> 切 T1
9<10>~10<00> 尝试切 T2，失败
10<00>~11<00> 写 T3 暴力
11<00>~11<30> 切 T2
11<30>~12<00> 颓废

挂分原因#

T2 分层图偏移量开小了，大样例也没测出来．
T3 long long 开大了，512 MB 只能开 1e8 个 int，6e7 个 long long，1 秒钟只能进行 1e8 此操作．

安吉D17 T3

Wed, 19 Aug 2026 00:00:00 GMT

原题呈现

P12459 亲密的厨师 / Intimate Chef#

题目描述#

在某家玻利维亚餐厅，有 NNN 位厨师，编号从 111 到 NNN．厨师 iii (1≤i≤N1 \le i \le N1≤i≤N) 可以制作美味度为 AiA_iAi 的锡尔潘乔 (silpancho) 和美味度为 BiB_iBi 的皮克马乔 (pique macho)．

然而，这些厨师都有很强的个性，因此有 MMM 对厨师彼此不和．第 jjj 对 (1≤j≤M1 \le j \le M1≤j≤M) 不和的厨师是厨师 UjU_jUj 和厨师 VjV_jVj．

来到这家餐厅的顾客会按以下方式用餐：

选择满足 1≤p<q≤N1 \le p < q \le N1≤p<q≤N 的整数 p,qp, qp,q，并委托厨师 ppp 和厨师 qqq 这两人制作料理．但是，不能委托不和的两人组制作料理．
锡尔潘乔和皮克马乔这两道菜都由厨师 ppp 和厨师 qqq 中能够做出更高美味度料理的那位厨师制作．如果对于某道菜，两人都能做出相同美味度的料理，则由其中一人制作．注意，一位厨师可以制作两道菜．
顾客的满意度是锡尔潘乔的美味度和皮克马乔的美味度之和．

这家餐厅来了 QQQ 位顾客，编号从 111 到 QQQ．

顾客 kkk (1≤k≤Q1 \le k \le Q1≤k≤Q) 会委托在所有可以委托的两人组中，满意度第 XkX_kXk 高的两人组制作料理．具体来说，如果满意度为 SSS，则选择使得 S×N2+p×N+qS \times N^2 + p \times N + qS×N2+p×N+q 的值是第 XkX_kXk 高的厨师 ppp 和厨师 qqq (1≤p<q≤N1 \le p < q \le N1≤p<q≤N) 两人组来制作料理．

给定餐厅厨师和顾客的信息，请编写一个程序来计算顾客 kkk (1≤k≤Q1 \le k \le Q1≤k≤Q) 的满意度．

输入格式#

输入按照如下格式给出：

N M QA1 A2 … ANB1 B2 … BNU1 V1U2 V2⋮UM VMX1 X2 … XQ\begin{aligned} &N\ M\ Q\\ &A_1\ A_2\ \ldots\ A_N\\ &B_1\ B_2\ \ldots\ B_N\\ &U_1\ V_1\\ &U_2\ V_2\\ &\vdots\\ &U_M\ V_M\\ &X_1\ X_2\ \ldots\ X_Q\\ \end{aligned}N M QA1 A2 … ANB1 B2 … BNU1 V1U2 V2⋮UM VMX1 X2 … XQ

输出格式#

输出 QQQ 行．第 kkk 行 (1≤k≤Q1 \le k \le Q1≤k≤Q) 输出顾客 kkk 的满意度．

输入输出样例 #1#

输入 #1#

输出 #1#

输入输出样例 #2#

输入 #2#

输出 #2#

1
6

输入输出样例 #3#

输入 #3#

输出 #3#

输入输出样例 #4#

输入 #4#

1
13 12 10
2
2 28 28 60 48 77 63 92 13 71 36 91 87
3
85 7 64 15 55 92 66 91 83 35 49 22 61
4
2 9
5
8 13
6
7 11
7
9 11
8
8 12
9
5 12
10
4 7
11
11 12
12
10 12
13
4 11
14
1 5
15
3 8
16
49 21 46 13 20 41 6 33 24 7

展开收起

输出 #4#

说明/提示#

样例 1 解释#

可以委托制作料理的厨师二人组有 4 种，每种组合的顾客满意度如下：

选择厨师 1 和厨师 2 时，锡尔潘乔由厨师 2 制作，皮克马乔由厨师 1 制作．因此，锡尔潘乔的美味度为 7，皮克马乔的美味度为 4．所以，顾客的满意度为 7+4=117 + 4 = 117+4=11．
选择厨师 1 和厨师 4 时，锡尔潘乔由厨师 4 制作，皮克马乔由厨师 4 制作．因此，锡尔潘乔的美味度为 5，皮克马乔的美味度为 8．所以，顾客的满意度为 5+8=135 + 8 = 135+8=13．
选择厨师 2 和厨师 3 时，锡尔潘乔由厨师 2 制作，皮克马乔由厨师 3 制作．因此，锡尔潘乔的美味度为 7，皮克马乔的美味度为 4．所以，顾客的满意度为 7+4=117 + 4 = 117+4=11．
选择厨师 3 和厨师 4 时，锡尔潘乔由厨师 4 制作，皮克马乔由厨师 4 制作．因此，锡尔潘乔的美味度为 5，皮克马乔的美味度为 8．所以，顾客的满意度为 5+8=135 + 8 = 135+8=13．

因此，对于每位顾客，可以得到以下信息：

顾客 1 选择厨师 3 和厨师 4 的二人组．因此，顾客 1 的满意度为 13．
顾客 2 选择厨师 1 和厨师 4 的二人组．因此，顾客 2 的满意度为 13．
顾客 3 选择厨师 2 和厨师 3 的二人组．因此，顾客 3 的满意度为 11．
顾客 4 选择厨师 1 和厨师 2 的二人组．因此，顾客 4 的满意度为 11．

这个输入样例满足子任务 1, 7, 8 的约束．

样例 2 解释#

可以委托制作料理的厨师二人组有 3 种，每种组合的顾客满意度如下：

选择厨师 1 和厨师 3 时，锡尔潘乔由厨师 3 制作，皮克马乔由厨师 1 或厨师 3 制作．因此，锡尔潘乔的美味度为 5，皮克马乔的美味度为 1．所以，顾客的满意度为 5+1=65 + 1 = 65+1=6．
选择厨师 1 和厨师 4 时，锡尔潘乔由厨师 4 制作，皮克马乔由厨师 1 或厨师 4 制作．因此，锡尔潘乔的美味度为 4，皮克马乔的美味度为 1．所以，顾客的满意度为 4+1=54 + 1 = 54+1=5．
选择厨师 3 和厨师 4 时，锡尔潘乔由厨师 3 制作，皮克马乔由厨师 3 或厨师 4 制作．因此，锡尔潘乔的美味度为 5，皮克马乔的美味度为 1．所以，顾客的满意度为 5+1=65 + 1 = 65+1=6．

因此，对于顾客 1，可以得到以下信息：

顾客 1 选择厨师 3 和厨师 4 的二人组．因此，顾客 1 的满意度为 6．

这个输入样例满足子任务 1, 3, 4, 5, 6, 7, 8 的约束．

数据范围#

2≤N≤4×1052 \le N \le 4\times 10^52≤N≤4×105
1≤Ai≤1091 \le A_i \le 10^91≤Ai≤109 (1≤i≤N1 \le i \le N1≤i≤N)
1≤Bi≤1091 \le B_i \le 10^91≤Bi≤109 (1≤i≤N1 \le i \le N1≤i≤N)
0≤M≤4×1050 \le M \le 4\times 10^50≤M≤4×105
M<N(N−1)÷2M < N(N - 1) \div 2M<N(N−1)÷2
1≤Uj<Vj≤N1 \le U_j < V_j \le N1≤Uj<Vj≤N (1≤j≤M1 \le j \le M1≤j≤M)
(Ui,Vi)≠(Uj,Vj)(U_i, V_i) \neq (U_j, V_j)(Ui,Vi)=(Uj,Vj) (1≤i<j≤M1 \le i < j \le M1≤i<j≤M)
1≤Q≤4×1051 \le Q \le 4\times 10^51≤Q≤4×105
1≤Xk≤4×1051 \le X_k \le 4\times 10^51≤Xk≤4×105 (1≤k≤Q1 \le k \le Q1≤k≤Q)
Xk≤N(N−1)÷2−MX_k \le N(N - 1) \div 2 - MXk≤N(N−1)÷2−M (1≤k≤Q1 \le k \le Q1≤k≤Q)
输入的所有值都是整数．

子任务#

(4 分) N≤50N \le 50N≤50, M≤50M \le 50M≤50, Q≤50Q \le 50Q≤50, Xk≤50X_k \le 50Xk≤50 (1≤k≤Q1 \le k \le Q1≤k≤Q).
(9 分) Bi=1B_i = 1Bi=1 (1≤i≤N1 \le i \le N1≤i≤N), M=0M = 0M=0, Q=1Q = 1Q=1.
(10 分) Bi=1B_i = 1Bi=1 (1≤i≤N1 \le i \le N1≤i≤N), Q=1Q = 1Q=1.
(5 分) Bi=1B_i = 1Bi=1 (1≤i≤N1 \le i \le N1≤i≤N).
(29 分) N≤105N \le 10^5N≤105, M≤105M \le 10^5M≤105, Q=1Q = 1Q=1, X1=1X_1 = 1X1=1.
(14 分) N≤105N \le 10^5N≤105, M≤105M \le 10^5M≤105, Q=1Q = 1Q=1, X1≤105X_1 \le 10^5X1≤105.
(18 分) N≤105N \le 10^5N≤105, M≤105M \le 10^5M≤105, Q≤105Q \le 10^5Q≤105, Xk≤105X_k \le 10^5Xk≤105 (1≤k≤Q1 \le k \le Q1≤k≤Q).
(11 分) 没有额外的限制．

小技巧

观察本题排序条件 S×N2+p×N+qS \times N^2 + p \times N + qS×N2+p×N+q，因为系数为 N2N^2N2 和 NNN，所以该问题可以看作以 SSS 为第一关键字，ppp 为第二关键字，qqq 为第三关键字进行排序．

一般的，看到 a×n2+b×n+ca\times n^2 + b\times n + ca×n2+b×n+c 进行排序，可以将其拆分为关键字排序．

我们想来想想，如果没有不和的厨师，问题应该怎么做．

观察此题，由于我们要求第 kkk 大，先来思考 k=1k=1k=1 选择．因此需要将 aaa 数组和 bbb 数组从大到小排序，这样，同时选择 a1a_1a1 和 b1b_1b1 就可以了．那第二大呢？显然，第二大可能是 a1a_1a1 和 b2b_2b2，也可能是 a2a_2a2 和 b1b_1b1．是这两者和的较大值．那第三大呢？不难发现，第三大肯定基于已被扩展过的菜品对，且选择只比其在其中一道菜上后退了一档．

举个例子，若存在三个厨师，其 a,b={1,4},{2,3},{5,5}a,b=\{1,4\},\{2,3\}, \{5,5\}a,b={1,4},{2,3},{5,5}．则首先进行排序：a={5,2,1}a=\{5, 2, 1\}a={5,2,1}，b={5,4,3}b=\{5, 4, 3\}b={5,4,3}．则首先，第一大的肯定是 {a,b}={5,5}\{a,b\}=\{5, 5\}{a,b}={5,5}，这是出自同一个人的两个菜品，在这里暂不处理，后文中会把这种情况删去．之后，第二大可能是 {a,b}={5,4}\{a,b\}=\{5, 4\}{a,b}={5,4} 或 {a,b}={2,5}\{a,b\}=\{2, 5\}{a,b}={2,5}，{5,4}\{5, 4\}{5,4} 对应的厨师对是 {3,1}\{3, 1\}{3,1}，即 5 对应的厨师是 3，4 对应的厨师是 1，厨师对 {1,3}\{1, 3\}{1,3} 能够带来 10 的满意度．而 {2,5}\{2, 5\}{2,5} 对应的厨师对是 {2,3}\{2, 3\}{2,3}，也能够带来 10 的满意度．由于满意度相同时按较小厨师编号从小到大排序，则第二大的厨师对是 {1,3}\{1,3\}{1,3}．此时第三大的菜品对可能是还没用上的 {2,5}\{2, 5\}{2,5}，或者是从 {5,4}\{5, 4\}{5,4} 扩展出来的 {2,4}\{2, 4\}{2,4} 或 {5,3}\{5, 3\}{5,3}．就这样运行下去．

可以使用 bfs 处理．在程序中，以 a1,b1a_1,b_1a1,b1 为原点扩展，加入优先队列（注意区分菜品二元组和厨师二元组），每一次扩展都尝试找出下一个较大的厨师二元组：取出当前优先队列中能使顾客满意度最高的菜品二元组 ai,bia_i, b_iai,bi（这里一个菜品二元组的满意度定义为：两道菜对应的厨师二元组的满意度）．其中，若设 aia_iai 出自厨师 xxx，bib_ibi 出自厨师 yyy，则厨师组合 (x,y)(x,y)(x,y) 就是当前为记录的最大的厨师二元组．将 (x,y)(x,y)(x,y) 记录之后，将可能的下一个菜品二元组加入优先队列，即 ai+1,bia_{i+1},b_iai+1,bi 和 ai,bi+1a_i, b_{i+1}ai,bi+1．注意，在二元组加入优先队列时需要去重，避免重复．

当然除此之外，还有一些菜品二元组需要被避免．设菜品二元组 (i,j)(i,j)(i,j) 对应的厨师二元组 (x,y)(x,y)(x,y)，以下的情况仍旧需要加入优先队列继续用于扩展，但是不能被记录为答案：

x=yx=yx=y，显然自己不能和自己合作．
之前已经记录过 (x,y)(x,y)(x,y) 或 (y,x)(y,x)(y,x)，题目明确说明了 (x,y)(x,y)(x,y) 和 (y,x)(y,x)(y,x) 是相同的．
存在一对不和的厨师 u,vu,vu,v，满足 u=x,v=yu=x,v=yu=x,v=y 或 u=y,v=xu=y,v=xu=y,v=x．

在记录了足够多的厨师二元对之后，停止 bfs，由于 k≤4×105k\leq 4\times 10^5k≤4×105，所以在记录了 kkk 对之后就可以停下来．之后对于每一个询问，查询记录 O(1)O(1)O(1) 回答即可．

你可能会疑问：那一名厨师 iii 的 aaa 和 bbb 都特别高，这种情况在哪里统计呢？这种情况会在优先队列首的菜品二元组中有且仅有一个是厨师 iii 的时候被统计．显然，这样的菜品二元组有多个，若另一道菜出自厨师 jjj，就对应着这名厨师和不同的其他厨师 jjj 合作．

标程

1
#include <bits/stdc++.h>
2
#define int long long
3
using namespace std;
4
typedef pair<int, int> pii;
5
const int N = 4e5 + 100;
6
int n, m, q;
7
int ans[N], cnt;
8
int qs[N];
9
int c[N], d[N];
10

11
struct Hash {
12
    size_t operator()(const pii &p) const {
13
        return p.first * (n + 1) + p.second;
14
    }
15
};
16

17
unordered_set<pii, Hash> vis, err;
18

19
struct Node {
20
    int v, id;
21
    friend bool operator<(const Node a, const Node b) {
22
        if (a.v == b.v)
23
            return a.id > b.id;
24
        return a.v > b.v;
25
    }
26
} a[N], b[N];
27

28
struct Chefs : public pii {
29
    Chefs(int x, int y) : pii(x, y) {}
30

31
    int value() const {
32
        int ida = a[first].id;
33
        int idb = b[second].id;
34
        return max(c[ida], c[idb]) + max(d[ida], d[idb]);
35
    }
36
    friend bool operator<(const Chefs &x, const Chefs &y) {
37
        auto sx = x.value();
38
        auto sy = y.value();
39
        if (sx != sy)
40
            return sx < sy;
41
        if (a[x.first].id != a[y.first].id)
42
            return a[x.first].id < a[y.first].id;
43
        return b[x.second].id < b[y.second].id;
44
    }
45
};
46

47
priority_queue<Chefs> pq;
48

49
void solve(int need) {
50
    pq.push({1, 1});
51
    while (!pq.empty()) {
52
        auto top = pq.top();
53
        pq.pop();
54
        int chefa = a[top.first].id, chefb = b[top.second].id;
55
        if (vis.find(top) != vis.end()) {
56
            continue;
57
        }
58
        vis.insert(top);
59
        if (err.find({chefa, chefb}) == err.end() && chefa != chefb) {
60
            ans[++cnt] = top.value();
61
            if (cnt >= need)
62
                return;
63
        }
64
        err.insert({chefb, chefa});
65
        Chefs nxt = {top.first + 1, top.second};
66
        if (top.first + 1 <= n && vis.find(nxt) == vis.end()) {
67
            pq.push(nxt);
68
        }
69
        nxt = {top.first, top.second + 1};
70
        if (top.second + 1 <= n && vis.find(nxt) == vis.end()) {
71
            pq.push(nxt);
72
        }
73
    }
74
    return;
75
}
76

77
signed main() {
78
    ios::sync_with_stdio(false);
79
    cin.tie(0);
80
    cout.tie(0);
81
    cin >> n >> m >> q;
82
    for (int i = 1; i <= n; i++) {
83
        cin >> a[i].v;
84
        a[i].id = i;
85
        c[i] = a[i].v;
86
    }
87
    for (int i = 1; i <= n; i++) {
88
        cin >> b[i].v;
89
        b[i].id = i;
90
        d[i] = b[i].v;
91
    }
92
    sort(a + 1, a + n + 1);
93
    sort(b + 1, b + n + 1);
94
    for (int i = 1; i <= m; i++) {
95
        int u, v;
96
        cin >> u >> v;
97
        if (u > v)
98
            swap(u, v);
99
        err.insert({u, v});
100
        err.insert({v, u});
101
    }
102
    int need = 0;
103
    for (int i = 1; i <= q; i++) {
104
        cin >> qs[i];
105
        need = max(need, qs[i]);
106
    }
107
    solve(min(need, N - 1));
108
    for (int i = 1; i <= q; i++) {
109
        cout << ans[qs[i]] << endl;
110
    }
111
    return 0;
112
}

展开收起

安吉D17 T4

Wed, 19 Aug 2026 00:00:00 GMT

原题呈现

P7670 毒蛇越狱 / Snake Escaping#

题目描述#

JOI 实验室有 2L2^L2L 条毒蛇．蛇的编号为 0,1,⋯ ,2L−10,1,\cdots,2^L−10,1,⋯,2L−1．每条蛇从头到尾分为 LLL 个部分．每个部分的颜色是蓝色或红色．对于毒蛇 iii，令 i=∑k=1Lck2L−ki = \sum_{k=1}^{L} c_k2^{L-k}i=∑k=1Lck2L−k（0≤ck≤10 \leq c_k \leq 10≤ck≤1）为 iii 的二进制表达式．那么，

如果 ck=0c_k=0ck=0，毒蛇 iii 从头开始的第 kkk 部分的颜色是蓝色，
如果 ck=1c_k=1ck=1，毒蛇 iii 从头开始的第 kkk 部分的颜色是红色．

每条毒蛇都有一个 000 到 999 之间的整数，包括 000 和 999，为毒性．给出一个由 0,1,2,3,4,5,6,7,8,9\texttt{0,1,2,3,4,5,6,7,8,9}0,1,2,3,4,5,6,7,8,9 组成的长度为 2L2^L2L 的字符串 SSS．第 iii 个字符（1≤i≤2L1 \leq i \leq 2^L1≤i≤2L）是毒蛇 i−1i−1i−1 的毒性．由于毒蛇行动迅速，所以经常从 JOI 实验室逃走．住在实验室附近的人向 JOI 实验室投诉，他们看到毒蛇从实验室逃逸．您将收到 QQQ 天的投诉清单．第 ddd 天的投诉（1≤d≤Q1 \leq d \leq Q1≤d≤Q）是一个长度为 LLL 的字符串 TdT_dTd，由 0,1,?\texttt{0,1,?}0,1,? 组成．

如果 TdT_dTd 的第 jjj 个字符（1≤j≤L1 \leq j ≤ L1≤j≤L）为 0\texttt{0}0，这意味着第 ddd 天从实验室逃出的每条毒蛇的第 jjj 个部分是蓝色的，
如果 TdT_dTd 的第 jjj 个字符（1≤j≤L1 \leq j \leq L1≤j≤L）为 1\texttt{1}1，这意味着第 ddd 天从实验室逃出的每条毒蛇的第 jjj 部分是红色的，并且
如果 TdT_dTd 的第 jjj 个字符（1≤j≤L1 \leq j \leq L1≤j≤L）为 ?\texttt{?}?，这意味着人们没有提供关于第 ddd 天从实验室逃逸的毒蛇的第 jjj 部分的信息．

所有的投诉都是准确的信息．所有从实验室逃逸的毒蛇都在同一天被 JOI 实验室的工作人员收留．可能发生同一条蛇在不同的日子逃脱． JOI 实验室执行主任 K 教授为了估计毒蛇逃逸的风险，想知道可能逃出实验室的毒蛇的毒性总和．你的任务是编写一个程序，根据 QQQ 天的投诉列表，计算每天可能从实验室逃逸的蛇的毒性总和．现给定描述毒蛇毒性的字符串 SSS 和 QQQ 天的投诉列表，请编写一个程序来计算每天可能从实验室逃逸的蛇的毒性总和．

输入格式#

第一行包含两个空格分隔的整数 LLL，QQQ，分别是每条毒蛇的部位数和投诉天数．第二行包含长度为 2L2^L2L 的字符串 SSS，描述了毒蛇的毒性．后面 QQQ 行的第 ddd 行包含一个长度为 LLL 的字符串 TdT_dTd，为第 ddd 天的投诉．

输出格式#

共 QQQ 行，第 ddd 行应包含一个整数，即第 ddd 天可能从实验室逃逸的蛇的毒性总和．

输入输出样例 #1#

输入 #1#

输出 #1#

输入输出样例 #2#

输入 #2#

1
4 8
2
3141592653589793
3
0101
4
?01?
5
??1?
6
?0??
7
1?00
8
01?1
9
??10
10
????

输出 #2#

说明/提示#

数据规模与约定#

对于 100%100 \%100% 的数据，1≤L≤201 \leq L \leq 201≤L≤20，1≤Q≤1061 \leq Q \leq 10^61≤Q≤106，SSS 是长度为 2L2^L2L 的字符串，字符串 SSS 由 0,1,2,3,4,5,6,7,8,9\texttt{0,1,2,3,4,5,6,7,8,9}0,1,2,3,4,5,6,7,8,9 组成，TdT_dTd 是长度为 LLL（1≤d≤Q1 \leq d \leq Q1≤d≤Q）的字符串，字符串 TdT_dTd 由 0,1,?\texttt{0,1,?}0,1,?（1≤d≤Q1 \leq d \leq Q1≤d≤Q）组成．

Subtask 111（555 points）：L≤10L \leq 10L≤10，Q≤1000Q \leq 1000Q≤1000．
Subtask 222（777 points）：L≤10L \leq 10L≤10．
Subtask 333（101010 points）：L≤13L \leq 13L≤13．
Subtask 444（535353 points）：Q≤5000Q \leq 5000Q≤5000．
Subtask 555（252525 points）：没有额外的限制．

样例说明#

对于样例 111：L=3L=3L=3，共 23=82^3=823=8 条毒蛇，它们中的每一条都分为 333 个部分．投诉时间为 555 天．

第一天，可能逃出实验室的毒蛇只有毒蛇 000．毒性总和为 111．
第二天，可能从实验室逃逸的毒蛇是毒蛇 0,1,2,30,1,2,30,1,2,3．毒性总和为 101010．
第三天，可能从实验室逃逸的毒蛇是毒蛇 4,64,64,6．毒性总和为 121212．
第四天，可能从实验室逃逸的毒蛇是毒蛇 3,73,73,7．毒性总和是 121212．
第五天，可能从实验室逃逸的毒蛇是毒蛇 0,1,2,3,4,5,6,70,1,2,3,4,5,6,70,1,2,3,4,5,6,7．毒性总和为 363636．

此题题意就是给定一个模式串，求二进制表示匹配这个模式串的所有数权值之和．

最容易想到的就是枚举所有问号部分应该填什么，然后将所有可能的数字权值加起来．下面的程序实现了这个暴力．其中，

A 的二进制上每一位是 1，当且仅当模式串上这一位是 0．
B 的二进制上每一位是 1，当且仅当模式串上这一位是 1．
C 的二进制上每一位是 1，当且仅当模式串上这一位是 ?．

1
// 枚举 T，T 表示我们钦定这些部分应该填 1
2
for (int T = C; T > 0; T = (T - 1) & C) {
3
  int U = B | T;
4
  ans += w[U];
5
}
6
ans += w[B];

程序的复杂度高达 O(q2L)O(q2^L)O(q2L)，需要优化．

在复杂度中，LLL 在指数位上，只需要让 L≤8L\leq 8L≤8 就可以了．因此，对于问号数量小于等于 8 的模式串，可以使用上面的暴力．那对于问号数量大于 8 的呢？问号数量既然大于 8，由于 L≤20L\leq 20L≤20，那么必然会有 1 的数量小于 8，或者 0 的数量小于 8．对于这两种情况分别考虑．

对于 0 的数量小于 8 的情况，我们可以尝试使用容斥．具体来说，对于每一个为 0 的位置，设其组成一个集合，即为上述的 AAA，则满足条件的情况为：模式串中每一个规定为 0 的位置都全部遵守的权值，减去钦定有一个位置不遵守的权值，加上有钦定两个位置不遵守的权值……公式化的，设钦定模式串中为 0 的位置必须为 1 的位置集合是 TTT，则有：

ans=∑T⊆A((−1)∣T∣g(B∪T))ans=\sum_{T\subseteq A}((-1)^{|T|}g(B\cup T))ans=T⊆A∑((−1)∣T∣g(B∪T))

其中，BBB 的含义为上文所述，故 B∪TB\cup TB∪T 的含义为当前钦定限制下，所有必须为 1 的位置集合，g(x)g(x)g(x) 表示超集和，即所有满足以下条件的数字 yyy 的权值和：

若设 aaa 的从右到左第 iii 个二进制位为 aia_iai，则当 xi=1x_i=1xi=1 时，yi=1y_i=1yi=1．即 xxx 中为 1 的位 yyy 中也必须为 1．

公式化的，其统计的是 ∑T⊇xw(T)\sum_{T\supseteq x}w(T)∑T⊇xw(T)．

g(x)g(x)g(x) 可以通过高维后缀和预处理出来，在后文会详细说明．

1
// 枚举 T，T 表示我们钦定这些部分应该填 1，即使模式串中为 0
2
for (int T = A; T > 0; T = (T - 1) & A) {
3
  int U = B | T;
4
  if (__builtin_popcount(T) & 1) {
5
    ans -= g[U];
6
  } else {
7
    ans += g[U];
8
  }
9
}
10
ans += g[B];

对于 1 的数量小于 8 的情况，我们可以仍可以像处理 0 一样使用容斥．具体来说，对于每一个为 1 的位置，设其组成一个集合，即为上述的 BBB，则满足条件的情况为：模式串中每一个规定为 1 的位置都全部遵守的权值，减去钦定有一个位置不遵守的权值，加上有钦定两个位置不遵守的权值……公式化的，设钦定模式串中为 1 的位置必须为 0 的位置集合是 TTT，则有：

ans=∑T⊆B[(−1)∣T∣f((A∪T)c)]ans=\sum_{T\subseteq B}[(-1)^{|T|}f((A\cup T)^c)]ans=T⊆B∑[(−1)∣T∣f((A∪T)c)]

其中，A∪TA\cup TA∪T 的含义为当前钦定限制下，所有必须为 0 的位置集合，因此 (A∪T)c(A\cup T)^c(A∪T)c 就是 A∪TA\cup TA∪T 的补集，其代表所有可以为 1 的位置集合，f(x)f(x)f(x) 表示子集和，即所有满足以下条件的数字 yyy 的权值和：

若设 aaa 的从右到左第 iii 个二进制位为 aia_iai，则当 xi=0x_i=0xi=0 时，yi=0y_i=0yi=0．即 xxx 中为 0 的位 yyy 中也必须为 0．

公式化的，其统计的是 ∑T⊆xw(T)\sum_{T\subseteq x}w(T)∑T⊆xw(T)．

f(x)f(x)f(x) 可以通过高维前缀和预处理出来，在后文会详细说明．

1
int U = (1 << n) - 1;
2
// 枚举 T，T 表示我们钦定这些部分应该填 0，即使模式串中为 1
3
for (int T = B; T; T = (T - 1) & B) {
4
  int NA = A | T;
5
  int Com = U ^ NA;
6
  if (__builtin_popcount(T) & 1) {
7
    ans -= f[Com];
8
  } else {
9
    ans += f[Com];
10
  }
11
}
12
int Com = U ^ A;
13
ans += f[Com];

最后，对于 f(x)f(x)f(x) 和 g(x)g(x)g(x) 的预处理，可以使用高维前后缀和．

我们知道，对于一维的前缀和，其转移方程是这样的：

1
for(int i = 1; i <= n; i++)
2
  a[i] += a[i-1];

而对于二维，可以使用容斥，也可以一维一维地求：

1
for(int i = 1; i <= n; i++)
2
    for(int j = 1; j <= n; j++)
3
        a[i][j] += a[i - 1][j];
4
for(int i = 1; i <= n; i++)
5
  for(int j = 1; j <= n; j++)
6
    a[i][j] += a[i][j - 1];

对于高维前缀和，可以将其视作多维前缀和，这里 n=20n=20n=20，就是 20 维空间，每一维的大小是 2，即只有 0 和 1 两种状态．我们对于每一个维度，都尝试将 0 的统计值加到 1 的头上．高维后缀和正好相反，它尝试将 1 的统计值加到 0 的头上．

可以使用下面的代码，时间复杂度 O(n2n)O(n2^n)O(n2n)．

1
for (int i = 0; i < n; i++) { // 枚举维度
2
  for (int T = 0; T < (1 << n); T++) { // 枚举所有的状态
3
    if (T >> i & 1) { // 如果第 i 位是 0
4
      // 就把状态加到同维 1 的头上
5
      f[T] += f[T ^ (1 << i)];
6
    } else { // 如果第 i 位是 1
7
      // 就把状态加到同维 0 的头上
8
      g[T] += g[T ^ (1 << i)];
9
    }
10
  }
11
}

整体的复杂度为 O(n2n+q2L3)O(n2^n+\sqrt[3]{q2^L})O(n2n+3q2L)，这种分类讨论是一种分治技巧，常称之为根号分治．

标程

1
#define IO(x) freopen(x ".in", "r", stdin), freopen(x ".out", "w", stdout)
2
#include <bits/stdc++.h>
3
using namespace std;
4
const int N = 2e6 + 100;
5
int n, q, w[N], f[N], g[N];
6
int A, B, C, ans;
7

8
void solve_A() {
9
    // 0 居少
10
    // 枚举必须为 0 中为 1 的位置
11
    for (int T = A; T > 0; T = (T - 1) & A) {
12
        int U = B | T;
13
        if (__builtin_popcount(T) & 1) {
14
            ans -= g[U];
15
        } else {
16
            ans += g[U];
17
        }
18
    }
19
    ans += g[B];
20
}
21

22
void solve_B() {
23
    // 1 较少
24
    // 枚举必须为 0 的位置
25
    int U = (1 << n) - 1;
26
    for (int T = B; T; T = (T - 1) & B) {
27
        int NA = A | T;
28
        int Com = U ^ NA;
29
        if (__builtin_popcount(T) & 1) {
30
            ans -= f[Com];
31
        } else {
32
            ans += f[Com];
33
        }
34
    }
35
    int Com = U ^ A;
36
    ans += f[Com];
37
}
38

39
void solve_C() {
40
    // 问号居少，暴力
41
    for (int T = C; T > 0; T = (T - 1) & C) {
42
        int U = B | T;
43
        ans += w[U];
44
    }
45
    ans += w[B];
46
}
47

48
signed main() {
49
    ios::sync_with_stdio(false);
50
    cin.tie(0);
51
    cout.tie(0);
52
    cin >> n >> q;
53
    string str;
54
    cin >> str;
55
    for (int i = 0; i < (1 << n); i++) {
56
        w[i] = str[i] - '0';
57
        f[i] = g[i] = w[i];
58
    }
59
    for (int i = 0; i < n; i++) {
60
        for (int T = 0; T < (1 << n); T++) {
61
            if (T >> i & 1) {
62
                f[T] += f[T ^ (1 << i)];
63
            } else {
64
                g[T] += g[T ^ (1 << i)];
65
            }
66
        }
67
    }
68
    while (q--) {
69
        string str;
70
        cin >> str;
71
        A = 0, B = 0, C = 0, ans = 0;
72
        for (int i = 0; i < str.size(); i++) {
73
            char ch = str[n - i - 1];
74
            if (ch == '0') {
75
                A |= (1 << i);
76
            } else if (ch == '1') {
77
                B |= (1 << i);
78
            } else {
79
                C |= (1 << i);
80
            }
81
        }
82
        if (__builtin_popcount(A) <= n / 3) {
83
            solve_A();
84
        } else if (__builtin_popcount(B) <= n / 3) {
85
            solve_B();
86
        } else {
87
            solve_C();
88
        }
89
        cout << ans << endl;
90
    }
91
    return 0;
92
}

展开收起

安吉D19 模考11总结

Wed, 19 Aug 2026 00:00:00 GMT

得分情况#

预期得分：80+30+15+10

实际得分：80+30+7+10

Time Line#

8<30>~8<50> 看题
8<50>~9<50> 写 T1
9<50>~11<00> 写 T2
11<00>~11<30> 写 T3
11<30>~12<00> 写 T4

挂分原因#

T3 性质写挂

安吉D15 A

Mon, 17 Aug 2026 00:00:00 GMT

原题呈现

P9753 消消乐#

题目描述#

小 L 现在在玩一个低配版本的消消乐，该版本的游戏是一维的，一次也只能消除两个相邻的元素．

现在，他有一个长度为 nnn 且仅由小写字母构成的字符串．我们称一个字符串是可消除的，当且仅当可以对这个字符串进行若干次操作，使之成为一个空字符串．

其中每次操作可以从字符串中删除两个相邻的相同字符，操作后剩余字符串会拼接在一起．

小 L 想知道，这个字符串的所有非空连续子串中，有多少个是可消除的．

输入格式#

输入的第一行包含一个正整数 nnn，表示字符串的长度．

输入的第二行包含一个长度为 nnn 且仅由小写字母构成的字符串，表示题目中询问的字符串．

输出格式#

输出一行包含一个整数，表示题目询问的答案．

输入输出样例 #1#

输入 #1#

1
8
2
accabccb

输出 #1#

1
5

说明/提示#

【样例 1 解释】

一共有 555 个可消除的连续子串，分别是 cc、acca、cc、bccb、accabccb．

【数据范围】

对于所有测试数据有：1≤n≤2×1061 \le n \le 2 \times 10^61≤n≤2×106，且询问的字符串仅由小写字母构成．

测试点	n≤n\leqn≤	特殊性质
1∼51\sim 51∼5	101010	无
6∼76\sim 76∼7	800800800	无
8∼108\sim 108∼10	800080008000	无
11∼1211\sim 1211∼12	2×1052\times 10^52×105	A
13∼1413\sim 1413∼14	2×1052\times 10^52×105	B
15∼1715\sim 1715∼17	2×1052\times 10^52×105	无
18∼2018\sim 2018∼20	2×1062\times 10^62×106	无

特殊性质 A：字符串中的每个字符独立等概率地从字符集中选择．

特殊性质 B：字符串仅由 a 和 b 构成．

此题和括号树惊人的相似．

采用和括号树类似的 dp 状态定义：dp[i] 表示以第 iii 个字符结尾能够构成的合法子串数量．

考虑一下如何转移．

首先，不难发现，若 stri=stri−1str_{i} = str_{i-1}stri=stri−1，即相邻两个位置拥有同样的字符，dpidp_idpi 就可以由 dpi−2dp_{i-2}dpi−2 转移而来，即以第 i−2i-2i−2 个字符结尾的每一个字符串都可以加上 i−1,ii-1,ii−1,i，从而形成一个新的合法串，而 [i−1,i][i-1,i][i−1,i] 自身又是一个合法串．转移式为：dpi=dpi−2+1dp_i = dp_{i-2} + 1dpi=dpi−2+1．

但是 stri≠stri−1str_i\neq str_{i-1}stri=stri−1 怎么办呢？想一想，如果两个不相等的字符拼在了一起，并且前一个和 stristr_istri 相同的字符是 strjstr_jstrj．那么唯一可以让 stristr_istri 被消除的方法就是让 [j+1,i−1][j+1, i-1][j+1,i−1] 之间的所有字符都被消除。不妨定义 preipre_iprei 表示满足以下条件的下标：

stri=strpreistr_i=str_{pre_i}stri=strprei
[prei+1,i−1][pre_i+1, i-1][prei+1,i−1] 可被消除。

则 dpidp_idpi 可以尝试从 dppreidp_{pre_i}dpprei 转移

安吉D16 T4

Mon, 17 Aug 2026 00:00:00 GMT

原题呈现

01 的冒泡排序#

题目描述#

01 学习了冒泡排序，觉得太简单，于是创造了属于自己的排序方式．

给定一个长度为 nnn 的排列 aaa 以及一个神秘数字 kkk，01 会执行以下操作：

初始令 cnt=0cnt = 0cnt=0．
如果当前数组已经排好序（即非降序），则停止操作．
否则，按 iii 从 111 到 n−k+1n - k + 1n−k+1 遍历：
- 若子区间 ai,ai+1,…,ai+k−1a_i, a_{i+1}, \ldots, a_{i+k-1}ai,ai+1,…,ai+k−1 并非升序，则将该区间从小到大排序，同时令 cnt=cnt+1cnt = cnt + 1cnt=cnt+1．
一轮结束，回到第二步．（这一步时题解作者增加的，或许加上会更严谨一些？）

你需要求出操作结束时 cntcntcnt 的值．

输入格式#

第一行输入两个整数 n,kn, kn,k，表示数组长度和神秘数字．第二行输入 nnn 个整数 a1,a2,…,ana_1, a_2, \ldots, a_na1,a2,…,an，表示给定的排列．

输出格式#

输出一行一个整数，表示最终的 cntcntcnt 值．

样例#

输入样例 1#

输出样例 1#

1
5

数据范围#

对于 20%20\%20% 的数据，保证 n≤2000n \le 2000n≤2000．
对于另 10%10\%10% 的数据，保证 k=2k = 2k=2．
对于另 20%20\%20% 的数据，保证 ∀1≤i≤k, ai=i\forall 1 \le i \le k,\ a_i = i∀1≤i≤k, ai=i．
对于 100%100\%100% 的数据：
- 1≤n≤2×1051 \le n \le 2 \times 10^51≤n≤2×105
- 2≤k≤n2 \le k \le n2≤k≤n

我们回忆冒泡排序的过程，实际上，冒泡排序每一次可以让未排序的最大的一个数归位，那么变种有没有这种性质呢？

我们尝试模拟这个流程，首先，对区间 [1,k][1,k][1,k] 排序，然后，丢下了最小的一个数，区间右移到 [2,k+1][2, k+1][2,k+1]．显然，此时区间内，[2,k][2,k][2,k] 里面存放的是 [1,k][1,k][1,k] 中前 k−1k-1k−1 大的 k−1k-1k−1 个数．将其扩展到 iii，当遍历到区间 [i,i+k−1][i, i+k-1][i,i+k−1] 时，其中的 [i,i+k−2][i,i+k-2][i,i+k−2] 是 [1,i+k−2][1, i+k-2][1,i+k−2] 中最大的 k−1k-1k−1 个数．

我们来转向结束条件．题目中的结束条件是：

如果当前数组已经排好序（即非降序），则停止操作．

显然，我们不能对于每一个数，都将它和前一个数比较，这样不好维护．我们知道，一个数组是有序的当且仅当每个数前面都没有比它大的数，因此，我们定义 bib_ibi 表示位置 iii 之前比 aia_iai 大的数．这样，结束条件就从“有序”转化为了 ∀i,bi=0\forall i,b_i=0∀i,bi=0．bib_ibi 可以使用树状数组快速算出．

那要如何才能使得 bib_ibi 减小呢？我们在每一次区间右移时，区间左边的 k−1k-1k−1 个数都是有序的，只有最后一个数是无序的．因此，这就相当于将最后一个数插入到前面这个序列中．此时 bib_ibi 变化如下：

若 bi>k−1b_i > k-1bi>k−1，由于当前区间只有 kkk 个数，且前 k−1k-1k−1 个数是当前已遍历到的最大的 k−1k-1k−1 个数．又因为比 iii 大的至少也有 kkk 个．因此，这表示 iii 是当前区间内最小的数，将 iii 的位置前移 k−1k-1k−1，即 bi→bi−k+1b_i\to b_i-k+1bi→bi−k+1．
若 bi≤k−1b_i \leq k-1bi≤k−1，由于比 bib_ibi 小的数最多也只有 k−1k-1k−1 个，那么这 bib_ibi 个全在当前区间里了．这说明将当前区间进行一次排序就足以把所有比 aia_iai 大的数移动到 aia_iai 后面了，此时，aia_iai 前面已经没有比 aia_iai 小的数了，故 bi→0b_i\to 0bi→0．

综上所述，iii 需要移动 ⌈bik−1⌉\lceil\frac{b_i}{k-1}\rceil⌈k−1bi⌉ 次才能移动到目标位置．当然，所有最后一次移动到区间 [1,k][1,k][1,k] 的数可以一次性全部排序使其回到正确的位置．故若设 t1=⌈bik−1⌉t_1=\lceil\frac{b_i}{k-1}\rceilt1=⌈k−1bi⌉，t2t_2t2 表示当前点每一次移动 k−1k-1k−1 移动到区间 [1,k][1,k][1,k] 需要移动的次数：

若 t1≤t2t_1 \leq t_2t1≤t2，则表示 iii 根本不会移动到 [1,k][1,k][1,k]，或是移动到时 bib_ibi 已经为 0，不需要集体排序．
若 t1>t2t_1>t_2t1>t2，则表示 iii 在进行了 t2t_2t2 次移动后，移动到了 [1,k][1,k][1,k]，由于每一轮每一个数字最多只能移动 k−1k-1k−1 步一次，故此时已经过去 t2t_2t2 轮．会在第 t2+1t_2+1t2+1 轮预定一次 [1,k][1,k][1,k] 的集体排序．

特别的，一开始就在 [1,k][1,k][1,k] 的数若 bi≠0b_i\neq 0bi=0，则会在第一轮 [1,k][1, k][1,k] 的集体排序中恢复有序．

对于每一项计算移动次数加和即可．

标程

1
#include <bits/stdc++.h>
2
#define int long long
3
using namespace std;
4
const int N = 2e5 + 100;
5
int n, k;
6
int a[N]；
7
bool sfa[N];
8
// sfa => Sort in the First Action in i th round，是否需要在第 i 轮在区间 [1,k] 进行排序
9

10
struct BIT {
11
    int f[N];
12
    void Modify(int pos, int v) {
13
        for (int i = pos; i <= n; i += (i & (-i))) {
14
            f[i] += v;
15
        }
16
    }
17
    int query(int pos) {
18
        if (pos == 0)
19
            return 0;
20
        int ans = 0;
21
        for (int i = pos; i >= 1; i -= (i & (-i))) {
22
            ans += f[i];
23
        }
24
        return ans;
25
    }
26
    int query(int l, int r) { return query(r) - query(l - 1); }
27
} bit;
28

29
signed main() {
30
    ios::sync_with_stdio(false);
31
    cin.tie(0);
32
    cout.tie(0);
33
    cin >> n >> k;
34
    for (int i = 1; i <= n; i++) {
35
        cin >> a[i];
36
    }
37
    long long cnt = 0;
38
    for (int i = 1; i <= k; i++) {
39
        int b = bit.query(a[i], n);
40
        if (b != 0) {
41
            sfa[1] = true;
42
        }
43
        bit.Modify(a[i], 1);
44
    }
45
    for (int i = k + 1; i <= n; i++) {
46
        int b = bit.query(a[i], n);
47
        bit.Modify(a[i], 1);
48
        int t1 = ceil(1.0 * b / (k - 1.0));
49
        int t2 = ceil((i - k + 0.0) / (k - 1.0));
50
        if (t1 <= t2) {
51
            cnt += t1;
52
        } else {
53
            cnt += t2;
54
            sfa[t2 + 1] = true;
55
        }
56
    }
57
    for (int i = 1; i <= n; i++)
58
        cnt += sfa[i];
59
    cout << cnt;
60
    return 0;
61
}

展开收起

安吉D17 模考10总结

Mon, 17 Aug 2026 00:00:00 GMT

得分情况#

预期得分：100+100+25+0

实际得分：100+100+15+0

Time Line#

8<30>~8<50> 看题
8<50>~9<40> 想 T1
9<40>~10<50> 切 T2
10<50>~11<30> 写 T3 部分分
11<30>~12<00> 切 T1

挂分原因#

T3 暴力没开long long

安吉D17 T1

Mon, 17 Aug 2026 00:00:00 GMT

原题呈现

P3917 异或序列#

题目描述#

给出序列 A1,A2,⋯ ,ANA_1,A_2,\cdots,A_NA1,A2,⋯,AN，求

∑1≤i≤j≤NAi⊕Ai+1⊕⋯⊕Aj\sum_{1\le i\le j\le N} A_i\oplus A_{i+1}\oplus\cdots\oplus A_j1≤i≤j≤N∑Ai⊕Ai+1⊕⋯⊕Aj

的值．其中，⨁\bigoplus⨁ 表示按位异或．

输入格式#

第一行，一个整数 NNN．

第二行，NNN 个整数 A1,A2,⋯ ,ANA_1,A_2,\cdots,A_NA1,A2,⋯,AN．

输出格式#

一个数，为表达式的值．

输入输出样例 #1#

输入 #1#

输出 #1#

1
6

说明/提示#

对于 60%60\%60% 的数据，1≤N≤1031 \le N \le 10^31≤N≤103；
对于 100%100\%100% 的数据，1≤N≤1051 \le N \le 10^51≤N≤105，0≤Ai≤1090 \le A_i \le 10^90≤Ai≤109．

我们知道，按位异或具有位独立性，即位与位之间的运算是独立的，因此可以按位计算贡献．

对于子串贡献题，最常见的是使用 dp，定义 dp[i] 表示以第 iii 个数结尾能够做出的贡献．由于异或具有位独立性，因此，对状态稍作修改，定义状态 dp[i][j] 表示只考虑每一个数的第 jjj 位，以第 iii 个数为结尾的子串中异或和为 1 的数量．即若设 si,js_{i,j}si,j 表示 sis_isi 的第 jjj 位，则 dpi,jdp_{i,j}dpi,j 为 ∀k≤i\forall k \leq i∀k≤i，满足 sk,j⊕sk+1,j⊕sk+2,j⋯⊕si,j=1s_{k,j}\oplus s_{k+1, j}\oplus s_{k+2, j}\cdots \oplus s_{i,j}=1sk,j⊕sk+1,j⊕sk+2,j⋯⊕si,j=1 的 kkk 的数量．

这样就可以开始 dp 了，对于每一位 jjj，初始状态为 dp1,j=s1,jdp_{1, j}=s_{1,j}dp1,j=s1,j，接着，遍历每一个数，设遍历到第 iii 个数，则：

若 si,j=0s_{i, j}=0si,j=0，
- 对于以 iii 结尾且长度为 1 序列，其异或和为 0，故对答案没有贡献．
- 对于以 iii 结尾且长度为 k,k>1k,k>1k,k>1 的序列，其异或和为不会发生改变，因此原来以 i−1i-1i−1 结尾，长度为 k−1k-1k−1 的序列异或了 0 之后值仍不变．因此，这种情况对答案的贡献就是以 i−1i-1i−1 结尾的序列中异或和为 1 的序列数量．
- 因此存在转移方程：dpi,j=dpi−1,jdp_{i, j}=dp_{i-1, j}dpi,j=dpi−1,j．
若 si,j=1s_{i,j}=1si,j=1，
- 对于以 iii 结尾且长度为 1 序列，其异或和为 1，对答案贡献为 1．
- 对于以 iii 结尾且长度为 k,k>1k,k>1k,k>1 的序列，其异或和会改变，因此原来以 i−1i-1i−1 结尾，长度为 k−1k-1k−1 的序列异或了 1 之后原来是 1 的会变成 0，原来是 0 的会变成 1．因此，这种情况对答案的贡献就是以 i−1i-1i−1 结尾的序列中异或和为 0 的序列数量．使用总序列数量 i−1i-1i−1，减去为 1 的序列数量 dpi−1,jdp_{i-1,j}dpi−1,j 即可．
- 因此存在转移方程：dpi,j=i−1−dpi−1,j+1=i−dpi−1,jdp_{i,j}=i-1-dp_{i-1,j}+1=i-dp_{i-1,j}dpi,j=i−1−dpi−1,j+1=i−dpi−1,j．

对于答案，我们需要统计以每一个数结尾的子串每一位的贡献，即：

∑i=1n∑j=031dpi,j×2j\sum_{i=1}^n\sum_{j=0}^{31} dp_{i,j}\times2^ji=1∑nj=0∑31dpi,j×2j

可以写出标程．由于 dpi,jdp_{i,j}dpi,j 只与 dpi−1,jdp_{i-1,j}dpi−1,j 有关，故可以把 dpdpdp 数组变成一个变量 ans 以达到节省空间的效果，以下标程实现了这个效果．

标程

1
#include <bits/stdc++.h>
2
using namespace std;
3
#define int long long
4
const int N = 2e6 + 100;
5
int a[N], ans;
6

7
signed main() {
8
    ios::sync_with_stdio(false);
9
    cin.tie(0);
10
    cout.tie(0);
11
    int n;
12
    cin >> n;
13
    for (int i = 1; i <= n; i++) {
14
        cin >> a[i];
15
    }
16
    for (int i = 0; i < 32; i++) {
17
        int now = (a[1] >> i) & 1;
18
        ans += now * (1 << i);
19
        for (int j = 2; j <= n; j++) {
20
            if (a[j] & (1 << i)) {
21
                now = j - 1 - now + 1;
22
            }
23
            ans += now * (1 << i);
24
        }
25
    }
26
    cout << ans;
27
    return 0;
28
}

展开收起

安吉D16 模考9总结

Sun, 16 Aug 2026 00:00:00 GMT

得分情况#

预期得分：100+100+0+0

实际得分：100+20+0+0

Time Line#

8<30>~8<50> 看题
8<50>~9<30> 切 T1
9<30>~10<40> 做 T2
10<40>~12<00> 做 T4

挂分原因#

T2 正解已想出，但由于时间复杂度算错导致误判为仅有 10 分的部分分，导致没调出来．

收获#

复习了冒泡排序

安吉D16 T3

Sun, 16 Aug 2026 00:00:00 GMT

原题呈现

P3813 矩阵填数#

题目描述#

给定一个 h×wh \times wh×w 的矩阵，矩阵的行编号从上到下依次为 1∼h1 \sim h1∼h，列编号从左到右依次 1∼w1 \sim w1∼w．

在这个矩阵中你需要在每个格子中填入 1∼m1 \sim m1∼m 中的某个数．

给这个矩阵填数的时候有一些限制，给定 nnn 个该矩阵的子矩阵，以及该子矩阵的最大值 vvv，要求你所填的方案满足该子矩阵的最大值为 vvv．

现在，你的任务是求出有多少种填数的方案满足 nnn 个限制．

两种方案是不一样的当且仅当两个方案至少存在一个格子上有不同的数．由于答案可能很大，你只需要输出答案对 109+710 ^ 9 + 7109+7 取模后的结果．

输入格式#

输入数据的第一行为一个数 TTT，表示数据组数．

对于每组数据，第一行为四个数 h,w,m,nh,w,m,nh,w,m,n．

接下来 nnn 行，每一行描述一个子矩阵的最大值 v．每行为五个整数 x1,y1,x2,y2,vx1,y1,x2,y2,vx1,y1,x2,y2,v，表示一个左上角为 (x1,y1)(x1,y1)(x1,y1),右下角为 (x2,y2)(x2,y2)(x2,y2) 的子矩阵的最大值为 vvv． 1≤x1≤x2≤h1 \le x1 \le x2 \le h1≤x1≤x2≤h, 1≤y1≤y2≤w1 \le y1 \le y2 \le w1≤y1≤y2≤w

输出格式#

对于每组数据输出一行，表示填数方案 mod 1,000,000,0071,000,000,0071,000,000,007 后的值．

输入输出样例 #1#

输入 #1#

输出 #1#

说明/提示#

对于 20%20\%20% 的数据，n≤2n \le 2n≤2．

另有 20%20\%20% 的数据，1≤h,w≤501 \le h, w \le 501≤h,w≤50．

对于 100%100\%100% 的数据，T≤5T \le 5T≤5，1≤h,w,m≤1041 \le h, w, m \le 10 ^ 41≤h,w,m≤104，1≤n≤101 \le n \le 101≤n≤10，1≤v≤m1 \le v \le m1≤v≤m．

先考虑 n=0n=0n=0 的情况．

此时，所有填数都没有限制，则显然，答案为 (hw)m(hw)^m(hw)m．

n=1n=1n=1 时呢？

此时只有一个限制矩形，设这个矩形面积为 SSS，则可行的方案数为：矩形外随便填，存在 (hw−S)m(hw-S)^m(hw−S)m 种填法．矩形内则是限制每一个元素都要小于等于 v1v_1v1，且必须要有 viv_ivi 存在．那么矩形内合法的方案数为每一个元素都小于等于 v1v_1v1 的方案数，减去没有元素是 v1v_1v1 的方案数（即所有元素都小于等于 v1−1v_1-1v1−1 的方案数）．矩形外和矩形内互不干涉，故将两者方案数答案相乘即为答案．

n=2n=2n=2 时呢？

矩形外仍是随便填，矩形内呢？显然，只被矩形 1 包括的点需要小于等于 v1v_1v1，只被矩形 2 包括的点需要小于等于 v2v_2v2，同时被两者包括的点需要小于等于 min⁡{v1,v2}\min\{v1,v2\}min{v1,v2}．除此之外，还需要满足矩形 1 内存在 v1v_1v1，矩形 2 内存在 v2v_2v2．这需要怎么处理呢？

定义满足上述不等条件的方案数为 SSS．即满足：

只被矩形 1 包括的点需要小于等于 v1v_1v1，只被矩形 2 包括的点需要小于等于 v2v_2v2，同时被两者包括的点需要小于等于 min⁡{v1,v2}\min\{v1,v2\}min{v1,v2}．

关系的方案存在 A∅A_{\varnothing}A∅ 种．而不满足矩形 1 的相等关系（即矩形 1 内存在值等于 v1v_1v1）的有 A{1}A_{\{1\}}A{1} 种（此时矩形 2 的相等关系可以满足，也可以不满足），不满足矩形 2 相等关系的有 A{2}A_{\{2\}}A{2} 种．同时不满足两个矩形的相等关系的有 A{1,2}A_{\{1,2\}}A{1,2} 种．则根据容斥的相关知识，存在答案 tottottot 的表达式：

tot=A∅−A{1}−A{2}+A{1,2}tot = A_{\varnothing} -A_{\{1\}}-A_{\{2\}}+A_{\{1,2\}}tot=A∅−A{1}−A{2}+A{1,2}

将其扩展到 n=10n=10n=10，则若 ASA_SAS 中，SSS 的大小为偶数，则符号为正，SSS 的大小为奇数，则符号位负，就可以使用 2n2^n2n 项将答案计算出来．

计算一下时间复杂度：

O(2n)O(2^n)O(2n) 用于遍历所有可能的 ASA_SAS 中的 SSS
O(hw)O(hw)O(hw) 用于遍历图
O(n)O(n)O(n) 用于在确定 ASA_SAS 的 SSS 后计算答案

时间复杂度 O(n2nhw)O(n2^nhw)O(n2nhw)，需要优化．

观察到此题 nnn 很小，而 h,wh,wh,w 很大，当值域很大，但值的个数很小时，可以考虑离散化．

具体来说，依照限制矩形的左右端点和上下端点可以将整个网格划分成一个一个的小矩形，同时满足每一个矩形内部的所有点共享一个限制．

![[grid_paper.png]]

如上图的示意图，上图中，有两个限制矩形（标为红色），依照这些矩形的边框，绿色实线将网格图分成了 9 块，每一块中的取值限制都是相同的．

具体来说，子集枚举所有可能的集合，对于每一个集合 sss，尝试计算出 AsA_sAs，计算时，对于每一块，我们可以通过上面的研究计算出这一块的取值上限，然后使用快速幂计算取值上限的面积次方，加和即为 AsA_sAs，再通过容斥公式计算出最后的答案．

小技巧：离散化

离散化常用来解决值域很大，但值数很小，且只关心数与数之间相对关系的问题．离散化将值转换为该值在所有值中排名，以此减小值域．

本题用到的离散化将相同限制区域合并在一起，一同计算，这也属于离散化中的一种．

标程

1
#include <bits/stdc++.h>
2
#define int long long
3
typedef long long ll;
4
using namespace std;
5
const int MOD = 1'000'000'007;
6
const int N = 50;
7
int h, w, m, n;
8
int lx[N], ly[N], rx[N], ry[N], v[N], a[N][N], tx[N], ty[N];
9
int cntx, cnty;
10
ll ans;
11

12
int fastpow(int a, int p) {
13
    ll now = a, ans = 1;
14
    while (p > 0) {
15
        if (p & 1) {
16
            (ans *= now) %= MOD;
17
        }
18
        (now *= now) %= MOD;
19
        p >>= 1;
20
    }
21
    return ans;
22
}
23

24
void solve() {
25
    ans = 0;
26
    cntx = cnty = 0;
27
    cin >> h >> w >> m >> n;
28
    tx[++cntx] = 1, tx[++cntx] = h + 1;
29
    ty[++cnty] = 1, ty[++cnty] = w + 1;
30
    for (int i = 1; i <= n; i++) {
31
        cin >> lx[i] >> ly[i] >> rx[i] >> ry[i] >> v[i];
32
        tx[++cntx] = lx[i];
33
        tx[++cntx] = rx[i] + 1;
34
        ty[++cnty] = ly[i];
35
        ty[++cnty] = ry[i] + 1;
36
    }
37
    // 离散化
38
    sort(tx + 1, tx + cntx + 1);
39
    sort(ty + 1, ty + cnty + 1);
40
    int nx = unique(tx + 1, tx + cntx + 1) - tx - 1;
41
    int ny = unique(ty + 1, ty + cnty + 1) - ty - 1;
42
    for (int i = 1; i <= n; i++) {
43
        lx[i] = lower_bound(tx + 1, tx + nx + 1, lx[i]) - tx;
44
        rx[i] = lower_bound(tx + 1, tx + nx + 1, rx[i] + 1) - tx;
45
        ly[i] = lower_bound(ty + 1, ty + ny + 1, ly[i]) - ty;
46
        ry[i] = lower_bound(ty + 1, ty + ny + 1, ry[i] + 1) - ty;
47
    }
48
    // 进行容斥，mask 位上为 0，表不钦定，否则表钦定不能有 v_i
49
    for (int mask = 0; mask < (1 << n); mask++) {
50
        // 先默认每一个小矩形都没有限制，可以取到 [1,m]
51
        for (int i = 1; i < nx; i++) {
52
            for (int j = 1; j < ny; j++) {
53
                a[i][j] = m;
54
            }
55
        }
56
        // 对于题中提到的小矩形，我们将其限制为 v_i / v_i-1
57
        for (int i = 1; i <= n; i++) {
58
            // 现在正在处理第 i 个矩形
59
            for (int x = lx[i]; x < rx[i]; x++) {
60
                for (int y = ly[i]; y < ry[i]; y++) {
61
                    // 对于在第 i 个矩形内部的点(x,y)，更新其上限
62
                    if ((1 << (i - 1)) & mask) {
63
                        // 对应位是 1，被钦定不能有 v_i
64
                        // 因此上限是 v_i-1
65
                        a[x][y] = min(a[x][y], v[i] - 1);
66
                    } else {
67
                        // 没有钦定，随意
68
                        a[x][y] = min(a[x][y], v[i]);
69
                    }
70
                }
71
            }
72
        }
73
        ll tot = 1;
74
        // 对于上述限制，计算结果
75
        for (int x = 1; x < nx; x++) {
76
            for (int y = 1; y < ny; y++) {
77
                ll area = 1ll * (tx[x + 1] - tx[x]) * (ty[y + 1] - ty[y]);
78
                tot = 1ll * tot * fastpow(a[x][y], area) % MOD;
79
            }
80
        }
81
        if (__builtin_popcount(mask) & 1) {
82
            tot = -tot;
83
        }
84
        (ans += (tot + MOD) % MOD) %= MOD;
85
    }
86
    cout << ans << endl;
87
}
88

89
signed main() {
90
    ios::sync_with_stdio(false);
91
    cin.tie(0);
92
    cout.tie(0);
93
    int T;
94
    cin >> T;
95
    while (T--) {
96
        solve();
97
    }
98
    return 0;
99
}

展开收起

安吉D13 模考8总结

Fri, 14 Aug 2026 00:00:00 GMT

得分情况#

预期得分：100+20+40+0

实际得分：0+20+40+0

Time Line#

8<30>~8<50> 看题
8<50>~9<20> 切 T1
9<20>~10<40> 写 T2
10<40>~12<00> 写 T3

挂分原因#

T1 文件输入输出被注释没有删去

收获#

一定要检查文件输入输出
学习了笛卡尔树

安吉D13-T2

Fri, 14 Aug 2026 00:00:00 GMT

原题呈现

P9352 训猫 / Cat Exercise#

题目描述#

有 NNN 个猫塔，编号从 111 到 NNN．塔 iii 的高度为 PiP_iPi（1≤i≤N1 \le i \le N1≤i≤N）．这些塔的高度是 111 到 NNN 之间的不同整数．共有 N−1N - 1N−1 对相邻的塔．对于每个 jjj（1≤j≤N−11 \le j \le N - 11≤j≤N−1），塔 AjA_jAj 和塔 BjB_jBj 是相邻的．最开始，可以通过从一个塔移动到相邻的塔，来从一个塔到达任何其他塔．

最开始，一只猫待在高度为 NNN 的塔上．

然后我们进行猫运动．在猫运动中，我们反复选择一个塔并在其上放置一个障碍．然而，我们不能在已经放置障碍的塔上再放置障碍．在这个过程中，将发生以下情况：

如果猫不在所选的塔上，什么也不会发生．
如果猫在所选的塔上，并且所选塔的每个相邻塔上都有障碍，猫运动将结束．
否则，在猫可以通过从塔移动到相邻塔而不受障碍影响到达的塔中，猫将移动到除当前塔外最高的塔．过程中，猫会选择从塔移动到相邻塔的步数最少的路线．

给定塔的高度信息和相邻塔的对，编写程序计算在适当放置障碍的情况下，猫从塔移动到相邻塔的最大可能移动次数之和．

输入格式#

从标准输入读取以下数据．

NNN P1P_1P1 P2P_2P2 ⋯\cdots⋯ PNP_NPN A1A_1A1 B1B_1B1 A2A_2A2 B2B_2B2 ⋮\vdots⋮ AN−1A_{N-1}AN−1 BN−1B_{N-1}BN−1

输出格式#

向标准输出写入一行．输出应包含猫从塔移动到相邻塔的最大可能移动次数之和．

输入输出样例 #1#

输入 #1#

输出 #1#

1
3

输入输出样例 #2#

输入 #2#

1
7
2
3 2 7 1 5 4 6
3
1 2
4
1 3
5
2 4
6
2 5
7
3 6
8
3 7

输出 #2#

1
7

说明/提示#

样例#

样例 1#

如果我们按以下方式进行猫运动，猫总共移动 3 次．

我们在塔 1 上放置一个障碍．猫不移动．
我们在塔 2 上放置一个障碍．猫从塔 2 移动到塔 3．然后，猫从塔 3 移动到塔 4．
我们在塔 4 上放置一个障碍．猫从塔 4 移动到塔 3．
我们在塔 3 上放置一个障碍．然后猫运动结束．

由于没有办法进行猫运动，使得猫从塔移动到相邻塔的次数大于或等于 4，因此输出 3．

此样例输入满足子任务 1、2、3、4、5、7 的约束．

样例 2#

此样例输入满足子任务 4、6、7 的约束．

约束#

2≤N≤2×1052 \le N \le 2\times 10^52≤N≤2×105．
1≤Pi≤N1 \le P_i \le N1≤Pi≤N (1≤i≤N1 \le i \le N1≤i≤N)．
Pi≠PjP_i \neq P_jPi=Pj (1≤i<j≤N1 \le i < j \le N1≤i<j≤N)．
1≤Aj<Bj≤N1 \le A_j < B_j \le N1≤Aj<Bj≤N (1≤j≤N−11 \le j \le N - 11≤j≤N−1)．
最开始，可以通过从一个塔移动到相邻塔，来从一个塔到达任何其他塔．
给定的值都是整数．

子任务#

(7 分) Ai=i,Bi=i+1A_i = i, B_i = i + 1Ai=i,Bi=i+1 (1≤i≤N−11 \le i \le N - 11≤i≤N−1)，N≤16N \le 16N≤16．
(7 分) Ai=i,Bi=i+1A_i = i, B_i = i + 1Ai=i,Bi=i+1 (1≤i≤N−11 \le i \le N - 11≤i≤N−1)，N≤300N \le 300N≤300．
(7 分) Ai=i,Bi=i+1A_i = i, B_i = i + 1Ai=i,Bi=i+1 (1≤i≤N−11 \le i \le N - 11≤i≤N−1)，N≤5000N \le 5 000N≤5000．
(10 分) N≤5000N \le 5 000N≤5000．
(20 分) Ai=i,Bi=i+1A_i = i, B_i = i + 1Ai=i,Bi=i+1 (1≤i≤N−11 \le i \le N - 11≤i≤N−1)．
(23 分) Ai=⌊i+12⌋,Bi=i+1A_i =\left\lfloor\frac{i+1}2\right\rfloor, B_i = i + 1Ai=⌊2i+1⌋,Bi=i+1 (1≤i≤N−11 \le i \le N - 11≤i≤N−1)．这里 ⌊x⌋\lfloor x \rfloor⌊x⌋ 是小于或等于 xxx 的最大整数．
(26 分) 无额外约束．

我们通过模拟样例可以得知，每一次猫的移动（设从 uuu 到 vvv）都会将点 uuu 和与和 uuu 相邻的所有边全部删去，形成若干个互不连通的子树，同时，这只猫会跑到拥有更大高度点的子树上，其他子树都由于点 uuu 的阻碍，而在后面的过程中不会被经过，因此可以被删去．我们可以贪心地只保留后续价值最大的子树（即使它并不含有当前高度最高的节点，如果这样，只需要将其余的高度最高的节点先堵上即可），这样问题就转化为在新的一棵树上的问题，这满足最优子问题．因此，考虑 dp．

树形的 dp 思路都是相似的．我们设 dp[u] 表示以 u 为根时，不经过所有高度大于 u 的点，所能完成的最长距离．从 uuu 开始能够完成的最长距离可以理解为先从 uuu 到达一个高度比它小的节点 vvv，然后利用从 vvv 开始能够完成的最长距离加上从 uuu 到 vvv 的这段距离即可．因此，有转移方程：

dp[u]=max⁡{dp[v]+dist(u,v)},p[u]>p[v]dp[u] = \max\{dp[v] + dist(u,v)\},p[u]>p[v]dp[u]=max{dp[v]+dist(u,v)},p[u]>p[v]

，其中，dist(u,v)dist(u,v)dist(u,v) 表示 u,vu,vu,v 两点间的距离．这个距离可以使用最近公共祖先．用 u,vu,vu,v 的深度之和，减去多余的两倍最近公共祖先的深度即可，即 dist(u,v)=dep(u)+dep(v)−2×dep(lca)dist(u,v)=dep(u)+dep(v)-2\times dep(lca)dist(u,v)=dep(u)+dep(v)−2×dep(lca)，可以预处理出来．

由于高度大的节点的贡献不影响高度小的节点，我们将节点按高度从小到大排列．对于每一个节点 uuu，尝试以 uuu 为根计算 dp[u]．可以进行一次从 uuu 开始的 dfs，每次遍历到一个点就尝试用这个点的 dp 值去更新点 uuu 的 dp 值．但要注意，搜索过程中如果遇到了高度比 uuu 大的点需要立即 return;，因为路径上不能存在比 uuu 高的点．

时间复杂度 O(n2)O(n^2)O(n2)．

考虑优化．我们有哪些是重复计算的？以样例 2 为例：

遍历过程如下：

u=1u=1u=1，此时无路可走，dp[1]=0dp[1]=0dp[1]=0．
u=2u=2u=2，此时能走到的点为 {1}\{1\}{1}，dp[2]=dp[1]+1=1dp[2] = dp[1]+1=1dp[2]=dp[1]+1=1．
u=3u=3u=3，此时能走到的点为 {1,2}\{1,2\}{1,2}，dp[3]=dp[2]+1=2dp[3] = dp[2]+1=2dp[3]=dp[2]+1=2．
u=4u=4u=4，此时无路可走，dp[4]=0dp[4]=0dp[4]=0．
u=5u=5u=5，此时能走到的点为 {1,2,3}\{1,2,3\}{1,2,3}，dp[5]=dp[3]+2=4dp[5] = dp[3] + 2=4dp[5]=dp[3]+2=4．
u=6u=6u=6，此时无路可走，dp[6]=0dp[6]=0dp[6]=0．
u=7u=7u=7，此时能走到的点为 {1,2,3,4,5,6}\{1,2,3,4,5,6\}{1,2,3,4,5,6}，dp[7]=dp[5]+3=7dp[7]=dp[5]+3=7dp[7]=dp[5]+3=7．
遍历结束，答案为 dp[7]=7dp[7]=7dp[7]=7．

观察这个过程，我们发现，当遍历到节点 222 时，由于 1,21,21,2 相互连通，因此所有能够到达 111 的点都能够到达 222，反过来也成立，这类似于强连通分量！因此，可以将这两个点缩成一个大点统一处理，这个大点的 dp 值即为大点中所有点最大的 dp 值，显然为 dp[2]dp[2]dp[2]．当遍历到节点 777 时，可以给 777 做出贡献的节点已经分成了三个大点：{1,2,3,5},{4},{6}\{1,2,3,5\},\{4\},\{6\}{1,2,3,5},{4},{6}，这实际上对应着 777 的三条边，于是就不必枚举六个点，只需要枚举三个大点．

可以使用并查集来维护每一个节点归属于哪一个大点．特别的，我们设并查集中一个大点的根节点为这个大点中高度最高的点．这是因为 dp 值是随着高度增高而只增不降，因此高度更高的点能做出贡献也更多，可以使用根节点来代表这一个大点的贡献．

具体来说，在程序中，将所有节点按高度从小到大排序．这里有一个小技巧，显然点的编号在读完输入之后就没用了，又因为点的高度互不重复，因此可以使用点的高度作为编号进行存图．这样就不需要排序，直接从小到大遍历节点即可．设当前遍历到节点 uuu：

检查所有与 uuu 仅使用一条边即能够到达的大点，使用这个大点的 dp 值更新自己的 dp 值．显然，若这个大点仅由一个点组成，且高度高于 uuu，则忽视这个大点．
接下来，将所有高度小于 uuu 的大点（一个大点的高度定义为其中所有节点高度的最大值）和 uuu 加入到并查集，将 uuu 和所有满足条件的大点合并在一起，成为一个更大的大大点．

小技巧

若在题目中发现形如“若一个点可以作为贡献，则所有与它满足某种联系的点都可以作为贡献”，考虑将这些满足联系的点组合成一个大点，整体提交贡献．这一般使用并查集进行维护．

标程

1
#include <bits/stdc++.h>
2
#define int long long
3
using namespace std;
4
const int N = 2e5 + 100;
5
int n, dep[N], g[N], p[N];
6
vector<int> e[N];
7
int wt[N], id[N];
8
int cnt = 0;
9
int f[22][N];
10

11
int LCA(int a, int b) {
12
    if (dep[a] < dep[b]) {
13
        swap(a, b);
14
    }
15
    int delta = dep[a] - dep[b];
16
    for (int j = 20; j >= 0; j--) {
17
        if (delta & (1 << j)) {
18
            a = f[j][a];
19
        }
20
    }
21
    if (a == b)
22
        return a;
23
    for (int j = 20; j >= 0; j--) {
24
        if (f[j][a] != f[j][b]) {
25
            a = f[j][a];
26
            b = f[j][b];
27
        }
28
    }
29
    return f[0][a];
30
}
31

32
int qryDist(int a, int b) {
33
    int lca = LCA(a, b);
34
    return dep[a] + dep[b] - 2 * dep[lca];
35
}
36

37
void dfs(int u, int fa) {
38
    f[0][u] = fa;
39
    dep[u] = dep[fa] + 1;
40
    for (int i = 0; i < e[u].size(); i++) {
41
        if (e[u][i] != fa)
42
            dfs(e[u][i], u);
43
    }
44
}
45

46
// 并查集
47
struct DSU {
48
    int fa[N];
49
    void build(int size) {
50
        for (int i = 1; i <= size; i++) {
51
            fa[i] = i;
52
        }
53
    }
54
    int find(int x) {
55
        if (fa[x] == x) {
56
            return x;
57
        }
58
        fa[x] = find(fa[x]);
59
        return fa[x];
60
    }
61
    void merge(int x, int y) {
62
        x = find(x), y = find(y);
63
        if (x < y) {
64
            swap(x, y);
65
        }
66
        fa[y] = x;
67
    }
68
} dsu;
69

70
signed main() {
71
    ios::sync_with_stdio(false);
72
    cin.tie(0);
73
    cout.tie(0);
74
    cin >> n;
75
    for (int i = 1; i <= n; i++) {
76
        cin >> p[i];
77
    }
78
    for (int i = 1; i < n; i++) {
79
        int a, b;
80
        cin >> a >> b;
81
        e[p[a]].push_back(p[b]);
82
        e[p[b]].push_back(p[a]);
83
    }
84
    dfs(1, 0);
85
    for (int j = 1; j <= 20; j++) {
86
        for (int i = 1; i <= n; i++) {
87
            f[j][i] = f[j - 1][f[j - 1][i]];
88
        }
89
    }
90
    dsu.build(n);
91

92
    for (int u = 1; u <= n; u++) {
93
        for (int j = 0; j < e[u].size(); j++) {
94
            int v = e[u][j];
95
            if (v < u) {
96
                v = dsu.find(v);
97
                g[u] = max(g[u], g[v] + qryDist(u, v));
98
            }
99
        }
100
        for (int j = 0; j < e[u].size(); j++) {
101
            int v = e[u][j];
102
            if (v < u) {
103
                dsu.merge(u, v);
104
            }
105
        }
106
    }
107
    cout << g[n] << endl;
108
}

展开收起

安吉D13-T3

Fri, 14 Aug 2026 00:00:00 GMT

原题呈现

风蚀#

题目描述#

考古队发现了一排古老的岩柱，一共有 nnn 根，从左到右编号为 111 到 nnn．

第 iii 根岩柱有一个坚硬度 aia_iai．保证所有坚硬度两两不同．

考古队会对一段连续岩柱做“风蚀实验”．

设这一段是从第 lll 根到第 rrr 根．实验按“天”进行．

第 1 天，这一整段岩柱看成一个完整的连续块．之后每一天的操作会对当前所有连续块分别进行同样的操作，彼此互不影响：

在这个连续块里，找出坚硬度最小的那一根岩柱；
这根岩柱会在这一天被风蚀掉；
记下一个二元组 (L,R)(L, R)(L,R)，其中：
- LLL 表示这根岩柱左边、仍属于这个连续块的岩柱数量；
- RRR 表示这根岩柱右边、仍属于这个连续块的岩柱数量．

因为所有坚硬度两两不同，所以每个连续块里“最小的那根岩柱”总是唯一的．

把这一天所有连续块得到的二元组，按照这些连续块从左到右的顺序依次写下来，就得到这一天的风蚀记录．

当天结束后，被风蚀掉的岩柱消失．剩下的岩柱会分裂成若干个新的连续块，进入下一天．

如果某一天开始时已经没有岩柱了，那么这一天以及之后所有天的风蚀记录都视为空序列．

现在有 qqq 次询问．

每次询问给出两段连续区间 [l1,r1][l_1, r_1][l1,r1] 和 [l2,r2][l_2, r_2][l2,r2]．

如果这两段区间在每一天得到的风蚀记录都完全相同，就称它们是同谱的．

你需要对每次询问回答这两段区间是否同谱．

输入格式#

第一行两个整数 n,qn, qn,q．

第二行 nnn 个整数 a1,a2,…,ana_1, a_2, \dots, a_na1,a2,…,an，表示每根岩柱的坚硬度．保证它们两两不同．

接下来 qqq 行，每行四个整数 l1,r1,l2,r2l_1, r_1, l_2, r_2l1,r1,l2,r2，表示一次询问．

输出格式#

对于每次询问输出一行．

如果两段区间同谱，输出 Yes；否则输出 No．

样例#

输入 #1#

1
7 5
2
3 1 4 2 7 5 6
3
1 3 5 7
4
1 4 4 7
5
2 4 5 7
6
1 1 4 4
7
3 6 4 7

输出 #1#

1
Yes
2
No
3
No
4
Yes
5
No

样例解释#

区间 [1,3][1,3][1,3] 的序列是 (3,1,4)(3,1,4)(3,1,4)，区间 [5,7][5,7][5,7] 的序列是 (7,5,6)(7,5,6)(7,5,6)．它们第一天都会删掉中间位置的最小值，得到记录 (1,1)(1,1)(1,1)；第二天左右各剩一个单点块，记录也完全一样，所以它们同谱．
区间 [1,4][1,4][1,4] 和 [4,7][4,7][4,7] 第一天删掉最小值后，左右剩余规模就不同，因此不同谱．

数据范围#

对于所有测试数据，均有：

1≤n,q≤5×1051 \le n, q \le 5 \times 10^51≤n,q≤5×105
对于所有 1≤i≤n1 \le i \le n1≤i≤n，均有 1≤ai≤n1 \le a_i \le n1≤ai≤n，且 a1,a2,…,ana_1, a_2, \dots, a_na1,a2,…,an 两两不同；
对于所有询问，均有 1≤l1≤r1≤n, 1≤l2≤r2≤n1 \le l_1 \le r_1 \le n,\ 1 \le l_2 \le r_2 \le n1≤l1≤r1≤n, 1≤l2≤r2≤n．

测试点编号	n≤n \len≤	q≤q \leq≤	特殊性质
1	500	500	无
2	2000	2000	无
3	3000	3000	无
4, 5	50000	50000	A
6	100000	100000	B
7	100000	100000	C
8	100000	100000	D
10	100000	100000	E
9, 11	200000	100000	无
12	200000	100000	D
13, 14	300000	200000	无
15, 16	300000	200000	D
17 ~ 20	500000	500000	无

特殊性质说明：

A：对于所有询问，均有 r1−l1+1≤32r_1 - l_1 + 1 \le 32r1−l1+1≤32 且 r2−l2+1≤32r_2 - l_2 + 1 \le 32r2−l2+1≤32．
B：数组严格递增，即对于所有 1≤i≤n1 \le i \le n1≤i≤n，均有 ai=ia_i = iai=i．
C：数组严格递减，即对于所有 1≤i≤n1 \le i \le n1≤i≤n，均有 ai=n−i+1a_i = n - i + 1ai=n−i+1．
D：数组为交错排列，即 a=(1,n,2,n−1,3,n−2,… )a = (1, n, 2, n-1, 3, n-2, \dots)a=(1,n,2,n−1,3,n−2,…)．
E：对于所有询问，均有 l1=l2=1l_1 = l_2 = 1l1=l2=1．

观察题目中的风蚀，我们可以发现，这是判断两棵笛卡尔树是否同构．

笛卡尔树

每一次都以当前区间内最小的点作为根节点，将最小点的左边定为左子树，将最小点的右边定为右子树，接着分别对于左边和右边建树．示意图如下：

![[cartesian-tree1.png]] （图源 oi-wiki）

这棵树在构建时，会将序列中最小的节点 1 取出作为根节点，将 1 左边的节点 9,3,79,3,79,3,7 作为左子树节点，右边的 8,12,10,20,15,18,58,12,10,20,15,18,58,12,10,20,15,18,5 作为右子树节点，然后对于左子树和右子树分别递归建树．

笛卡尔树除了上述的构建方法，还可以使用单调栈进行构建．

具体来说，构建一个从栈底到栈顶从小到大排列的单调栈，从左到右依次让元素进栈：

若当前栈顶的元素比将要进栈的元素 iii 大，则令栈顶元素出栈．记录最后一个出栈的元素为 jjj．
设通过上面一步之后，栈顶元素为 kkk，则 iii 是 kkk 的右子节点，jjj 及其子树为 iii 的左子节点．

示意图如下．实际上，栈中维护的序列就是示意图中红框标出来的部分组成的序列：

![[cartesian-tree2.png]]

（图源 oi-wiki）

这里，两棵树同构是指这两棵树形状相同，但不代表它们每一个点的权值相同．如下面的两棵树是同构的：

显然，每一次如果都构建笛卡尔树并且暴力比较是否同构必定超时，那该怎么做呢？

可以将笛卡尔树转换为一个序列．由单调栈构建法可以从中得出灵感，我们定义 LiL_iLi 表示区间 [l,r][l,r][l,r] 第 iii 个元素左边第一个小于 aia_iai 元素的位置（这里的位置时区间内的相对位置，而不是全局的位置）．特别的，若没有这样的元素，即 aia_iai 为当前区间的前缀最小值，则令 Li=0L_i=0Li=0．显然，在考虑第 iii 个元素时，只需要将其接在元素 LiL_iLi 的右节点，如果 LiL_iLi 有右节点，则将原来的右节点挤到左节点即可，这样构造出的笛卡尔树形状是唯一的，因此，对于一个 {Li}\{L_i\}{Li} 序列，其笛卡尔树是唯一确定的，这样只需要比较 {Li}\{L_i\}{Li} 序列即可．

如果只是暴力计算 {Li}\{L_i\}{Li} 序列再比较，每一次询问都是 O(n)O(n)O(n) 的，这肯定不行，考虑优化．

我们可以使用单调栈预处理 ppp 数组，用于记录每个元素左边第一个比它小的元素．关于 ppp 数组的构造，具体来说，维护一个栈底小的单调栈，从前往后遍历每一个点，对于每一个点 iii，若栈顶的元素比 iii 大，则将栈顶元素舍弃，这是由于有 iii 的存在，栈顶元素不可能作为后续元素所记录的“每个元素左边第一个比它小的元素”．直到栈顶元素比 iii 小，此时栈顶元素就是 pip_ipi．

则 LiL_iLi 可以尝试使用 pIp_IpI 推导．此处为了不造成混淆，令全局下标为 III，局部下标为 iii，因此存在 i=I−l+1i=I-l+1i=I−l+1，此处 lll 是区间左边界．推导过程如下：

若 pI<lp_I< lpI<l，则表示元素 III 左边第一个比它小的元素不在 [l,r][l,r][l,r] 之中．因此特殊的，置 Li=0L_i=0Li=0．
否则，Li=PI−l+1L_i=P_I-l+1Li=PI−l+1．

此处变量 lll 每一次查询都会变化，尝试将其优化．

Li=PI−l+1Li+I=PI+I−l+1Li=PI+i−ILi−i=PI−Ii−Li=I−PI\begin{aligned} L_i&=P_I-l+1\\ L_i+I&=P_I+I-l+1\\ L_i&=P_I+i-I\\ L_i-i&=P_I-I\\ i-L_i&=I-P_I \end{aligned}LiLi+ILiLi−ii−Li=PI−l+1=PI+I−l+1=PI+i−I=PI−I=I−PI

这样，若设 di=i−Lid_i=i-L_idi=i−Li，特别的，若 Li=0L_i=0Li=0，则 di=0d_i=0di=0．则公式简化为：

di=I−PId_i=I-P_Idi=I−PI

由于 did_idi 和 LiL_iLi 一一对应，因此知道一个确定的 {d}\{d\}{d} 序列也可以确定笛卡尔树的形状．显然，ddd 数组可以预处理出来．我们可以使用类似字符串哈希的方法来快速判定两个序列是否相等．若设哈希基数为 BBB，则 {d}\{d\}{d} 序列哈希可以表示为：

Hash⁡d[1,m]=∑i=1mBi−1di\operatorname{Hash}_{d[1,m]}=\sum_{i=1}^{m}B^{i-1}d_iHashd[1,m]=i=1∑mBi−1di

对于询问 [l,r][l,r][l,r]，其哈希值为（[pi≥l][p_i\geq l][pi≥l] 是指示函数，当且仅当 pi≥lp_i\geq lpi≥l 成立时，其值为 1，否则为 0）：

Hash⁡d[l,r]=∑i=lr([pi≥l]Bi−ldi)=∑i=lr([pi≥l]BiB−ldi)=B−l∑i=lr([pi≥l]Bidi)\begin{aligned} \operatorname{Hash}_{d[l,r]}&=\sum_{i=l}^{r}([p_i\geq l]B^{i-l}d_i)\\ &=\sum_{i=l}^{r}([p_i\geq l]B^iB^{-l}d_i)\\ &=B^{-l}\sum_{i=l}^{r}([p_i\geq l]B^id_i) \end{aligned}Hashd[l,r]=i=l∑r([pi≥l]Bi−ldi)=i=l∑r([pi≥l]BiB−ldi)=B−li=l∑r([pi≥l]Bidi)

因此只需要求出两个区间的哈希，再一比较，若相等，就可以认为这两个区间符合题意．如何快速求出两个区间的哈希呢？

如果暴力枚举公式中的 i∈[l,r]i\in[l,r]i∈[l,r]，则单次查询复杂度回到了 O(n)O(n)O(n)，白优化了．若设 wi=Bidiw_i=B^id_iwi=Bidi，那么就需要快速求出 [l,r][l,r][l,r] 区间内 pi≥lp_i\geq lpi≥l 的项的区间和．由于 pip_ipi 随着 iii 的增大而增大，因此满足 pi≥lp_i\geq lpi≥l 的项数量肯定是随 iii 增大而减少的．且已经不满足条件的项不可能在之后的过程中重新满足条件．这可以使用树状数组来优化．具体来说，在树状数组中储存所有在当前还满足要求的 wiw_iwi：

在遍历开始前，将所有的 iii 以 iii 作为键，w[i]w[i]w[i] 作为值加入到树状数组．
离线所有的查询，将每一次查询中的区间拆开，一共 2q2q2q 个区间，将这些区间按照 lll 从小到大排序．依照这个顺序依次解决每一个区间的哈希值．
对于每一个左端点为 lll 的一组请求，我们依次处理，每一次处理时，依照公式，先用树状数组计算 [l,r][l,r][l,r] 之间的区间和，再乘 B−lB^{-l}B−l，即 BlB^lBl 的逆元．
解决完一组请求之后，设下一组请求的左端点为 l′l'l′，则满足 pi∈[l,l′)p_i\in[l,l')pi∈[l,l′) 的 iii 值都将不满足条件，将它们从树状数组中删除，即置为 0．

当然，为了防止冲突，除了使用双哈希之外，对于每一个询问，还需要特判这两个区间长度是否相等，如果不相等，直接为 No．（序列 {0}\{0\}{0} 和 {0,0}\{0,0\}{0,0} 这两者的哈希是相同的）

小技巧：求带前置条件的前缀和

有的时候，我们需要求出区间 [l,r][l,r][l,r] 中所有符合某种条件的元素之和，若这个条件符合单调性，即随着某一个变量的增大或减小，符合条件的元素逐渐变多，且开始符合条件的元素不可能在之后的某一瞬间不符合条件，则称这个条件具有单调性．这个与之相关的变量成为单调变量．

面对有单调性条件的区间部分元素求和问题，我们可以使用树状数组．具体来说，将所有元素按单调变量的顺序递增或递减排列，当遍历到某一个元素时，将从此刻起开始符合条件的元素加入树状数组．

标程

1
#include <bits/stdc++.h>
2
typedef long long ll;
3
#define inv(x, MOD) (fastpow(x, MOD - 2, MOD))
4
#define w(x, MOD) (fastpow(BASE, x, MOD) * (x - p[x]) % MOD)
5
using namespace std;
6
const int N = 5e5 + 100;
7
const int BASE = 127;
8
const int MOD1 = 1e9 + 7;
9
const int MOD2 = 1e9 + 9;
10
int n, q, a[N], p[N];
11
bool ans[N];
12
vector<int> buc[N];
13
map<int, ll> mp1, mp2;
14
struct Query {
15
    int l, r, id;
16
    friend bool operator<(const Query a, const Query b) { return a.l < b.l; }
17
};
18
vector<Query> qry;
19

20
ll fastpow(int a, int p, int MOD) {
21
    ll ans = 1, now = a;
22
    while (p > 0) {
23
        if (p & 1) {
24
            (ans *= now) %= MOD;
25
        }
26
        p >>= 1;
27
        (now *= now) %= MOD;
28
    }
29
    return ans;
30
}
31

32
struct BIT {
33
    ll f[N];
34
    int MOD;
35
    BIT(int MOD) : MOD(MOD) {}
36
    int lowbit(int x) { return x & (-x); }
37
    void Modify(int pos, int v) {
38
        if (v < 0)
39
            v += MOD;
40
        for (int i = pos; i <= n; i += lowbit(i)) {
41
            (f[i] += v) %= MOD;
42
        }
43
    }
44
    int Query(int pos) {
45
        if (pos == 0)
46
            return 0;
47
        ll ans = 0;
48
        for (int i = pos; i >= 1; i -= lowbit(i)) {
49
            (ans += f[i]) %= MOD;
50
        }
51
        return ans;
52
    }
53
    int Query(int l, int r) { return (Query(r) - Query(l - 1) + MOD) % MOD; }
54
} bit1(MOD1), bit2(MOD2);
55

56
signed main() {
57
    ios::sync_with_stdio(false);
58
    cin.tie(0);
59
    cout.tie(0);
60
    cin >> n >> q;
61
    for (int i = 1; i <= n; i++) {
62
        cin >> a[i];
63
    }
64
    stack<int> sta;
65
    for (int i = 1; i <= n; i++) {
66
        while (!sta.empty() && a[sta.top()] >= a[i]) {
67
            sta.pop();
68
        }
69
        if (sta.empty()) {
70
            p[i] = 0;
71
        } else {
72
            p[i] = sta.top();
73
        }
74
        sta.push(i);
75
    }
76
    for (int i = 1; i <= q; i++) {
77
        int l1, l2, r1, r2;
78
        cin >> l1 >> r1 >> l2 >> r2;
79
        if (r1 - l1 != r2 - l2) {
80
            ans[i] = false;
81
            continue;
82
        }
83
        qry.push_back({l1, r1, i});
84
        qry.push_back({l2, r2, i});
85
    }
86
    sort(qry.begin(), qry.end());
87
    for (int i = 1; i <= n; i++) {
88
        if (p[i]) {
89
            bit1.Modify(i, w(i, MOD1));
90
            bit2.Modify(i, w(i, MOD2));
91
            buc[p[i]].push_back(i);
92
        }
93
    }
94
    int cur_l = 1;
95
    for (auto query : qry) {
96
        while (cur_l != -1 && cur_l != query.l) {
97
            for (auto x : buc[cur_l]) {
98
                bit1.Modify(x, -w(x, MOD1));
99
                bit2.Modify(x, -w(x, MOD2));
100
            }
101
            cur_l++;
102
        }
103
        ll hs1 = inv(fastpow(BASE, query.l, MOD1), MOD1) *
104
                 bit1.Query(query.l, query.r) % MOD1;
105
        ll hs2 = inv(fastpow(BASE, query.l, MOD2), MOD2) *
106
                 bit2.Query(query.l, query.r) % MOD2;
107
        if (mp1.count(query.id)) {
108
            if (mp1[query.id] == hs1 && mp2[query.id] == hs2) {
109
                ans[query.id] = true;
110
            } else {
111
                ans[query.id] = false;
112
            }
113
        } else {
114
            mp1[query.id] = hs1;
115
            mp2[query.id] = hs2;
116
        }
117
    }
118
    for (int i = 1; i <= q; i++) {
119
        if (ans[i]) {
120
            cout << "Yes" << endl;
121
        } else {
122
            cout << "No" << endl;
123
        }
124
    }
125
    return 0;
126
}

展开收起

安吉D12-T3

Thu, 13 Aug 2026 00:00:00 GMT

原题呈现

遗忘与新生#

题目背景#

小信经营着一座“天体希尔伯特旅馆”．旅馆的房间编号遍布全部整数，而房间会按照编号对 nnn 取模后的非负余数分配到不同楼层．

题目描述#

旅馆共有 nnn 个楼层．若两个房间编号除以 nnn 的非负余数相同，则它们位于同一楼层．

现在有 mmm 条搬迁指令．每条指令形如 (a,b)(a, b)(a,b)，表示：所有与房间 aaa 位于同一楼层的住客，都可以搬进编号为自己的房间号加上 bbb 的新房间．

对于每次查询给出的初始房间号 xxx，假设这 mmm 条指令可以按任意顺序、任意次数反复使用．你需要判断：从房间 xxx 出发，住客所有可能到达的房间号所形成的集合，是否是一个无限集合．

输入格式#

第一行包含三个整数 n,m,qn, m, qn,m,q．

接下来 mmm 行，每行两个整数 ai,bia_i, b_iai,bi，表示一条指令．

接下来 qqq 行，每行一个整数 xjx_jxj，表示一个查询．

输出格式#

对于每次查询，如果可能到达的房间号集合是无限集，则输出 Yes；否则输出 No．

样例#

样例输入 #1#

样例输出 #1#

1
Yes
2
Yes
3
No

样例输入 #2#

样例输出 #2#

1
No
2
No
3
No

数据范围#

1≤n,m,q≤5×1051 \le n, m, q \le 5 \times 10^51≤n,m,q≤5×105
−109≤ai,bi,xi≤109-10^9 \le a_i, b_i, x_i \le 10^9−109≤ai,bi,xi≤109

子任务#

Subtask	分值	特殊限制
1	10 pts	n,m,q≤40n, m, q \le 40n,m,q≤40
2	10 pts	对所有指令都满足 bi≡0(modn)b_i \equiv 0 \pmod nbi≡0(modn)
3	20 pts	对每个余数 rrr，至多存在一条指令满足 ai≡r(modn)a_i \equiv r \pmod nai≡r(modn)
4	20 pts	n,m,q≤3000n, m, q \le 3000n,m,q≤3000
5	40 pts	无特殊限制

观察题目的“搬迁指令”，每一条允许与模 nnn 为特定值的住户移动到另一层．我们知道，一名住户具体在哪一个房间并不重要，重要的是在哪一个楼层．因此，可以将每一个楼层抽象成一个点，将每一条搬迁指令抽象成一条边，从而组成一张图．

小技巧：抽象化为图

如果题目表述满足有一些方法可以改变一种状态，并且每一种方法都可以使用多次，这就是一张以这种状态的每一个值为端点，每一种方法为边的有向图．若方法是可逆的，则是无向图．

那么什么样的住户所到的端点会是“无限集”呢？想象一下，让一个点在图上走，如果这个点走着走着不能走了，没路了，那么这个点所到的端点就不是“无限集”．显然，只有在环上运动才不会无路可走，即一个用户可以通过一些操作到回到自己原来的楼层．但是，如果通过这些操作最终回到的还是原来那个房间，那么住户到达的还是有限集．比如说以下这个样例：

住户通过第一条指令从一号房搬到三号房，又通过第二条指令从三号房搬回一号房．这显然是一个环，但是不满足题意（只到达了一号和三号房）．

因此，对于一个住户，若该住户最终可以在一个环上运动，且移动的距离和不为 0，则这名住户所到的房间端点是一个无限集．抽象到图上，若以每一个搬迁指令的移动数量为这个指令对应边的权值，则符合条件的用户最终会走到一个权值和非 0 的环上．

那么首先，就需要把环求出来，就是求出图中的强连通分量．这部分可以用 tarjan 实现．

之后，对于每一个强连通分量，我们要判断其中有没有权值和非 0 的环．这部分可以使用 bfs 实现．我们知道，对于一个权值和为 0 的环，其满足若随机一个点为起始点，每一个点到起始点的距离唯一．因此，在环上进行遍历，并记录该点到起始点的距离．若第二次遍历到某点时，此时的权值与第一次不同（发现一个起始点到达该点距离不唯一的点），则这个强连通分量中必然存在权值非 0 的环．

-1

-3

-1

-3

如上图，若选定 A 为起始点，我们会发现，从 A 点到 B 点有多种距离．其一为 2，A→BA\to BA→B，其二为 4，A→B→C→D→E→BA\to B\to C \to D\to E\to BA→B→C→D→E→B．说明这个连通分量中含有权值和非 0 环．

我们对于每一个强连通分量，都跑一遍 bfs，如果该强连通分量中含有权值和非 0 环，则将这个分量打上标记．之后将每个强连通分量缩点（详见强连通分量 - 缩点），从而形成一个 DAG．

最后，通过逆向的拓扑序处理每一个节点 iii．逆向拓扑序可以保证在处理每一个节点时，其可以到达的节点已经处理过了．在处理时，遍历所有能够一步到达 iii 的节点 uuu，若 iii 被标记了，那么可以把标记传到 uuu．根据缩点的相关知识，我们知道，tarjan 缩点后的点排列顺序天然是逆拓扑序．于是只需要根据 tarjan 缩点后点排列的顺序将标记进行扩散即可．

最后的最后，根据每一次询问，都检查：该点是否被打上了标记，如果是，输出 Yes，否则，输出 No．

标程

1
#include <bits/stdc++.h>
2
using namespace std;
3
const int N = 5e5 + 100;
4
typedef long long ll;
5
#define int ll
6
const ll INF = 0x3f3f3f3f3f3f3f3f;
7
int n, m, q, dfn[N], low[N], cnt, bel[N], scc_cnt = 0;
8
bool in_stack[N], mark[N];
9
stack<int> s;
10
struct Node {
11
    int v, w;
12
};
13
vector<Node> e[N];
14
vector<int> g[N];
15
ll h[N];
16
int mod(int x) { return (x % n + n) % n; }
17

18
void tarjan(int u) {
19
    if (dfn[u])
20
        return;
21
    dfn[u] = ++cnt;
22
    low[u] = dfn[u];
23
    s.push(u);
24
    in_stack[u] = true;
25
    for (int i = 0; i < e[u].size(); i++) {
26
        int v = e[u][i].v;
27
        if (dfn[v] == 0) {
28
            tarjan(v);
29
            low[u] = min(low[u], low[v]);
30
        } else if (in_stack[v]) {
31
            low[u] = min(low[u], dfn[v]);
32
        }
33
    }
34
    if (low[u] == dfn[u]) {
35
        scc_cnt++;
36
        set<int> v;
37
        int top;
38
        do {
39
            top = s.top();
40
            s.pop();
41
            in_stack[top] = false;
42
            bel[top] = scc_cnt;
43
            v.insert(top);
44
        } while (top != u);
45
    }
46
}
47

48
bool check_scc(int start) {
49
    queue<int> qu;
50
    qu.push(start);
51
    h[start] = 0;
52
    while (!qu.empty()) {
53
        int u = qu.front();
54
        qu.pop();
55
        for (int i = 0; i < e[u].size(); i++) {
56
            int v = e[u][i].v;
57
            int w = e[u][i].w;
58
            if (bel[v] != bel[u]) {
59
                continue;
60
            }
61
            if (h[v] == INF) {
62
                h[v] = h[u] + w;
63
                qu.push(v);
64
            } else if (h[v] != h[u] + w) {
65
                return true;
66
            }
67
        }
68
    }
69
    return false;
70
}
71

72
signed main() {
73
    ios::sync_with_stdio(false);
74
    cin.tie(0);
75
    cout.tie(0);
76
    cin >> n >> m >> q;
77
    for (int i = 1; i <= m; i++) {
78
        int a, b;
79
        cin >> a >> b;
80
        e[mod(a)].push_back({mod(a + b), b});
81
    }
82
    for (int i = 0; i < n; i++) {
83
        tarjan(i);
84
    }
85
    memset(h, 0x3f, sizeof(h));
86
    for (int u = 0; u < n; u++)
87
        if (h[u] == INF && !mark[bel[u]])
88
            mark[bel[u]] = check_scc(u);
89
    for (int u = 0; u < n; u++) {
90
        for (auto v : e[u]) {
91
            int a = bel[u], b = bel[v.v];
92
            if (a != b) {
93
                g[a].push_back(b);
94
            }
95
        }
96
    }
97
    for (int u = 1; u <= scc_cnt; u++) {
98
        for (auto v : g[u]) {
99
            mark[u] |= mark[v];
100
        }
101
    }
102
    for (int i = 1; i <= q; i++) {
103
        int x;
104
        cin >> x;
105
        x = mod(x);
106
        if (mark[bel[x]]) {
107
            cout << "Yes" << endl;
108
        } else {
109
            cout << "No" << endl;
110
        }
111
    }
112
    return 0;
113
}

展开收起

安吉D11-B

Wed, 12 Aug 2026 00:00:00 GMT

原题呈现

P5658 括号树#

题目背景#

本题中合法括号串的定义如下：

() 是合法括号串．
如果 A 是合法括号串，则 (A) 是合法括号串．
如果 A，B 是合法括号串，则 AB 是合法括号串．

本题中子串与不同的子串的定义如下：

字符串 S 的子串是 S 中连续的任意个字符组成的字符串．S 的子串可用起始位置 lll 与终止位置 rrr 来表示，记为 S(l,r)S (l, r)S(l,r)（1≤l≤r≤∣S∣1 \leq l \leq r \leq |S |1≤l≤r≤∣S∣，∣S∣|S |∣S∣ 表示 S 的长度）．
S 的两个子串视作不同当且仅当它们在 S 中的位置不同，即 lll 不同或 rrr 不同．

题目描述#

一个大小为 nnn 的树包含 nnn 个结点和 n−1n - 1n−1 条边，每条边连接两个结点，且任意两个结点间有且仅有一条简单路径互相可达．

小 Q 是一个充满好奇心的小朋友，有一天他在上学的路上碰见了一个大小为 nnn 的树，树上结点从 1∼n1 \sim n1∼n 编号，111 号结点为树的根．除 111 号结点外，每个结点有一个父亲结点，uuu（2≤u≤n2 \leq u \leq n2≤u≤n）号结点的父亲为 fuf_ufu（1≤fu<u1 ≤ f_u < u1≤fu<u）号结点．

小 Q 发现这个树的每个结点上恰有一个括号，可能是 ( 或 )．小 Q 定义 sis_isi 为：将根结点到 iii 号结点的简单路径上的括号，按结点经过顺序依次排列组成的字符串．

显然 sis_isi 是个括号串，但不一定是合法括号串，因此现在小 Q 想对所有的 iii（1≤i≤n1\leq i\leq n1≤i≤n）求出，sis_isi 中有多少个互不相同的子串是合法括号串．

这个问题难倒了小 Q，他只好向你求助．设 sis_isi 共有 kik_iki 个不同子串是合法括号串，你只需要告诉小 Q 所有 i×kii \times k_ii×ki 的异或和，即：

(1×k1) xor (2×k2) xor (3×k3) xor ⋯ xor (n×kn) (1 \times k_1)\ \text{xor}\ (2 \times k_2)\ \text{xor}\ (3 \times k_3)\ \text{xor}\ \cdots\ \text{xor}\ (n \times k_n) (1×k1) xor (2×k2) xor (3×k3) xor ⋯ xor (n×kn)

其中 xor\text{xor}xor 是位异或运算．

输入格式#

第一行一个整数 nnn，表示树的大小．

第二行一个长为 nnn 的由 ( 与 ) 组成的括号串，第 iii 个括号表示 iii 号结点上的括号．

第三行包含 n−1n − 1n−1 个整数，第 iii（1≤i<n1 \leq i \lt n1≤i<n）个整数表示 i+1i + 1i+1 号结点的父亲编号 fi+1f_{i+1}fi+1．

输出格式#

仅一行一个整数表示答案．

输入输出样例 #1#

输入 #1#

1
5
2
(()()
3
1 1 2 2

输出 #1#

1
6

说明/提示#

【样例 1 解释】

树的形态如下图：

将根到 1 号结点的简单路径上的括号，按经过顺序排列所组成的字符串为 (，子串是合法括号串的个数为 000．

将根到 2 号结点的字符串为 ((，子串是合法括号串的个数为 000．

将根到 3 号结点的字符串为 ()，子串是合法括号串的个数为 111．

将根到 4 号结点的字符串为 (((，子串是合法括号串的个数为 000．

将根到 5 号结点的字符串为 (()，子串是合法括号串的个数为 111．

【样例 2】

见选手目录下的 brackets/brackets2.in 与 brackets/brackets2.ans．

【数据范围】

测试点编号	n≤n\len≤	特殊性质
1∼21\sim 21∼2	888	fi=i−1f_i=i-1fi=i−1
3∼43\sim 43∼4	200200200	^
5∼75\sim 75∼7	200020002000	^
8∼108\sim 108∼10	^	无
11∼1411\sim 1411∼14	10510^5105	fi=i−1f_i=i-1fi=i−1
15∼1615\sim 1615∼16	^	无
17∼2017\sim 2017∼20	5×1055\times 10^55×105	^

既然是一棵树，不知道怎么做的时候就搜索．尝试 dfs，并在搜索时维护一些数据．

显然，我们在这道题中发现了括号，括号和栈是紧密相关的，可以在搜索时维护一个栈，栈内存储当前路径上还没有被匹配的左括号的下标．

最后，我们还发现了子串，看到了子串或子序列，就要想到 dp，并定义状态为：

定义 dp[i] 为以……结尾……的方案数（长度）

因此，此题我们定义 dp[i] 表示以节点 iii 结尾的方案数．

这道题已经拆解完了，接下来就只需要进行一次搜索，并在搜索时动态维护栈、dp 数组、题目中的 k 数组即可．具体来说，当我们遍历到节点 uuu 时：

将初始化 dpu=0,ku=kfaudp_u=0,k_u=k_{fa_u}dpu=0,ku=kfau，faufa_ufau 是 uuu 的父节点．
检查当前节点的括号
- 若是左括号，则将 uuu 入栈．由于不可能有合法的括号序列是以左括号为结尾的，因此 dpudp_udpu 仍为 0．
- 若是右括号，检查栈中有没有可以配对的左括号
  - 若是没有，则这个右括号不能成功匹配，因此 dpudp_udpu 仍为 0．
  - 若是存在，则完成一次匹配，将栈顶的左括号出栈．设这个左括号的位置为 xxx，则 dpfaxdp_{fa_x}dpfax 为在这对括号配成之前就组合成的子串，且恰好以 faxfa_xfax 结尾．显然，这每一个子串都可以加上 [x,u][x,u][x,u]，成为一个新的子串．因此，dpu=dpfax+1dp_u = dp_{fa_x} + 1dpu=dpfax+1，kuk_uku 增加 dpudp_udpu．
继续向下 dfs．
将栈还原．

依照这个流程，可以写出标程：

1
#include <bits/stdc++.h>
2
using namespace std;
3
#define int long long
4
const int N = 5e5 + 10;
5
int n, f[N], ans, dp[N], k[N];
6
stack<int> sta;
7
vector<int> e[N];
8
char c[N];
9

10
void dfs(int t) {
11
    k[t] = k[f[t]];
12
    int top = -1;
13
    if (c[t] == '(') {
14
        sta.push(t);
15
    } else {
16
        if (sta.empty()) {
17
            // 无法匹配
18
            dp[t] = 0;
19
        } else {
20
            // 可以匹配
21
            top = sta.top();
22
            sta.pop();
23
            dp[t] = dp[f[top]] + 1;
24
            k[t] += dp[t];
25
        }
26
    }
27
    for (int i = 0; i < e[t].size(); i++) {
28
        int v = e[t][i];
29
        dfs(v);
30
    }
31
    if (c[t] == '(') {
32
        sta.pop();
33
    } else if (top != -1) {
34
        // 可以匹配
35
        sta.push(top);
36
    }
37
}
38

39
signed main() {
40
    cin >> n;
41
    for (int i = 1; i <= n; i++) {
42
        cin >> c[i];
43
    }
44
    for (int i = 2; i <= n; i++) {
45
        cin >> f[i];
46
        e[f[i]].push_back(i);
47
    }
48
    dfs(1);
49
    for (int i = 1; i <= n; i++) {
50
        ans ^= i * k[i];
51
    }
52
    cout << ans;
53
    return 0;
54
}

展开收起

安吉D11-C

Wed, 12 Aug 2026 00:00:00 GMT

原题呈现

P3605 Promotion Counting P#

题目描述#

奶牛们又一次试图创建一家创业公司，还是没有从过去的经验中吸取教训——牛是可怕的管理者！

为了方便，把奶牛从 1∼n1\sim n1∼n 编号，把公司组织成一棵树，1 号奶牛作为总裁（这棵树的根节点）．除了总裁以外的每头奶牛都有一个单独的上司（它在树上的 “双亲结点”）．

所有的第 iii 头牛都有一个不同的能力指数 pip_ipi，描述了她对其工作的擅长程度．如果奶牛 iii 是奶牛 jjj 的祖先节点，那么我们把奶牛 jjj 叫做 iii 的下属．

不幸地是，奶牛们发现经常发生一个上司比她的一些下属能力低的情况，在这种情况下，上司应当考虑晋升她的一些下属．你的任务是帮助奶牛弄清楚这是什么时候发生的．简而言之，对于公司的中的每一头奶牛 iii，请计算其下属满足 pj>pip_j > p_ipj>pi 的 jjj 的数量．

输入格式#

输入的第一行包括一个整数 nnn．

接下来的 nnn 行包括奶牛们的能力指数 p1,p2…pnp_1,p_2 \dots p_np1,p2…pn．保证所有数互不相同．

接下来的 n−1n-1n−1 行描述了奶牛 2∼n2 \sim n2∼n 的上司的编号．再次提醒，1 号奶牛作为总裁，没有上司．

输出格式#

输出包括 nnn 行．输出的第 iii 行应当给出有多少奶牛 iii 的下属比奶牛 iii 能力高．

输入输出样例 #1#

输入 #1#

输出 #1#

说明/提示#

对于 100%100\%100% 的数据，1≤n≤1051\le n \le 10^51≤n≤105，1≤pi≤1091 \le p_i \le 10^91≤pi≤109．

既然是一棵树，不知道怎么做的时候就搜索．尝试 dfs，并在搜索时维护一些数据．

之后，我们观察到问题问的是：满足 pj>pip_j > p_ipj>pi 的 jjj 的数量，要求有多少数大于（或小于）目标值，可以使用离散化 + 树状数组．

具体来说，我们遍历到一个节点 uuu 时：

查询当前树状数组中有多少数比 pup_upu 大．注意：现在树状数组中还没有加入过 uuu 的任何子孙节点．
遍历 uuu 子节点．
再次回到 uuu 时，树状数组已经完全收录的 uuu 的所有子孙节点．再次查询当前树状数组中有多少数比 pup_upu 大，与第一次查询的差值就是答案．

小技巧：树的 dfs 中两次查询时机

当我们在树上进行 dfs 搜索时，遍历到一个节点 uuu，在遍历其子节点前，uuu 的子节点任意一个都没有被遍历，在遍历其子节点之后，uuu 的所有子节点都会被遍历过．在两者之间，不会有不是 uuu 子节点的节点被遍历，因此，若是想要查询子节点的一些情况，可以在这两次查询时机各记录一次结果，然后考虑差量．

标程

1
#include <bits/stdc++.h>
2
using namespace std;
3

4
const int N = 1e5 + 100;
5

6
int n, p[N], q[N], f[N], ans[N];
7
vector<int> e[N];
8

9
struct BIT {
10
    int f[N];
11
    int lowbit(int i) { return i & (-i); }
12
    void Modify(int pos, int v) {
13
        for (int i = pos; i <= n; i += lowbit(i)) {
14
            f[i] += v;
15
        }
16
    }
17
    int Query(int pos) {
18
        if (pos == 0)
19
            return 0;
20
        int ans = 0;
21
        for (int i = pos; i >= 1; i -= lowbit(i)) {
22
            ans += f[i];
23
        }
24
        return ans;
25
    }
26
    int Query(int l, int r) { return Query(r) - Query(l - 1); }
27
} bit;
28

29
void dfs(int u) {
30
    int tot = bit.Query(p[u] + 1, n);
31
    bit.Modify(p[u], 1);
32
    for (auto v : e[u]) {
33
        dfs(v);
34
    }
35
    ans[u] = bit.Query(p[u] + 1, n) - tot;
36
}
37

38
signed main() {
39
    cin >> n;
40
    for (int i = 1; i <= n; i++) {
41
        cin >> p[i];
42
        q[i] = p[i];
43
    }
44
    sort(q + 1, q + n + 1);
45
    for (int i = 1; i <= n; i++) {
46
        p[i] = lower_bound(q + 1, q + n + 1, p[i]) - q;
47
    }
48
    for (int i = 2; i <= n; i++) {
49
        cin >> f[i];
50
        e[f[i]].push_back(i);
51
    }
52
    dfs(1);
53
    for (int i = 1; i <= n; i++) {
54
        cout << ans[i] << endl;
55
    }
56
    return 0;
57
}

展开收起

安吉D11-D

Wed, 12 Aug 2026 00:00:00 GMT

原题呈现

Codeforces 2193G - Paths in a Tree#

题目描述#

本题为交互式题目．

给你一个无环连通的无向图，包含 nnn 个顶点．定义一条从顶点 vvv 到顶点 uuu 的路径为一个由互不相同的顶点组成的序列 p1,p2,…,pkp_1, p_2, \dots, p_kp1,p2,…,pk，满足 p1=vp_1 = vp1=v，pk=up_k = upk=u，并且对于所有 iii（1≤i<k1 \le i < k1≤i<k），顶点 pip_ipi 与 pi+1p_{i+1}pi+1 之间都存在一条边．

图中有两个隐藏的顶点 xxx 和 yyy（它们可能相同）．你可以进行如下询问：

选择两个顶点 a,ba, ba,b（1≤a,b≤n1 \le a, b \le n1≤a,b≤n）．交互库会返回 111，如果从 xxx 到 yyy 的路径与从 aaa 到 bbb 的路径至少有一个公共顶点；否则返回 000．

你的任务是在不超过 ⌊n/2⌋+1\lfloor n/2 \rfloor + 1⌊n/2⌋+1 次询问内，找到至少一个位于 xxx 到 yyy 路径上的顶点．

注意：交互库是自适应的，这意味着隐藏的顶点可能会根据你的询问而改变，但不会与先前的回答矛盾．

输入格式#

每个测试包含多个测试用例．第一行包含一个整数 ttt（1≤t≤1041 \le t \le 10^41≤t≤104）—— 测试用例的数量．接下来的行描述每个测试用例．

每个测试用例的第一行包含一个整数 nnn（2≤n≤2⋅1052 \le n \le 2 \cdot 10^52≤n≤2⋅105）—— 图中顶点个数．

接下来 n−1n-1n−1 行，每行包含两个整数 v,uv, uv,u（1≤v,u≤n1 \le v, u \le n1≤v,u≤n），表示顶点 vvv 和 uuu 之间有一条边．

保证所有测试用例的 nnn 之和不超过 2⋅1052 \cdot 10^52⋅105．

交互过程#

为了找到路径上的顶点，你最多可以使用 ⌊n/2⌋+1\lfloor n/2 \rfloor + 1⌊n/2⌋+1 次询问．询问格式为 ? a b．

每次询问后，读入一个整数，即返回的 000 或 111．

当你找到一个满足要求的顶点时，输出一行 ! v（1≤v≤n1 \le v \le n1≤v≤n），其中 vvv 是你找到的顶点．

如果你的程序对某个测试用例发出了超过 ⌊n/2⌋+1\lfloor n/2 \rfloor + 1⌊n/2⌋+1 次询问，那么交互库会返回 −1-1−1．在收到这样的回答后，你的程序应该立即终止，否则将得到“答案错误”的评判．否则，它可能会得到其他评判结果．

输出询问后，记得输出换行并刷新输出缓冲区，否则你会收到“超时”的评判．在 C++ 中可使用 fflush(stdout) 或 cout.flush()；在 Java 中可使用 System.out.flush()；在 Python 中可使用 stdout.flush()；其他语言请参考相应文档．

样例#

输入#

展开收起

输出#

展开收起

首先，观察到询问次数的限制是 ⌊n/2⌋+1\lfloor n/2 \rfloor + 1⌊n/2⌋+1，这说明我们每次至少要排除两个节点．

有以下一个结论：我们可以按照 dfn 次序，每一次询问 dfn 最靠前的两个没有被询问过的节点．如果回答是 Yes，则再花一次询问分出是询问的两个点其中哪一个点．如果回答 No 则接着询问另外两个 dfn 最靠前且没有被询问过的节点

为什么是这样呢？我们观察 dfn 连续的两个节点，发现它们只会存在两种位置关系：

一条边的两个顶点（如下图的 (1,2)(1,2)(1,2)，(2,3)(2,3)(2,3)）
分居于一个节点的两颗子树（如下图的 (4,5)(4,5)(4,5)，(6,7)(6,7)(6,7)）

对于第一种情况，由于本身就是一条边，不会有其他点干扰．因此，可以稳定地排除两个点；对于第二种情况，我们可以发现，对于一对点，其路径上的其他点必然在前面的询问中已经排除了．如 (6,7)(6,7)(6,7) 这一对点，其路径上的 1,2,51,2,51,2,5 都已经在前面的询问中被排除过了．因此也可以稳定地排除两个点．

标程

1
#include <bits/stdc++.h>
2
using namespace std;
3
const int N = 2e5 + 100;
4
int n, dfn[N], cnt, id[N];
5
vector<int> e[N];
6

7
void dfs(int u, int fa) {
8
    dfn[u] = ++cnt;
9
    id[dfn[u]] = u;
10
    for (auto v : e[u]) {
11
        if (v != fa)
12
            dfs(v, u);
13
    }
14
}
15

16
void solve() {
17
    for (int i = 1; i <= n; ++i)
18
        e[i].clear();
19
    cin >> n;
20
    cnt = 0;
21
    int root = -1;
22
    for (int i = 1; i <= n - 1; i++) {
23
        int u, v;
24
        cin >> u >> v;
25
        if (root == -1) {
26
            root = u;
27
        }
28
        e[u].push_back(v);
29
        e[v].push_back(u);
30
    }
31
    dfs(root, 0);
32
    for (int i = 1; i + 1 <= n; i += 2) {
33
        cout << "? " << id[i] << " " << id[i + 1] << endl;
34
        cout.flush();
35
        int res;
36
        cin >> res;
37
        if (res == 1) {
38
            cout << "? " << id[i] << " " << id[i] << endl;
39
            cout.flush();
40
            cin >> res;
41
            if (res) {
42
                cout << "! " << id[i] << endl;
43
                cout.flush();
44
                return;
45
            } else {
46
                cout << "! " << id[i + 1] << endl;
47
                cout.flush();
48
                return;
49
            }
50
        }
51
    }
52
    cout << "! " << id[n] << endl;
53
    cout.flush();
54
}
55

56
signed main() {
57
    int t;
58
    cin >> t;
59
    while (t--) {
60
        solve();
61
    }
62
    return 0;
63
}

展开收起

安吉D12 模考7总结

Wed, 12 Aug 2026 00:00:00 GMT

得分情况#

预期得分：100+0+0+0

实际得分：100+0+0+0

Time Line#

8<30>~8<50> 看题
8<50>~9<40> 切 T1
9<40>~11<00> T2 做不出来，放弃
11<00>~12<00> 尝试调 T3 失败

挂分原因#

T3 调不出来是因为先增加 vis 标签，再检查了 vis 标签是否存在．
T2 状态想错了，我的状态即存在了后效性，又记录了重复的状态．

收获#

学会了 tarjan 的缩点小技巧
复习了树上背包

安吉D12-T2

Wed, 12 Aug 2026 00:00:00 GMT

原题呈现

森林基站#

题目描述#

熊大为了保卫狗熊岭，要在森林里建立一个由 nnn 个通信基站组成的预警网络．这 nnn 个基站由 n−1n-1n−1 条隐蔽的光缆连接，形成了一棵树的结构．

为了保证信号畅通，熊大需要为每个基站分配一个运行频率．频率可以选择 1∼m1 \sim m1∼m 之间的任意整数．

然而，频率 kkk 是一个“高功率特殊频率”．由于高功率频率之间会互相干扰，且对周围低功率设备有压制作用，光头强的探测器很容易发现异常．为了安全，熊大设定了以下规则：

整个网络中，最多只能有 xxx 个基站被分配为频率 kkk．
如果某个基站被分配了频率 kkk，那么与它通过光缆直接相连的所有相邻基站的频率必须严格小于 kkk．

熊大想知道，一共有多少种合法的频率分配方案？两种方案被认为是不同的，当且仅当至少有一个基站被分配了不同的频率．

由于答案可能很大，请将结果对 998244353998244353998244353 取模后告诉熊大．

输入格式#

输入文件名为 forest.in．

输入的第一行包含一个整数 TTT，表示测试数据的组数．

对于每组测试数据：

第一行包含四个整数 n,m,k,xn, m, k, xn,m,k,x，分别表示基站的数量、可选频率的上限、高功率特殊频率的值，以及最多允许分配频率 kkk 的基站数量．
接下来 n−1n-1n−1 行，每行包含两个整数 u,vu, vu,v，表示基站 uuu 和基站 vvv 之间有一条光缆相连．

输出格式#

输出文件名为 forest.out．

对于每组测试数据，输出一行一个整数，表示合法的频率分配方案数对 998244353998244353998244353 取模后的结果．

样例#

输入 #1#

输出 #1#

样例解释#

【样例 1 解释】

第 1 组测试数据：有 333 个基站，频率可以选择 1,2,31, 2, 31,2,3．高功率特殊频率是 222，最多允许有 111 个基站使用频率 222．

不使用频率 222：每个基站都可以选择频率 111 或 333，共有 23=82^3 = 823=8 种方案．
恰好有 111 个基站使用频率 222：
- 若基站 111 频率为 222，则相邻的基站 222 频率必须严格小于 222（只能为 111），基站 333 的频率可以是 111 或 333，共 222 种方案．
- 若基站 222 频率为 222，则相邻的基站 111 和 333 频率都必须为 111，共 111 种方案．
- 若基站 333 频率为 222，则相邻的基站 222 频率必须为 111，基站 111 的频率可以是 111 或 333，共 222 种方案．

合计共有 8+2+1+2=138+2+1+2 = 138+2+1+2=13 种合法的分配方案．

第 2 组测试数据：有 444 个基站，结构为以 111 为中心的菊花图．频率可选 1,2,31,2,31,2,3，特殊频率是 222，最多允许 222 个基站使用频率 222．

若基站 111 使用频率 222，则基站 2,3,42,3,42,3,4 必须全部使用频率 111．共 111 种方案．
若基站 111 不使用频率 222：
- 若基站 111 使用频率 111，则基站 2,3,42,3,42,3,4 可随意选择 1,2,31,2,31,2,3，但频率 222 的基站数不能超过 222．这部分共有 23+3×22+3×2=8+12+6=262^3 + 3 \times 2^2 + 3 \times 2 = 8 + 12 + 6 = 2623+3×22+3×2=8+12+6=26 种方案．
- 若基站 111 使用频率 333，则基站 2,3,42,3,42,3,4 不能使用频率 222（因为使用频率 222 的基站，其所有邻居的频率必须严格小于 222）．所以基站 2,3,42,3,42,3,4 只能选择频率 111 或 333，共 23=82^3 = 823=8 种方案．

总计 1+26+8=351 + 26 + 8 = 351+26+8=35 种方案．

数据范围#

对于所有测试数据，保证：

1≤T≤101 \le T \le 101≤T≤10
1≤n≤30001 \le n \le 30001≤n≤3000
1≤x≤30001 \le x \le 30001≤x≤3000
1≤k≤m≤1091 \le k \le m \le 10^91≤k≤m≤109
1≤u,v≤n1 \le u, v \le n1≤u,v≤n
所有测试数据的 nnn 之和不超过 100001000010000．

测试点编号	n≤n \len≤	m≤m \lem≤	x≤x \lex≤	特殊性质
1 ~ 2	10	3	10	无
3 ~ 4	12	10910^9109	12	无
5	15	10910^9109	15	无
6 ~ 8	200	10910^9109	200	无
9 ~ 11	3000	10910^9109	10	无
12 ~ 14	3000	10910^9109	3000	A（菊花图）
15 ~ 17	3000	10910^9109	3000	B（链）
18 ~ 20	3000	10910^9109	3000	无

特殊性质说明：

A：树的形态为菊花图，即存在一个基站 ccc，其余所有基站都与基站 ccc 直接相连．
B：树的形态为一条链，即每个基站的度数均不超过 222．

观察到 n≤3000n\leq 3000n≤3000，可以支持 O(n2)O(n^2)O(n2) 的做法．此题选用 dp．由于每一个节点的决策都只与总共存在的高功率节点和其相邻节点有关，因此，定义 dp[i][j][k] 表示考虑 iii 为根的子树，子树内已经有了 jjj 个高功率节点（包括点 iii），由于根据不同情况，iii 也会有不同的取值，因此最后一维 k∈[0,2]k\in[0,2]k∈[0,2]，表示节点 iii 频率 vvv 的取值范围所拥有的方案数：

1≤v≤k−11\leq v\leq k-11≤v≤k−1，此时 k=0k=0k=0．
v=kv=kv=k，此时 k=1k=1k=1．
k+1≤v≤mk+1\leq v\leq mk+1≤v≤m，此时 k=2k=2k=2．

不难发现初始状态：考虑了 0 个节点，子树已有 0 个高功率节点，共有 1 种情况．根据树形背包的相关知识，即 g[0][0][0/1/2] = 1．

接下来根据 kkk 的不同分别考虑转移：

若 k=0k=0k=0，则表示相邻节点无限制．因此，可以从其子节点 k∈{0,1,2}k\in\{0,1,2\}k∈{0,1,2} 的状态转移而来．具体来说，若 vvv 是第 iii 个子节点：g[i][j+k][0]=g[i−1][j][0]×(∑l=02dp[v][k][l])g[i][j+k][0] =g[i-1][j][0] \times (\sum_{l=0}^{2}dp[v][k][l])g[i][j+k][0]=g[i−1][j][0]×(∑l=02dp[v][k][l])．注意其中是加号还是乘号．互斥的状态是相加，承接的状态是相乘．
若 k=1k=1k=1，则其相邻节点只能取到 [1,k)[1,k)[1,k)．因此，可以从其子节点 k=0k=0k=0 的状态转移而来．具体来说，若 vvv 是第 iii 个子节点：g[i][j+k][1]=g[i−1][j][1]×dp[v][k][0]g[i][j+k][1] =g[i-1][j][1] \times dp[v][k][0]g[i][j+k][1]=g[i−1][j][1]×dp[v][k][0]．
若 k=2k=2k=2，其相邻节点不能是高功率节点．因此，可以从其子节点 k∈{0,2}k\in\{0,2\}k∈{0,2} 的状态转移而来．具体来说，若 vvv 是第 iii 个子节点：g[i][j+k][2]=g[i−1][j][2]×(dp[v][k][0]+dp[v][k][2])g[i][j+k][2] =g[i-1][j][2] \times (dp[v][k][0] + dp[v][k][2])g[i][j+k][2]=g[i−1][j][2]×(dp[v][k][0]+dp[v][k][2])．

接下来就完全是树形背包的转移．

最终状态是 ∑k=02dp[root][x][i]\sum_{k=0}^{2}dp[root][x][i]∑k=02dp[root][x][i]．

小技巧：状态的定义与转移

状态的定义常和问题有关．极简单的状态定义就是根据问题定义状态．例如本题询问有多少种方案数，于是就可以定义 dp 状态为考虑到某个节点（或考虑完某节点的子树）时可行的方案数．

稍复杂的 dp 需要加一些限制条件．如此题，由于一个节点的决策只与其子节点决策和剩余“高功率节点”配额相关，于是需要在状态中增加两维．又由于父节点决策只与子节点决策的范围（与 kkk 的大小关系）有关，因此可以坍缩一维大小为 3 的维度，使其成为常数维．需要注意的是，

在增加限制时，不得依赖于当前节点的父节点．如，我定义一维状态表示当前节点有没有受到父节点的影响，这是不可行的
状态不能重复、不能遗漏．如，我定义一维常数维，其中 0 表示当前节点不受影响的方案数（当前节点可以取 [1,m][1,m][1,m]），1 表示当前节点受影响的方案数（当前状态可以取 [1,k−1][1,k-1][1,k−1]），这两者在 [1,k−1][1,k-1][1,k−1] 的值域内重叠了．

此外，在转移时，特别是方案数，需要注意运算符号究竟是加号还是乘号．相互排斥的状态需要相加，相互承接的状态需要相乘．

标程

1
#include <bits/stdc++.h>
2
using namespace std;
3
typedef long long ll;
4
const int N = 3005;
5
const int MOD = 998244353;
6
int n, m, k, x, root;
7
vector<int> e[N];
8
int dp[N][N][3], g[2][N][3], sz[N];
9
void dfs(int u, int fa) {
10
    sz[u] = 1;
11
    for (int i = 0; i < e[u].size(); i++) {
12
        int v = e[u][i];
13
        if (v != fa) {
14
            dfs(v, u);
15
            sz[u] += sz[v];
16
        }
17
    }
18
    if (u != root && e[u].size() == 1) {
19
        dp[u][0][0] = k - 1;
20
        dp[u][1][1] = 1;
21
        dp[u][0][2] = m - k;
22
        return;
23
    }
24
    g[0][0][0] = 1;
25
    g[0][0][1] = 1;
26
    g[0][0][2] = 1;
27
    int totsz = 0;
28
    int offset = 0;
29
    for (int xi = 1; xi <= e[u].size(); xi++) {
30
        int v = e[u][xi - 1];
31
        if (v == fa) {
32
            offset++;
33
            continue;
34
        }
35
        int i = xi - offset;
36
        int now = i & 1, prev = (i + 1) & 1;
37
        memset(g[now], 0, sizeof(g[now]));
38
        for (int j = 0; j <= totsz; j++) {
39
            for (int k = 0; k <= sz[v]; k++) {
40
                (g[now][j + k][0] +=
41
                 1ll * g[prev][j][0] *
42
                 (0ll + dp[v][k][0] + dp[v][k][1] + dp[v][k][2] % MOD) % MOD) %=
43
                    MOD;
44
                (g[now][j + k][1] += 1ll * g[prev][j][1] * dp[v][k][0] % MOD) %=
45
                    MOD;
46
                (g[now][j + k][2] += 1ll * g[prev][j][2] *
47
                                     (0ll + dp[v][k][0] + dp[v][k][2] % MOD) %
48
                                     MOD) %= MOD;
49
            }
50
        }
51
        totsz += sz[v];
52
    }
53
    int maxs = (e[u].size() - offset) & 1;
54
    for (int i = 0; i <= totsz; i++) {
55
        (dp[u][i][0] = 1ll * g[maxs][i][0] * (k - 1) % MOD) %= MOD;
56
        dp[u][i + 1][1] = g[maxs][i][1] % MOD;
57
        dp[u][i][2] = 1ll * g[maxs][i][2] * (m - k) % MOD;
58
    }
59
}
60

61
void solve() {
62
    memset(sz, 0, sizeof(sz));
63
    memset(dp, 0, sizeof(dp));
64
    cin >> n >> m >> k >> x;
65
    for (int i = 1; i <= n; i++) {
66
        e[i].clear();
67
    }
68
    root = -1;
69
    for (int i = 1; i < n; i++) {
70
        int u, v;
71
        cin >> u >> v;
72
        if (root == -1) {
73
            root = u;
74
        }
75
        e[u].push_back(v);
76
        e[v].push_back(u);
77
    }
78
    dfs(root, 0);
79
    ll ans = 0;
80
    for (int i = 0; i <= x; i++) {
81
        (ans += dp[root][i][0]) %= MOD;
82
        (ans += dp[root][i][1]) %= MOD;
83
        (ans += dp[root][i][2]) %= MOD;
84
    }
85
    cout << ans << endl;
86
}
87

88
signed main() {
89
    int T;
90
    cin >> T;
91
    while (T--)
92
        solve();
93
    return 0;
94
}

展开收起

安吉D11-A

Tue, 11 Aug 2026 00:00:00 GMT

原题呈现

P6374 树上询问#

题目描述#

给定一棵 nnn 个点的无根树，有 qqq 次询问．

每次询问给一个参数三元组 (a,b,c)(a,b,c)(a,b,c)，求有多少个 iii 满足这棵树在以 iii 为根的情况下 aaa 和 bbb 的最近公共祖先为 ccc．

输入格式#

第一行 222 个数，为 nnn 和 qqq．

接下来 n−1n-1n−1 行，每行 222 个数，表示树的一条边．

接下来 qqq 行，每行 333 个数，为 (a,b,c)(a,b,c)(a,b,c)．

输出格式#

共 qqq 行，每行一个数，为对于每个三元组的 iii 的个数．

输入输出样例 #1#

输入 #1#

展开收起

输出 #1#

输入输出样例 #2#

输入 #2#

输出 #2#

输入输出样例 #3#

输入 #3#

展开收起

输出 #3#

说明/提示#

样例 2 解释#

第一个查询的 iii 为 333 和 444．

第二个查询的 iii 为 111．

数据范围#

本题按子任务测试：#

Subtask 1（202020 pts）：1≤n≤10001 \leq n \leq 10001≤n≤1000，1≤q≤5001 \leq q \leq 5001≤q≤500．
Subtask 2（151515 pts）：1≤n≤1051 \leq n \leq 10^{5}1≤n≤105，1≤q≤1051 \leq q \leq 10^{5}1≤q≤105，树退化成链．
Subtask 3（252525 pts）：1≤n≤5×1051 \leq n \leq 5 \times 10^{5}1≤n≤5×105，1≤q≤1051 \leq q \leq 10^{5}1≤q≤105，数据不随机．
Subtask 4（404040 pts）：1≤n≤5×1 \leq n \leq 5 \times1≤n≤5× 10510^{5}105，1≤q≤2×1051 \leq q \leq 2 \times 10^{5}1≤q≤2×105．

对于所有数据：1≤n≤5×1051 \leq n \leq 5 \times 10^{5}1≤n≤5×105，1≤q≤2×1051 \leq q \leq 2 \times 10^{5}1≤q≤2×105．

注：数据强度不高，不必卡常与快读快输．

考虑样例 2，当询问为 (2,5,z)(2, 5, z)(2,5,z) 时，此时，

根节点	lca(2,5)
1	1
2	2
3	3
4	3
5	5

显然，不在 2→52\to 52→5 这条链上的 444 不可能为两节点的最近公共祖先．实际上，对于询问 (x,y,z)(x,y,z)(x,y,z)，不在 x→yx\to yx→y 这条链上的所有点 aaa，若满足 a=za=za=z，则方案数必然为 000．因为若 aaa 与 x→yx\to yx→y 连通时存在一个汇入点 bbb，满足 a→ba\to ba→b 和 x→yx\to yx→y 交于点 bbb，且点 bbb 在 x→yx\to yx→y 上，则此时路径 a→xa\to xa→x 和 a→ya\to ya→y 会有重合（a→ba\to ba→b）．因此，aaa 不能成为 x,yx,yx,y 的最近公共祖先．

那对于 zzz 在 x→yx\to yx→y 上的情况怎么办呢？那么此时首先，zzz 自身可以作为根节点．其次，不在 x→yx\to yx→y 上的点，且与 zzz 连通的点可以将 zzz 拎起来．因此，答案就是不在 x→yx\to yx→y 上且与 zzz 直接相连（这里指不通过 x→yx\to yx→y 上的任何边就能够相连）的点以及 zzz 本身的节点数量．

考虑如何 O(1)O(1)O(1) 算出．显然，我们可以以 111 为根建树进行一次 dfs，那么，对于询问 (x,y,z)(x,y,z)(x,y,z)，会有四种可能：

zzz 不在 x→yx\to yx→y 上．此时根据分析，输出 0．
zzz 正好是 x,yx,yx,y 的最近公共祖先．此时，所有可能的根节点就是 zzz 去除含有 x,yx,yx,y 的两颗子树（这里含有……的子树指所有以 zzz 子节点为根节点的子树中含有该节点的子树，下同）大小，剩余的图中所有点都可以作根
zzz 在 x,yx,yx,y 的最近公共祖先的含有 xxx 的子树上，如上述样例中的 (2,5,3)(2,5,3)(2,5,3)，333 就在 2,52,52,5 最近公共祖先 111 的含有 222 的子树上．再如下图中的 (x,y,z)(x,y,z)(x,y,z)，那么此时，zzz 的子树中含有 xxx 的子树部分（即图中节点 u,x,D,Eu,x,D,Eu,x,D,E）肯定不行（因为子树上的任意一点都需要经过 u→zu\to zu→z，这条边在 x→yx\to yx→y 上），且此时除了 zzz 子树之外的部分 sss （即图中点 A,b,y,vA,b,y,vA,b,y,v）也不能作为子节点（因为 sss 上的每一个点想要到达 zzz 都需要经过 v→zv\to zv→z，显然 yyy 不在 zzz 的子树上，故 y→z→xy\to z\to xy→z→x 也需要通过 v→zv\to zv→z，因此 v→zv\to zv→z 在 x→yx\to yx→y 上）因此答案为：所有的节点，减去 zzz 子树中含有 xxx 的子树大小，再减去不在 zzz 子树中的节点．
zzz 在 x,yx,yx,y 的最近公共祖先的有 yyy 的子树上，这一种和上一种相同．

小技巧：如何 O(1)O(1)O(1) 计算一个点是否是另外一个点的子孙节点．

这需要用到 dfs 序，所谓 dfs 序，就是通过 dfs 首次先序遍历到每一个节点的次序，这可以在 dfs 的时候预处理出来．节点 uuu 的 dfs 序常记为 dfn⁡u\operatorname{dfn}_udfnu．不难发现，同一个子树内的节点，dfndfndfn 是连续的．可以利用这个性质，若我们现在想要知道 vvv 是否是 uuu 的子节点，那么这个命题完全等同于：

\DeclareMathOperator\dfndfn\dfnu≤\dfnv<\dfnu+size\DeclareMathOperator{\dfn}{dfn} \dfn_u \leq \dfn_v \lt \dfn_u + size\DeclareMathOperator\dfndfn\dfnu≤\dfnv<\dfnu+size

，其中，sizesizesize 为 uuu 及其子节点的数量．

可以写出代码：

1
#include <bits/stdc++.h>
2
using namespace std;
3
const int N = 5e5 + 100;
4
int n, q;
5
vector<int> e[N];
6
int f[22][N], cnt, dfn[N], sz[N], dep[N];
7

8
int LCA(int x, int y) {
9
    if (dep[x] > dep[y]) {
10
        swap(x, y);
11
    }
12
    int step = dep[y] - dep[x];
13
    for (int i = 20; i >= 0; i--) {
14
        if (step & (1 << i)) {
15
            y = f[i][y];
16
        }
17
    }
18
    if (x == y)
19
        return x;
20
    for (int i = 20; i >= 0; i--) {
21
        if (f[i][x] != f[i][y]) {
22
            x = f[i][x];
23
            y = f[i][y];
24
        }
25
    }
26
    return f[0][x];
27
}
28

29
void dfs(int t, int fa) {
30
    f[0][t] = fa;
31
    dep[t] = dep[f[0][t]] + 1;
32
    dfn[t] = ++cnt;
33
    for (int i = 0; i < e[t].size(); i++) {
34
        if (e[t][i] != fa)
35
            dfs(e[t][i], t);
36
    }
37
    for (int i = 0; i < e[t].size(); i++) {
38
        if (e[t][i] != fa)
39
            sz[t] += sz[e[t][i]];
40
    }
41
    sz[t]++;
42
}
43

44
/**
45
 * 判断 x 是不是在 y 的子树中
46
 */
47
bool isIn(int x, int y) { return dfn[y] <= dfn[x] && dfn[x] < dfn[y] + sz[y]; }
48

49
/**
50
 * 通过倍增计算以fa子节点为根节点的子树中含有dir的子树
51
 */
52
int getSubSz(int dir, int fa) {
53
    if (dir == fa) {
54
        return 0;
55
    }
56
    for (int i = 20; i >= 0; i--) {
57
        int now = f[i][dir];
58
        if (dfn[now] > dfn[fa]) {
59
            dir = now;
60
        }
61
    }
62
    return sz[dir];
63
}
64

65
signed main() {
66
    cin >> n >> q;
67
    for (int i = 1; i <= n - 1; i++) {
68
        int u, v;
69
        cin >> u >> v;
70
        e[u].push_back(v);
71
        e[v].push_back(u);
72
    }
73
    dfs(1, 0);
74
    for (int j = 1; j <= 20; j++) {
75
        for (int i = 1; i <= n; i++) {
76
            f[j][i] = f[j - 1][f[j - 1][i]];
77
        }
78
    }
79
    for (int i = 1; i <= q; i++) {
80
        int a, b, c;
81
        cin >> a >> b >> c;
82
        if (LCA(a, b) == c) {
83
            cout << n - getSubSz(a, c) - getSubSz(b, c) << endl;
84
        } else if (isIn(a, c) && !isIn(b, c)) {
85
            cout << n - getSubSz(a, c) - (n - sz[c]) << endl;
86
        } else if (!isIn(a, c) && isIn(b, c)) {
87
            cout << n - getSubSz(b, c) - (n - sz[c]) << endl;
88
        } else {
89
            cout << 0 << endl;
90
        }
91
    }
92
    return 0;
93
}

展开收起

安吉D10 模考6总结

Mon, 10 Aug 2026 00:00:00 GMT

得分情况#

预期得分：100+100+20+0

实际得分：66+100+0+0

Time Line#

8<30>~8<50> 看题
8<50>~9<30> 完成 T1
9<30>~11<20> 完成 T2
11<20>~12<00> 写 T3

挂分原因#

T1 由于没有严格使用“忽略最后一个操作 3 前面的操作”这种方式，而是使用“遇到操作 3 就清空操作数组”，这导致超时

收获#

了解了 Lucas 定理
认识了基于前缀和数组的线段树编写

安吉D10-T3

Mon, 10 Aug 2026 00:00:00 GMT

原题呈现

我爱喝奶茶#

题目背景#

小信家附近开了一家奶茶店，从此他迷上了喝奶茶．

题目描述#

奶茶店共有 mmm 款特色限定奶茶，编号为 1,2,...,m1,2,...,m1,2,...,m，第 iii 款奶茶给小信带来的愉悦度为 wiw_iwi．

在 nnn 天之中，奶茶店每天只会上架其中一款限定奶茶，第 iii 天上架的是第 fif_ifi 款．

小信可以选择打卡连续的 [l,r][l,r][l,r] 天内上架的所有奶茶．

但是小信是一个非常喜新厌旧的人，一旦同一款奶茶打卡多于一次，就会厌恶这款奶茶，甚至忘记奶茶曾经带给他的快乐（即仅当该款奶茶在区间内恰好只打卡过 1 次时，才能获得其愉悦程度 wiw_iwi）．

现在，请问小信怎么打卡能让他的愉悦程度最大，最大的愉悦度是多少．

输入格式#

第一行两个整数 n,mn,mn,m．

第二行包含 nnn 个整数，第 iii 个表示 fif_ifi．

第三行包含 mmm 个整数，第 iii 个表示 wiw_iwi．

输出格式#

一行三个整数，分别表示打卡的区间 [l,r][l,r][l,r]，以及最大打卡收益，用空格隔开．如果有多个区间满足条件，输出区间长度最短且 lll 最小的一个．

样例#

样例输入#

1
9 4
2
2 3 1 1 4 1 2 4 1
3
5 3 6 6

样例输出#

1
1 5 15

数据范围#

对于 20pts20\text{pts}20pts 的数据：0≤n,m≤5000 \le n,m \le 5000≤n,m≤500

对于 60pts60\text{pts}60pts 的数据：0≤n,m≤1040 \le n,m \le 10^40≤n,m≤104 其中有 10pts10\text{pts}10pts 的数据满足每种奶茶最多出现两次

对于 100pts100\text{pts}100pts 的数据：0≤n,m≤1060 \le n,m \le 10^60≤n,m≤106，1≤fi≤m1 \le f_i \le m1≤fi≤m，1≤wi≤1091 \le w_i \le 10^91≤wi≤109

我们枚举起点，对于每一个起点 iii，对从第 iii 天起的每一天的奶茶的权值做一次前缀和，其中，第二次出现的奶茶权值为 −w[i]-w[i]−w[i]，第三次出现的奶茶权值为 000．

如下面的例子：

1
9 4
2
2 3 1 1 4 1 2 4 1
3
1 2 3 4

则以第一天为起点每一天出现的奶茶的权值列表为：

1
2 3 1 1 4 1 2 4 1

将其中第二次出现的奶茶权值置为 −w[i]-w[i]−w[i]，第三次出现的奶茶权值置为 000，则可得：

1
2 3 1 -1 4 0 -2 -4 0

将其做一次前缀和：

1
2 5 6 5 9 9 7 3 3

前缀和数组中最大的值（设其下标为 kkk，此例中 k=5k=5k=5）即为起点为 1 时的最大答案，区间为 [1,k][1,k][1,k]．

再如，第二天为起点每一天出现的奶茶的权值列表为：

1
3 1 1 4 1 2 4 1

将其中第二次出现的奶茶权值置为 −w[i]-w[i]−w[i]，第三次出现的奶茶权值置为 000，则可得：

1
3 1 -1 4 0 2 -4 0

将其做一次前缀和：

1
3 4 3 7 7 9 5 5

前缀和数组中最大的值（设其下标为 kkk，此例中 k=6k=6k=6）即为起点为 2 时的最大答案，区间为 [2,k][2,k][2,k]．

对于每一天作为起点都这么操作一次，取起点为 [1,n][1,n][1,n] 答案的最大值，时间复杂度为 O(n2)O(n^2)O(n2)，考虑优化．

枚举起点好像没有优化空间，但是如何快速处理前缀和呢？

仔细观察原数组在 i→i+1i\rightarrow i+1i→i+1 时有什么变化：

原数组中第一个奶茶种类为 a[i] 的奶茶（设其下标为 iii）消失了．
原数组中第二个奶茶种类为 a[i] 的奶茶（设其下标为 nxtinxt_inxti）权值取了相反数，变为 w[a[i]]．
原数组中第三个奶茶种类为 a[i] 的奶茶（设其下标为 nxtnxtinxt_{nxt_i}nxtnxti）权值从 0 变为 -w[a[i]]．

对应到前缀和数组（设大小为 nnn）上就是：

区间 [i,n][i,n][i,n] 中每一项减少 w[a[i]]．
区间 [nxti,n][nxt_i, n][nxti,n] 中每一项增加 2*w[a[i]]．
区间 [nxtnxti,n][nxt_{nxt_i}, n][nxtnxti,n] 中每一项减少 w[a[i]]．

区间修改使用线段树优化，就可以在 O(log⁡n)O(\log n)O(logn) 的复杂度内更新前缀和数组．

至于区间，只需要在线段树上二分查找：

对于每一个线段树上的节点，比较其两个子节点的 max 哪一个更大，选择更大的那个节点，在该子节点中继续查找，直到找到大小为 1 的节点．

标程

1
#include <bits/stdc++.h>
2
typedef long long ll;
3
using namespace std;
4
const int N = 1e6 + 100;
5

6
int n, m, a[N], w[N], l, r;
7
ll s[N];
8
ll ans = -1;
9

10
vector<int> vec[N];
11
int pointer[N];
12

13
class SegmentTree {
14
  public:
15
    struct Node {
16
        int l, r;
17
        ll max;
18
        ll add;
19
    } f[N * 5];
20
    void Build(int t, int l, int r) {
21
        f[t].l = l;
22
        f[t].r = r;
23
        if (l == r) {
24
            f[t].max = s[l];
25
            return;
26
        }
27

28
        int mid = (l + r) / 2;
29
        Build(t * 2, l, mid);
30
        Build(t * 2 + 1, mid + 1, r);
31

32
        pushup(t);
33
    }
34
    void Add(int t, int x, int y, ll v) {
35
        pushdown(t);
36
        if (x <= f[t].l && f[t].r <= y) {
37
            f[t].add += v;
38
            f[t].max += v;
39
            return;
40
        }
41
        if (x > f[t].r || y < f[t].l) {
42
            return;
43
        }
44

45
        Add(t * 2, x, y, v);
46
        Add(t * 2 + 1, x, y, v);
47

48
        pushup(t);
49
    }
50
    ll Query(int t, int x, int y) {
51
        pushdown(t);
52

53
        if (x <= f[t].l && f[t].r <= y) {
54
            return f[t].max;
55
        }
56
        if (x > f[t].r || y < f[t].l) {
57
            return -1;
58
        }
59

60
        return max(Query(t * 2, x, y), Query(t * 2 + 1, x, y));
61
    }
62
    int findmax(int t) {
63
        if (f[t].l == f[t].r) {
64
            return f[t].l;
65
        }
66
        if (Query(t * 2, 1, n) >= Query(t * 2 + 1, 1, n)) {
67
            return findmax(t * 2);
68
        }
69
        return findmax(t * 2 + 1);
70
    }
71

72
  private:
73
    void pushup(int t) { f[t].max = max(f[t * 2].max, f[t * 2 + 1].max); }
74
    void pushdown(int t) {
75
        if (f[t].add) {
76
            ll add = f[t].add;
77
            f[t * 2].add += add;
78
            f[t * 2].max += add;
79
            f[t * 2 + 1].add += add;
80
            f[t * 2 + 1].max += add;
81
            f[t].add = 0;
82
        }
83
    }
84
} tr;
85

86
signed main() {
87
    ios::sync_with_stdio(false);
88
    cin.tie(0);
89
    cout.tie(0);
90
    cin >> n >> m;
91
    for (int i = 1; i <= n; i++) {
92
        cin >> a[i];
93
    }
94
    for (int i = 1; i <= m; i++) {
95
        cin >> w[i];
96
    }
97
    for (int i = 1; i <= n; i++) {
98
        vec[a[i]].push_back(i);
99
        int wt = w[a[i]];
100
        if (vec[a[i]].size() == 2) {
101
            wt = -w[a[i]];
102
        }
103
        if (vec[a[i]].size() > 2) {
104
            wt = 0;
105
        }
106
        s[i] = s[i - 1] + wt;
107
    }
108
    tr.Build(1, 1, n);
109
    for (int i = 1; i <= n; i++) {
110
        ll tot = tr.Query(1, 1, n);
111
        int newR = tr.findmax(1);
112
        int nowLen = newR - i + 1;
113
        int miniLen = r - l + 1;
114
        if (tot > ans || (tot == ans && nowLen < miniLen)) {
115
            ans = tot;
116
            l = i;
117
            r = newR;
118
        }
119

120
        int wt = w[a[i]];
121
        tr.Add(1, i, n, -wt);
122
        pointer[a[i]]++;
123
        if (pointer[a[i]] != vec[a[i]].size()) {
124
            int top = vec[a[i]][pointer[a[i]]];
125
            tr.Add(1, top, n, 2ll * wt);
126
            pointer[a[i]]++;
127
            if (pointer[a[i]] != vec[a[i]].size()) {
128
                int top = vec[a[i]][pointer[a[i]]];
129
                tr.Add(1, top, n, -wt);
130
            }
131
            pointer[a[i]]--;
132
        }
133
    }
134
    cout << l << " " << r << " " << ans;
135
    return 0;
136
}

展开收起

安吉D10-T4

Mon, 10 Aug 2026 00:00:00 GMT

原题呈现

题目描述#

输入一个长度为 nnn 的数列 a1,a2,⋯ ,ana_1, a_2, \cdots, a_na1,a2,⋯,an，问有多少个长度大于等于 222 的不上升的子序列满足：

∏i=2k(abi−1abi) mod 2>0\prod_{i=2}^{k} \binom{a_{b_{i-1}}}{a_{b_i}} \bmod 2 > 0i=2∏k(abiabi−1)mod2>0

输出这个个数对 100000000710000000071000000007 取模的结果．

输入格式#

第一行一个整数 nnn．

接下来 nnn 行，每行一个整数，第 iii 行表示 aia_iai．

输出格式#

一行一个整数表示答案．

样例#

样例输入#

样例输出#

1
11

数据范围#

前 10%10\%10% 的测试点：n≤9n \le 9n≤9，1≤ai≤131 \le a_i \le 131≤ai≤13．
前 20%20\%20% 的测试点：n≤17n \le 17n≤17，1≤ai≤201 \le a_i \le 201≤ai≤20．
前 40%40\%40% 的测试点：n≤1911n \le 1911n≤1911，1≤ai≤40001 \le a_i \le 40001≤ai≤4000．
前 70%70\%70% 的测试点：n≤2017n \le 2017n≤2017．
前 85%85\%85% 的测试点：n≤100084n \le 100084n≤100084．
100%100\%100% 的测试点：1≤n≤2119851 \le n \le 2119851≤n≤211985，1≤ai≤2333331 \le a_i \le 2333331≤ai≤233333．

所有的 aia_iai 互不相同，即不存在 i≠ji \neq ji=j 满足 ai=aja_i = a_jai=aj．

我们可以尝试使用 dp 来解决子序列问题．

定义 dp[i] 表示以第 iii 个数结尾能够有多少满足要求的子序列．由于题意要求所有组合数的乘积模 2 大于 0，那就是要求所有组合数都是奇数．

转移方程为：

dp[i]=1+∑jj<idp[j],(ji) mod 2=1dp[i]=1+\sum_{j}^{j <i}dp[j],\binom{j}{i}\bmod 2=1dp[i]=1+j∑j<idp[j],(ij)mod2=1

可以使用递推公式快速算出组合数．

这样能够拿到 40 pts．当 aia_iai 到二十万的数据规模就无法处理了，那该怎么办呢？

Lucas 定理：

(xy) mod p=(⌊x/p⌋⌊y/p⌋)(x mod py mod p) mod p\binom{x}{y}\bmod p=\binom{\lfloor x/p\rfloor}{\lfloor y/p\rfloor}\binom{x\bmod p}{y\bmod p}\bmod p(yx)modp=(⌊y/p⌋⌊x/p⌋)(ymodpxmodp)modp

当 p=2p=2p=2 时，

(xy) mod 2=(⌊x/2⌋⌊y/2⌋)(x mod 2y mod 2) mod p\binom{x}{y}\bmod 2=\binom{\lfloor x/2\rfloor}{\lfloor y/2\rfloor}\binom{x\bmod 2}{y\bmod 2}\bmod p(yx)mod2=(⌊y/2⌋⌊x/2⌋)(ymod2xmod2)modp

将 (⌊x/2⌋⌊y/2⌋)\binom{\lfloor x/2\rfloor}{\lfloor y/2\rfloor}(⌊y/2⌋⌊x/2⌋) 拆解，可得：

(xy) mod 2=(⌊x/4⌋⌊y/4⌋)(⌊x/2⌋ mod 2⌊y/2⌋ mod 2)(x mod 2y mod 2) mod p\binom{x}{y}\bmod 2=\binom{\lfloor x/4\rfloor}{\lfloor y/4\rfloor}\binom{\lfloor x/2\rfloor\bmod 2}{\lfloor y/2\rfloor\bmod 2}\binom{x\bmod 2}{y\bmod 2}\bmod p(yx)mod2=(⌊y/4⌋⌊x/4⌋)(⌊y/2⌋mod2⌊x/2⌋mod2)(ymod2xmod2)modp

像这样拆解，最终可得：

(xy) mod 2=∏(xiyi)\binom{x}{y}\bmod 2=\prod\binom{x_i}{y_i}(yx)mod2=∏(yixi)

其中，xi,y1x_i,y_1xi,y1 分别表示 x,yx,yx,y 中二进制表示的第 iii 位．

当且仅当 xi=0,yi=1x_i=0,y_i=1xi=0,yi=1 时，(xiyi)=0\binom{x_i}{y_i}=0(yixi)=0，故 (xy) mod 2=1\binom{x}{y}\bmod 2=1(yx)mod2=1 等价于 ∀i,xi=0⇒yi=0\forall i,x_i=0\Rightarrow y_i=0∀i,xi=0⇒yi=0，即位运算中 x∧y=yx\wedge y=yx∧y=y．其实就是 xxx 是 yyy 二进制中的子集．

因此，在 dp 时，尝试子集枚举．具体来说，遍历到 a[i]a[i]a[i] 时，先将 f[i]f[i]f[i] 增加 1，表示 a[i]a[i]a[i] 单独成一组．再枚举 a[i]a[i]a[i] 的所有子集 kkk，若 kkk 在后面出现过（设其处于 a[j]a[j]a[j]），则说明 f[i]f[i]f[i] 可以转移到 f[j]f[j]f[j]，将 f[i]f[i]f[i] 贡献给 f[j]f[j]f[j]．

子集枚举可以使用下面的代码：

1
for (int j = (a[i] - 1) & a[i]; j > 0; j = (j - 1) & a[i])

请注意：由于题目中所要求的序列长度大于等于 2，因此最终答案需要减去 nnn 个长度为 1 的序列．

标程

1
#include <bits/stdc++.h>
2
using namespace std;
3
#define int long long
4
const int N = 240000;
5
const int MOD = 1e9 + 7;
6

7
int n, a[N], id[N], f[N], ans;
8

9
signed main() {
10
    cin >> n;
11
    for (int i = 1; i <= n; i++) {
12
        cin >> a[i];
13
        id[a[i]] = i;
14
    }
15
    for (int i = 1; i <= n; i++) {
16
        (f[i] += 1) %= MOD;
17
        (ans += f[i]) %= MOD;
18
        for (int j = (a[i] - 1) & a[i]; j > 0; j = (j - 1) & a[i]) {
19
            if (id[j] > i)
20
                (f[id[j]] += f[i]) %= MOD;
21
        }
22
    }
23
    cout << ans - n;
24
    return 0;
25
}

展开收起

安吉D8-E

Mon, 10 Aug 2026 00:00:00 GMT

原题呈现

P10381 杂赛选比#

题目背景#

你说得对，但是小 ∭\iiint∭ 在打 CF 时将 Earn or Unlock 错看成了下面的鬼畜样子，痛失 2h 遗憾离场，希望大家引以为戒．

题目描述#

给定一个长度为 nnn 的数组 aaa，初始只有 a1a_1a1 是已被解锁的．现在有一个整数 iii，初始值为 111．现在小 ∭\iiint∭ 在对这个数组进行一个游戏：

如果 aia_iai 未被解锁，游戏结束．
否则他可以将 ai+1∼i+aia_{i+1\sim i+a_i}ai+1∼i+ai 设置成已被解锁的，或是获得 aia_iai 个金币（如果 ai=0a_i=0ai=0 则无法解锁任何元素），然后将 iii 加 111．

请你求出游戏结束后你能获得的最大金币数量．

输入格式#

本题有多组测试数据．

第一行一个整数 TTT，表示测试数据组数．

对于每一组数据，第一行一个正整数 nnn．

接下来一行 nnn 个非负整数 a1∼na_{1\sim n}a1∼n．

输出格式#

对于每一组数据，一行一个数，表示答案．

输入输出样例 #1#

输入 #1#

输出 #1#

输入输出样例 #2#

输入 #2#

1
1
2
10
3
1 1 4 5 1 4 1 9 1 9

输出 #2#

1
26

说明/提示#

【样例 1 解释】#

对于第一组数据，你可以解锁 a2a_2a2，再获得 a2a_2a2 个金币．而对于第三组数据，你无法解锁 a2a_2a2，因此只能获得 000 个金币．

对于第二组数据，你可以解锁 a2,a3a_2,a_3a2,a3，并获得 999 个金币．

【样例 2 解释】#

将第 1,2,3,61,2,3,61,2,3,6 个位置用于解锁为最优方案．

【数据范围】#

对于 100%100\%100% 的数据，1≤n≤1051\le n\le10^51≤n≤105，0≤ai≤1050\le a_i\le10^50≤ai≤105，T≤5T\le 5T≤5．

测试点编号	n≤n\leqn≤	ai≤a_i\leqai≤	T=T=T=	特殊性质
111	101010	000	111	/
2∼32\sim32∼3	101010	555	111	/
4∼54\sim54∼5	600600600	600600600	111	/
6∼86\sim86∼8	500050005000	500050005000	111	/
9∼109\sim109∼10	10510^5105	555	555	/
11∼1211\sim1211∼12	5×1045\times10^45×104	10510^5105	555	ai>na_i>nai>n
13∼2013\sim2013∼20	10510^5105	10510^5105	555	/

此题考虑使用动态规划．

不妨定义 dp[i][0/1] 表示考虑到第 iii 张卡牌（即 aaa 数组中第 iii 个数），且第 iii 张选择用于解锁（第二维为 0）或选择用于获得金币（第二维为 1），所能够获得的最大金币．

显然，当想要去考虑第 iii 张卡牌，前提是第 iii 张卡牌被解锁．因此，dp[i][0/1] 可以由所有能够解锁第 iii 张卡牌的状态转移而来．具体来说，是由所有满足以下条件的卡牌 jjj 从 dp[k][0] 转移而来：

卡牌 jjj 的解锁范围能够触及到卡牌 iii，即 j+a[j]≥ij + a[j] \geq ij+a[j]≥i．

由于使用卡牌 jjj 之后，卡牌 iii 立即被解锁了，因此处于卡牌 jjj 到 iii 之间的卡牌选择什么都可以，显然，这里选择得分比选择解锁更优，因此，可以在转移时加上卡牌 [k+1,i−1][k+1, i-1][k+1,i−1] 的权值之和，因此，有如下的转移方程：

dp[i][0]=max⁡jj+a[j]≥i(dp[j][0]+∑k=j+1i−1ak)dp[i][0] = \max_j^{j + a[j] \geq i}(dp[j][0] + \sum^{i-1}_{k=j+1}a_k)dp[i][0]=jmaxj+a[j]≥i(dp[j][0]+k=j+1∑i−1ak) dp[i][1]=dp[i][0]+aidp[i][1] = dp[i][0] + a_idp[i][1]=dp[i][0]+ai

其中的 jjj 满足上述条件．最终状态即为 dp[n][1]dp[n][1]dp[n][1]．

不难发现，dp[x][1]（x∈N+x\in\mathbb{N}^+x∈N+）没有在转移中提供过数据，因此可以舍去第二维，且默认第二维是 0．这样状态就变为了：考虑前 iii 张卡牌，且钦定第 iii 张需要用于解锁，所能够获取的最多金币．这样最终状态需要补上最后一张卡牌用于解锁相对用来获取金币所带来的损失（即 ana_nan），故最终状态为 dp[n]+andp[n] + a_ndp[n]+an．

求区间和可以使用前缀和优化，总算法时间复杂度为 O(n2)O(n^2)O(n2)．

40pts 标程

1
#include <bits/stdc++.h>
2
#define sum(l, r) (s[(r)] - s[(l) - 1])
3
using namespace std;
4
const int N = 1e5 + 100;
5
int n, a[N], f[N], s[N];
6

7
void solve() {
8
    cin >> n;
9
    for (int i = 1; i <= n; i++) {
10
        cin >> a[i];
11
        s[i] = s[i - 1] + a[i];
12
        f[i] = -1e8;
13
    }
14
    f[1] = 0;
15
    for (int i = 1; i <= n; i++) {
16
        for (int j = 1; j < i; j++) {
17
            if (j + a[j] >= i) {
18
                f[i] = max(f[i], f[j] + sum(j + 1, i - 1));
19
            }
20
        }
21
    }
22
    int ans = a[1] + f[1];
23
    for (int i = 2; i <= n; i++) {
24
        ans = max(ans, a[i] + f[i]);
25
    }
26
    cout << ans << endl;
27
}
28

29
signed main() {
30
    int T;
31
    cin >> T;
32
    while (T--)
33
        solve();
34
    return 0;
35
}

展开收起

考虑如何优化掉枚举 jjj 的那一层循环．

上面的转移方程可以变形为下面的形式：

dp[i]=max⁡jj+a[j]≥i((dp[j]−s[j])+s[i−1])dp[i] = \max_j^{j + a[j] \geq i}((dp[j] - s[j]) + s[i-1])dp[i]=jmaxj+a[j]≥i((dp[j]−s[j])+s[i−1])

若设 v[j]=dp[j]−s[j],u[j]=j+a[j]v[j] = dp[j] - s[j],u[j]=j+a[j]v[j]=dp[j]−s[j],u[j]=j+a[j]，则可以表示为：

dp[i]=s[i−1]+max⁡ju[j]≥iv[j]dp[i]=s[i-1]+\max_j^{u[j] \geq i} v[j]dp[i]=s[i−1]+jmaxu[j]≥iv[j]

可以使用线段树动态维护最大值．每计算完一个点 kkk 之后，将 kkk 对应的 v[k]v[k]v[k] 当作值，u[j]u[j]u[j] 当作键加入线段树．在每一次计算时，查询在 [1,i][1,i][1,i] 之间的元素的最大值，就可以使用 O(log⁡n)O(\log n)O(logn) 的时间复杂度计算 max⁡ju[j]≥iv[j]\max_j^{u[j] \geq i} v[j]maxju[j]≥iv[j]．

标程

1
#include <bits/stdc++.h>
2
#define int long long
3
using namespace std;
4
const int N = 1e5 + 100;
5
const int INF = 1e18;
6
int n, a[N], f[N], s[N];
7

8
struct SegmentTree {
9
    struct Node {
10
        int l, r, max;
11
        friend Node operator+(const Node a, const Node b) {
12
            if (a.max == -INF)
13
                return b;
14
            if (b.max == -INF)
15
                return a;
16
            Node nNode;
17
            nNode.max = std::max(a.max, b.max);
18
            nNode.l = a.l;
19
            nNode.r = b.r;
20
            return nNode;
21
        }
22
        static Node null() { return {0, 0, (int)-1e18}; }
23
    } f[N * 8];
24
    void build(int t, int l, int r) {
25
        if (l > r) {
26
            return;
27
        }
28
        f[t].l = l;
29
        f[t].r = r;
30
        if (l == r) {
31
            f[t].max = -INF;
32
            return;
33
        }
34

35
        int mid = (l + r) / 2;
36
        build(t * 2, l, mid);
37
        build(t * 2 + 1, mid + 1, r);
38
        pushup(t);
39
    }
40
    void pushup(int t) {
41
        int l = f[t].l, r = f[t].r;
42
        f[t] = f[t * 2] + f[t * 2 + 1];
43
        f[t].l = l;
44
        f[t].r = r;
45
    }
46
    Node query(int t, int x, int y) {
47
        if (x > y) {
48
            return Node::null();
49
        }
50
        if (x <= f[t].l && f[t].r <= y) {
51
            return f[t];
52
        }
53
        if (x > f[t].r || y < f[t].l) {
54
            return Node::null();
55
        }
56
        return query(t * 2, x, y) + query(t * 2 + 1, x, y);
57
    }
58
    void Modify(int t, int pos, int v) {
59
        if (f[t].l == pos && f[t].r == pos) {
60
            f[t].max = max(f[t].max, v);
61
            return;
62
        }
63
        if (f[t].l > pos || f[t].r < pos) {
64
            return;
65
        }
66
        Modify(t * 2, pos, v);
67
        Modify(t * 2 + 1, pos, v);
68
        pushup(t);
69
    }
70
} sgTree;
71

72
void solve() {
73
    cin >> n;
74
    for (int i = 1; i <= n; i++) {
75
        cin >> a[i];
76
        s[i] = s[i - 1] + a[i];
77
        f[i] = -INF;
78
    }
79
    sgTree.build(1, 1, n * 2);
80

81
    f[1] = 0;
82
    sgTree.Modify(1, 1 + a[1], f[1] - s[1]);
83
    int maxidx = 1 + a[1];
84

85
    for (int i = 2; i <= n; i++) {
86
        int qry = sgTree.query(1, i, maxidx).max;
87
        if (qry == -INF) {
88
            continue;
89
        }
90
        f[i] = qry + s[i - 1];
91
        sgTree.Modify(1, i + a[i], f[i] - s[i]);
92
        maxidx = max(maxidx, i + a[i]);
93
    }
94
    int ans = a[1] + f[1];
95
    for (int i = 2; i <= n; i++) {
96
        ans = max(ans, a[i] + f[i]);
97
    }
98
    cout << ans << endl;
99
}
100

101
signed main() {
102
    int T;
103
    cin >> T;
104
    while (T--)
105
        solve();
106
    return 0;
107
}

展开收起

安吉D9-T4

Mon, 10 Aug 2026 00:00:00 GMT

原题呈现

P5100 足球 / Soccer#

题目描述#

你是 JOI 联赛中一所声名卓著的足球俱乐部的经理．

俱乐部有 NNN 名球员，编号为 1…N1\ldots N1…N．球员们每天都刻苦地进行训练，剑指联赛冠军．足球场可视为一个底为 WWW 米，高 HHH 米的长方形，底平行于东西方向，高平行于南北方向．如果某个点向北走 iii 米，再向西走 jjj 米恰好到达球场的西北角，这个点可用坐标 (i,j)(i, j)(i,j) 来表示．

练习结束后，你要回收练习用的足球．开始回收时，所有球员都在足球场上，球员 i(1⩽i⩽N)i (1\leqslant i\leqslant N)i(1⩽i⩽N) 位于 (Si,Ti)(S_i, T_i)(Si,Ti)，球在球员 111 脚下．你正和球员 NNN 一起站在 (SN,TN)(S_N, T_N)(SN,TN)，并准备回收球．球员们把球传到 (SN,TN)(S_N, T_N)(SN,TN) 时，你才会回收球．

你可以指挥球员，但某些操作会提升球员的疲劳度．一个球员不能同时进行多项操作．你可以指挥控球的球员进行如下操作：

踢球．在东西南北四个方向中任选一个，并指定一个正整数 ppp，该球员将球朝指定方向踢出恰好 ppp 米．假定球滚动时可以穿过其他球员．该球员不会移动，且自动停止控球，疲劳度上升 A×p+BA\times p+BA×p+B．
运球．在东西南北四个方向中任选一个，该球员带球，朝指定方向移动 111 米．该球员仍然控球，疲劳度上升 CCC．
停止控球．该球员的疲劳度不改变．

你可以指挥没有控球的球员进行如下操作：

移动．在东西南北四个方向中任选一个，该球员朝指定方向移动 111 米，疲劳度上升 CCC．
控球．如果该球员所在的位置恰好有球，且没有其他球员控球，该球员才能控球．该球员的疲劳度不改变．

球员和球有可能跑出场外，一个位置上可能有多个球员．一天的训练结束后，球员们非常疲惫．你想知道在回收球的过程中，所有球员上升的疲劳度之和的最小值．

输入格式#

第一行有两个整数 H,WH, WH,W，用空格分隔．第二行有三个整数 A,B,CA, B, CA,B,C，用空格分隔．第三行有一个整数 NNN．在接下来的 NNN 行中，第 iii 行 (1⩽i⩽N)(1\leqslant i\leqslant N)(1⩽i⩽N) 有两个整数 Si,TiS_i, T_iSi,Ti，用空格分隔．输入的所有数的含义见题目描述．

输出格式#

一行，一个整数，表示在回收球的过程中，所有球员上升的疲劳度之和的最小值．

输入输出样例 #1#

输入 #1#

输出 #1#

1
26

输入输出样例 #2#

输入 #2#

输出 #2#

1
60

输入输出样例 #3#

输入 #3#

输出 #3#

1
45

输入输出样例 #4#

输入 #4#

输出 #4#

1
2020

说明/提示#

样例解释 1#

在这组样例中，球场、球员、球处于如图所示的状态．图中，黑框空心圆圈表示球员，实心圆表示球，你在 (6,5)(6,5)(6,5)．

最优解如下：

球员 111 把球向东踢出 333 米．疲劳度上升了 1×3+3=61\times 3+3=61×3+3=6，球移动到 (1,4)(1,4)(1,4)．
球员 222 向南移动 111 米．疲劳度又上升了 666．
球员 222 开始控球．
球员 222 向东运球 111 米．疲劳度又上升了 666．
球员 222 把球向南踢出 555 米，疲劳度上升了 1×5+3=81\times 5+3=81×5+3=8，球移动到 (6,5)(6,5)(6,5)．

此时，疲劳度之和为 6+6+6+8=266+6+6+8=266+6+6+8=26．没有更好的方案．

样例解释 2#

在最优解中，不需要踢球．

样例解释 4#

注意这组样例中有多个球员在同一位置的情况．

数据范围与提示#

对于 5%5\%5% 的数据，N=2N=2N=2．对于另外 30%30\%30% 的数据，N⩽1000,A=0N\leqslant 1000, A=0N⩽1000,A=0．对于所有数据， 1⩽H,W⩽500,0⩽A,B,C⩽109,2⩽N⩽105,0⩽Si⩽H,0⩽Ti⩽W(1⩽i⩽N),(S1,T1)≠(SN,TN)1\leqslant H,W\leqslant 500, 0\leqslant A, B, C\leqslant 10^9, 2\leqslant N\leqslant 10^5, 0\leqslant S_i\leqslant H, 0\leqslant T_i\leqslant W(1\leqslant i\leqslant N), (S_1, T_1)\neq(S_N, T_N)1⩽H,W⩽500,0⩽A,B,C⩽109,2⩽N⩽105,0⩽Si⩽H,0⩽Ti⩽W(1⩽i⩽N),(S1,T1)=(SN,TN)．

注意到 NNN 的范围达到了 10510^5105，且球员时时刻刻都在跑动，无法记录球员的状态．于是可以反过来思考：我们可以记录球的状态．由于 HHH 和 WWW 都小于 500，因此，可以对于每一个 (x,y)(x,y)(x,y) 满足 x≤H,y≤Wx\leq H,y\leq Wx≤H,y≤W 都视为图上的一个点，最多只有 250000 个点．

对于球，其有两大类状态，一是球所在的位置；二是球的运动状态，关于运动状态，有以下三类：

被人持有，记为 0．
水平自主移动，记为 1．
横向自主移动，记为 2．

依次对于这几种状态之间的转移进行考虑：

0⇒00\Rightarrow00⇒0 即某一个人向一个方向运球．其转移为：

(x,y,0)→C(x±1,y,0)(x,y,0) \xrightarrow{C}(x\pm1,y,0)(x,y,0)C(x±1,y,0) (x,y,0)→C(x,y±1,0)(x,y,0) \xrightarrow{C}(x,y\pm1,0)(x,y,0)C(x,y±1,0)

0⇒1/20\Rightarrow1/20⇒1/2 当一个球被踢出去：

(x,y,0)→B(x,y,1/2)(x,y,0)\xrightarrow{B}(x,y,1/2)(x,y,0)B(x,y,1/2)

1⇒11\Rightarrow 11⇒1 或 2⇒22\Rightarrow 22⇒2 （被踢出去之后的）球自己移动一步：

(x,y,1)→A(x±1,y,1)(x,y,1)\xrightarrow{A}(x\pm1,y,1)(x,y,1)A(x±1,y,1) (x,y,2)→A(x,y±1,2)(x,y,2)\xrightarrow{A}(x,y\pm1,2)(x,y,2)A(x,y±1,2)

1/2⇒01/2\Rightarrow 01/2⇒0 有一个人接住了这个球．此时需要距离这个位置最近的球员跑过来接球．不难证明，若是一名球员接两次必定不优，因此，选择初始位置距离 (x,y)(x,y)(x,y) 最近的球员．这个可以使用多源 BFS 预处理，设该球员距离球的距离为 disdisdis，则转移方程为：

(x,y,1/2)→dis×C(x,y,0)(x,y,1/2)\xrightarrow{dis\times C} (x,y,0)(x,y,1/2)dis×C(x,y,0)

关于上述 1/2⇒01/2\Rightarrow 01/2⇒0 中的 BFS 预处理，一般的，我们可以通过以下的步骤来进行处理．使用一个队列：

首先，将所有的球员所在的位置入队．
取出队首的球员位置，让这位球员（设为 iii）向前后左右都移动一格（如果这个格子已经别的球员移动到过，则不朝这个方向移动），记录落点（设为 kkk），则离点 kkk 最近的球员即为球员 iii．将点 kkk 加入队列，重复这一步，直到队列清空．

依照上面几个转移方程建边，再跑一遍 dijkstra 即可．

标程

1
#include <bits/stdc++.h>
2
#define int long long
3
using namespace std;
4
typedef pair<int, int> pii;
5
const int N = 1e5 + 100;
6
const int MAXPT = 5 * 500 * 500 + 100;
7
int h, w, a, b, c, n, dist[MAXPT], vis[MAXPT];
8
pii pos[N];
9
queue<pair<int, pii>> bfs_q;
10

11
// [v, cost]
12
vector<pii> g[MAXPT];
13
int near[MAXPT];
14

15
struct Node {
16
    int v, d;
17
    friend bool operator<(const Node a, const Node b) {
18
        return a.d > b.d; // 小根堆
19
    }
20
};
21

22
int pt(int a, int x, int y) {
23
    return ((a) * (w + 1) * (h + 1) + (x) * (w + 1) + (y));
24
}
25
int pt(int x, int y) { return pt(0, x, y); }
26

27
void bfs_upd(int pl, int x, int y) {
28
    if (!near[pt(x, y)]) {
29
        near[pt(x, y)] = pl;
30
        bfs_q.push({pl, {x, y}});
31
    }
32
}
33
void bfs() {
34
    while (!bfs_q.empty()) {
35
        auto top = bfs_q.front();
36
        bfs_q.pop();
37
        int pl = top.first, x = top.second.first, y = top.second.second;
38
        if (x + 1 <= h)
39
            bfs_upd(pl, x + 1, y);
40
        if (x - 1 >= 0)
41
            bfs_upd(pl, x - 1, y);
42
        if (y + 1 <= w)
43
            bfs_upd(pl, x, y + 1);
44
        if (y - 1 >= 0)
45
            bfs_upd(pl, x, y - 1);
46
    }
47
}
48

49
int dijkstra(int t) {
50
    memset(dist, 0x3f, sizeof(dist));
51
    memset(vis, 0, sizeof(vis));
52
    priority_queue<Node> pq;
53
    dist[t] = 0;
54
    pq.push({t, dist[t]});
55
    while (!pq.empty()) {
56
        int u = pq.top().v;
57
        pq.pop();
58
        if (vis[u])
59
            continue;
60
        vis[u] = true;
61
        for (int i = 0; i < g[u].size(); i++) {
62
            int v = g[u][i].first;
63
            int w = g[u][i].second;
64
            if (dist[v] > dist[u] + w) {
65
                dist[v] = dist[u] + w;
66
                pq.push({v, dist[v]});
67
            }
68
        }
69
    }
70
    return dist[pt(0, pos[n].first, pos[n].second)];
71
}
72

73
signed main() {
74
    cin >> h >> w;
75
    cin >> a >> b >> c;
76
    cin >> n;
77
    for (int i = 1; i <= n; i++) {
78
        int s, t;
79
        cin >> s >> t;
80
        pos[i] = {s, t};
81
        bfs_q.push({i, pos[i]});
82
        near[pt(s, t)] = i;
83
    }
84
    bfs();
85
    for (int x = 0; x <= h; x++) {
86
        for (int y = 0; y <= w; y++) {
87
            if (x + 1 <= h) {
88
                g[pt(0, x, y)].push_back({pt(0, x + 1, y), c});
89
                g[pt(1, x, y)].push_back({pt(1, x + 1, y), a});
90
                g[pt(0, x, y)].push_back({pt(1, x, y), b});
91
            }
92
            if (x - 1 >= 0) {
93
                g[pt(0, x, y)].push_back({pt(0, x - 1, y), c});
94
                g[pt(1, x, y)].push_back({pt(1, x - 1, y), a});
95
                g[pt(0, x, y)].push_back({pt(1, x, y), b});
96
            }
97
            if (y + 1 <= w) {
98
                g[pt(0, x, y)].push_back({pt(0, x, y + 1), c});
99
                g[pt(2, x, y)].push_back({pt(2, x, y + 1), a});
100
                g[pt(0, x, y)].push_back({pt(2, x, y), b});
101
            }
102
            if (y - 1 >= 0) {
103
                g[pt(0, x, y)].push_back({pt(0, x, y - 1), c});
104
                g[pt(2, x, y)].push_back({pt(2, x, y - 1), a});
105
                g[pt(0, x, y)].push_back({pt(2, x, y), b});
106
            }
107
            int nPl = near[pt(x, y)];
108
            int dist = abs(x - pos[nPl].first) + abs(y - pos[nPl].second);
109
            g[pt(1, x, y)].push_back({pt(0, x, y), c * dist});
110
            g[pt(2, x, y)].push_back({pt(0, x, y), c * dist});
111
        }
112
    }
113
    cout << dijkstra(pt(0, pos[1].first, pos[1].second));
114
    return 0;
115
}

展开收起

安吉D8-A

Sun, 09 Aug 2026 00:00:00 GMT

原题呈现

P3509 ZAB-Frog#

题目描述#

在一个特别长且笔直的 Byteotian 小溪的河床上，有 nnn 块石头露出水面．它们距离小溪源头的距离分别为 p1<p2<⋯<pnp_1 < p_2 < \cdots < p_np1<p2<⋯<pn．一只小青蛙正坐在其中一块石头上，准备开始它的跳跃训练．每次青蛙跳跃到距离它所在石头第 kkk 近的石头上．具体来说，如果青蛙坐在位置 pip_ipi 的石头上，那么它将跳到这样的 pjp_jpj 上，使得：

∣{pa:∣pa−pi∣<∣pj−pi∣}∣≤k and ∣{pa:∣pa−pi∣≤∣pj−pi∣}∣>k|\{ p_a : |p _ a - p _ i| < |p_j - p_i| \}| \le k \text{ and } |\{ p_a : |p _ a - p _ i| \le |p_j - p_i| \}| > k∣{pa:∣pa−pi∣<∣pj−pi∣}∣≤k and ∣{pa:∣pa−pi∣≤∣pj−pi∣}∣>k

如果 pjp_jpj 不是唯一的，那么青蛙在其中选择距离源头最近的石头．对于每一块石头分别计算，若青蛙从这块石头开始跳跃，经过 mmm 次跳跃后最终会停留在哪一块石头上？

输入格式#

标准输入的第一行包含三个整数 nnn、kkk 和 mmm（1≤k<n≤106,1≤m≤10181 \le k < n \le 10^6, 1 \le m \le 10^{18}1≤k<n≤106,1≤m≤1018），用空格分隔，分别表示石头的数量、参数 kkk 和计划跳跃的次数．第二行包含 nnn 个整数 pjp_jpj（1≤p1<p2<⋯<pn≤10181 \le p_1 < p_2 < \cdots < p_n \le 10^{18}1≤p1<p2<⋯<pn≤1018），用空格分隔，表示小溪河床上连续石头的位置．

输出格式#

你的程序应在标准输出上打印一行，包含 nnn 个整数 r1,r2,⋯ ,rnr_1, r_2, \cdots, r_nr1,r2,⋯,rn，用空格分隔．数字 rir_iri 表示从输入顺序中的第 iii 块石头开始跳跃 mmm 次后，青蛙最终停留的石头编号．

输入输出样例 #1#

输入 #1#

输出 #1#

1
1 1 3 1 1

说明/提示#

样例 #1 解释：#

图中展示了青蛙从每块石头跳跃（单次跳跃）到的位置．

我们发现此题中，mmm 的范围是 1e181e181e18，这显然不可能模拟跳那么多步．

通过模拟样例，我们可以发现：从一个格子开始，跳到的下一个格子是固定的．因此，考虑使用倍增．

具体来说，分别预处理出每一个点跳 1 次、跳 2 次、跳 4 次……，设点 iii 跳了 2j2^j2j 次之后落在了 f[j][i]f[j][i]f[j][i]，则转移方程为：

1
f[i][j] = f[i-1][f[i-1][j]];

可以枚举 mmm 中所有二进制为 1 的位数 xxx（如 666 的二进制表示为 110110110，由于二进制表示中为 1 的数位是右起第二位和右起第三位，因此此时 x∈{2,3}x\in\{2, 3\}x∈{2,3}），初始时，设每一个格子 iii 上都有一只青蛙，这只青蛙实时位置为 aia_iai，对于每一个 xxx，将每一个格子 aia_iai 跳 2x−12^{x-1}2x−1 次，即 a[i] = f[x-1][i]．

最终 aia_iai 中记录的值就是答案了．

那么，怎么求出最初始的 f[0][i]f[0][i]f[0][i]，即每一个点跳一步会落在哪里呢？

使用滑动窗口．维护一个大小始终为 k+1k+1k+1 的滑动窗口 [l,r][l, r][l,r]．初始时，将前 k+1k+1k+1 个数加入滑动窗口，之后，对于每一个点 iii，维护这个滑动窗口，使得其恰好包含 iii 和离 iii 最近的前 kkk 个数：

尝试将此窗口整体右移 1 格．具体的：若滑动窗口外右边第一个元素 r+1r+1r+1 离 iii 的距离比滑动窗口中最左边元素 lll 小，即第 r+1r+1r+1 块石头离 iii 比第 lll 块石头近，此时，将滑动窗口右移一格．重复这个操作，直到上述条件不满足．
接着，比较滑动窗口中最左端的 lll 和最右端的 rrr，这两块石头是滑动窗口中离 iii 最远的两块，比较谁离 iii 更远，更远的一块就是 iii 下一步会跳到的石头．

可以写出代码：

1
#include <bits/stdc++.h>
2
using namespace std;
3
const int N = 1e6 + 1;
4
typedef long long ll;
5
const int INF = 0x3f3f3f3f;
6
ll n, k, m, a[N];
7
int f[60][N];
8
signed main() {
9
    ios::sync_with_stdio(false);
10
    cin.tie(0);
11
    cout.tie(0);
12
    cin >> n >> k >> m;
13
    for (int i = 1; i <= n; i++) {
14
        cin >> a[i];
15
    }
16
    a[n + 1] = INF; // 哨兵
17
    int l = 1, r = k + 1;
18
    for (int i = 1; i <= n; i++) {
19
        while (r < n && a[r + 1] - a[i] < a[i] - a[l]) {
20
            l++;
21
            r++;
22
        }
23
        if (a[i] - a[l] >= a[r] - a[i])
24
            f[0][i] = l;
25
        else
26
            f[0][i] = r;
27
    }
28

29
    for (int i = 1; i <= 59; i++) {
30
        for (int j = 1; j <= n; j++) {
31
            f[i][j] = f[i - 1][f[i - 1][j]];
32
        }
33
    }
34

35
    for (int i = 1; i <= n; i++) {
36
        ll x = i, st = m, wt = 0;
37
        while (st >= 1) {
38
            if (st % 2) {
39
                x = f[wt][x];
40
            }
41
            st /= 2;
42
            wt++;
43
        }
44
        cout << x << ' ';
45
    }
46
}

展开收起

如果这样写，会导致 MLE．具体来说，由于此题的 125MB 内存限制，我们只能存 3×1073\times 10^73×107 个 int 类型变量．而 f 数组中有 60×106=6×10760\times 10^6 = 6\times 10^760×106=6×107 个 int 变量．

此题应该选用滚动倍增数组进行优化．具体来说，省去 f 数组，在计算 aia_iai 时，动态计算当前需要的倍增数组．

标程

1
#include <bits/stdc++.h>
2
#define int long long
3
using namespace std;
4
const int N = 1e6 + 100;
5
typedef long long ll;
6
const ll INF = 2e18;
7
int n, k;
8
ll m, a[N];
9
int nxt[N], cur[N], tmp[N];
10
signed main() {
11
    ios::sync_with_stdio(false);
12
    cin.tie(0);
13
    cout.tie(0);
14
    cin >> n >> k >> m;
15
    for (int i = 1; i <= n; i++) {
16
        cin >> a[i];
17
    }
18
    a[n + 1] = INF;
19
    int l = 1, r = k + 1;
20
    for (int i = 1; i <= n; i++) {
21
        while (r < n && a[r + 1] - a[i] < a[i] - a[l]) {
22
            l++;
23
            r++;
24
        }
25
        if (a[i] - a[l] >= a[r] - a[i])
26
            nxt[i] = l;
27
        else
28
            nxt[i] = r;
29
    }
30

31
    for (int i = 1; i <= n; i++) {
32
        cur[i] = i;
33
    }
34
    while (m >= 1) {
35
        if (m & 1) {
36
            for (int i = 1; i <= n; i++) {
37
                tmp[i] = cur[i];
38
            }
39
            for (int i = 1; i <= n; i++) {
40
                cur[i] = nxt[tmp[i]];
41
            }
42
        }
43
        m /= 2;
44
        for (int i = 1; i <= n; i++)
45
            tmp[i] = nxt[i];
46
        for (int i = 1; i <= n; i++)
47
            nxt[i] = tmp[tmp[i]];
48
    }
49
    for (int i = 1; i <= n; i++) {
50
        cout << cur[i] << ' ';
51
    }
52
}

展开收起

安吉D8-B

Sun, 09 Aug 2026 00:00:00 GMT

原题呈现

B4160 排座位#

题目描述#

有 nnn 个座位，从左到右编号为 1∼n1 \sim n1∼n．现在有 mmm 个小朋友，第 iii 个小朋友可以坐在 l[i]∼r[i]l[i] \sim r[i]l[i]∼r[i] 这些座位上，每个座位至多坐一个人．

现在请问，如果只保留 1∼k1 \sim k1∼k 这些座位，最多可以给多少小朋友安排座位．请你输出 k=1∼nk = 1 \sim nk=1∼n 的所有答案．

例如 n=3,m=3n = 3, m = 3n=3,m=3，333 个小朋友 A,B,CA, B, CA,B,C 的区间为 [2,2],[2,3],[1,3][2, 2], [2, 3], [1, 3][2,2],[2,3],[1,3]：

k=1k = 1k=1 时：一个可行方案为 [C][C][C]，答案为 111；
k=2k = 2k=2 时：一个可行方案为 [C,B][C, B][C,B]，答案为 222；
k=3k = 3k=3 时：一个可行方案为 [C,A,B][C, A, B][C,A,B]，答案为 333；

输入格式#

第一行 222 个整数 n,mn, mn,m 代表座位和小朋友的数量．

接下来 mmm 行，每行 222 个整数 l[i],r[i]l[i], r[i]l[i],r[i] 代表第 iii 个小朋友的意愿区间．

输出格式#

输出 nnn 行，第 kkk 行代表只保留前 1∼k1 \sim k1∼k 个座位之后最多可以给几个小朋友安排座位．

输入输出样例 #1#

输入 #1#

输出 #1#

输入输出样例 #2#

输入 #2#

输出 #2#

数据范围#

对于所有数据，1≤n,m≤2×105,1≤l[i]≤r[i]≤n1 \leq n, m \leq 2 \times 10^5, 1 \leq l[i] \leq r[i] \leq n1≤n,m≤2×105,1≤l[i]≤r[i]≤n．

本题采用捆绑测试，你必须通过子任务中的所有数据点以及其依赖的子任务，才能获得子任务对应的分数．

子任务编号	分值	数据范围	特殊性质	子任务依赖
1	26	n,m≤10n, m \leq 10n,m≤10
2	28	n,m≤100n, m \leq 100n,m≤100		1
3	11	n,m≤5000n, m \leq 5000n,m≤5000	l[i]=r[i]l[i] = r[i]l[i]=r[i]
4	26	n,m≤5000n, m \leq 5000n,m≤5000		1,2,3
5	9	n,m≤2×105n, m \leq 2 \times 10^5n,m≤2×105		1,2,3,4

此题使用贪心．

先考虑第 iii 个座位．对于可能坐在这个座位上的小朋友（即左端点 lll 和右端点 rrr 满足 l≤i≤rl\leq i \leq rl≤i≤r），从这些小朋友中选择最紧急的（即右端点 rrr 最小），坐在当前座位中空闲的且在第 iii 个位置上．如果没有小朋友，那么这个位置只能空着，再去往后考虑第 i+1i+1i+1 个座位．

每次考虑 mmm 个小朋友，需要时间复杂度 O(nm)O(nm)O(nm)，考虑优化．

由于 iii 时升序枚举的，因此显然，对于一个小朋友 jjj，如果它曾经成为过“可能坐在这些座位上的小朋友”（设满足该条件的集合为 sss），即如果在枚举第 iii 个位置的时刻，jjj 开始满足 j∈sj\in sj∈s，那么，不会在后面的时刻，jjj 再次开始满足 j∈sj\in sj∈s．即对于每一个 jjj，最多只会进去 sss 一次，再被删除一次，不会再进去第二次．

因此，可以使用优先队列进行优化．使用一个优先队列记录上述的集合 sss．将所有小朋友按照左端点排序．在遍历到第 iii 个座位时：

将所有满足 l≤il \leq il≤i 且没有进入优先队列的小朋友入队．由于 lll 升序排列，所以，若前一个小朋友没有入队，则后面的小朋友更不可能入队．这里可以使用指针记录．
在当前优先队列中，获得 rrr 最小的小朋友．若该小朋友的 r<ir<ir<i，说明该小朋友“过期”了，将该小朋友出队，重新获取一个新的小朋友．
如果优先队列为空，则当前位置只能空着．否则，我们就找到了一个可以坐在这个位置上的小朋友．将该小朋友出队，并将答案增加一．

标程

1
#include <bits/stdc++.h>
2
using namespace std;
3

4
const int N = 2e5 + 100;
5
int ans = 0;
6

7
struct People {
8
    int l, r;
9
    friend bool operator<(const People a, const People b) {
10
        if (a.l == b.l)
11
            return a.r < b.r;
12
        return a.l < b.l;
13
    }
14
} a[N];
15

16
struct People_Prio {
17
    int l, r;
18
    friend bool operator<(const People_Prio a, const People_Prio b) {
19
        return a.r > b.r;
20
    }
21
};
22

23
int n, m;
24
priority_queue<People_Prio> pq;
25

26
signed main() {
27
    cin >> n >> m;
28
    for (int i = 1; i <= m; i++) {
29
        cin >> a[i].l >> a[i].r;
30
    }
31
    int ptr = 0;
32
    sort(a + 1, a + m + 1);
33
    for (int i = 1; i <= n; i++) {
34
        // 将所有可用的都放入优先队列：
35
        while (ptr != m && a[ptr + 1].l <= i) {
36
            pq.push({a[++ptr].l, a[ptr].r});
37
        }
38
        while (!pq.empty()) {
39
            auto top = pq.top();
40
            pq.pop();
41
            if (top.r < i) {
42
                continue;
43
            }
44
            ans++;
45
            break;
46
        }
47
        cout << ans << endl;
48
    }
49
    return 0;
50
}

展开收起

安吉D8-C

Sun, 09 Aug 2026 00:00:00 GMT

原题呈现

P12247 跳舞机#

题目描述#

小 O 想要经营电 van 城，跳舞机的运营非常重要．

小 O 的电 van 城有一台跳舞机，跳舞机在同一时间至多有一名玩家游玩，每局游戏需要完整且连续地游玩 kkk 分钟．

电 van 城将营业 mmm 分钟．期间有 nnn 名玩家想要游玩跳舞机，编号 1∼n1\sim n1∼n．编号为 iii 的玩家会在营业的第 lil_ili 分钟到第 rir_iri 分钟（包括 lil_ili 和 rir_iri）待在电 van 城，在此期间可以游玩任意局跳舞机．并且，每游玩一局，会产生 wiw_iwi 的兴奋值．注意，如果玩家 iii 要玩一局跳舞机，则每局游戏的 kkk 分钟必须完全包含于玩家的停留时间 [li,ri][l_i,r_i][li,ri]．

小 O 想要最大化所有玩家的兴奋值之和，请你帮他求出最大的兴奋值之和．

输入格式#

输入共 n+1n+1n+1 行．

第一行输入三个整数 n,m,kn,m,kn,m,k，分别表示玩家个数、营业时间、游玩一局跳舞机需要的时间．

第 2∼n+12\sim n+12∼n+1 行，第 i+1i+1i+1 行有三个整数 li,ri,wil_i,r_i,w_ili,ri,wi，表示编号为 iii 的玩家的停留时间和游玩一局产生的兴奋值．

输出格式#

输出共一行一个整数，表示最大的兴奋值之和．

输入输出样例 #1#

输入 #1#

输出 #1#

1
5

输入输出样例 #2#

输入 #2#

输出 #2#

1
9

说明/提示#

样例 #1 解释#

可以让编号为 111 的玩家在第 1∼21\sim21∼2 分钟、第 3∼43\sim 43∼4 分钟玩一局跳舞机，编号为 333 的玩家在第 5∼65\sim 65∼6 分钟玩一局．兴奋值的总和为 1+1+3=51+1+3=51+1+3=5，可以发现没有让兴奋值总和更大的方案．

样例 #2 解释#

可以让编号为 222 的玩家在第 2∼42\sim42∼4 分钟玩一局跳舞机，编号为 333 的玩家在第 5∼75\sim 75∼7 分钟玩一局．兴奋值的总和为 4+5=94+5=94+5=9，可以发现没有让兴奋值总和更大的方案．

数据范围#

对于所有数据，满足：

1≤n,m,k≤5×1051\le n,m,k\le 5\times 10^51≤n,m,k≤5×105；
k≤mk\le mk≤m；
1≤li≤ri≤m1\le l_i\le r_i\le m1≤li≤ri≤m；
1≤wi≤1091\le w_i\le 10^91≤wi≤109．

设 Li=ri−li+1L_i=r_i-l_i+1Li=ri−li+1，则具体测试点限制如下：

测试点编号	nnn 的范围	mmm 的范围	特殊性质
1∼31\sim 31∼3	n≤5n\le 5n≤5	m≤10m\le 10m≤10	wi≤20w_i\le 20wi≤20
4∼64\sim 64∼6	n≤105n\le 10^5n≤105	m≤105m\le 10^5m≤105	Li=k=1L_i=k=1Li=k=1
7∼107\sim107∼10	n≤1000n\le 1000n≤1000	m≤1000m\le 1000m≤1000	无
11∼1311\sim 1311∼13	n≤105n\le 10^5n≤105	m≤105m\le 10^5m≤105	Li=kL_i=kLi=k
14∼1614\sim 1614∼16	n≤100n\le 100n≤100	m≤105m\le 10^5m≤105	无
17∼2017\sim 2017∼20	n≤105n\le 10^5n≤105	m≤105m\le 10^5m≤105	wi=1w_i=1wi=1
21,2221,2221,22	n≤105n\le 10^5n≤105	m≤105m\le 10^5m≤105	无
23∼2523\sim 2523∼25	n≤5×105n\le 5\times 10^5n≤5×105	m≤5×105m\le 5\times 10^5m≤5×105	无

此题使用 dp．

定义状态 dp[i] 表示到第 iii 分钟结束时的最大收益．（这样定义状态的方法叫做依照问题法．在实践中，我们可以依照题目所求的内容来制定状态）

不难发现初始状态：

1
dp[0] = 0;

由于此题推进时间或赢得分数的途径只有：

让一个人玩跳舞机
让跳舞机闲置

，因此不难发现转移方程：

dpi=max⁡{max⁡jlj≤i−k<i≤rj(dpi−k+wj),dpi−1}dp_i = \max\{\max_{j}^{l_j\leq i-k < i \leq r_j} (dp_{i-k} + w_j),dp_{i-1}\}dpi=max{jmaxlj≤i−k<i≤rj(dpi−k+wj),dpi−1}

这个转移方程是 O(n2)O(n^2)O(n2) 的，如何优化？

将转移方程变形为：

dpi=max⁡{dpi−k+max⁡jlj≤i−k<i≤rjwj,dpi−1}dp_i = \max\{dp_{i-k} + \max_{j}^{l_j\leq i-k < i \leq r_j} w_j,dp_{i-1}\}dpi=max{dpi−k+jmaxlj≤i−k<i≤rjwj,dpi−1}

加下来，只需要算出：

d=max⁡jlj≤i−k<i≤rjwjd=\max_{j}^{l_j\leq i-k < i \leq r_j} w_jd=jmaxlj≤i−k<i≤rjwj

即可．

由于 iii 在枚举时是递增的，所以可以使用优先队列优化．使用一个优先队列，其中储存所有可能在当前时刻恰好结束一局跳舞机的玩家（即呆在电玩城中的时间大于等于 kkk）．

将所有的玩家按照来的顺序排序．每当遍历到时刻 iii 时，将所有第 i−k+1i-k+1i−k+1 这个时刻进入电玩城的玩家加入优先队列，这些玩家有可能在第 iii 秒结束时正好结束一局跳舞机（从第 i−k+1i-k+1i−k+1 到第 iii 秒）．

然后，在优先队列中获取 www 最高的一名玩家，如果该玩家已经离开电玩城了（即 ri<ir_i < iri<i），那么将该玩家从优先队列中删去，重新选取一名 www 最高的玩家．让该玩家在 i−k+1i-k+1i−k+1 到 iii 这一段时间里游玩跳舞机．这名玩家的 www 就是上面需要算出的 ddd．

标程

1
#include <bits/stdc++.h>
2
using namespace std;
3
typedef long long ll;
4
const int N = 5e5 + 100;
5
struct People {
6
    int l, r, w;
7
    friend bool operator<(const People a, const People b) { return a.w < b.w; }
8
} a[N];
9

10
priority_queue<People> pq;
11
int n, m, k;
12
ll f[N];
13

14
signed main() {
15
    cin >> n >> m >> k;
16
    for (int i = 1; i <= n; i++) {
17
        cin >> a[i].l >> a[i].r >> a[i].w;
18
    }
19
    sort(a + 1, a + n + 1,
20
         [](const People a, const People b) { return a.l < b.l; });
21
    int ptr = 0;
22
    for (int i = 1; i <= m; i++) {
23
        while (ptr != n && a[ptr + 1].l <= i - k + 1) {
24
            pq.push(a[++ptr]);
25
        }
26
        f[i] = f[i - 1];
27
        while (!pq.empty()) {
28
            People top = pq.top();
29
            if (top.r < i) {
30
                pq.pop();
31
                continue;
32
            }
33
            f[i] = max(f[i], f[i - k] + top.w);
34
            break;
35
        }
36
    }
37
    cout << f[m];
38
    return 0;
39
}

展开收起

安吉D8-D

Sun, 09 Aug 2026 00:00:00 GMT

原题呈现

P13037 Hidden Pancakes#

题目描述#

我们总共要烹饪 N\mathbf{N}N 张煎饼．这些煎饼的半径分别为 111 厘米（cm）、2 cm2 \mathrm{~cm}2 cm、3 cm3 \mathrm{~cm}3 cm，……，以及 Ncm\mathbf{N} \mathrm{cm}Ncm，但烹饪顺序不一定按半径从小到大排列．烹饪完第一张煎饼后，我们直接将其放在盘子上．之后每烹饪完一张煎饼，就将其叠放在之前所有煎饼的最上方，且所有煎饼的中心对齐．这样，每张煎饼在刚被加入时都能从顶部被看到．只有当之后烹饪了比它半径更大的煎饼时，这张煎饼才会被隐藏．

例如，假设我们烹饪 4 张煎饼．首先烹饪半径为 3 cm3 \mathrm{~cm}3 cm 的煎饼，此时它可见．接着烹饪半径为 1 cm1 \mathrm{~cm}1 cm 的煎饼，叠放在第一张煎饼上，此时两张煎饼都可见．然后烹饪半径为 2 cm2 \mathrm{~cm}2 cm 的煎饼，它会覆盖前一张煎饼（半径为 1 cm1 \mathrm{~cm}1 cm 的煎饼），但不会覆盖第一张煎饼，因此此时共有 2 张煎饼可见．最后，烹饪半径为 4 cm4 \mathrm{~cm}4 cm 的煎饼，它会覆盖所有其他煎饼，此时只有 1 张煎饼可见．下图展示了每张煎饼被烹饪后叠放的状态，其中完全不透明的煎饼表示可见，半透明的煎饼表示不可见．

设 Vi\mathbf{V}_{\mathbf{i}}Vi 表示叠放了恰好 iii 张煎饼时可见的煎饼数量．在上面的例子中，V1=1\mathbf{V}_{1}=1V1=1、V2=2\mathbf{V}_{2}=2V2=2、V3=2\mathbf{V}_{3}=2V3=2、V4=1\mathbf{V}_{4}=1V4=1．

给定列表 V1,V2,…,VN\mathbf{V}_{1}, \mathbf{V}_{2}, \ldots, \mathbf{V}_{\mathbf{N}}V1,V2,…,VN，问在所有 N!\mathbf{N} !N! 种可能的烹饪顺序中，有多少种顺序能恰好得到给定的 Vi\mathbf{V}_{\mathbf{i}}Vi 序列？由于结果可能非常大，只需输出结果对质数 109+710^{9}+7109+7（即 100000000710000000071000000007）取模后的值．

输入格式#

输入的第一行包含测试用例数量 T\mathbf{T}T．每个测试用例包含两行：第一行是一个整数 N\mathbf{N}N，表示烹饪的煎饼数量；第二行包含 N\mathbf{N}N 个整数 V1,V2,…,VN\mathbf{V}_{1}, \mathbf{V}_{2}, \ldots, \mathbf{V}_{\mathbf{N}}V1,V2,…,VN，分别表示叠放了 1,2,…,N1, 2, \ldots, \mathbf{N}1,2,…,N 张煎饼时的可见煎饼数量．

输出格式#

对于每个测试用例，输出一行 Case #x: y，其中 xxx 是测试用例编号（从 1 开始），yyy 是满足条件的烹饪顺序数量对 109+710^{9}+7109+7 取模后的结果．

输入输出样例 #1#

输入 #1#

输出 #1#

1
Case #1: 1
2
Case #2: 2
3
Case #3: 0

输入输出样例 #2#

输入 #2#

1
1
2
24
3
1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2

输出 #2#

1
Case #1: 234141013

说明/提示#

样例解释

样例 #1 已在题目描述中说明，唯一的满足条件的烹饪顺序是 3,1,2,43,1,2,43,1,2,4．

在样例 #2 中，顺序 1,3,21,3,21,3,2 和 2,3,12,3,12,3,1 均能满足给定的 Vi\mathbf{V}_{\mathbf{i}}Vi 序列．下图展示了这两种情况：

在样例 #3 中，叠加第二张煎饼后只有 1 张煎饼可见，因此无法通过叠加第三张煎饼使可见煎饼数量超过 2．

样例测试集 2 符合测试集 2 的限制条件，但提交的解法不会实际运行该测试集．

在测试集 2 的样例中，共有 316234143225316234143225316234143225 种烹饪顺序满足给定的 Vi\mathbf{V}_{\mathbf{i}}Vi 序列，对 109+710^{9}+7109+7 取模后的结果是 234141013234141013234141013．

限制条件

1≤T≤1001 \leq \mathbf{T} \leq 1001≤T≤100．
对于所有 iii，1≤Vi≤i1 \leq \mathbf{V}_{\mathbf{i}} \leq i1≤Vi≤i．

测试集 1（可见判定）

时间限制：30 秒．
2≤N≤132 \leq \mathbf{N} \leq 132≤N≤13．

测试集 2（隐藏判定）

时间限制：40 秒．
2≤N≤1052 \leq \mathbf{N} \leq 10^{5}2≤N≤105．

直接解决问题有些难度，我们先不要想着如何确定所有煎饼的位置，先想想如何确定最大煎饼（即半径为 N 的煎饼）的位置．

显然，当最大煎饼铺在盘子上时，可见的煎饼数量一定为 1，只能看见最大煎饼．而且之后的煎饼无法覆盖这张煎饼，故后面的可见煎饼数量必然大于 1．因此，我们得知：最大的煎饼就处于 vvv 序列中最后一个 1 的位置．

得知了最大煎饼，又有什么用呢？我们知道，最大煎饼会把所有的煎饼分成上面和下面两个部分，由于有最大煎饼的阻隔，上下两个部分互不干涉，分成了两个子问题．在子问题中，我们也可以获取子区间内最后一个 1 的位置，这是子区间内的最大煎饼（当然，如果该子区间在父问题中在上面，则该区间内的每一个数字被增加了 1，即父问题中的最大煎饼是可见的，因此，此时需要查询的是子区间内最后一个 1 的位置）

一般的，对于一个子问题，它需要得到 [l,r][l,r][l,r] 之间煎饼排列的方案数，其会存在一个权值 www．解决子问题的操作如下（设该子问题中煎饼数量为 x=r−l+1x=r-l+1x=r−l+1）：

找出当前区间中最小的元素 v[k]v[k]v[k]，如果 v[k]≠wv[k]\neq wv[k]=w，说明没有方案，返回 0．
依照这个最小的元素进行分割，可以分成上子问题和下子问题，上子问题的权值为 w+1w+1w+1（因为有煎饼 kkk 的存在），下子问题的权值为 www．若上子问题和下子问题的答案分别为 aaa 和 bbb，且上子问题的煎饼数量为 yyy，那么答案相当于在一共的 xxx 个煎饼中选择 yyy 个放在上子区间，为 (xy)×a×b\binom{x}{y}\times a\times b(yx)×a×b．
边界情况，若该子问题中煎饼数量为 1，则表明只有 1 种情况．

一般的，根问题（最大的问题）的权值为 1．

1
#include <bits/stdc++.h>
2
using namespace std;
3
#define int long long
4
const int N = 1e5 + 100;
5
const int MOD = 1e9 + 7;
6
int n, fac[N];
7

8
struct Node {
9
    int v, id;
10
    friend bool operator<(const Node a, const Node b) {
11
        if (a.v == b.v)
12
            return a.id > b.id;
13
        return a.v < b.v;
14
    }
15
};
16

17
Node v[N];
18
struct ST {
19
    Node mn[18][N];
20
    Node *a;
21
    int size;
22
    void init(Node *a, int size) {
23
        this->a = a;
24
        memset(mn, 0x3f, sizeof(mn));
25
        for (int i = 1; i <= size; i++) {
26
            mn[0][i] = a[i];
27
        }
28
        for (int j = 1; j <= 16; j++) {
29
            for (int i = 1; i <= size; i++) {
30
                mn[j][i] = min(mn[j - 1][i], mn[j - 1][i + (1 << (j - 1))]);
31
            }
32
        }
33
    }
34
    Node qry(int l, int r) {
35
        int len = log2(r - l + 1);
36
        return min(mn[len][l], mn[len][r - (1 << len) + 1]);
37
    }
38
} st;
39

40
int fastPow(int a, int p) {
41
    int ans = 1, cur = a;
42
    while (p >= 1) {
43
        if (p & 1) {
44
            (ans *= cur) %= MOD;
45
        }
46
        (cur *= cur) %= MOD;
47
        p /= 2;
48
    }
49
    return ans;
50
}
51

52
int inv(int x) { return fastPow(x, MOD - 2); }
53

54
int calFac(int x) {
55
    if (!fac[x]) {
56
        fac[x] = calFac(x - 1) * x % MOD;
57
    }
58
    return fac[x];
59
}
60

61
int calC(int from, int select) {
62
    if (select == 0 || from == select)
63
        return 1;
64
    return calFac(from) * inv(calFac(select)) % MOD *
65
           inv(calFac(from - select)) % MOD;
66
}
67

68
int solve_sub(int l, int r, int lower) {
69
    // cout << "DEBA " << l << "~" << r << endl;
70
    if (l > r)
71
        return 1;
72
    Node nd = st.qry(l, r);
73
    if (nd.v != lower) {
74
        return 0;
75
    }
76
    if (l == r) {
77
        return 1;
78
    }
79
    int mid = nd.id;
80
    int upper = r - mid;
81
    int ways = calC(r - l, upper);
82
    // cout << "DEBB " << l << "~" << r << ": " << mid << " " << ways << " "
83
    // << lower << " " << nd.v << endl;
84
    int left = solve_sub(l, mid - 1, lower);
85
    int right = solve_sub(mid + 1, r, lower + 1);
86
    return left * right % MOD * ways % MOD;
87
}
88

89
void solve(int id) {
90
    cin >> n;
91
    for (int i = 1; i <= n; i++) {
92
        cin >> v[i].v;
93
        v[i].id = i;
94
    }
95
    st.init(v, n);
96
    cout << "Case #" << id << ": " << solve_sub(1, n, 1) << endl;
97
}
98

99
signed main() {
100
    int T;
101
    cin >> T;
102
    fac[0] = 1;
103
    for (int i = 1; i <= T; i++)
104
        solve(i);
105
    return 0;
106
}

展开收起

安吉D9 模考5总结

Sun, 09 Aug 2026 00:00:00 GMT

得分情况#

预期得分：100+40+15+0

实际得分：100+60+15+0

Time Line#

8<30>~8<46> 看题
8<46>~9<16> 切 T1
9<16>~10<40> 写 T2
10<40>~12<00> 写 T3

挂分原因#

无挂分部分

收获#

增进了多层图的技巧
认识到了一种新的贪心技巧

安吉D9-T2

Sun, 09 Aug 2026 00:00:00 GMT

原题呈现

P4447 分组#

题目描述#

小可可的学校信息组总共有 nnn 个队员，每个人都有一个实力值 aia_iai．现在，一年一度的编程大赛就要到了，小可可的学校获得了若干个参赛名额，教练决定把学校信息组的 nnn 个队员分成若干个小组去参加这场比赛．

但是每个队员都不会愿意与实力跟自己过于悬殊的队员组队，于是要求分成的每个小组的队员实力值连续，同时，一个队不需要两个实力相同的选手．举个例子：[1,2,3,4,5][1, 2, 3, 4, 5][1,2,3,4,5] 是合法的分组方案，因为实力值连续；[1,2,3,5][1, 2, 3, 5][1,2,3,5] 不是合法的分组方案，因为实力值不连续；[0,1,1,2][0, 1, 1, 2][0,1,1,2] 同样不是合法的分组方案，因为出现了两个实力值为 111 的选手．

如果有小组内人数太少，就会因为时间不够而无法获得高分，于是小可可想让你给出一个合法的分组方案，满足所有人都恰好分到一个小组，使得人数最少的组人数最多，输出人数最少的组人数的最大值．

注意：实力值可能是负数，分组的数量没有限制．

输入格式#

输入有两行：

第一行一个正整数 nnn，表示队员数量．

第二行有 nnn 个整数，第 iii 个整数 aia_iai 表示第 iii 个队员的实力．

输出格式#

输出一行，包括一个正整数，表示人数最少的组的人数最大值．

输入输出样例 #1#

输入 #1#

1
7
2
4 5 2 3 -4 -3 -5

输出 #1#

1
3

说明/提示#

样例解释#

分为 222 组，一组的队员实力值是 [4,5,2,3][4, 5, 2, 3][4,5,2,3]，一组是 [−4,−3,−5][-4, -3, -5][−4,−3,−5]，其中最小的组人数为 333，可以发现没有比 333 更优的分法了．

数据范围#

对于 100%100\%100% 的数据满足：1≤n≤1051\leq n\leq 10^51≤n≤105，∣ai∣≤109|a_i|\leq10^9∣ai∣≤109．

本题共 101010 个测试点，编号为 1∼101\sim101∼10，每个测试点额外保证如下：

测试点编号	数据限制
1∼21\sim21∼2	n≤6,1≤ai≤100n\leq 6, 1\leq a_i \leq 100n≤6,1≤ai≤100
3∼43\sim43∼4	n≤1000,1≤ai≤105n\leq 1000, 1\leq a_i\leq 10^5n≤1000,1≤ai≤105 且 aia_iai 互不相同
5∼65\sim65∼6	n≤105n\leq 10^5n≤105，aia_iai 互不相同
7∼87\sim87∼8	n≤105,1≤ai≤105n\leq 10^5, 1\leq a_i \leq10^5n≤105,1≤ai≤105
9∼109\sim 109∼10	n≤105,−109≤ai≤109n\leq 10^5, -10^9 \leq a_i \leq 10^9n≤105,−109≤ai≤109

此题使用贪心．

考虑下面这个情景：有一些人已经分好了组，每一组可以看作一条链，每一条链都单调递增，且公差为 1．现在，来了一个实力值正好同时可以接在这几条链末尾的人．此时，不难发现贪心策略：将这个人放在最短的链末尾．

依照这个策略，我们可以建立一个优先队列，用于存储以当前值减一为末尾的链的长度．在读取输入时，记录每个权值和对应的人数，接下来，从小到大遍历每一个权值 iii：

对于每一个权值为 iii 的人：可以接在当前处于优先队列中的最短的链上．更新长度，并将长度移动到第二个优先队列（该队列用于保存已经吸纳了当前权值的人的小组，即以当前值为末尾的链）．
在遍历完该权值的所有人之后，如果有一组没有收集到该权值的任意一个人（即还留在第一个优先队列），那么该链断裂，不能再吸纳更多的人．将其与答案取最小值，并删除这一条链．
将所有存于第二个优先队列的链移动到第一个．

标程：

1
#include <bits/stdc++.h>
2
using namespace std;
3
const int N = 1e5 + 100;
4
int n, a[N], ans = 1e9 + 10;
5
priority_queue<int> us[2];
6

7
struct Node {
8
    int v, num;
9
    friend bool operator<(const Node a, const Node b) { return a.v < b.v; }
10
} d[N];
11

12
void clear(int idx) {
13
    while (!us[idx].empty()) {
14
        ans = min(ans, -us[idx].top());
15
        us[idx].pop();
16
    }
17
}
18

19
signed main() {
20
    cin >> n;
21
    int cnt = 0;
22
    for (int i = 1; i <= n; i++) {
23
        cin >> a[i];
24
    }
25
    sort(a + 1, a + n + 1);
26
    for (int i = 1; i <= n; i++) {
27
        if (a[i] == a[i - 1]) {
28
            d[cnt].num++;
29
        } else {
30
            d[++cnt].v = a[i];
31
            d[cnt].num = 1;
32
        }
33
    }
34
    for (int i = 1; i <= cnt; i++) {
35
        int now = i & 1, pre = (i - 1) & 1;
36
        if (d[i].v != d[i - 1].v + 1) {
37
            clear(pre);
38
        }
39
        for (int j = 1; j <= d[i].num; j++) {
40
            if (us[pre].empty()) {
41
                us[now].push(-1);
42
            } else {
43
                int top = us[pre].top();
44
                us[pre].pop();
45
                us[now].push(top - 1);
46
            }
47
        }
48
        clear(pre);
49
    }
50
    clear(0);
51
    clear(1);
52
    cout << ans;
53
    return 0;
54
}

展开收起

安吉D9-T3

Sun, 09 Aug 2026 00:00:00 GMT

原题呈现

P1688 新单词接龙问题#

题目描述#

给定一个包含 nnn 个单词的字典，定义字典序为单词在这本字典的顺序．从中选择若干个单词，按字典序进行单词接龙，使得接龙的长度最大．

新单词接龙的规则：

单词变换：单词 wiw_iwi 添加一个字母，删除一个字母，或修改一个字母可以得到单词 wi+1w_{i+1}wi+1；
字典序接龙：w1,w2,⋯ ,wnw_1,w_2,\cdots,w_nw1,w2,⋯,wn，满足字典序．

输入格式#

第一行一个整数 nnn（1≤n≤25,0001 \le n \le 25,0001≤n≤25,000），表示字典中单词的总数．接下来 nnn 行，按字典序输入 nnn 个单词，每行一个字符串，表示单词，单词仅由小写字母组成，长度在 111 至 161616 以内．

输出格式#

输出一行一个整数，表示能获得的单词接龙的最大长度．

输入输出样例 #1#

输入 #1#

1
9
2
cat
3
dig
4
dog
5
fig
6
fin
7
fine
8
fog
9
log
10
wine

输出 #1#

1
5

说明/提示#

样例解释#

长度为 555 的单词接龙为：dig→fig→fin→fine→wine\texttt{dig}\to \texttt{fig}\to \texttt{fin}\to \texttt{fine}\to\texttt{wine}dig→fig→fin→fine→wine．

此题动态规划．类似最长上升子序列问题，定义 f[n] 表示以 nnn 结尾的字符串最长的接龙长度．

观察到字符串的长度很小，远小于 nnn．因此，对于此题，我们在转移时不选择枚举之前的所有字符串，而是选择枚举所有能够通过一次修改转移到当前字符串的前置字符串．具体来说：

枚举每一个字符串 iii，在枚举时，遍历所有可能的前置字符串（相对 iii 多一个字符、少一个字符、改一个字符），并在前面所有枚举过的给定字符串中查找，如果存在这样的前置字符串 jjj，则说明 iii 可以接在 jjj 后面，可以转移：将 f[i] = f[j] + 1．

这样的算法枚举前置字符串的复杂度为 O(53L)O(53L)O(53L)，每一次比较是 O(L)O(L)O(L)，总复杂度是 O(53L2n2)O(53L^2n^2)O(53L2n2) 的，．

考虑优化枚举前面的字符串，可以使用 unordered_map umumum 存储前面所有遍历过的给定字符串对应的 f 值，直接在 umumum 中查找，这样的时间复杂度是 O(53L2n)O(53L^2n)O(53L2n) 的．

考虑使用哈希优化，这样判断两个字符串相等就可以在 O(1)O(1)O(1) 的复杂度内完成，时间复杂度 O(53Ln)O(53Ln)O(53Ln)．

由于此题字符串比较多，推荐使用 unsigned long long 自然溢出来实现哈希，不易冲突的同时且能够做到时间常数较小．

1
#include <bits/stdc++.h>
2
using namespace std;
3
typedef unsigned long long ull;
4
const int N = 25005;
5
const int BASE = 129;
6
int m, f[N], ans;
7
string s[N];
8
unordered_map<ull, int> um;
9
ull h[N], p[N];
10

11
// l,r 1-based
12
ull H(int l, int r) {
13
    if (l > r)
14
        return 0;
15
    return h[r] - h[l - 1] * p[r - l + 1];
16
}
17

18
signed main() {
19
    cin >> m;
20
    p[0] = 1;
21
    for (int i = 1; i <= 20; i++) {
22
        p[i] = p[i - 1] * BASE;
23
    }
24
    for (int q = 1; q <= m; q++) {
25
        string s;
26
        cin >> s;
27

28
        int len = s.size();
29

30
        for (int i = 1; i <= len; i++) {
31
            h[i] = h[i - 1] * BASE + s[i - 1];
32
        }
33

34
        f[q] = 1;
35

36
        // 增加一个
37
        for (int i = 0; i <= len; i++) {
38
            for (char c = 'a'; c <= 'z'; c++) {
39
                ull hs =
40
                    H(1, i) * p[len - i + 1] + c * p[len - i] + H(i + 1, len);
41
                if (um.count(hs))
42
                    f[q] = max(f[q], f[um[hs]] + 1);
43
            }
44
        }
45
        // 删除一个
46
        for (int i = 1; i <= len; i++) {
47
            ull hs = H(1, i - 1) * p[len - i] + H(i + 1, len);
48
            if (um.count(hs))
49
                f[q] = max(f[q], f[um[hs]] + 1);
50
        }
51
        // 修改一个
52
        for (int i = 1; i <= len; i++) {
53
            for (char c = 'a'; c <= 'z'; c++) {
54
                ull hs = H(1, i - 1) * p[len - i + 1] + c * p[len - i] +
55
                         H(i + 1, len);
56
                if (um.count(hs))
57
                    f[q] = max(f[q], f[um[hs]] + 1);
58
            }
59
        }
60

61
        ans = max(ans, f[q]);
62

63
        um[H(1, len)] = q;
64
    }
65
    cout << ans;
66
    return 0;
67
}

展开收起

安吉D6-T4

Fri, 07 Aug 2026 00:00:00 GMT

原题呈现

题目描述#

你需要维护一个序列，初始长度为 nnn．序列中的每个元素带有两个标记：权值 aia_iai 和颜色 cic_ici．

本题要求强制在线．

接下来有 mmm 次操作：

1 l r x：仅关注下标在 [l,r][l, r][l,r] 内的元素．把其中权值不大于 xxx 的元素按原下标递增顺序取出来，形成一个子序列．对于这个子序列，若相邻两个元素颜色相同，则认为它们属于同一段．求这个子序列共有多少段．
2 x y：在序列尾部插入一个新的元素，其权值为 xxx，颜色为 yyy．

例如：某次查询得到的颜色序列为

[1,4,4,6,6,6,2,5,5][1,4,4,6,6,6,2,5,5][1,4,4,6,6,6,2,5,5]

那么会被分成

[1],[4,4],[6,6,6],[2],[5,5][1], [4,4], [6,6,6], [2], [5,5][1],[4,4],[6,6,6],[2],[5,5]

共 555 段．

输入格式#

从文件 subsequence.in 中读入数据．

第一行三个整数 n,m,kn, m, kn,m,k，分别表示序列的初始长度、操作次数和是否强制在线．

接下来两行，第一行 nnn 个整数，表示 aia_iai；第二行 nnn 个整数，表示 bib_ibi（即颜色 cic_ici）．

接下来 mmm 行，每行首先一个整数 ttt，表示本次操作的种类．

若 t=1t=1t=1，接下来三个整数 l,r,xl, r, xl,r,x，描述一次查询．
若 t=2t=2t=2，接下来两个整数 x,yx, yx,y，描述一次插入．

对于 k=0k=0k=0，不要求强制在线．对于 k=1k=1k=1，要求输入的 l,r,x,yl, r, x, yl,r,x,y 均对上一次查询的结果按位异或，即 l′=l⊕ansl' = l \oplus ansl′=l⊕ans，若上一次查询不存在，则 ans = 0．

解码方式示例：

1
int n, m, k;
2
cin >> n >> m >> k;
3
for (int i = 1 ; i <= m ; i++) {
4
    cin >> t;
5
    if (t == 1) {
6
        int l, r, x;
7
        cin >> l >> r >> x;
8
        l ^= ans * k;
9
        r ^= ans * k;
10
        x ^= ans * k;
11
    } else {
12
        int x, y;
13
        cin >> x >> y;
14
        x ^= ans * k;
15
        y ^= ans * k;
16
    }
17
}

展开收起

输出格式#

输出到文件 subsequence.out 中．

对于每个操作 111，每行输出一个整数表示查询的结果．

样例#

样例输入 #1#

1
10 10 0
2
6 8 5 9 6 10 2 4 8 9
3
2 4 3 3 4 1 2 3 3 2
4
1 7 9 7
5
1 1 4 4
6
2 2 8
7
2 1 6
8
2 10 2
9
2 10 8
10
2 8 4
11
2 3 10
12
1 5 16 5
13
1 4 14 7

样例输出 #1#

样例输入 #2#

1
10 20 0
2
2 19 13 20 7 19 17 8 15 12
3
1 2 4 3 5 3 2 4 2 2
4
2 9 3
5
1 1 9 15
6
2 17 3
7
1 1 12 3
8
2 15 5
9
1 6 13 6
10
2 7 1
11
2 20 3
12
2 10 1
13
1 5 9 4
14
1 1 7 15
15
2 12 1
16
2 7 5
17
2 12 4
18
1 3 18 6
19
1 12 12 14
20
1 7 7 1
21
2 8 5
22
1 6 8 10
23
1 14 18 4

展开收起

样例输出 #2#

数据范围#

对于 100%100\%100% 的数据，保证：

1≤n,m≤3×1051 \le n, m \le 3 \times 10^51≤n,m≤3×105；
0≤k≤10 \le k \le 10≤k≤1；
1≤op≤21 \le op \le 21≤op≤2；
1≤l,r≤n1 \le l, r \le n1≤l,r≤n（解码后）；
1≤ai,ci,x,y≤1091 \le a_i, c_i, x, y \le 10^91≤ai,ci,x,y≤109．

子任务#

本题采用捆绑测试，你必须通过子任务内所有测试点才能获得该子任务分数．

测试点编号	n,m≤n, m \len,m≤	特殊性质
1∼101 \sim 101∼10	10310^3103	无
11∼2011 \sim 2011∼20	10510^5105	无
21∼3021 \sim 3021∼30	3×1053\times10^53×105	k=0k=0k=0
31∼4031 \sim 4031∼40	3×1053\times10^53×105	操作 111 的 l=1l=1l=1
41∼5041 \sim 5041∼50	3×1053\times10^53×105	无

涉及到区间查询，单点修改，考虑使用树状数组或是线段树，但这道题并非简单的求区间和，于是选择使用线段树．

对于线段树的每一个节点，我们记录一个 vector，vector 中的每一个元素是一个四元组 [x, lcol, rcol, cnt]，

x 为选择的权值．
lcol 是选择权值为 x 时，该区间最左端有效元素的颜色．
rcol 是选择权值为 x 时，该区间最右端有效元素的颜色．
cnt 是选择权值为 x 时，该区间所有有效元素一共能组成多少段．

将这个四元组类型定义为结构体 Node．将包含 Node 的 vector 定义为类 Nodes．Nodes 即为线段树中每一个端点的数据类型．

对于该区间内每一个可能的 x，都建一个 Node，保存在该区间节点的 Nodes 中．

对于两个 Node a,ba,ba,b 之间的合并，可以表示为：

对于 x，取 max⁡{a.x,b.x}\max\{a.x,b.x\}max{a.x,b.x}．
对于 lcol，取 a.lcola.lcola.lcol．
对于 rcol，取 b.rcolb.rcolb.rcol．
对于 cnt，
- 若 a.rcol=b.lcola.rcol = b.lcola.rcol=b.lcol，即两个节点中间部分的颜色可以合并成一大段，答案取 a.cnt+b.cnt−1a.cnt + b.cnt-1a.cnt+b.cnt−1．
- 否则，取 a.cnt+b.cnta.cnt + b.cnta.cnt+b.cnt．

1
friend Node operator+(const Node a, const Node b) {
2
  // 对于所有权值为 0 的点，我们定义它为空 (null)，一个 Node 加上空还是该 Node
3
  if (a.x == 0)
4
    return b;
5
  if (b.x == 0)
6
    return a;
7
  Node ans;
8
  ans.x = max(a.x, b.x);
9
  ans.lcol = a.lcol;
10
  ans.rcol = b.rcol;
11
  ans.cnt = a.cnt + b.cnt - (a.rcol == b.lcol);
12
  return ans;
13
}

对于两个 Nodes m,nm,nm,n（显然，m,nm,nm,n 中的元素按照 .x.x.x 升序排列）需要合并到 kkk，可以采用类似归并排序的方法．其宗旨为：

对于每一个存在于 mmm 中的四元组 iii，查找 nnn 中最后一个四元组 jjj 满足 i.x≥j.xi.x \geq j.xi.x≥j.x．此时 jjj 中统辖的所有元素权值是节点 nnn 所代表区间中所有小于等于 i.xi.xi.x 的元素．将这两个四元组合并，加入到 kkk 中，对于每一个存在于 nnn 中的四元组也是如此．

在程序中，我们使用双指针，指针 iii 指向 mmm，指针 jjj 指向 nnn．初始时，i,ji,ji,j 都指向 m,nm,nm,n 第一个元素的前一个位置．在每一次循环时，我们需要决定主场节点：

检查两个指针是否指向了两个 vector 的最后一个元素．
- 若都指向，结束循环．
- 若指针 iii 指向了 mmm 的最后一个元素，则主场节点为 nnn．
- 若指针 jjj 指向了 nnn 的最后一个元素，则主场节点为 mmm．
- 若以上情况都不满足，则比较指针 iii 指向的下一个元素 ppp 和指针 jjj 指向的下一个元素 qqq 的大小
  - 若 p<qp<qp<q 则主场节点为 nnn．
  - 若 p>qp>qp>q 则主场节点为 mmm．
  - 否则，主场节点同时为 m,nm,nm,n．
在决定主场节点之后，将主场节点对应的指针向后移动一次．
最后，将 iii 指向的元素和 jjj 指向的元素合并，加入节点 kkk．

1
friend Nodes operator+(const Nodes a, const Nodes b) {
2
  Nodes ans;
3
  ans.l = a.l;
4
  ans.r = b.r;
5
  int i = -1, j = -1;
6
  while (true) {
7
    Node tmp;
8
    bool isInEndA = i + 1 >= a.size();
9
    bool isInEndB = j + 1 >= b.size();
10
    if (isInEndA && isInEndB)
11
      break;
12
    if (isInEndB || (!isInEndA && a[i + 1].x < b[j + 1].x)) {
13
      i++;
14
      tmp = a[i];
15
      if (j != -1) {
16
        tmp = tmp + b[j];
17
      }
18
    } else if (isInEndA || a[i + 1].x > b[j + 1].x) {
19
      j++;
20
      tmp = b[j];
21
      if (i != -1) {
22
        tmp = a[i] + tmp;
23
      }
24
    } else {
25
      i++;
26
      j++;
27
      tmp = a[i] + b[j];
28
    }
29
    ans.push_back(tmp);
30
  }
31
  return ans;
32
}

展开收起

建树和修改的代码和普通线段树大差不差，因为没有区间修改，所以都不需要 pushup．

由于最多会有 mmm 次插入操作，所以要预留出这些空间．线段树的大小要开 m+nm+nm+n．

1
void build(int t, int l, int r) {
2
  f[t].l = l, f[t].r = r;
3
  if (l == r) {
4
    if (l > n) { // 大于 n 的点当前还是空的
5
      return;
6
    }
7
    Node nd;
8
    nd.x = a[l];
9
    nd.lcol = b[l];
10
    nd.rcol = b[l];
11
    nd.cnt = 1;
12
    f[t].push_back(nd);
13
    return;
14
  }
15
  int mid = (l + r) / 2;
16
  build(t * 2, l, mid);
17
  build(t * 2 + 1, mid + 1, r);
18
  pushup(t);
19
}
20
void pushup(int t) { f[t] = f[t * 2] + f[t * 2 + 1]; }
21
void Modify(int t, int pos, int a, int b) {
22
  if (f[t].l == pos && f[t].r == pos) {
23
    f[t].push_back({a, b, b, 1});
24
    return;
25
  }
26
  if (f[t].l > pos || f[t].r < pos) {
27
    return;
28
  }
29
  Modify(t * 2, pos, a, b);
30
  Modify(t * 2 + 1, pos, a, b);
31

32
  pushup(t);
33
}

展开收起

至于查询操作，需要注意：

若当前区间被查询区间完全覆盖，则需要使用 upper_bound 找到当前 Nodes 中所有的 Node，满足权值 xxx 小于等于查询权值 qxqxqx，其中权值最大的一个．将这个节点返回．
若当前区间和查询区间完全没有交集，则返回一个空的 Node（在本程序中，权值为 0 的 Node 为空的 Node，权值默认为 0），表示什么都没有．

1
Node Query(int t, int x, int y, int tgt) {
2
  if (f[t].l >= x && f[t].r <= y) {
3
    auto it = upper_bound(f[t].begin(), f[t].end(), tgt);
4
    if (it == f[t].begin())
5
      return Node();
6
    return *(it - 1);
7
  }
8
  if (f[t].l > y || f[t].r < x) {
9
    return Node();
10
  }
11
  return Query(t * 2, x, y, tgt) + Query(t * 2 + 1, x, y, tgt);
12
}

这样线段树就建完了．

在处理查询时，调用线段树的 Query 方法，收到节点中的 cnt 即为答案．

在处理插入时，直接调用线段树的 Modify 方法即可．

但是这样每次插入一个节点，每一层都会调用一次 pushup，pushup 复杂度最高 O(n)O(n)O(n)，每一次查询的复杂度为 O(nlog⁡n)O(n\log n)O(nlogn)．qqq 次查询的复杂度为 O(nqlog⁡n)O(nq\log n)O(nqlogn)，不如暴力．

仔细想想，对于一个区间，只有其中的全部元素都被插入之后，这个区间才会被访问到．因此，只需要在 pos=rpos=rpos=r 的时候执行一次 pushup 即可．

1
void Modify(int t, int pos, int a, int b) {
2
  if (f[t].l == pos && f[t].r == pos) {
3
    f[t].push_back({a, b, b, 1});
4
    return;
5
  }
6
  if (f[t].l > pos || f[t].r < pos) {
7
    return;
8
  }
9
  Modify(t * 2, pos, a, b);
10
  Modify(t * 2 + 1, pos, a, b);
11

12
  if (f[t].r == pos) {
13
    pushup(t);
14
  }
15
}

展开收起

标程

1
#include <bits/stdc++.h>
2
using namespace std;
3
const int N = 3e5 + 100;
4
const int INF = 0x3f3f3f3f;
5
int n, m, k, a[2 * N], b[2 * N];
6
int l, r, x, y, ans;
7

8
struct SegmentTree {
9
    struct Node {
10
        int x = 0, lcol = 0, rcol = 0, cnt = 0;
11
        friend Node operator+(const Node a, const Node b) {
12
            if (a.x == 0)
13
                return b;
14
            if (b.x == 0)
15
                return a;
16
            Node ans;
17
            ans.x = max(a.x, b.x);
18
            ans.lcol = a.lcol;
19
            ans.rcol = b.rcol;
20
            ans.cnt = a.cnt + b.cnt - (a.rcol == b.lcol);
21
            return ans;
22
        }
23
        friend bool operator<(const int a, const Node b) { return a < b.x; }
24
    };
25
    class Nodes : public vector<Node> {
26
      public:
27
        int l, r;
28
        friend Nodes operator+(const Nodes a, const Nodes b) {
29
            Nodes ans;
30
            ans.l = a.l;
31
            ans.r = b.r;
32
            int i = -1, j = -1;
33
            while (true) {
34
                Node tmp;
35
                bool isInEndA = i + 1 >= a.size();
36
                bool isInEndB = j + 1 >= b.size();
37
                if (isInEndA && isInEndB)
38
                    break;
39
                if (isInEndB || (!isInEndA && a[i + 1].x < b[j + 1].x)) {
40
                    i++;
41
                    tmp = a[i];
42
                    if (j != -1) {
43
                        tmp = tmp + b[j];
44
                    }
45
                } else if (isInEndA || a[i + 1].x > b[j + 1].x) {
46
                    j++;
47
                    tmp = b[j];
48
                    if (i != -1) {
49
                        tmp = a[i] + tmp;
50
                    }
51
                } else {
52
                    i++;
53
                    j++;
54
                    tmp = a[i] + b[j];
55
                }
56
                ans.push_back(tmp);
57
            }
58
            return ans;
59
        }
60
    } f[N * 8];
61
    void build(int t, int l, int r) {
62
        f[t].l = l, f[t].r = r;
63
        if (l == r) {
64
            if (l > n) {
65
                return;
66
            }
67
            Node nd;
68
            nd.x = a[l];
69
            nd.lcol = b[l];
70
            nd.rcol = b[l];
71
            nd.cnt = 1;
72
            f[t].push_back(nd);
73
            return;
74
        }
75
        int mid = (l + r) / 2;
76
        build(t * 2, l, mid);
77
        build(t * 2 + 1, mid + 1, r);
78
        pushup(t);
79
    }
80
    void pushup(int t) { f[t] = f[t * 2] + f[t * 2 + 1]; }
81
    void Modify(int t, int pos, int a, int b) {
82
        if (f[t].l == pos && f[t].r == pos) {
83
            f[t].push_back({a, b, b, 1});
84
            return;
85
        }
86
        if (f[t].l > pos || f[t].r < pos) {
87
            return;
88
        }
89
        Modify(t * 2, pos, a, b);
90
        Modify(t * 2 + 1, pos, a, b);
91

92
        if (f[t].r == pos) {
93
            pushup(t);
94
        }
95
    }
96
    Node Query(int t, int x, int y, int tgt) {
97
        if (f[t].l >= x && f[t].r <= y) {
98
            auto it = upper_bound(f[t].begin(), f[t].end(), tgt);
99
            if (it == f[t].begin())
100
                return Node();
101
            return *(it - 1);
102
        }
103
        if (f[t].l > y || f[t].r < x) {
104
            return Node();
105
        }
106
        return Query(t * 2, x, y, tgt) + Query(t * 2 + 1, x, y, tgt);
107
    }
108
} sgTree;
109

110
signed main() {
111
    ios::sync_with_stdio(false);
112
    cin.tie(0);
113
    cout.tie(0);
114
    cin >> n >> m >> k;
115
    for (int i = 1; i <= n; i++) {
116
        cin >> a[i];
117
    }
118
    for (int i = 1; i <= n; i++) {
119
        cin >> b[i];
120
    }
121
    sgTree.build(1, 1, n + m);
122
    int cnt = n;
123
    for (int i = 1; i <= m; i++) {
124
        int t;
125
        cin >> t;
126
        if (t == 1) {
127
            cin >> l >> r >> x;
128
            l ^= ans * k;
129
            r ^= ans * k;
130
            x ^= ans * k;
131
            int nds = sgTree.Query(1, l, r, x).cnt;
132
            ans = nds;
133
            cout << ans << endl;
134
        } else {
135
            cin >> x >> y;
136
            x ^= ans * k;
137
            y ^= ans * k;
138
            sgTree.Modify(1, ++cnt, x, y);
139
        }
140
    }
141
}

展开收起

安吉D4-G

Thu, 06 Aug 2026 00:00:00 GMT

原题呈现

P5505 分特产#

题目描述#

JYY 带队参加了若干场 ACM/ICPC\text{ACM/ICPC}ACM/ICPC 比赛，带回了许多土特产，要分给实验室的同学们．

JYY 想知道，把这些特产分给 nnn 个同学，一共有多少种不同的分法？当然，JYY 不希望任何一个同学因为没有拿到特产而感到失落，所以每个同学都必须至少分得一个特产．

例如，JYY 带来了 222 袋麻花和 111 袋包子，分给 AAA 和 BBB 两位同学，那么共有 444 种不同的分配方法：

AAA：麻花， BBB：麻花、包子

AAA：麻花、麻花， BBB：包子

AAA：包子， BBB：麻花、麻花

AAA：麻花、包子， BBB：麻花

输入格式#

输入数据：

第一行是同学的数量 nnn 和特产的种类 mmm．

第二行包含 mmm 个整数，表示每一种特产的数量．

n,mn, mn,m 不超过 100010001000 ，每一种特产的数量不超过 100010001000．

输出格式#

输出一行，不同分配方案的总数．

由于输出结果可能非常巨大，你只需要输出最终结果 mod 109+7\bmod\ {10^9+7}mod 109+7 的数值就可以了．

输入输出样例 #1#

输入 #1#

输出 #1#

1
384835

正难则反，我们先抛弃“所以每个同学都必须至少分得一个特产”这一个条件，对于每一种特产，我们需要求将 aia_iai 个特产分给 nnn 位同学的方案数，这等同于将 aia_iai 个没标号的小球放在 nnn 个标号的盒子里，允许空盒．共有 (ai+n−1n−1)\binom{a_i+n-1}{n-1}(n−1ai+n−1) 种可能．由于对于每一种特产都有上述方案，因此总方案数 a(0)a(0)a(0) 为：

a(0)=∏i=1m(ai+n−1n−1)a(0) = \prod^{m}_{i=1} \binom{a_i+n-1}{n-1}a(0)=i=1∏m(n−1ai+n−1)

接下来处理空盒的情况．

我们使用容斥，答案为 TTT 减去钦定任意一个盒子为空的方案数，加上钦定任意两个盒子为空的方案数，减去钦定任意三个盒子为空的方案数，直到所有盒子都为空的方案数．

存在 kkk 个盒子为空的方案数 a(k)a(k)a(k)，可以想象成去掉这 kkk 个盒子，其他盒子可以为空，也可以不为空，可以使用上面计算 k=0k=0k=0 的方法，因此对于每一种钦定方案所对应的方案数 a′(k)a'(k)a′(k)，有：

a′(k)=∏i=1m(ai+n−k−1n−k−1)a'(k)=\prod^{m}_{i=1} \binom{a_i+n-k-1}{n-k-1}a′(k)=i=1∏m(n−k−1ai+n−k−1)

由于钦定了 kkk 个盒子为空，这又有 (nk)\binom{n}{k}(kn) 种钦定方法，所以有：

a(k)=(nk)a′(k)a(k)=\binom{n}{k} a'(k)a(k)=(kn)a′(k)

显然，各个约束地位相等，因此根据容斥公式，可以算出答案 ansansans，公式如下：

ans=∑k=0n((−1)ka(k))ans = \sum_{k=0}^{n}((-1)^k a(k))ans=k=0∑n((−1)ka(k))

标程

1
#include <bits/stdc++.h>
2
using namespace std;
3
#define int long long
4
const int N = 2005;
5
const int MOD = 1e9 + 7;
6
int n, m, a[N], C[N][N];
7
int ans;
8
int calC(int x, int y) {
9
    if (x == y || y == 0)
10
        return 1;
11
    if (C[x][y] == 0) {
12
        C[x][y] = (calC(x - 1, y) + calC(x - 1, y - 1)) % MOD;
13
    }
14
    return C[x][y];
15
}
16
signed main() {
17
    cin >> n >> m;
18
    for (int i = 1; i <= m; i++) {
19
        cin >> a[i];
20
    }
21
    for (int i = 0; i < n; i++) {
22
        int tot = 1;
23
        for (int j = 1; j <= m; j++) {
24
            (tot *= calC(n + a[j] - i - 1, n - i - 1)) %= MOD;
25
        }
26
        int coe = calC(n, i);
27
        if (i % 2 == 1)
28
            coe = (MOD - coe) % MOD; // (-1)^i
29
        ans = (ans + coe * tot) % MOD;
30
    }
31
    cout << ans % MOD;
32
}

展开收起

安吉D5-T2

Thu, 06 Aug 2026 00:00:00 GMT

原题呈现

题目描述#

给定一个长度为 nnn 的环形序列 a1,a2,…,ana_1, a_2, \dots, a_na1,a2,…,an．

其中每个位置的值满足：

若 ai=0a_i = 0ai=0，表示第 iii 个位置尚未确定；
若 1≤ai≤n1 \le a_i \le n1≤ai≤n，表示第 iii 个位置已经确定为编号 aia_iai 的灵魂宝石．

你需要将所有值为 000 的位置填上剩余未出现的数字，使得最终序列成为一个 111 到 nnn 的排列．

对于一个非负整数 xxx，定义 cnt⁡(x)\operatorname{cnt}(x)cnt(x) 表示 xxx 的二进制表示中 111 的个数．

对于最终排列中一对相邻位置上的数字 x,yx, yx,y，如果 cnt⁡(x&y)\operatorname{cnt}(x \mathbin{\&} y)cnt(x&y) 与 cnt⁡(x∣y)\operatorname{cnt}(x \mathbin{|} y)cnt(x∣y) 的奇偶性不同，则称这对相邻数字达成了平衡．

其中 &\mathbin{\&}& 表示按位与，∣\mathbin{|}∣ 表示按位或．

由于序列是环形的，(an,a1)(a_n, a_1)(an,a1) 也相邻．

如果最终排列中的所有相邻数字对都达成了平衡，则称这个排列符合圆环之理．

现在有 qqq 次观测修改．每次修改会将某个位置的值改为一个新的值，新的值可以是 000，也可以是 111 到 nnn 之间的整数．

请你分别求出初始状态以及每次修改之后，当前序列可以补全为符合圆环之理的排列数量．

两个补全方案不同，当且仅当至少存在一个位置，在两个最终排列中的数字不同．

答案对 998244353998244353998244353 取模．

输入格式#

第一行包含两个整数 n,qn, qn,q，表示圆环长度和观测修改次数．

第二行包含 nnn 个整数 a1,a2,…,ana_1, a_2, \dots, a_na1,a2,…,an，表示初始圆环状态．

接下来 qqq 行，每行包含两个整数 p,xp, xp,x，表示一次观测修改：将 apa_pap 修改为 xxx．

输出格式#

输出 q+1q+1q+1 行．

第一行输出初始状态下的答案．

接下来第 iii 行输出第 iii 次修改后的答案．

样例#

输入 #1#

1
6 6
2
0 0 0 0 0 0
3
1 1
4
2 3
5
3 2
6
4 5
7
5 4
8
6 1

输出 #1#

数据范围#

本题采用捆绑评测，对于一个子任务，你必须通过其中的所有测试点才能得到对应分数．

子任务编号	分数	n,q≤n, q \len,q≤	特殊性质
1	10	101010	无
2	15	181818	无
3	15	200020002000	无
4	15	2×1052 \times 10^52×105	q=0q=0q=0
5	20	2×1052 \times 10^52×105	保证任意时刻，序列中存在不为 000 的位置
6	25	2×1052 \times 10^52×105	无

对于全部数据：

1≤n≤2×1051 \le n \le 2 \times 10^51≤n≤2×105；
0≤q≤2×1050 \le q \le 2 \times 10^50≤q≤2×105；
0≤ai≤n0 \le a_i \le n0≤ai≤n；
1≤p≤n1 \le p \le n1≤p≤n；
0≤x≤n0 \le x \le n0≤x≤n．

观察题意中平衡的条件：若两个数，cnt⁡(x&y)+cnt⁡(x∣y)\operatorname{cnt}(x \mathbin{\&} y) + \operatorname{cnt}(x \mathbin{|} y)cnt(x&y)+cnt(x∣y) 为奇数（根据题意，这里 cnt⁡\operatorname{cnt}cnt 等同于 popcount⁡\operatorname{popcount}popcount），则这两个数平衡．又由于 cnt⁡(x&y)+cnt⁡(x∣y)=cnt⁡(x)+cnt⁡(y)\operatorname{cnt}(x \mathbin{\&} y) + \operatorname{cnt}(x \mathbin{|} y) = \operatorname{cnt}(x) + \operatorname{cnt}(y)cnt(x&y)+cnt(x∣y)=cnt(x)+cnt(y)，所以题意中平衡的条件转化为：

popcount⁡\operatorname{popcount}popcount 奇偶性不同的两个数相互平衡．

记 popcount⁡\operatorname{popcount}popcount 结果为奇数的正整数集合为 s1s_1s1，称其为一类数，结果为偶数的正整数集合是 s2s_2s2，称其为二类数，则合法序列必须满足：一类数（和 0）和二类数（和 0）交错排列，因此，∣s1∣|s_1|∣s1∣ 必须等于 ∣s2∣|s_2|∣s2∣，否则就始终没有合法的方案．

定义 ci,jc_{i,j}ci,j，i,j∈{0,1}i,j\in\{0,1\}i,j∈{0,1}，表示在已知序列中，∀i∈[1,n]\forall i \in [1,n]∀i∈[1,n] 满足是一类数（若 i=1i=1i=1）或是二类数（若 i=0i=0i=0）、且处于奇数（j=1j=1j=1）或偶数（j=0j=0j=0）位置的正整数的数量．

先遍历整个已知的序列，计算出 ci,jc_{i,j}ci,j，再判断以下条件是否成立：

没有重复的正整数
不存在 i∈{0,1}i\in\{0,1\}i∈{0,1}，满足 ci,0c_{i,0}ci,0 和 ci,1c_{i,1}ci,1 都不为 0．（保证不会有两个 popcount⁡\operatorname{popcount}popcount 奇偶性相同的数，一个在奇数位置上，一个在偶数位置上）

如果存在任意一个条件不成立，无解，输出 0．

否则，令 cnt0cnt_0cnt0 表示已知序列二类数数量，cnt0=c0,0+c0,1cnt_0=c_{0, 0} + c_{0, 1}cnt0=c0,0+c0,1．令 cnt1cnt_1cnt1 表示已知序列中一类数数量，cnt1=c1,0+c1,1cnt_1=c_{1, 0} + c_{1, 1}cnt1=c1,0+c1,1．

则存在 f1=∣s1∣−cnt1f_1 = |s_1| - cnt_1f1=∣s1∣−cnt1 个可以自由分配位置的一类数，存在 f2=∣s2∣−cnt2f_2 = |s_2| - cnt_2f2=∣s2∣−cnt2 个可以自由分配位置的二类数，最终结果为 f1!f2!f_1!f_2!f1!f2!．

特别的，若所有数字都是 0（cnt1=cnt2=0cnt_1=cnt_2=0cnt1=cnt2=0），则一类数和二类数可以整体交换位置，答案要乘 2．

当需要修改时，只需要动态维护 ccc 数组，再维护每一个数字出现几次（用于检查是否重复）即可．

标程

1
#include <bits/stdc++.h>
2
#define group(x) (__builtin_popcountll(x) % 2)
3
// 该内建函数（__builtin_popcount）可以计算一个数二进制表示中1的数量
4
using namespace std;
5
typedef long long ll;
6
const int N = 2e5 + 100;
7
const int MOD = 998244353;
8
int n, q, a[N], fac[N];
9
int c[2][2];
10
int cnt1 = 0, cnt0 = 0;
11
int rep = 0;
12
map<int, int> used;
13
// c[i][j] 表示当前序列中0/1类数在偶/奇位置上的一共有多少个．
14

15
int calFac(int x) {
16
    if (!fac[x]) {
17
        fac[x] = 1ll * calFac(x - 1) * x % MOD;
18
    }
19
    return fac[x];
20
}
21

22
void solve() {
23
    if (!((c[0][0] == 0 && c[1][1] == 0) || (c[0][1] == 0 && c[1][0] == 0))) {
24
        cout << 0 << endl;
25
        return;
26
    }
27
    int unused0 = cnt0 - (c[0][1] + c[0][0]);
28
    int unused1 = cnt1 - (c[1][1] + c[1][0]);
29
    ll ans = 1ll * calFac(unused0) * calFac(unused1) % MOD;
30
    if (c[0][1] + c[0][0] + c[1][1] + c[1][0] == 0) {
31
        (ans *= 2) %= MOD;
32
    }
33
    cout << ans << endl;
34
}
35

36
int main() {
37
#ifdef ONLINE_JUDGE
38
    freopen("circle.in", "r", stdin);
39
    freopen("circle.out", "w", stdout);
40
#endif
41
    cin >> n >> q;
42
    fac[0] = 1;
43
    for (int i = 1; i <= n; i++) {
44
        cin >> a[i];
45
        if (used[a[i]] != 0 && a[i] != 0) {
46
            rep++;
47
        }
48
        used[a[i]]++;
49
        if (a[i] != 0)
50
            c[group(a[i])][i % 2]++;
51
    }
52
    for (int i = 1; i <= n; i++) {
53
        if (group(i)) {
54
            cnt1++;
55
        } else {
56
            cnt0++;
57
        }
58
    }
59
    if (cnt1 != cnt0) {
60
        for (int i = 0; i <= q; i++) {
61
            cout << 0 << endl;
62
        }
63
        return 0;
64
    }
65
    if (!rep)
66
        solve();
67
    else
68
        cout << 0 << endl;
69
    for (int i = 1; i <= q; i++) {
70
        int p, x;
71
        cin >> p >> x;
72
        if (a[p]) {
73
            c[group(a[p])][p % 2]--;
74
            used[a[p]]--;
75
        }
76
        if (used[a[p]] == 1) {
77
            rep--;
78
        }
79
        a[p] = x;
80
        if (x) {
81
          c[group(x)][p % 2]++;
82
            used[x]++;
83
        }
84
        if (used[x] == 2) {
85
            rep++;
86
        }
87
        if (rep) {
88
            cout << 0 << endl;
89
            continue;
90
        }
91
        solve();
92
    }
93
}

展开收起

安吉D6 模考4总结

Thu, 06 Aug 2026 00:00:00 GMT

得分情况#

预期得分：55+100+0+20

实际得分：58+100+0+6

Time Line#

8<30>~8<50> 看题
8<50>~9<20> 切 T2
9<20>~10<40> 写 T1
10<40>~11<30> 写 T4
11<30>~12<00> 想 T3

挂分原因#

T4 将应该为全局变量的 ans 声明为局部变量，导致每一次解密的 ans 都为 0．

收获#

学会了二位偏序．

安吉D6-T1

Thu, 06 Aug 2026 00:00:00 GMT

原题呈现

数组询问#

题目描述#

有一个由 nnn 个整数组成的数组，你需要回答一些关于这个数组的询问．

输入格式#

第一行输入两个整数 n,Qn, Qn,Q，表示数组长度和询问次数．

第二行输入 nnn 个整数 a1∼ana_1 \sim a_na1∼an，表示数组中的数字．

接下来 QQQ 行，每行输入两个整数 opt,xopt, xopt,x，表示一次询问：

如果 opt=1opt=1opt=1，表示询问数组中 >x> x>x 数字的数量．
如果 opt=2opt=2opt=2，表示询问数组中字典序 >x> x>x 数字的数量．
如果 opt=3opt=3opt=3，表示询问数组中 >x> x>x，且字典序也 >x> x>x 数字的数量．

其中“字典序比较”指把整数当成十进制字符串比较．例如：

123<9123 < 9123<9，因为字典序先比较首字符，1<91 < 91<9．
870>8099870 > 8099870>8099，因为首位同为 888，第二位 7>07 > 07>0．
12<12312 < 12312<123，如果一个字符串是另一个字符串的真前缀，那么长度更长的字符串字典序更大．

输出格式#

对于每次询问输出一行一个整数，表示答案．

样例#

输入 #1#

1
8 5
2
9 88 777 6666 55555 114514 321 1234
3
1 222
4
2 222
5
3 222
6
1 114514
7
2 114514

输出 #1#

数据范围#

本题采用捆绑评测，对于一个子任务，你必须通过其中的所有数据才能得到相应分数．

子任务编号	分数	n,Qn, Qn,Q	ai,xa_i, xai,x	特殊性质
1	25	≤5000\le 5000≤5000	<109< 10^9<109	无
2	10	≤105\le 10^5≤105	10910^9109	无
3	10	≤3×105\le 3\times10^5≤3×105	<100< 100<100	无
4	10	≤3×105\le 3\times10^5≤3×105	<106< 10^6<106	无
5	10	≤3×105\le 3\times10^5≤3×105	≥108\ge 10^8≥108	无
6	10	≤3×105\le 3\times10^5≤3×105	10910^9109	opt=1opt=1opt=1
7	10	≤3×105\le 3\times10^5≤3×105	10910^9109	opt=2opt=2opt=2
8	15	≤3×105\le 3\times10^5≤3×105	10910^9109	无

全部数据范围#

1≤n,Q≤3×1051 \le n, Q \le 3\times10^51≤n,Q≤3×105
1≤ai,x<1091 \le a_i, x < 10^91≤ai,x<109
opt∈{1,2,3}opt \in \{1, 2, 3\}opt∈{1,2,3}

显然，对于操作 1，只要将数组排序，然后使用 lower_bound 进行查询，复杂度 O(nlog⁡n)O(n\log n)O(nlogn)．对于操作 2，只要将数组按字典序排序，然后使用字典序的 lower_bound 进行查询，复杂度 O(nlog⁡n)O(n\log n)O(nlogn)．

重点看操作 3．如果将所有的数字按数学顺序排序，每一个值 aia_iai 得到一个排名 rkv⁡ai\operatorname{rkv}{a_i}rkvai，再按字典序排序，所有数字又得到一个排名 rkd⁡ai\operatorname{rkd}{a_i}rkdai，那么，原问题转换为，对于给定值 xxx，查找所有的 iii 满足 rkv⁡ai>rkv⁡x\operatorname{rkv}{a_i} > \operatorname{rkv}{x}rkvai>rkvx 且 rkd⁡ai>rkd⁡x\operatorname{rkd}{a_i} > \operatorname{rkd}{x}rkdai>rkdx．满足条件的所有方案数可以使用容斥，即所有的 nnn 个点，减去所有 rkv⁡ai≤rkv⁡x\operatorname{rkv}{a_i} \leq \operatorname{rkv}{x}rkvai≤rkvx 的点（设为 A1A_1A1），减去所有 rkd⁡ai≤rkd⁡x\operatorname{rkd}{a_i} \leq \operatorname{rkd}{x}rkdai≤rkdx 的点（设为 A2A_2A2），再加上被重复减去的的 rkv⁡ai≤rkv⁡x\operatorname{rkv}{a_i} \leq \operatorname{rkv}{x}rkvai≤rkvx 且 rkd⁡ai≤rkd⁡x\operatorname{rkd}{a_i} \leq \operatorname{rkd}{x}rkdai≤rkdx 的点（设为 B12B_{12}B12），A1A_1A1 可以使用 n 减去操作 1 的结果，A2A_2A2 可以使用 n 减去操作 2 的结果，而求解 B12B_{12}B12 问题为二维偏序．

具体的，将所有操作中的参数 xix_ixi 离线，并将这些参数依照上面的标准获得两个排名 rkd⁡xi\operatorname{rkd}{x_i}rkdxi 和 rkv⁡xi\operatorname{rkv}{x_i}rkvxi（由于 xix_ixi 不参与排序，于是这个排名就相当于所有小于 xix_ixi 的数的数量 +1），将所有 aia_iai 和 xix_ixi 的两个排名视作一个二维平面上的两个坐标，于是所有 aia_iai 和 xix_ixi 就可以视作 1 个点．

此时参数 xix_ixi 对应询问的答案即为以 xix_ixi 为右下角，原点为左上角的矩形内，原始点的数量．将所有点按照横坐标排序（相同则原始点排在查询点之前），这样就省去了一维，只需考虑纵坐标的大小．依照排序顺序从小到大进行遍历，遍历到每一个点：

若该点为原始点：将该点的纵坐标加入树状数组．
若该点为查询点：查询树状数组中处于 1 和该点纵坐标之间的区间和，该和即为该查询的答案．

标程

1
#include <bits/stdc++.h>
2
using namespace std;
3
#define int long long
4
const int N = 3e5 + 100;
5
int n, Q, a[N], b[N], rkv[N], rkd[N], opt[N], x[N], ans[N], lenV, lenD;
6

7
// 按字典序排序的结构体
8
struct DictInt {
9
    int v, id;
10
    friend bool operator<(const DictInt x, const DictInt y) {
11
        int vx = x.v, vy = y.v, size1 = 0, size2 = 0;
12
        int ka[20], kb[20];
13
        while (vx > 0) {
14
            int xx = vx % 10;
15
            ka[++size1] = xx;
16
            vx /= 10;
17
        }
18
        while (vy > 0) {
19
            int yy = vy % 10;
20
            kb[++size2] = yy;
21
            vy /= 10;
22
        }
23
        for (int i = 1; i <= min(size1, size2); i++) {
24
            int ptr1 = size1 - i + 1, ptr2 = size2 - i + 1;
25
            if (ka[ptr1] < kb[ptr2])
26
                return true;
27
            if (ka[ptr1] > kb[ptr2])
28
                return false;
29
        }
30
        return size1 < size2;
31
    }
32
} d[N];
33

34
int calLessV(int x) { return upper_bound(b + 1, b + lenV + 1, x) - b - 1; }
35

36
int calLessD(int x) {
37
    DictInt di;
38
    di.v = x;
39
    di.id = 0;
40
    return upper_bound(d + 1, d + lenD + 1, di) - d - 1;
41
}
42

43
// 树状数组
44
struct BIT {
45
    int f[N];
46
    int size;
47
    BIT() {}
48
    void init(int size) { this->size = size; }
49
    int lowbit(int x) { return x & (-x); }
50
    void upd(int p, int v) {
51
        for (int i = p; i <= size; i += lowbit(i)) {
52
            f[i] += v;
53
        }
54
    }
55
    int qry(int p) {
56
        int ans = 0;
57
        for (int i = p; i >= 1; i -= lowbit(i)) {
58
            ans += f[i];
59
        }
60
        return ans;
61
    }
62
    int qry(int l, int r) { return qry(r) - qry(l - 1); }
63
} bit;
64

65
struct Point {
66
    int x, y, qid;
67
    friend bool operator<(const Point a, const Point b) {
68
        if (a.x == b.x) {
69
            if (a.qid == -1 && b.qid == -1) {
70
                return a.y < b.y;
71
            }
72
            if (a.qid == -1)
73
                return true;
74
            if (b.qid == -1)
75
                return false;
76
            return a.y < b.y;
77
        }
78
        return a.x < b.x;
79
    }
80
};
81
vector<Point> pt;
82

83
signed main() {
84
#ifdef ONLINE_JUDGE
85
    freopen("dichrome.in", "r", stdin);
86
    freopen("dichrome.out", "w", stdout);
87
#endif
88
    ios::sync_with_stdio(false);
89
    cin.tie(0);
90
    cout.tie(0);
91
    cin >> n >> Q;
92
    for (int i = 1; i <= n; i++) {
93
        int x;
94
        cin >> x;
95
        d[i] = {x, i};
96
        a[i] = x;
97
        b[i] = x;
98
    }
99
    sort(b + 1, b + n + 1);
100
    lenV = n;
101
    for (int i = 1; i <= n; i++) {
102
        rkv[i] = lower_bound(b + 1, b + n + 1, a[i]) - b;
103
    }
104
    sort(d + 1, d + n + 1);
105
    lenD = n;
106
    for (int i = 1; i <= n; i++) {
107
        DictInt di = {a[i], i};
108
        rkd[i] = lower_bound(d + 1, d + n + 1, di) - d;
109
        pt.push_back({rkv[i], rkd[i], -1});
110
    }
111

112
    for (int i = 1; i <= Q; i++) {
113
        int op, xx;
114
        cin >> op >> xx;
115
        opt[i] = op;
116
        x[i] = xx;
117
        if (op == 3) {
118
            pt.push_back({calLessV(x[i]), calLessD(x[i]), i});
119
        }
120
    }
121

122
    sort(pt.begin(), pt.end());
123

124
    bit.init(n);
125
    for (int i = 0; i < pt.size(); i++) {
126
        if (pt[i].qid == -1) {
127
            bit.upd(pt[i].y, 1);
128
        } else {
129
            ans[pt[i].qid] = bit.qry(pt[i].y);
130
        }
131
    }
132

133
    for (int i = 1; i <= Q; i++) {
134
        if (opt[i] == 1) {
135
            ans[i] = n - calLessV(x[i]);
136
        }
137
        if (opt[i] == 2) {
138
            ans[i] = n - calLessD(x[i]);
139
        }
140
        if (opt[i] == 3) {
141
            ans[i] = n - calLessD(x[i]) - calLessV(x[i]) + ans[i];
142
        }
143
        cout << ans[i] << endl;
144
    }
145
    return 0;
146
}

展开收起

安吉D6-T3

Thu, 06 Aug 2026 00:00:00 GMT

原题呈现

题目描述#

小信在玩一款卡牌游戏．对方场上有 nnn 张怪物卡，第 iii 张怪物的初始血量为 hih_ihi．

小信有两种攻击方式：

群攻：使用一次群攻，会让当前所有存活怪物的血量都减少 111．如果这次减少后存在至少一只怪物血量变为 000 或更小，这些怪物会立刻死亡，并且群攻效果会立刻再次触发一次（再次让所有仍存活怪物血量减少 111，并且这次额外效果不会消耗群攻次数）．如此反复，只要某一次群攻触发后有怪物死亡，就会继续自动触发下一次群攻；当某一次触发后没有任何怪物死亡时，这张群攻卡牌的效果结束．
普攻：一次普攻可以选择任意一只存活怪物，使其血量减少 111．

现在有 qqq 次询问．每次询问只给出一个整数 kkk，表示本次询问中小信可以使用 kkk 次群攻，普攻的使用次数无限制．小信可以以任意顺序穿插使用群攻与普攻，目标是消灭全部怪物，并使总攻击次数最少．

请你对每次询问输出最少需要多少次攻击．

输入格式#

第一行输入一个整数 nnn，表示怪物数量．

第二行输入 nnn 个整数 h1∼hnh_1 \sim h_nh1∼hn，表示各怪物初始血量．

第三行输入一个整数 qqq，表示询问次数．

接下来 qqq 行，每行输入一个整数 kkk，表示每次询问中小信的群攻次数限制．

输出格式#

输出 qqq 行．每行输出一次询问的答案：在最优策略下最少需要的总攻击次数．

样例#

样例 1#

输入：

1
10
2
1 3 2 2 6 7 2 1 2 10
3
9
4
1
5
2
6
3
7
4
8
5
9
6
10
7
11
8
12
9

输出：

样例 2#

输入：

输出：

数据范围#

本题采用捆绑评测，对于一个子任务，你必须通过其中的所有数据才能得到相应分数．

子任务编号	分数	n,qn,qn,q	特殊性质
1	20	≤10\le 10≤10	无
2	10	≤5000\le 5000≤5000	hi=nh_i = nhi=n
3	20	≤5000\le 5000≤5000	无
4	10	≤3×105\le 3\times 10^5≤3×105	hi=nh_i = nhi=n
5	10	≤3×105\le 3\times 10^5≤3×105	q=10q=10q=10
6	15	≤3×105\le 3\times 10^5≤3×105	无
7	15	10610^6106	无

对于所有数据：1≤n,q≤1061 \le n,q \le 10^61≤n,q≤106，1≤hi,k≤n1 \le h_i,k \le n1≤hi,k≤n．

结论题，结论为：由于值域很小，我们可以将所有数字按值放在一个桶中，桶中所有为 0 的且后面存在非 0 位置的位置视为一个空格．每一次群攻可以消灭一个空格，当场上没有剩余空格时，再进行一次群攻即可消灭全部敌人．

由于群攻总是比普攻不劣，我们先考虑群攻次数足够的情况，此时只需要施展场上空格次数 +1 次群攻即可．

群攻次数不足时呢？我们考虑使用普攻填空格．从后面往前进行遍历，每当遇到一个空格 iii：

若该格右边存在：同种血量的怪物存在多种，则选择血量最接近的一种，该种怪物中的一个通过普攻降到血量 iii，来填补这个空格的同时，又不会拆东墙补西墙．
否则，选择当前血量最大的怪兽，通过普攻将其血量变为 iii，用来填补这个空格．

例如：现在存在 2,3,5,7,7,92,3,5,7,7,92,3,5,7,7,9，将其整理成桶的形式：10,21,31,40,51,60,72,80,911_0,2_1,3_1,4_0,5_1,6_0,7_2,8_0,9_110,21,31,40,51,60,72,80,91，所有不存在（即为空格）的数值为 1,4,6,81,4,6,81,4,6,8．

从右边开始：

对于 888，让 999 通过一次普攻变成 888．此时：2,3,5,7,7,82,3,5,7,7,82,3,5,7,7,8．代价为 1．
对于 666，让 777 通过一次普攻变成 666．此时：2,3,5,6,7,82,3,5,6,7,82,3,5,6,7,8．代价为 1．
对于 444，让 888 通过四次普攻变成 444．此时：2,3,4,5,6,72,3,4,5,6,72,3,4,5,6,7．代价为 4．
对于 111，让 777 通过六次普攻变成 111．此时：1,2,3,4,5,61,2,3,4,5,61,2,3,4,5,6．代价为 6．

显然，由于存在群攻，这四次填空格的方式并不需要全部操作．只需要贪心的选择其中的部分空格填上，即选择代价最少的几种．因此：将 4 次操作按照代价从小到大排序，在其中选择 4−k+14-k+14−k+1 项（其中 kkk 是允许群攻的次数），所需代价就是普攻的次数，再加上 kkk 次群攻即可．

标程

1
#include <bits/stdc++.h>
2
using namespace std;
3
typedef long long ll;
4
const int N = 1e6 + 100;
5
int n, h[N], q, a[N];
6
ll sum[N];
7

8
signed main() {
9
#ifdef ONLINE_JUDGE
10
    freopen("profane.in", "r", stdin);
11
    freopen("profane.out", "w", stdout);
12
#endif
13
    ios::sync_with_stdio(false);
14
    cin.tie(0);
15
    cout.tie(0);
16
    cin >> n;
17
    for (int i = 1; i <= n; i++) {
18
        cin >> h[i];
19
    }
20
    sort(h + 1, h + n + 1);
21
    stack<int> stk;
22
    vector<int> vec;
23
    int maxh = -1;
24
    for (int i = 1; i <= n; i++) {
25
        a[h[i]]++;
26
        maxh = max(maxh, h[i]);
27
    }
28
    for (int i = maxh; i >= 1; i--) {
29
        if (a[i] > 1) {
30
            for (int j = 2; j <= a[i]; j++)
31
                stk.push(i);
32
        } else if (a[i] == 0) {
33
            int cost = 0;
34
            if (!stk.empty()) {
35
                int tp = stk.top();
36
                stk.pop();
37
                cost = tp - i;
38
            } else {
39
                cost = maxh - i;
40
                maxh--;
41
            }
42
            vec.push_back(cost);
43
        }
44
    }
45
    sort(vec.begin(), vec.end());
46
    for (int i = 0; i < vec.size(); i++) {
47
        sum[i + 1] = sum[i] + vec[i];
48
    }
49
    cin >> q;
50
    while (q--) {
51
        int k;
52
        cin >> k;
53
        if (k > vec.size()) {
54
            cout << vec.size() + 1 << endl;
55
        } else {
56
            int need = vec.size() - k + 1;
57
            cout << sum[need] + k << endl;
58
        }
59
    }
60
    return 0;
61
}

展开收起

ST表

Wed, 05 Aug 2026 00:00:00 GMT

ST 表适用于解决可重复贡献问题．

可重复贡献问题

在统计时，一个元素被统计多次对结果没有影响（即对于任意的运算 optoptopt，存在 x opt x=xx\ opt\ x = xx opt x=x），常见的可重复贡献问题有：求区间最值（RMQ）、区间按位与、区间按位或、区间 gcd等．

ST 表使用倍增的思想．我们现在想要快速求序列 aaa 中的区间最小值，需要维护以下数据：

f[j][i]：从 i 开始，长度为 2j2^j2j 的序列的最小值．

f 数组可以通过递推的方式预处理出来，每次计算 [i,i+2j−1][i, i+2^j-1][i,i+2j−1] 的最小值时，可以拆分为 [i,i+2j−1−1][i, i+2^{j-1}-1][i,i+2j−1−1] 和 [i+2j−1,2j−1][i+2^{j-1}, 2^j-1][i+2j−1,2j−1] 这两个区间中的较小值，递推关系如下：

f[j][i]=min⁡{f[j−1][i],f[j−1][i+2j−1]}f[j][i] = \min\{f[j-1][i], f[j-1][i+2^{j-1}]\}f[j][i]=min{f[j−1][i],f[j−1][i+2j−1]}

显然，初始条件为：f[0][i]=a[i]f[0][i] = a[i]f[0][i]=a[i]．预处理时间复杂度 O(nlog⁡n)O(n\log n)O(nlogn)．

1
for (int i = 0; i <= n; i++) {
2
  st[0][i] = a[i];
3
}
4
for (int j = 1; j <= 17; j++) {
5
  for (int i = 1; i + (1 << j) - 1 <= n; i++) {
6
    st[j][i] = min(st[j - 1][i], st[j - 1][i + (1 << (j - 1))]);
7
  }
8
}

在查询 [l,r][l,r][l,r] 的最小值时，我们可以将长度 sss 取 log⁡2\log_2log2．设结果为 kkk，则 2k2^k2k 必定大于等于 sss 的一半，且小于 sss．此时，答案为从 lll 开始，长度为 2k2^k2k 的区间，和末尾为 rrr，长度为 2k2^k2k 的区间的最小值．这两个区间的交集必然是 [l,r][l,r][l,r]．可以列出表达式：

ans=min⁡{f[k][l],f[k][r−2k+1]}ans=\min\{f[k][l],f[k][r-2^k+1]\}ans=min{f[k][l],f[k][r−2k+1]}

查询复杂度是 O(1)O(1)O(1) 的．

1
int query(int l, int r) {
2
    int len = log2(r - l + 1);
3
    return min(st[len][l], st[len][r - (1 << len) + 1]);
4
}

<< 的优先级问题

在 C++ 中， << 和 >> 的优先级是低于 + 和 - 的，因此在进行左移和右移运算时，一定要注意括号问题．

安吉-开营测试 T4

Wed, 05 Aug 2026 00:00:00 GMT

原题呈现

题目描述#

香风智乃想画一幅画．这幅画一共有 nnn 个像素，每个像素上可以画 mmm 种颜色的其中一种．但是，如果某一种颜色连续重复出现太多次，那么就会显得这幅画很单调．具体来说，智乃不希望第 iii 种颜色连续出现超过 aia_iai 次．智乃想知道，她一共能画出多少种不同的画．两幅画不同，当且仅当某个像素上所画的颜色不同．

输入格式#

从文件 draw.in 中读入数据．第一行输入两个整数 n,mn, mn,m．第二行输入 mmm 个整数，第 iii 个表示 aia_iai．

输出格式#

输出到文件 draw.out 中．输出一个非负整数，表示答案对 998244353 取模后的值．

样例输入#

样例输出#

1
21

数据范围#

对于 10%10\%10% 的数据，1≤n,m≤51 \leq n, m \leq 51≤n,m≤5．对于 30%30\%30% 的数据，1≤n,m≤501 \leq n, m \leq 501≤n,m≤50．对于 50%50\%50% 的数据，1≤n,m≤5001 \leq n, m \leq 5001≤n,m≤500．对于 70%70\%70% 的数据，1≤n,m≤50001 \leq n, m \leq 50001≤n,m≤5000．对于 100%100\%100% 的数据，1≤ai≤n≤5000,1≤m≤1051 \leq a_i \leq n \leq 5000, 1 \leq m \leq 10^51≤ai≤n≤5000,1≤m≤105．

观察 nnn 的范围，显然使用 dp．

定义状态：dp[i][j] 表示考虑前 i 个像素，最后一个颜色为 j 的方案数．

一般情况下，对于一个序列，该序列的下一个像素都可以取 mmm 种颜色，但是有一个例外．由于不能连续重复出现太多次这一限制的存在，存在一种危险序列，满足以下所有条件：

该序列的后面 aka_kak 个都是颜色 kkk．
该序列的第倒数 ak+1a_k+1ak+1 个像素的颜色不是颜色 kkk．

此时，这个序列的下一个像素就不能是颜色 kkk．

若定义前 iii 个像素的合法方案数为 sis_isi（无最后一个颜色的限制），合法但是后面不能再增加颜色 jjj 的方案数为 di,jd_{i,j}di,j，可以预处理出 sis_isi，通过容斥，先计算出无视这一限制后的方案数 si−1s_{i - 1}si−1（直接往所有合法序列后面添加颜色 jjj），再减去上述的不合法方案数 di−1d_{i - 1}di−1，就是 dp[i][j]

si=∑j=1mdp[i][j]s_i = \sum_{j=1}^{m} dp[i][j]si=j=1∑mdp[i][j] di,j=si−aj−dp[i−aj][j]d_{i,j} = s_{i-a_j} - dp[i-a_j][j]di,j=si−aj−dp[i−aj][j]

故 dp[i][j] 的表达式为：

si−1−(si−aj−1−dp[i−aj−1][j])s_{i-1} - (s_{i-a_j-1}-dp[i-a_j-1][j])si−1−(si−aj−1−dp[i−aj−1][j])

最终结果为 s[n]．

这种方法的时间复杂度为 O(mn)O(mn)O(mn)．

观察到颜色种类很多，但是限制种类很少，说明有多种颜色的限制相同．那么这些颜色就可以一起处理．

修改状态：dp[i][j] 表示考虑前 i 个像素，最后一个颜色是限制为 j 的某一种颜色的方案数．

定义 cnt[i] 表示限制为 iii 的颜色数量．

由此，我们修改 sis_isi 和 did_idi 的表达式：

si=∑k∈adp[i][k]×cnt[k]s_i = \sum_{k\in a} dp[i][k] \times cnt[k]si=k∈a∑dp[i][k]×cnt[k] di=si−k−dp[i−k][k]d_i = s_{i-k} - dp[i-k][k]di=si−k−dp[i−k][k] dp[i][k]=si−1−(si−k−1−dp[i−k−1][k])dp[i][k] = s_{i-1} - (s_{i-k-1}-dp[i-k-1][k])dp[i][k]=si−1−(si−k−1−dp[i−k−1][k])

这样的时间复杂度为 O(n2+m)O(n^2+m)O(n2+m)．

标程

1
#include <bits/stdc++.h>
2
using namespace std;
3
const int M = 1e5 + 100;
4
const int N = 5005;
5
const int MOD = 998244353;
6
int n, m;
7
map<int, int> cnt;
8
int dp[N][N], s[N];
9
int main() {
10
    cin >> n >> m;
11
    for (int i = 1; i <= m; i++) {
12
        int a;
13
        cin >> a;
14
        cnt[a]++;
15
    }
16
    vector<int> keys;
17
    for (auto i : cnt) {
18
        if (i.second != 0)
19
            keys.push_back(i.first);
20
    }
21
    s[0] = 1;
22
    for (int i = 1; i <= n; i++) {
23
        for (int j = 0; j < keys.size(); j++) {
24
            int k = keys[j];
25
            if (i - k <= 0) {
26
                dp[i][k] = s[i - 1];
27
            } else
28
                dp[i][k] = (0ll + s[i - 1] - (s[i - k - 1] - dp[i - k - 1][k]) + MOD) % MOD;
29
        }
30
        for (int j = 0; j < keys.size(); j++) {
31
            int k = keys[j];
32
            (s[i] += 1ll * dp[i][k] * cnt[k] % MOD) %= MOD;
33
        }
34
    }
35
    cout << s[n];
36
}

展开收起

实际上，若一个 dp 状态与之前的连续的一段状态（开头为位置 ppp）都有关，则可能可以从状态 p−1p-1p−1 进行转移．

安吉D5 模考3总结

Wed, 05 Aug 2026 00:00:00 GMT

得分情况#

预期得分：100+55+0+26

实际得分：100+0+0+0

Time Line#

8<30>~8<50> 看题
8<50>~10<00> 做 T1
10<00>~11<20> 做 T2
11<20>~12<00> 做 T4

挂分原因#

T2 的部分情况没有考虑到
T2 花费过多时间在写部分分
T4 忽略了 << 和 + 之间的运算优先级

收获#

了解了一种状态设计的新方法．

安吉D5-T3

Wed, 05 Aug 2026 00:00:00 GMT

题目呈现

P9100 Miny#

题目描述#

nnn 枚地雷被运到 Bytau 的军事训练场，并沿一条直线埋设．每个地雷位于不同的地方，并且有自己的爆炸半径．当引爆时，地雷会自动引爆其爆炸半径内所有尚未爆炸的地雷．如果地雷 aaa 和地雷 bbb 之间的距离不超过地雷 bbb 的爆炸半径，则我们称地雷 aaa 在地雷 bbb 的爆炸半径内．

Bytomir 中士想进行一项实验．他选择了一个任意的地雷子集（也许是空的），并让这个地雷子集内的所有地雷在同时手动引爆．实验的结果是一组已经爆炸的地雷——要么是手动引爆的引起的爆炸，要么是其他地雷爆炸导致的爆炸．

Bytomir 能得到多少种可能的实验结果？如果两个实验结果中爆炸的地雷相同，则这两个实验结果是相同的．由于结果可能很大，请输出它除以 109+710^9+7109+7 的余数．

输入格式#

输入第一行包含一个整数 nnn，表示地雷个数．

接下来 nnn 行，每行两个整数 ai,ria_i,r_iai,ri，分别表示地雷的位置和爆炸半径．你可以假设 a1<a2<⋯<ana_1<a_2<\cdots<a_na1<a2<⋯<an．

输出格式#

输出可能的实验结果总数对 109+710^9+7109+7 取模后的值．

输入输出样例 #1#

输入 #1#

输出 #1#

1
7

说明/提示#

样例 1 解释#

你可以得到 777 种可能的实验结果：

{}\{\}{}（空集）：如果不引爆任何地雷；
{1,2}\{1,2\}{1,2}（地雷 1,21,21,2）：如果我们只引爆地雷 111；
{1,2,3}\{1,2,3\}{1,2,3}：如果我们引爆地雷 111 和 333；
{1,2,3,4}\{1,2,3,4\}{1,2,3,4}：如果我们引爆地雷 111 和 444；
{2}\{2\}{2}：如果我们只引爆地雷 222；
{2,3}\{2,3\}{2,3}：如果我们只引爆地雷 333；
{2,3,4}\{2,3,4\}{2,3,4}：如果我们只引爆地雷 444；

请注意，可以通过不同的方式得到同一个实验结果——例如，如果我们引爆地雷 111 和 222，也会得到 {1,2}\{1, 2\}{1,2} 的结果．

数据范围#

本题采用捆绑测试

对于 50%50\%50% 的数据，保证 1≤n≤50001\le n\le 50001≤n≤5000．

对于 100%100\%100% 的数据，保证 1≤n≤3×1051\le n\le 3\times 10^51≤n≤3×105，0≤ai,ri≤10180\le a_i,r_i\le 10^{18}0≤ai,ri≤1018．

先来解决小数据．

由于小数据数据范围较少，考虑 dp，这里定义 dp[i] 表示考虑到第 iii 个地雷，且第 iii 个地雷不被引爆的方案数，这样 dp 可以使得第 iii 个地雷（及以前的所有地雷）都不会引爆第 iii 个地雷之后的所有地雷，从而满足无后效性．

显然，有初始状态：dp[0] = 1，即不选择地雷，则存在没有地雷爆炸这一种情况．

考虑转换方程：dp[i] 可以由 dp[j] 转换而来（j<ij<ij<i），当且仅当手动引爆第 [i+1,j−1][i+1,j-1][i+1,j−1] 个地雷时，地雷 iii 和 jjj 都不会被引爆．

为了满足这两颗地雷都不会被引爆，我们需要保证：

地雷 iii 左边第一个会引爆 iii 的地雷不在区间 [i+1,j−1][i+1,j-1][i+1,j−1] 之中．（保证地雷 iii 不会被引爆）
地雷 jjj 右边第一个会引爆 jjj 的地雷不在区间 [i+1,j−1][i+1,j-1][i+1,j−1] 之中．（保证地雷 iii 不会被引爆）

即，设地雷 iii 左边第一个会引爆 iii 的地雷为 LiL_iLi，地雷 iii 右边第一个会引爆 iii 的地雷为 RiR_iRi．则符合条件的 jjj 满足：

j<ij<ij<i
Li≤jL_i\leq jLi≤j
i≤Rji\leq R_ji≤Rj

，从 i−1i-1i−1 开始向前遍历直到 LiL_iLi，寻找合法的 jjj 加入贡献即可．

在计算 LiL_iLi 时，从 i−1i-1i−1 开始向前遍历，找到第一个 aj+rj≥aia_j + r_j \geq a_iaj+rj≥ai 的地雷，Li=jL_i=jLi=j．同理，在计算 RiR_iRi 时，从 i+1i+1i+1 开始向前遍历，找到第一个 aj−rj≤aia_j - r_j \leq a_iaj−rj≤ai 的地雷，Li=jL_i=jLi=j．

在统计最终状态时，可以引入哨兵，在地雷序列首位和末尾各增加一个距离无限远、爆炸半径无限远（可以炸到另外一个哨兵）的哨兵地雷 000 和 n+1n+1n+1．从而使得 ∀i∈[1,n]\forall i \in [1, n]∀i∈[1,n]，LiL_iLi 和 RiR_iRi 都不为空，同时，dp[n+1] 还能收集到所有未贡献状态（即 ∀j∈[0,n],Rj=n+1\forall j\in [0, n],R_j=n+1∀j∈[0,n],Rj=n+1 的状态 dp[j]）．

最终状态即为 dp[n+1]．

50pts50pts50pts 标程

1
#include <bits/stdc++.h>
2
using namespace std;
3
#define int long long
4
const int N = 3e5 + 100;
5
const int MOD = 1e9 + 7;
6
int n, a[N], r[N], dp[N], L[N], R[N];
7

8
signed main() {
9
#ifdef ONLINE_JUDGE
10
    freopen("landmine.in", "r", stdin);
11
    freopen("landmine.out", "w", stdout);
12
#endif
13
    cin >> n;
14
    for (int i = 1; i <= n; i++) {
15
        cin >> a[i] >> r[i];
16
    }
17
    a[n + 1] = 2e18;
18
    r[n + 1] = 4e18 + 10; // LLONG_MAX 约为 9e18
19
    a[0] = -2e18;
20
    r[0] = 4e18 + 10;
21
    for (int i = 0; i <= n + 1; i++) {
22
        for (int j = 0; j < i; j++) {
23
            if (a[j] + r[j] >= a[i]) {
24
                L[i] = j;
25
            }
26
        }
27
    }
28
    memset(R, 0x3f, sizeof(R));
29
    for (int i = 0; i <= n + 1; i++) {
30
        for (int j = i + 1; j <= n + 1; j++) {
31
            if (a[j] - r[j] <= a[i]) {
32
                R[i] = min(j, R[i]);
33
            }
34
        }
35
    }
36
    dp[0] = 1;
37
    for (int i = 0; i <= n + 1; i++) {
38
        for (int j = L[i]; j < i; j++) {
39
            if (i <= R[j]) {
40
                (dp[i] += dp[j]) %= MOD;
41
            }
42
        }
43
    }
44
    cout << dp[n + 1];
45
    return 0;
46
}

展开收起

这样的复杂度是 O(n2)O(n^2)O(n2) 的，考虑如何优化．

首先，预处理 LiL_iLi 和 RiR_iRi 可以使用 ST 表和二分进行优化．以计算 LiL_iLi 为例，具体来说，对于区间 [l,r][l,r][l,r]，二分可能的子区间 i∈[mid,r]i\in [mid,r]i∈[mid,r]，对于该子区间，求出 a[i]+r[i]a[i]+r[i]a[i]+r[i] 的最大值（即每个地雷最右影响位置）是否比 aia_iai 大（或等于），如果是，说明 LiL_iLi 在该子区间内，在该子区间内继续二分，否则，在相反的子区间 [l,mid−1][l, mid-1][l,mid−1] 内进行二分．RiR_iRi 的处理和 LiL_iLi 相类似．

ST 表实现如下：

1
struct ST {
2
    int *p;
3
    int fmax[32][N];
4
    int fmin[32][N];
5
    ST(int *p) : p(p) {}
6
    void init(int size) {
7
        for (int i = 0; i <= size; i++) {
8
            fmax[0][i] = p[i];
9
            fmin[0][i] = p[i];
10
        }
11
        for (int j = 1; j <= 30; j++) {
12
            for (int i = 0; i + (1 << (j - 1)) <= size; i++) {
13
                fmax[j][i] =
14
                    max(fmax[j - 1][i], fmax[j - 1][i + (1 << (j - 1))]);
15
                fmin[j][i] =
16
                    min(fmin[j - 1][i], fmin[j - 1][i + (1 << (j - 1))]);
17
            }
18
        }
19
    }
20
    int mini(int l, int r) {
21
        int len = log(r - l + 1) / log(2);
22
        return min(fmin[len][l], fmin[len][r - (1 << len) + 1]);
23
    }
24
    int maxi(int l, int r) {
25
        int len = log(r - l + 1) / log(2);
26
        return max(fmax[len][l], fmax[len][r - (1 << len) + 1]);
27
    }
28
};
29

30
ST l_st(l_lim), r_st(r_lim);

展开收起

预处理实现如下：

1
for (int i = 0; i <= n + 1; i++) {
2
  l_lim[i] = a[i] - r[i];
3
  r_lim[i] = a[i] + r[i];
4
}
5

6
l_st.init(n + 1), r_st.init(n + 1);
7

8
for (int i = 0; i <= n + 1; i++) {
9
  int l = 0, r = i - 1, ans = 0;
10
  while (l <= r) {
11
    int mid = (l + r) / 2;
12
    if (r_st.maxi(mid, r) >= a[i]) {
13
      ans = mid;
14
      l = mid + 1;
15
    } else {
16
      r = mid - 1;
17
    }
18
  }
19
  L[i] = ans;
20
}
21
for (int i = 0; i <= n + 1; i++) {
22
  int l = i + 1, r = n + 1, ans = n + 1;
23
  while (l <= r) {
24
    int mid = (l + r) / 2;
25
    if (l_st.mini(l, mid) <= a[i]) {
26
      ans = min(ans, mid);
27
      r = mid - 1;
28
    } else {
29
      l = mid + 1;
30
    }
31
  }
32
  R[i] = ans;
33
}

展开收起

再考虑如何优化 dp．

dp 的转移方程中涉及到区间加和的问题，因此可以将 dpdpdp 数组放入树状数组优化．在每一次计算 dp[i]dp[i]dp[i] 时，计算 j∈[Li,i−1]j\in [L_i,i-1]j∈[Li,i−1] 之和，再减去所有不满足 i≤Rji\leq R_ji≤Rj 的 jjj．

怎么减去呢？要减去的 jjj 满足 Rj<iR_j < iRj<i，显然，当一项需要被减去之后（Rj=iR_j=iRj=i），该项就不会再对之后的计算产生贡献（Rj≥i+k,k∈N+R_j \geq i+k,k\in\mathbb{N}^+Rj≥i+k,k∈N+）．因此，在每一次计算完 dp[i]dp[i]dp[i] 之后，将所有的 jjj 满足 Rj=iR_j=iRj=i 的 dp[j]dp[j]dp[j] 在树状数组中删除（即设为 0）（查找满足要求的 jjj 可以使用 map），这样，在后续进行计算时，该项就不会被计入贡献．

1
map<int, vector<int>> r_R;
2

3
// 树状数组实现
4
struct BIT {
5
    int c[N];
6
    int size;
7
    int lowbit(int i) { return i & (-i); }
8
    BIT() { memset(c, 0, sizeof(c)); }
9

10
    void init(int size) { this->size = size; }
11
    void upd(int p, int v) {
12
        p++; // 转为 1-based
13
        for (int i = p; i <= size; i = i + lowbit(i)) {
14
            (c[i] += v + MOD) %= MOD;
15
        }
16
    }
17
    int qry(int p) {
18
        p++; // 转为 1-based
19
        int ans = 0;
20
        for (int i = p; i >= 1; i -= lowbit(i)) {
21
            (ans += c[i]) %= MOD;
22
        }
23
        return ans;
24
    }
25
    int qry(int l, int r) { return qry(r) - qry(l - 1); }
26
};
27
BIT bit;

展开收起

main 函数内：

1
bit.upd(0, 1);
2
dp[0] = 1;
3
for (int i = 1; i <= n + 1; i++) {
4
  (dp[i] += bit.qry(L[i], i - 1)) %= MOD;
5
  bit.upd(i, dp[i]);
6
  vector<int> &vec = r_R[i];
7
  for (int j = 0; j < vec.size(); j++) {
8
    int ori = bit.qry(vec[j], vec[j]);
9
    bit.upd(vec[j], -ori);
10
  }
11
}

100pts100pts100pts 标程

1
#include <bits/stdc++.h>
2
using namespace std;
3
#define int long long
4
const int N = 3e5 + 100;
5
const int MOD = 1e9 + 7;
6
int n, a[N], r[N], dp[N], L[N], R[N], l_lim[N], r_lim[N];
7
map<int, vector<int>> r_R;
8

9
struct ST {
10
    int *p;
11
    int fmax[32][N];
12
    int fmin[32][N];
13
    ST(int *p) : p(p) {}
14
    void init(int size) {
15
        for (int i = 0; i <= size; i++) {
16
            fmax[0][i] = p[i];
17
            fmin[0][i] = p[i];
18
        }
19
        for (int j = 1; j <= 30; j++) {
20
            for (int i = 0; i + (1 << (j - 1)) <= size; i++) {
21
                fmax[j][i] =
22
                    max(fmax[j - 1][i], fmax[j - 1][i + (1 << (j - 1))]);
23
                fmin[j][i] =
24
                    min(fmin[j - 1][i], fmin[j - 1][i + (1 << (j - 1))]);
25
            }
26
        }
27
    }
28
    int mini(int l, int r) {
29
        int len = log(r - l + 1) / log(2);
30
        return min(fmin[len][l], fmin[len][r - (1 << len) + 1]);
31
    }
32
    int maxi(int l, int r) {
33
        int len = log(r - l + 1) / log(2);
34
        return max(fmax[len][l], fmax[len][r - (1 << len) + 1]);
35
    }
36
};
37

38
struct BIT {
39
    int c[N];
40
    int size;
41
    int lowbit(int i) { return i & (-i); }
42
    BIT() { memset(c, 0, sizeof(c)); }
43

44
    void init(int size) { this->size = size; }
45
    void upd(int p, int v) {
46
        p++; // 转为 1-based
47
        for (int i = p; i <= size; i = i + lowbit(i)) {
48
            (c[i] += v + MOD) %= MOD;
49
        }
50
    }
51
    int qry(int p) {
52
        p++; // 转为 1-based
53
        int ans = 0;
54
        for (int i = p; i >= 1; i -= lowbit(i)) {
55
            (ans += c[i]) %= MOD;
56
        }
57
        return ans;
58
    }
59
    int qry(int l, int r) { return qry(r) - qry(l - 1); }
60
};
61

62
ST l_st(l_lim), r_st(r_lim);
63
BIT bit;
64

65
signed main() {
66
#ifdef ONLINE_JUDGE
67
    freopen("landmine.in", "r", stdin);
68
    freopen("landmine.out", "w", stdout);
69
#endif
70
    cin >> n;
71
    for (int i = 1; i <= n; i++) {
72
        cin >> a[i] >> r[i];
73
    }
74
    a[n + 1] = 2e18;
75
    r[n + 1] = 4e18 + 10;
76
    a[0] = -2e18;
77
    r[0] = 4e18 + 10;
78
    for (int i = 0; i <= n + 1; i++) {
79
        l_lim[i] = a[i] - r[i];
80
        r_lim[i] = a[i] + r[i];
81
    }
82

83
    l_st.init(n + 1), r_st.init(n + 1);
84
    bit.init(n + 1);
85

86
    for (int i = 0; i <= n + 1; i++) {
87
        int l = 0, r = i - 1, ans = 0;
88
        while (l <= r) {
89
            int mid = (l + r) / 2;
90
            if (r_st.maxi(mid, r) >= a[i]) {
91
                ans = mid;
92
                l = mid + 1;
93
            } else {
94
                r = mid - 1;
95
            }
96
        }
97
        L[i] = ans;
98
    }
99
    for (int i = 0; i <= n + 1; i++) {
100
        int l = i + 1, r = n + 1, ans = n + 1;
101
        while (l <= r) {
102
            int mid = (l + r) / 2;
103
            if (l_st.mini(l, mid) <= a[i]) {
104
                ans = min(ans, mid);
105
                r = mid - 1;
106
            } else {
107
                l = mid + 1;
108
            }
109
        }
110
        R[i] = ans;
111
        r_R[R[i]].push_back(i);
112
    }
113
    bit.upd(0, 1);
114
    dp[0] = 1;
115
    for (int i = 1; i <= n + 1; i++) {
116
        (dp[i] += bit.qry(L[i], i - 1)) %= MOD;
117
        bit.upd(i, dp[i]);
118
        vector<int> &vec = r_R[i];
119
        for (int j = 0; j < vec.size(); j++) {
120
            int ori = bit.qry(vec[j], vec[j]);
121
            bit.upd(vec[j], -ori);
122
        }
123
    }
124
    cout << dp[n + 1];
125
    return 0;
126
}

展开收起

安吉Day4-D

Tue, 04 Aug 2026 00:00:00 GMT

原题呈现

P10390 因数计数#

题目描述#

小蓝随手写出了含有 nnn 个正整数的数组 {a1,a2,⋯ ,an}\{a_1, a_2,\cdots, a_n\}{a1,a2,⋯,an}，他发现可以轻松地算出有多少个有序二元组 (i,j)(i, j)(i,j) 满足 aja_jaj 是 aia_iai 的一个因数．因此他定义一个整数对 (x1,y1)(x_1, y_1)(x1,y1) 是一个整数对 (x2,y2)(x_2, y_2)(x2,y2) 的“因数”当且仅当 x1x_1x1 和 y1y_1y1 分别是 x2x_2x2 和 y2y_2y2 的因数．他想知道有多少个有序四元组 (i,j,k,l)(i, j, k, l)(i,j,k,l) 满足 (ai,aj)(a_i , a_j)(ai,aj) 是 (ak,al)(a_k, a_l)(ak,al) 的因数，其中 i,j,k,li, j, k, li,j,k,l 互不相等．

输入格式#

输入的第一行包含一个正整数 nnn．第二行包含 nnn 个正整数 a1,a2,⋯ ,ana_1, a_2,\cdots, a_n a1,a2,⋯,an，相邻整数之间使用一个空格分隔．

输出格式#

输出一行包含一个整数表示答案．

输入输出样例 #1#

输入 #1#

输出 #1#

1
4

说明/提示#

四元组 (1,4,2,3)(1, 4, 2, 3)(1,4,2,3)：(3,2)(3, 2)(3,2) 为 (6,2)(6, 2)(6,2) 的因子；四元组 (1,3,2,4)(1, 3, 2, 4)(1,3,2,4)：(3,2)(3, 2)(3,2) 为 (6,2)(6, 2)(6,2) 的因子；四元组 (4,1,3,2)(4, 1, 3, 2)(4,1,3,2)：(2,3)(2, 3)(2,3) 为 (2,6)(2, 6)(2,6) 的因子；四元组 (3,1,4,2)(3, 1, 4, 2)(3,1,4,2)：(2,3)(2, 3)(2,3) 为 (2,6)(2, 6)(2,6) 的因子．

对于 20%20\%20% 的评测用例，n≤50n ≤ 50n≤50；对于 40%40\%40% 的评测用例，n≤104n ≤ 10^4n≤104；对于所有评测用例，1≤n≤105，1≤ai≤1051 ≤ n ≤ 10^5 ，1 ≤ a_i ≤ 10^51≤n≤105，1≤ai≤105．

在题面中，出现了一个子问题：

求出长度为 nnn 的序列 aaa 中有多少个有序二元组 (i,j)(i, j)(i,j) 满足 aj∣aia_j \mid a_iaj∣ai．

接下来，我们来解决这个子问题．

考虑到值域只到 10510^5105，我们考虑将值域放入数组下标，定义 cnt[x]cnt[x]cnt[x] 表示序列 aaa 中元素 xxx 的数量，并预处理下列数据：

mult[x]=∑y∈{i:x∣i}cnt[y]mult[x]=\sum_{y\in \{i :x\mid i \}}cnt[y]mult[x]=∑y∈{i:x∣i}cnt[y]，记录序列中是 xxx 的倍数的数有多少个（包含 xxx）
divs[x]=∑y∈{i:i∣x}cnt[y]divs[x]=\sum_{y\in \{i :i\mid x \}}cnt[y]divs[x]=∑y∈{i:i∣x}cnt[y]，记录序列中是 xxx 的因数的数有多少个（包含 xxx）这些数据可以用调和级数 O(nlog⁡n)O(n\log n)O(nlogn) 时间复杂度解决．

接下来，我们就可以使用 F=∑x∈Ncnt[x]×mult[x]F = \sum_{x\in\mathbb{N}} cnt[x] \times mult[x]F=∑x∈Ncnt[x]×mult[x]，来计算所有满足 aj∣aia_j \mid a_iaj∣ai 的有序二元组 (i,j)(i, j)(i,j) 数量（包括 i=ji=ji=j）．去掉 i=ji=ji=j 情况的方法也很简单，显然，i=ji=ji=j 的方法有 nnn 种，因此使用 T=F−nT = F -nT=F−n 就可以解决上面的子问题．

那么，有序四元对的数量就是 T2T^2T2 吗？显然不是．我们需要先确定一组满足子问题的有序二元对 (i,k)(i, k)(i,k)，设 a[i]=x,a[k]=ya[i] = x, a[k] = ya[i]=x,a[k]=y，由于值域小，我们可以使用枚举 xxx 和 yyy 的方式来确定一对数值对（此处不需要求出 iii 和 jjj 具体是多少，因为后续只会用到 a[i]a[i]a[i] 和 a[j]a[j]a[j]，因此所有 a[i]a[i]a[i] 和 a[j]a[j]a[j] 分别相等，但 i,ji,ji,j 不分别相等的有序二元对是等价的），时间复杂度 O(nlog⁡n)O(n\log n)O(nlogn)．显然，这一对数值对对应着 cnt[x]×cnt[y]cnt[x] \times cnt[y]cnt[x]×cnt[y] 个有序二元对（如果 x=yx=yx=y 则对应 cnt[x]×(cnt[x]−1)cnt[x]\times (cnt[x] - 1)cnt[x]×(cnt[x]−1) 个）这些有序二元对是完全相同的，可以一起处理．

接下来，对于每一对合法的有序二元对 (i,k)(i,k)(i,k)，我们需要枚举另外一对合法的有序二元对 (j,l)(j,l)(j,l)，当然，需要满足下面这些条件：

aj∣ala_j \mid a_laj∣al 且 j≠lj\neq lj=l
j,l∉{i,k}j,l\notin \{i,k\}j,l∈/{i,k}

根据容斥原理，总方案数 tottottot 有如下表达式：

tot=T−Ai−Ak+Biktot = T - A_i -A_k+B_{ik}tot=T−Ai−Ak+Bik

其中：

TTT 为上述子问题的答案
AiA_iAi 为 jjj 和 lll 中存在一个与 iii 相等的情况，即 j=ij=ij=i 或 l=il=il=i（j≠lj\neq lj=l），计算方法如下：
- 使用 mult[a[i]]mult[a[i]]mult[a[i]] 计算 a[i]a[i]a[i] 的倍数有多少个，当 a[j]a[j]a[j] 取到 a[i]a[i]a[i] 时，a[l]a[l]a[l] 的取值就一定是 a[i]a[i]a[i] 的倍数，一共会有 mult[a[i]]−1mult[a[i]] - 1mult[a[i]]−1 个，由于 a[j]≠a[l]a[j] \neq a[l]a[j]=a[l]，所以要 -1．
- 使用 divs[a[i]]divs[a[i]]divs[a[i]] 计算 a[i]a[i]a[i] 的因数有多少个，当 a[l]a[l]a[l] 取到 a[i]a[i]a[i] 时，a[j]a[j]a[j] 的取值就一定是 a[i]a[i]a[i] 的因数，一共会有 divs[a[i]]−1divs[a[i]] - 1divs[a[i]]−1 个，由于 a[j]≠a[l]a[j] \neq a[l]a[j]=a[l]，所以要 -1．
- 综合一下，Ai=mult[a[i]]+divs[a[i]]−2A_i = mult[a[i]] + divs[a[i]] - 2Ai=mult[a[i]]+divs[a[i]]−2．
AkA_kAk 为 jjj 和 lll 中存在一个与 kkk 相等的情况，即 j=kj=kj=k 或 l=kl=kl=k（j≠lj\neq lj=l），计算方法同上．
BikB_{ik}Bik jjj 和 lll 中一个与 iii 相等，另一个与 kkk 相等的情况，即 j=ij=ij=i 且 l=kl=kl=k；或 j=kj=kj=k 且 l=il=il=i
- 对于 j=ij=ij=i 且 l=kl=kl=k 的情况，由于 ai∣aka_i \mid a_kai∣ak，故 aj∣ala_j \mid a_laj∣al 恒成立，因此，这种情况一定会有一个贡献为 1．
- 对于 j=kj=kj=k 且 l=il=il=i 的情况，由于 ai∣aka_i \mid a_kai∣ak，当且仅当 aj=ala_j=a_laj=al 时， aj∣ala_j \mid a_laj∣al 成立，故当 aj=ala_j=a_laj=al 时贡献为 1，否则贡献为 0．

得出 tottottot 之后，数值对 (x,y)(x,y)(x,y) 对答案的贡献就是这个数值对对应的有序二元组数量和 tottottot 之积，具体来说，

若 x=yx=yx=y，贡献为 cnt[x]∗(cnt[x]−1)∗totcnt[x] * (cnt[x] - 1) * totcnt[x]∗(cnt[x]−1)∗tot．
否则，贡献为 cnt[x]∗cnt[y]∗totcnt[x] * cnt[y] * totcnt[x]∗cnt[y]∗tot．

注意，这个题需要开 __int128．

标程

1
#include <bits/stdc++.h>
2
using namespace std;
3
typedef __int128 lll;
4
const int N = 1e5 + 100;
5
int n, a[N];
6
lll cnt[N], mult[N], divs[N];
7

8
void print(lll x) {
9
    if (x >= 10)
10
        print(x / 10);
11
    putchar('0' + x % 10);
12
}
13

14
signed main() {
15
    cin >> n;
16
    int maxa = -1;
17
    for (int i = 1; i <= n; i++) {
18
        cin >> a[i];
19
        cnt[a[i]]++;
20
        maxa = max(maxa, a[i]);
21
    }
22
    // 预处理
23
    for (int i = 1; i <= maxa; i++) {
24
        for (int j = i; j <= maxa; j += i) {
25
            mult[i] += cnt[j];
26
        }
27
        for (int j = 1; j <= sqrt(i); j++) {
28
            if (i % j)
29
                continue;
30
            divs[i] += cnt[j];
31
            if (j * j != i) {
32
                divs[i] += cnt[i / j];
33
            }
34
        }
35
    }
36
    lll T = -n;
37
    for (int i = 1; i <= maxa; i++) {
38
        T += cnt[i] * mult[i];
39
    }
40
    // 计算贡献
41
    lll ans = 0;
42
    for (int x = 1; x <= maxa; x++) {
43
        for (int y = x; y <= maxa; y += x) {
44
            lll Ai = mult[x] + divs[x] - 2;
45
            lll Ak = mult[y] + divs[y] - 2;
46
            lll Bik = 1 + (x == y);
47
            lll tot = T - Ai - Ak + Bik;
48
            if (x == y) {
49
                ans += (lll)cnt[x] * (cnt[y] - 1) * tot;
50
            } else {
51
                ans += (lll)cnt[x] * cnt[y] * tot;
52
            }
53
        }
54
    }
55
    print(ans);
56
}

展开收起

安吉D4-A

Tue, 04 Aug 2026 00:00:00 GMT

原题呈现

P1450 硬币购物#

题目描述#

共有 444 种硬币．面值分别为 c1,c2,c3,c4c_1,c_2,c_3,c_4c1,c2,c3,c4．

某人去商店买东西，去了 nnn 次，对于每次购买，他带了 did_idi 枚 iii 种硬币，想购买 sss 的价值的东西．请问每次有多少种付款方法．

输入格式#

输入的第一行是五个整数，分别代表 c1,c2,c3,c4,nc_1,c_2,c_3,c_4, nc1,c2,c3,c4,n．

接下来 nnn 行，每行有五个整数，描述一次购买，分别代表 d1,d2,d3,d4,sd_1, d_2, d_3, d_4,sd1,d2,d3,d4,s．

输出格式#

对于每次购买，输出一行一个整数代表答案．

输入输出样例 #1#

输入 #1#

1
1 2 5 10 2
2
3 2 3 1 10
3
1000 2 2 2 900

输出 #1#

说明/提示#

数据规模与约定#

对于 100%100\%100% 的数据，保证 1≤ci,di,s≤1051 \leq c_i, d_i, s \leq 10^51≤ci,di,s≤105，1≤n≤10001 \leq n \leq 10001≤n≤1000．

我们发现这道题是一个物品数很少的多重背包问题，但显然，使用多重背包会超时．

因此，我们尝试将其转化为完全背包．

观察到完全背包和多重背包的区别只在于限制，我们先无视限制，跑一次完全背包．

1
dp[0] = 1;
2
for (int i = 1; i <= 4; i++) {
3
  for (int j = c[i]; j <= N; j++) {
4
    dp[j] += dp[j - c[i]];
5
  }
6
}

显然，这样的方案数比目标方案数大，多出了：

至少有 1 种数值的硬币超出限制

这样的方案．

为了计算出多出的方案数，我们可以使用容斥．定义 f(s)f(s)f(s) 表示第 iii 种硬币（sss 是一个集合且满足 i∈si \in si∈s）必须超出限制，其余不管．

则至少有 1 种数值的硬币超出限制的答案 ansansans ：

ans=f({1})+f({2})+f({3})+f({4})−(f({1,2})+f({1,3})+f({1,4})+f({2,3})+f({2,4})+f({3,4}))+f({1,2,3})+f({1,2,4})+f({1,3,4})+f({2,3,4})−f({1,2,3,4})\begin{align*} ans &= f(\{1\}) + f(\{2\}) + f(\{3\}) + f(\{4\})\\ &-(f(\{1,2\}) + f(\{1,3\}) + f(\{1,4\}) + f(\{2,3\}) + f(\{2,4\}) + f(\{3,4\}))\\ &+f(\{1,2,3\})+f(\{1,2,4\})+f(\{1,3,4\})+f(\{2,3,4\})\\ &-f(\{1,2,3,4\}) \end{align*} ans=f({1})+f({2})+f({3})+f({4})−(f({1,2})+f({1,3})+f({1,4})+f({2,3})+f({2,4})+f({3,4}))+f({1,2,3})+f({1,2,4})+f({1,3,4})+f({2,3,4})−f({1,2,3,4})

最终答案为：dp[s]−ansdp[s] - ansdp[s]−ans．

问题是，如何求 f(s)f(s)f(s)？

以 f({2,4})f(\{2,4\})f({2,4}) 为例，需要统计第 2 种和第 4 种硬币超出限制的方案数，那么，只需要固定第 2 种有 d[2]+1d[2]+1d[2]+1 个，用掉 (d[2]+1)×c[2](d[2] + 1) \times c[2](d[2]+1)×c[2] 元，第 4 种有 c[4]c[4]c[4] 个，用掉 (d[4]+1)×c[4](d[4] + 1) \times c[4](d[4]+1)×c[4] 元，将这些当成已知，剩余的需要分配的元数为 s′=s−(d[2]+1)×c[2]−(d[4]+1)×c[4]s' = s - (d[2] + 1) \times c[2] - (d[4] + 1) \times c[4]s′=s−(d[2]+1)×c[2]−(d[4]+1)×c[4]，f({2,4})f(\{2,4\})f({2,4}) 就等于 s′s's′．

标程

1
#include <bits/stdc++.h>
2
using namespace std;
3
#define int long long
4
const int N = 1e5 + 100;
5
int c1, c2, c3, c4, d1, d2, d3, d4, d5, s;
6
int dp[N], c[5], d[5];
7
// dp[i][j] 考虑到前i种硬币，总价值为j的方案数
8
// 不存在硬币超出 = 无限制 - (必须1种超出) + (必须2种超出) - (必须3种超出) +
9
// (必须4种超出)
10
signed main() {
11
    cin >> c[1] >> c[2] >> c[3] >> c[4];
12
    int T;
13
    cin >> T;
14
    dp[0] = 1;
15
    for (int i = 1; i <= 4; i++) {
16
        for (int j = c[i]; j <= N; j++) {
17
            dp[j] += dp[j - c[i]];
18
        }
19
    }
20
    while (T--) {
21
        cin >> d[1] >> d[2] >> d[3] >> d[4] >> s;
22
        int ans = 0;
23
        // 子集枚举
24
        for (int st = 0; st < (1 << 4); st++) {
25
            int cur = s, vaild = 0;
26
            for (int i = 0; i < 4; i++) {
27
                if (st & (1 << i)) {
28
                    vaild++;
29
                    cur -= (d[i + 1] + 1) * c[i + 1];
30
                }
31
            }
32
            if (cur >= 0)
33
                ans += (vaild % 2 ? -1 : 1) * dp[cur];
34
        }
35
        cout << ans << endl;
36
    }
37
}

展开收起

正难则反，正着思考问题没有结果不妨反过来思考．

安吉D4：容斥原理

Tue, 04 Aug 2026 00:00:00 GMT

容斥原理是组合数学中用于计数的一种基本方法，核心思想是：先不考虑重叠，把各种情况计数后，再减去重复计算的部分，加上被多减的部分，以此类推．

两个集合的情况

设有两个集合 AAA 和 BBB，我们想求它们的并集大小 ∣A∪B∣|A \cup B|∣A∪B∣．

直接加 ∣A∣+∣B∣|A| + |B|∣A∣+∣B∣ 会把中间重叠部分 ∣A∩B∣|A \cap B|∣A∩B∣ 算两次，所以需要减去一次：

∣A∪B∣=∣A∣+∣B∣−∣A∩B∣|A \cup B| = |A| + |B| - |A \cap B|∣A∪B∣=∣A∣+∣B∣−∣A∩B∣

三个集合的情况

∣A∪B∪C∣=∣A∣+∣B∣+∣C∣−∣A∩B∣−∣B∩C∣−∣A∩C∣+∣A∩B∩C∣|A \cup B \cup C| = |A| + |B| + |C| - |A \cap B| - |B \cap C| - |A \cap C| + |A \cap B \cap C|∣A∪B∪C∣=∣A∣+∣B∣+∣C∣−∣A∩B∣−∣B∩C∣−∣A∩C∣+∣A∩B∩C∣

规律：奇加偶减．即：

加 1 个集合的交集
减 2 个集合的交集
加 3 个集合的交集
……

一般形式#

设 A1,A2,…,AnA_1, A_2, \dots, A_nA1,A2,…,An 是有限集合，则：

∣⋃i=1nAi∣=∑k=1n(−1)k−1∑1≤i1<⋯<ik≤n∣Ai1∩Ai2∩⋯∩Aik∣\left| \bigcup_{i=1}^n A_i \right| = \sum_{k=1}^n (-1)^{k-1} \sum_{1 \le i_1 < \dots < i_k \le n} |A_{i_1} \cap A_{i_2} \cap \dots \cap A_{i_k}|i=1⋃nAi=k=1∑n(−1)k−11≤i1<⋯<ik≤n∑∣Ai1∩Ai2∩⋯∩Aik∣

使用补集：求“不满足任何性质”的元素个数#

正难则反，如果全集 UUU 中有一些“坏性质” P1,P2,…,PnP_1, P_2, \dots, P_nP1,P2,…,Pn，设 AiA_iAi 为满足性质 PiP_iPi 的元素集合，则不满足任何性质的元素个数为：

∣A1‾∩A2‾∩⋯∩An‾∣=∣U∣−∣⋃i=1nAi∣|\overline{A_1} \cap \overline{A_2} \cap \dots \cap \overline{A_n}| = |U| - \left| \bigcup_{i=1}^n A_i \right|∣A1∩A2∩⋯∩An∣=∣U∣−i=1⋃nAi

对于各个性质地位相等#

如果已知“各个性质彼此地位相等”，即对于选择一些性质后的交集大小只与性质的条数 kkk 有关，与这些性质具体是什么无关．我们就说这个问题是对称的．换句话说，交集的大小和性质的条数呈函数关系，不妨记交集的大小为 a(k)a(k)a(k)，故 a(k)a(k)a(k) 在 kkk 确定时为一定值，即

a(k)=∣Ai1∩Ai2∩⋯∩Aik∣(∀i1<⋯<ik)a(k)=|A_{i_1}\cap A_{i_2}\cap\cdots\cap A_{i_k}| \quad (\forall i_1<\dots<i_k)a(k)=∣Ai1∩Ai2∩⋯∩Aik∣(∀i1<⋯<ik)

则至少满足一个性质的元素个数：

∣⋃i=1nAi∣=∑k=1n(−1)k−1∑1≤i1<⋯<ik≤na(k)\Bigl|\bigcup_{i=1}^n A_i\Bigr| = \sum_{k=1}^n (-1)^{k-1} \sum_{1\le i_1<\dots<i_k\le n} a(k)i=1⋃nAi=k=1∑n(−1)k−11≤i1<⋯<ik≤n∑a(k)

内层对每个 kkk 都要枚举 (nk)\binom{n}{k}(kn) 个交集，总共 2n2^n2n 项．

由于内层的每个性质条数为 kkk 的交集都等于 a(k)a(k)a(k)，而性质条数为 kkk 的子集共有 (nk)\binom{n}{k}(kn) 个（一共 nnn 条性质），因此

∑1≤i1<⋯<ik≤n∣Ai1∩⋯∩Aik∣=(nk)a(k)\sum_{1\le i_1<\dots<i_k\le n} |A_{i_1}\cap\cdots\cap A_{i_k}| = \binom{n}{k} a(k)1≤i1<⋯<ik≤n∑∣Ai1∩⋯∩Aik∣=(kn)a(k)

代入上式得

∣⋃i=1nAi∣=∑k=1n(−1)k−1(nk)a(k)\boxed{\Bigl|\bigcup_{i=1}^n A_i\Bigr| = \sum_{k=1}^n (-1)^{k-1} \binom{n}{k} a(k)}i=1⋃nAi=k=1∑n(−1)k−1(kn)a(k)

项数立刻由 2n2^n2n 降为 nnn（实际对 kkk 从 111 到 nnn 求和）．这就是容斥原理的多项式形式．

依此，有补集形式：不满足任何性质的元素个数：

∣A1‾∩⋯∩An‾∣=∣U∣−∣⋃i=1nAi∣=∑k=0n(−1)k(nk)a(k)|\overline{A_1}\cap\cdots\cap\overline{A_n}| = |U| - \Bigl|\bigcup_{i=1}^n A_i\Bigr| = \sum_{k=0}^n (-1)^k \binom{n}{k} a(k)∣A1∩⋯∩An∣=∣U∣−i=1⋃nAi=k=0∑n(−1)k(kn)a(k)

其中规定 a(0)=∣U∣a(0)=|U|a(0)=∣U∣（选取 000 个性质即全集）．

经典例子：错位排列#

求 1,2,⋯ ,n1,2,\cdots ,n1,2,⋯,n 的排列 aaa 中满足 ai≠ia_i \neq iai=i 的排列数．

正难则反，可以定义性质 PiP_iPi：第 iii 位是 iii．显然对称．

a(k)a(k)a(k)：固定某 kkk 个位置不动，其余 n−kn-kn−k 个位置任意排列，故 a(k)=(n−k)!a(k)=(n-k)!a(k)=(n−k)!
∣U∣=n!|U|=n!∣U∣=n!

错位排列数：

Dn=∑k=0n(−1)k(nk)(n−k)!D_n = \sum_{k=0}^n (-1)^k \binom{n}{k} (n-k)!Dn=k=0∑n(−1)k(kn)(n−k)!

化简即为 Dn=n!∑k=0n(−1)kk!D_n = n! \sum_{k=0}^n \frac{(-1)^k}{k!}Dn=n!∑k=0nk!(−1)k，复杂度 O(n)O(n)O(n)．

二项式反演#

定义#

设我们有一个包含 nnn 个性质的集合．

fkf_kfk：恰好满足 kkk 个性质的元素个数．
gkg_kgk：钦定必须满足某 kkk 个特定性质的元素个数，但不关心其他性质是否满足．更准确地说，我们选定 kkk 个性质，强制要求元素满足这 kkk 个性质，而其余 n−kn-kn−k 个性质可以满足也可以不满足．从 nnn 个性质中选择 kkk 个来钦定有 (nk)\binom{n}{k}(kn) 种选择方案，因此我们定义 gkg_kgk 为所有 (nk)\binom{n}{k}(kn) 种选法的总和，即

gk=∑1≤i1<⋯<ik≤n∣{x:x 满足性质 Pi1,…,Pik}∣g_k = \sum_{1\le i_1<\dots<i_k\le n} \bigl|\{x : x \text{ 满足性质 } P_{i_1},\dots,P_{i_k}\}\bigr|gk=1≤i1<⋯<ik≤n∑{x:x 满足性质 Pi1,…,Pik}

如果问题是对称的， gkg_kgk 就等于 (nk)×a(k)\binom{n}{k} \times a(k)(kn)×a(k)．

关系推导#

任何一个恰好满足 iii 个性质的元素，在计算 gkg_kgk 时，会被重复计数．具体来说，若一个元素 xxx 恰好满足 iii 个性质（i≥ki \ge ki≥k），那么从这 iii 个性质中选出 kkk 个来“钦定”的方式有 (ik)\binom{i}{k}(ki) 种．即 xxx 会出现在 (ik)\binom{i}{k}(ki) 个钦定子集之中，它对每一个子集的贡献都为 1，因此它对 gkg_kgk 的贡献是 (ik)\binom{i}{k}(ki)．

于是有：

gk=∑i=kn(ik)fig_k = \sum_{i=k}^n \binom{i}{k} f_igk=i=k∑n(ki)fi

反演公式#

已知 gkg_kgk，想要求出 fkf_kfk，就需要反演上面的关系．二项式反演告诉我们：

fk=∑i=kn(−1)i−k(ik)gi\boxed{f_k = \sum_{i=k}^n (-1)^{i-k} \binom{i}{k} g_i}fk=i=k∑n(−1)i−k(ki)gi

常见应用#

错位排列：
- f0f_0f0 = 没有不动点的排列数（错排数 DnD_nDn）
- a(k)a(k)a(k) = 固定 kkk 个位置不动，其余任意排列的方法数 = (n−k)!(n-k)!(n−k)!
- 由 gk=(nk)(n−k)!g_k = \binom{n}{k}(n-k)!gk=(kn)(n−k)!，用反演求出 f0f_0f0．
组合计数：求恰好有 kkk 个指定特征的方案数．

安吉D4-B

Tue, 04 Aug 2026 00:00:00 GMT

原题呈现

题目描述#

小 Ω 在小学数学课上学到了“幂次”的概念：∀a,b∈N+\forall a, b \in \mathbb{N}^+∀a,b∈N+，定义 aba^bab 为 bbb 个 aaa 相乘．

她很好奇有多少正整数可以被表示为上述 aba^bab 的形式？由于所有正整数 m∈N+m \in \mathbb{N}^+m∈N+ 总是可以被表示为 m1m^1m1 的形式，因此她要求上述的表示中，必须有 b≥kb \geq kb≥k，其中 kkk 是她事先选取好的一个正整数．

因此她想知道在 111 到 nnn 中，有多少正整数 xxx 可以被表示为 x=abx = a^bx=ab 的形式，其中 a,ba, ba,b 都是正整数，且 b≥kb \geq kb≥k？

输入格式#

第一行包含两个正整数 n,kn, kn,k，意义如上所述．

输出格式#

输出一行包含一个非负整数表示对应的答案．

输入输出样例 #1#

输入 #1#

1
99 1

输出 #1#

1
99

输入输出样例 #2#

输入 #2#

1
99 3

输出 #2#

1
7

输入输出样例 #3#

输入 #3#

1
99 2

输出 #3#

1
12

说明/提示#

【样例 2 解释】

以下是全部 777 组符合题意的正整数及对应的一种合法的表示方法．

1=13,8=23,16=24,27=33,32=25,64=43,81=341 = 1^3, 8 = 2^3, 16 = 2^4, 27 = 3^3, 32 = 2^5, 64 = 4^3, 81 = 3^41=13,8=23,16=24,27=33,32=25,64=43,81=34

注意某些正整数可能有多种合法的表示方法，例如 646464 还可以表示为 64=2664 = 2^664=26．

但根据题意，同一个数的不同的合法表示方法只会被计入一次．

【样例 3 解释】

以下是全部 121212 组符合题意的正整数及对应的一种合法的表示方法．

1=12,4=22,8=23,9=32,16=42,25=52,27=33,32=25,36=62,49=72,64=82,81=92 1 = 1^2, 4 = 2^2, 8 = 2^3, 9 = 3^2, 16 = 4^2, 25 = 5^2, 27 = 3^3, 32 = 2^5, 36 = 6^2, 49 = 7^2, 64 = 8^2, 81 = 9^2 1=12,4=22,8=23,9=32,16=42,25=52,27=33,32=25,36=62,49=72,64=82,81=92

【数据范围】

对于所有数据，保证 1≤n≤10181 \leq n \leq 10^{18}1≤n≤1018，1≤k≤1001 \leq k \leq 1001≤k≤100．

测试点编号	n≤n \len≤	kkk
1	10210^2102	=1=1=1
2	^	≥2\ge2≥2
3	10410^4104	≥3\ge3≥3
4	^	≥2\ge2≥2
5	10610^6106	≥3\ge3≥3
6	^	≥2\ge2≥2
7	10810^8108	≥3\ge3≥3
8	^	≥2\ge2≥2
9	101010^{10}1010	≥3\ge3≥3
10	^	≥2\ge2≥2
11	101210^{12}1012	≥3\ge3≥3
12	^	≥2\ge2≥2
13	101410^{14}1014	≥3\ge3≥3
14	^	≥2\ge2≥2
15	101610^{16}1016	≥3\ge3≥3
16	^	≥2\ge2≥2
17	101810^{18}1018	≥3\ge3≥3
18	^	≥2\ge2≥2
19	^	^
20	^	^

不难得知，使用次方的逆运算 ⌊nk⌋\lfloor\sqrt[k]{n}\rfloor⌊kn⌋ 可以快速得知小于 nnn 的完全 kkk 次方数的数量．那么答案就是

∑i=klog⁡21018⌊ni⌋\sum_{i=k}^{\log_{2}10^{18}} \lfloor\sqrt[i]{n}\rfloori=k∑log21018⌊in⌋

对于 8 来说，它既是完全平方数，也是完全立方数，在 i=1i=1i=1 、 i=2i=2i=2 和 i=3i=3i=3 时都被算了一次，重复算了两次．为了去除这种重复，我们定义 f[i] 表示满足下列条件的正整数数量：

小于 nnn
是完全 kkk 次方数
不是完全 j×kj\times kj×k 次方数，j∈N,j>1j\in\mathbb{N}, j>1j∈N,j>1

因此，f[i] 的数值就等于满足条件 1 和 2 的正整数数量（即 ⌊nk⌋\lfloor\sqrt[k]{n}\rfloor⌊kn⌋）减去不满足条件 3 的正整数数量（log⁡21018≈60\log_{2}10^{18}\approx 60log21018≈60）：

f[i]=⌊nk⌋−1−∑j=k60f[i×j]f[i] = \lfloor\sqrt[k]{n}\rfloor - 1 - \sum_{j=k}^{60}f[i\times j]f[i]=⌊kn⌋−1−j=k∑60f[i×j]

上式中的 -1 是因为去除以 1 为底数的数，以 1 为底数，任意自然数为指数都为 1．所以每一次计算 ⌊nk⌋\lfloor\sqrt[k]{n}\rfloor⌊kn⌋，1 都会被算 1 遍，在这里减去，最后统一加 1．

最终答案为：1+∑i=k60f[i]1 + \sum_{i=k}^{60} f[i]1+∑i=k60f[i]．

标程

1
#include <bits/stdc++.h>
2
using namespace std;
3
typedef long long ll;
4
ll n, k, f[62], ans;
5
int main() {
6
    cin >> n >> k;
7

8
    for (int i = 60; i >= k; i--) {
9
        f[i] = powl(n, 1.0 / i) - 1;
10
        for (int j = 2; j * i <= 60; j++) {
11
            f[i] -= f[j * i];
12
        }
13
    }
14
    for (int i = k; i <= 60; i++) {
15
        ans += f[i];
16
    }
17
    cout << ans + 1;
18
}

展开收起

安吉D4-C

Tue, 04 Aug 2026 00:00:00 GMT

原题呈现

P5123 Cowpatibility G#

题目描述#

研究证明，有一个因素在两头奶牛能否作为朋友和谐共处这方面比其他任何因素都来得重要——她们是不是喜欢同一种口味的冰激凌！

Farmer John 的 NNN 头奶牛（2≤N≤5×1042\le N\le 5\times 10^42≤N≤5×104）各自列举了她们最喜欢的五种冰激凌口味的清单．为使这个清单更加精炼，每种可能的口味用一个不超过 10610^6106 的正整数 ID\texttt{ID}ID 表示．如果两头奶牛的清单上有至少一种共同的冰激凌口味，那么她们可以和谐共处．

请求出不能和谐共处的奶牛的对数．

输入格式#

输入的第一行包含 NNN．以下 NNN 行每行包含 555 个整数（各不相同），表示一头奶牛最喜欢的冰激凌口味．

输出格式#

输出不能和谐共处的奶牛的对数．

输入输出样例 #1#

输入 #1#

1
4
2
1 2 3 4 5
3
1 2 3 10 8
4
10 9 8 7 6
5
50 60 70 80 90

输出 #1#

1
4

说明/提示#

在这里，奶牛 444 不能和奶牛 111、222、333 中的任一头和谐共处，奶牛 111 和奶牛 333 也不能和谐共处．

或许直接求不能和谐共处的奶牛数量不好求，但是正难则反，我们可以先求能和谐共处的奶牛数量．

能和谐共处的奶牛数量 ansansans，就是至少有一种共同的冰淇淋的奶牛对数，通过容斥原理，我们在所有的冰淇凌口味，一共 tottottot 种，钦定 iii 种，一共有 (toti)\binom{tot}{i}(itot) 种钦定的方法．对于每一种钦定方案，我们统计所有的奶牛对，满足每一头奶牛的列表上都有钦定的 iii 种冰淇凌，这样的奶牛对数量，记为 fff，将 (toti)\binom{tot}{i}(itot) 种钦定的方法所得的 fff 取和，将其记为 gig_igi，则 ansansans 和 gig_igi 满足：

ans=g1−g2+g3−g4+g5ans=g_1-g_2+g_3-g_4+g_5ans=g1−g2+g3−g4+g5

在程序中，我们定义 cntTcnt_TcntT 用于记录子集 TTT 出现的数量，一开始，cntcntcnt 为空，遍历每一头奶牛，让这头奶牛尝试和前面的奶牛在不同钦定方案下组成奶牛对，具体来说，需要做以下事情：

遍历当前奶牛清单 sis_isi 的所有非空子集 TTT（即枚举钦定方案为 TTT）
- 将 ans 增加 (−1)∣T−1∣∗cntT(-1)^{|T-1|} * cnt_T(−1)∣T−1∣∗cntT
- 将 cntTcnt_TcntT 增加 1

最终答案就是 (n−1)×n/2−ans(n - 1) \times n / 2 - ans(n−1)×n/2−ans．

标程

1
#include <bits/stdc++.h>
2
using namespace std;
3
typedef long long ll;
4
const int N = 5e4 + 100;
5
ll ans;
6
int n;
7
vector<int> a[N];
8
map<vector<int>, int> cnt;
9

10
int main() {
11
    ios::sync_with_stdio(false);
12
    cin.tie(0);
13
    cout.tie(0);
14
    cin >> n;
15
    for (int i = 1; i <= n; i++) {
16
        for (int j = 1; j <= 5; j++) {
17
            int x;
18
            cin >> x;
19
            a[i].push_back(x);
20
        }
21
        sort(a[i].begin(), a[i].end());
22
    }
23
    ans = 1ll * (n - 1) * n / 2;
24
    for (int i = 1; i <= n; i++) {
25
        vector<int> vec;
26
        for (int k : a[i])
27
            vec.push_back(k);
28
        for (int st = 1; st <= (1 << 5) - 1; st++) {
29
            vector<int> now;
30
            for (int j = 0; j <= 4; j++) {
31
                if (st & (1 << j))
32
                    now.push_back(vec[j]);
33
            }
34
            ans += (now.size() % 2 ? -1 : 1) * cnt[now];
35
            cnt[now]++;
36
        }
37
    }
38
    cout << ans;
39
}

展开收起

安吉D3 模考2总结

Mon, 03 Aug 2026 00:00:00 GMT

得分情况#

预期得分：100+50+0+0

实际得分：70+40+0+20

Time Line#

8<30>~8<50> 看题面，初步了解
8<50>~10<00> 尝试 T1 大数据
10<00>10<50> 尝试 T2 Sub 12
10<50>~11<20> 尝试 T3 Sub 1
11<20>~12<00> 尝试 T4 Sub 2、4

挂分原因#

T1 T2 没有想到简单的方法，浪费时间太多
T1 T2 复杂方法过绕，没有考虑到边界
T2 题意理解偏差
T3 T4 在时间紧缺时没有进行充分思考就动手．

收获#

增进了离线处理的代码能力
增进了哈希的代码能力

安吉D3-T1

Mon, 03 Aug 2026 00:00:00 GMT

原题呈现

题目描述#

书上记载，这两串密语可能拥有共同的“基础咒语”．如果一个短咒语 ttt 可以通过将自身连续拼接多次来完全构成字符串 s1s_1s1，同时也可以通过连续拼接多次完全构成字符串 s2s_2s2（即 ttt 同时是 s1s_1s1 和 s2s_2s2 的循环节，或称为公共除数），那么 ttt 就是一个合法的“基础咒语”．

小信想要彻底解开魔法书的秘密，他需要计算出，到底有多少个不同的字符串 ttt 能够同时满足上述条件？

输入格式#

第一行包含一个字符串 s1s_1s1．

第二行包含一个字符串 s2s_2s2．

保证两个字符串均只包含小写英文字母，且中间没有空格．

输出格式#

输出一行一个整数，表示满足条件的字符串 ttt 的数量．如果不存在这样的字符串 ttt，则输出 0．

样例#

输入 #1#

1
abcdabcd
2
abcdabcdabcdabcd

输出 #1#

1
2

样例解释#

对于样例 # 1，满足条件的“基础咒语” ttt 有两个：

abcd：拼接 2 次可得 s1s_1s1，拼接 4 次可得 s2s_2s2．
abcdabcd：拼接 1 次可得 s1s_1s1，拼接 2 次可得 s2s_2s2．

数据范围#

Subtask	分值	数据范围	特殊性质
1	30	1≤s1,s2≤1031\le s_1, s_2 \le 10^31≤s1,s2≤103	无
2	30	1≤s1,s2≤1051\le s_1, s_2 \le 10^51≤s1,s2≤105	保证两个字符串都由同一个较短字符串重复得到
3	40	1≤s1,s2≤1071\le s_1, s_2 \le 10^71≤s1,s2≤107	无

由题意可得，这两个字符串 s1s_1s1、s2s_2s2 的循环节的长度，一定是原来两个字符串长度最大公因数的因数．

因此，尝试枚举循环节的长度：

1
int maxLen = gcd(sx.size(), sy.size());
2
vector<int> fac;
3
for (int i = 1; i <= sqrt(maxLen); i++) {
4
  if (maxLen % i == 0) {
5
    fac.push_back(i);
6
    if (i * i != maxLen) {
7
      fac.push_back(maxLen / i);
8
    }
9
  }
10
}

对于每一个长度 ddd，只需要验证：

s1[0..d−1]s_1[0..d-1]s1[0..d−1] 是 s1s_1s1（设长度为 nnn）的循环节，即 s1s_1s1 去掉前面一节循环节和去掉后面一节循环节是相同的：s1[0,n−d−1]=s1[d,n−1]s_1[0, n - d - 1] = s_1[d, n - 1]s1[0,n−d−1]=s1[d,n−1]
s2[0..d−1]s_2[0..d-1]s2[0..d−1] 是 s2s_2s2 的循环节，同上．
s1[0..d−1]=s2[0..d−1]s_1[0..d-1]=s_2[0..d-1]s1[0..d−1]=s2[0..d−1]

所有的字符串判等可以使用哈希优化。

标程

以下标程使用双哈希来快速进行字符串判等。

1
#include <bits/stdc++.h>
2
using namespace std;
3
#define int long long
4
const int BASE = 128;
5
const int MOD1 = 1e9 + 7;
6
const int MOD2 = 1e9 + 9;
7
const int N = 1e7 + 10;
8
int la1[N], la2[N], lb1[N], lb2[N], p1[N], p2[N];
9
string sx, sy;
10

11
struct Hash {
12
    int *h;
13
    int *p;
14
    int MOD;
15
    Hash(int *h, int *p, int MOD) {
16
        this->h = h;
17
        this->p = p;
18
        this->MOD = MOD;
19
    }
20
    void init(string &str) {
21
        p[0] = 1;
22
        for (int i = 1; i <= str.size(); i++) {
23
            (h[i] = 1ll * h[i - 1] * BASE % MOD + str[i - 1]) %= MOD;
24
            p[i] = p[i - 1] * BASE % MOD;
25
        }
26
    }
27
    /**
28
     * 获取子串 hash，0-based
29
     */
30
    int get(int l, int r) {
31
        r++, l++; // 转成 1-based
32
        return (h[r] - (1ll * h[l - 1] * p[r - l + 1] % MOD) + MOD) % MOD;
33
    }
34
};
35

36
Hash hx1(la1, p1, MOD1), hx2(la2, p2, MOD2), hy1(lb1, p1, MOD1),
37
    hy2(lb2, p2, MOD2);
38

39
int gcd(int a, int b) {
40
    if (b == 0)
41
        return a;
42
    return gcd(b, a % b);
43
}
44

45
signed main() {
46
    freopen("magic.in", "r", stdin);
47
    freopen("magic.out", "w", stdout);
48

49
    cin >> sx >> sy;
50
    hx1.init(sx), hx2.init(sx), hy1.init(sy), hy2.init(sy);
51
    int maxLen = gcd(sx.size(), sy.size());
52
    vector<int> fac;
53
    for (int i = 1; i <= sqrt(maxLen); i++) {
54
        if (maxLen % i == 0) {
55
            fac.push_back(i);
56
            if (i * i != maxLen) {
57
                fac.push_back(maxLen / i);
58
            }
59
        }
60
    }
61
    int ans = 0;
62
    for (int i = 0; i < fac.size(); i++) {
63
        int len = fac[i];
64
        // 判断是否是循环节
65
        if (!(hx1.get(0, sx.size() - len - 1) == hx1.get(len, sx.size() - 1) &&
66
              hx2.get(0, sx.size() - len - 1) == hx2.get(len, sx.size() - 1)))
67
            continue;
68

69
        if (!(hy1.get(0, sy.size() - len - 1) == hy1.get(len, sy.size() - 1) &&
70
              hy2.get(0, sy.size() - len - 1) == hy2.get(len, sy.size() - 1)))
71
            continue;
72

73
        // 判断循环节是否在两个子串中都相等
74
        if (!(hx1.get(0, len - 1) == hy1.get(0, len - 1) &&
75
              hx2.get(0, len - 1) == hy2.get(0, len - 1)))
76
            continue;
77
        ans++;
78
    }
79
    cout << ans;
80
}

展开收起

一般的，对循环节的判断可以使用哈希轻松解决。

安吉D3-T2

Mon, 03 Aug 2026 00:00:00 GMT

原题呈现

题目描述#

巴蜀地区的地势非常崎岖，山峰耸立．我们将每座山峰依次编号为 111 到 nnn，第 iii 座山峰的高度为 hih_ihi．

总共 mmm 支施工队，每支施工队的能力各不相同——有些擅长高空作业，有些擅长隧道构建．每支施工队有两个参数：

aia_iai：最高能施工的高度（即可以处理不超过该高度的山峰）；
bib_ibi：最长能修建的隧道长度（即最多可以连续炸掉 bi−1b_i - 1bi−1 座山来修建隧道，因为出口和入口需要额外加固）．

施工队需要从起点 111 出发，修建一条直达 nnn 的道路．我们规定 111 号和 nnn 号都是平地（高度为 000）．

施工队可以从任意一个不超过最高施工高度的高度开始，修建一条高架和隧道结合的道路．一旦确定了道路的初始高度，整条道路的高度就不能再有任何变化．因此：

如果某座山峰的高度低于或等于施工高度，则只需正常修建高架即可；
如果某座山峰的高度高于施工高度，则必须炸山修隧道（即施工队需要在这座山上打通隧道）．

请判断每支施工队是否能够胜任这项工作．

输入格式#

第一行包含两个空格分隔的整数 nnn 和 mmm．第二行包含 nnn 个空格分隔的整数，其中第 iii 个为 hih_ihi（第 iii 座山峰的高度）．接下来 mmm 行，每行包含两个空格分隔的整数 aia_iai 和 bib_ibi，代表第 iii 支施工队的最大施工高度和最长隧道长度．

输出格式#

输出共 mmm 行．第 iii 行输出一个整数：如果第 iii 支施工队能够胜任工作，则为 1，否则为 0．

样例#

输入 #1#

1
8 7
2
0 3 8 5 6 9 0 0
3
0 5
4
0 6
5
6 2
6
8 1
7
10 1
8
5 3
9
150 7

输出 #1#

数据范围#

数据点	分值	限制
1	40 pts	0≤n,m≤50000 \le n, m \le 50000≤n,m≤5000，1≤hi,ai≤1061 \le h_i, a_i \le 10^61≤hi,ai≤106
2	10 pts	额外满足 ai≤ai+1a_i \le a_{i+1}ai≤ai+1 且 bi≤bi+1b_i \le b_{i+1}bi≤bi+1
3	100 pts	0≤n,m≤1050 \le n, m \le 10^50≤n,m≤105，1≤hi,ai≤1091 \le h_i, a_i \le 10^91≤hi,ai≤109，1≤bi≤n−11 \le b_i \le n-11≤bi≤n−1

题意可以理解为：求一段序列中一段最大的连续区间 sss，满足：sss 内每一个数都大于 aia_iai，求 sss 的大小 lsl_sls，将其和 bib_ibi 比大小，且多测．

考虑到每个施工队施工的高度越高，障碍越少，且消失的障碍不会回复，因而所需要的 bib_ibi 也越少．

用一个更加形象的例子，现在有 nnn 道题，mmm 个学生，每个学生有一个能力值 aia_iai，有一个耐力值 b1b_1b1，每道题有一个难度 hjh_jhj，现在，让每一名学生来做这些题目，若 ∃j\exists j∃j 使得 ai<hja_i < h_jai<hj，则这名学生做不出来第 jjj 道题，若有连续 bi−1b_i-1bi−1 道题这位学生都做不出来，这位学生就会崩溃，求这位学生会不会崩溃．

显然，如果学生 s1s_1s1 做不出来题目 iii，那么能力弱于 s1s_1s1 的 s2s_2s2 也肯定做不出来题目 iii．

因此使用离线处理．将每一次询问（即每一个施工队）按 aia_iai 从高到低排序，将每一座山也按照高度从高到低排序．模拟一个收容山的并查集，用于记录已经对当前施工队产生影响的障碍，一开始，并查集为空，设未加入并查集且最高的山是第 mmm 座，高度为 hmh_mhm，则对于每一次询问：

检查 aia_iai 和 hmh_mhm 的大小关系
- 若当前询问的 aia_iai 比 hmh_mhm 大或等于（即第 mmm 座山，也就是未记录的最高的山都无法对该施工队增加障碍），跳过这个阶段．
- 否则，说明第 mmm 座山成为该施工队施工的新的障碍（由于施工队按照 aia_iai 从高到低排列，对靠前者造成影响的山，也会对靠后者造成影响），将 mmm 加入并查集，且与第 m−1m-1m−1 座和第 m+1m+1m+1 座（如果已经加入并查集的话）合并，并维护每个集合的左边界 lll 和右边界 rrr，统计最大的区间 maxmaxmax（初始由于没有山加入到并查集，所以是 0）．重复这个操作，直到当前询问的 aia_iai 比 hmh_mhm 大或等于．
将 ans[i]ans[i]ans[i] 设置为 maxmaxmax．

标程

1
#include <bits/stdc++.h>
2
using namespace std;
3
const int N = 1e5 + 100;
4
int n, m, maxb, ans[N];
5

6
struct Mout {
7
    int h, id;
8
    friend bool operator<(const Mout a, const Mout b) { return a.h > b.h; }
9
};
10

11
struct Team {
12
    int h, b, id;
13
    friend bool operator<(const Team a, const Team b) { return a.h > b.h; }
14
};
15

16
struct Node {
17
    int fa, l, r;
18
} d[N];
19

20
// 并查集
21
struct DSU {
22
    Node *d;
23
    DSU(Node *d) : d(d) {};
24
    // 将节点 x 加入到并查集之中
25
    void active(int x) {
26
        d[x].fa = x;
27
        d[x].l = x, d[x].r = x;
28
        maxb = max(maxb, 1);
29
    }
30
    int find(int x) {
31
        if (d[x].fa == x)
32
            return x;
33
        d[x].fa = find(d[x].fa);
34
        return d[x].fa;
35
    }
36
    void merge(int a, int b) {
37
        a = find(a), b = find(b);
38
        if (a == b)
39
            return;
40
        d[a].fa = b;
41
        d[b].l = min(d[b].l, d[a].l);
42
        d[b].r = max(d[b].r, d[a].r);
43
        maxb = max(maxb, d[b].r - d[b].l + 1);
44
    }
45
} dsu(d);
46

47
Mout h[N];
48
Team a[N];
49
int main() {
50
    freopen("mountain.in", "r", stdin);
51
    freopen("mountain.out", "w", stdout);
52
    cin >> n >> m;
53
    for (int i = 1; i <= n; i++) {
54
        cin >> h[i].h;
55
        h[i].id = i;
56
    }
57
    for (int i = 1; i <= m; i++) {
58
        cin >> a[i].h >> a[i].b;
59
        a[i].id = i;
60
    }
61
    sort(h + 1, h + n + 1);
62
    sort(a + 1, a + m + 1);
63
    int ptr = 0;
64
    for (int i = 1; i <= m; i++) {
65
        int reqH = a[i].h;
66
        while (h[ptr + 1].h > reqH) {
67
            ptr++;
68
            int curId = h[ptr].id;
69
            dsu.active(curId);
70
            if (dsu.d[curId + 1].fa)
71
                dsu.merge(curId, curId + 1);
72
            if (dsu.d[curId - 1].fa)
73
                dsu.merge(curId, curId - 1);
74
        }
75
        ans[a[i].id] = ((maxb <= a[i].b - 1) ? 1 : 0);
76
    }
77
    for (int i = 1; i <= m; i++) {
78
        cout << ans[i] << endl;
79
    }
80
}

展开收起

实际上，对于多次询问，若存在：

如果询问 s1s_1s1 中，元素 e1e_1e1 会对该询问的结果产生影响，那么对于所有弱于（或强于） s1s_1s1 的 s2s_2s2 ，元素 e1e_1e1 会对该询问的结果产生影响．

可以考虑使用离线处理 + 排序解决，此时处理后者时可以保留对前者的影响．

安吉D3-T4

Mon, 03 Aug 2026 00:00:00 GMT

原题呈现

题目描述#

给定两个长度均为 nnn 的字符串 S,TS, TS,T，它们都只包含小写英文字母．

另外给定 mmm 条转换规则，第 iii 条规则由三个量组成：

字符串 AiA_iAi
字符串 BiB_iBi
代价 CiC_iCi

并且保证字符串 AiA_iAi 与 BiB_iBi 的长度相同，CiC_iCi 是正整数．

一次操作中，你可以选择当前字符串中的一个区间 [l,r][l, r][l,r]，若该区间对应的子串恰好等于某个 AiA_iAi，则可以花费 CiC_iCi 的代价，将这一段替换为 BiB_iBi．

你可以进行任意多次操作，但所有操作所选择的区间必须满足下面条件之一：

两次操作所选区间完全相同；
两次操作所选区间没有公共位置．

也就是说，若两次操作作用在不同区间上，则这两个区间不能有任何重叠；若有重叠，则它们必须是同一个区间．

请你求出将字符串 SSS 变为字符串 TTT 的最小总代价．若无法完成转换，输出 −1-1−1．

输入格式#

第一行一个字符串 SSS．第二行一个字符串 TTT．第三行一个整数 mmm，表示转换规则的条数．接下来 mmm 行，每行输入两个字符串 Ai,BiA_i, B_iAi,Bi 和一个整数 CiC_iCi，表示一条规则．

输出格式#

输出一个整数，表示将 SSS 转换为 TTT 的最小总代价．如果无解，输出 −1-1−1．

样例#

样例 1#

输入

1
abcd
2
acbe
3
6
4
a b 2
5
b c 5
6
c b 5
7
c e 1
8
e b 2
9
d e 20

输出

1
28

样例 2#

输入

1
abcdefgh
2
acdeeghh
3
3
4
bcd cde 1
5
fgh thh 3
6
thh ghh 5

输出

1
9

样例 3#

输入

1
abcdefgh
2
addddddd
3
2
4
bcd ddd 100
5
defgh ddddd 1578

输出

1
-1

样例解释#

样例 1#

一种最优方案如下：

把位置 222 上的 b 变成 c，代价 555；
把位置 333 上的 c 变成 e，代价 111；
再把位置 333 上的 e 变成 b，代价 222；
把位置 444 上的 d 变成 e，代价 202020．

总代价为 5+1+2+20=285 + 1 + 2 + 20 = 285+1+2+20=28．注意第三步与第二步作用在同一个区间，因此是允许的．

样例 2#

可以按如下方式转换：

将区间 [2,4][2,4][2,4] 的 bcd 变为 cde，代价 111；
将区间 [6,8][6,8][6,8] 的 fgh 变为 thh，代价 333；
再将区间 [6,8][6,8][6,8] 的 thh 变为 ghh，代价 555．

前一次和后两次操作分别作用在两个互不相交的区间上，因此合法；后两次操作作用在同一个区间上，也合法．

总代价为 1+3+5=91 + 3 + 5 = 91+3+5=9．这也是最小代价．

样例 3#

若先把区间 [2,4][2,4][2,4] 的 bcd 变成 ddd，那么之后若想再处理区间 [4,8][4,8][4,8]，这两个区间会在位置 444 发生重叠，但它们并不是同一个区间，因此不合法．反过来，若先处理区间 [4,8][4,8][4,8]，再处理区间 [2,4][2,4][2,4]，同样会产生非法重叠．因此无论怎样都无法得到目标串，答案为 −1-1−1．

数据范围#

对于所有数据，满足：

1≤n≤500001 \le n \le 500001≤n≤50000
1≤m≤1001 \le m \le 1001≤m≤100
1≤∣Ai∣=∣Bi∣≤n1 \le |A_i| = |B_i| \le n1≤∣Ai∣=∣Bi∣≤n
1≤Ci≤1051 \le C_i \le 10^51≤Ci≤105
字符串仅由小写字母组成．

测试点编号	n≤n \len≤	m≤m \lem≤	特殊限制
1,2	101010	101010	-
3,4,5	100010001000	100100100	所有规则长度为 111
6,7,8	100010001000	100100100	所有规则长度 ≤50\le 50≤50
9,10	500005000050000	100100100	所有规则长度为 111
11~14	500005000050000	100100100	所有规则长度 ≤50\le 50≤50
15~20	500005000050000	100100100	-

观察所谓的转换规则：给定一个起始字符串，一个终点字符串，和一个将起始字符串转换为终点字符串的权值，可以将其想象成一条单项边，使用哈希将两个字符串离散成两个数字，并使用 map 映射到点的编号．

因此，对于所有的转换规则，可以将其看作是一张图，只需要在图上跑一边 floyd，就可以在 O(1)O(1)O(1) 得知两个字符串之间的权值，floyd 时间复杂度 O(m3)O(m^3)O(m3)．

紧接着，观察这个 nnn 的范围，可以使用 dp，定义 dp[i] 表示 sss 和 ttt 的前 iii 个字符相等（即：s[0..i-1] = t[0..i-1]）所需要的代价，有初始状态：

1
dp[0] = 0;

有转移方程：

dp[i]=min⁡len=1idp[i−len]+cost(i−len+1,i)dp[i] = \min^{i}_{len=1} dp[i-len] + cost(i-len+1, i)dp[i]=len=1minidp[i−len]+cost(i−len+1,i)

其中，cost(l,r)cost(l,r)cost(l,r) 指通过一次变换操作将 s[l..r]s[l..r]s[l..r] 变为 t[l..r]t[l..r]t[l..r] 所需要的代价，可以先预处理出 sss 和 ttt 的哈希，再将两者进行子串哈希为数字 hlhlhl 和 hrhrhr，复杂度 O(1)O(1)O(1)，再通过 map 找到点的编号 aaa 和 bbb，最后查询 floyd 得到的 dis 数组，cost(l,r)=dis[a][b]cost(l,r)=dis[a][b]cost(l,r)=dis[a][b]．当然，如果查询不到 aaa 和 bbb（map[hl]map[hl]map[hl] 或 map[lr]map[lr]map[lr] 为 0），或者说 aaa 到 bbb 没有连边，这个转移方程就不成立．

最终状态：dp[s.size()]．

你会发现，这个 dp 是 O(n2)O(n^2)O(n2) 的，怎么优化呢？不难发现，一共只有 mmm 条规则，每条规则只有一个起始字符串，也就是说最多只有 mmm 个起始字符串，也就是说，这些字符串的长度最多只有 mmm 种，因此，在上述转换方程中，lenlenlen 不需要从 111 枚举到 iii，只需要遍历所有字符串长度组成的集合 len_set（举个例子，看测试点 3~5，所有的起始字符串长度都是 1，因此 len_set 中只有 1，len 也只需要取到 1，取到别的是浪费时间的操作），时间复杂度 O(nm)O(nm)O(nm)．

看着不错，交一发试试．恭喜你，被卡常了．

这里有一些卡常小技巧：

能不用 long long 就不用．
使用快读快写．
少用 STL 的迭代器，对于 set 和 map 可以转成 vector 之后使用下标读写．
减少 vector 申请空间的次数．

标程

1
#include <bits/stdc++.h>
2
using namespace std;
3
const int BASE = 128;
4
const int N = 50005;
5
const int M = 2 * 105;
6
const int MOD = 1e9 + 7;
7
const int INF = 0x3f3f3f3f;
8
string s, t;
9
int m, dis[M][M], cnt;
10
map<int, int> g;
11
set<int> len_set;
12
int dp[N]; // dp[i] 表示前 i 个字符相等的代价
13
int sh[N], th[N];
14
int p[N];
15

16
// 哈希函数，针对字符串
17
int hs(string &str) {
18
    int h = 0;
19
    for (int i = 1; i <= str.size(); i++) {
20
        (h = 1ll * h * BASE % MOD + str[i - 1]) %= MOD;
21
    }
22
    return h % MOD;
23
}
24

25
// 哈希函数，针对子串
26
int hs(int *h, int l, int r) {
27
    return (h[r] - (1ll * h[l - 1] * p[r - l + 1] % MOD) + MOD) % MOD;
28
}
29

30
// 计算[l,r]的花费，1-based
31
int cost(int l, int r) {
32
    int a = g[hs(sh, l, r)];
33
    int b = g[hs(th, l, r)];
34
    if (a == 0 || b == 0)
35
        return INF;
36
    return dis[a][b];
37
}
38

39
signed main() {
40
    freopen("string.in", "r", stdin);
41
    freopen("string.out", "w", stdout);
42
    ios::sync_with_stdio(false);
43
    cin.tie(0);
44
    cout.tie(0);
45
    cin >> s >> t >> m;
46
    memset(dis, 0x3f, sizeof(dis));
47
    // 预处理哈希
48
    p[0] = 1;
49
    for (int i = 1; i <= s.size(); i++) {
50
        sh[i] = (1ll * sh[i - 1] * BASE + s[i - 1]) % MOD;
51
    }
52
    for (int i = 1; i <= t.size(); i++) {
53
        th[i] = (1ll * th[i - 1] * BASE + t[i - 1]) % MOD;
54
        p[i] = 1ll * p[i - 1] * BASE % MOD;
55
    }
56
    // 建图
57
    for (int i = 1; i <= m; i++) {
58
        string a, b;
59
        int c;
60
        cin >> a >> b >> c;
61
        len_set.insert(a.size());
62
        int ha = hs(a), hb = hs(b);
63
        if (g[ha] == 0)
64
            g[ha] = ++cnt;
65
        if (g[hb] == 0)
66
            g[hb] = ++cnt;
67
        int x = g[ha], y = g[hb];
68
        dis[x][y] = min(dis[x][y], c);
69
    }
70
    // floyd
71
    for (int i = 1; i <= cnt; i++) {
72
        dis[i][i] = 0;
73
    }
74
    for (int k = 1; k <= cnt; k++) {
75
        for (int i = 1; i <= cnt; i++) {
76
            for (int j = 1; j <= cnt; j++) {
77
                dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
78
            }
79
        }
80
    }
81
    vector<int> len;
82
    for (auto i : len_set)
83
        len.push_back(i);
84
    // 开始 DP
85
    memset(dp, 0x3f, sizeof(dp));
86
    dp[0] = 0;
87
    for (int i = 1; i <= s.size(); i++) {
88
        if (s[i - 1] == t[i - 1]) {
89
            dp[i] = min(dp[i], dp[i - 1]);
90
        }
91
        for (int j : len) {
92
            if (i - j >= 0) {
93
                int c = cost(i - j + 1, i);
94
                if (c >= INF)
95
                    continue;
96
                dp[i] = min(dp[i], dp[i - j] + c);
97
            }
98
        }
99
    }
100
    if (dp[s.size()] < INF)
101
        cout << dp[s.size()];
102
    else {
103
        cout << -1;
104
    }
105
}

展开收起

字符串问题可以通过哈希 + map 离散化转换为数字问题．

安吉D2 模考1总结

Sun, 02 Aug 2026 00:00:00 GMT

得分情况#

预期得分：100+25+18+40

实际得分：100+25+11+40

Time Line#

8<30>~8<50> 看题面，初步了解
8<50>~9<30> 尝试 T1 小数据
9<30>~10<30> 尝试 T1 大数据
10<30>~11<00> 尝试 T2 子任务 1、2
11<00>~11<30> 尝试 T3 子任务 3、4
11<30>12<05> 尝试 T4 子任务 14

挂分原因#

T3 子任务 4 特殊情况（n=2n=2n=2）没有想到．

收获#

学会了更多分治的小技巧

安吉D2-T2

Sun, 02 Aug 2026 00:00:00 GMT

原题呈现

P11261 直方图 Histogram#

题目描述#

给定笛卡尔坐标系中的直方图，宽度为 nnn，第 iii 格的高度为 hih_ihi．也就是说，对于 ∀1≤i≤n\forall 1\le i\le n∀1≤i≤n，第 iii 格所占矩形的顶点坐标分别为 (i−1,0),(i,0),(i−1,hi),(i,hi)(i-1,0),(i,0),(i-1,h_i),(i,h_i)(i−1,0),(i,0),(i−1,hi),(i,hi)．

给定正整数 ppp，求出满足以下条件的矩形的数量：

矩形的四个顶点的坐标均为整数；
矩形有一条边在 xxx 轴上；
矩形完全位于直方图内部（可以与边界相切）；
矩形的面积至少为 ppp．

输入格式#

第一行，两个正整数 n,pn,pn,p．

第二行，nnn 个正整数 h1,h2,…,hnh_1,h_2,\ldots,h_nh1,h2,…,hn．

输出格式#

输出一行一个整数，表示答案．

输入输出样例 #1#

输入 #1#

1
6 9
2
1 4 4 5 2 3

输出 #1#

1
3

输入输出样例 #2#

输入 #2#

1
10 5
2
3 6 1 3 2 1 5 3 4 2

输出 #2#

1
31

说明/提示#

样例解释#

样例一解释：

数据范围#

对于 100%100\%100% 的数据，保证：

1≤n≤1051\le n\le 10^51≤n≤105；
1≤p≤10141\le p\le 10^{14}1≤p≤1014；
1≤hi≤1091\le h_i\le 10^{9}1≤hi≤109．

子任务编号	n≤n\le n≤	ppp	hi≤h_i\lehi≤	得分
111	3 0003\, 0003000	≤1012\le 10^{12}≤1012	109 10^9109	101010
222	10510^5105	≤108\le 10^8≤108	1 0001\, 0001000	151515
333	105 10^5105	=1=1=1	10910^9109	151515
444	105 10^5105	≤105\le 10^5≤105	10910^9109	25 2525
555	105 10^5105	≤1014\le 10^{14}≤1014	10910^9109	353535

思路#

由于高度最小的一项是瓶颈，考虑以高度最小的一项为中点，先计算出左端点在中点左边，右端点在中点右边的方案数，再分治，分左半边和右半边两个子问题分别考虑．

在处理子问题 [l,r][l, r][l,r] 时，首先，使用 ST 表计算出 [l,r][l,r][l,r] 中最小的一项 limlimlim，其下表为 mmm．若 mmm 左边的元素数量更小，考虑枚举起点 iii，假定终点为 jjj，则有方案数为：

∑i=lm∑j=rrmax{lim−⌈pj−i+1⌉+1,0}\sum^{m}_{i=l}\sum^{r}_{j=r}max\{lim - \lceil\frac{p}{j-i+1}\rceil + 1, 0\}i=l∑mj=r∑rmax{lim−⌈j−i+1p⌉+1,0}

想想如何去掉 maxmaxmax．

当 lim−⌈pj−i+1⌉+1≥0lim - \lceil\frac{p}{j-i+1}\rceil + 1 \geq 0lim−⌈j−i+1p⌉+1≥0 时，就有：

lim−⌈pj−i+1⌉≥0lim≥⌈pj−i+1⌉lim×(j−i+1)≥pj−i+1≥plimj≥plim−1+i\begin{align*} lim - \lceil\frac{p}{j-i+1}\rceil &\geq 0\\ lim &\geq\lceil\frac{p}{j-i+1}\rceil\\ lim \times(j - i + 1) &\geq p\\ j - i + 1 &\geq \frac{p}{lim}\\ j&\geq\frac{p}{lim} - 1 + i\\ \end{align*} lim−⌈j−i+1p⌉limlim×(j−i+1)j−i+1j≥0≥⌈j−i+1p⌉≥p≥limp≥limp−1+i

由于 j∈Nj\in\mathbb{N}j∈N，所以：

j≥⌈plim⌉−1+ij\geq\lceil\frac{p}{lim}\rceil - 1 + ij≥⌈limp⌉−1+i

令：need=⌈plim⌉−1+ineed = \lceil\frac{p}{lim}\rceil - 1 + ineed=⌈limp⌉−1+i

则原式化简为：

∑i=lm∑j=needr(lim−⌈pj−i+1⌉+1)∑i=lm(∑j=needr(lim+1)−∑j=needr(⌈pj−i+1⌉))\begin{align*} \sum^{m}_{i=l}\sum^{r}_{j=need}(lim - \lceil\frac{p}{j-i+1}\rceil + 1)\\ \sum^{m}_{i=l}(\sum^{r}_{j=need}(lim + 1) - \sum^{r}_{j=need}(\lceil\frac{p}{j-i+1}\rceil)) \end{align*} i=l∑mj=need∑r(lim−⌈j−i+1p⌉+1)i=l∑m(j=need∑r(lim+1)−j=need∑r(⌈j−i+1p⌉))

只需要使用前缀和记录 ⌈pi⌉\lceil\frac{p}{i}\rceil⌈ip⌉，就可以在 O(n)O(n)O(n) 的时间里算出上式．

若 mmm 右边的元素数量更小，也是同理，考虑枚举终点为 jjj，假定起点为 iii，则若令 need=j+1−⌈plim⌉need = j + 1 - \lceil\frac{p}{lim}\rceilneed=j+1−⌈limp⌉

原式化简为：

∑j=1m(∑i=lneed(lim+1)−∑i=lneed(⌈pj−i+1⌉))\sum^{m}_{j=1}(\sum^{need}_{i=l}(lim + 1) - \sum^{need}_{i=l}(\lceil\frac{p}{j-i+1}\rceil))j=1∑m(i=l∑need(lim+1)−i=l∑need(⌈j−i+1p⌉))

1
#include <bits/stdc++.h>
2
#define int long long
3
using namespace std;
4
#define querySum(l, r) (sum[(r)] - sum[(l) - 1])
5

6
const int N = 1e5 + 100;
7

8
int n, p, h[N], sum[N], ans;
9

10
struct Node {
11
    int n;
12
    int id;
13
    friend bool operator<(const Node a, const Node b) { return a.n < b.n; }
14
} st[N][20];
15

16
Node query(int l, int r) {
17
    int len = log2(r - l + 1);
18
    return min(st[l][len], st[r - (1 << (len)) + 1][len]);
19
}
20

21
int ceilDivided(int a, int b) {
22
    double da = 1.0 * a / b;
23
    int ia = a / b;
24
    if (da != (double)ia) {
25
        da++;
26
    }
27
    return da;
28
}
29

30
void solve(int l, int r) {
31
    if (l > r) {
32
        // 不可能存在合法方案
33
        return;
34
    }
35
    if (l == r) {
36
        // 仅一竖条
37
        ans += max(0ll, h[l] - p + 1);
38
        return;
39
    }
40
    int m = query(l, r).id;
41
    int lim = h[m];
42
    // 处理跨过中间的
43
    if (m - l < r - m) {
44
        // 左边更少一点
45
        for (int i = l; i <= m; i++) {
46
            int j0 = max(m, ceilDivided(p, lim) + i - 1);
47
            if (j0 <= r)
48
                ans +=
49
                    (lim + 1) * (r - j0 + 1) - querySum(j0 - i + 1, r - i + 1);
50
        }
51
    } else {
52
        // 右边更少一点
53
        for (int j = m; j <= r; j++) {
54
            int i0 = min(m, j + 1 - ceilDivided(p, lim));
55
            if (l <= i0)
56
                ans +=
57
                    (lim + 1) * (i0 - l + 1) - querySum(j - i0 + 1, j - l + 1);
58
        }
59
    }
60
    // 处理只在两边的
61
    solve(l, m - 1);
62
    solve(m + 1, r);
63
}
64

65
signed main() {
66
    ios::sync_with_stdio(false);
67
    cin.tie(0);
68
    cout.tie(0);
69
    cin >> n >> p;
70
    // 预处理 ceil(p / i)
71
    for (int i = 1; i <= n; i++) {
72
        sum[i] = sum[i - 1] + ceilDivided(p, i);
73
    }
74
    for (int i = 1; i <= n; i++) {
75
        cin >> h[i];
76
    }
77
    for (int i = 0; i <= n; i++) {
78
        st[i][0] = {h[i], i};
79
    }
80
    for (int j = 1; j <= 17; j++) {
81
        for (int i = 1; i + (1 << j) - 1 <= n; i++) {
82
            st[i][j] = min(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
83
        }
84
    }
85
    solve(1, n);
86
    cout << ans << endl;
87
    return 0;
88
}

展开收起

一般的，如果对于一道题，统计方案时有最大值或最小值作为阻碍/瓶颈，可以考虑分治。

安吉D1-G

Sat, 01 Aug 2026 00:00:00 GMT

原题呈现

P8366 [LNOI2022] 题#

题目描述#

给定长度为 3n3 n3n、值域为 [0,3][0, 3][0,3] 的整数序列 S=s1s2⋯s3nS = s_1 s_2 \cdots s_{3 n}S=s1s2⋯s3n．你需要首先将 SSS 中的每个 000 替换为 [1,3][1, 3][1,3] 中的任意一个整数，得到序列 T=t1t2⋯t3nT = t_1 t_2 \cdots t_{3 n}T=t1t2⋯t3n，然后给出 nnn 个长度为 333 的整数序列 {ai,1,ai,2,ai,3}1≤i≤n{\{ a_{i, 1}, a_{i, 2}, a_{i, 3} \}}_{1 \le i \le n}{ai,1,ai,2,ai,3}1≤i≤n，使得

∀1≤i≤n\forall 1 \le i \le n∀1≤i≤n，1≤ai,1<ai,2<ai,3≤3n1 \le a_{i, 1} < a_{i, 2} < a_{i, 3} \le 3 n1≤ai,1<ai,2<ai,3≤3n；
∀(i1,j1)≠(i2,j2)\forall (i_1, j_1) \ne (i_2, j_2)∀(i1,j1)=(i2,j2)，ai1,j1≠ai2,j2a_{i_1, j_1} \ne a_{i_2, j_2}ai1,j1=ai2,j2；
∀1≤i≤n\forall 1 \le i \le n∀1≤i≤n，{tai,1,tai,2,tai,3}\{ t_{a_{i, 1}}, t_{a_{i, 2}}, t_{a_{i, 3}} \}{tai,1,tai,2,tai,3} 是 {1,2,3}\{ 1, 2, 3 \}{1,2,3} 的一个排列且逆序对数为奇数．

认为两个方案本质不同当且仅当序列 TTT 不同或存在 ai,ja_{i, j}ai,j（1≤i≤n1 \le i \le n1≤i≤n，1≤j≤31 \le j \le 31≤j≤3）不同，求以上操作的本质不同的方案数，对 (109+7)({10}^9 + 7)(109+7) 取模．

输入格式#

本题有多组测试数据．输入的第一行包含一个正整数 CCC 表示测试数据组数．

对于每组测试数据，第一行一个整数 nnn，接下来一行一个长度为 3n3 n3n 的字符串描述序列 SSS．

输出格式#

对于每组测试数据输出一行一个整数表示方案数对 (109+7)({10}^9 + 7)(109+7) 取模的结果．

输入输出样例 #1#

输入 #1#

输出 #1#

说明/提示#

【样例解释 #1】

前三组测试数据中 n=1n = 1n=1，故 {a1,1,a1,2,a1,3}={1,2,3}\{ a_{1, 1}, a_{1, 2}, a_{1, 3} \} = \{ 1, 2, 3 \}{a1,1,a1,2,a1,3}={1,2,3}．

对于第一组测试数据，只能有 T=123T = 123T=123，而 {1,2,3}\{ 1, 2, 3 \}{1,2,3} 的逆序对数为 000 不合法，故不存在方案．

对于第二组测试数据，T=123T = 123T=123 不合法，而 T=132T = 132T=132 时 {1,3,2}\{ 1, 3, 2 \}{1,3,2} 的逆序对数为 111 合法，故存在一个方案．

对于第三组测试数据，取 T=132T = 132T=132，T=213T = 213T=213，T=321T = 321T=321 可以得到三个合法方案．

对于第四组测试数据，T=321321T = 321321T=321321，有如下六种方案：

{a1,1,a1,2,a1,3}={1,2,3}\{ a_{1, 1}, a_{1, 2}, a_{1, 3} \} = \{ 1, 2, 3 \}{a1,1,a1,2,a1,3}={1,2,3}，{a2,1,a2,2,a2,3}={4,5,6}\{ a_{2, 1}, a_{2, 2}, a_{2, 3} \} = \{ 4, 5, 6 \}{a2,1,a2,2,a2,3}={4,5,6}
{a1,1,a1,2,a1,3}={4,5,6}\{ a_{1, 1}, a_{1, 2}, a_{1, 3} \} = \{ 4, 5, 6 \}{a1,1,a1,2,a1,3}={4,5,6}，{a2,1,a2,2,a2,3}={1,2,3}\{ a_{2, 1}, a_{2, 2}, a_{2, 3} \} = \{ 1, 2, 3 \}{a2,1,a2,2,a2,3}={1,2,3}
{a1,1,a1,2,a1,3}={1,2,6}\{ a_{1, 1}, a_{1, 2}, a_{1, 3} \} = \{ 1, 2, 6 \}{a1,1,a1,2,a1,3}={1,2,6}，{a2,1,a2,2,a2,3}={3,4,5}\{ a_{2, 1}, a_{2, 2}, a_{2, 3} \} = \{ 3, 4, 5 \}{a2,1,a2,2,a2,3}={3,4,5}
{a1,1,a1,2,a1,3}={3,4,5}\{ a_{1, 1}, a_{1, 2}, a_{1, 3} \} = \{ 3, 4, 5 \}{a1,1,a1,2,a1,3}={3,4,5}，{a2,1,a2,2,a2,3}={1,2,6}\{ a_{2, 1}, a_{2, 2}, a_{2, 3} \} = \{ 1, 2, 6 \}{a2,1,a2,2,a2,3}={1,2,6}
{a1,1,a1,2,a1,3}={1,5,6}\{ a_{1, 1}, a_{1, 2}, a_{1, 3} \} = \{ 1, 5, 6 \}{a1,1,a1,2,a1,3}={1,5,6}，{a2,1,a2,2,a2,3}={2,3,4}\{ a_{2, 1}, a_{2, 2}, a_{2, 3} \} = \{ 2, 3, 4 \}{a2,1,a2,2,a2,3}={2,3,4}
{a1,1,a1,2,a1,3}={2,3,4}\{ a_{1, 1}, a_{1, 2}, a_{1, 3} \} = \{ 2, 3, 4 \}{a1,1,a1,2,a1,3}={2,3,4}，{a2,1,a2,2,a2,3}={1,5,6}\{ a_{2, 1}, a_{2, 2}, a_{2, 3} \} = \{ 1, 5, 6 \}{a2,1,a2,2,a2,3}={1,5,6}

【数据范围】

对于所有测试数据，1≤C≤51 \le C \le 51≤C≤5，1≤n≤191 \le n \le 191≤n≤19，字符串 SSS 的长度为 3n3 n3n 且仅由 0,1,2,30, 1, 2, 30,1,2,3 构成．

测试点编号	n≤n \len≤	特殊性质
111	111	无
222	222	无
333	333	无
444	555	A
555	777	无
666	101010	无
777	131313	A
888	161616	无
999	181818	无
101010	191919	无

特殊性质 A：字符串 SSS 由全 000 的字符串构成．

【提示】

请注意程序的空间消耗．

思路#

观察到数据范围中 nnn 很小，所以可以选择使用高次的 DP．

不难发现，一个序列是 {1,2,3}\{ 1, 2, 3 \}{1,2,3} 的一个排列且逆序对数为奇数，当且仅当这个序列属于 {{1,3,2},{2,1,3},{3,2,1}}\{\{1,3,2\}, \{2, 1, 3\}, \{3, 2, 1\}\}{{1,3,2},{2,1,3},{3,2,1}}．

遍历整个序列，若当前元素为 1（或 0），则可以是：

单独的一个 {1}\{1\}{1}
和前面的 {2}\{2\}{2} 组合成 {2,1}\{2, 1\}{2,1}
和前面的 {3,2}\{3,2\}{3,2} 组合成 {3,2,1}\{3, 2, 1\}{3,2,1}

若当前元素为 2 或 3 时同理．

依照这个设计状态：dp[i][a][b][c][d][e][f]，用于表示考虑到第 iii 个元素时：

前面剩余单独的 {1}\{1\}{1} 有 a 个
前面剩余单独的 {2}\{2\}{2} 有 b 个
前面剩余单独的 {3}\{3\}{3} 有 c 个
前面剩余的 {2,1}\{2, 1\}{2,1} 有 d 个
前面剩余的 {1,3}\{1, 3\}{1,3} 有 e 个
前面剩余的 {3,2}\{3, 2\}{3,2} 有 f 个的方案数量．

初始时，dp[0][0][0][0][0][0][0] = 1 表示前 0 个元素时，肯定什么都没有剩余，此时仅一种方案．

接着，遍历整个序列，若当前元素为 2（或 0），则 dp[i][a][b][c][d][e][f] 可以增加：

dp[i-1][a][b-1][c][d][e][f]，增加了一个单独的 {1}\{1\}{1}
dp[i-1][a][b][c+1][d][e][f-1] * (c+1)，花费任意一个 {3}\{3\}{3}（由于有 c+1c+1c+1 个 {3}\{3\}{3}，所以有 c+1c+1c+1 种选法），增加了一个 {3,2}\{3, 2\}{3,2}
dp[i-1][a][b][c][d][e+1][f] * (e+1)，花费一个 {1，3}\{1，3\}{1，3}（同理，有 e+1e+1e+1 种选法），组成了一个 {1,3,2}\{1,3,2\}{1,3,2}，这个组合合法，消去．

若当前元素为 1 或 3 时同理．

最终状态为 dp[3*n][0][0][0][0][0][0]．

观察得出 dp[i][...] 只与 dp[i-1][...] 有关，因此使用滚动数组优化．

什么是滚动数组？

滚动数组，是一种节省空间的做法，一般来说，如果 dp[i][...] 只与 dp[i-x][...]（x 为常数，且 x 通常为 1）有关时，可以使用滚动数组．

以 x=1 为例，在计算完 dp[0][...] 和 dp[1][...] 之后，由于之后的计算不再需要用到 dp[0][...]，因此，可以将 dp[2][...] 存放在 dp[0][...] 的位置，从而达到节省空间的目的．

在实现时，常常定义 cur = i & 1 和 pre = (i-1) & 1，利用 dp[cur][...] 来代替 dp[i][...]，dp[pre][...] 来代替 dp[i-1][...]．

由于算出来的是划分数，而题目要求的是排列，所以还要乘 n!n!n!．

1
#include <bits/stdc++.h>
2
#define allow_one(x) ((x) <= i && (x) <= n)
3
typedef long long ll;
4
using namespace std;
5
const int N = 60;
6
const int MOD = 1e9 + 7;
7
int n, A[N];
8
ll fac[N];
9
ll calFac(int x) {
10
    if (fac[x] == 0) {
11
        fac[x] = (1ll * calFac(x - 1) * x) % MOD;
12
    }
13
    return fac[x];
14
}
15
// dp[one][two][three][oneTwo][oneThree][twoThree]
16
// {1,3,2},{2,1,3},{3,2,1} 是合法的
17
int dp[2][21][21][21][21][21][21];
18
void solve() {
19
    memset(dp, 0, sizeof(dp));
20
    cin >> n;
21
    string str;
22
    cin >> str;
23
    for (int i = 0; i < str.size(); i++) {
24
        A[i + 1] = str[i] - '0';
25
    }
26
    dp[0][0][0][0][0][0][0] = 1;
27
    for (int i = 1; i <= 3 * n; i++) {
28
        int pre = (i - 1) & 1, now = i & 1;
29
        for (int a = 0; allow_one(a); a++)
30
            for (int b = 0; allow_one(a + b); b++)
31
                for (int c = 0; allow_one(a + b + c); c++)
32
                    for (int d = 0;
33
                         a + b + c + d <= n && a + b + c + 2 * d <= i; d++)
34
                        for (int e = 0;
35
                             e <= n && a + b + c + 2 * d + 2 * e <= i &&
36
                             a + b + c + d + e <= n;
37
                             e++)
38
                            for (int f = 0;
39
                                 f <= n &&
40
                                 a + b + c + 2 * d + 2 * e + 2 * f <= i &&
41
                                 a + b + c + d + e + f <= n;
42
                                 f++) {
43
                                ll cur = 0; // 清零
44
                                if (A[i] == 1 || A[i] == 0) {
45
                                    // 新增一个 1
46
                                    if (a - 1 >= 0)
47
                                        cur = (cur +
48
                                               dp[pre][a - 1][b][c][d][e][f]) %
49
                                              MOD;
50
                                    // 与已有的 2 结合成 {2,1}，消耗 b，增加 d
51
                                    if (d - 1 >= 0)
52
                                        cur = (cur + 1ll *
53
                                                         dp[pre][a][b + 1][c]
54
                                                           [d - 1][e][f] *
55
                                                         (b + 1)) %
56
                                              MOD;
57
                                    // 与已有的 {3,2} 完成，消耗 f
58
                                    if (f < n) // 保证 f+1 不越界
59
                                        cur =
60
                                            (cur +
61
                                             1ll *
62
                                                 dp[pre][a][b][c][d][e][f + 1] *
63
                                                 (f + 1)) %
64
                                            MOD;
65
                                }
66
                                if (A[i] == 2 || A[i] == 0) {
67
                                    // 新增一个 2
68
                                    if (b - 1 >= 0)
69
                                        cur = (cur +
70
                                               dp[pre][a][b - 1][c][d][e][f]) %
71
                                              MOD;
72
                                    // 与已有的 3 结合成 {3,2}，消耗 c，增加 f
73
                                    if (f - 1 >= 0)
74
                                        cur = (cur + 1ll *
75
                                                         dp[pre][a][b][c + 1][d]
76
                                                           [e][f - 1] *
77
                                                         (c + 1)) %
78
                                              MOD;
79
                                    // 与已有的 {1,3} 完成，消耗 e
80
                                    if (e < n)
81
                                        cur =
82
                                            (cur +
83
                                             1ll *
84
                                                 dp[pre][a][b][c][d][e + 1][f] *
85
                                                 (e + 1)) %
86
                                            MOD;
87
                                }
88
                                if (A[i] == 3 || A[i] == 0) {
89
                                    // 新增一个 3
90
                                    if (c - 1 >= 0)
91
                                        cur = (cur +
92
                                               dp[pre][a][b][c - 1][d][e][f]) %
93
                                              MOD;
94
                                    // 与已有的 1 结合成 {1,3}，消耗 a，增加 e
95
                                    if (e - 1 >= 0)
96
                                        cur = (cur + 1ll *
97
                                                         dp[pre][a + 1][b][c][d]
98
                                                           [e - 1][f] *
99
                                                         (a + 1)) %
100
                                              MOD;
101
                                    // 与已有的 {2,1} 完成，消耗 d
102
                                    if (d < n)
103
                                        cur =
104
                                            (cur +
105
                                             1ll *
106
                                                 dp[pre][a][b][c][d + 1][e][f] *
107
                                                 (d + 1)) %
108
                                            MOD;
109
                                }
110
                                dp[now][a][b][c][d][e][f] = cur % MOD;
111
                            }
112
    }
113
    cout << (dp[(3 * n) & 1][0][0][0][0][0][0] * calFac(n)) % MOD << endl;
114
}
115

116
signed main() {
117
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
118
    fac[0] = 1;
119
    int T;
120
    cin >> T;
121
    while (T--) {
122
        solve();
123
    }
124
    return 0;
125
}

展开收起

安吉D1-L

Sat, 01 Aug 2026 00:00:00 GMT

原题呈现

P15862 回去！#

题目描述#

有一个 nnn 个点 nnn 条边的有向图 GGG，满足每个点的出度为 111．每个点有一个小写字母作为权值．

现在 DZ1000 准备在 GGG 上游走，他打算用一个字符串 sss 和一个栈 ttt 来记录他的行程．初始时栈 ttt 为空．

每一步他都有两种可能的行动选择：

「前进？」：DZ1000 有 ppp 的概率沿着当前点的出边移动，并将他到达的节点放进栈 ttt 中．
「回去！」：DZ1000 有 (1−p)(1-p)(1−p) 的概率弹出栈 ttt 顶部的节点，然后回到当前位于栈 ttt 顶部的节点．（若行动前栈 ttt 为空则他不会这么做且一定会前进，若行动前栈 ttt 大小为 111 则回到起点．）

每走完一步，DZ1000 都会将当前他所在节点的权值接在字符串 sss 的后面．

现在 DZ1000 将从 GGG 上等概率随机选择一个起始节点，开始走 2k2k2k 步，他想让你求出走完 2k2k2k 步后字符串 sss 的前 kkk 位和后 kkk 位相等的概率．答案乘上 nnn 后对 998,244,35399\textcolor{#fec52b}8,\textcolor{purple}{24}4,353998,244,353 取模．

注意起始节点的权值不等同于字符串 sss 的第一位．

输入格式#

输入共 333 行．

第一行，三个正整数 n,k,pn,k,pn,k,p，分别表示 GGG 的点数、行动的步数和往前进的概率（ppp 原本是一个介于 000 和 111 之间的有理数，现给出其对 998,244,35399\textcolor{#fec52b}8,\textcolor{purple}{24}4,353998,244,353 取模后的结果）．

第二行，由小写字母组成的长度为 nnn 的字符串，第 iii 个字母 cic_ici 表示 iii 号点的权值．

第三行，nnn 个正整数 vvv，第 iii 个正整数 viv_ivi 表示 iii 号点出边指向的点．

输出格式#

输出共 111 行，一个正整数表示走完 2k2k2k 步后字符串 sss 的前 kkk 位和后 kkk 位相等的概率乘 nnn 的结果，对 998,244,35399\textcolor{#fec52b}8,\textcolor{purple}{24}4,353998,244,353 取模．

输入输出样例 #1#

输入 #1#

1
3 1 499122177
2
aba
3
2 3 1

输出 #1#

1
1

输入输出样例 #2#

输入 #2#

1
10 10 882315098
2
nqqmlmnnon
3
6 3 4 1 4 4 9 4 10 7

输出 #2#

1
106458929

说明/提示#

样例 111 解释#

12\frac1221 在模 998244353998244353998244353 下是 499122177499122177499122177，故原始的 p=12p=\frac12p=21．

有如下路径：

1→2→31\to 2\to 31→2→3，概率为 1n×p=16\frac1n\times p=\frac16n1×p=61，字符串为 ba，不符合条件．
1→2→11\to 2\to 11→2→1，概率为 1n×p=16\frac1n\times p=\frac16n1×p=61，字符串为 ba，不符合条件．
2→3→12\to 3\to 12→3→1，概率为 1n×p=16\frac1n\times p=\frac16n1×p=61，字符串为 aa，符合条件．
2→3→22\to 3\to 22→3→2，概率为 1n×p=16\frac1n\times p=\frac16n1×p=61，字符串为 ab，不符合条件．
3→1→23\to 1\to 23→1→2，概率为 1n×p=16\frac1n\times p=\frac16n1×p=61，字符串为 ab，不符合条件．
3→1→33\to 1\to 33→1→3，概率为 1n×p=16\frac1n\times p=\frac16n1×p=61，字符串为 aa，符合条件．

故有 16+16=13\frac16+\frac16=\frac1361+61=31 的概率符合条件，乘 nnn 的结果为 111，故输出 111．

数据规模#

对于 100%100\%100% 的数据，满足 1≤n≤30,1≤k≤301 \le n \le 30,1 \le k \le 301≤n≤30,1≤k≤30．

子任务编号	nnn	kkk	特殊性质	分值
111	≤9\le 9≤9	≤9\le 9≤9	无	555
222	无特殊限制	^	^	101010
333	^	≤17\le 17≤17	^	303030
444	^	无特殊限制	A	555
555	^	^	B	555
666	^	^	C	101010
777	^	^	无	353535

特殊性质 A：所有 cic_ici 相同．

特殊性质 B：对于任意 1≤i≤n1\le i\le n1≤i≤n，有 vi=iv_i=ivi=i．

特殊性质 C：对于任意 1≤i<n1\le i<n1≤i<n，有 vi=i+1v_i=i+1vi=i+1，且 vn=1v_n=1vn=1．

思路#

由于每一个节点出度相同，考虑枚举起点．如果枚举了起点，一直往前走的整条路径就固定了，可以将其预处理出来．将图上的问题转化为链上的问题．

接下来，问题转化为：有一个人在一条链上跳，可以向前跳，也可以向后跳，但是不能跳出界．问如何跳才能满足得到的字符串前 kkk 个和后 kkk 个相等．

由于想要前后两半相等，可以想象有两个人，一个人跳前半段，一个人跳后半段，枚举权值与第一个点 fififi 相等的点 sesese，两人从 fififi 和 sesese 开始跳，每跳一步都保证落点权值相等，且最终第一个人的最终落点和第二个人的起点相邻的可能．

为了计算可能性，我们定义 dp[i][x][y] 表示两个人都走了 i 步，第一个人走到 x，第二个人走到 y 这种情况的可能性．

存在如下初始状态：

1
dp[1][fi][se] = 1;

存在如下转移方程：

1
int q = (1 - p + MOD) % MOD; // 后退的概率
2
if (x - 1 >= 0) {
3
  int p1 = (x - 1 == 0) ? 1 : p; // 玩家 1 前进的概率
4
  if (y - 1 >= 0) {
5
    int p2 = (y - 1 == 0) ? 1 : p; // 玩家 2 前进的概率
6
    // 都前进
7
    dp[i][x][y] =
8
      (dp[i][x][y] + 1ll * dp[i - 1][x - 1][y - 1] *
9
                 (1ll * p1 * p2 % MOD)) %
10
      MOD;
11
  }
12
  if (y + 1 <= 2 * k)
13
    // 玩家 1 前进，玩家 2 后退
14
    dp[i][x][y] =
15
      (dp[i][x][y] + 1ll * dp[i - 1][x - 1][y + 1] *
16
                 (1ll * p1 * q % MOD)) %
17
      MOD;
18
}
19
if (x + 1 <= 2 * k) {
20
  if (y - 1 >= 0) {
21
    // 玩家 1 后退，玩家 2 前进
22
    int p2 = (y - 1 == 0) ? 1 : p; // 玩家 2 前进的概率
23
    dp[i][x][y] =
24
      (dp[i][x][y] + 1ll * dp[i - 1][x + 1][y - 1] *
25
                 (1ll * q * p2 % MOD)) %
26
      MOD;
27
  }
28
  if (y + 1 <= 2 * k)
29
    // 都后退
30
    dp[i][x][y] =
31
      (dp[i][x][y] + 1ll * dp[i - 1][x + 1][y + 1] *
32
                 (1ll * q * q % MOD)) %
33
      MOD;
34
}

展开收起

统计结果时，只统计第一人终点和第二人起点相邻的情况：

1
for (int x = 0; x <= 2 * k; x++) { // 枚举第一人终点
2
  if (x != se - 1 && x != se + 1)
3
    continue; // 距离恰好等于 1
4
  int bp = (se == x + 1) ? ((x == 0) ? 1 : p) : q; // 连接步（k->k+1）走对的概率
5
  long long s = 0;
6
  for (int y = 0; y <= 2 * k; y++) // 枚举第二人终点
7
    s += dp[k][x][y];
8
  ans = (ans + (s % MOD) * bp) % MOD;
9
}

显然，通过观察，我们不难发现，dp[i][..][..] 的值只与 dp[i-1][..][..] 有关，因此可以使用滚动数组优化．

标程

1
#include <bits/stdc++.h>
2
using namespace std;
3
const int MOD = 998244353;
4
const int N = 70;
5
int n, k, p;
6
char c[N];
7
int nxt[N];
8
int dp[2][N][N]; // 使用滚动数组
9
vector<int> pane;
10
int ans;
11

12
void start(int fi, int se) {
13
    memset(dp, 0, sizeof(dp));
14
    dp[1][fi][se] = 1;
15
    int q = (1 - p + MOD) % MOD;
16
    for (int i = 2; i <= k; i++) {
17
        int cur = i & 1, pre = (i - 1) & 1;
18
        // cur => i; pre => i - 1
19
        for (int x = 0; x <= 2 * k; x++) {
20
            for (int y = 0; y <= 2 * k; y++) {
21
                dp[cur][x][y] = 0;
22
                if (c[pane[x]] != c[pane[y]])
23
                    continue;
24
                if (x - 1 >= 0) {
25
                    int p1 = (x - 1 == 0) ? 1 : p;
26
                    if (y - 1 >= 0) {
27
                        int p2 = (y - 1 == 0) ? 1 : p;
28
                        dp[cur][x][y] =
29
                            (dp[cur][x][y] + 1ll * dp[pre][x - 1][y - 1] *
30
                                                 (1ll * p1 * p2 % MOD)) %
31
                            MOD;
32
                    }
33
                    if (y + 1 <= 2 * k)
34
                        dp[cur][x][y] =
35
                            (dp[cur][x][y] + 1ll * dp[pre][x - 1][y + 1] *
36
                                                 (1ll * p1 * q % MOD)) %
37
                            MOD;
38
                }
39
                if (x + 1 <= 2 * k) {
40
                    if (y - 1 >= 0) {
41
                        int p2 = (y - 1 == 0) ? 1 : p;
42
                        dp[cur][x][y] =
43
                            (dp[cur][x][y] + 1ll * dp[pre][x + 1][y - 1] *
44
                                                 (1ll * q * p2 % MOD)) %
45
                            MOD;
46
                    }
47
                    if (y + 1 <= 2 * k)
48
                        dp[cur][x][y] =
49
                            (dp[cur][x][y] + 1ll * dp[pre][x + 1][y + 1] *
50
                                                 (1ll * q * q % MOD)) %
51
                            MOD;
52
                }
53
            }
54
        }
55
    }
56
    int bk = k & 1;
57
    for (int x = 0; x <= 2 * k; x++) {
58
        if (x != se - 1 && x != se + 1)
59
            continue; // 距离恰好等于 1
60
        int bp = (se == x + 1) ? ((x == 0) ? 1 : p) : q;
61
        long long s = 0;
62
        for (int y = 0; y <= 2 * k; y++)
63
            s += dp[bk][x][y];
64
        ans = (ans + (s % MOD) * bp) % MOD;
65
    }
66
}
67
void solve(int st) {
68
    pane.clear();
69
    for (int i = 1; i <= 2 * k + 1; i++) {
70
        pane.push_back(st);
71
        st = nxt[st];
72
    }
73
    for (int i = 0; i <= 2 * k; i++) {
74
        if (c[pane[i]] == c[pane[1]]) {
75
            start(1, i);
76
        }
77
    }
78
}
79
signed main() {
80
    cin >> n >> k >> p;
81
    for (int i = 1; i <= n; i++)
82
        cin >> c[i];
83
    for (int i = 1; i <= n; i++)
84
        cin >> nxt[i];
85
    for (int i = 1; i <= n; i++)
86
        solve(i);
87
    cout << (ans + MOD) % MOD;
88
}

展开收起

实际上，对于一个对象进行两组重复的动作时，这也可以等同于两个对象分别做一组相同的动作．

安吉D2-T4

Sat, 01 Aug 2026 00:00:00 GMT

原题呈现

P9356 Bracket#

题目描述#

Mirika 有一个长度为 nnn 的括号序列 sss．

对于一个括号序列 SSS，Mirika 可以执行两种操作：

变换：选择一个位置 iii 满足 1≤i≤∣S∣1 \leq i \leq \lvert S \rvert1≤i≤∣S∣，使得 SSS 变为 SiSi+1⋯S∣S∣S1S2⋯Si−2Si−1S_iS_{i+1}\cdots S_{\lvert S\rvert}S_1S_2\cdots S_{i-2}S_{i-1}SiSi+1⋯S∣S∣S1S2⋯Si−2Si−1．
插入：在这个序列的 任意位置 插入一个括号（左右括号均可）．

Mirika 定义括号序列 SSS 的权值 f(S)f(S)f(S) 为能将这个括号序列变成一个合法括号序列所需的最小操作数．

其中，合法括号序列的定义为：

空串为合法括号序列．
若 A\texttt AA 为合法括号序列，则 (A)\texttt{(A)}(A) 为合法括号序列．
若 A,B\texttt A, \texttt BA,B 均为合法括号序列，则 AB\texttt{AB}AB 也为合法括号序列．

现在 Mirika 想要求出：

∑l=1n∑r=lnf(s[l,r])\sum_{l=1}^n \sum_{r=l}^n f(s[l,r])∑l=1n∑r=lnf(s[l,r])

其中 s[l,r]s[l,r]s[l,r] 表示由 sl,sl+1,⋯ ,srs_l,s_{l+1},\cdots,s_rsl,sl+1,⋯,sr 形成的连续子序列．

但是 Mirika 太菜了不会算，于是只好求助于你．

输入格式#

本题每个测试点内有多组数据．

第一行一个正整数 TTT 表示测试数据组数．

对于每组数据，第一行一个正整数 nnn．

第二行一个长度为 nnn 的括号序列 sss．

输出格式#

输出共 TTT 行，第 iii 行一个整数表示第 iii 组测试数据的答案．

输入输出样例 #1#

输入 #1#

1
5
2
2
3
((
4
4
5
())(
6
5
7
()(()
8
5
9
()()(
10
15
11
()())(())))()()

输出 #1#

说明/提示#

样例解释#

对于 s=())(s = \texttt{())(}s=())(：

考虑 s[1,4]=())(s[1,4]=\texttt{())(}s[1,4]=())(．执行变换操作 i=4i=4i=4，有 ())(⇒(())\texttt{())(} \Rightarrow \texttt{(())}())(⇒(())，其中 (())\texttt{(())}(()) 是合法括号序列，故 f(s[1,4])=1f(s[1, 4]) = 1f(s[1,4])=1．可以证明不存在更优的策略．
考虑 s[2,4]=))(s[2,4]=\texttt{))(}s[2,4]=))(．执行变换操作 i=2i=2i=2，再在序列开头插入一个左括号，有 ))(⇒)()⇒()()\texttt{))(} \Rightarrow \texttt{)()} \Rightarrow \texttt{()()}))(⇒)()⇒()()，其中 ()()\texttt{()()}()() 是合法括号序列，故 f(s[2,4])=2f(s[2, 4]) = 2f(s[2,4])=2．可以证明不存在更优的策略．

数据规模与约定#

本题采用捆绑测试．

Subtask 0（15 pts）：n≤400n \leq 400n≤400，∑n≤800\sum n \leq 800∑n≤800．
Subtask 1（20 pts）：n≤2×103n \leq 2\times 10^3n≤2×103，∑n≤4×103\sum n \leq 4\times 10^3∑n≤4×103．
Subtask 2（5 pts）：sss 内不含有右括号．
Subtask 3（10 pts）：对于所有整数 1≤i<n1\le i < n1≤i<n，有 si≠si+1s_i \neq s_{i+1}si=si+1．
Subtask 4（30 pts）：n≤2×105n \leq 2\times 10^5n≤2×105，∑n≤5×105\sum n \leq 5\times 10^5∑n≤5×105．
Subtask 5（20 pts）：无特殊限制．

对于所有数据，1≤T≤100001 \leq T \leq 100001≤T≤10000，1≤n≤2×1061 \leq n \leq 2 \times 10^61≤n≤2×106，1≤∑n≤2×1071 \leq \sum n \leq 2 \times 10^71≤∑n≤2×107．

小技巧：快速判断括号序列的合法性

对于一个括号序列 TTT，长度为 mmm，若将其左括号视作 1，右括号视作 -1，将这个序列做一次前缀和，得到 sss 数组：

s0=0s_0 = 0s0=0，是一个空串
sis_isi 表示括号序列遍历到第 iii 个括号时，栈中的左括号个数

因此，对于括号序列 TTT，TTT 是合法的当且仅当：

sm=0s_m = 0sm=0
∀i,si≥0\forall i, s_i \geq 0∀i,si≥0

对于括号序列 TTT，一个 TTT 的子串 [l,r][l,r][l,r] 是合法的，当且仅当以下条件全部满足：

sr=sl−1s_r=s_{l-1}sr=sl−1
srs_rsr 是 sl..rs_{l..r}sl..r 中的最小值

对于一个括号序列 TTT，长度为 mmm，若将其左括号视作 1，右括号视作 -1，将这个序列做一次前缀和，得到 sss 数组：

s[0] = 0，是一个空串
s[i] 表示括号序列遍历到第 iii 个括号时，栈中的左括号个数则一个 TTT 的子串 [l,r][l,r][l,r] 是合法的，当且仅当以下条件全部满足：
sr=sl−1s_r=s_{l-1}sr=sl−1
srs_rsr 是 sl..rs_{l..r}sl..r 中的最小值

由于 f(T)f(T)f(T) 为通过循环移位和插入括号变成合法括号序列的最少操作数，则有：

若 s1s_1s1 是前缀和数组中最小的，则所需操作数为 ∣sm∣|s_m|∣sm∣，即在末尾补充 ∣sm∣|s_m|∣sm∣ 个右括号．
若 sms_msm 是前缀和数组中最小的，则所需操作数为 ∣sm∣|s_m|∣sm∣，即在开头补充 ∣sm∣|s_m|∣sm∣ 个左括号．
否则，需要先循环移位一次，转换为上面两种情况，再补充括号，所需操作数 ∣sm∣+1|s_m| + 1∣sm∣+1

因此，可以将子串的贡献拆分为所有子串的 ∣sm∣|s_m|∣sm∣ 的部分和部分子串所需 1 的部分．

∣sm∣|s_m|∣sm∣ 的部分#

∣sm∣|s_m|∣sm∣ 的部分的贡献为：

∑l=1m∑r=lm∣s[r]−s[l−1]∣\sum_{l=1}^{m}\sum_{r=l}^{m} |s[r]-s[l-1]|l=1∑mr=l∑m∣s[r]−s[l−1]∣

将两个和式化简，得：

∑0≤i<j≤m∣s[j]−s[i]∣\sum_{0\leq i<j\leq m} |s[j]-s[i]|0≤i<j≤m∑∣s[j]−s[i]∣

注意，这里 i=l−1i=l-1i=l−1．

将 sss 数组排序，就可以消去绝对值，变成下面的形式（注意：这里需要桶排）：

∑0≤i<j≤ms[j]−s[i]\sum_{0\leq i<j\leq m} s[j]-s[i]0≤i<j≤m∑s[j]−s[i]

接着，遍历每一个元素，将这一个元素和前面每一个元素进行配对，具体来说，若遍历到的当前元素前面还有 iii 个元素，则当前元素会配成 iii 对，贡献为 (s[i+1]−s[i])+(s[i+1]−s[i−1])+(s[i+1]−s[i−2])+⋯+(s[i+1]−s[1])(s[i + 1] - s[i]) + (s[i+1]-s[i-1]) + (s[i+1]-s[i-2]) + \cdots + (s[i+1]-s[1])(s[i+1]−s[i])+(s[i+1]−s[i−1])+(s[i+1]−s[i−2])+⋯+(s[i+1]−s[1])

可以化简为：s[i−1]×i+s[1]+s[2]+⋯+s[i]s[i-1] \times i + s[1] + s[2] + \cdots + s[i]s[i−1]×i+s[1]+s[2]+⋯+s[i]

可以维护当前前缀和来 O(n)O(n)O(n) 解决．

1 的部分#

正难则反，只需要算出不需要 +1 的子串，剩下的就是需要 +1 的子串．

通过上面规律分析我们可以知道，一个子串不需要 +1，当且仅当以下条件满足其一：

该子串左端点在该字串范围前缀和数组中取到最小值
该子串右端点在该字串范围前缀和数组中取到最小值

观察可知，这两个条件对称，只需要反转序列，并将左右括号对调，就可以将第二个问题条件转化为第一个条件．

定义 p[i]p[i]p[i] 为左端点 l=i−1l=i-1l=i−1 右边第一个位置 rrr，满足 s[r+1]s[r+1]s[r+1] 小于 s[i]s[i]s[i]（注意，位置和 p 数组下标是 0-based，而 s 数组下标是 1-based）．可以使用从小到大的单调栈进行维护．

求出 p[i]p[i]p[i] 之后，左端点 lll 的右端点就可以取 i+1,i+2,⋯ ,p[i]−1i+1,i+2,\cdots,p[i]-1i+1,i+2,⋯,p[i]−1，一共是 p[i]−i−1p[i]-i-1p[i]−i−1 种情况，将其作为负贡献计入总和．

容斥掉合法子串#

不难发现，合法子串同时满足上面两个条件，因此合法子串会被算两次，要扣除重复的部分，就要知道有多少合法子串．

回顾上面的规律，我们知道，一个子串 [l,r][l,r][l,r] 是合法序列，当且仅当以下两个条件全部满足：

首尾相等：s[l−1]=s[r]s[l-1] = s[r]s[l−1]=s[r]
s[l−1]s[l-1]s[l−1] 是当前区间最小值

我们将所有的 sss 放到一个桶 bucketbucketbucket 中，桶里存放每个元素的下标，sss 的值域为 [−n,n][-n, n][−n,n]，可以偏移为 [0,2n][0, 2n][0,2n]．

枚举每一个值 xxx，遍历下标数组 pos=bucked[x]pos=bucked[x]pos=bucked[x]，对于每一个下标 uuu（即为左端点 -1），找到所有的 vvv （即为右端点）满足 u<vu<vu<v 且 v<puv < p_uv<pu（使得 s[u]s[u]s[u] 是当前区间最小值），其中，u,v∈posu,v\in posu,v∈pos．

在程序中，我们使用双指针，使用一个指针 ptrptrptr 指向 pospospos 中的元素，初始为 0，用于记录当前第一个不满足条件的 vvv．遍历元素 pos[i]pos[i]pos[i] 时：

移动双指针，直到移动到 pospospos 边界，或 pos[ptr]>ppos[i]pos[ptr] > p_{pos[i]}pos[ptr]>ppos[i]．
此时，所有可能的右边界为：i+1,i+2,⋯ ,ptri+1,i+2,\cdots,ptri+1,i+2,⋯,ptr，共有 ptr−i−iptr-i-iptr−i−i 个，将其作为贡献计入总和．

最终答案为：

S∣sm∣+T−S1+SgS_{|s_m|} +T-S_{1} +S_gS∣sm∣+T−S1+Sg

其中：

S∣sm∣S_{|s_m|}S∣sm∣ 为 ∣sm∣|s_m|∣sm∣ 的部分的贡献．
TTT 为子串数，T=(m+1)m2T=\frac{(m+1)m}{2}T=2(m+1)m．
S1S_1S1 为上述不需要 +1 的子串数量．
SgS_gSg 为 S1S_1S1 计算中被重复计数的合法子串数量．

标程

1
#include <bits/stdc++.h>
2
using namespace std;
3
typedef long long ll;
4
const int N = 2e6 + 100;
5
int n, s[N], p[N], rs[N], rp[N];
6
ll ans;
7
string str;
8

9
// s[i] := sum{ str[0] ~ str[i-1] }
10

11
ll solve_1(int *s, int *p) {
12
    ll ans = 0;
13
    stack<pair<int, int>> sta;
14
    for (int i = 0; i <= n; i++)
15
        p[i] = n + 1;
16
    for (int i = 0; i <= n; i++) {
17
        while (!sta.empty() && sta.top().first > s[i]) {
18
            int ele = sta.top().second;
19
            sta.pop();
20
            p[ele] = i;
21
        }
22
        sta.push({s[i], i});
23
    }
24
    for (int i = 0; i < n; i++) { // i 表示左端点的前一个位置
25
        ans += p[i] - 1 - i;
26
    }
27
    return ans;
28
}
29

30
void solve() {
31
    ans = 0;
32
    cin >> n >> str;
33
    vector<int> cnt((n << 1) + 1, 0);
34
    cnt[s[0] + n] = 1;
35
    for (int i = 1; i <= str.size(); i++) {
36
        s[i] = s[i - 1] + (str[i - 1] == '(' ? 1 : -1);
37
        cnt[s[i] + n]++;
38
    }
39
    // 计算 |Sn| 的部分
40
    vector<int> vec;
41
    for (int i = 0; i <= n << 1; i++) {
42
        for (int j = 1; j <= cnt[i]; j++)
43
            vec.push_back(i - n);
44
    }
45

46
    ll pref = 0;
47
    for (int i = 0; i < vec.size(); i++) {
48
        ans += 1ll * vec[i] * i - pref;
49
        pref += vec[i];
50
    }
51

52
    // 计算 1 的部分
53
    ll tot = (1ll * n * (n + 1)) >> 1;
54
    // 左边取到最小，p[i] := 下标为i后边第一个小于s[i]的值的下标
55
    tot -= solve_1(s, p);
56
    // 右边取到最小
57
    string rstr = str;
58
    reverse(rstr.begin(), rstr.end());
59
    for (int i = 1; i <= rstr.size(); i++) {
60
        rs[i] = rs[i - 1] + (rstr[i - 1] == '(' ? -1 : 1);
61
    }
62
    tot -= solve_1(rs, rp);
63

64
    // 去重
65
    vector<vector<int>> bucket(n * 2 + 1);
66
    for (int i = 0; i <= n; i++) {
67
        bucket[s[i] + n].push_back(i);
68
    }
69
    for (int x = 0; x <= n << 1; x++) {
70
        int ptr = 0;
71
        for (int i = 0; i < bucket[x].size(); i++) {
72
            vector<int> &pos = bucket[x];
73
            while (ptr < pos.size() && p[pos[i]] > pos[ptr])
74
                ptr++;
75
            tot += ptr - 1 - i;
76
        }
77
    }
78

79
    cout << ans + tot << endl;
80
}
81

82
signed main() {
83
    freopen("bracket.in", "r", stdin);
84
    freopen("bracket.out", "w", stdout);
85
    ios::sync_with_stdio(false);
86
    cin.tie(0);
87
    cout.tie(0);
88
    int T;
89
    cin >> T;
90
    while (T--) {
91
        solve();
92
    }
93
}

展开收起

对于括号，可以将其视为一串只含有 ±1\pm 1±1 的序列，并通过下标从 0 开始的前缀和解决问题．

ABC468D

Fri, 31 Jul 2026 00:00:00 GMT

题目描述#

Note

一个由小写英文字母组成的字符串，如果它最多通过修改一个字符就能变成一个回文串，则称它为一个好字符串．

例如，a、iwai 和 abcdcza 都是好字符串，而 abcd 和 atcoder 则不是．需要注意，回文串本身也是好字符串．

给定一个由小写英文字母组成的字符串 S，请找出 S 中非空子串（连续子序列） 中，好字符串的数量．

如果两个子串在 S 中的位置不同，即使它们的内容相同，也视为不同的子串，需要分别计数．

约束条件#

字符串 S 的长度介于 1 到 10^4 之间．

思路#

对于一个字符串，若想要判断该字符串的子串是否回文，则需要明确一个中心和一个半径．

因此，对于此题，我们枚举中心，并向两边扩展（加长半径），对于扩展的一对字符，若这两个字符不相同，则将 diff 增加 1，若 diff 增加到 2，则剪枝，并更换中点．

标程：

1
#include <bits/stdc++.h>
2
using namespace std;
3
string s;
4
int ans;
5
signed main() {
6
    cin >> s;
7
    for (int i = 0; i < s.size(); i++) {
8
        // 奇数：中点为 i
9
        int diff = 0;
10
        for (int r = 0; i - r >= 0 && i + r < s.size(); r++) {
11
            // 半径为 r（仅存在i则半径为0）
12
            if (s[i - r] != s[i + r])
13
                diff++;
14
            if (diff >= 2) {
15
                break;
16
            }
17
            ans++;
18
        }
19
    }
20
    for (int i = 0; i < s.size() - 1; i++) {
21
        // 偶数：中点为 i 和 i+1 之间
22
        int diff = 0;
23
        for (int r = 0; i - r >= 0 && i + r + 1 < s.size(); r++) {
24
            // 半径为 r（仅存在i和i+1则半径为0）
25
            if (s[i - r] != s[i + r + 1])
26
                diff++;
27
            if (diff >= 2) {
28
                break;
29
            }
30
            ans++;
31
        }
32
    }
33
    cout << ans;
34
}

展开收起

这样的算法时间复杂度 O(n2)O(n^2)O(n2)．勉强可以通过．

这道题还可以使用哈希 + 二分的方法，在这里不再赘述．

差分和前缀和

Sat, 11 Apr 2026 00:00:00 GMT

前缀和#

前缀和用于查询区间和．

定义 s[i]s[i]s[i] 表示区间 [1,i][1,i][1,i] 之间所有元素的和（即前 iii 个数的和），不难发现，区间 [l,r][l,r][l,r] 的和为 s[r]−s[l−1]s[r] - s[l-1]s[r]−s[l−1]．

计算 sss 数组可以使用递推的方式，有 s[i]=s[i−1]+a[i]s[i] = s[i-1] + a[i]s[i]=s[i−1]+a[i]．

差分#

差分用于区间修改，是前缀和的逆运算．

定义 d[i]d[i]d[i] 表示 a[i]a[i]a[i] 相对 a[i−1]a[i-1]a[i−1] 变化了多少，即 d[i]=a[i]−a[i−1]d[i] = a[i] - a[i-1]d[i]=a[i]−a[i−1]．

当想要对 [l,r][l, r][l,r] 增加 xxx 时，只需要将 d[l]d[l]d[l] 增加 xxx，d[r+1]d[r+1]d[r+1] 减少 xxx．

如果想要将差分数组还原成原数组，可以使用下面的公式：a[i]=a[i−1]+d[i]a[i] = a[i-1] + d[i]a[i]=a[i−1]+d[i]．

快速幂

Sat, 11 Apr 2026 00:00:00 GMT

快速幂用于在 O(log⁡n)O(\log n)O(logn) 的速度计算一个数的 nnn 次幂．

P1226 【模板】快速幂

题目描述#

给你三个整数 a,b,pa,b,pa,b,p，求 ab mod pa^b \bmod pabmodp．

输入格式#

输入只有一行三个整数，分别代表 a,b,pa,b,pa,b,p．

输出格式#

输出一行一个字符串 a^b mod p=s，其中 a,b,pa,b,pa,b,p 分别为题目给定的值， sss 为运算结果．

数据范围#

对于 100%100\%100% 的数据，保证 0≤a,b<2310\le a,b < 2^{31}0≤a,b<231，a+b>0a+b>0a+b>0，2≤p<2312 \leq p \lt 2^{31}2≤p<231．

快速幂使用倍增的思想．

对于任意一个指数 bbb，将其用二进制表示，可以拆解为 2a1+2a2+⋯+2an2^{a_1} + 2^{a_2} + \cdots + 2^{a_n}2a1+2a2+⋯+2an 的形式，其中 aia_iai 为互不相同的非负整数．不难得出，设 bbb 二进制表示中的第 kkk 位为 1，则所有 aia_iai 和所有 k−1k-1k−1 对应相等．

根据幂的相关性质可知，ab=a2k1+2k2+⋯+2kn=a2k1×a2k2×⋯×a2kna^b=a^{2^{k_1} + 2^{k_2} + \cdots + 2^{k_n}}=a^{2^{k_1}}\times a^{2^{k_2}}\times \cdots \times a^{2^{k_n}}ab=a2k1+2k2+⋯+2kn=a2k1×a2k2×⋯×a2kn，即指数的二进制表示中，所有位数值为 1 的位，记该位的权值为 ppp，答案就是 ∑pi∈Pap\sum_{p_i \in P}a^p∑pi∈Pap，其中，PPP 是所有满足要求的 ppp 的取值．

例如，对于 a=3a=3a=3，b=10b=10b=10 的情况，由于 101010_{10}1010 的二进制为 101021010_210102，其中，为 1 的位是右起第 2 位（对应权值为 22−1=22^{2-1}=222−1=2）和右起第四位（对应权值 24−1=82^{4-1}=824−1=8），所以，P={2,8}P=\{2,8\}P={2,8}，310=32×383^{10} = 3^2\times 3^8310=32×38．

因此，检查 bbb 二进制中的每一位．并对于权值为 ppp 的位，通过递推记录当前位的 apa^pap ，若 bbb 二进制的该位为 1，则将 apa^pap 计入答案．如何通过递推记录？只需要在从权值为 ppp 的一位转移到左边一位时，由于左边一位的权值是 2p2p2p，将 apa^pap 平方为 a2pa^{2p}a2p 即可．

可以写出基本流程：

检查 bbb 二进制右起第一位是否为 1，若是，则将答案乘上 aaa．
将 bbb 左移一位，露出 bbb 的二进制右起第二位．
由于 bbb 左移了一位，所以目前 bbb 右起第一位的权值翻了倍，需要让 aaa 平方才能让权值指数也翻倍．
若当前 bbb 大于等于 1，则回到步骤 1．

核心代码如下：

1
int exp = b; // 记录目前剩余的指数
2
int ans = 1; // 记录答案
3
int now = a; // 记录现在位的权值
4
while (exp >= 1) {
5
  if (exp % 2) // 如果当前位是1
6
    ans *= now; // 就将当前位的权值记录答案
7
  exp /= 2; // 指数右移一位
8
  now *= now; // 权值对应增加
9
}

此外，这道题还要注意取模和开 long long．

标程如下：

1
#include <bits/stdc++.h>
2
using namespace std;
3

4
int a, b, p;
5

6
int main() {
7
  cin >> a >> b >> p;
8
  long long exp = b, ans = 1, now = a;
9
  while (exp >= 1) {
10
    if (exp % 2)
11
      (ans *= now) %= p;
12
    exp /= 2;
13
    (now *= now) %= p;
14
  }
15
  cout << a << "^" << b << " mod " << p << "=" << ans;
16
  return 0;
17
}

展开收起

树状数组

Sun, 05 Apr 2026 00:00:00 GMT

树状数组是用来实现单点查询，区间修改的数据结构，虽然功能上可以被线段树完全覆盖，但是容易实现．

P3374 【模板】树状数组 1

题目描述#

如题，已知一个数列，你需要进行下面两种操作：

将某一个数加上 xxx；
求出某区间每一个数的和．

输入格式#

第一行包含两个正整数 n,mn,mn,m，分别表示该数列数字的个数和操作的总个数．

第二行包含 nnn 个用空格分隔的整数，其中第 iii 个数字表示数列第 iii 项的初始值．

接下来 mmm 行每行包含 333 个整数，表示一个操作，具体如下：

1 x k 含义：将第 xxx 个数加上 kkk；
2 x y 含义：输出区间 [x,y][x,y][x,y] 内每个数的和．

输出格式#

输出包含若干行整数，即为所有操作 222 的结果．

数据范围#

对于 100%100\%100% 的数据，1≤n,m≤5×1051\le n,m \le 5\times 10^51≤n,m≤5×105，1≤x≤y≤n1\le x\le y\le n1≤x≤y≤n，−231≤k<231-2^{31}\le k<2^{31}−231≤k<231．

数据保证对于任意时刻，aaa 的任意子区间（包括长度为 111 和 nnn 的子区间）和均在 [−231,231)[-2^{31}, 2^{31})[−231,231) 范围内．

基础树状数组#

构造#

我们让树状数组 c 的每一项 c[i] 都存储以 i 为最终位置，以 lowbit(i) 为长度的区间中所有数的和，即 c[i] 存储区间 [i−lowbit(i)+1,i][i-lowbit(i)+1, i][i−lowbit(i)+1,i]．

什么是 lowbit

lowbit，即低位，是指一个数的二进制从右起的第一个 1 和这个 1 右边的所有 0 所构成的新的二进制数．或者说是最右边的 1 所对应的权值．

如，lowbit(12)=lowbit(11002)=1002=4lowbit(12) = lowbit(1100_2)=100_2=4lowbit(12)=lowbit(11002)=1002=4

例如，一个 16 个元素的数组，其树状数组的管辖区间示意如下：（摘自 oi-wiki）

如果写成二进制，更直观地：

令 iii 的二进制表示中，从右起第一个 1 位于第 kkk 位（即 lowbit(i)=2k−1lowbit(i) = 2^{k-1}lowbit(i)=2k−1），则 c[i]c[i]c[i] 管辖的区间由其本身 iii 和所有满足以下条件的正整数 mmm 组成：

mmm 的二进制中，比 kkk 更高的所有位与 iii 对应相等，第 kkk 位为 000，低于第 kkk 位的部分可以是任意值．

例：对于 i=88i=88i=88，二进制为 101 1000，从右起第一个 1 在第 4 位．

因此 c[88]c[88]c[88] 存储的数为 88 和所有形如 101 0xxx 的正整数——即固定高三位 101，低四位从 0000 变到 1000，对应区间 [81,88][81, 88][81,88]．

根据二进制知识可知，lowbit(i) = i & -i．

为什么？

由于 -i 在计算机里是补码，等于 ~i + 1（按位取反再加 1）．

这样操作后，若记 i 最右边的一个 1 为 kkk，由于取反，kkk 右边的所有位都会变成 1，在加一后由于进位，再次变成 0．kkk 在取反时变成 0，但由于进位变回 1．kkk 左边的所有位都由于取反和原来不一样．这样，在按位与后，除了 kkk 必然为 1 之外，其余的位必然都为 0．

例子：

i = 6 → 二进制 110，-i 是 010（补码计算：~110 = 001，加 1 得 010）．

110 & 010 = 010 → 正是最右边的 1（二进制 10，即 2）．

查询操作#

想要对区间 [l,r][l, r][l,r] 查询，只需要知道区间 [1,l−1][1,l-1][1,l−1] 和区间 [1,r][1, r][1,r] 的和，之后用后者减去前者即可．

如何进行前缀查询呢？

例如，我想要查询区间 [1,7][1, 7][1,7]，先看 c[7]c[7]c[7]，能管辖 [7,7][7,7][7,7]，那 6 及之前的怎么办呢？c[i]c[i]c[i] 肯定包含 iii 的，于是找到 c[6]c[6]c[6]，能管辖 [5,6][5,6][5,6]，同样的，那 4 及之前的怎么办呢，再看到 c[4]c[4]c[4]，能管辖 [1,4][1,4][1,4]，不剩了．

再例如，我想要查询区间 [1,5][1, 5][1,5]，先看 c[5]c[5]c[5]，能管辖 [5,5][5,5][5,5]，于是再找到 c[4]c[4]c[4]，能管辖 [1,4][1,4][1,4]，不剩了，故答案为 c[4]+c[5]c[4]+c[5]c[4]+c[5]．

一般的，我想要查询区间 [1,n][1, n][1,n]，先看 c[n]c[n]c[n]，发现 c[n]c[n]c[n] 所能够管辖到的最小值为 n−lowbit(n)+1n-lowbit(n)+1n−lowbit(n)+1，在将 c[n]c[n]c[n] 加和到 ansansans 中后，原问题就转化为查询区间 [1,n−lowbit(n)][1,n-lowbit(n)][1,n−lowbit(n)]，边界条件是 [1,0]=0[1,0] = 0[1,0]=0．

时间复杂度 O(log⁡n)O(\log n)O(logn)．

1
// 查询区间[1,ed]
2
int query(int ed) {
3
  int ans = 0;
4
  for (int i = ed; i >= 1; i -= i & -i) {
5
    ans += c[i];
6
  }
7
  return ans;
8
}
9
// 查询区间[l,r]
10
int query(int l, int r) {
11
  return query(r) - query(l - 1);
12
}

修改操作#

我们现在尝试修改序列的第 iii 项．

我们知道，树状数组是一棵树的形态，因此，修改一个元素，只需要更新记录这个元素的节点即可．

通过观察上图，所有被影响的节点会组成一条链的形状，且对于节点 a[i]a[i]a[i]，最底端（即下标最小）的节点为 c[i]c[i]c[i]．只需要找出 c[i]c[i]c[i] 及所有的祖先节点，将它们都同步进行更改即可．

注意到，节点 c[i]c[i]c[i] 的父节点总是 c[i+lowbit(i)]c[i+lowbit(i)]c[i+lowbit(i)]．（节点 c[i]c[i]c[i] 的父节点为 iii 最小的、真包含 c[i]c[i]c[i] 的节点）

因此，得出修改操作的一般步骤：

令 kkk 初始化为 iii
修改 c[k]c[k]c[k]
将 kkk 设定为 k+lowbit(k)k+lowbit(k)k+lowbit(k)，若 k≤nk\leq nk≤n，回到步骤 2

时间复杂度 O(log⁡n)O(\log n)O(logn)．

1
void add(int t, int k) {
2
  for (int i = t; i <= n; i += i & -i) {
3
    c[i] += k;
4
  }
5
}

建树#

一般来说，建树只需要转化为 nnn 次单点增加就可以了．时间复杂度 O(nlog⁡n)O(n\log n)O(nlogn)．

但是有没有 O(n)O(n)O(n) 建树的方法呢？

前面提到，c[i]=sum{ai∣i∈[i−lowbit(i)+1,i]}c[i] = sum\{a_i | i \in [i-lowbit(i)+1, i]\}c[i]=sum{ai∣i∈[i−lowbit(i)+1,i]}，可以使用前缀和优化．

1
for (int i = 1; i <= n; i++) {
2
  cin >> a[i];
3
  sum[i] = sum[i - 1] + a[i];
4
}
5
for (int i = 1; i <= n; i++) {
6
  c[i] = sum[i] - sum[i - (i & -i)];
7
}

标程#

1
#include <bits/stdc++.h>
2
using namespace std;
3

4
const int N = 5e5 + 100;
5

6
int n, m, c[N], a[N], sum[N];
7

8
class Tree {
9
public:
10
  int query(int ed) {
11
    int ans = 0;
12
    for (int i = ed; i >= 1; i -= i & -i) {
13
      ans += c[i];
14
    }
15
    return ans;
16
  }
17
  int query(int l, int r) {
18
    return query(r) - query(l - 1);
19
  }
20
  void add(int t, int k) {
21
    for (int i = t; i <= n; i += i & -i) {
22
      c[i] += k;
23
    }
24
  }
25
};
26

27
int main() {
28
  cin >> n >> m;
29
  Tree tree;
30
  for (int i = 1; i <= n; i++) {
31
    cin >> a[i];
32
    sum[i] = sum[i - 1] + a[i];
33
  }
34
  for (int i = 1; i <= n; i++) {
35
    c[i] = sum[i] - sum[i - (i & -i)];
36
  }
37
  for (int i = 1; i <= m; i++) {
38
    int op, x, k;
39
    cin >> op >> x >> k;
40
    if (op == 1)
41
      tree.add(x, k);
42
    else
43
      cout << tree.query(x, k) << endl;
44
  }
45
  return 0;
46
}

展开收起

树状数组变体#

如果需要单点查询，区间修改，又该怎么做呢？

P3368 【模板】树状数组 2

题目描述#

如题，已知一个数列，你需要进行下面两种操作：

将某区间每一个数加上 xxx；
求出某一个数的值．

输入格式#

第一行包含两个整数 NNN、MMM，分别表示该数列数字的个数和操作的总个数．

第二行包含 NNN 个用空格分隔的整数，其中第 iii 个数字表示数列第 ii i 项的初始值．

接下来 MMM 行每行包含 222 或 444 个整数，表示一个操作，具体如下：

操作 111：格式：1 x y k 含义：将区间 [x,y][x,y][x,y] 内每个数加上 kkk；

操作 222：格式：2 x 含义：输出第 xxx 个数的值．

输出格式#

输出包含若干行整数，即为所有操作 222 的结果．

数据范围#

对于 100%100\%100% 的数据：1≤N,M≤5×1051 \leq N, M\le 5\times10^51≤N,M≤5×105，1≤x,y≤n1 \leq x, y \leq n1≤x,y≤n，保证任意时刻序列中任意元素的绝对值都不大于 2302^{30}230．

很简单，只要使用差分来维护就可以了．

树状数组的主体不用改变，在建树时，由维护数组值改为维护差分值．

1
for (int i = 1; i <= n; i++) {
2
  cin >> a[i];
3
  tree.add(i, a[i] - a[i - 1]);
4
}

对于查询第 xxx 项，等同于区间查询差分数组 [1,x][1, x][1,x]．

1
cin >> x;
2
cout << tree.query(1, x) << endl;

对于区间修改，设第 k1k_1k1 到 k2k_2k2 项增加 xxx，等同于 c[k1]c[k_1]c[k1] 增加 xxx，c[k2+1]c[k_2+1]c[k2+1] 减少 xxx．

1
cin >> x >> y >> k;
2
tree.add(x, k);
3
tree.add(y + 1, -k);

标程#

1
#include <bits/stdc++.h>
2
using namespace std;
3

4
const int N = 5e5 + 100;
5

6
int n, m, c[N], a[N], sum[N];
7

8
class Tree {
9
public:
10
  int query(int ed) {
11
    int ans = 0;
12
    for (int i = ed; i >= 1; i -= i & -i) {
13
      ans += c[i];
14
    }
15
    return ans;
16
  }
17
  int query(int l, int r) {
18
    return query(r) - query(l - 1);
19
  }
20
  void add(int t, int k) {
21
    for (int i = t; i <= n; i += i & -i) {
22
      c[i] += k;
23
    }
24
  }
25
};
26

27
int main() {
28
  cin >> n >> m;
29
  Tree tree;
30
  for (int i = 1; i <= n; i++) {
31
    cin >> a[i];
32
    tree.add(i, a[i] - a[i - 1]);
33
  }
34
  for (int i = 1; i <= m; i++) {
35
    int op, x, y, k;
36
    cin >> op;
37
    if (op == 1) {
38
      cin >> x >> y >> k;
39
      tree.add(x, k);
40
      tree.add(y + 1, -k);
41
    }
42
    else {
43
      cin >> x;
44
      cout << tree.query(1, x) << endl;
45
    }
46
  }
47
  return 0;
48
}

展开收起