Golang — Leetcode. 1005-1008

最新推荐文章于 2022-12-16 18:18:50 发布

Lazyboy_Chen7

最新推荐文章于 2022-12-16 18:18:50 发布

阅读量267

点赞数

分类专栏： Leetcode 文章标签： Leetcode golang Go

本文链接：https://blog.csdn.net/lazyboy_/article/details/88566670

版权

Leetcode 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Leetcode. 1005 Maximize Sum Of Array After K Negations

这道题看起来写的很乱，，，实际就是很乱。思路很简单，首先排序，负数个数大于K就翻转K个再累和，结束；K大于负数个数就先把所有负数转为整数后找最小的正数翻转（K-负数个数）次。注意边界问题。
func largestSumAfterKNegations(A []int, K int) int {
    sort.Ints(A)
    sum := 0
    i := 0
    for ;K>0; {
        if A[i] < 0 {
            A[i] = -A[i]
        } else if A[i] == 0 {
            break
        }else {
            if K%2 == 0 {
                break
            }
            if i == 0 {
                A[i] = -A[i]
                break
            }
            if(A[i] < A[i-1]) {
                A[i] = -A[i]
            } else {
                A[i-1] = -A[i-1]
            }
            break;
        }
        K--
        i++
    }
    for _,a := range A {
        sum += a
    }
    return sum
}

Leetcode. 1006 Clumsy Factorial

这个题enmm，挺没意思的。如果不找规律纯做可以用栈。

func clumsy(N int) int {
    if N <= 2 {
        return N
    }
    if N <= 4 {
        return N + 3
    }
    if (N - 4) % 4 == 0 {
        return N + 1
    } else if (N - 4) % 4 <= 2 {
        return N + 2
    } else {
        return N - 1
    }
}

Leetcode. 1007 Minimum Domino Rotations For Equal Row

第一点，找最大众数，且不能小于切片长度；

第二点，这个众数必须在每个索引都出现；

第三点，看哪个切片的众数少，就要旋转该切片众数的个数次。

func minDominoRotations(A []int, B []int) int {
    m := make(map[int]int)
    for _,a := range A {
        m[a]++
    }
    for _,b := range B {
        m[b]++
    }
    maxv, index := 0, 0
    for k,v := range m {
        if v > maxv {
            maxv = v
            index = k
        }
    }
    if maxv<len(A) {
        return -1
    }
    ca, cb := 0, 0
    for i:= 0;i<len(A);i++ {
        if A[i] != index && B[i] != index {
            return -1
        }
        if A[i] == index && B[i] == index {
            continue
        }
        if A[i] != index {
            ca++
        } else {
            cb++
        }
    }
    if ca > cb {
        return cb
    }
    return ca
}

Leetcode. 1008 Construct Binary Search Tree from Preorder Traversal

很简单一道题，根据先序遍历恢复一棵二叉搜索树，使用的递归。
func bstFromPreorder(preorder []int) *TreeNode {
    if len(preorder) < 1 {
		return nil
	}
	node := new(TreeNode)
	node.Val = preorder[0]
	l := 1
	for l < len(preorder) && preorder[l] < node.Val {
		l++
	}
	node.Left = bstFromPreorder(preorder[1:l])
	node.Right = bstFromPreorder(preorder[l:])
	return node
}

最近这周的四道题很简单，基本一眼就看出怎么做能做出来，具体有没有更好的办法还没有细想，暂时四道题都是双100%，不过应该有更好的方法。

记录每天解决的一点小问题，积累起来就能解决大问题。