LeetCode Weekly Competition 345 (2023/05/14) 1 つの問題に対して複数の解決策をもつアルゴリズムの美しさを体験する

この記事にはAndroidFamily、技術的および職場の問題が含まれています。質問するには公開アカウント [Peng Xurui] にご注意ください。

• 過去のレビュー：LeetCode隔週コンペティション104・流れる水の動的プログラミング、ハードワークの構造化思考

ウィークリートーナメント概要

T1. スピンゲームの敗者を見つける (簡単)

• タグ: シミュレーション、カウンティング

T2. 隣接する値のビットごとの XOR (中)

• タグ: シミュレーション、数学、構築

T3. マトリックス内の最大移動数 (中)

• タグ: グラフ、BFS、DFS、動的プログラミング

T4. 完全に接続されたコンポーネントの数を数える (中)

• タグ: グラフ、BFS、DFS、ユニオン検索

---

T1. スピンゲームの敗者を見つける (簡単)

https://leetcode.cn/problems/find-the-losers-of-the-circular-game/

解決策（シミュレーション）

簡単な模擬質問。

マーカー配列を使用してボールに触れたプレーヤーをマークし、マーカー配列に従って結果を出力します。

class Solution {
    
    
    fun circularGameLosers(n: Int, k: Int): IntArray {
    
    
        val visit = BooleanArray(n)
        var i = 0
        var j = 1
        var cnt = n
        while (!visit[i]) {
    
    
            visit[i] = true
            i = (i + j++ * k) % n
            cnt--
        }
        val ret = IntArray(cnt)
        var k = 0
        for (i in visit.indices) {
    
    
            if(!visit[i]) ret[k++] = i + 1
        }
        return ret
    }
}

複雑さの分析:

• 時間計算量: $O\left(n\right)$各プレーヤーは最大 1 回マークとチェックを行います。
• 空間の複雑さ: $O\left(n\right)$個のトークン化された配列スペース。

---

T2. 隣接する値のビットごとの XOR (中)

https://leetcode.cn/problems/neighboring-bitwise-xor/

予備知識

注 ⊕ は XOR 演算であり、XOR 演算は次の特性を満たします。

• 基本特性: x ⊕ y = 0
• 交換法則: x ⊕ y = y ⊕ x
• 結合性: (x ⊕ y) ⊕ z = x ⊕ (y ⊕ z)
• 再帰法則: x ⊕ y ⊕ y = x

解決策 1 (シミュレーション)

各派生[i]はoriginal[i] ⊕original[i + 1]で得られるので、元のoriginal[0]を0に設定し、次にoriginal[n](循環配列)まで順番に再帰することができます。 、original[0]とoriginal[n]が同じかどうかをチェックします。異なる場合は、派生配列を構築できないことを意味します。

class Solution {
    
    
    fun doesValidArrayExist(derived: IntArray): Boolean {
    
    
        var pre = 0
        for ((i,d) in derived.withIndex()) {
    
    
            if (d == 1) pre = pre xor 1
        }
        return pre == 0
    }
}

複雑さの分析:

• 時間計算量: $O\left(n\right)$ここで、 n は派生配列の長さです。
• スペースの複雑さ: 一定レベルのスペースのみが使用されます。

解決策 2 (数学)

問題の数学的性質をさらに掘り下げていきます。

• 要求事項：$派生\left[i\right]\_\_\_\_\_=またはiginal\left[i\right]\_\oplus またはigina\; l[i+1]$
• 根据自反律（两边异或 original[i]）：$またはigina\; l[i+1]=派生\left[i\right]\_\_\_\_\_\oplus またはiginal\left[i\right]$、オリジナル [ i + 2 ] = 派生 [ i + 1 ] ⊕ オリジナル [ i + 1 ] オリジナル[i + 2] = 派生[i + 1] ⊕ オリジナル[i + 1$]$$またはigina\; l[i+2]=派生[i\_\_\_\_\_+1]\oplus またはigina\; l[i+1]$
• 根据递推关系有 $またはigin\; al[n-1]=導出[n\_\_\_\_\_-2]\oplus 導出[n\_\_\_\_\_-1]\dots 導出\left[0\right]\_\_\_\_\_\oplus またはiginal\left[0\right]\_$
• 要求事項：$またはiginal\left[0\right]\_\oplus またはigin\; al[n-1]=導出[n\_\_\_\_\_-1]$
• 联合两式：$またはiginal\left[0\right]\_=またはiginal\left[0\right]\_\oplus 導出[n\_\_\_\_\_-1]\oplus 導出[n\_\_\_\_\_-1]\dots 導出\left[0\right]\_\_\_\_\_\oplus またはiginal\left[0\right]$，即0 = 導出 [ n − 1 ] ⊕ 導出 [ n − 1 ] … 導出 [ 0 ] 0 = 導出[n-1] ⊕ 導出[n - 1]… 導出[0$]$$0=導出[n\_\_\_\_\_-1]\oplus 導出[n\_\_\_\_\_-1]\dots 導出\left[0\right]\_\_\_\_\_$

結論式によると、シミュレーションは次のようになります。

class Solution {
    
    
    fun doesValidArrayExist(derived: IntArray): Boolean {
    
    
        // return derived.fold(0) {acc, e -> acc xor e} == 0
        return derived.reduce {
    
    acc, e -> acc xor e} == 0
    }
}

複雑さの分析:

• 時間計算量: $O\left(n\right)$ここで、 n は派生配列の長さです。
• スペースの複雑さ: 一定レベルのスペースのみが使用されます。

---

T3. マトリックス内の最大移動数 (中)

https://leetcode.cn/problems/maximum-number-of-moves-in-a-grid/

トピックの説明

 添え字が 0から始まり 、サイズが である 行列が与え られる と、行列はいくつかの 正の 整数で構成されます。m x ngrid

行列の最初の列の任意 のセルから開始して 、次のように繰り返すこと ができますgrid 。

• セルから、  現在のセルより厳密に 値が大きい 3 つのセル  のいずれ かに(row, col) 移動できます 。(row - 1, col + 1)(row, col + 1)(row + 1, col + 1)

マトリックス内で 移動 できる 最大回数を返します 。

例 1:

输入：grid = [[2,4,3,5],[5,4,9,3],[3,4,2,11],[10,9,13,15]]
输出：3
解释：可以从单元格 (0, 0) 开始并且按下面的路径移动：
- (0, 0) -> (0, 1).
- (0, 1) -> (1, 2).
- (1, 2) -> (2, 3).
可以证明这是能够移动的最大次数。

例 2:

输入：grid = [[3,2,4],[2,1,9],[1,1,7]]
输出：0
解释：从第一列的任一单元格开始都无法移动。

ヒント：

• m == grid.length
• n == grid[i].length
• 2 <= m, n <= 1000
• 4 <= m * n <= 105
• 1 <= grid[i][j] <= 106

問題の構造化

1. 問題の目標を要約する

移動できる最大回数を計算します。これは、アクセス可能な距離 - 1 としても理解できます。

2. 問題の要素を分析する

各移動操作では、右列の最後の 3 つの行位置 (i-1、i、j+1) に移動できますが、その数値は現在の位置より厳密に大きい必要があります。

3. 抽象度を高める

• 副問題: 各移動の後、移動できる回数は、新しい位置に移動できる回数 + 1 であることがわかりました。これは、元の問題に似ていますが、規模が小さい副問題です。
• 決断力の問題でしょうか？各手に対して最大 3 つの位置の選択肢があるため、これは決定の問題です。

4. 具体的な解決策

• 手段 1 (記憶された再帰): Grid[i][j] から始まる最大移動数を表す dfs(i, j) を定義し、dfs(i, j)= mas{dfs(i-1, j+1) )、dfs(i, j+1), dfs(i+1, j+1)};
• 方法 2 (再帰): 記憶再帰では、「再帰」の過程で部分問題の解をマージします。再帰の方向は検証行列の上から下、左から右であるため、「」を排除できます。 recursion". "" 処理し、"return" プロセスのみを保持し、再帰を再帰に変換します。
• 手段 3 (BFS): 移動回数は最も移動できる列番号に依存するため、BFS/DFS を使用して最も遠くにアクセスできる列番号を検索できます。

解決策 1 (記憶された再帰)

「方法 1」のシミュレーションによると、次のようになります。

• 再帰関数: dfs(i, j)= mas{dfs(i-1, j+1), dfs(i, j+1), dfs(i+1, j+1)}
• 開始状態: dfs(i, 0)
• 境界条件: dfs(i, j) = 0

class Solution {
    
    

    val directions = arrayOf(intArrayOf(-1, 1), intArrayOf(0, 1), intArrayOf(1, 1)) // 右上、右、右下

    private val memo = HashMap<Int, Int>()
    private val U = 1001

    fun maxMoves(grid: Array<IntArray>): Int {
    
    
        var ret = 0
        for (i in 0 until grid.size) {
    
    
            ret = Math.max(ret, dfs(grid, i, 0))
        }
        return ret - 1
    }

    private fun dfs(grid: Array<IntArray>, i: Int, j: Int): Int {
    
    
        val n = grid.size
        val m = grid[0].size
        val key = i * U + j
        if (memo.contains(key)) return memo[key]!!
        // 枚举选项
        var maxChoice = 0
        for (direction in directions) {
    
    
            val newI = i + direction[0]
            val newJ = j + direction[1]
            if (newI < 0 || newI >= n || newJ < 0 || newJ >= m || grid[i][j] >= grid[newI][newJ]) continue
            maxChoice = Math.max(maxChoice, dfs(grid, newI, newJ))
        }
        memo[key] = maxChoice + 1
        return maxChoice + 1
    }
}

複雑さの分析:

• 時間計算量: $O\left(nm\right)$合計 nm 個の部分問題があり、各部分問題は 3 つの選択肢を列挙し、時間計算量は O(1) です。
• 空間複雑さ: $O\left(nm\right)$メモスペース。

解決策 2 (再帰)

「再帰」プロセスを削除して「再帰」プロセスのみを保持し、再帰を再帰に変換します。

class Solution {
    
    
    fun maxMoves(grid: Array<IntArray>): Int {
    
    
        val n = grid.size
        val m = grid[0].size
        val step = Array(n) {
    
     IntArray(m) }
        for (i in 0 until n) step[i][0] = 1
        var ret = 0
        // 按列遍历
        for(j in 1 until m) {
    
    
            for(i in 0 until n) {
    
    
                for(k in Math.max(0, i - 1) .. Math.min(n - 1,i + 1)) {
    
    
                    if (step[k][j - 1] > 0 && grid[i][j] > grid[k][j - 1]) step[i][j] = Math.max(step[i][j], step[k][j - 1] + 1)
                }
                ret = Math.max(ret, step[i][j])
            }
        }
        return Math.max(ret - 1, 0)
    }
}

あるいは、ローリング配列を使用してスペースを最適化することもできます。

class Solution {
    
    
    fun maxMoves(grid: Array<IntArray>): Int {
    
    
        val n = grid.size
        val m = grid[0].size
        var step = IntArray(n) {
    
     1 }
        var ret = 0
        // 按列遍历
        for(j in 1 until m) {
    
    
            val newStep = IntArray(n) {
    
     0 } // 不能直接在 step 数组上修改
            for(i in 0 until n) {
    
    
                for(k in Math.max(0, i - 1) .. Math.min(n - 1,i + 1)) {
    
    
                    if (step[k] > 0 && grid[i][j] > grid[k][j - 1]) newStep[i] = Math.max(newStep[i], step[k] + 1)
                }
                ret = Math.max(ret, newStep[i])
            }
            step = newStep
        }
        return Math.max(ret - 1, 0)
    }
}

複雑さの分析:

• 時間計算量: $O\left(nm\right)$
• 空間の複雑さ: $O\left(n\right)$

問題解決策 3 (BFS)

幅優先探索に従って、キューを使用してアクセス可能なノードを維持し、次にノードを使用して次の層の到達可能な位置を検出し、キューに参加します。

class Solution {
    
    
    fun maxMoves(grid: Array<IntArray>): Int {
    
    
        val n = grid.size
        val m = grid[0].size
        // 行号
        var queue = LinkedList<Int>()
        for (i in 0 until n) {
    
    
            queue.offer(i)
        }
        // 访问标记
        val visit = IntArray(n) {
    
     -1 }
        // 枚举列
        for (j in 0 until m - 1) {
    
    
            val newQueue = LinkedList<Int>() // 不能直接在 step 数组上修改
            for (i in queue) {
    
    
                for (k in Math.max(0, i - 1)..Math.min(n - 1, i + 1)) {
    
    
                    if (visit[k] < j && grid[k][j + 1] > grid[i][j]) {
    
    
                        newQueue.offer(k)
                        visit[k] = j
                    }
                }
            }
            queue = newQueue
            if (queue.isEmpty()) return j
        }
        return m - 1
    }
}

複雑さの分析:

• 時間計算量: $O\left(nm\right)$
• 空間の複雑さ: $O\left(n\right)$

同様の質問:

• 62. 異なる道
• 63. 異なる道 II

---

T4. 完全に接続されたコンポーネントの数を数える (中)

https://leetcode.cn/problems/count-the-number-of-complete-components/

問題の説明

整数を返します n 。n 頂点 を含む無向 グラフ の場合 、頂点には から0 までの 番号が付けられますn - 1 。 頂点  と の間に無向 エッジがある edges 整数 の 2 次元配列が与えられます  。edges[i] = [ai, bi]aibi

グラフ内の全結合成分の数を返します  。

サブグラフ内の任意 の 2 つの頂点間にパスがあり、サブグラフ内のどの頂点もサブグラフの外側の頂点とエッジを共有していない場合、サブグラフは連結コンポーネントと呼ばれます 。

接続されたコンポーネントは、その中のすべてのノードのペアの間にエッジがある場合、 完全に接続されていると言われます 。

例 1:

输入：n = 6, edges = [[0,1],[0,2],[1,2],[3,4]]
输出：3
解释：如上图所示，可以看到此图所有分量都是完全连通分量。

例 2:

输入：n = 6, edges = [[0,1],[0,2],[1,2],[3,4],[3,5]]
输出：1
解释：包含节点 0、1 和 2 的分量是完全连通分量，因为每对节点之间都存在一条边。
包含节点 3 、4 和 5 的分量不是完全连通分量，因为节点 4 和 5 之间不存在边。
因此，在图中完全连接分量的数量是 1 。

ヒント：

• 1 <= n <= 50
• 0 <= edges.length <= n * (n - 1) / 2
• edges[i].length == 2
• 0 <= ai, bi <= n - 1
• ai != bi
• 重複したエッジはありません

予備知識 - 全体像

完全なグラフ内の異なる頂点の各ペアは 1 つのエッジによって接続されており、n 個のノードを持つ完全なグラフには n*(n − 1) / 2 個のエッジがあります。

問題分析

この問題は比較的単純な島/連結成分の問題であり、DFS / BFS / Union Search を直接実行して、各連結成分のノード数とエッジ数が釣り合っているかどうかを計算します。

連結成分が完全なグラフの場合、ノードの数 v とエッジの数 e は e == v * (v - 2) / 2 を満たします。

問題解決策 1 (DFS)

各ノードを列挙して DFS を実行し、同じ連結成分のノード v の数とノード e の数を数えます。トラバース中に 2 つのノードで同じエッジが繰り返し数えられるため、連結成分が完全であるかどうかを判断する式は次のようになります。グラフは e == v * (v - 2) に合わせて調整されています。

class Solution {
    
    
    fun countCompleteComponents(n: Int, edges: Array<IntArray>): Int {
    
    
        // 建图（邻接表）
        val graph = Array(n) {
    
     mutableListOf<Int>() }
        for (edge in edges) {
    
    
            graph[edge[0]].add(edge[1])
            graph[edge[1]].add(edge[0]) // 无向边
        }
        // 标记数组
        val visit = BooleanArray(n)
        // 枚举
        var ret = 0
        for (i in 0 until n) {
    
    
            if (visit[i]) continue
            val cnt = IntArray(2) // v, e
            dfs(graph, visit, i, cnt)
            if (cnt[1] == cnt[0] * (cnt[0] - 1)) ret++
        }
        return ret
    }

    private fun dfs(graph: Array<out List<Int>>, visit: BooleanArray, i: Int, cnt: IntArray) {
    
    
        visit[i] = true
        cnt[0] += 1 // 增加节点
        cnt[1] += graph[i].size // 增加边（会统计两次）
        for (to in graph[i]) {
    
    
            if (!visit[to]) dfs(graph, visit, to, cnt)
        }
    }
}

複雑さの分析:

• 時間計算量: $O(n+m)$ここで、n はノードの数、m はエッジの長さです。
• 空間計算量: グラフ空間$O\left(m\right)$、マークされた配列空間$O\left(n\right)$。

問題解決策 2 (BFS)

BFS コードが付属しています:

class Solution {
    
    
    fun countCompleteComponents(n: Int, edges: Array<IntArray>): Int {
    
    
        // 建图（邻接表）
        val graph = Array(n) {
    
     mutableListOf<Int>() }
        for (edge in edges) {
    
    
            graph[edge[0]].add(edge[1])
            graph[edge[1]].add(edge[0]) // 无向边
        }
        // 标记数组
        val visit = BooleanArray(n)
        // 枚举
        var ret = 0
        for (i in 0 until n) {
    
    
            if (visit[i]) continue
            var v = 0
            var e = 0
            // BFS
            var queue = LinkedList<Int>()
            queue.offer(i)
            visit[i] = true
            while (!queue.isEmpty()) {
    
    
                val temp = queue
                queue = LinkedList<Int>()
                for (j in temp) {
    
    
                    v += 1 // 增加节点
                    e += graph[j].size // 增加边（会统计两次）
                    for (to in graph[j]) {
    
    
                        if (!visit[to]) {
    
    
                            queue.offer(to)
                            visit[to] = true
                        }
                    }
                }
            }
            if (e == v * (v - 1)) ret++
        }
        return ret
    }
}

複雑さの分析:

• 時間計算量: $O(n+m)$ここで、n はノードの数、m はエッジの長さです。
• 空間の複雑さ: グラフ空間、タグ配列空間、およびキュー空間。

解決策 3 (およびチェック セット)

コピーを添付してコードを確認してください。

class Solution {
    
    

    fun countCompleteComponents(n: Int, edges: Array<IntArray>): Int {
    
    
        val uf = UnionFind(n)
        for (edge in edges) {
    
    
            uf.union(edge[0], edge[1])
        }
        return uf.count()
    }

    private class UnionFind(n: Int) {
    
    
        private val parent = IntArray(n) {
    
     it }
        private val rank = IntArray(n)
        private val e = IntArray(n)
        private val v = IntArray(n) {
    
     1 }

        fun find(x: Int): Int {
    
    
            // 路径压缩
            var a = x
            while (parent[a] != a) {
    
    
                parent[a] = parent[parent[a]]
                a = parent[a]
            }
            return a
        }

        fun union(x: Int, y: Int) {
    
    
            val rootX = find(x)
            val rootY = find(y)
            if (rootX == rootY) {
    
    
                e[rootX]++
            } else {
    
    
                // 按秩合并
                if (rank[rootX] < rank[rootY]) {
    
    
                    parent[rootX] = rootY
                    e[rootY] += e[rootX] + 1 // 增加边
                    v[rootY] += v[rootX] // 增加节点
                } else if (rank[rootY] > rank[rootX]) {
    
    
                    parent[rootY] = rootX
                    e[rootX] += e[rootY] + 1
                    v[rootX] += v[rootY]
                } else {
    
    
                    parent[rootY] = rootX
                    e[rootX] += e[rootY] + 1
                    v[rootX] += v[rootY]
                    rank[rootX]++
                }
            }
        }

        // 统计连通分量
        fun count(): Int {
    
    
            return parent.indices.count {
    
     parent[it] == it && v[it] * (v[it] - 1) / 2 == e[it] }
        }
    }
}

複雑さの分析:

• 時間計算量: $O(n+am)$ここで、n はノードの数、m はエッジの長さ、および$a$は逆アッカーマン関数です。
• 空間の複雑さ: $O\left(n\right)$共用体ルックアップ空間。

---

過去のレビュー

• LeetCode Weekly Competition No. 344 手書き再帰関数の一般的なルーチン
• LeetCode Weekly Competition No.343・「次の順列」を組み合わせた欲張りな作図問題
• LeetCode 隔週コンペティション No. 104 流れの動的プログラミング、鉄の構造化思考
• LeetCode 隔週コンペティション No. 103 区間和ツリー配列の古典的な応用