fd

Author: dingjikerbo

README.md

@@ -294,6 +294,7 @@
 |325|[Maximum Size Subarray Sum Equals k](https://leetcode.com/problems/maximum-size-subarray-sum-equals-k/)| [Java](https://github.com/dingjikerbo/leetcode/blob/master/solution/src/main/java/com/inuker/solution/MaximumSizeSubarraySumEqualsK.java)|75|这题思路有意思，多做几遍|
 |328|[Odd Even Linked List](https://leetcode.com/problems/odd-even-linked-list/)| [Java](https://github.com/dingjikerbo/leetcode/blob/master/solution/src/main/java/com/inuker/solution/OddEvenLinkedList.java)|90|
 |329|[Longest Increasing Path in a Matrix](https://leetcode.com/problems/longest-increasing-path-in-a-matrix/)| [Java](https://github.com/dingjikerbo/leetcode/blob/master/solution/src/main/java/com/inuker/solution/LongestIncreasingPathInAMatrix.java)|70|这题要多做几遍|
+|332|[Reconstruct Itinerary](https://leetcode.com/problems/reconstruct-itinerary/)| [Java](https://github.com/dingjikerbo/leetcode/blob/master/solution/src/main/java/com/inuker/solution/ReconstructItinerary.java)|||
 |333|[Largest BST Subtree](https://leetcode.com/problems/largest-bst-subtree/)| [Java](https://github.com/dingjikerbo/leetcode/blob/master/solution/src/main/java/com/inuker/solution/LargestBSTSubtree.java)|50|这道题虽然不难，但是折腾了很久，一定要多做|
 |334|[Increasing Triplet Subsequence](https://leetcode.com/problems/increasing-triplet-subsequence/)| [Java](https://github.com/dingjikerbo/leetcode/blob/master/solution/src/main/java/com/inuker/solution/IncreasingTripletSubsequence.java)|75|
 |335|[Self Crossing](https://leetcode.com/problems/self-crossing/)| [Java](https://github.com/dingjikerbo/leetcode/blob/master/solution/src/main/java/com/inuker/solution/SelfCrossing.java)|80|

solution/src/main/java/com/inuker/solution/ContainsDuplicateIII.java

@@ -16,6 +16,8 @@ public class ContainsDuplicateIII {
     /**
      * 这题要注意溢出问题，干脆都用long
      * 时间复杂度O(nlg(min(n,k))
+     * for循环走到当前的nums[i]说明之前的都不行，因此只要判断当前
+     * nums[i]的加入是否可以即可，因此只要判断nums[i]相邻的上下两个数是否在t范围内
      */
     public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
         TreeSet<Long> set = new TreeSet<>();

solution/src/main/java/com/inuker/solution/MinimumSizeSubarraySum.java

@@ -7,7 +7,9 @@
  */
 
 public class MinimumSizeSubarraySum {
-
+    /**
+     * 仍然采用滑动窗口的办法
+     */
     public int minSubArrayLen(int s, int[] nums) {
         int sum = 0, min = Integer.MAX_VALUE;
         for (int i = 0, j = 0; i < nums.length; i++) {

solution/src/main/java/com/inuker/solution/ReconstructItinerary.java

@@ -0,0 +1,141 @@
+package com.inuker.solution;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.PriorityQueue;
+import java.util.Stack;
+
+/**
+ * Created by liwentian on 2017/9/2.
+ */
+/**
+ * 这题有两个前提
+ * 1， 必须从JFK开始
+ * 2， 解一定存在
+ */
+
+/**
+ * 这题有两种解法：
+ * 1， 常规是DFS暴力解法，面试能写出这种就行了
+ * 2， 欧拉解法
+ */
+public class ReconstructItinerary {
+
+    /**
+     * 常规DFS暴力列出所有可能的路径，可以一次走遍所有的边
+     */
+    public List<List<String>> findItinerary(String[][] tickets) {
+        HashMap<String, ArrayList<String>> map = new HashMap<>();
+        for (String[] ticket : tickets) {
+            map.computeIfAbsent(ticket[0], k -> new ArrayList<>()).add(ticket[1]);
+        }
+        List<List<String>> result = new LinkedList<>();
+        dfs("JFK", result, map, new LinkedList<>(Arrays.asList("JFK")), tickets.length);
+        return result;
+    }
+
+    void dfs(String airport, List<List<String>> result, HashMap<String, ArrayList<String>> map, LinkedList<String> route, int n) {
+        if (route.size() == n + 1) {
+            result.add(new ArrayList<>(route));
+            return;
+        }
+        if (!map.containsKey(airport) || map.get(airport).isEmpty()) {
+            return;
+        }
+        ArrayList<String> list = map.get(airport);
+        for (int i = 0; i < list.size(); i++) {
+            String target = list.remove(i);
+
+            route.add(target);
+            dfs(target, result, map, route, n);
+            route.removeLast();
+
+            list.add(i, target);
+        }
+    }
+
+    /**
+     * 题目要求是列出字母顺序最小的
+     */
+    public List<String> findItinerary2(String[][] tickets) {
+        HashMap<String, ArrayList<String>> map = new HashMap<>();
+        for (String[] ticket : tickets) {
+            map.computeIfAbsent(ticket[0], k -> new ArrayList<>()).add(ticket[1]);
+        }
+        for (List<String> list : map.values()) {
+            Collections.sort(list);
+        }
+        LinkedList<String> result = new LinkedList<>(Arrays.asList("JFK"));
+        dfs("JFK", map, result, tickets.length);
+        return result;
+    }
+
+    boolean dfs(String airport, HashMap<String, ArrayList<String>> map, LinkedList<String> route, int n) {
+        if (route.size() == n + 1) {
+            return true;
+        }
+        if (!map.containsKey(airport) || map.get(airport).isEmpty()) {
+            return false;
+        }
+        ArrayList<String> list = map.get(airport);
+        for (int i = 0; i < list.size(); i++) {
+            String target = list.remove(i);
+
+            route.add(target);
+            if (dfs(target, map, route, n)) {
+                return true;
+            }
+            route.removeLast();
+
+            list.add(i, target);
+        }
+        return false;
+    }
+
+    /**
+     * 欧拉递归解法如下
+     */
+    public List<String> findItinerary3(String[][] tickets) {
+        for (String[] ticket : tickets)
+            targets.computeIfAbsent(ticket[0], k -> new PriorityQueue()).add(ticket[1]);
+        visit("JFK");
+        return route;
+    }
+
+    Map<String, PriorityQueue<String>> targets = new HashMap<>();
+    List<String> route = new LinkedList();
+
+    void visit(String airport) {
+        while (targets.containsKey(airport) && !targets.get(airport).isEmpty())
+            visit(targets.get(airport).poll());
+        route.add(0, airport);
+    }
+
+    /**
+     * 欧拉迭代写法
+     */
+    public List<String> findItinerary4(String[][] tickets) {
+        for (String[] ticket : tickets)
+            targets.computeIfAbsent(ticket[0], k -> new PriorityQueue()).add(ticket[1]);
+
+        Map<String, PriorityQueue<String>> targets = new HashMap<>();
+        List<String> route = new LinkedList();
+
+        Stack<String> stack = new Stack<>();
+        stack.push("JFK");
+
+        while (!stack.isEmpty()) {
+            String s = stack.peek();
+            while (targets.containsKey(s) && !targets.get(s).isEmpty())
+                stack.push(targets.get(s).poll());
+            route.add(0, stack.pop());
+        }
+
+        return route;
+    }
+}