《剑指 Offer II》—数组04

学习计划链接

剑指offer——学习计划

题目解析

1. 剑指 Offer II 010. 和为 k 的子数组

1) 问题描述

2) 思路分析

辅助哈希表记录前缀和
求sum[i~j]=k,即：sum[i]-sum[j-1]=k;即sum[i]-k==sum[j-1];

1. 使用hash表存储前i个数的和sum和个数。
2. 判断是否存在何为sum-k的数，若存在，则结果加上这个个数。
3. 在hash表中插入sum[i]； 若hash表中存在sum值，则对应的值（和为sum的个数）+1；否则，置为1.

3) leetcode链接

剑指 Offer II 010. 和为 k 的子数组

4) 代码实现

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        //使用hash表存储前i个数的和sum和个数。
        unordered_map<int,int> hash;
        int sum=0;
        int counts=0;
        hash[0]=1;
        //求num[i,j]=k,即：sum[i]-sum[j-1]=k;即sum[i]-k==sum[j-1];
        for(const auto &n:nums)
        {
            sum+=n;

            //判断是否存在何为sum-k的数，若存在，则结果加上这个个数。
            if(hash.count(sum-k))
                counts+=hash[sum-k];
                
            //若hash表中存在sum值，则对应的值（和为sum的个数）+1；否则，置为1.
            if(hash.count(sum))
                hash[sum]++;
            else
                hash[sum]=1;
        }
        return counts;
    }
};

2. 剑指 Offer II 011. 0 和 1 个数相同的子数组

1) 问题描述

2) 思路分析

求具有相同数量的0和1的最长连续子数组。
思路：① 将所有0替换为-1，则转换为求最长连续子数组和为0；② 若前j个数的和为S，前i个数的和同为S,则说明j+1~i的和为0。

1. 遍历数组，求前i个数的和（如果当前值为0，则替换为-1，即和-1）。
2. 查看map中，是否已经存在前j项和为sum？
3. 存在。记录其对应下标j，此时说明第j~i个元素和为0，计算更新maxLen=max(maxLen,i-j);
4. 若不存在，则将<sum,i>插入到map中记录。

3) leetcode链接

剑指 Offer II 011. 0 和 1 个数相同的子数组

4) 代码实现

class Solution {
public:
//求具有相同数量的0和1的最长连续子数组。思路：将所有0替换为-1，则转换为求最长连续子数组和为0。
    int findMaxLength(vector<int>& nums) {
        //1.使用unordered_map存储前i项和和i；
        unordered_map<int,int> ump;
        ump[0]=-1;        
        int sum=0;        //前n项和
        int maxLen=0;     //保留具有相同数量的0和1的连续子数组的长度
        
        //若前j个数的和为S，前i个数的和同为S,则说明j+1~i的和为0。
        for(int i=0;i<nums.size();++i)
        {
            //求前i个数的和
            if(nums[i]==0)
                --sum;
            else
                ++sum;
            //判断该数是否已经存在，找出其下标j，此时说明第j~i个元素和为0，计算更新maxLen
            if(ump.count(sum))
            {
                //j表示：上一个和为sum的下标值
                int j=ump[sum];
                maxLen=max(maxLen,i-j);
            }
            //否则，插入前i项和及i到ump中，记录起来。
            else
            {
                ump[sum]=i;
            }
        }
        return maxLen;
    }
};

3. 剑指 Offer II 012. 左右两边子数组的和相等

1) 问题描述

2) 思路分析

两遍遍历：
某数左侧和右侧的值相等，求下标i。假设totals为总和，sum[i]为前i项和，则需要找到满足totals-sum[i]（i后部分）== sum[i]-num[i]条件的下标i，否则,则未找到。

1. 遍历数组，求数组总和totals
2. 二次遍历数组，并判断[0,i-1]区间的和与[i+1,size-1]区间的和是否相等，若相等,则返回下标；否则，继续遍历，若遍历到结束还未找到，则说明不存在这样的下标，返回-1。

3) leetcode链接

剑指 Offer II 012. 左右两边子数组的和相等

4) 代码实现

class Solution {
public:
    int pivotIndex(vector<int>& nums){
        //totals：nums的总和
        //1. 从头开始相加totals
        int totals=0;
        for(auto &n:nums)
        {
            totals+=n;
        }

        int sum=0;
        for(int i=0;i<nums.size();++i)
        {
            sum+=nums[i];
            //从nums[i]分割成前半边和后半边
            if(sum-nums[i]==totals-sum)
            {
                return i;
            }
        }      
        return -1;
    }
};

4. 剑指 Offer II 013. 二维子矩阵的和

1) 问题描述

2) 思路分析

辅助空间
（以空间换时间——用_sum二维数组保存matrix中以[i,j]为左上顶点，[rows-1,cols-1]为右下顶点的子矩阵）

1. 为_sum开辟rows+1行cols+1列空间，并将其进行初始化为0
2. 初始化——自矩阵右下角进行计算。 _sum[i][j]=_sum[i][j+1]+_sum[i+1][j]-_sum[i+1][j+1]+matrix[i][j];
3. 求子矩阵的和——_sum[row1][col1]-_sum[row1][col2+1]-_sum[row2+1][col1]+_sum[row2+1][col2+1]

3) leetcode链接

剑指 Offer II 013. 二维子矩阵的和

4) 代码实现

class NumMatrix {
public:
    NumMatrix(vector<vector<int>>& matrix) {
        if(matrix.size()==0||matrix[0].size()==0)
        {
            return;
        }
        int rows=matrix.size();
        int cols=matrix[0].size();
        //1. 为_sum开辟rows+1行cols+1列空间，并将其进行初始化为0。
        _sum.resize(rows+1,vector<int>(cols+1,0));
        for(int i=rows-1;i>=0;--i)
        {
            for(int j=cols-1;j>=0;--j)
            {
            
                // if(i==rows-1&&j==cols-1)
                //     _sum[i][j]=matrix[i][j];
                // else
                //自矩阵右下角进行计算。
                _sum[i][j]=_sum[i][j+1]+_sum[i+1][j]-_sum[i+1][j+1]+matrix[i][j];
            }
        }
    }
    
    int sumRegion(int row1, int col1, int row2, int col2) {
        return _sum[row1][col1]-_sum[row1][col2+1]-_sum[row2+1][col1]+_sum[row2+1][col2+1];
    }
private:
    vector<vector<int>> _sum;   //以空间换时间。用_sum二维数组保存matrix子矩阵矩阵[i,j]~[rows,cols]的和。
};
//以下代码：超出时间限制
// class NumMatrix {
// public:
//     NumMatrix(vector<vector<int>>& matrix) {
//         if(matrix.size()==0||matrix[0].size()==0)
//         {
//             return;
//         }
//         int rows=matrix.size();
//         int cols=matrix[0].size();
//         _matrix.resize(rows);
//         for(int i=0;i<rows;++i)
//         {
//             _matrix[i].resize(cols);
//             for(int j=0;j<cols;++j)
//             {
//                 _matrix[i][j]=matrix[i][j];
//             }
//         }
//     }
    
//     int sumRegion(int row1, int col1, int row2, int col2) {
//         int sum=0;
//         for(int i=row1;i<=row2;++i)
//         {
//             for(int j=col1;j<=col2;++j)
//                 sum+=_matrix[i][j];
//         }
//         return sum;
//     }
// private:
//     vector<vector<int>> _matrix;
// };
/**
 * Your NumMatrix object will be instantiated and called as such:
 * NumMatrix* obj = new NumMatrix(matrix);
 * int param_1 = obj->sumRegion(row1,col1,row2,col2);
 */