LeetCode第 18 场双周赛

1331. 数组序号转换

给你一个整数数组 arr ，请你将数组中的每个元素替换为它们排序后的序号。

序号代表了一个元素有多大。序号编号的规则如下：

序号从 1 开始编号。
一个元素越大，那么序号越大。如果两个元素相等，那么它们的序号相同。
每个数字的序号都应该尽可能地小。

示例 1：

输入：arr = [40,10,20,30]
输出：[4,1,2,3]
解释：40 是最大的元素。 10 是最小的元素。 20 是第二小的数字。 30 是第三小的数字。
示例 2：

输入：arr = [100,100,100]
输出：[1,1,1]
解释：所有元素有相同的序号。
示例 3：

输入：arr = [37,12,28,9,100,56,80,5,12]
输出：[5,3,4,2,8,6,7,1,3]

提示：

0 <= arr.length <= 105
-109 <= arr[i] <= 109

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/rank-transform-of-an-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

分析

将数组中的每个元素用排序后第几大的序号代替
可以开一个辅助数组存放原数组中的元素，之后对辅助数组进行排序，之后用个哈希表标记下每个元素是第几大就行了

class Solution {
public:
    vector<int> arrayRankTransform(vector<int>& arr) {
        vector<int> res;
        int len = arr.size();
        if(len == 0) {
            return res;
        }
        vector<int> temp(len);
        for(int i = 0; i < arr.size(); i++) {
            temp[i] = arr[i];
        }
        sort(temp.begin(), temp.end());
        unordered_map<int, int> map;
        int t = 1;
        for(int i = 0; i < temp.size() - 1; i++) {
            map[temp[i]] = t;
            if(temp[i+1] > temp[i]) {
                t++;
            }
        }
        map[temp.back()] = t;
        for(int i = 0; i < arr.size(); i++) {
            res.push_back(map[arr[i]]);
        }
        return res;
    }
};

1328. 破坏回文串

给你一个回文字符串 palindrome ，请你将其中 一个 字符用任意小写英文字母替换，使得结果字符串的字典序最小，且 不是 回文串。

请你返回结果字符串。如果无法做到，则返回一个空串。

示例 1：

输入：palindrome = “abccba”
输出：“aaccba”
示例 2：

输入：palindrome = “a”
输出：""

提示：

1 <= palindrome.length <= 1000
palindrome 只包含小写英文字母。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/break-a-palindrome
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

分析

要求修改一个字符，使得结果字符串的字典序最小并且不能是回文串
我写的代码其实不太好，实际上只要从前往后遍历，把首个非a字符改成a，如果全是a，那就把最后一个换成b就是了

class Solution {
public:
    string breakPalindrome(string palindrome) {
        string res;
        if(palindrome.size() == 1) {
            return res;
        }
        char temp;
        for(int i = 0; i < palindrome.size(); i++) {
            if(palindrome[i] != 'a') {
                temp = palindrome[i];
                palindrome[i] = 'a';
            } else {
                continue;
            }
            if(!isPalindrome(palindrome)) {
                return palindrome;
            } else {
                palindrome[i] = temp;
            }
        }
        for(int i = palindrome.size()-1; i >= 0; i--) {
            if(palindrome[i] != 'b') {
                temp = palindrome[i];
                palindrome[i] = 'b';
            } else {
                continue;
            }
            if(!isPalindrome(palindrome)) {
                return palindrome;
            } else {
                palindrome[i] = temp;
            }
        }
        return res;
    }
    bool isPalindrome(string s) {
        int i=0,j=s.size()-1;
        while(i<j)
        {
            while(i<j && !isdigit(s[i]) && !isalpha(s[i]))i++;
            while(i<j && !isdigit(s[j]) && !isalpha(s[j]))j--;
            if(i<j && tolower(s[i])!=tolower(s[j]))
                return false;
            i++;j--;
        }
        return true;
    }
};

1329. 将矩阵按对角线排序

给你一个 m * n 的整数矩阵 mat ，请你将同一条对角线上的元素（从左上到右下）按升序排序后，返回排好序的矩阵。

示例 1：

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

提示：

m == mat.length
n == mat[i].length
1 <= m, n <= 100
1 <= mat[i][j] <= 100

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sort-the-matrix-diagonally
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

分析

按照要求模拟就行了，将每个对角线的所有元素用一个临时数组存放，排序后重新赋值即可

class Solution {
public:
    vector<vector<int>> diagonalSort(vector<vector<int>>& mat) {
        
        int n = mat.size();
        int row = mat.size(), col = mat[0].size();
        if(row == 1) {
         return mat;   
        }
        vector<vector<int> > res(row, vector<int>(col));
        int iStart = 0;  
        int jStart = col - 1;
        while (iStart < row) {  
            vector<int> temp;
            for (int i = iStart, j = jStart; i < row && j < col; i++, j++) {  
                  temp.push_back(mat[i][j]);
                res[i][j] = mat[i][j];
            }
            sort(temp.begin(), temp.end());
            int t = 0;
            for (int i = iStart, j = jStart; i <= row - 1 && j <= col - 1; i++, j++) {  
                  res[i][j] = temp[t];
                t++;
            }
            if (jStart > 0) {  
                jStart--;  
            } else {  
                iStart++;  
            }
        }  
        return res;
    }  
};

1330. 翻转子数组得到最大的数组值

给你一个整数数组 nums 。「 数组值」定义为所有满足 0 <= i < nums.length-1 的 |nums[i]-nums[i+1]| 的和。

你可以选择给定数组的任意子数组，并将该子数组翻转。但你只能执行这个操作 一次 。

请你找到可行的最大 数组值 。

示例 1：

输入：nums = [2,3,1,5,4]
输出：10
解释：通过翻转子数组 [3,1,5] ，数组变成 [2,5,1,3,4] ，数组值为 10 。
示例 2：

输入：nums = [2,4,9,24,2,1,10]
输出：68

提示：

1 <= nums.length <= 3*10^4
-10^5 <= nums[i] <= 10^5

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-subarray-to-maximize-array-value
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。