Leetcode 周赛 200

统计好三元组

$$\begin{gathered} 由数据规模，就算是O(n^3)也能AC... \\ 当然也可以预先存储每个合法的(i,j)对然后再来找K也可以 \end{gathered}$$

class Solution:
    def countGoodTriplets(self, arr: List[int], a: int, b: int, c: int) -> int:
        ans=0
        for i in range(len(arr)-2):
            for j in range(i+1,len(arr)-1):
                for k in range(j+1,len(arr)):
                    if abs(arr[i]-arr[j])<=a and abs(arr[j]-arr[k])<=b and abs(arr[i]-arr[k])<=c:
                        ans+=1
        return ans

找出数组游戏的赢家

数据规模：

2 <= arr.length <= 10^5
1 <= arr[i] <= 10^6
arr 所含的整数 各不相同 。
1 <= k <= 10^9

$$\begin{gathered} 双指针，第一个指针指向当前的获胜者，第二个指针指向挑战者。 \\ 时间复杂度为O(N)，第一圈找到获胜者，第二圈确定获胜者 \end{gathered}$$

class Solution:
    def getWinner(self, arr: List[int], k: int) -> int:
        if k>=len(arr):
            return max(arr)
        
        cur=0
        p=1
        cnt=0
        while cnt<k:
            if arr[p]<arr[cur]:
                cnt+=1
            else:
                cur=p
                cnt=1
            
            p=(p+1)%len(arr)
        return arr[cur]

排布二进制网格的最少交换次数

数据规模：

n == grid.length
n == grid[i].length
1 <= n <= 200
grid[i][j] 要么是 0 要么是 1 。

$$\begin{gathered} 结果三十分钟做完其他题就这题没想到 \\ 先二维转一维，再冒泡 \end{gathered}$$

class Solution:
    def minSwaps(self, grid: List[List[int]]) -> int:
        '''
        第一步，计算每一列的后缀0的个数，示例1为[0,1,2]
        '''
        g = []
        for l in grid:
            g.append(0)
            for i in l[::-1]:
                if i == 0:
                    g[-1] += 1
                else:
                    break
        '''
        第二步，对g数组使用冒泡算法，使得数组从大到小排列
        '''
        ans = 0
        for i in range(len(g)):
            for j in range(i, len(g)):
                if g[j] >= len(g) - i - 1:
                    ans += j - i
                    g = g[: i] + [g[j]] + g[i: j] + g[j + 1:]
                    break

            else:
                return -1
        return ans

最大得分

数据规模：

1 <= nums1.length <= 10^5
1 <= nums2.length <= 10^5
1 <= nums1[i], nums2[i] <= 10^7
nums1 和 nums2 都是严格递增的数组。

又到了我怎么过的T4，一头雾水时间
一开始不会用数据规模的第四条所以用的dp，状态转移方程是

i,k分别表示数组编号nums[k]中第i个数字
dp(i, k)=dp(i-1, k) + nums[k][i] # 若nums[k][i]不在另一个数组
        =max(dp(i-1, k)，dp(j-1, 1-k)) + nums[k][i] # 若nums[k][i]在另一个数组,j为其对应下标

结果跑出来200M内存开销，但是还能AC就较为震惊
但是结合第4条就可以有双指针解法

1.整合两个数组 nums1 = [2,4,5,8,10], nums2 = [4,6,8,9]->[2,4,5,6,8,9,10]
2.设定两个值ans1,ans2=0,0分别表示两个数组当前最大值，类似dp(i,k)
3.顺序遍历newnums,若只在一个数组出现则只加给对应数组，若都出现则ans1,ans2同时设定为最大值

class Solution:
    def maxSum(self, nums1: List[int], nums2: List[int]) -> int:
        num1, num2= set(nums1),set(nums2)
        ans1,ans2=0,0
        for num in sorted(num1|num2):
            if num in num1 and num in num2:
                ans1=ans2=max(ans1,ans2)
            if num in num1:
                ans1+=num
            if num in num2:
                ans2+=num
        return max(ans1,ans2) %1000000007