HDU3594 Cactus 判断是否为仙人掌图 难度中

这道题目挺有意思，amb大牛还发了那个强大的仙人掌图剖析的pdf,自己yy了一种解法，由于HDU上的数据够弱，

暂时没有发现自己的代码有啥错误的。网上各种代码错误，还各种ac了~~这道题的数据，汗~~

可以测测这一组数据：

1
4
0 1
1 2
2 0
2 3
3 2
3 0
0 0

正确输出：no

/*
*State: HDU3594 78MS 2644K 3134 B C++ 
*题目大意：
*        给一个有向图，判断这个有向图是否为仙人掌图。
*        仙人掌图满足：1、是强连通图 2、每条边都只属于一个环
*解题思路：
*        判断强连通比较好做，主要是要判断每条边都属于一个环。
*        我想到了用块来判断，但是只用块判断过无向图，但是用笔模拟
*        了下，感觉有向图跟无向图都是一样的判断。
*        就保存了有向图跟无向图，想想一个强连通图是仙人掌图，那么
*        它从无向图上看一定是多个块之间靠一个点连接起来。那么好做
*        把它保存为无向图，然后求块，判断每个块中边的个数是否等于
*        块中点的个数，即可判断是否每条边只属于一个环。
*解题感想；
*        1a了，没想到这么神奇，看来专注是必须的。
*        这道题目的数据比较水，该方法还有待验证。
*        该题值得慢慢品味
*/

#include <iostream>
using namespace std;

const int MAXN = 20005;
const int MAXE = 50005;

typedef struct _node
{
    int v, next, isdir;
    _node() :isdir(0) {};
}N;

N edge[MAXE * 2];
int head[MAXN], cntEdge, myS[MAXN], top;
int inS[MAXN], isScc;

int bMyS[MAXN], bTop;
int low[MAXN], dfn[MAXN], step;

int block[MAXN], isOneCir;

void init()
{
    top = bTop = 0;
    cntEdge = 0;
    isScc = false;
    isOneCir = true;
    for(int i = 0; i < MAXN; i++)
    {
        inS[i] = 0;
        head[i] = -1;
    }
}

void addEdge(int u, int v)
{
    edge[cntEdge].v = v;
    edge[cntEdge].isdir = 1;
    edge[cntEdge].next = head[u];
    head[u] = cntEdge++;

    edge[cntEdge].v = u;
    edge[cntEdge].next = head[v];
    edge[cntEdge].isdir = 0;
    head[v] = cntEdge++;
}

void tarjan_scc(int n, int toln)
{
    dfn[n] = low[n] = ++step;
    myS[top++] = n;
    inS[n] = 1;
    for(int f = head[n]; f != -1; f = edge[f].next)
    {
        if(!edge[f].isdir)
            continue;
        int son = edge[f].v;
        if(dfn[son] == -1)
        {
            tarjan_scc(son, toln);
            low[n] = min(low[n], low[son]);
        }
        else if(inS[son] == 1)
            low[n] = min(low[n], dfn[son]);
    }
    if(low[n] == dfn[n] && top != 0)
    {
        int _cnt = 0;
        int tmp;
        do
        {
            tmp = myS[--top];
            _cnt++;
        }while(top != 0 && tmp != n);
        if(_cnt == toln)
            isScc = true;
    }
}

void judge()
{
    int vst[MAXN] = {0};
    for(int i = 1; i <= block[0]; i++)
    {
        vst[block[i]] = 1;
    }
    int u, v, sum = 0;
    for(int i = 1; i <= block[0]; i++)
    {
        u = block[i];
        for(int f = head[u]; f != -1; f = edge[f].next)
        {
            v = edge[f].v;
            if(vst[v])
                sum++;
        }
    }
    sum /= 2;
    if(isOneCir == true && sum != block[0])
        isOneCir = false;
}

//求块
void tarjan_block(int n)
{
    dfn[n] = low[n] = ++step;
    bMyS[bTop++] = n;

    for(int f = head[n]; f != -1; f = edge[f].next)
    {
        int son = edge[f].v;
        if(dfn[son] == -1)
        {
            tarjan_block(son);
            low[n] = min(low[n], low[son]);

            if(low[son] >= dfn[n])
            {
                block[0] = 0;
                int tmp;
                while(true)
                {
                    tmp = bMyS[bTop - 1];
                    block[++block[0]] = tmp;
                    if(bMyS[--bTop] == son)
                        break;
                }
                block[++block[0]] = n;
                judge();
            }
        }
        else
            low[n] = min(low[n], dfn[son]);
    }
}

int main(void)
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif

    int cas;
    scanf("%d", &cas);
    while(cas--)
    {
        init();
        int n, u, v;
        scanf("%d", &n);
        while(scanf("%d %d", &u, &v), u || v)
        {
            addEdge(u, v);
        }
        for(int i = 0; i < MAXN; i++)
            dfn[i] = low[i] = -1;
        step = 0;
        tarjan_scc(0, n);

        //强连通才继续判断
        for(int i = 0; i < MAXN; i++)
            dfn[i] = low[i] = -1;
        step = 0;

        if(isScc)
            tarjan_block(0);

        if(isScc && isOneCir)
            printf("YES\n");
        else
            printf("NO\n");
    }
    return 0;
}