Leetcode（二）-哈希表（二）

970. 强整数

思路：set大法好，直接暴力，因为bound 区间范围为1e6次方， max = log10^6 = 19.9316 max取20 ，所以直接遍历到20也可以

或者直接采用模拟的方法

class Solution {
public:
    vector<int> powerfulIntegers(int x, int y, int bound) {
        
        set<int> s;
        for(int a=1;a<bound;a*=x)
        {
            for(int b=1;a+b<=bound;b*=y)
            {
                s.insert(a+b);
                if(y==1) break; 
            }
            if(x==1) break;
        }
        vector<int> res;
        for(auto iter=s.begin();iter!=s.end();iter++)
            res.push_back(*iter);
        return res;
    }
};

454. 四数相加 II

思路：纯暴力，先统计A+B的和的组合数，如果A+B+C+D==0，则只需要再查找-(A+B)的和的次数即可，时间复杂度为O(n^2)

class Solution {
public:
    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
        
        map<int,int> map;
        map.clear();
        int res = 0;
        for(const auto& a:A)
        {
            for(const auto& b:B)
            {
                map[a+b]++;
            }
        }
        for(const auto& c:C)
        {
            for(const auto& d:D)
            {
                res+=map[-(c+d)];
            }
        }
        return res;
    }
};

781. 森林中的兔子

思路：挺有意思的一道数学题，如果A说还有3只跟自己颜色一致，那么此颜色组合的大小应该为3+1（自己），然后统计该颜色组合有多少个 ceil(count(A))/t*t；

class Solution {
public:
    int numRabbits(vector<int>& answers) {
        unordered_map<int,int> map;
        int sum = 0,t = 0;
        for(const auto& ans : answers) ++map[ans];
        for(const auto& p : map)
        {
            t = p.first+1;
            sum+=ceil((double)p.second/t)*t;
        }
        return sum;
    }
};

560. 和为K的子数组

思路：暴力，直接两次遍历数组来求sum==k的次数，时间复杂度为O(n^2)

代码：

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        
        int size = nums.size(),res = 0;
        for(int i=0;i<size;i++)
        {
            int sum = 0;
            for(int j=i;j<size;j++)
            {
                sum+=nums[j];
                if(sum==k) res++;
            }
        }
        return res;
    }
};

思路：在暴力计算中，重复计算了很多遍，比如求n1+n2+n3，但是如果求n1+n2+n3+n4的时候其实不需要在继续去遍历n1,n2,n3，只需要将上一步结果进行保存即可sum[3]+n4，挺常用到的思路！！

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        
        unordered_map<int,int> map;
        map.clear();
        map[0] = 1;
        int sum = 0,res = 0;
        for(const auto& num:nums)
        {
            sum += num;
            res+=map[sum-k];
            map[sum]++;
        }
        return res;
    }
};

1. 两数之和

思路：1，可以直接暴力，但是时间复杂度为O（n^2），同时也可以利用Hash, 先将数组遍历一遍，然后再找有没有target-Hash[i]的存在。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        
        unordered_map<int,int> map;
        vector<int> res;
        for(int i=0;i<nums.size();i++)
        {
            if(map.count(target-nums[i]))
            {
                res.push_back(map[target-nums[i]]);
                res.push_back(i);
            }
            map[nums[i]] = i;
        }
        return res;
    }
};