算法训练 Day 25

LeetCode 216. 组合总和 III

题目链接：216. 组合总和 III

思路：正常的回溯思路，传参中唯一需要考虑的是每次开始递归时的初始值start，因为每个数字最多使用一次，所以在递归的时候需要在i的基础上+1。

Python版本：

class Solution:
    def combinationSum3(self, k: int, n: int) -> List[List[int]]:
        def backt(path, start):
            if sum(path) > n:
                return

            if len(path)==k:
                if sum(path)==n:
                    res.append(path[:])
                return

            for i in range(start, 10):
                path.append(i)
                backt(path, i+1)
                path.pop()

        res = []
        backt([], 1)
        return res

go版本：

var res [][]int

func combinationSum3(k int, n int) [][]int {
    res = [][]int{}
    backtracking([]int{}, 1, k, n)
    return res
}

func backtracking(path []int, start, k, n int) {
    if sum(path) > n {
        return
    }

    if len(path)==k {
        if sum(path)==n {
            tmp := make([]int, k)
            copy(tmp, path)
            res = append(res, tmp)
        }
        return
    }

    for i:=start; i<=9; i++ {
        path = append(path, i)
        backtracking(path, i+1, k, n)
        path = path[:len(path)-1]
    }
}

func sum(nums []int) int {
    sum_ := 0
    for i := range nums {
        sum_ += nums[i]
    }
    return sum_
}

LeetCode 17. 电话号码的字母组合

题目链接：17. 电话号码的字母组合

思路：需要先建立一个哈希表，以便快速的遍历各个数字对应的字母。回溯过程中最重要的一个参数就是每次回溯的起始值，本题的起始值含义与上一题完全不同，上一题的起始值是从1至9往后遍历的元素，本题的初始值是digits遍历到了第几个元素。

Python版本：

class Solution:
    def letterCombinations(self, digits: str) -> List[str]:
        if len(digits)==0:
            return []

        phoneMap = {
            "2": "abc",
            "3": "def",
            "4": "ghi",
            "5": "jkl",
            "6": "mno",
            "7": "pqrs",
            "8": "tuv",
            "9": "wxyz",
        }
        
        def backtracking(index):
            if index==len(digits):
                res.append(''.join(path))
                return
            number = digits[index]
            for single_num in phoneMap[number]:
                path.append(single_num)
                backtracking(index+1)
                path.pop()            
                    
        path = []
        res = []
        backtracking(0)
        
        return res

go版本：

var res []string
var phoneMap map[string]string = map[string]string{
    "2": "abc",
    "3": "def",
    "4": "ghi",
    "5": "jkl",
    "6": "mno",
    "7": "pqrs",
    "8": "tuv",
    "9": "wxyz",
}

func letterCombinations(digits string) []string {
    if len(digits) == 0 {
        return []string{}
    }
    res = []string{}
    backtrack("", 0, digits)
    return res

}

func backtrack(path string, index int, digits string) {
    if index==len(digits) {
        // tmp := make([]string, index)
        // copy(tmp, path)
        res = append(res, path)
        return
    }
    nums := string(digits[index])
    letters := phoneMap[nums]
    for i := 0; i < len(letters); i++ {
        backtrack(path + string(letters[i]), index+1, digits)
    }
}