Added tasks 733, 735, 736, 738, 740.

Author: ThanhNIT

src/main/java/g0701_0800/s0733_flood_fill/Solution.java

@@ -0,0 +1,27 @@
+package g0701_0800.s0733_flood_fill;
+
+// #Easy #Array #Depth_First_Search #Breadth_First_Search #Matrix
+
+public class Solution {
+    public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
+        int o = image[sr][sc];
+        helper(image, sr, sc, newColor, o);
+        return image;
+    }
+
+    private void helper(int[][] img, int r, int c, int n, int o) {
+        if (r >= img.length
+                || c >= img[0].length
+                || r < 0
+                || c < 0
+                || img[r][c] == n
+                || img[r][c] != o) {
+            return;
+        }
+        img[r][c] = n;
+        helper(img, r + 1, c, n, o);
+        helper(img, r - 1, c, n, o);
+        helper(img, r, c + 1, n, o);
+        helper(img, r, c - 1, n, o);
+    }
+}

src/main/java/g0701_0800/s0733_flood_fill/readme.md

@@ -0,0 +1,36 @@
+733\. Flood Fill
+
+Easy
+
+An image is represented by an `m x n` integer grid `image` where `image[i][j]` represents the pixel value of the image.
+
+You are also given three integers `sr`, `sc`, and `newColor`. You should perform a **flood fill** on the image starting from the pixel `image[sr][sc]`.
+
+To perform a **flood fill**, consider the starting pixel, plus any pixels connected **4-directionally** to the starting pixel of the same color as the starting pixel, plus any pixels connected **4-directionally** to those pixels (also with the same color), and so on. Replace the color of all of the aforementioned pixels with `newColor`.
+
+Return _the modified image after performing the flood fill_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/06/01/flood1-grid.jpg)
+
+**Input:** image = [[1,1,1],[1,1,0],[1,0,1]], sr = 1, sc = 1, newColor = 2
+
+**Output:** [[2,2,2],[2,2,0],[2,0,1]]
+
+**Explanation:** From the center of the image with position (sr, sc) = (1, 1) (i.e., the red pixel), all pixels connected by a path of the same color as the starting pixel (i.e., the blue pixels) are colored with the new color. Note the bottom corner is not colored 2, because it is not 4-directionally connected to the starting pixel.
+
+**Example 2:**
+
+**Input:** image = [[0,0,0],[0,0,0]], sr = 0, sc = 0, newColor = 2
+
+**Output:** [[2,2,2],[2,2,2]]
+
+**Constraints:**
+
+*   `m == image.length`
+*   `n == image[i].length`
+*   `1 <= m, n <= 50`
+*   <code>0 <= image[i][j], newColor < 2<sup>16</sup></code>
+*   `0 <= sr < m`
+*   `0 <= sc < n`

src/main/java/g0701_0800/s0735_asteroid_collision/Solution.java

@@ -0,0 +1,43 @@
+package g0701_0800.s0735_asteroid_collision;
+
+// #Medium #Array #Stack
+
+import java.util.Deque;
+import java.util.LinkedList;
+
+public class Solution {
+    public int[] asteroidCollision(int[] asteroids) {
+        Deque<Integer> stack = new LinkedList<>();
+        for (int a : asteroids) {
+            if (a > 0) {
+                stack.addLast(a);
+            } else {
+                if (!stack.isEmpty() && stack.peekLast() > 0) {
+                    if (stack.peekLast() == Math.abs(a)) {
+                        stack.pollLast();
+                    } else {
+                        while (!stack.isEmpty()
+                                && stack.peekLast() > 0
+                                && stack.peekLast() < Math.abs(a)) {
+                            stack.pollLast();
+                        }
+                        if (!stack.isEmpty()
+                                && stack.peekLast() > 0
+                                && stack.peekLast() == Math.abs(a)) {
+                            stack.pollLast();
+                        } else if (stack.isEmpty() || stack.peekLast() < 0) {
+                            stack.addLast(a);
+                        }
+                    }
+                } else {
+                    stack.addLast(a);
+                }
+            }
+        }
+        int[] ans = new int[stack.size()];
+        for (int i = stack.size() - 1; i >= 0; i--) {
+            ans[i] = stack.pollLast();
+        }
+        return ans;
+    }
+}

src/main/java/g0701_0800/s0735_asteroid_collision/readme.md

@@ -0,0 +1,39 @@
+735\. Asteroid Collision
+
+Medium
+
+We are given an array `asteroids` of integers representing asteroids in a row.
+
+For each asteroid, the absolute value represents its size, and the sign represents its direction (positive meaning right, negative meaning left). Each asteroid moves at the same speed.
+
+Find out the state of the asteroids after all collisions. If two asteroids meet, the smaller one will explode. If both are the same size, both will explode. Two asteroids moving in the same direction will never meet.
+
+**Example 1:**
+
+**Input:** asteroids = [5,10,-5]
+
+**Output:** [5,10]
+
+**Explanation:** The 10 and -5 collide resulting in 10. The 5 and 10 never collide.
+
+**Example 2:**
+
+**Input:** asteroids = [8,-8]
+
+**Output:** []
+
+**Explanation:** The 8 and -8 collide exploding each other.
+
+**Example 3:**
+
+**Input:** asteroids = [10,2,-5]
+
+**Output:** [10]
+
+**Explanation:** The 2 and -5 collide resulting in -5. The 10 and -5 collide resulting in 10.
+
+**Constraints:**
+
+*   <code>2 <= asteroids.length <= 10<sup>4</sup></code>
+*   `-1000 <= asteroids[i] <= 1000`
+*   `asteroids[i] != 0`

src/main/java/g0701_0800/s0736_parse_lisp_expression/Solution.java

@@ -0,0 +1,75 @@
+package g0701_0800.s0736_parse_lisp_expression;
+
+// #Hard #String #Hash_Table #Stack #Recursion
+
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Map;
+
+public class Solution {
+    static class Exp {
+        Deque<Exp> exps;
+        String op;
+        Exp parent;
+
+        public Exp(Exp from) {
+            this.exps = new LinkedList<>();
+            this.parent = from;
+        }
+
+        private int evaluate(Map<String, Integer> vars) {
+            if (op.equalsIgnoreCase("add")) {
+                return exps.pop().evaluate(vars) + exps.pop().evaluate(vars);
+            } else if (op.equalsIgnoreCase("mult")) {
+                return exps.pop().evaluate(vars) * exps.pop().evaluate(vars);
+            } else if (op.equalsIgnoreCase("let")) {
+                Map<String, Integer> nextVars = new HashMap<>(vars);
+                while (exps.size() > 1) {
+                    String varName = exps.pop().op;
+                    int val = exps.pop().evaluate(nextVars);
+                    nextVars.put(varName, val);
+                }
+                return exps.pop().evaluate(nextVars);
+            } else {
+                if (Character.isLetter(op.charAt(0))) {
+                    return vars.get(op);
+                } else {
+                    return Integer.parseInt(op);
+                }
+            }
+        }
+    }
+
+    private Exp buildTree(String exp) {
+        Exp root = new Exp(null);
+        Exp cur = root;
+        int n = exp.length() - 1;
+        while (n >= 0) {
+            char c = exp.charAt(n);
+            if (c == ')') {
+                Exp next = new Exp(cur);
+                cur.exps.push(next);
+                cur = next;
+            } else if (c == '(') {
+                cur.op = cur.exps.pop().op;
+                cur = cur.parent;
+            } else if (c != ' ') {
+                int pre = n;
+                while (pre >= 0 && exp.charAt(pre) != '(' && exp.charAt(pre) != ' ') {
+                    pre--;
+                }
+                Exp next = new Exp(cur);
+                next.op = exp.substring(pre + 1, n + 1);
+                cur.exps.push(next);
+                n = pre + 1;
+            }
+            n--;
+        }
+        return root.exps.pop();
+    }
+
+    public int evaluate(String exp) {
+        return buildTree(exp).evaluate(new HashMap<>());
+    }
+}

src/main/java/g0701_0800/s0736_parse_lisp_expression/readme.md

@@ -0,0 +1,47 @@
+736\. Parse Lisp Expression
+
+Hard
+
+You are given a string expression representing a Lisp-like expression to return the integer value of.
+
+The syntax for these expressions is given as follows.
+
+*   An expression is either an integer, let expression, add expression, mult expression, or an assigned variable. Expressions always evaluate to a single integer.
+*   (An integer could be positive or negative.)
+*   A let expression takes the form <code>"(let v<sub>1</sub> e<sub>1</sub> v<sub>2</sub> e<sub>2</sub> ... v<sub>n</sub> e<sub>n</sub> expr)"</code>, where let is always the string `"let"`, then there are one or more pairs of alternating variables and expressions, meaning that the first variable <code>v<sub>1</sub></code> is assigned the value of the expression <code>e<sub>1</sub></code>, the second variable <code>v<sub>2</sub></code> is assigned the value of the expression <code>e<sub>2</sub></code>, and so on sequentially; and then the value of this let expression is the value of the expression `expr`.
+*   An add expression takes the form <code>"(add e<sub>1</sub> e<sub>2</sub>)"</code> where add is always the string `"add"`, there are always two expressions <code>e<sub>1</sub></code>, <code>e<sub>2</sub></code> and the result is the addition of the evaluation of <code>e<sub>1</sub></code> and the evaluation of <code>e<sub>2</sub></code>.
+*   A mult expression takes the form <code>"(mult e<sub>1</sub> e<sub>2</sub>)"</code> where mult is always the string `"mult"`, there are always two expressions <code>e<sub>1</sub></code>, <code>e<sub>2</sub></code> and the result is the multiplication of the evaluation of e1 and the evaluation of e2.
+*   For this question, we will use a smaller subset of variable names. A variable starts with a lowercase letter, then zero or more lowercase letters or digits. Additionally, for your convenience, the names `"add"`, `"let"`, and `"mult"` are protected and will never be used as variable names.
+*   Finally, there is the concept of scope. When an expression of a variable name is evaluated, within the context of that evaluation, the innermost scope (in terms of parentheses) is checked first for the value of that variable, and then outer scopes are checked sequentially. It is guaranteed that every expression is legal. Please see the examples for more details on the scope.
+
+**Example 1:**
+
+**Input:** expression = "(let x 2 (mult x (let x 3 y 4 (add x y))))"
+
+**Output:** 14
+
+**Explanation:** In the expression (add x y), when checking for the value of the variable x, we check from the innermost scope to the outermost in the context of the variable we are trying to evaluate. Since x = 3 is found first, the value of x is 3.
+
+**Example 2:**
+
+**Input:** expression = "(let x 3 x 2 x)"
+
+**Output:** 2
+
+**Explanation:** Assignment in let statements is processed sequentially.
+
+**Example 3:**
+
+**Input:** expression = "(let x 1 y 2 x (add x y) (add x y))"
+
+**Output:** 5
+
+**Explanation:** The first (add x y) evaluates as 3, and is assigned to x. The second (add x y) evaluates as 3+2 = 5.
+
+**Constraints:**
+
+*   `1 <= expression.length <= 2000`
+*   There are no leading or trailing spaces in `expression`.
+*   All tokens are separated by a single space in `expression`.
+*   The answer and all intermediate calculations of that answer are guaranteed to fit in a **32-bit** integer.
+*   The expression is guaranteed to be legal and evaluate to an integer.

src/main/java/g0701_0800/s0738_monotone_increasing_digits/Solution.java

@@ -0,0 +1,17 @@
+package g0701_0800.s0738_monotone_increasing_digits;
+
+// #Medium #Math #Greedy
+
+public class Solution {
+    public int monotoneIncreasingDigits(int n) {
+        for (int i = 10; n / i > 0; i *= 10) {
+            int digit = (n / i) % 10;
+            int endnum = n % i;
+            int firstendnum = endnum * 10 / i;
+            if (digit > firstendnum) {
+                n -= endnum + 1;
+            }
+        }
+        return (n);
+    }
+}

src/main/java/g0701_0800/s0738_monotone_increasing_digits/readme.md

@@ -0,0 +1,29 @@
+738\. Monotone Increasing Digits
+
+Medium
+
+An integer has **monotone increasing digits** if and only if each pair of adjacent digits `x` and `y` satisfy `x <= y`.
+
+Given an integer `n`, return _the largest number that is less than or equal to_ `n` _with **monotone increasing digits**_.
+
+**Example 1:**
+
+**Input:** n = 10
+
+**Output:** 9
+
+**Example 2:**
+
+**Input:** n = 1234
+
+**Output:** 1234
+
+**Example 3:**
+
+**Input:** n = 332
+
+**Output:** 299
+
+**Constraints:**
+
+*   <code>0 <= n <= 10<sup>9</sup></code>

src/main/java/g0701_0800/s0740_delete_and_earn/Solution.java

@@ -0,0 +1,23 @@
+package g0701_0800.s0740_delete_and_earn;
+
+// #Medium #Array #Hash_Table #Dynamic_Programming
+
+public class Solution {
+    public int deleteAndEarn(int[] nums) {
+        int[] sum = new int[10001];
+        int min = 10001;
+        int max = 0;
+        for (int num : nums) {
+            sum[num] += num;
+            min = Math.min(num, min);
+            max = Math.max(num, max);
+        }
+
+        int[] dp = new int[max + 1];
+        dp[min] = sum[min];
+        for (int i = min + 1; i <= max; i++) {
+            dp[i] = Math.max(dp[i - 1], dp[i - 2] + sum[i]);
+        }
+        return dp[max];
+    }
+}

src/main/java/g0701_0800/s0740_delete_and_earn/readme.md

@@ -0,0 +1,44 @@
+740\. Delete and Earn
+
+Medium
+
+You are given an integer array `nums`. You want to maximize the number of points you get by performing the following operation any number of times:
+
+*   Pick any `nums[i]` and delete it to earn `nums[i]` points. Afterwards, you must delete **every** element equal to `nums[i] - 1` and **every** element equal to `nums[i] + 1`.
+
+Return _the **maximum number of points** you can earn by applying the above operation some number of times_.
+
+**Example 1:**
+
+**Input:** nums = [3,4,2]
+
+**Output:** 6
+
+**Explanation:** You can perform the following operations: 
+
+- Delete 4 to earn 4 points. Consequently, 3 is also deleted. nums = [2]. 
+
+- Delete 2 to earn 2 points. nums = []. 
+  
+You earn a total of 6 points.
+
+**Example 2:**
+
+**Input:** nums = [2,2,3,3,3,4]
+
+**Output:** 9
+
+**Explanation:** You can perform the following operations: 
+
+- Delete a 3 to earn 3 points. All 2's and 4's are also deleted. nums = [3,3]. 
+
+- Delete a 3 again to earn 3 points. nums = [3]. 
+
+- Delete a 3 once more to earn 3 points. nums = []. 
+  
+You earn a total of 9 points.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 2 * 10<sup>4</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>4</sup></code>