poj 2793 Cactus(无向仙人掌图判定)

有向Cactus图：

1.它是一个强连通图。

2.它的任意一条边都属于且仅属于一个环。

有向Cactus图判定：

性质1 有向Cactus的DFS树没有横向边(不等价于非父子边)。

性质2 low(u)<=dfn(v) (u是v的儿子)

性质3 设某个点v有a(v)个儿子的low值小于dfn(v)，同时v自己有b(v)条逆向边。那么a(v)+b(v)<2。

这三条性质也就是一个有向图是有向Cactus的充要条件。详细的证明请看《cactus solution》写的很详细，三个条件都有。

对应的题目HDU 3594，只要搞懂了定理很好实现，通过此题深刻理解了横叉边和反向边的区别。

无向Cactus图定义：

1.它是一个连通图。

2.它的任意一条边都至多属于一个环。

poj 2793 Cactus

题意：判断一个图是否为cactus图，并求计算一个图的cactus度：有多少个生成子图（包括自身）也是cactus。

解法：根据无向仙人掌图的定义，只需判断每条边属于几个环即可，对图进行dfs后所有父子边形成以棵树，每条反向边<a,b>加入树后都会使a-lca[a][b]--b形成一个环，可以用poj3417的做法（详见《Tarjan离线算法求LCA小结》）统计每条边被环覆盖了多少次。还有一种方法是在dfs时顺便维护，实现起来可能还会更简单些。

在确定是cactus图后只需统计每个环上有多少条边，然后利用乘法原理就可以计算度数.由于每条反向边只会形成一个环，因此记录每个节点的深度depth[]，在碰到反向边<b,a>时,depth[b]-depth[a]+1就是这个环内边的条数，累乘即可，注意要用高精。

public class Main{
	int maxn = 20010, maxm = 1000010;
	class node {
		int be, ne, val;
		node(int b, int e, int v) {
			be = b;
			ne = e;
			val = v;
		}
	}
	class LCA {
		node buf[] = new node[maxn * 2], query[] = new node[maxn * 2];
		int Eb[] = new int[maxn], lb, Eq[] = new int[maxn], lq;
		void init(int n) {
			lq = lb = 0;
			for (int i = 1; i <= n; i++) {
				f[i] = i;
				Eb[i] = Eq[i] = -1;
				vis[i] = 0;
			}
		}
		void addedge(int a, int b, int v) {
			buf[lb] = new node(b, Eb[a], v);
			Eb[a] = lb++;
			buf[lb] = new node(a, Eb[b], v);
			Eb[b] = lb++;
		}
		void addquery(int a, int b, int v) {
			query[lq] = new node(b, Eq[a], v);
			Eq[a] = lq++;
			query[lq] = new node(a, Eq[b], v);
			Eq[b] = lq++;
		}
		int f[] = new int[maxn], vis[] = new int[maxn];
		int find(int x) {
			if (x != f[x])
				f[x] = find(f[x]);
			return f[x];
		}
		void dfs(int a) {
			vis[a] = 1;
			// 处理子树
			for (int i = Eq[a]; i != -1; i = query[i].ne) {
				int b = query[i].be;
				if (vis[b] == 1) {
					int temp = find(b);
					ans[temp] -= 2;
					//System.out.println("te "+temp);
				}
			}
			for (int i = Eb[a]; i != -1; i = buf[i].ne) {
				int b = buf[i].be;
				if (vis[b] == 0) {
					dfs(b);
					f[b] = a;
					ans[a] += ans[b];
				//	System.out.println(a+" "+b+" "+ans[a]+" "+ans[b]);
				}
			}
		}
	}

	class BCC {
		node buf[] = new node[maxm*2];
		int E[] = new int[maxn], len, n;
		int dfn[] = new int[maxn], low[] = new int[maxn],cnt;
		int depth[]=new int[maxn];
		void init(int n) {
			this.n = n;
			Arrays.fill(E, -1);
			len = 0;
		}
		void add(int a, int b) {
			buf[len] = new node(b, E[a], 0);
			E[a] = len++;
			buf[len] = new node(a, E[b], 0);
			E[b] = len++;
		}

		void dfs(int a, int fa,int d) {
			//System.out.println(a);
			dfn[a] = low[a] = ++cnt;
			depth[a]=d;
			for (int i = E[a]; i != -1; i = buf[i].ne) {
				int b = buf[i].be;
				if (dfn[b] == 0) {
					dfs(b, a,d+1);
					lca.addedge(a, b,i);
					low[a] = Math.min(low[b], low[a]);
				} else if (b != fa && dfn[b] < low[a]) {
					low[a] = dfn[b];
					//System.out.println(a+" "+b);
					res=res.multiply(new BigInteger(depth[a]-depth[b]+2+""));
					ans[a]++;
					ans[b]++;
					lca.addquery(a, b, i);
				}
			}
		}
		String solve() {		
			for (int i = 1; i <= n; i++)
				dfn[i] = low[i] = 0;
			cnt = 0;
			Arrays.fill(ans, 0);
			dfs(1,1,1);
			for (int i = 1; i <= n; i++)
				if (dfn[i] == 0)	
					return "0";									
			lca.dfs(1);
			for(int i=1;i<=n;i++)
				if(ans[i]>1)				
					return "0";
					
			return res.toString();
		}
	}

	int ans[] = new int[maxn];
	LCA lca = new LCA();
	BCC bcc = new BCC();
	int path[] = new int[1010];
	boolean vis[] = new boolean[maxn];
	BigInteger res;
	StreamTokenizer in = new StreamTokenizer(new BufferedReader(
			new InputStreamReader(System.in)));

	int nextInt() throws IOException {
		in.nextToken();
		return (int) in.nval;
	}
	void run() throws IOException {
		int n = nextInt();
		int m = nextInt();
		res=BigInteger.ONE;
		bcc.init(n);
		lca.init(n);
		while (m-- > 0) {
			int k = nextInt();
			for (int i = 1; i <= k; i++)
				path[i] = nextInt();
			for (int i = 1; i < k; i++)
				bcc.add(path[i], path[i + 1]);
		}
		System.out.println(bcc.solve());
	}
	public static void main(String[] args) throws IOException {
		new Main().run();

	}

}

关于cactus 问题，周冬08年的论文里有详细的介绍，主要是利用dfs树性质结合cactus图双连通、强连通的特殊性进行求解，例如求cactus直径/最长链问题等。