Added tasks 1547, 1550, 1551, 1552, 1553.

Author: ThanhNIT

src/main/java/g1501_1600/s1547_minimum_cost_to_cut_a_stick/Solution.java

@@ -0,0 +1,26 @@
+package g1501_1600.s1547_minimum_cost_to_cut_a_stick;
+
+// #Hard #Array #Dynamic_Programming #2022_04_11_Time_6_ms_(100.00%)_Space_41.9_MB_(90.56%)
+
+import java.util.Arrays;
+
+public class Solution {
+ public int minCost(int n, int[] cuts) {
+ Arrays.sort(cuts);
+ int m = cuts.length;
+ int[][] dp = new int[m + 1][m + 1];
+
+ for (int i = 1; i <= m; i++) {
+ for (int j = 0; j <= m - i; j++) {
+ int k = j + i;
+ int min = Integer.MAX_VALUE;
+ for (int p = j; p < k; p++) {
+ min = Math.min(min, dp[j][p] + dp[p + 1][k]);
+ }
+ int len = (k == m ? n : cuts[k]) - (j == 0 ? 0 : cuts[j - 1]);
+ dp[j][k] = min + len;
+ }
+ }
+ return dp[0][m];
+ }
+}

src/main/java/g1501_1600/s1547_minimum_cost_to_cut_a_stick/readme.md

@@ -0,0 +1,40 @@
+1547\. Minimum Cost to Cut a Stick
+
+Hard
+
+Given a wooden stick of length `n` units. The stick is labelled from `0` to `n`. For example, a stick of length **6** is labelled as follows:
+
+![](https://assets.leetcode.com/uploads/2020/07/21/statement.jpg)
+
+Given an integer array `cuts` where `cuts[i]` denotes a position you should perform a cut at.
+
+You should perform the cuts in order, you can change the order of the cuts as you wish.
+
+The cost of one cut is the length of the stick to be cut, the total cost is the sum of costs of all cuts. When you cut a stick, it will be split into two smaller sticks (i.e. the sum of their lengths is the length of the stick before the cut). Please refer to the first example for a better explanation.
+
+Return _the minimum total cost_ of the cuts.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/07/23/e1.jpg)
+
+**Input:** n = 7, cuts = [1,3,4,5]
+
+**Output:** 16
+
+**Explanation:** Using cuts order = [1, 3, 4, 5] as in the input leads to the following scenario: ![](https://assets.leetcode.com/uploads/2020/07/21/e11.jpg) The first cut is done to a rod of length 7 so the cost is 7. The second cut is done to a rod of length 6 (i.e. the second part of the first cut), the third is done to a rod of length 4 and the last cut is to a rod of length 3. The total cost is 7 + 6 + 4 + 3 = 20. Rearranging the cuts to be [3, 5, 1, 4] for example will lead to a scenario with total cost = 16 (as shown in the example photo 7 + 4 + 3 + 2 = 16).
+
+**Example 2:**
+
+**Input:** n = 9, cuts = [5,6,1,4,2]
+
+**Output:** 22
+
+**Explanation:** If you try the given cuts ordering the cost will be 25. There are much ordering with total cost <= 25, for example, the order [4, 6, 5, 2, 1] has total cost = 22 which is the minimum possible.
+
+**Constraints:**
+
+* <code>2 <= n <= 10<sup>6</sup></code>
+* `1 <= cuts.length <= min(n - 1, 100)`
+* `1 <= cuts[i] <= n - 1`
+* All the integers in `cuts` array are **distinct**.

src/main/java/g1501_1600/s1550_three_consecutive_odds/Solution.java

@@ -0,0 +1,14 @@
+package g1501_1600.s1550_three_consecutive_odds;
+
+// #Easy #Array #2022_04_11_Time_0_ms_(100.00%)_Space_43.3_MB_(21.06%)
+
+public class Solution {
+ public boolean threeConsecutiveOdds(int[] arr) {
+ for (int i = 0; i < arr.length - 2; i++) {
+ if (arr[i] % 2 == 1 && arr[i + 1] % 2 == 1 && arr[i + 2] % 2 == 1) {
+ return true;
+ }
+ }
+ return false;
+ }
+}

src/main/java/g1501_1600/s1550_three_consecutive_odds/readme.md

@@ -0,0 +1,26 @@
+1550\. Three Consecutive Odds
+
+Easy
+
+Given an integer array `arr`, return `true` if there are three consecutive odd numbers in the array. Otherwise, return `false`.
+
+**Example 1:**
+
+**Input:** arr = [2,6,4,1]
+
+**Output:** false
+
+**Explanation:** There are no three consecutive odds.
+
+**Example 2:**
+
+**Input:** arr = [1,2,34,3,4,5,7,23,12]
+
+**Output:** true
+
+**Explanation:** [5,7,23] are three consecutive odds.
+
+**Constraints:**
+
+* `1 <= arr.length <= 1000`
+* `1 <= arr[i] <= 1000`

src/main/java/g1501_1600/s1551_minimum_operations_to_make_array_equal/Solution.java

@@ -0,0 +1,16 @@
+package g1501_1600.s1551_minimum_operations_to_make_array_equal;
+
+// #Medium #Math #2022_04_11_Time_7_ms_(12.93%)_Space_40.9_MB_(68.22%)
+
+public class Solution {
+ public int minOperations(int n) {
+ int min = 1;
+ int max = 2 * (n - 1) + 1;
+ int equalNumber = (max + min) / 2;
+ int ops = 0;
+ for (int i = 0; i < n / 2; i++) {
+ ops += equalNumber - (2 * i + 1);
+ }
+ return ops;
+ }
+}

src/main/java/g1501_1600/s1551_minimum_operations_to_make_array_equal/readme.md

@@ -0,0 +1,27 @@
+1551\. Minimum Operations to Make Array Equal
+
+Medium
+
+You have an array `arr` of length `n` where `arr[i] = (2 * i) + 1` for all valid values of `i` (i.e., `0 <= i < n`).
+
+In one operation, you can select two indices `x` and `y` where `0 <= x, y < n` and subtract `1` from `arr[x]` and add `1` to `arr[y]` (i.e., perform `arr[x] -=1` and `arr[y] += 1`). The goal is to make all the elements of the array **equal**. It is **guaranteed** that all the elements of the array can be made equal using some operations.
+
+Given an integer `n`, the length of the array, return _the minimum number of operations_ needed to make all the elements of arr equal.
+
+**Example 1:**
+
+**Input:** n = 3
+
+**Output:** 2
+
+**Explanation:** arr = [1, 3, 5] First operation choose x = 2 and y = 0, this leads arr to be [2, 3, 4] In the second operation choose x = 2 and y = 0 again, thus arr = [3, 3, 3].
+
+**Example 2:**
+
+**Input:** n = 6
+
+**Output:** 9
+
+**Constraints:**
+
+* <code>1 <= n <= 10<sup>4</sup></code>

src/main/java/g1501_1600/s1552_magnetic_force_between_two_balls/Solution.java

@@ -0,0 +1,46 @@
+package g1501_1600.s1552_magnetic_force_between_two_balls;
+
+// #Medium #Array #Sorting #Binary_Search #2022_04_11_Time_39_ms_(99.65%)_Space_56.9_MB_(90.25%)
+
+import java.util.Arrays;
+
+public class Solution {
+ public int maxDistance(int[] position, int m) {
+ Arrays.sort(position);
+ return binarySearch(position, m);
+ }
+
+ private int binarySearch(int[] arr, int m) {
+ int low = 0;
+ int n = arr.length;
+ int high = arr[n - 1];
+ int max = -1;
+ while (low <= high) {
+ int mid = low + (high - low) / 2;
+ if (check(arr, mid, m)) {
+ if (max < mid) {
+ max = mid;
+ }
+ low = mid + 1;
+ } else {
+ high = mid - 1;
+ }
+ }
+ return max;
+ }
+
+ private boolean check(int[] arr, int mid, int m) {
+ int pos = arr[0];
+ int magnet = 1;
+ for (int i = 1; i < arr.length; i++) {
+ if (arr[i] - pos >= mid) {
+ pos = arr[i];
+ magnet += 1;
+ if (magnet == m) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+}

src/main/java/g1501_1600/s1552_magnetic_force_between_two_balls/readme.md

@@ -0,0 +1,35 @@
+1552\. Magnetic Force Between Two Balls
+
+Medium
+
+In the universe Earth C-137, Rick discovered a special form of magnetic force between two balls if they are put in his new invented basket. Rick has `n` empty baskets, the <code>i<sup>th</sup></code> basket is at `position[i]`, Morty has `m` balls and needs to distribute the balls into the baskets such that the **minimum magnetic force** between any two balls is **maximum**.
+
+Rick stated that magnetic force between two different balls at positions `x` and `y` is `|x - y|`.
+
+Given the integer array `position` and the integer `m`. Return _the required force_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/08/11/q3v1.jpg)
+
+**Input:** position = [1,2,3,4,7], m = 3
+
+**Output:** 3
+
+**Explanation:** Distributing the 3 balls into baskets 1, 4 and 7 will make the magnetic force between ball pairs [3, 3, 6]. The minimum magnetic force is 3. We cannot achieve a larger minimum magnetic force than 3.
+
+**Example 2:**
+
+**Input:** position = [5,4,3,2,1,1000000000], m = 2
+
+**Output:** 999999999
+
+**Explanation:** We can use baskets 1 and 1000000000.
+
+**Constraints:**
+
+* `n == position.length`
+* <code>2 <= n <= 10<sup>5</sup></code>
+* <code>1 <= position[i] <= 10<sup>9</sup></code>
+* All integers in `position` are **distinct**.
+* `2 <= m <= position.length`

src/main/java/g1501_1600/s1553_minimum_number_of_days_to_eat_n_oranges/Solution.java

@@ -0,0 +1,26 @@
+package g1501_1600.s1553_minimum_number_of_days_to_eat_n_oranges;
+
+// #Hard #Dynamic_Programming #Memoization #2022_04_11_Time_5_ms_(91.90%)_Space_43.5_MB_(31.90%)
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution {
+
+ public int minDays(int n) {
+ return eat(n, new HashMap<>());
+ }
+
+ private int eat(int n, Map<Integer, Integer> cache) {
+ if (n <= 1) {
+ return n;
+ }
+ Integer cached = cache.get(n);
+ if (cached != null) {
+ return cached;
+ }
+ int result = Math.min(n % 2 + eat(n / 2, cache), n % 3 + eat(n / 3, cache)) + 1;
+ cache.put(n, result);
+ return result;
+ }
+}

src/main/java/g1501_1600/s1553_minimum_number_of_days_to_eat_n_oranges/readme.md

@@ -0,0 +1,51 @@
+1553\. Minimum Number of Days to Eat N Oranges
+
+Hard
+
+There are `n` oranges in the kitchen and you decided to eat some of these oranges every day as follows:
+
+* Eat one orange.
+* If the number of remaining oranges `n` is divisible by `2` then you can eat `n / 2` oranges.
+* If the number of remaining oranges `n` is divisible by `3` then you can eat `2 * (n / 3)` oranges.
+
+You can only choose one of the actions per day.
+
+Given the integer `n`, return _the minimum number of days to eat_ `n` _oranges_.
+
+**Example 1:**
+
+**Input:** n = 10
+
+**Output:** 4
+
+**Explanation:** You have 10 oranges. 
+
+Day 1: Eat 1 orange, 10 - 1 = 9. 
+
+Day 2: Eat 6 oranges, 9 - 2\*(9/3) = 9 - 6 = 3. (Since 9 is divisible by 3) 
+
+Day 3: Eat 2 oranges, 3 - 2\*(3/3) = 3 - 2 = 1. 
+
+Day 4: Eat the last orange 1 - 1 = 0. 
+
+You need at least 4 days to eat the 10 oranges.
+
+**Example 2:**
+
+**Input:** n = 6
+
+**Output:** 3
+
+**Explanation:** You have 6 oranges. 
+
+Day 1: Eat 3 oranges, 6 - 6/2 = 6 - 3 = 3. (Since 6 is divisible by 2). 
+
+Day 2: Eat 2 oranges, 3 - 2\*(3/3) = 3 - 2 = 1. (Since 3 is divisible by 3) 
+
+Day 3: Eat the last orange 1 - 1 = 0. 
+
+You need at least 3 days to eat the 6 oranges.
+
+**Constraints:**
+
+* <code>1 <= n <= 2 * 10<sup>9</sup></code>