【LeetCode】哈希表 hash_table（共88题）

【1】Two Sum （2018年11月9日，k-sum专题，算法群衍生题）

给了一个数组 nums， 和一个 target 数字，要求返回一个下标的 pair， 使得这两个元素相加等于 target 。

题解：我这次最大范围的优化代码， hash-table + one pass，时间复杂度 O(N)，空间复杂度 O(N)。重点在于动态找，一边生成hash-table的同时去找答案，不是先生成hash-table再开始找答案。

//这种类似 hash 的能用 unordered_map 就不要用 map, hash-table + one pass
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        const int n = nums.size();
        unordered_map<int, int> mp;
        vector<int> ans(2);
        for (int i = 0; i < n; ++i) {
            int key = target - nums[i];
            if (mp.find(key) != mp.end()) {
                ans[0] = mp[key];
                ans[1] = i;
                break;
            }
            mp[nums[i]] = i;
        }
        return ans;
    }
};

  

【3】Longest Substring Without Repeating Characters （2019年1月19日，谷歌决战复习，sliding window）

给了一个字符串 s， 返回最长的没有重复字符子串长度。

题解：sliding window， O(N)的算法，同 438题，有一个 unordered_map, 一个 begin，一个end, 开始数就行了。

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        const int n = s.size();
        int begin = 0, end = 0;
        int ret = 0;
        unordered_map<char, int> mp;
        while (end < n) {
            char c = s[end]; 
            mp[c]++;
            while (mp[c] > 1) {
                char tempc = s[begin];
                mp[tempc]--;
                begin++;
            }
            ret = max(end - begin + 1, ret);
            end++;
        }
        return ret;
    }
};

 

【18】4Sum （2018年11月9日，k-sum专题，算法群衍生题）

 

【30】Substring with Concatenation of All Words （2019年1月19日，谷歌决战复习，sliding window）（提出了一种新的想法）

给了一个 string s，一个 words list, 里面每个 word 一样长，找出 s 中所有子串的位置，子串需要包含 list 中的每个单词。（任意顺序）

Example 1:
Input:
  s = "barfoothefoobarman",
  words = ["foo","bar"]
Output: [0,9]
Explanation: Substrings starting at index 0 and 9 are "barfoor" and "foobar" respectively.
The output order does not matter, returning [9,0] is fine too.
Example 2:
Input:
  s = "wordgoodgoodgoodbestword",
  words = ["word","good","best","word"]
Output: []

题解：sliding window， 用个map记录单词出现的次数。用2 pointers来滑动窗口。遍历 s 数组，O(N * M) 的复杂度

class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
        const int n = s.size(), m = words.size();
        if (n == 0 || m == 0) { return vector<int>(); }
        const int size = words[0].size();
        if (n < m * size) {return vector<int>();}
        unordered_map<string, int> mp;
        for (auto w : words) {
            mp[w]++;
        }
        vector<int> ret;
        for (int i = 0; i + m * size <= n; ++i) {
            unordered_map<string, int> mpcopy = mp;
            int k = 0;
            int start = i;
            while (k < m) {
                string str = s.substr(start, size);
                if (mpcopy.find(str) == mpcopy.end() || mpcopy[str] < 1) {
                    break;
                }
                mpcopy[str]--;
                ++k;
                start += size;
            }
            if (k == m) {
                ret.push_back(i);
            }
        }
        return ret;
    }
};

 

【36】Valid Sudoku 

【37】Sudoku Solver 

 

【49】Group Anagrams (2019年1月23日，谷歌tag复习)

给了一个单词列表，给所有的异构词分组。

 

Input: ["eat", "tea", "tan", "ate", "nat", "bat"],
Output:
[
  ["ate","eat","tea"],
  ["nat","tan"],
  ["bat"]
]

 

题解：我的解法，hashmap + sort。不是最优秀的解法。还有什么用 26个素数代替法，这个更快吧。

代码不贴了。

 

【76】Minimum Window Substring （2018年1月19日，谷歌决战复习，sliding window）

给了两个字符串，一个 S，一个T，在 S 中找一个子串，包含t中所有的字符，除了包含t中所有的字符之外，还可以用冗余的字符。 

Example:
Input: S = "ADOBECODEBANC", T = "ABC"
Output: "BANC"

题解：还是 hash-map + sliding window，模版套路，先init一个unordered_map, 然后用begin，end，count 这三个变量搞一搞。

class Solution {
public:
    string minWindow(string s, string t) {
        const int ssize = s.size(), tsize = t.size();
        if (tsize > ssize) {return "";}
        unordered_map<char, int> mp;
        for (auto c : t) {
            mp[c]++;
        }
        int count = 0;
        int begin = 0, end = 0;
        string ret = "";
        int len = INT_MAX;
        while (end < ssize) {
            char tempc = s[end];
            if (mp.find(tempc) == mp.end()) {
                ++end; continue;
            }
            mp[tempc]--;
            if (mp[tempc] == 0) {
                count++;
            }
            while (count == mp.size()) {
                len = end - begin + 1;
                string tempAns = s.substr(begin, len);
                if (ret.empty() || len < ret.size()) {
                    ret = tempAns;
                }
                char c = s[begin];
                if (mp.find(c) == mp.end()) {
                    ++begin; continue;
                }
                mp[c]++;
                if (mp[c] > 0) {
                    count--;
                }
                begin++;
            }
            ++end;
        }
        return ret;
    }
};

 

【85】Maximal Rectangle 

【94】Binary Tree Inorder Traversal 

【136】Single Number 

【138】Copy List with Random Pointer 

 

【149】Max Points on a Line （2018年11月10号，算法群）

给了 2D 平面上的 n 个点，两个点能组成一条直线，返回一条直线上最多能有几个点。

题解：本题在数学分类上有，不再这里重复写。math：https://www.cnblogs.com/zhangwanying/p/9790007.html

 

【159】Longest Substring with At Most Two Distinct Characters （2019年1月19日，谷歌决战复习，sliding window）

给了一个字符串 s，返回一个最长的子串，里面最多包含两个unique的字符。

Example 1:
Input: "eceba"
Output: 3
Explanation: t is "ece" which its length is 3.
Example 2：
Input: "ccaabbb"
Output: 5
Explanation: t is "aabbb" which its length is 5.

题解：unordered_map + sliding window， 依旧是 一个unordered_map, 三个变量， begin， end， cnt

class Solution {
public:
    int lengthOfLongestSubstringTwoDistinct(string s) {
        const int n = s.size();
        if (n <= 2) { return n; }
        unordered_map<char, int> mp;
        int begin = 0, end = 0, cnt = 0;
        int ret = 2;
        while (end < n) {
            char c = s[end];
            mp[c]++;
            if (mp[c] == 1) {
                cnt++;
            }
            while (cnt > 2) {
                char t = s[begin];  //这里写的是t，下面写成了c，debug了好久好久啊，哭死
                mp[t]--;
                if (mp[t] == 0) {
                    cnt--;
                }
                ++begin;
            }
            int len = end - begin + 1;
            ret = max(len, ret);
            end++;
        }
        return ret;
    }
};

 

【166】Fraction to Recurring Decimal 

【170】Two Sum III - Data structure design 

【187】Repeated DNA Sequences 

【202】Happy Number 

【204】Count Primes 

【205】Isomorphic Strings 

【217】Contains Duplicate 

【219】Contains Duplicate II 

【242】Valid Anagram 

【244】Shortest Word Distance II 

【246】Strobogrammatic Number 

给了一个字符串代表一个数字，返回这个数字 upside down 之后是不是和原来数字一样。（返回布尔类型）

Example 1:
Input:  "69"
Output: true

Example 2:
Input:  "88"
Output: true

Example 3:
Input:  "962"
Output: false

题解：用个 map 表示数字字符上下颠倒后的对应数字字符。务必写全：mp['0'] = '0', mp['1'] = '1', mp['6'] = '9', mp['8'] = '8', mp['9'] = '6';

class Solution {
public:
    bool isStrobogrammatic(string num) {
        map<char, char> mp;
        mp['0'] = '0', mp['1'] = '1', mp['6'] = '9', mp['8'] = '8', mp['9'] = '6';
        string temp = num;
        reverse(temp.begin(), temp.end());
        for (auto& p : temp) {
            if (mp.find(p) == mp.end()) {return false;}
            p = mp[p];
        }
        return temp == num;
    }
};

 

【249】Group Shifted Strings 

【266】Palindrome Permutation 

【274】H-Index 

【288】Unique Word Abbreviation 

【290】Word Pattern 

【299】Bulls and Cows 

【311】Sparse Matrix Multiplication 

【314】Binary Tree Vertical Order Traversal 

【325】Maximum Size Subarray Sum Equals k 

【336】Palindrome Pairs 

【340】Longest Substring with At Most K Distinct Characters 

【347】Top K Frequent Elements 

【349】Intersection of Two Arrays （2018年11月6日，算法群相关题）

给了两个数组，返回他们交叠的元素，如果有重复元素的话，只返回一个就行了。

题解：直接用 set 解了。

//题意是给了两个数组，返回他们的重复元素.
//我是用了两个set去重，然后O(n) 的时间复杂度遍历出结果。
class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        set<int> st1(nums1.begin(), nums1.end()), st2(nums2.begin(), nums2.end());
        vector<int> ans;
        for (auto num : st1) {
            if (st2.find(num) != st2.end()) {
                ans.push_back(num);
            }
        }
        return ans;
    }
};

 

【350】Intersection of Two Arrays II (2018年11月6日，算法群)

给了两个数组，返回他们所有交叠的元素，元素可以任意顺序返回，但是如果一个元素在A，B数组中都出现多次，需要返回公共的多次。

Example 1:
Input: nums1 = [1,2,2,1], nums2 = [2,2]
Output: [2,2]

Example 2:
Input: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
Output: [4,9]

题解：用两个map记录每个数组的元素和元素个数，然后遍历一个map，对于两个数组都存在的元素t， 在ret数组里面插入 min(cnt1[t], cnt2[t]). 时间复杂度是 O(N)，肯定是线性的。

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        vector<int> ans;
        cnt1 = genMap(nums1);
        cnt2 = genMap(nums2);
        for (auto p : cnt1) {
            int t = p.first, times = min(cnt1[t], cnt2[t]);
            for (int i = 0; i < times; ++i) {
                ans.push_back(t);
            }
        }
        return ans;
    }
    map<int, int> genMap(vector<int>& nums) {
        map<int, int> ret;
        for (auto p : nums) {
            ret[p]++;
        }
        return ret;
    }
    map<int, int> cnt1, cnt2;
};

还有一种方法就是用元素比较少的数组建立map，然后O(N)的遍历另外一个数组。

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        const int n = nums1.size(), m = nums2.size();
        map<int, int> cnt =  n <= m ? genMap(nums1) : genMap(nums2);
        vector<int> ans = n > m ? genAns(nums1, cnt) : genAns(nums2, cnt);
        return ans;
    }
    map<int, int> genMap(const vector<int>& nums) {
        map<int, int> ret;
        for (auto p : nums) {
            ret[p]++;
        }
        return ret;
    }
    vector<int> genAns(const vector<int>& nums, map<int, int>& cnt) {
        vector<int> ans;
        for (auto p : nums) {
            if (cnt.find(p) != cnt.end() && cnt[p] > 0) {
                cnt[p]--;
                ans.push_back(p);
            } 
        }
        return ans;
    }
};

本题还有三个follow up：

（1）What if the given array is already sorted? How would you optimize your algorithm?

如果数组已经排好序了，我就不用map了，每个数组用一个指针遍历，相同元素就加到ans数组中。时间复杂度O(N + M)，省掉了map。

（2）What if nums1's size is small compared to nums2's size? Which algorithm is better?

 如果nums1的size很小，那我就用nums1建立map，然后遍历nums2，往答案数组里面加元素。

（3）What if elements of nums2 are stored on disk, and the memory is limited such that you cannot load all elements into the memory at once?

nums2用数据流读出来（或者 read chunks of array that fit the memory），nums1计算一个map出来，每次nums2中有个元素在map1中对应，就把map1[x]--。

discuss：如果两个array都巨大，memory读不出来，那就先external sort indivisually，每次从排序好的数组里面读出来两个元素，交叠。就和 follow-up1 一样。

 

【355】Design Twitter 

【356】Line Reflection 

【358】Rearrange String k Distance Apart 

【359】Logger Rate Limiter 

【380】Insert Delete GetRandom O(1) 

【381】Insert Delete GetRandom O(1) - Duplicates allowed 

【387】First Unique Character in a String 

 

【389】Find the Difference 

 

【409】Longest Palindrome （2018年11月14日，为了冲题数做的简单题）（2019年2月18日打卡群复习）

给了一个字符串包含大小写的英文字母（区分大小写，相当于两个字母），问用这个字符串里面的这些字母最长能组成多长的回文串。

题解：我用了一个 map 记录每个字母出现了几次，如果出现了偶数次就直接加次数，出现了奇数次就加奇数次减一。此外，如果有奇数次的话， 最后答案要加1，因为那个字母可以放中心。 

class Solution {
public:
    int longestPalindrome(string s) {
        const int n = s.size();
        unordered_map<int, int> mp;
        for (auto c : s) { mp[c]++; }
        int ret = 0;
        int add1 = 0;
        for (auto p : mp) {
            if (p.second % 2) {
                add1 = 1;
                ret += p.second - 1;
            } else {
                ret += p.second;
            }
        }
        ret += add1;
        return ret;
    }
};

 

【438】Find All Anagrams in a String （2018年1月19日，谷歌决战复习，sliding window）

类似的题目有： 

3. Longest Substring Without Repeating Characters

30. Substring with Concatenation of All Words

76. Minimum Window Substring

159. Longest Substring with At Most Two Distinct Characters

438. Find All Anagrams in a String

给了一个字符串 s 和字符串 p，找出 s 中的所有子串，和字符串 p 异构。返回所有满足条件的 s 子串的begin index数组。

题解：这个题暴力解法 tle，我们想一个 O(N+M)的方法。主要就是用类似于一个 sliding window 的写法。

我们用一个 map 存储所有 p 的字符和对应的个数。然后用两个变量 begin 和 end 当作 2 pointers，用 count 变量记录当前子串中已经符合的字符数量。当count == mp.size的时候，我们考虑往前移动 begin 指针。

//O(N)
class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        vector<int> ans;
        if (s.empty() || p.empty()) {
            return ans;
        }
        const int n = s.size(), m = p.size();
        unordered_map<char, int> mp;
        for (auto c : p) {
            mp[c]++;
        }
        int count = 0;
        int begin = 0, end = 0;
        while (end < n) {
            char c = s[end++];
            if (mp.find(c) != mp.end()) {
                mp[c]--;
                if(mp[c] == 0) {
                    count++;
                }
            }
            while (count == mp.size()) {
                char e = s[begin];
                if (end - begin == m) {
                    ans.push_back(begin);
                }
                if (mp.find(e) != mp.end()) {
                    mp[e]++;
                    if (mp[e] >= 1) {
                        count--;
                    }
                }
                begin++;
            }
        }
        return ans;
    }
};

 

【447】Number of Boomerangs 

【451】Sort Characters By Frequency （2018年11月14日，为了冲刺题数）

给了一个字符串 S， 要求给它重新排序，排序的规则是出现次数多的字母堆在一起放前面。

题解：无，我是用了两个map。（有没有更优解不知道，有点不用脑子做题了快） 

class Solution {
public:
    string frequencySort(string s) {
        int n = s.size();
        unordered_map<char, int> mp;
        for (auto c : s) {
            mp[c]++;
        }
        map<int, vector<char>> mp2;
        for (auto p : mp) {
            mp2[p.second].push_back(p.first);
        }
        string ret = "";
        for (auto p : mp2) {
            int cnt = p.first; vector<char> vec = p.second;
            for (auto e : vec) {
                ret = string(cnt, e) + ret;
            }
        }
        return ret;
    }
};

 

【454】4Sum II （2018年11月9日，算法群）

给了四个长度一样的数组A，B，C，D，问从这四个数组中每个数组都选出一个数，这四个数加起来为 0 的种数一共有多少种。

题解：早上无聊看了qc的极客时间，他也就总结了两种有效的方法对于【15】3 Sum这种题型。具体可以看 数组 或者 2 pointers 的专题。不过我觉着都一样吧。

本题就是 hash， 把A，B数组任意两个数的和存在一个 unordered_map 里面，然后遍历 C，D 数组，选择两个元素相加，看在 hash 里面能不能找到这两个数和的相反数。时间复杂度是 O(N^2)。但是需要注意的是 map 这题要 200+ms， unordered_map  只需要 100+ ms。 

//unordered_map beats 90%+, map beats 30%+
class Solution {
public:
    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
        unordered_map<int, int> mapAB = genMap(A, B);
        int ans = 0;
        for (int i = 0; i < C.size(); ++i) {
            for (int j = 0; j < D.size(); ++j) {
                int value = C[i] + D[j];
                if (mapAB.find(-value) != mapAB.end()) {
                    ans += mapAB[-value];
                }
            }
        }
        return ans;
    }
    unordered_map<int, int> genMap(const vector<int>& A, const vector<int>& B) {
        unordered_map<int, int> cnt;
        for (int i = 0; i < A.size(); ++i) {
            for (int j = 0; j < B.size(); ++j) {
                int summ = A[i] + B[j];
                cnt[summ]++;
            }
        }
        return cnt;
    }
    
};

  

【463】Island Perimeter （计算岛的周长）（2018年11月13日，为了冲点题数做的）（2019年2月4日，算法群打卡）

给了一个二维的grid，里面是 0/ 1 矩阵， 0代表水，1代表陆地。一个小方块的边长是 1。 问陆地组成的岛的周长是多少。

Input:
[[0,1,0,0],
 [1,1,1,0],
 [0,1,0,0],
 [1,1,0,0]]

Output: 16
Explanation: The perimeter is the 16 yellow stripes in the image below:

 

题解：我直接二维数组遍历了，没用搜索。

class Solution {
public:
    int islandPerimeter(vector<vector<int>>& grid) {
        int ret = 0;
        int n = grid.size(), m = grid[0].size();
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                int temp = 0;
                if (grid[i][j] == 1) {
                    if (i == 0) {temp += 1;}
                    if (i == n - 1) {temp += 1;}
                    if (j == 0) {temp += 1;}
                    if (j == m - 1) {temp += 1;}
                    for (int k = 0; k < 4; ++k) {
                        int newx = i + dirx[k], newy = j + diry[k];
                        if (newx < 0 || newx >= n || newy < 0 || newy >= m) {continue;}
                        if (grid[newx][newy] == 0) {temp += 1;}
                    }
                }
                ret += temp;
            }
        }
        return ret;
    }
    int dirx[4] = {-1, 0, 1, 0};
    int diry[4] = {0, -1, 0, 1};
    
};

2019年2月4日更新。看了花花酱的视频感觉和我一开始想的差不多。时间复杂度都是 O(N^3)

class Solution {
public:
    int islandPerimeter(vector<vector<int>>& grid) {
        int ret = 0;
        int n = grid.size(), m = grid[0].size();
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                if (grid[i][j] == 1) {
                    ret += 4;
                    if (i > 0 && grid[i-1][j]) { --ret; } 
                    if (i < n-1 && grid[i+1][j]) { --ret; }
                    if (j > 0 && grid[i][j-1]) { --ret; }
                    if (j < m-1 && grid[i][j+1]) { --ret; }
                }
            }
        }
        return ret;
    }

};

 

【500】Keyboard Row 

 

【508】Most Frequent Subtree Sum 

 

【525】Contiguous Array （2019年1月9日，算法群）

给了一个0/1数组，返回最长的子数组长度，要求是子数组里面的0和1的个数相等。

题解：先求前缀和，对于元素0，碰到了要当成-1。 这样如果一个子数组里面刚好有相同个数的0和1的话，他们的和就是0。用一个hash-map保存前缀和第一次出现的位置。下次如果遇到了前面已经出现过的前缀和，就说明这个区间里面元素和为0。更新结果。

class Solution {
public:
    int findMaxLength(vector<int>& nums) {
        const int n = nums.size();
        vector<int> summ(n+1, 0);
        unordered_map<int, int> hash;
        hash[0] = 0;
        int ans = 0;
        for (int i = 1; i < n+1; ++i) {
            summ[i] = summ[i-1] + (nums[i-1] == 0 ? -1 : nums[i-1]);
            if (hash.find(summ[i]) != hash.end()) {
                ans = max(ans, i - hash[summ[i]]);
            } else {
                hash[summ[i]] = i;
            }
        }
        return ans;
    }
};

 

【535】Encode and Decode TinyURL （2019年2月11日，谷歌tag题）

实现两个方法，string encode(string longUrl)， string decode(string shortUrl) 。

题解：我是用了一个map，base62编码，用一个count变量用来生成key，map的结构是 key -> longUrl。 这样的缺点是如果一个longUrl访问多次，会多次占用count和map空间。可以搞成两个map。

class Solution {
public:
    const string vars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
    // Encodes a URL to a shortened URL.
    string encode(string longUrl) {
        string key = getKey();
        mp[key] = longUrl;
        return "http://tinyurl.com/" + key;
    }
    // Decodes a shortened URL to its original URL.
    string decode(string shortUrl) {
        int pos = shortUrl.find_last_of('/');
        string key = shortUrl.substr(pos+1);
        return mp[key];
    }
    string getKey() {
        int number = count;
        string key = "";
        while (number > 0) {
            key = key + string(1, vars[number % 62]);
            number /= 62;
        }
        ++count;
        return key;
    }
    int count = 1;
    unordered_map<string, string> mp;
};

// Your Solution object will be instantiated and called as such:
// Solution solution;
// solution.decode(solution.encode(url));

 

 

【554】Brick Wall 

【560】Subarray Sum Equals K 

【575】Distribute Candies 

【594】Longest Harmonious Subsequence 

 

【599】Minimum Index Sum of Two Lists (2018年11月27日)

给了两个字符串数组，每个字符串数组代表一个人的最喜欢的饭馆的名字，返回两个人都喜欢的饭馆，并且这两个饭馆字符串的下标和最小的饭馆名称。

题解：用了unordered_map直接解答了。

class Solution {
public:
    vector<string> findRestaurant(vector<string>& list1, vector<string>& list2) {
        unordered_map<string, int> mp;
        for (int i = 0; i < list1.size(); ++i) {
            mp[list1[i]] = i;
        }
        int minSum = list1.size() + list2.size();
        unordered_map<int, vector<string>> record;
        for (int i = 0; i < list2.size(); ++i) {
            string word = list2[i];
            if (mp.find(word) == mp.end()) {continue;}
            if (minSum  == mp[word] + i) {
                record[minSum].push_back(word);
            } else if (minSum > mp[word] + i) {
                minSum = mp[word] + i;
                record[minSum].push_back(word);
            }
        }
        return record[minSum];
    }
};

 

【609】Find Duplicate File in System 

【624】Maximum Distance in Arrays 

【632】Smallest Range 

【645】Set Mismatch 

【648】Replace Words 

 

【676】Implement Magic Dictionary (2019年3月13日，google tag)

设计一个魔法字典，完成两个 api。

 

Implement a magic directory with buildDict, and search methods.

 

For the method buildDict, you'll be given a list of non-repetitive words to build a dictionary.

 

For the method search, you'll be given a word, and judge whether if you modify exactly one character into another character in this word, the modified word is in the dictionary you just built.

 

Example 1:

 

Input: buildDict(["hello", "leetcode"]), Output: Null
Input: search("hello"), Output: False
Input: search("hhllo"), Output: True
Input: search("hell"), Output: False
Input: search("leetcoded"), Output: False

 

Note:

 

1. You may assume that all the inputs are consist of lowercase letters a-z.
2. For contest purpose, the test data is rather small by now. You could think about highly efficient algorithm after the contest.
3. Please remember to RESET your class variables declared in class MagicDictionary, as static/class variables are persisted across multiple test cases. Please see here for more details.

题解：用一个set存储 wordlist，用另外一个存储邻居，比如 apple 的邻居可以是 *pple, a*ple, ap*le, app*e, appl*, 这五个。

在search中对于输入的单词，先把每个字母都先隐藏一下看能不能变成邻居的set中的元素。如果能的话，看是不是wordlist中的单词，如果是的话，那么需要 neighbors.count(word) >= 2 才行。

//build time: O(NM), space: O(NM)
//search: time O(N)
class MagicDictionary {
public:
    /** Initialize your data structure here. */
    MagicDictionary() {
        
    }
    
    /** Build a dictionary through a list of words */
    void buildDict(vector<string> dict) {
        stdict = unordered_set(dict.begin(), dict.end());
        for (auto& word: dict) {
            for (int i = 0; i < word.size(); ++i) {
                string s = word;
                s[i] = '*';
                neighbors.insert(s);
            }
        }
    }
    
    /** Returns if there is any word in the trie that equals to the given word after modifying exactly one character */
    bool search(string word) {
        for (int i = 0; i < word.size(); ++i) {
            string s = word;
            s[i] = '*';
            if (neighbors.count(s) >= 1 && stdict.count(word) == 0)  {return true;}
            if (neighbors.count(s) > 1 && stdict.count(word) == 1)  {return true;}
        }
        return false;
    }
    unordered_set<string> stdict;
    multiset<string> neighbors;
};

/**
 * Your MagicDictionary object will be instantiated and called as such:
 * MagicDictionary obj = new MagicDictionary();
 * obj.buildDict(dict);
 * bool param_2 = obj.search(word);
 */

 

【690】Employee Importance 

【692】Top K Frequent Words 

【694】Number of Distinct Islands 

 

【705】Design HashSet （2019年2月12日）

设计一个hashset。

题解：用个1D-array或者一个 2D-array。时间复杂度分析：三个接口都是 O(1)，空间复杂度分析，最差O(N)。

class MyHashSet {
public:
    /** Initialize your data structure here. */
    MyHashSet() {
        data.resize(1000);
    }
    
    void add(int key) {
        int r = key % 1000, c = key / 1000;
        if (data[r].empty()) {
            data[r] = vector<bool>(1000, false);
        }
        data[r][c] = true;
    }
    
    void remove(int key) {
        int r = key % 1000, c = key / 1000;
        if (data[r].empty()) {return;}
        data[r][c] = false;
    }
    
    /** Returns true if this set contains the specified element */
    bool contains(int key) {
        int r = key % 1000, c = key / 1000;
        if (data[r].empty()) {return false;}
        return data[r][c];
    }
    vector<vector<bool>> data;
};

/**
 * Your MyHashSet object will be instantiated and called as such:
 * MyHashSet obj = new MyHashSet();
 * obj.add(key);
 * obj.remove(key);
 * bool param_3 = obj.contains(key);
 */

 

【706】Design HashMap （2019年2月12日）

设计一个hashmap。

题解：用个1D-array或者一个 2D-array。时间复杂度分析 三个接口都是 O(1)，空间复杂度分析，最差O(N)。

class MyHashMap {
public:
    /** Initialize your data structure here. */
    MyHashMap() {
        data.resize(1000);
    }
    
    /** value will always be non-negative. */
    void put(int key, int value) {
        int r = key % 1000, c = key / 1000;
        if (data[r].empty()) {
            data[r] = vector<int>(1000, -1);
        }
        data[r][c] = value;
    }
    
    /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
    int get(int key) {
        int r = key % 1000, c = key / 1000;
        if (data[r].empty()) {return -1;}
        return data[r][c];
    }
    
    /** Removes the mapping of the specified value key if this map contains a mapping for the key */
    void remove(int key) {
        int r = key % 1000, c = key / 1000;
        if (data[r].empty()) {return;}
        data[r][c] = -1;
    }
    vector<vector<int>> data;
};

/**
 * Your MyHashMap object will be instantiated and called as such:
 * MyHashMap obj = new MyHashMap();
 * obj.put(key,value);
 * int param_2 = obj.get(key);
 * obj.remove(key);
 */

 

【710】Random Pick with Blacklist 

【711】Number of Distinct Islands II 

【718】Maximum Length of Repeated Subarray 

【720】Longest Word in Dictionary 

【726】Number of Atoms 

【734】Sentence Similarity 

【739】Daily Temperatures 

【748】Shortest Completing Word 

【760】Find Anagram Mappings 

【770】Basic Calculator IV 

【771】Jewels and Stones 

【781】Rabbits in Forest 

【811】Subdomain Visit Count 

【846】Hand of Straights（不好意思，本来是map分类，然鹅map分类一共就两个题，我就放在了这里orz）

小红有一堆纸牌，每张纸牌上有一个数字，问能不能把纸牌均匀的分成每组 W 张，每组的数字都是连续递增 1 的。

Example 1:
Input: hand = [1,2,3,6,2,3,4,7,8], W = 3
Output: true
Explanation: Alice's hand can be rearranged as [1,2,3],[2,3,4],[6,7,8].

Example 2:
Input: hand = [1,2,3,4,5], W = 4
Output: false
Explanation: Alice's hand can't be rearranged into groups of 4.

1 <= hand.length <= 10000
0 <= hand[i] <= 10^9
1 <= W <= hand.length

题解：我本来想排序之后二分的，但是点了下tag，tag 写的是 map， 我就往 map 上面想了。用了 map 能 AC 但是时间上比较差。还要看别人的题解，要记得看discuss。

class Solution {
public:
    bool isNStraightHand(vector<int>& hand, int W) {
        const int n = hand.size();
        if (n % W != 0) {return false;}
        map<int, int> mp;
        for (auto p : hand) {
            mp[p]++;
        }
        int cnt(0);
        while (cnt < n / W) {
            int begin;
            for (auto ele : mp) {
                if (ele.second > 0) {
                    begin = ele.first;
                    break;
                }
            }
            int num = begin; 
            for (; num < begin + W; ++num) {
                if (mp.find(num) == mp.end() || mp[num] <= 0) {
                    return false;
                }
                mp[num]--;
            }
            cnt++;
        }
        return true;
    }
};

 

【884】Uncommon Words from Two Sentences 

【895】Maximum Frequency Stack