Heavy Transportation（最大生成树|最短路变形）

题目链接：Heavy Transportation

思路分析

最短路的变形，要知道最短路的核心思想就是 贪心

• dijkstra、prim是对顶点选取的贪心
  对于dijkstra、prim，每次从未收录的顶点中段一个dist最小的收入S集合
  收入S集合的顶点，最短路径是已经确定的
  而v节点出队时查看临边dist[to]>dist[v]+w，满足就入队(自动排序啦)
  这里dist维护的是节点v、to到源点的最短距离
  而本题，dist维护的应是源点到节点v、to的路上的最小边 的最大值
  那么自然尽可能走权值大的边
  从节点v走到节点to，v节点已经收录，
  说明dits[v]已经是源点到v的所有边的最小边，(尽可能大的结果)
  将v出队时要最后为to做考虑，dist[to]自然是越大越好，却不可能大于dist[v]
  要判断v到to这条边收不收，就要看to连上v这个节点之后是否dist[to]能大于原本的值

if(dist[to]<min(dist[v],w)){
dist[to]=min(dist[v],w);
Q.push(dist[to],to);
}
注意对于dist的初始化稍有不同，dist的值是要尽可能大，首先节点是按照dist的降序排列在队列中，且dist全部初始化为0（才可能被临界点v优化成更大的一个值），最初的dits【s】初始化为inf

• kruskal是对边的贪心
  将所有的边按从小到大排序，每一步都选最小的边，
  收集齐了n-1条边(n-1次合并两个不同的集合)就一定是最小生成树子树
  最后一次收的边使得顶点x、y在同一个集合时，最后收的这条边自然就是x到y的路上最大的一条边
  最大生成树/x到y的路上最短的一条边，只需从大到小将边排序

最大生成树

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <queue>
#define pii pair<int,int>
using namespace std;
const int inf=0x3f3f3f3f;
const int N=1005;
int n,m;
struct edge{
	int u,v,w;
	bool operator<(const edge& a)const{
		return w>a.w;
	}
};
vector<edge> e;
int fa[N];
int find(int x){
	if(x==fa[x])return x;
	return fa[x]=find(fa[x]);
}
signed main(){
//从1到n的路上的最大的最小边 
//1~n有许多条路，第i条路由x条边组成，求这x条边中最小权值的边 
	int t;
	scanf("%d",&t);
	for(int l=1;l<=t;l++){
		e.clear();
		scanf("%d%d",&n,&m);
		for(int i=1;i<=n;i++){
			fa[i]=i;
		}
		int u,v,w;
		for(int i=1;i<=m;i++){
			scanf("%d%d%d",&u,&v,&w);
			e.push_back({u,v,w});
//			e.push_back({v,u,w});
		}
		sort(e.begin(),e.end());
		int res;
		for(int i=0;i<m;i++){
//			if(cnt==n-1)break;//最小生成树
			int fx=find(e[i].u);
			int fy=find(e[i].v);
			if(fx!=fy){
				fa[fx]=fy;
			}
			if(find(1)==find(n)){
				res=e[i].w;
				break;
			} 
			
		}
		cout<<"Scenario #"<<l<<":"<<endl; 
		cout<<res<<endl<<endl;//要输入两个空格 \_/ 
//		if(l==t)cout<<endl;
	}
    return 0;
}

最短路变形（抓住最短路核心思想）

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <queue>
#define pii pair<int,int>
using namespace std;
const int inf=0x3f3f3f3f;
const int N=1005;
const int M=1e6+5;
int n,m;
struct edge{
	int to,nex,w;
}e[M<<1];
int head[N];
int cnt; 
void add(int u,int v,int w){
	e[++cnt].to=v;
	e[cnt].w=w;
	e[cnt].nex=head[u];
	head[u]=cnt;
}
int dist[N];
int vis[N];
void dijkstra(){
	for(int i=1;i<=n;i++){
		dist[i]=0;//根据dist[to]<min(dist[v],w)，可见dist[]要取尽可能大的值 
		vis[i]=0;
	}
	dist[1]=inf;
	priority_queue<pii,vector<pii>,less<pii> > Q;
	Q.push({inf,1});
	for(int t=0;t<n;t++){
		if(Q.empty())break;//用prim的习惯，不影响最小路，不加就ＲＥ 
		pii p=Q.top();Q.pop();
		int v=p.second;
		if(vis[v]){
			t--;
			continue;
		}
		vis[v]=1;
		for(int i=head[v];i;i=e[i].nex){
			int to=e[i].to;
			int w=e[i].w;
//v的dist已经是所求，即将出队 ，出对前再看看能否帮助邻节点优化一点dist 
//			if(dist[to]>dits[v]+w){//v帮助to优化dist[to](to到源点的距离) 
//				dist[to]=dits[v]+w;
//				Q.push(dist[to],to);
//			} 
			if(!vis[to]&&dist[to]<min(dist[v],w)){
				dist[to]=min(dist[v],w);
				Q.push({dist[to],to});
			} 
		}
	}
}
signed main(){
//从1到n的路上的最大的最小边 
//1~n有许多条路，第i条路由x条边组成，求这x条边中最小权值的边 
	int t;
//	cin>>t;
	scanf("%d",&t);
	for(int l=1;l<=t;l++){
		cnt=0;
		fill(head,head+N,0);
//		cin>>n>>m;
		scanf("%d%d",&n,&m);
		int u,v,w;
		for(int i=1;i<=m;i++){
//			cin>>u>>v>>w;
			scanf("%d%d%d",&u,&v,&w);
			add(u,v,w);
			add(v,u,w);
		}
		dijkstra();
		cout<<"Scenario #"<<l<<":"<<endl; 
		cout<<dist[n]<<endl<<endl;//要输入两个空格 \_/ 
//		if(l==t)cout<<endl;
	}
    return 0;
}

套路完全相同的题

Frogger

#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
#include <math.h>
#include <iomanip>
#define pii pair<double,int>
using namespace std;
const double inf=1e9;
const int N=1005;
const int M=2e4+5;
int n,m,x;
struct edge{
	int to,nex;
	double w;
}e[M<<1];
int head[N];
int cnt=0; 
void add(int u,int v,double w){
	e[++cnt].to=v;
	e[cnt].w=w;
	e[cnt].nex=head[u];
	head[u]=cnt;
}
bool vis[N];
double dist[N];
double maxx(double x,double y){
	if(x>y)return x;
	else return y;
}
void dijkstra(int x){
	for(int i=1;i<=n;i++){
		vis[i]=false;
		dist[i]=inf;
	}
	dist[x]=0;
	priority_queue<pii,vector<pii>, greater<pii> > Q;
	Q.push({0,x});
	for(int t=0;t<n;t++){
		pii p=Q.top();Q.pop();
		int v=p.second;
		if(vis[v]){
			t--;
			continue; 
		}
		vis[v]=1;
		for(int i=head[v];i;i=e[i].nex){
			int to=e[i].to;
			if((vis[to]==false)&&dist[to]>maxx(dist[v],e[i].w)){
					dist[to]=maxx(dist[v],e[i].w);
					Q.push({dist[to],to});
			}
		}
	}
}
//最小的最大边，dits[]维持源点到to的最大边，尽可能最小 
struct node{
	int sign,x,y;
};
vector<node> v;
double fun(int x1,int y1,int x2,int y2){
	return 1.000*(double)sqrt((double)(x1-x2)*(x1-x2)+(double)(y1-y2)*(y1-y2));
}
signed main(){
//	并不是要求最短路，而是路上的最大边最小的这条路径 
	int t=1;
	while(cin>>n&&n){
		int x,y;
		v.clear();
		cnt=0;
		fill(head,head+N,0);
		for(int i=1;i<=n;i++){
			cin>>x>>y;
			v.push_back({i,x,y});
		}
		for(int i=0;i<n;i++){
			for(int j=i+1;j<n;j++){
				double len=fun(v[i].x,v[i].y,v[j].x,v[j].y);
					add(v[i].sign,v[j].sign,len);
					add(v[j].sign,v[i].sign,len);
			}
		}
		dijkstra(1);
		cout<<"Scenario #"<<t++<<endl;
//		cout<<dist[2]<<endl;
		cout<<"Frog Distance = "<<fixed<<setprecision(3)<<dist[2]<<endl<<endl;
	}
    return 0;
}

最小的最大边（直接kruskal最小生成树）

#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
#include <math.h>
#include <iomanip>
using namespace std;
const double inf=1e9;
const int N=1005;
const int M=2e4+5;
int n,m,x;
double fun(int x1,int y1,int x2,int y2){
	return 1.000*(double)sqrt((double)(x1-x2)*(x1-x2)+(double)(y1-y2)*(y1-y2));
}
struct node{
	int sign,x,y;
};
vector<node> v;
struct edge{
	int u, v;
	double w;
	bool operator<(const edge &a)const{
		return w<a.w;
	}
};
vector<edge> e;
int fa[N];
int find(int x){
	if(fa[x]==x)return x;
	return fa[x]=find(fa[x]);
}
signed main(){
//	并不是要求最短路，而是路上的最大边最小的这条路径 
	int t=1;
	while(cin>>n&&n){
		int x,y;
		v.clear();
		e.clear();
		for(int i=1;i<=n;i++){
			cin>>x>>y;
			v.push_back({i,x,y});
			fa[i]=i;
		}
		for(int i=0;i<n;i++){
			for(int j=i+1;j<n;j++){
				double len=fun(v[i].x,v[i].y,v[j].x,v[j].y);
					e.push_back({v[i].sign,v[j].sign,len});
			}
		}
		sort(e.begin(),e.end());
		double res=0;
		for(int i=0;i<e.size();i++){
			int fx=find(e[i].u);
			int fy=find(e[i].v);
			if(fx!=fy){
				fa[fx]=fy;
//				res+=e[i].w;//是求最小的最大边啦，就是最后收录的那条边 
			}
			if(find(1)==find(2)){
				res=e[i].w;
				break;
			}
		}
		cout<<"Scenario #"<<t++<<endl;
//		cout<<dist[2]<<endl;
		cout<<"Frog Distance = "<<fixed<<setprecision(3)<<res<<endl<<endl;
	}
    return 0;
}