代码随想录算法训练营第二天 | 数组4，5，6，7

数组四-有序数组的平方

第一天内有详细代码批注，今天默写了一遍，总结失误点。

1.k字母老是忘记同一大小写。

2.i<=j，不然会漏比较数字。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        //先创建一个数组,并初始化为0
        vector<int>A(nums.size(),0);
        int k=nums.size()-1;//作为新数组的末下标
        //双指针
        for(int i=0,j=nums.size()-1;i<=j; ){//循环，目的：比较找出大值倒着放在新数组

        if(nums[i]*nums[i]>nums[j]*nums[j]){
            A[k]=nums[i]*nums[i];
            k--;
            i++;
        }else{
            A[k]=nums[j]*nums[j];
            k--;
            j--;
        }
        }
      return A;
    }
};

数组5-长度最小的数组

易错点：结果没有考虑不符合条件的情况，要输出为0，用return re==result?0:re;只要被更新最小值就输出，没有变换就表示没有符合的值。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int re=INT_MAX;  
        int sum=0;
        int len=0;
        for(int i=0;i<nums.size();i++){  //实现滑动起始位
          sum=0;
            for(int j=i;j<nums.size();j++){
               sum+=nums[j];
               if(sum>=target){
                   len=j-i+1;//长度不断在改变
                   re=re<len?re:len;//比较取最小
                   break;
                   //保证加完一次和就停下里比较，不接着走
                   //因为不是每一次间隔里面都保证能得出结果
                //每一个间隔break，就可以得到满足的条件和的多个长度
    //然后re不断更新最小长度，直至ij移动结束，跳出循环，输出最小长度
               }//当if里面的不满足了，就i,j++,末位置移动
        }
    }//没有被赋值，则表示没有符合条件的
    return re == INT32_MAX ? 0 : re;
}
};

数组5.1-904水果成篮

有点难，后面再来搞明白

class Solution {
public:
    int totalFruit(vector<int>& fruits) {
    int n = fruits.size();
    int left = 0, ans = 0;
    //声明了一个名为fruit_count的无序映射（unordered_map）该映射的键（key）和值（value）都是整数类型（int）。用于存储数组中每个元素出现的次数。
    unordered_map<int, int> fruit_count;
    for (int right = 0; right < n; ++right) {
        fruit_count[fruits[right]]++;//33312，就是三种类型
        while (fruit_count.size() > 2) {
        // ++left;
         fruit_count[fruits[left]]--;//以上三步始终保证水果类型只有两种，就只减去一种
         //我理解的这一步就是彻底换新的起始水果，也就是最左值
    if (fruit_count[fruits[left]] == 0) {//++left直到将第一个种类水果完全移除，出现次数为0
        fruit_count.erase(fruits[left]);//如果左边界元素的出现次数变为0，则从fruit_count中删除该元素。
            }
            ++left;
        }
        ans = max(ans, right - left + 1);//长度更新，选最大长度的，其实也是在判断长度是否被更新
    }
    return ans;
    }
};

数组5.2-76最小覆盖子串

有点难，后面再来搞明白

class Solution {
public:
    string minWindow(string s, string t) {
    //两个无序映射（unordered_map），分别命名为need和wind。
    //这两个映射的键（key）是字符类型（char），值（value）是整数类型（int）。
        unordered_map<char, int> need, win;
        //其实就是need哈希表存放t中每种字符及个数
        for (auto &i : t) ++need[i]; 
//遍历字符串t中的每个字符，并将当前字符赋值给变量i。
//将字符i作为键，在need映射中查找对应的值。如果找到了对应的值则将其加1如果没有找到对应的值，则将其初始化为1。
        int left = 0, right = 0, count = 0, len = INT_MAX, start = 0;
        //开始对窗口进行处理
        while (right < s.size()) {
            if (need.find(s[right]) != need.end()) {//检查s当前字符是否存在于need映射中。
                ++win[s[right]];//扩充窗口
                if (win[s[right]] == need[s[right]]) {
                    ++count;//保证要覆盖t
                }
            }
            //如果此时的窗口值完全覆盖了我们需要的子串，就要进行缩小窗口的操作
            while (count == need.size()) {
                //这里是进行更新我们的最小子串
                if (len > right - left + 1) {
                    start = left;
                    len = right - left + 1;//取刚开始还没有缩减窗口的长度，后面也会改变的
                }
                if (need.find(s[left]) != need.end()) {
                    if (need[s[left]] == win[s[left]]) {
                        --count;
                    }
                    //将窗口左侧的值进行减一，缩小窗口
                    --win[s[left]];
                }
                ++left;//其实边界已经往前移动，删除一位数字，变成新的起始数字，右边界接着改变，往右移动
                //但是还是在循环要求满足覆盖t元素的间隔内
            }
            ++right;//结束标志，直达起始位置移到最后，满不满足，最短长度已经更新为最小长度不会改变
        }
        return len == INT_MAX ? "" : s.substr(start, len);
    }
};

数组6-螺旋矩阵||

class Solution {//就是规律题，特殊点就是中间值，循环圈数，每一条长度，每多循环一圈，左闭右开减少一位
public:
    vector<vector<int>> generateMatrix(int n) {
  vector<vector<int>> res(n, vector<int>(n, 0)); // 使用vector定义一个二维数组
        int startx = 0, starty = 0; // 定义每循环一个圈的起始位置
        int loop = n / 2; // 每个圈循环几次，例如n为奇数3，那么loop = 1 只是循环一圈
        int mid = n / 2; // 矩阵中间的位置，例如：n为3， 中间的位置就是(1，1)，n为5，中间位置为(2, 2)
        int count = 1; // 用来给矩阵中每一个空格赋值
        int offset = 1; // 需要控制每一条边遍历的长度，每次循环右边界收缩一位，左闭右开
        int i,j;
        while (loop --) {
            i = startx;
            j = starty;
            // 下面开始的四个for就是模拟转了一圈
            // 模拟填充上行从左到右(左闭右开)
            for (j = starty; j < n - offset; j++) {//00 01
                res[startx][j] = count++;
            }                                 
            // 模拟填充右列从上到下(左闭右开)
            for (i = startx; i < n - offset; i++) {//02 12
                res[i][j] = count++;
            }
            // 模拟填充下行从右到左(左闭右开)
            for (; j > starty; j--) {//22 21 
                res[i][j] = count++;
            }
            // 模拟填充左列从下到上(左闭右开)
            for (; i > startx; i--) {//20 10
                res[i][j] = count++;
            }
            // 下一圈开始的时候，起始位置要各自加1， 例如：第一圈起始位置是(0, 0)，第二圈起始位置是(1, 1)
            startx++;
            starty++;
            // offset 控制每一圈里每一条边遍历的长度
            offset += 1;
        }
        // 如果n为奇数的话，需要单独给矩阵最中间的位置赋值
        if (n % 2) {
            res[mid][mid] = count;
        }
        return res;
    }
};

数组7-总结