模板

不时更新常用的模板，模板可能写的有些早，不像现在写的一样

数论

组合数递推公式

C[1][0] = C[1][1] = 1;
for (int i=2; i<=N; i++)
{
    C[i][0] = 1;
    for (int j=1; j<=N; j++)
        C[i][j] = C[i-1][j]+C[i-1][j-1];
}

求逆元

a扩展欧几里得求逆元

#include<cstdio>

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 tmp = x;
    x = y;
    y = tmp-a/b*y;
    return r;
}

int main()
{
    //gcd(a,p)==1
    int a,p,r,x,y;
    while (scanf("%d%d",&a,&p)!=EOF)
    {
        r = exgcd(a,p,x,y);
        printf("%d",(x%p+p)%p);
    }
    return 0;
}

b线性求逆元

int inv[MAXN]; 
void INV() //线性求到a的逆元 
{
    inv[1] = 1;
    for (int i=2; i<=n; ++i) {
        inv[i] = (1ll*(-(p/i))*inv[p%i])%p;
        inv[i] = (inv[i]+p)%p;
    }
}

/*-----------------------------------------------*/

int INV(int a)//线性求a的逆元，可以记忆化 
{
    if (a==1) return 1;
    return ((-(p/a)*INV(p%a))%p);
}

c线性求阶乘的逆元 

/*
假设知道了模p下a阶乘的逆元b，fac[a] * b ≡ 1 (mod p)
那么a-1的阶乘的逆元就是，fac[a-1] * a * b ≡ 1 (mod p)
所以 b * a 就是a-1的阶乘的逆元。
*/
ifac[1000000] = ksm(1000000, mod - 2);
for (int i=1000000; i>=1; --i)　ifac[i - 1] = ifac[i] * i % mod;

 

中国剩余定理51nod1079

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;

inline LL read() {
    LL x=0,f=1;char ch=getchar();for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-1;
    for (;isdigit(ch);ch=getchar())x=x*10+ch-'0';return x*f;
}


LL a[100], m[100];

LL inv(LL a,LL b,LL p) {
    LL res = 1;
    while (b) {
        if (b & 1) res = res * a % p;
        a = a * a % p;
        b >>= 1;
    }
    return res;
}

int main() {
    
    int n;scanf("%d",&n);
    LL M = 1;
    
    for (int i=1; i<=n; ++i) {
        m[i] = read();
        a[i] = read();
        M = M * m[i];
    }

        
    LL Ans = 0;
    for (int i=1; i<=n; ++i) {
        LL Mi = M / m[i];
        LL T = inv(Mi,m[i]-2,m[i]);
        Ans = (Ans + a[i] * T * Mi) % M;
    }
    cout << (Ans % M + M) % M;
    return 0;
}

扩展中国剩余定理POJ2891

#include<cstdio>
#include<cctype>
using namespace std;
typedef long long LL;

inline int read() {
    int x=0,f=1;char ch=getchar();for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-1;
    for (;isdigit(ch);ch=getchar())x=x*10+ch-'0';return x*f;
}

LL gcd(LL a, LL b) {
    return b == 0 ? a : gcd(b, a%b);
}

void exgcd(LL a,LL b,LL &x,LL &y) {
    if (b == 0) {
        x = 1,b = 0;
        return ;
    }
    exgcd(b,a%b,x,y);
    LL t = x;
    x = y;
    y = t - a / b * y;
}

LL inv(LL a,LL b) {
    LL x = 0,y = 0;
    exgcd(a,b,x,y);
    x = (x % b + b) % b;
    while (x <= 0) x += b;
    return x;
}

LL m[1010],a[1010];

int main() {
    int n;
    while (scanf("%d",&n) != EOF) {
        bool flag = true;
        for (int i=1; i<=n; ++i) {
            scanf("%lld%lld",&m[i],&a[i]);
        }
        LL m1,m2,a1,a2,c,d;
        for (int i=2; i<=n; ++i) {
            m1 = m[i-1], m2 = m[i], a1 = a[i-1], a2 = a[i], c = a2 - a1;
            d = gcd(m1, m2);
            if (c % d) {flag = false;break;}
            m[i] = m1 * m2 / d;
            a[i] = inv(m1/d, m2/d) * (c / d) % (m2 / d) * m1 + a1;
            a[i] = (a[i] % m[i] + m[i]) % m[i];
        }
        if (!flag) puts("-1");
        else printf("%lld
",a[n]);
    }
    return 0;
}

矩阵乘法求斐波那契，矩阵快速幂（第一项是1，第二项是1）

#include<cstdio>
#include<algorithm>
#include<cstring>

using namespace std;

const int mod = 1e9+7;
const int N = 2;

struct Matrix{
    int a[N][N];
    Matrix(){
        this->clear();
    }
    void clear(){
        memset(a,0,sizeof(a));
    }
    void setone(){
        this->clear();
        for (int i=0; i<N; ++i)
            a[i][i] = 1;
    }
    Matrix operator * (const Matrix &x) const 
    {
        Matrix c;
        for (int k=0; k<N; k++)
            for (int i=0; i<N; ++i)
                for (int j=0; j<N; ++j)
                    c.a[i][j] = (c.a[i][j]+1ll*a[i][k]*x.a[k][j])%mod;
        return c;
    }
};

int fibn(int n)
{
    Matrix x,s;
    x.a[0][0] = x.a[0][1] = x.a[1][0] = 1;
    s.setone();
    for (; n; n>>=1)
    {
        if (n&1) s = s*x;
        x = x*x; 
    }
    return (s.a[0][0]+s.a[0][1])%mod;
}
int main()
{
    int n;
    while (~scanf("%d",&n))
    {
        if (n==1||n==2) puts("1");
        else printf("%d
",fibn(n-2));
    }
    return 0;
}

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;

const int mod = 1e9+7;
const int N = 2;

struct Matrix{
    int a[N][N];
    Matrix () {memset(a,0,sizeof(a));}
}t;
Matrix mul(Matrix a,Matrix b) {
    Matrix c;
    for (int k=0; k<N; k++)
        for (int i=0; i<N; ++i)
            for (int j=0; j<N; ++j)
                c.a[i][j] = (c.a[i][j]+1ll*a.a[i][k]*b.a[k][j])%mod;
    return c;
}
int fibn(int n) {
    Matrix x,s;
    x.a[0][0] = x.a[0][1] = x.a[1][0] = 1;
    s.a[0][0] = s.a[1][1] = 1;
    while (n) {
        if (n&1) s = mul(s,x);
        x = mul(x,x); 
        n >>= 1;
    }
    return (s.a[0][0]+s.a[0][1])%mod;
}
int main() {
    int n;
    while (~scanf("%d",&n)) {
        if (n==1||n==2) puts("1");
        else printf("%d
",fibn(n-2));
    }
    return 0;
}

线性筛素数O（n）

for (int i=2; i<=N; i++) {
    if (!noprime[i]) {
        prime[++tot]=i;
    }
    for (int j=1; j<=tot&&i*prime[j]<=N; j++) {
        noprime[i*prime[j]] = true;
        if(i % prime[j] == 0) break ;  
    }
}

线性筛欧拉函数

for (int i=2; i<=N; i++) {
    if (!noprime[i]) {
        prime[++tot]=i;
        phi[i] = i-1; 
    }
    for (int j=1; j<=tot&&i*prime[j]<=N; j++) {
        noprime[i*prime[j]] = true;
        if(i % prime[j] == 0) {
            phi[i * prime[j]] = phi[i] * prime[j];
            break ; //重要 
        }
        else phi[i * prime[j]] = phi[i]*(prime[j]-1);
    }
}

线性筛莫比乌斯函数

void getmu() {
    mu[1] = 1;
    for (int i=2; i<=N; ++i) {
        if (!noprime[i]) prime[++tot] = i,mu[i] = -1;
        for (int j=1; j<=tot&&i*prime[j]<=N; ++j) {
            noprime[i * prime[j]] = true;
            if (i % prime[j] == 0) {mu[i * prime[j]] = 0; break;}
            mu[i * prime[j]] = - mu[i];
        }
    }
}

求组合数（很大！）

一般的逆元求解

#include<bits/stdc++.h>
using namespace std;
const int maxn=1000000;
const int mod=1000000007;

int f[maxn+10];
void init(){//阶乘
    f[0]=1;
    for(int i=1;i<=maxn;i++){
        f[i]=1ll*f[i-1]*i%mod;
    }
}

int fast(int a,int n){
    if (n==0) return 1;
    if (n%2) return 1ll*a*fast(a,n-1)%mod;
    int tmp=fast(a,n/2);
    return 1ll*tmp*tmp%mod;
}

int C(int n,int m){
    if(n==m||m==0)return 1;
    return (1ll*f[n]*fast(f[m],mod-2)%mod)*fast(f[n-m],mod-2)%mod;
}

int main(){
    init();
    int n,m,k;
    scanf("%d%d%d",&n,&m,&k);
    int x = n-k,y = m-1;
        printf("%d
",C(x,y));
    return 0;
}

Lucas定理

//适用于p很小，n，m很大 或者 n，m不大但大于p
#include<cstdio>

typedef long long LL;
const int N = 1000010;

LL n,m,p,f[N];

void init(int x) {
    f[0] = 1;
    for (int i=1; i<=x; ++i) f[i] = (i * f[i-1]) % x;
}
LL ksm(LL a,LL b) {
    LL ans = 1;
    while (b) {
        if (b & 1) ans = (ans * a) % p;
        b >>= 1;
        a = (a * a) % p;
    }
    return ans;
}
LL C(LL n,LL m) {
    if (m > n) return 0;
    return (f[n] * ksm(f[m],p-2)) % p * ksm(f[n-m],p-2) % p;
}
LL Lucas(LL n,LL m) {
    if (m == 0) return 1;
    else return (C(n%p,m%p) * Lucas(n/p,m/p)) % p;
}
int main() {
    int T;
    scanf("%d",&T);
    while (T--) {
        scanf("%lld%lld%lld",&n,&m,&p);
        init(p);
        printf("%lld
",Lucas(n,m));
    }
    return 0;
}

快速幂

int ksm(int a,int b,int p) {
    int ret = 1;
    while (b) {
        if (b & 1) ret = (1ll*ret*a) % p;
        a = (1ll*a*a)%p;
        b >>= 1;
    }
    return ret%p;
}

快速乘

int ksc(int a,int b,int p) {
    int ret = 0;
    while (b) {
        if (b & 1) ret = (ret+a)%p;
        a = (a+a)%p;
        b >>= 1;
    }
    return ret;
}

素数判定Miller_Rabin

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<ctime>

using namespace std;

typedef long long LL;

LL ksm(LL a,LL b,LL p) {
    LL ans = 1;
    a = a % p;
    while (b) {
        if (b & 1) ans = (ans * a) % p;
        a = (a * a) % p;
        b >>= 1;
    }
    return ans;
}
bool witness(LL a,LL n,LL d,LL r) {
    LL ret = ksm(a,d,n);
    LL last = ret;
    while (r--) {
        ret = ret * ret % n;
        if (ret==1 && last!=1 && last!=n-1) return false;
        last = ret;
    }
    if (ret != 1) return false;
    return true;
}
bool miller_rabin(LL n) {
    if (n==2) return true;
    if (n==1 || (n&1)==0) return false;
    LL d = n - 1,r = 0;
    while ((d&1)==0) r++,d>>=1;
    for (LL i=1; i<=20; ++i) {
        LL a = rand()%(n-1)+1;
        if (!witness(a,n,d,r)) return false;
    }
    return true;
}
int main () {
    srand((unsigned)time(NULL));
    LL a,b;
    while (cin >> a) {
        if (miller_rabin(a)) cout << "yes
";
        else cout << "no
";    
    }
    return 0;
}

FFT

递归

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<iostream>

using namespace std;
const int N = 300100;
const double eps = 1e-8;
const double pi = acos(-1.0);
typedef long long LL;

struct Complex {
    double x,y;
    Complex() {x=0,y=0;}
    Complex(double xx,double yy) {x=xx,y=yy;}

}A[N],B[N];

Complex operator + (Complex a,Complex b) {
    return Complex(a.x+b.x,a.y+b.y);
}
Complex operator - (Complex a,Complex b) { 
    return Complex(a.x-b.x,a.y-b.y);
}
Complex operator * (Complex a,Complex b) {
    return Complex(a.x*b.x-a.y*b.y,a.x*b.y+b.x*a.y);
}

void FFT(Complex *a,int n,int ty) {
    if (n==1) return ;
    Complex a1[n>>1],a2[n>>1];
    for (int i=0; i<=n; i+=2) {
        a1[i>>1] = a[i],a2[i>>1] = a[i+1];
    }
    FFT(a1,n>>1,ty);
    FFT(a2,n>>1,ty);
    Complex w1 = Complex(cos(2.0*pi/n),ty*sin(2.0*pi/n));
    Complex w = Complex(1.0,0.0);
    for (int i=0; i<(n>>1); i++) {
        Complex t = w * a2[i];
        a[i+(n>>1)] = a1[i] - t;
        a[i] = a1[i] + t;
        w = w * w1;
    }
}
int main() {
    int n,m;
    scanf("%d%d",&n,&m);
    for (int i=0; i<=n; ++i) scanf("%lf",&A[i].x);
    for (int i=0; i<=m; ++i) scanf("%lf",&B[i].x);
    int fn = 1;
    while (fn <= n+m) fn <<= 1;
    FFT(A,fn,1);
    FFT(B,fn,1);
    for (int i=0; i<=fn; ++i) 
        A[i] = A[i] * B[i];
    FFT(A,fn,-1);
    for (int i=0; i<=n+m; ++i) 
        printf("%d ",(int)(A[i].x/fn+0.5));
    return 0;
}

非递归

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<iostream>

using namespace std;
const int N = 300100;
const double eps = 1e-8;
const double pi = acos(-1.0);
typedef long long LL;

struct Complex {
    double x,y;
    Complex() {x=0,y=0;}
    Complex(double xx,double yy) {x=xx,y=yy;}

}A[N],B[N];

Complex operator + (Complex a,Complex b) {
    return Complex(a.x+b.x,a.y+b.y);
}
Complex operator - (Complex a,Complex b) { 
    return Complex(a.x-b.x,a.y-b.y);
}
Complex operator * (Complex a,Complex b) {
    return Complex(a.x*b.x-a.y*b.y,a.x*b.y+b.x*a.y);
}
void FFT(Complex a[],int n,int ty) {
    for (int i=0,j=0; i<n; ++i) {
        if (i < j) swap(a[i],a[j]);
        for (int k=n>>1; (j^=k)<k; k>>=1);//-----
    }
    for (int s=1; (1<<s)<=n; ++s) {
        int m = (1 << s);
        Complex w1 = Complex(cos(2*pi/m),ty*sin(2*pi/m));
        for (int i=0; i<n; i+=m) {
            Complex w = Complex(1,0);
            for (int k=0; k<(m>>1); ++k) {
                Complex t = w*a[i+k+(m>>1)];
                a[i+k+(m>>1)] = a[i+k] - t;//-----
                a[i+k] = a[i+k] + t; //-----
                w = w*w1;
            }
        }
    }
}
int main() {
    int n,m;
    scanf("%d%d",&n,&m);
    for (int i=0; i<=n; ++i) scanf("%lf",&A[i].x);
    for (int i=0; i<=m; ++i) scanf("%lf",&B[i].x);
    int fn = 1;
    while (fn <= n+m) fn <<= 1;
    FFT(A,fn,1);
    FFT(B,fn,1);
    for (int i=0; i<=fn; ++i) 
        A[i] = A[i] * B[i];
    FFT(A,fn,-1);
    for (int i=0; i<=n+m; ++i) 
        printf("%d ",(int)(A[i].x/fn+0.5));
    return 0;
}

图论

树上倍增lca模板（例题https://www.luogu.org/problem/show?pid=3379）

#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;
const int N = 1000100;

struct Edge{
    int v,nxt;
}e[N];
int fa[N][25];    //开25，一开始开的20，找了好长时间的错误 
int deth[N];    
int head[N];
int n,m,s,cnt,a,b,d;

void add(int u,int v)
{
    cnt++;
    e[cnt].v = v;
    e[cnt].nxt = head[u];
//    e[cnt]=(Edge) {v,head[u]};    
    head[u] = cnt;
}

void dfs(int x)
{
    for (int i=head[x]; i; i=e[i].nxt)
    {
        int v = e[i].v;
        if(!deth[v])//判重，因为扫过的点都有了深度，也可以另设一个v数组 
        {
            deth[v] = deth[x]+1;
            fa[v][0] = x;
            dfs(v);
        }
    }
}

void init()
{
    for (int j=1; j<=20; ++j)
        for (int i=1; i<=n; ++i)
            fa[i][j] = fa[fa[i][j-1]][j-1];
}

int lca(int u,int v)
{
    if (deth[u] < deth[v]) swap(u,v);
    /*for (int i=20; i>=0; --i)    
    {
        if (deth[fa[u][i]] >= deth[v])
            u = fa[u][i];
    }*/
    d = deth[u]-deth[v];    //位运算 
    for (int i=0; i<=20; ++i)
    {
        if ((1<<i) & d)
            u = fa[u][i];
    }
    if (u==v) return u;
    for (int i=20; i>=0; --i)
    {
        if(fa[u][i] != fa[v][i])
        {
            u = fa[u][i];
            v = fa[v][i];
        }
    }
    return fa[u][0];
}

int main()
{
    scanf("%d%d%d",&n,&m,&s);
    for (int i=1; i<n; ++i)
    {
        scanf("%d%d",&a,&b);
        add(a,b);
        add(b,a);
    }
    deth[s] = 1;
    fa[s][0] = 0;
    dfs(s);
    init();
    for (int i=1; i<=m; ++i)
    {
        scanf("%d%d",&a,&b);
        printf("%d
",lca(a,b));
    }
    return 0;
}

求树的直径

/*
我们在树上任选一个节点u，以这个点为根进行一遍dfs，可以求出距离点u最远的点s，
再由s为根进行一遍dfs，找到距离s最远的点t，点s与点t之间的路径即为树的直径。
*/

#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
const int MAXN = 100010;
int dis[MAXN];
vector<int>tree[MAXN];

void dfs(int now)
{
    for (int i=0; i<tree[now].size(); ++i)
    {
        if (!dis[tree[now][i]])
        {
            dis[tree[now][i]] = dis[now]+1;
            dfs(tree[now][i]);
        }
    }
}

int main()
{
    int n,t,ans;
    scanf("%d",&n);
    for (int u,v,i=1; i<n; ++i)
    {
        scanf("%d%d",&u,&v);
        tree[u].push_back(v);
        tree[v].push_back(u);
    }
    t = 1;
    dis[t] = 0;
    dfs(t);
    for (int i=1; i<=n; ++i)
        if (dis[i]>dis[t]) t = i;
    memset(dis,0,sizeof(dis));
    dis[t] = 0;
    dfs(t);
    ans = 1;
    for (int i=1; i<n; ++i)
        if (dis[i]>dis[ans]) ans = i;
    printf("%d",dis[ans]);
    return 0;
}

最小生成树 kruskal 算法（例题https://www.luogu.org/problem/show?pid=3366）

#include<iostream>
#include<cstdio>
#include<algorithm>

using namespace std;

struct edge{
    int a,b,c;
}e[200100];
int n,m;
int far[5100];
int ans,cnt;

int find(int a)
{
    return far[a]==a?a:far[a]=find(far[a]);
}
bool cmp(edge a,edge b)
{
    return a.c<b.c;
}

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;++i) far[i] = i;
    for(int i=1;i<=m;++i)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        e[i].a=a;
        e[i].b=b;
        e[i].c=c;
    }
    sort(e+1,e+m+1,cmp);
    for(int i=1;i<=m;++i)
    {
        int aa = find(e[i].a);
        int bb = find(e[i].b);
        if(aa!=bb)
        {
            cnt++;
            far[aa] = bb;
            ans += e[i].c;
            if(cnt==(n-1))break;
        }
    }
    if(cnt==(n-1)) cout<<ans;
    else cout<<"orz";
    return 0;
}

最短路 spfa 算法 （例题https://www.luogu.org/problem/show?pid=3371）

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int MAXN = 10100;

struct Edge{
    int to,w,nxt;
}e[500100];

int dis[MAXN];
int head[MAXN];
bool vis[MAXN];
queue<int>q;
int n,m,s,cnt;

void add(int u,int v,int w)    //从u到v有一条长度是w的边 
{
    ++cnt;
    e[cnt].to = v;
    e[cnt].w = w;
    e[cnt].nxt = head[u];
    head[u] = cnt;
}

void spfa()
{
    for (int i=1; i<=n; ++i)
        dis[i] = 2147483647;
    dis[s] = 0;
    q.push(s);
    vis[s] = true;
    while (!q.empty())
    {
        int u = q.front();
        q.pop();
        for (int i=head[u]; i; i=e[i].nxt)
        {
            int v = e[i].to;
            int w = e[i].w;
            if (dis[v]>dis[u]+w)
            {
                dis[v] = dis[u]+w;
                if (!vis[v])
                {
                    q.push(v);
                    vis[v] = true;
                }
            }
        }
        vis[u] = false;
    }
}

int main()
{
    scanf("%d%d%d",&n,&m,&s);
    for (int u,v,w,i=1; i<=m; ++i)
    {
        scanf("%d%d%d",&u,&v,&w);
        add(u,v,w);    //有向图，如果是无向图加一行add(v,u,w); 
    }
    spfa();
    for (int i=1; i<=n; ++i)
        printf("%d ",dis[i]);
    return 0;
}

最短路 dijkstra 算法

const int  MAXN = 1010;
int dis[MAXN];
int pre[MAXN];
int w[MAXN][MAXN];
bool vis[MAXN];    // 判断是否已存入该点松弛过 
int n; //点 

void Dijkstra(int st)
{
    for (int i=1; i<=n; ++i) dis[i] = w[st][i];
    dis[st] = 0;
    vis[st] = true;
    pre[st] = 0;
    for (int i=1; i<=n-1; i++)
    {
        int minn = 1e8;
        int u = 0;                    // 找出当前未使用的点j的dist[j]最小值
        for (int j=1; j<=n; ++j)
            if (!vis[j] && dis[j]<minn)
            {
                u = j;                // u保存当前邻接点中距离最小的点的号码 
                minn = dis[j];
            }
        if (u==0) break;
        vis[u] = true; 
        for(int v=1; v<=n; v++)
            if(dis[u] + w[u][v] < dis[v])    //在通过新加入的u点路径找到离v0点更短的路径  
            {
                dis[v] = dis[u]+w[u][v];    //更新dist 
                pre[v] = u;                    //记录前驱顶点 
            }
    }
}

堆优化的dijkstra

#include<cstdio>
#include<cstring>
#include<queue>

using namespace std;

const int N = 10100;
const int M = 500100;

struct Edge{
    int to,nxt,w;
}e[M]; 
struct Node{
    int x,dis;
    bool operator < (const Node &a) const {
        return dis > a.dis;
    }
    Node() {}
    Node(int a,int b) {x = a,dis = b;}
}now;
int head[N],tot,dis[N];
bool vis[N];
priority_queue<Node>q;
int n,m,s;

inline int read() {
    int x = 0,f = 1;char ch = getchar();
    for (; ch<'0'||ch>'9'; ch = getchar())
        if (ch=='-') f = -1;
    for (; ch>='0'&&ch<='9'; ch = getchar())
        x = x*10+ch-'0';
    return x*f;
}
inline void add_edge(int u,int v,int w) {
    e[++tot].to = v,e[tot].w = w,e[tot].nxt = head[u],head[u] = tot;
//    e[++tot].to = u,e[tot].w = w,e[tot].nxt = head[v],head[v] = tot;
}
void Dijkstra() {
    for (int i=1; i<=n; ++i) dis[i] = 2147483647;
    memset(vis,false,sizeof(vis));
    dis[s] = 0;
    q.push(Node(s,0));
    while (!q.empty()) {
        now = q.top();
        q.pop();
        int u = now.x;
        if (vis[u]) continue;
        vis[u] = true;
        for (int i=head[u]; i; i=e[i].nxt) {
            int v = e[i].to,w = e[i].w;
            if (dis[v] > dis[u]+w) {
                dis[v] = dis[u]+w;
                q.push(Node(v,dis[v]));
            }
        }
        
    }
}
int main() {
    n = read(),m = read(),s = read();
    for (int i=1; i<=m; ++i) {
        int u = read(),v = read(),w = read();
        add_edge(u,v,w);
    }
    Dijkstra();
    for (int i=1; i<=n; ++i) printf("%d ",dis[i]);
    return 0;    
}

网络流dinic算法

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;

const int MAXN = 100100;
const int INF = 1e9;

struct Edge{
    int to,c,nxt;
    Edge(){}
    Edge(int tt,int cc,int nn) {to = tt,c = cc,nxt = nn;}
}e[1000100];
queue<int>q;

int head[MAXN],dis[MAXN];
int s,t,n,m,tot = 1;

int read()
{
    int x = 0, f = 1;char ch = getchar();
    while (ch<'0'||ch>'9') {if (ch=='-') f = -1; ch = getchar();}
    while (ch>='0'&&ch<='9') {x = x*10+ch-'0'; ch = getchar();}
    return x*f;
}
bool bfs()
{
    q.push(s);
    memset(dis,-1,sizeof(dis));
    dis[s] = 0;
    while (!q.empty())
    {
        int u = q.front();
        q.pop();
        for (int i=head[u]; i; i=e[i].nxt)
        {
            int v = e[i].to;
            if (dis[v]==-1&&e[i].c>0)
            {
                dis[v] = dis[u]+1;
                q.push(v);
            }
        }
    }
    if (dis[t]!=-1) return true;
    return false;
}
int dfs(int u,int low)
{
    if (u==t) return low;
    int w,used = 0;
    for (int i=head[u]; i; i=e[i].nxt)
    {
        int v = e[i].to;
        if (dis[v]==dis[u]+1&&e[i].c>0)
        {
            w = dfs(v,min(low-used,e[i].c));
            e[i].c -= w;
            e[i^1].c += w;
            used += w;
            if (used==low) return low;
        }
    }
    if (!used) dis[u] = -1;
    return used;
}
int dinic()
{
    int ans = 0,t;
    while (bfs())
        ans += dfs(s,INF);
    return ans;
}
int main()
{
    n = read();m = read();s = read();t = read();
    for (int u,v,w,i=1; i<=m; ++i)
    {
        u = read();v = read();w = read();
        e[++tot] = Edge(v,w,head[u]);
        head[u] = tot;
        e[++tot] = Edge(u,0,head[v]);
        head[v] = tot;    
    }
    printf("%d",dinic());
    return 0;
}

KM算法 HDU2255

#include<cstdio>
#include<cctype>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long LL;

inline int read() {
    int x=0,f=1;char ch=getchar();for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-1;
    for(;isdigit(ch);ch=getchar())x=x*10+ch-'0';return x*f;
}

const int INF = 1e9;
const int N = 305; //--
int match[N], mp[N][N], lx[N], ly[N], slack[N];
bool visx[N], visy[N];
int n;

bool dfs(int u) {
    visx[u] = true;
    for (int v=1; v<=n; ++v) {
        if (visy[v]) continue;
        int t = lx[u] + ly[v] - mp[u][v];
        if (!t) {
            visy[v] = true;
            if (!match[v] || dfs(match[v])) {
                match[v] = u;
                return true;
            }
        }
        else slack[v] = min(slack[v], t);
    }
    return false;
}
void KM() {
    memset(match, 0, sizeof(match));
    memset(ly, 0, sizeof(ly));
    for (int i=1; i<=n; ++i) 
        for (int j=1; j<=n; ++j) 
            lx[i] = max(lx[i], mp[i][j]);
            
    for (int x=1; x<=n; ++x) {
        for (int i=1; i<=n; ++i) slack[i] = INF;
        while (true) {
            memset(visx, false, sizeof(visx));
            memset(visy, false, sizeof(visy));
            if (dfs(x)) break;
            int d = INF;
            for (int i=1; i<=n; ++i) 
                if (!visy[i]) d = min(d, slack[i]);
            for (int i=1; i<=n; ++i) {
                if (visx[i]) lx[i] -= d;
                if (visy[i]) ly[i] += d;
                else slack[i] -= d;
            }
        }
    }
}
int main() {
    while (~scanf("%d",&n)) {
        for (int i=1; i<=n; ++i) 
            for (int j=1; j<=n; ++j) mp[i][j] = read();    
        KM();
        int ans = 0;
        for (int i=1; i<=n; ++i) 
            if (match[i]) ans += mp[match[i]][i];
        printf("%d
",ans);
    }
    return 0;
}

数据结构

树状数组，单点查询，区间修改（例题https://www.luogu.org/problem/show?pid=3368）需要用到差分的思想，即数列前后两个数的差。数组不需要开四倍

//树状数组：区间修改，单点查询，差分 
#include<cstdio>
int sum[500100];
int n,m,last = 0;
int lowbit(int x)
{
    return x&(-x);
}
void update(int x,int v)
{
    while (x<=n)
    {
        sum[x] += v;
        x += lowbit(x);
    }
}
int query(int x)
{
    int ans = 0;
    while (x)
    {
        ans += sum[x];
        x -= lowbit(x);
    }
    return ans;
}
int main()
{
    scanf("%d%d",&n,&m);
    for (int a,i=1; i<=n; ++i)
    {
        scanf("%d",&a);
        update(i,a-last);
        last = a;
    }
    for (int x,y,z,a,i=1; i<=m; ++i)
    {
        scanf("%d",&a);
        if (a==1)    //区间修改
        {
            scanf("%d%d%d",&x,&y,&z);
            update(x,z);
            update(y+1,-z); 
        } 
        else        //单点查询 
        {
            scanf("%d",&x);
            printf("%d
",query(x));
        }
    }
    return 0;
}

树状数组，单点修改，区间查询（例题https://www.luogu.org/problem/show?pid=3374）这个不需要用差分

//树状数组：区间查询，单点修改 
#include<cstdio>
int sum[500100];
int n,m;
int lowbit(int x)
{
    return x&(-x);
}
void update(int x,int v)
{
    while (x<=n)
    {
        sum[x] += v;
        x += lowbit(x);
    }
}
int query(int x)
{
    int ans = 0;
    while (x)
    {
        ans += sum[x];
        x -= lowbit(x);
    }
    return ans;
}
int main()
{
    scanf("%d%d",&n,&m);
    for (int a,i=1; i<=n; ++i)
    {
        scanf("%d",&a);
        update(i,a);
    }
    for (int i=1; i<=m; ++i)
    {
        int x,y,z;
        scanf("%d%d%d",&z,&x,&y);
        if (z==1) update(x,y);    //单点修改 
        else printf("%d
",query(y)-query(x-1));
    }
    return 0;
}

树状数组，区间修改，区间查询 （http://codevs.cn/problem/1082/）

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;

inline int read() {
    int x=0,f=1;char ch=getchar();for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-1;
    for (;isdigit(ch);ch=getchar())x=x*10+ch-'0';return x*f;
}

const int N = 200010;
int a[N],b[N];

struct BIT{
    int n;LL c1[N],c2[N];
    void update(int p,int v) {
        for (int i=p; i<=n; i+=(i&(-i))) c1[i] += v,c2[i] += p*v;
    }
    LL query(int p) {
        LL ans = 0;
        for (int i=p; i; i-=(i&(-i))) ans += (p+1)*c1[i]-c2[i];
        return ans;
    }
}bit;

int main() {
    int n = read(),last = 0;
    bit.n = n;
    for (int i=1; i<=n; ++i) {
        int tmp = read();
        a[i] = tmp - last;
        last = tmp;
    }
    for (int i=1; i<=n; ++i) 
        bit.update(i,a[i]);
        
    int m = read();
    while (m--) {
        int opt = read();
        if (opt == 1) {
            int l = read(),r = read(),v = read();
            bit.update(l,v);
            if (r < n) bit.update(r+1,-v);
        }
        else {
            int l = read(),r = read();
            printf("%lld
",bit.query(r)-bit.query(l-1));
        }
    }
    return 0;
}

树链剖分

void dfs1(int u,int f,int d)    //找重孩子 ,u是当前节点，f节点的父亲，d深度 
{
    dep[u] = d;
    fa[u] = f;
    siz[u] = 1;
    for (int i=head[u]; i; i=e[i].nxt)
    {
        int v = e[i].to;
        if (v!=f)
        {
            dfs1(v,u,d+1);
            siz[u] += siz[v];
            if (siz[v]>siz[son[u]])//son[]数组，用来保存重儿子
                son[u] = v;
        }
    }
}
void dfs2(int x)    //找重链 
{
    int t = 0;
    if (!top[x]) top[x] = x;
    for (int i=head[x]; i; i=e[i].nxt)
        if (fa[x]!=e[i].to&&siz[t]<siz[e[i].to]) 
            t = e[i].to;
    if (t) top[t] = top[x], dfs2(t);
    for (int i=head[x]; i; i=e[i].nxt)
        if(fa[x]!=e[i].to&&t!=e[i].to) dfs2(e[i].to);
}

/*
siz[]数组，用来保存以x为根的子树节点个数
top[]数组，用来保存当前节点的所在链的顶端节点
son[]数组，用来保存重儿子
dep[]数组，用来保存当前节点的深度
fa[]数组，用来保存当前节点的父亲
*/

splay 基本的插入，删除，查询x数的排名，查询排名为x的数，求x的前驱，后继（例题http://www.lydsy.com/JudgeOnline/problem.php?id=3224）

#include<cstdio>
 
const int N = 100010;
int fa[N],ch[N][2],siz[N],cnt[N],data[N];
int tn,Root;

inline char nc() {
    static char buf[100000],*p1 = buf,*p2 = buf;
    return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2) ? EOF :*p1++;
}
inline int read() {
    int x = 0,f = 1;char ch=nc();
    for (; ch<'0'||ch>'9'; ch = nc()) 
        if (ch == '-') f = -1;
    for (; ch>='0'&&ch<='9'; ch = nc()) 
        x = x*10+ch-'0';
    return x * f;
}
inline int son(int x) {
    return x == ch[fa[x]][1]; // - 
}
inline void pushup(int x) {
    siz[x] = siz[ch[x][0]] + siz[ch[x][1]] + cnt[x];
}
inline void rotate(int x) {
    int y = fa[x],z = fa[y],b = son(x),c = son(y),a = ch[x][!b];
    if (z) ch[z][c] = x;else Root = x;fa[x] = z; // 调整x的位置
    ch[x][!b] = y;fa[y] = x; // 调整y的位置
    ch[y][b] = a;if (a) fa[a] = y; // 给y另一个子节点
    pushup(y);pushup(x);
}
inline void splay(int x,int rt) {
    while (fa[x] != rt) {
        int y = fa[x],z = fa[y];
        if (z==rt) rotate(x);
        else {
            if (son(x)==son(y)) rotate(y),rotate(x);
            else rotate(x),rotate(x);
        }
    }
}
inline int getpre(int x) { //得到第一个比x小的数 
    int p = Root,ans;
    while (p) {
        if (x <= data[p]) p = ch[p][0];
        else ans = p,p = ch[p][1];
    }
    return ans;
}
inline int getsuc(int x) { // 得到第一个比x大的数
    int p = Root,ans;
    while (p) {
        if (x >= data[p]) p = ch[p][1];
        else ans = p,p = ch[p][0];
    }
    return ans;
}
inline int getk(int k) { // 得到k的排名
    int p = Root,ans = 0;
    while (true) {
        if (k < data[p]) p = ch[p][0];
        else {
            ans += (ch[p][0] ? siz[ch[p][0]] : 0);
            if (k==data[p]) {
                splay(p,0);return ans+1;
            }
            ans += cnt[p];
            p = ch[p][1];
        }
    }
}
inline int getkth(int k) { // 得到第k个数
    int p = Root;
    while (true) {
        if (ch[p][0] && k <= siz[ch[p][0]]) p = ch[p][0];
        else {
            int tmp = (ch[p][0] ? siz[ch[p][0]] : 0) + cnt[p];
            if (k <= tmp) return data[p];
            k -= tmp; p = ch[p][1];
        }
    }
}
inline void Insert(int x) { // 插入
    if (Root==0) {
        ++tn; Root = tn; 
        ch[tn][1] = ch[tn][0] = fa[tn] = 0;
        siz[tn] = cnt[tn] = 1;data[tn] = x;
        return;
    }
    int p = Root,pa = 0;
    while (true) {
        if (x==data[p]) {
            cnt[p]++;pushup(p);pushup(pa);splay(p,0);break;
        }
        pa = p;
        p = ch[p][x > data[p]];
        if (p==0) {
            tn++;
            ch[tn][1] = ch[tn][0] = 0;siz[tn] = cnt[tn] = 1;
            fa[tn] = pa;ch[pa][x > data[pa]] = tn;data[tn] = x; //-
            pushup(pa),splay(tn,0);break;
        }
    }
}
inline void Clear(int x) {
    ch[x][0] = ch[x][1] = fa[x] = siz[x] = cnt[x] = data[x] = 0;
}
inline void Delete(int x) { // 删除
    getk(x);
    if (cnt[Root] > 1) {cnt[Root]--;pushup(Root);return;}
    if (!ch[Root][0] && !ch[Root][1]) {Clear(Root);Root = 0;return;}
    if (!ch[Root][0]) {
        int tmp = Root;Root = ch[Root][1];fa[Root] = 0;Clear(tmp);return;
    }
    else if (!ch[Root][1]) {
        int tmp = Root;Root = ch[Root][0];fa[Root] = 0;Clear(tmp);return;
    }
    int tmp = Root,pre = ch[Root][0];//可以是getpre(data[Root]);等价于下面的while 
    while (ch[pre][1]) pre = ch[pre][1];
    splay(pre,0);
    ch[Root][1] = ch[tmp][1];
    fa[ch[tmp][1]] = Root;
    Clear(tmp);
    pushup(Root);
}
int main() {
    int n = read();
    while (n--){
        int opt = read(),x = read();
        if (opt==1) Insert(x);
        else if (opt==2) Delete(x);
        else if (opt==3) printf("%d
",getk(x));
        else if (opt==4) printf("%d
",getkth(x));
        else if (opt==5) printf("%d
",data[getpre(x)]);
        else printf("%d
",data[getsuc(x)]);
    }
    return 0;
}

虚树的建立

bool cmp_dfn(int a,int b) {
    return dfn[a] < dfn[b];
}
void Insert(int p) {
    int x = sk[top], lca = LCA(x, p);
    if (lca == x) { sk[++top] = p; return ; }
    while (lca != x) {
        int y = sk[--top];
        if (dfn[y] < dfn[lca]) {
            add_edge(lca, x); sk[++top] = lca; 
            break;
        }
        add_edge(y, x); x = y;
    }
    sk[++top] = p;
}
void build() {
    int k = read();
    for (int i=1; i<=k; ++i) A[i] = read(); 
    sort(A + 1, A + k + 1, cmp_dfn);
    top = 0; sk[++top] = 1;
    if (A[1] != 1) sk[++top] = A[1];
    else sk[++top] = A[2];
    for (int i=(A[1]!=1?2:3); i<=k; ++i) Insert(A[i]);
    while (--top) add_edge(sk[top], sk[top + 1]);
}

字符串

kmp模板（例题https://www.luogu.org/problem/show?pid=3375）

#include<cstdio>
#include<cstring>

char a[1000100],b[1010];
int p[1010];     //最长公共前后缀长度 
int s1,s2;
void init()
{
    int j = 0;
    p[0] = 0;
    for (int i=1; i<s2; ++i)
    {
        while(j>0 && b[i]!=b[j]) j = p[j-1];
        if(b[i]==b[j]) j++;
        p[i] = j;
    }
}
void kmp()
{
    int j = 0;
    for (int i=0; i<s1; ++i)
    {
        while(j>0 && a[i]!=b[j]) j = p[j-1];
        if(a[i]==b[j]) j++;
        if(j==s2) printf("%d
",i+1-s2+1); //找到匹配输出i的值，第一个字符是 0，所以加1 
    }
}
int main()
{
    scanf("%s",a);
    scanf("%s",b);
    s1 = strlen(a);
    s2 = strlen(b);
    init();
    kmp();
    for(int i=0;i<s2;++i)
        printf("%d ",p[i]);
    return 0;
}

manacher算法，求最长回文串（例题https://www.luogu.org/problem/show?pid=3805）

#include<cstdio>
#include<algorithm>
#include<cstring>
#define MAXN 31000000
using namespace std;

char s[MAXN],str[MAXN];
int p[MAXN],len;

void init()
{
    len = strlen(str);
    s[0] = '#';
    for (int i=0; i<len; ++i)
    {
        s[i<<1|1] = '#';
        s[(i+1)<<1] = str[i];
    }
    s[len<<1|1] = '#';
    len = (len<<1|1);
}
int manacher()
{
    int mx = 0, id;
    for (int i=1; i<=len; ++i)
    {
        if (mx>i) p[i] = min(p[id<<1-1],mx-i);
        else p[i] = 1;
        while (s[i+p[i]]==s[i-p[i]]) p[i]++;
        if (p[i]+i>mx) 
            mx = p[i]+i, id = i;
    }
    int ans = 0;
    for (int i=1; i<len; ++i) ans = max(ans,p[i]);
    return ans-1;
}
int main()
{
    scanf("%s",str);
    init();
    printf("%d",manacher());
    return 0;
}

trie树，结构体封装函数

struct Trie
{
    int ch[MAXN][26];//MAXN=字符集*长度 
    int val[MAXN];
    int size;
    Trie()    //或者：函数Clear()
    {
        size = 1;
        memset(ch,0,sizeof(ch));
        memset(val,0,sizeof(val));
    }
    int id(char c)
    {
        return c-'a';
    }
    void Insert(char* s)
    {
        int u = 0, len = strlen(s);
        for (int i=0; i<len; ++i)
        {
            int c = id(s[i]);
            if (!ch[u][c]) ch[u][c] = size++;
            u = ch[u][c];
            //如果是统计前缀单词个数，在此处上val[u]++;下面的val[u]=1删掉 
        }
        val[u] = 1;//标记单词是否出现过 
    }
    bool Find(char* s)
    {
        int u = 0, len = strlen(s);
        for (int i=0; i<len; ++i)
        {
            int c = id(s[i]);
            if (!ch[u][c]) return false;
            u = ch[u][c];
        }
        if (val[u]) return true;//统计前缀单词个数，return val[u]; 
        return false; 
    }    
}t;

AC自动机模板

//AC自动机 
struct AC_automaton{
    int ch[MAXN][26],val[MAXN],last[MAXN],fail[MAXN],size,ret;
    void clear()
    { 
        memset(ch[0],0,sizeof(ch[0]));
        memset(val,0,sizeof(val));
        memset(fail,0,sizeof(fail));
        size = 0;
        ret = 0;
    }
    int idx(char c)
    {
        return c-'a';
    }
    void insert(char *s)//插入一个字符串 
    {
        int u = 0,len = strlen(s);
        for (int i=0; i<len; ++i)
        {
            int c = idx(s[i]);
            if (!ch[u][c])
            {
                ch[u][c] = ++size;
                val[size] = 0;
                memset(ch[size],0,sizeof(ch[size]));
            }
            u = ch[u][c];
        }
        val[u] ++;
    }
    void getfail()//处理fail指针 
    {
        queue<int>q;
        fail[0] = 0;
        for (int c=0; c<26; ++c) 
        {
            int u = ch[0][c];
            if (u) 
            {
                fail[u] = 0;q.push(u);last[u] = 0;
            }
        }
        while (!q.empty())
        {
            int r = q.front();q.pop();
            for (int c=0; c<26; ++c)
            {
                int u = ch[r][c];
                if (!u)
                {
                    ch[r][c] = ch[fail[r]][c];//有这一行就可以减去89行 
                    continue;
                }
                q.push(u);
                int v = fail[r];
                while (v && !ch[v][c]) v = fail[v];
                fail[u] = ch[v][c];
                last[u] = val[fail[u]] ? fail[u] : last[fail[u]];
            }
        }
    }
    void solve(int j)//可以任意改变的函数，看题目需要什么，这个是处理文本串中有多少个模式串 
    {
        if (!j) return ;
        if (val[j])
        {
            ret += val[j];
            val[j] = 0;
        }
        solve(last[j]);
    }
    void find(char *T)//遍历一遍文本串 
    {
        int j = 0,len = strlen(T);
        for (int i=0; i<len; ++i)
        {
            int c = idx(T[i]);
            //while (j && !ch[j][c]) j = fail[j];
            j = ch[j][c];
            if (val[j]) solve(j);
            else if (last[j]) solve(last[j]);
        }
    }
    
}ac;

后缀数组

int s[N];
int t1[N],t2[N],c[N],sa[N],height[N],rank[N];
int n,m = 130,k;

void get_sa() {
    int i,p,*x = t1,*y = t2;
    for (i=0; i<m; ++i) c[i] = 0;
    for (i=0; i<n; ++i) x[i] = s[i],c[x[i]]++;
    for (i=1; i<m; ++i) c[i] += c[i-1];
    for (i=n-1; i>=0; --i) sa[--c[x[i]]] = i;
    for (int k=1; k<=n; k<<=1) {
        p = 0;
        for (i=n-k; i<n; ++i) y[p++] = i;
        for (i=0; i<n; ++i) if(sa[i]>=k) y[p++]=sa[i]-k;
        for (i=0; i<m; ++i) c[i] = 0;
        for (i=0; i<n; ++i) c[ x[y[i]] ]++;
        for (i=1; i<m; ++i) c[i] += c[i-1];
        for (i=n-1; i>=0; --i) sa[--c[ x[y[i]] ]] = y[i];
        swap(x,y);
        p = 1;
        x[sa[0]] = 0;
        for (i=1; i<n; ++i) 
            x[sa[i]] = y[sa[i-1]]==y[sa[i]]&&y[sa[i-1]+k]==y[sa[i]+k] ? p-1:p++;
        if (p>=n) break;
        m = p;
    }
}
void get_height() {
    for (int i=0; i<n; ++i) rank[sa[i]] = i;
    int k = 0;
    height[0] = 0;
    for (int i=0; i<n; ++i) {
        if (!rank[i]) continue;
        if (k) k--;
        int j = sa[rank[i]-1];
        while (i+k<n && j+k<n && s[i+k]==s[j+k]) k++;
        height[rank[i]] = k;
    }
}

Hash

void init() {
    mi[0] = 1;
    for (int i=1; i<=n; ++i) mi[i] = mi[i - 1] * Base;
    for (int i=1; i<=n; ++i) Hash[i] = Hash[i - 1] * Base + (s[i] - 'a' + 1);
}
uLL gethash(int l,int r) {
    return Hash[r] - Hash[l] * mi[r - l + 1];
}

计算几何

Graham求凸包，luogu2742

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<cctype>
#include<cmath>
using namespace std;
typedef long long LL;

double read() {
    double x = 0, f = 1, y = 0.1; char ch = getchar();
    for (; !isdigit(ch)&&ch!='.'; ch=getchar()) if (ch=='-') f = -1;
    for (; isdigit(ch); ch=getchar()) x = x * 10 + ch - '0';
    if (ch == '.') ch = getchar();
    for (; isdigit(ch); ch=getchar()) x += (ch - '0') * y, y *= 0.1;
    return x * f;
}

const double eps = 1e-8;

struct Vector{
    double x,y;
    Vector() {}
    Vector(double a,double b) { x = a, y = b; }
};
typedef Vector Point;
Vector operator + (Vector a,Vector b) { return Vector(a.x+b.x, a.y+b.y); }
Vector operator - (Vector a,Vector b) { return Vector(a.x-b.x, a.y-b.y); }
Vector operator * (Vector a,double p) { return Vector(a.x * p, a.y * p); }
Vector operator / (Vector a,double p) { return Vector(a.x / p, a.y / p); }
bool operator == (Point a,Point b) { return (a.x == b.x) && (a.y == b.y); }

int dcmp(double x) {
    if (fabs(x) <= eps) return 0;
    return x > 0 ? x : -x;
}
double cross(Vector a, Vector b) {
    return a.x * b.y - a.y * b.x;
}
double len(Vector a) {
    return sqrt(a.x * a.x + a.y * a.y);
}

double X,Y;
bool cmp_angle(Point a,Point b) {
    if (atan2(a.y-Y,a.x-X) == atan2(b.y-Y,b.x-X)) return a.x < b.x;
    return atan2(a.y-Y,a.x-X) < atan2(b.y-Y,b.x-X);
}

const int N = 100100;
Point A[N], sk[N];
int n;

void Graham() {
    Y = 1e9;
    int t, Top = 0;
    for (int i=1; i<=n; ++i) 
        if (A[i].y < Y) Y = A[i].y, X = A[i].x, t = i;
    swap(A[t],A[1]);
    sort(A+2,A+n+1,cmp_angle);
    sk[++Top] = A[1];
    sk[++Top] = A[2];
    for (int i=3; i<=n; ++i) {
        // 直线Top-1 -> A[i] 如果在Top-1 -> Top的 外侧，即逆时针旋转过去的，那么Top可以弹出。 
        while (Top > 1 && cross(sk[Top]-sk[Top-1],A[i]-sk[Top-1]) < 0) Top--;
        sk[++Top] = A[i];
    }
    double ans = 0;
    for (int i=2; i<=Top; ++i) 
        ans += len(sk[i] - sk[i-1]);
    ans += len(sk[1] - sk[Top]);
    printf("%.2lf",ans);
}

int main() {
    cin >> n;
    for (int i=1; i<=n; ++i) 
        A[i].x = read(), A[i].y = read();
    Graham();
    return 0;
}

增量排序法求半平面交，poj2451

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<cctype>
#include<cmath>
using namespace std;
typedef long long LL;

double read() {
    double x = 0, f = 1, y = 0.1; char ch = getchar();
    for (; !isdigit(ch)&&ch!='.'; ch=getchar()) if (ch=='-') f = -1;
    for (; isdigit(ch); ch=getchar()) x = x * 10 + ch - '0';
    if (ch == '.') ch = getchar();
    for (; isdigit(ch); ch=getchar()) x += (ch - '0') * y, y *= 0.1;
    return x * f;
}

const double eps = 1e-8;

struct Vector{
    double x,y;
    Vector() {}
    Vector(double a,double b) { x = a, y = b; }
};
typedef Vector Point;
Vector operator + (Vector a,Vector b) { return Vector(a.x+b.x, a.y+b.y); }
Vector operator - (Vector a,Vector b) { return Vector(a.x-b.x, a.y-b.y); }
Vector operator * (Vector a,double p) { return Vector(a.x * p, a.y * p); }
Vector operator / (Vector a,double p) { return Vector(a.x / p, a.y / p); }
bool operator == (Point a,Point b) { return (a.x == b.x) && (a.y == b.y); }

struct Line{
    Point s, t;
    double angle;
    Line () {}
    Line (Point a,Point b) {s = a, t = b, angle = atan2(b.y - a.y, b.x - a.x);}
    
};

int dcmp(double x) {
    if (fabs(x) <= eps) return 0;
    return x > 0 ? 1 : -1;
}
double cross(Vector a, Vector b) {
    return a.x * b.y - a.y * b.x;
}
Point jiaodian(Line a, Line b) {
    Point A = a.s, B = a.t, C = b.s, D = b.t;
    double t1 = cross(D - A, B - A), t2 = cross(B - A, C - A);
    double t = t1 / (t1 + t2);
    return C * t + D * (1 - t);
}

const int N = 20010;

Point A[N];
Line seg[N];
int q[N];
int n,tot;

bool cmp_angle(Line A,Line B) { // 按极角排序，小的在前，极角相等的话，左边的在前 
    double d = dcmp(A.angle - B.angle);
    if (!d) return dcmp(cross(B.s - A.s, B.t - A.s)) > 0;
    return d < 0;
}
bool judge(Line C,Line A, Line B) { // 判断AB的交点是否在C的左边 
    Point p = jiaodian(A, B);
    return dcmp(cross(C.s - p, C.t - p)) < 0; // 在C的右边返回true 
}

void solve() {
    sort(seg+1, seg+n+1, cmp_angle);
    int j = 1;
    for (int i=2; i<=n; ++i) // 将极角相同的只保留最左边的 
        if (dcmp(seg[i].angle - seg[j].angle) > 0) seg[++j] = seg[i];
    n = j;
    q[1] = 1, q[2] = 2;
    int L = 1, R = 2;
    for (int i=3; i<=n; ++i) {
        while (L < R && judge(seg[i], seg[q[R]], seg[q[R-1]])) R --; // 栈中最后两个线段的交点在这条的右边 
        while (L < R && judge(seg[i], seg[q[L]], seg[q[L+1]])) L ++; // 由于是凸多边形，新加入的线段可能转回来，把起点挡在右边 
        q[++R] = i;
    }
    while (L < R && judge(seg[q[L]], seg[q[R]], seg[q[R-1]])) R --;
    while (L < R && judge(seg[q[L]], seg[q[L]], seg[q[L+1]])) L ++;
    q[++R] = q[L];
    tot = 0;
    for (int i=L; i<R; ++i) 
        A[++tot] = jiaodian(seg[q[i]], seg[q[i+1]]); // 求交点 
}

double Area() {
    double ans = 0;
    for (int i=2; i<tot; ++i) 
        ans += cross(A[i]-A[1],A[i+1]-A[1]);
    return ans / 2.0;
} 

int main() {    
    while (~scanf("%d",&n)) {
        for (int i=1; i<=n; ++i) {
            double a1 = read(), b1 = read(), a2 = read(), b2 = read();
            seg[i] = Line(Point(a1, b1), Point(a2, b2));
        }
        seg[++n] = Line(Point(0, 0), Point(10000, 0));
        seg[++n] = Line(Point(10000, 0), Point(10000, 10000));
        seg[++n] = Line(Point(10000, 10000), Point(0, 10000));
        seg[++n] = Line(Point(0, 10000), Point(0, 0));
        solve();
        printf("%.1lf
",Area());
    }
    return 0;
}

旋转卡壳，求凸包直径，poj2187

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<cctype>
#include<cmath>
using namespace std;
typedef long long LL;

inline int read() {
    int x = 0, f = 1; char ch = getchar(); for (; !isdigit(ch); ch=getchar()) if (ch=='-') f = -1;
    for (; isdigit(ch); ch=getchar()) x = x * 10 + ch - '0'; return x * f;
}

struct Vector{
    int x,y;
    Vector() {}
    Vector(int a,int b) { x = a, y = b; }
};
typedef Vector Point;
Vector operator + (Vector a,Vector b) { return Vector(a.x+b.x, a.y+b.y); }
Vector operator - (Vector a,Vector b) { return Vector(a.x-b.x, a.y-b.y); }
Vector operator * (Vector a,double p) { return Vector(a.x * p, a.y * p); }
Vector operator / (Vector a,double p) { return Vector(a.x / p, a.y / p); }
bool operator == (Point a,Point b) { return (a.x == b.x) && (a.y == b.y); }

int len(Vector a) {
    return a.x * a.x + a.y * a.y;
}
int cross(Vector a, Vector b) {
    return a.x * b.y - a.y * b.x;
}

const int N = 50010;
Point A[N], sk[N];
double X,Y;
int n, Top;

bool cmp_angle(Point a,Point b) { // --- 
    int t = cross(a - A[1], b - A[1]);
    if (t > 0 || (t == 0 && len(a - A[1]) > len(b - A[1]))) return true;
    return false;
}

void Graham() {
    int t; Top = 0; Y = 1e9;
    for (int i=1; i<=n; ++i) 
        if (A[i].y < Y || (A[i].y == Y && A[i].x < X)) Y = A[i].y, X = A[i].x, t = i;
    swap(A[t], A[1]);
    sort(A+2, A+n+1, cmp_angle);
    sk[++Top] = A[1];
    sk[++Top] = A[2];
    for (int i=3; i<=n; ++i) {
        while (Top > 1 && cross(sk[Top] - sk[Top-1], A[i] - sk[Top-1]) < 0) Top --;
        sk[++Top] = A[i];
    }
}
int Area(Point a,Point b,Point c) {
    return cross(b - a, c - a);
}
void RC() {
    sk[++Top] = sk[1];
    int p = 2;
    int ans = len(sk[2] - sk[1]);
    for (int i=1; i<Top; ++i) {
        while (Area(sk[i],sk[i+1],sk[p+1]) > Area(sk[i],sk[i+1],sk[p])) p = p % Top + 1;
        ans = max(ans, max(len(sk[p] - sk[i]), len(sk[p] - sk[i+1])));
    }
    printf("%d
",ans);
}
int main() {
    while (~scanf("%d",&n)) {
        for (int i=1; i<=n; ++i) 
            A[i].x = read(), A[i].y = read();
        Graham();
        RC();
    }
    return 0;
}

其他

二分答案

a最小值最大

//最小值最大
int l = min_ans, r = max_ans;  
while (l < r) 
{  
    int mid = (l+r+1)/2;   //+1避免 r==l+1 时mid一直等于l，从而死循环  
    if (ok(mid))    //符合条件返回True  
        l = mid;  
    else  
        r = mid - 1;  
}  

b最大值最小

//最大值最小
int l = min_ans, r = max_ans;  
while (l < r) 
{  
    int mid = (l+r)/2;  
    if (ok(mid))    //符合条件返回True  
        r = mid;  
    else  
        l = mid + 1;  
} 

归并排序模板（例题https://www.luogu.org/problem/show?pid=1177）

#include<cstdio>

int n,ans;
int a[500100],b[500100];    //a原数组，b暂存数组 

void merge_sort(int l,int r)    //归并 
{
    if (l==r) return ;    //一个数不用排序 
    int m = (l+r)>>1;
    merge_sort(l,m);    //排序左边 
    merge_sort(m+1,r);    //排序右边 
    int i = l, j = m+1, k = l ;    //i左边最小的位置，j右边最小的位置 
    while (i<=m && j<=r)
        if (a[i]<=a[j]) b[k++] = a[i++];
        else b[k++] = a[j++];
    while (i<=m) b[k++] = a[i++];    //加入左边剩余的数 
    while (j<=r) b[k++] = a[j++];    //加入右边剩余的数
    for (i=l; i<=r; ++i) a[i] = b[i];    //从暂存数组中赋值 
}

int main()
{
    scanf("%d",&n);
    for (int i=1; i<=n; ++i)
        scanf("%d",&a[i]);
    merge_sort(1,n);
    for (int i=1; i<=n; ++i)
        printf("%d ",a[i]);
    return 0;
}

归并排序求逆序对（例题https://www.luogu.org/problem/show?pid=1908）

#include<cstdio>

int n,ans;
int a[500100],b[500100];    //a原数组，b暂存数组 

void merge_sort(int l,int r)    //归并 
{
    if (l==r) return ;    //一个数不用排序 
    int m = (l+r)>>1;
    merge_sort(l,m);    //排序左边 
    merge_sort(m+1,r);    //排序右边 
    int i = l, j = m+1, k = l ;    //i左边最小的位置，j右边最小的位置 
    while (i<=m && j<=r)
        if (a[i]<=a[j]) b[k++] = a[i++];
        else ans += m-i+1, b[k++] = a[j++];    //加入右半段时，逆序对数增加 
    while (i<=m) b[k++] = a[i++];    //加入左边剩余的数 
    while (j<=r) b[k++] = a[j++];    //加入右边剩余的数
    for (i=l; i<=r; ++i) a[i] = b[i];    //从暂存数组中赋值 
}

int main()
{
    scanf("%d",&n);
    for (int i=1; i<=n; ++i)
        scanf("%d",&a[i]);
    merge_sort(1,n);
    printf("%d",ans);
    return 0;
}

树状数组求逆序对

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<iostream>
#include<cctype>

using namespace std;

const int N = 100010;

struct Node{
    int val,pos;
    bool operator < (const Node &a) const {
        return val > a.val;
    }
}a[N];
int sum[N],n;

inline int read() {
    int x = 0,f = 1;char ch=getchar();
    for (; !isdigit(ch); ch=getchar()) if(ch=='-')f=-1;
    for (; isdigit(ch); ch=getchar()) x=x*10+ch-'0';
    return x*f;
}
void update(int p,int x) {
    for (; p<=n; p+=p&(-p)) sum[p] += x;
}
int query(int p) {
    int ans = 0;
    for (; p>=1; p-=p&(-p)) ans += sum[p];
    return ans;
}
int main() {
    n = read();
    for (int i=1; i<=n; ++i) 
        a[i].val = read(),a[i].pos = i;
    sort(a+1,a+n+1);
    int ans = 0;
    for (int i=1; i<=n; ++i) {
        ans += query(a[i].pos-1);
        update(a[i].pos,1);
    }
    cout << ans;
    return 0;
}

 二分查找一个数，必须要排好序

int binary_search(int x,int y,int c)
{
    int l,r,mid;
    l = x; 
    r = y;
    while (l<r)
    {
        mid = (l+r)>>1;
        if (c<=a[mid]) r = mid;
        else l = mid+1;
    }
    return l;
}
/*------------------------------------*/
int find(int l,int r,int x)
{
    while (l<=r)
    {
        int mid = (l+r)>>1;
        if (a[mid]<=x) l = mid+1;
        else r = mid-1;
    }
    return l;
}

等价于（stl）：

lower_bound(a+x,a+y+1,c)-a; 

 快速排序

void qsort(int l,int r)
{
    int i = l,j = r;
    int mid = a[(l+r)>>1];
    while (i<=j)
    {
        while (a[i]<mid) i++;
        while (a[j]>mid) j--;
        if (i<=j)
        {
            int t = a[i]; a[i] = a[j]; a[j] = t;
            i++; j--;
        }
    }
    if (i<r) qsort(i,r);
    if (l<j) qsort(l,j);
}

快速排序求第k大的数

int qsort(int *a,int l,int r)
{
    int tmp = a[l],pos = l;
    int i = l, j = r;
    while (i<j)
    {
        while (i<j&&a[j]>tmp) j--;
        if (i<j)
        {
            a[pos] = a[j];
            pos = j;
        }
        while (i<j&&a[i]<tmp) i++;
        if (i<j)
        {
            a[pos] = a[i];
            pos = i;
        }
    }
    a[pos] = tmp;
    return pos;
}
int findkth(int *a,int n,int k)
{
    int l = 0,r = n-1;
    while (1)
    {
        int pos = qsort(a,l,r);
        if (pos==n-k) return a[pos];
        else if (pos<n-k) l = pos+1;
        else r = pos-1;
    }
}

dfs序

void dfs(int u,int fa) {
    q[++tot] = u;
    L[u] = tot;
    for (int i=head[u]; i; i=e[i].nxt) {
        int v = e[i].to;
        if (v==fa) continue;
        dfs(v,u);
    }
    R[u] = tot;
}

生成下一个（前一个）排列

#include<iostream>
#include<algorithm>
#include<string>
 
using namespace std;
 
int main()
{
    string s;
    cin>>s; // 包括string类型，vector，还有数组（指针左闭右开） 
    sort(str.begin(), str.end());
    cout<<str<<endl;
    while (next_permutation(str.begin(), str.end())) { // 返回bool类型， 
        cout << str << endl;
    }
    return 0;
}
// 相应的 前一个排列 pre_permutation 

 三分查找（求凸函数最大值的位置）

double search() {
    while (r - l >= eps) {
        lmid = (l + r) / 2.0;
        rmid = (lmid + r) / 2.0;
        if (f(lmid) >= f(rmid)) r = rmid;
        else l = lmid;
    }
    return l;
}

集合hash，判断两个集合是否一样

uLL getkey() {
    uLL a = (rand() << 15) | rand();
    uLL b = (rand() << 15) | rand();
    return a * b;    
} 
uLL init() {
    for (int i=1; i<=MAX_NUM; ++i) Key[i] = init(); // 数字i的key 
}
int gethash(int *A) {
    uLL ans = 0;
    for (int i=1; i<=n; ++i) ans = ans ^ Key[A[i]];
    return ans;
}

  

——————————————————————