【算法总结】图论相关

【最近公共祖先】

〖模板代码〗

  [倍增算法]

void dfs(int k)
{
    for(int i=1;(1<<i)<=deep[k];i++)
        x[k][i]=x[x[k][i-1]][i-1];
    for(int i=head[k];i;i=e[i].next) 
    {
        if(deep[e[i].to])continue;
        x[e[i].to][0]=k;
        deep[e[i].to]=deep[k]+1;
        di[e[i].to]=di[k]+e[i].w;
        dfs(e[i].to);
    }
}
int lca(int ri,int rj)
{
    if(deep[ri]<deep[rj])swap(ri,rj);
    int d=deep[ri]-deep[rj]; 
    for(int i=0;(1<<i)<=d;i++)
        if((1<<i)&d)ri=x[ri][i];
    if(ri==rj)return ri;
    for(int i=16;i>=0;i--)
        if((1<<i)<=deep[rj]&&x[ri][i]!=x[rj][i])
            ri=x[ri][i],rj=x[rj][i];
    return x[ri][0];
}

  [树链剖分]

void dfs1(int x)
{
    sz[x]=1;
    for(int i=first[x];i;i=e[i].next)
    {
        int to=e[i].to;
        deep[to]=deep[x]+1;
        fa[to]=x;
        dfs1(to);sz[x]+=sz[to];
        if(sz[to]>sz[son[x]])son[x]=to;
    }
}
void dfs2(int x)
{
    if(x==son[fa[x]])top[x]=top[fa[x]];
    else top[x]=x;
    for(int i=first[x];i;i=e[i].next)dfs2(e[i].to);
}
int lca(int x,int y)
{
    for(;top[x]!=top[y];deep[top[x]]>deep[top[y]]?x=fa[top[x]]:y=fa[top[y]]);
    return deep[x]<deep[y]?x:y;
}

〖相关题目〗

1.【codevs2370】小机房的树

题意：见原题

分析：见代码

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=50010;
struct point{int from,to,v;}e[maxn*2];
int n,m,cnt,a,b,c;
int head[maxn],deep[maxn],x[maxn][17],di[maxn];
//deep数组表示节点所在的层数，di数组表示节点到根节点的距离 
//x[i][j]的含义为：节点i的祖先中与其相差2^j层的节点；例如，x[i][0]代表节点i的父亲 
bool f[maxn];//判断节点是否访问过 
void add(int a,int b,int c)//邻接表建边 
{cnt++;e[cnt].from=head[a];e[cnt].to=b;e[cnt].v=c;head[a]=cnt;}
void dfs(int k)
{
    f[k]=true;
    for(int i=1;(1<<i)<=deep[k];i++)
        x[k][i]=x[x[k][i-1]][i-1];//递推得出x数组 
    for(int i=head[k];i;i=e[i].from) 
    {
        if(!f[e[i].to])
        {
            x[e[i].to][0]=k;//将节点k标记为e[i].to的父亲 
            deep[e[i].to]=deep[k]+1;//层数+1 
            di[e[i].to]=di[k]+e[i].v;
            dfs(e[i].to);
        }
    }
}
int solve(int ri,int rj)
{
    if(deep[ri]<deep[rj])swap(ri,rj);
    int d=deep[ri]-deep[rj]; 
    for(int i=0;(1<<i)<=d;i++)//利用倍增思想，将ri节点跳到与rj节点同层 
        if((1<<i)&d)ri=x[ri][i];
    if(ri==rj)return ri;//找到最近公共祖先 
    for(int i=16;i>=0;i--)
        if((1<<i)<=deep[rj]&&x[ri][i]!=x[rj][i])
            ri=x[ri][i],rj=x[rj][i];//同时往上跳，直到ri与rj为兄弟节点为止 
    return x[ri][0];//返回他们的父亲 
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<n;i++)
    {
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
        add(b,a,c);
    }
    dfs(0);//此处假设以0为根节点 
    scanf("%d",&m);
    while(m--)
    {
        scanf("%d%d",&a,&b);
        printf("%d
",di[a]+di[b]-2*di[solve(a,b)]);
    }
    return 0;
}

【网络流】

〖相关知识〗

[无源汇有上下界可行流]

模型：给出一个网络，每条边的流量有一个上界 $H_i$ 和一个下界 $L_i$ ，每个点必须满足流量守恒。

分析：首先令每条边的流量等于 $L_i$ ，得到一个不一定满足流量守恒的初始流。令 $a_i$ 表示初始流中点 $i$ 的流入量-流出量。新建附加节点 $SS$ 和 $TT$ ，若 $a_i<0$ ，则新建一条从 $i$ 到 $TT$ 的容量为 $-a_i$ 的边；若 $a_i>0$ ，则新建一条从 $SS$ 到 $i$ 的容量为 $a_i$ 的边。直接跑最大流，若从 $SS$ 出发的所有边都是满流，则存在可行解。原图中每条边的流量为流量下界与附加流之和。

[有源汇有上下界可行流]

分析：从 $T$ 向 $S$ 连一条下界为 $0$ 上界为 $inf$ 的边，即可转化为无源汇有上下界可行流。

[有源汇有上下界最大流]

分析：在残量网络上跑 $S$ 到 $T$ 的最大流。

[有源汇有上下界最小流]

分析：在残量网络上跑 $T$ 到 $S$ 的最大流。

〖模板代码〗

  [最小割]

int cnt=1;
void insert(int u,int v,int w)
{
    e[++cnt]=(edge){v,first[u],w};first[u]=cnt;
    e[++cnt]=(edge){u,first[v],0};first[v]=cnt;
}
bool bfs()
{
    memset(dis,-1,sizeof(dis));
    int head=0,tail=1;
    q[head]=S;dis[S]=0;
    while(head!=tail)
    {
        int u=q[head++];
        for(int i=first[u];i;i=e[i].next)
        {
            int v=e[i].to;
            if(dis[v]!=-1||!e[i].flow)continue;
            dis[v]=dis[u]+1;
            q[tail++]=v;
        }
    }
    return dis[T]!=-1;
}
int dfs(int u,int a)
{
    if(u==T||a==0)return a;
    int f,flow=0;
    for(int& i=cur[u];i;i=e[i].next)
    {
        int v=e[i].to;
        if(dis[v]==dis[u]+1&&(f=dfs(v,min(e[i].flow,a)))>0)
        {
            e[i].flow-=f;e[i^1].flow+=f;
            flow+=f;a-=f;if(a==0)break;
        }
    }
    return flow;
}
int main()
{
    while(bfs())
    {
        for(int i=S;i<=T;i++)cur[i]=first[i];
        ans+=dfs(S,inf);
    }
    return 0;
}

  [最小费用最大流]

bool spfa()
{
    memset(inq,0,sizeof(inq));memset(dis,0x3f,sizeof(dis));
    int head=0,tail=1;q[0]=T;inq[T]=true;dis[T]=0;
    while(head!=tail)
    {
        u=q[head++];inq[u]=false;if(head>5000)head=0;
        for(int i=first[u];i;i=e[i].next)
        {
            v=e[i].to;
            if(e[i^1].flow>0&&dis[u]+e[i^1].cost<dis[v])
            {
                dis[v]=dis[u]+e[i^1].cost;
                if(!inq[v])
                {
                    if(dis[v]<dis[q[head]]){head--;if(head<0)head=5000;q[head]=v;}
                    else{q[tail++]=v;if(tail>5000)tail=0;}
                    inq[v]=true;
                }
            }
        }
    }
    return dis[S]<inf;
}
int dfs(int u,int a)
{
    if(u==T||a==0)return a;
    inq[u]=true;int f,flow=0;
    for(int& i=cur[u];i;i=e[i].next)
    {
        v=e[i].to;
        if(!inq[v]&&dis[u]==e[i].cost+dis[v]&&(f=dfs(v,min(e[i].flow,a)))>0)
        {
            e[i].flow-=f;e[i^1].flow+=f;
            ans+=e[i].cost*f;flow+=f;a-=f;if(a==0)break;
        }
    }
    return flow;
}

〖相关题目〗

1.【codevs1993】草地排水

题意：见原题

分析：见代码

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
int n,m,a,b,c,ans=0,ansn;
int map[210][210],dis[210];//邻接矩阵储存图，dis数组储存分层后节点深度 
bool bfs()//广搜建立层次图 
{
    queue<int>q;
    memset(dis,-1,sizeof(dis));
    q.push(1);
    dis[1]=0;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=1;i<=n;i++)
            if(map[u][i]>0&&dis[i]<0)//从顶点u到顶点i的边容量不为0且节点i未被访问过 
                q.push(i),dis[i]=dis[u]+1;//层数+1，并将顶点i丢进广搜队列 
    }
    if(dis[n]<0)return false;//如果汇点不在层次图上，则算法结束 
    return true;
}
int find(int k,int low)//在层次图上进行增广 
{
    int s;
    if(k==n||low==0)return low;
    for(int i=1;i<=n;i++)
        if(map[k][i]&&dis[i]==dis[k]+1&&(s=find(i,min(low,map[k][i]))))
            {map[k][i]-=s;map[i][k]+=s;return s;}
    return 0;
}
int main()
{
    scanf("%d%d",&m,&n);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&a,&b,&c);
        map[a][b]+=c;
    }
    while(bfs())
        ans+=find(1,99999999);
    printf("%d",ans);
    return 0;
}

【二分图匹配】

〖相关资料〗

《二分图匹配》

〖相关知识〗

点覆盖：对于图中所有的边，至少有一个端点属于该点集；最小点覆盖=最大匹配。

边覆盖：对于图中所有的点，该边集中至少有一条边以其为顶点；最小边覆盖=总点数-最大匹配。

独立集：该点集中任意两点之间都不存在边；最大独立集=总点数-最小点覆盖。

有向无环图最小不相交路径覆盖：用最少的不相交路径覆盖所有顶点；原图每个点i拆成i₁与i₂，若原图中如果存在边 (x, y)，那么就连接x₁, y₂，原图的最小路径覆盖=原图总点数 n - 二分图最大匹配 。

有向无环图最小可相交路径覆盖：用最少的可相交路径覆盖所有顶点；将原图做一次Floyd传递闭包，如果两个点x 可以到达 y，连接x₁, y₂，将问题转化为最小不相交路径覆盖。

链：链上任意两个点x, y，满足x 能到达y或y能到达x。

反链：链上任意两个点x, y互不可达；最长反链长度=最小链覆盖=有向无环图最小可相交路径覆盖；最长链长度 = 最小反链覆盖。

〖模板代码〗

int push(int x)
{
    for(int i=1;i<=m;i++)
        if(!f[i]&&map[x][i])
        {
            f[i]=true;
            if(link[i]==-1||push(link[i]))
            {
                link[i]=x;
                return 1;
            }
        }
    return 0;
}

〖相关题目〗

1.【codevs2776】寻找代表元

题意：见原题

分析：无

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int n,m,link[210],to,ans;
bool map[210][210],f[210];//邻接矩阵储存 
int push(int x)
{
    for(int i=1;i<=m;i++)
    {
        if(!f[i]&&map[x][i])
        {
            f[i]=true;
            if(link[i]==-1||push(link[i]))
            {
                link[i]=x;
                return 1;
            }
        }
    }
    return 0;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        while(1)
        {
            scanf("%d",&to);
            if(!to)break;
            map[i][to]=true;
        }
    memset(link,-1,sizeof(link));
    for(int i=1;i<=n;i++)
    {
        memset(f,0,sizeof(f));
        ans+=push(i);
    }
    printf("%d",ans);
    return 0;
}

2.【bzoj1143】[CTSC2008]祭祀river

题意：给定一个有向无环图，求出最大的点集，使得点集中的点两两不可达。

分析：JoeFanの博客

#include<cstdio>
#include<cstring>
#include<algorithm>
#define ll long long
using namespace std;
int n,m,u,v,ans,link[205];
bool map[205][205],f[205];
int read()
{
    int x=0,f=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}
int push(int x)
{
    for(int i=n+1;i<=2*n;i++)
    {
        if(!f[i]&&map[x][i])
        {
            f[i]=true;
            if(link[i]==-1||push(link[i]))
                {link[i]=x; return 1;}
        }
    }
    return 0;
}
int main()
{
    n=read();m=read();
    for(int i=1;i<=m;i++)
    {
        u=read();v=read();
        map[u][v]=true;
    }
    for(int k=1;k<=n;k++)
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                if(map[i][k]&&map[k][j])map[i][j]=true;
    for(int i=1;i<=n;i++)map[i][i]=false;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            if(map[i][j])map[i][j+n]=true,map[i][j]=false;
    memset(link,-1,sizeof(link));
    for(int i=1;i<=n;i++)
    {
        memset(f,0,sizeof(f));
        ans+=push(i);
    }
    printf("%d
",n-ans);
    return 0;
}

【最小生成树】

〖模板代码〗

int find(int t){return f[t]==t?t:f[t]=find(f[t]);}
int main()
{
    n=read();m=read();
    for(int i=1;i<=n;i++)f[i]=i;
    for(int i=1;i<=m;i++)e[i].x=read(),e[i].y=read(),e[i].w=read();
    sort(e+1,e+m+1,cmp);
    for(int i=1;i<=m;i++)
    {
        x=find(e[i].x);y=find(e[i].y);
        if(x==y)continue;
        f[x]=y;ans+=e[i].w;num++;
        if(num==n-1)break;
    }
    if(num==n-1)printf("%d",ans);
    else printf("-1");
    return 0;
}

【最短路】

〖模板代码〗

struct node{int id;LL d;bool operator <(const node& a)const{return d>a.d;}};
priority_queue<node>q;
void ins(int u,int v,int w){e[++cnt]=(edge){v,first[u],w};first[u]=cnt;}
int main()
{
    for(int i=1;i<=n;i++)dis[i]=inf;
    dis[S]=0;q.push((node){S,0});
    while(!q.empty())
    {
        node t=q.top();q.pop();u=t.id;
        if(dis[t.id]!=t.d)continue;
        for(int i=first[u];i;i=e[i].next)
            if(dis[e[i].to]>dis[u]+e[i].w)
                dis[e[i].to]=dis[u]+e[i].w,q.push((node){e[i].to,dis[e[i].to]});
    }
}

【有向图的强连通分量】

〖模板代码〗

void tarjan(int x)
{
    low[x]=dfn[x]=++tim;
    sta[++top]=x;vis[x]=true;
    for(int i=first[x];i;i=e[i].next)
    {
        int to=e[i].to;
        if(!dfn[to])tarjan(to),low[x]=min(low[x],low[to]=min(low[x],low[to]));
        else if(vis[to])low[x]=min(low[x],dfn[to]);
    }
    if(low[x]==dfn[x])
    {
        color++;
        while(sta[top]!=x)vis[sta[top]]=false,c[sta[top--]]=color;
        vis[x]=false;c[x]=color;top--;
    }
}
int main()
{
    for(int i=1;i<=n;i++)if(!dfn[i])tarjan(i);
    return 0;
}

【无向图的点双连通分量】

〖模板代码〗

#include<cstdio>
#include<algorithm> 
#include<cstring>
#define LL long long
using namespace std;
const int N=1e5+5;
int n,m,x,y,cnt=1,tim,ans;
int first[N],dfn[N],low[N];
bool iscut[N];
struct edge{int to,next;}e[N*2];
int read()
{
    int x=0,f=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
} 
void ins(int u,int v){e[++cnt]=(edge){v,first[u]};first[u]=cnt;}
void tarjan(int x,int fa)
{
    dfn[x]=low[x]=++tim;
    int son=0;
    for(int i=first[x];i;i=e[i].next)
    {
        int to=e[i].to;
        if(to==fa)continue;
        if(!dfn[to])
        {
            son++;tarjan(to,x);
            low[x]=min(low[x],low[to]);
            if(low[to]>=dfn[x])iscut[x]=true;
        }
        else low[x]=min(low[x],dfn[to]);
    }
    if(fa<0&&son<=1)iscut[x]=false;
}
int main()
{
    n=read();m=read();
    for(int i=1;i<=m;i++)
    {
        x=read();y=read();
        ins(x,y);ins(y,x);
    }
    for(int i=1;i<=n;i++)
        if(!dfn[i])tarjan(i,-1);
    for(int i=1;i<=n;i++)
        if(iscut[i])ans++;
    printf("%d
",ans);
    for(int i=1;i<=n;i++)
        if(iscut[i])printf("%d ",i);
    return 0;
}