update

Author: ldeng7

000xxx/010.go

@@ -1,11 +1,25 @@
 func isMatch(s string, p string) bool {
-	ls, lp := len(s), len(p)
-	if 0 == lp {
-		return 0 == ls
+	m, n := len(s), len(p)
+	t := make([][]bool, m+1)
+	t[0] = make([]bool, n+1)
+	t[0][0] = true
+	for j := 2; j <= n; j++ {
+		if p[j-1] == '*' {
+			t[0][j] = t[0][j-2]
+		}
 	}
-	if lp > 1 && p[1] == '*' {
-		return isMatch(s, p[2:]) || (ls > 0 && (s[0] == p[0] || p[0] == '.') && isMatch(s[1:], p))
-	} else {
-		return ls > 0 && (s[0] == p[0] || p[0] == '.') && isMatch(s[1:], p[1:])
+	for i := 1; i <= m; i++ {
+		t[i] = make([]bool, n+1)
+		if 0 != n {
+			t[i][1] = t[i-1][0] && (s[i-1] == p[0] || p[0] == '.')
+		}
+		for j := 2; j <= n; j++ {
+			if p[j-1] == '*' {
+				t[i][j] = t[i][j-2] || ((s[i-1] == p[j-2] || p[j-2] == '.') && t[i-1][j])
+			} else {
+				t[i][j] = t[i-1][j-1] && (s[i-1] == p[j-1] || p[j-1] == '.')
+			}
+		}
 	}
+	return t[m][n]
 }

000xxx/011.go

@@ -1,21 +1,25 @@
+func min(a, b int) int {
+	if a <= b {
+		return a
+	}
+	return b
+}
+
 func maxArea(height []int) int {
-	out := 0
+	o := 0
 	i, j := 0, len(height)-1
 	for i != j {
-		h := height[i]
-		if h > height[j] {
-			h = height[j]
-		}
-		s := (j - i) * h
-		if s > out {
-			out = s
+		hi, hj := height[i], height[j]
+		s := (j - i) * min(hi, hj)
+		if s > o {
+			o = s
 		}
 
-		if height[i] > height[j] {
+		if hi > hj {
 			j--
 		} else {
 			i++
 		}
 	}
-	return out
+	return o
 }

000xxx/012.go

@@ -1,7 +1,8 @@
+var t = [4]string{"", "M", "MM", "MMM"}
+var h = [10]string{"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"}
+var d = [10]string{"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"}
+var u = [10]string{"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"}
+
 func intToRoman(num int) string {
-	t := []string{"", "M", "MM", "MMM"}
-	h := []string{"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"}
-	d := []string{"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"}
-	u := []string{"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"}
 	return t[num/1000] + h[(num%1000)/100] + d[(num%100)/10] + u[num%10]
 }

000xxx/013.go

@@ -1,12 +1,14 @@
+var m = map[byte]int{'M': 1000, 'D': 500, 'C': 100, 'L': 50, 'X': 10, 'V': 5, 'I': 1}
+
 func romanToInt(s string) int {
-	m := map[byte]int{'M': 1000, 'D': 500, 'C': 100, 'L': 50, 'X': 10, 'V': 5, 'I': 1}
-	n := 0
-	for i, c := range []byte(s) {
-		if i == len(s)-1 || m[c] >= m[s[i+1]] {
-			n += m[c]
+	o, l := 0, len(s)
+	for i := 0; i < l; i++ {
+		v := m[s[i]]
+		if i == l-1 || v >= m[s[i+1]] {
+			o += v
 		} else {
-			n -= m[c]
+			o -= v
 		}
 	}
-	return n
+	return o
 }

000xxx/016.go

@@ -1,28 +1,28 @@
-import "sort"
+import (
+	"math"
+	"sort"
+)
 
 func threeSumClosest(nums []int, target int) int {
+	o, l, d := 0, len(nums), math.MaxInt64
 	sort.Ints(nums)
-	var diff *int
-	out := 0
-
-	for i := 0; i < len(nums)-2; i++ {
-		j, k := i+1, len(nums)-1
+	for i := 0; i < l-2; i++ {
+		j, k := i+1, l-1
 		for j < k {
-			sum := nums[i] + nums[j] + nums[k]
-			d := sum - target
-			if d < 0 {
-				d = -d
+			s := nums[i] + nums[j] + nums[k]
+			d1 := s - target
+			if d1 < 0 {
+				d1 = -d1
 			}
-			if (nil != diff && d < *diff) || nil == diff {
-				diff = &d
-				out = sum
+			if d1 < d {
+				d, o = d1, s
 			}
-			if sum > target {
+			if s > target {
 				k--
 			} else {
 				j++
 			}
 		}
 	}
-	return out
+	return o
 }

000xxx/017.go

@@ -1,31 +1,24 @@
-var m = map[byte][]string{
-	'2': {"a", "b", "c"},
-	'3': {"d", "e", "f"},
-	'4': {"g", "h", "i"},
-	'5': {"j", "k", "l"},
-	'6': {"m", "n", "o"},
-	'7': {"p", "q", "r", "s"},
-	'8': {"t", "u", "v"},
-	'9': {"w", "x", "y", "z"},
+var m = [9][]string{{"a", "b", "c"}, {"d", "e", "f"}, {"g", "h", "i"}, {"j", "k", "l"},
+	{"m", "n", "o"}, {"p", "q", "r", "s"}, {"t", "u", "v"}, {"w", "x", "y", "z"},
 }
 
 func letterCombinations(digits string) []string {
-	ss := []string{}
+	o := []string{}
 	if 0 == len(digits) {
-		return ss
+		return o
 	}
-	bs := m[digits[0]]
+	bs := m[digits[0]-'2']
 	if 1 == len(digits) {
 		for _, b := range bs {
-			ss = append(ss, b)
+			o = append(o, b)
 		}
-		return ss
+		return o
 	}
 	subs := letterCombinations(digits[1:])
 	for _, b := range bs {
 		for _, s := range subs {
-			ss = append(ss, b+s)
+			o = append(o, b+s)
 		}
 	}
-	return ss
+	return o
 }

000xxx/018.go

@@ -1,36 +1,45 @@
 import "sort"
 
 func fourSum(nums []int, target int) [][]int {
+	o, l := [][]int{}, len(nums)
 	sort.Ints(nums)
-	out := [][]int{}
-	for i := 0; i < len(nums)-3; i++ {
-		for j := i + 1; j < len(nums)-2; j++ {
-			if j > i+1 && nums[j] == nums[j-1] {
+	for i := 0; i < l-3; i++ {
+		ni := nums[i]
+		if i != 0 && ni == nums[i-1] {
+			continue
+		}
+		if ni+nums[i+1]+nums[i+2]+nums[i+3] > target {
+			break
+		}
+		if ni+nums[l-1]+nums[l-2]+nums[l-2] < target {
+			continue
+		}
+		for j := i + 1; j < l-2; j++ {
+			nj := nums[j]
+			if j != i+1 && nj == nums[j-1] {
 				continue
 			}
-			k, l := j+1, len(nums)-1
-			for k < l {
-				s := nums[i] + nums[j] + nums[k] + nums[l]
-				if s == target {
-					ok := true
-					for _, o := range out {
-						if o[0] == nums[i] && o[1] == nums[j] && o[2] == nums[k] && o[3] == nums[l] {
-							ok = false
-							break
-						}
-					}
-					if ok {
-						out = append(out, []int{nums[i], nums[j], nums[k], nums[l]})
+			if ni+nj+nums[j+1]+nums[j+2] > target {
+				break
+			}
+			if ni+nj+nums[l-1]+nums[l-2] < target {
+				continue
+			}
+			b, e := j+1, l-1
+			for b < e {
+				t := ni + nj + nums[b] + nums[e]
+				if t == target {
+					o, b = append(o, []int{ni, nj, nums[b], nums[e]}), b+1
+					for b < e && nums[b] == nums[b-1] {
+						b++
 					}
-					k++
-					l--
-				} else if s < target {
-					k++
+				} else if t > target {
+					e--
 				} else {
-					l--
+					b++
 				}
 			}
 		}
 	}
-	return out
+	return o
 }

000xxx/019.go

@@ -4,14 +4,15 @@ func removeNthFromEnd(head *ListNode, n int) *ListNode {
 		nodes = append(nodes, head)
 		head = head.Next
 	}
-	if len(nodes) <= 1 {
+	l := len(nodes)
+	if l <= 1 {
 		return nil
 	}
 	if 1 == n {
-		nodes[len(nodes)-2].Next = nil
+		nodes[l-2].Next = nil
 		return nodes[0]
-	} else if n < len(nodes) {
-		nodes[len(nodes)-n-1].Next = nodes[len(nodes)-n+1]
+	} else if n < l {
+		nodes[l-n-1].Next = nodes[l-n+1]
 		return nodes[0]
 	}
 	return nodes[1]

000xxx/022.go

@@ -1,17 +1,20 @@
 func generateParenthesis(n int) []string {
-	strs := []string{}
-	var gen func(int, int, int, string)
-	gen = func(a, b, n int, s string) {
+	o, bs := []string{}, []byte{}
+	var cal func(int, int)
+	cal = func(a, b int) {
 		if a == n && b == n {
-			strs = append(strs, s)
+			o = append(o, string(bs))
 			return
 		}
 		if b > a || b > n || a > n {
 			return
 		}
-		gen(a+1, b, n, s+"(")
-		gen(a, b+1, n, s+")")
+		bs = append(bs, '(')
+		cal(a+1, b)
+		bs[len(bs)-1] = ')'
+		cal(a, b+1)
+		bs = bs[:len(bs)-1]
 	}
-	gen(0, 0, n, "")
-	return strs
+	cal(0, 0)
+	return o
 }

000xxx/023.go

@@ -1,33 +1,31 @@
-func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
-	h := &ListNode{}
-	l := h
-	for nil != l1 && nil != l2 {
-		if l1.Val <= l2.Val {
-			l.Next = l1
-			l1 = l1.Next
+func merge2Lists(l1, l2 *ListNode) *ListNode {
+	n := &ListNode{}
+	h := n
+	for l1 != nil && l2 != nil {
+		if l1.Val < l2.Val {
+			l1, n.Next = l1.Next, l1
 		} else {
-			l.Next = l2
-			l2 = l2.Next
+			n.Next = l2
+			l1, l2 = n.Next.Next, l1
 		}
-		l = l.Next
+		n = n.Next
 	}
 	if l1 != nil {
-		l.Next = l1
-	} else {
-		l.Next = l2
+		n.Next = l1
+	}
+	if l2 != nil {
+		n.Next = l2
 	}
 	return h.Next
 }
 
 func mergeKLists(lists []*ListNode) *ListNode {
-	if 0 == len(lists) {
+	l := len(lists)
+	if l == 0 {
 		return nil
-	} else if 1 == len(lists) {
+	} else if l == 1 {
 		return lists[0]
 	}
-	h := lists[0]
-	for _, l := range lists[1:] {
-		h = mergeTwoLists(h, l)
-	}
-	return h
+	m := l >> 1
+	return merge2Lists(mergeKLists(lists[:m]), mergeKLists(lists[m:]))
 }