day 29 |● 1005.K次取反后最大化的数组和 ● 134. 加油站 ● 135. 分发糖果

1005.K次取反后最大化的数组和

先优先解决最大的负数，所以第一次排序。
如果没用完k，那么重新排序后反复迭代最小的那个数

func largestSumAfterKNegations(nums []int, k int) int {
    sort.Ints(nums)
    i := 0
    for i = 0; i < k && i < len(nums); i++{
        if nums[i] < 0{
            nums[i] *= -1
        }else{
            break
        }
    }

    sort.Ints(nums)
    if (k - i) % 2 != 0{
        nums[0] *= -1
    }

    sum :=0
    for i = 0; i < len(nums); i++{
        sum += nums[i]
    }
    return sum
}

134. 加油站

min和sum判定了是否能走完一个闭环或者无脑从0走完一个闭环
后面的就要判定是从哪能走完一个闭环
本来写了一个循环的函数来判定，但是函数超时了
所以就从头开始，不满足就下一个。

func canCompleteCircuit(gas []int, cost []int) int {
    cha := make([]int, len(gas))
    min := math.MaxInt64
    sum := 0
    for i := 0; i < len(gas); i++{
        cha[i] = gas[i] - cost[i]
        if min > cha[i]{
            min = cha[i]
        }
        sum += cha[i]
    }
    if min >= 0{return 0}
    if sum < 0{return -1    }
    /*
    var istrue func(int) bool
    istrue = func(index int) bool{
        sum := 0
        for i := 0; i < len(cha); i++{
            sum += cha[(i + index) % len(cha)]
            if sum < 0{
                return false
            }
        }
        return true
    }*/
    pos := 0
    tmpsum := -1
   
    for i := 0; i < len(gas); i++{
        tmpsum += cha[i]
        if tmpsum < 0{
            pos = (i + 1) % len(gas)
            tmpsum = 0
        }
    }
    return pos
}

135. 分发糖果

有点不是很理解，但是正反两遍遍历就可以确保满足规则了
第一遍正序，当大于，就比前面加一个
第二遍倒叙，当大于，就比后面加一个

func candy(ratings []int) int {
    ca := make([]int, len(ratings))
    ca[0] = 1
    for i := 1; i < len(ratings);i++{
        if ratings[i] > ratings[i - 1]{
            ca[i] = ca[i - 1] + 1
        }else{
            ca[i] = 1
        }
    }
    sum := 0
    for i := len(ratings) - 2; i >= 0; i--{
        if ratings[i] > ratings[i + 1] && ca[i] <= ca[i+1]{
            ca[i] = ca[i + 1] + 1
        }
        sum += ca[i]
    } 
    fmt.Print(ca)
    sum += ca[len(ratings) - 1]
    return sum
}