深度遍历模版与广度遍历模版

深度优先遍历

//void dfs(中间容器，数据)
//{
//    if(临界走到末尾)
//    {
//        中间容器加到最终容器
//        return；
//    }
//    for(做选择)
//    {
//        改变中间容器
//        dfs(中间容器，数据)
//        撤回对中间容器的改变
//    }
//}

全排列例题

#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
using namespace std;
void dfs(string &rs,vector<string> &rss,vector<int> &choose,int n)
{
    if(rs.size()==n)
    {
        rss.push_back(rs);
        return;
    }
    for(int i=0;i<choose.size();i++)
    {
        int temp=choose[i];
        rs.push_back(temp+'0');
        choose.erase(choose.begin()+i);
        dfs(rs,rss,choose,n);
        rs.pop_back();
        choose.insert(choose.begin()+i,temp);
    }
}

int main()
{
    int n=0;
    cin>>n;
    string rs;
    vector<string > rss;
    vector<int> choose;
    for(int i=1;i<=n;i++)
    {
        choose.push_back(i);
    }
    dfs(rs,rss,choose,n);
    sort(rss.begin(),rss.end());
    for(int i=0;i<rss.size();i++)
    {
        for(int j=0;j<rss[i].size();j++)
        {
            cout<<rss[i][j]<<" ";
        }
        cout<<endl;
    }
}

n皇后问题

从第一行看皇后 能看到放在哪一列

走的过程中 判断是否在

剪枝有两种

可信性剪枝是判断 走的过程提前判断 ,非法的就没必要走了

最优性剪枝 比其他路优秀 不用走那条路了

用三个map作为中间变量

第一个map。 key是列,value是行

第二个map 存储x+y的截距

第三个map 存储x-y的解决

因为斜线的斜率是1,所以 y=x+b. y=-x+b 即可 算出两个方向的截距,通过截距可以唯一确定一条直线

#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<map>
#include<cmath>
using namespace std;


void dfs(map<int,int> &kv,map<int,int> &kv2,map<int,int> &kv3,vector<map<int,int> > &rss,int k,int n)
{
    if(kv.size()==n)
    {
        rss.push_back(kv);
    }
    for(int i=0;i<n;i++) // 在第k行选择哪一列
    {
        if(kv.count(i))
        {
            continue;
        }
        if(kv2.count(k+i))
        {
            continue;
        }
        if(kv3.count(k-i))
        {
            continue;
        }
        kv[i]=k;
        kv2[k+i]=1;
        kv3[k-i]=1;
        dfs(kv,kv2,kv3,rss,k+1,n);
        kv.erase(i);
        kv2.erase(k+i);
        kv3.erase(k-i);
    }
}

int main()
{
    int n=0;
    cin>>n;
    map<int,int> kv;// key 是列，value是行
    map<int,int> kv2;// 存储第一种截距 +
    map<int,int> kv3;// 存储第二种截距 -
    vector<map<int,int> > rss;
    dfs(kv,kv2,kv3,rss,0,n);
    for(auto item:rss)
    {
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(item.count(j)&&item[j]==i)
                {
                    cout<<"Q";
                }
                else
                {
                    cout<<".";
                }
            }
            cout<<endl;
        }
        cout<<endl;
    }

}

广度优先遍历

有 “最短路” 的概念, 当图的权重都是为1的时候, 图先找到的都是bfs,最短的

最短 看好广搜 记得边的权重为1

但是费空间 o(2^N). 深搜只用o(n)

quene <- 初始状态
while(queue 不空)
{
	t<- 对头拿出来
	扩展队头
	压入队列
}

走迷宫例题 用广搜

需要额外的数据存储 vis表示是否访问过 dis表示距离

#include<vector>
#include<algorithm>
#include<iostream>
#include<queue>
#include<map>
using namespace std;
int bfs(vector<vector<int> > &mapit)
{
    int n=mapit.size();
    int m=mapit[0].size();
    queue<pair<int,int> > ls;
    vector<vector<int> > dis(n,vector<int>(m));
    vector<vector<int> > vis(n,vector<int>(m));
    ls.push(make_pair(0,0));
    while(ls.size()!=0)
    {
        pair<int,int> it=ls.front();
        ls.pop();
        int qs[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
        for(int i=0;i<4;i++)
        {
            if(it.first+qs[i][0]<n&&it.first+qs[i][0]>=0&&it.second+qs[i][1]<m&&it.second+qs[i][1]>=0&&vis[it.first+qs[i][0]][it.second+qs[i][1]]==0&&mapit[it.first+qs[i][0]][it.second+qs[i][1]]==0)
            {
                dis[it.first+qs[i][0]][it.second+qs[i][1]]=dis[it.first][it.second]+1;
                vis[it.first+qs[i][0]][it.second+qs[i][1]]=1;
                ls.push(make_pair(it.first+qs[i][0],it.second+qs[i][1]));
            }
        }
    }
    return dis[n-1][m-1];
}
int main()
{
    int n,m;
    cin>>n>>m;
    vector<vector<int> > mapit(n, vector<int>(m));
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            cin>>mapit[i][j];
        }
    }
    cout<<bfs(mapit)<<endl;

}