n

Author: hitzzc

README.md

@@ -241,6 +241,16 @@ Golang solution for leetcode. For each problem, there is a simple *_test.go to t
 #### [334. Increasing Triplet Subsequence](https://github.com/hitzzc/go-leetcode/tree/master/increasing_triplet_subsequence)
 #### [335. Self Crossing](https://github.com/hitzzc/go-leetcode/tree/master/self_crossing)
 #### [336. Palindrome Pairs](https://github.com/hitzzc/go-leetcode/tree/master/palindrome_pairs)
+#### [337. House Robber III](https://github.com/hitzzc/go-leetcode/tree/master/house_robber_III)
+#### [338. Counting Bits](https://github.com/hitzzc/go-leetcode/tree/master/counting_bits)
+#### [341. Flatten Nested List Iterator](https://github.com/hitzzc/go-leetcode/tree/master/flatten_nested_list_iterator)
+#### [342. Power of Four](https://github.com/hitzzc/go-leetcode/tree/master/power_of_four)
+#### [343. Integer Break](https://github.com/hitzzc/go-leetcode/tree/master/integer_break)
+#### [344. Reverse String](https://github.com/hitzzc/go-leetcode/tree/master/reverse_string)
+#### [345. Reverse Vowels of a String](https://github.com/hitzzc/go-leetcode/tree/master/reverse_vowels_of_a_string)
+#### [347. Top K Frequent Elements](https://github.com/hitzzc/go-leetcode/tree/master/top_k_frequent_elements)
+#### [349. Intersection of Two Arrays](https://github.com/hitzzc/go-leetcode/tree/master/intersection_of_two_arrays)
+#### [350. Intersection of Two Arrays II](https://github.com/hitzzc/go-leetcode/tree/master/intersection_of_two_arrays_II)
 
 
 

counting_bits/counting_bits.cpp

@@ -0,0 +1,11 @@
+class Solution {
+public:
+    vector<int> countBits(int num) {
+        vector<int> result(num+1);
+        result[0] = 0;
+        for (int i = 1; i <= num; ++i) {
+        	result[i] = result[i&(i-1)] + 1;
+        }
+        return result;
+    }
+};

counting_bits/t

@@ -0,0 +1,49 @@
+/**
+ * // This is the interface that allows for creating nested lists.
+ * // You should not implement it, or speculate about its implementation
+ * class NestedInteger {
+ *   public:
+ *     // Return true if this NestedInteger holds a single integer, rather than a nested list.
+ *     bool isInteger() const;
+ *
+ *     // Return the single integer that this NestedInteger holds, if it holds a single integer
+ *     // The result is undefined if this NestedInteger holds a nested list
+ *     int getInteger() const;
+ *
+ *     // Return the nested list that this NestedInteger holds, if it holds a nested list
+ *     // The result is undefined if this NestedInteger holds a single integer
+ *     const vector<NestedInteger> &getList() const;
+ * };
+ */
+class NestedIterator {
+	vector<int> v;
+	int index = 0;
+	void flatten(vector<NestedInteger> &nestedList) {
+		for (auto& item: nestedList) {
+    		if (item.isInteger()) {
+    			v.push_back(item.getInteger());
+    		}else {
+    			flatten(item.getList());
+    		}
+    	}
+    	return;
+	}
+public:
+    NestedIterator(vector<NestedInteger> &nestedList) {
+    	flatten(nestedList);
+    }
+
+    int next() {
+    	return v[index++];
+    }
+
+    bool hasNext() {
+        return index < v.size();
+    }
+};
+
+/**
+ * Your NestedIterator object will be instantiated and called as such:
+ * NestedIterator i(nestedList);
+ * while (i.hasNext()) cout << i.next();
+ */

flatten_nested_list_iterator/flatten_nested_list_iterator.cpp

@@ -0,0 +1,23 @@
+struct TreeNode {
+	int val;
+	TreeNode *left;
+	TreeNode *right;
+	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution {
+	unordered_map<TreeNode*, int> records;
+public:
+    int rob(TreeNode* root) {
+        if (root == NULL) return 0;
+        if (records.count(root) == 0) {
+        	int left = rob(root->left);
+        	int right = rob(root->right);
+        	int without_left = 0, without_right = 0;
+        	if (root->left) without_left = rob(root->left->left) + rob(root->left->right);
+        	if (root->right) without_right = rob(root->right->left) + rob(root->right->right);
+        	records[root] = max(root->val+without_left+without_right, left+right);
+        }
+        return records[root];
+    }
+};

house_robber_III/house_robber_III.cpp

@@ -0,0 +1,14 @@
+class Solution {
+public:
+    int integerBreak(int n) {
+        if (n == 2) return 1;
+        if (n == 3) return 2;
+        int result = 1;
+        while (n > 4) {
+        	result *= 3;
+        	n -= 3;
+        }
+        result *= n;
+        return result;
+    }
+};

integer_break/integer_break.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
+        unordered_set<int> s, visited;
+        for (auto& num: nums1) {
+        	s.insert(num);
+        }
+        vector<int> res;
+        for (auto& num: nums2) {
+        	if (s.count(num) && visited.count(num) == 0) res.push_back(num);
+        	visited.insert(num);
+        }
+        return res;
+    }
+};

intersection_of_two_arrays/intersection_of_two_arrays.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
+        unordered_map<int, int> m;
+        for (auto& num: nums1) {
+        	++m[num];
+        }
+        vector<int> res;
+        for (auto& num: nums2) {
+        	if (m[num] > 0) {
+        		--m[num];
+        		res.push_back(num);
+        	}
+        }
+        return res;
+    }
+};

intersection_of_two_arrays_II/intersection_of_two_arrays_II.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    bool isPowerOfFour(int num) {
+        static int mask = 0b01010101010101010101010101010101;
+        
+        //edge case
+        if (num<=0) return false;
+        
+        // there are multiple bits are 1
+        if ((num & num-1) != 0) return false;
+        
+        // check which one bit is zero, if the place is 1 or 3 or 5 or 7 or 9...,
+        // then it is the power of 4
+        if ((num & mask) != 0) return true;
+        return false;
+    }
+};

power_of_four/power_of_four.cpp

@@ -0,0 +1,11 @@
+class Solution {
+public:
+    string reverseString(string s) {
+     	string ret(s.size(), '\0');
+     	for (int i = 0, j = s.size()-1; i <= j; ++i, --j) {
+     		ret[i] = s[j];
+     		ret[j] = s[i];
+     	}
+     	return ret;
+    }
+};

reverse_string/reverse_string.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    string reverseVowels(string s) {
+    	unordered_set<char> vowels = {'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'};
+        string ret(s.size(), '\0');
+        for (int i = 0, j = s.size()-1; i <= j; ++i, --j) {
+        	while (i < s.size()-1 && vowels.count(s[i]) == 0) {
+        		ret[i] = s[i];
+        		++i;
+        	}
+        	while (j >= 0 && vowels.count(s[j]) == 0) {
+        		ret[j] = s[j];
+        		--j;
+        	}
+        	if (i > j) break;
+        	ret[i] = s[j];
+        	ret[j] = s[i]; 
+        }
+        return ret;
+    }
+};

reverse_vowels_of_a_string/reverse_vowels_of_a_string.cpp

@@ -0,0 +1,22 @@
+class Solution {
+public:
+    vector<int> topKFrequent(vector<int>& nums, int k) {
+        unordered_map<int, int> mapping;
+        for (auto num: nums) {
+        	++mapping[num];
+        }
+        vector<vector<int>> freq(nums.size()+1);
+        for (auto m: mapping) {
+        	freq[m.second].push_back(m.first);
+        }
+        vector<int> result;
+        for (int i = freq.size()-1; i >=0 && k > 0; --i) {
+        	for (auto num: freq[i]) {
+        		result.push_back(num);
+        		--k;
+        		if (k == 0) break;
+        	}
+        }
+        return result;
+    }
+};