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

---

贪心

贪心的策略是 根据cost(A) - cost(B)升序排序， 让前一半人选A城市，后一半人选B城市

差价为正时，越高意味着去A城市的花费要远远大于B城市，所以肯定要选择去B

同理，差价为负时，要选择去B

其中关于排序中的lambda表达式

class Solution {
public:
    int twoCitySchedCost(vector<vector<int>>& costs) {
        sort(costs.begin(), costs.end(), [](vector<int> &a, vector<int> &b){
            return a[0] - a[1] < b[0] - b[1];
        });
        int ans = 0, mid = costs.size() >> 1;
        for (int i = 0; i < costs.size(); ++i)
            ans += costs[i][i >= mid];
        return ans;
    }
};

---

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

这一看就是BFS，虽然做的时候能感觉出来有比这个好的方法不过没有想到

从给定点开始逐步向外扩展

class Solution{
private:
    int dir[4][2] = {0, 1, 1, 0, 0, -1, -1, 0};
    vector<vector<int>> ans;
    queue<pair<int, int>> q;
    bool vis[105][105];
public:
    vector<vector<int>> allCellsDistOrder(int R, int C, int r0, int c0)
    {
        memset(vis, 0, sizeof(vis));
        q.push({r0, c0});
        vis[r0][c0] = 1;
        ans.push_back({r0, c0});

        while (!q.empty())
        {
            int x = q.front().first, y = q.front().second;
            q.pop();
            for (int i = 0; i < 4; ++i)
            {
                int dx = x + dir[i][0];
                int dy = y + dir[i][1];
                if (dx >= 0 && dx < R && dy >= 0 && dy < C && !vis[dx][dy])
                {
                    vis[dx][dy] = 1;
                    ans.push_back({dx, dy});
                    q.push({dx, dy});
                }
            }
        }
        return ans;
    }
};

排序

把所有单元格都加进答案，直接按照曼哈顿距离排序，好简单QAQ

class Solution{
public:
    vector<vector<int>> allCellsDistOrder(int R, int C, int r0, int c0)
    {
        vector<vector<int>> ans;
        for (int i = 0; i < R; ++i)
            for (int j = 0; j < C; ++j)
                ans.push_back({i, j});
        sort(ans.begin(), ans.end(), [r0, c0](vector<int> &a, vector<int> &b) {
            return abs(a[0] - r0) + abs(a[1] - c0) < abs(b[0] - r0) + abs(b[1] - c0);
        });
        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。

提示：

1. L >= 1
2. M >= 1
3. L + M <= A.length <= 1000
4. 0 <= A[i] <= 1000

---

前缀和

其实题目中的这句话提示了我们：

这里需要澄清的是，长为 L 的子数组可以出现在长为 M 的子数组之前或之后。

也就是我们可以计算出前缀和，然后枚举所有满足的情况就可以了，所有情况又分为L在前和M在前

i从1开始，长度为L的子数组和为sum[i + L - 1] - sum[i - 1]

j从i + L开始，长度为M的子数组和为sum[j + M - 1] - sum[j - 1]

然后把L,M互换位置就可以枚举另一种情况了

class Solution {
public:
    int maxSumTwoNoOverlap(vector<int>& A, int L, int M) {
        int len = A.size();
        vector<int> sum(len + 1, 0);
        for (int i = 1; i <= len; ++i)
            sum[i] = A[i - 1] + sum[i - 1];//前缀和
        
        int ans = 0;
        // L先出现
        for (int i = 1; i + L - 1 <= len; ++i)
            for (int j = i + L; j + M - 1 <= len; ++j)
                ans = max(ans, sum[i + L - 1] - sum[i - 1] + sum[j + M -1] - sum[j - 1]);
        // M先出现
        for (int i = 1; i + M - 1 <= len; ++i)
            for (int j = i + M; j + L - 1 <= len; ++j)
                ans = max(ans, sum[i + M - 1] - sum[i - 1] + sum[j + L -1] - sum[j - 1]);
        
        return ans;
    }
};