2022-02-19每日刷题打卡

2022-02-19每日刷题打卡

飞书——每日一题

228. 汇总区间

给定一个 无重复元素 的 有序 整数数组 nums 。

返回 恰好覆盖数组中所有数字 的 最小有序 区间范围列表 。也就是说，nums 的每个元素都恰好被某个区间范围所覆盖，并且不存在属于某个范围但不属于 nums 的数字 x 。

列表中的每个区间范围 [a,b] 应该按如下格式输出：

“a->b” ，如果 a != b
“a” ，如果 a == b

示例 1：

输入：nums = [0,1,2,4,5,7]
输出：[“0->2”,“4->5”,“7”]
解释：区间范围是：
[0,2] --> “0->2”
[4,5] --> “4->5”
[7,7] --> “7”

毕竟是简单题，就按照题目意思写，只不过要注意细节问题。

class Solution {
public:
    vector<string> summaryRanges(vector<int>& nums) {
        vector<string>v;
        if(nums.size()==0)return v;
        string str=to_string(nums[0]);
        int ans=nums[0],n=nums.size();
        for(int i=1;i<n;i++)
        {
            if(nums[i]!=ans+1)
            {
                if(ans==stoi(str))v.push_back(str);
                else 
                {
                    str+="->";
                    str+=to_string(ans);
                    v.push_back(str);
                }
                str.clear();
                str+=to_string(nums[i]);
                ans=nums[i];
            }
            else ans=nums[i];
        }
        if(ans==stoi(str))v.push_back(str);
        else 
        {
            str+="->";
            str+=to_string(ans);
            v.push_back(str);
        }
        return v;
    }
};

力扣——每日一题

969. 煎饼排序

给你一个整数数组 arr ，请使用 煎饼翻转 完成对数组的排序。

一次煎饼翻转的执行过程如下：

选择一个整数 k ，1 <= k <= arr.length
反转子数组 arr[0…k-1]（下标从 0 开始）
例如，arr = [3,2,1,4] ，选择 k = 3 进行一次煎饼翻转，反转子数组 [3,2,1] ，得到 arr = [1,2,3,4] 。

以数组形式返回能使 arr 有序的煎饼翻转操作所对应的 k 值序列。任何将数组排序且翻转次数在 10 * arr.length 范围内的有效答案都将被判断为正确。

示例 1：

输入：[3,2,4,1]
输出：[4,2,4,3]
解释：
我们执行 4 次煎饼翻转，k 值分别为 4，2，4，和 3。
初始状态 arr = [3, 2, 4, 1]
第一次翻转后（k = 4）：arr = [1, 4, 2, 3]
第二次翻转后（k = 2）：arr = [4, 1, 2, 3]
第三次翻转后（k = 4）：arr = [3, 2, 1, 4]
第四次翻转后（k = 3）：arr = [1, 2, 3, 4]，此时已完成排序。

遍历数组，每次找到数组里的最大值，看这个最大值的下标是否是在它对应的位置上（如果要求数组有序，那么这个数应该在数组末尾），如果不在，可以通过两遍翻转使其到达数组末尾。为什么两次翻转可以使其到达末尾呢，举个例子，比如数组1 2 3 6 4 5，此时6在第四个位置上，我们可以翻转前四个元素，使6到达开头，再翻转整个数组，使其到达末尾。我们每次找到当前数组的最大值的下标，再通过下标进行第一次翻转，再反转整个数组，当最大值到达末尾后我们把它剔除出数组，然后寻找下一个最大值。我们每次翻转的时候把翻转的个数记录在vector里，最后返回这个vector。

class Solution {
public:
    vector<int> pancakeSort(vector<int>& arr) {
        int n=arr.size();
        vector<int>v;
        for(int i=n;i>1;i--)
        {
            int idx=max_element(arr.begin(),arr.begin()+i)-arr.begin();
            if(idx==i-1)continue;
            reverse(arr.begin(),arr.begin()+idx+1);
            reverse(arr.begin(),arr.begin()+i);
            v.push_back(idx+1);
            v.push_back(i);
        }
        return v;
    }
};

1380. 矩阵中的幸运数

给你一个 m * n 的矩阵，矩阵中的数字 各不相同 。请你按 任意 顺序返回矩阵中的所有幸运数。

幸运数是指矩阵中满足同时下列两个条件的元素：

在同一行的所有元素中最小
在同一列的所有元素中最大

示例 1：

输入：matrix = [[3,7,8],[9,11,13],[15,16,17]]
输出：[15]
解释：15 是唯一的幸运数，因为它是其所在行中的最小值，也是所在列中的最大值。

先一列列求，求出每一列的最大值，再根据最大值的下标遍历所在那一行，判断这个是不是这一行最小值。

（可以优化一下，每次找完一行的最小值后，如果列的最大值不是这个行的最小值的话，我们可以记录下这一行的最小值，这样当下一次如果还有列的最大值出现在这一行，就可以直接判断这个列的最大值是不是这个行的最小值了）

class Solution {
public:
    vector<int> luckyNumbers (vector<vector<int>>& matrix) {
        vector<int>v;
        int n=matrix.size(),m=matrix[0].size();
        vector<int>min_math(n,-1);
        for(int i=0;i<m;i++)
        {
            bool flag=true;
            int max_ans=0,x;
            for(int j=0;j<n;j++)
            {
                if(max_ans<matrix[j][i])
                {
                    max_ans=matrix[j][i];
                    x=j;
                }
            }
            if(min_math[x]!=-1)
            {
                if(min_math[x]!=max_ans)
                {
                    flag=false;
                }
            }
            else 
            {
                int min_ans=INT_MAX,y;
                for(int j=0;j<m;j++)
                {
                    if(min_ans>matrix[x][j])
                    {
                        min_ans=matrix[x][j];
                        y=j;
                    }
                }
                if(max_ans!=min_ans)
                {
                    flag=false;
                }
                min_math[x]=min_ans;
            }
            if(flag)v.push_back(max_ans);

        }
        
        return v;
    }
};

1189. “气球” 的最大数量

给你一个字符串 text，你需要使用 text 中的字母来拼凑尽可能多的单词 “balloon”（气球）。

字符串 text 中的每个字母最多只能被使用一次。请你返回最多可以拼凑出多少个单词 “balloon”。

示例 1：

输入：text = “nlaebolko”
输出：1

哈希表遍历字符串，记录每个字符出现的次数，再从哈希表里取出组成气球所需要的字母，找到最小值，那个最小值就是可以拼凑出多少个单词（要注意的是，‘l’字符和’0‘字符比较出现次数时要除2，因为拼一个单词，这俩字符都分别要用2次）

class Solution {
public:
    int maxNumberOfBalloons(string text) {
        unordered_map<char,int>mymap;
        string str="balon";
        int min_num=INT_MAX;
        for(auto i:text)
        {
            mymap[i]++;
        }
        for(auto i:str)
        {
            if(i=='o'||i=='l')min_num=min(min_num,mymap[i]/2);
            else min_num=min(min_num,mymap[i]);
        }
        return min_num;
    }
};