【模板】仙人掌的基本概念和判定

本文参考并转自：

https://blog.csdn.net/houserabbit/article/details/38874549

https://blog.csdn.net/kksleric/article/details/7870398

https://blog.csdn.net/creationaugust/article/details/48007069

• 什么是仙人掌? 仙人掌是不含自环的,一条边最多属于一个简单环的无向连通图. 从定义不难看出树其实也是仙人掌的一种,也就是说这几个概念的关系大概是: 树是一种特殊的仙人掌,仙人掌是一类特殊的无向连通图.

• 对于树我们都很熟悉,那么能不能想办法把仙人掌看成一棵树呢? 办法是有的.仙人掌上最讨厌的就是环.但是我们注意到仙人掌上不可能存在环与其他环有重边,这就好办了,我们可以把环看成类似树上的节点的东西,只是这个节点包含了更大的信息量.(注意只是类似,和真正树上的节点是不一样的!)

仿照树相关的定义,我们可以对仙人掌定义仙人掌上的节点的父亲和环的父亲. 对于仙人掌上的节点,它的父亲是可能存在多种可能的.

• 如果它到根的路径上与它相邻的是一条简单路径而不是环,那么这个节点的父亲和平常树上节点的父亲是没什么区别的, 它的父亲是它到根的简单路径上经历的第二个点。

• 如果它到根节点路径上与它相邻的是个环,则将其到根的路径上经历的第一条边所在的环当做其父亲.

对于环,我们将它的父亲定义为一个环上离根最近的点. 相对的那么就出现了儿子关系了.

对于仙人掌上的节点,它的儿子显然可以是环可以是普通节点. 但是对于环的儿子,则是环上除掉这个环的父亲以外的其他所有节点

怎样进行仙人掌的遍历和节点信息的确定呢? 依然是从根节点开始DFS.

• 如果我们将要访问一个节点,而这个节点之前还没有被访问过,那么我们直接把这个节点的父亲设为当前节点就行了.(从环和节点的父亲的定义上看这样显然没问题)

• 那么如果我们将要访问的那个节点已经被访问过了呢?显然这时候出现了环. 那么就有两种情况: 1.现在我们假设我们正在访问的节点为x,将要访问的那个节点为y 那么如果x的第一次被访问时间比y早,那么这证明y所在的环已经被我们访问过了,就不需要再单独对y处理什么. 2.如果x的第一次被访问时间比y晚,则说明x在一个以y为父亲的环上,此时再遍历整个环标记一下父亲节点母亲节点.

 

例题：

1.HDU3594（仙人掌图的判定）

判断一个有向图是不是仙人掌图。即强连通且每条边只属于一个环。

利用tarjan求强连通的同时找环。当某个顶点被第二次访问时，说明有环存在。

即访问某个顶点的时候，记录该顶点的上一个节点，每次找到一个环，就将该环上的所有顶点度数+1，如果某个顶点度数超过1，则说明其属于两个环。

​

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<stack>
#include<vector>
using namespace std;
#define maxn 20005
vector<int> G[maxn];
int pre[maxn],low[maxn],dfs_clock,scc_cnt,fa[maxn],in[maxn];
 
bool Find(int x,int a)
{
    while(fa[x]!=a){
        in[x]++;
        if(in[x]>1) return 0;
        x=fa[x];
    }
    return 1;
}
 //Tarjan算法求SCC
bool dfs(int u){
    pre[u]=low[u]=++dfs_clock;
    for(int i=0;i<(int)G[u].size();++i){
        int v=G[u][i];
        if(!pre[v]){
            fa[v]=u;
            if(!dfs(v)) return 0;
            low[u]=min(low[u],low[v]);//用后代的low函数更新自身
        }
        else{
            low[u]=min(low[u],pre[v]);//用反向边更新
            if(!Find(u,v)) return 0;
        }
    }
    if(low[u]==pre[u]){
        ++scc_cnt;
        if(scc_cnt>1) return 0;
    }
    return 1;
}
 
bool find_scc(int n){
    dfs_clock=scc_cnt=0;
    memset(pre,0,sizeof(pre));
    memset(in,0,sizeof(in));
    for(int i=0;i<n;++i)
        if(!pre[i])
            if(!dfs(i)) return 0;
    return 1;
}
 
int main()
{
    int t,i,x,y,n;
    cin>>t;
    while(t--)
    {
        scanf("%d",&n);
        for(i=0;i<n;++i) G[i].clear();
        while(scanf("%d%d",&x,&y)&&(x+y)) G[x].push_back(y);
        if(find_scc(n)&&scc_cnt==1) puts("YES");
        else puts("NO");
    }
    return 0;
}

2.POJ2793（无向仙人掌图的判定）

给你一幅无向图 计算它有多少生成子图是仙人掌 如果它本身不是仙人掌输出0

无向图的仙人掌是一个连通图且一条边最多在一个环上

对于这道题 需要区分“生成子图”和“导出子图”的概念

生成子图：包含G的所有顶点V和其中一些边的子图

导出子图：选择G中一些点组成集合V'，将E中所有两端点在V'中的边全部找出形成的子图叫点导出子图；选择G中一些边组成集合E'，将V中所有与E'中的边有关系的点全部找出形成的子图叫边导出子图。

那么这道题就是说你要扔掉一些边 使图还是仙人掌 问方案数

易知扔掉的边必定是环上的边 而且由于原图是仙人掌 所以每个环只能扔1条边或不扔

那么总方案数其实就是所有的环中的边数加一后的乘积 由于最后数字很大所以要用高精度

import java.io.*;
import java.util.*;
import java.math.*;
 
public class Main {
    class edge {
        int v, next;
        boolean flag;
 
        edge(int v, int next) {
            this.v = v;
            this.next = next;
            this.flag = false;
        }
    }
 
    edge[] ed = new edge[2000001];
    int[] head = new int[20001];
    int[] dfn = new int[20001];
    int[] low = new int[20001];
    int[] st = new int[2000001];
    int tot, idx, top;
    BigInteger res;
 
    public void tarjan(int u, int fa) {
        int i, j, v, f = 0;
        dfn[u] = low[u] = ++idx;
        for (i = head[u]; i != -1; i = ed[i].next) {
            v = ed[i].v;
            if (ed[i].flag)
                continue;
            ed[i].flag = ed[i ^ 1].flag = true;
            st[++top] = i;
            if (dfn[v] == -1) {
                tarjan(v, u);
                low[u] = min(low[u], low[v]);
                if (dfn[u] <= low[v]) {
                    int num = 0;
                    do {
                        j = st[top--];
                        num++;
                    } while (i != j);
                    if (num > 1)
                        num++;
                    res = res.multiply(new BigInteger(num + ""));
                }
            } else
                low[u] = min(low[u], dfn[v]);
            if (low[v] < dfn[u])
                f++;
        }
        if (f > 1)
            res = BigInteger.ZERO;
    }
 
    public static int min(int i, int j) {
        if (i < j)
            return i;
        return j;
    }
 
    public void solve(int n) {
        idx = top = 0;
        res = BigInteger.ONE;
        tarjan(1, 1);
        for (int i = 1; i <= n; i++) {
            if (dfn[i] == -1) {
                res = BigInteger.ZERO;
                break;
            }
        }
    }
 
    public void run() {
        Scanner cin = new Scanner(System.in);
        int n, m, i, j, k, u, v;
        while (cin.hasNext()) {
            n = cin.nextInt();
            m = cin.nextInt();
            tot = 0;
            for (i = 1; i <= n; i++) {
                dfn[i] = -1;
                head[i] = -1;
            }
            for (i = 1; i <= m; i++) {
                k = cin.nextInt();
                u = cin.nextInt();
                for (j = 2; j <= k; j++) {
                    v = cin.nextInt();
                    ed[tot] = new edge(v, head[u]);
                    head[u] = tot++;
                    ed[tot] = new edge(u, head[v]);
                    head[v] = tot++;
                    u = v;
                }
            }
            solve(n);
            System.out.println(res);
        }
        cin.close();
    }
 
    public static void main(String[] args) {
        new Main().run();
    }
}