ACM模板（自用）
目录
- 手动开-o2优化
- 常用头文件
- 读入优化
- 并查集
- 欧拉筛
- 快速幂
- 矩阵快速幂
- 最小生成树
- Kruskal O(nlogn)
- Prim O((n+m)logm)
- lcm、gcd与exgcd
- 单源最短路之队优Dijkstra
- 线段树
- 二分图
- 最长上升子序列（LIS）
- 最长公共子序列（LCS）
- 区间dp
- 大数加法
- 大数阶乘
- kmp
- 树状数组
手动开-o2优化
#pragma GCC optimize (2)//淦怎么会有憨批不给开-o2
常用头文件
#include读入优化
#include并查集
//https://www.luogu.org/problem/P3367
//题目大意：给定n个数 查询m次 1合并 2查询 判断是否在同一集合内
#include欧拉筛
注意素数定义：质数(素数)是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数（即0，1均非素数）
//https://www.luogu.org/problem/P3383
//题目大意 给定1-n个数 m次查询 输出该数是否是素数
#includep1,所以这样是筛不到的。唯一会筛的是第一种：p1和 p2*p3。
2、没有漏筛。
还是假设把这个合数分解质因数a*b*c，保证a
快速幂
//https://www.luogu.org/problem/P1226
#include矩阵快速幂
只有左矩阵的列数等于右矩阵的行数才可乘
（其实矩阵快速幂的难点在构造矩阵=.=）
矩阵乘法：行乘列（ans[i][j]=a[i][k]*b[k][j]的和）
//例题：求斐波那契数列
#include最小生成树
prim算法适合稠密图（边多点少），kruskal算法适合稀疏图（边少点多）。
Kruskal O(nlogn)
//https://www.luogu.org/problem/P3366
#includePrim O((n+m)logm)
//https://www.luogu.org/problem/P3366
#includelcm、gcd与exgcd
注意该无法处理含有负数的情况
#include单源最短路之队优Dijkstra
//https://www.luogu.org/problem/P4779
#include线段树
难点在多种操作（例如区间加与区间乘与区间覆盖等操作同时存在时down函数的处理顺序上以及对不同lazy下标优先级与操作顺序上是否进行清零等操作）
看起来好乱
#include二分图
#include最长上升子序列（LIS）
//初始化dp为inf=0x3f3f3f
memset(dp,inf,sizeof(dp));
for (int i=0;i<len;i++)
{
//获取位置
int pos=lower_bound(dp,dp+len,s[i])-dp;
//更新位置
dp[pos]=s[i];
ans=max(ans,pos);
}
//答案为ans+1
cout << ans+1 << endl;
最长公共子序列（LCS）
//len1和len2为两字符串长度
for (int i=1;i<=len1;i++)
for (int j=1;j<=len2;j++)
//相等时直接更新
if (s1[i-1]==s2[j-1])
dp[i][j]=dp[i-1][j-1]+1;
//不相等时继承之前的最大值
else
dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
//答案为dp[len1][len2]
cout << dp[len1][len2] << endl;
区间dp
//初始化DP数组
for (int i=1;i<=n;i++)
dp[i][i]=INF(0 or 其他)
//枚举区间长度
for (int len=1;len<n;len++)
//枚举起点
for (int i=1;i+len<=n;i++)
{
//区间终点
int j=i+len;
//枚举分割点
for (int k=i;k<j;k++)
dp[i][j]=max(dp[i][j],dp[i][k]+dp[k+1][j]+w[i][j]);
}
//区间1-n的结果
cout << dp[1][n] << endl;
大数加法
/*
|大数模拟加法|
|用string模拟|
|16/11/05ztx, thanks to caojiji|
*/
string add1(string s1, string s2)
{
if (s1 == "" && s2 == "") return "0";
if (s1 == "") return s2;
if (s2 == "") return s1;
string maxx = s1, minn = s2;
if (s1.length() < s2.length()){
maxx = s2;
minn = s1;
}
int a = maxx.length() - 1, b = minn.length() - 1;
for (int i = b; i >= 0; --i){
maxx[a--] += minn[i] - '0'; // a一直在减 ， 额外还要减个'0'
}
for (int i = maxx.length()-1; i > 0;--i){
if (maxx[i] > '9'){
maxx[i] -= 10;//注意这个是减10
maxx[i - 1]++;
}
}
if (maxx[0] > '9'){
maxx[0] -= 10;
maxx = '1' + maxx;
}
return maxx;
}
大数阶乘
/*
|大数模拟阶乘|
|用数组模拟|
|16/12/02ztx|
*/
#include - 01背包
1.1 题目
有N件物品和一个容量为V的背包。第i件物品的费用是w[i]，价值是v[i]，求将哪些物品装入背包可使价值总和最大。
1.2 特点
每种物品仅有一件，可以选择放与不放。
1.3 基本的状态转移方程
f[i][j] = max(f[i − 1][j], f[i − 1][j − w[i]] + v[i])
1.4 基本模板
for(int i = 0; i < h; i++)
{
for(int j = c; j >= v[i]; j–)
{
dp[j] = max(dp[j], dp[j - v[i]] + v[i]);
}
}
1.5沾题
1.P2925 [USACO08DEC]干草出售Hay For Sale
简单01背包有一点优化：背包装满后就没必要再继续循环了。
#include
using namespace std;
const int maxn = 50010;
int c, h, v[maxn], dp[maxn];
int main()
{
scanf("%d%d", &c, &h);
for(int i = 0; i < h; i++) scanf("%d", &v[i]);
for(int i = 0; i < h; i++)
{
for(int j = c; j >= v[i]; j--)
{
dp[j] = max(dp[j], dp[j - v[i]] + v[i]);
if(dp[j] == j) continue;
}
if(dp[c] == c) // 优化装满后退出
{
break;
}
}
printf("%d\n", dp[c]);
return 0;
}
1.6 常数优化
for(int i = 0; i < h; i++)
{
int sum = 0;
for(int k = i; k < h; k++) sum += v[i];
int maxx = max(c - sum, v[i]);
for(int j = c; j >= maxx; j–)
{
dp[j] = max(dp[j], dp[j - v[i]] + v[i]);
}
if(dp[c] == c)
{
break;
}
}
1.7初始化细节
(1)恰好装满背包，初始化dp[0] = 0,其余F[1 … V] 均设为-INF
(2)未要求将背包装满，只是价格尽量大 F[0 … V] 均设为0
2.完全背包
2.1 题目
有N种物品和一个容量为V的背包，每种物品都有无限件可用。第i种物品的费用是w[i]，价值是v[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。
2.2 基本思路
这个问题非常类似于01背包问题，所不同的是每种物品有无限件。也就是从每种物品的角度考虑，与它相关的策略已并非取或不取两种，而是有取0件、取1件、取2件……等很多种。如果仍然按照解01背包时的思路，令f[i][j]表示前i种物品恰放入一个容量为V的背包的最大权值。仍然可以按照每种物品不同的策略写出状态转移方程，像这样：
f[i][j] = max(f[i − 1][j − k ∗ w[i]] + k ∗ v[i]) ∣ 0 <= k ∗ w[i] <= V
二维状态转移方程
f[i][j] = max(f[i − 1][j], f[i][j − w[i]] + v[i])
2.3 模板
for(int i = 0; i < n; i++)
for(int j = w[i]; j <= W; j++)
{
dp[j] = min(dp[j], dp[j - w[i]] + v[i]);
}
2.4 沾个题
Piggy-Bank
#include
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 10010;
int t, W, w[maxn], v[maxn], dp[maxn], n;
int main()
{
scanf("%d", &t);
while(t–)
{
int w1, w2;
scanf("%d%d", &w1, &w2);
fill(dp, dp + maxn, INF);
W = w2 - w1;
scanf("%d", &n);
for(int i = 0; i < n; i++)
{
scanf("%d%d", &v[i], &w[i]);
}
dp[0] = 0;
for(int i = 0; i < n; i++)
for(int j = w[i]; j <= W; j++)
{
dp[j] = min(dp[j], dp[j - w[i]] + v[i]);
}
if(dp[W] == INF)
{
printf(“This is impossible.\n”);
}
else
{
printf(“The minimum amount of money in the piggy-bank is %d.\n”, dp[W]);
}
}
return 0;
}
3 多重背包
3.1题目
有N种物品和一个容量为V的背包。第i种物品最多有p[i]件可用，每件费用是w[i]，价值是v[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。
3.2 复杂度的多重背包问题
void Zero(int w, int p)
{
for(int j = W; j >= w; j–)
{
dp[j] = max(dp[j], dp[j - w] + p);
}
}
void Complete(int w, int p)
{
for(int j = w; j <= W; j++)
{
dp[j] = max(dp[j], dp[j - w] + p);
}
}
void Multiple(int c, int w, int p)
{
if(c * w >= W)
{
Complete(w, p);
return;
}
int k = 1;
while(k < c)
{
Zero(k * w, k * p);
c = c - k;
k = 2 * k;
}
Zero(c * w, c * p);
}
3.3可行性问题O(VN)的算法
当问题是每种有若干的物品能否他Inman给定容积的背包，只需考虑装满背包的可行性O（VN）复杂度。
基本思想：设F[i， j]表示用了前i种物品填满容量为j的背包后最多还剩几个第i种物品可用。若F[i, j] = -1表示这种状态不太可行，若可行则满足F[i , j] >=0 && F[i, j] <= Mi
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for(int i = 1; i <= n; i++)
{
for(int j = 0; j <= V; j++)
{
if(dp[i - 1][j] >= 0) dp[i][j] = M[i];
else dp[i][j]= -1;
}
for(int j = 0; j <= V - C[i]; j++)
{
if(dp[i][j] > 0)
dp[i][j + C[i]] = max(dp[i][j + C[i], dp[i][j] - 1);
}
}
4 混合多种背包
4.1问题
如果将前面三个背包混合起来，也就是说，有的物品只可以取一次（01背包），有的物品可以取无限次（完全背包），有的物品可以取的次数有一个上限（多重背包），应该怎么求解呢？
4.2 01背包与完全背包的混合
考虑到在01背包和完全背包中给出的伪代码只有一处不同，故如果只有两类物品：一类物品只能取一次，另一类物品可以取无限次，那么只需在对每个物品应用转移方程时，根据物品的类别选用顺序或逆序的循环即可，复杂度是O(VN) O(VN)O(VN)。
4.3再加上多重背包
如果再加上有的物品最多可以取有限次，那么原则上也可以给出O(VN) O(VN)O(VN)的解法：遇到多重背包类型的物品用单调队列解即可。但如果不考虑超过NOIP NOIPNOIP范围的算法的话，用多重背包中将每个这类物品分成O(log(p[i])) O(log(p[i]))O(log(p[i]))个01背包的物品的方法也已经很优了
4.4赋个多校题
AreYouBusy
题意：他由很多工作0 ，至少取一个，1 最多取一个， 2随意取，让你求在时间之内，求最大的开心值。
1.第一类，至少选一项，即必须要选，那么在开始时，对于这一组的dp的初值，应该全部赋为负无穷，这样才能保证不会出现都不选的情况。
dp[i][j]=max(dp[i][j],max(dp[i][j-w[x]]+p[x],dp[i-1][j-w[x]]+p[x]));
2.第二类，最多选一项，即要么不选，一旦选，只能是第一次选。
dp[i][j]=max(dp[i][j],dp[i-1][j-w[x]]+p[x]);
3.第三类，任意选，即不论选不选，选几个都可以。
dp[i][j]=max(dp[i][j],dp[i][j-w[x]]+p[x]);
代码
#include
using namespace std;
const int maxn = 110;
const int INF = 0x3f3f3f3f;
int n, t, x, y, v[maxn], w[maxn], dp[maxn][maxn];
int main()
{
while(scanf("%d%d", &n, &t) != EOF)
{
memset(dp, 0, sizeof(dp));
for(int i = 1; i <= n; i++)
{
scanf("%d%d", &x, &y);
for(int k = 1; k <= x; k++) scanf("%d%d", &v[k], &w[k]);
if(y == 0) // 至少取一个
{
for(int j = 0; j <= t; j++) dp[i][j] = -INF;
for(int k = 1; k <= x; k++)
{
for(int j = t; j >= v[k]; j–)
{
dp[i][j] = max(dp[i][j], dp[i][j - v[k]] + w[k]);
dp[i][j] = max(dp[i][j], dp[i - 1][j - v[k]] + w[k]);
}
}
}
else if(y == 1) // 至多取一个
{
for(int j = 0; j <= t; j++) dp[i][j] = dp[i - 1][j];
for(int k = 1; k <= x; k++)
{
for(int j = t; j >= v[k]; j–)
dp[i][j] = max(dp[i][j], dp[i - 1][j - v[k]] + w[k]);
}
}
else if(y == 2) // 至多取一个
{
for(int j = 0; j <= t; j++) dp[i][j] = dp[i - 1][j];
for(int k = 1; k <= x; k++)
{
for(int j = t; j >= v[k]; j–)
dp[i][j] = max(dp[i][j], dp[i][j - v[k]] + w[k]);
}
}
}
int ans = -1;
ans = max(ans, dp[n][t]);
printf("%d\n", ans);
}
return 0;
}
5 二维费用背包
5.1题目
二维费用的背包问题是指：对于每件物品，具有两种不同的费用；选择这件物品必须同时付出这两种代价；对于每种代价都有一个可付出的最大值（背包容量）。问怎样选择物品可以得到最大的价值。设这两种代价分别为代价1和代价2，第i件物品所需的两种代价分别为w[i]和g[i]。两种代价可付出的最大值（两种背包容量）分别为V和T。物品的价值为v[i]。
5.2模板
for(int i = 0; i < n; i++)
{
for(int j = v; j >= a[i]; j--)
{
for(int k = m; k >= b[i]; k--)
{
dp[j][k] = max(dp[j][k], dp[j - a[i]][k - b[i]] + c[i]);
}
}
}
5.3沾题
1.P1507 NASA的食物计划
#include
using namespace std;
const int maxn = 410;
int v, m, n, a[maxn], b[maxn], c[maxn], dp[maxn][maxn];
int main()
{
scanf("%d%d", &v, &m);
scanf("%d", &n);
for(int i = 0; i < n; i++) scanf("%d%d%d", &a[i], &b[i], &c[i]);
for(int i = 0; i < n; i++)
{
for(int j = v; j >= a[i]; j–)
{
for(int k = m; k >= b[i]; k–)
{
dp[j][k] = max(dp[j][k], dp[j - a[i]][k - b[i]] + c[i]);
}
}
}
printf("%d\n", dp[v][m]);
return 0;
}
2.FATE
题意：打游戏有忍耐值，需要在忍耐值之内刷够经验，最多杀n只怪。
#include
using namespace std;
const int maxn = 110;
int n, m, k, s, a[maxn], b[maxn], dp[maxn][maxn];
int main()
{
while(scanf("%d%d%d%d", &n, &m, &k, &s) != EOF)
{
memset(dp, 0, sizeof(dp));
for(int i = 0; i < k; i++) scanf("%d%d", &a[i], &b[i]);
for(int i = 0; i < k; i++)
{
for(int j = b[i]; j <= m; j++)
{
for(int x = s; x >= 1; x–)
{
dp[j][x] = max(dp[j][x], dp[j - b[i]][x - 1] + a[i]);
}
}
}
int ans = 0x3f3f3f3f;
for(int i = 1; i <= m; i++)
{
for(int j = 1; j <= s; j++)
{
if(dp[i][s] >= n)
{
ans = m - i;
break;
}
}
if(ans != 0x3f3f3f3f) break;
}
if(ans == 0x3f3f3f3f) printf("-1\n");
else printf("%d\n", ans);
}
return 0;
}
6 分组背包
有N件物品和一个容量为V的背包。第i件物品的费用是w[i]，价值是v[i]。这些物品被划分为若干组，每组中的物品互相冲突，最多选一件。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。
f[k][j]=max(f[k−1][j],f[k−1][j−c[i]]+w[i]∣物品i属于组k)
模板：
for(int i = 1; i <= n; i++)
{
for(int j = m; j >= 1; j–)
{
for(int k = 1; k <= j; k++)
{
dp[j] = max(dp[j], dp[j - k] + a[i][k]);
}
}
kmp
/*
|kmp算法|
|字符串匹配|
|17/1/21ztx|
*/
void getnext(char str[maxn], int nextt[maxn]) {
int j = 0, k = -1;
nextt[0] = -1;
while (j < m) {
if (k == -1 || str[j] == str[k]) {
j++;
k++;
nextt[j] = k;
}
else
k = nextt[k];
}
}
void kmp(int a[maxn], int b[maxn]) {
int nextt[maxm];
int i = 0, j = 0;
getnext(b, nextt);
while (i < n) {
if (j == -1 || a[i] == b[j]) { // 母串不动，子串移动
j++;
i++;
}
else {
// i不需要回溯了
// i = i - j + 1;
j = nextt[j];
}
if (j == m) {
printf("%d\n", i - m + 1); // 母串的位置减去子串的长度+1
return;
}
}
printf("-1\n");
}
树状数组
/*
|16/11/06ztx|
*/
#include