Merge pull request #251 from Don2025/master

Leetcode419

Author: halfrost

leetcode/0396.Rotate-Function/396. Rotate Function.go

@@ -0,0 +1,18 @@
+package leetcode
+
+func maxRotateFunction(nums []int) int {
+	n := len(nums)
+	var sum, f int
+	for i, num := range nums {
+		sum += num
+		f += i * num // F(0)
+	}
+	ans := f
+	for i := 1; i < n; i++ {
+		f += sum - n*nums[n-i] // F(i) = F(i-1) + sum - n*nums[n-i]
+		if f > ans {
+			ans = f
+		}
+	}
+	return ans
+}

leetcode/0396.Rotate-Function/396. Rotate Function_test.go

@@ -0,0 +1,46 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question396 struct {
+	para396
+	ans396
+}
+
+// para 是参数
+// one 代表第一个参数
+type para396 struct {
+	one []int
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans396 struct {
+	one int
+}
+
+func Test_Problem396(t *testing.T) {
+
+	qs := []question396{
+		{
+			para396{[]int{4, 3, 2, 6}},
+			ans396{26},
+		},
+
+		{
+			para396{[]int{100}},
+			ans396{0},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 396------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans396, q.para396
+		fmt.Printf("【input】:%v       【output】:%v\n", p, maxRotateFunction(p.one))
+	}
+	fmt.Printf("\n\n\n")
+}

leetcode/0396.Rotate-Function/README.md

@@ -0,0 +1,110 @@
+# [396. Rotate Function](https://leetcode.com/problems/rotate-function/)
+
+## 题目
+
+You are given an integer array `nums` of length `n`.
+
+Assume `arrk` to be an array obtained by rotating `nums` by `k` positions clock-wise. We define the **rotation function** `F` on `nums` as follow:
+
+- `F(k) = 0 * arrk[0] + 1 * arrk[1] + ... + (n - 1) * arrk[n - 1]`.
+
+Return the maximum value of `F(0), F(1), ..., F(n-1)`.
+
+The test cases are generated so that the answer fits in a **32-bit** integer.
+
+**Example 1:**
+
+```c
+Input: nums = [4,3,2,6]
+Output: 26
+Explanation:
+F(0) = (0 * 4) + (1 * 3) + (2 * 2) + (3 * 6) = 0 + 3 + 4 + 18 = 25
+F(1) = (0 * 6) + (1 * 4) + (2 * 3) + (3 * 2) = 0 + 4 + 6 + 6 = 16
+F(2) = (0 * 2) + (1 * 6) + (2 * 4) + (3 * 3) = 0 + 6 + 8 + 9 = 23
+F(3) = (0 * 3) + (1 * 2) + (2 * 6) + (3 * 4) = 0 + 2 + 12 + 12 = 26
+So the maximum value of F(0), F(1), F(2), F(3) is F(3) = 26.
+```
+
+**Example 2:**
+
+```c
+Input: nums = [100]
+Output: 0
+```
+
+**Constraints:**
+
+- `n == nums.length`
+- `1 <= n <= 105`
+- `-100 <= nums[i] <= 100`
+
+## 题目大意
+
+给定一个长度为`n`的整数数组`nums`，设`arrk`是数组`nums`顺时针旋转`k`个位置后的数组。
+
+定义`nums`的旋转函数`F`为：
+
+- `F(k) = 0 * arrk[0] + 1 * arrk[1] + ... + (n - 1) * arrk[n - 1]`
+
+返回`F(0), F(1), ..., F(n-1)`中的最大值。
+
+## 解题思路
+
+**抽象化观察：**
+
+```c
+nums = [A0, A1, A2, A3]
+
+sum  = A0 + A1 + A2+ A3
+F(0) = 0*A0 +0*A0 + 1*A1 + 2*A2 + 3*A3
+    
+F(1) = 0*A3 + 1*A0 + 2*A1 + 3*A2 
+     = F(0) + (A0 + A1 + A2) - 3*A3 
+     = F(0) + (sum-A3) - 3*A3 
+     = F(0) + sum - 4*A3
+
+F(2) = 0*A2 + 1*A3 + 2*A0 + 3*A1 
+     = F(1) + A3 + A0 + A1 - 3*A2 
+     = F(1) + sum - 4*A2
+
+F(3) = 0*A1 + 1*A2 + 2*A3 + 3*A0 
+     = F(2) + A2 + A3 + A0 - 3*A1 
+     = F(2) + sum - 4*A1
+    
+// 记sum为nums数组中所有元素和
+// 可以猜测当0 ≤ i < n时存在公式:
+F(i) = F(i-1) + sum - n * A(n-i)
+```
+
+**数学归纳法证明迭代公式：**
+
+根据题目中给定的旋转函数公式可得已知条件：
+
+- `F(0) = 0×nums[0] + 1×nums[1] + ... + (n−1)×nums[n−1]`；
+
+- `F(1) = 1×nums[0] + 2×nums[1] + ... + 0×nums[n-1]`。
+
+令数组`nums`中所有元素和为`sum`，用数学归纳法验证：当`1 ≤ k < n`时，`F(k) = F(k-1) + sum - n×nums[n-k]`成立。
+
+**归纳奠基**：证明`k=1`时命题成立。
+
+```c
+F(1) = 1×nums[0] + 2×nums[1] + ... + 0×nums[n-1]
+     = F(0) + sum - n×nums[n-1]
+```
+
+**归纳假设**：假设`F(k) = F(k-1) + sum - n×nums[n-k]`成立。
+
+**归纳递推**：由归纳假设推出`F(k+1) = F(k) + sum - n×nums[n-(k+1)]`成立，则假设的递推公式成立。
+
+```c
+F(k+1) = (k+1)×nums[0] + k×nums[1] + ... + 0×nums[n-1]
+       = F(k) + sum - n×nums[n-(k+1)] 
+```
+
+因此可以得到递推公式：
+
+- 当`n = 0`时，`F(0) = 0×nums[0] + 1×nums[1] + ... + (n−1)×nums[n−1]`
+- 当`1 ≤ k < n`时，`F(k) = F(k-1) + sum - n×nums[n-k]`成立。
+
+循环遍历`0 ≤ k < n`，计算出不同的`F(k)`并不断更新最大值，就能求出`F(0), F(1), ..., F(n-1)`中的最大值。

leetcode/0419.Battleships-in-a-Board/419. Battleships in a Board.go

@@ -0,0 +1,21 @@
+package leetcode
+
+func countBattleships(board [][]byte) (ans int) {
+	if len(board) == 0 || len(board[0]) == 0 {
+		return 0
+	}
+	for i := range board {
+		for j := range board[i] {
+			if board[i][j] == 'X' {
+				if i > 0 && board[i-1][j] == 'X' {
+					continue
+				}
+				if j > 0 && board[i][j-1] == 'X' {
+					continue
+				}
+				ans++
+			}
+		}
+	}
+	return
+}

leetcode/0419.Battleships-in-a-Board/419. Battleships in a Board_test.go

@@ -0,0 +1,59 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+	"unsafe"
+)
+
+type question419 struct {
+	para419
+	ans419
+}
+
+// para 是参数
+// one 代表第一个参数
+type para419 struct {
+	one [][]byte
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans419 struct {
+	one int
+}
+
+func Test_Problem419(t *testing.T) {
+
+	qs := []question419{
+
+		{
+			para419{[][]byte{{'X', '.', '.', 'X'}, {'.', '.', '.', 'X'}, {'.', '.', '.', 'X'}}},
+			ans419{2},
+		},
+
+		{
+			para419{[][]byte{{'.'}}},
+			ans419{0},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 419------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans419, q.para419
+		fmt.Printf("【input】:%v       【output】:%v\n", bytesArrayToStringArray(p.one), countBattleships(p.one))
+	}
+	fmt.Printf("\n\n\n")
+
+}
+
+// 在运行go test时 为了更直观地显示[][]byte中的字符而非ASCII码数值
+// bytesArrayToStringArray converts [][]byte to []string
+func bytesArrayToStringArray(b [][]byte) []string {
+	s := make([]string, len(b))
+	for i := range b {
+		s[i] = fmt.Sprintf("[%v]", *(*string)(unsafe.Pointer(&b[i])))
+	}
+	return s
+}

leetcode/0419.Battleships-in-a-Board/README.md

@@ -0,0 +1,51 @@
+# [419. Battleships in a Board](https://leetcode.com/problems/battleships-in-a-board/)
+
+## 题目
+
+Given an `m x n` matrix `board` where each cell is a battleship `'X'` or empty `'.'`, return the number of the **battleships** on `board`.
+
+**Battleships** can only be placed horizontally or vertically on `board`. In other words, they can only be made of the shape `1 x k` (`1` row, `k` columns) or `k x 1` (`k` rows, `1` column), where `k` can be of any size. At least one horizontal or vertical cell separates between two battleships (i.e., there are no adjacent battleships).
+
+**Example 1:**
+
+![img](https://assets.leetcode.com/uploads/2021/04/10/battelship-grid.jpg)
+
+```c
+Input: board = [["X",".",".","X"],[".",".",".","X"],[".",".",".","X"]]
+Output: 2
+```
+
+**Example 2:**
+
+```c
+Input: board = [["."]]
+Output: 0
+```
+
+**Constraints:**
+
+- `m == board.length`
+- `n == board[i].length`
+- `1 <= m, n <= 200`
+- `board[i][j] is either '.' or 'X'`.
+
+**Follow up:** Could you do it in one-pass, using only `O(1)` extra memory and without modifying the values `board`?
+
+## 题目大意
+
+给定一个大小为`m × n`的矩阵 称之为甲板，矩阵单元格中的`'X'`表示战舰，`'.'`表示空位。
+
+战舰只能水平或竖直摆放在甲板上（换句话说，可以理解为联通的同一行`'X'`或同一列`'X'`只算作一个“战舰群”），任意俩个“战舰群”间都是不相邻的。返回甲板上“战舰群”的数量。
+
+## 解题思路
+
+题目进阶要求一次扫描算法，空间复杂度为`O(1)`，且不能修改矩阵中的值。
+
+因为题目中给定的两个“战舰群”间至少有一个水平或垂直的空位分隔，所以可以通过枚举每个战舰的左上顶点即可统计“战舰群”的个数。
+
+假设当前遍历到矩阵中`'X'`的位置为`(i, j)`，即 `board[i][j]='X'`。如果当前战舰属于一个新的“战舰群”，则需要满足以下条件：
+
+- 当前位置的上方位为空，即 `board[i-1][j]='.'`；
+- 当前位置的左方位为空，即 `board[i][j-1]='.'`；
+
+统计出所有左方位和上方位为空的战舰个数，即可得到“战舰群”的数量。