HDU 4582 DFS spanning tree 解题报告（贪心 & 树形DP）

    此题贪心可解。从下往上，到了必须选边的时候才选边即可。296MS，代码如下：

#include <bitset>
#include <iostream>
using namespace std;

const int maxn=2013;
int first[maxn],pre[maxn],vv[maxn*20],nxt[maxn*20];
bitset<2001> to[2001];
bool vis[maxn];
int ans;

void dfs(int u,int p)
{
	vis[u]=true;
	to[u].reset();

	for(int e=pre[u];e;e=nxt[e]) if(vis[vv[e]])
		to[u].set(vv[e]);
	for(int e=first[u];e;e=nxt[e]) if(vv[e]!=p)
		dfs(vv[e],u);
	if(p==-1)
		return;
	if(to[u].test(p))
		ans++;
	else
		to[p]|=to[u];
}

int main()
{
	int n,m;
	while(~scanf("%d%d",&n,&m) && n|m)
	{
		memset(vis,0,sizeof(vis));
		memset(first,0,sizeof(first));
		memset(pre,0,sizeof(pre));

		int e=2;
		for(int i=1;i<n;i++)
		{
			int u,v;
			scanf("%d%d",&u,&v);
			nxt[e]=first[u],vv[e]=v,first[u]=e++;
			nxt[e]=first[v],vv[e]=u,first[v]=e++;
		}
		for(int i=n;i<=m;i++)
		{
			int u,v;
			scanf("%d%d",&u,&v);
			nxt[e]=pre[u],vv[e]=v,pre[u]=e++;
			nxt[e]=pre[v],vv[e]=u,pre[v]=e++;
		}

		ans=0;
		dfs(1,-1);
		printf("%d\n",ans);
	}
}

    当然，之前写的树形DP也是可以过的。

    首先声明，参考了frog1902的解题报告。http://blog.csdn.net/frog1902/article/details/9921845

    这里是另外一份解题报告的地址：http://www.cnblogs.com/wangfang20/archive/2013/08/13/3254920.html

    其实我都看了，仍然不是太懂。在画了很多图，debug许久后，终于有点理解了。希望和我一样不懂的弱菜能看懂= =。

    

    首先是题意：给定n个点，m条边的图。前n-1条边是DFS树。所说的T环是只有一条边不属于DFS树的环。问最小选取多少条边，可以使所有的T环都能被覆盖到。

    

    图中 1,2,3,1 是一个T环，1,2,4,1是一个T环。只要选择(1,2)这条边，那么两个T换都被覆盖到了。

    frog1902的解题报告中所说的横叉边与返祖边，简单引用并解释下：

    =====================================================

    “需注意的是，题目给出的是一个无向图的DFS树，

    所以不在这棵树上的边一定不可能是"横叉边"，而一定是" 后向边(返祖边)"。

    也就是说，不在DFS树上的边，一定是由某点指向它的某个祖先的。

    很容易想象，如果不是这样，那么DFS树的形态一定会发生改变。”

    =====================================================

    横叉边是某一节点x到DFS树中另一子树上节点y的边，返祖边是某一节点x到其DFS树中祖先y的边。如下图：

    算法导论中DFS那里有说明，不懂大家可以去看一下。

    题中所说的a Depth-First-Search(DFS) spanning tree T of a undirected connected graph G。图是无向图，所以不会有类似于7->5这样的横叉边，以为无向，所以如果5,7间有边，遍历到5时，7就是5的子节点了。对于无向边(u,v)，假设DFS到u点。如果u点通过其他路径访问了v点，DFS v点时发现u被标记过，自然不会走(u,v),(u,v)边自然就是不属于DFS树，相当于反向边。否则u一定会通过(u,v)边访问v，自然不存在横叉边。

    理解完这些后，就可以思考下怎么做了。

    上图中存在(4,1),(4,0)构成的两个T环。显然当小环中选边时大环自然也选边了。我们可以用lim[u]记录与u节点的最小环中选边的最小深度。我们用dep[u]记录u点的深度，一遍DFS既可以求出所有点的深度了。图中1,3,4,1构成的T环中，我们可以选择(1,3)边或者(3,4)边。则lim[u]的值为节点3的深度，2。也就是说这里定义一条边的深度以为深度较大节点的深度，选择3节点即为选择3节点和3节点的父节点构成的边。

    那么对于u节点来说，选边时应该选择深度为[ lim[u],dep[u] ] 的边。

    接下来是dp[u][k]的定义。定义dp[u][k]为对于节点u，在选择了深度为k的边后，以u点为根节点的树中还需要选择多少条边。

    首先看dp[0][0]。dp[0][0]就是对于节点0，选择了深度为0的边后，以0为根节点的树中还需要多少边。我们假象0节点上有一个-1节点，这样比较好理解。而dp[0][0]看起来就是我们最终要求的值。如下图：

    同样，lim[u]=0就代表u节点可以选择(-1,0)这条边，当然这条边不在计数内。

    如何求dp[u][k]的值呢？对于任一子节点v来说，dp[v][j]的合理取值是lim[v]<=j<=dep[v]。对于dp[u][k]来说，合理取值是lim[u]<=k<=dep[u]。我们希望dp[u][k]尽量小，那么选择了深度为k的边后，dp[v][j]如果存在j，满足lim[v]<=j<=k，那么在这一区间内的最小的dp[v][j]是满足条件的。因为选择了k边，j满足lim[v]<=j<=k，说明v点形成的T环里有了符合条件的深度为k的边被选择了。当然，对于区间lim[u]<=k<=dep[u]内所有的边，我们可以选择k边，再选择(v,u)这条边。我们在所有的可能中选择最小值。所以我们将(v,u)这条边计算在dp[u][dep[u]]中。

    举个例子：当u为节点3时。节点3中，dp[3][k]，深度k可以是0,1,2。也就是(-1,0),(0,1),(1,3)这3条边。当我们选(-1,0)时，显然节点4的lim[4]深度大了点，我们需要同时选择(3,4)这条边。当我们选择(1,3)这条边时，节点4的需求也满足了，也就不要选择(3,4)这条边了。对于所有的dp[u][k]，我们都让它们取最小值，这样最终的dp[0][0]是最小的。

    在下表达能力欠佳，如果不懂，可以直接回复= =。

    代码中相当于选择了(-1,0)这条边，所以最后的答案减1了。杭电上时984MS，代码如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxV=2013;
int first[maxV],vv[maxV<<1],nxt[maxV<<1];
int dp[maxV][maxV];
int lim[maxV],dep[maxV];

void DFS(int u,int p)
{
	for(int e=first[u];e;e=nxt[e]) if(vv[e]!=p)
	{
		dep[vv[e]]=dep[u]+1;
		DFS(vv[e],u);
	}
}

void DP(int u,int p)
{
	for(int i=lim[u];i<=dep[u];i++)
		dp[u][i]=0;

	for(int e=first[u];e;e=nxt[e]) if(vv[e]!=p)
	{
		int v=vv[e];
		DP(v,u);
		int temp=dp[v][dep[v]];
		for(int i=lim[v];i<lim[u];i++)
			temp=min(temp,dp[v][i]);
		for(int i=lim[u];i<=dep[u];i++)
		{
			temp=min(temp,dp[v][i]);
			dp[u][i]+=temp;
		}
	}
	dp[u][dep[u]]++;
}

int main()
{
	int n,m;
	while(~scanf("%d%d",&n,&m) && n|m)
	{
		memset(lim,0,sizeof(lim));
		memset(dp,0x7f,sizeof(dp));
		memset(first,0,sizeof(first));

		int e=2;
		for(int i=1;i<n;i++)
		{
			int u,v;
			scanf("%d%d",&u,&v);
			u--,v--;
			nxt[e]=first[u],vv[e]=v,first[u]=e++;
			nxt[e]=first[v],vv[e]=u,first[v]=e++;
		}

		dep[0]=0;
		DFS(0,-1);

		for(int i=n;i<=m;i++)
		{
			int u,v;
			scanf("%d%d",&u,&v);
			u--,v--;
			if(dep[u]<dep[v])
				swap(u,v);
			lim[u]=max(lim[u],dep[v]+1);
		}
		DP(0,-1);
		printf("%d\n",dp[0][0]-1);
	}
}