noip2018 旅行 加强版

贪心

\(O(N^2logn)\)很好做，直接暴力断边。

\(O(nlogn)\)做法

同样考虑贪心，每次往最小的点走一定更优，只不过我们可以在一个环上走一半之后回溯，使得答案更优

我们在 当前点 最近的 还有儿子没走的祖先的 最小的儿子比当前点的儿子小时 就回溯

当然这个回溯的儿子必须在环上，且必须是当前点最大的儿子，因为如果不是最大的儿子，就必须要在其他比他更大的儿子访问完后再回溯，这样不满足字典序最小

正确性是显然的，我们要让字典序最小，只需排在前面的最小，并且所有点必须被访问到，所以当前点的其他儿子必须被访问到（回溯后就无法再访问了），且不能回溯到一个更远的祖先（因为更近的祖先还有儿子没走）

实现较为复杂，细节较多

#include<bits/stdc++.h>
using namespace std;

#define go(i,a,b) for(int i=a;i<=b;++i)
#define com(i,a,b) for(int i=a;i>=b;--i)
#define mem(a,b) memset(a,b,sizeof(a))
#define fo(i,a) for(int i=0;i<a;++i)
#define il inline

const int inf=0x3f3f3f3f,N=500000+10;

int n,m,head[N],cnt,s[N],top;
struct edge{
	int nxt,v;
}e[N*2];
vector<int>ans;
bool vis[N],cir[N],flag;

void add(int u,int v){
	e[cnt]=(edge){head[u],v};
	head[u]=cnt++;
}

il void read(int &x){
	x=0;char c=getchar(),f=1;
	while(c<'0'||c>'9'){ c=='-'?f=-1:0; c=getchar(); }
	while(c>='0'&&c<='9'){ x=x*10+c-'0'; c=getchar(); }
	x*=f;
}

bool dfs(int u,int fa){
	if(vis[u]){
		int x;
		do{
			x=s[top--];
			cir[x]=1;
		}while(x!=u);
		return 1;
	}
	s[++top]=u;
	vis[u]=1;
	for(int i=head[u],v;i+1;i=e[i].nxt){
		v=e[i].v;
		if(v==fa) continue;
		if(dfs(v,u)) return 1;
	}
	--top;
	vis[u]=0;
	return 0;
}

void Dfs(int u,int last){
	if(vis[u]) return;
	vis[u]=1;
	ans.push_back(u);
	vector<int>tmp;
	int v,mn;
	for(int i=head[u];i+1;i=e[i].nxt){
		v=e[i].v;
		if(!vis[v]) tmp.push_back(v);
	}
	sort(tmp.begin(),tmp.end());
	fo(i,tmp.size()){
		v=tmp[i];
		if(!flag&&i+1==tmp.size()&&cir[v]&&v>last){
			flag=1;
			return;
		}
		mn=inf;
		if(cir[u]&&i+1!=tmp.size()) mn=tmp[i+1];
		Dfs(v,mn==inf?last:mn);
	}
}

int main(){
	//freopen("input.txt","r",stdin);
	//freopen("out.txt","w",stdout);
	mem(head,-1);
	read(n),read(m);
	int u,v;
	go(i,1,m){
		read(u),read(v);
		add(u,v),add(v,u);
	}
	dfs(1,0);
	mem(vis,0);
	Dfs(1,inf);
	fo(i,ans.size()) printf("%d ",ans[i]);
	return 0;
}