BFS&&DFS入门

dfs(深搜)

思想：

一条路走到黑，当前情况无法满足题意时，返回上一层重新选择。

核心代码：

int dfs()
{ 
    if(now==End) return now_ans;
    
    if(check(i, j)) 
  {
      fl[i][j]=true;
      dfs(i, j);
      fl[i][j]=false;
  }
  else return;
  
}

题目：棋盘问题

在一个给定形状的棋盘（形状可能是不规则的）上面摆放棋子，棋子没有区别。要求摆放时任意的两个棋子不能放在棋盘中的同一行或者同一列，请编程求解对于给定形状和大小的棋盘，摆放k个棋子的所有可行的摆放方案C。

Input

输入含有多组测试数据。
每组数据的第一行是两个正整数，n k，用一个空格隔开，表示了将在一个n*n的矩阵内描述棋盘，以及摆放棋子的数目。 n <= 8 , k <= n
当为-1 -1时表示输入结束。
随后的n行描述了棋盘的形状：每行有n个字符，其中 '#' 表示棋盘区域， '.' 表示空白区域（数据保证不出现多余的空白行或者空白列）。

Output

对于每一组数据，给出一行输出，输出摆放的方案数目C （数据保证C<2^31）。

Sample

Inputcopy	Outputcopy
2 1 #. .# 4 4 ...# ..#. .#.. #... -1 -1	2 1

ac代码：

#include <iostream>
#include<cstdio>
#include<algorithm>

using namespace std;

char mp[10][10];
int cnt;
int n, k;
bool fl[10];

void dfs(int x,int num)
{

    if(num==0)
    {
        cnt++;
        return;
    }

    if(x>=n) return;

    int y;

    for(y=0;y<n;y++)
    {
        if(mp[x][y]=='#'&&!fl[y])
        {
            fl[y]=true;
            dfs(x+1,num-1);
            fl[y]=false;
        }
    }

    dfs(x+1,num);

    return;

}
int main()
{

   while(~scanf("%d%d",&n,&k))
   {
       if(n==-1) break;

       getchar();

       cnt=0;

       for(int i=0;i<n;i++)
       {
           scanf("%s",mp[i]);
       }

       dfs(0,k);

       printf("%d\n",cnt);

   }

    return 0;
}

 题目：N皇后问题

 

n−皇后问题是指将 n 个皇后放在 n×n 的国际象棋棋盘上，使得皇后不能相互攻击到，即任意两个皇后都不能处于同一行、同一列或同一斜线上。

现在给定整数 n，请你输出所有的满足条件的棋子摆法。

输入格式

共一行，包含整数 n。

输出格式

每个解决方案占 n 行，每行输出一个长度为 nn 的字符串，用来表示完整的棋盘状态。

其中 . 表示某一个位置的方格状态为空，Q 表示某一个位置的方格上摆着皇后。

每个方案输出完成后，输出一个空行。

注意：行末不能有多余空格。

输出方案的顺序任意，只要不重复且没有遗漏即可。

数据范围

1≤n≤91≤n≤9

输入样例：

4

输出样例：

.Q..
...Q
Q...
..Q.

..Q.
Q...
...Q
.Q..

难度：中等

时/空限制：1s / 64MB

总通过数：53846

总尝试数：85112

来源：模板题,AcWing

算法标签

 题目链接：https://www.acwing.com/problem/content/845/

 ac代码：

//第一种搜索顺序
#include <iostream>

using namespace std;

const int N = 10;

int n;
bool row[N], col[N], dg[N * 2], udg[N * 2];
char g[N][N];

void dfs(int x, int y, int s)
{
    if (s > n) return;
    if (y == n) y = 0, x ++ ;

    if (x == n)
    {
        if (s == n)
        {
            for (int i = 0; i < n; i ++ ) puts(g[i]);
            puts("");
        }
        return;
    }

    g[x][y] = '.';
    dfs(x, y + 1, s);

    if (!row[x] && !col[y] && !dg[x + y] && !udg[x - y + n])
    {
        row[x] = col[y] = dg[x + y] = udg[x - y + n] = true;
        g[x][y] = 'Q';
        dfs(x, y + 1, s + 1);
        g[x][y] = '.';
        row[x] = col[y] = dg[x + y] = udg[x - y + n] = false;
    }
}

int main()
{
    cin >> n;

    dfs(0, 0, 0);

    return 0;
}
//第二种搜索顺序
#include <iostream>

using namespace std;

const int N = 20;

int n;
char g[N][N];
bool col[N], dg[N], udg[N];

void dfs(int u)
{
    if (u == n)
    {
        for (int i = 0; i < n; i ++ ) puts(g[i]);
        puts("");
        return;
    }

    for (int i = 0; i < n; i ++ )
        if (!col[i] && !dg[u + i] && !udg[n - u + i])
        {
            g[u][i] = 'Q';
            col[i] = dg[u + i] = udg[n - u + i] = true;
            dfs(u + 1);
            col[i] = dg[u + i] = udg[n - u + i] = false;
            g[u][i] = '.';
        }
}

int main()
{
    cin >> n;
    for (int i = 0; i < n; i ++ )
        for (int j = 0; j < n; j ++ )
            g[i][j] = '.';

    dfs(0);

    return 0;
}

 

bfs(宽搜)

思想：

通过队列存储每一层的状态，一层一层的搜索，直到遇到答案。所以bfs搜索的是所有解中的最优解。

核心代码:

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<string.h>
#include<string>
#include<queue>

using namespace std;

//不同方位
int dx[]={-1, 0, 0, 1};
int dy[]={0, -1, 1, 0};

//标记已经访问过的点
bool fl[210][210][15];

//初始状态
int a,b,c;

//表示状态
struct state
{
    int x;
    int y;
};

//根据具体条件判断下次情况是否选择
bool check()
{
    
}

int bfs(int i, int j, int t)
{
    //用队列储存
    queue<state> q;
    struct state now;
 
    //切记不要忘记对起点的标记
    fl[i][j][t] = true;

    q.push(now);

    while(!q.empty())
    {
        //每次拿出一个队头
        now = q.front();
        q.pop();
        
        //下一种情况满足入队
        if(check()) q.push(nex);
    }

    return -1;
}

//输入
void cint()
{
    
}

//输出
void cou()
{
    
}

int main()
{   
    cint();
    bfs(a,b,c);
    cou();

    return 0;
}

题目：鸣人和佐助

已知一张地图（以二维矩阵的形式表示）以及佐助和鸣人的位置。地图上的每个位置都可以走到，只不过有些位置上有大蛇丸的手下，需要先打败大蛇丸的手下才能到这些位置。鸣人有一定数量的查克拉，每一个单位的查克拉可以打败一个大蛇丸的手下。假设鸣人可以往上下左右四个方向移动，每移动一个距离需要花费 1 个单位时间，打败大蛇丸的手下不需要时间。如果鸣人查克拉消耗完了，则只可以走到没有大蛇丸手下的位置，不可以再移动到有大蛇丸手下的位置。佐助在此期间不移动，大蛇丸的手下也不移动。请问，鸣人要追上佐助最少需要花费多少时间？

输入格式

输入的第一行包含三个整数：M，N，T。代表 M 行 N 列的地图和鸣人初始的查克拉数量 T。0 < M,N < 200，0≤T<10

后面是 M 行 N 列的地图，其中 @ 代表鸣人，+ 代表佐助。* 代表通路，# 代表大蛇丸的手下。

输出格式

输出包含一个整数 R，代表鸣人追上佐助最少需要花费的时间。如果鸣人无法追上佐助，则输出 −1。

Sample 1

Inputcopy	Outputcopy
4 4 1 #@## **## ###+ ****	6

Sample 2

Inputcopy	Outputcopy
4 4 2 #@## **## ###+ ****	4

ac代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<string.h>
#include<string>
#include<queue>

using namespace std;

char mp[210][210];
bool fl[210][210][15];
int dx[]={-1, 0, 0, 1};
int dy[]={0, -1, 1, 0};
bool flag;
int n,m,t;

struct state
{
    int x;
    int y;
    int num;//查克拉
    int ans;//时间
};

int bfs(int i, int j, int t)
{
    queue<state> q;
    struct state now;

    now.x = i, now.y = j, now.num = t, now.ans = 0;

    fl[i][j][t] = true;

    q.push(now);

    while(!q.empty())
    {
        now = q.front();
        q.pop();

        if(mp[now.x][now.y] == '+') return now.ans;

        for(int i = 0; i < 4; i ++ )
        {
            struct state nex;
            nex.x = now.x + dx[i];
            nex.y = now.y + dy[i];

            if(nex.x >= 0 && nex.x < m && nex.y >= 0 && nex.y < n)
            {

                if(mp[nex.x][nex.y] == '#' && !fl[nex.x][nex.y][now.num - 1] && now.num-1>=0 )
                {
                    nex.num = now.num - 1;
                    nex.ans = now.ans + 1;
                }
                else if(!fl[nex.x][nex.y][now.num] && mp[nex.x][nex.y] != '#')
                {
                    nex.num = now.num;
                    nex.ans = now.ans + 1;
                }
                else   continue;

                fl[nex.x][nex.y][nex.num] = true;

                q.push(nex);
            }
        }

    }

    return -1;
}
int main()
{
    int i,j,x,y;

	scanf("%d%d%d",&m,&n,&t);

	for(i=0;i<m;i++)
	{
		scanf("%s",mp[i]);

	}

    for(int i = 0; i < m; i ++ )
    {
        for(int j = 0; j < n; j ++ )
        {
            if(mp[i][j] == '@')
            {
                x=i;
                y=j;
                flag=true;
                break;
            }
        }
        if(flag) break;
    }

    int sum=bfs(x, y, t);

    printf("%d",sum);

    return 0;
}