第一周---最短路（Dijkstra、SPFA）

最新推荐文章于 2022-04-03 16:55:25 发布
最新推荐文章于 2022-04-03 16:55:25 发布
阅读量365 收藏
点赞数
分类专栏： POJ HDU 图论 文章标签： dijkstra spfa poj
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/llwwlql/article/details/70213247
版权
HDU 同时被 3 个专栏收录
77 篇文章 0 订阅
订阅专栏
POJ
27 篇文章 0 订阅
订阅专栏
图论
14 篇文章 0 订阅
订阅专栏

训练链接：

https://vjudge.net/contest/157742

Poj 2387

题意：

  • 给出N个谷仓，T条路径，求出从1谷仓到N号谷仓的最短距离。

分析：

  • Dijkstra模板题目，只是需要注意判断重边的情况。

AC代码：

  • 用邻接矩阵存储
#include <stdio.h>
#include <string.h>
#define INF 1<<30
int map[1005][1005];
int dis[1005];
int vis[1005];
int T,N;
void dij()
{
    int i,j;
    memset(vis,0,sizeof(vis));
    for(i=0;i<=N;i++)
        dis[i]=map[1][i];
    int mark=0;
    vis[1]=1;
    for(i=1;i<N;i++)
    {
        int min=INF;
        for(j=2;j<=N;j++)
        {
            if(!vis[j] && dis[j]<min)
            {
                min=dis[j];
                mark=j;
            }
        }
        vis[mark]=1;

        for(j=2;j<=N;j++)
        {
            if(!vis[j] && dis[j] > dis[mark] + map[mark][j])
                dis[j] = dis[mark] + map[mark][j];
        }
    }
}

int main()
{
    int i,j;
    int a,b,c;
    while(~scanf("%d %d",&T,&N))
    {
        for(i=0;i<=N;i++)
        {
            for(j=0;j<=N;j++)
                map[i][j]= i==j? 0 : INF;

        }

        for(i=0;i<T;i++)
        {
            scanf("%d %d %d",&a,&b,&c);
            if(c<map[a][b])
                map[a][b]=map[b][a]=c;
        }

        dij();
        printf("%d\n",dis[N]);
    }

    return 0;
}
  • 用链式前向星存储，WA，待调整
#include <stdio.h>
#include <string.h>
#define INF 1<<30
struct edge{
    int next;
    int to;
    int w;
}edge[2005];
int head[1005];
int cnt;
int dis[1005],vis[1005];
int n,t;

void add(int u,int v,int w)
{
    edge[cnt].w = w;
    edge[cnt].to = v;
    edge[cnt].next = head[u];
    head[u] = cnt++;
}

void dij(){
    int i,j;
    memset(vis,0,sizeof(vis));

    for(i=0;i<=n;i++)
        dis[i] = INF;

    for(i = head[1]; i!=-1 ; i=edge[i].next)
        dis[edge[i].to] = edge[i].w;

    vis[1]=1;
    dis[1]=0;
    int mark=0;
    for(i=2;i<=n;i++)
    {
        int min=INF;
        for(j=2;j<=n;j++)
        {
            if(!vis[j] && dis[j]<min)
            {
                min = dis[j];
                mark=j;
            }
        }
        vis[mark]=1;

        for(j = head[mark] ; j!=-1 ; j=edge[j].next)
        {
            if(!vis[edge[j].to] && dis[edge[j].to] > dis[mark] + edge[j].w)
                dis[edge[j].to] = dis[mark] + edge[j].w;
        }
    }
}

int main()
{
    int i,j;
    int u,v,w;
    while(scanf("%d %d",&t,&n)!=EOF)
    {
        cnt=0;
        for(i=0;i<=n;i++)
            head[i]=-1;
        for(i=0;i<t;i++)
        {
            scanf("%d %d %d",&u,&v,&w);
            add(u,v,w);
        }
        dij();
        printf("%d\n",dis[n]);      
    }
    return 0;
}

Poj 2253

题意：

有两只青蛙和若干块石头，现在已知这些东西的坐标，两只青蛙A坐标和青蛙B坐标是第一个和第二个坐标，现在A青蛙想要到B青蛙那里去，并且A青蛙可以借助任意石头的跳跃，而从A到B有若干通路，问从A到B的所有通路上的最大边的最小值

分析：

求起点到终点的所有可能路径中权值最大的边的最小值问题。Dijkstra的变化，这里把dis数组的含义变成了最大边的最小值。该题目比较坑的地方是在输出，输出%lf就会报WA，输出%f就能AC。

AC代码：

#include <stdio.h>
#include <string.h>
#include <math.h>
#define INF 1<<30
struct Node{
    int x,y;
}node[205];

double dis[205];
int vis[205];
int n;
double map[205][205];

double distance(Node a,Node b){
    return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

double max(double a,double b){
    return a>b?a:b;
}

void dijkstra(){
    int i,j;
    int mark=0;
    memset(vis,0,sizeof(vis));
    for(i=0;i<n;i++)
        dis[i] = map[0][i];
    vis[0]=1;
    for(i=0;i<n;i++)
    {
        int min=INF;
        for(j=0;j<n;j++)
        {
            if(!vis[j] && dis[j]<min)
            {
                min=dis[j];
                mark = j;
            }
        }
        vis[mark]=1;

        for(j=0;j<n;j++)
        {
            double temp = max(dis[mark],map[mark][j]);
            if(dis[j]>temp)
                dis[j] = temp;
        }
    }
}

int main()
{
    int i,j;
    int cnt=1;
    while(scanf("%d",&n),n)
    {
        for(i=0;i<n;i++)
            scanf("%d %d",&node[i].x,&node[i].y);

        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
                map[i][j] = distance(node[i],node[j]);
            map[i][i]=0;
        }

        dijkstra();

        printf("Scenario #%d\nFrog Distance = %.3f\n\n",cnt++,dis[1]);
    }
    return 0;
}

Poj 1797

题意：

给出一些路和这条路最大能过的重量，求从1到n，能运送的最大重量。

分析：

Dijkstra的变形，和上面那道题目有些类似，这个dis代表的是最大能运送的重量。这个松弛操作是计算的max(dis[j] , max(dis[mark] , map[mark][j]));

AC代码：

#include <stdio.h>
#include <string.h>
#define INF 1<<30
int dis[1005];
int vis[1005];
int n,m;
int map[1005][1005];

int mmin(int a,int b)
{
    return a > b? b:a;
}

void dijkstra()
{
    int i,j;
    int mark=0;
    memset(vis,0,sizeof(vis));
    for(i=0;i<=n;i++)
        dis[i]=map[1][i];
    vis[1]=1;
    for(i=1;i<n;i++)
    {
        int max = 0;
        for(j=1;j<=n;j++)
        {
            if(!vis[j] && dis[j] > max)
            {
                max = dis[j];
                mark = j;
            }
        }
        vis[mark]=1;
        for(j=1;j<=n;j++)
        {
            int temp = mmin(dis[mark],map[mark][j]);
            if(!vis[j] && dis[j] < temp)
                dis[j] = temp;
        }
    }
}

int main()
{
    int T;
    int a,b,c,i,j;
    int cnt=0;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d %d",&n,&m);

        memset(map,0,sizeof(map));

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

        dijkstra();
        printf("Scenario #%d:\n%d\n\n",++cnt,dis[n]);
    }

    return 0;
}

训练链接：

https://vjudge.net/contest/157742

Poj 3268

题意：

奶牛开Party，都到第k号农场去，每个奶牛去第k个农场都走最短路，最后开完Party再回到自己农场且也是走最短路，问走的路程最远的距离是多少。

分析：

之前做过的题目，水题，两边Dijkstra就可以，奶牛到k农场的过程，把路径反着存，就相当于从k到任意其它奶牛的地方。

AC代码：

#include <stdio.h>
#define INF 1<<30
int map1[1005][1005],map2[1005][1005];
int n,m,k;
void dijkstra(int dis[],int map[][1005]){
    int i,j;
    int vis[1005]={0};
    for(i=1;i<=n;i++)
        dis[i] = map[k][i];
    vis[k]=1;
    int mark=0;
    for(i=1;i<n;i++)
    {
        int min=INF;
        for(j=1;j<=n;j++)
        {
            if(!vis[j] && dis[j]<min)
            {
                min = dis[j];
                mark = j;
            }
        }
        vis[mark] = 1;
        for(j=1;j<=n;j++)
        {
            if(!vis[j] && dis[j] > dis[mark] + map[mark][j])
                dis[j] = dis[mark] + map[mark][j];
        }
    }
}
int main()
{
    int i,j;
    int a,b,c;
    int dis1[1005],dis2[1005];
    while(scanf("%d %d %d",&n,&m,&k)!=EOF)
    {
        for(i=0;i<=n;i++)
        {
            for(j=0;j<=n;j++)
            {

                map1[i][j]= (i==j) ? 0:INF;
                map2[i][j]= (i==j) ? 0:INF;
            }

        }

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

        dijkstra(dis1,map1);
        dijkstra(dis2,map2);
        int max=-1;
        for(i=1;i<=n;i++)
        {
            if(max < dis1[i] + dis2[i])
                max = dis1[i] + dis2[i];
        }
        printf("%d\n",max);
    }

    return 0;
}

Poj 2502

题意：

给出家和学校的坐标(x,y)，给出几条地铁线以及地铁站的坐标，可以步行，也可坐地铁，步行10km/h，地铁40km/h。求从家到学校的用的最短时间是多少。

分析：

该题目对于输入的有一定的要求，重点在于把输入的地铁站转换成一个图。这里把家、学校、地铁站看成n个点，把同一地铁线上的点计算时间，其它坐标点都记录成走路通过的时间。然后就用Dijkstra计算就可以了

AC代码

#include <stdio.h>
#include <string.h>
#include <math.h>
#define INF 1<<30
struct node{
    int x,y;
};
double map[205][205];
double dic[205];
node p[205];
int n=0;
double dis(node a,node b)
{
    return sqrt((a.x-b.x) * (a.x-b.x) + (a.y-b.y) * (a.y-b.y));
}

void dijkstra()
{
    int i,j;
    int vis[205]={0};
    for(i=1;i<n;i++)
        dic[i]=map[0][i];
    int mark=0;
    for(i=1;i<n;i++)
    {
        int min=INF;
        for(j=1;j<n;j++)
        {
            if(!vis[j] && min>dic[j])
            {
                min = dic[j];
                mark=j;
            }
        }
        vis[mark]=1;
        for(j=1;j<n;j++)
        {
            if(!vis[j] && dic[j] > dic[mark] + map[mark][j])
                dic[j] = dic[mark] + map[mark][j];
        }
    }
}

int main()
{
    int i,j;
    node s,e;
    node temp;
    double foot = 10000.0/60;
    double subway = 40000.0/60;
    scanf("%d %d %d %d",&s.x,&s.y,&e.x,&e.y);
    p[0]=s;
    p[1]=e;
    n=2;
    for(i=0;i<=202;i++)
    {
        for(j=0;j<=202;j++)
            map[i][j]=-1;
    }
    node parent;
    parent.x=parent.y=-1;
    while(scanf("%d %d",&temp.x,&temp.y)!=EOF)
    {
        if(temp.x!=-1 ||temp.y!=-1)
        {
            if(parent.x != -1 || parent.y!=-1)
                map[n][n-1]=map[n-1][n]=dis(parent,temp)/subway;
            p[n]=temp;
            n++;
        }
        parent=temp;
    }
    for(i=0;i<n;i++)
    {
        for(j=i;j<n;j++)
        {
            if(map[i][j]==-1)
                map[i][j]=map[j][i]=dis(p[i],p[j])/foot;
        }
    }
    dijkstra();
    printf("%.0f\n",dic[1]);

    return 0;
}

HDU 2680

题意：

有n个车站，求从给出的m个起点到终点所花最短时间。

分析：

该题目把终点作为起点，起点作为终点计算最短路即可。可以用Dijkstra去写，这里我用的是SPFA + 邻接矩阵存储。

spfa介绍：

这里用到队列来实现的。首先把所有距离起点s的距离都标为无穷大，把它距离自己的距离标为0。用一个used数组标记该点是否在队列中。如果队列不为空，则队首元素出队列，user数组标记为0（标志为不在队列中），然后对该点相邻的边进行循环、松弛。如果距离更新，则判断更新的点是否在队列中，如果不在队列中，则进队列，user数组标记为1。

AC代码：

#include <stdio.h>
#include <string.h>
#include <queue>
#define INF 1<<29
using namespace std;
int map[1005][1005];
int dis[1005];
int vis[1005];
int n,m,s;
queue <int>q;
void spfa(){
    memset(vis,0,sizeof(vis));
    int i,j;
    for(i=0;i<=n;i++)
        dis[i]=INF;
    dis[s]=0;
    vis[s]=1;
    q.push(s);
    while(!q.empty())
    {
        int top = q.front();
        q.pop();
        vis[top]=0;
        for(i=1;i<=n;i++)
        {
            if(dis[i] > dis[top] + map[top][i])
            {
                dis[i] = dis[top] + map[top][i];
                if(!vis[i])
                {
                    vis[i]=1;
                    q.push(i);
                }
            }
        }
    }
}

int main()
{
    int i,j;
    int a,b,c;
    int k,t;
    while(scanf("%d %d %d",&n,&m,&s)!=EOF)
    {
        for(i=0;i<=n;i++)
        {
            for(j=0;j<=n;j++)
                map[i][j] = i==j? 0:INF;
        }
        for(i=0;i<m;i++)
        {
            scanf("%d %d %d",&a,&b,&c);
            if(c<map[b][a])
                map[b][a]=c;
        }
        spfa();
        scanf("%d",&k);
        int min=INF;
        for(i=0;i<k;i++)
        {
            scanf("%d",&t);
            if(min > dis[t])
                min = dis[t];
        }
        if(min==INF)
            printf("-1\n");
        else
            printf("%d\n",min);
    }

    return 0;
}

Poj 1511

题意：

要求计算从1到所有点的最短路与所有点返回到1的最短路的和。

分析：

如果数据小的话，可以用Dijkstra做的，但是这个题的数据量还是挺大的，n为10^6，所以我们就用了SPFA去求两遍最短路。
网上说要设置一个0，为所有点的起始点，这个题我没有明白为什么要这么做，因为题目已经给出了单源，只是求返回的时候要把路径反过来存储就可以。

#include <stdio.h>
#include <string.h>
#include <queue>
#define INF 1<<30
using namespace std;
struct node{
    int to,w;
    int next;
};
node edge1[1000005];
node edge2[1000005];
int head1[1000005];
int head2[1000005];
long long dis1[1000005];
long long dis2[1000005];
int used[1000005];
int n,m;
int cnt;
long long sum;
queue <int> q;
void add1(int u,int v,int w)
{
    edge1[cnt].next = head1[u];
    edge1[cnt].to = v;
    edge1[cnt].w = w;
    head1[u] = cnt;
}

void add2(int u,int v,int w)
{
    edge2[cnt].next = head2[u];
    edge2[cnt].to = v;
    edge2[cnt].w = w;
    head2[u] = cnt++;
}

void spfa(long long *dis,int *head,node *edge)
{
    memset(used,0,sizeof(used));
    for(int i=0;i<=n;i++)
        dis[i] = INF;
    dis[1]=0;
    q.push(1);
    used[1]=1;
    while(!q.empty())
    {
        int top = q.front();
        q.pop();
        used[top]=0;
        for(int k =head[top] ; k!=-1; k =edge[k].next)
        {
            //printf("<%d %d %d>\n",top,edge[k].to,edge[k].w);
            if(dis[edge[k].to] > dis[top] + edge[k].w)
            {
                dis[edge[k].to] = dis[top] + edge[k].w;
                if(!used[edge[k].to])
                {
                    q.push(edge[k].to);
                    used[edge[k].to]=1;
                }
            }
        }
    }
}

int main()
{
    int T;
    int i,j;
    int a,b,c;
    scanf("%d",&T);
    while(T--)
    {
        cnt=0;
        scanf("%d %d",&n,&m);
        for(i=0;i<=n;i++)
            head1[i]=head2[i]=-1;
        for(i=0;i<m;i++)
        {
            scanf("%d %d %d",&a,&b,&c);
            add1(a,b,c);
            add2(b,a,c);
        }
        sum = 0;
        spfa(dis1,head1,edge1);
        spfa(dis2,head2,edge2);
        for(i=2;i<=n;i++)
        {
            sum+=(dis1[i] + dis2[i]);
        }
        printf("%I64d\n",sum);
    }

    return 0;
}

Poj 1860

题意：

给出n中货币，和初始金钱，问能否第s种能否通过汇率交换，使它升值。给出A金钱换B金钱汇率为Rab，佣金为Cab，B金钱换A金钱汇率为Rba，佣金为Cba。

分析：

这题目是最短路的一个变形，只需要求单元最短路就可以，只是该题目如果存在解，则一定存在正向环，所以用spfa来解决这个题目。这里还存在一个问题，判断存在正向环的时候return true，但是队列不一定为空。所以一开始我是在每次计算之前先清空队列，但是我发现提交超时，所以改成了每次在函数中重新声明一个队列，这样就节省了清空队列的时间。

AC代码：

#include <stdio.h>
#include <string.h>
#include <queue>
#define N 105
using namespace std;
int n,m,s;
double money;
double dis[N];
int head[N];
int used[N];
int num[N];
int cnt=0;
struct node{
    int to;
    int next;
    double r,c;
};
node edge[N];
void add(int a,int b,double r,double c)
{
    edge[cnt].next = head[a];
    edge[cnt].to = b;
    edge[cnt].r = r;
    edge[cnt].c = c;
    head[a] = cnt++;
}

bool spfa()
{
    int i,j;
    queue <int> q;
    for(i=0;i<=n;i++)
        dis[i]= 0.0;
    dis[s] = money;
    memset(used,0,sizeof(used));
    memset(num,0,sizeof(num));
    q.push(s);
    used[s]=0;
    num[s]++;
    while(!q.empty())
    {
        int top = q.front();
        q.pop();
        used[top]=0;
        for(int k = head[top] ; k!=-1 ; k = edge[k].next)
        {
            int v = edge[k].to;
            if(dis[v] < (dis[top] - edge[k].c)*edge[k].r)
            {
                dis[v] = (dis[top] - edge[k].c)*edge[k].r;
                if(num[v]>=n)
                    return true;
                if(!used[v])
                {
                    used[v]=1;
                    num[v]++;
                    q.push(v);
                }
            }
        }
    }
    if(dis[s] > money)
        return true;
    return false;
}
int main()
{
    int i,j;
    int a,b;
    double r1,c1,r2,c2;
    while(scanf("%d %d %d %lf",&n,&m,&s,&money)!=EOF)
    {
        cnt=0;
        for(i=0;i<=n;i++)
            head[i]=-1;
        for(i=0;i<m;i++)
        {
            scanf("%d %d %lf %lf %lf %lf",&a,&b,&r1,&c1,&r2,&c2);
            add(a,b,r1,c1);
            add(b,a,r2,c2);
        }
        bool temp = spfa();
        if(temp)
            printf("YES\n");
        else
            printf("NO\n");
    }
    return 0;
}
L-75
关注
专栏目录
HDU - 2544 最短路 dijkstra+spfa
斯文~
07-24 169
https://vjudge.net/problem/HDU-2544 HDU - 2544 最短路 dijkstra+spfa题目分析AC代码 spfaAC代码 题目 在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候，却是非常累的！所以现在他们想要寻找最短的从商店到赛场的路线，你可以帮助他们吗？ Input 输入包括多组数据。每组数据第一行是两个整数N、M（N<=100，M<=10000），N表示成都的大街上有几个
最短路练习-Floyd-SPFA-Dijkstra
m0_51376859的博客
09-30 119
Border Restrictions Description To prevent the spread of the virus, many countries have closed their borders to travellers arriving from certain other countries. Over time, different people travel to different countries and it is still possible for the vi
【HDU - 2544 最短路】 最短路 dijkstra,spfa
于心有愧丶
08-29 292
A - 最短路 在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候，却是非常累的！所以现在他们想要寻找最短的从商店到赛场的路线，你可以帮助他们吗？  Input输入包括多组数据。每组数据第一行是两个整数N、M（N 输入保证至少存在1条商店到赛场的路线。  Output对
最短路-----spfa（单源最短路）
bleak_dream的博客
01-07 231
文章目录一、spfa1、算法一句话思想2、如何判负环呢？二、代码演示 一、spfa 1、算法 这东西属于bellmen-ford的优化，恕我直言，没看出来，到有点像dijkstra的改版，改成可以判负环的形式，时间复杂度是O（m）->O（n*m）的，看出题人想不想卡了（不过一般情况，只要出题人没问题，他都要卡一下） 开始演示： 设：dist[i]为源点S到i点的路经长度。 由松弛操作我们可知：dist[v] = min(dist[v], dist[u] + w)；只有当dist[u]变小的时候，d
最短路-SPFA
weixin_49393180的博客
02-01 600
最短路-SPFA 文章目录最短路-SPFASPFA算法描述模板例题POJ-3259 Wormholes题目描述思路分析详细代码POJ-1860 Currency Exchange题目描述思路分析详细代码POJ-1062 昂贵的聘礼题目描述思路分析详细代码 SPFA SPFA算法是基于Bellman-Ford队列优化的算法，通常处理求含负边权的单源最短路径的算法，可以用于判断是否有负权环，最坏时间复杂度O（VE）。 算法描述 初始化dist数组，除起点s以外的点的距离初始化为INF，dist[s]=0
Floyd Dijkstra Bellman-Ford spfa 四种最短路经典算法汇总 HDU 2544为例
Sothan
03-25 911
求单源最短路径，本文包括了Floyd， Dijkstra， Bellman-Ford， Spfa算法。
最短路算法桶（Dijkstra，Floyd，Bellman-Ford，Spfa）
一只不争气的蒸汽机的博客
11-14 905
自己对最短路的简单总结并不涉及详解   1.Dijkstra 算法思想：（求单源最短路，朴素算法复杂度O(n^2)，堆优化O(nlogn) 将点分为两类，一类为已被更新最短距离的点为“标记点”，另一类为还没有被更新最短距离的点为“未标记点”。初始dist[i]=INF 一开始将起点到起点的距离标记为0，加入优先队列（dist从小到大排序）；每次取dist最小的点（即与起始点距离最小的点）...
ACM算法--spfa算法--最短路算法
xuanweiace的博客
07-31 452
 求单源最短路的SPFA算法的全称是：Shortest Path Faster Algorithm。      SPFA算法是西南交通大学段凡丁于1994年发表的。     从名字我们就可以看出，这种算法在效率上一定有过人之处。      很多时候，给定的图存在负权边，这时类似Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。有人称sp...
蓝桥杯_图论_2 (最短路 [ Dijkstra - SPFA - Floyd ] )
violet的博客
04-03 165
#include using namespace std; /*最短路 ①单源最短路 所有边权都是正数 朴素Dijkstra算法 O(n2) ，n为点数 ，m为边数 【稠密图使用】 堆优化版的Dijkstra算法 O(mlogn) 【稀疏图使用】 存在负权边 Bellman-Ford O(nm) [不超过多少条边，此算法做] SPFA 一般：O(m) ，最坏 O(nm) 【目前掌握这个就可以】 ②多源汇最短路 Floyd算法 O(n3) */ /*朴素Dijkstra算法 O(n2) Dij
图论- 最短路- Bellman-Ford 算法与 SPFA.rar
09-16
SPFA是基于队列的一种启发式最短路径算法，主要针对Dijkstra算法在处理负权重边时的不足。虽然其具体实现细节可能因人而异，但通常包括以下步骤： 1. 初始化：创建一个队列，将源点加入队列，并将其到源点的距离设...
最短路全家桶（Floyd,Dijkstra,SPFA）
06-02
1. **Floyd算法**，也称为Floyd-Warshall算法，是一种解决所有对最短路径问题的动态规划方法。它通过不断尝试所有可能的中间节点来更新最短路径。Floyd算法的基本思想是，对于图中任意两点i和j，如果存在第三个节点k...
Dijkstra----图论最短路算法/Dijkstra堆/优先队列优化
weixin_43045799的博客
02-09 472
Dijkstra是图论最常用的最短路算法，floyed复杂度是O(n^3)，显然是超时的，Bellman-Ford也是超时问题，SPFA更不用说，已经死了 菊花图给你拿捏的死死的 所以万众瞩目的Dijkstra单源最短路径你怎么能不会呢，我也不会 先从未优化的dij开始讲起 大概的思路就是讲=将图上的点分为两类，一类是找到最短路的节点，一类是未找到最短路的节点(建议用一个bool数组就行，不同并查集) 那么讲讲准备，首先未优化的dij是通过；邻接矩阵存储的图，所以我们需要一个数组A[][]表示i和j直接连接
HDU 2083 简易版之最短距离
L-75的专栏
12-29 1394
简易版之最短距离 Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 14911    Accepted Submission(s): 6583 Problem Description 寒假的时候，ACBOY要去拜访很
HDU 1257最少拦截系统（贪心算法）
L-75的专栏
09-20 1306
最少拦截系统 Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 65536/32768K (Java/Other) Total Submission(s) : 1   Accepted Submission(s) : 1 Font: Times New Roman | Verdana | Georgia Font Size:
HDU 1575 Tr A（矩阵快速幂）
L-75的专栏
03-02 1194
Tr A Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 4016    Accepted Submission(s): 2994 Problem Description A为一个方阵，则Tr A表示A的迹（就是主对角
背包问题总结(01背包、完全背包、多重背包)
L-75的专栏
09-01 1174
1、 01背包问题 有n个物品，每个物品只有一件。 动归方程: (1)  二维数组解法      dp[i][j]=max{dp[i-1][j-w[i]]+v[i] , dp[i-1][j]}; (2)  一维数组解法      dp[j]=max{dp[j-w[i]]+v[i] , dp[j]} 附代码： HDU 2602 Bone Collector 二维数组： #in
HDU 迷瘴（贪心算法）
L-75的专栏
09-21 1076
迷瘴 Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 32768/32768K (Java/Other) Total Submission(s) : 4   Accepted Submission(s) : 1 Font: Times New Roman | Verdana | Georgia Font Size: ← →
HDU 2131 Probability
L-75的专栏
10-30 851
Probability Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 5634    Accepted Submission(s): 2811 Problem Description Mickey is intere
最短路徑算法详解：Dijkstra、Floyd、Bellman-Ford与SPFA
本文档是关于最短路问题的教程，涵盖了Dijkstra算法、Floyd算法、Bellman-Ford算法以及SPFA算法。这些算法都是解决图论中的经典问题，旨在寻找网络中两点间的最短路径或者所有点对的最短路径。 最短路徑問題是图论...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值