weekly-240

Signed-off-by: ashKIK <[email protected]>

Author: px100

weekly-240/LargestColorValueInADirectedGraph.java

@@ -0,0 +1,57 @@
+
+// https://leetcode.com/contest/weekly-contest-240/problems/largest-color-value-in-a-directed-graph/
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+public class LargestColorValueInADirectedGraph {
+
+  // Topological sort + DP
+  public int largestPathValue(String colors, int[][] edges) {
+    int n = colors.length();
+    List<List<Integer>> childToParent = new ArrayList<>();
+    List<List<Integer>> parentToChildren = new ArrayList<>();
+    int[] outDegree = new int[n];
+    for (int i = 0; i < n; i++) {
+      childToParent.add(new ArrayList<>());
+      parentToChildren.add(new ArrayList<>());
+    }
+    for (int[] edge : edges) {
+      int from = edge[0];
+      int to = edge[1];
+      childToParent.get(to).add(from);
+      parentToChildren.get(from).add(to);
+      outDegree[from]++;
+    }
+    Queue<Integer> queue = new LinkedList<>();
+    int[][] dp = new int[n][26];
+    for (int i = 0; i < n; i++) {
+      if (outDegree[i] == 0) {
+        queue.add(i);
+      }
+    }
+    int res = 0;
+    int count = n;
+    while (!queue.isEmpty()) {
+      int node = queue.poll();
+      count--;
+      int nodeColor = colors.charAt(node) - 'a';
+      for (int i = 0; i < 26; i++) {
+        for (int prev : parentToChildren.get(node)) {
+          dp[node][i] = Math.max(dp[node][i], dp[prev][i]);
+        }
+      }
+      dp[node][nodeColor]++;
+      res = Math.max(res, dp[node][nodeColor]);
+      for (int parent : childToParent.get(node)) {
+        outDegree[parent]--;
+        if (outDegree[parent] == 0) {
+          queue.add(parent);
+        }
+      }
+    }
+    return count > 0 ? -1 : res;
+  }
+}

weekly-240/MaximumDistanceBetweenAPairOfValues.java

@@ -0,0 +1,19 @@
+
+// https://leetcode.com/contest/weekly-contest-240/problems/maximum-distance-between-a-pair-of-values/
+
+public class MaximumDistanceBetweenAPairOfValues {
+
+  public int maxDistance(int[] nums1, int[] nums2) {
+    int i = 0;
+    int j = 0;
+    int max = 0;
+    while (i < nums1.length) {
+      while (j < nums2.length && nums1[i] <= nums2[j]) {
+        j++;
+      }
+      max = Math.max(max, j - i - 1);
+      i++;
+    }
+    return max;
+  }
+}

weekly-240/MaximumPopulationYear.java

@@ -0,0 +1,23 @@
+
+// https://leetcode.com/contest/weekly-contest-240/problems/maximum-population-year/
+
+public class MaximumPopulationYear {
+
+  public int maximumPopulation(int[][] logs) {
+    int maxPopSoFar = 0;
+    int year = 0;
+    for (int i = 1950; i <= 2050; i++) {
+      int pop = 0;
+      for (int[] log : logs) {
+        if (i >= log[0] && i < log[1]) {
+          pop++;
+        }
+      }
+      if (pop > maxPopSoFar) {
+        maxPopSoFar = pop;
+        year = i;
+      }
+    }
+    return year;
+  }
+}

weekly-240/MaximumSubarrayMinProduct.java

@@ -0,0 +1,53 @@
+
+// https://leetcode.com/contest/weekly-contest-240/problems/maximum-subarray-min-product/
+
+import java.util.Stack;
+
+public class MaximumSubarrayMinProduct {
+
+  public int maxSumMinProduct(int[] nums) {
+    int n = nums.length;
+    int[] leftBound = new int[n + 1];
+    int[] rightBound = new int[n + 1];
+    Stack<Integer> stack = new Stack<>();
+    for (int i = 0; i < n; i++) {
+      while (!stack.isEmpty() && nums[stack.peek()] >= nums[i]) {
+        stack.pop();
+      }
+      if (stack.isEmpty()) {
+        leftBound[i] = 0;
+      } else {
+        leftBound[i] = stack.peek() + 1;
+      }
+      stack.push(i);
+    }
+    stack.clear();
+    for (int i = n - 1; i >= 0; i--) {
+      while (!stack.isEmpty() && nums[stack.peek()] >= nums[i]) {
+        stack.pop();
+      }
+      if (stack.isEmpty()) {
+        rightBound[i] = n - 1;
+      } else {
+        rightBound[i] = stack.peek() - 1;
+      }
+      stack.push(i);
+    }
+    long[] preSum = new long[n + 1];
+    for (int i = 0; i < n; i++) {
+      preSum[i + 1] = preSum[i] + nums[i];
+    }
+    long maxProduct = 0;
+    for (int i = 0; i < n; i++) {
+      maxProduct = Math.max(maxProduct, nums[i] * getSum(preSum, leftBound[i], rightBound[i]));
+    }
+    return (int) (maxProduct % 1000000007);
+  }
+
+  private long getSum(long[] preSum, int left, int right) {
+    if (left > right) {
+      return 0;
+    }
+    return preSum[right + 1] - preSum[left];
+  }
+}