那么来一波模板吧=。=

---

ST表(RMQ问题)
//打表与查询 这个是针对最大最小值

    void STpre()    {        for(int i = 1; i <= n; i++) dp[i][0][0] = dp[i][0][1] = d[i];        for(int j = 1; (1<<j) < n; j++)        for(int i = 1; i <= n; i++)        {            if(i + (1<<j) -1 > n) continue;            dp[i][j][0] = max(dp[i][j-1][0],dp[i+(1<<(j-1))][j-1][0]);            dp[i][j][1] = min(dp[i][j-1][1],dp[i+(1<<(j-1))][j-1][1]);        }    }    void rmq(int a,int b)    {        int len = b-a+1;        int k = 0;        while(1<<(k+1) <= len)  k++;        int la = max(dp[a][k][0],dp[b-(1<<k)+1][k][0]);        int sm = min(dp[a][k][1],dp[b-(1<<k)+1][k][1]);    }

---

LCA(tarjan)

    void tarjan(int u)    {        anc[u] = u;        for(int i = h[u] ; i != -1 ; i = edge[i].next)        {            int v = edge[i].to;            if(!vis[v])            {                vis[v] = 1;                tarjan(v);  join(u,v);                anc[getf(u)] = u;                vis[v] = 0;            }        }        col[u] = 1;        for(int i = h1[u]; ~i; i = query[i].next)        {            int v = query[i].to, id = query[i].w;            if(!col[v]) continue;            ans[id] = d[u] + d[v] - 2*d[anc[getf(v)]];        }    }

---

LCA(倍增)

预处理每个结点的父亲和深度

    void pre(int u,int d,int fa)       //处理每个结点的深度和父亲    {        for(int i = h[u]; ~i; i = edge[i].next)        {            int v = edge[i].to, w = edge[i].w;            if(fa != v)            {                dis[v] = dis[u] + w;                dp[v][0] = u;   maxd[v] = d;                pre(v,d+1,u);            }        }    }    

倍增的预处理

    int doubl()                 //倍增的预处理    {        for(int j = 1; j <= 20; j++)        for(int i = 1; i <= n ; i++)        {            if((1 << j) > maxd[i]) continue;            int k = dp[i][j-1]; dp[i][j] = dp[k][j-1];        }        return 0;    }

询问

    int query(int a,int b)    {        int x = a, y = b;        int ans = 0;        if(maxd[x] > maxd[y]) swap(x,y);        for(int j = 20; j >= 0; j--)//先跳到同一高度，再一起往上跳。        {            if(maxd[x] == maxd[y]) break;            if(maxd[y] - (1<<j) < maxd[x]) continue;            ans += (dis[y] - dis[dp[y][j]]);            y = dp[y][j];        }        if(x == y) return ans;        for(int j = 20; j >= 0; j--)        {            if(dp[x][0] == dp[y][0] )break;            if(maxd[y] - (1 << j) < 0 || dp[x][j] == dp[y][j]) continue;            ans += (dis[x]-dis[dp[x][j]] + dis[y] - dis[dp[y][j]]);            x = dp[x][j], y = dp[y][j];        }        ans += (dis[x] - dis[dp[x][0]] + dis[y] - dis[dp[y][0]]);        return ans;    }

---

tarjan
(1).求有向图强连通分量

int tarjan(int id){    vis[id] = 1;    dfn[id] = low[id] = ++tot;    sta[index++] = id;    for(int i = head[id]; ~i; i = edge[i].next)    {        int v = edge[i].to;        if(!dfn[v])        {            tarjan(v);            low[id] = min(low[id],low[v]);        }        else if(vis[v])            low[id] = min(low[id],dfn[v]);    }    if(low[id] == dfn[id])    {        int num = 0;        do        {            vis[sta[index--] ] = 0;            num++;        }while(sta[index] != id);        ans[anum ++] = num;    }    return 0;}

(2).求无向图割点

void tarjan(int u,int father)    {        dfn[u] = low[u] = ++tot;        int child = 0;        for(int i = h[u]; ~i ; i = edge[i].next)        {            int v = edge[i].to;            if(!dfn[v])            {                child++;                tarjan(v,u);                low[u] = min(low[u],low[v]);                if(low[v] >= dfn[u]) isCut[u] = 1;            }            else if(dfn[v] < dfn[u] && father != v)                low[u] = min(low[u],dfn[v]);        }        if(father == -1 && child == 1) isCut[u] = 0;    }

(3).求无向图割边(注意割边需要去重，也就是有重边的都不是割边)

int tarjan(int u,int fa){    dfn[u] = low[u] = ++tot;    for(int i = h[u]; ~i; i = edge[i].next)    {        int v = edge[i].to;        if(!dfn[v])        {            tarjan(v,u);            low[u] = min(low[u],low[v]);            if(dfn[u] < low[v])            {                int a = u, b = v;                if(u > v) swap(a,b);                edge[i].isb = 1;            }        }        else if(dfn[v] < dfn[u] && v != fa)            low[u] = min(low[u],dfn[v]);    }    return 0;}

---

匈牙利算法：

    bool Find(int u)    {        for(int i = 1; i < rnum; i++)            if(g[u][i] && !used[i])        {            used[i] = 1;            if(belong[i] == -1 || Find(belong[i]))            {                belong[i] = u;                return true;            }        }        return false;    }

---

2-sat问题
缩点 + 拓扑序

void tarjan(int u)  {      low[u] = dfn[u] = ++tot;      S[++snum] = u; inS[u] = 1;      for(int i = h[u]; ~i; i = edge[i].next)      {          int v = edge[i].to;          if(!dfn[v])          {              tarjan(v);              low[u] = min(low[u],low[v]);          }          else if(inS[v])              low[u] = min(low[u],dfn[v]);      }      if(low[u] == dfn[u])      {          int v = -1;        snum++;          while(v != u)          {              v = S[snum--];              scc[v] = snum; inS[v] = 0;          }      }  }  void solve()  {      for(int i = 0; i < 2*n; i++)          if(!dfn[i]) tarjan(i);      int flag = 0;      for(int i = 0; i < 2*n; i += 2)          if(scc[i] == scc[i+1]) {flag = 1; break;}      flag == 0 ? printf("YES\n") : printf("NO\n");  }  

---

Dinic求最大流 前向弧优化+ 单路增广（因为多路我很迷茫）
bfs求层次图

int bfs(){    for(int i = s; i <= t; i++)        deg[i] = -1;    queue<int> q;    q.push(s);  deg[s] = 0;    while(!q.empty())    {        int u = q.front(); q.pop();        for(int i = h[u]; ~i ; i = edge[i].next)        {            int v = edge[i].to,cap = edge[i].cap;            if(cap && deg[v] == -1)            {                deg[v] = deg[u] + 1;                q.push(v);            }        }    }    return deg[t] != -1;}

dfs找增广路

int dfs(int u,int f){    if(u == t) return f;    for(int i = cur[u]; ~i; i = edge[i].next)    {        cur[u] = i;        int v = edge[i].to, cap = edge[i].cap, rev = edge[i].rev;        if(cap && deg[v] == deg[u] + 1)        {            int k = dfs(v,min(f,cap));            if(!k)continue;            edge[i].cap -= k;            edge[rev].cap += k;            return k;        }    }    return 0;}

void solve(){    int flow = 0;    while(bfs())    {        for(int i = s; i <= t; i++) cur[i] = h[i];        while(int k = dfs(s,inf)) flow += k;    }   cout << m-flow << endl;}

---

E-K + bellman
E-k算法其实就是找增广路的bfs实现，来达到每次都找的是最短增广路的目的。
对于最小费用最大流其实就是每次找费用最少且路径最短的增广路。

int bfs(){    for(int i = 0; i < maxn; i++)        d[i] = inf,a[i] = 0,inq[i] = 0;    queue<int> q;    q.push(0);    d[0] = 0;a[0] = inf;    inq[0] = 1;    while(!q.empty())       //找最短且费用最少的增广路    {        int u = q.front(); q.pop();        inq[u] = 0;        for(int i = h[u]; ~i; i = edge[i].next)        {            int v = edge[i].to,cap = edge[i].cap, w = edge[i].w;            if(cap && d[v] > d[u] + w)            {                a[v] = min(a[u],cap);   d[v] = d[u] + w;                pre[v] = i;                if(!inq[v]) {q.push(v); inq[v] = 1;}            }        }    }    if(d[t] == inf ) return 0;    for(int u = t; u != st; u = edge[pre[u]].from)    {        int rev = edge[pre[u]].rev;        edge[pre[u]].cap -= a[t];        edge[rev].cap += a[t];    }    return d[t];}

---