基础搜索算法的常见题型

重点：这是一份课件整理，出自杨乐大佬之手，就此声明。

首先，搜索是一种暴力，在数据范围小的情况下，枚举所有的可能性。我们来模拟处理问题的步骤。

搜索主要分两类：dfs（深度优先搜索）

　　　　　　　：bfs（广度优先搜索）

dfs的经典例题：

范式：

void dfs(_position_,_state_)
if _success_ then _goal_
else
    for every possible _move_//枚举每一种可能行动
    if _acailable_ then//如果没有违法约束
       _new_state_=(_state_,_move_)//计算新的状态
       _new_possible_=nexr_position_ //计算下一个阶段
       dfs(_new_position_,_new_state_)//进行下一步的搜索

1.数独问题

题目梗概：给出一个 9×9 的棋盘，上面已经填好了部分数字。要 求补充完整个棋盘，并且使得每行、每列、每个 3×3 小方阵内没 有重复的数字。
* 分析数独问题： 1 “划分游戏阶段”：从左到右从前到后，决定每一个空格的数字

　　　　　　　　 2“行动”：对于某一个特定的空格，枚举上面填什么数字

　　　　　　　　 3* “胜利”：全部填完了之后，判断这个填的方法是否符合条件

#include<iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

const int N = 9;
const int Group[9][9] = 
{
    0, 0, 0, 1, 1, 1, 2, 2, 2,
    0, 0, 0, 1, 1, 1, 2, 2, 2,
    0, 0, 0, 1, 1, 1, 2, 2, 2,
    3, 3, 3, 4, 4, 4, 5, 5, 5,
    3, 3, 3, 4, 4, 4, 5, 5, 5,
    3, 3, 3, 4, 4, 4, 5, 5, 5,
    6, 6, 6, 7, 7, 7, 8, 8, 8,
    6, 6, 6, 7, 7, 7, 8, 8, 8,
    6, 6, 6, 7, 7, 7, 8, 8, 8
};

int a[N][N];
int row[N][N], col[N][N], gr[N][N];


void print()
{
    printf("One Possible Solution:
");
    for(int i=0; i<N; i++)
    {
        for(int j=0; j<N; j++) printf("%d ", a[i][j] + 1);
        printf("
");
    }
}
void dfs3(int x, int y)
{
    if(x == N)
    {
        print();
        return;
    }

    int next_x = x, next_y = y + 1;
    if(next_y == N) next_x = x + 1, next_y = 0;//提前将下一步的位置处理好 

    if(a[x][y] >= 0) dfs3(next_x, next_y);//已经填好数了，那么我就跳过 
    else
    {
        for(int i=0; i<N; i++)
            if(!row[x][i] && !col[y][i] && !gr[Group[x][y]][i])
            {
                row[x][i] = col[y][i] = gr[Group[x][y]][i] = 1;

                a[x][y] = i;//这个数没有出现过，就让它等于当前数 并标记 
                dfs3(next_x, next_y);
                a[x][y] = -1;

                row[x][i] = col[y][i] = gr[Group[x][y]][i] = 0;
            }
            /*每到一个位置，枚举每一个数，如果该数行，列，小正方都不重复，则填入
            继续搜索下一个，之后便是回溯一步*/ 
    }
}

int main()
{


    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
            scanf("%d", &a[i][j]), a[i][j]--;//因为我们从0开始存 

    printf("Dfs Method3:
");

    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
            if(a[i][j] >= 0) 
                {
                    row[i][a[i][j]] = 1;
                    col[j][a[i][j]] = 1;
                    gr[Group[i][j]][a[i][j]] = 1;
                }
        /*把每一行每一列，每一小方块的已经给出的数全部标记为，
        而这个group就是来判定这个位置是属于哪一个小方块的*/
/*        printf("row:
");
    for(int i=0; i<N; i++)
    {
        for(int j=0; j<N; j++) printf("%d ", row[i][j]);
        printf("
");
    }
    printf("********************
");
        printf("col:
");
    for(int i=0; i<N; i++)
    {
        for(int j=0; j<N; j++) printf("%d ", col[i][j]);
        printf("
");
    }
    printf("********************
");
        printf("gr:
");
    for(int i=0; i<N; i++)
    {
        for(int j=0; j<N; j++) printf("%d ", gr[i][j]);
        printf("
");
    }
    printf("********************
");    
    如果对col,row,gr的定义还是不大懂的话，可以解锁以上程序加以理解*/
    dfs3(0, 0);

    return 0;
}

* 分析背包问题： 1 “划分游戏阶段”：从第一个物品开始，考虑它的选取情况

　　　　　　　　 2 “行动”：对于某一个特定的物品，考虑它选不选

　　　　　　　　 3* “约束”：选取完成后，还需要判断它是否能装得下

　　　　　　　　4* “最优方案”：如果可以装得下，我们需要选择一 个价值之和最大的

#include<iostream>
#include<cstdio>
using namespace std;
int w[1001],v[1001],n;
int ans,t;
void dfs(int x,int totw,int totv)
{
    if(x>n)
    {
        if(totw>ans)
            ans=totw;
        return ;
    }
    else
    {
        dfs(x+1,totw,totv);
        if(totv+v[x]<=t)
        dfs(x+1,totw+w[x],totv+v[x]);
    }
}
int main()
{
    scanf("%d%d",&n,&t);
    for(int i=1;i<=n;i++)
    scanf("%d%d",&w[i],&v[i]);
    dfs(1,0,0);
    printf("%d",ans);
    return 0;
}

对于这个问题我们来拓展一下：

1.如何记录拿了几件

//多定义一个a[1001] b[1001]
void dfs(int x,int totw,int totv)
{
    if(x>n)
    {
        if(totw>ans)
            {
                for(int i=1;i<=a[0];i++)
                b[i]=a[i];
                ans=totw;
            }
        return ;
    }
    else
    {
        dfs(x+1,totw,totv);
        if(totv+v[x]<=t)
        {
            ++a[0],a[a[0]]=x;
            dfs(x+1,totw+w[x],totv+v[x]);
            a[a[0]]=0,--a[0];
            //用a[0]来记录拿的个数 这个 也算一个技巧
        }
    }
}

2.完全背包（取无数件）

void dfs(int x,int totw,int totv)
{
    if(x>n)
    {
        if(totw>ans)
            ans=totw;
        return ;
    }
    else
    {
        dfs(x+1,totw,totv);
        while(totv+v[x]*m<=t)
        {
        dfs(x+1,totw+w[x]*m,totv+v[x]*m);
        m+=1;
        }
    }
}

3.多重背包：给了规定件数可以取，求最大价值

void dfs(int x,int totw,int totv)
{
    if(x>n)
    {
        if(totw>ans)
            ans=totw;
        return ;
    }
    else
    {
        dfs(x+1,totw,totv);
        for(int i=1;i<=member[x];i++)
        {
            if(totv+v[x]*i<t)
        dfs(x+1,totw+w[x]*i,totv+v[x]*i);
        m+=1;
        }
    }
}

当然，我们这里都是最最基本的搜索，欢迎补充优化

* 分析哈密顿回路问题： 1 “划分游戏阶段”：走到了哪一个点

　　　　　　　　　　　 2 “行动”：下一步走哪一个点

　　　　　　　　　　　 3* “胜利”：把全部点都走遍了

　　　　　　　　　　　 4* “约束”：在过程中有没有走到重复的点

#include <cstdio>
#include <algorithm>
using namespace std;

const int N = 25;

int n, cnt;
int a[N][N];
int v[N], p[N];

void print()
{
    printf("Route #%d: ", ++cnt);
    for(int i=1; i<=p[0]; i++) printf("%d - ", p[i]);
    printf("1
");
}

void dfs(int x)
{
    v[x] = 1, p[++p[0]] = x;//记录走的那几个点 

    if(p[0] == n)
    {
        if(a[p[0]][1]) print();//如果头和尾也相连，输出 
    }
    else for(int i=1; i<=n; i++) 
            if(a[x][i] && !v[i])//有路径并且没有走过->搜索 
                dfs(i);
    
    v[x] = 0, p[p[0]] = 0, --p[0];//回溯 
}

int main()
{
//    freopen("hamilton.in", "r", stdin);
//    freopen("hamilton.out", "w", stdout);

    scanf("%d", &n);
    for(int i=1; i<=n; i++) 
        for(int j=1; j<=n; j++) 
            scanf("%d", &a[i][j]);//用邻接矩阵来存储的哈密尔顿环 

    dfs(1);

    return 0;
}

*POJ 1979  红与黑：考虑 问题的各个步骤
　　1 阶段/ 搜索顺序：一步一步的走
　　2 状态：目前走到的位置
　　3 行动：向上下左右各走一步
　　4 胜利条件/ 结束条件：没有地方可以走了
　　5 约束：不能走出房间/ 不能走到红色瓷砖上

#include <cstdio>
using namespace std;

const int N = 25;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};

int n, m, sx, sy, cnt;
int a[N][N], vs[N][N];

void dfs(int x, int y)
{
    ++cnt, vs[x][y] = 1;//计数加标记 
    for(int d=0; d<4; d++)
    {
        int i=x+dx[d], j=y+dy[d];//上下左右四个方向 
        if(i<1 || j<1 || i>n || j>m || a[i][j]=='#' || vs[i][j]) continue;
        //不越界，不违法约束 
        dfs(i, j);
    }
}
//当然，这道题用bfs也可以做，但都差不多 
int gc()
{
    int c;
    while(c=getchar(), c<=' ');
    /*先输入数据，之后getchar()的返回值一个接一个赋给c,
     然后比较c是不是不等于' '，如果不等于回车键就会执行循环。
     如果等于就会结束*/ 
     //相当于用输入字符矩阵 
    return c;
}

void work()
{
    for(int i=1; i<=n; i++) 
        for(int j=1; j<=m; j++)
    {
        a[i][j] = gc(), vs[i][j] = 0;
        if(a[i][j]=='@') sx = i, sy = j;//标记所给位置 
    }
    /*
    ch=getchar();等待从键盘上输入一个字符
    putchar(ch);输出此字符
    他们包含在头文件　#include<stdio.h>中．
    */ 
    cnt = 0;
    dfs(sx, sy);//从所给位置开始搜索 
    printf("%d
", cnt);
}

int main()
{
    freopen("rnb.in", "r", stdin);
    freopen("rnb.out", "w", stdout);
    
    while(scanf("%d%d", &m, &n), n*m) work(); 
    //且m!=0||n!=0 ,当然它的数据是保证合法的 
    //用while循环输入，它的输入输出端是自动连在文件上的，
    //所以用键盘输入是不会有结果的 
    
    return 0;
}

DFS小总结：* 问题的各个步骤:
　　　　　　1 阶段/ 搜索顺序　　　　

　　　　　　2 状态：全局状态记得回溯（有的不需要）　　　

　　　　　　3 行动：枚举所有可能的行动
　　　　　　4 胜利条件/ 结束条件
　　　　　　5 约束

下面我们来看BFS(前方高能预警)

* BFS 搜索的思想是十分简单的： - 给定一个起始状态(将其记作 S0)；

　　　　　　　　　　 - 记录从起始状态向外走一步能到达的状态(我们把它记作 S1)；

　　　　　　　　　　 - 记录从 S1 走一步能到达的状态(将它们记作 S2)；

　　　　　　　　　　　显然，这些 状态都能从起始状态走两步到达。

　　　　　　　　　　　* 最终，如果目标状态出现在 Sk 中，则显然它可以从起始状态 走k 步到达(所以最终答案是最小的 k)。

　　　　　　　　　　　* 我们称这种做法为逐步扩展。

八数码

题目太经典就不显示了，而且这道题目曾经搞的我一晚上也没睡好，所以我今天一定要把它办掉

八数码问题的状态即为棋盘上的八个数字

从每一个空格开始上下左右各一种可能

扩展出第一种状态，依次类推

补充一点，bfs 是用队列来实现的

但有一个很重要的问题就是 ：如何判重，以及哪些是重复的。

（好像这里有图的样子）

#include<iostream>
#include<cstdio>
using namespace std;
int main()
{
    printf("1 2 3
");
    printf("5   6
");
    printf("7 8 9
");
    cout<<"---->"
    printf("         1 2 3
");
    printf("         5 6  
");
    printf("         7 8 9
");
    //那么把从这个空格开始向四个方向扩展，必定有一种情况是这样的
    printf("1 2 3
");
    printf("5   6
");
    printf("7 8 9
");
    //这样就回到原来的状态了，即为重复
    //而我们要克服的就是这些 
} 

接下来我们从程序入手

本来应该是三步优化，一步比一步快，但我想，我写的既然是一个总结帖，我为什么不直接把最优的展示出来能？（好像很有道理的样子）

---

其实是我懒

 下面我们看程序

struct _state
{
    int w[N][N];//当前这个棋盘的状态
    int x, y;//该空格的位置
    int step;//走了几步
    int pre, dirc;//父亲和对应的操作

如何判重？

如果我们开一个九维数组的话，哪怕是开bool型的，有以下几个麻烦之处

1.写起来麻烦

2.存起来费空间

3.查找起来费时间

4.看着别扭

综上所述，我们聪明的前辈想到了一种很不错的存储办法，

------>用一个九位数来存

这样只需要int就足够了

像这样：

    int calc()
    {
        int ret = 0;
        for(int i=0; i<N; i++)
            for(int j=0; j<N; j++)
                ret = ret * 10 + w[i][j];
        return ret;
    }

那么程序实现就是

int bfs(_state start, _state end)
{
    head = tail = 1;
    start.step = 0;
    start.pre = -1;
    queue[1] = start;
    
    S.clear();
    S.insert(start.calc());

    for(; head<=tail; ++head)
    {
        _state cur = queue[head];
        int x = cur.x, y = cur.y;

        for(int i=0; i<4; i++)
        {
            int nx = x + dx[i], ny = y + dy[i];
            if(nx<0 || ny<0 || nx>=N || ny>=N) continue;
                        //枚举上下左右四个位置
            _state now = cur;//新的状态
            now.x = nx, now.y = ny;//新的空格位置
            swap(now.w[x][y], now.w[nx][ny]);//交换位置
            now.step++;//步数+1
            now.pre = head;//记录父亲
            now.dirc = i;//操作：空格移动的方向

            int nst = now.calc();
            if(S.find(nst) == S.end())//用set的一个判重，下面会讲：如果没有重复的数字
                queue[++tail] = now,//加入队列
                S.insert(nst);//并标记该状态

            if (equal(now,end)) return tail;
        }
    }

    return -1;
}
            

补充一点：set是个神马东东

 set集合容器实现了红黑树（Red-Black Tree）的平衡二叉检索树的的数据结构，在插入元素时，它会自动调整二叉树的排列，把该元素放到适当的位置，以确保每个子树根节点的键值大于左子树所有节点的键值，而小于右子树所有节点的键值；另外，还得确保根节点的左子树的高度与右子树的高度相等，这样，二叉树的高度最小，从而检索速度最快。要注意的是，它不会重复插入相同键值的元素，而采取忽略处理。

        平衡二叉检索树的检索使用中序遍历算法，检索效率高于vector、deque、和list的容器。另外，采用中序遍历算法可将键值由小到大遍历出来，所以，可以理解为平衡二叉检索树在插入元素时，就会自动将元素按键值从小到大的顺序排列。

        构造set集合的主要目的是为了快速检索，使用set前，需要在程序头文件中包含声明“#include<set>”。

采用inset()方法把元素插入到集合中，插入规则在默认的比较规则下，是按元素值从小到大插入，如果自己指定了比较规则函数，则按自定义比较规则函数插入。使用前向迭代器对集合中序遍历，结果正好是元素排序后的结果。

下面我先放一波程序

#include <set>
#include <cstdio>
#include <algorithm>
using namespace std;

const int N = 3;
const int M = 1e6 + 5;

const int dx[4] = {0, 0, 1, -1};
const int dy[4] = {1, -1, 0, 0};//四个方向搜索的小技巧
const char mov[4] = {'R', 'L', 'D', 'U'};

struct _state
{
    int w[N][N];
    int x, y;
    int step;
    int pre, dirc;

    void read()//读入矩阵并存储空格位置
    {
        for(int i=0; i<N; i++)
            for(int j=0; j<N; j++)
            {
                scanf("%d", &w[i][j]);
                if(!w[i][j]) x=i, y=j;
            }
    }

    int calc()//将矩阵改为一个九位数
    {
        int ret = 0;
        for(int i=0; i<N; i++)
            for(int j=0; j<N; j++)
                ret = ret * 10 + w[i][j];
        return ret;
    }
};

int equal(_state x, _state y)//
{
    for(int i=0; i<N; i++)
     for(int j=0; j<N; j++)
        if(x.w[i][j] != y.w[i][j]) return 0;
    return 1;
}

_state queue[M];
set<int> S;

int head, tail;

int bfs(_state start, _state end)//开始状态，结束状态各有两个矩阵来表示
{
    head = tail = 1;//队列为空
    start.step = 0;//初始步骤为零
    start.pre = -1;//初始状态没有父亲
    queue[1] = start;//初始状态入队

    S.clear();//清空set
    S.insert(start.calc());//插入这个矩阵所转化为的九位数

    for(; head<=tail; ++head)//如果队列不为空
    {
        _state cur = queue[head];//取队首
        int x = cur.x, y = cur.y;//复制空格位置

        for(int i=0; i<4; i++)
        {
            int nx = x + dx[i], ny = y + dy[i];
            if(nx<0 || ny<0 || nx>=N || ny>=N) continue;

            _state now = cur;
            now.x = nx, now.y = ny;
            swap(now.w[x][y], now.w[nx][ny]);//拓展空格位置
            now.step++;
            now.pre = head;//记录是第几步
            now.dirc = i;//从哪个方向拓展来的

            int nst = now.calc();
            if(S.find(nst) == S.end())//end()返回集合里最后一个元素的迭代器
　　　　　　　　　　　　　　　　　　　　　　//返回指向被查找元素的迭代器
　　　　//find()可以查找一个元素在集合里的迭代器，如果该元素未出现过，则返回end()
                queue[++tail] = now,//（注意是逗号）使该元素入队
                S.insert(nst);

            if (equal(now,end)) return tail;//如果该矩阵已经和要求矩阵一样了
        }
    }

    return -1;
}

int seq[N];

void print(int no, int x)
{
    printf("Step #%d
", x);
    for(int i=0; i<N; i++)
    {
        for(int j=0; j<N; j++)
　　　　　　 printf("%d ", queue[no].w[i][j]);//输出当前步数下的矩阵
        printf("
");
    }
}

int main()
{
    //freopen("eight.in", "r", stdin);
   // freopen("eight.out", "w", stdout);

    _state start, end;

    start.read();
    end.read();

    int ans = bfs(start, end);

    printf("%d
", queue[ans].step);

s:
    for(int i=tail; i>=0; i=queue[i].pre)
        seq[++seq[0]] = i;//用s[0]来存储个数
    for(int i=seq[0]; i>=1; i--)
        print(seq[i], seq[0]-i);//输出矩阵
    printf("Moving Sequence: 
");
    for(int i=seq[0]-1; i>=1; i--)
        printf("%c", mov[ queue[seq[i]].dirc ]);//输出该矩阵的操作

    return 0;
}

 注意，bfs是逐层扩展的，相当于给第一次一个编号，给第二层一个编号。。。。。。

不要与dfs混淆

下面我们看跳马问题

跳马就是八个方向遍历，然后判重，如程序

#include <cstdio>
#include <algorithm>
using namespace std;

const int N = 303;
const int dx[8] = {-2, -1, 1, 2, 2, 1, -1, -2};
const int dy[8] = {1, 2, 2, 1, -1, -2, -2, -1};

struct _state
{
    int x, y, step;
};

int t, n;
int sx, sy, tx, ty;
int vs[N][N];
int head, tail;
_state que[N * N];

void work()
{
    scanf("%d", &n);
    scanf("%d%d", &sx, &sy);
    scanf("%d%d", &tx, &ty);

    for(int i=0; i<n; i++)
        for(int j=0; j<n; j++) vs[i][j] = 0;//标记初始状态全部为未走过

    head = tail = 1;
    que[head].x = sx;
    que[head].y = sy;//入队
    que[head].step = 0;//这个步数还是逐层扩展的
    vs[sx][sy] = 1;

    for(; head <= tail; ++head)
    {
        int x = que[head].x;
        int y = que[head].y;
        int step = que[head].step;

        if(x == tx && y == ty)//到达目标，输出
        {
            printf("%d
", step);
            return;
        }

        for(int i=0; i<8; i++)
        {
            int nx = x + dx[i];
            int ny = y + dy[i];
            int nstep = step + 1;//大佬做深/广搜题喜欢先把下一步的状态写出来，然后再判断，再入队/搜索

            if(nx<0 || ny<0 || nx>=n || ny>=n) continue;
            if(vs[nx][ny]) continue;

            ++tail;
            que[tail].x = nx;
            que[tail].y = ny;
            que[tail].step = nstep;
            vs[nx][ny] = 1;//这里就是判重，使得它必定能找到解
        }
    }
}

int main()
{
    //freopen("knight.in", "r", stdin);
    //freopen("knight.out", "w", stdout);

    scanf("%d", &t);
    for(int i=1; i<=t; i++) work();

    return 0;
}

接下来是倒水问题，

 倒水问题：有两个水壶，容积分别为 A，B。有三种操作： Fill(往一个水壶倒满水)，Drop(倒出某个水壶的水)，Pour(将 其中一个水壶的水倒入另一个水壶中，倒满即止)。

- 问倒出 C 升水，最少的步数是多少。

这个我们就分六步来进行讨论

设水壶a,b;

1.倒空a

2.倒空b;

3.倒满a;

4.倒满b;

5.把a倒向b(这里需要判断a,b水量)

6.把b倒向a(这里需要判断a,b水量)

具体操作如下

#include <cstdio>
#include <string>
#include <algorithm>
using namespace std;

const int N = 103;

const string operate[6] =
{
"FILL(1)", "FILL(2)", "DROP(1)",
"DROP(2)", "POUR(1,2)", "POUR(2,1)"
};

struct _state//每一个水杯状态所含的消息
{
int x, y;
int step;
int pre, op;
};

int a, b, c;
int vs[N][N];
int head, tail;
_state que[N * N];

int seq[N];

void print(int x)
{
printf("%d ", que[x].step);
for(int i=x; i>=0; i=que[i].pre)
seq[++seq[0]] = i;
for(int i=seq[0]-1; i>=1; i--)
printf("%s ", operate[que[seq[i]].op].c_str());//c_str()下文有讲，

}

//总结一下这种倒向输出转移状态的步骤

/*

1.新开一个数组来倒叙存储下标

2.一个倒叙for，输出最后一步所在队列的状态，用刚才存储的下标来做

3.前提：你在进行bfs扩展时，已经存储了它的父节点，已经操作方式

*/

void add_state(int nx, int ny, int nstep, int pre, int op)
{
if(vs[nx][ny]) return;

vs[nx][ny] = 1;//标记该状态已经走过

++tail;
que[tail].x = nx;
que[tail].y = ny;
que[tail].step = nstep;
que[tail].pre = pre;
que[tail].op = op;

//入队

}

void work()
{
scanf("%d%d%d", &a, &b, &c);

for(int i=0; i<=a; i++)
for(int j=0; j<=b; j++) vs[i][j] = 0;

head = tail = 1;
que[head].x = 0;
que[head].y = 0;
que[head].step = 0;
que[head].pre = -1;
vs[0][0] = 1;//初始状态入队

for(; head <= tail; ++head)
{
int x = que[head].x;
int y = que[head].y;
int step = que[head].step;//取队首

if(x == c || y == c)
{
print(head);//正解，输出
return;
}

// Fill
add_state(a, y, step+1, head, 0);
add_state(x, b, step+1, head, 1);

// Drop
add_state(0, y, step+1, head, 2);
add_state(x, 0, step+1, head, 3);

// Pour
int aug = min(x, b - y);
add_state(x-aug, y+aug, step+1, head, 4);

aug = min(y, a - x);
add_state(x+aug, y-aug, step+1, head, 5);
}

puts("impossible");
}

int main()
{
freopen("cups.in", "r", stdin);
freopen("cups.out", "w", stdout);

work();

return 0;
}

补充：

函数声明:const char *c_str();

c_str()函数返回一个指向正规C字符串的指针, 内容与本string串相同.

这是为了与c语言兼容，在c语言中没有string类型，故必须通过string类对象的成员函数c_str()把string 对象转换成c中的字符串样式。

注意:一定要使用strcpy()函数 等来操作方法c_str()返回的指针

例：

应该这样用:

char c[20];

string s="1234";

strcpy(c,s.c_str());

这样才不会出错，c_str()返回的是一个临时指针，不能对其进行操作

c_str()返回的是一个分配给const char*的地址，其内容已设定为不可变更，如果再把此地址赋给一个可以变更内容的char*变量，就会产生冲突，在2010中是不被允许的。但是如果放入函数调用，或者直接输出，因为这些函数和输出都是把字符串指针作为 const char*引用的，所以不会有问题。

c_str() 以const char* 类型返回 string 内含的字符串

如果一个函数要求char*参数，可以使用c_str()方法:

string s = "Hello World!";

printf("%s", s.c_str()); //输出 "Hello World!"

c_str在打开文件时的用处:

当需要打开一个由用户自己输入文件名的文件时，可以这样写:ifstream in(st.c_str());。其中st是string类型，存放的即为用户输入的文件名。

bfs小结

* BFS 问题的各个步骤:

1 阶段/ 搜索顺序：题目会明确地给出

2 状态：与 DFS 类似，要保存所有的信息

3 行动：与 DFS 类似，枚举所有可能的行动

4 胜利条件/ 结束条件：题目明确地给出

5 约束

6* 判重：如何判断状态已经重复？- DFS 问题中，使用判重来减少搜索量：记忆化搜索

7* 输出方案：通过记录父亲状态，一步一步回推。 - 为什么在 DFS 问题中，我们没有着重提出如何输出方案？

好了，那么到现在为止，基础搜索题目我已经把我所学到的全部整理完了，

如果你认为还有和这些题目同样经典的，请私信找我

byebye！(^o^)/~