图论模板

/* // 图论模板 // */
//-----------------------------------------------------------------------------
/*卡常小技巧*/
#define re register
#define max(x,y) ((x)>(y)?(x):(y))
#define min(x,y) ((x)<(y)?(x):(y))
#define swap(x,y) ((x)^=(y)^=(x)^=(y))
#define abs(x) ((x)<0?-(x):(x))
inline + 函数（非递归）
static 相当于全局变量，防止爆栈，且不用重复申请空间，初值为0
//-----------------------------------------------------------------------------
/*前向星邻接表*/
//单向链表
int tot,first[100010];
struct node{int u,v,w,next;}edge[200010];
inline void add(re int x,re int y,re int w){
    edge[++tot].u=x;
    edge[tot].v=y;
    edge[tot].w=w;
    edge[tot].next=first[x];
    first[x]=tot;
}
//双向链表
int tot,head[100010],tail[100010];
struct node{int u,v,next,last;}edge[200010];
inline void add(re int x,re int y){
    edge[++tot].u=x;
    edge[tot].v=y;
    edge[tot].w=w;
    edge[tot].next=0;
    edge[tot].last=tail[x];
    edge[tail[x]].next=tot;tail[x]=tot;
    if(!head[x]) head[x]=tot;
}
//-----------------------------------------------------------------------------
/*遍历（dfs，bfs)*/
//dfs
void dfs(re int x,re int fa){
    for(re int i=first[x];i;i=edge[i].next){
        re int y=edge[i].v;
        if(y==fa) continue;
        dfs(y,x);
    }
}
//bfs
inline void bfs(re int s){
    static queue<int> q; 
    q.push(s);ins[s]=1;
    while(!q.empty()){
        re int x=q.front();q.pop(),ins[x]=0;
        for(re int i=first[x];i;i=edge[i].next){
            re int y=edge[i].v;
            if(ins[y]) continue;
            q.push(y);ins[y]=1;
        }
    }
}
//-----------------------------------------------------------------------------
/*最短路*/
//Floyd
for(re int k=1;k<=n;++k)
for(re int i=1;i<=n;++i)
    for(re int j=1;j<=n;++j)
        if(f[i][k]+f[k][j]<f[i][j])
            f[i][j]=f[i][k]+f[k][j];
//堆优化Dijkstra
inline void Dijkstra(re int s){
    static priority_queue<pair<int,int> > q;
    memset(dis,0x3f,sizeof(dis));dis[s]=0;
    q.push(make_pair(dis[s],s));
    while(!q.empty()){
        re int x=q.top();q.pop();
        if(vis[x]) continue;vis[x]=1;
        for(re int i=first[x];i;i=edge[i].next){
            re int y=edge[i].v,w=edge[i].w;
            if(dis[x]+w<dis[y]){
                dis[y]=dis[x]+w;
                q.push(make_pair(dis[y],y));
            }            
        }
    }
}
//spfa
inline void spfa(re int s){
    static queue<int> q;
    memset(dis,0x3f,sizeof(dis)); 
    dis[s]=0;q.push(s);ins[s]=1;
    while(!q.empty()){
        re int x=q.front();q.pop();ins[x]=0;
        for(re int i=first[x];i;i=edge[i].next){
            re int y=edge[i].v,w=edge[i].w;
            if(dis[x]+w<dis[y]){
                dis[y]=dis[x]+w;
                if(!ins[y]) q.push(y),ins[y]=1;
            }
        }
    }
}
//-----------------------------------------------------------------------------
/*拓扑排序*/
inline void topsort(){
    static queue<int> q;
    for(re int i=1;i<=n;++i)
        if(!in[i]) q.push(i);
    while(!q.empty()){
        re int x=q.front();q.pop();
        for(re int i=first[x];i;i=edge[i].next){
            re int y=edge[i].v; --in[y];
            if(!in[y]) q.push(y);
        }
    }
}
//-----------------------------------------------------------------------------
/*并查集*/
//普通并查集
int find(re int x){return fa[x]==x?x:find(fa[x]);}
inline void merge(re int x,re int y){
    x=find(x),y=find(y);
    if(x!=y) fa[x]=y;
}
//路径压缩
int find(re int x){return fa[x]==x?x:fa[x]=find(fa[x]);}
//按秩合并
inline void merge(re int x,re int y){
    x=find(x),y=find(y);
    if(x==y) return ;
    if(rk[x]<=rk[y]) fa[x]=y,rk[y]=max(rk[y],rk[x]+1);
    else fa[y]=x,rk[x]=max(rk[x],rk[y]+1); 
}
//-----------------------------------------------------------------------------
/*最小生成树*/
//Kruskal
inline bool cmp(node x,node y){
    return x.w<y.w;
}
inline void Kruskal(){
    sort(a+1,a+m+1,cmp);
    for(re int i=1;i<=m;i++){
        re int x=a[i].x,y=a[i].y;
        x=find(x),y=find(y);
        if(x==y) continue;
        fa[x]=y,++cnt,ans+=a[i].w;
        if(cnt==n-1) break;
    }
}
//prim
inline void init(){
    for(re int i=1;i<=n;++i)
        for(re int j=1;j<=n;++j)
            w[i][j]=inf;
    for(re int i=1,u,v,w;i<=m;++i){
        u=read(),v=read(),w=read();
        if(w[u][v]>w) w[u][v]=w[v][u]=w;
    }
    for(re int i=1;i<=n;++i) to[i]=w[1][i];
    fm[1]=1;
}
inline int prim(){
    while(tot<n){
        re int minn=inf,now;++tot;
        for(re int i=1;i<=n;++i)
        if(!fm[i]&&to[i]<minn)minn=to[i],now=i;
        ans+=minn;
        for(re int i=1;i<=n;++i)
        if(to[i]>w[now][i]&&!fm[i]) to[i]=w[now][i];
        fm[now]=1;
    }
    return ans;
}
//-----------------------------------------------------------------------------
/*树的直径*/
//树形DP
void dfs(re int x){
    vis[x]=1;
    for(re int i=first[x];i;i=edge[i].next){
        re int y=edge[i].v;if(vis[y]) continue;
        dfs(y);ans=max(ans,dep[x]+dep[y]+edge[i].w);
        dep[x]=max(dep[x],dep[y]+edge[i].w);
    }
}
//两遍dfs
void dfs(re int x,re int fa){
    for(re int i=first[x];i;i=edge[i].next){
        re int y=edge[i].v;
        if(y==fa) continue;
        dis[y]=dis[x]+1,pre[y]=x; dfs(y,x);
    }
}
re int st=0,ed=0,len=0;
dis[1]=0;dfs(1,0);
for(re int i=1;i<=n;++i)
    if(dis[i]>dis[st]) st=i;
dis[st]=0;dfs(st,0);
for(re int i=1;i<=n;++i)
    if(dis[i]>dis[ed]) len=dis[ed],ed=i;
//-----------------------------------------------------------------------------
/*tarjan*/
//有向图强联通分量+缩点重建
void tarjan(re int x){
    dfn[x]=low[x]=++cnt;
    stk[++top]=x,ins[x]=1;
    for(re int i=first[x];i;i=edge[i].next){
        re int y=edge[i].v;
        if(!dfn[y]){
            tarjan(y);
            low[x]=min(low[x],low[y]);
        }
        else if(ins[y]) low[x]=min(low[x],dfn[y]);
    }
    if(dfn[x]==low[x]){
        ++cnt;re int dat;
        do{
            dat=stk[top--],ins[dat]=0;
            bel[y]=cnt,scc[cnt].push_back(dat);
        }while(dat!=x);
    }
}
for(re int i=1;i<=n;++i)
    if(!dfn[i]) tarjan(i);
for(re int x=1;x<=n;++x){
    for(re int i=first[x];i;i=edge[i].next){
        re int y=edge[i].v;
        if(bel[x]==bel[y]) continue;
        readd(bel[x],bel[y]);
    }
}
//割点(无向图）
void tarjan(re int x){
    dfn[x]=low[x]=++cnt;re int flag=0;
    for(re int i=first[x];i;i=edge[i].next){
        re int y=edge[i].v;
        if(!dfn[y]){
            tarjan(y);
            low[x]=min(low[x],low[y]);
            if(low[y]>=dfn[x]) {
                ++flag;
                if(x!=root||flag>1) cut[x]=1;
            }
        }
        else low[x]=min(low[x],dfn[y]);
    }
}
for(re int i=1;i<=n;++i)
    if(!dfn[i]) root=i,tarjan(i);
//割边(无向图）
void tarjan(re int x,re int ed){
    dfn[x]=low[x]=++cnt;
    for(re int i=first[x];i;i=edge[i].next){
        re int y=edge[i].v;
        if(dfn[y]){
            if(i!=(ed^1)) 
                low[x]=min(low[x],dfn[y]);
            continue;
        }
        tarjan(y,i);
        low[x]=min(low[x],low[y]);
        if(low[y]>dfn[x]) bridge[i]=bridge[i^1]=1;
    }
}
for(re int i=1;i<=n;++i)
    if(!dfn[i]) tarjan(i,0);
//点双+缩点重建
void tarjan(re int x){
    dfn[x]=low[x]=++num;
    stk[++top]=x;
    if(x==root&&first[x]==0){
        dcc[++cnt].push_back(x);
        return ;
    }
    re int flag=0;
    for(re int i=first[x];i;i=edge[i].next){
        re int y=edge[i].v;
        if(!dfn[y]){
            tarjan(y);
            low[x]=min(low[x],low[y]);
            if(low[y]>=dfn[x]){
                ++flag;
                if(x!=root||flag>1) cut[x]=1;
                cnt++;re int dat;
                do{
                    dat=stk[top--];
                    dcc[cnt].push_back(dat);
                }while(dat!=y);
                dcc[cnt].push_back(x);
            }
        }
        else low[x]=min(low[x],dfn[y]);
    }
}
for(re int i=1;i<=n;++i) 
    if(!dfn[i]) root=i,tarjan(i);
num=cnt;
for(re int i=1;i<=n;++i)
    if(cut[i]) id[i]=++num;
retot=1;
for(re int i=1;i<=cnt;++i){
    for(re int j=0;j<dcc[i].size();++j){
        re int x=dcc[i][j];
        if(cut[x])
            readd(i,id[x]),readd(id[x],i);
        else bel[x]=i;
    }
}
//边双(即删除割边)(无向图)+缩点重建
void tarjan(re int x,re int ed){
    dfn[x]=low[x]=++cnt;
    for(re int i=first[x];i;i=edge[i].next){
        re int y=edge[i].v;
        if(dfn[y]){
            if(i!=(ed^1)) 
                low[x]=min(low[x],dfn[y]);
            continue;
        }
        tarjan(y,i);
        low[x]=min(low[x],low[y]);
        if(low[y]>dfn[x]) bridge[i]=bridge[i^1]=1;
    }
}
void dfs(re int x){
    id[x]=dcc;
    for(re int i=first[x];i;i=edge[i].next){
        re int y=edge[i].v;
        if(id[y]||bridge[i]) continue;
        dfs(y);
    }
}
for(re int i=1;i<=n;++i)
    if(!dfn[i]) tarjan(i,0);
for(re int i=1;i<=n;++i){
    if(!id[i]) ++dcc,dfs(i);
}
for(re int i=1;i<=tot;++i){
    re int x=edge[i].v,y=edge[i^1].v;
    if(id[x]==id[y]) continue;
    readd(id[x],id[y]);
}
//-----------------------------------------------------------------------------
/*二分图*/
//匈牙利算法（增广路算法）
bool dfs(re int x){
    for(re int i=first[x];i;i=edge[i].next){
        re int y=edge[i].v;
        if(!vis[y]){
            vis[y]=1;
            if(!match[y]||dfs(match[y])){
                match[y]=x;return 1;
            }
        }
    }
    return 0;
}
for(re int i=1;i<=n;++i){
    memset(vis,0,sizeof(vis));
    if(dfs(i)) ++ans;
}
//-----------------------------------------------------------------------------
/*lca*/
//倍增lca
void dfs(re int x,re int fa){
    dep[x]=dep[fa]+1;
    for(re int i=1;i<=20;++i)
        f[x][i]=f[f[x][i-1]][i-1];
    for(re int i=first[x];i;i=edge[i].next){
        re int y=edge[i].v;
        if(y==fa) continue;
        f[y][0]=x;dfs(y,x);
    }
}
inline int lca(re int x,re int y){
    if(dep[x]<dep[y]) x^=y^=x^=y;
    re int dat=dep[x]-dep[y];
    for(re int i=0;i<=20;++i) if(dat>>i&1) x=f[x][i];
    if(x==y) return x;
    for(re int i=20;~i;--i)
        if(f[x][i]!=f[y][i]) x=f[x][i],y=f[y][i];
    return f[x][0];
}
//ST表lca
void dfs(re int x,re int fa){
    dep[x]=dep[fa]+1,id[x]=++cnt,euler[cnt]=x;
    for(re int i=first[x];i;i=edge[i].next){
        re int y=edge[i].v;
        if(y==fa) continue;
        dfs(y,x),euler[++cnt]=x;
    }
}
inline void ST(){
    for(re int i=1;i<=cnt;++i) f[i][0]=euler[i];
    for(re int j=1;j<20;++j){
        for(re int i=1;i<=cnt;++i){
            if(i+(1<<j)>cnt) break;
            if(dep[f[i][j-1]]<dep[f[i+(1<<(j-1))][j-1]])
                f[i][j]=f[i][j-1];
            else f[i][j]=f[i+(1<<(j-1))][j-1];
        }    
    }
}
inline int lca(re int x,re int y){
    if(x>y) x^=y^=x^=y;
    re int pos=(int)(log(y-x+1)/log(2));
    re int res=f[x][pos];
    re int k=f[y-(1<<pos)+1][pos];
    if(dep[res]>dep[k]) res=k; return res;
}
LCA(x,y)=lca(id[x],id[y]);
//树链剖分lca
void dfs1(re int x){
    siz[x]++;
    for(re int i=first[x];i;i=edge[i].next){
        re int y=edge[i].v;
        if(dep[y]) continue;
        dep[y]=dep[x]+1,fa[y]=x;
        dfs1(y);siz[x]+=siz[y];
    }
}
void dfs2(re int x,re int pt){
    top[x]=pt;re int sz=0,pos=0;
    for(re int i=first[x];i;i=edge[i].next){
        re int y=edge[i].v;
        if(fa[y]==x) continue;
        if(siz[y]>sz)
            pos=y,sz=siz[y];
    }
    dfs2(pos,pt);
    for(re int i=first[x];i;i=edge[i].next){
        re int y=edge[i].v;
        if(y==pos||fa[y]==x) continue;
        dfs2(y,y);
    }
}
inline int lca(re int x,re int y){
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]]) x^=y^=x^=y;
        x=fa[top[x]];
    }
    return dep[x]<dep[y]?x:y;
}
//-----------------------------------------------------------------------------
/*欧拉回路*/
inline void euler(){
    stk[++top]=1;
    while(top){
        re int x=stk[top],i=first[x];
        while(i&&vis[i]) i=edge[i].next;
        if(i){
            stk[++top]=edge[i].v;
            vis[i]=vis[i^1]=1;
            first[x]=edge[i].next;
        }
        else top--,ans[++cnt]=x;
    }
}
for(re int i=cnt;i;--i) printf("%d ",ans[i]);
//-----------------------------------------------------------------------------
/*网络流*/
//最大流EK
int tot=1;//!!!
struct node{int u,v,next,w,c,eg}edge[200010];//w:流量 c:容量
inline void add(re int x,re int y,re int w){
    edge[tot]=(node){x,y,first[x],0,w,cnt+1};
    first[x]=tot++;
    edge[tot]=(node){y,x,first[y],0,0,cnt-1};
    first[y]=tot++;
}
inline void EK(){
    re int ans=0;static queue<int> q;
    while(1){
        for(re int i=1;i<=n;++i) a[i]=0;
        while(!q.empty()) q.pop();    
        q.push(S);pre[S]=0;a[S]=inf;
        while(!q.empty()){
            re int x=q.front();q.pop();
            for(re int i=first[x];i;i=edge[i].next){
                re int y=edge[i].v;
                if(!a[y]&&edge[i].c>edge[i].w){
                    a[y]=min(a[x],edge[i].c-edge[i].w);
                    pre[y]=i,q.push(y);
                }
            }            
            if(a[T]) break;
        }
        if(!a[T]) break;
        for(re int u=T;u!=S;u=edge[pre[u]].u){
            edge[pre[u]].w+=a[T];
            edge[edge[pre[u]].eg].w-=a[T];
        }
        ans+=a[T];    
    }
}
//最大流dinic
int tot=1;//!!!
struct node{int v,next,w,eg}edge[200010];
inline void add(re int x,re int y,re int w){
    edge[tot]=(node){x,y,first[x],w,cnt+1};
    first[x]=tot++;
    edge[tot]=(node){y,x,first[y],0,cnt-1};
    first[y]=tot++;
}
inline bool bfs(){
    for(re int i=1;i<=n;++i) bel[i]=0;
    bel[S]=1;static queue<int> q;
    while(!q.empty()) q.pop();
    q.push(S);
    while(!q.empty()){
        re int x=q.front();q.pop();
        for(re int i=first[x];i;i=edge[i].next){
            re int y=edge[i].v;
            if(edge[i].w&&!bel[y])
                bel[y]=bel[x]+1,q.push(y);
        }
    }
    return bel[T];
}
int dfs(re int s,re int t,re int flow){
    if(s==t||flow==0) return flow;
    re int res=0;
    for(re int i=first[u];i;i=edge[i].next){
        re int y=edge[i].v;
        if(edge[i].w&&bel[y]==bel[u]+1){
            re int dat=dfs(y,T,min(flow,edge[i].w));
            res+=dat; flow-=dat;
            edge[i].w-=dat;edge[edge[i].eg].w+=dat;
        }
    }
    return res;
}
inline int dinic(){
    re int res=0;
    while(bfs()) res+=dfs(S,T,inf);
    return res;
}