190423

Author: aluferraz

src/Main.java

@@ -1,3 +1,5 @@
+import leetcode.editor.en.Q1014.BestSightseeingPair;
+import leetcode.editor.en.Q122.BestTimeToBuyAndSellStockIi;
 import leetcode.editor.en.Q152.MaximumProductSubarray;
 import leetcode.editor.en.Q1548.TheMostSimilarPathInAGraph;
 import leetcode.editor.en.Q1567.MaximumLengthOfSubarrayWithPositiveProduct;
@@ -23,7 +25,7 @@
 
 public class Main {
     public static void main(String[] args) throws IOException {
-        System.out.println(new MaximumLengthOfSubarrayWithPositiveProduct().getMaxLen(toIntArray("[1,2,3,5,-6,4,0,10]\n")));
+        System.out.println(new BestTimeToBuyAndSellStockIi().maxProfit(toIntArray("[7,1,5,3,6,4]")));
 
     }
 

src/leetcode/editor/en/Q1014/BestSightseeingPair.java

@@ -0,0 +1,71 @@
+package leetcode.editor.en.Q1014;
+
+import java.util.*;
+
+import javafx.util.Pair;
+import leetcode.editor.en.Q169.MajorityElement;
+
+//You are given an integer array values where values[i] represents the value of 
+//the iᵗʰ sightseeing spot. Two sightseeing spots i and j have a distance j - i 
+//between them. 
+//
+// The score of a pair (i < j) of sightseeing spots is values[i] + values[j] + 
+//i - j: the sum of the values of the sightseeing spots, minus the distance 
+//between them. 
+//
+// Return the maximum score of a pair of sightseeing spots. 
+//
+// 
+// Example 1: 
+//
+// 
+//Input: values = [8,1,5,2,6]
+//Output: 11
+//Explanation: i = 0, j = 2, values[i] + values[j] + i - j = 8 + 5 + 0 - 2 = 11
+// 
+//
+// Example 2: 
+//
+// 
+//Input: values = [1,2]
+//Output: 2
+// 
+//
+// 
+// Constraints: 
+//
+// 
+// 2 <= values.length <= 5 * 10⁴ 
+// 1 <= values[i] <= 1000 
+// 
+//
+// 👍 2312 👎 52
+
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int maxScoreSightseeingPair(int[] values) {
+        LinkedList<int[]> monoStack = new LinkedList<>();
+        monoStack.add(new int[]{values[0], 0});
+        int max = Integer.MIN_VALUE;
+        for (int i = 1; i < values.length; i++) {
+            int num = values[i];
+            int[] prev = monoStack.peekLast();
+            int bestPairHere = (num + prev[0] + (prev[1] - i));
+            max = Math.max(max, bestPairHere);
+            while (!monoStack.isEmpty() && (monoStack.peekLast()[0] - (i - prev[1])) <= num) {
+                monoStack.pollLast();
+            }
+            if (monoStack.isEmpty()) {
+                monoStack.addFirst(new int[]{num, i});
+            }
+        }
+        return max;
+
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+
+public class BestSightseeingPair extends Solution {
+}

src/leetcode/editor/en/Q122/BestTimeToBuyAndSellStockIi.java

@@ -0,0 +1,77 @@
+package leetcode.editor.en.Q122;
+
+import java.util.*;
+
+import javafx.util.Pair;
+
+//You are given an integer array prices where prices[i] is the price of a given 
+//stock on the iᵗʰ day. 
+//
+// On each day, you may decide to buy and/or sell the stock. You can only hold 
+//at most one share of the stock at any time. However, you can buy it then 
+//immediately sell it on the same day. 
+//
+// Find and return the maximum profit you can achieve. 
+//
+// 
+// Example 1: 
+//
+// 
+//Input: prices = [7,1,5,3,6,4]
+//Output: 7
+//Explanation: Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 
+//5-1 = 4.
+//Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3.
+//
+//Total profit is 4 + 3 = 7.
+// 
+//
+// Example 2: 
+//
+// 
+//Input: prices = [1,2,3,4,5]
+//Output: 4
+//Explanation: Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 
+//5-1 = 4.
+//Total profit is 4.
+// 
+//
+// Example 3: 
+//
+// 
+//Input: prices = [7,6,4,3,1]
+//Output: 0
+//Explanation: There is no way to make a positive profit, so we never buy the 
+//stock to achieve the maximum profit of 0.
+// 
+//
+// 
+// Constraints: 
+//
+// 
+// 1 <= prices.length <= 3 * 10⁴ 
+// 0 <= prices[i] <= 10⁴ 
+// 
+//
+// 👍 10849 👎 2523
+
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+
+    public int maxProfit(int[] prices) {
+        int total_profit = 0;
+        for (int i = 0; i < prices.length - 1; i++) {
+            int pontential_profit = prices[i + 1] - prices[i];
+            total_profit += Math.max(pontential_profit, 0);
+        }
+        return total_profit;
+    }
+
+
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+
+public class BestTimeToBuyAndSellStockIi extends Solution {
+}

src/leetcode/editor/en/Q1372/LongestZigzagPathInABinaryTree.java

@@ -0,0 +1,122 @@
+package leetcode.editor.en.Q1372;
+
+import java.util.*;
+
+import javafx.util.Pair;
+
+//You are given the root of a binary tree. 
+//
+// A ZigZag path for a binary tree is defined as follow: 
+//
+// 
+// Choose any node in the binary tree and a direction (right or left). 
+// If the current direction is right, move to the right child of the current 
+//node; otherwise, move to the left child. 
+// Change the direction from right to left or from left to right. 
+// Repeat the second and third steps until you can't move in the tree. 
+// 
+//
+// Zigzag length is defined as the number of nodes visited - 1. (A single node 
+//has a length of 0). 
+//
+// Return the longest ZigZag path contained in that tree. 
+//
+// 
+// Example 1: 
+// 
+// 
+//Input: root = [1,null,1,1,1,null,null,1,1,null,1,null,null,null,1,null,1]
+//Output: 3
+//Explanation: Longest ZigZag path in blue nodes (right -> left -> right).
+// 
+//
+// Example 2: 
+// 
+// 
+//Input: root = [1,1,1,null,1,null,null,1,1,null,1]
+//Output: 4
+//Explanation: Longest ZigZag path in blue nodes (left -> right -> left -> 
+//right).
+// 
+//
+// Example 3: 
+//
+// 
+//Input: root = [1]
+//Output: 0
+// 
+//
+// 
+// Constraints: 
+//
+// 
+// The number of nodes in the tree is in the range [1, 5 * 10⁴]. 
+// 1 <= Node.val <= 100 
+// 
+//
+// 👍 1960 👎 33
+
+class TreeNode {
+    int val;
+    TreeNode left;
+    TreeNode right;
+
+    TreeNode() {
+    }
+
+    TreeNode(int val) {
+        this.val = val;
+    }
+
+    TreeNode(int val, TreeNode left, TreeNode right) {
+        this.val = val;
+        this.left = left;
+        this.right = right;
+    }
+}
+//leetcode submit region begin(Prohibit modification and deletion)
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ * int val;
+ * TreeNode left;
+ * TreeNode right;
+ * TreeNode() {}
+ * TreeNode(int val) { this.val = val; }
+ * TreeNode(int val, TreeNode left, TreeNode right) {
+ * this.val = val;
+ * this.left = left;
+ * this.right = right;
+ * }
+ * }
+ */
+class Solution {
+    int max = 0;
+
+    public int longestZigZag(TreeNode root) {
+        longestZigZagHelper(root);
+        return Math.max(max - 1, 0);
+    }
+
+    private int[] longestZigZagHelper(TreeNode root) {
+        if (root == null) {
+            return new int[]{0, 0};
+        }
+        int[] rightPath = longestZigZagHelper(root.right);
+        int[] leftPath = longestZigZagHelper(root.left);
+        int rightSum = 1 + rightPath[0];
+        int leftSum = 1 + leftPath[1];
+
+        this.max = Math.max(max, rightSum);
+        this.max = Math.max(max, leftSum);
+
+        return new int[]{leftSum, rightSum};
+
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+
+public class LongestZigzagPathInABinaryTree extends Solution {
+}