2021-07-28:最短的桥。在给定的二维二进制数组 A 中,存在两座岛。(岛是由四面相连的 1 形成的一个最大组。)现在,我们可以将 0 变为 1,以使两座岛连接起来,变成一座岛。返回必须翻转的(

Posted 福大大架构师每日一题

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了2021-07-28:最短的桥。在给定的二维二进制数组 A 中,存在两座岛。(岛是由四面相连的 1 形成的一个最大组。)现在,我们可以将 0 变为 1,以使两座岛连接起来,变成一座岛。返回必须翻转的(相关的知识,希望对你有一定的参考价值。

2021-07-28:最短的桥。在给定的二维二进制数组 A 中,存在两座岛。(岛是由四面相连的 1 形成的一个最大组。)现在,我们可以将 0 变为 1,以使两座岛连接起来,变成一座岛。返回必须翻转的 0 的最小数目。(可以保证答案至少是 1 。)

福大大 答案2021-07-28:

宽度优先遍历。找到第一个岛,广播一次,增加一层,碰到第二个岛为止。层数就是需要的返回值。
时间复杂度:O(NM)。
空间复杂度:O(NM)。

代码用golang编写。代码如下:

package main

import (
    "fmt"
    "math"
)

func main() {
    m := [][]int{{0, 1, 0}, {0, 0, 0}, {0, 0, 1}}
    ret := shortestBridge(m)
    fmt.Println(ret)
}

func shortestBridge(m [][]int) int {
    N := len(m)
    M := len(m[0])
    all := N * M
    island := 0
    curs := make([]int, all)
    nexts := make([]int, all)
    records := make([][]int, 2)
    for i := 0; i < 2; i++ {
        records[i] = make([]int, all)
    }
    for i := 0; i < N; i++ {
        for j := 0; j < M; j++ {
            if m[i][j] == 1 { // 当前位置发现了1!
                // 把这一片的1,都变成2,同时,抓上来了,这一片1组成的初始队列
                // curs, 把这一片的1到自己的距离,都设置成1了,records
                queueSize := infect(m, i, j, N, M, curs, 0, records[island])
                V := 1
                for queueSize != 0 {
                    V++
                    // curs里面的点,上下左右,records[点]==0, nexts
                    queueSize = bfs(N, M, all, V, curs, queueSize, nexts, records[island])
                    tmp := curs
                    curs = nexts
                    nexts = tmp
                }
                island++
            }
        }
    }
    min := math.MaxInt64
    for i := 0; i < all; i++ {
        min = getMin(min, records[0][i]+records[1][i])
    }
    return min - 3
}

func getMin(a int, b int) int {
    if a < b {
        return a
    } else {
        return b
    }
}

// 当前来到m[i][j] , 总行数是N,总列数是M
// m[i][j]感染出去(找到这一片岛所有的1),把每一个1的坐标,放入到int[] curs队列!
// 1 (a,b) -> curs[index++] = (a * M + b)
// 1 (c,d) -> curs[index++] = (c * M + d)
// 二维已经变成一维了, 1 (a,b) -> a * M + b
// 设置距离record[a * M +b ] = 1
func infect(m [][]int, i int, j int, N int, M int, curs []int, index int, record []int) int {
    if i < 0 || i == N || j < 0 || j == M || m[i][j] != 1 {
        return index
    }
    // m[i][j] 不越界,且m[i][j] == 1
    m[i][j] = 2
    p := i*M + j
    record[p] = 1
    // 收集到不同的1
    curs[index] = p
    index++
    index = infect(m, i-1, j, N, M, curs, index, record)
    index = infect(m, i+1, j, N, M, curs, index, record)
    index = infect(m, i, j-1, N, M, curs, index, record)
    index = infect(m, i, j+1, N, M, curs, index, record)
    return index
}

// 二维原始矩阵中,N总行数,M总列数
// all 总 all = N * M
// V 要生成的是第几层 curs V-1 nexts V
// record里面拿距离
func bfs(N int, M int, all int, V int, curs []int, size int, nexts []int, record []int) int {
    nexti := 0 // 我要生成的下一层队列成长到哪了?
    for i := 0; i < size; i++ {
        // curs[i] -> 一个位置
        up := twoSelectOne(curs[i] < M, -1, curs[i]-M)
        down := twoSelectOne(curs[i]+M >= all, -1, curs[i]+M)
        left := twoSelectOne(curs[i]%M == 0, -1, curs[i]-1)
        right := twoSelectOne(curs[i]%M == M-1, -1, curs[i]+1)
        if up != -1 && record[up] == 0 {
            record[up] = V
            nexts[nexti] = up
            nexti++
        }
        if down != -1 && record[down] == 0 {
            record[down] = V
            nexts[nexti] = down
            nexti++
        }
        if left != -1 && record[left] == 0 {
            record[left] = V
            nexts[nexti] = left
            nexti++
        }
        if right != -1 && record[right] == 0 {
            record[right] = V
            nexts[nexti] = right
            nexti++
        }
    }
    return nexti
}

func twoSelectOne(c bool, a int, b int) int {
    if c {
        return a
    } else {
        return b
    }
}

执行结果如下:


左神java代码

以上是关于2021-07-28:最短的桥。在给定的二维二进制数组 A 中,存在两座岛。(岛是由四面相连的 1 形成的一个最大组。)现在,我们可以将 0 变为 1,以使两座岛连接起来,变成一座岛。返回必须翻转的(的主要内容,如果未能解决你的问题,请参考以下文章

leetcode 934. Shortest Bridge 最短的桥(中等)

力扣 每日一题 934. 最短的桥难度:中等,rating: 1825(dfs / bfs)

是否有一种算法可以为给定范围内的每个条目找到最短的二进制表示?

在单词中找到最短的重复周期?

最短母串

如何找到最短的堆栈移动序列以获得目标堆栈?