finish easy & medium

medium/130.go

@@ -1,14 +1,83 @@
 package main
 
-func solve(board [][]byte) {
+import (
+	"fmt"
+)
 
+func solve(board [][]byte) {
+	height := len(board)
+	if height == 0 {
+		return
+	}
+	width := len(board[0])
+	type Grid struct {
+		X int
+		Y int
+	}
+	flipMap := make(map[Grid]bool, 0)
+	stack := make([]Grid, 0)
+	for y := 0; y < height; y++ {
+		for x := 0; x < width; x++ {
+			if (x == 0 || x == width-1 || y == 0 || y == height-1) &&
+				board[y][x] == 'O' {
+				flipMap[Grid{x, y}] = true
+				stack = append(stack, Grid{x, y})
+			}
+		}
+	}
+	for len(stack) != 0 {
+		length := len(stack)
+		grid := stack[length-1] // Pop top grid
+		stack = stack[:length-1]
+		if grid.X > 0 &&
+			!flipMap[Grid{grid.X - 1, grid.Y}] && // If left grid's not visited
+			board[grid.Y][grid.X-1] == 'O' {
+			flipMap[Grid{grid.X - 1, grid.Y}] = true
+			stack = append(stack, Grid{grid.X - 1, grid.Y})
+		}
+		if grid.X < width-1 &&
+			!flipMap[Grid{grid.X + 1, grid.Y}] && // ...Right grid
+			board[grid.Y][grid.X+1] == 'O' {
+			flipMap[Grid{grid.X + 1, grid.Y}] = true
+			stack = append(stack, Grid{grid.X + 1, grid.Y})
+		}
+		if grid.Y > 0 &&
+			!flipMap[Grid{grid.X, grid.Y - 1}] && // ...Up
+			board[grid.Y-1][grid.X] == 'O' {
+			flipMap[Grid{grid.X, grid.Y - 1}] = true
+			stack = append(stack, Grid{grid.X, grid.Y - 1})
+		}
+		if grid.Y < height-1 &&
+			!flipMap[Grid{grid.X, grid.Y + 1}] && //...Down
+			board[grid.Y+1][grid.X] == 'O' {
+			flipMap[Grid{grid.X, grid.Y + 1}] = true
+			stack = append(stack, Grid{grid.X, grid.Y + 1})
+		}
+	}
+	for y := 0; y < height; y++ {
+		for x := 0; x < width; x++ {
+			if !flipMap[Grid{x, y}] && board[y][x] == 'O' {
+				board[y][x] = 'X'
+			}
+		}
+	}
 }
 
-func main() {
-	b1 := [][]byte{
-		{'X', 'X', 'X', 'X'},
-		{'X', 'O', 'O', 'X'},
-		{'X', 'O', 'X', 'X'},
-		{'X', 'X', 'O', 'X'}}
-	solve(b1)
+func printBoard(board [][]byte) {
+	for _, row := range board {
+		for _, val := range row {
+			fmt.Printf("%c ", val)
+		}
+		println()
+	}
 }
+
+// func main() {
+// 	b1 := [][]byte{
+// 		{'X', 'X', 'X', 'X'},
+// 		{'X', 'O', 'X', 'X'},
+// 		{'X', 'X', 'O', 'X'},
+// 		{'X', 'X', 'O', 'X'}}
+// 	solve(b1)
+// 	printBoard(b1)
+// }

medium/179.go

@@ -21,23 +21,25 @@ func (strs StringSlice) Less(i, j int) bool { // Less is "More"
 	len1, len2 := len(strs[i]), len(strs[j])
 	for k := 0; k < len1 && k < len2; k++ {
 		if strs[i][k] != strs[j][k] {
-			return !(strs[i][k] < strs[j][k])
+			return strs[i][k] > strs[j][k]
 		}
 	}
 	if len1 < len2 {
 		for k := len1; k < len2; k++ {
-			if strs[i][len1-1] != strs[j][k] {
-				return !(strs[i][len1-1] < strs[j][k])
+			if strs[i][0] != strs[j][k] {
+				return strs[i][0] > strs[j][k]
 			}
 		}
+		return strs[j][1] > strs[j][0] // Important!
 	} else if len1 > len2 {
 		for k := len2; k < len1; k++ {
-			if strs[i][k] != strs[j][len2-1] {
-				return !(strs[i][k] < strs[j][len2-1])
+			if strs[i][k] != strs[j][0] {
+				return strs[i][k] > strs[j][0]
 			}
 		}
+		return strs[i][1] < strs[i][0]
 	}
-	return !false
+	return false // strs[i] equals strs[j]
 }
 
 func largestNumber(nums []int) string {
@@ -61,7 +63,25 @@ func largestNumber(nums []int) string {
 
 // func main() {
 // 	println(largestNumber([]int{
+// 		12, 121}))
+// 	nums := StringSlice([]string{"8308", "830"})
+// 	println(nums.Less(0, 1))
+// 	println(nums.Less(1, 0))
+// 	println(largestNumber([]int{
 // 		3, 30, 34, 5, 9}))
 // 	println(largestNumber([]int{
 // 		824, 938, 1399, 5607, 6973, 5703, 9609, 4398, 8247}))
+// 	answer := largestNumber([]int{
+// 		9051, 5526, 2264, 5041, 1630, 5906, 6787, 8382, 4662, 4532,
+// 		6804, 4710, 4542, 2116, 7219, 8701, 8308, 957, 8775, 4822,
+// 		396, 8995, 8597, 2304, 8902, 830, 8591, 5828, 9642, 7100, 3976,
+// 		5565, 5490, 1613, 5731, 8052, 8985, 2623, 6325, 3723, 5224,
+// 		8274, 4787, 6310, 3393, 78, 3288, 7584, 7440, 5752, 351,
+// 		4555, 7265, 9959, 3866, 9854, 2709, 5817, 7272, 43, 1014,
+// 		7527, 3946, 4289, 1272, 5213, 710, 1603, 2436, 8823, 5228,
+// 		2581, 771, 3700, 2109, 5638, 3402, 3910, 871, 5441, 6861,
+// 		9556, 1089, 4088, 2788, 9632, 6822, 6145, 5137, 236, 683,
+// 		2869, 9525, 8161, 8374, 2439, 6028, 7813, 6406, 7519})
+// 	correct := "995998549642963295795569525905189958985890288238775871870185978591838283748308830827481618052787813771758475277519744072727265721971071006861683682268046787640663256310614560285906582858175752573156385565552654905441522852245213513750414822478747104662455545424532434289408839763963946391038663723370035134023393328828692788270926232581243924362362304226421162109163016131603127210891014"
+// 	println(answer == correct)
 // }

medium/199.go

@@ -0,0 +1,54 @@
+package main
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func rightSideView(root *TreeNode) []int {
+	view := make([]int, 0)
+	if root == nil {
+		return view
+	}
+	type Node struct {
+		Ptr   *TreeNode
+		Level int
+	}
+	viewed := make(map[int]bool)
+	queue := make([]Node, 0)
+	curr := root
+	queue = append(queue, Node{curr, 0})
+	for len(queue) != 0 {
+		curr = queue[0].Ptr
+		level := queue[0].Level
+		queue = queue[1:] // Pop
+		if !viewed[level] {
+			view = append(view, curr.Val)
+			viewed[level] = true
+		}
+		if curr.Right != nil {
+			queue = append(queue, Node{curr.Right, level + 1})
+		}
+		if curr.Left != nil {
+			queue = append(queue, Node{curr.Left, level + 1})
+		}
+	}
+	return view
+}
+
+// func main() {
+// 	fmt.Println(rightSideView(nil))
+// 	//        1
+// 	//       /
+// 	//      2
+// 	//     / \
+// 	//    3   4
+// 	n4 := TreeNode{4, nil, nil}
+// 	n3 := TreeNode{3, nil, nil}
+// 	n2 := TreeNode{2, &n3, &n4}
+// 	n1 := TreeNode{1, &n2, nil}
+// 	fmt.Println(rightSideView(&n1))
+// }

medium/200.go

@@ -0,0 +1,88 @@
+package main
+
+// Grid coordinate of single grid
+type Grid struct {
+	X int
+	Y int
+}
+
+// UF state of union-find algorithm
+type UF struct {
+	ID   map[Grid]Grid
+	Size map[Grid]int
+	Cnt  int
+}
+
+// Union ...
+func (uf *UF) Union(x1, y1, x2, y2 int) {
+	g1 := uf.Find(x1, y1)
+	g2 := uf.Find(x2, y2)
+	if g1 == g2 {
+		return
+	}
+	if uf.Size[g1] < uf.Size[g2] {
+		uf.ID[g1] = g2
+		uf.Size[g2] += uf.Size[g1]
+	} else {
+		uf.ID[g2] = g1
+		uf.Size[g1] += uf.Size[g2]
+	}
+	uf.Cnt--
+}
+
+// Find ...
+func (uf *UF) Find(x, y int) Grid {
+	g := Grid{x, y}
+	for g != uf.ID[g] {
+		g = uf.ID[g]
+	}
+	return g
+}
+
+// Connected ...
+func (uf *UF) Connected(x1, y1, x2, y2 int) bool {
+	return uf.Find(x1, y1) == uf.Find(x2, y2)
+}
+
+func numIslands(grid [][]byte) int { // Union-find algorithm
+	hei := len(grid)
+	if hei == 0 {
+		return 0
+	}
+	wid := len(grid[0])
+	var uf UF
+	uf.ID = make(map[Grid]Grid)
+	uf.Size = make(map[Grid]int)
+	for y := 0; y < hei; y++ {
+		for x := 0; x < wid; x++ {
+			if grid[y][x] == '1' {
+				g := Grid{x, y}
+				uf.ID[g] = g
+				uf.Size[g] = 1
+				uf.Cnt++
+			}
+		}
+	}
+	for y := 0; y < hei; y++ {
+		for x := 0; x < wid; x++ {
+			if grid[y][x] == '0' {
+				continue
+			}
+			if x+1 < wid && grid[y][x+1] == '1' {
+				uf.Union(x, y, x+1, y)
+			}
+			if y+1 < hei && grid[y+1][x] == '1' {
+				uf.Union(x, y, x, y+1)
+			}
+		}
+	}
+	return uf.Cnt
+}
+
+func main() {
+	println(numIslands([][]byte{
+		{'1', '1', '0', '0', '0'},
+		{'1', '1', '0', '0', '0'},
+		{'0', '0', '1', '0', '0'},
+		{'0', '0', '0', '1', '1'}}))
+}