569-Week 05

Author: digitspace

Week_05/G20200343030569/LeetCode_221_569.java

@@ -0,0 +1,62 @@
+
+/*
+ * 221. Maximal Square
+ * 最大正方形
+ * 
+ * 在一个由 0 和 1 组成的二维矩阵内，找到只包含 1 的最大正方形，并返回其面积。
+
+示例:
+
+输入: 
+
+1 0 1 0 0
+1 0 1 1 1
+1 1 1 1 1
+1 0 0 1 0
+
+输出: 4
+
+
+ */
+public class LeetCode_221_569 {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		char[][] matrix = {
+				{ '1', '0', '1', '0', '0' },
+				{ '1', '0', '1', '1', '1' },
+				{ '1', '1', '1', '1', '1' },
+				{ '1', '0', '0', '1', '0' }
+		};
+		
+		int result = new LeetCode_221_569().new Solution().maximalSquare(matrix);
+		System.out.println(result);
+	}
+
+	/*
+	 * 看来的别人的思路，关键在于状态方程 
+	 * 状态数组dp[i][j],里面放的是最大长方形边长
+	 * 状态方程： dp(i, j)=min(dp(i−1, j), dp(i−1, j−1), dp(i, j−1))+1
+	 * if (grid(i, j) == 1) {
+    		dp(i, j) = min(dp(i-1, j), dp(i, j-1), dp(i-1, j-1)) + 1;
+	   }
+	 */
+	
+	class Solution {
+	    public int maximalSquare(char[][] matrix) {
+	        int rows = matrix.length;
+	        int cols = matrix[0].length;
+	        int[][] dp = new int[rows + 1][cols + 1];
+	        int maxsqlen = 0;
+	        for (int i = 1; i <= rows; i++) {
+	            for (int j = 1; j <= cols; j++) {
+	                if (matrix[i-1][j-1] == '1'){
+	                    dp[i][j] = Math.min(Math.min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
+	                    maxsqlen = Math.max(maxsqlen, dp[i][j]);
+	                }
+	            }
+	        }
+	        return maxsqlen * maxsqlen;
+	    }
+	}
+}

Week_05/G20200343030569/LeetCode_621_569.java

@@ -0,0 +1,63 @@
+import java.util.Arrays;
+
+/*
+ * 621. Task Scheduler
+ * 任务调度器
+ * 
+ * 给定一个用字符数组表示的 CPU 需要执行的任务列表。其中包含使用大写的 A - Z 字母表示的26 种不同种类的任务。
+ * 任务可以以任意顺序执行，并且每个任务都可以在 1 个单位时间内执行完。CPU 在任何一个单位时间内都可以执行一
+ * 个任务，或者在待命状态。
+
+然而，两个相同种类的任务之间必须有长度为 n 的冷却时间，因此至少有连续 n 个单位时间内 CPU 在执行不同的任务，
+或者在待命状态。
+
+你需要计算完成所有任务所需要的最短时间。
+
+示例 1：
+
+输入: tasks = ["A","A","A","B","B","B"], n = 2
+输出: 8
+执行顺序: A -> B -> (待命) -> A -> B -> (待命) -> A -> B.
+注：
+
+任务的总个数为 [1, 10000]。
+n 的取值范围为 [0, 100]。
+
+ */
+public class LeetCode_621_569 {
+
+	public static void main(String[] args) {
+		char[] tasks = { 'A', 'A', 'A', 'B', 'B', 'B' };
+		int n = 2;
+		int result = new LeetCode_621_569().new Solution().leastInterval(tasks, n);
+		System.out.println( result );
+	}
+
+	/*
+	 * 解题思路：
+     * 1、将任务按类型分组，正好A-Z用一个int[26]保存任务类型个数
+     * 2、对数组进行排序，优先排列个数（count）最大的任务，
+     *      如题得到的时间至少为 retCount =（count-1）* (n+1) + 1 ==> A->X->X->A->X->X->A(X为其他任务或者待命)
+     * 3、再排序下一个任务，如果下一个任务B个数和最大任务数一致，
+     *      则retCount++ ==> A->B->X->A->B->X->A->B
+     * 4、如果空位都插满之后还有任务，那就随便在这些间隔里面插入就可以，因为间隔长度肯定会大于n，在这种情况下就是任务的总数是最小所需时间
+     *
+	 */
+	class Solution {
+	    public int leastInterval(char[] tasks, int n) {
+	    	int[] taskCounts = new int[26];
+	    	for(char task: tasks) {
+	    		taskCounts[task-'A']++;
+	    	}
+	    	Arrays.sort(taskCounts);
+	    	int lastCount = 0; //那最后一个桶大小如何求呢，很明显就是 拥有最多数任务的个数
+	    	for (int i = 25; i >= 0; i--) {
+	            if(taskCounts[i] != taskCounts[25]){
+	                break;
+	            }
+	            lastCount++;
+	        }
+	    	return Math.max((taskCounts[25] - 1) * (n + 1) + lastCount, tasks.length);
+	    }
+	}
+}

Week_05/G20200343030569/LeetCode_64_569.java

@@ -0,0 +1,59 @@
+/*
+ * 64. Minimum Path Sum
+ * 最小路径和
+ * 
+ * 
+ * 给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
+
+说明：每次只能向下或者向右移动一步。
+
+示例:
+
+输入:
+[
+  [1,3,1],
+  [1,5,1],
+  [4,2,1]
+]
+输出: 7
+解释: 因为路径 1→3→1→1→1 的总和最小。
+
+ */
+public class LeetCode_64_569 {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		int[][] grid = {
+					{1, 3, 1 },
+					{1, 5, 1},
+					{4, 2, 1}
+				};
+		int result = new LeetCode_64_569().new Solution().minPathSum(grid);
+		System.out.println( result);
+	}
+	
+	/*
+	 * 从终点到起点
+	 * 分治： problem[i,j] = min( subproblem[i+1,j], subproblem[i,j+1] )
+	 * 状态表： grid[i,j]
+	 * dp方程: f[i,j] = min( f[i+1,j], f[i,j+1] ) + grid[i,j];
+	 * 
+	 */
+
+	class Solution {
+	    public int minPathSum(int[][] grid) {
+	    	for(int i = grid.length -1; i>=0; i-- ) {
+	    		for( int j = grid[0].length-1; j>=0; j-- ) {
+	    			if( i == grid.length-1 && j != grid[0].length -1 ) {
+	    				grid[i][j] = grid[i][j] + grid[i][j+1];
+	    			}else if( j == grid[0].length-1 && i != grid.length-1 ) {
+	    				grid[i][j] = grid[i][j] + grid[i+1][j];
+	    			}else if( i != grid.length-1 && j != grid[0].length-1 ) {
+	    				grid[i][j] = Math.min(grid[i+1][j], grid[i][j+1]) + grid[i][j];
+	    			}
+	    		}
+	    	}
+	    	return grid[0][0];
+	    }
+	}
+}

Week_05/G20200343030569/LeetCode_91_569.java

@@ -0,0 +1,67 @@
+
+/*
+ * 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 = "12031";
+		int result = new LeetCode_91_569().new Solution().numDecodings(s);
+		System.out.println( result );
+	}
+
+	/*
+	 * 自底而上
+	 * 分治：problem[i] = subproblem[i+1] + subproblem[i+2](i+2如果该双字符不大于26，则i+2=0)
+	 * 状态数组： dp[n+1]
+	 * 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 Solution {
+	    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];
+	    }
+	}
+}