Added tasks 741, 743, 744, 745.

Author: ThanhNIT

src/main/java/g0701_0800/s0741_cherry_pickup/Solution.java

@@ -0,0 +1,47 @@
+package g0701_0800.s0741_cherry_pickup;
+
+// #Hard #Array #Dynamic_Programming #Matrix
+
+public class Solution {
+    public int cherryPickup(int[][] grid) {
+        int[][][] dp = new int[grid.length][grid.length][grid.length];
+        int ans = solve(0, 0, 0, grid, dp);
+        return Math.max(ans, 0);
+    }
+
+    private int solve(int r1, int c1, int r2, int[][] arr, int[][][] dp) {
+        int c2 = r1 + c1 - r2;
+        if (r1 >= arr.length
+                || r2 >= arr.length
+                || c1 >= arr[0].length
+                || c2 >= arr[0].length
+                || arr[r1][c1] == -1
+                || arr[r2][c2] == -1) {
+            return Integer.MIN_VALUE;
+        }
+
+        if (r1 == arr.length - 1 && c1 == arr[0].length - 1) {
+            return arr[r1][c1];
+        }
+
+        if (dp[r1][c1][r2] != 0) {
+            return dp[r1][c1][r2];
+        }
+
+        int cherries = 0;
+        if (r1 == r2 && c1 == c2) {
+            cherries += arr[r1][c1];
+        } else {
+            cherries += arr[r1][c1] + arr[r2][c2];
+        }
+
+        int a = solve(r1, c1 + 1, r2, arr, dp);
+        int b = solve(r1 + 1, c1, r2 + 1, arr, dp);
+        int c = solve(r1, c1 + 1, r2 + 1, arr, dp);
+        int d = solve(r1 + 1, c1, r2, arr, dp);
+
+        cherries += Math.max(Math.max(a, b), Math.max(c, d));
+        dp[r1][c1][r2] = cherries;
+        return cherries;
+    }
+}

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

@@ -0,0 +1,41 @@
+741\. Cherry Pickup
+
+Hard
+
+You are given an `n x n` `grid` representing a field of cherries, each cell is one of three possible integers.
+
+*   `0` means the cell is empty, so you can pass through,
+*   `1` means the cell contains a cherry that you can pick up and pass through, or
+*   `-1` means the cell contains a thorn that blocks your way.
+
+Return _the maximum number of cherries you can collect by following the rules below_:
+
+*   Starting at the position `(0, 0)` and reaching `(n - 1, n - 1)` by moving right or down through valid path cells (cells with value `0` or `1`).
+*   After reaching `(n - 1, n - 1)`, returning to `(0, 0)` by moving left or up through valid path cells.
+*   When passing through a path cell containing a cherry, you pick it up, and the cell becomes an empty cell `0`.
+*   If there is no valid path between `(0, 0)` and `(n - 1, n - 1)`, then no cherries can be collected.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/12/14/grid.jpg)
+
+**Input:** grid = [[0,1,-1],[1,0,-1],[1,1,1]]
+
+**Output:** 5
+
+**Explanation:** The player started at (0, 0) and went down, down, right right to reach (2, 2). 4 cherries were picked up during this single trip, and the matrix becomes [[0,1,-1],[0,0,-1],[0,0,0]]. Then, the player went left, up, up, left to return home, picking up one more cherry. The total number of cherries picked up is 5, and this is the maximum possible.
+
+**Example 2:**
+
+**Input:** grid = [[1,1,-1],[1,-1,1],[-1,1,1]]
+
+**Output:** 0
+
+**Constraints:**
+
+*   `n == grid.length`
+*   `n == grid[i].length`
+*   `1 <= n <= 50`
+*   `grid[i][j]` is `-1`, `0`, or `1`.
+*   `grid[0][0] != -1`
+*   `grid[n - 1][n - 1] != -1`

src/main/java/g0701_0800/s0743_network_delay_time/Solution.java

@@ -0,0 +1,46 @@
+package g0701_0800.s0743_network_delay_time;
+
+// #Medium #Depth_First_Search #Breadth_First_Search #Heap_Priority_Queue #Graph #Shortest_Path
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class Solution {
+    public int networkDelayTime(int[][] times, int n, int k) {
+        int[][] graph = new int[n + 1][n + 1];
+        for (int[] g : graph) {
+            Arrays.fill(g, -1);
+        }
+        for (int[] t : times) {
+            graph[t[0]][t[1]] = t[2];
+        }
+        boolean[] visited = new boolean[n + 1];
+        int[] dist = new int[n + 1];
+        Arrays.fill(dist, Integer.MAX_VALUE);
+        dist[k] = 0;
+        Queue<Integer> spfa = new LinkedList<>();
+        spfa.add(k);
+        visited[k] = true;
+        while (!spfa.isEmpty()) {
+            int curr = spfa.poll();
+            visited[curr] = false;
+            for (int i = 1; i <= n; i++) {
+                if (graph[curr][i] != -1) {
+                    if (dist[i] > dist[curr] + graph[curr][i]) {
+                        dist[i] = dist[curr] + graph[curr][i];
+                        if (!visited[i]) {
+                            spfa.add(i);
+                            visited[i] = true;
+                        }
+                    }
+                }
+            }
+        }
+        int result = 0;
+        for (int i = 1; i <= n; i++) {
+            result = Math.max(dist[i], result);
+        }
+        return result == Integer.MAX_VALUE ? -1 : result;
+    }
+}

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

@@ -0,0 +1,37 @@
+743\. Network Delay Time
+
+Medium
+
+You are given a network of `n` nodes, labeled from `1` to `n`. You are also given `times`, a list of travel times as directed edges <code>times[i] = (u<sub>i</sub>, v<sub>i</sub>, w<sub>i</sub>)</code>, where <code>u<sub>i</sub></code> is the source node, <code>v<sub>i</sub></code> is the target node, and <code>w<sub>i</sub></code> is the time it takes for a signal to travel from source to target.
+
+We will send a signal from a given node `k`. Return the time it takes for all the `n` nodes to receive the signal. If it is impossible for all the `n` nodes to receive the signal, return `-1`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2019/05/23/931_example_1.png)
+
+**Input:** times = [[2,1,1],[2,3,1],[3,4,1]], n = 4, k = 2
+
+**Output:** 2
+
+**Example 2:**
+
+**Input:** times = [[1,2,1]], n = 2, k = 1
+
+**Output:** 1
+
+**Example 3:**
+
+**Input:** times = [[1,2,1]], n = 2, k = 2
+
+**Output:** -1
+
+**Constraints:**
+
+*   `1 <= k <= n <= 100`
+*   `1 <= times.length <= 6000`
+*   `times[i].length == 3`
+*   <code>1 <= u<sub>i</sub>, v<sub>i</sub> <= n</code>
+*   <code>u<sub>i</sub> != v<sub>i</sub></code>
+*   <code>0 <= w<sub>i</sub> <= 100</code>
+*   All the pairs <code>(u<sub>i</sub>, v<sub>i</sub>)</code> are **unique**. (i.e., no multiple edges.)

src/main/java/g0701_0800/s0744_find_smallest_letter_greater_than_target/Solution.java

@@ -0,0 +1,28 @@
+package g0701_0800.s0744_find_smallest_letter_greater_than_target;
+
+// #Easy #Array #Binary_Search
+
+public class Solution {
+    public char nextGreatestLetter(char[] letters, char target) {
+        if (letters[0] > target) {
+            return letters[0];
+        }
+        int left = 0;
+        int right = letters.length - 1;
+        while (left < right) {
+            int mid = left + (right - left) / 2;
+            if (letters[mid] > target) {
+                while (letters[mid] > target) {
+                    mid--;
+                }
+                return letters[++mid];
+            } else {
+                left = mid + 1;
+            }
+        }
+        if (right < letters.length && letters[right] > target) {
+            return letters[right];
+        }
+        return letters[0];
+    }
+}

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

@@ -0,0 +1,35 @@
+744\. Find Smallest Letter Greater Than Target
+
+Easy
+
+Given a characters array `letters` that is sorted in **non-decreasing** order and a character `target`, return _the smallest character in the array that is larger than_ `target`.
+
+**Note** that the letters wrap around.
+
+*   For example, if `target == 'z'` and `letters == ['a', 'b']`, the answer is `'a'`.
+
+**Example 1:**
+
+**Input:** letters = ["c","f","j"], target = "a"
+
+**Output:** "c"
+
+**Example 2:**
+
+**Input:** letters = ["c","f","j"], target = "c"
+
+**Output:** "f"
+
+**Example 3:**
+
+**Input:** letters = ["c","f","j"], target = "d"
+
+**Output:** "f"
+
+**Constraints:**
+
+*   <code>2 <= letters.length <= 10<sup>4</sup></code>
+*   `letters[i]` is a lowercase English letter.
+*   `letters` is sorted in **non-decreasing** order.
+*   `letters` contains at least two different characters.
+*   `target` is a lowercase English letter.

src/main/java/g0701_0800/s0745_prefix_and_suffix_search/TrieNode.java

@@ -0,0 +1,11 @@
+package g0701_0800.s0745_prefix_and_suffix_search;
+
+class TrieNode {
+    public TrieNode[] children;
+    public int weight;
+
+    TrieNode() {
+        this.children = new TrieNode[27];
+        this.weight = 0;
+    }
+}

src/main/java/g0701_0800/s0745_prefix_and_suffix_search/WordFilter.java

@@ -0,0 +1,43 @@
+package g0701_0800.s0745_prefix_and_suffix_search;
+
+// #Hard #String #Design #Trie
+
+public class WordFilter {
+
+    TrieNode root = new TrieNode();
+
+    public WordFilter(String[] words) {
+        for (int i = 0; i < words.length; i++) {
+            String s = words[i];
+            for (int j = 0; j < s.length(); j++) {
+                insert(s.substring(j) + '{' + s, i);
+            }
+        }
+    }
+
+    public void insert(String wd, int weight) {
+        TrieNode node = root;
+        for (char ch : wd.toCharArray()) {
+            if (node.children[ch - 'a'] == null) {
+                node.children[ch - 'a'] = new TrieNode();
+            }
+            node = node.children[ch - 'a'];
+            node.weight = weight;
+        }
+    }
+
+    public int f(String prefix, String suffix) {
+        return startsWith(suffix + '{' + prefix);
+    }
+
+    public int startsWith(String pref) {
+        TrieNode node = root;
+        for (char ch : pref.toCharArray()) {
+            if (node.children[ch - 'a'] == null) {
+                return -1;
+            }
+            node = node.children[ch - 'a'];
+        }
+        return node.weight;
+    }
+}

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

@@ -0,0 +1,33 @@
+745\. Prefix and Suffix Search
+
+Hard
+
+Design a special dictionary with some words that searchs the words in it by a prefix and a suffix.
+
+Implement the `WordFilter` class:
+
+*   `WordFilter(string[] words)` Initializes the object with the `words` in the dictionary.
+*   `f(string prefix, string suffix)` Returns _the index of the word in the dictionary,_ which has the prefix `prefix` and the suffix `suffix`. If there is more than one valid index, return **the largest** of them. If there is no such word in the dictionary, return `-1`.
+
+**Example 1:**
+
+**Input** 
+
+["WordFilter", "f"] 
+
+[[["apple"]], ["a", "e"]]
+
+**Output:** [null, 0]
+
+**Explanation:** 
+
+    WordFilter wordFilter = new WordFilter(["apple"]); 
+    wordFilter.f("a", "e"); // return 0, because the word at index 0 has prefix = "a" and suffix = 'e".
+
+**Constraints:**
+
+*   `1 <= words.length <= 15000`
+*   `1 <= words[i].length <= 10`
+*   `1 <= prefix.length, suffix.length <= 10`
+*   `words[i]`, `prefix` and `suffix` consist of lower-case English letters only.
+*   At most `15000` calls will be made to the function `f`.

src/test/java/g0701_0800/s0741_cherry_pickup/SolutionTest.java

@@ -0,0 +1,22 @@
+package g0701_0800.s0741_cherry_pickup;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void cherryPickup() {
+        assertThat(
+                new Solution().cherryPickup(new int[][] {{0, 1, -1}, {1, 0, -1}, {1, 1, 1}}),
+                equalTo(5));
+    }
+
+    @Test
+    void cherryPickup2() {
+        assertThat(
+                new Solution().cherryPickup(new int[][] {{1, 1, -1}, {1, -1, 1}, {-1, 1, 1}}),
+                equalTo(0));
+    }
+}

src/test/java/g0701_0800/s0743_network_delay_time/SolutionTest.java

@@ -0,0 +1,26 @@
+package g0701_0800.s0743_network_delay_time;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void networkDelayTime() {
+        assertThat(
+                new Solution()
+                        .networkDelayTime(new int[][] {{2, 1, 1}, {2, 3, 1}, {3, 4, 1}}, 4, 2),
+                equalTo(2));
+    }
+
+    @Test
+    void networkDelayTime2() {
+        assertThat(new Solution().networkDelayTime(new int[][] {{1, 2, 1}}, 2, 1), equalTo(1));
+    }
+
+    @Test
+    void networkDelayTime3() {
+        assertThat(new Solution().networkDelayTime(new int[][] {{1, 2, 1}}, 2, 2), equalTo(-1));
+    }
+}