力扣第15场双周赛

这次双周赛的题比较简单，我居然在比赛时间内全AC了。。真是少见的操作

由于力扣双周赛的题过一段时间会被锁住，只有开vip才能做题，所以贴在这里记录一下吧

5126. 有序数组中出现次数超过25%的元素

给你一个非递减的 有序 整数数组，已知这个数组中恰好有一个整数，它的出现次数超过数组元素总数的 25%。

请你找到并返回这个整数

示例：

输入：arr = [1,2,2,6,6,6,6,7,10]
输出：6

提示：

• 1 <= arr.length <= 10^4
• 0 <= arr[i] <= 10^5

class Solution {
public:
    int a[100005];
    int findSpecialInteger(vector<int>& arr) {
        int n=arr.size()/4,m=0;
        for(int i=0;i<arr.size();i++){
            ++a[arr[i]];
        }
        for(int i=0;i<100005;i++){
            if(a[i]>n){
                return i;
            }
        }
        return m;
    }
};

5127. 删除被覆盖区间

给你一个区间列表，请你删除列表中被其他区间所覆盖的区间。

只有当 c <= a 且 b <= d 时，我们才认为区间 [a,b) 被区间 [c,d) 覆盖。

在完成所有删除操作后，请你返回列表中剩余区间的数目。

示例：

输入：intervals = [[1,4],[3,6],[2,8]]
输出：2
解释：区间 [3,6] 被区间 [2,8] 覆盖，所以它被删除了。

提示：

• 1 <= intervals.length <= 1000
• 0 <= intervals[i][0] < intervals[i][1] <= 10^5
• 对于所有的 i != j：intervals[i] != intervals[j]

class Solution {
public:
    int removeCoveredIntervals(vector<vector<int>>& intervals) {
        int ans=intervals.size();
        for(int i=0;i<intervals.size();i++){
            int l=intervals[i][0],r=intervals[i][1];
            for(int j=0;j<intervals.size();j++){
                if(i==j) continue;
                int ll=intervals[j][0],rr=intervals[j][1];
                if(l>=ll&&r<=rr){
                    ans--;
                    break;
                }
            }
        }
        return ans;
    }
};

5123. 字母组合迭代器

请你设计一个迭代器类，包括以下内容：

• 一个构造函数，输入参数包括：一个 有序且字符唯一 的字符串 characters（该字符串只包含小写英文字母）和一个数字 combinationLength 。
• 函数 next() ，按 字典序 返回长度为 combinationLength 的下一个字母组合。
• 函数 hasNext() ，只有存在长度为 combinationLength 的下一个字母组合时，才返回 True；否则，返回 False。

示例：

CombinationIterator iterator = new CombinationIterator("abc", 2); // 创建迭代器 iterator

iterator.next(); // 返回 "ab"
iterator.hasNext(); // 返回 true
iterator.next(); // 返回 "ac"
iterator.hasNext(); // 返回 true
iterator.next(); // 返回 "bc"
iterator.hasNext(); // 返回 false

提示：

• 1 <= combinationLength <= characters.length <= 15
• 每组测试数据最多包含 10^4 次函数调用。
• 题目保证每次调用函数 next 时都存在下一个字母组合

这里的字符串全部组合是copy一篇别人得博客的，毕竟ctrl+c和ctrl+v比自己重新实现一遍快多了哈哈

class CombinationIterator {
public:
    vector<string> vv;int s=0,ss=0,com=0;
    void Print(vector<char>& v)
    {
       string str="";
    	for (int i = 0; i<v.size(); i++)
    	{
           str.push_back(v[i]);
	    }
       vv.push_back(str);
    }
    void _Combination(const char* str, int len, vector<char>&v)
    {
        if (!str || (*str == '\0'&&len > 0))
            return;
        if (len == 0)
        {
            Print(v);
            return;
        }
        v.push_back(*str);
        _Combination(str + 1, len - 1, v);
        v.pop_back();
        _Combination(str + 1, len, v);
    }
    void ComBination(const char* str)
    {
        vector<char>v;
        int len = strlen(str);
        for (int i = 1; i <= len; i++)
        {
            _Combination(str, i, v);
        }
    }
    CombinationIterator(string characters, int combinationLength) {
        vv.clear();
        const char *cha=characters.c_str();
        ComBination(cha);
        com=combinationLength;
        ss=vv.size();
    }
    string next() {
        for(int i=s;i<vv.size();i++){
            if(vv[i].size()==com){
                s=i+1;
                return vv[i];
            }
        }
        return "";
    }
    bool hasNext() {
        for(int i=s;i<vv.size();i++){
            if(vv[i].size()==com) return true;
        }
       return false;
    }
};

/**
 * Your CombinationIterator object will be instantiated and called as such:
 * CombinationIterator* obj = new CombinationIterator(characters, combinationLength);
 * string param_1 = obj->next();
 * bool param_2 = obj->hasNext();
 */

5129. 下降路径最小和 II

给你一个整数方阵 arr ，定义「非零偏移下降路径」为：从 arr 数组中的每一行选择一个数字，且按顺序选出来的数字中，相邻数字不在原数组的同一列。

请你返回非零偏移下降路径数字和的最小值。

示例 1：

输入：arr = [[1,2,3],[4,5,6],[7,8,9]]
输出：13
解释：
所有非零偏移下降路径包括：
[1,5,9], [1,5,7], [1,6,7], [1,6,8],
[2,4,8], [2,4,9], [2,6,7], [2,6,8],
[3,4,8], [3,4,9], [3,5,7], [3,5,9]
下降路径中数字和最小的是 [1,5,7] ，所以答案是 13 。

提示：

• 1 <= arr.length == arr[i].length <= 200
• -99 <= arr[i][j] <= 99

很easy的一道dp题emmmm

class Solution {
public:
    int dp[300][300];
    int minFallingPathSum(vector<vector<int>>& arr) {
        memset(dp,0,sizeof(dp));
       for(int i=0;i<arr[0].size();i++){
           dp[0][i]=arr[0][i];
       }
        for(int i=1;i<arr.size();i++){
            for(int j=0;j<arr[i].size();j++){
                int tmp=INT_MAX;
                for(int w=0;w<arr[i].size();w++){
                    if(j==w) continue;            
                    tmp=min(tmp,dp[i-1][w]);                  
                }
                dp[i][j]=arr[i][j]+tmp;
            }
        }
        int ans=INT_MAX;
        for(int i=0;i<arr[0].size();i++){
            ans=min(ans,dp[arr.size()-1][i]);
        }
        return ans;
    }
};