hdoj 1253 胜利大逃亡宽度优先遍历

最新推荐文章于 2016-04-08 12:36:17 发布

原创最新推荐文章于 2016-04-08 12:36:17 发布 · 768 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#struct #c #扩展

ACM 同时被 2 个专栏收录

114 篇文章

订阅专栏

搜索

20 篇文章

订阅专栏

本文探讨了在三维空间中寻找最短路径的问题，并加入了时间约束条件。通过宽度优先搜索算法，作者解决了该问题。文章详细解释了算法流程，包括如何在不剪枝的情况下超时，以及在剪枝后的优化过程。最终，文章通过实例演示了如何在给定时间内找到从起点到终点的最短路径。

题目大意：3维空间找最短距离，加了个时间约束条件

解题思路：这题算是水题了，最短距离，宽度优先遍历就可以了，加个时间约束条件，到达那个时间的节点就不扩展了

之前没剪枝，超时了，网上有人不剪枝就过了，可能是因为使用了标准库的队列的缘故，超时后然后加个剪枝，对些当前节点到最终节点经过的格子数超过剩余时间的节点剪枝

最终过了，不过时间消耗也很大。。。。。

#include <iostream>
#include <cstdio>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 51;

struct node
{
    int x, y, z, step, ti;
};

int a, b, c, t;
int maze[maxn][maxn][maxn];
int dir[6][3] = {{1,0 ,0}, {-1, 0, 0}, {0, 1, 0}, {0, -1, 0}, {0, 0, 1}, {0, 0, -1}};

int bfs();

int main()
{
   
    int test;
    scanf("%d", &test);
    while(test-- != 0)
    {
        scanf("%d %d %d %d", &a, &b, &c, &t);
        for(int i = 0; i < a; i++)
        {
            for(int j = 0; j < b; j++)
            {
                for(int k = 0; k < c; k++)
                    scanf("%d", &maze[i][j][k]);
            }
        }
        int ans = bfs();
        if(ans == -1)
            printf("-1\n");
        else
            printf("%d\n", ans);
    }
        return 0;
}

int bfs()
{
    queue<node> que;
    node s;
    s.x = s.y = s.z = s.step = s.ti = 0;
    que.push(s);
    while(!que.empty())
    {
        node tmp = que.front();
        que.pop();
        if(tmp.ti <= t && tmp.x == a - 1 && tmp.y == b - 1 && tmp.z == c - 1)
            return tmp.step;
        if(tmp.ti >= t)
            continue;
        for(int i = 0; i < 6; i++)
        {
            int dx = tmp.x + dir[i][0];
            int dy = tmp.y + dir[i][1];
            int dz = tmp.z + dir[i][2];
            if(dx >= 0 && dx < a && dy >= 0 && dy < b && dz >= 0 && dz < c && maze[dx][dy][dz] != 1)
            {
                int sx = abs(a - 1 - dx);
                int sy = abs(b - 1 - dy);
                int sz = abs(c - 1 - dz);
                if((sx + sy + sz ) <= (t - tmp.ti) )
                {
                    maze[dx][dy][dz] = 1;
                    node in;
                    in.x = dx;
                    in.y = dy;
                    in.z = dz;
                    in.step = tmp.step + 1;
                    in.ti = tmp.ti + 1;
                    que.push(in);
                }
            }
        }
    }
    return -1;
}