[CF_GYM101371H]Recover path

题目

传送门 to CF

思路

这是啥玩意儿？感觉难搞啊。因为图是一个复杂的东西。如果是树就好了。

但是它真的不是树吗？注意到 两点的最短路（距离）是唯一的，并且满足 整体包含部分（对于一条最短路 $P$，任意 $x,y\in P$ 的最短路就是沿着 $P$ 移动）。很显然，在一条链上，我们完全应该将其视为树。

现在，题目保证有解。也就是说，存在一条最短路 $P$，依次经过所有点。那么，在最短路的含义下，无论 $P$ 上哪个点作为起点，$P$ 中的其余点都仍然构成链。

可以类比求树的直径的方法，实际上这个更简单。从任意一个必须经过的点出发（为了保证在 $P$ 上）求最短路。必须经过的点中，有一个点的距离是最大的，它必然是链端。于是以它为起点，再次求解最短路。此时有一个点的距离是最大的，它也必然是链端。所以链的端点就求出来啦！

链的端点求出来了，不就可以还原路径了吗？注意最短路不止一条，只需要同时最大化路径上经过的特殊点数量即可。时间复杂度 $\mathcal{O}(m\log n)$ 。

代码

#include <cstdio>
#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;
# define rep(i,a,b) for(int i=(a); i<=(b); ++i)
# define drep(i,a,b) for(int i=(a); i>=(b); --i)
typedef long long int_;
inline int readint(){
	int a = 0, c = getchar(), f = 1;
	for(; '0'>c||c>'9'; c=getchar())
		if(c == '-') f = -f;
	for(; '0'<=c&&c<='9'; c=getchar())
		a = (a<<3)+(a<<1)+(c^48);
	return a*f;
}
void writeUnsigned(const unsigned &x){
	if(x > 9) writeUnsigned(x/10);
	putchar((x-x/10*10)^48);
}
inline void writeint(const int &x){
	if(x < 0){
		putchar('-');
		writeUnsigned(-x);
	}
	else writeUnsigned(x);
}

const int MAXN = 100005;
struct Edge{
	int to, nxt, val;
	Edge() = default;
	Edge(int _to,int _nxt,int _val){
		to = _to, nxt = _nxt, val = _val;
	}
};
Edge e[MAXN<<1];
int head[MAXN], cntEdge;
void addEdge(int a,int b,int c){
	e[cntEdge] = Edge(b,head[a],c);
	head[a] = cntEdge ++;
}

const int infty = (1<<30)-1;
pair<int,int> dis[MAXN];
int pq[MAXN<<1], pre[MAXN];
bool good[MAXN]; // special nodes of priority!
bool cmpDis(const int &a,const int &b){ return dis[a] < dis[b]; }
# define pushUp(x) pq[x] = cmpDis(pq[x<<1],pq[x<<1|1]) ? pq[x<<1] : pq[x<<1|1]
# define gengxin(pos,y) do{ dis[pos] = y;\
	for(int _o=pos+n; _o>>=1; ) pushUp(_o);} while(false)
void dijkstra(int x,int n){
	fill(dis,dis+n+1,make_pair(infty,0));
	dis[x] = make_pair(0,0); pair<int,int> nv;
	memset(pq+1,0,n<<2); rep(i,1,n) pq[i+n] = i;
	for(pq[1]=x,pre[x]=-1; pq[1]; ){
		x = pq[1]; pq[x+n] = 0;
		gengxin(x,dis[x]); // remove x
		if(good[x]) -- dis[x].second;
		for(int i=head[x]; ~i; i=e[i].nxt){
			nv.first = dis[x].first+e[i].val;
			nv.second = dis[x].second;
			if(dis[e[i].to] > nv){
				gengxin(e[i].to,nv);
				pre[e[i].to] = i; // edge id
			}
		}
	}
}

int goal[MAXN];
vector<int> path;
int main(){
	freopen("recover.in","r",stdin);
	freopen("recover.out","w",stdout);
	int n = readint(), m = readint();
	memset(head+1,-1,n<<2);
	for(int a,b,c; m; --m){
		a = readint(), b = readint();
		c = readint();
		addEdge(a,b,c), addEdge(b,a,c);
	}
	drep(i,m=readint(),1){	
		goal[i] = readint();
		good[goal[i]] = true;
	}
	dijkstra(goal[1],n); // whatever
	int far = *max_element(goal+1,goal+m+1,cmpDis);
	dijkstra(far,n); // one of the endpoint
	int res = *max_element(goal+1,goal+m+1,cmpDis);
	for(int i=res; true; i=e[pre[i]^1].to){
		if(pre[i] == -1) break; // game over
		path.push_back((pre[i]>>1)+1);
	}
	int len = int(path.size());
	writeint(len), putchar('\n');
	if(len == 0) return 0;
	writeint(path[0]);
	for(int i=1; i!=len; ++i){
		putchar(' ');
		writeint(path[i]);
	}
	putchar('\n');
	return 0;
}