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

最新推荐文章于 2019-08-23 14:38:02 发布
最新推荐文章于 2019-08-23 14:38:02 发布
阅读量399 收藏
点赞数
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...
【刷题计划1】【poj分类转载】
loving coding
08-19 1341
----------------2018.4.10更新-----------------------原本这只是暑假刷题计划，后来因为某些原因，自己就不是很努力的刷题，现在情况有变，so，重新继续咯~下个月26号省赛，扣去中间实训的一周时间和几次校赛，大概只有一个月时间。目前计划是，每天基础算法题+cf上3题，专业课也先停了，自己这段时间只想认真写题。昨天晚上又失眠了，虽然我知道保证训练效率的关键是...
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...
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 1139
题目链接：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 766
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 828
题目连接：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 213
题目链接：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 220
原题网址：http://poj.org/problem?id=2457 题意：给出n条路 每条路的边权为1 求从1走到k要经过的最少的点的个数 并输出路径 最少点的个数 其实就是最短路径+1 那么怎么去记录路径呢？ 这里我们可以去开一个数组 记录当前这个点是由哪个点过来的 那么可以一直回溯 回溯到这个数组的初始化 等等 这是不是有点并查集的思想呢? 是的 确实是并查集找父节点的思想 那么我...
对dijkstra的浅见（引例 poj 2457）
code_or_code
07-02 1286
非负权值的但源最短路之 dijkstra dijkstra-------我认为这个算法的核心思想是：最短路径长度递增。 怎么理解呢？       假如有一条最短路径已经存在了，那么其中任意两点的路径都将是最短的，否则假设是不成立了。 算法实现过程：      已当前点 pos 更新，dis[ i ]的值（即 点 i 到源点的距离）     找出dis[ i ] 最小的 i 点
POJ 2457 Part Acquisition 最短路径
zck921031的专栏
06-26 1290
注意题目中点是从1-k，k是终点，同时也是图的大小。 用的是zju的模板。list[]链表的尾用list[i]->next==NULL来判断。点从0开始，到n-1，传进去的图的大小应该是k+1，否则....等着悲剧吧，反正我wa了好多次   Description The cows have been sent on a mission through space to acquire a
【最短路】poj2457 SPFA+记录路径
BonjourFFF的博客
07-12 2226
SPFA算法，简单回溯记录路径。 翻译来自scy Part Acquisition部分收购 题意：     奶牛们被送往太空去执行一个任务：为它们的农场收购一台挤奶机器。它们正通过 一个含有N颗行星的星系。（1     奶牛们决定了使用 K种（1 有发展货币，所以星球交易都是在货易系统下工作的：所有的交易都是用一种货物交换 另外一种货物。假设互相交易的两种货物是不同的。
POJ 2983算法题解：差分约束+Bellman优化技术
1. **POJ2983-Is the Information Reliable【差分约束+优化Bellman】.cpp**：这是一份包含了针对POJ2983题目的C++源代码，其中应用了差分约束和优化过的Bellman-Ford算法。 2. **POJ2983-Is the Information ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值