leetcode解题思路分析（一百五十三）1327 - 1333 题

1327. 列出指定时间段内所有的下单产品
      写一个解决方案，要求获取在 2020 年 2 月份下单的数量不少于 100 的产品的名字和数目。

select product_name, sum(unit) unit
from Products join Orders using(product_id)

# where year(order_date) = '2020' and month(order_date) = '02'
where order_date >= '2020-02-01' and order_date < '2020-03-01'
# where order_date like '2020-02%'

group by product_name
having unit >= 100

1328. 破坏回文串
      给你一个由小写英文字母组成的回文字符串 palindrome ，请你将其中 一个 字符用任意小写英文字母替换，使得结果字符串的 字典序最小 ，且 不是 回文串。请你返回结果字符串。如果无法做到，则返回一个 空串 。

贪心算法，从左往右找第一个不是a的，如果全是a，则替换末尾的

class Solution {
public:
    string breakPalindrome(string palindrome) {
        int n = palindrome.size();
        if(n==1)return "";
        bool f = false;
        for(int i=0;i<n/2;++i){
            if(palindrome[i]!='a'){
                palindrome[i]='a';
                f = true;
                break;
            }
        }
        if(!f){
            palindrome[n-1]='b';
        }
        return palindrome;
    }
};

1329. 将矩阵按对角线排序
      矩阵对角线 是一条从矩阵最上面行或者最左侧列中的某个元素开始的对角线，沿右下方向一直到矩阵末尾的元素。例如，矩阵 mat 有 6 行 3 列，从 mat[2][0] 开始的 矩阵对角线 将会经过 mat[2][0]、mat[3][1] 和 mat[4][2] 。给你一个 m * n 的整数矩阵 mat ，请你将同一条 矩阵对角线 上的元素按升序排序后，返回排好序的矩阵。

左斜线特点是同行上i-j都相等，因此先取斜线，然后排序，然后再放回去即可。

class Solution {
public:
    vector<vector<int>> diagonalSort(vector<vector<int>>& mat) {
        int n = mat.size(), m = mat[0].size();
        unordered_map<int, vector<int>> vs;
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j)
                vs[i - j].emplace_back(mat[i][j]);
        }
        for (auto& v : vs) sort(v.second.rbegin(), v.second.rend());

        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                mat[i][j] = vs[i - j].back();
                vs[i - j].pop_back();
            }
        }
        return mat;
    }
};

1330. 翻转子数组得到最大的数组值
      给你一个整数数组 nums 。「数组值」定义为所有满足 0 <= i < nums.length-1 的 |nums[i]-nums[i+1]| 的和。
      你可以选择给定数组的任意子数组，并将该子数组翻转。但你只能执行这个操作 一次 。
      请你找到可行的最大 数组值 。

本题破题点在于分析各种情况，确定什么情况下才需要翻转，然后迎刃而解

class Solution {
public:
    int maxValueAfterReverse(vector<int>& nums) {
        int value = 0, n = nums.size();
        for (int i = 0; i < n - 1; i++) {
            value += abs(nums[i] - nums[i + 1]);
        }
        int mx1 = 0;
        for (int i = 1; i < n - 1; i++) {
            mx1 = max(mx1, abs(nums[0] - nums[i + 1]) - abs(nums[i] - nums[i + 1]));
            mx1 = max(mx1, abs(nums[n - 1] - nums[i - 1]) - abs(nums[i] - nums[i - 1]));
        }
        int mx2 = INT_MIN, mn2 = INT_MAX;
        for (int i = 0; i < n - 1; i++) {
            int x = nums[i], y = nums[i + 1];
            mx2 = max(mx2, min(x, y));
            mn2 = min(mn2, max(x, y));
        }
        return value + max(mx1, 2 * (mx2 - mn2));
    }
};

1331. 数组序号转换
      给你一个整数数组 arr ，请你将数组中的每个元素替换为它们排序后的序号。序号代表了一个元素有多大。序号编号的规则如下：
      序号从 1 开始编号。
      一个元素越大，那么序号越大。如果两个元素相等，那么它们的序号相同。
      每个数字的序号都应该尽可能地小。

排序后存入哈希表，已经存过的元素不再变化即可满足题意

class Solution {
public:
    vector<int> arrayRankTransform(vector<int>& arr) {
        vector<int> sortedArr = arr;
        sort(sortedArr.begin(), sortedArr.end());
        unordered_map<int, int> ranks;
        vector<int> ans(arr.size());
        for (auto &a : sortedArr) {
            if (!ranks.count(a)) {
                ranks[a] = ranks.size() + 1;
            }
        }
        for (int i = 0; i < arr.size(); i++) {
            ans[i] = ranks[arr[i]];
        }
        return ans;
    }
};

1332. 删除回文子序列
      给你一个字符串 s，它仅由字母 ‘a’ 和 ‘b’ 组成。每一次删除操作都可以从 s 中删除一个回文 子序列。返回删除给定字符串中所有字符（字符串为空）的最小删除次数。
      「子序列」定义：如果一个字符串可以通过删除原字符串某些字符而不改变原字符顺序得到，那么这个字符串就是原字符串的一个子序列。回文」定义：如果一个字符串向后和向前读是一致的，那么这个字符串就是一个回文。

脑筋急转弯的题：每次删一个子串，那直接删全a或者全b，下次一定就删完了。如果本身就是回文串则1次删完，根本不需要考虑最长子串之类的问题。

class Solution {
public:
    int removePalindromeSub(string s) {
        int n = s.size();
        for (int i = 0; i < n / 2; ++i) {
            if (s[i] != s[n - 1 - i]) {
                return 2;
            }
        }
        return 1;
    }
};

1333. 餐厅过滤器
      给你一个餐馆信息数组 restaurants，其中 restaurants[i] = [idi, ratingi, veganFriendlyi, pricei, distancei]。你必须使用以下三个过滤器来过滤这些餐馆信息。其中素食者友好过滤器 veganFriendly 的值可以为 true 或者 false，如果为 true 就意味着你应该只包括 veganFriendlyi 为 true 的餐馆，为 false 则意味着可以包括任何餐馆。此外，我们还有最大价格 maxPrice 和最大距离 maxDistance 两个过滤器，它们分别考虑餐厅的价格因素和距离因素的最大值。过滤后返回餐馆的 id，按照 rating 从高到低排序。如果 rating 相同，那么按 id 从高到低排序。简单起见， veganFriendlyi 和 veganFriendly 为 true 时取值为 1，为 false 时，取值为 0 。

考察stl的基本用法，使用lamda是比较方便的，也可以直接写cmp函数

class Solution {
public:
    vector<int> filterRestaurants(vector<vector<int>>& restaurants, int veganFriendly, int maxPrice, int maxDistance) 
    {
        vector<int> ret;
        vector<pair<int, int>> rateVec;

        for (int i = 0; i < restaurants.size(); ++i)
        {
            if (veganFriendly && !restaurants[i][2])
                continue;
            if (restaurants[i][3] > maxPrice)
                continue;
            if (restaurants[i][4] > maxDistance)
                continue;
            rateVec.push_back(make_pair(restaurants[i][0], restaurants[i][1]));        
        }

        sort(rateVec.begin(), rateVec.end(), [=](std::pair<int, int>& a, std::pair<int, int>& b)
            {
                return a.second > b.second || (a.second == b.second && a.first > b.first);
            }
        );

        for (int i = 0; i < rateVec.size(); ++i)
        {
            ret.push_back(rateVec[i].first);
        }

        return ret;
    }
};