update

hard/126.go

@@ -1,9 +1,108 @@
 package main
 
-func findLadders(beginWord string, endWord string, wordList []string) [][]string {
-	return [][]string{}
+import (
+	"fmt"
+)
+
+func findLadders(beginWord string, endWord string, wordList []string) (ladders [][]string) {
+	endIdx, listLen := -1, len(wordList)
+	for i := 0; i < listLen; i++ {
+		if endWord == wordList[i] {
+			endIdx = i
+			break
+		}
+	}
+	if endIdx == -1 {
+		return
+	} // Find end word in word list, if not found, return false
+	adj := make([][]int, listLen)
+	for i := 0; i < listLen; i++ {
+		adj[i] = make([]int, 0)
+		for j := i + 1; j < listLen; j++ {
+			if isConvertible(wordList[i], wordList[j]) {
+				adj[i] = append(adj[i], j)
+				adj[j] = append(adj[j], i)
+			}
+		}
+	} // Create adj matrix
+	fmt.Println(adj)
+	visited := make([]bool, listLen)
+	closest := make([]int, 0)
+	distance := make([]int, listLen) // Distance from begin to word i
+	prev := make([][]int, listLen)   // List of prev point
+	for i := 0; i < listLen; i++ {
+		prev[i] = make([]int, 0)
+		if isConvertible(beginWord, wordList[i]) {
+			visited[i] = true
+			prev[i] = append(prev[i], -1) // -1 means begin word
+			closest = append(closest, i)
+			distance[i] = 1
+		}
+	} // Init closest array
+	for distance[endIdx] == 0 && len(closest) != 0 {
+		newClosest := make([]int, 0)
+		for _, c := range closest {
+			for _, i := range adj[c] {
+				if !visited[i] {
+					if distance[i] == 0 {
+						distance[i] = distance[c] + 1
+						newClosest = append(newClosest, i)
+					}
+					prev[i] = append(prev[i], c)
+				}
+			}
+		}
+		for i := range newClosest {
+			visited[newClosest[i]] = true
+		}
+		closest = newClosest
+	}
+	fmt.Println(prev)
+	var getLadders func(int, []string)
+	getLadders = func(idx int, ladder []string) {
+		newLadder := make([]string, len(ladder))
+		copy(newLadder, ladder)
+		if idx == -1 {
+			newLadder = append(newLadder, beginWord)
+			for beg, end := 0, len(newLadder)-1; beg < end; beg, end = beg+1, end-1 {
+				newLadder[beg], newLadder[end] = newLadder[end], newLadder[beg]
+			}
+			ladders = append(ladders, newLadder)
+			return
+		}
+		newLadder = append(newLadder, wordList[idx])
+		for i := range prev[idx] {
+			getLadders(prev[idx][i], newLadder)
+		}
+	}
+	getLadders(endIdx, []string{})
+	return
 }
 
-func main() {
+func isConvertible(a, b string) bool {
+	diff := 0
+	for i := range a {
+		if a[i] != b[i] {
+			diff++
+		}
+		if diff > 1 {
+			return false
+		}
+	}
+	return diff == 1
+}
 
+func main() {
+	fmt.Println(findLadders(
+		"hit",
+		"cog",
+		[]string{"hot", "dot", "dog", "lot", "log", "cog"}))
+	fmt.Println(findLadders(
+		"hit",
+		"cog",
+		[]string{"hot", "dot", "dog", "lot", "log"}))
+	fmt.Println(findLadders(
+		"hot",
+		"dog",
+		[]string{"hot", "dog", "dot"}))
 }

hard/65.go

@@ -3,7 +3,7 @@ package main
 func isNumber(s string) bool {
 	// Indices of number begin, dot, exp, number end (not included)
 	begIdx, dotIdx, expIdx, endIdx := -1, -1, -1, -1
-	// Has significant digit, has exp digit, last one is digit
+	// Has significant digit, has exp digit, previous one is digit
 	sigDigit, expDigit, lDigit := false, true, false
 	for i := range s {
 		switch s[i] {

hard/97.go

@@ -21,7 +21,7 @@ func isInterleaveSlow(s1 string, s2 string, s3 string) bool {
 			if len(st) == 0 {
 				return false
 			}
-			t := st.Pop()
+			t := st.Pop().(int)
 			i[t]--
 			i[2], j = i[2]-1, t+1
 		}

hard/pairstack.go

@@ -0,0 +1,47 @@
+package main
+
+// Pair ...
+type Pair struct {
+	_1 int
+	_2 int
+}
+
+// Equals ...
+func (p1 Pair) Equals(p2 Pair) bool {
+	return p1._1 == p2._1 && p1._2 == p2._2
+}
+
+// PairStack ...
+type PairStack []Pair
+
+// Len ...
+func (ps PairStack) Len() int { return len(ps) }
+func (ps PairStack) Less(i, j int) bool {
+	if ps[i]._1 == ps[j]._1 {
+		return ps[i]._2 < ps[j]._2
+	}
+	return ps[i]._1 < ps[j]._1
+}
+func (ps PairStack) Swap(i, j int) { ps[i], ps[j] = ps[j], ps[i] }
+
+// Top ...
+func (ps PairStack) Top() Pair {
+	return ps[len(ps)-1]
+}
+
+// Empty ...
+func (ps PairStack) Empty() bool {
+	return len(ps) == 0
+}
+
+// Push ...
+func (ps *PairStack) Push(p interface{}) {
+	*ps = append(*ps, p.(Pair))
+}
+
+// Pop ...
+func (ps *PairStack) Pop() interface{} {
+	x := (*ps)[len(*ps)-1]
+	*ps = (*ps)[:len(*ps)-1]
+	return x
+}

hard/stack.go

@@ -3,6 +3,10 @@ package main
 // Stack ...
 type Stack []int
 
+func (s Stack) Len() int           { return len(s) }
+func (s Stack) Less(i, j int) bool { return s[i] < s[j] }
+func (s Stack) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
 // Top ...
 func (s Stack) Top() int {
 	return s[len(s)-1]
@@ -14,12 +18,12 @@ func (s Stack) Empty() bool {
 }
 
 // Push ...
-func (s *Stack) Push(val int) {
-	*s = append(*s, val)
+func (s *Stack) Push(val interface{}) {
+	*s = append(*s, val.(int))
 }
 
 // Pop ...
-func (s *Stack) Pop() int {
+func (s *Stack) Pop() interface{} {
 	top := s.Top()
 	*s = (*s)[:len(*s)-1]
 	return top
@@ -28,6 +32,10 @@ func (s *Stack) Pop() int {
 // Stack64 ...
 type Stack64 []int64
 
+func (s Stack64) Len() int           { return len(s) }
+func (s Stack64) Less(i, j int) bool { return s[i] < s[j] }
+func (s Stack64) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
 // Top ...
 func (s Stack64) Top() int64 {
 	return s[len(s)-1]
@@ -39,12 +47,12 @@ func (s Stack64) Empty() bool {
 }
 
 // Push ...
-func (s *Stack64) Push(val int64) {
-	*s = append(*s, val)
+func (s *Stack64) Push(val interface{}) {
+	*s = append(*s, val.(int64))
 }
 
 // Pop ...
-func (s *Stack64) Pop() int64 {
+func (s *Stack64) Pop() interface{} {
 	top := s.Top()
 	*s = (*s)[:len(*s)-1]
 	return top