leetcode1034. 边界着色 bfs+队列

给你一个大小为 m x n 的整数矩阵 grid ，表示一个网格。另给你三个整数 row、col 和 color 。网格中的每个值表示该位置处的网格块的颜色。

两个网格块属于同一 连通分量 需满足下述全部条件：

两个网格块颜色相同
在上、下、左、右任意一个方向上相邻
连通分量的边界 是指连通分量中满足下述条件之一的所有网格块：

在上、下、左、右四个方向上与不属于同一连通分量的网格块相邻
在网格的边界上（第一行/列或最后一行/列）
请你使用指定颜色 color 为所有包含网格块 grid[row][col] 的 连通分量的边界 进行着色，并返回最终的网格 grid 。

示例 1：

输入：grid = [[1,1],[1,2]], row = 0, col = 0, color = 3

输出：[[3,3],[3,2]]

示例 2：

输入：grid = [[1,2,2],[2,3,2]], row = 0, col = 1, color = 3

输出：[[1,3,3],[2,3,3]]

示例 3：

输入：grid = [[1,1,1],[1,1,1],[1,1,1]], row = 1, col = 1, color = 2

输出：[[2,2,2],[2,1,2],[2,2,2]]

提示：

m == grid.length

n == grid[i].length

1 <= m, n <= 50

1 <= gridi, color <= 1000

0 <= row < m

0 <= col < n

广度优先搜索

本题我是用的bfs来解答的，bfs（广度优先搜索）是常用的一个暴力搜索法之一，通常我们用队列来实现它，什么是广度优先搜索呢，顾名思义是广泛的搜索。

本题这一道矩阵的题目，用bfs最好不过了，当然了用dfs也行。一般情况下用这个bfs的代码量稍微比dfs的代码多一点。

一.准备的东西

1.四个移动方向

首先我做用到bfs和dfs上的题目，我都把四个移动的方向先写好。下面的这个我是学的《算法竞赛》这本书上的。这样的话代码打起来比较的清晰。

int dir[4][2] = {//四个方向
		{-1,0},
		{0,-1},
		{1,0},
		 {0,1}
	};

2.一个记录是否记录过的数组和队列的结构

bool room[55][55];

struct node {
		int x, y;
	};

当然队列，我们也可以直接用pair。queue<pair<int,int>>

二.bfs的过程了

bfs就是通过开始的一个位置，来把四面的数据，根据条件放在队列里面，这里就是跟据给出的初始位置的那个值来判断，如果有相邻的值一样，那么入队。并且在room里面设为true。

vector<vector<int>> colorBorder(vector<vector<int>>& grid, int row, int col, int color) {
		int length = grid.size();
		int width = grid[0].size();
		queue<node>q;
		node start, next;//start为起始位置，next为后继位置
		start.x = row;
		start.y = col;
		int num = grid[row][col];
		q.push(start);
		memset(room, false, sizeof room);//初始的room全部设为false
		room[row][col] = true;
		while (!q.empty()) {              //判断是否是要比较的值，是就记为true，不是就还是false
			start = q.front();
			q.pop();
			for (int i = 0; i < 4; i++) {//四个方向上搜索
				next.x = start.x + dir[i][0];
				next.y = start.y + dir[i][1];
				if (next.x < length && next.x >= 0 && next.y < width && next.y >= 0 && grid[next.x][next.y] == num && !room[next.x][next.y]) {
					q.push(next);
					room[next.x][next.y] = true;
				}
			}
		}
	}
};

三.判断，改颜色

判断就是看是否给定初始位置它周围的颜色都是与他一样，一样那么它的颜色就不变并且把room值设置为false，不一样就改成color的值。

for (int i = 0; i < length; i++) {
			for (int j = 0; j < width; j++) {
				if (!room[i][j])continue;
				if (i == 0 || j == 0 || i == length - 1 || j == width - 1) continue;
				for (int m = 0; m < 4; m++) {
					int xx = i + dir[m][0];
					int yy = j + dir[m][1];
					if (grid[xx][yy] != num) break;//判断四周是否是值为起点数组的数值
					if (m == 3) room[i][j] = false;//注意：要写一开始的数组
				}
			}
		}

		for (int i = 0; i < length; i++) {//改颜色，循环一下如果是romm的值是true，相应的grid就变成color
			for (int j = 0; j < width; j++) {
				if (room[i][j])
					grid[i][j] = color;
			}
		}

总代码

class Solution {
public:
	bool room[55][55];
	int dir[4][2] = {//四个方向
		{-1,0},
		{0,-1},
		{1,0},
		 {0,1}
	};
	struct node {
		int x, y;
	};

vector<vector<int>> colorBorder(vector<vector<int>>& grid, int row, int col, int color) {
		int length = grid.size();
		int width = grid[0].size();
		queue<node>q;
		node start, next;
		start.x = row;
		start.y = col;
		int num = grid[row][col];
		q.push(start);
		memset(room, false, sizeof room);
		room[row][col] = true;
		while (!q.empty()) {              //判断是否是要比较的值，是就记为true，不是就还是false
			start = q.front();
			q.pop();
			for (int i = 0; i < 4; i++) {
				next.x = start.x + dir[i][0];
				next.y = start.y + dir[i][1];
				if (next.x < length && next.x >= 0 && next.y < width && next.y >= 0 && grid[next.x][next.y] == num && !room[next.x][next.y]) {
					q.push(next);
					room[next.x][next.y] = true;
				}
			}
		}
		for (int i = 0; i < length; i++) {
			for (int j = 0; j < width; j++) {
				if (!room[i][j])continue;
				if (i == 0 || j == 0 || i == length - 1 || j == width - 1) continue;
				for (int m = 0; m < 4; m++) {
					int xx = i + dir[m][0];
					int yy = j + dir[m][1];
					if (grid[xx][yy] != num) break;//判断四周是否是值为起点数组的数值
					if (m == 3) room[i][j] = false;
				}
			}
		}

		for (int i = 0; i < length; i++) {
			for (int j = 0; j < width; j++) {
				if (room[i][j])
					grid[i][j] = color;
			}
		}
		return grid;
	}
};

景sl