Leetcode 第138场周赛题目学习

1051.高度检查器

题目描述

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

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

提示：

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

解题思路

将所给数组排序，随后进行一次遍历，找出排序前后位置不相符的人，返回其数目。
时间复杂度：排序为$O(nlogn)$，遍历为$O(n)$，共计为$O(nlogn)$

参考代码

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

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

参考思路

首先计算出不生气时客人数的总和，随后将不生气时客人数置0。接下来累积计算生气客人数目。
例如：

customers = [1,0,1,2,1,1,7,5]
grumpy =    [0,1,0,1,0,1,0,1]

则计算结束不生气时客人数总和后，有：

customers = [0,0,0,2,0,1,0,5]
grumpy =    [0,1,0,1,0,1,0,1]
sum=10

随后，customers变为：

customers = [0,0,0,2,2,3,3,8]

即customers[i]为到i为止的所有元素的和。

随后，利用滑动窗口法进行选择。从customer的[x-1]位置开始滑窗筛选，每次向右滑动1，统计窗口内的值，并选择最大值。如：

customers = [0,0,0,2,2,3,3,8]
X-1=2
每向右滑动一个，窗口内的客人数量为customer[i]-customer[i-X]

随后，将不生气时客人的数目和使用技巧时获得的最大收益进行加和。
时间复杂度，三次遍历，为$O(n)$

参考代码

class Solution {
public:
  int maxSatisfied(vector<int>& customers, vector<int>& grumpy, int X) 
  {
    int N = customers.size();
    int ans = 0;
    for (int i = 0; i < N; i++) 
    if (grumpy[i] == 0) 
    	ans += customers[i], customers[i] = 0;
    partial_sum(customers.begin(), customers.end(), customers.begin());
    int best = customers[X - 1];
    for (int i = X; i < N; i++) 
    	best = max(best, customers[i] - customers[i - X]);
    return best + ans;
  }
};

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. 1 <= A.length <= 10000
2. 1 <= A[i] <= 10000

参考思路

首先，从后向前找到第一个逆序对，记录其位置pos1。随后，再从后向前，直到开头，将元素与A[pos1]比较，若比其小，则交换，并停止循环。
例如：

A=[1,9,4,6,7]
则pos1=1，即为元素9
随后的遍历，发现7比9小，则二者交换，得到结果
A=[1,7,4,6,9]

若整个序列为升序排列，则其不存在最小排列。存在最小排列的序列，一定含有逆序对。从后向前在第一个逆序对处进行调整，可保证前几位保持不变，从而能获得一个较大的最小排列。
时间复杂度：两次遍历，$O(n)$

参考代码

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

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. 1 <= barcodes.length <= 10000
2. 1 <= barcodes[i] <= 10000

参考思路

首先建立一个字典，用以统计所给序列中每个元素出现的次数。随后以<值，键>对的形式保存到一个序列中，将序列降序排序（按值大小）。
随后，以奇偶位插入的方式插入相应的元素。当某个元素的计数为零后，再插入下一个元素。

参考代码

class Solution {
public:
    vector<int> rearrangeBarcodes(vector<int>& barcodes) 
    {
        int n=barcodes.size();
        map<int,int> Counter;
        for(int i=0;i<n;++i)
            Counter[barcodes[i]]++;
        vector<pair<int,int> >p;
        for (auto d : Counter)
			p.push_back(make_pair(d.second,d.first));
        sort(p.begin(),p.end());
        reverse(p.begin(),p.end());//一定要保证多的元素放前面，若少的元素放前面，多的元素可能会出现连续
        int j=0;
        vector<int> ans(n);
        for(int i=0;i<n;i+=2)
        {
            ans[i]=p[j].second;
            if(!--p[j].first)
                j++;
        }
        for(int i=1;i<n;i+=2)
        {
            ans[i]=p[j].second;
            if(!--p[j].first)
                j++;
        }
        return ans;
    }
};