添加 problems

Author: halfrost

Algorithms/0017. Letter Combinations of a Phone Number/17. Letter Combinations of a Phone Number.go

@@ -0,0 +1,39 @@
+package leetcode
+
+var (
+	letterMap = []string{
+		" ",    //0
+		"",     //1
+		"abc",  //2
+		"def",  //3
+		"ghi",  //4
+		"jkl",  //5
+		"mno",  //6
+		"pqrs", //7
+		"tuv",  //8
+		"wxyz", //9
+	}
+	res = []string{}
+)
+
+func letterCombinations(digits string) []string {
+	if digits == "" {
+		return []string{}
+	}
+	res = []string{}
+	findCombination(&digits, 0, "")
+	return res
+}
+
+func findCombination(digits *string, index int, s string) {
+	if index == len(*digits) {
+		res = append(res, s)
+		return
+	}
+	num := (*digits)[index]
+	letter := letterMap[num-'0']
+	for i := 0; i < len(letter); i++ {
+		findCombination(digits, index+1, s+string(letter[i]))
+	}
+	return
+}

Algorithms/0017. Letter Combinations of a Phone Number/17. Letter Combinations of a Phone Number_test.go

@@ -0,0 +1,42 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question17 struct {
+	para17
+	ans17
+}
+
+// para 是参数
+// one 代表第一个参数
+type para17 struct {
+	s string
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans17 struct {
+	one []string
+}
+
+func Test_Problem17(t *testing.T) {
+
+	qs := []question17{
+
+		question17{
+			para17{"23"},
+			ans17{[]string{"ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"}},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 17------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans17, q.para17
+		fmt.Printf("【input】:%v       【output】:%v\n", p, letterCombinations(p.s))
+	}
+	fmt.Printf("\n\n\n")
+}

Algorithms/0017. Letter Combinations of a Phone Number/README.md

@@ -0,0 +1,30 @@
+# [17. Letter Combinations of a Phone Number](https://leetcode.com/problems/letter-combinations-of-a-phone-number/)
+
+
+## 题目:
+
+Given a string containing digits from `2-9` inclusive, return all possible letter combinations that the number could represent.
+
+A mapping of digit to letters (just like on the telephone buttons) is given below. Note that 1 does not map to any letters.
+
+![](http://upload.wikimedia.org/wikipedia/commons/thumb/7/73/Telephone-keypad2.svg/200px-Telephone-keypad2.svg.png)
+
+**Example:**
+
+```c
+Input: "23"
+Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
+```
+
+**Note:**
+
+Although the above answer is in lexicographical order, your answer could be in any order you want.
+
+## 题目大意
+
+给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
+
+
+## 解题思路
+
+- DFS 递归深搜即可

Algorithms/0022. Generate Parentheses/22. Generate Parentheses.go

@@ -0,0 +1,23 @@
+package leetcode
+
+func generateParenthesis(n int) []string {
+	if n == 0 {
+		return []string{}
+	}
+	res := []string{}
+	findGenerateParenthesis(n, n, "", &res)
+	return res
+}
+
+func findGenerateParenthesis(lindex, rindex int, str string, res *[]string) {
+	if lindex == 0 && rindex == 0 {
+		*res = append(*res, str)
+		return
+	}
+	if lindex > 0 {
+		findGenerateParenthesis(lindex-1, rindex, str+"(", res)
+	}
+	if rindex > 0 && lindex < rindex {
+		findGenerateParenthesis(lindex, rindex-1, str+")", res)
+	}
+}

Algorithms/0022. Generate Parentheses/22. Generate Parentheses_test.go

@@ -0,0 +1,49 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question22 struct {
+	para22
+	ans22
+}
+
+// para 是参数
+// one 代表第一个参数
+type para22 struct {
+	one int
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans22 struct {
+	one []string
+}
+
+func Test_Problem22(t *testing.T) {
+
+	qs := []question22{
+
+		question22{
+			para22{3},
+			ans22{[]string{
+				"((()))",
+				"(()())",
+				"(())()",
+				"()(())",
+				"()()()",
+			}},
+		},
+		// 如需多个测试，可以复制上方元素。
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 22------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans22, q.para22
+		fmt.Printf("【input】:%v       【output】:%v\n", p, generateParenthesis(p.one))
+	}
+	fmt.Printf("\n\n\n")
+}

Algorithms/0022. Generate Parentheses/README.md

@@ -0,0 +1,30 @@
+# [22. Generate Parentheses](https://leetcode.com/problems/generate-parentheses/)
+
+
+## 题目
+
+Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.
+
+For example, given n = 3, a solution set is:
+
+
+    [
+      "((()))",
+      "(()())",
+      "(())()",
+      "()(())",
+      "()()()"
+    ]
+
+
+## 题目大意
+
+给出 n 代表生成括号的对数，请你写出一个函数，使其能够生成所有可能的并且有效的括号组合。
+
+
+## 解题思路
+
+- 这道题乍一看需要判断括号是否匹配的问题，如果真的判断了，那时间复杂度就到 O(n * 2^n)了，虽然也可以 AC，但是时间复杂度巨高。
+- 这道题实际上不需要判断括号是否匹配的问题。因为在 DFS 回溯的过程中，会让 `(` 和 `)` 成对的匹配上的。
+
+

Algorithms/0036. Valid Sudoku/36. Valid Sudoku.go

@@ -0,0 +1,85 @@
+package leetcode
+
+import "strconv"
+
+// 解法一 暴力遍历，时间复杂度 O(n^3)
+func isValidSudoku(board [][]byte) bool {
+	// 判断行 row
+	for i := 0; i < 9; i++ {
+		tmp := [10]int{}
+		for j := 0; j < 9; j++ {
+			cellVal := board[i][j : j+1]
+			if string(cellVal) != "." {
+				index, _ := strconv.Atoi(string(cellVal))
+				if index > 9 || index < 1 {
+					return false
+				}
+				if tmp[index] == 1 {
+					return false
+				}
+				tmp[index] = 1
+			}
+		}
+	}
+	// 判断列 column
+	for i := 0; i < 9; i++ {
+		tmp := [10]int{}
+		for j := 0; j < 9; j++ {
+			cellVal := board[j][i]
+			if string(cellVal) != "." {
+				index, _ := strconv.Atoi(string(cellVal))
+				if index > 9 || index < 1 {
+					return false
+				}
+				if tmp[index] == 1 {
+					return false
+				}
+				tmp[index] = 1
+			}
+		}
+	}
+	// 判断 9宫格 3X3 cell
+	for i := 0; i < 3; i++ {
+		for j := 0; j < 3; j++ {
+			tmp := [10]int{}
+			for ii := i * 3; ii < i*3+3; ii++ {
+				for jj := j * 3; jj < j*3+3; jj++ {
+					cellVal := board[ii][jj]
+					if string(cellVal) != "." {
+						index, _ := strconv.Atoi(string(cellVal))
+						if tmp[index] == 1 {
+							return false
+						}
+						tmp[index] = 1
+					}
+				}
+			}
+		}
+	}
+	return true
+}
+
+// 解法二 添加缓存，时间复杂度 O(n^2)
+func isValidSudoku_(board [][]byte) bool {
+	rowbuf, colbuf, boxbuf := make([][]bool, 9), make([][]bool, 9), make([][]bool, 9)
+	for i := 0; i < 9; i++ {
+		rowbuf[i] = make([]bool, 9)
+		colbuf[i] = make([]bool, 9)
+		boxbuf[i] = make([]bool, 9)
+	}
+	// 遍历一次，添加缓存
+	for r := 0; r < 9; r++ {
+		for c := 0; c < 9; c++ {
+			if board[r][c] != '.' {
+				num := board[r][c] - '0' - byte(1)
+				if rowbuf[r][num] || colbuf[c][num] || boxbuf[r/3*3+c/3][num] {
+					return false
+				}
+				rowbuf[r][num] = true
+				colbuf[c][num] = true
+				boxbuf[r/3*3+c/3][num] = true // r,c 转换到box方格中
+			}
+		}
+	}
+	return true
+}

Algorithms/0036. Valid Sudoku/36. Valid Sudoku_test.go

@@ -0,0 +1,79 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question36 struct {
+	para36
+	ans36
+}
+
+// para 是参数
+// one 代表第一个参数
+type para36 struct {
+	s [][]byte
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans36 struct {
+	s bool
+}
+
+func Test_Problem36(t *testing.T) {
+
+	qs := []question36{
+
+		question36{
+			para36{[][]byte{
+				[]byte{'5', '3', '.', '.', '7', '.', '.', '.', '.'},
+				[]byte{'6', '.', '.', '1', '9', '5', '.', '.', '.'},
+				[]byte{'.', '9', '8', '.', '.', '.', '.', '6', '.'},
+				[]byte{'8', '.', '.', '.', '6', '.', '.', '.', '3'},
+				[]byte{'4', '.', '.', '8', '.', '3', '.', '.', '1'},
+				[]byte{'7', '.', '.', '.', '2', '.', '.', '.', '6'},
+				[]byte{'.', '6', '.', '.', '.', '.', '2', '8', '.'},
+				[]byte{'.', '.', '.', '4', '1', '9', '.', '.', '5'},
+				[]byte{'.', '.', '.', '.', '8', '.', '.', '7', '9'}}},
+			ans36{true},
+		},
+
+		question36{
+			para36{[][]byte{
+				[]byte{'8', '3', '.', '.', '7', '.', '.', '.', '.'},
+				[]byte{'6', '.', '.', '1', '9', '5', '.', '.', '.'},
+				[]byte{'.', '9', '8', '.', '.', '.', '.', '6', '.'},
+				[]byte{'8', '.', '.', '.', '6', '.', '.', '.', '3'},
+				[]byte{'4', '.', '.', '8', '.', '3', '.', '.', '1'},
+				[]byte{'7', '.', '.', '.', '2', '.', '.', '.', '6'},
+				[]byte{'.', '6', '.', '.', '.', '.', '2', '8', '.'},
+				[]byte{'.', '.', '.', '4', '1', '9', '.', '.', '5'},
+				[]byte{'.', '.', '.', '.', '8', '.', '.', '7', '9'}}},
+			ans36{false},
+		},
+
+		question36{
+			para36{[][]byte{
+				[]byte{'.', '8', '7', '6', '5', '4', '3', '2', '1'},
+				[]byte{'2', '.', '.', '.', '.', '.', '.', '.', '.'},
+				[]byte{'3', '.', '.', '.', '.', '.', '.', '.', '.'},
+				[]byte{'4', '.', '.', '.', '.', '.', '.', '.', '.'},
+				[]byte{'5', '.', '.', '.', '.', '.', '.', '.', '.'},
+				[]byte{'6', '.', '.', '.', '.', '.', '.', '.', '.'},
+				[]byte{'7', '.', '.', '.', '.', '.', '.', '.', '.'},
+				[]byte{'8', '.', '.', '.', '.', '.', '.', '.', '.'},
+				[]byte{'9', '.', '.', '.', '.', '.', '.', '.', '.'}}},
+			ans36{true},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 36------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans36, q.para36
+		fmt.Printf("【input】:%v       【output】:%v\n", p, isValidSudoku_(p.s))
+	}
+	fmt.Printf("\n\n\n")
+}