對酒當歌,人生幾何? 譬如朝露,去日苦多

分类 ACM算法 下的文章

这里有几个点需要注意
1.为什么无向图缩点需要变成有向图缩点?
无向图两两之间的点可以到达,无法跑回边的话,就跑不到父节点以上的节点了,那么肯定是桥了。
2.为什么不能跑回边,而不是跑父节点?
本来是个无向图单连通,但是你阻止了父节点跑回去,那就不是无向图单连通了。
但是这个题去重也对,嗯。。。数据弱

#include<stdio.h>
#include<string.h>
#include<string>
#include<iostream>
#include<algorithm>
#define mem(a,b) memset(a,b,sizeof(a))
#define LL long long
using namespace std;
const int maxn=10005;

struct node
{
    int u,v,nex;
} e[maxn*maxn];
int first[maxn];
int tot;
int n,m;
int ans,din,top;
int dfn[maxn],low[maxn],Stack[maxn],in[maxn];
int belong[maxn];
void init()
{
    mem(first,-1);
    tot=0;
    din=1;
    ans=0;
    top=0;
    mem(dfn,0);
    mem(low,0);
    mem(Stack,0);
    mem(in,0);
    mem(belong,0);
}
void edge(int u,int v)
{
    e[tot].u=u;
    e[tot].v=v;
    e[tot].nex=first[u];
    first[u]=tot++;
}
void tarjan(int u,int id)
{
    dfn[u]=low[u]=++din;
    Stack[top++]=u;
    in[u]=1;
    int v;
    for(int i=first[u]; i!=-1; i=e[i].nex)
    {
        v=e[i].v;
        if(i==(id^1))
            continue;
        if(!dfn[v])
        {
            tarjan(v,i);
            low[u]=min(low[u],low[v]);
        }
        else if(in[v])
        {
            low[u]=min(low[u],low[v]);
        }
    }
    if(dfn[u]==low[u])
    {
        ans++;
        do
        {
            v=Stack[--top];
            in[v]=0;
            belong[v]=ans;
            //printf("%d\n",ans);
        }
        while(v!=u);
    }
}
void scc()
{
    for(int i=1; i<=n; i++)
    {
        if(!dfn[i])
            tarjan(i,-1);
    }
    //printf("%d\n",ans);
    int sum=0;
    int k=0;
    int aa[maxn],gg[maxn];
    mem(aa,0);
    mem(gg,0);
    for(int i=0; i<tot; i+=2)
    {
        int u=e[i].u;
        int v=e[i].v;
        if(belong[u]!=belong[v])
        {
            //printf("%d %d\n",belong[u],belong[v]);
            aa[belong[u]]++;
            aa[belong[v]]++;
        }
    }
    for(int i=1; i<=ans; i++)
    {
        if(aa[i]==1) sum++;
    }
    printf("%d\n",(sum+1)/2);
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        init();
        for(int i=0; i<m; i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
//            int flag=0;
//            for(int j=first[u]; j!=-1; j=e[j].nex)
//            {
//                int to=e[j].v;
//                if(v==to)
//                {
//                    flag=1;
//                    break;
//                }
//            }
//            if(flag==1) continue;
            edge(u,v);
            edge(v,u);
        }
        scc();
    }
}

 

博客推荐

与割点的最大不同之处:low[v]>low[u]

易错点:

1.父亲节点与子节点区别一下,防止两个点误认为环。

2.去重边

#include<stdio.h>
#include<string.h>
#include<string>
#include<iostream>
#include<algorithm>
#define mem(a,b) memset(a,b,sizeof(a))
#define LL long long
using namespace std;
const int maxn=10005;
int n,m;
struct node2
{
    int x,y;
} ee[maxn*maxn];
int cmp(node2 a,node2 b)
{
    if(a.x==b.x)
        return a.y<b.y;
    else
        return a.x<b.x;
}
struct node
{
    int v,nex;
} e[maxn*maxn];
int first[maxn];
int tot,top,ans,din,cnt;
int dfn[maxn],low[maxn],Stack[maxn],in[maxn];
int son,flag[maxn];
void init()
{
    mem(first,-1);
    tot=0;
    top=0;
    din=0;
    son=0;
    ans=0;
    cnt=0;
    mem(dfn,0);
    mem(low,0);
    mem(Stack,0);
    mem(in,0);
    mem(flag,0);
}
void edge(int u,int v)
{
    e[tot].v=v;
    e[tot].nex=first[u];
    first[u]=tot++;
}
void tarjan(int u,int vv)
{
    dfn[u]=low[u]=++din;
    Stack[top++]=u;
    in[u]=1;
    int v;
    for(int i=first[u]; i!=-1; i=e[i].nex)
    {

        v=e[i].v;
        if(i==(vv^1)) continue;
        if(!dfn[v])
        {
            tarjan(v,i);
            low[u]=min(low[u],low[v]);
            //printf("       %d %d\n",low[v],dfn[u]);
            if(low[v]>dfn[u])
            {
                ee[cnt].x=v;
                ee[cnt].y=u;
                if(v>u)
                    swap(ee[cnt].x,ee[cnt].y);
                cnt++;
            }
        }
        else if(in[v]&&low[u]>dfn[v])
        {
            //printf("       %d %d\n",u,v);
            low[u]=dfn[v];
        }
    }//printf("sdfa\n");
}

int main()
{
    int tt=1;
    while(~scanf("%d",&n))
    {
        if(n==0)
        {
            printf("0 critical links\n\n");
            continue;
        }
        init();
        int u,v,k;
        for(int i=0; i<n; i++)
        {
            scanf("%d (%d)",&u,&k);
            for(int j=0; j<k; j++)
            {
                scanf("%d",&v);
                int flag=0;
                for(int j=first[u]; j!=-1; j=e[j].nex)
                {
                    int qq=e[j].v;
                    if(qq==v)
                    {
                        flag=1;
                        break;
                    }
                }
                if(flag==1) continue;
                //printf("%d %d\n",u,v);
                edge(u,v);
                edge(v,u);
            }
        }
        for(int i=0; i<n; i++)
        {
            if(!dfn[i])
                tarjan(i,-1);
        }
        sort(ee,ee+cnt,cmp);
        printf("%d critical links\n",cnt);
        for(int i=0; i<cnt; i++)
        {
            printf("%d - %d\n",ee[i].x,ee[i].y);
        }
        printf("\n");
    }
    return 0;
}

 

先学tarjan算法,再学割点,优质博客 .

割点也就是把此点去掉后,使无向强连通图至少变成2部分。

1.哪些点是割点?

2.此割点把图割成了几部分?

第一个问题:1.如果根有两个或两个以上的树,那么此点必为割点。

2.如果u不是根节点,它有一个子节点v,并且以v为根节点的子树中,没有一个顶点有通向任意一个u的祖先的回边。

第二个问题:就是去点此割点,然后求并查集。

#include<stdio.h>
#include<string.h>
#include<string>
#include<iostream>
#include<algorithm>
#define mem(a,b) memset(a,b,sizeof(a))
#define LL long long
using namespace std;
const int maxn=200;
int n,m;
struct node
{
    int v,nex;
} e[maxn*maxn];
int first[maxn];
int tot,top,ans,din;
int dfn[maxn],low[maxn],Stack[maxn],in[maxn];
int son,flag[maxn];
void init()
{
    mem(first,-1);
    tot=0;
    top=0;
    din=0;
    son=0;
    ans=0;
    mem(dfn,0);
    mem(low,0);
    mem(Stack,0);
    mem(in,0);
    mem(flag,0);
}
void edge(int u,int v)
{
    e[tot].v=v;
    e[tot].nex=first[u];
    first[u]=tot++;
}
void tarjan(int u)
{
    dfn[u]=low[u]=++din;
    Stack[top++]=u;
    in[u]=1;
    int v;
    for(int i=first[u]; i!=-1; i=e[i].nex)
    {

        v=e[i].v;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
            //printf("       %d %d\n",low[u],low[v]);
            if(u!=1&&low[v]>=dfn[u])
            {

                flag[u]=1;
            }
            else if(u==1)
                son++;
        }
        else if(in[v]&&low[u]>dfn[v])
        {
            //printf("       %d %d\n",u,v);
            low[u]=dfn[v];
        }
    }//printf("sdfa\n");
    if(dfn[u]==low[u])
    {
        ans++;
        do
        {
            v=Stack[--top];
            in[v]=0;
            //belong[v]=ans;
            //printf("%d ",v);
        }
        while(v!=u);
        //printf("\n");
    }
}

int main()
{
    while(~scanf("%d",&n)&&n)
    {
        init();
        int u,v;
        while(scanf("%d",&u)&&u)
        {
            while(getchar()!='\n')
            {
                scanf("%d",&v);
                //printf("       %d %d\n",u,v);
                edge(u,v);
                edge(v,u);
            }
        }
        tarjan(1);
        int sum=0;
        for(int i=2;i<=n;i++)
        {
            if(flag[i]) sum++;
        }
        if(son>1) sum++;
        printf("%d\n",sum);
    }
    return 0;
}

 

1.求至少选几个点作为起点走遍全图(也就是这几个点走的路加起来走遍全图)?

2.求最小加多少边能使图变成强连通图?

tarjan缩点求入度为0的点为第一个题的答案,求max(入度为0的点,出度为0的点)为第二个题的答案。

tarjan缩点方法最后给出代码。

疑问:

1.缩点之后的入度为0的点数量为什么为第一问的答案?

入度为0,也就是没有点能够到达它,它也就是起点。但是入度不为0的点,总有点能够到达它。

2.为什么max(入度为0的点,出度为0点)为第二问的答案?

想让此图变成强连通图,就要消除起点和终点,那么就要取他们的最大值。

 

缩点最好用染的颜色缩点,由我前面的文章可知,一个连通分量的值不一定相等。

然而有些题却能用low值过,嗯。。。。数据弱

#include<stdio.h>
#include<string.h>
#include<string>
#include<iostream>
#include<algorithm>
#define mem(a,b) memset(a,b,sizeof(a))
#define LL long long
using namespace std;
const int maxn=105;
int n,m;
struct node
{
    int v,nex;
} e[maxn*maxn];
int first[maxn];
int tot,top,ans,din;
int dfn[maxn],low[maxn],Stack[maxn],in[maxn];
int belong[maxn],out[maxn];
void init()
{
    mem(first,-1);
    tot=0;
    top=0;
    ans=0;
    din=0;
    mem(dfn,0);
    mem(low,0);
    mem(Stack,0);
    mem(in,0);
}
void edge(int u,int v)
{
    e[tot].v=v;
    e[tot].nex=first[u];
    first[u]=tot++;
}
void tarjan(int u)
{
    dfn[u]=low[u]=++din;
    Stack[top++]=u;
    in[u]=1;
    int v;
    for(int i=first[u]; i!=-1; i=e[i].nex)
    {

        v=e[i].v;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(in[v]&&low[u]>dfn[v])
        {
            low[u]=dfn[v];
        }
    }//printf("sdfa\n");
    if(dfn[u]==low[u])
    {
        ans++;
        do
        {
            v=Stack[--top];
            in[v]=0;
            belong[v]=ans;
            //printf("%d ",v);
        }
        while(v!=u);
        //printf("\n");
    }
}
void scc()
{
    for(int i=1; i<=n; i++)
    {
        if(!dfn[i])
            tarjan(i);
    }
    if(ans==1)
    {
        printf("1\n0\n");
        return ;
    }
    mem(in,0);
    mem(out,0);
    int ans1=0,ans2=0;
    for(int i=1;i<=n;i++)
    {
        for(int j=first[i];j!=-1;j=e[j].nex)
        {
            int v=e[j].v;
            //printf("    %d %d\n",i,v);
            if(belong[i]!=belong[v])
            {
                in[belong[v]]++;
                out[belong[i]]++;
            }
        }
    }
    for(int i=1;i<=ans;i++)
    {
        //printf("%d \n",in[i]);
        if(in[i]==0) ans1++;
        if(out[i]==0) ans2++;
    }
    printf("%d\n%d\n",ans1,max(ans1,ans2));
}
int main()
{
    while(~scanf("%d",&n))
    {
        init();
        for(int i=1;i<=n;i++)
        {
            while(1)
            {
                int v;
                scanf("%d",&v);
                if(v==0)
                    break;
                //printf("      %d %d\n",i,v);
                edge(i,v);
            }
        }
        scc();
    }
    return 0;
}

 

过程我就不多说了,百度一下,一堆博客。

我参照kuangbin的板子和hdu1269学的基础。

只会敲板子是非常不开心的,所以我自己想了想过程为什么这样写,以下纯属个人理解,如果有错,欢迎指出。

1.我就想为什么在一个连通内只有一个节点dfn[i]==low[i]?

借鉴此博客理解

答:由于位于同一个连通内,所以任意两个节点可以相互到达,那么两者的low值一定会被另一个所影响(要看谁的low最小),所以不可能存在两对dfn和low的值相等。但是一个连通图内的low值不一定都相等(例如3个点,6条边,1-2,2-1,2-3,3-2,3-4,4-3,自己去试试就知道了)。

2.为什么low值要取最小的,最大的不可以吗?

答:对于一个连通图,我们很容易想到,在该连通图中有且仅有一个节点u的DFN值和low值相等。该节点一定是在深度遍历的过程中,该节点为连通图中第一个被访问过的节点,因为它的dfn值和low值最小,不会被其他节点影响。最大的话,出栈那里就不对了。

我们的一个连通图在栈中是根节点在最下面,也是最小的low,那么以这个为区分其他强连通分量具有重要意义,所以我们取最小。

3.这个连通图内所有的点一定都可以low一定可以取最小值吗?

借鉴此博客理解

答:dfs过程中只会遇到这四种边

树枝边:DFS 时经过的边,即 DFS 搜索树上的边

前向边:与 DFS 方向一致,从某个结点指向其某个子孙的边

后向边:与 DFS 方向相反,从某个结点指向其某个祖先的边

横叉边:从某个结点指向搜索树中另一子树中的某结点的边

第一种边是对各个点赋dfn和low的值的遍历

第二种边在回溯的时候会进行最小处理(min(自身,子节点))

第三种边会与祖先进行最小处理(min(自身,祖先))

第四种边不是这个强连通的边,不在这个问题考虑之内。

那么dfs后,一个强连通分量的low一定会是最小的。

易错点:

1.记录访问顺序时,++din,din++可能导致记录的深度为0,我的判断条件有误。