合肥工业大学oj 1009 纷争

//因为我们不知道访问这四个B的先后顺序，所以我们采取先使用广度优先搜索求出B和B之间的距离以及出发点和每个B之间的距离，
//再根据这些数据建立起一个节点为五，两两之间有边的无向图。
//再对这张图进行深度优先搜索即可。
#include<iostream>
#include<queue>
#include<string.h>
#include<algorithm>
#define INF 99999999
using namespace std;

class Unite{
public:
  int x;
  int y;
  int value;
  Unite(int x, int y, int value){
    this->x = x;
    this->y = y;
    this->value = value;
  }
};
int m, n, MIN;
char map[20][20];//用于存储原始的地图
int matrix[5][5];//用于存储之后建立的有向图
bool isvisited[20][20];//用于广度优先搜索时辅助
bool isvisited_1[5];//用于深度优先搜索时辅助
int pos[4][2];//用于存储4个B的坐标
int BFS(int, int, int, int);
void DFS(int, int, int);

int main(){
  while(cin >> m >> n){
    int z = 0;
    for(int i = 0; i < m; i++){
      for(int j = 0; j < n; j++){
        cin >> map[i][j];//输入地图
        if(map[i][j] == 'B'){//如果是B，存储在pos数组里面
          pos[z][0] = i;
          pos[z][1] = j;
          z++;
        }
      }
    }
    //初始化无向图
    //因为是带权无向图， 所以相同的点之间距离为零，不相同的点默认为INF（一个比较大的数字即可）
    for(int i = 0; i < 5; i++){
      for(int j = 0; j < 5; j++){
        if(i == j) matrix[i][j] = 0;
        else matrix[i][j] = INF;
      }
    }
    for(int i = 0; i < 4; i++){
      for(int j = i + 1; j < 4; j++){
        memset(isvisited, false, sizeof(isvisited));//在广度优先搜索之前先初始化isvisited
        int dir = BFS(pos[i][0], pos[i][1], pos[j][0], pos[j][1]);//搜索B和B之间的距离
        matrix[i + 1][j + 1] = dir;//无向图
        matrix[j + 1][i + 1] = dir;
      }
    }
    for(int i = 0; i < 4; i++){
      memset(isvisited, false, sizeof(isvisited));
      int dir = BFS(0, 0, pos[i][0], pos[i][1]);//搜索起始点和各个B之间的距离
        matrix[0][i + 1] = dir;
    }
    memset(isvisited_1, false, sizeof(isvisited_1));//初始化isvisited_1
    MIN = INF;
    isvisited_1[0] = true;//出发点设置为已经访问过了
    DFS(0, 0, 0);//从出发点开始深度优先搜索
    cout << MIN << endl;
  }

  return 0;
}

int BFS(int x, int y, int x_, int y_){//广度优先搜索
  int nxt[4][2]{{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
  queue<Unite*> queue;
  queue.push(new Unite(x, y, 0));
  int MIN = INF;
  isvisited[x][y] = true;
  while(!queue.empty()){
    Unite* unite = queue.front();
    queue.pop();
    if(unite->x == x_ && unite->y == y_) MIN = min(MIN, unite->value);
    for(int i = 0; i < 4; i++){//将周围四个点放进数组
      int ix = unite->x + nxt[i][0];
      int iy = unite->y + nxt[i][1];
      if((ix >= 0 && ix < m) && (iy >= 0 && iy < n) && !isvisited[ix][iy] && map[ix][iy] != '*'){
        queue.push(new Unite(ix, iy, unite->value + 1));
        isvisited[ix][iy] = true;
      }
    }
  }
  return MIN;
}

void DFS(int cur, int step, int count){//深度优先搜索
  if(count == 4){//并未使用最短路径相关的算法，而是采用这种方式进行判断是否遍历了所有B
    MIN = min(MIN, step);
    return;
  }
  for(unsigned int i = 0; i < 5; i++){
    if(matrix[cur][i] != 0 && matrix[cur][i] != INF && !isvisited_1[i]){
      isvisited_1[i] = true;
      DFS(i, step + matrix[cur][i], count + 1);
      isvisited_1[i] = false;
    }
  }
}

//presented by 大吉大利，今晚AC