Added tasks 1726, 1727, 1728, 1732, 1733.

Author: ThanhNIT

src/main/java/g1701_1800/s1726_tuple_with_same_product/Solution.java

@@ -0,0 +1,25 @@
+package g1701_1800.s1726_tuple_with_same_product;
+
+// #Medium #Array #Hash_Table #2022_04_28_Time_235_ms_(90.73%)_Space_63.4_MB_(87.42%)
+
+import java.util.HashMap;
+
+public class Solution {
+ public int tupleSameProduct(int[] nums) {
+ HashMap<Integer, Integer> ab = new HashMap<>();
+
+ for (int i = 0; i < nums.length; i++) {
+ for (int j = i + 1; j < nums.length; j++) {
+ ab.put(nums[i] * nums[j], ab.getOrDefault(nums[i] * nums[j], 0) + 1);
+ }
+ }
+
+ int count = 0;
+ for (Integer key : ab.keySet()) {
+ int val = ab.get(key);
+ count = count + (val * (val - 1)) / 2;
+ }
+
+ return count * 8;
+ }
+}

src/main/java/g1701_1800/s1726_tuple_with_same_product/readme.md

@@ -0,0 +1,39 @@
+1726\. Tuple with Same Product
+
+Medium
+
+Given an array `nums` of **distinct** positive integers, return _the number of tuples_ `(a, b, c, d)` _such that_ `a * b = c * d` _where_ `a`_,_ `b`_,_ `c`_, and_ `d` _are elements of_ `nums`_, and_ `a != b != c != d`_._
+
+**Example 1:**
+
+**Input:** nums = [2,3,4,6]
+
+**Output:** 8
+
+**Explanation:** There are 8 valid tuples: 
+
+(2,6,3,4) , (2,6,4,3) , (6,2,3,4) , (6,2,4,3) 
+
+(3,4,2,6) , (4,3,2,6) , (3,4,6,2) , (4,3,6,2)
+
+**Example 2:**
+
+**Input:** nums = [1,2,4,5,10]
+
+**Output:** 16
+
+**Explanation:** There are 16 valid tuples: 
+
+(1,10,2,5) , (1,10,5,2) , (10,1,2,5) , (10,1,5,2) 
+
+(2,5,1,10) , (2,5,10,1) , (5,2,1,10) , (5,2,10,1) 
+
+(2,10,4,5) , (2,10,5,4) , (10,2,4,5) , (10,2,5,4) 
+
+(4,5,2,10) , (4,5,10,2) , (5,4,2,10) , (5,4,10,2)
+
+**Constraints:**
+
+* `1 <= nums.length <= 1000`
+* <code>1 <= nums[i] <= 10<sup>4</sup></code>
+* All elements in `nums` are **distinct**.

src/main/java/g1701_1800/s1727_largest_submatrix_with_rearrangements/Solution.java

@@ -0,0 +1,27 @@
+package g1701_1800.s1727_largest_submatrix_with_rearrangements;
+
+// #Medium #Array #Sorting #Greedy #Matrix #2022_04_28_Time_9_ms_(90.48%)_Space_67.7_MB_(91.27%)
+
+import java.util.Arrays;
+
+public class Solution {
+ public int largestSubmatrix(int[][] matrix) {
+ int m = matrix.length;
+ int n = matrix[0].length;
+ for (int i = 1; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ if (matrix[i][j] != 0) {
+ matrix[i][j] = matrix[i - 1][j] + 1;
+ }
+ }
+ }
+ int count = 0;
+ for (int[] ints : matrix) {
+ Arrays.sort(ints);
+ for (int j = 1; j <= n; j++) {
+ count = Math.max(count, j * ints[n - j]);
+ }
+ }
+ return count;
+ }
+}

src/main/java/g1701_1800/s1727_largest_submatrix_with_rearrangements/readme.md

@@ -0,0 +1,42 @@
+1727\. Largest Submatrix With Rearrangements
+
+Medium
+
+You are given a binary matrix `matrix` of size `m x n`, and you are allowed to rearrange the **columns** of the `matrix` in any order.
+
+Return _the area of the largest submatrix within_ `matrix` _where **every** element of the submatrix is_ `1` _after reordering the columns optimally._
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/12/29/screenshot-2020-12-30-at-40536-pm.png)
+
+**Input:** matrix = [[0,0,1],[1,1,1],[1,0,1]]
+
+**Output:** 4
+
+**Explanation:** You can rearrange the columns as shown above. The largest submatrix of 1s, in bold, has an area of 4.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/12/29/screenshot-2020-12-30-at-40852-pm.png)
+
+**Input:** matrix = [[1,0,1,0,1]]
+
+**Output:** 3
+
+**Explanation:** You can rearrange the columns as shown above. The largest submatrix of 1s, in bold, has an area of 3.
+
+**Example 3:**
+
+**Input:** matrix = [[1,1,0],[1,0,1]]
+
+**Output:** 2
+
+**Explanation:** Notice that you must rearrange entire columns, and there is no way to make a submatrix of 1s larger than an area of 2.
+
+**Constraints:**
+
+* `m == matrix.length`
+* `n == matrix[i].length`
+* <code>1 <= m * n <= 10<sup>5</sup></code>
+* `matrix[i][j]` is either `0` or `1`.

src/main/java/g1701_1800/s1728_cat_and_mouse_ii/Solution.java

@@ -0,0 +1,96 @@
+package g1701_1800.s1728_cat_and_mouse_ii;
+
+// #Hard #Dynamic_Programming #Math #Breadth_First_Search #Graph #Memoization #Game_Theory
+// #2022_04_28_Time_12_ms_(99.12%)_Space_42.7_MB_(96.49%)
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+ private final int mouseTurn = 0;
+ private final List<Integer>[][] graphs = new List[2][];
+ private int foodPos;
+ private int[][][] memo;
+
+ public boolean canMouseWin(String[] grid, int catJump, int mouseJump) {
+ int m = grid.length;
+ int n = grid[0].length();
+ int mousePos = 0;
+ int catPos = 0;
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ char c = grid[i].charAt(j);
+ if (c == 'F') {
+ foodPos = i * n + j;
+ } else if (c == 'C') {
+ catPos = i * n + j;
+ } else if (c == 'M') {
+ mousePos = i * n + j;
+ }
+ }
+ }
+ graphs[0] = buildGraph(mouseJump, grid);
+ graphs[1] = buildGraph(catJump, grid);
+ memo = new int[m * n][m * n][2];
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ char c = grid[i].charAt(j);
+ if (c == '#' || c == 'F') {
+ continue;
+ }
+ int catTurn = 1;
+ dfs(i * n + j, foodPos, catTurn);
+ }
+ }
+ return memo[mousePos][catPos][mouseTurn] < 0;
+ }
+
+ private List<Integer>[] buildGraph(int jump, String[] grid) {
+ int[][] dirs = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}};
+ int m = grid.length;
+ int n = grid[0].length();
+ List<Integer>[] graph = new List[m * n];
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ List<Integer> list = new ArrayList<>();
+ graph[i * n + j] = list;
+ if (grid[i].charAt(j) == '#') {
+ continue;
+ }
+ list.add(i * n + j);
+ for (int[] dir : dirs) {
+ for (int step = 1; step <= jump; step++) {
+ int x = i + dir[0] * step;
+ int y = j + dir[1] * step;
+ if (x < 0 || x >= m || y < 0 || y >= n || grid[x].charAt(y) == '#') {
+ break;
+ }
+ list.add(x * n + y);
+ }
+ }
+ }
+ }
+ return graph;
+ }
+
+ private void dfs(int p1, int p2, int turn) {
+ if (p1 == p2) {
+ return;
+ }
+ if ((turn == 0 ? p2 : p1) == foodPos) {
+ return;
+ }
+ if (memo[p1][p2][turn] < 0) {
+ return;
+ }
+ memo[p1][p2][turn] = -1;
+ turn ^= 1;
+ for (int w : graphs[turn][p2]) {
+ if (turn == mouseTurn) {
+ dfs(w, p1, turn);
+ } else if (++memo[w][p1][turn] == graphs[turn][w].size()) {
+ dfs(w, p1, turn);
+ }
+ }
+ }
+}

src/main/java/g1701_1800/s1728_cat_and_mouse_ii/readme.md

@@ -0,0 +1,63 @@
+1728\. Cat and Mouse II
+
+Hard
+
+A game is played by a cat and a mouse named Cat and Mouse.
+
+The environment is represented by a `grid` of size `rows x cols`, where each element is a wall, floor, player (Cat, Mouse), or food.
+
+* Players are represented by the characters `'C'`(Cat)`,'M'`(Mouse).
+* Floors are represented by the character `'.'` and can be walked on.
+* Walls are represented by the character `'#'` and cannot be walked on.
+* Food is represented by the character `'F'` and can be walked on.
+* There is only one of each character `'C'`, `'M'`, and `'F'` in `grid`.
+
+Mouse and Cat play according to the following rules:
+
+* Mouse **moves first**, then they take turns to move.
+* During each turn, Cat and Mouse can jump in one of the four directions (left, right, up, down). They cannot jump over the wall nor outside of the `grid`.
+* `catJump, mouseJump` are the maximum lengths Cat and Mouse can jump at a time, respectively. Cat and Mouse can jump less than the maximum length.
+* Staying in the same position is allowed.
+* Mouse can jump over Cat.
+
+The game can end in 4 ways:
+
+* If Cat occupies the same position as Mouse, Cat wins.
+* If Cat reaches the food first, Cat wins.
+* If Mouse reaches the food first, Mouse wins.
+* If Mouse cannot get to the food within 1000 turns, Cat wins.
+
+Given a `rows x cols` matrix `grid` and two integers `catJump` and `mouseJump`, return `true` _if Mouse can win the game if both Cat and Mouse play optimally, otherwise return_ `false`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/12/sample_111_1955.png)
+
+**Input:** grid = ["####F","#C...","M...."], catJump = 1, mouseJump = 2
+
+**Output:** true
+
+**Explanation:** Cat cannot catch Mouse on its turn nor can it get the food before Mouse.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/09/12/sample_2_1955.png)
+
+**Input:** grid = ["M.C...F"], catJump = 1, mouseJump = 4
+
+**Output:** true
+
+**Example 3:**
+
+**Input:** grid = ["M.C...F"], catJump = 1, mouseJump = 3
+
+**Output:** false
+
+**Constraints:**
+
+* `rows == grid.length`
+* `cols = grid[i].length`
+* `1 <= rows, cols <= 8`
+* `grid[i][j]` consist only of characters `'C'`, `'M'`, `'F'`, `'.'`, and `'#'`.
+* There is only one of each character `'C'`, `'M'`, and `'F'` in `grid`.
+* `1 <= catJump, mouseJump <= 8`

src/main/java/g1701_1800/s1732_find_the_highest_altitude/Solution.java

@@ -0,0 +1,15 @@
+package g1701_1800.s1732_find_the_highest_altitude;
+
+// #Easy #Array #Prefix_Sum #2022_04_28_Time_0_ms_(100.00%)_Space_40.1_MB_(83.65%)
+
+public class Solution {
+ public int largestAltitude(int[] gain) {
+ int max = 0;
+ int[] altitudes = new int[gain.length + 1];
+ for (int i = 0; i < gain.length; i++) {
+ altitudes[i + 1] = altitudes[i] + gain[i];
+ max = Math.max(max, altitudes[i + 1]);
+ }
+ return max;
+ }
+}

src/main/java/g1701_1800/s1732_find_the_highest_altitude/readme.md

@@ -0,0 +1,29 @@
+1732\. Find the Highest Altitude
+
+Easy
+
+There is a biker going on a road trip. The road trip consists of `n + 1` points at different altitudes. The biker starts his trip on point `0` with altitude equal `0`.
+
+You are given an integer array `gain` of length `n` where `gain[i]` is the **net gain in altitude** between points `i` and `i + 1` for all (`0 <= i < n)`. Return _the **highest altitude** of a point._
+
+**Example 1:**
+
+**Input:** gain = [-5,1,5,0,-7]
+
+**Output:** 1
+
+**Explanation:** The altitudes are [0,-5,-4,1,1,-6]. The highest is 1.
+
+**Example 2:**
+
+**Input:** gain = [-4,-3,-2,-1,4,3,2]
+
+**Output:** 0
+
+**Explanation:** The altitudes are [0,-4,-7,-9,-10,-6,-3,-1]. The highest is 0.
+
+**Constraints:**
+
+* `n == gain.length`
+* `1 <= n <= 100`
+* `-100 <= gain[i] <= 100`