[Leetcode Weekly Contest]196

Posted Jamest

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了[Leetcode Weekly Contest]196相关的知识,希望对你有一定的参考价值。

链接:LeetCode

[Leetcode]5452. 判断能否形成等差数列

给你一个数字数组 arr 。如果一个数列中,任意相邻两项的差总等于同一个常数,那么这个数列就称为 等差数列 。
如果可以重新排列数组形成等差数列,请返回 true ;否则,返回 false 。

排序后暴力即可。

class Solution:
    def canMakeArithmeticProgression(self, arr: List[int]) -> bool:
        arr.sort()
        diff = arr[1]-arr[0]
        for i in range(2,len(arr)):
            if arr[i]-arr[i-1]!=diff:
                return False
        return True

[Leetcode]5453. 所有蚂蚁掉下来前的最后一刻

有一块木板,长度为 n 个 单位 。一些蚂蚁在木板上移动,每只蚂蚁都以 每秒一个单位 的速度移动。其中,一部分蚂蚁向 左 移动,其他蚂蚁向 右 移动。
当两只向 不同 方向移动的蚂蚁在某个点相遇时,它们会同时改变移动方向并继续移动。假设更改方向不会花费任何额外时间。
而当蚂蚁在某一时刻 t 到达木板的一端时,它立即从木板上掉下来。
给你一个整数 n 和两个整数数组 left 以及 right 。两个数组分别标识向左或者向右移动的蚂蚁在 t = 0 时的位置。请你返回最后一只蚂蚁从木板上掉下来的时刻。

两只蚂蚁碰面后不会改变任何数组,找最后到达的蚂蚁即可。

class Solution:
    def getLastMoment(self, n: int, left: List[int], right: List[int]) -> int:
        rightmin = min(right) if right else n
        leftmax = max(left) if left else 0
        return max(n-rightmin,leftmax)

[Leetcode]5454. 统计全 1 子矩形

给你一个只包含 0 和 1 的 rows * columns 矩阵 mat ,请你返回有多少个 子矩形 的元素全部都是 1 。

与统计正方形个数的题目类似,我们循环每一行,计算该行作为首行的前提下,有多少个子矩形。

class Solution:
    def numSubmat(self, mat: List[List[int]]) -> int:
        n,m = len(mat),len(mat[0])
        res = 0
        for i in range(n):
            tmp = mat[i]
            for j in range(i,n):
                tmp = [x&y for x,y in zip(tmp,mat[j])]
                res += self.get1(tmp)
        return res

    def get1(self,nums):
        res = 0
        result = 0
        for i in range(len(nums)):
            if nums[i] == 0:
                result = 0
            else:
                result += 1
                res += result
        return  res

[Leetcode]5455. 最多 K 次交换相邻数位后得到的最小整数

给你一个字符串?num 和一个整数?k 。其中,num 表示一个很大的整数,字符串中的每个字符依次对应整数上的各个 数位 。
你可以交换这个整数相邻数位的数字 最多?k?次。
请你返回你能得到的最小整数,并以字符串形式返回。

可以从最简单易行的暴力法开始优化。暴力法在每一次置换的时候查找满足条件间距小于k且比当前值小的最小值,时间复杂度(O(N^2))如下所示:

class Solution:
    def minInteger(self, num: str, k: int) -> str:
        num = list(num)
        sorted_num = sorted(num)
        if num == sorted_num or len(num) ** 2 < k:
            return ‘‘.join(sorted_num)
        for i in range(len(num)):
            if num[i]!=sorted_num[i] and k:
                min_num = num[i]
                min_ind = i
                for j in range(i+1,min(len(num),i+k+1)):
                    if num[j] < min_num:
                        min_ind=j
                        min_num = num[j]
                k -= (min_ind-i)
                num = num[:i]+[num[min_ind]]+num[i:min_ind]+num[min_ind+1:]
        return ‘‘.join(num)

一种高效的代替方法是做预处理:记录下所有的0-9的位置然后用这些预处理的位置来进行查找,好处是每次查找时不需要重头开始遍历。
在每一次置换的过程中,需要将置换的数左侧ind+1,右侧保持不变, 由于需要对区间递增,可以采用线段树的方法简化复杂度(O(Nlog(N)))

import collections
class Solution:
    def minInteger(self, num: str, k: int) -> str:
        numIndex = collections.defaultdict(list)
        N = len(num)
        for i in range(N):
            numIndex[int(num[i])].append(i)
        segemnt_nums = NumArray([0 for _ in range(N)])
        res = ‘‘
        for i in range(N):
            for n in range(10):
                if not numIndex[n]:continue
                min_ind = numIndex[n][0]
                new_ind = segemnt_nums.sumRange(min_ind+1,N-1)+min_ind
                if new_ind-i > k:
                    continue
                k -= (new_ind-i)
                numIndex[n].pop(0)
                segemnt_nums.add(min_ind,1)
                res += str(n)
                break
        return res

#Segment tree node
class Node(object):
    def __init__(self, start, end):
        self.start = start
        self.end = end
        self.total = 0
        self.left = None
        self.right = None


class NumArray(object):
    def __init__(self, nums):
        def createTree(nums, l, r):
            if l > r:
                return None
            if l == r:
                n = Node(l, r)
                n.total = nums[l]
                return n
            mid = (l + r) // 2
            root = Node(l, r)
            root.left = createTree(nums, l, mid)
            root.right = createTree(nums, mid+1, r)

            root.total = root.left.total + root.right.total
            return root
        self.root = createTree(nums, 0, len(nums)-1)

    def add(self, i, val):
        def addVal(root, i, val):
            if root.start == root.end:
                root.total += val
                return root.total

            mid = (root.start + root.end) // 2
            if i <= mid:
                addVal(root.left, i, val)
            else:
                addVal(root.right, i, val)
            root.total = root.left.total + root.right.total
            return root.total
        return addVal(self.root, i, val)

    def sumRange(self, i, j):
        if i>j:return 0
        def rangeSum(root, i, j):
            if root.start == i and root.end == j:
                return root.total

            mid = (root.start + root.end) // 2
            if j <= mid:
                return rangeSum(root.left, i, j)
            elif i >= mid + 1:
                return rangeSum(root.right, i, j)
            else:
                return rangeSum(root.left, i, mid) + rangeSum(root.right, mid+1, j)
        return rangeSum(self.root, i, j)

参考:
Leetcode









以上是关于[Leetcode Weekly Contest]196的主要内容,如果未能解决你的问题,请参考以下文章

LeetCode(Weekly Contest 183)题解

LeetCode(Weekly Contest 187)题解

LeetCode笔记:Weekly Contest 297

LeetCode笔记:Weekly Contest 301

LeetCode笔记:Weekly Contest 317

LeetCode笔记:Weekly Contest 288