[NOIP2018]旅行

嘟嘟嘟




鉴于一些知道的人所知道的，不知道的人所不知道的原因，我来发NOIPday2T1的题解了。




\(O(n ^ 2)\)的做法自然很暴力，枚举断边断环为链就行了。

所以我是来讲\(O(nlogn)\)的做法的。




准确说是排序复杂度，剩下的都是\(O(n)\)的。

大体思想就是通过一遍dfs\(O(n)\)找到该断的边，然后跑一遍树输出答案就行了。




为了方便，我们把在环外并和环上节点直接相连的点称作某个点的子结点。

那么对于环上的结点\(i\)和下一个结点\(nxt[i]\)，肯定是先把小于\(nxt[i]\)的\(i\)的子结点都走完了，然后判断是该走\(nxt[i]\)还是回溯（就是断边）。

回溯的话，就说明前面有一个子结点比\(nxt[i]\)小而且这个点当时又没走。

所以维护一个变量\(tp\)记录这个东西。首先要清楚的一点是如果回溯的话，那么路径上所有没走过的点都得走。然后每一次遍历点\(i\)的出边，对于所有大于\(nxt[i]\)的子结点取min。如果存在这个点，就必须要更新tp。

然后每一次判断一下，如果\(tp < nxt[i]\)，就断边啦。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
#define enter puts("")
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define In inline
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 5e5 + 5;
inline ll read()
{
	ll ans = 0;
	char ch = getchar(), last = ' ';
	while(!isdigit(ch)) last = ch, ch = getchar();
	while(isdigit(ch)) ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
	if(last == '-') ans = -ans;
	return ans;
}
inline void write(ll x)
{
	if(x < 0) x = -x, putchar('-');
	if(x >= 10) write(x / 10);
	putchar(x % 10 + '0');
}

int n, m;
vector<int> v[maxn];

bool in[maxn];
int st[maxn], top = 0, a[maxn], cnt = 0;
In bool dfs_cir(int now, int _f)		//找环
{
	st[++top] = now; in[now] = 1;
	for(int i = 0, to; i < (int)v[now].size(); ++i)
	{
		if((to = v[now][i]) == _f) continue;
		if(in[to])
		{
			while(st[top] ^ to) a[++cnt] = st[top--];
			a[++cnt] = st[top];
			return 1;
		}
		if(dfs_cir(to, now)) return 1;
	}
	in[st[top--]] = 0; return 0;
}

In void dfs(int now, int _f)
{
	write(now), space;
	for(int i = 0, to; i < (int)v[now].size(); ++i) if((to = v[now][i]) ^ _f) dfs(to, now);
}

bool vis[maxn];

int main()
{
	n = read(); m = read();
	for(int i = 1; i <= m; ++i)
	{
		int x = read(), y = read();
		v[x].push_back(y); v[y].push_back(x);
	}
	for(int i = 1; i <= n; ++i) sort(v[i].begin(), v[i].end());
	if(m == n - 1) {dfs(1, 0); return 0;}
	dfs_cir(1, 0);
	reverse(a + 1, a + cnt + 1);		//以下三条语句是判断开始往环的那一头走
	if(a[2] > a[cnt]) reverse(a + 2, a + cnt + 1);
	for(int i = 1; i <= cnt; ++i) vis[a[i]] = 1;
	a[cnt + 1] = a[1];
	for(int i = 1, tp = a[cnt]; i <= cnt; ++i)
	{
		int Min = INF;
		for(int j = 0, to; j < (int)v[a[i]].size(); ++j)
			if(!vis[to = v[a[i]][j]] && to > a[i + 1]) Min = min(Min, to);
		if(Min ^ INF) tp = Min;
		if(tp < a[i + 1] || i == cnt)	//断边，直接从vector中删除元素
		{
			vector<int>::iterator it = lower_bound(v[a[i]].begin(), v[a[i]].end(), a[i + 1]);
			v[a[i]].erase(it);
			vector<int>::iterator it2 = lower_bound(v[a[i + 1]].begin(), v[a[i + 1]].end(), a[i]);
			v[a[i + 1]].erase(it2);
			break;
		}
	}
	dfs(1, 0);
	return 0;
}