【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$ 市面试。综合考虑每个人的成本，对每个人(去 $A$ 市的成本-去 $B$ 市的成本)差值进行排序，之后选择前 $N/2$ 个人去 $A$ 市,后 $N/2$ 个人去 $B$ 市，这样总成本一定是最低的，因为经过这样的排序之后选择去 $A$ 市的人其成本远远低于去 $B$ 市面试，同理选择去 $B$ 市的人其成本远远低于去 $A$ 市面试

class Solution {
public:
    int sum;
    int twoCitySchedCost(vector<vector<int>>& costs) {
    	//传给sort一个lambda表达式作为排序规则
       sort(costs.begin(), costs.end(), 
            [&](vector<int> a, vector<int> b) {
           return a[0] - a[1] < b[0] - b[1];
       });
       for (int i = 0; i < costs.size(); ++i) {
           if (i < costs.size()/2)
               sum += costs[i][0];
           else
               sum += costs[i][1];
       }
        return sum;
    }
};

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

思路：将点的坐标、到 $(r0,c0)$ 的曼哈顿距离封装作为一个节点，存入数组；对于数组按曼哈顿距离大小进行排序，排序之后将节点内的坐标按顺序存入 $vector$

class Solution {
public:
    struct node {
        int x, y;
        int dis;
    };
    //制定排序规则
    static bool cmp(node &a, node &b){
        return a.dis < b.dis;
    }
    vector<vector<int>> allCellsDistOrder(int R, int C, int r0, int c0) {
        vector<vector<int>> a;
        vector<node> vec;
        node via;
        for (int i = 0; i < R; ++i) {
            for (int j = 0; j < C; ++j) {
                int dis = abs(i - r0) + abs(j - c0);
                via.x = i;
                via.y = j;
                via.dis = dis;
                //每个点作为一个节点
                vec.push_back(via);
            }
        }
        sort(vec.begin(), vec.end(), cmp);
        for (int i = 0; i < vec.size(); ++i) {
            vector<int> t;
            t.push_back(vec[i].x);
            t.push_back(vec[i].y);
            a.push_back(t);
            t.clear();
        }
        return a;
    }
};

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

思路：将每个从 $0$ 到 $i$ 的子数组大小封装为 $s[i + 1]$ ,即表示 $A[0] + A[1] + ...A[i]$

$L$ 长度的子数组在 $M$ 长度的子数组之前，则其形成的两个子数组之和为 $s[i + L - 1] - s[i - 1] + s[j + M - 1] - s[j - 1]$ ,其中 $j$ 从 $i+L$ 开始
$M$ 长度的子数组在 $L$ 长度的子数组之前，则其形成的两个子数组之和为 $s[i + M - 1] - s[i - 1] + s[j + L - 1] - s[j - 1]$ ,其中 $j$ 从 $i + M$ 开始

class Solution {
public:
    int ans;
    int maxSumTwoNoOverlap(vector<int>& A, int L, int M) {
        int n = A.size();
        int s[n + 1];
        s[0] = 0;
        for (int i = 1; i <= n; ++i)
            s[i] = s[i - 1] + A[i - 1];
        for (int i = 1; i <= n; ++i) {
            for (int j = i + L; j <= n; ++j) {
                if (i + L - 1 <= n && j + M - 1 <= n) 
                    ans = max(ans, s[i + L - 1] - s[i - 1] + s[j + M - 1] - s[j - 1]);
            }
        }
        for (int i = 1; i <= n; ++i) {
            for (int j = i + M; j <= n; ++j) {
                if (i + M - 1 <= n && j + L - 1 <= n)
                    ans = max(ans, s[i + M - 1] - s[i - 1] + s[j + L - 1] - s[j - 1]);
            }
        }
        return ans;
    }
};

1032. 字符流

按下述要求实现 $StreamChecker$ 类：

$StreamChecker(words)$ ：构造函数，用给定的字词初始化数据结构。
$query(letter)$ ：如果存在某些 $k >= 1$ ，可以用查询的最后 $k$ 个字符（按从旧到新顺序，包括刚刚查询的字母）拼写出给定字词表中的某一字词时，返回 $true$ 。否则，返回 $false$ 。

示例：

StreamChecker streamChecker = new StreamChecker(["cd","f","kl"]); // 初始化字典
streamChecker.query('a');          // 返回 false
streamChecker.query('b');          // 返回 false
streamChecker.query('c');          // 返回 false
streamChecker.query('d');          // 返回 true，因为 'cd' 在字词表中
streamChecker.query('e');          // 返回 false
streamChecker.query('f');          // 返回 true，因为 'f' 在字词表中
streamChecker.query('g');          // 返回 false
streamChecker.query('h');          // 返回 false
streamChecker.query('i');          // 返回 false
streamChecker.query('j');          // 返回 false
streamChecker.query('k');          // 返回 false
streamChecker.query('l');          // 返回 true，因为 'kl' 在字词表中。

提示：

1. 1 <= words.length <= 2000
2. 1 <= words[i].length <= 2000
3. 字词只包含小写英文字母。
4. 待查项只包含小写英文字母。
5. 待查项最多 40000 个。

思路：本质还是字符串匹配的问题。因为长度很大，所以如果不做任何处理肯定会超时；那么简单做一些处理，首先对长度进行筛选，如果当前字符串长度小于 $vector$ 中的 $string$ 长度，那么比较下一个 $string$ ，直到长度能够满足；接下来从后往前进行匹配，如果对于当前 $string$ 都能完全匹配，那么返回 $true$ ，否则寻找下一个 $string$ 进行匹配判断；如果所有 $string$ 都无法匹配，那么返回 $false$

class StreamChecker {
public:
    StreamChecker(vector<string>& words) {
        ans = words;
    }
    
    bool query(char letter) {
        str += letter;
        int n = str.size();
        for (int i = 0; i < ans.size(); ++i) {
            if (n < ans[i].size())
                continue;
            int len = 1;
            while (len <= ans[i].size() && str[n - len] == ans[i][ans[i].size() - len])
                len++;
            if (len > ans[i].size())
                return true;
        }
        return false;
    }
    string str;
    vector<string> ans;
};

看了大佬的解法，用到了字典树，有兴趣的可以了解一下字符流