添加仓库代码

0344-Reverse-String/cpp-0344/main.cpp

+/// Source : https://leetcode.com/problems/reverse-string/description/
+/// Author : liuyubobobo
+/// Time   : 2018-06-04
+
+#include <iostream>
+
+using namespace std;
+
+// 344. Reverse String
+// https://leetcode.com/problems/reverse-string/description/
+// Two Pointers
+// 时间复杂度: O(n)
+// 空间复杂度: O(1)
+class Solution {
+public:
+    string reverseString(string s) {
+
+        int i = 0, j = s.size() - 1;
+        while(i < j){
+            swap(s[i], s[j]);
+            i ++;
+            j --;
+        }
+
+        return s;
+    }
+};
+
+
+int main() {
+
+    cout << Solution().reverseString("hello") << endl;
+
+    return 0;
+}

0349-Intersection-of-Two-Arrays/cpp-0349/CMakeLists.txt

+cmake_minimum_required(VERSION 3.5)
+project(cpp_0349)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+
+set(SOURCE_FILES main.cpp)
+add_executable(cpp_0349 ${SOURCE_FILES})
\ No newline at end of file

0349-Intersection-of-Two-Arrays/cpp-0349/main.cpp

+/// Source : https://leetcode.com/problems/intersection-of-two-arrays/description/
+/// Author : liuyubobobo
+/// Time   : 2017-07-12
+
+#include <iostream>
+#include <vector>
+#include <unordered_set>
+
+using namespace std;
+
+/// Hash Set
+/// Time complexity: O(len(nums1) + len(nums2))
+/// Space Complexity: O(len(nums1))
+class Solution {
+public:
+    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
+
+        unordered_set<int> record(nums1.begin(), nums1.end());
+
+        unordered_set<int> resultSet;
+        for( int i = 0 ; i < nums2.size() ; i ++ )
+            if( record.find(nums2[i]) != record.end() )
+                resultSet.insert( nums2[i] );
+
+        return vector<int>(resultSet.begin(), resultSet.end());
+    }
+};
+
+
+void printVec(const vector<int>& vec){
+    for(int e: vec)
+        cout << e << " ";
+    cout << endl;
+}
+
+int main() {
+
+    int nums1[] = {1, 2, 2, 1};
+    vector<int> vec1(nums1, nums1 + sizeof(nums1)/sizeof(int));
+
+    int nums2[] = {2, 2};
+    vector<int> vec2(nums2, nums2 + sizeof(nums2)/sizeof(int));
+
+    printVec(Solution().intersection(vec1, vec2));
+
+    return 0;
+}
\ No newline at end of file

0349-Intersection-of-Two-Arrays/java-0349/src/Solution.java

+/// Source : https://leetcode.com/problems/intersection-of-two-arrays/description/
+/// Author : liuyubobobo
+/// Time   : 2017-07-12
+
+import java.util.HashSet;
+
+/// Hash Set
+/// Time complexity: O(len(nums1) + len(nums2))
+/// Space Complexity: O(len(nums1))
+public class Solution {
+
+    public int[] intersection(int[] nums1, int[] nums2) {
+
+        HashSet<Integer> record = new HashSet<Integer>();
+        for(int num: nums1)
+            record.add(num);
+
+        HashSet<Integer> resultSet = new HashSet<Integer>();
+        for(int num: nums2)
+            if(record.contains(num))
+                resultSet.add(num);
+
+        int[] res = new int[resultSet.size()];
+        int index = 0;
+        for(Integer num: resultSet)
+            res[index++] = num;
+
+        return res;
+    }
+
+    private static void printArr(int[] arr){
+        for(int e: arr)
+            System.out.print(e + " ");
+        System.out.println();
+    }
+
+    public static void main(String[] args) {
+
+        int[] nums1 = {1, 2, 2, 1};
+        int[] nums2 = {2, 2};
+        int[] res = (new Solution()).intersection(nums1, nums2);
+        printArr(res);
+    }
+}
\ No newline at end of file

0350-Intersection-of-Two-Arrays-II/cpp-0350/CMakeLists.txt

+cmake_minimum_required(VERSION 3.5)
+project(cpp_0350)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+
+set(SOURCE_FILES main.cpp)
+add_executable(cpp_0350 ${SOURCE_FILES})
\ No newline at end of file

0350-Intersection-of-Two-Arrays-II/cpp-0350/main.cpp

+/// Source : https://leetcode.com/problems/intersection-of-two-arrays-ii/description/
+/// Author : liuyubobobo
+/// Time   : 2017-11-14
+
+#include <iostream>
+#include <vector>
+#include <unordered_map>
+using namespace std;
+
+/// Using Hash Map
+/// Time Complexity: O(len(nums1) + len(nums2))
+/// Space Complexity: O(len(nums1))
+class Solution {
+public:
+    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
+
+        unordered_map<int, int> record;
+        for(int i = 0 ; i < nums1.size() ; i ++)
+            record[nums1[i]] += 1;
+
+        vector<int> resultVector;
+        for(int i = 0 ; i < nums2.size() ; i ++)
+            if(record[nums2[i]] > 0){
+                resultVector.push_back(nums2[i]);
+                record[nums2[i]] --;
+            }
+
+        return resultVector;
+    }
+};
+
+
+void printVec(const vector<int>& vec){
+    for(int e: vec)
+        cout << e << " ";
+    cout << endl;
+}
+
+int main() {
+
+    int nums1[] = {1, 2, 2, 1};
+    vector<int> vec1(nums1, nums1 + sizeof(nums1)/sizeof(int));
+
+    int nums2[] = {2, 2};
+    vector<int> vec2(nums2, nums2 + sizeof(nums2)/sizeof(int));
+
+    printVec(Solution().intersect(vec1, vec2));
+
+    return 0;
+}
\ No newline at end of file

0350-Intersection-of-Two-Arrays-II/cpp-0350/main2.cpp

+/// Source : https://leetcode.com/problems/intersection-of-two-arrays-ii/description/
+/// Author : liuyubobobo
+/// Time   : 2017-11-14
+
+#include <iostream>
+#include <vector>
+#include <set>
+
+using namespace std;
+
+/// Using Hash Map
+/// Time Complexity: O(len(nums1) + len(nums2)*log(len(nums1)))
+/// Space Complexity: O(len(nums1))
+class Solution {
+public:
+    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
+
+        multiset<int> record;
+        for(int num: nums1)
+            record.insert(num);
+
+        multiset<int> result;
+        for(int num: nums2){
+            multiset<int>::iterator iter = record.find(num);
+            if( iter != record.end()){
+                result.insert(num);
+                record.erase(iter);
+            }
+        }
+
+        return vector<int>(result.begin(), result.end());
+    }
+};
+
+int main() {
+
+    int nums1[] = {1, 2, 2, 1};
+    vector<int> vec1(nums1, nums1 + sizeof(nums1)/sizeof(int));
+
+    int nums2[] = {2, 2};
+    vector<int> vec2(nums2, nums2 + sizeof(nums2)/sizeof(int));
+
+    printVec(Solution().intersect(vec1, vec2));
+
+    return 0;
+}
\ No newline at end of file

0350-Intersection-of-Two-Arrays-II/java-0350/src/Solution.java

+/// Source : https://leetcode.com/problems/intersection-of-two-arrays-ii/description/
+/// Author : liuyubobobo
+/// Time   : 2017-11-14
+
+import java.util.HashMap;
+import java.util.ArrayList;
+
+/// Using Hash Map
+/// Time Complexity: O(len(nums1) + len(nums2)*log(len(nums1)))
+/// Space Complexity: O(len(nums1))
+public class Solution {
+
+    public int[] intersect(int[] nums1, int[] nums2) {
+
+        HashMap<Integer, Integer> record = new HashMap<Integer, Integer>();
+        for(int num: nums1)
+            if(!record.containsKey(num))
+                record.put(num, 1);
+            else
+                record.put(num, record.get(num) + 1);
+
+        ArrayList<Integer> result = new ArrayList<Integer>();
+        for(int num: nums2)
+            if(record.containsKey(num) && record.get(num) > 0){
+                result.add(num);
+                record.put(num, record.get(num) - 1);
+            }
+
+        int[] ret = new int[result.size()];
+        int index = 0;
+        for(Integer num: result)
+            ret[index++] = num;
+
+        return ret;
+    }
+
+    private static void printArr(int[] arr){
+        for(int e: arr)
+            System.out.print(e + " ");
+        System.out.println();
+    }
+
+    public static void main(String[] args) {
+
+        int[] nums1 = {1, 2, 2, 1};
+        int[] nums2 = {2, 2};
+        int[] res = (new Solution()).intersect(nums1, nums2);
+        printArr(res);
+    }
+}

0447-Number-of-Boomerangs/cpp-0447/CMakeLists.txt

+cmake_minimum_required(VERSION 3.5)
+project(cpp_0447)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+
+set(SOURCE_FILES main.cpp)
+add_executable(cpp_0447 ${SOURCE_FILES})
\ No newline at end of file

0447-Number-of-Boomerangs/cpp-0447/main.cpp

+/// Source : https://leetcode.com/problems/number-of-boomerangs/description/
+/// Author : liuyubobobo
+/// Time   : 2017-11-15
+
+#include <iostream>
+#include <vector>
+#include <unordered_map>
+#include <cassert>
+#include <stdexcept>
+
+using namespace std;
+
+/// Using Hash Map
+/// Time Complexity: O(n^2)
+/// Space Complexity: O(n)
+class Solution {
+public:
+    int numberOfBoomerangs(vector<pair<int, int>>& points) {
+
+        int res = 0;
+        for( int i = 0 ; i < points.size() ; i ++ ){
+
+            // record中存储 点i 到所有其他点的距离出现的频次
+            unordered_map<int, int> record;
+            for(int j = 0 ; j < points.size() ; j ++)
+                if(j != i)
+                    // 计算距离时不进行开根运算, 以保证精度
+                    record[dis(points[i], points[j])] += 1;
+
+            for(unordered_map<int, int>::iterator iter = record.begin() ; iter != record.end() ; iter ++)
+                res += (iter->second) * (iter->second - 1);
+        }
+        return res;
+    }
+
+private:
+    int dis(const pair<int,int> &pa, const pair<int,int> &pb){
+        return (pa.first - pb.first) * (pa.first - pb.first) +
+               (pa.second - pb.second) * (pa.second - pb.second);
+    }
+};
+
+int main() {
+
+    vector<pair<int,int>> vec;
+    vec.push_back(make_pair(0, 0));
+    vec.push_back(make_pair(1, 0));
+    vec.push_back(make_pair(2, 0));
+
+    cout << Solution().numberOfBoomerangs(vec) << endl;
+
+    return 0;
+}
\ No newline at end of file

0447-Number-of-Boomerangs/java-0447/src/Solution.java

+/// Source : https://leetcode.com/problems/number-of-boomerangs/description/
+/// Author : liuyubobobo
+/// Time   : 2017-11-15
+
+import java.util.HashMap;
+
+/// Using Hash Map
+/// Time Complexity: O(n^2)
+/// Space Complexity: O(n)
+public class Solution {
+
+    public int numberOfBoomerangs(int[][] points) {
+
+        int res = 0;
+        for( int i = 0 ; i < points.length ; i ++ ){
+
+            // record中存储 点i 到所有其他点的距离出现的频次
+            HashMap<Integer, Integer> record = new HashMap<Integer, Integer>();
+            for(int j = 0 ; j < points.length ; j ++)
+                if(j != i){
+                    // 计算距离时不进行开根运算, 以保证精度
+                    int dis = dis(points[i], points[j]);
+                    if(record.containsKey(dis))
+                        record.put(dis, record.get(dis) + 1);
+                    else
+                        record.put(dis, 1);
+            }
+
+            for(Integer dis: record.keySet())
+                res += record.get(dis) * (record.get(dis) - 1);
+        }
+
+        return res;
+    }
+
+    private int dis(int[] pa, int pb[]){
+        return (pa[0] - pb[0]) * (pa[0] - pb[0]) +
+               (pa[1] - pb[1]) * (pa[1] - pb[1]);
+    }
+
+    public static void main(String[] args) {
+
+        int[][] points = {{0, 0}, {1, 0}, {2, 0}};
+        System.out.println((new Solution()).numberOfBoomerangs(points));
+    }
+}

0454-4Sum-II/cpp-0454/CMakeLists.txt

+cmake_minimum_required(VERSION 3.5)
+project(cpp_0454)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+
+set(SOURCE_FILES main.cpp)
+add_executable(cpp_0454 ${SOURCE_FILES})
\ No newline at end of file

0454-4Sum-II/cpp-0454/main.cpp

+/// https://leetcode.com/problems/4sum-ii/description/
+/// Author : liuyubobobo
+/// Time   : 2017-11-15
+
+#include <iostream>
+#include <vector>
+#include <unordered_map>
+#include <cassert>
+
+using namespace std;
+
+/// Using Hash Map
+/// Time Complexity: O(n^2)
+/// Space Complexity: O(n^2)
+class Solution {
+public:
+    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
+
+        unordered_map<int,int> hashtable;
+        for(int i = 0 ; i < C.size() ; i ++)
+            for(int j = 0 ; j < D.size() ; j ++)
+                hashtable[C[i]+D[j]] += 1;
+
+        int res = 0;
+        for(int i = 0 ; i < A.size() ; i ++)
+            for(int j = 0 ; j < B.size() ; j ++)
+                if(hashtable.find(-A[i]-B[j]) != hashtable.end())
+                    res += hashtable[-A[i]-B[j]];
+
+        return res;
+    }
+};
+
+int main() {
+
+    int a[] = {1, 2};
+    int b[] = {-2, -1};
+    int c[] = {-1, 2};
+    int d[] = {0, 2};
+    vector<int> a_vec = vector<int>(a, a + sizeof(a)/sizeof(int));
+    vector<int> b_vec = vector<int>(b, b + sizeof(b)/sizeof(int));
+    vector<int> c_vec = vector<int>(c, c + sizeof(c)/sizeof(int));
+    vector<int> d_vec = vector<int>(d, d + sizeof(d)/sizeof(int));
+
+    cout << Solution().fourSumCount(a_vec, b_vec, c_vec, d_vec) << endl;
+
+    return 0;
+}
+

0454-4Sum-II/cpp-0454/main2.cpp

+/// https://leetcode.com/problems/4sum-ii/description/
+/// Author : liuyubobobo
+/// Time   : 2017-11-15
+
+#include <iostream>
+#include <vector>
+#include <unordered_map>
+#include <cassert>
+#include <stdexcept>
+
+using namespace std;
+
+/// Another Way to use Hash Map
+/// Time Complexity: O(n^2)
+/// Space Complexity: O(n^2)
+class Solution {
+public:
+    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
+
+        unordered_map<int,int> hashtable1;
+        unordered_map<int,int> hashtable2;
+
+        for(int i = 0 ; i < A.size() ; i ++)
+            for(int j = 0 ; j < B.size() ; j ++)
+                hashtable1[A[i]+B[j]] += 1;
+
+        for(int i = 0 ; i < C.size() ; i ++)
+            for(int j = 0 ; j < D.size() ; j ++)
+                hashtable2[C[i]+D[j]] += 1;
+
+        int res = 0;
+        for(unordered_map<int,int>::iterator iter = hashtable1.begin() ; iter != hashtable1.end() ; iter ++)
+            if(hashtable2.find(-(iter->first)) != hashtable2.end())
+                res += iter->second * hashtable2[-(iter->first)];
+
+        return res;
+    }
+};
+
+int main() {
+
+    int a[] = {1, 2};
+    int b[] = {-2, -1};
+    int c[] = {-1, 2};
+    int d[] = {0, 2};
+    vector<int> a_vec = vector<int>(a, a + sizeof(a)/sizeof(int));
+    vector<int> b_vec = vector<int>(b, b + sizeof(b)/sizeof(int));
+    vector<int> c_vec = vector<int>(c, c + sizeof(c)/sizeof(int));
+    vector<int> d_vec = vector<int>(d, d + sizeof(d)/sizeof(int));
+
+    cout << Solution().fourSumCount(a_vec, b_vec, c_vec, d_vec) << endl;
+
+    return 0;
+}
+

0454-4Sum-II/java-0454/src/Solution1.java

+/// https://leetcode.com/problems/4sum-ii/description/
+/// Author : liuyubobobo
+/// Time   : 2017-11-15
+
+import java.util.HashMap;
+
+/// Using Hash Map
+/// Time Complexity: O(n^2)
+/// Space Complexity: O(n^2)
+public class Solution1 {
+
+    public int fourSumCount(int[] A, int[] B, int[] C, int[] D) {
+
+        if(A == null || B == null || C == null || D == null)
+            throw new IllegalArgumentException("Illegal argument");
+
+        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
+        for(int i = 0 ; i < C.length ; i ++)
+            for(int j = 0 ; j < D.length ; j ++){
+                int sum = C[i] + D[j];
+                if(map.containsKey(sum))
+                    map.put(sum, map.get(sum) + 1);
+                else
+                    map.put(sum, 1);
+            }
+
+        int res = 0;
+        for(int i = 0 ; i < A.length ; i ++)
+            for(int j = 0 ; j < B.length ; j ++)
+                if(map.containsKey(-A[i]-B[j]))
+                    res += map.get(-A[i]-B[j]);
+
+        return res;
+    }
+
+    public static void main(String[] args) {
+
+        int[] a = {1, 2};
+        int[] b = {-2, -1};
+        int[] c = {-1, 2};
+        int[] d = {0, 2};
+        System.out.println((new Solution1()).fourSumCount(a, b, c, d));
+    }
+}

0454-4Sum-II/java-0454/src/Solution2.java

+/// https://leetcode.com/problems/4sum-ii/description/
+/// Author : liuyubobobo
+/// Time   : 2017-11-15
+
+import java.util.HashMap;
+
+/// Another Way to use Hash Map
+/// Time Complexity: O(n^2)
+/// Space Complexity: O(n^2)
+public class Solution2 {
+
+    public int fourSumCount(int[] A, int[] B, int[] C, int[] D) {
+
+        if(A == null || B == null || C == null || D == null)
+            throw new IllegalArgumentException("Illegal argument");
+
+        HashMap<Integer, Integer> mapAB = new HashMap<Integer, Integer>();
+        for(int i = 0 ; i < A.length ; i ++)
+            for(int j = 0 ; j < B.length ; j ++){
+                int sum = A[i] + B[j];
+                if(mapAB.containsKey(sum))
+                    mapAB.put(sum, mapAB.get(sum) + 1);
+                else
+                    mapAB.put(sum, 1);
+            }
+
+        HashMap<Integer, Integer> mapCD = new HashMap<Integer, Integer>();
+        for(int i = 0 ; i < C.length ; i ++)
+            for(int j = 0 ; j < D.length ; j ++){
+                int sum = C[i] + D[j];
+                if(mapCD.containsKey(sum))
+                    mapCD.put(sum, mapCD.get(sum) + 1);
+                else
+                    mapCD.put(sum, 1);
+            }
+
+        int res = 0;
+        for(Integer sumab: mapAB.keySet()){
+            if(mapCD.containsKey(-sumab))
+                res += mapAB.get(sumab) * mapCD.get(-sumab);
+        }
+
+        return res;
+    }
+
+    public static void main(String[] args) {
+
+        int[] a = {1, 2};
+        int[] b = {-2, -1};
+        int[] c = {-1, 2};
+        int[] d = {0, 2};
+        System.out.println((new Solution2()).fourSumCount(a, b, c, d));
+    }
+}

Readme.md

@@ -8,8 +8,10 @@
 
 快去试一试吧~~~
 
-## Problems
+## 代码来源声明
+本仓库代码如无特殊说明，全部来源于此仓库[Play-Leetcode](https://github.com/liuyubobobo/Play-Leetcode)
 
+## Problems
 
 
 | ID | Problem  | Article | Animation |