素数筛

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
#include <bits/stdc++.h>

\#define ll long long

using namespace std;

const int MAX = 1000100; // 求MAX范围内的素数

ll su[MAX],cnt;

bool isprimer[MAX];

void prime()

{

cnt = 1;

memset(isprimer,1,sizeof isprimer); // 初始化认为所有数都为素数

isprimer[0] = isprimer[1] = 0; // 0和1不是素数

for(ll i = 2;i <= MAX;i++)

{

if(isprimer[i]) // 保存素数

​ {

​ su[cnt++] = i;

​ }

for(ll j = 1;j < cnt && su[j]*i < MAX;++j) // 素数的倍数都为合数

​ {

​ isprimer[su[j]*i] = 0; // 筛掉小于等于i的素数和i的积构成的合数

​ }

}

}

int main()

{

prime();

for(ll i = 1;i < cnt;i++)

printf("%lld ",su[i]);

return 0;

}


最大子序和:在线处理法

https://blog.csdn.net/qazwsxxxxxasd/article/details/107029534

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
int MaxSubseqSum( int A[], int N )

{

int ThisSum, MaxSum;

int i;

​ ThisSum = MaxSum = 0;

for( i = 0; i <N; i++ ) {

​ ThisSum += A[i]; //向右累加

if( ThisSum > MaxSum )

​ MaxSum = ThisSum; //发现更大的和则更新当前结果

else if( ThisSum < 0 ) //如果当前子列和为0

​ ThisSum = 0; //则不可能使后面的部分增大,抛弃之

​ }

return MaxSum;

前缀和

// partial_sum(容器要计算的起始位置,容器要计算的结束位置,结果存放的起始位置,*自定义函数)

1
partial_sum(vec.begin(), vec.end(), arr, func);

差分

1
std::adjacent_difference(v.begin(), v.end(), v.begin());

除法分块

img

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
long long H(int n) {

long long res = 0; // 储存结果

int l = 1, r; // 块左端点与右端点

while (l <= n) {

r = n / (n / l); // 计算当前块的右端点

res += (r - l + 1) * 1LL *

​ (n / l); // 累加这一块的贡献到结果中。乘上 1LL 防止溢出

l = r + 1; // 左端点移到下一块

}

return res;}

最大公约数和最小公倍数

1
2
3
4
5
gcd(a,b) x lcm(a,b) = a x b



gcd(a,b)=k得到gcd(a/k,b/k)=1

欧几里得算法

1
2
3
4
5
int gcd(int a, int b) {

if (b == 0) return a;

return gcd(b, a % b);}

扩展欧几里得算法

1.递归
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int Exgcd(int a, int b, int &x, int &y) {

if (!b) {

x = 1; y = 0;

return a;

}

int d = Exgcd(b, a % b, x, y);

int t = x;

x = y;

y = t - (a / b) * y;

return d;}
2. 迭代
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int gcd(int a, int b, int& x, int& y) {

x = 1, y = 0;

int x1 = 0, y1 = 1, a1 = a, b1 = b;

while (b1) {

int q = a1 / b1;

tie(x, x1) = make_tuple(x1, x - q * x1);

tie(y, y1) = make_tuple(y1, y - q * y1);

tie(a1, b1) = make_tuple(b1, a1 - q * b1);

}

return a1;}
3. stein算法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
int gcdcore(int a,int b) {

if (a==0) return b;

if (b==0) return a;

while ((a & 0x1)==0) {

​ a=a>>1;

}

if (a<b) {

​ b=(b-a)>>1;

return gcdcore(b,a);

}

else {

​ a=(a-b)>>1;

return gcdcore(a,b);

}

}

int gcd(int a,int b) {

int c=0;

while (((a & 0x1)==0)&&(( b & 0x1 )==0)) {

​ a=a>>1;

​ b=b>>1;

​ c++;

}

if ((a & 0x1) == 0) {

​ a=a>>1;

return gcdcore(a,b)<<c;

}

else {

return gcdcore(b,a)<<c;

}

}

img

\

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include<cstdio>#define re register intlong long n,ans,f[100010];

int main(){

scanf("%lld",&n);

for(re i=n;i;--i){

​ f[i]=n/i*(n/i);

for(re j=i<<1;j<=n;j+=i)f[i]-=f[j];

​ ans+=f[i]*i;

}

printf("%lld",ans);return 0;

}


数位DP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
typedef long long ll;

int a[20];

ll dp[20][state];//不同题目状态不同

ll dfs(int pos,/*state变量*/,bool lead/*前导零*/,bool limit/*数位上界变量*/)//不是每个题都要判断前导零

{

//递归边界,既然是按位枚举,最低位是0,那么pos==-1说明这个数我枚举完了

if(pos==-1) return 1;/*这里一般返回1,表示你枚举的这个数是合法的,那么这里就需要你在枚举时必须每一位都要满足题目条件,也就是说当前枚举到pos位,一定要保证前面已经枚举的数位是合法的。不过具体题目不同或者写法不同的话不一定要返回1 */

//第二个就是记忆化(在此前可能不同题目还能有一些剪枝)

if(!limit && !lead && dp[pos][state]!=-1) return dp[pos][state];

/*常规写法都是在没有限制的条件记忆化,这里与下面记录状态是对应,具体为什么是有条件的记忆化后面会讲*/

int up=limit?a[pos]:9;//根据limit判断枚举的上界up;这个的例子前面用213讲过了

ll ans=0;

//开始计数

for(int i=0;i<=up;i++)//枚举,然后把不同情况的个数加到ans就可以了

{

if() ...

else if()...

​ ans+=dfs(pos-1,/*状态转移*/,lead && i==0,limit && i==a[pos]) //最后两个变量传参都是这样写的

/*这里还算比较灵活,不过做几个题就觉得这里也是套路了

​ 大概就是说,我当前数位枚举的数是i,然后根据题目的约束条件分类讨论

​ 去计算不同情况下的个数,还有要根据state变量来保证i的合法性,比如题目

​ 要求数位上不能有62连续出现,那么就是state就是要保存前一位pre,然后分类,

​ 前一位如果是6那么这意味就不能是2,这里一定要保存枚举的这个数是合法*/

}

//计算完,记录状态

if(!limit && !lead) dp[pos][state]=ans;

/*这里对应上面的记忆化,在一定条件下时记录,保证一致性,当然如果约束条件不需要考虑lead,这里就是lead就完全不用考虑了*/

return ans;

}

ll solve(ll x)

{

int pos=0;

while(x)//把数位都分解出来

{

​ a[pos++]=x%10;//个人老是喜欢编号为[0,pos),看不惯的就按自己习惯来,反正注意数位边界就行

​ x/=10;

}

return dfs(pos-1/*从最高位开始枚举*/,/*一系列状态 */,true,true);//刚开始最高位都是有限制并且有前导零的,显然比最高位还要高的一位视为0嘛

}

int main()

{

ll le,ri;

while(~scanf("%lld%lld",&le,&ri))

{

//初始化dp数组为-1,这里还有更加优美的优化,后面讲

printf("%lld\n",solve(ri)-solve(le-1));

}

}


龟速乘

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
lt mul(lt a,lt b,lt mod){

lt res=0;

while(b>0)

{

if(b&1) res=(res+a)%mod;

​ a=(a+a)%mod;

​ b>>=1;

}

return res;

}

中国剩余定理

1(两两互质)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
LL CRT(int k, LL* a, LL* r) {

LL n = 1, ans = 0;

for (int i = 1; i <= k; i++) n = n * r[i];

for (int i = 1; i <= k; i++) {

LL m = n / r[i], b, y;

exgcd(m, r[i], b, y); // b * m mod r[i] = 1

ans = (ans + a[i] * m * b % mod) % mod;

}

return (ans % mod + mod) % mod;}


(两两不互质(注意bi和ai的位置))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
lt excrt(){

lt x,y,k;

lt M=bi[1],ans=ai[1];//第一个方程的解特判

for(int i=2;i<=n;i++)

{

​ lt a=M,b=bi[i],c=(ai[i]-ans%b+b)%b;//ax≡c(mod b)

​ lt gcd=exgcd(a,b,x,y),bg=b/gcd;

if(c%gcd!=0) return -1; //判断是否无解,然而这题其实不用



​ x=mul(x,c/gcd,bg);

​ ans+=x*M;//更新前k个方程组的答案

​ M*=bg;//M为前k个m的lcm

​ ans=(ans%M+M)%M;

}

return (ans%M+M)%M;

}


线段树

\

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
#include<iostream>#include<cstdio>

\#define MAXN 1000001#define ll long long

using namespace std;

unsigned ll n,m,a[MAXN],ans[MAXN<<2],tag[MAXN<<2];

inline ll ls(ll x){

return x<<1;

}inline ll rs(ll x){

return x<<1|1;

}void scan(){

cin>>n>>m;

for(ll i=1;i<=n;i++)

scanf("%lld",&a[i]);

}inline void push_up(ll p){

ans[p]=ans[ls(p)]+ans[rs(p)];

// 向上不断维护区间操作

}

void build(ll p,ll l,ll r){

tag[p]=0;

if(l==r){ans[p]=a[l];return ;}

ll mid=(l+r)>>1;

build(ls(p),l,mid);

build(rs(p),mid+1,r);

push_up(p);

} inline void f(ll p,ll l,ll r,ll k){

tag[p]=tag[p]+k;

ans[p]=ans[p]+k*(r-l+1);

//记录当前节点所代表的区间

}inline void push_down(ll p,ll l,ll r){

ll mid=(l+r)>>1;

f(ls(p),l,mid,tag[p]);

f(rs(p),mid+1,r,tag[p]);

tag[p]=0;

}inline void update(ll nl,ll nr,ll l,ll r,ll p,ll k){

//nl,nr为要修改的区间

//l,r,p为当前节点所存储的区间以及节点的编号

if(nl<=l&&r<=nr)

{

​ ans[p]+=k*(r-l+1);

​ tag[p]+=k;

return ;

}

push_down(p,l,r);

ll mid=(l+r)>>1;

if(nl<=mid)update(nl,nr,l,mid,ls(p),k);

if(nr>mid) update(nl,nr,mid+1,r,rs(p),k);

push_up(p);

}ll query(ll q_x,ll q_y,ll l,ll r,ll p){

ll res=0;

if(q_x<=l&&r<=q_y)return ans[p];

ll mid=(l+r)>>1;

push_down(p,l,r);

if(q_x<=mid)res+=query(q_x,q_y,l,mid,ls(p));

if(q_y>mid) res+=query(q_x,q_y,mid+1,r,rs(p));

return res;

}int main(){

ll a1,b,c,d,e,f;

scan();

build(1,1,n);

while(m--)

{

scanf("%lld",&a1);

switch(a1)

​ {

case 1:{

scanf("%lld%lld%lld",&b,&c,&d);

​ update(b,c,1,n,1,d);

break;

​ }

case 2:{

scanf("%lld%lld",&e,&f);

printf("%lld\n",query(e,f,1,n,1));

break;

​ }

​ }

}

return 0;

}

快速幂

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
int quickPow(int n,int p,int k)

{

int ans = 1;

int base = n;



while (p)

{

//最后一位为1

if(p&1)

​ {

​ ans *= base;

​ ans %= k;

​ }

//去掉一位数

​ base *= base;

​ base %= k;

​ p >>= 1;

}



return ans;

}
1
2
3
template <class F, class T, class Compare>

F lower_bound (F first, F last,const T& val, Compare comp);

第一个first参数是一段连续空间的首地址,last是连续空间末端的地址,val是要查找的值。自定义版本里有一个comp参数(可省略)

离散化有三步走战略:

1.去重(可以用到unique去重函数)

2.排序

3.二分索引(可以用到lower_bound函数)

Unique(begin,end)去重

想得到去重后的size,需要减去初始地址 sz = unique(a,a + n) - a;