OJ 4105 拯救公主__广搜

描述

多灾多难的公主又被大魔王抓走啦！国王派遣了第一勇士阿福去拯救她。
身为超级厉害的术士，同时也是阿福的好伙伴，你决定祝他一臂之力。你为阿福提供了一张大魔王根据地的地图，上面标记了阿福和公主所在的位置，以及一些不能够踏入的禁区。你还贴心地为阿福制造了一些传送门，通过一个传送门可以瞬间转移到任意一个传送门，当然阿福也可以选择不通过传送门瞬移。传送门的位置也被标记在了地图上。此外，你还查探到公主所在的地方被设下了结界，需要集齐K种宝石才能打开。当然，你在地图上也标记出了不同宝石所在的位置。
你希望阿福能够带着公主早日凯旋。于是在阿福出发之前，你还需要为阿福计算出他最快救出公主的时间。
地图用一个R×C的字符矩阵来表示。字符S表示阿福所在的位置，字符E表示公主所在的位置，字符#表示不能踏入的禁区，字符$表示传送门，字符.表示该位置安全，数字字符0至4表示了宝石的类型。阿福每次可以从当前的位置走到他上下左右四个方向上的任意一个位置，但不能走出地图边界。阿福每走一步需要花费1个单位时间，从一个传送门到达另一个传送门不需要花费时间。当阿福走到宝石所在的位置时，就视为得到了该宝石，不需要花费额外时间。

输入

第一行是一个正整数T（1 <= T <= 10），表示一共有T组数据。
每一组数据的第一行包含了三个用空格分开的正整数R、C（2 <= R, C <= 200）和K，表示地图是一个R×C的矩阵，而阿福需要集齐K种宝石才能够打开拘禁公主的结界。
接下来的R行描述了地图的具体内容，每一行包含了C个字符。字符含义如题目描述中所述。保证有且仅有一个S和E。$的数量不超过10个。宝石的类型在数字0至4范围内，即不会超过5种宝石。

输出

对于每一组数据，输出阿福救出公主所花费的最少单位时间。若阿福无法救出公主，则输出“oop!”（只输出引号里面的内容，不输出引号）。每组数据的输出结果占一行。

样例输入

1
7 8 2
……..
..S..#0.
.##..1..
.0#…..
…1#…
…##E..
…1….

样例输出

11

分析

迷宫问题，区别在于要集齐宝石，并且有传递门，因为有宝石数目限制所以是否访问过的标记要增加一个维度用户表示特定宝石数目下是否访问过某一结点。这次7218变的写法是用常规的(x,y)表示坐标了，确认这样更好写些。。
郁闷的是写出来后样例通过了，也自己找了很多测试项通过了，结果提示OJ死活过不了，之后睡了一觉隔了一天才想到是doorCount没有置0！吐血三升！！！

实现

#include <iostream>
#include <cstring>
#include <queue>
#include <map>
using namespace std;
#define MAX 201
char a[MAX][MAX];

struct Node
{
    int x, y; //坐标。
    int gem = 0; //存储宝石数目。
    int deep = 0; //搜索深度。

    Node() {
    }

    Node(int xx, int yy, int gg, int dd) : x(xx), y(yy), gem(gg), deep(dd) {
    }
};

int dir[4][2] = {{0, -1},{-1, 0},{0, 1},{1, 0}};
int visited[MAX][MAX][1 << 5 - 1];   //宝石数目最大11111
int r, c, k, doorCount;
Node doors[11];

void print(int result) {
    result == -1 ? (cout << "oop!" << endl) : (cout << result << endl);
}

int bit1Count(int value) {
    unsigned int count = 0;
    while (value > 0) { // until all bits are zero
        if ((value & 1) == 1) // check lower bit
            count++;
        value >>= 1; // shift bits, removing lower bit
    }
    return count;
}

void printQueue(std::queue<Node> q) {
    while (!q.empty()) {
        Node node = q.front();
        q.pop();
        cout << "(" << node.x << ", " << node.y << ", "
            << bit1Count(node.gem) << ", " << node.deep << ") ";
    }
    cout << endl << endl;
}

int getTarget(Node* node, Node* endNode) {
    return (node->x == endNode->x && node->y == endNode->y && bit1Count(node->gem) >= k);
}

int bfs(Node* startNode, Node* endNode) {
    if (startNode == NULL || endNode == NULL) return -1;
    memset(visited, 0, sizeof(visited));
    visited[startNode->x][startNode->y][0] = 1;
    std::queue<Node> q;
    q.push(*startNode);
    while (!q.empty()) {
        Node node = q.front();
        q.pop();
        for (int i = 0; i < 4; i++) {
            int newX = node.x + dir[i][0];
            int newY = node.y + dir[i][1];
            if (newX < 0 || newX >= r || newY < 0 || newY >= c) continue;
            if (a[newX][newY] == '#' || visited[newX][newY][node.gem]) continue;
            //不是墙壁并且此节点没访问过。
            visited[newX][newY][node.gem] = 1;
            //记录宝石数量。
            Node newNode(newX, newY, node.gem, node.deep + 1);
            if (a[newX][newY] >= '0' && a[newX][newY] <= '4') {
                newNode.gem |= 1 << (a[newX][newY] - '0');
            }
            if (getTarget(&newNode, endNode)) {
                //printQueue(q);
                return newNode.deep;
            }
            q.push(newNode);

            //如果是传送门的话就将所有其它传送门加入搜索队列。
            if (a[newX][newY] == '$') {
                for (int j = 0; j < doorCount; j++) {
                    Node currNode = doors[j];
                    if (currNode.x == newX && currNode.y == newY) continue;
                    Node doorNode(currNode.x, currNode.y, newNode.gem, newNode.deep);
                    q.push(doorNode);
                }
            }
        }
        //printQueue(q);
    }
    return -1;
}

int main() {
    //  freopen("in.txt", "r", stdin);
    int t;
    cin >> t;
    while (t--) {
        Node *startNode = NULL, *endNode = NULL;
        cin >> r >> c >> k;
        doorCount = 0;
        for (int i = 0; i < r; i++) {
            for (int j = 0; j < c; j++) {
                cin >> a[i][j];
                //记录所有传送门的位置。
                switch (a[i][j]) {
                case '$':
                    doors[doorCount++] = Node(i, j, 0, 0);
                    break;
                case 'S':
                    startNode = new Node(i, j, 0, 0);
                    break;
                case 'E':
                    endNode = new Node(i, j, 0, 0);
                }
            }
        }
        print(bfs(startNode, endNode));
    }
    return 0;
}