单向连通图 Going from u to v or from v to u? poj2762

 

http://poj.org/problem?id=2762

 

强连通求子图和子图关系 + 子图关系是链式结构

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <iostream>
using namespace std;
#define ll long long

const double eps=1e-8;
const ll inf=1e9;
const ll mod=1e9+7;
const int maxn=1e3+10;

struct node
{
    int d;
    node *to;
}*e[maxn];

bool vis[maxn];

int num,cnt_st,st[maxn],dfn[maxn],low[maxn],cnt_group,group[maxn],cnt_single,gx[maxn],gy[maxn];
bool vis_st[maxn],ifok;

void tarjan(int d)
{
    dfn[d]=low[d]=++num;
    vis[d]=1;
    st[++cnt_st]=d;
    node *p=e[d];
    while (p)
    {
        if (!vis[p->d])
        {
            tarjan(p->d);
            low[d]=min(low[d],low[p->d]);
        }
        else if (!vis_st[p->d])
            low[d]=min(low[d],dfn[p->d]);
        p=p->to;
    }
    if (dfn[d]==low[d])
    {
        cnt_group++;
        while (d!=st[cnt_st])
        {
            group[st[cnt_st]]=cnt_group;
            vis_st[st[cnt_st]]=1;
            cnt_st--;
        }
        group[st[cnt_st]]=cnt_group;
        vis_st[st[cnt_st]]=1;
        cnt_st--;
    }
}

int main()
{
    node *p;
    int T,n,m,x,y,i;
    scanf("%d",&T);
    while (T--)
    {
        scanf("%d%d",&n,&m);
        for (i=1;i<=n;i++)
            e[i]=NULL;

        while (m--)
        {
            scanf("%d%d",&x,&y);
            p=new node();
            p->d=y;
            p->to=e[x];
            e[x]=p;
        }

        memset(vis,0,sizeof(vis));
        memset(vis_st,0,sizeof(vis_st));
        num=0,cnt_st=0,cnt_group=0;
        for (i=1;i<=n;i++)
            if (!vis[i])
                tarjan(i);

        /*
        if all are ok:需要的是链式结构
        1.对于一个子图，最多只有一个子图指向它，最多只有一个子图被它指向(非头结点)
        2.有且只有一个子图，没有子图指向它(头结点)
        */

        ifok=1,cnt_single=0;
        memset(gx,0,sizeof(gx));
        memset(gy,0,sizeof(gy));
        for (i=1;i<=n;i++)
        {
            p=e[i];
            while (p)
            {
                ///i -> p->d
                if (group[p->d]!=group[i])
                {
                    if (gx[group[p->d]]==0)
                        gx[group[p->d]]=group[i];
                    else if (gx[group[p->d]]!=group[i])
                        ifok=0;

                    if (gy[group[i]]==0)
                        gy[group[i]]=group[p->d];
                    else if (gy[group[i]]!=group[p->d])
                        ifok=0;
                }
                p=p->to;
            }
        }
        for (i=1;i<=cnt_group;i++)
            if (!gx[i])
                cnt_single++;

        printf("%s\n",(ifok&(cnt_single==1))?"Yes":"No");
    }
    return 0;
}
/*
10
3 2
1 2
3 2

4 3
1 2
2 3
3 1

3 3
1 2
2 3
3 1

5 4
1 2
2 3
3 4
4 5

3 2
1 2
1 3

3 2
1 2
3 2

4 3
1 2
2 3
3 1

3 3
1 2
2 3
3 1

5 4
1 2
2 3
3 4
4 5

3 2
1 2
1 3
*/

 

Advance:如何判断两个结点是否属于同一个单向连通子图（就是是否可以从x到y或者从y到x）[多组数据]

强连通图，同一个集合内的点，可以互相到达

拓扑结构，point a in group x, point b in group y,如x能到达y，则a能到b，但b不能到a。

其它情况下，两者均不能到达对方。

 

在拓扑结构中，一个点也许有多个孩子，多个祖先。

没有想到什么好的方法。。。不过感觉应该有。

 

TLE代码

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <iostream>
using namespace std;
#define ll long long
//#include <map>

const double eps=1e-8;
const ll inf=1e9;
const ll mod=1e9+7;
const int maxn=1e3+10;

struct node
{
    int d;
    node *to;
}*e[maxn];

bool vis[maxn],f[maxn][maxn];
int c,q[maxn];

//void dfs(int d)
//{
//    vis[d]=1;
//    f[c][d]=1;
//    node *p=e[d];
//    while (p)
//    {
//        if (!vis[p->d])
//            dfs(p->d);
//        p=p->to;
//    }
//}

//map<int,int> ma;

int main()
{
    node *p;
    int T,n,m,x,y,i,j;
    int head,tail,d;
    int num;
    bool v;
    scanf("%d",&T);
    while (T--)
    {
        scanf("%d%d",&n,&m);
        for (i=1;i<=n;i++)
            e[i]=0;
//        ma.clear();
        num=0;
        while (m--)
        {
            scanf("%d%d",&x,&y);
//            if (ma.find(x)!=ma.end())
//                x=ma[x];
//            else
//                ma[x]=++num,x=num;
//            if (ma.find(y)!=ma.end())
//                y=ma[y];
//            else
//                ma[y]=++num,y=num;


            p=new node();
            p->d=y;
            p->to=e[x];
            e[x]=p;
        }
        for (c=1;c<=n;c++)
        {
//            memset(vis,0,sizeof(vis));
//            dfs(c);

            q[1]=c;
            vis[c]=1;
            head=0,tail=1;
            while (head<tail)
            {
                head++;
                d=q[head];
                p=e[d];
                while (p)
                {
                    if (!vis[p->d])
                    {
                        vis[p->d]=1;
                        q[++tail]=p->d;
                        f[c][p->d]=1;
                    }
                    p=p->to;
                }
            }
            for (j=1;j<=tail;j++)
                vis[q[j]]=0;
        }

        v=1;
        for (i=1;i<=n;i++)
            for (j=i+1;j<=n;j++)
                if (!f[i][j] && !f[j][i])
                    v=0;
        printf("%s\n",v?"Yes":"No");
    }
    return 0;
}