poj2457 Part Acquisition（dijkstra||spfa+路径记录优化）

最新推荐文章于 2020-01-29 22:09:42 发布
最新推荐文章于 2020-01-29 22:09:42 发布
阅读量401 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： poj 图论-最短路&差分约束 文章标签： poj
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Flynn_curry/article/details/52892555
本文详细介绍了使用Dijkstra和SPFA算法解决最短路径问题的方法，并对比了两种算法的实现细节，包括如何初始化变量、存储路径及优化技巧。此外，还提供了使用Floyd算法求解最短路径的示例。

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


http://poj.org/problem?id=2457

题意：m个关系n个货物，关系中的a b代表可以拿货物a换取货物b，构造一条最短路，起点1终点n，输出交换次数和路径。


思路：看了这个教程。注意是有向图。dijkstra和spfa事实上是一个思路，都是找到最短路后，沿着这条路根据找路时存储的前驱来存储相应的节点。记录路径的方式也有几种，刚开始用数组记录，绕的我头都晕了。后来用栈优化，一目了然。


这题后来也回顾过，好好想了想初始化问题。dijkstra和spfa其实都可以一开始就将dis数组置为无穷大，pre数组更新为-1。dijkstra中仅仅把dis[1]置为0，但是未访问，这样所有的点都能算上。spfa中第一个点要入队列，dis[1]置为0，变成已访问，同样可以算上所有的点。

这样初始化就不会对起点进行一些对pre和dis的繁琐操作，使思路更加清晰。


首先来终极简化版本，以后做路径题方式就是以这个为参考：

#include <stdio.h>
#include <algorithm>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <queue>
#include <stack>

using namespace std;

typedef long long LL;

const int N = 1005;
const int INF = 0x3f3f3f3f;

int dis[N], G[N][N], pre[N], ans[N], n;
bool vis[N];

void dijkstra(int s)
{
    memset(vis, false, sizeof(vis));
    memset(pre, -1, sizeof(pre));
    for(int i = 1; i <= n; i++)
        dis[i] = INF;
    dis[s] = 0;
    for(int i = 1; i <= n; i++)
    {
        int k = -1;
        for(int j = 1; j <= n; j++)
        {
            if(!vis[j] && (k==-1 || dis[j]<dis[k]))
                k = j;
        }
        if(k == -1) break;//已经遍历所有的点
        vis[k] = true;
        for(int j = 1; j <= n; j++)
        {
            if(!vis[j] && dis[k]+G[k][j]<dis[j])
            {
                dis[j] = dis[k]+G[k][j];
                pre[j] = k;
            }
        }
    }
}

void spfa(int s)
{
    memset(vis, false, sizeof(vis));
    memset(pre, -1, sizeof(pre));
    queue<int>que;
    for(int i = 1; i <= n; i++)
        dis[i] = INF;
    dis[s] = 0;
    vis[s] = true;
    que.push(s);
    while(!que.empty())
    {
        int now = que.front();
        que.pop();
        vis[now] = false;
        for(int i = 1; i <= n; i++)
        {
            if(dis[now]+G[now][i]<dis[i])
            {
                dis[i] = dis[now]+G[now][i];
                pre[i] = now;
                if(!vis[i])
                {
                    vis[i] = true;
                    que.push(i);
                }
            }
        }
    }
}

void Print()
{
    stack<int>path;
    int now = n, cnt = 0;
    if(dis[n] == INF) printf("-1\n");
    else
    {
        while(now != -1)
        {
            path.push(now);
            now = pre[now];
            cnt++;
        }
        printf("%d\n", cnt);
        while(!path.empty())
        {
            printf("%d\n", path.top());
            path.pop();
        }
    }
}

int main()
{
  //  freopen("in.txt", "r", stdin);
    int m, s, e;
    scanf("%d%d", &m, &n);
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++)
        {
            if(i == j) G[i][j] = 0;
            else G[i][j] = INF;
        }
    for(int i = 1; i <= m; i++)
    {
        scanf("%d%d", &s, &e);
        G[s][e] = 1;
    }
  //  dijkstra(1);
    spfa(1);
    Print();
    return 0;
}


然后是这个把我绕晕了的数组记录路径：


#include <stdio.h>
#include <algorithm>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <queue>
#include <stack>

using namespace std;

typedef long long LL;

const int N = 1005;
const int INF = 0x3f3f3f3f;

int dis[N], G[N][N], pre[N], ans[N], n;
bool vis[N];

void dijkstra(int s)
{
    memset(vis, false, sizeof(vis));
    memset(pre, -1, sizeof(pre));
    for(int i = 1; i <= n; i++)
    {
        dis[i] = G[s][i];
        if(dis[i]!=INF && i!=s) pre[i] = s;
    }
    dis[s] = 0;
    vis[s] = true;
    for(int i = 1; i <= n; i++)
    {
        int k = -1;
        for(int j = 1; j <= n; j++)
        {
            if(!vis[j] && (k==-1 || dis[j]<dis[k]))
                k = j;
        }
        if(k == -1) break;//已经遍历所有的点
        vis[k] = true;
        for(int j = 1; j <= n; j++)
        {
            if(!vis[j] && dis[k]+G[k][j]<dis[j])
            {
                dis[j] = dis[k]+G[k][j];
                pre[j] = k;
            }
        }
    }
}

void spfa(int s)
{
    memset(vis, 0, sizeof(vis));
    memset(pre, -1, sizeof(pre));
    queue<int>que;
    for(int i = 1; i <= n; i++)
        dis[i] = INF;//初值记得赋无穷，而不是G数组中的值！
    dis[s] = 0;
    vis[s] = true;
    que.push(s);
    while(!que.empty())
    {
        int now = que.front();
        que.pop();
        vis[now] = false;//记得还原！！
        for(int i = 1; i <= n; i++)
        {
            if(dis[now]+G[now][i]<dis[i])
            {
                dis[i] = dis[now]+G[now][i];
                pre[i] = now;
                if(!vis[i])
                {
                    vis[i] = true;
                    que.push(i);
                }
            }
        }
    }
}

void print()
{
    memset(ans, 0, sizeof(ans));
    int cnt = 0;
    if(dis[n] == INF)
        printf("-1\n");
    else
    {
        ans[cnt++] = n;
        int tmp = pre[n];
        while(tmp != -1)
        {
            ans[cnt++] = tmp;
            tmp = pre[tmp];
        }
        printf("%d\n", cnt);
        for(int i = cnt-1; i >= 0; i--)
            printf("%d\n", ans[i]);
     //   printf("sad");
    }
}

int main()
{
   // freopen("in.txt", "r", stdin);
    int m, s, e;
    scanf("%d%d", &m, &n);
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++)
        {
            if(i == j) G[i][j] = 0;
            else G[i][j] = INF;
        }
    for(int i = 1; i <= m; i++)
    {
        scanf("%d%d", &s, &e);
        G[s][e] = 1;
    }
//    dijkstra(1);
    spfa(1);
    print();
    return 0;
}



后来用两种floyd敲了两次，都是TLE。大体思路就是二维数组在DP的时候已经将路径的前驱保存了下来，我们正好利用了这种特殊的性质。记录前驱就和前面思想一样，记录后继很方便，就是floyd的特权吧，然而复杂度太高，人家不让过哎= =


floyd记录前驱的路径记录法：

#include <stdio.h>
#include <algorithm>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <queue>

using namespace std;

typedef long long LL;

const int N = 1005;
const int INF = 0x3f3f3f3f;

int G[N][N], pre[N][N], ans[N], n;

void floyd()
{
    for(int k = 1; k <= n; k++)
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
            {
                if(G[i][k]+G[k][j] < G[i][j])
                {
                    G[i][j] = G[i][k]+G[k][j];
                    pre[i][j] = pre[k][j];
                }
            }
    pre[1][1] = -1;
}

void print()
{
    memset(ans, 0, sizeof(ans));
    int cnt = 0;
    if(G[1][n] == INF)
        printf("-1\n");
    else
    {
        ans[cnt++] = n;
        int tmp = pre[1][n];
        while(tmp != -1)
        {
            ans[cnt++] = tmp;
            tmp = pre[1][tmp];
        }
        printf("%d\n", cnt);
        for(int i = cnt-1; i >= 0; i--)
            printf("%d\n", ans[i]);
    }
}

int main()
{
  //  freopen("in.txt", "r", stdin);
    int m, s, e;
    scanf("%d%d", &m, &n);
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++)
        {
            if(i == j) G[i][j] = 0;
            else G[i][j] = INF;
            pre[i][j] = i;
        }
    for(int i = 1; i <= m; i++)
    {
        scanf("%d%d", &s, &e);
        G[s][e] = 1;
    }
    floyd();
    print();
    return 0;
}




floyd记录后继的路径记录法：

#include <stdio.h>
#include <algorithm>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <queue>

using namespace std;

typedef long long LL;

const int N = 1005;
const int INF = 0x3f3f3f3f;

int G[N][N], pre[N][N], n;

void floyd()
{
    for(int k = 1; k <= n; k++)
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
            {
                if(G[i][k]+G[k][j] < G[i][j])
                {
                    G[i][j] = G[i][k]+G[k][j];
                    pre[i][j] = pre[i][k];
                }
            }
    pre[n][n] = -1;
}

void print()
{
    int cnt = 0;
    if(G[1][n] == INF)
        printf("-1\n");
    else
    {
        printf("%d\n", G[1][n]+1);
        int tmp = pre[1][n];
        printf("%d\n", 1);
        while(tmp != -1)
        {
            printf("%d\n", tmp);
            tmp = pre[tmp][n];
        }
    }
}

int main()
{
  //  freopen("in.txt", "r", stdin);
    int m, s, e;
    scanf("%d%d", &m, &n);
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++)
        {
            if(i == j) G[i][j] = 0;
            else G[i][j] = INF;
            pre[i][j] = j;
        }
    for(int i = 1; i <= m; i++)
    {
        scanf("%d%d", &s, &e);
        G[s][e] = 1;
    }
    floyd();
    print();
    return 0;
}


Part Acquisition POJ - 2457 （Spfa+优先队列优化+输出路径）
Top_Spirit的博客
05-13 249
The cows have been sent on a mission through space to acquire a new milking machine for their barn. They are flying through a cluster of stars containing N (1 <= N <= 50,000) planets, each with...
POJ1722二维spfa+优先队列优化
墨鱼菜鸡
12-18 199
题意： 给你一个有向图，然后求从起点到终点的最短，但是还有一个限制，就是总花费不能超过k，也就是说每条边上有两个权值，一个是长度，一个是花费，求满足花费的最短长度。 思路： 一开始写了一个mark[i][j]第i个点花费j状态的spfa，TLE了，然后又优化了下，就是先反向搜索一遍简...
poj 2457
王纪刚的博客
03-15 349
Part Acquisition Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 4693   Accepted: 1998   Special Judge Description The cows have been sent on a mission thr
poj2457
weixin_33834910的博客
10-02 139
最短路 View Code #include &lt;iostream&gt;#include &lt;cstdlib&gt;#include &lt;cstring&gt;#include &lt;cstdio&gt;using namespace std;#define maxm 50005#define maxn 1005struct Edge{ int v, next;}e...
POJ 2457 Part Acquisition
weixin_34249678的博客
01-11 144
Part Acquisition Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 2909   Accepted: 1262   Special Judge Description The cows have been sent on a mission throu...
poj3259 Wormholes（floyd||spfa判断负环）
Iguodala的博客
05-31 878
http://poj.org/problem?id=3259 题意：n个点，m个正权边，w个负权边，正权边为双向，负权边为单向，判断是否有负环。 思路：首先知道何为负环，例如有3个点编号1,2,3，任意两点之间都存在一条边，那么1,2,3存在一个环，其上权值和为负即为负环。floyd和spfa两种做法，floyd法卡的时间紧，不但要把min改成普通判断，输出也不能在函数内。整体来说
『最短路径』单源无负权值最短路径算法——Dijkstra算法（优先队列优化 + C++实现 + 例题）
Miserable_ccf的博客
01-29 679
『算法原理』 最短路径（Shortest Path）：一个结点到另一个结点的最小权值和。 Dijkstra算法同时也叫单源最短路算法，其思想是——按路径长度递增的次序产生最短路的算法。 通俗来讲就是，找出从源点开始通过1条边可以到达的点的最小路径，2条边可以到达的点的最小路径，....，n-1条边可以到达的点的最小路径，将权值最小的点加入到集合S中，一直更新到终点位置，找到源点和终点的最小路...
poj1787 完全背包+路径记录总结
qq_34034442的博客
11-01 637
第一次接触完全背包，看了别人思路后再写的。 关于本题的背包问题的几个总结： 1. 注意分析全面转移条件，有时候这个问题会卡住 2. 这题的背包是每个物品有限个，本题中用cnt[]在转移条件中限制 3. 学会将问题转化，例如本题一开始想不到用背包，考虑用搜索如果真的搜索的话效率一定低下，但要求是硬币数最多的组合，就能用背包了 4. 通过Pre[]记录路径的方法很有意思   代码： ...
POJ2457(广搜)
immiao的专栏
12-05 651
需要输出路径，一开始没理清思路搞错了。 pre数组用来记录每个节点的父节点，记录路径。 #include #include #include #include using namespace std; bool vstd[50005]={false}; int pre[50005]; struct Vertex { int in,out; int pos; }A[50005];
POJ2457 Part Acquisition（Spfa最短路+记录路径）
Xuh7的专栏
04-03 1141
题目链接：http://poj.org/problem?id=2457 Part Acquisition Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 3345   Accepted: 1461   Special Judge Descript
poj 2457(spfa+路径保存）
坏坏的薯片
07-29 416
问题描述 The cows have been sent on a mission through space to acquire a new milking machine for their barn. They are flying through a cluster of stars containing N (1 <= N <= 50,000) planets, each wit
POJ-2457 SPFA+路径记录
qq_25881967的博客
07-17 289
思路：先建一个数组pre[MAXVEX]，松弛操作时，便将当前节点i的前驱节点j记下pre[i]=j。 因为SPFA已证明最短路上的起点到任意一点的路都为最短。所以SPFA后，得出的数组pre中 的元素j,便是起点到节点i最短路径上的前驱...(有点难表达....image...image)
poj——2457——Part Acquisition
清溪浅水
01-21 767
Description The cows have been sent on a mission through space to acquire a new milking machine for their barn. They are flying through a cluster of stars containing N (1 The cows have determin
poj 2457 Part Acquisition-dijkstra
桑榆
01-02 744
Part Acquisition Time Limit: 1000MS  Memory Limit: 65536K Total Submissions: 2842  Accepted: 1231  Special Judge Description The cows have been sent on a mission through space to acquire a new m
poj2457 Part Acquisition
Loi_whales 的坑
10-13 347
题目大意：给你一些点和边（单向边），所有边权都相等，问从第一个点到最后一个点最少经过多少点（包含初始和结束点），并把这条最短路的路径上的点输出来。 当然，把题目直接翻译过来的话不是上述内容，你需要转换成上面的意思，这是一道最短路还原路径的典型题（模板题），具体实现如下：#include <cstdio> #include <iostream> #include <cstring> #include
POJ 2457 Part Acquisition(最短路）
fire__ice的专栏
04-12 829
题目连接：http://poj.org/problem?id=2457 裸露的最短路，Dijkstra + 优先队列水过。。。 题意：就是求1到k之间的最短路，每条边的权值为1，若存在最短路，输出任意一条，若不存在，输出-1。 代码如下： #include #include #include #include using namespace std; #define INS 1<<29
POJ 2457 Part Acquisition - (BFS最短路打印)
rsy56640的博客
04-21 215
题目链接：http://poj.org/problem?id=2457 #include &lt;stdio.h&gt; #include &lt;vector&gt; #include &lt;algorithm&gt; #include &lt;queue&gt; using namespace std; //POJ 2457 Part Acquisition struct E...
poj 2457 最短路 输出路径 dijkstra
菜鸡的学习记录
08-23 221
原题网址：http://poj.org/problem?id=2457 题意：给出n条路 每条路的边权为1 求从1走到k要经过的最少的点的个数 并输出路径 最少点的个数 其实就是最短路径+1 那么怎么去记录路径呢？ 这里我们可以去开一个数组 记录当前这个点是由哪个点过来的 那么可以一直回溯 回溯到这个数组的初始化 等等 这是不是有点并查集的思想呢? 是的 确实是并查集找父节点的思想 那么我...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值