P5022 旅行(拓扑排序+树形DP+环套树)

题目描述

小 Y 是一个爱好旅行的 OIer。她来到 X 国，打算将各个城市都玩一遍。

小Y了解到， X国的 nn 个城市之间有 mm 条双向道路。每条双向道路连接两个城市。 不存在两条连接同一对城市的道路，也不存在一条连接一个城市和它本身的道路。并且， 从任意一个城市出发，通过这些道路都可以到达任意一个其他城市。小 Y 只能通过这些 道路从一个城市前往另一个城市。

小 Y 的旅行方案是这样的：任意选定一个城市作为起点，然后从起点开始，每次可 以选择一条与当前城市相连的道路，走向一个没有去过的城市，或者沿着第一次访问该 城市时经过的道路后退到上一个城市。当小 Y 回到起点时，她可以选择结束这次旅行或 继续旅行。需要注意的是，小 Y 要求在旅行方案中，每个城市都被访问到。

为了让自己的旅行更有意义，小 Y 决定在每到达一个新的城市（包括起点）时，将 它的编号记录下来。她知道这样会形成一个长度为 nn 的序列。她希望这个序列的字典序 最小，你能帮帮她吗？ 对于两个长度均为 nn 的序列 AA 和 BB，当且仅当存在一个正整数 xx，满足以下条件时， 我们说序列 A 的字典序小于 B。

• 对于任意正整数 1 ≤ i < x，序列 A的第 i 个元素 Ai​ 和序列 B 的第 i 个元素 Bi​ 相同。
• 序列 A 的第 x个元素的值小于序列 B 的第 x 个元素的值。

输入格式

输入文件共 m + 1m+1 行。第一行包含两个整数 n,m(m ≤ n)，中间用一个空格分隔。

接下来 m 行，每行包含两个整数 u,v (1 ≤ u,v ≤ n)，表示编号为 u 和 v 的城市之 间有一条道路，两个整数之间用一个空格分隔。

输出格式

输出文件包含一行，nn 个整数，表示字典序最小的序列。相邻两个整数之间用一个 空格分隔。

输入输出样例

输入 #1复制

6 5 
1 3 
2 3 
2 5 
3 4 
4 6

输出 #1复制

1 3 2 5 4 6

输入 #2复制

6 6 
1 3 
2 3 
2 5 
3 4 
4 5 
4 6

输出 #2复制

1 3 2 4 5 6

说明/提示

【数据规模与约定】

对于 100\%100% 的数据和所有样例， 1 \le n \le 50001≤n≤5000 且 m = n − 1m=n−1 或 m = nm=n 。

对于不同的测试点， 我们约定数据的规模如下：

题解

对于这道题，蒟蒻写码一小时，调试三小时，交了数十次才CH3COO了

所以决定写一篇题解来纪念这件事

首先先码了60分的，然而去年这时候的蒟蒻，连这60分也不会打，所以也讲一下前60分的方法，前60分用vector存图，然后对于每一个节点队他的儿子节点排序，因为我们要求字典序最小，用vector排序无疑是很好的选择，当然也可以用邻接表存图，那样你可以不怕麻烦的一个一个排序找，虽然这样会快不少，但是代码量大了很多，尤其是考试的时候不是很划算（巨佬们当做没听见就好）

然后满分算法，也看了不少O(n),O(nlogN)的解法，但是我还是坚持用O(N^2)的朴素算法，实用而简单

易知，m=n时的图是一个环套数，途中有且仅有一个环，如破坏环中的任意一条边，就可以变成标准的树，然后就可以进行我们的算法一。

在这里，很容易得到的一种想法就是枚举环上的所有边进行逐个删除，每轮记录答案并比较，找出最小的ans（字典序）

那么如何找到环呢，可以用拓扑排序，如果直接dfs的话只能找一个环，虽然这题也够用了，但是个人认为还是拓扑排序简单一点，至此，这个问题就圆满解决了。

当然，也可以不用拓扑排序找环，每条边都枚举删一次，这样算法更简单，但是有常数级别的优化，however,As we all know,vector的常数很大，所以能卡一点是一点吧，而且不删的话会有一点麻烦，在dfs的时候要加一个vis数组记录这条边是否访问过，因为有可能是环，也有可能图不连通

最后，注意事项（恐怕也只有蒟蒻会错了。。。）

一定要把每个节点邻接边都排序

#include<vector> 
#include<queue>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
inline int read()
{
	int s=0,f=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){s=(s<<1)+(s<<3)+(ch^48);ch=getchar();}
	return s*f;
}
const int N=10005;
vector<int>G[N];
int n,m; 
int dep=0;
int ans[N];
void dfs(int u,int fa)
{
	ans[++dep]=u;
	for(int i=0;i<G[u].size();i++)
	{
		int v=G[u][i];
		if(v==fa)continue;
		dfs(v,u); 
	}
}
int du[N],in[N];//因为我们记录每次出队的i更方便，所以记录不在环中的节点，剩下的就是在环中的了 
void topo()
{
	queue<int>q;
	for(int i=1;i<=n;i++)
	{
		if(du[i]==1)
		{
			q.push(i);
			in[i]=1;//i不在环中 
		}
	}
	while(!q.empty())
	{
		int t=q.front();
		int len=G[t].size();
		q.pop();
		in[t]=1;//不在环中
		for(int i=0;i<len;i++)
		{
			int nxtt=G[t][i];
			du[nxtt]--;
			if(du[nxtt]==1)
			{
				q.push(nxtt);
				in[nxtt]=1;
			}
		}
	}
}
struct node
{
	int xx;
	int yy;
}line[N];
int dis[5005][5005];
int tmp[N],vis[N];//tmp[i]是用于更新答案的 
int tot=0;
void dfs2(int u,int fa)//对于删了一条边的树dfs 
{
	tmp[++tot]=u;
	for(int i=0;i<G[u].size();i++)
	{
		int v=G[u][i];
		if(v==fa)continue;
		if(!dis[u][v])continue;
		dfs2(v,u);
	}
}
void upans()
{
	for(int i=1;i<=n;i++)
		ans[i]=tmp[i];                             
}
void update()
{
	for(int i=1;i<=n;i++)
	{
		if(tmp[i]==ans[i])continue;
		else if(tmp[i]<ans[i])
		{
			upans();
			return;
		}
		return ;
	}
}
int main()
{
	int i,x,y;
	n=read();m=read();
	if(m==n-1)//树的情况
	{
		for(i=1;i<=m;i++)
		{
			x=read();y=read();
			G[x].push_back(y);
			G[y].push_back(x);
			line[i].xx=x;
			line[i].yy=y;
		}
		for(i=1;i<=n;i++)
			sort(G[i].begin(),G[i].end()); 
		dfs(1,0);
		for(i=1;i<=n;i++)
			printf("%d ",ans[i]);
		printf("\n");	
	}
	else
	{
		for(i=1;i<=m;i++)
		{
			x=read();y=read();
			G[x].push_back(y);
			G[y].push_back(x);
			line[i].xx=x;
			line[i].yy=y;
			du[x]++;du[y]++;
			dis[x][y]=1;dis[y][x]=1;
		}
		topo();
		for(i=1;i<=n;i++)
			sort(G[i].begin(),G[i].end());
		memset(ans,0x3f,sizeof(ans));
		for(i=1;i<=m;i++)//枚举删那一条边
		{
		 	int x=line[i].xx;
		 	int y=line[i].yy;
		 	if(in[x]||in[y])continue;
		 	dis[x][y]=0;dis[y][x]=0;
		 	memset(vis,0,sizeof(vis));
		 	tot=0;
		 	dfs2(1,0);
			update();
			dis[x][y]=1;dis[y][x]=1; 
		}
		for(i=1;i<=n;i++)
			printf("%d ",ans[i]);
		printf("\n");
	}
	return 0;
}