SDUTOJ2779_找朋友(BFS | | DFS双解法)

找朋友

Time Limit: 1000 ms Memory Limit: 65536 KiB

Submit Statistic

Problem Description

X，作为户外运动的忠实爱好者，总是不想呆在家里。现在，他想把死宅Y从家里拉出来。问从X的家到Y的家的最短时间是多少。

为了简化问题，我们把地图抽象为n*m的矩阵，行编号从上到下为1 到 n，列编号从左到右为1 到 m。矩阵中’X’表示X所在的初始坐标，’Y’表示Y的位置 , ’#’表示当前位置不能走，’ * ’表示当前位置可以通行。X每次只能向上下左右的相邻的 ’*’ 移动，每移动一次耗时1秒。

Input

多组输入。每组测试数据首先输入两个整数n，m(1<= n ,m<=15 )表示地图大小。接下来的n 行，每行m个字符。保证输入数据合法。

Output

若X可以到达Y的家，输出最少时间，否则输出 -1。

Sample Input

3 3 
X#Y
***
#*#
3 3
X#Y
*#*
#*#

Sample Output

4
-1

Hint

 

Source

zmx

 

BFS:

挨层遍历

#include <bits/stdc++.h>
using namespace std;
struct node
{
    int x, y, step; // 用结构体存坐标 和 步长
};
int n, m;
char gra[16][16]; // 临接表
int cat[16][16];
/*定义方向数组*/
int gotox[4] = {0, 0, 1, -1};
int gotoy[4] = {1, -1, 0, 0};

int bfs(int a, int b)
{
    cat[a][b] = 1;
    node t = {a, b, 0};
    queue<node> q;
    q.push(t);
    while (!q.empty())
    {
        node temp = q.front();
        q.pop();
        if (gra[temp.x][temp.y] == 'Y')
            return temp.step;
        for (int i = 0; i < 4; i++) // 遍历四个方向
        {
            node d;
            d.x = temp.x + gotox[i];
            d.y = temp.y + gotoy[i];
            d.step = temp.step + 1;
            if (d.x >= 0 && d.x < n && d.y >= 0 && d.y < m && !cat[d.x][d.y] && gra[d.x][d.y] != '#')
            {
                q.push(d);
                cat[d.x][d.y] = 1;
            }
        }
    }
    return -1;
}
int main()
{
    ios::sync_with_stdio(false);
    while (cin >> n >> m)
    {
        int a, b;
        memset(cat, 0, sizeof(cat));
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < m; j++)
            {
                cin >> gra[i][j];
                if (gra[i][j] == 'X') // 找出起点
                {
                    a = i;
                    b = j;
                }
            }
        }
        cout << bfs(a, b) << endl;
    }
    return 0;
}

DFS:

对于最新发现的顶点，如果它还有以此为起点还有 未发现的边，就继续搜索下去。直到当前点的所有方向都已搜索完毕不符合条件了，就往前回溯，访问过的  点标记为0。

#include <bits/stdc++.h>
#define INF INT_MAX
using namespace std;
int n, m, ans, MIN;
char gra[16][16]; // 临接表
int cat[16][16];
/*定义方向数组*/
int gotox[4] = {0, 0, 1, -1};
int gotoy[4] = {1, -1, 0, 0};

void dfs(int a, int b, int ans)
{
    cat[a][b] = 1;
    if (ans >= MIN) // 步数比已经找出的最小的 步数MIN 还有要大
        return;
    if (ans < MIN && gra[a][b] == 'Y') // 步数比最小的已经找出的 步数MIN 还要小且已经找到Y
    {                                  // 如果找不到Y  MIN 仍然是INF
        MIN = ans;
        return;
    }
    for (int i = 0; i < 4; i++)
    {
        int x = a + gotox[i]; // 遍历四个方向的邻点
        int y = b + gotoy[i];
        if (x >= 0 && x < n && y >= 0 && y < m && !cat[x][y] && gra[x][y] != '#')
        {
            cat[x][y] = 1;
            dfs(x, y, ans + 1); // 符合条件 搜索 步数+1  递归搜下一点
            cat[x][y] = 0;      // 递归完无果  把访问过的点标记为未访问
        }
    }
}
int main()
{
    ios::sync_with_stdio(false);
    while (cin >> n >> m)
    {
        int a, b;
        memset(cat, 0, sizeof(cat));
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < m; j++)
            {
                cin >> gra[i][j];
                if (gra[i][j] == 'X')
                {
                    a = i;
                    b = j;
                }
            }
        }
        MIN = INF;
        ans = 0;
        dfs(a, b, ans);
        if (MIN != INF)
            cout << MIN << endl;
        else
            cout << "-1" << endl;
    }
    return 0;
}