第二章 搜索（DFS之连通性模型，搜索顺序）

迷宫（连通性模型）

问题描述

解题思路

一道简单的DFS连通性模型的问题，其中需要注意的是遍历过的每一个点，在回溯时不需要恢复现场，因为本题中dfs是为了搜索时候能到达最重点，若一个不可到达最终点，那么也就没有回溯的必要了，所以每个点只会被遍历一次

AC代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 105;
int n;
char g[N][N];
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
bool st[N][N];
int gx,gy;

bool dfs(int x,int y)
{
    if(x==gx && y==gy) return true;
    
    for(int i=0;i<4;i++)
    {
        int a=x+dx[i],b=y+dy[i];
        if(a<0 || b<0 || a>=n || b>=n) continue;
        if(st[a][b]) continue;
        if(g[a][b]=='#') continue;
        st[a][b]=true;
        if(dfs(a,b)) return true;
    }
    return false;
    
}

void solve()
{
    memset(st, 0, sizeof st);
    cin>>n;
    for(int i=0;i<n;i++) cin>>g[i];
    int sx,sy;
    cin>>sx>>sy>>gx>>gy;
    if(g[sx][sy]=='#' || g[gx][gy]=='#')
    {
        cout<<"NO"<<endl;
        return;
    }
    if(dfs(sx,sy)) puts("YES");
    else puts("NO");
}

int main()
{
    cin.tie(0);
    int t;
    cin>>t;
    while(t--)
    {
        solve();
    }
    return 0;
}

红与黑（连通性模型）

问题描述

解题思路

爽题

AC代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 30;
int res = 1;
int n, m;

char g[N][N];
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
bool st[N][N];

void dfs(int x, int y)
{

    for (int i = 0; i < 4; i++)
    {
        int a = x + dx[i], b = y + dy[i];
        if (a < 0 || a >= n || b < 0 || b >= m)
            continue;
        if (st[a][b])
            continue;
        if (g[a][b] == '#' || g[a][b] == '@')
            continue;
        st[a][b] = true;
        res++;
        dfs(a, b);
    }
    return;
}

int main()
{
    while (cin >> m >> n && m != 0 && n != 0)
    {
        res = 1;
        memset(st, 0, sizeof st);
        for (int i = 0; i < n; i++)
            cin >> g[i];
        int x, y;
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
            {
                if (g[i][j] == '@')
                    x = i, y = j;
            }
        dfs(x, y);
        cout << res << endl;
    }
    return 0;
}

马走日（搜索顺序）

问题描述

解题思路

本体需要注意的是在恢复现场的过程中需要回溯的时候，记得恢复现场。而且本题在遍历到一个点的时候，需要对它立刻进行标记，并且在函数快要结束时，恢复现场

AC代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 30;

int n,m,x,y;
int res;
bool st[N][N];

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

void dfs(int u,int x,int y)
{
    if(u==n*m)
    {
        res++;
        return;
    }
    st[x][y]=true;
    for(int i=0;i<8;i++)
    {
        int a=x+dx[i],b=y+dy[i];
        if(a<0 || b<0 || a>=n || b>=m) continue;
        if(st[a][b]) continue;
        dfs(u+1,a,b);
        
    }
    st[x][y]=false;
}


void solve()
{
    memset(st, 0, sizeof st);
    cin>>n>>m>>x>>y;
    res=0;
    dfs(1,x,y);
    cout<<res<<endl;
}

int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        solve();
    }
    return 0;
}

单词接龙（搜索顺序）

问题描述

解题思路

本道题的解题关键在于g[i][j]数组，用于存储编号i为龙头，编号j为龙尾时重合部分的长度。而dfs部分则没有什么难度，注意好字符串拼接即可

AC代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 22;

int n;
string word[N];
int g[N][N];//g[i][j]代表以编号i为龙头，编号j为龙尾时重合部分的长度
bool st[N][N];
int used[N];
int ans;

void dfs(string dragon,int last)//last表示当前是第几个单词
{
    ans = max((int) dragon.size(), ans);//取最大值，dragon.size()为当前合并的长度

    used[last]++;//编号为last的单词被用次数++；

    for (int i = 0; i < n; i++)
        if (g[last][i] && used[i] < 2)//used[i]<2代表单词用次数不超过2
            dfs(dragon + word[i].substr(g[last][i]), i); //编号为last的可以被i拼接现在尾巴为i号

    used[last]--;//恢复现场

}
int main()
{
    cin>>n;
    for(int i=0;i<n;i++)
    cin>>word[i];
    char start;
    cin>>start;

    for (int i = 0; i < n; i++)//遍历得到各个g[i][j]
        for (int j = 0; j < n; j++) {
            string a = word[i], b = word[j];
            for (int k = 1; k < min(a.size(), b.size()); k++)
                if (a.substr(a.size() - k, k) == b.substr(0, k)) {
                    g[i][j] = k;
                    break;
                }
        }


    for(int i=0;i<n;i++)
    {
        if(word[i][0]==start)
        dfs(word[i],i);
    }
    cout<<ans<<endl;
    return 0;
}

分成互质组（搜索顺序）

问题描述

解题思路

本题通过分组按顺序的方式来枚举每一个方案将每一个数看是否能插入到一个互助组里，若能，这插入，若不能则新开一个组。

AC代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 15;

int n;
int a[N];
int res = N;
bool st[N];
int g[N][N];

int gcd(int a, int b)
{
    return b ? gcd(b, a % b) : a;
}

// check函数用于判断当前的数和当前组里的数是否一一互质
bool check(int g[], int a, int start)
{
    for (int i = 1; i < start; i++)
    {
        if (gcd(g[i], a) > 1)
            return false;
    }
    return true;
}

//关于dfs的四个参数：
// gr表示所在第几组，gc表示所在该组的第几个数
// start表示当前能放入该组的数从几开始
// cnt表示当前已经有多少个数分配完毕
void dfs(int gr, int gc, int start, int cnt)
{
    if (gr >= res)
        return; //剪枝
    if (cnt == n)
        res = gr; // n个数分配完毕，更新res

    bool flag = true; //用于判断当前组里面是否还能继续分配元素了

    for (int i = start; i <= n; i++)
    {
        //如果下面是个if成立说明当前组还能继续分配数字
        if (!st[i] && check(g[gr], a[i], gc))
        {
            st[i] = true;
            g[gr][gc] = a[i];
            dfs(gr, gc + 1, i + 1, cnt + 1);
            st[i] = false;
            flag = false;
        }
    }
    //如果当前组一个数字也分配不了了，则需要另开一个新的组
    if (flag)
        dfs(gr + 1, 1, 1, cnt);
}

int main()
{
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> a[i];

    dfs(1, 1, 1, 0);
    cout << res << endl;

    return 0;
}