Added tasks 575, 576.

Author: ThanhNIT

src/main/java/g0501_0600/s0575_distribute_candies/Solution.java

@@ -0,0 +1,16 @@
+package g0501_0600.s0575_distribute_candies;
+
+// #Easy #Array #Hash_Table
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class Solution {
+ public int distributeCandies(int[] candyType) {
+ Set<Integer> set = new HashSet<>();
+ for (int i : candyType) {
+ set.add(i);
+ }
+ return Math.min(set.size(), candyType.length / 2);
+ }
+}

src/main/java/g0501_0600/s0575_distribute_candies/readme.md

@@ -0,0 +1,40 @@
+575\. Distribute Candies
+
+Easy
+
+Alice has `n` candies, where the <code>i<sup>th</sup></code> candy is of type `candyType[i]`. Alice noticed that she started to gain weight, so she visited a doctor.
+
+The doctor advised Alice to only eat `n / 2` of the candies she has (`n` is always even). Alice likes her candies very much, and she wants to eat the maximum number of different types of candies while still following the doctor's advice.
+
+Given the integer array `candyType` of length `n`, return _the **maximum** number of different types of candies she can eat if she only eats_ `n / 2` _of them_.
+
+**Example 1:**
+
+**Input:** candyType = [1,1,2,2,3,3]
+
+**Output:** 3
+
+**Explanation:** Alice can only eat 6 / 2 = 3 candies. Since there are only 3 types, she can eat one of each type.
+
+**Example 2:**
+
+**Input:** candyType = [1,1,2,3]
+
+**Output:** 2
+
+**Explanation:** Alice can only eat 4 / 2 = 2 candies. Whether she eats types [1,2], [1,3], or [2,3], she still can only eat 2 different types.
+
+**Example 3:**
+
+**Input:** candyType = [6,6,6,6]
+
+**Output:** 1
+
+**Explanation:** Alice can only eat 4 / 2 = 2 candies. Even though she can eat 2 candies, she only has 1 type.
+
+**Constraints:**
+
+* `n == candyType.length`
+* <code>2 <= n <= 10<sup>4</sup></code>
+* `n` is even.
+* <code>-10<sup>5</sup> <= candyType[i] <= 10<sup>5</sup></code>

src/main/java/g0501_0600/s0576_out_of_boundary_paths/Solution.java

@@ -0,0 +1,41 @@
+package g0501_0600.s0576_out_of_boundary_paths;
+
+// #Medium #Dynamic_Programming
+
+import java.util.Arrays;
+
+public class Solution {
+ private final int[][] dRowCol = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
+
+ private int dfs(int m, int n, int remainingMoves, int currRow, int currCol, int[][][] cache) {
+ if (currRow < 0 || currRow == m || currCol < 0 || currCol == n) {
+ return 1;
+ }
+ if (remainingMoves == 0) {
+ return 0;
+ }
+
+ if (cache[currRow][currCol][remainingMoves] == -1) {
+ int paths = 0;
+ for (int i = 0; i < 4; i++) {
+ int newRow = currRow + dRowCol[i][0];
+ int newCol = currCol + dRowCol[i][1];
+ int m1 = 1000000007;
+ paths = (paths + dfs(m, n, remainingMoves - 1, newRow, newCol, cache)) % m1;
+ }
+ cache[currRow][currCol][remainingMoves] = paths;
+ }
+ return cache[currRow][currCol][remainingMoves];
+ }
+
+ public int findPaths(int m, int n, int maxMoves, int startRow, int startCol) {
+ int[][][] cache = new int[m][n][maxMoves + 1];
+ for (int[][] c1 : cache) {
+ for (int[] c2 : c1) {
+ Arrays.fill(c2, -1);
+ }
+ }
+
+ return dfs(m, n, maxMoves, startRow, startCol, cache);
+ }
+}

src/main/java/g0501_0600/s0576_out_of_boundary_paths/readme.md

@@ -0,0 +1,30 @@
+576\. Out of Boundary Paths
+
+Medium
+
+There is an `m x n` grid with a ball. The ball is initially at the position `[startRow, startColumn]`. You are allowed to move the ball to one of the four adjacent cells in the grid (possibly out of the grid crossing the grid boundary). You can apply **at most** `maxMove` moves to the ball.
+
+Given the five integers `m`, `n`, `maxMove`, `startRow`, `startColumn`, return the number of paths to move the ball out of the grid boundary. Since the answer can be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/04/28/out_of_boundary_paths_1.png)
+
+**Input:** m = 2, n = 2, maxMove = 2, startRow = 0, startColumn = 0
+
+**Output:** 6
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/04/28/out_of_boundary_paths_2.png)
+
+**Input:** m = 1, n = 3, maxMove = 3, startRow = 0, startColumn = 1
+
+**Output:** 12
+
+**Constraints:**
+
+* `1 <= m, n <= 50`
+* `0 <= maxMove <= 50`
+* `0 <= startRow < m`
+* `0 <= startColumn < n`

src/test/java/g0501_0600/s0575_distribute_candies/SolutionTest.java

@@ -0,0 +1,23 @@
+package g0501_0600.s0575_distribute_candies;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void distributeCandies() {
+ assertThat(new Solution().distributeCandies(new int[] {1, 1, 2, 2, 3, 3}), equalTo(3));
+ }
+
+ @Test
+ void distributeCandies2() {
+ assertThat(new Solution().distributeCandies(new int[] {1, 1, 2, 3}), equalTo(2));
+ }
+
+ @Test
+ void distributeCandies3() {
+ assertThat(new Solution().distributeCandies(new int[] {6, 6, 6, 6}), equalTo(1));
+ }
+}

src/test/java/g0501_0600/s0576_out_of_boundary_paths/SolutionTest.java

@@ -0,0 +1,18 @@
+package g0501_0600.s0576_out_of_boundary_paths;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void findPaths() {
+ assertThat(new Solution().findPaths(2, 2, 2, 0, 0), equalTo(6));
+ }
+
+ @Test
+ void findPaths2() {
+ assertThat(new Solution().findPaths(1, 3, 3, 0, 1), equalTo(12));
+ }
+}