UVa1078 Steam Roller(Dijkstra)

已于 2023-11-01 23:31:50 修改
阅读量175 收藏
点赞数
分类专栏： 算法设计与分析 OJ 训练指南 文章标签： Dijkstra
于 2023-10-29 22:47:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiexingshishu/article/details/134109480
版权

题意

给出一个图，边值不等于0的表示通过这条路所需要的时间，有如下一些约束

  • 在进入这条边前刚转弯
  • 离开这条边后立即转弯
  • 起点开始的边
  • 终点的边
    时间需要加倍，同时时间加倍不能叠加

问从起点到终点所需要的最短时间

思路

方法1：将一个点拆分成8个点，每个点有(r,c,dir,doubled)表示，表示上一步经过方向dir移动到(r,c)这个点，以及移动到这个点，边的值是否已经加倍。在构造图过程中，计算当前结点的后继结点时，首先看点对应方向是否可以走，在计算时间加倍时，如果到当前节点没有加倍，并且方向与下一步方向不一致，则上一步的边需要加倍，同时下一步的连也需要加倍
在根据遍历(r,c,dir,doubled)时，可以先遍历新的方向，看对应方向是否可行，来优化执行时间
方法2：添加一种静止点，即一个点扩展为5个点。由运动点转变为静止点以及继续运动，边的值不加倍。而静止点转变为继续运动和运动后再静止时边的值需要加倍

代码

方法1代码

#include <bits/stdc++.h>

using namespace std;

#define _for(i, a, b) for(int i = (a); i < (b); i++)
#define _rep(i, a, b) for (int i = (a); i <= (b); i++)

struct Edge
{
    int from, to, dist;
};

struct HeapNode
{
    int u, d;

    bool operator<(const HeapNode& other) const
    {
        return d > other.d;
    }
};



template <size_t SZV, int INF>
struct Dijkstra
{
    int n;
    bool done[SZV];
    vector<Edge> edges;
    vector<int> graph[SZV];
    int d[SZV];
    int p[SZV];

    void init(int n)
    {
        this-> n = n;
        _for(i, 0, n) {
            graph[i].clear();
        }
        edges.clear();
    }

    void addEdge(int from, int to, int d)
    {
        graph[from].push_back(edges.size());
        edges.push_back((Edge){from, to, d});
    }

    void dijkstra(int s)
    {
        priority_queue<HeapNode> pq;
        fill_n(done, n, false);
        fill_n(d, n, INF);
        d[s] = 0;
        pq.push({s, 0});

        while (!pq.empty()) {
            HeapNode curNode = pq.top();
            pq.pop();

            int u = curNode.u;
            if (done[u]) {
                continue;
            }

            done[u] = true;
            _for(i, 0, graph[u].size()) {
                Edge& edge = edges[graph[u][i]];
                if (d[u] + edge.dist < d[edge.to]) {
                    d[edge.to] = d[u] + edge.dist;
                    p[edge.to] = graph[u][i];
                    pq.push((HeapNode){edge.to, d[edge.to]});
                }
            }


        }
    }
};



void fastio()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
}

const int maxr = 100;
const int maxc = 100;
const int UP = 0, LEFT = 1, DOWN = 2, RIGHT = 3;
const int inv[] = {2, 3, 0, 1};
const int dr[] = {-1, 0, 1, 0};
const int dc[] = {0, -1, 0, 1};
const int MAXN = maxr * maxc * 8 + 2;
const int INF = 1e6;

int R, C;
int r1, c1, r2, c2;
int grid[maxr][maxc][4];
Dijkstra<MAXN, INF> solver;
int id[maxr][maxc][4][2];
int n;


int ID(int r, int c, int dir, int doubled)
{
    int& x= id[r][c][dir][doubled];
    if (x == 0) {
        x = ++n;
    }

    return x;
}

bool canGo(int r, int c, int dir)
{
    if (r < 0 || r >= R || c < 0 || c >= C) {
        return false;
    }

    return grid[r][c][dir] > 0;
}

int main()
{
    fastio();

    #ifndef ONLINE_JUDGE
        ifstream fin("f:\\OJ\\uva_in.txt");
        streambuf* back = cin.rdbuf(fin.rdbuf());
    #endif

    int kase = 1;
    while (cin >> R >> C >> r1 >> c1 >> r2 >> c2) {
        if (R == 0) {
            break;
        }

        --r1; --c1; --r2; --c2;
        _for(r, 0, R) {
            _for(c, 0, C - 1) {
                int num;
                cin >> num;
                grid[r][c][RIGHT] = grid[r][c + 1][LEFT] = num;
            }

            if (r != R - 1) {
                _for(c, 0, C) {
                    int num;
                    cin >> num;
                    grid[r][c][DOWN] = grid[r + 1][c][UP] = num;
                }
            }
        }

        solver.init(R * C * 8 + 1);
        n = 0;
        memset(id, 0x00, sizeof(id));


        _for(dir, 0, 4) {
            if (canGo(r1, c1, dir)) {
                solver.addEdge(0, ID(r1 + dr[dir], c1 + dc[dir], dir, 1), grid[r1][c1][dir] * 2);
            }
        }

        _for(r, 0, R) {
            _for(c, 0, C) {
                _for(dir, 0, 4) {
                    if (!canGo(r, c, inv[dir])) {
                        continue;
                    }
                     _for(newdir, 0, 4) {
                        if (!canGo(r, c, newdir)) {
                                continue;
                            }

                        _for(doubled, 0, 2) {


                            int newr = r + dr[newdir];
                            int newc = c + dc[newdir];
                            int v = grid[r][c][newdir];
                            int newdoubled = 0;

                            if (dir != newdir) {
                                if (!doubled) {
                                    v += grid[r][c][inv[dir]];
                                }
                                newdoubled = 1;
                                v += grid[r][c][newdir];
                            }

                            solver.addEdge(ID(r, c, dir, doubled), ID(newr, newc, newdir, newdoubled), v);
                        }
                    }
                }
            }
        }

        solver.dijkstra(0);

        int ans = INF;
        _for(dir, 0, 4) {
            if (!canGo(r2, c2, inv[dir])) {
                continue;
            }

            _for(doubled, 0, 2) {
                int v = solver.d[ID(r2, c2, dir, doubled)];
                //cout << "v:" << v << endl;
                if (!doubled) {
                    v += grid[r2][c2][inv[dir]];
                }

                ans = min(ans, v);
            }
        }

        cout << "Case " << kase++ << ": ";
        if (ans == INF) {
            cout << "Impossible" << endl;
        } else {
            cout << ans << endl;
        }
    }


    #ifndef ONLINE_JUDGE
        cin.rdbuf(back);
    #endif

    return 0;
}

方法2代码

#include <bits/stdc++.h>

using namespace std;

#define _for(i, a, b) for(int i = (a); i < (b); i++)
#define _rep(i, a, b) for (int i = (a); i <= (b); i++)

struct Edge
{
    int from, to, dist;
};

struct HeapNode
{
    int u, d;

    bool operator<(const HeapNode& other) const
    {
        return d > other.d;
    }
};



template <size_t SZV, int INF>
struct Dijkstra
{
    int n;
    bool done[SZV];
    vector<Edge> edges;
    vector<int> graph[SZV];
    int d[SZV];
    int p[SZV];

    void init(int n)
    {
        this-> n = n;
        _for(i, 0, n) {
            graph[i].clear();
        }
        edges.clear();
    }

    void addEdge(int from, int to, int d)
    {
        graph[from].push_back(edges.size());
        edges.push_back((Edge){from, to, d});
    }

    void dijkstra(int s)
    {
        priority_queue<HeapNode> pq;
        fill_n(done, n, false);
        fill_n(d, n, INF);
        d[s] = 0;
        pq.push({s, 0});

        while (!pq.empty()) {
            HeapNode curNode = pq.top();
            pq.pop();

            int u = curNode.u;
            if (done[u]) {
                continue;
            }

            done[u] = true;
            _for(i, 0, graph[u].size()) {
                Edge& edge = edges[graph[u][i]];
                if (d[u] + edge.dist < d[edge.to]) {
                    d[edge.to] = d[u] + edge.dist;
                    p[edge.to] = graph[u][i];
                    pq.push((HeapNode){edge.to, d[edge.to]});
                }
            }


        }
    }
};



void fastio()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
}

const int maxr = 100;
const int maxc = 100;
const int UP = 0, LEFT = 1, DOWN = 2, RIGHT = 3;
const int inv[] = {2, 3, 0, 1};
const int dr[] = {-1, 0, 1, 0};
const int dc[] = {0, -1, 0, 1};
const int MAXN = maxr * maxc * 8 + 2;
const int INF = 1e6;

int R, C;
int r1, c1, r2, c2;
int grid[maxr][maxc][4];
Dijkstra<MAXN, INF> solver;
int id[maxr][maxc][5];
int n;


int ID(int r, int c, int dir)
{
    int& x= id[r][c][dir];
    if (x == 0) {
        x = ++n;
    }

    return x;
}

bool canGo(int r, int c, int dir)
{
    if (r < 0 || r >= R || c < 0 || c >= C) {
        return false;
    }

    return grid[r][c][dir] > 0;
}

int main()
{
    fastio();

    #ifndef ONLINE_JUDGE
        ifstream fin("f:\\OJ\\uva_in.txt");
        streambuf* back = cin.rdbuf(fin.rdbuf());
    #endif

    int kase = 1;
    while (cin >> R >> C >> r1 >> c1 >> r2 >> c2) {
        if (R == 0) {
            break;
        }

        --r1; --c1; --r2; --c2;
        _for(r, 0, R) {
            _for(c, 0, C - 1) {
                int num;
                cin >> num;
                grid[r][c][RIGHT] = grid[r][c + 1][LEFT] = num;
            }

            if (r != R - 1) {
                _for(c, 0, C) {
                    int num;
                    cin >> num;
                    grid[r][c][DOWN] = grid[r + 1][c][UP] = num;
                }
            }
        }

        solver.init(R * C * 5 + 1);
        n = 0;
        memset(id, 0x00, sizeof(id));


        _for(dir, 0, 4) {
            if (!canGo(r1, c1, dir)) {
                continue;
            }

            solver.addEdge(0, ID(r1 + dr[dir], c1 + dc[dir], dir), grid[r1][c1][dir] * 2);
            solver.addEdge(0, ID(r1 + dr[dir], c1 + dc[dir], 4), grid[r1][c1][dir] * 2);
        }

        _for(r, 0, R) {
            _for(c, 0, C) {
                _for(dir, 0, 4) {
                    if (!canGo(r, c, inv[dir])) {
                        continue;
                    }

                    solver.addEdge(ID(r, c, dir), ID(r, c, 4), grid[r][c][inv[dir]]);


                    if (!canGo(r, c, dir)) {
                        continue;
                    }

                    solver.addEdge(ID(r, c, dir), ID(r + dr[dir], c + dc[dir], dir), grid[r][c][dir]);
                }

                _for(dir, 0, 4) {
                    if (!canGo(r, c, dir)) {
                        continue;
                    }

                    solver.addEdge(ID(r, c, 4), ID(r + dr[dir], c + dc[dir], dir), grid[r][c][dir] * 2);
                    solver.addEdge(ID(r, c, 4), ID(r + dr[dir], c + dc[dir], 4), grid[r][c][dir] * 2);
                }
            }
        }

        solver.dijkstra(0);

        int ans = solver.d[ID(r2, c2, 4)];
        cout << "Case " << kase++ << ": ";
        if (ans == INF) {
            cout << "Impossible" << endl;
        } else {
            cout << ans << endl;
        }
    }


    #ifndef ONLINE_JUDGE
        cin.rdbuf(back);
    #endif

    return 0;
}
kgduu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
roller:Apache Roller的镜像
05-14
Roller通常与Apache Tomcat和MySQL一起运行。 Roller由以下Maven项目组成： 滚子项目：顶级项目 app ：Roller Weblogger webapp，JSP页面，Velocity模板 assembly-release ：用于创建Roller的正式发行版 docs ：...
开源Java博客Roller源代码
03-18
Roller 是一个全功能的多用户博客平台，于2002年首发，采用Java语言开发，设计精巧，源代码是很好的学习资料。它支持weblogging应有的特性如：评论功能，所见即所得HTML编辑，TrackBack，提供页面模板，RSS ...
UVa 1078 Steam Roller
Fuxey
10-07 716
借鉴了陈峰在训练指南的思路， 表示感谢 提示： 1. 直接求最短路是有困难的， 因为状态不满足独立性 ， 所以拆点     2. 将(x , y)细分成 ， (x , y , dir , doubled)  ， 后两个分别为到这个点时的方向、这条边是否两次计算了     3. 将每一个状态用一个id 函数投射到一个具体的数值 ， 然后预处理所有状态之间的边(处理好那些double) ， 这样
Uva 1078 Steam Roller（多状态最短路）
hnust_Derker的博客
10-01 368
题意：有一个n条竖线m条横线组成的网络，你的任务是开着一辆蒸汽压路机，用最短的时间从一个点到另一个点，其中一些线段上的权值表示压路机全速前进所用的时间，0表示不能通过，由于蒸汽机的惯性较大所以在转弯前和转弯后那条边所走的实际速度都是全速前进速度的两倍。开始后和结束前的边也是两倍。时间加倍的规则是不会叠加的。最后给你两个顶点求最短路。 思路：设d[i][j][k][l] : 沿着第k(1 显然
UVA 1078 Steam Roller 建图 Dijksta
weixin_33875839的博客
03-29 65
把一个点(r,c)拆成（r,c,dir,doubled)八个点 表示上个点是从dir方向到(r,c)的，doubled表示那条边是否已经加倍。 而后就是考虑清楚细节，建图。 最后跑最短路。 //#pragma comment(linker, "/STACK:1024000000,1024000000") #include<cstdio> #include<cs...
uva 1078 - Steam Roller（最短路）
不慌不忙、不急不躁
09-07 817
题目链接：uva 1078 - Steam Roller 建图，将一个点拆成8个点，分别是4个方向，以及入边是否加倍。然后做最短路。 #include #include #include #include #include using namespace std; const int maxn = 105; const int inf = 0x3f3f3f3f;
UVA 1078 - Steam Roller（最短路）
Remilia's
09-26 1670
UVA 1078 - Steam Roller 题目链接 题意：给定一个地图，要求起点走到终点需要的时间，如果进入一个转弯位置，则进入和出去的时候时间要加倍 思路：最短路，关键在于如何建模，每个结点d[x][y][d][flag]表示在x, y结点，方向为d，是否加倍过了，这样就可以把每个结点之间对应的关系建边，做最短路即可 代码： #include #includ
UVALive4128[Steam Roller] dijkstra+拆点
Venishel的博客
08-30 352
UVALive4128 dijkstra 拆点
La 4128 Steam Roller 状态图上的Dijkstra
Free keyboard 跳动的键盘
08-01 617
题目大意： 给定一个R行C列的网格图和图上的边权（0表示两点之间无法连通）, 并已知起点，终点，每次转弯或者启动、停止时需要耗费双倍时间(从上一条边到这一条边的转向和从这条边到下一条边的转向最多计算一次）， 求到终点的最短路径。 分析： 我们可以用一个大的状态图来存储整个复杂的图，利用（r, c, dir, doubled)这个状态来表示从上一个点沿着dir的方向到达当前点（r, c）的这条边
1078 - Steam Roller
09-06 557
Johnny drives a steam roller, which like all steam rollers is slow and takes a relatively long time to start moving, change direction, and brake to a full stop. Johnny has just finished his day's work
Steam Roller UVALive - 4128
FTM's Blog
05-22 294
Steam Roller UVALive - 4128图论·最短路题目大意：给你一张格子图，r根横线，c根竖线。告诉你起点和终点，然后从起点走，每条边有权值，如果是0，就表示无法通行。走的规则是（通俗点）：车子的惯性比较大，如果你在下个路口要转弯，那么后半段就开慢了，好转弯，转弯完了之后，你要加速，那么前半段就慢了，这两种情况都会使这段路的时间加倍，但是如果一条路同时是这样，那么也只算两倍。起点这终
3DMAX卷曲修改器Roller下载
最新发布
06-16
在3DMAX中，卷曲修改器是实现复杂动态效果的重要工具，而Roller正是这样一款专为卷曲效果设计的插件。这款插件能够帮助用户轻松创建出卷曲形状的模型，不仅限于静态的造型，还能生成逼真的卷曲和展开的动画效果。 ...
roller-src-1.2.tar.gz_roller webloggi
09-20
这个weblogging 设计得比较精巧，源代码是很好的学习资料。它支持weblogging应有的特性如：评论功能，所见即所得HTML编辑，TrackBack，提供页面模板，RSS syndication,blogroll管理和提供一个XML-RPC 接口。
Apache Roller
07-18
Apache Roller是一个全功能，多用户和组博客服务器，适合大型和小型博客网站。它运行一个Java Web应用程序应该能够运行在任何Java EE服务器和关系数据库。目前，Apache Roller能很好的支持Tomcat和MySQL。 本人用...
UVa247 Calling Circles(Floyd warshall算法)
多看多听多总结
08-19 1169
给定两个人相互打电话，如果a打给b,b打给c,c打给a，则说a,b,c在同一电话圈中。给出n个人的m次通话，输出所有的电话圈。
UVa307 - Sticks(DFS+剪枝)
多看多听多总结
02-14 876
题意：给出若干个一样长的sticks，剪断后有n个部分，问原来sticks的最小长度。 思路：首先要确定sticks的长度范围，范围应该在[max(n1,n2..., n), sum(n1,n2...,n)}之间。然后用深度优先算法，在深搜时注意剪枝 （1）如果当前木棒搜索没有成功，那么后面的木棒长度与当前木棒长度一样，就应该跳过。 （2）如果当前木棒是第一个是没有成功，后面的也不会成功
UVa11300 Spreading the Wealth(数学问题)
多看多听多总结
11-17 858
题意：给出n个人，每个人有一些金币，可以给一些金币左边或者右边的人，最终使得每个人有相同的金币，问最小的转移金币是多少？ 思路：可以假定给金币方向是逆时间方向，值可能是正负。M表示最终每个人有的金币，用xi表示第i个人所给的，Pi表示第i个人有的金币 有M = P1 - x1 + x2   => x2 = x1 - (P1 - M)  => x2 = x1 - c1 P2 - x2 + x3
训练指南第一部分解题报告
多看多听多总结
02-14 838
主要是提供训练指南第一部分解题报告链接，后面会持续更新中 307 - Sticks （DFS+剪枝） 11292 - Dragon of Loowater (贪心) 11729 - Commando War(贪心) 11300 -Spreading the wealth(几何问题) 1388 - Graveyard(数学问题，一个很好的逆向思维问题) 10881 Piotr's A...
LVGL roller
12-05
LVGL的Roller是一个小部件，它允许用户通过滚动来选择一个选项。以下是一个简单的示例，演示如何使用LVGL的Roller小部件： ```c // 创建一个Roller小部件 lv_obj_t * roller = lv_roller_create(lv_scr_act(), NULL...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

kgduu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值