PAT 1030

最新推荐文章于 2020-04-08 15:22:00 发布

原创最新推荐文章于 2020-04-08 15:22:00 发布 · 245 阅读

0 ·

CC 4.0 BY-SA版权

PAT 专栏收录该内容

90 篇文章

订阅专栏

本文介绍了一个基于Dijkstra算法实现的最短路径搜索方案，并在此基础上进一步优化了路径的成本，通过递归深度优先搜索（DFS）遍历所有可能的路径组合来找到最低成本的路径。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#include<cstdio>
#include<algorithm>
#include<vector>

using namespace std;

const int maxn=1010;
const int INF=100000000;
int dis[maxn],G[maxn][maxn];
int visit[maxn]={false};
vector<int>pre[maxn];

int n,m,s,d;
void dijkstra(int s)
{
	fill(dis,dis+maxn,INF);
	dis[s]=0;
	for(int i=0;i<n;i++)
	{
		int u=-1;
		int min=INF;
		for(int j=0;j<n;j++)
		{
			if(visit[j]==false&&dis[j]<min)
			{
				u=j;
				min=dis[j];
			}
		}
		if(u==-1)
			return;
		visit[u]=true;
		for(int v=0;v<n;v++)
		{
			if(visit[v]==false&&G[u][v]!=INF)
			{
				if(G[u][v]+dis[u]<dis[v])
				{
					dis[v]=G[u][v]+dis[u];
					pre[v].clear();
					pre[v].push_back(u);
				}
				else if(G[u][v]+dis[u]==dis[v])
				{
					pre[v].push_back(u);
				}
			}
		}
	}
}

vector<int> path,temppath;

int cost[maxn][maxn];
int optvalue=INF;

void DFS(int d)
{
	if(d==s)
	{
		temppath.push_back(d);
		int value=0;
		for(int i=temppath.size()-1;i>0;i--)
		{
			value+=cost[temppath[i]][temppath[i-1]];
		}
		if(value<optvalue)
		{
			optvalue=value;
			path=temppath;
		}
		temppath.pop_back();
		return;
	}
	temppath.push_back(d);
    for(int i=0;i<pre[d].size();i++)
	{	
		//int g=pre[d][i];
		DFS(pre[d][i]);	
	}
	temppath.pop_back();
}


int main()
{
	fill(cost[0],cost[0]+maxn*maxn,INF);
	fill(G[0],G[0]+maxn*maxn,INF);
	scanf("%d%d%d%d",&n,&m,&s,&d);
	int a,b,c,f;
	for(int i=0;i<m;i++)
	{
		scanf("%d%d%d%d",&a,&b,&c,&f);
		cost[a][b]=cost[b][a]=f;
		G[a][b]=G[b][a]=c;
	}
	dijkstra(s);
	DFS(d);
	for(int i=path.size()-1;i>=0;i--)
	{
		printf("%d ",path[i]);
	}
	printf("%d ",dis[d]);
	printf("%d",optvalue);

	system("pause");
	return 0;
}