你现在手里有一份大小为 n x n 的 网格 grid,
上面的每个 单元格 都用 0 和 1 标记好了其中 0 代表海洋，1 代表陆地。
请你找出一个海洋单元格，这个海洋单元格到离它最近的陆地单元格的距离是最大的,
并返回该距离。如果网格上只有陆地或者海洋，请返回 -1。
我们这里说的距离是「曼哈顿距离」（ Manhattan Distance）：
(x0, y0) 和 (x1, y1) 这两个单元格之间的距离是 |x0 - x1| + |y0 - y1| 。
输入：grid = [[1,0,0],[0,0,0],[0,0,0]]。
输出：4。
大体步骤如下：
1.定义变量：
- 声明一个二维整数数组
grid表示网格，以及整数变量n和m表示网格的行数和列数； - 声明一个二维布尔数组
visited，用于记录每个单元格是否被访问过； - 声明一个二维整数数组
queue，用于存储队列中的每个元素； - 声明整数变量
l和r，分别表示队列的左右端点； - 声明整数变量
find，统计已经找到的海洋的数量； - 声明整数变量
seas，统计海洋的总数量； - 声明整数变量
distance，表示最深能找到的海洋层数，初始化为-1。
2.初始化变量：
- 将
l、r、find、seas和distance全部初始化为0或-1，将visited数组全部设为false； - 遍历整个网格，对于每个陆地单元格，将其标记为已访问，并将其加入队列中；对于每个海洋单元格，将
seas增加1。
3.进行BFS搜索：
- 当队列不为空时，取出队列中所有元素进行处理，直到找到所有的海洋单元格；
- 对于每个队列元素，将其四周的海洋单元格加入队列中，并标记为已访问；同时统计找到的海洋单元格数量，并将
distance加1。
4.返回结果：
- 如果没有找到任何海洋或者陆地，则返回-1；
- 否则，返回
distance。
时间复杂度：
- 初始化visited数组、queue数组和一些变量的时间复杂度是O(n^2)，其中n为网格边长；
- 遍历整个网格的时间复杂度也是O(n^2)；
- BFS搜索的时间复杂度最坏情况下是O(n^2)，因为最多需要遍历整个网格。
因此，总的时间复杂度是O(n^2)。
空间复杂度：
- visited数组的空间复杂度是O(n^2)；
- queue数组的空间复杂度是O(n^2)；
- 其他变量占用常数空间。
因此，总的空间复杂度是O(n^2)。
go语言完整代码如下：
package main
var queue [10000][2]int
var l int
var r int
var visited [100][100]bool
var find int
func maxDistance(grid [][]int) int {
// 清空变量
l = 0
r = 0
find = 0
n := len(grid)
m := len(grid[0])
// 清空visited
for i := 0; i < n; i++ {
for j := 0; j < m; j++ {
visited[i][j] = false
}
}
// 大体思路 :
// 1) 先把所有的陆地加入队列，并且统计一共有多少海洋
seas := 0
for i := 0; i < n; i++ {
for j := 0; j < m; j++ {
if grid[i][j] == 1 {
visited[i][j] = true
queue[r][0] = i
queue[r][1] = j
r++
} else {
seas++
}
}
}
// 2) 从陆地开始广播出去(bfs)，每一块陆地的上、下、左、右所能找到的海洋都是第一层海洋
// 3) 第一层海洋继续bfs，每一块海洋的上、下、左、右所能找到的海洋都是第二层海洋
// 4) 第二层海洋继续bfs，每一块海洋的上、下、左、右所能找到的海洋都是第三层海洋
// ...
// 也就是说，以陆地做起点，每一层bfs都只找海洋！
// 看看最深能找到多少层海洋
distance := -1 // 这个变量就是最深的海洋层数
for l < r && find < seas { // find < seas说明所有的海洋块没有找全，继续找！
size := r - l
for i := 0; i < size && find < seas; i++ {
row := queue[l][0]
col := queue[l][1]
add(row-1, col, n, m, grid)
add(row+1, col, n, m, grid)
add(row, col-1, n, m, grid)
add(row, col+1, n, m, grid)
l++
}
distance++
}
if find == 0 {
return -1
}
return distance + 1
}
func add(i int, j int, n int, m int, grid [][]int) {
if i >= 0 && i < n && j >= 0 && j < m && grid[i][j] == 0 && !visited[i][j] {
find++
visited[i][j] = true
queue[r][0] = i
queue[r][1] = j
r++
}
}
func main() {
grid := [][]int{{1, 0, 1}, {0, 0, 0}, {1, 0, 1}}
result := maxDistance(grid)
println(result)
grid = [][]int{{1, 0, 0}, {0, 0, 0}, {0, 0, 0}}
result = maxDistance(grid)
println(result)
}
rust语言完整代码如下：
static mut QUEUE: [[i32; 2]; 10000] = [[0; 2]; 10000];
static mut L: usize = 0;
static mut R: usize = 0;
static mut VISITED: [[bool; 100]; 100] = [[false; 100]; 100];
static mut FIND: i32 = 0;
fn main() {
let grid = vec![vec![1, 0, 1], vec![0, 0, 0], vec![1, 0, 1]];
unsafe {
let ans = max_distance(grid);
println!("ans = {}", ans);
}
let grid = vec![vec![1, 0, 0], vec![0, 0, 0], vec![0, 0, 0]];
unsafe {
let ans = max_distance(grid);
println!("ans = {}", ans);
}
}
unsafe fn max_distance(grid: Vec<Vec<i32>>) -> i32 {
// 清空变量
// 只要l = 0，r = 0，队列就算被清空了
L = 0;
R = 0;
FIND = 0;
let n = grid.len();
let m = grid[0].len();
// 清空visited
for i in 0..n {
for j in 0..m {
VISITED[i][j] = false;
}
}
// 初始化队列
let mut queue: [[i32; 2]; 10000] = [[0; 2]; 10000];
// 大体思路 :
// 1) 先把所有的陆地加入队列，并且统计一共有多少海洋
let mut seas = 0;
for i in 0..n {
for j in 0..m {
if grid[i][j] == 1 {
VISITED[i][j] = true;
queue[R][0] = i as i32;
queue[R][1] = j as i32;
R += 1;
} else {
seas += 1;
}
}
}
// 2) 从陆地开始广播出去(bfs)，每一块陆地的上、下、左、右所能找到的海洋都是第一层海洋
// 3) 第一层海洋继续bfs，每一块海洋的上、下、左、右所能找到的海洋都是第二层海洋
// 4) 第二层海洋继续bfs，每一块海洋的上、下、左、右所能找到的海洋都是第三层海洋
// ...
// 也就是说，以陆地做起点，每一层bfs都只找海洋！
// 看看最深能找到多少层海洋
let mut distance = 0; // 这个变量就是最深的海洋层数
while L < R && FIND < seas {
// find < seas说明所有的海洋块没有找全，继续找！
let size = R - L;
for i in 0..size {
if FIND >= seas {
break;
}
let row = queue[L][0];
let col = queue[L][1];
add(row - 1, col, n, m, grid.clone(), &mut queue);
add(row + 1, col, n, m, grid.clone(), &mut queue);
add(row, col - 1, n, m, grid.clone(), &mut queue);
add(row, col + 1, n, m, grid.clone(), &mut queue);
L += 1;
}
distance += 1;
}
if FIND == 0 {
return -1;
} else {
return distance;
}
}
unsafe fn add(
i: i32,
j: i32,
n: usize,
m: usize,
grid: Vec<Vec<i32>>,
queue: &mut [[i32; 2]; 10000],
) {
if i >= 0
&& i < n as i32
&& j >= 0
&& j < m as i32
&& grid[i as usize][j as usize] == 0
&& !VISITED[i as usize][j as usize]
{
FIND += 1;
VISITED[i as usize][j as usize] = true;
queue[R][0] = i;
queue[R][1] = j;
R += 1;
}
}
c语言完整代码如下：
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define MAX_SIZE 10000
int queue[MAX_SIZE][2];
int l;
int r;
bool visited[100][100];
int find;
void add(int i, int j, int n, int m, int** grid);
int maxDistance(int** grid, int gridSize, int* gridColSize) {
l = 0;
r = 0;
find = 0;
int n = gridSize;
int m = *gridColSize;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
visited[i][j] = false;
}
}
int seas = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (grid[i][j] == 1) {
visited[i][j] = true;
queue[r][0] = i;
queue[r++][1] = j;
}
else {
seas++;
}
}
}
int distance = 0;
while (l < r && find < seas) {
int size = r - l;
for (int i = 0; i < size && find < seas; i++, l++) {
int row = queue[l][0];
int col = queue[l][1];
add(row - 1, col, n, m, grid);
add(row + 1, col, n, m, grid);
add(row, col - 1, n, m, grid);
add(row, col + 1, n, m, grid);
}
distance++;
}
return find == 0 ? -1 : distance;
}
void add(int i, int j, int n, int m, int** grid) {
if (i >= 0 && i < n && j >= 0 && j < m && grid[i][j] == 0 && !visited[i][j]) {
find++;
visited[i][j] = true;
queue[r][0] = i;
queue[r++][1] = j;
}
}
int main() {
int gridSize = 3;
int gridColSize[3] = { 3, 3, 3 };
int** grid = (int**)malloc(gridSize * sizeof(int*));
for (int i = 0; i < gridSize; i++) {
grid[i] = (int*)malloc(gridColSize[i] * sizeof(int));
}
grid[0][0] = 1;
grid[0][1] = 0;
grid[0][2] = 1;
grid[1][0] = 0;
grid[1][1] = 0;
grid[1][2] = 0;
grid[2][0] = 1;
grid[2][1] = 0;
grid[2][2] = 1;
int result = maxDistance(grid, gridSize, gridColSize);
printf("%d\n", result);
grid[0][0] = 1;
grid[0][1] = 0;
grid[0][2] = 0;
grid[1][0] = 0;
grid[1][1] = 0;
grid[1][2] = 0;
grid[2][0] = 0;
grid[2][1] = 0;
grid[2][2] = 0;
result = maxDistance(grid, gridSize, gridColSize);
printf("%d\n", result);
for (int i = 0; i < gridSize; i++) {
free(grid[i]);
}
free(grid);
return 0;
}
c++语言完整代码如下：
#include <iostream>
#include <vector>
#include <cstring>
using namespace std;
int queue[10000][2];
int l;
int r;
bool visited[100][100];
int find0;
int maxDistance(vector<vector<int>>& grid) {
// 清空变量
// 只要l = 0，r = 0，队列就算被清空了
l = 0;
r = 0;
find0 = 0;
int n = grid.size();
int m = grid[0].size();
// 清空visited
memset(visited, false, sizeof(visited));
// 大体思路 :
// 1) 先把所有的陆地加入队列，并且统计一共有多少海洋
int seas = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (grid[i][j] == 1) {
visited[i][j] = true;
queue[r][0] = i;
queue[r++][1] = j;
}
else {
seas++;
}
}
}
// 2) 从陆地开始广播出去(bfs)，每一块陆地的上、下、左、右所能找到的海洋都是第一层海洋
// 3) 第一层海洋继续bfs，每一块海洋的上、下、左、右所能找到的海洋都是第二层海洋
// 4) 第二层海洋继续bfs，每一块海洋的上、下、左、右所能找到的海洋都是第三层海洋
// ...
// 也就是说，以陆地做起点，每一层bfs都只找海洋！
// 看看最深能找到多少层海洋
int distance = 0; // 这个变量就是最深的海洋层数
while (l < r && find0 < seas) { // find < seas说明所有的海洋块没有找全，继续找！
int size = r - l;
for (int i = 0; i < size && find0 < seas; i++, l++) {
int row = queue[l][0];
int col = queue[l][1];
if (row - 1 >= 0 && row - 1 < n && col >= 0 && col < m && grid[row - 1][col] == 0 && !visited[row - 1][col]) {
find0++;
visited[row - 1][col] = true;
queue[r][0] = row - 1;
queue[r++][1] = col;
}
if (row + 1 >= 0 && row + 1 < n && col >= 0 && col < m && grid[row + 1][col] == 0 && !visited[row + 1][col]) {
find0++;
visited[row + 1][col] = true;
queue[r][0] = row + 1;
queue[r++][1] = col;
}
if (row >= 0 && row < n && col - 1 >= 0 && col - 1 < m && grid[row][col - 1] == 0 && !visited[row][col - 1]) {
find0++;
visited[row][col - 1] = true;
queue[r][0] = row;
queue[r++][1] = col - 1;
}
if (row >= 0 && row < n && col + 1 >= 0 && col + 1 < m && grid[row][col + 1] == 0 && !visited[row][col + 1]) {
find0++;
visited[row][col + 1] = true;
queue[r][0] = row;
queue[r++][1] = col + 1;
}
}
distance++;
}
return find0 == 0 ? -1 : distance;
}
int main() {
vector<vector<int>> grid = { {1,0,1}, {0,0,0}, {1,0,1} };
cout << maxDistance(grid) << endl;
grid = { {1,0,0}, {0,0,0}, {0,0,0} };
cout << maxDistance(grid) << endl;
}
