[kuangbin带你飞]专题一 简单搜索 题解报告

又重头开始刷kuangbin，有些题用了和以前不一样的思路解决。全部题解如下

点击每道题的标题即可跳转至VJ题目页面。

A-棋盘问题

棋子不能摆在相同行和相同列，所以我们可以依此枚举每一行，然后标记每一列是否走过，在此基础上进行DFS即可。

代码如下：

#include <iostream>
#include <cstring>
using namespace std;
int n,m,sum;
char mp[10][10];
int vis[10] = {0};

void dfs(int r,int k){
  if(k == m){
    sum++;
    return ;  
  }
  for(int i = r; i < n; i++){
    for(int j = 0; j < n; j++){
      if(mp[i][j] == '#' && !vis[j]){
        vis[j] = 1;
        dfs(i+1,k+1);
        vis[j] = 0;
      }
    }
  }
}

int main(){
  while(cin>>n>>m && n > 0 && m > 0){
    memset(vis, 0, sizeof vis);
    sum = 0;
    for(int i = 0; i < n; i++){
      for(int j = 0; j < n; j++){
        cin>>mp[i][j];
      }
    }
    dfs(0,0);
    cout << sum << endl;
  }
  return 0;
}

B-Dungeon Master

题意就是给你一个三维的迷宫，从S走到E，判断能否逃脱若能逃离则输出最短时间。

裸BFS/DFS，只是多了两个方向，向上走和向下走，我用的是BFS，代码如下：

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;

int r,c,h;
char mp[35][35][35];
bool vis[35][35][35];
int sz,sx,sy,ez,ex,ey;

int fx[6][3] = {{1,0,0},{-1,0,0},{0,1,0},{0,-1,0},{0,0,-1},{0,0,1}};

struct node{
    int z,x,y,t;
};

bool check(int x,int y,int z){
    if(mp[z][x][y] == '#' || vis[z][x][y] || z < 0 || z >= h || x < 0 || x >= r || y < 0 || y >= c){
        return false;
    }
    vis[z][x][y] = 1;
    return true;
}

int bfs(){
    memset(vis, false, sizeof vis);
    queue<node> q;
    q.push(node{sz,sx,sy,0});
    vis[sz][sx][sy] = 1;
    while(!q.empty()){
        node now = q.front();
        q.pop();
        //cout << now.z << " " << now.x << " " << now.y << endl;
        if(now.z == ez && now.x == ex && now.y == ey){
            return now.t;
        }
        for(int i = 0; i < 6; i++){
            int nx = now.x + fx[i][0];
            int ny = now.y + fx[i][1];
            int nz = now.z + fx[i][2];
            if(check(nx,ny,nz)){
                q.push(node{nz,nx,ny,now.t+1});
            }
        }
    }
    return -1;
}


int main(){
    ios_base::sync_with_stdio(0);
    while(cin >> h >> r >> c && r ){
        for(int k = 0; k < h; k++){
            for(int i = 0; i < r; i++){
                for(int j = 0; j < c; j++){
                    cin>>mp[k][i][j];
                    if(mp[k][i][j] == 'S'){
                        sz = k,sx = i,sy = j;
                    }
                    else if(mp[k][i][j] == 'E'){
                        ez = k,ex = i,ey = j;
                    }
                }
            }
        }
        int ret = bfs();
        if(ret == -1)
            cout << "Trapped!" << endl;
        else
            cout << "Escaped in " << ret << " minute(s)." << endl;

    }
    return 0;
}

C-Catch That Cow

题意就是你现在在n位置处，牛在k位置处，你有下面三种走路方式，每次花费一分钟，牛不会动，问抓到牛的最小时间。

• 走到x+1位置处
• 走到x-1位置处
• 走到x*2位置处

BFS模拟即可，注意判断走到x*2时候，应该先判断x*2是否越界再判断vis[x*2]是否走过，可以用短路运算符&&实现，否则会造成RE，当然你也可以开成两倍的 数组空间来避免这种错误，但我还是推荐使用前者方式。

代码如下：

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;

int n,k;
bool vis[100005];

struct node{
    int s,t;
};

int bfs(){
    memset(vis,0,sizeof vis);
    queue<node> q;
    q.push(node{n,0});
    vis[n] = 1;
    while(!q.empty()){
        node now = q.front();
        q.pop();
        if(now.s == k)
            return now.t;
        if(now.s-1 >= 0 && !vis[now.s-1]){
            vis[now.s-1] = 1;
            q.push(node{now.s-1,now.t+1});
        }
        if(now.s+1 <= 100000 && !vis[now.s+1]){
            vis[now.s+1] = 1;
            q.push(node{now.s+1,now.t+1});
        }
        if(now.s*2 <= 100000 && !vis[now.s*2]){
            vis[now.s*2] = 1;
            q.push(node{now.s*2,now.t+1});
        }
    }
    return 0;
}

int main(){
    ios_base::sync_with_stdio(0);
    while(cin>>n>>k){
        cout << bfs() << endl;
    }
    return 0;
}

D-Fliptile

 玩过关灯游戏理解这个题就很简单，n*m的矩阵，0代表灯关，1代表灯开，然后可以反转某个灯的状态，但是这个灯周围四个方向的灯也会反转，然后问如何吧所有灯全关掉，若是不可能则输出IMPOSSIBLE，若是有多种情况请输出字典序最小的那个操作矩阵。

思路就是枚举，如何枚举，首先我们可以枚举第一层的每种操作可能，若是上一层有灯没关，这层的相应位置则必须反转，这样只要判断最下面一层的灯是否全关了即可。

那么我们需要对第一层枚举多少种状态呢？答案是2^m种，为什么呢，因为每层有m个灯，每种灯两个状态，所以就是2^m种操作方式，每种操作方式也就刚好对应了0——2^m-1中数的二进制，

例如对于样例，需要枚举0——15

0 = 0000

1 = 0001

……

15 = 1111

二进制刚好就是第一层的操作方式，然后我们从第二层开始，判断上一层是否还有状态为灯开的灯，有则操作当前位置，再判断最后一层是否全为灯关。

至于字典序处理，我们只需要数操作矩阵1的个数，找最小值即可，你可能会问相等的情况呢，因为我们是按0->2^m-1，所以若是前面的1个数和后面1个数相等，字典序一定是前面的更小，所以无需考虑。

代码如下：

#include <iostream>
#include <cstring>
#include <queue>
#include <vector>
#include <string>
#include <iomanip>
#include <cmath>
#include <climits>
using namespace std;

int n,m;
int mp[20][20],fp[20][20],vis[20][20];
int fx[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};

void change(int i,int j){
    fp[i][j] ^= 1;
    for(int k = 0; k < 4; k++){
        int ni = i + fx[k][0];
        int nj = j + fx[k][1];
        if(ni >= 0 && nj >= 0 && ni < n && nj < m){
            fp[ni][nj] ^= 1;
        }
    }
}

int dfs(int k){
    memcpy(fp, mp, sizeof fp);
    memset(vis, 0, sizeof vis);
    int tot = m-1,res = 0;
    while(k || tot>=0){
        int t = k%2;
        vis[0][tot] = t;
        res+=t;
        if(t == 1)
            change(0,tot);
        tot--;
        k /= 2;
    }
    //cout  << setw(3) << setfill('0') << *fp[0] << endl;
    for(int i = 1; i < n; i++){
        for(int j = 0; j < m; j++){
            if(fp[i-1][j] == 1){
                vis[i][j] = 1;
                res++;
                change(i,j);
            }
        }
    }
    for(int j = 0; j < m; j++){
        if(fp[n-1][j] == 1)
            return 15*15*2;
    }
    return res;
}

int main(){
    ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
    while(cin>>n>>m){
        int ans[20][20];
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                cin>>mp[i][j];
            }
        }
        int num = pow(2,m),minn = INT_MAX;
        for(int i = 0; i < num; i++){
            int ret = dfs(i);
            if(ret < minn){
                memcpy(ans, vis, sizeof vis);
                minn = ret;
            }
        }
        if(minn == 15*15*2)
            cout << "IMPOSSIBLE" << endl;
        else{
            for(int i = 0; i < n; i++){
                for(int j = 0; j < m; j++){
                    if(j == 0)
                        cout << ans[i][j];
                    else
                        cout << " " << ans[i][j];
                }
                cout << endl;
            }
        }
    }
    return 0;
}

E-Find The Multiple

题意就是给你一个数n，然后让你找到一个只由1和0构成的数x，使得x是n的倍数。

BFS遍历即可，所有数组都在long long范围内有解，其实甚至都不需要BFS，直接依此枚举即可。

代码如下：

#include <iostream>
#include <cstring>
#include <queue>
#include <string>
using namespace std;

int n;

long long bfs(){
    queue<long long> q;
    q.push(1);
    while(!q.empty()){
        long long x = q.front();
        q.pop();
        if(x % n == 0){
            return x;
        }
        q.push(x*10);
        q.push(x*10+1);
    }
    return 0;
}

int main(){
    while(cin>>n && n){
        cout << bfs() << endl;
    }
    return 0;
}

F-Prime Path

题意就是给你两个数p1，p2，两个数都是四位数且都是素数，现在要把p1变成p2，规则是每次只能变换某一位上的数，且保证变换过程中的数也是素数。求最小变换次数。

还是BFS撒，从最高位开始变换，枚举所有素数的变换情况直至找到p2位置，这题麻烦的是变一位的数。

代码如下：

#include <iostream>
#include <queue>
#include <algorithm>
#include <string>
#include <cstring>
#include <cmath>
using namespace std;

int a,b;
int sum = 0;
bool vis[10005];

struct node{
    int x,s;
};

int change(int k,int i,int j){
    return k - (int(k/pow(10,3-i))%10)*pow(10,3-i) + j*pow(10,3-i);
}

bool isprime(int n){
    if(n==2 || n==3)
        return true;
    if(n%6 != 1 && n%6 != 5)
        return false;
    float n_sqrt = floor(sqrt((float)n));
    for(int i = 5; i <= n_sqrt; i += 6)
        if(n%(i) == 0 | n%(i+2) == 0)
            return false;
    return true;
}

int bfs(int k){
    vis[k] = 1;
    queue<node> q;
    q.push(node{k,0});
    while(!q.empty()){
        node now = q.front();
        //cout << now.x << endl;
        q.pop();
        if(now.x == b)
            return now.s;
        for(int i = 0; i < 4; i++){
            for(int j = 9; j >= 0; j--){
                if(i == 0 && j == 0) break;
                int t = change(now.x,i,j);
                if(isprime(t) && !vis[t]){
                    vis[t] = 1;
                    q.push(node{t,now.s+1});
                }
            }
        }
    }
    return 0;
}

int main(){
    int t;
    cin>>t;
    while(t--){
        memset(vis, 0, sizeof vis);
        cin>>a>>b;
        sum = bfs(a);
        cout << sum << endl;
    }
    return 0;
}

G-Shuffle'm Up

给你两个字符串长度都为n的字符串s1、s2，然后可以结合成题目图中那种形状，s2和s1交叉且s2的最下面一块在结合后的形状中还是最下面一块，s1又变成结合后的串的前n个字符，s2变成后n个字符，判断能否得到想要的字符串并询问最小变换次数。

主要考字符串处理，代码如下：

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

string s1,s2,es;
int n;
map<string,int> vis;

string fun(string a,string b){
    string s = "";
    for(int i = 0; i < n; i++){
        s += b[i];
        s += a[i];
    }
    return s;
}

int bfs(){
    int tot = 0;
    while(1){
        tot ++;
        string ss = fun(s1,s2);
        //cout << ss << endl;
        if(ss == es)
            return tot;
        if(!vis[ss])
            vis[ss] = 1;
        else
            break;
        s1 = ss.substr(0,n);
        s2 = ss.substr(n,n);
    }
    return -1;
}

int main(){
    int t;
    cin>>t;
    for(int tt = 1; tt <= t; tt++){
        cin>>n>>s1>>s2>>es;
        cout  << tt << ' ' << bfs() << endl;
    }
    return 0;
}

H-Pots

题意：有两个壶，容量分别为A，B，现在想要C（C ≤ max(a,b)）容量的水，然后可以相互倒水（只能倒到另一壶满或者本壶倒完为止），倒空本壶，装满本壶。问操作次数（SPJ，不需要最小操作 次数）并且应该如何操作。

因为有SPJ存在，所以直接BFS就行了，主要麻烦的是如何存储每次的操作。我是用一个vector<pair<char,int>>来实现，这样会消耗很大的空间，但题目空间很充裕，所以这个做法没有问题。

代码如下：

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

int a,b,c;
bool vis[105][105];

struct node{
    int a,b;
    vector< pair<char,int> > v;
};

void print(node n){
    cout << n.v.size() << endl;
    for(vector< pair<char,int> >::iterator it = n.v.begin(); it != n.v.end(); it++){
        if(it->first == 'f')
            cout << "FILL(" << it->second << ")" << endl;
        else if(it->first == 'd')
            cout << "DROP(" << it->second << ")" << endl;
        else if(it->first == 'p')
            cout << "POUR(" << it->second << ',' << (it->second == 1?2:1) << ")" << endl;
    }
    return ;
}

void bfs(){
    memset(vis, 0, sizeof vis);
    queue<node> q;
    q.push(node{0,0});
    vis[a][b] = 1;
    while(!q.empty()){
        node now = q.front(),nt;
        //cout << now.a << ' ' << now.b << endl;
        q.pop();
        if(now.a == c || now.b == c){
            print(now);
            return ;
        }
        if(now.a != 0 && !vis[0][now.b]){
            vis[0][now.b] = 1;
            nt = now;
            nt.a = 0;
            nt.v.push_back(make_pair('d',1));
            q.push(nt);
        }
        if(now.b != 0 && !vis[0][now.a]){
            vis[now.a][0] = 1;
            nt = now;
            nt.b = 0;
            nt.v.push_back(make_pair('d',2));
            q.push(nt);
        }
        if(now.a != a && !vis[a][now.b]){
            vis[a][now.b] = 1;
            nt = now;
            nt.a = a;
            nt.v.push_back(make_pair('f',1));
            q.push(nt);
        }
        if(now.b != b && !vis[b][now.a]){
            vis[now.a][b] = 1;
            nt = now;
            nt.b = b;
            nt.v.push_back(make_pair('f',2));
            q.push(nt);
        }
        if(now.a > 0 && now.b != b){
            int tb = now.b+now.a >= b?b:now.b+now.a;
            int ta = b-now.b >= now.a?0:now.a-b+now.b;
            if(!vis[ta][tb]){
                vis[ta][tb] = 1;
                nt = now;
                nt.a = ta;
                nt.b = tb;
                nt.v.push_back(make_pair('p',1));
                q.push(nt);
            }
        }
        if(now.a != a && now.b > 0){
            int ta = now.a+now.b >= a?a:now.a+now.b;
            int tb = a-now.a >= now.b?0:now.b-a+now.a;
            if(!vis[ta][tb]){
                vis[ta][tb] = 1;
                nt = now;
                nt.a = ta;
                nt.b = tb;
                nt.v.push_back(make_pair('p',2));
                q.push(nt);
            }
        }
    }
    cout << "impossible" << endl;
    return ;
}

int main(){
    while(cin>>a>>b>>c){
        bfs();
    }
    return 0;
}

I-Fire!

题意就是人在J位置处，火在F位置处，不一定只有一堆火，火每分钟会向四周蔓延，人每分钟可以走一格，问能否逃出以及最小逃跑时间。

做了一遍再对比了一下以前的代码，发现区别还是很大的，以前是人每走一格就去BFS使得火蔓延一次，现在的做法是BFS人到达每个出口的时间，再BFS火到达每个出口的时间，再判断大小也就是判断人能否在火之前到达出口。

两份代码如下：

BEFORE（乱七八糟的宏定义比较多= =）：

#include <iostream>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <sstream>
#include <iomanip>
#include <map>
#include <stack>
#include <deque>
#include <queue>
#include <vector>
#include <set>
#include <list>
#include <cstring>
#include <cctype>
#include <algorithm>
#include <iterator>
#include <cmath>
#include <bitset>
#include <ctime>
#include <fstream>
#include <limits.h>
#include <numeric>

using namespace std;

#define F first
#define S second
#define mian main
#define ture true

#define MAXN 1000000+5
#define MOD 1000000007
#define PI (acos(-1.0))
#define EPS 1e-6
#define MMT(s) memset(s, 0, sizeof s)
typedef unsigned long long ull;
typedef long long ll;
typedef double db;
typedef long double ldb;
typedef stringstream sstm;
const int INF = 0x3f3f3f3f;

int n,m,t,jx,jy;
char mp[1005][1005];
int vis[1005][1005];
int fx[4][2] = {1,0,-1,0,0,-1,0,1};
vector< pair<int,int> >q;

void init(){
    MMT(mp);
    fill(vis[0],vis[0]+1005*1005,0);
    q.clear();
}

bool check(int x,int y){
    if(x < 0 || x >= n || y < 0 || y >= m || mp[x][y] == '#' || vis[x][y])
        return false;
    return true;
}

int bfs(){
    queue< pair<int,int> >p;
    queue< pair<int,int> >pf;
    p.push(make_pair(jx,jy));
    int step = 0;
    for(int i = 0, len = q.size(); i < len; i++){
        vis[q[i].F][q[i].S] = 1;
        pf.push(q[i]);
    }
    vis[jx][jy] = 1;
    while(!p.empty()){
        pair<int,int>nx = p.front();

        if(nx.F == 0 || nx.F == n-1 || nx.S == 0 || nx.S == m-1)
            return vis[nx.F][nx.S];

        if(vis[nx.F][nx.S] > step)
            step++;
        if(vis[nx.F][nx.S] == step){
            while(!pf.empty()){
                pair<int,int>nf = pf.front();
                if(vis[nf.F][nf.S] > step)
                    break;
                pf.pop();
                for(int i = 0; i < 4; i++){
                    int nxx = nf.F + fx[i][0];
                    int nxy = nf.S + fx[i][1];
                    if(check(nxx,nxy)){
                        vis[nxx][nxy] = vis[nf.F][nf.S] + 1;
                        pf.push(make_pair(nxx,nxy));
                    }
                }
            }
        }
        p.pop();
        for(int i = 0; i < 4; i++){
            int nxx = nx.F + fx[i][0];
            int nxy = nx.S + fx[i][1];
            if(check(nxx,nxy)){
                vis[nxx][nxy] = vis[nx.F][nx.S] + 1;
                p.push(make_pair(nxx,nxy));
            }
        }
    }
    return -1;
}

int main(){
    ios_base::sync_with_stdio(false);
    cout.tie(0);
    cin.tie(0);
    cin>>t;
    while(t--){
        init();
        cin>>n>>m;
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                cin>>mp[i][j];
                if(mp[i][j] == 'J'){
                    jx = i, jy = j;
                }
                if(mp[i][j] == 'F'){
                    q.push_back(make_pair(i,j));
                }
            }
        }
        int ret = bfs();
        if(ret > 0)
            cout << ret << endl;
        else
            cout << "IMPOSSIBLE" << endl;

    }
    return 0;
}

NOW：

#include <iostream>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <map>
#include <vector>
#include <climits>
#include <queue>
using namespace std;

int n,m;
char mp[1005][1005];
int dis[1005][1005];
int fdis[1005][1005];
bool vis[1005][1005];
int px,py;
int fx[4][2] = {{1,0},{-1,0},{0,-1},{0,1}};
struct node{
    int x,y;
};

queue<node> q[2];

bool pass1(int x,int y){
    if(x < 0 || y < 0 || x >= n || y >= m || mp[x][y] != '.' || dis[x][y])
        return false;
    return true;
}

bool pass2(int x,int y){
    if(x < 0 || y < 0 || x >= n || y >= m || mp[x][y] == '#' || fdis[x][y])
        return false;
    return true;
}

void bfs(){
    while(!q[0].empty()){
        node now = q[0].front();
        q[0].pop();
        for(int i = 0; i < 4; i++){
            int nx = now.x + fx[i][0];
            int ny = now.y + fx[i][1];
            if(pass1(nx,ny)){
                q[0].push(node{nx,ny});
                dis[nx][ny] = dis[now.x][now.y]+1;
            }
        }
    }

    while(!q[1].empty()){
        node now = q[1].front();
        q[1].pop();
        for(int i = 0; i < 4; i++){
            int nx = now.x + fx[i][0];
            int ny = now.y + fx[i][1];
            if(pass2(nx,ny)){
                q[1].push(node{nx,ny});
                fdis[nx][ny] = fdis[now.x][now.y]+1;
            }
        }
    }
}

int check(){
    int ans = INT_MAX;
    for(int j = 0; j < m; j++){
        if(dis[0][j] > 0 && (fdis[0][j] > dis[0][j] || fdis[0][j] == 0))
            ans = min(ans,dis[0][j]);
        if(dis[n-1][j] > 0 && (fdis[n-1][j] > dis[n-1][j] || fdis[n-1][j] == 0))
            ans = min(ans,dis[n-1][j]);
    }
    for(int j = 0; j < n; j++){
        if(dis[j][0] > 0 && (fdis[j][0] > dis[j][0] || fdis[j][0] == 0))
            ans = min(ans,dis[j][0]);
        if(dis[j][m-1] > 0 && (fdis[j][m-1] > dis[j][m-1] || fdis[j][m-1] == 0))
            ans = min(ans,dis[j][m-1]);
    }
    if(ans == INT_MAX)
        return -1;
    else
        return ans;
}

void init(){
    while(!q[0].empty()) q[0].pop();
    while(!q[1].empty()) q[1].pop();
    memset(dis, 0, sizeof dis);
    memset(fdis, 0, sizeof fdis);
    return ;
}

int main(){
    int t;
    cin>>t;
    while(t--){
        init();
        cin>>n>>m;
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                cin>>mp[i][j];
                if(mp[i][j] == 'J')
                    q[0].push(node{i,j}),dis[i][j] = 1;
                if(mp[i][j] == 'F')
                    q[1].push(node{i,j}),fdis[i][j] = 1;
            }
        }
        bfs();
        int ret = check();
        if(ret == -1)
            cout << "IMPOSSIBLE" << endl;
        else
            cout << ret << endl;
    }
    return 0;
}

J-迷宫问题

这个我以前写过一篇博客https://www.cnblogs.com/xenny/p/9473555.html

然后再贴一下现在的代码吧:

#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>
#include <stack>
#include <vector>
using namespace std;

char mp[5][5];
bool vis[5][5];
int fx[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};
vector< pair<int,int> > ans(1,make_pair(0,0));
bool pass(int x,int y){
    if(x < 0 || y < 0 || x >= 5 || y >= 5 || vis[x][y] || mp[x][y] == '1')
        return false;
    return true;
}

void print(vector< pair<int,int> > v){
    for(vector< pair<int,int> >::iterator it = v.begin(); it != v.end(); it++){
        cout << '(' << it->first << ", " << it->second << ')' << endl;
    }
}

void dfs(int x,int y,vector< pair<int,int> > v){
    if(x == 4 && y == 4){
        if(ans.size() == 1 || v.size() < ans.size())
            ans = v;
        return ;
    }
    for(int i = 0; i < 4; i++){
        int nx = x + fx[i][0];
        int ny = y + fx[i][1];
        if(pass(nx,ny)){
            vis[nx][ny] = 1;
            v.push_back(make_pair(nx,ny));
            dfs(nx,ny,v);
            v.erase(--v.end());
            vis[nx][ny] = 0;
        }
    }
}

int main(){
    memset(vis, 0, sizeof vis);
    vis[0][0] = 1;
    for(int i = 0; i < 5; i++){
        for(int j = 0; j < 5; j++){
            cin>>mp[i][j];
        }
    }
    dfs(0,0,ans);
    print(ans);
    return 0;
}

感觉现在写的比以前的还是清晰明了了很多= =

K-Oil Deposits

很多人的搜索入门题都是这个题目吧，很经典，就是问有几块油田，一块油田的8个方向内有油田就看为连在一起。

把遍历过的油田记为*号，都可以把vis数组都省略掉。

代码如下：

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

int n,m;
char mp[105][105];
int fx[8][2] = {{1,0},{-1,0},{0,1},{0,-1},{1,1},{1,-1},{-1,1},{-1,-1}};

bool pass(int x,int y){
    if(x < 0 || y < 0 || x >= n || y >= m || mp[x][y] == '*')
        return false;
    return true;
}

void dfs(int x,int y){
    for(int i = 0; i < 8; i++){
        int nx = x + fx[i][0];
        int ny = y + fx[i][1];
        if(pass(nx,ny)){
            mp[nx][ny] = '*';
            dfs(nx,ny);
        }
    }
}

int main(){
    while(cin>>n>>m && n){
        int sum = 0;
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                cin>>mp[i][j];
            }
        }
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if(mp[i][j] == '@'){
                    sum++;
                    dfs(i,j);
                }
            }
        }
        cout << sum << endl;
    }
    return 0;
}

L-非常可乐

和Pots那个题类似，也是枚举每种状态，但是其实在搜索还可以加上剪枝，例如s为奇数直接输出NO，然后本题还有数学做法，可以自行百度，我不再给出。

代码如下：

#include <iostream>
#include <cstring>
#include <queue>
#include <algorithm>
using namespace std;

int s,n,m;
bool vis[105][105][105];
struct node{
    int s,n,m,t;
};

bool check(node n){
    if((n.s > 0 && n.n > 0 && n.s == n.n && n.s + n.n == s) || 
        (n.s > 0 && n.m > 0 && n.s == n.m && n.s + n.m == s) || 
        (n.m > 0 && n.n > 0 && n.m == n.n && n.m + n.n == s))
        return true;
    return false;
}

int bfs(){
    memset(vis, 0, sizeof vis);
    queue<node> q;
    q.push(node{s,0,0,0});
    vis[s][0][0] = 0;
    while(!q.empty()){
        node now = q.front();
        q.pop();
        if(check(now)){
            return now.t;
        }
        node nt = now;
        nt.s = now.s - (n-now.n) <= 0 ? 0 : now.s - (n-now.n);
        nt.n = now.n + now.s >= n ? n : now.n + now.s;
        if(!vis[nt.s][nt.n][nt.m]){
            vis[nt.s][nt.n][nt.m] = 1;
            nt.t = now.t+1;
            q.push(nt);
        }
        nt = now;
        nt.s = now.s - (m-now.m) <= 0 ? 0 : now.s - (m-now.m);
        nt.m = now.m + now.s >= m ? m : now.m + now.s;
        if(!vis[nt.s][nt.n][nt.m]){
            vis[nt.s][nt.n][nt.m] = 1;
            nt.t = now.t+1;
            q.push(nt);
        }
        nt = now;
        nt.n = now.n - (s-now.s) <= 0 ? 0 : now.n - (s-now.s);
        nt.s = now.n + now.s >= s ? s : now.n + now.s;
        if(!vis[nt.s][nt.n][nt.m]){
            vis[nt.s][nt.n][nt.m] = 1;
            nt.t = now.t+1;
            q.push(nt);
        }
        nt = now;
        nt.m = now.m - (s-now.s) <= 0 ? 0 : now.m - (s-now.s);
        nt.s = now.m + now.s >= s ? s : now.m + now.s;
        if(!vis[nt.s][nt.n][nt.m]){
            vis[nt.s][nt.n][nt.m] = 1;
            nt.t = now.t+1;
            q.push(nt);
        }
        nt = now;
        nt.n = now.n - (m-now.m) <= 0 ? 0 : now.n - (m-now.m);
        nt.m = now.m + now.n >= m ? m : now.m + now.n;
        if(!vis[nt.s][nt.n][nt.m]){
            vis[nt.s][nt.n][nt.m] = 1;
            nt.t = now.t+1;
            q.push(nt);
        }
        nt = now;
        nt.m = now.m - (n-now.n) <= 0 ? 0 : now.m - (n-now.n);
        nt.n = now.n + now.m >= n ? n : now.m + now.n;
        if(!vis[nt.s][nt.n][nt.m]){
            vis[nt.s][nt.n][nt.m] = 1;
            nt.t = now.t+1;
            q.push(nt);
        }
    }
    return -1;
}

int main(){
    while(cin>>s>>n>>m && s){
        int ret = bfs();
        if(ret == -1)
            cout << "NO" << endl;
        else
            cout << ret << endl;
    }
    return 0;
}

M-Find a way

这个题我也写过博客，还是我的第一篇题解博客。

地址链接：https://www.cnblogs.com/xenny/p/9361825.html

然后这是现在写的代码：

#include <iostream>
#include <queue>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;

char mp[205][205];
int vis[205][205][2];
int fx[4][2] = {0,1,0,-1,-1,0,1,0};
int n,m,yx,yy,mx,my;
struct node{
    int x,y;
};

const int inf = 123456789;

bool check(int x,int y,int z){
    if(vis[x][y][z] != inf || x < 0 || x >= n || y < 0 || y >= m || mp[x][y] == '#')
        return false;
    return true;
}

void bfs(int x,int y,int z){
    vis[x][y][z] = 0;
    queue<node>q;
    q.push(node{x,y});
    while(!q.empty()){
        node now = q.front();
        q.pop();
        for(int i = 0; i < 4; i++){
            int nx = now.x + fx[i][0];
            int ny = now.y + fx[i][1];
            if(check(nx,ny,z)){
                vis[nx][ny][z] = vis[now.x][now.y][z] + 1;
                q.push(node{nx,ny});
            }
        }
    }
}

int main(){
    while(cin>>n>>m){
        fill(vis[0][0], vis[0][0]+205*205*2, inf);
        vector< pair<int,int> > v;
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                cin>>mp[i][j];
                if(mp[i][j] == 'Y')
                    yx = i,yy = j;
                if(mp[i][j] == 'M')
                    mx = i,my = j;
                if(mp[i][j] == '@')
                    v.push_back(make_pair(i,j));
            }
        }
        bfs(yx,yy,0);
        bfs(mx,my,1);
        int ans = INT_MAX;
        for(vector< pair<int,int> >::iterator it = v.begin(); it != v.end(); it++)
            ans = min(ans,vis[it->first][it->second][0] + vis[it->first][it->second][1]);
        cout << ans*11 << endl;
    }

    return 0;
}

---

看了以前的博客和现在的，区别还是挺大的，各位也可以尝试用多种方法解决一道题。关于kuangbin专题一的所有题目到此就完了，又不懂的地方可以在评论区留言，同时欢迎指正上面代码的错误。