目录
数论
快速幂取模
int Pow(int a,int b,int c)
{
int res=1;
while(b>0)
{
if(b&1) res=res*a%c;
a=a*a%c;
b>>=1;
}
return res;
}//复杂度O(logn)二分乘法
用途：用来解决乘法的结果远超long long范围，但需要的结果有取余的乘法运算
时间复杂度：和快速幂一样，为O(logn)
ll qmul(ll a,ll b,ll m)
{
ll ans=0;
ll k=a;
ll f=1;//f是用来存负号的
if(k<0)
{f=-1;k=-k;}
if(b<0)
{f*=-1;b=-b;}
while(b){
if(b&1)
ans=(ans+k)%m;
k=(k+k)%m;
b>>=1;
}
return ans*f;
}快速乘
和二分乘法的用途一样，但是时间复杂度为O(1)
ll modmul(ll A,ll B,ll Mod)
{
return (A*B-(ll)((long double)A*B/Mod)*Mod+Mod)%Mod;
}gcd
int gcd(int a,int b)
{
return b==0?a:gcd(b,a%b);
}lcm
int lcm(int a,int b)
{
return a/gcd(a,b)*b;//如果先运算a*b，很可能超数据范围
}扩展欧几里得（递归）
int exgcd(int a,int b,int &x,int &y)
{
if(b==0)
{
x=1;
y=0;
return a;
}
int r=exgcd(b,a%b,x,y);
int t=x;
x=y;
y=t-a/b*y;
return r;
}欧拉函数
//欧拉函数公式：
//φ(N)=N*(1-1/P1)*(1-1/P2)*...*(1-1/Pn).
int Eular(int n)
{
int eu = n;
for (int i = 2 ; i * i <= n ; i++)
{
if (n % i == 0)
{
eu -= eu / i;
while (n % i == 0)
n /= i;
}
}
if (n > 1) //n本身也是个质因子
eu -= eu / n;
return eu;
}
欧拉函数打表
void Eular()
{
euler[1]=1;
for(int i=2;i<maxn;i++)
euler[i]=i;
for(int i=2;i<maxn;i++)
if(euler[i]==i)
for(int j=i;j<maxn;j+=i)
euler[j]=euler[j]/i*(i-1);//先进行除法是为了防止中间数据的溢出
}容斥（二进制状态枚举）
int n;
for(int i=0;i<(1<<n);i++)
{ // 相当于枚举所有的情况 o(2^n*n)
for(int j = 0; j < n ;j++)
{
printf("%d ",(i>>j)&1);
}
}
/**********应用*************/
// 二进制枚举计算[1,n]区间内有多少和数组a互质/不互质的数
ll ans = 0;
for(int i = 1; i < (1 << n); i++)
{ // 相当于枚举所有的情况 o(2^n*n)
int cnt = 0; ll tmp = 1;
for(int j = 0; j < n ;j++)
{ // a[j]
if(i >> j & 1)
{
cnt ++;
tmp = lcm(tmp, a[j]);
}
}
if(cnt & 1) ans += n / tmp;
else ans -= n / tmp;
}中国剩余定理
//chu是除数，yu是余数
//注意只适用于除数两两互质
#define ll long long
ll extended_euclid(ll a, ll b, ll &x, ll &y)
{
ll d;
if(b == 0)
{
x = 1;
y = 0;
return a;
}
d = extended_euclid(b, a % b, y, x);
y -= a / b * x;
return d;
}
ll chinese_remainder(ll b[], ll w[], ll len)
{
ll i, d, x, y, m, n, ret;
ret = 0; n = 1;
for(i=0; i < len ;i++)
n *= w[i];
for(i=0; i < len ;i++)
{
m = n / w[i];
d = extended_euclid(w[i], m, x, y);
ret = (ret + y*m*b[i]) % n;
}
return (n + ret%n) % n;
}数据结构
归并排序
#include <bits/stdc++.h>
using namespace std;
const int maxn=1e6+10;
int ans;//记录逆序对数
int a[maxn];//原数组
int b[maxn];//作用是记录排好序的数组
//将有二个有序数列a[first...mid]和a[mid...last]合并。
void mergearray(int a[], int first, int mid, int last, int temp[])
{
int i = first, j = mid + 1;
int m = mid, n = last;
int k = 0;
while (i <= m && j <= n)
{
if (a[i] <= a[j])
temp[k++] = a[i++];
else
{
temp[k++] = a[j++];
ans+=mid-i+1;//对逆序数进行记录
}
}
while (i <= m)
temp[k++] = a[i++];
while (j <= n)
temp[k++] = a[j++];
k=first;
i=0;
while(i<last-first+1)
a[k++]=temp[i++];
// 这个也行，但是有人说可能会数组越界
// for (i = 0; i < k; i++)
// a[first + i] = temp[i];
}
void mergesort(int a[], int first, int last, int temp[])
{
if (first < last)
{
int mid = (first + last) / 2;
mergesort(a, first, mid, temp); //左边有序
mergesort(a, mid + 1, last, temp); //右边有序
mergearray(a, first, mid, last, temp); //再将二个有序数列合并
}
}
//没搞懂这个是干什么用的
bool MergeSort(int a[], int n)
{
int *p = new int[n];
if (p == NULL)
return false;
mergesort(a, 0, n - 1, p);
delete[] p;
return true;
}
int main(int argc, char const *argv[])
{
int n;
cin>>n;
for(int i=0;i<n;i++)
cin>>a[i];
ans=0;
//用这个求逆序对数速度超级快，不知道为什么
MergeSort(a, n);
//mergesort(a,0,n-1,b);
cout<<ans<<endl;//输出逆序数对的个数
return 0;
}博弈论
威佐夫博奕
//有2堆石子。A B两个人轮流拿，A先拿。
//每次可以从一堆中取任意个或从2堆中取相同数量的石子，但不可不取。
//拿到最后1颗石子的人获胜。
void Witzov_game(int a,int b)//a代表第一堆，b代表第二堆
{
if(a>b) swap(a,b);//如果a>b交换a，b的值
int k=(double)a*(i-1.0)/2.0;
int x=k*(1+i)/2;
if(x==a&&a+k==b) printf("First one take win\n");
else
{
k++;
x=k*(i+1)/2;
if(x==a&&a+k==b) printf("Last one take win\n");
else printf("First one take win\n");
}
}Nim博弈
//有N堆石子。A B两个人轮流拿，A先拿。
//每次只能从一堆中取若干个，可将一堆全取走，
//但不可不取，拿到最后1颗石子的人获胜。
int a[N];//有N堆石子
void Nimbo()
{
int res=0;
for(int i=1;i<=N;i++)
{
res^=a[i];
}
if(res)
printf("Firse one take win\n");
else
printf("Last one take win\n");
}Bash博弈
//有一堆石子共有N个。A B两个人轮流拿，A先拿。
//每次最少拿1颗，最多拿K颗，
//拿到最后1颗石子的人获胜。
void Bash_game(int N,int K)
{
if (N%(K+1)==0)
{
std::cout<<"Last one take win"<<std::endl;
}
else
std::cout<<"First one take win"<<std::endl;
}递归实现n！
int fact(int n)
{
/*if(n==0||n==1) return 1;
else return n*fact(n-1);*/
return n==0?1:fact(n-1)*n;//上面注释的简化版
}图论（待补充）
建图方式
链式前向星
// 遍历以u为起始位置的所有边(逆序遍历)
// for(int i=head[u];~i;i<edge[i].Next)
struct Edge
{
int Next; //下一条边的储存下标
int to; //这条边的终点
int value; //权值
}edge[maxn];
int cnt;
int n,m; //n个点，m条边
// head数组初始化为-1
int head[maxn]; //head[i]表示以i为起点的第一条边
inline void add(int u,int v,int w) //起点u，终点v，权值w
{
edge[cnt].Next=head[u];
edge[cnt].value=w;
edge[cnt].to=v;
head[u]=cnt++; //第一条边为当前边
}vector
struct Edge
{
int y;
int value;
};
vector<Edge>V[maxn];
inline void add(int u,int v,int w)
{
V[u].push_back((Edge{v,w}));
}
inline void print(int u) //遍历以u为起始位置的所有的边
{
// 输出与u相连的边和对应的权值
for(int i=0;i<V[u].size();i++)
cout<<u<<" ---> "<<V[u][i].y<<" == "<<V[u][i].value<<endl;
}
int main(int argc, char const *argv[])
{
int n,m;
int x,y,z;
cin>>n>>m;
// 对vector进行清空
for(int i=0;i<maxn;i++)
V[i].clear();
while(m--)
{
cin>>x>>y>>z;
add(x,y,z);
}
for(int i=1;i<=n;i++)
print(i);
return 0;
}拓扑排序
void toposort()
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(!vis[j])//如果入度为0（没有前驱点）
{
vis[j]--;//入度变成-1进行标记（入度为-1的点均为已经删除的点）
printf("%d",j);//输出该节点
if(i!=n)
printf(" ");
else
printf("\n");
for(int k=1;k<=n;k++)
{
if(p[j][k])
vis[k]--;//将与j相连的节点都删去（删除与j有关的边）
}
break;
}
}
}
}最短路
Dijkstra（单源最短路）
邻接矩阵（时间复杂度O(n^2)）
#include <bits/stdc++.h>
using namespace std;
#define INF 0x7f7f7f7f
const int maxn=1e3+10;
int edge[maxn][maxn];
int flag[maxn]; //flag[i]标记节点i是否被查询
int dis[maxn]; //dis[i]表示节点i距离起始节点的最短距离
int n,m; //n个点，m条边
void Dijkstra()
{
memset(flag,0,sizeof(flag));
int ans,x;
for(int i=1;i<=n;i++)
dis[i]=edge[1][i];
dis[1]=0;
flag[1]=1;
for(int i=1;i<=n;i++)
{
ans=INF;
for(int j=1;j<=n;j++)
{
if(ans>dis[j]&&!flag[j])
{
ans=dis[j];
x=j;
}
}
flag[x]=1;
for(int j=1;j<=n;j++)
if(!flag[j])
dis[j]=min(dis[j],dis[x]+edge[x][j]);
}
}
int main(int argc, char const *argv[])
{
cin>>n>>m;
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
edge[i][j]=INF;
memset(dis,INF,sizeof(dis));
int x,y,z;
while(m--)
{
cin>>x>>y>>z;
edge[x][y]=z;
edge[y][x]=z;
}
Dijkstra();
for(int i=1;i<=n;i++)
cout<<"节点 "<<i<<" 到起点的最短距离为："<<(dis[i]==INF?-1:dis[i])<<endl;
return 0;
}链式前向星+堆优化 （时间复杂度O(E*log(V)）
#include <bits/stdc++.h>
using namespace std;
#define INF 0x7f7f7f7f
const int maxn=1e3+10;
struct Edge
{
int Next; //下一条变的储存下标
int to; //这条边的终点
int value; //权值
}edge[maxn];
int cnt;
int n,m,s; //s表示起点
int head[maxn];
int dis[maxn]; //最短距离
// 堆节点
struct node
{
int u,d;
bool operator < (const node& dui) const {return d>dui.d;}
};
inline void add(int u,int v,int w)
{
edge[cnt].Next=head[u];
edge[cnt].value=w;
edge[cnt].to=v;
head[u]=cnt++;
}
inline void dijkstra(int a)
{
memset(dis,INF,sizeof(dis));
priority_queue<node>q;
q.push(node{a,0});
dis[a]=0;
while(!q.empty())
{
node res=q.top();q.pop();
int u=res.u,d=res.d;
/
// 注意：没有下面这个会超时！！！
/
if(d!=dis[u])
continue;
for(int k=head[u];~k;k=edge[k].Next)
{
int v=edge[k].to,w=edge[k].value;
if(dis[v]>dis[u]+edge[k].value)
{
dis[v]=dis[u]+w;
q.push((node){v,dis[v]});
}
}
}
}
int main(int argc, char const *argv[])
{
memset(head,-1,sizeof(head));
scanf("%d%d%d",&n,&m,&s);
int x,y,z;
while(m--)
{
scanf("%d%d%d",&x,&y,&z);
add(x,y,z);
}
dijkstra(s);
for(int i=1;i<=n;i++)
{
printf("%d ",dis[i]);
}
printf("\n");
return 0;
}Spfa（单源最短路）
链式前向星（时间复杂度O(K*E)）
//不想敲了，副会长的代码直接粘来算了(～￣▽￣)～
#include <stdio.h>
#include <queue>
#include <string.h>
using namespace std;
// <1> spfa求单源最短路,链式前向星存图 时间复杂度o(kE) k是常数，大多数情况下为2
const int N = (int) 1e5 + 11; // 最大点数
const int M = (int) 1e6 + 11; // 最大边数
const int INF = (int) 0x3f3f3f3f;
struct Edge{ // 边的定义
int to, val, next;
Edge(){}
Edge(int _to, int _val, int _next){
to = _to; val = _val; next = _next;
}
}edge[M << 1]; // !!如果是双向图的话，边的数量是题目中描述的二倍
int n, m; // n 是图中的点数，m是图中的边数
int head[N], top;
void init(int n){ // 初始化
memset(head, -1, sizeof(int) * (n + 1));
top = 0;
}
void Add(int u, int v, int val){ // 加单向边
edge[top] = Edge(v, val, head[u]);
head[u] = top++;
}
void getmap(int m){ // 建图
int u, v, val;
while(m--){
scanf("%d%d%d",&u , &v, &val); // u->v有边
Add(u, v, val);
Add(v, u, val); // 如果是双向图，加上这个代码
}
}
bool vis[N]; int dis[N];
void spfa(int st, int ed){ // 核心代码,点序号从0-(n-1)或者1-n都可以
memset(dis, 0x3f, sizeof(int) * (n + 1));
memset(vis, false, sizeof(bool) * (n + 1)); // 清空和初始化
queue<int>que; que.push(st);
vis[st] = true; dis[st] = 0;
while(!que.empty()){
int u = que.front(); que.pop(); vis[u] = false;
for(int i = head[u]; ~i; i = edge[i].next){
Edge e = edge[i];
if(dis[e.to] > dis[u] + e.val) {//是否可以进行松弛
dis[e.to] = dis[u] + e.val;
if(!vis[e.to]){ // 是否在队列中，如果在可以跳过
que.push(e.to);
vis[e.to] = true;
}
}
}
}
printf("%d\n", dis[ed] == INF ? -1 : dis[ed]); // st到不了ed输出-1
}
int main(){
int t; scanf("%d%d", &t, &n);
init(n);
getmap(t);
spfa(n, 1);
return 0;
}
Floyd（多源最短路）
邻接矩阵（时间复杂度O(n^3)）
#include <bits/stdc++.h>
#define INF 0x7f7f7f7f
const int maxn=1e3+10;
using namespace std;
int n,m;
int edge[maxn][maxn];
//初始化
inline void init(int n)
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(i==j)
edge[i][j]=0;
else
edge[i][j]=edge[j][i]=INF;
}
}
}
// 建图
inline void add(int m)
{
int u,v,val;
while(m--)
{
cin>>u>>v>>val;
// 双向图写这行
edge[u][v]=edge[v][u]=min(edge[u][v],val);
// 单向图写这行
//edge[u][v] = min(edge[u][v], val);
}
}
inline void floyd(int n)
{
for(int k=1;k<=n;k++)
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
edge[i][j]=min(edge[i][j],edge[i][k]+edge[k][j]);
}
}
}
}
int main(int argc, char const *argv[])
{
cin>>n>>m;
init(n);
add(m);
floyd(n);
cout<<(edge[n][1]==INF?-1:edge[n][1])<<endl;
return 0;
}第K短路
Spfa+A*
#include <bits/stdc++.h>
#define ms(a) memset(a,0,sizeof(a))
#define INF 0x7f7f7f7f
#define ll long long
const int maxn=1e6+10;
using namespace std;
ll num1=0,num2=0;
ll n,m;//n个点m条边
ll s,t,k;//S->起点,t->终点,k->第k短路
ll h1[maxn],h2[maxn],d[maxn],flag[maxn];
struct node1
{
ll x,y,z,next;
}mp1[maxn],mp2[maxn];
struct node
{
ll v,c;
node(ll vv,ll cc) : v(vv),c(cc){}
friend bool operator < (node x,node y){return x.c+d[x.v]>y.c+d[y.v];}
};
inline void insert1(ll x,ll y,ll z)
{
mp1[++num1].x=x;
mp1[num1].y=y;
mp1[num1].z=z;
mp1[num1].next=h1[x];
h1[x]=num1;
}
inline void insert2(ll x,ll y,ll z)
{
mp2[++num2].x=x;
mp2[num2].y=y;
mp2[num2].z=z;
mp2[num2].next=h2[x];
h2[x]=num2;
}
void spfa()
{
queue<ll>Q;
Q.push(t);
for(int i=1;i<=n;i++)
d[i]=INF;
d[t]=0;
ms(flag);
flag[t]=1;
while(!Q.empty())
{
ll u=Q.front();
Q.pop();
flag[u]=0;
for(int i=h1[u];i;i=mp1[i].next)
{
ll v=mp1[i].y;
if(d[v]>d[u]+mp1[i].z)
{
d[v]=d[u]+mp1[i].z;
if(!flag[v])
{
flag[v]=1;
Q.push(v);
}
}
}
}
}
ll astar()
{
if(d[s]==INF)
return -1;
priority_queue<node>p;
ll cnt=0;p.push(node(s,0));
while(!p.empty())
{
node u=p.top();p.pop();
if(u.v==t)
{
cnt++;
if(cnt==k) return u.c;
}
for(int i=h2[u.v];i;i=mp2[i].next)
{
ll y=mp2[i].y;
p.push(node(y,u.c+mp2[i].z));
}
}
return -1;
}
int main(int argc, char const *argv[])
{
while(cin>>n>>m)
{
ms(h1);num1=0;
ms(h2);num2=0;
while(m--)
{
ll x,y,z;//起点，终点，权值
cin>>x>>y>>z;
insert1(y,x,z);
insert2(x,y,z);
}
cin>>s>>t>>k;
// 看清题目要求吧，POJ2449那题s和t是同一点时不能直接到达，要再走一圈
// if(s==t)
// k+=1;
spfa();
cout<<astar()<<endl;
}
return 0;
}并查集
init()
{
for(int i=0;i<=n;i++)
f[i]=i;
}
// 查询根节点（路径压缩）
int Find(int x)
{
if(f[x]==x)
return x;
return f[x]=Find(f[x]);
}
// 合并点
void Join(int x,int y)
{
f[Find(y)]=Find(x);
}最小生成树
Kruskal
#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define ms(a,b) memset(a,b,sizeof(a))
const int inf=(1<<30);
const ll INF=(1LL*1<<60);
const int maxn=1e6+10;
const int mod=1e9+7;
const int maxm=1e3+10;
using namespace std;
struct edge
{
int u,v,w;
}Edge[maxn];
int tol;
int f[maxn];
void add(int u,int v,int w)
{
Edge[tol].u=u;
Edge[tol].v=v;
Edge[tol++].w=w;
}
bool cmp(edge u,edge v)
{
return u.w<v.w;
}
int Find(int x)
{
if(f[x]==x)
return x;
return f[x]=Find(f[x]);
}
int Kruskal(int n)
{
int cnt=0;
int ans=0;
for(int i=0;i<tol;i++)
{
int u=Edge[i].u;
int v=Edge[i].v;
int w=Edge[i].w;
int tOne=Find(u);
int tTwo=Find(v);
if(tOne!=tTwo)
{
ans+=w;
f[tOne]=tTwo;
cnt++;
}
if(cnt==n-1)
break;
}
if(cnt<n-1)
return -1;
return ans;
}
int main(int argc, char const *argv[])
{
ios::sync_with_stdio(false);
cin.tie(0);
int n,m;
cin>>n>>m;
for(int i=0;i<=n;i++)
f[i]=i;
int x,y,z;
tol=0;
for(int i=0;i<m;i++)
{
cin>>x>>y>>z;
add(x,y,z);
add(y,x,z);
}
sort(Edge,Edge+tol,cmp);
int ans=Kruskal(n);
if(ans==-1)
cout<<"orz"<<endl;
else
cout<<ans<<endl;
return 0;
}数组/字符串类
最长回文子串长度（Manacher算法）
//复杂度O(n)
void Manacher()
{
l=strlen(ch);
//处理字符串，在字符串开头，结尾都加上'#'
for(int i=l;i>0;i--)//注意是从最后一位开始处理
{
ch[2*i]=ch[i-1];
ch[2*i+1]='#';
}
ch[0]='$';//避免出现越界问题
ch[1]='#';
int id,mx,ans;//id最大回文子串中心的位置，mx最大回文子串的边界
id=mx=ans=0;
for(int i=1;i<=2*l+1;i++)
{
if(mx>i) vis[i]=min(vis[2*id-i],mx-i);
else vis[i]=1;
while(ch[i+vis[i]]==ch[i-vis[i]]) vis[i]++;
if(mx<vis[i]+i)
{
id=i;
mx=vis[i]+i;
}
ans=max(ans,vis[i]);
}
printf("%d\n",ans-1);
} KMP（Kuangbin's）
// 字符串是从0开始的
// Next数组是从1开始的
void getNext()
{
int j, k;
j = 0; k = -1; next[0] = -1;
while(j < tlen)
if(k == -1 || T[j] == T[k])
next[++j] = ++k;
else
k = next[k];
}
/*
返回模式串T在主串S中首次出现的位置
返回的位置是从0开始的。
*/
int KMP_Index()
{
int i = 0, j = 0;
getNext();
while(i < slen && j < tlen)
{
if(j == -1 || S[i] == T[j])
{
i++; j++;
}
else
j = next[j];
}
if(j == tlen)
return i - tlen;
else
return -1;
}
/*
返回模式串在主串S中出现的次数
*/
int KMP_Count()
{
int ans = 0;
int i, j = 0;
if(slen == 1 && tlen == 1)
{
if(S[0] == T[0])
return 1;
else
return 0;
}
getNext();
for(i = 0; i < slen; i++)
{
while(j > 0 && S[i] != T[j])
j = next[j];
if(S[i] == T[j])
j++;
if(j == tlen)
{
ans++;
j = next[j];
}
}
return ans;
}前缀和
void Prefix(int n)
{
memset(sum,0,sizeof(sum));
for(int i=1;i<=n;i++)
sum[i]=sum[i-1]+a[i];
}DP类
背包类
01背包（每种物品只有一个）
//n 物品数量，v 背包容量
//size 单个物品体积，value 单个物品价值
void bag01()
{
for(int i=0;i<n;i++)
for(int j=v;j>=size[i];j--)
{
dp[j]=max(dp[j],dp[j-size[i]]+value[i]);
}
cout<<dp[v]<<endl;
}完全背包（每种物品有无穷多）
void complete()
{
for(int i=0;i<n;i++)
for(int j=size[i];j<=v;j++)
{
dp[j]=max(dp[j],dp[j-size[i]]+value[i]);
}
cout<<dp[v]<<endl;
}多重背包（每种物品数量有限）
//n 物品数量，v 背包容量
//size 单个物品体积，value 单个物品价值，num 该物品的数量
void multiply()
{
for(int i=0;i<n;i++)
{
int d1=1,d2=num[i];
while(d1<d2)
{
for(int j=v;j>=d1*size[i];j--)
{
dp[j]=max(dp[j],dp[j-d1*size[i]]+value[i]*d1);
}
d2-=d1;
d1*=2;
}
for(int j=v;j>=d2*size[i];j--) dp[j]=max(dp[j],dp[j-d2*size[i]]+value[i]*d2);
}
cout<<dp[v]<<endl;
}最长上升子序列（LIS）
//这个是计算连续的上升序列 如：1，2，3,4这种
void lis(int n)//n是数组元素的个数
{
for(int i=1;i<=n;i++)
{
b[a[i]]=b[a[i]-1]+1;
ans=std::max(ans,b[a[i]]);
}
}
//这个计算的是递增的（不需要连续递增）如：1,3,5,7这种
int a[maxn];
int dp[maxn];
int n;
void longest()
{
dp[0]=a[0];
int pos;
int L=1;
for(int i=0;i<n;i++)
{
pos=lower_bound(dp,dp+L,a[i])-dp;
dp[pos]=a[i];
L=max(L,pos+1);
}
cout<<L<<endl;
}最长公共子序列（LCS）
//状态转移方程：
// if( s[i]==t[j] )
// dp[i+1][j+1] = dp[i][j] + 1;
// else
// dp[i+1][j+1] = max(dp[i+1][j], dp[i][j+1]);
int dp[maxn][maxn];
char a[maxn],b[maxn];
int vis[maxn][maxn];//只求长度的时候可以去掉
// 如果要输出公共子序列，把int改成void，并把return去掉
int LCS()
{
int len1,len2,i,j;
len1=strlen(a);
len2=strlen(b);
memset(dp,0,sizeof(dp));
for(i=1;i<=len1;i++)
for(j=1;j<=len2;j++)
{
if(a[i-1]==b[j-1])
dp[i][j]=dp[i-1][j-1]+1;
else if(dp[i-1][j]>=dp[i][j-1])
{
dp[i][j]=dp[i-1][j];
vis[i][j]=1;
}
else
{
dp[i][j]=dp[i][j-1];
vis[i][j]=-1;
}
}
return dp[len1][len2];
}
// 这个函数可以将LCS打印出来
void Print(int i, int j)//i，j分别代表a，b字符串的长度
{
if(i==0||j==0)
return;
if(!vis[i][j])//如果a[i]和b[j]子母相同，输出
{
Print(i-1,j-1);
printf("%c",a[i-1]);
}
else if(vis[i][j]==1)//如果dp[i-1][j]>dp[i][j-1]
Print(i-1,j);
else//如果dp[i][j-1]>=dp[i-1][j]
Print(i,j-1);
}1~n全排列（递归实现）
int vis[10];//用于标记是否被访问过，0--未访问 1--已访问
int ans[10];//用于存储答案
int step,n;
void dfs(int step)
{
for(int i=1;i<=n;i++)
{
if(vis[i]==0)
{
vis[i]=1;
ans[step]=i;//将答案存储
if(step<n) //调用递归
dfs(step + 1); //即相当于再一次从头执行一个dfs函数，可以理解为一个嵌套
else
{
for(int i=1;i<=n;i++)
{
printf("%d",ans[i]);
if(i!=n) //用于控制输出格式
printf(" ");
else
printf("\n");
}
}
vis[i]=0; //访问完毕返回标记为可访问
//只有当输出了一个结果后才有可能执行
}
}
}
int main()
{
memset(vis,0,sizeof(vis));
step=0;
scanf("%d",&n);
dfs(1);
return 0;
}1~n全排列（利用STL）
void Full(int n)
{
for(int i=0;i<n;i++) a[i]=i+1;
do
{
for(int i=0;i<n;i++)
{
if(i!=0) cout<<" ";
cout<<a[i];
}
cout<<"\n";
}
while(next_permutation(a,a+n));
}DFS模板
void dfs()//参数用来表示状态
{
if(到达终点状态)
{
...//根据题意来添加
return;
}
if(越界或者是不符合法状态)
return;
for(扩展方式)
{
if(扩展方式所达到状态合法)
{
....//根据题意来添加
标记；
dfs（）；
修改（剪枝）；
(还原标记)；
//是否还原标记根据题意
//如果加上（还原标记）就是 回溯法
}
}
}判断1~1e9之内的数是不是素数
//是素数prime(n)==true
bool prime(int n)
{
for(int i=2;i*i<=n;i++)
if(n%i==0)
return false;
return n!=1;
}
vector<int> divisor(int n)
{
vector<int> res;
for(int i=1;i*i<=n;i++)
{
if(n%i==0)
{
res.push_back(i);
if(i!=n/i) res.push_back(n/i);
}
}
return res;
}
map<int,int> factor(int n)
{
map<int,int> res;
for(int i=2;i*i<=n;i++)
{
while(n%i==0)
{
++res[i];
n/=i;
}
if(n!=1) res[n]=1;
return res;
}
} Warshall算法求传递闭包（O(n^3)）
void Warshall()
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(a[j][i])
{
for(int k=0;k<=n;k++)
{
a[j][k]=a[j][k]|a[i][k];
}
}
}
}
}To be continued...
537
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
