day 23 | ● 39. 组合总和 ● 40.组合总和II ● 131.分割回文串

39. 组合总和

不要求是否可以重复，本来以为是不需要记录index，每一次都是从零开始。发现还是需要记录，但是记录的是本身，但是不是下一个了就是。
记录本身是可以下一次继续用本身，如果是每次回滚到0的话就重复了，比如一个12345数组，112和121就是重复的。

func combinationSum(candidates []int, target int) [][]int {
    ret := make([][]int, 0)
    path := make([]int, 0)
    sort.Ints(candidates)
    var combinue func(int, int)
    combinue = func(sum , index int){
        if sum > target{
            return
        }
        if sum == target{
            tmp := make([]int, len(path))
            copy(tmp, path)
            ret = append(ret, tmp)
            return
        }

        for i := index; i < len(candidates); i++{
            sum += candidates[i]
            path = append(path, candidates[i])
            combinue(sum, i)
            sum -= candidates[i]
            path = path[: (len(path) - 1)]
        }
    }

    combinue(0, 0)
    return ret
}

40.组合总和II

这个是要求去重，也就是去除同一树层中使用过的

func combinationSum2(candidates []int, target int) [][]int {
    
    sort.Ints(candidates)
   
    /*
    used := make([]bool, len(candidates))
    for i := 0; i < len(candidates); i++{
        used[i] = false
    }*/
    path := make([]int, 0)
    ret := make([][]int, 0)
    var combinue func(int, int)

    combinue = func(sum, index int){
        if sum > target{
            return 
        }
        if sum == target{
            ret = append(ret, append([]int(nil), path...))
            return
        }

        for i := index; i < len(candidates); i++{
            //if i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false {continue}
            if i != index && candidates[i] == candidates[i - 1]{ continue }
            path = append(path, candidates[i])
            sum += candidates[i]
            //used[i] = true
            combinue(sum, i + 1)
            path = path[:(len(path) - 1)]
            sum -= candidates[i]
            //used[i] = false
        }
    }
    combinue(0, 0)
    return ret

}

131.分割回文串

回溯里面比较简单的一种，判定是回文就将其添加进去，然后继续下一个

func partition(s string) [][]string {
    ret := make([][]string, 0)
    path := make([]string, 0)
    var build func(int)
    build = func(index int){
        if index == len(s){
            ret = append(ret, append([]string(nil), path...))
            return
        }
        for i := index; i < len(s); i++{
            str := s[index : (i + 1)]
            if istrue(str){
                path = append(path, str)
                build(i + 1)
                path = path[:(len(path) - 1)]
            }
        }
    }
    build(0)
    return ret
}

func istrue(s string) bool{
    left := 0
    right := len(s) - 1
    for left < right{
        if s[left] != s[right]{
            return false
        }
        left++
        right--
    }
    return true
}