20181113

Author: fay111101

src/main/java/leetcode/array/_41_FirstMissingPositive.java

@@ -21,23 +21,23 @@
  */
 public class _41_FirstMissingPositive {
 
-    public int firstMissingPositive(int[] A) {
-        if(A.length==0){
+    public int firstMissingPositive(int[] nums) {
+        if(nums.length==0){
             return 1;
         }
-        int n=A.length,i=0;
+        int n=nums.length,i=0;
         while(i<n){
-            if(A[i]!=i+1&&(A[i]>0&&A[i]<=n)&&A[i]!=A[A[i]-1]){
-                int temp=A[A[i]-1];
-                A[A[i]-1]=A[i];
-                A[i]=temp;
+            if(nums[i]!=i+1&&(nums[i]>0&&nums[i]<=n)&&nums[i]!=nums[nums[i]-1]){
+                int temp=nums[nums[i]-1];
+                nums[nums[i]-1]=nums[i];
+                nums[i]=temp;
             }else{
                 i++;
             }
 
         }
         for(i=0;i<n;i++){
-            if(A[i]!=i+1){
+            if(nums[i]!=i+1){
                 return i+1;
             }
         }

src/main/java/leetcode/array/_4_findMedianSortedArrays.java

@@ -22,33 +22,33 @@
  */
 public class _4_findMedianSortedArrays {
 
-    public double findMedianSortedArrays(int A[], int B[]) {
+    public double findMedianSortedArrays(int nums1[], int nums2[]) {
         double mid = 0.0;
-        int m = A.length;
-        int n = B.length;
-        if (A == null || B == null || m + n == 0) {
+        int m = nums1.length;
+        int n = nums2.length;
+        if (nums1 == null || nums2 == null || m + n == 0) {
             return mid;
         }
         int[] C = new int[m + n];
         int i = 0, j = 0, k = 0;
         while (i < m && j < n) {
-            if (A[i] < B[j]) {
-                C[k] = A[i];
+            if (nums1[i] < nums2[j]) {
+                C[k] = nums1[i];
                 k++;
                 i++;
             } else {
-                C[k] = B[j];
+                C[k] = nums2[j];
                 k++;
                 j++;
             }
         }
         while (j < n) {
-            C[k] = B[j];
+            C[k] = nums2[j];
             k++;
             j++;
         }
         while (i < m) {
-            C[k] = A[i];
+            C[k] = nums1[i];
             k++;
             i++;
         }

src/main/java/leetcode/dfsbfsbacktracing/_60_PermutationSequence.java

@@ -1,65 +1,66 @@
 package leetcode.dfsbfsbacktracing;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * 给出集合 [1,2,3,…,n]，其所有元素共有 n! 种排列。
-
- 按大小顺序列出所有排列情况，并一一标记，当 n = 3 时, 所有排列如下：
-
- "123"
- "132"
- "213"
- "231"
- "312"
- "321"
- 给定 n 和 k，返回第 k 个排列。
-
- 说明：
-
- 给定 n 的范围是 [1, 9]。
- 给定 k 的范围是[1,  n!]。
- 示例 1:
-
- 输入: n = 3, k = 3
- 输出: "213"
- 示例 2:
-
- 输入: n = 4, k = 9
- 输出: "2314"
+ * <p>
+ * 按大小顺序列出所有排列情况，并一一标记，当 n = 3 时, 所有排列如下：
+ * <p>
+ * "123"
+ * "132"
+ * "213"
+ * "231"
+ * "312"
+ * "321"
+ * 给定 n 和 k，返回第 k 个排列。
+ * <p>
+ * 说明：
+ * <p>
+ * 给定 n 的范围是 [1, 9]。
+ * 给定 k 的范围是[1,  n!]。
+ * 示例 1:
+ * <p>
+ * 输入: n = 3, k = 3
+ * 输出: "213"
+ * 示例 2:
+ * <p>
+ * 输入: n = 4, k = 9
+ * 输出: "2314"
  */
 public class _60_PermutationSequence {
-    //
+    /**
+     * n个数的permutation总共有n阶乘个，基于这个性质我们可以得到某一位对应的数字是哪一个。
+     * 思路是这样的，比如当前长度是n，我们知道每个相同的起始元素对应(n-1)!个permutation，
+     * 也就是(n-1)!个permutation后会换一个起始元素。因此，只要当前的k进行(n-1)!取余，
+     * 得到的数字就是当前剩余数组的index，如此就可以得到对应的元素。如此递推直到数组中没有元素结束。
+     * 实现中我们要维护一个数组来记录当前的元素，每次得到一个元素加入结果数组，然后从剩余数组中移除，
+     * 因此空间复杂度是O(n)。时间上总共需要n个回合，而每次删除元素如果是用数组需要O(n),所以总共是O(n^2)。
+     *
+     * @param n
+     * @param k
+     * @return
+     */
     public String getPermutation(int n, int k) {
-        int[] perm = new int[n];
-        int total = 1;
-        for(int i=1;i<=n;i++){
-            perm[i-1] = i;//这里边界出错了
-            total *= i;
+        k--; // to translate index from 0 rather than 1
+        List<Integer> list = new ArrayList<Integer>();
+        for (int i = 1; i <= n; i++) {
+            list.add(i);
         }
-        k %= total;
-        if(k==0) k = total;
-        int count = 0;
-        while(true){
-            count++;
-            if(count==k) break;
-            int i;
-            for(i=n-1;i>0;i--){
-                if(perm[i]>perm[i-1]){
-                    int temp = perm[i-1];
-                    int j;
-                    for(j=n-1;j>i&&perm[j]<temp;j--);
-                    perm[i-1] = perm[j];
-                    perm[j] = temp;
-                    break;
-                }
-            }
-            for(int m=i,j=n-1;m<j;m++,j--){
-                int temp = perm[j];
-                perm[j] = perm[m];
-                perm[m] = temp;
-            }
+        int factorial = 1;
+        for (int i = 2; i < n; i++) {
+            factorial *= i;
+        }
+        int round = n - 1;
+        StringBuilder sb = new StringBuilder();
+        while (round >= 0) {
+            sb.append(list.remove(k / factorial));//new list
+            k %= factorial;//new k
+            if (round != 0) factorial /= round;//new factorial
+            round--;// new round
         }
-        StringBuffer sb = new StringBuffer();
-        for(int num:perm) sb.append(num);
         return sb.toString();
     }
+
 }

src/main/java/leetcode/dpandgreedy/_62_UniquePaths.java

@@ -3,7 +3,8 @@
 /**
  * Created by fay on 2017/12/14.
  * A robot is located at the top-left corner of a m x n grid (marked 'Start' in the diagram below).
- * The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).
+ * The robot can only move either down or right at any point in time.
+ * The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).
  * How many possible unique paths are there?
  * 一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。
  *

src/main/java/leetcode/dpandgreedy/_63_UniquePaths2.java

@@ -2,81 +2,77 @@
 
 /**
  * Created by fay on 2017/12/14.
- *
- Follow up for "Unique Paths":
- Now consider if some obstacles are added to the grids. How many unique paths would there be?
- An obstacle and empty space is marked as1and0respectively in the grid.
- For example,
- There is one obstacle in the middle of a 3x3 grid as illustrated below.
- [
- [0,0,0],
- [0,1,0],
- [0,0,0]
- ]
- 现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
- 网格中的障碍物和空位置分别用 1 和 0 来表示。
- The total number of unique paths is 2.
- Note: m and n will be at most 100.
- 3x3 网格的正中间有一个障碍物。
- 从左上角到右下角一共有 2 条不同的路径：
- 1. 向右 -> 向右 -> 向下 -> 向下
- 2. 向下 -> 向下 -> 向右 -> 向右
+ * <p>
+ * Follow up for "Unique Paths":
+ * Now consider if some obstacles are added to the grids. How many unique paths would there be?
+ * An obstacle and empty space is marked as1and0respectively in the grid.
+ * For example,
+ * There is one obstacle in the middle of a 3x3 grid as illustrated below.
+ * [
+ * [0,0,0],
+ * [0,1,0],
+ * [0,0,0]
+ * ]
+ * 现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
+ * 网格中的障碍物和空位置分别用 1 和 0 来表示。
+ * The total number of unique paths is 2.
+ * Note: m and n will be at most 100.
+ * 3x3 网格的正中间有一个障碍物。
+ * 从左上角到右下角一共有 2 条不同的路径：
+ * 1. 向右 -> 向右 -> 向下 -> 向下
+ * 2. 向下 -> 向下 -> 向右 -> 向右
  */
 public class _63_UniquePaths2 {
 
+    //改进的方法，使用一维数组
     public int uniquePathsWithObstacles(int[][] obstacleGrid) {
-        int n=obstacleGrid[0].length;
-        int m=obstacleGrid.length;
-        int[] dp=new int[n];
-        dp[0]=1;
-        if(obstacleGrid[0][0]==1){
+        int n = obstacleGrid[0].length;
+        int m = obstacleGrid.length;
+        int[] dp = new int[n];
+        dp[0] = 1;
+        if (obstacleGrid[0][0] == 1) {
             return 0;
         }
-        for(int i=0;i<m;i++){
-            for(int j=0;j<n;j++){
-                if(obstacleGrid[i][j]==1){
-                    dp[j]=0;
-                }else if(j>0){
-                    dp[j]+=dp[j-1];
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                if (obstacleGrid[i][j] == 1) {
+                    dp[j] = 0;
+                } else if (j > 0) {
+                    dp[j] += dp[j - 1];
                 }
             }
         }
-        return dp[n-1];
+        return dp[n - 1];
     }
 
     public int uniquePathsWithObstacles1(int[][] obstacleGrid) {
-        if(obstacleGrid==null || obstacleGrid.length==0)
+        if (obstacleGrid == null || obstacleGrid.length == 0)
             return 0;
-        int m=obstacleGrid.length;
-        int n=obstacleGrid[0].length;
-        int[][] dp=new int[m][n]; //dp[i][j]表示从start到[i,j]位置不同路径条
-        // 不需要初始化，默认初始化。
-        //for(int i=0;i<m;i++)
-        // for(int j=0;j<n;j++)
-        //dp[i][j]=0;
-        for(int i=0;i<n;i++)   //第一行障碍处理
+        int m = obstacleGrid.length;
+        int n = obstacleGrid[0].length;
+        int[][] dp = new int[m][n]; //dp[i][j]表示从start到[i,j]位置不同路径条
+        for (int i = 0; i < n; i++)   //第一行障碍处理
         {
-            if(obstacleGrid[0][i]!=1)
-                dp[0][i]=1;
+            if (obstacleGrid[0][i] != 1)
+                dp[0][i] = 1;
             else
                 break;
         }
 
-        for(int j=0;j<m;j++)   //第一列障碍处理
+        for (int j = 0; j < m; j++)   //第一列障碍处理
         {
-            if(obstacleGrid[j][0]!=1)
-                dp[j][0]=1;
+            if (obstacleGrid[j][0] != 1)
+                dp[j][0] = 1;
             else
                 break;
         }
-        for(int i=1;i<m;i++)
-            for(int j=1;j<n;j++)
-            {
-                if(obstacleGrid[i][j]==1)   //如果该位置是障碍，则到达该点的路径条数为0
-                    dp[i][j]=0;
+        for (int i = 1; i < m; i++)
+            for (int j = 1; j < n; j++) {
+                if (obstacleGrid[i][j] == 1)   //如果该位置是障碍，则到达该点的路径条数为0
+                    dp[i][j] = 0;
                 else
-                    dp[i][j]=dp[i-1][j]+dp[i][j-1];
+                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
             }
-        return dp[m-1][n-1];
+        return dp[m - 1][n - 1];
     }
 }

src/main/java/leetcode/dpandgreedy/_70_ClimbingStairs.java

@@ -12,14 +12,16 @@ public int climbStairs(int n) {
         if(n<2){
             return 1;
         }
-        int[] dp=new int[n+1];
+        int[] dp=new int[n];
         dp[0]=1;
-        dp[1]=1;
-        for(int i=2;i<=n;i++){
+        dp[1]=2;
+        for(int i=2;i<n;i++){
             dp[i]=dp[i-1]+dp[i-2];
         }
-        return dp[n];
+        return dp[n-1];
     }
+
+
     public static void main(String[] args){
         _70_ClimbingStairs test=new _70_ClimbingStairs();
         System.out.print(test.climbStairs(5));

src/main/java/leetcode/dpandgreedy/_77_EditDistance.java

@@ -2,7 +2,8 @@
 
 /**
  * Created by fay on 2017/12/15.
- * Given two words word1 and word2, find the minimum number of steps required to convert word1 to word2. (each operation is counted as 1 step.)
+ * Given two words word1 and word2, find the minimum number of steps required to convert word1 to word2.
+ * (each operation is counted as 1 step.)
  You have the following 3 operations permitted on a word:
  a) insert a character
  b) Delete a character