update

medium/221.maximal-square.go

@@ -7,20 +7,41 @@ func maximalSquare(matrix [][]byte) int {
 	if m == 0 {
 		return 0
 	}
+	sideLen, sideMax := m, 0
+	if n < m {
+		sideLen = n
+	}
 	hei := make([][]int, n) // Init the accumulative height matrix
 	hei[0] = make([]int, m)
+	combo := make([]int, sideLen+1)
 	for i := range matrix[0] {
 		hei[0][i] = int(matrix[0][i]-'0')
+		if hei[0][i] == 1 {
+			sideMax = 1
+		}
 	}
-	for i := 1; i < m; i++ {
+	for i := 1; i < n; i++ {
 		hei[i] = make([]int, m)
+		combo = make([]int, sideLen+1)
 		for j := range matrix[i] {
 			if matrix[i][j] == '0' {
 				hei[i][j] = 0
+				for k := sideMax+1; k <= sideLen; k++ {
+					combo[k] = 0
+				}
 			} else {
 				hei[i][j] = hei[i-1][j] + 1
+				for k := sideMax+1; k <= sideLen && k <= hei[i][j]; k++ {
+					combo[k]++
+					if combo[k] == k {
+						sideMax = k
+					}
+				}
+				for k := hei[i][j]+1; k <= sideLen; k++ {
+					combo[k] = 0
+				}
 			}
 		}
 	}
-	return 0
+	return sideMax * sideMax
 }

medium/222.count-complete-tree-nodes.go

@@ -0,0 +1,26 @@
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func countNodes(root *TreeNode) (cnt int) {
+	if root == nil {
+		return
+	}
+	lvs := []*TreeNode{root}
+	for n := len(lvs); n != 0; n = len(lvs) {
+		node := lvs[n-1]
+		lvs = lvs[:n-1]
+		cnt++
+		if node.Left != nil {
+			lvs = append(lvs, node.Left)
+		}
+		if node.Right != nil {
+			lvs = append(lvs, node.Right)
+		}
+	}
+	return
+}

medium/223.rectangle-area.go

@@ -0,0 +1,29 @@
+func computeArea(A int, B int, C int, D int, E int, F int, G int, H int) int {
+	return areaOf(A, B, C, D) + areaOf(E, F, G, H) - overlap(A, C, E, G)*overlap(B, D, F, H)
+}
+
+func overlap(a1, a2, b1, b2 int) int {
+	l := a2 - a1 + b2 - b1 - (maxInt(a2, b2) - minInt(a1, b1))
+	if l < 0 {
+		return 0
+	}
+	return l
+}
+
+func areaOf(A, B, C, D int) int {
+	return (C - A) * (D - B)
+}
+
+func maxInt(x, y int) int {
+	if x < y {
+		return y
+	}
+	return x
+}
+
+func minInt(x, y int) int {
+	if x < y {
+		return x
+	}
+	return y
+}

medium/227.basic-calculator-ii.go

@@ -0,0 +1,58 @@
+import (
+	"strconv"
+	"strings"
+)
+
+func calculate(s string) int {
+	none := struct{}{}
+	opsSet := map[byte]struct{}{'+': none, '-': none, '*': none, '/': none}
+	ops := make([]byte, 0)
+	nums := make([]int, 0)
+	prev := -1
+	for i := range s {
+		if _, ok := opsSet[s[i]]; ok {
+			num, _ := strconv.Atoi(strings.Trim(s[prev+1:i], " ")) // Atoi should trim all spaces of string
+			mulOrDiv(&nums, &ops, &num)
+			nums = append(nums, num)
+			ops = append(ops, s[i])
+			prev = i
+		}
+	}
+	num, _ := strconv.Atoi(strings.Trim(s[prev+1:], " "))
+	mulOrDiv(&nums, &ops, &num)
+	nums = append(nums, num)
+	for left, right := 0, len(nums)-1; left < right; left, right = left+1, right-1 {
+		nums[left], nums[right] = nums[right], nums[left]
+	} // Reverse nums and ops
+	for left, right := 0, len(ops)-1; left < right; left, right = left+1, right-1 {
+		ops[left], ops[right] = ops[right], ops[left]
+	}
+	for l1, l2 := len(nums), len(ops); l1 != 1; l1, l2 = l1-1, l2-1 {
+		op := ops[l2-1]
+		ops = ops[:l2-1]
+		n1, n2 := nums[l1-2], nums[l1-1]
+		nums = nums[:l1-2]
+		switch op {
+		case '+':
+			nums = append(nums, n2+n1)
+		case '-':
+			nums = append(nums, n2-n1)
+		}
+	}
+	return nums[0]
+}
+
+func mulOrDiv(nums *[]int, ops *[]byte, num *int) {
+	if l := len(*ops); l != 0 && ((*ops)[l-1] == '*' || (*ops)[l-1] == '/') {
+		n := (*nums)[len(*nums)-1]
+		*nums = (*nums)[:len(*nums)-1]
+		switch (*ops)[l-1] {
+		case '*':
+			*num = n * (*num)
+		case '/':
+			*num = n / (*num)
+		}
+		*ops = (*ops)[:l-1]
+	}
+}
+