各种实用模板或指令（随时补充）

0.前言

各模板分别摘自博主不同时期所写的代码，码风可能出现不统一的情况。

1. 指令

- cmd操作

D:
cd
dir
gcc/g++
xx.exe

- 网络编译

#ifndef ONLINE_JUDGE
freopen...
#endif

2. 优化模板

- cin优化

std::ios::sync_with_stdio(false);

- 编译优化（火车头）

点击查看代码

# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wattributes"
# pragma GCC diagnostic ignored "-Wpragmas"
# pragma GCC diagnostic error "-std=c++11"
# pragma GCC optimize("-fdelete-null-pointer-checks,inline-functions-called-once,-fexpensive-optimizations,-foptimize-sibling-calls,-ftree-switch-conversion,-finline-small-functions,inline-small-functions,-frerun-cse-after-loop,-fhoist-adjacent-loads,-findirect-inlining,-freorder-functions,no-stack-protector,-fpartial-inlining,-fsched-interblock,-fcse-follow-jumps,-falign-functions,-fstrict-aliasing,-fschedule-insns2,-ftree-tail-merge,inline-functions,-fschedule-insns,-freorder-blocks,-funroll-loops,-fthread-jumps,-fcrossjumping,-fcaller-saves,-fdevirtualize,-falign-labels,-falign-loops,-falign-jumps,unroll-loops,-fsched-spec,-ffast-math,Ofast,inline,-fgcse,-fgcse-lm,-fipa-sra,-ftree-pre,-ftree-vrp,-fpeephole2",3)
# pragma GCC target("avx","sse2")
# pragma GCC optimize(3)
# pragma GCC optimize("Ofast")
# pragma GCC optimize("inline")
# pragma GCC optimize("-fgcse")
# pragma GCC optimize("-fgcse-lm")
# pragma GCC optimize("-fipa-sra")
# pragma GCC optimize("-ftree-pre")
# pragma GCC optimize("-ftree-vrp")
# pragma GCC optimize("-fpeephole2")
# pragma GCC optimize("-ffast-math")
# pragma GCC optimize("-fsched-spec")
# pragma GCC optimize("unroll-loops")
# pragma GCC optimize("-falign-jumps")
# pragma GCC optimize("-falign-loops")
# pragma GCC optimize("-falign-labels")
# pragma GCC optimize("-fdevirtualize")
# pragma GCC optimize("-fcaller-saves")
# pragma GCC optimize("-fcrossjumping")
# pragma GCC optimize("-fthread-jumps")
# pragma GCC optimize("-funroll-loops")
# pragma GCC optimize("-freorder-blocks")
# pragma GCC optimize("-fschedule-insns")
# pragma GCC optimize("inline-functions")
# pragma GCC optimize("-ftree-tail-merge")
# pragma GCC optimize("-fschedule-insns2")
# pragma GCC optimize("-fstrict-aliasing")
# pragma GCC optimize("-falign-functions")
# pragma GCC optimize("-fcse-follow-jumps")
# pragma GCC optimize("-fsched-interblock")
# pragma GCC optimize("-fpartial-inlining")
# pragma GCC optimize("no-stack-protector")
# pragma GCC optimize("-freorder-functions")
# pragma GCC optimize("-findirect-inlining")
# pragma GCC optimize("-fhoist-adjacent-loads")
# pragma GCC optimize("-frerun-cse-after-loop")
# pragma GCC optimize("inline-small-functions")
# pragma GCC optimize("-finline-small-functions")
# pragma GCC optimize("-ftree-switch-conversion")
# pragma GCC optimize("-foptimize-sibling-calls")
# pragma GCC optimize("-fexpensive-optimizations")
# pragma GCC optimize("inline-functions-called-once")
# pragma GCC optimize("-fdelete-null-pointer-checks")
# pragma GCC diagnostic pop


#define Finline __inline__ __attribute__ ((always_inline))
Finline char get_char(){
    static char READBUF[200000001], *READP1 = READBUF, *READP2 = READBUF + fread(READBUF, 1, 200000000, stdin);
    return READP1 == READP2 ? EOF : *READP1 ++;
}

- O2优化

#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")

- min函数优化

inline int min (int a, int b) {
    int c = (a - b) >> 31;
    return a ^ c | b ^ ~c;
}

- 常数优化

#define re register
#define il inline

在自定义函数前加上inline，在循环内加上register，可提升少许运行速度，例如：

il int find (int x) {
    return fa[x] == x ? x : fa[x] = find(fa[x]);
}
for (re int i = a;i <= b;++ i) {
    ...
}

- 提升效率的头部注释

freopen：

#define fin(a)  freopen (#a".in","r",stdin)
#define fout(a) freopen (#a".out","w",stdout)

循环：

#define rep(i,a,b)  for (re int i = a;i <= b;++ i)
#define Rep(i,a,b)  for (re int i = a;i < b;++ i)
#define drep(i,a,b) for (re int i = a;i >= b;-- i)

3.函数模板

- 快读快写函数

il ll read() {
    ll x = 0;
    char ch = 0;
    while (!isdigit(ch)) {
        ch = getchar();
    }
    while (isdigit(ch)) {
        x = (x << 3) + (x << 1) + (ch ^ 48);
        ch = getchar();
    }
    return x;
}

il void write (ll x) {
    if (x > 9) {
        write (x / 10);
    }
    putchar (x % 10 + '0');
}

- 比较大小

il int Min (int a,int b) {
    return a < b ? a : b;
}

il int Max (int a,int b) {
    return a > b ? a : b;
}

- 线性筛素数

bool isPrime[100000010];
int Prime[6000010], cnt = 0;
void GetPrime (int n) {
    memset (isPrime, 1, sizeof(isPrime));

    isPrime[1] = 0;
    
    for (re int i = 2; i <= n; i++) {
        if (isPrime[i]) {
            Prime[++cnt] = i;
        }
        for (re int j = 1; j <= cnt && i*Prime[j] <= n;j ++) {
            isPrime[i*Prime[j]] = 0;
            if (i % Prime[j] == 0) {
                break;
            }
        }
    }
}

- 幂函数

#define MOD 20100403
il ll Pow (ll a,ll b) {
    ll ans = 1;
    while (b) {
        if (b & 1) {
            ans = ans * a % MOD;
        }
        a = a * a % MOD;
        b >>= 1;
    }
    return ans % MOD;
}

- 并查集

il int find (int x) {
    return pre[x] == x ? pre[x] : (pre[x] = find (pre[x]));
}

il void join (int x,int y) {
    int fx = find(x),fy = find(y);
    if (fx != fy)
        pre[fx] = fy;
}

bool check (int x,int y) {
    return find(x) == find(y);
}

- 堆

int heap_size,heap[MAXN],n;
il void put (int x) {
    heap[++ heap_size] = x;
    push_heap (heap + 1,heap + heap_size + 1,greater<int>());
}
il int ask () {
    return heap[1];
}
il void del () {
    pop_heap(heap + 1,heap + heap_size + 1,greater<int>());
    heap_size --;
}

- 单调栈

int a[MAXN], ans[MAXN];
rep(i,1,n) {
    scanf("%d",&a[i]);
}
drep(i,n,1) {
    while(! st.empty() && a[st.top()] <= a[i]) {
    st.pop();
    }
    ans[i] = (st.empty() ? 0 : st.top());
    st.push(i);
}

- 滑动窗口/单调队列

il int Min (int a,int b) {
    return a < b ? a : b;
}

il int Max (int a,int b) {
    return a > b ? a : b;
}

int n,k;
int ans[3][MAXN];
struct Array {
    int id,w;
};
deque <Array> minq;
deque <Array> maxq;


int main () {
    scanf ("%d %d",&n,&k);
    int cnt = 1;
    Array ar;
    for (re int i = 1;i <= n;++ i) {
        int a;
        scanf ("%d",&a);
        ar.id = i;
        ar.w = a;

        while (maxq.size() && a >= maxq.back().w)
            maxq.pop_back();
        while (minq.size() && a <= minq.back().w)
            minq.pop_back();
        maxq.push_back(ar);
        minq.push_back(ar);
        while (i - k >= maxq.front().id)
            maxq.pop_front();
        while (i - k >= minq.front().id)
            minq.pop_front();
        if (i >= k) {
            ans[0][++ cnt] = maxq.front().w;
            ans[1][cnt] = minq.front().w;
        }
    }
    
    for (re int i = 2;i <= cnt;++ i) {
        printf ("%d ",ans[1][i]);
    }
    printf ("\n");
    for (re int i = 2;i <= cnt;++ i) {
        printf ("%d ",ans[0][i]);
    }

    return 0;
}

- 最长公共子序列（二分）

#define MAXN 100005
int a[MAXN],b[MAXN],map[MAXN],f[MAXN];
int main () {
    int n;
    cin >> n;
    for (re int i = 1;i <= n;i ++) {
        scanf ("%d",&a[i]);
        map[a[i]] = i;
    }
    for (re int i = 1;i <= n;i ++) {
        scanf("%d",&b[i]);
        f[i] = 0x7fffffff;
    }
    int len = 0;
    f[0] = 0;
    for (int i = 1;i <= n;i ++) {
        int l = 0,r = len,mid;
        if (map[b[i]] > f[len]) {
            f[++ len] = map[b[i]];
        }
        else {
            while (l < r) {   
                mid = (l + r) / 2;
                if (f[mid] > map[b[i]]) {
                    r = mid;
                }
                else {
                    l = mid + 1; 
                }
            }
            f[l] = min (map[b[i]],f[l]);
        }
    }
    cout << len;
    return 0;
}

- 字符串哈希

#define ull unsigned long long
ull mod = 212370440130137957ll;
const int prime = 131;
int n, ans = 1;
char s[10005];
ull hashnum[10005];
ull hashh (char s[]) {
    ull len = strlen(s);
    ull ans = 0;
    for (re int i = 0;i < len;i ++) {
        ans = ((ans * prime) % mod + ((ull)(s[i])) % mod) % mod;
    }
    return ans;
}

int main () {
    cin >> n;
    for (re int i = 1;i <= n;i ++) {
        scanf ("%s",s);
        hashnum[i] = hashh (s);
    }
    sort (hashnum + 1,hashnum + n + 1);
    for (re int i = 2;i <= n;i ++) {
        if (hashnum[i] != hashnum[i-1]) {
            ans++;
        }
    }
    cout << ans;
    return 0;
}

- Manacher算法

int p[MAXN];
int siz,ans = 0;
char a[MAXN];

il int min (int a,int b) {
    return a < b ? a : b;
}

il void ReadinManacher () {
    char ch = getchar();
    a[0] = '!';
    siz = 1;
    a[1] = '|';
    while (ch < 'a' || ch > 'z')
        ch = getchar();
    while (ch >= 'a' && ch <= 'z') {
        a[++ siz] = ch;
        a[++ siz] = '|';
        ch = getchar();
    }
}

il void write (int x) {
    if (x > 9)
        write(x / 10);
    putchar(x % 10 + '0');
}

int main () {
    #ifndef ONLINE_JUDGE
    fin(manacher);
    fout(manacher);
    #endif

    ReadinManacher();

    for(re int i = 1,mid = 0,r = 0;i <= siz;i ++) {
        if(i <= r)
            p[i] = min(p[(mid << 1) - i],r - i + 1);
        
        while(a[i - p[i]] == a[i + p[i]])
            ++ p[i];
        
        if(p[i] + i > r) {
            r = p[i] + i - 1;
            mid = i;
        }
        if(p[i] > ans)
            ans = p[i];
    }

    write(ans - 1);
    return 0;
}

- 线段树1

1. 将某区间每一个数加上 $k$。
2. 求出某区间每一个数的和。

struct str {
    long long sum;
    int l,r,lz;
} tr[400010];
int n,m,a[100010];
il void down (int k) {
    int lzy = tr[k].lz;
    if(lzy == 0) {
        return;
    }
    tr[k * 2].lz += lzy;
    tr[k * 2 + 1].lz += lzy;
    int mid = (tr[k].l + tr[k].r) / 2;
    tr[k * 2].sum += lzy * (mid - tr[k].l + 1);
    tr[k * 2 + 1].sum += lzy * (tr[k].r - mid);
    tr[k].lz = 0;
}
il void build (int k,int l,int r) {
    tr[k].l = l；
    tr[k].r = r;
    if (l == r) {
        tr[k].sum = a[l];
        return;
    }
    int mid = (l + r) / 2;
    build (2 * k,l,mid);
    build (2 * k + 1,mid + 1,r);
    tr[k].sum = tr[k * 2].sum + tr[k * 2 + 1].sum;
}
il void change (int k,int x,int y,int w) {   
    if (tr[k].l > y || tr[k].r < x) {
        return;
    }
    if (tr[k].l >= x && tr[k].r <= y) {
        tr[k].sum += w * (tr[k].r - tr[k].l + 1);
        tr[k].lz += w;
        return;
    }
    if(tr[k].l == tr[k].r) {
        return;
    }
    down (k);
    change (k * 2,x,y,w);
    change (k * 2 + 1,x,y,w);
    tr[k].sum = tr[k * 2].sum + tr[k * 2 + 1].sum;
}
il long long ask (int k,int x,int y) {
    if (tr[k].l > y || tr[k].r < x) {
        return 0;
    }
    else if (tr[k].l >= x && tr[k].r <= y) {
        return tr[k].sum;
    }
    down(k);
    return ask (k * 2,x,y) + ask(k * 2 + 1,x,y);
}
int main() {
    cin >> n >> m;
    int x, y, w, que;
    for (re int i = 1;i <= n;i ++) {
        scanf ("%d",&a[i]);
    }
    build (1,1,n);
    for (re int i = 1;i <= m;i ++) {
        cin >> que;
        if (que == 2) {
            scanf ("%d%d",&x,&y);
            printf ("%lld\n",ask (1,x,y));
        }
        else {
            scanf ("%d%d%d",&x,&y,&w);
            change (1,x,y,w);
        }
    }
    return 0;
}

线段树2

暂时不会

- 树状数组1

1.将某一个数加上 $x$。
2.求出某区间每一个数的和

int n,q;
int a[MAXN];
ll tr[MAXN];

il int lowbit(int x) {
    return x & (-x);
}

il void update (int x,int y) {
    while (x <= n) {
        tr[x] += y;
        x += lowbit(x);
    }
}

il ll query (int x) {
    ll sum = 0;
    while (x) {
        sum += tr[x];
        x -= lowbit(x);
    }
    return sum;
}



int main() {
    #ifndef ONLINE_JUDGE
    freopen("Fenwicktree.in","r",stdin);
    #endif

    scanf ("%d%d",&n,&q);
    rep(i,1,n) {
        scanf("%d",&a[i]);
        update(i,a[i]);
    }
    
    while (q --) {
        int op,x,y;
        scanf("%d%d%d",&op,&x,&y);
        if (op == 1)
            update(x,y);
        else
            printf("%lld\n",query(y) - query(x - 1));
    }

    return 0;
}

树状数组2

1.将某区间每一个数加上$x$。
2.求出某一数值的值。

int n,m;
int input[500010];
int tree[500100];
int lowbit (int x) {
    return x & -x;
}
il void add (int x,int k) {
    while (x <= n) {
        tree[x] += k;
        x += lowbit(x);
    }
}
il int search (int x) {
    int ans = 0;
    while (x != 0) {
        ans += tree[x];
        x -= lowbit(x);
    }
    return ans;
}
int main() {
    cin >> n >> m;
    for (re int i = 1; i <= n; i ++)
        cin >> input[i];
    for (int i = 1; i <= m; i ++) {
        int a;
        scanf ("%d",&a);
        if (a == 1) {
            int x,y,z;
            scanf ("%d%d%d",&x,&y,&z);
            add (x,z);
            add (y + 1, - z);
        }
        if (a == 2) {
            int x;
            scanf ("%d",&x);
            printf ("%d\n",input[x] + search(x));
        }
    }
}

- 最小生成树-kruskal算法

int n,m,ans = 0;
int fa[MAXN],cnt = 0;
struct edge {
    int u,v,w;
    bool operator  < (const edge& e) const {
        return w < e.w;
    }
} e[MAXM];

il bool cmp (edge a,edge b) {
    return a.w < b.w;
}

il int find (int x) {
    return fa[x] == x ? x : fa[x] = find(fa[x]);
}

il void join (int x,int y) {
    int fx = find(x),fy = find(y);
    if (fx != fy) {
        fa[fx] = fy;
    }
}

il bool check (int x,int y) {
    return fa[x] == fa[y];
}

il void kruskal () {
    for (re int i = 1;i <= m;++ i) {
        int fu = find(e[i].u),fv = find(e[i].v),fw = e[i].w;
        if (fu == fv) {
            continue;
        }
        //join (fu,fv);
        fa[fu] = fv;
        ans += fw;
        if (++ cnt == n - 1) {
            break;
        }
    }
}

int main () {
    scanf ("%d %d",&n,&m);
    for (re int i = 1;i <= n;++ i) {
        fa[i] = i;
    }
    for (re int i = 1;i <= m;++ i) {
        scanf ("%d %d %d",&e[i].u,&e[i].v,&e[i].w);
    }
    sort (e + 1,e + m + 1,cmp);

    kruskal ();
    printf ("%d",ans);

    return 0;
}

- 最小生成树-Prim算法

忘记了，以后补

- 单源最短路径-Dijkstra算法

#include <bits/stdc++.h>
#define re register
#define il inline
#define int long long
#define MAXN 100005
#define MAXM 200005

using namespace std;

int n,m,s;
int head[MAXN],cnt = 0;
int dis[MAXN];
struct edge {
    int to,nxt,w;
} e[MAXM << 1];
struct heapnode {
    int p,w;
    bool operator < (const heapnode& E)
    const {
        return w > E.w;
    }
};

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

il void dijkstra (int s) {
    priority_queue <heapnode> q;
    memset (dis,0x3f,sizeof(dis));
    dis[s] = 0;
    q.push((heapnode){s,dis[s]});

    while (q.size()) {
        int u = q.top().p,uw = q.top().w;
        q.pop();
        if (uw != dis[u]) {
            continue;
        }
        for (re 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((heapnode){v,dis[v]});
            }
        }
    }
}

signed main () {
    scanf ("%lld %lld %lld",&n,&m,&s);
    for (re int i = 1;i <= m;++ i) {
        int u,v,w;
        scanf ("%lld %lld %lld",&u,&v,&w);
        add (u,v,w);
        //add (v,u,w);
    }

    dijkstra (s);
    for (re int i = 1;i <= n;++ i) {
        printf ("%lld ",dis[i]);
    }
    return 0;
}

- 最近公共祖先（LCA）

int n,m,s;
int lg[MAXN],fa[MAXN][MAXB],dep[MAXN];
int head[MAXN],cnt = 0;
struct edge {
    int to,nxt;
} e[MAXN << 1];

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

il void getlog (int x) {
    for (re int i = 1;i <= x;++ i) {
        lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
    }
}

il void dfs (int u,int f) {
    fa[u][0] = f;
    dep[u] = dep[f] + 1;
    for (re int i = 1;i <= lg[dep[u]];++ i) {
        fa[u][i] = fa[fa[u][i - 1]][i - 1];
    }
    for (re int i = head[u];i;i = e[i].nxt) {
        int v = e[i].to;
        if (v != f) {
            dfs (v,u);
        }
    }
}

il int lca (int x,int y) {
    if (dep[x] < dep[y]) {
        swap (x,y);
    }
    while (dep[x] > dep[y]) {
        x = fa[x][lg[dep[x] - dep[y]] - 1];
    }
    if (x == y) {
        return x;
    }
    for (re int i = lg[dep[x]] - 1;i >= 0;-- i) {
        if (fa[x][i] != fa[y][i]) {
            x = fa[x][i];
            y = fa[y][i];
        }
    }
    
    return fa[x][0];
}

int main () {
    scanf ("%d %d %d",&n,&m,&s);
    for (re int i = 1;i < n;++ i) {
        int u,v;
        scanf ("%d %d",&u,&v);
        add (u,v);
        add (v,u);
    }
    getlog (n);
    dfs (s,0);
    while (m --) {
        int u,v;
        scanf ("%d %d",&u,&v);
        printf ("%d\n",lca(u,v));
    }

    return 0;
}

- 三分法

double eps = 1e-7;
double l,r,a[MAXN];
int n;

il db FABS (db x) {
    return
        x = ((x > 0) ? x : -x);
}

il db qjz (db x) {
    db ans = 0;

    drep(i,n,0)
        ans = ans * x + a[i];

    return ans;
}

int main() {
    cin >> n >> l >> r;

    drep(i,n,0)
        cin >> a[i];

    db mid;

    while (FABS(l - r) >= eps) {
        mid = (l + r) / 2;

        if (qjz(mid + eps) > qjz(mid - eps))
            l = mid;

        else
            r = mid;
    }

    printf("%.5lf",l);
    return 0;
}

- 组合数

il ll C(ll n,ll m) {
    if (m > n) {
        return 0;
    }
    if (m > n - m) {
        m = n - m;
    }
    ll s1 = 1,s2 = 1;
    Rep(i,0,m) {
        s1 = s1 * (n - i) % MOD;
        s2 = s2 * (i + 1) % MOD;
    }
    return s1 * Pow(s2,MOD - 2) % MOD;
}

- 卢卡斯定理

il ll Lucas (int n,int m) {
    if (!m) {
        return 1;
    }
    return C(n % MOD,m % MOD) * Lucas(n / MOD,m / MOD) % MOD;
}