最短路--Dijkstra&&Floyed&&SPFA

最短路径是一个很常见的问题,这里有3种方法,可供参考。

一.Dijkstra#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
int a[101][3];
double c[101];
bool b[101];
double f[101][101];
int n,i,j,k,x,y,m,s,e;
double minl;
double maxx = 1e30;
int main()
{
    cin >> n;
    for (i = 1; i <= n; i++)
        cin >> a[i][1] >> a[i][2];
    for (i = 1; i <= n; i++)
        for(j = 1; j <= n; j++)
            f[i][j] = maxx;
    cin >> m;
    for (i = 1; i <= m; i++)
    {
        cin >> x >> y;
        f[x][y] = f[y][x] = sqrt(pow(double(a[x][1]-a[y][1]),2)+pow(double(a[x][2]-a[y][2]),2));
    }
    cin>>s>>e;
    for(int i = 1;i <= n;i++)
    {
        c[i] = f[s][i];
    }
    memset(b,false,sizeof(b));
    b[s] = true;
    c[s] = 0;
    for(int i = 1;i <= n;i++)
    {
        minl = maxx;
        k = 0;
        for(int j = 1;j <= n;j++)
        {
            if(b[j] == false && c[j] < minl)//没走过的路程最小的点
            {
                minl = c[j];
                k = j;
            }
        }
        if(k == 0)
        break;
        b[k] = true;
        for(int j = 1;j <= n;j++)  //将所以能变的点最小路程全变了
        {
            if(c[k] + f[k][j] < c[j])
            c[j] = c[k] + f[k][j];
        }
    }
    printf("%.2lf",c[e]);
    return 0;
}
二.Floyed#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
double f[100][100];
int a[100][3];
int m,n,x,y,r,s,e;
int main()
{
    memset(f,127,sizeof(f));
    cin>>n;
    for(int i = 1;i <= n;i++)
    {
        cin>>a[i][1]>>a[i][2];
    }
    cin>>m;
    for(int i = 1;i <= m;i++)
    {
        cin>>x>>y;
        f[y][x] = f[x][y] = sqrt(pow(double(a[x][1]-a[y][1]),2)+pow(double(a[x][2]-a[y][2]),2));
    }
    cin>>s>>e;
    for(int k = 1;k <= n;k++)
    {
        for(int i = 1;i <= n;i++)
        {
            for(int j = 1;j <= n;j++)
            {
                if(f[i][j] > f[i][k] + f[k][j] && i != j && i != k && j != k)
                f[i][j] = f[i][k] + f[k][j];
            }
        }
    }
    printf("%.2lf",f[s][e]);
    return 0;
}
/*
5
0 0
2 0
2 2
0 2
3 1
5
1 2
1 3
1 4
2 5
3 5
1 5
*/
三.SPFA
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
int n,p,c,i,j,x,y,t,min1,head,tail,tot,u;
int a[801][801],b[501],dis[801],num[801],w[801][801];
queue <int> team;
bool exist[801];
int main()
{
    cin>>n>>p>>c;
    for(i=1;i<=p;i++)
    {
        b[i]=0;
        num[i]=0;
        for(j=1;j<=p;j++)
            w[i][j]=0x7fffffff/3;
    }
    for(i = 1;i <= n;i++)
        cin>>b[i];
    for(i=1;i<=c;i++)                                      //邻接矩阵存储
    {
        cin>>x>>y>>t;
        w[x][y] = t;
        a[x][++num[x]] = y;
        a[y][++num[y]] = x;
        w[y][x] = w[x][y];
    }
    min1=0x7fffffff/3;
    for(i=1;i<=p;i++)
    {
        for(j=1;j<=p;j++) dis[j]=0x7fffffff/3;                      //队列数组初始化
        memset(exist,false,sizeof(exist));                   //exist标志初始化
        dis[i]=0;
        exist[i]=true;
        team.push(i);
        while(!team.empty())
        {
            u = team.front();
            team.pop();
            exist[u] = true;
            for(int j = 1;j <= num[u];j++)
            {
                if(dis[a[u][j]] > dis[u] + w[u][a[u][j]])
                {
                    dis[a[u][j]] = dis[u] + w[u][a[u][j]];
                    if(!exist[a[u][j]])
                    {
                        team.push(a[u][j]);
                        a[u][j] = true;
                    }
                }
            }
        }
        tot=0;
        for(j=1;j<=n;j++)
        tot+=dis[b[j]];
        if (tot<min1) min1=tot;
    }
    cout<<min1;
    return 0;
}

原文地址:https://www.cnblogs.com/DukeLv/p/8366644.html

时间: 2024-10-12 04:07:00

最短路--Dijkstra&&Floyed&&SPFA的相关文章

UESTC - 30 B - 最短路(Dijkstra Floyed)

在每年的校赛里,所有进入决赛的同学都会获得一件很漂亮的T-shirt.但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候,却是非常累的!所以现在他们想要寻找最短的从商店到赛场的路线,你可以帮助他们吗? Input 输入包括多组数据. 每组数据第一行是两个整数NN,MM(N≤100N≤100,M≤10000M≤10000),NN表示成都的大街上有几个路口,标号为11的路口是商店所在地,标号为NN的路口是赛场所在地,MM则表示在成都有几条路.N=M=0N=M=0表示输入结束. 接下来MM行,

hdu1874 畅通project续 最短路 floyd或dijkstra或spfa

Problem Description 某省自从实行了非常多年的畅通project计划后.最终修建了非常多路.只是路多了也不好,每次要从一个城镇到还有一个城镇时,都有很多种道路方案能够选择.而某些方案要比还有一些方案行走的距离要短非常多.这让行人非常困扰. 如今,已知起点和终点.请你计算出要从起点到终点,最短须要行走多少距离. Input 本题目包括多组数据,请处理到文件结束. 每组数据第一行包括两个正整数N和M(0< N<200,0 < M<1000),分别代表现有城镇的数目和已

POJ 3013 Big Christmas Tree(最短路Dijkstra+优先队列优化,SPFA)

POJ 3013 Big Christmas Tree(最短路Dijkstra+优先队列优化,SPFA) ACM 题目地址:POJ 3013 题意: 圣诞树是由n个节点和e个边构成的,点编号1-n,树根为编号1,选择一些边,使得所有节点构成一棵树,选择边的代价是(子孙的点的重量)×(这条边的价值).求代价最小多少. 分析: 单看每个点被计算过的代价,很明显就是从根到节点的边的价值.所以这是个简单的单源最短路问题. 不过坑点还是很多的. 点的数量高达5w个,用矩阵存不行,只能用边存. 还有路径和结

HDU - 2544 - 最短路 (最基础单源最短路问题!!dijkstra+floyd+SPFA)

最短路 Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 34617    Accepted Submission(s): 15001 Problem Description 在每年的校赛里,所有进入决赛的同学都会获得一件很漂亮的t-shirt.但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候,却是非常累的!所以现在他们想要寻找

dijkstra,SPFA,Floyd求最短路

Dijkstra: 裸的算法,O(n^2),使用邻接矩阵: 算法思想: 定义两个集合,一开始集合1只有一个源点,集合2有剩下的点. STEP1:在集合2中找一个到源点距离最近的顶点k:min{d[k]} STEP2:把顶点k加入集合1中,同时修改集合2中的剩余顶点j的d[j]是否经过k之后变短,若变短则修改d[j]; if d[k]+a[k,j]<d[j] then   d[j]=d[k]+a[k,j]; STEP3:重复STEP1,直到集合2为空为止. #include <iostream&

POJ 2387 Til the Cows Come Home (最短路+Dijkstra)

Til the Cows Come Home Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 29550   Accepted: 9935 Description Bessie is out in the field and wants to get back to the barn to get as much sleep as possible before Farmer John wakes her for the

BOI&#39;98 DAY 2 TASK 1 CONFERENCE CALL Dijkstra/Dijkstra+priority_queue/SPFA

BOI'98 DAY 2 TASK 1 CONFERENCE CALL PROBLEM A telecom company would like to offer a three-party conference call service. This service enables three customers to participate in a telephone conversation simultaneously. A customer accesses the interconn

POJ1062 Expensive dowry 【最短路dijkstra】

详细看:http://blog.csdn.net/lyy289065406/article/details/6645852 简单说一下:每个物品是一个结点,边的权值是,edge[u][v]的值表示用物品u换物品v的价格 一开始所有物品都置为原价,即所有dist[i]为原价,用dijkstra算法,算出0点(啥物品都没有)到各点的最短距离,求出dist[1]即为花费 枚举每个物品的等级为这条交易链的最高等级,把所有等级高于它的或者比它小超过等级限制的点都剔除,可以用bool数组剔除,然后用上述的d

POJ-3268-最短路(dijkstra算法)

Silver Cow Party Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 12494   Accepted: 5568 Description One cow from each of N farms (1 ≤ N ≤ 1000) conveniently numbered 1..N is going to attend the big cow party to be held at farm #X (1 ≤ X