DFS:往深搜索，执着，确认从底下返回后的每个人的节点都已经用完，空间占用少，爆搜。

BFS:每一层搜索，稳重，(当一个图的权重都为1时搜到的一定是最短路)

 下面我们以dfs的一道经典例题来讲解

代码:

#include<iostream>
using namespace std;
const int N=10;
int n;
int path[N];
bool st[N];//记录位 

void dfs(int u)
{
	if(u==n)
	{
		for(int i=0;i<n;i++)
		cout<<path[i]<<" "; 
		cout<<endl;
		return ;
	}
	for(int i=1;i<=n;i++)
	{
		if(!st[i])
		{
			path[u]=i;//路径去记录
			st[i]=true;
			dfs(u+1);
			st[i]=false; 恢复现场	
		}
	}
}
int main()
{
	cin>>n;
	dfs(0);
	return 0;
}

例题二:n-皇后问题

方法一:全排列思想

#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]);//整行输出 
		cout<<endl;
		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;
}

法二:采用更为原始的判断

#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;
}