|Dijkstra+dfs打印最短路径、多条最短路径、最小花费边权|1030 Travel Plan (30分)

link

int G[N][N],cost[N][N];
 fill(G[0],G[0]+N*N,INF);
    for(int i=0;i<m;i++){
        int u,v,tmp_w,tmp_c;
        cin>>u>>v>>tmp_w>>tmp_c;
        G[u][v]=G[v][u]=tmp_w;
        cost[u][v]=cost[v][u]=tmp_c;
    }

Dijkstra(s);
int d[N],c[N];
fill(d,d+N,INF);
memset(c,0,sizeof(c));
    
d[s]=0;
c[s]=0;
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]=d[u]+G[u][v];
                    c[v]=c[u]+cost[u][v];
                    pre[v]=u;
                }else if(d[u]+G[u][v]==d[v]){
                    if(c[u]+cost[u][v]<c[v]){
                        c[v]=c[u]+cost[u][v];
                        pre[v]=u;
                    }
                }
            }
        }
    }
}

    for(int i=0;i<n;i++){
        int MIN=INF,u=-1;
        for(int j=0;j<n;j++){
            if(vis[j]==false&&d[j]<MIN){
                MIN=d[j];
                u=j;
            }
        }
        if(u==-1)return;
        vis[u]=true;

dfs(e);
//打印路径 找爸爸
 void dfs(int v){
    //pre[2]=1//
    //pre[3]=2
    if(v==s){
        cout<<v<<" ";
        return;
    }
    dfs(pre[v]);//pre[v]=u
    cout<<v<<" ";
    
    //dfs(pre[3])==>dfs(2);
    //dfs(pre[2])==>dfs(1);
    //1==1=======>cout<<1;
    //cout<<2;
    //cout<<3;
}

cout<<d[e]<<" "<<c[e];

//City1 City2 Distance Cost
#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;
const int N=1010;
const int INF=1000000000;

int n,m,s,e;
int G[N][N],cost[N][N];
int d[N],c[N],pre[N];
bool vis[N]={false};

void dfs(int v){
    //pre[2]=1//
    //pre[3]=2
    if(v==s){
        cout<<v<<" ";
        return;
    }
    dfs(pre[v]);//pre[v]=u
    cout<<v<<" ";
    
    //dfs(pre[3])==>dfs(2);
    //dfs(pre[2])==>dfs(1);
    //1==1=======>cout<<1;
    //cout<<2;
    //cout<<3;
}

void Dijkstra(int s){
    fill(d,d+N,INF);
    memset(c,0,sizeof(c));
    
    d[s]=0;
    c[s]=0;
    
    for(int i=0;i<n;i++){
        int MIN=INF,u=-1;
        for(int j=0;j<n;j++){
            if(vis[j]==false&&d[j]<MIN){
                MIN=d[j];
                u=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]=d[u]+G[u][v];
                    c[v]=c[u]+cost[u][v];
                    pre[v]=u;
                }else if(d[u]+G[u][v]==d[v]){
                    if(c[u]+cost[u][v]<c[v]){
                        c[v]=c[u]+cost[u][v];
                        pre[v]=u;
                    }
                }
            }
        }
    }
}

int main()
{
    cin>>n>>m>>s>>e;
    fill(G[0],G[0]+N*N,INF);
    for(int i=0;i<m;i++){
        int u,v,tmp_w,tmp_c;
        cin>>u>>v>>tmp_w>>tmp_c;
        G[u][v]=G[v][u]=tmp_w;
        cost[u][v]=cost[v][u]=tmp_c;
    }
    Dijkstra(s);
    dfs(e);

    cout<<d[e]<<" "<<c[e];
    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

0 2 3 3 40
*/

//1.Dijkstra
//2.Dijkstra+dfs

//今天，我们用第1种方法
//边权的存储

#include <iostream>
using namespace std;

#include <iostream>
using namespace std;
const int N = 1000;
const int INF = 1000000000;

int n, m, s, e;//顶点数，边数，起点，终点
int G[N][N],cost[N][N];
int d[N],c[N],pre[N];//记录从起点到某个点的最短距离
bool vis[N] = { false };


void Dijkstra(int s) {
	fill(d, d + N, INF);
	fill(c, c + N, INF);
	for (int i = 0; i < n; i++)pre[i] = i;//怎么和并查集的init一样
	d[s] = 0;
	c[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]) {
					//以u为中介点能令d[v]变小
					d[v] = d[u] + G[u][v];
					c[v] = c[u] + cost[u][v];
					pre[v] = u;//相当于节点记录父亲
				}
				else if (d[u] + G[u][v] == d[v]) {//找到一条相同长度的路径
					if (c[u] + cost[u][v] < c[v]) {
						c[v] = c[u] + cost[u][v];
						pre[v] = u;
					}
				}
			}
		}
	}
}

void dfs(int v) {//打印路径
	if (v == s) {//终止条件
		cout << v<<" ";
		return;
	}
	dfs(pre[v]);
	cout << v << " ";
	//笑死了
	//怎么和并查集的findF操作差不多
	//也是找爸爸，找到最上面的爸爸
	/*
int findF(int i){
	if(father[i]==i)return i;
	int f=findF(father[i]);
	father[i]=f;
	return f;
}
	*/
}

int main() {
	cin >> n >> m >> s >> e;
	fill(G[0], G[0] + N * N, INF);
	for (int i = 0; i < m; i++) {
		int u, v, tmp_w, tmp_cost;
		cin >> u >> v >> tmp_w >> tmp_cost;
		G[u][v] = G[v][u] = tmp_w;//无向边//双向边
		cost[u][v] = cost[v][u] = tmp_cost;
	}
	Dijkstra(s);
	dfs(e);//打印路径
	cout << d[e] << " " << c[e];//最短距离、最短距离下的最小花费
	return 0;
}