Go语言解leetcode(三)

0. 简介

最近在学Go语言，但是没怎么练习，因此在leetcode上用Go语言刷算法题巩固一下Go基础。

1. 组合总和：39. 组合总和 - 力扣（LeetCode） (leetcode-cn.com)

解题思路：采用递归回溯的思想，因为可以一个元素重复用多次，因此每次搜索解决方案都是从当前索引出发，不再搜索前面索引的元素(因为在之前已经搜索过了)。

需要注意的点是，由于Go语言底层的影响，这里我是额外写了一个函数来实现递归调用的，也是该程序的主体部分。其中，函数名为：

func find(candidates []int,target int,ans *[][]int,temp []int,index int)

candidates为无重复元素数组，target为目标值，ans为最终返回数组，temp为临时存储数组，index为索引位置。有一个很奇怪的地方是，一开始ans我用的是值，但是递归调用过程中的更改并没有起到作用，但是temp在递归调用过程中的更改确实真实生效的，还需要仔细研究一下原理。

这里在往ans中添加元素时，需要使用temp的副本，防止后面更改生效，使用copy()方法。

func combinationSum(candidates []int, target int) [][]int {
    if len(candidates)==0{
        return [][]int{}
    }
    ans := make([][]int,0)
    temp := make([]int,0)
    sort.Ints(candidates)
    find(candidates,target,&ans,temp,0)
    return ans
}

func find(candidates []int,target int,ans *[][]int,temp []int,index int){
    if(target==0){
        t := make([]int,len(temp))
        copy(t,temp)
        *ans = append(*ans,t)
        return
    }
    for i:=index;i<len(candidates);i++{
        if(candidates[i]<=target){
            temp = append(temp,candidates[i])
            find(candidates,target-candidates[i],ans,temp,i)
            temp = temp[0:len(temp)-1]
        }else{
            break
        }
    }
}

2. 组合总和II：40. 组合总和 II - 力扣（LeetCode） (leetcode-cn.com)

解题思路：思路与上一题几乎一致，这里不允许一个元素使用多次，但允许使用多个相同的元素。通过每次递归的时候索引参数自增即可解决问题。其次，需要考虑一个问题，即像1，2，2，2，5（5）这样的数组，如何解决重复答案的问题，即索引0，1，2组合为正解，索引0，1，3组合也为正解，但不能同时存在两个一样的答案。这里使用了多做了一步判断处理：

if(i-1>=index&&candidates[i]==candidates[i-1]){
    continue
}

func combinationSum2(candidates []int, target int) [][]int {

    sort.Ints(candidates)
    ans := make([][]int,0)
    temp := make([]int,0)
    find(candidates,target,&ans,temp,0)
    return ans

}

func find(candidates []int,target int,ans *[][]int,temp []int,index int){
    if(target==0){
        t := make([]int,len(temp))
        copy(t,temp)
        *ans = append(*ans,t)
        return
    }
    for i:=index;i<len(candidates);i++{
        if(i-1>=index&&candidates[i]==candidates[i-1]){
            continue
        }
        if(candidates[i]<=target){
            temp = append(temp,candidates[i])
            find(candidates,target-candidates[i],ans,temp,i+1)
            temp = temp[0:len(temp)-1]
        }else{
            break
        }
    }
}

3. 缺失的第一个正数：41. 缺失的第一个正数 - 力扣（LeetCode） (leetcode-cn.com)

解题思路：假设数组的长度为4，且1，2，3，4都在数组中，那么数组中的元素可以被复原为1，2，3，4的顺序。同理，在-1，2，3，4的情况下，我们可以一次遍历调整顺序，第二次遍历搜索是否当前索引元素的值为当前索引+1，如果不是则为缺失的第一个正数。

需要注意的一个点是，一开始我写的代码只判断了一次，即交换了一次，但是在0，5，4，1，2，8这种情况下，遍历到4我们交换位置，序列变为0，5，1，4，2，8，但1并不在正确的位置上，且后面不会被交换到正确的位置上，因此这里需要使用for循环做多次判断，同时需要设置合理的循环退出条件。

func firstMissingPositive(nums []int) int {
    for i:=1;i<len(nums);i++{
        for;(nums[i]>0&&nums[i]<len(nums));{
            if(nums[i]==nums[nums[i]-1]){
                break
            }
            nums[i],nums[nums[i]-1]=nums[nums[i]-1],nums[i]
        }
    }
    var index int
    for ;index<len(nums);index++{
        if(index+1!=nums[index]){
            return index+1
        }
    }
    return index+1
}

4. 接雨水：42. 接雨水 - 力扣（LeetCode） (leetcode-cn.com)

解题思路：设置两个数组，分别为从左往右，从右往左遍历元素数组，过程中的最大值，如数组1，4，2，则两个相应的数组分别为1，4，4和2，4，4，这里分别命名为left，right。从左/右遍历元素数组，对应索引上left和right较小的值，减去当前元素数组索引上的值，即为目标结果。

func trap(height []int) int {
    lens := len(height)
    left := make([]int,lens)
    right := make([]int,lens)
    for index:=0;index<lens;index++{
        if index==0{
            left[index]=height[index]
            right[lens-index-1] = height[lens-index-1]
            continue
        }
        if height[index]>left[index-1]{
            left[index]=height[index]
        }else{
            left[index]=left[index-1]
        }
        if height[lens-index-1]>right[lens-index]{
            right[lens-1-index]=height[lens-index-1]
        }else{
            right[lens-1-index]=right[lens-index]
        }
    }
    ans := min(left,right)
    var num int
    for index:=0;index<lens;index++{
        num = num - height[index] + ans[index]
    }
    return num
}

func min(left,right []int) []int{
    ans := make([]int,len(left))
    for index:=0;index<len(left);index++{
        if(left[index]<right[index]){
            ans[index]=left[index]
        }else{
            ans[index]=right[index]
        }
    }
    return ans
}

5. 字符串相乘：43. 字符串相乘 - 力扣（LeetCode） (leetcode-cn.com)

解题思路：举例"123"和"456"相乘，这里我们给数字的每个位置(个位，十位，百位……)都标上索引，如"123"中，分别0对应1，1对应2，2对应3；"456"中，分别0对应4，1对应5，6对应6。我们在建立一个切片，大小为3+3-1=5(因为123和456的位数都为3)，0索引对应"123"和"456"中索引相加为0的项相乘的结果，1索引对应"123"和"456"中索引相加为1的项相乘的结果(2*4,1*5)，依此类推，即该切片存储的是各位置上(个位，十位，百位……)未加上进位的结果。然后再对该切片做进位处理最后拼接成字符串返回即可。

数字转换为字符串的方法：

str := strconv.Itoa(int)

func multiply(num1 string, num2 string) string {
    if(num1=="0"||num2=="0"){
        return "0"
    }
    nums := make([]int,len(num1)+len(num2)-1)
    for i:=0;i<len(num1);i++{
        var a int
        a=int(num1[i]-'0')
        for j:=0;j<len(num2);j++{
            var b int
            b=int(num2[j]-'0')
            nums[i+j]=nums[i+j]+a*b
        }
    }
    var c int
    for index:=len(nums)-1;index>=0;index--{
        nums[index]=nums[index]+c
        if(index==0){
            break
        }
        c,nums[index]=nums[index]/10,nums[index]%10
    }
    var str string
    for index:=0;index<len(nums);index++{
        str = str+strconv.Itoa(nums[index])
    }
    return str
}