LeetCode周赛题解: 第 138 场

LeetCode周赛题解: 第 138 场

序言:
六月份开始终于可以不再研究“宇宙”了，可以稍微舒缓一下做点轻松的事，准备对每周的LeetCode比赛写一下自己的题解和心得。思路上如果有参考他人的，会从中指出。

本周题目列表如下(其实是上周…):

• 1051 高度检查器(简单)
• 1052 爱生气的书店老板(中等)
• 1053 交换一次的先前排列(中等)
• 1054 距离相等的条形码(中等)

1. 1051 高度检查器(简单)

描述：

学校在拍年度纪念照时，一般要求学生按照 非递减 的高度顺序排列。
请你返回至少有多少个学生没有站在正确位置数量。该人数指的是：能让所有学生以 非递减 高度排列的必要移动人数。

示例：

输入：[1,1,4,2,1,3] 输出：3
解释： 高度为 4、3 和最后一个 1 的学生，没有站在正确的位置。

提示：

1 <= heights.length <= 100
1 <= heights[i] <= 100

题意还是比较明确的：给一个数组，问至少“移动”其中的元素多少次，可以使其按升序排列。
这“移动”非常微妙，比如给定数组[2, 1]，按照题意，将其排成升序需要的移动次数应该是2。再如果给定[3, 2 ,1]，那就需要移动次数3。
其实示例2的解释“高度为 4、3 和最后一个 1 的学生，没有站在正确的位置”也已经差不多把答案都说出来了。没错，就是要求原数组和升序排序后数组有几个数字不同！

AC 代码:

class Solution {
public:
    int heightChecker(vector<int>& a) {
        vector<int> b = a;
        sort(a.begin(), a.end());
        int cnt = 0;
        for (int i = 0; i < a.size(); ++i) {
            if (a[i] != b[i]) ++cnt;
        }
        return cnt;
    }
};

2. 1052 爱生气的书店老板(中等)

描述:

今天，书店老板有一家店打算试营业 customers.length分钟。每分钟都有一些顾客（customers[i]）会进入书店，所有这些顾客都会在那一分钟结束后离开。

在某些时候，书店老板会生气。 如果书店老板在第 i 分钟生气，那么 grumpy[i] = 1，否则 grumpy[i] = 0。
当书店老板生气时，那一分钟的顾客就会不满意，不生气则他们是满意的。

书店老板知道一个秘密技巧，能抑制自己的情绪，可以让自己连续 X 分钟不生气，但却只能使用一次。

请你返回这一天营业下来，最多有多少客户能够感到满意的数量。

示例：

输入：customers = [1,0,1,2,1,1,7,5], grumpy = [0,1,0,1,0,1,0,1], X = 3
输出：16 解释： 书店老板在最后 3 分钟保持冷静。 感到满意的最大客户数量 = 1 + 1 + 1 + 1 + 7 + 5 = 16.

提示：

1 <= X <= customers.length == grumpy.length <= 20000
0 <= customers[i]<= 1000
0 <= grumpy[i] <= 1

这题的描述…机翻的吧，狗屁不通。不过幸好示例解释的还是很明白的: 给定数组a, b, 它们长度相同，a中全是非负数，b中只有0, 1。再给一个整数x，这个x可以使b中某段连续的长度为x的1全部变成0。现在要开始计算a中的数组元素总和，不过，对于下标 $i$, 只有当 $b[i]=0$ 时， 才把$a[i]$计到总和里，否则不计。即
$$sum=\sum _{i=0}^{len-1}a[i]\ast (1-b[i])$$
问如何使得sum最大？很显然O(n)遍历就能得到结果了。先把边界b[0:x - 1]全部置0的情况计算出来，那么b[1:x]全部置零就可以直接从上一步转移过来，后续依次类推即可。

AC 代码:

class Solution {
public:
    int maxSatisfied(vector<int>& a, vector<int>& b, int x) {
        int sum = 0, ans = 0;
        for (int i = 0; i < a.size(); ++i) {
            if (i < x) sum += a[i];
            else sum += a[i] * (1 - b[i]);
        }
        ans = sum;
        for (int i = 0; i < a.size() - x; ++i) {
            if (b[i] == 1) sum -= a[i];
            if (b[i + x] == 1) sum += a[i + x];
            ans = max(ans, sum);
        }
        return ans;
    }
};

3. 1053 交换一次的先前排列(中等)

描述:

给你一个正整数的数组 A（其中的元素不一定完全不同），请你返回可在一次交换（交换两数字 A[i] 和 A[j] 的位置）后得到的、按字典序排列小于 A 的最大可能排列。如果无法这么操作，就请返回原数组。

示例 1：

输入：[3,2,1]
输出：[3,1,2]
解释：交换 2 和 1

示例 2：

输入：[1,1,5]
输出：[1,1,5]
解释：这已经是最小排列

示例 3：

输入：[1,9,4,6,7]
输出：[1,7,4,6,9]
解释：交换 9 和 7

示例 4：

输入：[3,1,1,3]
输出：[1,3,1,3]
解释：交换 1 和 3

提示：

1 <= A.length <= 10000
1 <= A[i] <= 10000

做这题之前首先要了解“下一个全排列”的基本求解方法。本题含义便是“上一个全排列”
先来看一下“下一个全排列”的思路：

1. 从数组a末尾往前找，找到第一个逆序(从末尾往前看过去，第一个不满足升序的那个)， 记下标其 i
2. 再从末尾倒着到 i + 1中，第一个大于a[i]的下标记作 j, 交换a[i]和a[j]
3. 倒置 i + 1 到末尾的部分

对比而言，“上一个全排列”的思路是：

1. 从数组a末尾往前找，找到第一个非逆序(从末尾往前看过去，第一个不满足降序的那个)， 记下标其 i
2. 再从 i + 1到末尾中，第一个大于a[i]的下标记作 j, 交换a[i]和a[j]
3. 倒置 i + 1 到末尾的部分

此题，因为只允许交换其中两个数，因此省去第3步便可。

AC 代码:

class Solution {
public:
    vector<int> prevPermOpt1(vector<int>& A) {
        if (A.empty()) return {};
        int i = A.size() - 1;
        for (; i > 0 && A[i] >= A[i - 1]; --i);
        --i;
        if (i != -1) {
            int j = i + 1;
            while(j < A.size() && A[i] > A[j]) ++j;
            swap(A[i], A[--j]);
        }
        return A;
    }
};

4. 1054 距离相等的条形码(中等)

描述:

在一个仓库里，有一排条形码，其中第 i 个条形码为 barcodes[i]。
请你重新排列这些条形码，使其中两个相邻的条形码 不能 相等。
你可以返回任何满足该要求的答案，此题保证存在答案。

示例 1：

输入：[1,1,1,2,2,2]
输出：[2,1,2,1,2,1]

示例 2：

输入：[1,1,1,1,2,2,3,3]
输出：[1,3,1,3,2,1,2,1]

提示：

1 <= barcodes.length <= 10000
1 <= barcodes[i] <= 10000

还是一个数组，把里面的数字重排一下，使相同数字不相邻。这道题目的思路比较容易出来的，一开始肯定要先考虑先放个数多的呗，不然攒到后面想出手都出手不了。当然，还要记一下前一个排的数，如果当前个数最多的就是前一个排的数，那么本次只能选个数第二多的数。

AC 代码：

struct node{
    int v, cnt;
    friend bool operator < (const node& lhs, const node& rhs) {
        return lhs.cnt < rhs.cnt;
    }
};
int cnt[10005];
class Solution {
public:
    vector<int> rearrangeBarcodes(vector<int>& nums) {
        memset(cnt, 0, sizeof(cnt));
        for (auto n : nums) ++cnt[n];
        priority_queue<node> Q;
        for (int i = 0; i <= 10000; ++i) if (cnt[i] != 0) 
            Q.push({i, cnt[i]});
        // 对所有数组以计数的方式存储在优先队列中
        
        vector<int> ans(nums.size(), 0);
        int prev = -1; //记录前一个
        for (int i = 0; i < nums.size(); ++i) {
            node top1 = Q.top();
            Q.pop();
            // 如果先当前个数最多的前一个没有用过
            // 那就选他
            if (top1.v != prev) {
                ans[i] = top1.v;
                prev = top1.v;
                top1.cnt--;
                if (top1.cnt != 0) Q.push(top1);
            }
            //否则，选第二多的
            else {
                node top2 = Q.top();
                Q.pop();
                ans[i] = top2.v;
                prev = top2.v;
                top2.cnt--;
                Q.push(top1);
                if (top2.cnt != 0) Q.push(top2);
            }
        }
        return ans;
    }
};

总结：
上周题目总体来说算是比较简单的，不过由于码速问题，全部写出也只获得了第58名。感觉脑子还是转的不够快一些，只能靠勤补拙了~