uva 816 BFS求最短路的经典问题……

一开始情况没有考虑周全,直接WA掉了,

然后用fgets()出现了WA,给改成scanf就AC了

题目不是很难,用心就好……

#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <cstdlib>
#include <stack>
#include <cctype>
#include <string>
#include <malloc.h>
#include <queue>
#include <map>

using namespace std;
const int INF = 0xffffff;
const double Pi = 4 * atan(1);
const int Maxn = 200 + 10;
//int dir2[8][2] = {{-1,0},{0,-1},{-1,1},{1,-1},{-1,-1},{1,0},{0,1},{1,1}};
int dr[] = {-1,0,1,0};
int dc[] = {0,1,0,-1};

struct Node{
    int r;
    int c;
    int dir;
    Node(int rr,int cc,int dd){
        r = rr;
        c = cc;
        dir = dd;
    }
    Node(){}
};
const char * dirs = "NESW";
const char * turns = "FLR";
bool has_edge[10][10][4][4];
int d[10][10][4];
int r1,c1,dir;
int r0,c0;
int r2,c2;
bool flag;
Node p[10][10][4];

int dir_id(char ch){
    return strchr(dirs,ch) - dirs;
}
int turn_id(char ch){
    return strchr(turns,ch) - turns;
}

Node walk(Node & u,int turn){
    int dd = u.dir;
    if(turn == 1){
        dd = (dd + 3) % 4;
    }
    else if(turn == 2){
        dd = (dd + 1) % 4;
    }
    return Node(u.r + dr[dd],u.c + dc[dd],dd);
}

void print_ans(Node u){
    vector<Node>nodes;
    while(1){
        nodes.push_back(u);
        if(d[u.r][u.c][u.dir] == 0)
            break;
        u = p[u.r][u.c][u.dir];
    }
    nodes.push_back(Node(r0,c0,dir));
    int cnt = 0;
    for(int i = nodes.size()-1;i >= 0;i--){
        if(cnt % 10 == 0)
            cout << " ";
        cout << " (" << nodes[i].r << "," << nodes[i].c << ")";
        if(++cnt % 10 == 0)
            cout << endl;
    }
    if(nodes.size() % 10 != 0)
        cout << endl;
}

bool inside(int r,int c){
    if(r > 0 && r < 10 && c > 0 && c < 10)
        return true;
    return false;
}

void solve(){
    queue<Node>q;
    memset(d,-1,sizeof(d));
    memset(p,0,sizeof(p));
    Node u(r1,c1,dir);
    d[u.r][u.c][u.dir] = 0;
    q.push(u);
    while(!q.empty()){
        Node u = q.front();
        q.pop();
        if(u.r == r2 && u.c == c2){
            flag = 0;
            print_ans(u);
            return;
        }
        for(int i = 0;i < 3;i++){
            Node v = walk(u,i);
            if(has_edge[u.r][u.c][u.dir][i] && inside(v.r,v.c) && d[v.r][v.c][v.dir] < 0){
                d[v.r][v.c][v.dir] = d[u.r][u.c][u.dir] + 1;
                p[v.r][v.c][v.dir] = u;
                q.push(v);
            }
        }
    }
}

int main()
{
#ifndef ONLINE_JUDGE
    freopen("inpt.txt","r",stdin);
#endif
        char str[30];
        while(~scanf("%s",str) && strcmp(str,"END")){
        printf("%s\n",str);
        flag = 1;
        memset(has_edge,0,sizeof(has_edge));
        char ch;
        cin >> r0 >> c0 >> ch >> r2 >> c2;
        dir = dir_id(ch);
        r1 = r0 + dr[dir];
        c1 = c0 + dc[dir];
        int r,c;
        char str2[30];

        while(cin >> r){
            if(r == 0){
                break;
            }
            cin >> c;
            while(cin >> str2){
                if(str2[0] == ‘*‘)
                    break;
                int dirID = dir_id(str2[0]);
                int len = strlen(str2);
                for(int i = 1;i < len;i++){
                    int turnID = turn_id(str2[i]);
                    has_edge[r][c][dirID][turnID] = 1;
                }
            }
        }
        solve();
        if(flag){
            cout << "  No Solution Possible" << endl;
        }
        getchar();
    }
    return 0;
}

时间: 2024-10-10 11:34:12

uva 816 BFS求最短路的经典问题……的相关文章

UVa 816 (BFS求最短路)

/*816 - Abbott's Revenge ---代码完全参考刘汝佳算法入门经典 ---strchr() 用来查找某字符在字符串中首次出现的位置,其原型为:char * strchr (const char *str, int c) ---BFS求最短路 --*/ #define _CRT_SECURE_NO_DEPRECATE #include<iostream> #include<string.h> #include<queue> #include<al

UVA 816 -- Abbott&#39;s Revenge(BFS求最短路)

 UVA 816 -- Abbott's Revenge(BFS求最短路) 有一个 9 * 9 的交叉点的迷宫. 输入起点, 离开起点时的朝向和终点, 求最短路(多解时任意一个输出即可).进入一个交叉点的方向(用NEWS表示不同方向)不同时, 允许出去的方向也不相同. 例如:1 2 WLF NR ER * 表示如果 进去时朝W(左), 可以 左转(L)或直行(F), 如果 朝N只能右转(R) 如果朝E也只能右转.* 表示这个点的描述结束啦! 输入有: 起点的坐标, 朝向, 终点的坐标.然后是各个

POJ 2251 Dungeon Master --- 三维BFS(用BFS求最短路)

POJ 2251 题目大意: 给出一三维空间的地牢,要求求出由字符'S'到字符'E'的最短路径,移动方向可以是上,下,左,右,前,后,六个方向,每移动一次就耗费一分钟,要求输出最快的走出时间.不同L层的地图,相同RC坐标处是相连通的.(.可走,#为墙) 解题思路:从起点开始分别往6个方向进行BFS(即入队),并记录步数,直至队为空.若一直找不到,则困住. /* POJ 2251 Dungeon Master --- 三维BFS(用BFS求最短路) */ #include <cstdio> #i

bfs求最短路的几道例题

题目来自于记蒜客数据结构课,类型差不多,都是用bfs求最短路(注意是不加权的最短路,加权的情况后面的文章会讲). 代码如下: 1 //记蒜客习题 2 //bfs求某点到其他各点的最短距离 3 #include <iostream> 4 #include <cstring> 5 #include <queue> 6 using namespace std; 7 8 class Graph{ 9 private: 10 int n; 11 bool *visited; 12

[codeforces-543B]bfs求最短路

题意:给一个边长为1的无向图,求删去最多的边使得从a到b距离<=f,从c到d距离<=g,a,b,c,d,f,g都是给定的,求最多删去的边数. 思路:反过来思考,用最少的边构造两条从a到b,从c到d的路径,使得它们满足题目中的条件.于是可以把这两条路径的相对位置分为两种情况,不相交和相交,对于不相交的情况答案就是两组距离之和,对于相交的情况,两条路径肯定共享一段连续路径,对于共享多段的情况可以把中间没共享的取较小值变成共享,得到的距离和不会更大,因此最优情况一定是一段连续的路径.于是可以枚举共享

UVa439 Knight Moves (BFS求最短路)

链接:http://acm.hust.edu.cn/vjudge/problem/19436分析:BFS跑一次最短路,状态转移有8个. 1 #include <cstdio> 2 #include <queue> 3 #include <cstring> 4 using namespace std; 5 6 struct Point { 7 char r, c; 8 Point(char r = ' ', char c = ' '): r(r), c(c) {}; 9

uva 816 BFS迷宫

这是一道比较复杂的BFS迷宫问题,状态由普通的迷宫问题的坐标(x,y)变为三个变量的状态(r,c,dir)其中dir是到达(r,c)两点的方向,这个变量非常重要,导致了这题比普通的BFS迷宫问题要更加复杂. 普通BFS解法 http://blog.csdn.net/iboxty/article/details/45888923 BFS是用队列实现的,很重要并且要理解的是:每一个节点只访问一次,而且每次BFS过程都保证压入队列中的节点到起点的距离是最短的,这题也有这样的思想. #include <

POJ3669(Meteor Shower)(bfs求最短路)

Meteor Shower Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 12642   Accepted: 3414 Description Bessie hears that an extraordinary meteor shower is coming; reports say that these meteors will crash into earth and destroy anything they h

hdu 5876 Sparse Graph 无权图bfs求最短路

Sparse Graph Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others) Problem Description In graph theory, the complement of a graph G is a graph H on the same vertices such that two distinct vertices of H are adjacent if