LeetCode2019第 15 场双周赛

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

题目描述

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

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

提示：
1 <= arr.length <= 10^4
0 <= arr[i] <= 10^5

题解1

整数的范围为0-100000，可以直接作为数组的下标，统计每个元素出现的次数，当出现的次数超过0.25，则直接输出。
ps:如果整数范围很大，或者会出现负数时，这时可以会map来统计元素出现的次数。

代码1

class Solution {
public:
    int findSpecialInteger(vector<int>& arr) {
        int len = floor(arr.size() / 4.0);
        int cnt[100005], res;
        memset(cnt, 0, sizeof(cnt));
        for(int i = 0; i < arr.size(); ++i){
            cnt[arr[i]]++;//统计元素的次数
            if(cnt[arr[i]] > len){//超过25%
                res = arr[i];
                break;
            }
        }
        return res;
    }
};

1288. 删除被覆盖区间

题目描述

给你一个区间列表，请你删除列表中被其他区间所覆盖的区间。
只有当 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]

题解1

首先将所有的区间按照左端点值从小到大排列，相同的按照右端点值从小到大排列。
排列之后的区间只可能被它前面的区间覆盖掉，只需要遍历即可。两重循环复杂度为 $O(n^2)$

代码1

class Solution {
public:
    int removeCoveredIntervals(vector<vector<int>>& intervals) {
        sort(intervals.begin(), intervals.end());
        vector<vector<int>>res;
        bool flag = false;
        res.push_back(intervals[0]);
        for(int i = 1; i < intervals.size(); ++i){
            flag = false;
            for(int j = 0; j <= i - 1; ++j){
                if(intervals[i][1] <= intervals[j][1]){//区间覆盖
                    flag = true;
                    break;
                }
            }
            if(!flag){
                res.push_back(intervals[i]);
            }
        }
        return res.size();
    }
};

1286. 字母组合迭代器

题目描述

请你设计一个迭代器类，包括以下内容：
一个构造函数，输入参数包括：一个 有序且字符唯一 的字符串 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 时都存在下一个字母组合。

题解1

思路采用DFS写组合的思路，将所有的字母组合存到vector中(最多只存10000个，因为最多只包含10000次函数调用)，用一个指针指向当前的读取位置，如果到结尾应返回false，否则返回true。

代码1

vector<string>res;
map<string, bool>myMap;
string tmp;
int num;
void dfs(string s, int idx, int length){//选出字母的组合
    if(res.size() < 10000 && tmp.size() == length){
        if(myMap.find(tmp) == myMap.end()){
            myMap[tmp] == true;
            res.push_back(tmp);
        }
        return;
    }
    if(res.size() == 10000 || idx >= s.size()){//最多只存储10000个组合，因为只有10000次查询
        return;
    }
    for(int i = idx; i < s.size(); ++i){
        tmp.push_back(s[i]);
        dfs(s, i + 1, length);
        tmp.pop_back();
    }
}
class CombinationIterator {
public:
    
    CombinationIterator(string s, int length) {
        res.clear();
        tmp.clear();
        myMap.clear();
        num = 0;
        dfs(s, 0, length);
    }
    
    string next() {
        return res[num++];
    }
    
    bool hasNext() {
        return num < res.size();
    }
};

/**
 * 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();
 */

1289. 下降路径最小和 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

题解1

动态规划
对于 $n\times n$的方阵，到达位置(i, j)外的最小路径和记为dp(i, j)。
$dp[i][j] = min\lbrace dp[i-1][k] \space (k = 1, 2, , \cdots, j-1, j+1, \cdots, n ) \rbrace + arr[i][j]$
时间复杂度为 $O(n^3)$，可以用两个变量来存储每一行的最大的两个值，时间复杂可以降为 $O(n^2)$。

代码1

class Solution {
public:
    int minFallingPathSum(vector<vector<int>>& arr) {
        int sum[205][205];
        int len = arr.size(), minVal;
        for(int i = 0; i < len; ++i){
            sum[0][i] = arr[0][i];
        }
        for(int i = 1; i < len; ++i){
            for(int j = 0; j < len; ++j){
                minVal = (1 << 30);
                for(int k = 0; k < len; ++k){
                    if(k != j && sum[i - 1][k] < minVal){
                        minVal = sum[i - 1][k];
                    }
                }
                sum[i][j] = minVal + arr[i][j];
            }
        }
        minVal = 1 << 30;
        for(int i = 0; i < len; ++i){
            if(sum[len - 1][i] < minVal){
                minVal = sum[len - 1][i];
            }
        }
        return minVal;
    }
};