【HDU 2612 Find a Way（BFS）】(兼BFS入门笔记)

【HDU 2612 Find a Way（BFS）】(兼BFS入门笔记)

原题入口：
http://acm.hdu.edu.cn/showproblem.php?pid=2612

第一篇在CSDN的博客就写它了吧……
这道题说简单不简单（菜鸡疯狂TLE）
说难也不难（大佬一会儿就写完了）
说到BFS 什么是BFS？
（所以先简单说说BFS再写这道题吧）
BFS中文叫广度优先搜索，从起始状态向后一层一层的搜索，像年轮蛋糕一样（超爱吃年轮蛋糕）。
在C/C++中目前学会的只有通过队列实现。
BFS基本架构如下(因为学校先教C语言所以我写的C++基本就是用了C++头文件的C语言)：

#include <queue>
#include <iostream>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#define INF 0x3fffffff

using namespace std;

int n,m,sx,sy,tx,ty,direct;
int vis[105][105];
char s[105][105];
int dx[4] = {0,0,1,-1};
int dy[4] = {1,-1,0,0};
struct Node
{
    int x,y,step;
};
queue<Node>q;
void bfs(int sx,int sy) //! 这里int和void看情况 不做赘述
{
    while (!q.empty()) q.pop();
    memset(vis,0,sizeof(vis));
    Node st;
    st.x = sx;
    st.y = sy;
    st.step = 0;
    q.push(st);
    vis[sx][sy] = 1;
    while (!q.empty())
    {
        Node cur = q.front();
        q.pop();
        for (direct = 0; direct < 4; direct ++)
        {
            Node nx;
            nx.step = cur.step + 1;
            nx.x = cur.x + dx[direct];
            nx.y = cur.y + dy[direct];
            if (nx.x < 0 || nx.y < 0 || nx.x >= n || nx.y >= m) continue; //! 判断会不会超过范围，特别注意这里一定要先判断数组序号再进行数组内容的判断，不然可能会出现越界情况。
            if (vis[nx.x][nx.y] || s[nx.x][nx.y] == '#') continue; //! #是墙，表示这里不能走。
            vis[nx.x][nx.y] = 1;
            /*!
                在这里加入对搜索目标的判断。
            */
            q.push(nx);
        }
    }
    return ;
}//! BFS函数到此基本结束，内部有需要可以添枝加叶。
int main()
{
    int i,j,ans = INF;
    scanf("%d%d",&n,&m);
    for (i = 0; i < n; i++)
    {
        scanf("%s",s[i]);
        for (j = 0; j < m; j++)
        {
            if(s[i][j] == 'S') //! 起点横纵坐标
            {
                sx = i;
                sy = j;
            }
            else if (s[i][j] == 'T')//! 终点横纵坐标
            {
                tx = i;
                ty = j;
            }
        }
        /*!
            调用bfs。
            适当修改就OK了。
        */
    }
    return 0 ;
}
//! 以上为BFS模板

好啦，BFS模板介绍的差不多了，接下来进行这道题的理解。
首先，存在一种情况，即有人到不了某个KFC（这个要考虑）
其次，传统的方法比如搜索KFC对KFC数目计数然后遍历KFC搜索显然会超时（搜索次数太多了）
第三，多组样例
代码应该差不多就出来了（大佬都是这么说的（虽然我是菜逼））

/*！
Judge Status: Accepted;
Problem ID  : 2612;
Exe.Time    : 15MS;
Exe.Memory  : 2244K;
Code Len.   : 2973B;
Language    : G++;
Author      : BelieberJ;
School      : Harbin Institute of Technology(HIT)
*/
#include <iostream>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <queue>
#define INF 0x3fffffff
/*!
思路：按照KFC个数进行搜索，先从Y开始搜到一个KFC，标记这个KFC，再用M搜同一个KFC先判断能不能到，然后计步
Trial 1&Trial 2:Time limit exceed
可能原因：重复搜索次数太多，出现了重复搜索的情况，贼费时间
Trial 3目标：新建两个数组用来存放两人到每个KFC的距离，到时候只需遍历KFC即可
*/
using namespace std;
int vis[205][205],kfca[205][205],kfcb[205][205],dx[4] = {1,-1,0,0},dy[4] = {0,0,1,-1};
char s[205][205];
int kfc[205][2];                    //! 用来保存KFC坐标 这样可以减少冗余次数
int direct,sx1,sx2,sy1,sy2,m,n;
struct Node
{
    int x,y,step;
};
int my_min(int i,int j)
{
    return i <= j ? i : j;
}
queue<Node>q;
void bfs(int state,int sx,int sy)
{
    while (!q.empty()) q.pop();
    memset(vis,0,sizeof(vis));
    Node st;
    st.x = sx;
    st.y = sy;
    st.step = 0;
    q.push(st);
    vis[sx][sy] = 1;
    while (!q.empty())
    {
        Node cur = q.front();
        q.pop();
        if (s[sx][sy] == '@')
        {
            if (state == 1)
                kfca[sx][sy] = cur.step;
            else
                kfcb[sx][sy] = cur.step;
        }
        for (direct = 0; direct < 4; direct ++)
        {
            Node nx;
            nx.step = cur.step + 1;
            nx.x = cur.x + dx[direct];
            nx.y = cur.y + dy[direct];
            if (nx.x < 0 || nx.y < 0 || nx.x >= n || nx.y >= m || vis[nx.x][nx.y] || s[nx.x][nx.y] == '#') continue;
            vis[nx.x][nx.y] = 1;
            if (s[nx.x][nx.y] == '@')
            {
                if (state == 1)
                    kfca[nx.x][nx.y] = nx.step;
                else
                    kfcb[nx.x][nx.y] = nx.step;
            }
            q.push(nx);
        }
    }
    return ;
}
int main()
{
    while (scanf("%d%d",&n,&m) == 2)
    {
        int i,j,ans = INF,cou = 0;
        for (i = 0; i < n; i++)
            for (j = 0; j < m; j++)
            {
                kfca[i][j] = INF;
                kfcb[i][j] = INF;
            }
        for (i = 0; i < n; i++)
        {
            scanf("%s",s[i]);
            for (j = 0; j < m; j++)
            {
                if(s[i][j] == 'Y')
                {
                    sx1 = i;
                    sy1 = j;
                }
                else if (s[i][j] == 'M')
                {
                    sx2 = i;
                    sy2 = j;
                }
                else if (s[i][j] == '@')
                {
                    kfc[cou][0] = i;
                    kfc[cou][1] = j;
                    cou++;
                }
            }
        }
        bfs(1,sx1,sy1);
        bfs(2,sx2,sy2);
        for (i = 0; i < cou; i++)
            ans = my_min(ans,kfca[kfc[i][0]][kfc[i][1]] + kfcb[kfc[i][0]][kfc[i][1]]);
        printf("%d\n",ans * 11);
    }
    return 0;
}