21天力扣打卡记录

力扣打卡

力扣打卡第一天

题目

给你两个字符串 word1 和 word2 。请你从 word1 开始，通过交替添加字母来合并字符串。如果一个字符串比另一个字符串长，就将多出来的字母追加到合并后字符串的末尾。

返回 合并后的字符串 。

示例 1：

输入：word1 = "abc", word2 = "pqr"
输出："apbqcr"
解释：字符串合并情况如下所示：
word1：  a   b   c
word2：    p   q   r
合并后：  a p b q c r

示例 2：

输入：word1 = "ab", word2 = "pqrs"
输出："apbqrs"
解释：注意，word2 比 word1 长，"rs" 需要追加到合并后字符串的末尾。
word1：  a   b 
word2：    p   q   r   s
合并后：  a p b q   r   s

示例 3：

输入：word1 = "abcd", word2 = "pq"
输出："apbqcd"
解释：注意，word1 比 word2 长，"cd" 需要追加到合并后字符串的末尾。
word1：  a   b   c   d
word2：    p   q 
合并后：  a p b q c   d

提示：

• 1 <= word1.length, word2.length <= 100
• word1 和 word2 由小写英文字母组成

思路，定义一个word3和一个指针i，当指针i大于任何一个给定的字符串长度则结束，随后将剩余字符串补充到定义的word3。

class Solution {
   
public:
    string mergeAlternately(string word1, string word2) {
   
        string word3="";
        int i=0;
        for(;i<word1.size();i++){
   
            if(i>=word2.size())
            break;
            word3=word3+word1[i]+word2[i];
        }
        while(i<word1.size())
        {
   
            word3+=word1[i];
            i++;
        }
        while(i<word2.size())
        {
   
            word3+=word2[i];
            i++;
        }
        return word3;
    }
};

力扣打卡第二天

给定一个数组 nums ，将其划分为两个连续子数组 left 和 right， 使得：

• left 中的每个元素都小于或等于 right 中的每个元素。
• left 和 right 都是非空的。
• left 的长度要尽可能小。

在完成这样的分组后返回 left 的 长度 。

用例可以保证存在这样的划分方法。

思路：

left 中的每个元素都小于或等于 right 中的每个元素翻译为只要所有左边元素的最大值>=所有右边元素的最小值

因此，对于右边的最小值可以定义一个数组，从后向前建立 minright[n-1]=nums[n-1]; minright[i]=min(nums[i],minright[i+1]);

对于左边的最大值 可以每次入队比较 maxleft=max(nums[i],maxleft);

一次遍历即可结束，时间复杂度O(n);

代码如下

class Solution {
   
public:
    int partitionDisjoint(vector<int>& nums) {
   
       int n = nums.size();
       vector<int> minright(n);
       minright[n-1]=nums[n-1];
       for(int i =n-2;i>0;i--){
   
           minright[i]=min(nums[i],minright[i+1]);
       }
       int maxleft =0;
       for(int i=0;i<n-1;i++){
   
           maxleft=max(nums[i],maxleft);
           if(maxleft<=minright[i+1]){
   
               return i+1;
           }
           
       }
       return n-1;
    }
};

力扣打卡第三天

给你一个大小为 n x n 的二元矩阵 grid ，其中 1 表示陆地，0 表示水域。

岛 是由四面相连的 1 形成的一个最大组，即不会与非组内的任何其他 1 相连。grid 中 恰好存在两座岛 。

你可以将任意数量的 0 变为 1 ，以使两座岛连接起来，变成 一座岛 。

返回必须翻转的 0 的最小数目。

示例 1：

输入：grid = [[0,1],[1,0]]
输出：1

示例 2：

输入：grid = [[0,1,0],[0,0,0],[0,0,1]]
输出：2

示例 3：

输入：grid = [[1,1,1,1,1],[1,0,0,0,1],[1,0,1,0,1],[1,0,0,0,1],[1,1,1,1,1]]
输出：1

提示：

• n == grid.length == grid[i].length
• 2 <= n <= 100
• grid[i][j] 为 0 或 1
• grid 中恰有两个岛

思路如下：

先找到找到一座岛,然后从岛屿的边缘开始进行地BFS（广度优先）搜索,每次只前进一步,遇到另外一个岛屿,则代表两个岛屿之间连通，返回步数，同时，最短步数即最短的桥。时间复杂度O（n2）

代码如下：

class Solution {
   
public:
    int shortestBridge(vector<vector<int>>& grid) {
   
        int dir[4][2]{
   {
   0, 1}, {
   1, 0}, {
   0, -1}, {
   -1, 0}};//四个方向
        int n = grid.size(), m = grid[0].size();
        deque<int> st, st2;
        //从一个岛开始
        for (int i = 0; i < n; ++i) {
   
            for (int j = 0; j < m; ++j) {
   
                if (grid[i][j] == 1) {
   
                    st.push_back(i * 1000 + j);
                    grid[i][j] = -1;
                    break;
                }
            }
            if (!st.empty()) break;
        }
        // 扩展全岛入队
        while (!st.empty()) {
   
            int cur = st.front(); st.pop_front(); st2.push_back(cur);
            int x = cur / 1000, y = cur % 1000;
            for (int p = 0; p < 4; ++p) {
   
                int i = x + dir[p][0], j = y + dir[p][1];
                if (i < 0 || i >= n || j < 0 || j >= m) continue;
                if (grid[i][j] == 0 || grid[i][j] == -1) continue;
                st.push_back(i * 1000 + j);
                grid[i][j] = -1;  // 原地标记一下已访问位置
            }
        }
        // 分步 BFS 找最短路
        for (int step = 0; !st2.empty(); ++step) {
   
            // one step
            for (int k = 0, s = st2.size(); k < s; ++k) {
   
                int cur = st2.front(); st2.pop_front();
                int x = cur / 1000, y = cur % 1000;
                for (int p = 0; p < 4; ++p) {
   
                    int i = x + dir[p][0], j = y + dir[p][1];
                    if (i < 0 || i >= n || j < 0 || j >= m) continue;
                    if (grid[i][j] == -1) continue;
                    if (grid[i][j] == 1) return step;
                    st2.push_back(i * 1000 + j);
                    grid[i][j] = -1;
                }
            }
        }
        return -1;
    }
};

力扣打卡第四天

题目：

给你一个整数数组 nums 和一个整数 k ，找出 nums 中和至少为 k 的 最短非空子数组 ，并返回该子数组的长度。如果不存在这样的 子数组 ，返回 -1 。

子数组 是数组中 连续 的一部分。

示例 1：

输入：nums = [1], k = 1
输出：1

示例 2：

输入：nums = [1,2], k = 4
输出：-1

示例 3：

输入：nums = [2,-1,2], k = 3
输出：3

提示：

• 1 <= nums.length <= 105
• -105 <= nums[i] <= 105
• 1 <= k <= 109

思路：

从nums 中和至少为 k 的 最短非空子数组，且子数组 是数组中 连续 的一部分，由此想到使用前缀和，

具体使用如

求出前缀和s后，如果是枚举所有的i>j,s[i]-s[j]>=k的从j到i子数组中的数组长度最小值会超时，优化如下：

优化一：

定义左边元素为j，右边元素为i

如果s[i]-s[j]已经大于k了，继续向右寻找的s[j]无论如何长度都会比目前i-j长，因此继续向右继续寻找没有意义，将左边元素s[j]出队

优化二:

如果s[i]<=s[j],意味从j到i为增加的为负，这时候继续向右遍历x，如果满足s[x]-s[j]>k，因为s[i]<=s[j]，那么s[x]-s[i]也会>k，减去一个更小的数，因此左边j没有必要，可以出队，当完成两个优化后，将此时的右边i入队

具体代码如下

class Solution {
   
public:
    int shortestSubarray(vector<int>& nums, int k) {
   
        int n = nums.size();
        vector<long> preSumArr(n + 1);
        for (int i = 0; i < n; i++) {
   
            preSumArr[i + 1] = preSumArr[i] + nums[i];
        }
        int res = n + 1;
        deque<int> qu;
        for (int i =