update

medium/525.contiguous-array.go

@@ -1,22 +1,24 @@
-func findMaxLength(nums []int) int {
+func findMaxLength(nums []int) (max int) {
 	n := len(nums)
 	if n < 2 {
-		return 0
+		return
 	}
-	dp := make([]int, n+1)
-	for i := range nums {
+	sum := make([]int, n+1)
+	m := make(map[int]int)
+	m[0] = 0
+	for i := range nums { // Range sum + two sum
 		if nums[i] == 0 {
-			dp[i+1] = dp[i]
+			sum[i+1] = sum[i] - 1
 		} else {
-			dp[i+1] = dp[i] + 1
+			sum[i+1] = sum[i] + 1
 		}
-	}
-	for l := n / 2 * 2; 2 <= l; l -= 2 {
-		for i := n; 0 <= i-l; i-- { // On^2
-			if dp[i]-dp[i-l] == l/2 {
-				return l
+		if val, ok := m[sum[i+1]]; ok {
+			if max < i+1-val {
+				max = i + 1 - val
 			}
+		} else {
+			m[sum[i+1]] = i + 1
 		}
 	}
-	return 0
+	return
 }

medium/526.beautiful-arrangement.go

@@ -0,0 +1,18 @@
+func countArrangement(N int) (cnt int) {
+	dfs(N, 1, 0, &cnt)
+	return cnt
+}
+
+func dfs(N int, i int, used int, cnt *int) {
+	if N < i {
+		(*cnt)++
+		return
+	}
+	for a := 1; a <= N; a++ {
+		if mask := 1 << uint(a); used&mask == 0 && (a%i == 0 || i%a == 0) {
+			used |= mask
+			dfs(N, i+1, used, cnt)
+			used ^= mask // Backtracking
+		}
+	}
+}

medium/529.minesweeper.go

@@ -0,0 +1,92 @@
+func updateBoard(board [][]byte, click []int) [][]byte {
+	y, x := click[0], click[1]
+	if board[y][x] != 'E' {
+		if board[y][x] == 'M' {
+			board[y][x] = 'X'
+		}
+		return board
+	}
+	m, n := len(board), len(board[0])
+	count := make([][]int, m)
+	for i := range count {
+		count[i] = make([]int, n)
+	}
+	cntAllMines(board, m, n, count)
+	dfs(board, m, n, count, y, x)
+	return board
+}
+
+func dfs(board [][]byte, m, n int, count [][]int, y, x int) {
+	if count[y][x] == 0 {
+		board[y][x] = 'B'
+		for dy := -1; dy <= 1; dy++ {
+			for dx := -1; dx <= 1; dx++ {
+				ny, nx := y+dy, x+dx
+				if 0 <= ny && ny < m && 0 <= nx && nx < n && board[ny][nx] == 'E' {
+					dfs(board, m, n, count, ny, nx)
+				}
+			}
+		}
+	} else {
+		board[y][x] = byte(count[y][x] + '0')
+	}
+}
+
+func cntAllMines(board [][]byte, m, n int, count [][]int) {
+	for y := 0; y < m; y++ {
+		for x := 0; x < n; x++ {
+			if board[y][x] == 'M' {
+				for dy := -1; dy <= 1; dy++ {
+					for dx := -1; dx <= 1; dx++ {
+						ny, nx := y+dy, x+dx
+						if 0 <= ny && ny < m && 0 <= nx && nx < n {
+							count[ny][nx]++
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func updateBoardMLE(board [][]byte, click []int) [][]byte { // BFS, MLE
+	y, x, m, n := click[0], click[1], len(board), len(board[0])
+	if board[y][x] != 'E' {
+		if board[y][x] == 'M' {
+			board[y][x] = 'X'
+		}
+		return board
+	}
+	queue := [][]int{[]int{y, x}}
+	for len(queue) != 0 {
+		y, x = queue[0][0], queue[0][1]
+		queue = queue[1:]
+		cnt := cntMines(board, m, n, y, x)
+		if cnt == 0 {
+			board[y][x] = 'B'
+			for dy := -1; dy <= 1; dy++ {
+				for dx := -1; dx <= 1; dx++ {
+					ny, nx := y+dy, x+dx
+					if 0 <= ny && ny < m && 0 <= nx && nx < n && board[ny][nx] == 'E' {
+						queue = append(queue, []int{ny, nx})
+					}
+				}
+			}
+		} else {
+			board[y][x] = byte(cnt + '0')
+		}
+	}
+	return board
+}
+
+func cntMines(board [][]byte, m, n, y, x int) (cnt int) {
+	for dy := -1; dy <= 1; dy++ {
+		for dx := -1; dx <= 1; dx++ {
+			ny, nx := y+dy, x+dx
+			if 0 <= ny && ny < m && 0 <= nx && nx < n && board[ny][nx] == 'M' {
+				cnt++
+			}
+		}
+	}
+	return
+}