Leetcode（二）-哈希表（一）

771. 宝石与石头

思路：两种方法，一种是直接暴力匹配，时间复杂度为O(nm)，另外一种是先用Hash存宝石串，然后再遍历

class Solution {
public:
    int numJewelsInStones(string J, string S) {
        
        int lenJ = J.length();
        int lenS = S.length();
        int Hash[58] = {0};
        int res = 0;
        if (lenJ==0||lenS==0) return res;
        for(int i=0;i<lenJ;i++)
            Hash[J[i]-65] = 1;
        for(int i=0;i<lenS;i++)
        {
            if(Hash[S[i]-65]==1) res++;
        }
        return res;
    }
};

575. 分糖果

思路：再补

class Solution {
public:
    int distributeCandies(vector<int>& candies) {
        
        set<int> s;
        for(int i=0;i<candies.size();i++)
        {
            s.insert(candies[i]);
        }
        int kindsNum = s.size();
        int totalNum = candies.size()/2;
        return min(kindsNum,totalNum);
    }
};

884. 两句话中的不常见单词

思路：拼接字符串，查看字符串出现一次的次数

class Solution {
public:
    vector<string> uncommonFromSentences(string A, string B) {
        
        unordered_map<string,int> hashmap;
        vector<string> res;
        string word;
        stringstream out(A+" "+B);
        while(out>>word)
            hashmap[word]++;
        for(auto iter=hashmap.begin();iter!=hashmap.end();iter++)
        {
            if(iter->second == 1)
                res.push_back(iter->first);
        }
        return res;
    }
};

202. 快乐数

思路：直接模拟n被拆分为各个位平方和，如果再次出现n，则直接判false

class Solution {
public:
    bool isHappy(int n) {
        
        unordered_set<int> s;
        int sum = 0;
        while(n!=1)
        {
            s.insert(n);
            sum = 0;
            while(n!=0)
            {
                sum+=(n%10)*(n%10);
                n/=10;
            }
            n = sum;
            if(s.count(n)!=0) return false;
        }
        return true;
    }
};

204. 计数质数

思路：埃拉托斯特尼筛法

class Solution {
public:
    int countPrimes(int n) {
        
        vector<bool> isPrime(n+1,true);
        int res = 0;
        for(int i=2;i<n;i++)
        {
            if(isPrime[i])
            {
                res++;
                for(int j=2;i*j<n;j++)
                {
                    isPrime[i*j] = false;
                }
            }
        }
        return res;
    }
};

645. 错误的集合

思路：暴力，遍历三次，缺失的值：SUM(1...N)-SUM(set(1...N))，重复的值：SUM(array[i...N])-SUM(set(1...N))

class Solution {
public:
    vector<int> findErrorNums(vector<int>& nums) {
        set<int> s;
        vector<int> res;
        for(int i=0;i<nums.size();i++) s.insert(nums[i]);
        int sumSet = 0;
        int sumTotal = 0;
        int sumN = 0;
        for(int i=0;i<nums.size();i++) sumTotal+= nums[i];
        for(auto iter = s.begin();iter!=s.end();iter++) sumSet+=*iter;
        for(int i=1;i<=nums.size();i++) sumN+=i;
        res.push_back(sumTotal-sumSet);
        res.push_back(sumN-sumSet);
        return res;
    }
};

还有一种就所有都叠加一遍次数，然后统计次数为0还是次数==2的（因为重复的和缺失的都只缺失一次）

class Solution {
public:
    vector<int> findErrorNums(vector<int>& nums) {
        
        vector<int> Hash(nums.size()+1,0);
        vector<int> res(2,0);
        for(auto num:nums)
            Hash[num]++;
        for(int i=1;i<=nums.size();i++)
        {
            if(Hash[i]==2) res[0] = i;
            if(Hash[i]==0) res[1] = i;
        }
        return res;
    }
};