Added tasks 2849-2856

Author: ThanhNIT

src/main/java/g2801_2900/s2849_determine_if_a_cell_is_reachable_at_a_given_time/Solution.java

@@ -0,0 +1,14 @@
+package g2801_2900.s2849_determine_if_a_cell_is_reachable_at_a_given_time;
+
+// #Medium #Math #2023_12_15_Time_1_ms_(91.15%)_Space_39.3_MB_(87.43%)
+
+public class Solution {
+ public boolean isReachableAtTime(int sx, int sy, int fx, int fy, int t) {
+ if (sx == fx && sy == fy) {
+ return t != 1;
+ }
+ int width = Math.abs(sx - fx) + 1;
+ int height = Math.abs(sy - fy) + 1;
+ return Math.max(width, height) - 1 <= t;
+ }
+}

src/main/java/g2801_2900/s2849_determine_if_a_cell_is_reachable_at_a_given_time/readme.md

@@ -0,0 +1,36 @@
+2849\. Determine if a Cell Is Reachable at a Given Time
+
+Medium
+
+You are given four integers `sx`, `sy`, `fx`, `fy`, and a **non-negative** integer `t`.
+
+In an infinite 2D grid, you start at the cell `(sx, sy)`. Each second, you **must** move to any of its adjacent cells.
+
+Return `true` _if you can reach cell_ `(fx, fy)` _after **exactly**_ `t` **_seconds_**, _or_ `false` _otherwise_.
+
+A cell's **adjacent cells** are the 8 cells around it that share at least one corner with it. You can visit the same cell several times.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2023/08/05/example2.svg)
+
+**Input:** sx = 2, sy = 4, fx = 7, fy = 7, t = 6
+
+**Output:** true
+
+**Explanation:** Starting at cell (2, 4), we can reach cell (7, 7) in exactly 6 seconds by going through the cells depicted in the picture above.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2023/08/05/example1.svg)
+
+**Input:** sx = 3, sy = 1, fx = 7, fy = 3, t = 3
+
+**Output:** false
+
+**Explanation:** Starting at cell (3, 1), it takes at least 4 seconds to reach cell (7, 3) by going through the cells depicted in the picture above. Hence, we cannot reach cell (7, 3) at the third second.
+
+**Constraints:**
+
+* <code>1 <= sx, sy, fx, fy <= 10<sup>9</sup></code>
+* <code>0 <= t <= 10<sup>9</sup></code>

src/main/java/g2801_2900/s2850_minimum_moves_to_spread_stones_over_grid/Solution.java

@@ -0,0 +1,43 @@
+package g2801_2900.s2850_minimum_moves_to_spread_stones_over_grid;
+
+// #Medium #Array #Dynamic_Programming #Matrix #Breadth_First_Search
+// #2023_12_15_Time_1_ms_(100.00%)_Space_40.5_MB_(89.16%)
+
+public class Solution {
+ public int minimumMoves(int[][] grid) {
+ int a = grid[0][0] - 1;
+ int b = grid[0][1] - 1;
+ int c = grid[0][2] - 1;
+ int d = grid[1][0] - 1;
+ int f = grid[1][2] - 1;
+ int g = grid[2][0] - 1;
+ int h = grid[2][1] - 1;
+ int i = grid[2][2] - 1;
+ int minCost = Integer.MAX_VALUE;
+ for (int x = Math.min(a, 0); x <= Math.max(a, 0); x++) {
+ for (int y = Math.min(c, 0); y <= Math.max(c, 0); y++) {
+ for (int z = Math.min(i, 0); z <= Math.max(i, 0); z++) {
+ for (int t = Math.min(g, 0); t <= Math.max(g, 0); t++) {
+ int cost =
+ Math.abs(x)
+ + Math.abs(y)
+ + Math.abs(z)
+ + Math.abs(t)
+ + Math.abs(x - a)
+ + Math.abs(y - c)
+ + Math.abs(z - i)
+ + Math.abs(t - g)
+ + Math.abs(x - y + b + c)
+ + Math.abs(y - z + i + f)
+ + Math.abs(z - t + g + h)
+ + Math.abs(t - x + a + d);
+ if (cost < minCost) {
+ minCost = cost;
+ }
+ }
+ }
+ }
+ }
+ return minCost;
+ }
+}

src/main/java/g2801_2900/s2850_minimum_moves_to_spread_stones_over_grid/readme.md

@@ -0,0 +1,57 @@
+2850\. Minimum Moves to Spread Stones Over Grid
+
+Medium
+
+You are given a **0-indexed** 2D integer matrix `grid` of size `3 * 3`, representing the number of stones in each cell. The grid contains exactly `9` stones, and there can be **multiple** stones in a single cell.
+
+In one move, you can move a single stone from its current cell to any other cell if the two cells share a side.
+
+Return _the **minimum number of moves** required to place one stone in each cell_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2023/08/23/example1-3.svg)
+
+**Input:** grid = [[1,1,0],[1,1,1],[1,2,1]]
+
+**Output:** 3
+
+**Explanation:** One possible sequence of moves to place one stone in each cell is: 
+
+1- Move one stone from cell (2,1) to cell (2,2). 
+
+2- Move one stone from cell (2,2) to cell (1,2). 
+
+3- Move one stone from cell (1,2) to cell (0,2). 
+
+In total, it takes 3 moves to place one stone in each cell of the grid. 
+
+It can be shown that 3 is the minimum number of moves required to place one stone in each cell.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2023/08/23/example2-2.svg)
+
+**Input:** grid = [[1,3,0],[1,0,0],[1,0,3]]
+
+**Output:** 4
+
+**Explanation:** One possible sequence of moves to place one stone in each cell is: 
+
+1- Move one stone from cell (0,1) to cell (0,2). 
+
+2- Move one stone from cell (0,1) to cell (1,1). 
+
+3- Move one stone from cell (2,2) to cell (1,2). 
+
+4- Move one stone from cell (2,2) to cell (2,1). 
+
+In total, it takes 4 moves to place one stone in each cell of the grid. 
+
+It can be shown that 4 is the minimum number of moves required to place one stone in each cell.
+
+**Constraints:**
+
+* `grid.length == grid[i].length == 3`
+* `0 <= grid[i][j] <= 9`
+* Sum of `grid` is equal to `9`.

src/main/java/g2801_2900/s2851_string_transformation/Solution.java

@@ -0,0 +1,80 @@
+package g2801_2900.s2851_string_transformation;
+
+// #Hard #String #Dynamic_Programming #Math #String_Matching
+// #2023_12_15_Time_54_ms_(78.45%)_Space_54.3_MB_(93.97%)
+
+public class Solution {
+ private long[][] g;
+
+ public int numberOfWays(String s, String t, long k) {
+ int n = s.length();
+ int v = kmp(s + s, t);
+ g = new long[][] {{v - 1, v}, {n - v, n - 1 - v}};
+ long[][] f = qmi(k);
+ return s.equals(t) ? (int) f[0][0] : (int) f[0][1];
+ }
+
+ private int kmp(String s, String p) {
+ int n = p.length();
+ int m = s.length();
+ s = "#" + s;
+ p = "#" + p;
+ int[] ne = new int[n + 1];
+ int j = 0;
+ for (int i = 2; i <= n; i++) {
+ while (j > 0 && p.charAt(i) != p.charAt(j + 1)) {
+ j = ne[j];
+ }
+ if (p.charAt(i) == p.charAt(j + 1)) {
+ j++;
+ }
+ ne[i] = j;
+ }
+
+ int cnt = 0;
+ j = 0;
+ for (int i = 1; i <= m; i++) {
+ while (j > 0 && s.charAt(i) != p.charAt(j + 1)) {
+ j = ne[j];
+ }
+ if (s.charAt(i) == p.charAt(j + 1)) {
+ j++;
+ }
+ if (j == n) {
+ if (i - n + 1 <= n) {
+ cnt++;
+ }
+ j = ne[j];
+ }
+ }
+ return cnt;
+ }
+
+ private void mul(long[][] c, long[][] a, long[][] b) {
+ long[][] t = new long[2][2];
+ for (int i = 0; i < 2; i++) {
+ for (int j = 0; j < 2; j++) {
+ for (int k = 0; k < 2; k++) {
+ int mod = (int) 1e9 + 7;
+ t[i][j] = (t[i][j] + a[i][k] * b[k][j]) % mod;
+ }
+ }
+ }
+ for (int i = 0; i < 2; i++) {
+ System.arraycopy(t[i], 0, c[i], 0, 2);
+ }
+ }
+
+ private long[][] qmi(long k) {
+ long[][] f = new long[2][2];
+ f[0][0] = 1;
+ while (k > 0) {
+ if ((k & 1) == 1) {
+ mul(f, f, g);
+ }
+ mul(g, g, g);
+ k >>= 1;
+ }
+ return f;
+ }
+}

src/main/java/g2801_2900/s2851_string_transformation/readme.md

@@ -0,0 +1,55 @@
+2851\. String Transformation
+
+Hard
+
+You are given two strings `s` and `t` of equal length `n`. You can perform the following operation on the string `s`:
+
+* Remove a **suffix** of `s` of length `l` where `0 < l < n` and append it at the start of `s`. 
+ For example, let `s = 'abcd'` then in one operation you can remove the suffix `'cd'` and append it in front of `s` making `s = 'cdab'`.
+
+You are also given an integer `k`. Return _the number of ways in which_ `s` _can be transformed into_ `t` _in **exactly**_ `k` _operations._
+
+Since the answer can be large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** s = "abcd", t = "cdab", k = 2
+
+**Output:** 2
+
+**Explanation:** 
+
+First way: 
+
+In first operation, choose suffix from index = 3, so resulting s = "dabc". 
+
+In second operation, choose suffix from index = 3, so resulting s = "cdab". 
+
+Second way: 
+
+In first operation, choose suffix from index = 1, so resulting s = "bcda".
+
+In second operation, choose suffix from index = 1, so resulting s = "cdab".
+
+**Example 2:**
+
+**Input:** s = "ababab", t = "ababab", k = 1
+
+**Output:** 2
+
+**Explanation:** 
+
+First way: 
+
+Choose suffix from index = 2, so resulting s = "ababab". 
+
+Second way: 
+
+Choose suffix from index = 4, so resulting s = "ababab".
+
+**Constraints:**
+
+* <code>2 <= s.length <= 5 * 10<sup>5</sup></code>
+* <code>1 <= k <= 10<sup>15</sup></code>
+* `s.length == t.length`
+* `s` and `t` consist of only lowercase English alphabets.

src/main/java/g2801_2900/s2855_minimum_right_shifts_to_sort_the_array/Solution.java

@@ -0,0 +1,30 @@
+package g2801_2900.s2855_minimum_right_shifts_to_sort_the_array;
+
+// #Easy #Array #2023_12_15_Time_1_ms_(100.00%)_Space_42.6_MB_(5.66%)
+
+import java.util.List;
+
+public class Solution {
+ public int minimumRightShifts(List<Integer> nums) {
+ int i;
+ for (i = 1; i < nums.size(); i++) {
+ if (nums.get(i) < nums.get(i - 1)) {
+ break;
+ }
+ }
+ if (nums.size() == i) {
+ return 0;
+ } else {
+ int k;
+ for (k = i + 1; k < nums.size(); k++) {
+ if (nums.get(k) <= nums.get(k - 1)) {
+ break;
+ }
+ }
+ if (k == nums.size() && nums.get(k - 1) < nums.get(0)) {
+ return nums.size() - i;
+ }
+ return -1;
+ }
+ }
+}

src/main/java/g2801_2900/s2855_minimum_right_shifts_to_sort_the_array/readme.md

@@ -0,0 +1,43 @@
+2855\. Minimum Right Shifts to Sort the Array
+
+Easy
+
+You are given a **0-indexed** array `nums` of length `n` containing **distinct** positive integers. Return _the **minimum** number of **right shifts** required to sort_ `nums` _and_ `-1` _if this is not possible._
+
+A **right shift** is defined as shifting the element at index `i` to index `(i + 1) % n`, for all indices.
+
+**Example 1:**
+
+**Input:** nums = [3,4,5,1,2]
+
+**Output:** 2
+
+**Explanation:** 
+
+After the first right shift, nums = [2,3,4,5,1]. 
+
+After the second right shift, nums = [1,2,3,4,5]. 
+
+Now nums is sorted; therefore the answer is 2.
+
+**Example 2:**
+
+**Input:** nums = [1,3,5]
+
+**Output:** 0
+
+**Explanation:** nums is already sorted therefore, the answer is 0.
+
+**Example 3:**
+
+**Input:** nums = [2,1,4]
+
+**Output:** -1
+
+**Explanation:** It's impossible to sort the array using right shifts.
+
+**Constraints:**
+
+* `1 <= nums.length <= 100`
+* `1 <= nums[i] <= 100`
+* `nums` contains distinct integers.

src/main/java/g2801_2900/s2856_minimum_array_length_after_pair_removals/Solution.java

@@ -0,0 +1,28 @@
+package g2801_2900.s2856_minimum_array_length_after_pair_removals;
+
+// #Medium #Array #Hash_Table #Greedy #Binary_Search #Two_Pointers #Counting
+// #2023_12_15_Time_5_ms_(97.63%)_Space_59.1_MB_(36.50%)
+
+import java.util.List;
+
+public class Solution {
+ public int minLengthAfterRemovals(List<Integer> nums) {
+ int n = nums.size();
+ int i = 0;
+ int j;
+ if (n % 2 == 0) {
+ j = n / 2;
+ } else {
+ j = n / 2 + 1;
+ }
+ int count = 0;
+ while (i < n / 2 && j < n) {
+ if (nums.get(i) < nums.get(j)) {
+ count += 2;
+ }
+ i++;
+ j++;
+ }
+ return n - count;
+ }
+}