ACM新手DAY 6 最短路径

最新推荐文章于 2023-05-25 20:35:06 发布

Listening~

最新推荐文章于 2023-05-25 20:35:06 发布

阅读量272

点赞数

分类专栏： ACM 文章标签： ACM

本文链接：https://blog.csdn.net/listenhhh/article/details/96733175

版权

ACM 专栏收录该内容

37 篇文章 1 订阅

订阅专栏

题解

A - 最短路（样题）

题目：两个点之间可能有多条路线，求出从起点到终点的最短耗时

最短路
Dijkstra（迪杰斯特拉）算法¹。

#include<iostream>
#include<string.h>
using namespace std;
#define maxn 999999
int n,m,g[110][110],dis[110];
bool visit[110];
int Dijkstra(int src,int des)
{
    int temp,k;
    memset(visit,false,sizeof visit);
    for(int i=1;i<=n;i++)
    {
        dis[i]=(i==src?0:g[src][i]);
    }
    visit[src]=true;
    dis[src]=0;
    for(int i=1;i<=n;i++)
    {
        temp=maxn;
        for(int j=1;j<=n;j++)
        {
            if(!visit[j] && temp>dis[j])
                temp=dis[k=j];
        }
        if(temp==maxn)
            break;
        visit[k]=true;
        for(int j=1;j<=n;j++)
        {
            if(!visit[j]&&dis[j]>dis[k]+g[k][j])
                dis[j]=dis[k]+g[k][j];
        }
    }
    return dis[des];
}
int main()
{
    int ans;
    while(cin>>n>>m && (n+m))
    {
        memset(g,maxn,sizeof g);
        int a,b,c;
        while(m--)
        {
            cin>>a>>b>>c;
            if(c<g[a][b])
                g[a][b]=g[b][a]=c;
        }
        ans=Dijkstra(1,n);
        cout<<ans<<endl;
    }
    return 0;
}

B - 畅通工程续

与上一题的区别就是起点和终点需要读入，而且，存在不能找到从起点到终点的情况。思路是加一个bl数组初始化为0，出现过的城镇置为1，只要那些城镇都出现过，就一定有一条路从起点到终点。

C - 最短路径问题

要求路径最短的时候，费用也最少。

最短路
Dijkstra（迪杰斯特拉）算法
在路径判断的时候再加一个费用判断，当两条路长度一样时，优先选择费用少的。
读入部分

int a , b , l , p ;
			scanf("%d%d%d%d",&a,&b,&l,&p);
			if(g[a][b]>l)
			{
				g[a][b] = g[b][a] = l ;
				cost[a][b] = cost[b][a] = p ;
			}
			else if(g[a][b]==l && cost[a][b]>p)
			{
				cost[a][b] = cost[b][a] = p ;
			}

Dij函数部分

for(int j = 1 ; j<=n ; j++)
		{
			if(!vis[j] && dis[k]+g[k][j]<dis[j])
			{
				dis[j] = dis[k] + g[k][j];
				c[j] = c[k] + cost[k][j];
			}
			else if(!vis[j] && dis[k]+g[k][j]==dis[j])
			{
				if(c[j] > dis[k]+cost[k][j])
					c[j] = c[k]+cost[k][j];
			}
		}

D - find the longest of the shortest

题目：从起点到终点的最短路有m段，去掉其中某一段路可分别得到一个新的最短路，求这些最短路中的最大值

最短路+保存路径
Dijkstra（迪杰斯特拉）算法
分析：因为不知道是哪一段路坏了，所以先假设没有坏的路，走最短路径，开一个数组记录这条路的各个点，然后分别假设其中某一条路坏了，找到最短的路径。

#include<cstdio>
#include<cstring>

const int MAXINT = 999999;
int n, m;
int g[1010][1010], dis[1010], vis[1010];
int flag[1010];
bool bl;

void Dijkstra(int src)
{
    int  k, temp;
    memset(vis,0,sizeof vis);

    memset(dis, MAXINT, sizeof(dis));
    /*for(int i=1;i<=n;i++)
    {
        dis[i]=g[src][i];
    }*/
    dis[src] = 0;
    for(int i=1;i<=n;i++)
    {
        temp = MAXINT;
        for( int i = 1 ; i <= n ; i++ )
            if( !vis[i] && dis[i] < temp )
                temp = dis[k=i];
        if(temp==MAXINT)
            break;
        vis[k] = 1;
        for( int i = 1 ; i <= n ; i++ )
        {
            if( !vis[i] && dis[k]+g[k][i] < dis[i] )
            {
                dis[i] = dis[k]+g[k][i];
                if( !bl )   flag[i] = k;
            }
        }
    }
}
int main()
{
    while(~scanf("%d%d",&n,&m) )
    {
        memset( g, MAXINT, sizeof g);

        int a, b, c;
        for( int i = 0 ; i < m ; i++ )
        {
            scanf("%d%d%d",&a,&b,&c);
            if( g[a][b] > c )   g[a][b] = g[b][a] = c;
        }

        bl = false;
        Dijkstra(1);//实现一下标点
        bl = true;

        int maxx = 0;
        for( int i = n ; i > 1 ; i = flag[i] )
        {
            int ans = g[i][flag[i]];//中间变量
            g[i][flag[i]] = g[flag[i]][i] = MAXINT;//把路变成坏的
            Dijkstra(1);
            g[i][flag[i]] = g[flag[i]][i] = ans;//把路变回来
            if( dis[n] > maxx )  maxx = dis[n];
        }
        printf("%d\n",maxx );
    }
    return 0;
}

Dijkstra算法步骤
初始化：
1、将源点 $v_0$ 加到S中，即 $S[v_0] = true$ ；
将v0到各个终点的最短路径长度初始化为权值，即 $D [i] = G . a r c s [v 0] [v i] ， (v i \in V - S)$ ；
如果 $v_0$ 和顶点 $v_i$ 之间有弧，则将 $v_i$ 的前驱置为 $v_0$ ，即 $Path[i] = v_0$ ，否则 $P a t h [i] = - 1$ 。
2、选择下一条最短路径的终点vk，使得：
$D[k] = Min{D[i]|vi∈V − S}$
3、将 $v_k$ 加到S中，即 $S[v_k] = true$ 。
4、更新从 $v_0$ 出发到集合 $V - S$ 上任一顶点的最短路径的长度，同时更改 $v_l$ 的前驱为 $v_k$ 。
若 $D [k] + G . a r c s [k] [l] < D [l]$ ，则 $D [l] = D [k] + G . a r c s [k] [l]; P a t h [l] = k$ ;
5、重复②～④ n−1次，即可按照路径长度的递增顺序，逐个求得从 $v_0$ 到图上其余各顶点的最短路径。 ↩︎

Listening~

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ACM新手DAY 6 最短路径

题解A - 最短路以本题为模板做的讲解，直接放上代码，这个是Dijkstra（迪杰斯特拉）算法。Dijkstra算法步骤初始化：1、将源点v0加到S中，即S[v0] = true；将v0到各个终点的最短路径长度初始化为权值，即D[i] = G.arcs[v0][vi]，(vi∈V − S)；如果v0和顶点vi之间有弧，则将vi的前驱置为v0，即Path[i] = v0，否则Path[...
复制链接

扫一扫