Leetcode第133场周赛题目学习

1029.两地调度

题目描述

公司计划面试 2N 人。第 i 人飞往 A 市的费用为 costs[i][0]，飞往 B 市的费用为 costs[i][1]。
返回将每个人都飞到某座城市的最低费用，要求每个城市都有 N 人抵达。

示例：

输入：[[10,20],[30,200],[400,50],[30,20]]
输出：110
解释：
第一个人去 A 市，费用为 10。
第二个人去 A 市，费用为 30。
第三个人去 B 市，费用为 50。
第四个人去 B 市，费用为 20。

最低总费用为 10 + 30 + 50 + 20 = 110，每个城市都有一半的人在面试。
 

提示：

1. 1 <= costs.length <= 100
2. costs.length 为偶数
3. 1 <= costs[i][0], costs[i][1] <= 1000

解题思路

要求每个地去一半人，所以考虑，看每个人去A地和B地的差值，差值越大，说明去B地越划算。因此可将提供的列表按照A-B值大小排序，进而可区分出去A和去B的人选。

参考代码

class Solution:
    def twoCitySchedCost(self, costs):
        costs=sorted(costs,key=lambda x:x[0]-x[1])
        n=len(costs)//2
        res=0
        for i in range(n):
            res += (costs[i][0] + costs[n + i][1])
        return res

1030.距离顺序排列矩阵单元格

题目描述

给出 R 行 C 列的矩阵，其中的单元格的整数坐标为 (r, c)，满足 0 <= r < R 且 0 <= c < C。
另外，我们在该矩阵中给出了一个坐标为 (r0, c0) 的单元格。
返回矩阵中的所有单元格的坐标，并按到 (r0, c0) 的距离从最小到最大的顺序排，其中，两单元格(r1, c1) 和 (r2, c2) 之间的距离是曼哈顿距离，|r1 - r2| + |c1 - c2|。（你可以按任何满足此条件的顺序返回答案。）

示例1：

输入：R = 1, C = 2, r0 = 0, c0 = 0
输出：[[0,0],[0,1]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1]

示例2：

输入：R = 2, C = 2, r0 = 0, c0 = 1
输出：[[0,1],[0,0],[1,1],[1,0]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1,1,2]
[[0,1],[1,1],[0,0],[1,0]] 也会被视作正确答案。

示例3：

输入：R = 2, C = 3, r0 = 1, c0 = 2
输出：[[1,2],[0,2],[1,1],[0,1],[1,0],[0,0]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1,1,2,2,3]
其他满足题目要求的答案也会被视为正确，例如 [[1,2],[1,1],[0,2],[1,0],[0,1],[0,0]]。

提示：

1. 1 <= R <= 100
2. 1 <= C <= 100
3. 0 <= r0 < R
4. 0 <= c0 < C

解题思路

采用BFS的思路从起点开始遍历，并将遍历结果记录。

参考代码

class Solution:
    def allCellsDistOrder(self, R: int, C: int, r0: int, c0: int) -> List[List[int]]:
        toBepush=1
        nextLevel=0
        q=[[r0,c0]]
        ans=[]
        visited=[[0]*C for i in range(R)]
        visited[r0][c0]=1
        while len(q)!=0:
            temp=q[0]
            if temp[0]-1>=0 and visited[temp[0]-1][temp[1]]==0:
                q.append([temp[0]-1,temp[1]])
                visited[temp[0]-1][temp[1]]=1
                nextLevel+=1
            if temp[0]+1<R and visited[temp[0]+1][temp[1]]==0:
                q.append([temp[0]+1,temp[1]])
                visited[temp[0]+1][temp[1]]=1
                nextLevel+=1
            if temp[1]-1>=0 and visited[temp[0]][temp[1]-1]==0:
                q.append([temp[0],temp[1]-1])
                visited[temp[0]][temp[1]-1]=1
                nextLevel+=1
            if temp[1]+1<C and visited[temp[0]][temp[1]+1]==0:
                q.append([temp[0],temp[1]+1])
                visited[temp[0]][temp[1]+1]=1
                nextLevel+=1;
            ans.append(temp)
            q.pop(0)
            toBepush-=1
            if toBepush==0:
                toBepush,nextLevel=nextLevel,toBepush
        return ans
            

1031.两个非重叠子数组的最大和

题目描述

给出非负整数数组 A ，返回两个非重叠（连续）子数组中元素的最大和，子数组的长度分别为 L 和 M。（这里需要澄清的是，长为 L 的子数组可以出现在长为 M 的子数组之前或之后。）
从形式上看，返回最大的 V，而 V = (A[i] + A[i+1] + ... + A[i+L-1]) + (A[j] + A[j+1] + ... + A[j+M-1]) 并满足下列条件之一：

• 0 <= i < i + L - 1 < j < j + M - 1 < A.length, 或
• 0 <= j < j + M - 1 <i < i + L - 1 < A.length.

示例1：

输入：A = [0,6,5,2,2,5,1,9,4], L = 1, M = 2
输出：20
解释：子数组的一种选择中，[9] 长度为 1，[6,5] 长度为 2。

示例2：

输入：A = [3,8,1,3,2,1,8,9,0], L = 3, M = 2
输出：29
解释：子数组的一种选择中，[3,8,1] 长度为 3，[8,9] 长度为 2。

示例3：

输入：A = [2,1,5,6,0,9,5,0,3,8], L = 4, M = 3
输出：31
解释：子数组的一种选择中，[5,6,0,9] 长度为 4，[0,3,8] 长度为 3。

提示：

• L >= 1
• M >= 1
• L + M <= A.length <= 1000
• 0 <= A[i] <= 1000

参考思路

可以先计算出存在的L和M的和。随后，对于每一个L，遍历其左侧和右侧存在的M，找到最大的和即可。

参考代码

class Solution:
    def maxSumTwoNoOverlap(self, A: List[int], L: int, M: int) -> int:
        maximum=0
        length=len(A)
        sumL=[sum(A[i:i+L]) for i in range(0,length-L+1)]#存在的L的和，起始位置为i
        sumM=[sum(A[i:i+M]) for i in range(0,length-M+1)]#存在的M的和，起始位置为i
        ll=len(sumL)
        mm=len(sumM)
        for i in range(ll):
            if i-M>=0:#如果左侧有M
                for j in range(0,i-M+1):
                    if sumL[i]+sumM[j]>maximum:
                        maximum=sumL[i]+sumM[j]
            for j in range(i+L,mm):
                if sumL[i]+sumM[j]>maximum:
                    maximum=sumL[i]+sumM[j]
        return maximum