旅游规划。

#include <stdio.h>
#include <malloc.h>
#include <string.h>
#define ERROR -1
#define MaxVex 501
#define INF 0x3f3f3f3f
int Map[MaxVex][MaxVex];
int cost[MaxVex][MaxVex];
int Nv,Ne;
int visit[MaxVex]= {0};
int dist[MaxVex];
int Mcost[MaxVex];
void Init() {
	memset(Map,INF,sizeof(Map));
	memset(cost,0,sizeof(cost));
	int i;
	int v1,v2,p,c;
	for(i=0; i<Ne; i++) {
		scanf("%d %d %d %d",&v1,&v2,&p,&c);
		Map[v1][v2]=p;
		Map[v2][v1]=Map[v1][v2];
		cost[v1][v2]=c;
		cost[v2][v1]=cost[v1][v2];
	}
}
void D(int s) {
	visit[s]=1;
	int i,j,w;
	//加上这个好一点
	for(i=0;i<Nv;i++)
	{
		dist[i]=Map[s][i];
	}
	for(j=0; j<Nv; j++)
	{
		int MIN=INF;
		//min
		for(i=0; i<=Nv; i++) {
			if(!visit[i]) {
				if(dist[i]<MIN) {
					MIN=dist[i];
					w=i;
				}
			}
		}
		visit[w]=1;
		//更新邻接点，不再是无穷大
		for(i=0; i<=Nv; i++) {
			if(!visit[i]) {
				if(MIN+Map[w][i]<dist[i]) {
					dist[i]=MIN+Map[w][i];
					Mcost[i]=Mcost[w]+cost[w][i];
				} else if(MIN+Map[w][i]==dist[i]) {
					if(Mcost[i]>Mcost[w]+cost[w][i]) {
						Mcost[i]=Mcost[w]+cost[w][i];
					}
				}
			}
		}
	}
}
int main() {
	int s,d;
	scanf("%d %d %d %d",&Nv,&Ne,&s,&d);
	int i;
	for(i=0; i<Nv; i++) {
		visit[i]=0;
	}
	Init();
	for(i=0; i<Nv; i++) {
		dist[i]=Map[s][i];
		Mcost[i]=cost[s][i];
	}
	D(s);
	printf("%d %d",dist[d],Mcost[d]);
	return 0;
}

​​​​​​​

#include<stdio.h>
#include<stdlib.h>
typedef enum { false, true }bool;
#define MAX 500
#define INFINITY 65535
#define ERROR -1
typedef int Vertex;
typedef int WeightType;
typedef struct ENode *PtrToENode;
struct ENode{
	Vertex V1,V2;
	WeightType Dist,Cost;
};
typedef PtrToENode  Edge;
typedef struct GNode *PtrToGNode;
struct GNode{
	int Nv;
	int Ne;
	WeightType Dist[MAX][MAX];
	WeightType Cost[MAX][MAX];
	Vertex S,D;
};
typedef PtrToGNode MGraph;
MGraph CreateGraph(int Nv);
void InsertEdge(MGraph Graph,Edge E);
MGraph BuildGraph();
Vertex FindMinDist(MGraph Graph,int dist[],int collected[]);
void Dijkstra(MGraph Graph,int dist[],int cost[],Vertex S);
int main()
{
	int *dist,*cost;
	MGraph Graph=BuildGraph();
	dist=(int*)malloc(sizeof(int)*Graph->Nv);
	cost=(int*)malloc(sizeof(int)*Graph->Nv);
	Dijkstra(Graph,dist,cost,Graph->S);
	printf("%d %d\n",dist[Graph->D],cost[Graph->D]);
	
	return 0;
}
MGraph CreateGraph(int Nv)
{
	Vertex V,W;
	MGraph Graph;
	Graph=(MGraph)malloc(sizeof(struct GNode));
	Graph->Nv=Nv;
	Graph->Ne=0;
	for(V=0;V<Graph->Nv;V++)
		for(W=0;Graph->Nv;W++)
			Graph->Dist[V][W]=Graph->Cost[V][W]=INFINITY;
	return Graph;
}
void InsertEdge(MGraph Graph,Edge E)
{
	Graph->Dist[E->V1][E->V2]=E->Dist;
	Graph->Cost[E->V1][E->V2]=E->Cost;
	
	Graph->Dist[E->V2][E->V1]=E->Dist;
	Graph->Cost[E->V2][E->V1]=E->Cost;
}
MGraph BuildGraph()
{
	MGraph Graph;
	Edge E;
	Vertex V;
	int Nv,i;
	scanf("%d",&Nv);
	Graph=CreateGraph(Nv);
	scanf("%d",&(Graph->Ne));
	scanf("%d %d",&(Graph->S),&(Graph->D));
	if(Graph->Ne!=0){
		E=(Edge)malloc(sizeof(struct ENode));
		for(i=0;i<Graph->Ne;i++)
		{
			scanf("%d %d %d %d",&E->V1,&E->V2,&E->Dist,&E->Cost);
			InsertEdge(Graph,E);
		}
	}
	return Graph;
}
Vertex FindMinDist(MGraph Graph,int dist[],int collected[])
{
	Vertex MinV,V;
	int MinDist=INFINITY;
	for(V=0;V<Graph->Nv;V++)
	{
		if(collected[V]==false&&dist[V]<MinDist)
		{
			MinDist=dist[V];
			MinV=V;
		}
	}
	if(MinDist<INFINITY)
		return MinV;
	else return ERROR;
}
void Dijkstra(MGraph Graph,int dist[],int cost[],Vertex S)
{
	int collected[MAX];
	Vertex V,W;
	//初始化
	for(V=0;V<Graph->Nv;V++)
	{
		dist[V]=Graph->Dist[S][V];
		cost[V]=Graph->Cost[S][V];
		collected[V]=false;
	}
	dist[S]=cost[S]=0;
	collected[S]=true;
	while(1){
		//TODO
		V=FindMinDist(Graph,dist,collected);
		if(V==ERROR) break;
		collected[V]=true;
		for(W=0;W<Graph->Nv;W++)
		{
			if(collected[W]==false&&Graph->Dist[V][W]<INFINITY)
			{
				if(dist[V]+Graph->Dist[V][W]<dist[W]){
					dist[W]=dist[V]+Graph->Dist[V][W];
					cost[W]=cost[V]+Graph->Cost[V][W];
				}
				else if(dist[V]+Graph->Dist[V][W]==dist[W]&&cost[V]+Graph->Cost[V][W]<cost[W])
				{
					cost[W]=cost[V]+Graph->Cost[V][W];
				}
			}
		}
	}
}