add solution file

Author: ninechapter-algorithm

题解/132-pattern.md

@@ -0,0 +1,47 @@
+# 132 模式
+ > 题目来源: [LintCode 算法题库](https://www.lintcode.com/problem/132-pattern/?utm_source=sc-github-wzz)
+ ## 题目描述
+ 给你一个 n 个整数的序列 a1,a2,...,an，一个 `132` 模式是对于一个子串 ai,aj,ak，满足 `i` < `j` < `k` 和 `ai` < `ak` < `aj`。设计一个算法来检查输入的这 n 个整数的序列中是否存在132模式。
+`n` 会小于 `20,000`。
+ ### 样例说明
+ 例1:
+```
+输入: nums = [1, 2, 3, 4] 
+输出: False 
+解释:
+没有132模式在这个序列中。
+```
+例2:
+```
+输入: nums = [3, 1, 4, 2] 
+输出: True 
+解释:
+存在132模式：[1,4,2]。
+```
+
+ ### 参考代码
+ s2代表当前次大值。
+从最后一个开始遍历，依次与S2做比较，若小于，直接返回true，若大于，跟新s2的值即可
+```java
+public class Solution {
+    /**
+     * @param nums a list of n integers
+     * @return true if there is a 132 pattern or false
+     */
+    public boolean find132pattern(int[] nums) {
+        // Write your code here
+        Stack<Integer> stack = new Stack<Integer>();
+        for (int i = nums.length - 1, two = Integer.MIN_VALUE; i >= 0; i--) {
+            if (nums[i] < two) {
+                return true;
+            } else {
+                while (!stack.empty() && nums[i] > stack.peek())
+                    two = stack.pop();
+            }
+            stack.push(nums[i]);
+        }
+        return false;
+    }
+}
+```
+ 更多题解请参考: [LintCode 提供 2000+ 算法题和名企阶梯训练](https://www.lintcode.com/problem/?utm_source=sc-github-wzz)

题解/132-patterns.md

@@ -0,0 +1,40 @@
+# 132-patterns
+ > 题目来源: [LintCode 算法题库](https://www.lintcode.com/problem/132-patterns/?utm_source=sc-github-wzz)
+ ## 题目描述
+ 1776
+ ### 样例说明
+ 1776
+ ### 参考代码
+ ```java
+public class Solution {
+    public boolean find132pattern(int[] nums) {
+        if (nums == null || nums.length < 3) {
+            return false;
+        }
+
+        int[] min = new int[nums.length];
+        min[0] = nums[0];
+
+        //assign the minimum value from num[0] to num [i - 1] to min[i]
+        for (int i = 1; i < nums.length; i++) {
+            min[i] = Math.min(nums[i - 1], min[i - 1]);
+        }
+
+        Stack<Integer> stack = new Stack<>();
+        int max = Integer.MIN_VALUE;
+        for (int j = nums.length - 1; j >= 0; j--) {
+            if (nums[j] > min[j]) {
+                while (!stack.empty() && nums[j] > stack.peek()) {
+                    max = stack.pop();
+                }
+                if (max > min[j]) {
+                    return true;
+                }
+            }
+            stack.push(nums[j]);
+        }
+        return false;
+    }
+}
+```
+ 更多题解请参考: [LintCode 提供 2000+ 算法题和名企阶梯训练](https://www.lintcode.com/problem/?utm_source=sc-github-wzz)

题解/2-sum.md

@@ -0,0 +1,25 @@
+# 2 Sum
+ > 题目来源: [LintCode 算法题库](https://www.lintcode.com/problem/2-sum/?utm_source=sc-github-wzz)
+ ## 题目描述
+ 1754
+ ### 样例说明
+ 1754
+ ### 参考代码
+ ```java
+  public class Solution {
+    public int[] twoSum(int[] nums, int target) {
+      Map<Integer, Integer> hash = new HashMap<Integer, Integer> ();
+      int[] result = new int[2];
+      for (int i = 0; i < nums.length; ++i) {
+        if (hash.containsKey(target - nums[i])) {
+          result[0] = hash.get(target - nums[i]) + 1;
+          result[1] = i + 1;
+          break;
+        }
+        hash.put(nums[i], i);
+      }
+      return result;
+    }
+}
+```
+ 更多题解请参考: [LintCode 提供 2000+ 算法题和名企阶梯训练](https://www.lintcode.com/problem/?utm_source=sc-github-wzz)

题解/3sum-closest.md

@@ -0,0 +1,48 @@
+# 最接近的三数之和
+ > 题目来源: [LintCode 算法题库](https://www.lintcode.com/problem/3sum-closest/?utm_source=sc-github-wzz)
+ ## 题目描述
+ 给一个包含 *n* 个整数的数组 *S*, 找到和与给定整数 *target* 最接近的三元组，返回这三个数的和。
+ ### 样例说明
+ 例1:
+```
+输入:[2,7,11,15],3
+输出:20
+解释:
+2+7+11=20
+```
+
+例2:
+```
+输入:[-1,2,1,-4],1
+输出:2
+解释:
+-1+2+1=2
+```
+
+ ### 参考代码
+ 排序后。
+固定一个点，利用双指针的方式，扫描，记录答案即可。
+```python
+class Solution:
+    """
+    @param numbers: Give an array numbers of n integer
+    @param target: An integer
+    @return: return the sum of the three integers, the sum closest target.
+    """
+    def threeSumClosest(self, numbers, target):
+        numbers.sort()
+        ans = None
+        for i in range(len(numbers)):
+            left, right = i + 1, len(numbers) - 1
+            while left < right:
+                sum = numbers[left] + numbers[right] + numbers[i]
+                if ans is None or abs(sum - target) < abs(ans - target):
+                    ans = sum
+                    
+                if sum <= target:
+                    left += 1
+                else:
+                    right -= 1
+        return ans
+```
+ 更多题解请参考: [LintCode 提供 2000+ 算法题和名企阶梯训练](https://www.lintcode.com/problem/?utm_source=sc-github-wzz)

题解/3sum.md

@@ -0,0 +1,167 @@
+# 三数之和
+ > 题目来源: [LintCode 算法题库](https://www.lintcode.com/problem/3sum/?utm_source=sc-github-wzz)
+ ## 题目描述
+ <p><span style="line-height: 30px;">给出一个有n个整数的数组S，在S中找到三个整数a, b, c，找到所有使得a + b + c = 0的三元组。</span><br></p>
+ ### 样例说明
+ **例1:**
+```
+输入:[2,7,11,15]
+输出:[]
+```
+
+
+**例2:**
+```
+输入:[-1,0,1,2,-1,-4]
+输出:[[-1, 0, 1],[-1, -1, 2]]
+```
+
+
+ ### 参考代码
+ 暴力枚举三个数复杂度为O(N^3)
+先考虑2Sum的做法，假设升序数列a，对于一组解ai,aj, 另一组解ak,al
+必然满足 i<k j>l 或 i>k j<l, 因此我们可以用两个指针，初始时指向数列两端
+指向数之和大于目标值时，右指针向左移使得总和减小，反之左指针向右移
+由此可以用 O(N)O(N) 的复杂度解决2Sum问题，3Sum则枚举第一个数 O(N^2)O(N 
+2
+ )
+使用有序数列的好处是，在枚举和移动指针时值相等的数可以跳过，省去去重部分
+```java
+public class Solution {
+    /**
+     * @param nums : Give an array numbers of n integer
+     * @return : Find all unique triplets in the array which gives the sum of zero.
+     */
+    public List<List<Integer>> threeSum(int[] nums) {
+        List<List<Integer>> results = new ArrayList<>();
+        
+        if (nums == null || nums.length < 3) {
+            return results;
+        }
+        
+        Arrays.sort(nums);
+
+        for (int i = 0; i < nums.length - 2; i++) {
+            // skip duplicate triples with the same first numebr
+            if (i > 0 && nums[i] == nums[i - 1]) {
+                continue;
+            }
+
+            int left = i + 1, right = nums.length - 1;
+            int target = -nums[i];
+            
+            twoSum(nums, left, right, target, results);
+        }
+        
+        return results;
+    }
+    
+    public void twoSum(int[] nums,
+                       int left,
+                       int right,
+                       int target,
+                       List<List<Integer>> results) {
+        while (left < right) {
+            if (nums[left] + nums[right] == target) {
+                ArrayList<Integer> triple = new ArrayList<>();
+                triple.add(-target);
+                triple.add(nums[left]);
+                triple.add(nums[right]);
+                results.add(triple);
+                
+                left++;
+                right--;
+                // skip duplicate pairs with the same left
+                while (left < right && nums[left] == nums[left - 1]) {
+                    left++;
+                }
+                // skip duplicate pairs with the same right
+                while (left < right && nums[right] == nums[right + 1]) {
+                    right--;
+                }
+            } else if (nums[left] + nums[right] < target) {
+                left++;
+            } else {
+                right--;
+            }
+        }
+    }
+}
+
+// 九章硅谷求职算法集训营版本
+public class Solution {
+    /**
+     * @param nums : Give an array numbers of n integer
+     * @return : Find all unique triplets in the array which gives the sum of zero.
+     */
+    List<List<Integer>> results = new ArrayList<>();
+    
+    // This is soring results using 1st number as 1st key, 2nd number as 2nd key...
+    class ListComparator<T extends Comparable<T>> implements Comparator<List<Integer>> {
+      @Override
+      public int compare(List<Integer> a, List<Integer> b) {
+        for (int i = 0; i < Math.min(a.size(), b.size()); i++) {
+          int c = a.get(i).compareTo(b.get(i));
+          if (c != 0) {
+            return c;
+          }
+        }
+        return Integer.compare(a.size(), b.size());
+      }
+    }
+    
+    public List<List<Integer>> threeSum(int[] A) {
+        if (A == null || A.length < 3) {
+            return results;
+        }
+        
+        Arrays.sort(A);
+        // enumerate c, the maximum element
+        int i;
+        int n = A.length;
+        for (i = 2; i < n; ++i) {
+            // c is always the last in a bunch of duplicates
+            if (i + 1 < n && A[i + 1] == A[i]) {
+                continue;
+            }
+            
+            // want to find all pairs of A[j]+A[k]=-A[i], such that
+            // j < k < i
+            twoSum(A, i - 1, -A[i]);
+        }
+        
+        Collections.sort(results, new ListComparator<>());
+        
+        return results;
+    }
+    
+    // find all unique pairs such that A[i]+A[j]=S, and i < j <= right
+    private void twoSum(int[] A, int right, int S) {
+        int i, j;
+        j = right;
+        for (i = 0; i <= right; ++i) {
+            // A[i] must be the first in its duplicates
+            if (i > 0 && A[i] == A[i - 1]) {
+                continue;
+            }
+            
+            while (j > i && A[j] > S - A[i]) {
+                --j;
+            }
+            
+            if (i >= j) {
+                break;
+            }
+            
+            if (A[i] + A[j] == S) {
+                List<Integer> t = new ArrayList<>();
+                t.add(A[i]);
+                t.add(A[j]);
+                t.add(-S); // t.add(A[right+1])
+                results.add(t);
+            }
+        }
+    }
+}
+```
+ 更多题解请参考: [LintCode 提供 2000+ 算法题和名企阶梯训练](https://www.lintcode.com/problem/?utm_source=sc-github-wzz)