20181228

code/lc39.java

@@ -10,7 +10,7 @@ import java.util.List;
  * 分类：Array, Backtracking
  * 思路：回溯法
  * Tips：向res添加答案时注意要new一个新的List,否则后续循环的操作会影响res中的L; 设置一个start标志，记录上次数组循环到哪了,防止重复集合。
- * 和lc46做比较，46是排列组合，所以不需要start标志，start标志是为了防止相同元素的组合排列不同而当做了另一种
+ * 和lc46,lc78做比较，46是排列组合，所以不需要start标志，start标志是为了防止相同元素的组合排列不同而当做了另一种
  */
 public class lc39 {
     public static void main(String[] args) {

code/lc46.java

@@ -8,7 +8,7 @@ import java.util.List;
  * 题意：全排列
  * 难度：Medium
  * 分类：Backtracking
- * 思路：典型的回溯题,注意判断下相同元素重复添加,和lc39做比较
+ * 思路：典型的回溯题,注意判断下相同元素重复添加,和lc39,lc78做比较
  */
 public class lc46 {
     public static void main(String[] args) {

code/lc76.java

+package code;
+/*
+ * 76. Minimum Window Substring
+ * 题意：字符串s中找出能包含t所有字母的最短串
+ * 难度：Hard
+ * 分类：Hash Table, Two Pointers, String
+ * 思路：两个指针，移动右指针使得满足条件，移动左指针缩短距离。用hashmap存储进行判断是否满足条件。
+ * Tips：很难的题，思路记一下。
+ */
+import java.util.HashMap;
+
+public class lc76 {
+    public static void main(String[] args) {
+        System.out.println(minWindow("ADOBECODEBANC","ABC"));
+    }
+    public static String minWindow(String s, String t) {
+        HashMap<Character,Integer> mp = new HashMap();
+        for (int i = 0; i < t.length() ; i++) { //统计每个字符出现的个数
+            char ch = t.charAt(i);
+            if(mp.containsKey(ch))
+                mp.put(ch,mp.get(ch)+1);
+            else
+                mp.put(t.charAt(i),1);
+        }
+        int right = 0;
+        int left = 0;
+        int count = 0;
+        int res_left = 0;
+        int res_len = s.length()+1;
+        while(right<s.length()){
+            // 移动右指针,到能够覆盖t
+            char ch_r = s.charAt(right);
+            if(mp.containsKey(ch_r)){
+                mp.put(ch_r,mp.get(ch_r)-1);
+                if(mp.get(ch_r)>=0) // <0说明重复了
+                    count++;
+            }
+            while(count==t.length()){//右移左指针
+                if(right-left+1<res_len){ //更新结果
+                    res_left = left;
+                    res_len = right-left+1;
+                }
+                char ch_l = s.charAt(left);
+                if(mp.containsKey(ch_l)){
+                    mp.put(ch_l,mp.get(ch_l)+1);
+                    if(mp.get(ch_l)>0)
+                        count--;
+                }
+                left++;
+            }
+            right++;
+        }
+        if(res_len==s.length()+1)
+            return "";
+        return s.substring(res_left,res_left+res_len);
+    }
+}

code/lc78.java

+package code;
+/*
+ * 78. Subsets
+ * 题意：求数组子集
+ * 难度：Medium
+ * 分类：Array, Backtracking, Bit Manipulation
+ * 思路：回溯法
+ * Tips：和lc46,39作比较.要找出子集，所以每次backtracking直接添加进res
+ */
+import java.util.ArrayList;
+import java.util.List;
+
+public class lc78 {
+    public static void main(String[] args) {
+        int[] nums= {1,2,3};
+        System.out.println(subsets(nums).toString());
+    }
+    public static List<List<Integer>> subsets(int[] nums) {
+        List<List<Integer>> res = new ArrayList<List<Integer>>();
+        res.add(new ArrayList<>());
+        if(nums.length==0)
+            return res;
+        backtracking(res,nums,new ArrayList(),-1);
+        return res;
+    }
+    public static void backtracking(List<List<Integer>> res, int[] nums, List l, int start){
+        if(start>=nums.length)
+            return;
+        for (int i = start+1; i < nums.length ; i++) {
+            l.add(nums[i]);
+            res.add(new ArrayList<Integer>(l));
+            backtracking(res,nums,l,i);
+            l.remove((Integer)nums[i]);
+        }
+    }
+}