fd

Author: dingjikerbo

leetcode/solution/src/AddBinary.java

@@ -2,14 +2,13 @@ public class AddBinary {
 
     public String addBinary(String a, String b) {
         StringBuilder sb = new StringBuilder();
-        int i = a.length() - 1, j = b.length() - 1, k = 0;
-        for ( ; i >= 0 || j >= 0 || k > 0; i--, j--) {
-            int i0 = i >= 0 ? a.charAt(i) - '0' : 0;
-            int j0 = j >= 0 ? b.charAt(j) - '0' : 0;
-            int s = i0 + j0 + k;
-            sb.insert(0, s & 1);
-            k = s >> 1;
+        for (int i = a.length() - 1, j = b.length() - 1, flag = 0; i >= 0 || j >= 0 || flag > 0; i--, j--) {
+            int k1 = i >= 0 ? a.charAt(i) - '0' : 0;
+            int k2 = j >= 0 ? b.charAt(j) - '0' : 0;
+            int sum = k1 + k2 + flag;
+            sb.append(sum % 2);
+            flag = sum / 2;
         }
-        return sb.toString();
+        return sb.reverse().toString();
     }
 }

leetcode/solution/src/LongestIncreasingSubsequence.java

@@ -3,7 +3,7 @@
 public class LongestIncreasingSubsequence {
 
     /**
-     * 这题是典型的DP，f[i]包含i的最长子序列长度
+     * 这题是典型的DP，f[i]包含i的最长递增子序列长度
      */
     public int lengthOfLIS(int[] nums) {
         int n = nums.length;
@@ -27,24 +27,22 @@ public int lengthOfLIS(int[] nums) {
         return max;
     }
 
+    /**
+     * 核心思路是dp维护了一个递增的序列，dp[i]表示nums中长度为i+1的递增子序列中tail最小的值
+     * tail越小意味着之后延长这个序列更容易
+     * 为了保证dp[i]是tail最小的，我们遍历nums时，当发现有更小的值时，会替换dp[i]
+     */
     public int lengthOfLIS2(int[] nums) {
-        int len = 1;
-        for (int i = 0; i < nums.length; i++) {
-            /**
-             * 注意这里要指定区间，且end是开区间
-             */
-            int k = Arrays.binarySearch(nums, 0, len, nums[i]);
-            /**
-             * 只处理k<0的情况
-             */
-            if (k < 0) {
-                k = -(k + 1);
-                if (k == len) {
-                    len++;
-                }
-                nums[k] = nums[i];
-            }
+        int[] dp = new int[nums.length];
+        int len = 0;
+
+        for(int x : nums) {
+            int i = Arrays.binarySearch(dp, 0, len, x);
+            if(i < 0) i = -(i + 1);
+            dp[i] = x;
+            if(i == len) len++;
         }
+
         return len;
     }
 }

leetcode/src/Main.java

@@ -4,29 +4,32 @@ public class Main {
 
     public static class Solution {
 
-        public int firstMissingPositive(int[] nums) {
-            for (int i = 0; i < nums.length; i++) {
-                while (nums[i] - 1 < nums.length && nums[i] - 1 >= 0 && nums[i] != nums[nums[i] - 1]) {
-                    swap(nums, i, nums[i] - 1);
-                }
+        class MinStack {
+
+            /** initialize your data structure here. */
+            public MinStack() {
+
             }
-            for (int i = 0; i < nums.length; i++) {
-                if (nums[i] != i + 1) {
-                    return i + 1;
-                }
+
+            public void push(int x) {
+
+            }
+
+            public void pop() {
+
+            }
+
+            public int top() {
+
             }
-            return nums.length + 1;
-        }
 
-        private void swap(int[] nums, int i, int j) {
-            int t = nums[i];
-            nums[i] = nums[j];
-            nums[j] = t;
+            public int getMin() {
+
+            }
         }
     }
 
 
-
     public static void main(String[] args) {
         Solution solution = new Solution();
     }