569-Week 08

Author: digitspace

Week_08/G20200343030569/LeetCode_300_569.java

@@ -0,0 +1,48 @@
+package week08;
+import java.util.Arrays;
+
+/*
+ * 300. Longest Increasing Subsequence
+ * 最长上升子序列
+ * 
+ * 给定一个无序的整数数组，找到其中最长上升子序列的长度。
+
+示例:
+
+输入: [10,9,2,5,3,7,101,18]
+输出: 4 
+解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。
+说明:
+
+可能会有多种最长上升子序列的组合，你只需要输出对应的长度即可。
+你算法的时间复杂度应该为 O(n2) 。
+进阶: 你能将算法的时间复杂度降低到 O(n log n) 吗?
+
+ */
+public class LeetCode_300_569 {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+	}
+
+	//状态定义dp[i], 表示当包含nums[i]的这个位置最长上升子序列的长度
+	//状态方程  dp[i] = max(所有dp[j]) {0<=j<i且num[j]<num[i]的所有值}
+	class Solution {
+	    public int lengthOfLIS(int[] nums) {
+	    	if( nums.length == 0 )
+	    		return 0;
+	    	int[] dp = new int[nums.length];
+	    	Arrays.fill(dp, 1);
+	    	int max = 1;
+	    	for(int i = 1; i < dp.length; i++) {
+	    		for( int j = 0; j < i; j++ ) {
+	    			if( nums[j] < nums[i] )
+	    				dp[i] = Math.max(dp[i], dp[j]+1);
+	    		}
+	    		max = Math.max(max, dp[i]);
+	    	}
+	    	return max;
+	    }
+	}
+}

Week_08/G20200343030569/LeetCode_63_569.java

@@ -0,0 +1,65 @@
+package week08;
+/*
+ * 63. Unique Paths II
+ * 
+ * 个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。
+
+机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。
+
+现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
+
+网格中的障碍物和空位置分别用 1 和 0 来表示。
+
+说明：m 和 n 的值均不超过 100。
+
+示例 1:
+
+输入:
+[
+  [0,0,0],
+  [0,1,0],
+  [0,0,0]
+]
+输出: 2
+解释:
+3x3 网格的正中间有一个障碍物。
+从左上角到右下角一共有 2 条不同的路径：
+1. 向右 -> 向右 -> 向下 -> 向下
+2. 向下 -> 向下 -> 向右 -> 向右
+
+ */
+public class LeetCode_63_569 {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+	}
+
+	/*
+	 * dp[i][j] i表示行坐标，j表示列坐标，dp[i][j]表示在i,j这个坐标的路径数
+	 * dp[i][j] = dp[i-1][j] + dp[i][j-1];  i,j路径等于上面点路径和左边点路径之和
+	 * 第一行第一列路径皆为1，如果有障碍则该点和后续皆为0
+	 */
+	class Solution {
+	    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
+	    	if( obstacleGrid[0][0] == 1 )
+	    		return 0;
+	    	int[][] dp = new int[obstacleGrid.length][obstacleGrid[0].length];
+	    	dp[0][0] = 1;
+	    	for( int i = 1; i < dp.length; i++ )
+	    		dp[i][0] =( dp[i-1][0] == 1 && obstacleGrid[i][0] != 1 ) ? 1 : 0;
+	    	for( int i = 1; i < dp[0].length; i++ )
+	    		dp[0][i] =( dp[0][i-1] == 1 && obstacleGrid[0][i] != 1 ) ? 1 : 0;
+	    	for( int i = 1; i < dp.length; i++ ) {
+	    		for( int j = 1; j < dp[0].length; j++ ) {
+	    			if( obstacleGrid[i][j] != 1 ) {
+	    				dp[i][j] = dp[i-1][j] + dp[i][j-1];
+	    			}else {
+	    				dp[i][j] = 0;
+	    			}
+	    		}
+	    	}
+	    	return dp[dp.length-1][dp[0].length-1];
+	    }
+	}
+}

Week_08/G20200343030569/LeetCode_8_569.java

@@ -0,0 +1,42 @@
+package week08;
+
+/*
+ * 8. String to Integer (atoi)
+ * 字符串转换整数 (atoi)
+ */
+public class LeetCode_8_569 {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		String str = " ";
+		System.out.println( new  LeetCode_8_569().new Solution().myAtoi(str) );
+	}
+
+	class Solution {
+	    public int myAtoi(String str) {
+	    	if( str.length() <= 0 )
+	    		return 0;
+	    	int idx = 0;
+	    	int sign = 1; 
+	    	int result = 0;
+	    	while( idx < str.length() && str.charAt(idx) == ' ' )
+	    		idx++;	    	
+	    	if( idx < str.length() && (str.charAt(idx) == '+' || str.charAt(idx) == '-') ){
+	            sign = str.charAt(idx) == '+' ? 1 : -1;
+	            idx++;
+	        }
+	    	while ( idx < str.length() ) {
+	    		int digit = str.charAt(idx) - '0';
+	            if ( digit < 0 || digit > 9 ) 
+	            	break;
+	            if (result > (Integer.MAX_VALUE - digit) / 10) {
+	                 return  (sign == 1)? Integer.MAX_VALUE : Integer.MIN_VALUE;
+	            }
+	            result = result * 10 + digit;
+	            idx++;
+	         }
+	    	return result * sign;
+
+	    }
+	}
+}

Week_08/G20200343030569/LeetCode_91_569.java

@@ -0,0 +1,110 @@
+package week08;
+
+/*
+ * 91. Decode Ways
+ * 解码方法
+ * 一条包含字母 A-Z 的消息通过以下方式进行了编码：
+
+'A' -> 1
+'B' -> 2
+...
+'Z' -> 26
+给定一个只包含数字的非空字符串，请计算解码方法的总数。
+
+示例 1:
+
+输入: "12"
+输出: 2
+解释: 它可以解码为 "AB"（1 2）或者 "L"（12）。
+示例 2:
+
+输入: "226"
+输出: 3
+解释: 它可以解码为 "BZ" (2 26), "VF" (22 6), 或者 "BBF" (2 2 6) 。
+
+
+ */
+
+public class LeetCode_91_569 {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		String s = "12";
+		int result = new LeetCode_91_569().new Solution().numDecodings(s);
+		System.out.println( result );
+	}
+	
+	/*
+	 * 自右至左
+	 * 定义状态数组： dp[i] 代表从第i位到最后的字串的解码方法
+	 * dp方程：
+	 * 		如果s[i]=0, dp[i]=0
+	 * 		如果s[i]+s[i+1] <= 26, dp[i] = dp[i+1]+dp[i+2]
+	 * 		如果s[i]+s[i+1] > 26, dp[i] = dp[i+1]
+	 * 
+	 */
+	class Solution1 {
+	    public int numDecodings(String s) {
+	    	int n = s.length();
+	    	if( n <= 0)
+	    		return 0;
+	    	
+	    	int[] dp = new int[n+1];
+	    	dp[n] = 1;
+	    	dp[n-1] = s.charAt(n-1) != '0' ? 1 : 0;
+	    	
+	    	for( int i = n-2; i >= 0; i-- ) {
+	    		if ( s.charAt(i) == '0') {
+	    			dp[i] = 0;
+	    		} else if (Integer.parseInt(s.substring(i,i+2)) <= 26 ) {
+	    			dp[i] = dp[i+1] + dp[i+2];
+	    		} else  {
+	    			dp[i] = dp[i+1];
+	    		}
+	    	}
+	    	return dp[0];
+	    }
+	}
+	
+	//状态定义:
+	//  dp[i] 代表s[0..i]总共解码个数
+	//状态方程:
+	//  if s[i] = 0 
+    //      if s[i-1] = 1 || 2
+	//           dp[i] = dp[i-2]
+	//      else
+	//           return 0;
+	//  if s[i] != 0
+	//      if  s[i-1,i] <= 26  &&  s[i-1,i] > 10 
+	//           dp[i] = dp[i-1] + dp[i-2]
+	//      else s[i-1,i] < 10 || s[i-1,i] > 26
+	//           dp[i] = dp[i-1]
+	
+	class Solution {
+	    public int numDecodings(String s) {
+	    	int n = s.length();
+	    	if( n <= 0)
+	    		return 0;
+	    	
+	    	int[] dp = new int[n+1];
+	    	dp[0] = 1;
+	    	dp[1] = s.charAt(0) != '0' ? 1 : 0;
+	    	
+	    	for( int i = 1; i < s.length(); i++ ) {
+	    		if ( s.charAt(i) == '0') {
+	    			if( s.charAt(i-1) == '1' || s.charAt(i-1) == '2' ) {
+	    				dp[i+1] = dp[i-1];
+	    			}else {
+	    				return 0;
+	    			}
+	    		} else if (Integer.parseInt(s.substring(i-1,i+1)) <= 26 
+	    					&& Integer.parseInt(s.substring(i-1,i+1)) > 10 ) {
+	    			dp[i+1] = dp[i] + dp[i-1];
+	    		} else  {
+	    			dp[i+1] = dp[i];
+	    		}
+	    	}
+	    	return dp[n];
+	    }
+	}
+}