第三周学习总结

根据老师的要求，每天坚持看博客和题解，本周已经看了五十篇的博客。本周主要看了关于搜索与思维的博客与题解。

总结：

1.搜索

BFS广度优先搜索，是一种分层查找的过程，首先访问起始顶点v，然后由v出发，依次访问v的各个未被访问过的邻接顶点w1,w2,w3….wn，然后再依次访问w1，w2,…,wi的所有未被访问过的邻接顶点，再从这些访问过的顶点出发，再访问它们所有未被访问过的邻接顶点….以此类推，直到途中所有的顶点都被访问过为止。一般应用于单源最短路径的搜索。

搜索步骤：

1、首先创建一个vis[ ]数组和一个队列q，分别用来判断该位置是否已经访问过及让未访问过的点入队；

2、is[ ]数组，清空q队列；

 3、让起点start入队，并使该点的vis置1；

 4、while（！q.empty()）{......}执行搜索操作，
    a、取出队头元素后使队头元素出队，判断该元素是否为目标到达点；
    b、如果是目标点，就返回结果；
    c、如果不是目标点，就继续访问与其相邻的位置点，将可走的相邻的位置点入队，并更新vis[ ]；

下面通过一个题目进行理解BFS:

简单的迷宫: 它是一个N*M的矩形区域，每个格点可以通向相邻上下左右四个格点，起点为（1,1），终点为（N，M）。除此之外，迷宫内还有K个点为障碍点，表示他们不可到达，但障碍点不会出现在起点和终点。

#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
int const MAX = 55;
int map[MAX][MAX];
int vis[MAX][MAX];
int dirx[4] = {1,-1,0,0};   //四个方向
int diry[4] = {0,0,-1,1};
int n, m, k;
struct Point
{
    int x, y;
    int step;
};
 
int BFS()
{
    memset(vis,0,sizeof(vis));  //初始化vis
    queue<Point> q;
    Point node, t;
    node.x = 1;
    node.y = 1;
    node.step = 0;
    vis[1][1] = 1;
    q.push(node);   //将起点压入队列
    while(!q.empty())   //队列非空时执行操作
    {
        node = q.front();   //接收队首元素
        q.pop();            //队首出队
        for(int i = 0; i < 4; i++)   //向四个方向走
        {
            t = node;
            t.x += dirx[i];
            t.y += diry[i];
            t.step++;
            if(t.x == n && t.y == m)   //到达终点返回步数
                return t.step;
            //判断该点的可行性
            if(t.x < 1 || t.x > n || t.y < 1 || t.y > n || !map[t.x][t.y] || vis[t.x][t.y]) 
                continue;
            //可行则标记为已访问，该点如队列
            else
            {
                vis[t.x][t.y] = 1;
                q.push(t);
            }
        }
    }
    return -1;
}
 
int main()
{
    int xi, yi;
    while(scanf("%d %d %d",&n, &m, &k) != EOF)
    {
        memset(map,1,sizeof(map));
        for(int i = 0; i < k; i++)
        {
            scanf("%d %d",&xi, &yi);
            map[xi][yi] = 0;
        }
        printf("%d\n", BFS());
    }
}

DFS深度优先搜索，其过程为沿着每一个可能的路径向下进行搜索，直到不能再深入为止，然后回溯到上一层，取另一分支再进行搜素，并且每一个节点只能访问一次，直到找到目标状态为止。一般可以解决最短路径、n皇后等问题。

基本模板：

int check(参数)
{
    if(满足条件)
    return 1;
    return 0;
}
void dfs(int step)
{       判断边界
        {相应操作}
        尝试每一种可能
        {      满足check条件
               标记
               继续下一步dfs(step+1)
               恢复初始状态（回溯的时候要用到）

       }
}   
具体题目：n皇后问题

在N*N的方格棋盘放置了N个皇后，使得它们不相互攻击（即任意2个皇后不允许处在同一排，同一列，也不允许处在与棋盘边框成45角的斜线上。对于给定的N，求出有多少种合法的放置方法。

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
int map[20];   //  用来记录皇后在某行某列  如 map[a]=b 就表示皇后在 a 行 b 列 
int ans[20];   //  用于打表记录 N 皇后的个数 
int n,sum;
bool judge(int v)  // 判断放该皇后 前几列的情况 
{
	for(int i=1;i<v;i++)
	{
		if(map[v]==map[i]||abs(map[v]-map[i])==abs(v-i))    // 判断两个皇后 是否在同一列 是否在对角线上
			return 0;
	}
	return 1;
}
void DFS(int v)
{
	if(v>n)
	{
		sum++;
		return;
	}
	for(int i=1;i<=n;i++)
	{
		map[v]=i;  //记录皇后在 v 行的 i 列；第一次皇后从第一行第一列摆放，n个皇后全部放完后，结束；第二次从第一行第二列摆放；依次摆放到第一行第n列
		if(judge(v))
		{
			DFS(v+1);
		}
	}
}
int main()
{
	for(n=1;n<=10;n++)
	{
		sum=0;
		memset(map,0,sizeof(map));
		DFS(1);
		ans[n]=sum;
	}
	while(scanf("%d",&n)&&n)
	{
		printf("%d\n",ans[n]);
	}
	return 0;
} 

2、思维

在看的思维题目里看到的大多数都是比较简单一点的题目。我认为做此类问题总结为二个步骤：建模、解模。阅读问题，对题目进行数学上的理解，建立一个模型可以说是一个公式之类的（本质），然后，通过模型进行思考各种情况，将题目思考到位，解出模型。

题目：

有一天，尼基塔发现了只包含字母"a"和"b"的字符串。Nikita认为，如果字符串可以切成3个字符串（可能是空的），而不改变字母的顺序，其中1-st和3-rd只包含字母"a"，而2-nd只包含字母"b"，那么字符串是美丽的。Nikita 希望通过删除一些（可能没有）字符来使字符串变得漂亮，但不更改其顺序。他能得到的绳子的最大长度是多少？

思路：可以看出他们的相对位置非常重要，所以我们利用前后缀的思想，n^2暴力枚举，就可以得出最后答案了。注意我们枚举的是b的所在长度，为了前后缀当然我们要把他们转化成相应的01字符串就好做了。

#include<bits/stdc++.h>
using namespace std;

const int maxn = 1e4+5;
int n,m;
int a[maxn],b[maxn],c[maxn],dp[maxn];
//a存最后的答案. c是中间的辅助记数. dp表示对应此时a序列中的数都构成的方法数.
void solve()
{
    scanf("%d%d",&n,&m);
    for(int i=0;i<=m;i++) scanf("%d",&b[i]);
    int k = 0; Fill(dp,0); Fill(a,0); Fill(c,0);
    dp[0] = 1;   //初始dp[0]=1表示构成0肯定是有一种方案的.
    for(int i=1;i<=m;i++){
        c[i] = b[i] - dp[i];  //A序列中i的个数
        for(int j=1;j<=c[i];j++){
            a[k++] = i;  //对A序列赋值
            for(int k=m;k>=i;k--){ //处理成01背包
                dp[k] += dp[k-i]; //和为k的A子集个数相加去更新B序列
            }
        }
    }
    for(int i=0;i<k;i++){
        if(i>0) printf(" ");
        printf("%d",a[i]);
    }
    printf("\n");
}

本周看的题解比较多，拿出了我认为自己比较深刻的几道题目，但所看的题目也有一些自己理解不到位的地方，还需继续学习博主写题解的思路。而且，我觉得能够出题，最主要的要把握题目的本质。对于我来说，每个题目没法立刻能明白其本质，还需要反复的进行学习，做到熟能生巧。