PAT甲级10.4最短路径

10.4.1 迪杰斯特拉算法

内容

1.将离起始点最近的未访问顶点u加入已访问集合S
2.将u作为中介点，优化起点s与所有u能到达（相连）的顶点v之间的距离
··

#include <cstdio>
#include <algorithm>
using namespace std;
const int maxv=1122;
const int INF=1000000000;
int n,m,s,G[maxv][maxv];
int d[maxv];
bool vis[maxv]={false};
 
void Dijkstra(int s)//s为源点
{
	fill(d,d+maxv,INF); //fill函数将整个数组d设置为INF
	d[s]=0; //起点s到达自生的距离为0
	for(int i=0;i<n;++i)
	{
		int u=-1,min=INF;//u使d[u]最小，min存放最小的d[u];
		for(int j=0;j<n;++j)
		{
			if(vis[j]==false&&d[j]<min)
			{
				u=j;
				min=d[j];
			}
		}
		//找不到小于INF的d[u]，说明剩下的顶点和起点s不连通
		if(u==-1)
			return;
		vis[u]=true;
		for(int v=0;v<n;v++)
		{
			//v未被访问&&以u为中介点使s到顶点v的最短距离d[v]更优
			if(vis[v]==false&&G[u][v]!=INF&&d[u]+G[u][v]<d[v])
			{
				d[v]=d[u]+G[u][v];// 优化d[v] 
			}
		 }
	}
} 
 
int main()
{
	int u,v,w;
	scanf("%d%d%d",&n,&m,&s);
	fill(G[0],G[0]+maxv*maxv,INF);//初始化图G
	for(int i=0;i<m;++i)
	{
		scanf("%d%d%d",&u,&v,&w);
		G[u][v]=w;
	}
	Dijkstra(s);
	for(int i=0;i<n;++i)
	{
		printf("%d ",d[i]);//输出到所有顶点的最短距离 
	}
	return 0;
}

1003. Emergency (25)-PAT甲级真题（Dijkstra算法）

Sample Input
5 6 0 2
1 2 1 5 3
0 1 1
0 2 2
0 3 1
1 2 1
2 4 1
3 4 1
Sample Output
2 4
题目大意：n个城市m条路，每个城市有救援小组，所有的边的边权已知。给定起点和终点，求从起点到终点的最短路径条数以及最短路径上的救援小组数目之和。如果有多条就输出点权（城市救援小组数目）最大的那个

#include<bits/stdc++.h>
using namespace std;
const int MAXV = 501;
const int INF = 1e9;
int n,m,s,st,ed;
int w[MAXV],G[MAXV][MAXV],weight[MAXV],d[MAXV],num[MAXV];
bool vis[MAXV]={false};
void dijkstra(int s){
	fill(d,d+MAXV,INF);
	d[s]=0;
	num[s]=1;
	w[s]=weight[s];
	//前期准备上
	for(int i=0;i<n;i++){//n次循环
		int u=-1,min=INF;
		for(int j=0;j<n;j++){//搜最小u加入
			if(d[j]<min&&vis[j]==false){
				u=j;min=d[j];
			}
		}
		if(u==-1)return;
		vis[u]=true;
			for(int v=0;v<n;v++){//扩展松弛
			if(G[u][v]!=INF&&vis[v]==false){
				if(d[v]>d[u]+G[u][v]){
					d[v]=d[u]+G[u][v];
					w[v]=w[u]+weight[v];
					num[v]=num[u];//使用
					
				}else if(d[v]==d[u]+G[u][v]){
					
					if(w[v]<w[u]+weight[v]){
						w[v]=w[u]+weight[v];
					}
					num[v]+=num[u];//相加
				}
			}
		}
	}
}
int main(){
	cin>>n>>m>>st>>ed;
	int u,v,d;
	for(int i=0;i<n;i++){
		cin>>weight[i];
	}
	fill(G[0],G[0]+MAXV*MAXV,INF);
	for(int i=0;i<m;i++){
		cin>>u>>v;
		cin>>G[u][v];
		G[v][u]=G[u][v];
	}
	dijkstra(st);
	cout<<num[ed]<<" "<<w[ed]; 	
	return 0;
} 

1030. Travel Plan (30)-PAT甲级真题（Dijkstra或者Dijkstra + DFS，输出路径，边权）

题目大意：求起点到终点的最短路径最短距离和花费，要求首先路径最短，其次花费最少，要输出完整路径

Dijkstra

#include<bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int MAXV = 5001;
bool vis[5001]={false};
int cost[MAXV][MAXV];
int G[MAXV][MAXV];
int c[MAXV];//st到i的最小花费
int d[MAXV];//st到i的最短距离
int pre[MAXV];
int n,m,st,ed;
void dijkstra(int s){
	fill(d,d+MAXV,INF);
	fill(c,c+MAXV,INF);
	for(int i=0;i<n;i++){
		pre[i]=i; 
	}
	c[s]=0;
	d[s]=0;
	for(int i = 0;i<n;i++){
		int u=-1,min=INF;
		for(int j=0;j<n;j++){
			if(vis[j]==false&&d[j]<min){
				u=j;min=d[j];
			}	
		}	
		if(u==-1)return;
		vis[u]=true;
		for(int v=0;v<n;v++){
			if(vis[v]==false&&G[u][v]!=INF){
				if(d[u]+G[u][v]<d[v]){
					d[v]=G[u][v]+d[u];
					c[v]=cost[u][v]+c[u];
					pre[v]=u;
				}
				else if(d[u]+G[u][v]==d[v]){
					if(c[v]>cost[u][v]+c[u])
					{
						c[v]=cost[u][v]+c[u];
						pre[v]=u;
					}
				}	
			}	
		} 
	}
}
void DFS(int v){
	if(v==st){
		cout<<v<<" ";
		return;
	}
	DFS(pre[v]);
	cout<<v<<" "; 
} 
int main(){
	cin>>n>>m>>st>>ed;
	int u,v; 
	fill(G[0],G[0]+MAXV*MAXV,INF);
	fill(cost[0],G[0]+MAXV*MAXV,INF);
	for(int i=0;i<m;i++){
		cin>>u>>v;
		cin>>G[u][v];
		G[v][u]=G[u][v];
		cin>>cost[u][v];
		cost[v][u]=cost[u][v];
	}
	dijkstra(st);
	DFS(ed);	
	cout<<d[ed]<<" "<<c[ed];//最短路径及其花费 
	return 0;
} 
/*
4 5 0 3
0 1 1 20
1 3 2 30
0 3 4 10
0 2 2 20
2 3 1 20
*/ 

Dijkstra + DFS

#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
int n, m, s, d;
int e[510][510], dis[510], cost[510][510];
vector<int> pre[510];
bool visit[510];
const int inf = 99999999;
vector<int> path, temppath;
int mincost = inf;
void dfs(int v) {
    temppath.push_back(v);
    if(v == s) {
        int tempcost = 0;
        for(int i = temppath.size() - 1; i > 0; i--) {
            int id = temppath[i], nextid = temppath[i-1];
            tempcost += cost[id][nextid];
        }
        if(tempcost < mincost) {
            mincost = tempcost;
            path = temppath;
        }
        temppath.pop_back();
        return ;
    }
    for(int i = 0; i < pre[v].size(); i++)
        dfs(pre[v][i]);
    temppath.pop_back();
}
int main() {
    fill(e[0], e[0] + 510 * 510, inf);
    fill(dis, dis + 510, inf);
    scanf("%d%d%d%d", &n, &m, &s, &d);
    for(int i = 0; i < m; i++) {
        int a, b;
        scanf("%d%d", &a, &b);
        scanf("%d", &e[a][b]);
        e[b][a] = e[a][b];
        scanf("%d", &cost[a][b]);
        cost[b][a] = cost[a][b];
    }
    pre[s].push_back(s);
    dis[s] = 0;
    for(int i = 0; i < n; i++) {
        int u = -1, minn = inf;
        for(int j = 0; j < n; j++) {
            if(visit[j] == false && dis[j] < minn) {
                u = j;
                minn = dis[j];
            }
        }
        if(u == -1) break;
        visit[u] = true;
        for(int v = 0; v < n; v++) {
            if(visit[v] == false && e[u][v] != inf) {
                if(dis[v] > dis[u] + e[u][v]) {
                    dis[v] = dis[u] + e[u][v];
                    pre[v].clear();
                    pre[v].push_back(u);
                } else if(dis[v] == dis[u] + e[u][v]) {
                    pre[v].push_back(u);
                }
            }
        }
    }
    dfs(d);
    for(int i = path.size() - 1; i >= 0; i--)
        printf("%d ", path[i]);
    printf("%d %d", dis[d], mincost);
    return 0;
}

10.4.3 Floyd算法

内容：全源最短路径

n限制在200内

例题 亚历山大黑暗驱散光明

#include<bits/stdc++.h>
using namespace std;
const int MAXV = 200;
const int INF = 1e9;
int n,m;
int dis[MAXV][MAXV];
void floyd(){
	for(int k=0;k<n;k++){
		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				if(dis[i][k]!=INF&&dis[j][k]!=INF&&dis[i][k]+dis[k][j]<dis[i][j]){
					dis[i][j]=dis[i][k]+dis[k][j];
				}
			}
		}
	}
} 
int main(){
	int u,v,w;
	fill(dis[0],dis[0]+MAXV*MAXV,INF);
	cin>>n>>m;
	for(int i=0;i<n;i++){
		dis[i][i]=0;
	}
	for(int i=0;i<m;i++){
		cin>>u>>v>>w;
		dis[u][v]=w;
	}
	floyd();
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			cout<<dis[i][j]<<" ";
		}
		cout<<endl;
	}
	return 0;
}