LeetCode 前400题补充

Author: LjyYano

solution/0100-0199/0188.Best Time to Buy and Sell Stock IV/Solution.java

@@ -0,0 +1,34 @@
+class Solution {
+    public int maxProfit(int k, int[] prices) {
+		if (prices == null || prices.length == 0) {
+			return 0;
+		}
+        
+        if(k >= prices.length) return maxProfit(prices);
+        
+		int n = prices.length;
+		int[] l = new int[k + 1];
+		int[] g = new int[k + 1];
+
+		for (int i = 1; i < n; i++) {
+			int diff = prices[i] - prices[i - 1];
+			for (int j = k; j >= 1; j--) {
+				l[j] = Math.max(l[j], g[j - 1]) + diff;
+				g[j] = Math.max(l[j], g[j]);
+			}
+		}
+
+		return g[k];
+    }
+    
+    public int maxProfit(int[] prices) {
+        // 只要有利润就卖，就是最优解。
+        int profit = 0;
+        for(int i = 1; i < prices.length; i++) {
+            if(prices[i] > prices[i - 1]) {
+                profit += prices[i] - prices[i - 1];
+            }
+        }
+        return profit;
+    }
+}

solution/0200-0299/0204.Count Primes/Solution.java

@@ -0,0 +1,25 @@
+public class Solution {
+    public int countPrimes(int n) {
+
+		boolean[] b = new boolean[n];
+
+		for (int i = 2; i * i < n; i++) {
+			if (b[i] == false) {
+				for (int j = i; i * j < n; j++) {
+					b[i * j] = true;
+				}
+			}
+		}
+
+		int c = 0;
+		for (int i = 2; i < n; i++) {
+			if (b[i] == false) {
+				c++;
+			}
+		}
+
+		return c;
+	
+        
+    }
+}

solution/0200-0299/0205.Isomorphic Strings/Solution.java

@@ -0,0 +1,36 @@
+public class Solution {
+    public boolean isIsomorphic(String s, String t) {
+
+		if (s == null || t == null) {
+			return false;
+		}
+
+		if (s.length() != t.length()) {
+			return false;
+		}
+
+		Map<Character, Character> map = new HashMap<Character, Character>();
+		Set<Character> set = new HashSet<Character>();
+
+		for (int i = 0; i < s.length(); i++) {
+			char c1 = s.charAt(i);
+			char c2 = t.charAt(i);
+
+			if (map.containsKey(c1)) {
+				if (map.get(c1) != c2) {
+					return false;
+				}
+			} else {
+				if (set.contains(c2)) {
+					return false;
+				}
+				map.put(c1, c2);
+				set.add(c2);
+			}
+		}
+
+		return true;
+	
+        
+    }
+}

solution/0200-0299/0210.Course Schedule II/Solution.java

@@ -0,0 +1,54 @@
+class Solution {
+    public int[] findOrder(int numCourses, int[][] pre) {
+    	// key 课程id，value 前置课程id
+		Map<Integer, Set<Integer>> map = new HashMap<>();
+		for (int i = 0; i < pre.length; i++) {
+			if (map.containsKey(pre[i][0])) {
+				map.get(pre[i][0]).add(pre[i][1]);
+			} else {
+				Set<Integer> set = new HashSet<>();
+				set.add(pre[i][1]);
+				map.put(pre[i][0], set);
+			}
+		}
+
+		int[] visit = new int[numCourses];
+		List<Integer> ans = new ArrayList<>();
+		for (int i = 0; i < numCourses; i++) {
+			if (!dfs(i, visit, map, ans)) {
+				return new int[0];
+			}
+		}
+		
+		int[] result = new int[numCourses];
+		for(int i = 0; i < numCourses; i++){
+            result[i] = ans.get(i);
+        }
+		
+		return result;
+    }
+
+	private boolean dfs(int i, int[] visit, Map<Integer, Set<Integer>> map, List<Integer> ans) {
+		if (visit[i] == -1) {
+			return false;
+		}
+
+		if (visit[i] == 1) {
+			return true;
+		}
+
+		visit[i] = -1;
+
+		if (map.containsKey(i)) {
+			for (int pre : map.get(i)) {
+				if (!dfs(pre, visit, map,ans)) {
+					return false;
+				}
+			}
+		}
+
+		visit[i] = 1;
+		ans.add(i);
+		return true;
+	}
+}

solution/0200-0299/0213.House Robber II/Solution.java

@@ -0,0 +1,41 @@
+public class Solution {
+	public static int rob(int[] nums) {
+
+		if (nums == null || nums.length == 0) {
+			return 0;
+		}
+
+		if (nums.length == 1) {
+			return nums[0];
+		}
+
+		if (nums.length == 2) {
+			return Math.max(nums[0], nums[1]);
+		}
+
+		return Math.max(help(Arrays.copyOfRange(nums, 0, nums.length - 1)),
+				help(Arrays.copyOfRange(nums, 1, nums.length)));
+	}
+
+	public static int help(int[] nums) {
+
+		if (nums.length == 0) {
+			return 0;
+		}
+
+		if (nums.length == 1) {
+			return nums[0];
+		}
+
+		int[] P = new int[nums.length];
+
+		P[0] = nums[0];
+		P[1] = Math.max(nums[0], nums[1]);
+
+		for (int i = 2; i < nums.length; i++) {
+			P[i] = Math.max(nums[i] + P[i - 2], P[i - 1]);
+		}
+
+		return P[nums.length - 1];
+	}
+}

solution/0200-0299/0216.Combination Sum III/Solution.java

@@ -0,0 +1,26 @@
+class Solution {
+    public List<List<Integer>> combinationSum3(int k, int n) {
+        List<List<Integer>> ans = new ArrayList<>();        
+        robot(1, k, n, ans, new ArrayList<Integer>());
+        return ans;
+    }
+    
+    private void robot(int start, int k, int left, List<List<Integer>> ans, List<Integer> tmp) {
+        if(k < 0 || left < 0) return;
+        
+        if(k == 0 && left == 0) {
+            ans.add(new ArrayList<>(tmp));
+            return;
+        }
+        
+        for(int i = start; i <= 9; i++) {
+            if(left >= i && k > 0) {
+                tmp.add(i);
+                robot(i + 1, k - 1, left - i, ans, tmp);
+                tmp.remove(tmp.size() - 1);
+            } else {
+                return;
+            }
+        }
+    }
+}

solution/0200-0299/0217.Contains Duplicate/Solution.java

@@ -0,0 +1,13 @@
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        if(nums == null || nums.length == 0) return false;
+        Set<Integer> set = new HashSet<>();
+        
+        for(int v : nums) {
+            if(set.contains(v)) return true;
+            set.add(v);
+        }
+        
+        return false;
+    }
+}

solution/0200-0299/0219.Contains Duplicate II/Solution.java

@@ -0,0 +1,16 @@
+class Solution {
+    public boolean containsNearbyDuplicate(int[] nums, int k) {
+        if(nums == null || nums.length == 0) return false;
+        Map<Integer, Integer> map = new HashMap<>();
+        
+        for(int i = 0; i < nums.length; i++) {
+            if(map.containsKey(nums[i]) && i - map.get(nums[i]) <= k) {
+                return true;
+            } else {
+                map.put(nums[i], i);
+            }
+        }
+        
+        return false;
+    }
+}

solution/0200-0299/0220.Contains Duplicate III/Solution.java

@@ -0,0 +1,29 @@
+public class Solution {
+    public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
+
+		if (k < 1 || t < 0 || nums == null || nums.length < 2) {
+			return false;
+		}
+
+		SortedSet<Long> set = new TreeSet<Long>();
+
+		for (int j = 0; j < nums.length; j++) {
+
+			SortedSet<Long> subSet = set.subSet((long) nums[j] - t,
+					(long) nums[j] + t + 1);
+
+			if (!subSet.isEmpty()) {
+				return true;
+			}
+
+			if (j >= k) {
+				set.remove((long) nums[j - k]);
+			}
+
+			set.add((long) nums[j]);
+		}
+
+		return false;
+
+	}
+}

solution/0200-0299/0221.Maximal Square/Solution.java

@@ -0,0 +1,47 @@
+public class Solution {
+    public int maximalSquare(char[][] matrix) {
+
+		if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
+			return 0;
+		}
+
+		int mx = matrix.length;
+		int my = matrix[0].length;
+
+		int[][] dp = new int[mx][my];
+		int max = 0;
+
+		// 初始化第0行
+		for (int i = 0; i < my; i++) {
+			if (matrix[0][i] == '1') {
+				dp[0][i] = 1;
+				max = 1;
+			}
+		}
+
+		// 初始化第0列
+		for (int i = 1; i < mx; i++) {
+			if (matrix[i][0] == '1') {
+				dp[i][0] = 1;
+				max = 1;
+			}
+		}
+
+		// dp[x][y]=min(dp[x-1][y],dp[x][y-1],dp[x-1][y-1])+1
+		for (int x = 1; x < mx; x++) {
+			for (int y = 1; y < my; y++) {
+
+				if (matrix[x][y] == '1') {
+					dp[x][y] = Math.min(Math.min(dp[x - 1][y], dp[x][y - 1]),
+							dp[x - 1][y - 1]) + 1;
+					max = Math.max(max, dp[x][y]);
+				}
+
+			}
+		}
+
+		return max * max;
+	
+        
+    }
+}

solution/0200-0299/0222.Count Complete Tree Nodes/Solution.java

@@ -0,0 +1,31 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public int countNodes(TreeNode root) {
+        if(root == null){
+           return 0;
+        } 
+        int left = countLevel(root.left);
+        int right = countLevel(root.right);
+        if(left == right){
+            return countNodes(root.right) + (1<<left);
+        }else{
+            return countNodes(root.left) + (1<<right);
+        }
+    }
+    private int countLevel(TreeNode root){
+        int level = 0;
+        while(root != null){
+            level++;
+            root = root.left;
+        }
+        return level;
+    }
+}