最短路径树简谈

在最开始，我们要知道最短路径树是个什么东西，不同于最小生成树，最短路径树是选一个节点为根，得到一颗树上的所有点，与原图中根节点到其的最短距离相等。

因为很多要用到边的记录，然而我比较菜只会用链式前向星方便的记录边，所以在写最短路路径树的过程中全用的链式前向星存图（

先来个比较板子的

题意：给定一张带正权的无向图和一个源点，求边权和最小的最短路径树。

思路：在跑dij的过程中记录每个点的前驱边，因为题目要求边权和最小，所以如果遇到相同的最短距离，我们应该选取前驱边更小的那一个，然后累加所有点的前驱边边权并排序输出答案即可。

#include<bits/stdc++.h>
#define int long long
using namespace std;
typedef pair<int,int>pii;
constexpr int maxn=6e5+5,inf=0x3f3f3f3f;
int n,m,k,t,cnt=0,head[maxn],ans=0;
int vis[maxn],dis[maxn],pre[maxn],a[maxn];
struct edge{
	int v,w,nex;
}e[maxn];
inline void add(int u,int v,int w){
	e[++cnt].v=v;
	e[cnt].w=w;
	e[cnt].nex=head[u];
	head[u]=cnt;
}
priority_queue<pii,vector<pii>,greater<pii>>q;
void dij(int s){
	memset(dis,inf,sizeof dis);
	dis[s]=0;
	q.push({0,s});
	while(!q.empty()){
		auto x=q.top();
		q.pop();
		int u=x.second;
		if(vis[u])continue;
		vis[u]=1;
		for(int i=head[u];i;i=e[i].nex){
			int v=e[i].v;
			int w=e[i].w;
			if(dis[v]>dis[u]+w){
				pre[v]=i;
				dis[v]=dis[u]+w;
				q.push({dis[v],v});
			}
			else if(dis[v]==dis[u]+w){
				if(e[pre[v]].w>e[i].w){
					pre[v]=i;
				}
			}
		}
	}
}
signed main(){
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		int u,v,w;
		cin>>u>>v>>w;
		add(u,v,w);
		add(v,u,w);
	}
	int st;
	cin>>st;
	dij(st);
	for(int i=1;i<=n;i++){
		ans+=e[pre[i]].w;
	}
	for(int i=1;i<=n;i++){
		a[i]=(pre[i]+1)/2;
	}
	sort(a+1,a+1+n);
	cout<<ans<<endl;
	for(int i=2;i<=n;i++){
		cout<<a[i]<<" ";
	}
	return 0;
}

题意：给一个$n$个点,$m$条边的无向简单带权连通图, 要求删边至最多剩余$k$条边.
定义"好点"是指删边后, $1$号节点到它的最短路长度仍然等于原图最短路长度的节点.
最大化删边后的好点个数.

思路：跑dij记录最短路径树的前驱边，最后$DFS$输出答案

#include<bits/stdc++.h>
#define int long long
using namespace std;
typedef pair<int,int>pii;
constexpr int maxn=6e5+5,inf=0x3f3f3f3f;
int n,m,k,t,cnt=0,head[maxn],ans=0;
int vis[maxn],dis[maxn],pre[maxn],a[maxn],vis1[maxn];
struct edge{
	int v,w,nex;
}e[maxn];
inline void add(int u,int v,int w){
	e[++cnt].v=v;
	e[cnt].w=w;
	e[cnt].nex=head[u];
	head[u]=cnt;
}
priority_queue<pii,vector<pii>,greater<pii>>q;
void dij(int s){
	memset(dis,inf,sizeof dis);
	dis[s]=0;
	q.push({0,s});
	while(!q.empty()){
		auto x=q.top();
		q.pop();
		int u=x.second;
		if(vis[u])continue;
		vis[u]=1;
		for(int i=head[u];i;i=e[i].nex){
			int v=e[i].v;
			int w=e[i].w;
			if(dis[v]>dis[u]+w){
				pre[v]=i;
				dis[v]=dis[u]+w;
				q.push({dis[v],v});
			}
			else if(dis[v]==dis[u]+w){
				if(e[pre[v]].w>e[i].w){
					pre[v]=i;
				}
			}
		}
	}
}
void dfs(int u){
	if(!k)return;
	for(int i=head[u];i;i=e[i].nex){
		int v=e[i].v;
		if(!vis1[i]&&pre[v]==(i)&&ans<k){
			ans++;
			a[ans]=i;
			vis1[i]=1;
			dfs(v);
		}
	}
}
signed main(){
	cin>>n>>m>>k;
	for(int i=1;i<=m;i++){
		int u,v,w;
		cin>>u>>v>>w;
		add(u,v,w);
		add(v,u,w);
	}
	dij(1);
	
	dfs(1);
	
	printf("%d\n",min(n-1,k));
	for(int i=1;i<=ans;i++){
		cout<<(a[i]+1)/2<<" ";
	}
	return 0;
}

题意：求最短路径树的方案数

思路：在跑dij的过程中，记录方案即可（其实就是个最短路计数？）

看似有难度其实水的一批

#include<bits/stdc++.h>
#define int long long
using namespace std;
typedef pair<int,int>pii;
constexpr int maxn=100005,inf=0x3f3f3f3f,mod=2147483647;

int n,m,k,t,cnt=0,head[maxn],ans=1;
int vis[maxn],dis[maxn],v[maxn];
int pre[maxn];

struct edge{
	int v,w,nex;
}e[2000005];
inline void add(int u,int v,int w){
	e[++cnt].v=v;
	e[cnt].w=w;
	e[cnt].nex=head[u];
	head[u]=cnt;
}
priority_queue<pii,vector<pii>,greater<pii>>q;
void dij(int s){
	memset(dis,inf,sizeof dis);
	dis[s]=0;
	q.push({0,s});
	while(!q.empty()){
		auto x=q.top();
		q.pop();
		int u=x.second;
		if(vis[u])continue;
		vis[u]=1;
		for(int i=head[u];i;i=e[i].nex){
			int v=e[i].v;
			int w=e[i].w;
			if(dis[v]>dis[u]+w){
				pre[v]=1;
				dis[v]=dis[u]+w;
				q.push({dis[v],v});
			}
			else if(dis[v]==dis[u]+w){
				pre[v]++;
			}
		}
	}
}
signed main(){
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		int u,v,w;
		cin>>u>>v>>w;
		add(u,v,w);
		add(v,u,w);
	}
	dij(1);
	for(int i=2;i<=n;i++){
		ans=ans*pre[i]%mod;
	}
	cout<<ans;
	return 0;
}

题意：求k条最短路径树方案，若不足k条则输出所有可行方案

思路：记录每个点的所有前驱边，递归回溯输出方案

黑暗城堡的加强版本

#include<bits/stdc++.h>
#define int long long
using namespace std;
typedef pair<int,int>pii;
constexpr int maxn=4e5+5,inf=0x3f3f3f3f,mod=1ll<<31-1;

int n,m,k,t,cnt=0,head[maxn],ans=1;
int vis[maxn],dis[maxn],v[maxn];
vector<int>pre[maxn];

struct edge{
	int v,w,nex;
}e[maxn];
inline void add(int u,int v,int w){
	e[++cnt].v=v;
	e[cnt].w=w;
	e[cnt].nex=head[u];
	head[u]=cnt;
}
priority_queue<pii,vector<pii>,greater<pii>>q;
void dij(int s){
	memset(dis,inf,sizeof dis);
	dis[s]=0;
	q.push({0,s});
	while(!q.empty()){
		auto x=q.top();
		q.pop();
		int u=x.second;
		if(vis[u])continue;
		vis[u]=1;
		for(int i=head[u];i;i=e[i].nex){
			int v=e[i].v;
			int w=e[i].w;
			if(dis[v]>dis[u]+w){
				pre[v].clear();
				pre[v].push_back(i);
				dis[v]=dis[u]+w;
				q.push({dis[v],v});
			}
			else if(dis[v]==dis[u]+w){
				/*if(e[pre[v]].w>e[i].w){
					pre[v]=i;
				}*/
				pre[v].push_back(i);
			}
		}
	}
}
void dfs(int x){
	if(x>n){
		for(int i=1;i<=m;i++){
			printf("%d",v[i]);
		}
		puts("");
		t++;
		if(t==k){
			exit(0);
		}
		return;
	}
	for(auto i:pre[x]){
		v[(i+1)/2]=1;
		dfs(x+1);
		v[(i+1)/2]=0;
	}
}
signed main(){
	cin>>n>>m>>k;
	for(int i=1;i<=m;i++){
		int u,v,w;
		cin>>u>>v;
		add(u,v,1);
		add(v,u,1);
	}
	dij(1);
	for(int i=2;i<=n;i++){
		ans=ans*pre[i].size();
		if(ans>k){
			ans=k;
			break;
		}
	}
	cout<<ans<<endl;
	dfs(2);
	return 0;
}