在ACM的巨坑里挣扎的弱鸡整理的模板

头文件，定义，等等

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <math.h>
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <iomanip>

#define ll long long
#define ull unsigned long long
#define Pi 3.1415927
#define maxn 100005
#define debug cout<<"*******"<<endl
using namespace std;
const int minn = 1e-9;
const int INF = 0x3f3f3f3f;
const int mod = 1e9+7;
int main(){
    std::ios::sync_with_stdio(false);//提高cin效率
    return 0;
}

cout格式化输出

#include <iomanip>//头文件
//感觉就是没有printf好用！

字符串：

//逆置字符串
reverse(s.begin(),s.end());//无返回值，原字符串被逆置。

数学

//两点间距离 (x1,y1),(x2,y2)
sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2))
//球的体积公式 半径r
4*Pi*r*r*r/3
//一元二次方程求根公式
x1 = (-b + sqrt(b*b - 4*a*c))/(2a)
x2 = (-b - sqrt(b*b - 4*a*c))/(2a)
//一元二次方程配方法
ax^2 + bx + c = 0(a != 0)
(x - b/2a)^2 =  -c/a + (b/2a)^2

除法取模

1.(a/b)%mod=a%(b*mod)/b%mod;
2.(a/b)%mod=a*b^(mod-2)%mod，mod为素数

日期

bool is_Leap(int n){//是否为闰年
    if(n % 4 == 0 && n % 100 != 0 || n % 400 == 0) return true;
    return false;
}
//月，闰年时二月+1
int month[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
//求y年m月d日到1年1月1日时的天数
int getDays(int y,int m,int d){
    int days = 0;
    for(int i = 1; i < y;i++){
        days += 365;
        if(is_Leap(i)){
            days += 1;
        }
    }
    for(int i = 1; i < m;i++){
        days += month[i];
        if(i == 2 && is_Leap(y)){
            days += 1;
        }
    }
    days += d;
    return days;
}

位运算

a & b //与运算
a | b //或运算
a ^ b //异或运算
c >>= 1;//等价于c /= 2
//奇偶
if（c&1） is_odd;
else is_even;

幂运算

//快速幂
int pow(int a,int b){
    int ans = 1;
    while(b!=0){
        if(b&1) ans *= a;
        a *= a;
        b >>= 1;
    }
    return ans;
}
//快速幂取模
int f(int a,int b,int m){
    int ans = 1;
    a = a % m;
    while(b){
        if(b&1){
            ans = ans * a % m;
        }
        a = a * a % m;
        b>>=1;
    }
    return ans;
}
//矩阵快速幂
void matMulti(int a[][N], int b[][N],  int n) 
{//求a*b，并将相乘结果存入a中
    int temp[N][N];      //先将a与b的乘积存入temp，然后再将其存入a 
    memset(temp, 0, sizeof(temp));
    for(int i = 0;i < n;i++)
    {
        for(int j = 0;j < n;j++)
        for(int k=0;k< n;k++)  
        temp[i][j]+=a[i][k]*b[k][j]; 
    }    //该循环求a*b，并存入了temp 
    for(int i=0;i<n;i++)      //将temp中的值转存入a  
        for(int j=0;j<n;j++)  
            a[i][j]=temp[i][j];     
}
void matPow(int a[][N], int n) 
{  //求N*N矩阵a的n次幂  
    int ans[N][N];              //ans用来存放最终结果  
    memset(ans, 0, sizeof(ans));  //将矩阵ans的所有元素置为0  
    for(int i=0; i<n; i++)   ans[i][i] = 1;  //设置单位矩阵  
    while(n)  
    {   if(n&1) matMulti(ans, a, N);   // ans = ans*a；  
        matMulti(a, a, N);            //a = a*a，
        n=n>>1;                  //n = n/2 ;
    }  
    return ;  
}
//矩阵快速幂结构体表示---求第n个菲波那切数
#include<bits/stdc++.h>
#define ll long long
#define mod 1000000009
using namespace std;
struct Node{
    ll c[2][2];
}ans;
Node mult(Node a,Node b){
    Node c = {0};
    for(int i=0;i<2;i++){
        for(int j=0;j<2;j++){
            for(int k=0;k<2;k++){
                c.c[i][j] += (a.c[i][k] * b.c[k][j]) % mod;
                c.c[i][j] %= mod;
            }
        }
    }
    return c;
}
Node mulPow(ll n){
    Node res = ans;
    if(n<0) return res;
    while(n){
        if(n&1) res = mult(res,ans);
        ans = mult(ans,ans);
        n>>=1;
    }
    return res;
}
void init(){
    ans.c[0][0] = 1;
    ans.c[0][1] = 1;
    ans.c[1][0] = 1;
    ans.c[1][1] = 0;
}
int main(){
    ll n;
    while(cin>>n){
        init();
        Node a = mulPow(n-2);
        cout<<a.c[0][0]*1<<endl;
    }
return 0;}

扩展欧几里得

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
    x=y;
    y=t-a/b*y;
    return r;//返回最大公约数
}

并查集

int find(int root){//紫皮书的find
    return pre[root] == root ? root : pre[root] = find(pre[root]);
}
int find(int root)//自己整理的
{  
    int son, tmp;  
    son = root;  
    while(root != pre[root])  
        root = pre[root];  
    while(son != root)  
    {  
        tmp = pre[son];  
        pre[son] = root;  
        son = tmp;  
    }  
    return root;  
} 
void join(int root1, int root2)//连接  
{  
   int x, y;  
   x = find(root1);
   y = find(root2);
   if(x != y)   
      pre[x] = y;  
}  

动态规划典型问题状态转移方程

//数字三角形：
f[i][j]=max(f[i−1][j],f[i−1][j−1])+a[i][j]

最小生成树—克鲁斯卡尔

struct Edge{ //结点结构体
    int u,v,w;
    Edge(){}
    Edge(int u,int v,int w){//构造方法
        this->u = u;
        this->v = v;
        this->w = w;
    }
    bool operator < (const Edge &a){//排序规则
        return w < a.w;
    }
};
char a,b;
Edge e[maxn];
int pa[90];
void init(){//并查集初始化
    for(int i = 0; i <= 30; i++){
        pa[i] = i;
    }
}
int findset(int x){//寻找集合代表并进行路径压缩
    return x == pa[x] ? x : pa[x] = findset(pa[x]);
}
int main(){
    std::ios::sync_with_stdio(false);
    int n,m,x,w;
    while(cin>>n && n){
        m = 0;
        int cnt = n;
        n--;
        while(n--){
            cin>>a>>x;
            int u = a - 'A' + 1;
            while(x--){
                cin>>b>>w;
                int v = b - 'A' + 1;
                e[m++] = Edge(u,v,w);//添加边，并记录边的个数。
            }
        }

        sort(e,e+m);
        int cost = 0;//花费
        init();

        for(int i = 0; i < m; i++){//贪心，每次找最小花费的边，如果是不同树中的，添加到最小生成树中
            Edge u = e[i];
            int x = u.u;
            int y = u.v;
            x = findset(x);
            y = findset(y);
            if(x != y){
                cost += u.w;
                pa[x] = y;
                cnt--;
            }
            if(cnt == 1){
                break;
            }
        }
        cout<<cost<<endl;
    }
    return 0;
}

最短路径 迪杰斯特拉

int n;
struct Edge{
    int from,to,dist;
    Edge(int u,int v,int d):from(u),to(v),dist(d){}
};
struct HeapNode{
    int d,u;
    HeapNode(int td,int tu) : d(td) , u(tu) { }
    bool operator < (const HeapNode& rhs) const{
        return d > rhs.d;
    }
};
struct Dijkstra{
    int m;
    vector<Edge> edges;
    vector<int> G[maxn];
    bool done[maxn];
    int d[maxn];
    int p[maxn];
    void init(){
        for(int i = 0; i <= n+1;i++){
            G[i].clear();
        }
        edges.clear();
    }
    void AddEdge(int from,int to,int dist){
        edges.push_back(Edge(from,to,dist));
        m = edges.size();
        G[from].push_back(m-1);
    }
    void dijkstra(int s){
        priority_queue <HeapNode> Q;
        for(int i = 0; i <= n+1; i++){
            d[i] = INF;
        }
        d[s] = 0;
        memset(done,0,sizeof(done));
        Q.push(HeapNode(0,s));
        while(!Q.empty()){
            HeapNode x = Q.top();Q.pop();
            int u = x.u;
            if(done[u]) continue;
            done[u] = true;
            for(int i = 0; i < G[u].size();i++){
                Edge &e = edges[G[u][i]];
                if(d[e.to] >= d[u] + e.dist){
                    d[e.to] = d[u] + e.dist;
                    p[e.to] = u;
                    Q.push(HeapNode(d[e.to],e.to));
                }else if(d[e.to] == d[u] + e.dist){
                    p[e.to] = min(G[u][i], p[e.to]);
                }
            }
        }
    }
}D;
int main(){
    std::ios::sync_with_stdio(false);
    int T,m;cin>>T;
    while(T--){
        D.init();
        cin>>n>>m;
        int u,v,w;
        for(int i = 0; i < m;i++){
            cin>>u>>v>>w;
            D.AddEdge(v,u,w);
        }
        D.dijkstra(n+1);

        if(D.d[0] >= INF){
            cout<<-1<<endl;
        }
        else if(D.p[0] == n+1){
            cout<<0<<endl;
        }else{
            cout<<D.p[0]<<endl;
        }
    }
    return 0;
}

母函数：

多项式为：
    （1+x）*（1+x^2）*(1+x^10+x^15)
    = (1+x^2+x+x^3)*(1+x^10+x^15) 
    = (1+x^10+x^15) + x^2*(1+x^10+x^15) +x*(1+x^10+x^15) +x^3*(1+x^10+x^15) 
    =(1+x^10+x^15) +(x^2+x^12+x^17) +(x+x^11+x^16) +(x^3+x^13+x^18)
    =1+x+x^2+x^3+x^10+x^11+x^12+x^13+x^15+x^16+x^17+x^18

int main(){
    int v[] = {1,2,5};
    int n1[] = {0,0,0};
    int n2[3];
    int a[maxn],b[maxn];
    while(cin>>n2[0]>>n2[1]>>n2[2] && (n2[0] != 0 || n2[1] != 0 || n2[2] != 0)){
        int k = n2[0]+2*n2[1]+5*n2[2];
        memset(a,0,sizeof(a));
        a[0] = 1;
        for(int i = 0;i<=2;i++){
            memset(b,0,sizeof(b));
            for(int j = n1[i];j<=n2[i]&&j*v[i]<=k;j++){
                for(int t = 0; t+j*v[i]<=k;t++){
                    b[t+j*v[i]] += a[t];
                }
            }
            memcpy(a,b,sizeof(b));
        }
        bool f = true;
        for(int i = 1;i < k;i++){
            if(a[i]==0){
                cout<<i<<endl;
                f = false;
                break;
            }
        }
        if(f){
            cout<<k+1<<endl;
        }
    }
    return 0;
}

广搜

int bfs(int n)
{
    queue<node> que;
    node fr,en;
    fr.n=n,fr.step=0;
    book[n]=1;
    que.push(fr);
    while(!que.empty())
    {
        fr=que.front();
        que.pop();
        if(fr.n==K)
            return fr.step;
        for(int i=0;i<3;i++){
            step[2]=fr.n;
            en.n=fr.n+step[i];
            if(en.n>=0&&en.n<=Max&&book[en.n]==0){
                book[en.n]=1;
                en.step=fr.step+1;
                que.push(en);
            }
        }
    }
    return -1;
}

素数筛法（1不是素数）

int prime[maxn];  
bool is_prime[maxn];

int sieve(int n){
    int p = 0;
    for(int i = 0; i <= n; ++i)
        is_prime[i] = true;
    is_prime[0] = is_prime[1] = false;
    for (int i = 2; i <= n; ++i){   //  注意数组大小是n
        if(is_prime[i]){
            prime[p++] = i;
            for(int j = i + i; j <= n; j += i)//轻剪枝，j必定是i的倍数
                is_prime[j] = false;
        }
    }
    return p;   //  返回素数个数
}