20190118

Author: mJackie

code/lc394.java

@@ -0,0 +1,54 @@
+package code;
+/*
+ * 394. Decode String
+ * 题意：解码字符串
+ * 难度：Medium
+ * 分类：Stack, Depth-first Search
+ * 思路：用栈
+ * Tips：可以用两个栈，一个字符串入栈，而不是字符入栈，另一个数字入栈。提高运行速度，不用重复遍历字符。
+ */
+import java.util.Stack;
+
+public class lc394 {
+    public static void main(String[] args) {
+        System.out.println(decodeString("2[abc]3[cd]ef"));
+    }
+    public static String decodeString(String s) {
+        Stack<Character> st = new Stack();
+        int i = 0;
+        char[] str_arr = s.toCharArray();
+        StringBuilder res = new StringBuilder();
+
+        while(i<s.length()){
+            if(str_arr[i]==']'){
+                StringBuilder temp = new StringBuilder();
+                StringBuilder num = new StringBuilder();
+                while(st.peek()!='['){
+                    temp.insert(0, st.pop());
+                }
+                st.pop();   // pop出 [
+                while(!st.isEmpty() && Character.isDigit(st.peek())){
+                    num.insert(0, st.pop());
+                }
+                StringBuilder temp2 = new StringBuilder();
+                for (int j = 0; j < Integer.valueOf(num.toString()) ; j++) {
+                    temp2.append(temp.toString());
+                }
+                //入栈
+                for (int j = 0; j < temp2.toString().length() ; j++) {
+                    st.push(temp2.toString().toCharArray()[j]);
+                }
+            }else{
+                st.push(str_arr[i]);
+            }
+            i++;
+        }
+        // 别忘了末尾的
+        StringBuilder sb1 = new StringBuilder();
+        while(!st.isEmpty()){
+            sb1.insert(0, st.pop());
+        }
+        res.append(sb1);
+        return res.toString();
+    }
+}

code/lc406.java

@@ -0,0 +1,37 @@
+package code;
+/*
+ * 406. Queue Reconstruction by Height
+ * 题意：队列重构，每个元素有两个值，一个是身高，一个是他前边有几个比他高的，相同身高也算比他高
+ * 难度：Medium
+ * 分类：Greedy
+ * 思路：每次把当前最高身高的挑出来，按第二个值排序插进来
+ *      E.g.
+ *      input: [[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]
+ *      subarray after step 1: [[7,0], [7,1]]
+ *      subarray after step 2: [[7,0], [6,1], [7,1]]
+ * Tips：看下别人的代码，写的很简洁。注意相关的接口和方法。
+ */
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class lc406 {
+    public static void main(String[] args) {
+        int[][] people = {{7,0}, {4,4}, {7,1}, {5,0}, {6,1}, {5,2}};
+        reconstructQueue(people);
+    }
+    public static int[][] reconstructQueue(int[][] people) {
+        Arrays.sort(people,new Comparator<int[]>(){
+            @Override
+            public int compare(int[] o1, int[] o2){
+                return o1[0]!=o2[0]?-o1[0]+o2[0]:o1[1]-o2[1];       //按身高降序排序，如果身高相同，则按前边有几个人增序排序
+            }
+        });
+        List<int[]> res = new LinkedList<>();
+        for(int[] cur : people){
+            res.add(cur[1],cur);    //用于在列表的指定位置插入指定元素，并将当前处于该位置的元素及其后续元素的索引加1
+        }
+        return res.toArray(new int[people.length][]);   //list转array,需要传入一个array对象
+    }
+}

code/lc416.java

@@ -0,0 +1,42 @@
+package code;
+
+import java.util.HashSet;
+/*
+ * 416. Partition Equal Subset Sum
+ * 题意：一个数组，可否分成和相等的两部分
+ * 难度：Medium
+ * 分类：Dynamic Programming
+ * 思路：题意可以转换为用任意个元素组成的和等于数组和/2。可以和 lc1, lc15 3-Sum 对比。
+ *      0，1背包问题，递推比较简单，所以空间可以压缩成一维
+ *      自己想的思路其实和压缩后的0，1背包类似，但没想到该问题可以抽象为0，1背包
+ * Tips：
+ */
+public class lc416 {
+    public static void main(String[] args) {
+        int[] nums = {1, 2, 5};
+        System.out.println(canPartition(nums));
+    }
+    public static boolean canPartition(int[] nums) {
+        int sum = 0;
+        for (int i : nums) {
+            sum+=i;
+        }
+        if(sum%2==1)
+            return false;
+        sum/=2;
+        HashSet<Integer> s = new HashSet();
+        for (int i = 0; i < nums.length ; i++) {
+            if(nums[i]==sum)
+                return true;
+            HashSet<Integer> s2 = new HashSet();    // 新建一个set,用以存放这一轮的结果
+            s2.add(nums[i]);
+            for(int j: s){
+                if(j+nums[i]==sum)
+                    return true;
+                s2.add(j+nums[i]);
+            }
+            s.addAll(s2);
+        }
+        return false;
+    }
+}