旅行 Noip 2018 Day2T1

突然发现好久没写博客了，那就讲一讲Noip的题吧

-----------------------------------我是分割线---------------------------------------

直接上题：

题目描述

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

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

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

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

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

输入格式

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

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

输出格式

输出文件包含一行，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

考场上的心理：看起来还行，不难，不断dfs找编号小的点。long time later，代码实现：好像是错的，这什么玩意儿，凉凉
回归正题，这道题目该怎么做：
回到题目，看到提示和说明：m=n-1|m=n；
看起来好像没有什么用，但仔细想想啊
当m=n-1时，图不就退化成为一棵树了吗（暴力dfs，相信看到人都能够熟练的运用手动滑稽）
但是，第二种情况：m=n，这看起来就很麻烦了，因为有环，且只有一个环
那怎么办呢，好了，这是这道题目最难的一点，也是最难想到的（反正我是这样）
既然有且只有一个环，那么妥妥的奇环树
我么有一个专业名称：断环法，听起来好像特别高级，但其实通俗的讲就是暴力删边
重要的事情说三遍，不是每个边，只有环上的边*3滑稽
那么找环，就要拿出Tarjan，上一篇有详细讲过
第二种就是拓扑排序 topsort（应该也不用说）
那么找环代码如下：

void topsort(){
    int hd=0,tl=0;
    for(int i=1;i<=number;i++)
       if(in[i]==1)que[++tl]=i;
    while(hd<tl){
        int now=que[++hd];
        for(int i=head[now];i;i=nxt[i]){
            int y=ver[i];
            if(in[y]>1){
                in[y]--;
                if(in[y]==1)que[++tl]=y;
            }
        }
    }
}

que是不在环上的点，in表示入度，那么环上的点就是入度>=2的点

找到环以后，就开始删边了

将环上任意两个相邻点标记，mapp表示，代表这两个点之间的边被强行删去

那么删除之后，发现不又回到了m=n-1的情况吗

那么，最后只有判断当前的序列是否更优

代码如下

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

const int N=30002;
int number,magic,ans[N],res[N],sum=0,need[N];
int ver[N],nxt[N],tot=0,head[N],size[N];
int in[N],que[N],mapp[5002][5002];

int read(){
	int s=0,w=1;char ch=getchar();
	while(ch<'0'||ch>'9')w=(ch=='-')?-1:1,ch=getchar();
	while(ch>='0'&&ch<='9')s=s*10+ch-'0',ch=getchar();
	return s*w;
}

void add(int x,int y){
	ver[++tot]=y;nxt[tot]=head[x];head[x]=tot;
	in[x]++;in[y]++;
}

void dfs(int now,int fa){
	ans[++sum]=now;
	int q[3002]={0},vis=0;
	for(int i=head[now];i;i=nxt[i]){
		int y=ver[i];
		if(y==fa||mapp[now][y])continue;
		q[++vis]=y;
	}
	sort(q+1,q+vis+1);
	for(int i=1;i<=vis;i++)dfs(q[i],now);
}

void topsort(){
	int hd=0,tl=0;
	for(int i=1;i<=number;i++)
	   if(in[i]==1)que[++tl]=i;
	while(hd<tl){
		int now=que[++hd];
		for(int i=head[now];i;i=nxt[i]){
			int y=ver[i];
			if(in[y]>1){
				in[y]--;
				if(in[y]==1)que[++tl]=y;
			}
		}
	}
}

void check(){
	for(int i=1;i<=number;i++)
	   if(ans[i]>need[i])return;
	for(int i=1;i<=number;i++)
	   need[i]=ans[i];
}

void find(int now){
	int x=now,vis=0,xl[3002],last=0;
	do{
		in[x]=1;xl[++vis]=x;last=0;
		for(int i=head[x];i;i=nxt[i]){
			int y=ver[i];
			if(in[i]>1){
				x=y;last=i;break;
			}
		}
	}while(last);
	for(int i=1;i<vis;i++){
		mapp[xl[i]][xl[i+1]]=mapp[xl[i+1]][xl[i]]=1;
		dfs(1,0);
		check();
		mapp[xl[i]][xl[i+1]]=mapp[xl[i+1]][xl[i]]=0;
	}
}

int main(){
	number=read();magic=read();
	for(int i=1;i<=number;i++)need[i]=1e9;
	for(int i=1;i<=magic;i++){
		int x=read(),y=read();
		add(x,y);add(y,x);
	}
	if(number-1==magic)dfs(1,0);
	else {
		topsort();
		for(int i=1;i<=number;i++)
		   if(in[i]>1)find(i);
	}
	for(int i=1;i<=number;i++)
	   cout<<ans[i]<<" ";
	return 0;
}

　　

当然，还没有结束，当你把当前的代码交上去时发现如下：

T到起飞，（自动屏蔽wa，输出错了，应该是need，我是ans）
那么原因是什么呢，看到

void dfs(int now,int fa){
    ans[++sum]=now;
    int q[3002]={0},vis=0;
    for(int i=head[now];i;i=nxt[i]){
        int y=ver[i];
        if(y==fa||mapp[now][y])continue;
        q[++vis]=y;
    }
    sort(q+1,q+vis+1);
    for(int i=1;i<=vis;i++)dfs(q[i],now);
}

用了sort，可以卡到 O(n^3*log2n)

看看数据范围：n<=5000  接近崩溃的边缘

不过别慌，要用优化来打败TLE————沃兹基硕德

我们发现，超时的主要原因是不知道一个点连接边点的大小顺序，所以要先存起来

那么，我们可以预处理

现将连接着的点排序（程序开始存，不然没有效果）

注意：相信很多人排序都会从小到大排序，但是前项星存是倒过来的，所以要从大到小排

所以AC代码如下：

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

const int M=5050,N=M<<1;
int number,edge_n,ans[M],res[M],sum=0,need[M];
int ver[N],nxt[N],tot=0,head[N],size[N];
int in[M],que[M],mapp[M][M];
struct node{
    int x,y;
}edge[N];

int read(){
    int s=0,w=1;char ch=getchar();
    while(ch<'0'||ch>'9')w=(ch=='-')?-1:1,ch=getchar();
    while(ch>='0'&&ch<='9')s=s*10+ch-'0',ch=getchar();
    return s*w;
}

void add(int x,int y){
    ver[++tot]=y;nxt[tot]=head[x];head[x]=tot;
    in[y]++;
}

void dfs(int now){
    ans[++sum]=now;res[now]=1;
    for(int i=head[now];i;i=nxt[i]){
        int y=ver[i];
        if(res[y]||mapp[now][y])continue;
        dfs(y);
    }
}

void topsort(){
    int hd=0,tl=0;
    for(int i=1;i<=number;i++)
       if(in[i]==1)que[++tl]=i;
    while(hd<tl){
        int now=que[++hd];
        for(int i=head[now];i;i=nxt[i]){
            int y=ver[i];
            if(in[y]>1){
                in[y]--;
                if(in[y]==1)que[++tl]=y;
            }
        }
    }
}

void check(){
    int flag=0;
    for(int i=1;i<=number;i++){
        if(ans[i]<need[i]){
            flag=1;break;
        }
        if(ans[i]>need[i])return;
    }
    if(!flag)return;
    for(int i=1;i<=number;i++)
       need[i]=ans[i];
}

void find(int now){
    int x=now,vis=0,xl[5002],last=0;
    do{
        in[x]=1;xl[++vis]=x;last=0;
        for(int i=head[x];i;i=nxt[i]){
            int y=ver[i];
            if(in[y]>1){
                x=y;last=y;break;
            }
        }
    }while(last);
    xl[++vis]=now;
    for(int i=1;i<vis;i++){
        mapp[xl[i]][xl[i+1]]=mapp[xl[i+1]][xl[i]]=1;
        memset(res,0,sizeof(res));sum=0;
        dfs(1);
        check();
        mapp[xl[i]][xl[i+1]]=mapp[xl[i+1]][xl[i]]=0;
    }
}

bool cmp(node a,node b){
    return a.y>b.y;
}

int main(){
    number=read();edge_n=read();
    for(int i=1;i<=number;i++)need[i]=1e9;
    for(int i=1;i<=edge_n;i++){
        int x=read(),y=read();
        edge[i].x=x;edge[i].y=y;
        edge[i+edge_n].x=y;edge[i+edge_n].y=x;
    }
    sort(edge+1,edge+edge_n*2+1,cmp);
    for(int i=1;i<=edge_n*2;i++)
       add(edge[i].x,edge[i].y);
    if(number-1==edge_n){
        dfs(1);check();
    }
    if(number==edge_n){
        topsort();
        for(int i=1;i<=number;i++)
           if(in[i]>1){
               find(i);break;
           }
    }
    for(int i=1;i<=number;i++)
       cout<<need[i]<<" ";
    return 0;
}

CSP 2019 rp++