Leetcode 刷题之哈希表

来源：互联网发布：英雄无敌5 mac版编辑：程序博客网时间：2024/05/18 15:53

滑动窗口
哈希表

滑动窗口

349. Intersection of Two Arrays

class Solution {public:    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {        set<int> rec(nums1.begin(),nums1.end());        set<int> res;        for(int idx = 0; idx < nums2.size(); idx++) {            if(rec.find(nums2[idx]) != rec.end()) {                res.insert(nums2[idx]);            }        }        return vector<int>(res.begin(), res.end());    }};

350. Intersection of Two Arrays II

class Solution {public:    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {        map<int,int>mp1;        vector<int> res;        for(int idx = 0; idx < nums1.size(); idx++) {            mp1[nums1[idx]]++;        }        for(int idx = 0; idx < nums2.size(); idx++) {            if(mp1[nums2[idx]] > 0) {                res.push_back(nums2[idx]);                mp1[nums2[idx]]--;            }        }        return res;    }};

map的时间复杂度是O(nlogn)，空间复杂度是O(n)，底层实现是二叉平衡树。
unordered_map的时间复杂度是O(n)，空间复杂度是O(n)，底层实现是哈希表。

242. Valid Anagram

class Solution {public:    bool isAnagram(string s, string t) {        map<char, int> rec;        for(int idx = 0; idx < s.size(); idx++) {            rec[s[idx]]++;        }        for(int idx = 0; idx < t.size(); idx++) {            rec[t[idx]]--;            if(rec[t[idx]] < 0) {                return false;            }        }        for(map<char,int>::iterator it = rec.begin(); it != rec.end(); it++) {            if(it->second) {                return false;            }        }        return true;    }};

202. Happy Number

class Solution {public:    bool isHappy(int n) {        set<int> rec;        while(1) {            string str = to_string(n);            int tmp = 0;            for(char c:str) {                tmp += (c - '0')*(c - '0');            }            if(tmp == 1) {                return true;            }            if(rec.find(tmp) == rec.end()) {                rec.insert(tmp);            }            else {                return false;            }            n = tmp;        }        return true;    }};

290. Word Pattern

class Solution {public:    vector<string> split(string str, string pattern)    {        string::size_type pos;        vector<string> result;        str += pattern;        int size=str.size();        for(int i=0; i<size; i++)        {            pos=str.find(pattern,i);            if(pos<size)            {                string s = str.substr(i,pos-i);                result.push_back(s);                i = pos+pattern.size()-1;            }        }        return result;    }    bool wordPattern(string pattern, string str) {        map<char, string> rec;        map<string, char> rec2;        vector<string> strs = split(str, " ");        if(strs.size() != pattern.size()) {            return false;        }        for(int idx = 0; idx < pattern.size(); idx++) {            if(rec.find(pattern[idx]) == rec.end()) {                rec[pattern[idx]] = strs[idx];            }            else {                if(rec[pattern[idx]].compare(strs[idx])) {                    return false;                }            }            if(rec2.find(strs[idx]) == rec2.end()) {                rec2[strs[idx]] = pattern[idx];            }            else {                if(rec2[strs[idx]] != pattern[idx]) {                    return false;                }            }        }        return true;    }};

205. Isomorphic Strings

class Solution {public:    bool isIsomorphic(string s, string t) {        int s_len = s.size();        int t_len = t.size();        if(s_len != t_len) {            return false;        }        map<char, char> rec1;        map<char, char> rec2;        for(int idx = 0; idx < s_len; idx++) {            if(rec1.find(s[idx]) == rec1.end()) {                rec1[s[idx]] = t[idx];                }            else {                if(rec1[s[idx]] != t[idx]) {                    return false;                }            }            if(rec2.find(t[idx]) == rec2.end()) {                rec2[t[idx]] = s[idx];                }            else {                if(rec2[t[idx]] != s[idx]) {                    return false;                }            }        }        return true;    }};

451. Sort Characters By Frequency

class Solution {public:    string copy_chars(int cnt, char c) {        string res;        for(int idx = 0; idx < cnt; idx++) {            res += c;        }        return res;    }    string frequencySort(string s) {        string res;        map<char, int> rec;        for(char c:s) {            rec[c]++;        }        map<int,vector<char>> recs;        for(map<char, int>::iterator it = rec.begin(); it != rec.end(); it++) {            if(recs.find(it->second) == recs.end()) {                vector<char> tmp;                tmp.push_back(it->first);                recs.insert(make_pair(it->second, tmp));            }            else {                recs[it->second].push_back(it->first);            }        }        map<int,vector<char>>::reverse_iterator rit;        for (rit = recs.rbegin(); rit != recs.rend(); ++rit) {            int count = rit->first;            vector<char> chars = rit->second;            for(vector<char>::iterator it = chars.begin(); it != chars.end(); it++) {                res += copy_chars(count, *it);            }        }        return res;    }};

哈希表

454. 4Sum II

class Solution {public:    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {        assert(A.size() == B.size() || B.size() == C.size() ||                C.size() == D.size() || A.size() <= 500);        unordered_map<int,int> rec;        for(int idx1 = 0; idx1 < A.size(); idx1++) {            for(int idx2 = 0; idx2 < B.size(); idx2++) {                rec[A[idx1]+B[idx2]]++;            }        }        int res = 0;        for(int idx1 = 0; idx1 < C.size(); idx1++) {            for(int idx2 = 0; idx2 < D.size(); idx2++) {                int tar = -1*(C[idx1]+D[idx2]);                if(rec.find(tar) != rec.end()) {                    res += rec[tar];                }            }        }        return res;    }};

49. Group Anagrams

class Solution {public:    vector<vector<string>> groupAnagrams(vector<string>& strs) {        unordered_map<string, vector<string>> rec;        vector<vector<string>> res;        int len = strs.size();        if(!len) {            return res;        }        for(int i = 0; i < len; i++) {            string tmp = strs[i];            sort(tmp.begin(), tmp.end());            if(rec.find(tmp) == rec.end()) {                vector<string> new_item;                new_item.push_back(strs[i]);                rec[tmp] = new_item;            }                else {                rec[tmp].push_back(strs[i]);            }            }            for(unordered_map<string, vector<string>>::iterator it = rec.begin(); it != rec.end(); it++) {            res.push_back(it->second);        }            return res;    }};

447. Number of Boomerangs

class Solution {public:    int distanceTwoPoints(pair<int, int> p1, pair<int, int> p2) {        int res = (p1.first - p2.first)*(p1.first - p2.first);        res += (p1.second - p2.second)*(p1.second - p2.second);        return res;    }        int numberOfBoomerangs(vector<pair<int, int>>& points) {        int res = 0;        int len = points.size();        if(!len) {            return res;        }        for(int i = 0; i < len; i++) {            unordered_map<int, int> rec;            for(int j = 0; j < len; j++) {                if(i != j) {                    int dis = distanceTwoPoints(points[i], points[j]);                    rec[dis]++;                }                }                for(unordered_map<int,int>::iterator it = rec.begin(); it != rec.end(); it++) {                if(it->second >= 2) {                    res += it->second * (it->second-1);                }                }            }            return res;    }};

219. Contains Duplicate II

class Solution {public:    bool containsNearbyDuplicate(vector<int>& nums, int k) {        unordered_set<int> rec;        int len = nums.size();        for(int i = 0; i < len; i++) {            if(rec.find(nums[i]) != rec.end()) {                return true;            }               rec.insert(nums[i]);            if(rec.size() == k+1) {                rec.erase(nums[i-k]);            }            }        return false;    }};

217. Contains Duplicate

class Solution {public:    bool containsDuplicate(vector<int>& nums) {        set<int> rec;        for(int i = 0; i < nums.size(); i++) {            if(rec.find(nums[i]) != rec.end()) {                return true;            }            rec.insert(nums[i]);        }        return false;    }};

438. Find All Anagrams in a String

class Solution {public:    vector<int> findAnagrams(string s, string p) {        vector<int> res;        int len_s = s.size();        int len_p = p.size();        unordered_map<char, int> rec;         int fin = -1;        for(int idx = 0; idx < len_p; idx++) {            rec[p[idx]]++;        }        for(int idx = 0; idx < len_s; idx++) {            rec[s[idx]]--;              if(rec[s[idx]] == 0) {                rec.erase(s[idx]);                if(!rec.size()) {                    res.push_back(idx-len_p+1);                }                }                if(idx >= len_p-1) {                rec[s[idx-len_p+1]]++;                 if(rec[s[idx-len_p+1]] == 0) {                    rec.erase(s[idx-len_p+1]);                }                }            }            return res;    }};

220. Contains Duplicate III

class Solution {public:    bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {        set<long long> rec;        int len = nums.size();        long long tar = (long long)  t;        for(int idx = 0; idx < len; idx++) {            long long tmp_v = (long long) nums[idx];            bool isContain = rec.lower_bound(tmp_v-tar) != rec.end();            if(isContain) {                 bool isLower = (long long)*rec.lower_bound(tmp_v-tar) <= tmp_v+tar;                if(isLower) {                    return true;                }                }                rec.insert(tmp_v);            if(rec.size() == k+1) {                rec.erase(nums[idx-k]);            }        }           return false;    }};

149. Max Points on a Line

/** * Definition for a point. * struct Point { *     int x; *     int y; *     Point() : x(0), y(0) {} *     Point(int a, int b) : x(a), y(b) {} * }; */class Solution {public:    int gcd(int num1, int num2) {        while (num2) {            int temp = num2;             num2 = num1 % num2;            num1 = temp;        }        return num1;    }    int maxPoints(vector<Point>& points) {        int maxpt = 1;        int len = points.size();        if(!len) {            return 0;        }            for(int i = 0; i < len; i++) {            map<pair<int, int>, int> rec;            int rem = 0;            for(int j = i +1; j < len; j++) {                if(points[i].x == points[j].x && points[i].y == points[j].y) {                    rem++;                }                else {                    if(points[i].x == points[j].x) {                        rec[make_pair(INT_MAX, points[i].x)]++;                        }                       else {                        int diff_y = points[i].y - points[j].y;                        int diff_x = points[i].x - points[j].x;                        int gcd_v = gcd(diff_x, diff_y);                        diff_x /= gcd_v;                        diff_y /= gcd_v;                        rec[make_pair(diff_x, diff_y)]++;                       }                }            }            for(map<pair<int,int>,int>::iterator it = rec.begin(); it != rec.end(); it++) {                maxpt = max(maxpt, it->second+rem+1);            }              maxpt = max(maxpt, rem+1);        }            return maxpt;    }};

/** * Definition for a point. * struct Point { *     int x; *     int y; *     Point() : x(0), y(0) {} *     Point(int a, int b) : x(a), y(b) {} * }; */class Solution {public:    int gcd(int num1, int num2) {        while (num2) {            int temp = num2;             num2 = num1 % num2;            num1 = temp;        }        return num1;    }    int maxPoints(vector<Point>& points) {        int maxpt = 1;        int len = points.size();        if(!len) {            return 0;        }            for(int i = 0; i < len; i++) {            unordered_map<string, int> rec;            int rem = 0;            int vertical = 0;            for(int j = i +1; j < len; j++) {                if(points[i].x == points[j].x && points[i].y == points[j].y) {                    rem++;                }                else {                    if(points[i].x == points[j].x) {                        vertical++;                        }                       else {                        int diff_y = points[i].y - points[j].y;                        int diff_x = points[i].x - points[j].x;                        int gcd_v = gcd(diff_y, diff_x);                        diff_y /= gcd_v;                        diff_x /= gcd_v;                        string key_s = to_string(diff_y) + " " + to_string(diff_x);                        rec[key_s]++;                    }                }            }            for(unordered_map<string,int>::iterator it = rec.begin(); it != rec.end(); it++) {                maxpt = max(maxpt, it->second+rem+1);            }              maxpt = max(maxpt, rem+1);            maxpt = max(maxpt, vertical+rem+1);        }            return maxpt;    }};

阅读全文

0 0