Added tasks 1670, 1671.

Author: javadev

src/main/java/g1601_1700/s1670_design_front_middle_back_queue/FrontMiddleBackQueue.java

@@ -0,0 +1,88 @@
+package g1601_1700.s1670_design_front_middle_back_queue;
+
+// #Medium #Array #Design #Linked_List #Queue #Data_Stream
+// #2022_04_22_Time_5_ms_(100.00%)_Space_42.8_MB_(84.98%)
+
+public class FrontMiddleBackQueue {
+ private int[] queue = new int[1000];
+ private int cur = -1;
+
+ public FrontMiddleBackQueue() {
+ // empty constructor
+ }
+
+ public void pushFront(int val) {
+ cur++;
+ for (int i = cur; i > 0; i--) {
+ queue[i] = queue[i - 1];
+ }
+ queue[0] = val;
+ }
+
+ public void pushMiddle(int val) {
+ if (cur < 0) {
+ pushFront(val);
+ return;
+ }
+ cur++;
+ int mid = cur / 2;
+ for (int i = cur; i > mid; i--) {
+ queue[i] = queue[i - 1];
+ }
+ queue[mid] = val;
+ }
+
+ public void pushBack(int val) {
+ if (cur < 0) {
+ pushFront(val);
+ return;
+ }
+ cur++;
+ queue[cur] = val;
+ }
+
+ public int popFront() {
+ if (cur < 0) {
+ return -1;
+ }
+ int result = queue[0];
+ for (int i = 0; i < cur; i++) {
+ queue[i] = queue[i + 1];
+ }
+ cur--;
+ return result;
+ }
+
+ public int popMiddle() {
+ if (cur < 0) {
+ return -1;
+ }
+ int mid = cur / 2;
+ int result = queue[mid];
+ for (int i = mid; i < cur; i++) {
+ queue[i] = queue[i + 1];
+ }
+ cur--;
+ return result;
+ }
+
+ public int popBack() {
+ if (cur < 0) {
+ return -1;
+ }
+ int result = queue[cur];
+ cur--;
+ return result;
+ }
+}
+
+/*
+ * Your FrontMiddleBackQueue object will be instantiated and called as such:
+ * FrontMiddleBackQueue obj = new FrontMiddleBackQueue();
+ * obj.pushFront(val);
+ * obj.pushMiddle(val);
+ * obj.pushBack(val);
+ * int param_4 = obj.popFront();
+ * int param_5 = obj.popMiddle();
+ * int param_6 = obj.popBack();
+ */

src/main/java/g1601_1700/s1670_design_front_middle_back_queue/readme.md

@@ -0,0 +1,45 @@
+1670\. Design Front Middle Back Queue
+
+Medium
+
+Design a queue that supports `push` and `pop` operations in the front, middle, and back.
+
+Implement the `FrontMiddleBack` class:
+
+* `FrontMiddleBack()` Initializes the queue.
+* `void pushFront(int val)` Adds `val` to the **front** of the queue.
+* `void pushMiddle(int val)` Adds `val` to the **middle** of the queue.
+* `void pushBack(int val)` Adds `val` to the **back** of the queue.
+* `int popFront()` Removes the **front** element of the queue and returns it. If the queue is empty, return `-1`.
+* `int popMiddle()` Removes the **middle** element of the queue and returns it. If the queue is empty, return `-1`.
+* `int popBack()` Removes the **back** element of the queue and returns it. If the queue is empty, return `-1`.
+
+**Notice** that when there are **two** middle position choices, the operation is performed on the **frontmost** middle position choice. For example:
+
+* Pushing `6` into the middle of `[1, 2, 3, 4, 5]` results in `[1, 2, 6, 3, 4, 5]`.
+* Popping the middle from `[1, 2, 3, 4, 5, 6]` returns `3` and results in `[1, 2, 4, 5, 6]`.
+
+**Example 1:**
+
+**Input:** ["FrontMiddleBackQueue", "pushFront", "pushBack", "pushMiddle", "pushMiddle", "popFront", "popMiddle", "popMiddle", "popBack", "popFront"]
+
+[[], [1], [2], [3], [4], [], [], [], [], []]
+
+**Output:** [null, null, null, null, null, 1, 3, 4, 2, -1]
+
+**Explanation:**
+
+ FrontMiddleBackQueue q = new FrontMiddleBackQueue(); q.pushFront(1); // [1]
+ q.pushBack(2); // [1, 2]
+ q.pushMiddle(3); // [1, 3, 2]
+ q.pushMiddle(4); // [1, 4, 3, 2]
+ q.popFront(); // return 1 -> [4, 3, 2]
+ q.popMiddle(); // return 3 -> [4, 2]
+ q.popMiddle(); // return 4 -> [2]
+ q.popBack(); // return 2 -> []
+ q.popFront(); // return -1 -> [] (The queue is empty) 
+
+**Constraints:**
+
+* <code>1 <= val <= 10<sup>9</sup></code>
+* At most `1000` calls will be made to `pushFront`, `pushMiddle`, `pushBack`, `popFront`, `popMiddle`, and `popBack`.

src/main/java/g1601_1700/s1671_minimum_number_of_removals_to_make_mountain_array/Solution.java

@@ -0,0 +1,49 @@
+package g1601_1700.s1671_minimum_number_of_removals_to_make_mountain_array;
+
+// #Hard #Array #Dynamic_Programming #Greedy #Binary_Search
+// #2022_04_22_Time_19_ms_(81.23%)_Space_48.7_MB_(6.83%)
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class Solution {
+ public int minimumMountainRemovals(int[] nums) {
+ int n = nums.length;
+ // lbs -> longest bitomic subsequence
+ int lbs = 0;
+ int[] dp = new int[n];
+ // dp[i] -> lis end at index i, dp2[i] -> lds end at index i
+ int[] dp2 = new int[n];
+ List<Integer> lis = new ArrayList<>();
+ // calculate longest increasing subsequence
+ for (int i = 0; i < n - 1; i++) {
+ if (lis.isEmpty() || lis.get(lis.size() - 1) < nums[i]) {
+ lis.add(nums[i]);
+ } else {
+ int idx = Collections.binarySearch(lis, nums[i]);
+ if (idx < 0) {
+ lis.set(-idx - 1, nums[i]);
+ }
+ }
+ dp[i] = lis.size();
+ }
+ lis = new ArrayList<>();
+ // calculate longest decreasing subsequence
+ for (int i = n - 1; i >= 1; i--) {
+ if (lis.isEmpty() || lis.get(lis.size() - 1) < nums[i]) {
+ lis.add(nums[i]);
+ } else {
+ int idx = Collections.binarySearch(lis, nums[i]);
+ if (idx < 0) {
+ lis.set(-idx - 1, nums[i]);
+ }
+ }
+ dp2[i] = lis.size();
+ if (dp[i] > 1 && dp2[i] > 1) {
+ lbs = Math.max(lbs, dp[i] + dp2[i] - 1);
+ }
+ }
+ return n - lbs;
+ }
+}

src/main/java/g1601_1700/s1671_minimum_number_of_removals_to_make_mountain_array/readme.md

@@ -0,0 +1,34 @@
+1671\. Minimum Number of Removals to Make Mountain Array
+
+Hard
+
+You may recall that an array `arr` is a **mountain array** if and only if:
+
+* `arr.length >= 3`
+* There exists some index `i` (**0-indexed**) with `0 < i < arr.length - 1` such that:
+ * `arr[0] < arr[1] < ... < arr[i - 1] < arr[i]`
+ * `arr[i] > arr[i + 1] > ... > arr[arr.length - 1]`
+
+Given an integer array `nums`, return _the **minimum** number of elements to remove to make_ `nums` _a **mountain array**._
+
+**Example 1:**
+
+**Input:** nums = [1,3,1]
+
+**Output:** 0
+
+**Explanation:** The array itself is a mountain array so we do not need to remove any elements.
+
+**Example 2:**
+
+**Input:** nums = [2,1,1,5,6,2,3,1]
+
+**Output:** 3
+
+**Explanation:** One solution is to remove the elements at indices 0, 1, and 5, making the array nums = [1,5,6,3,1].
+
+**Constraints:**
+
+* `3 <= nums.length <= 1000`
+* <code>1 <= nums[i] <= 10<sup>9</sup></code>
+* It is guaranteed that you can make a mountain array out of `nums`.

src/test/java/g1601_1700/s1670_design_front_middle_back_queue/FrontMiddleBackQueueTest.java

@@ -0,0 +1,31 @@
+package g1601_1700.s1670_design_front_middle_back_queue;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class FrontMiddleBackQueueTest {
+ @Test
+ void frontMiddleBackQueue() {
+ FrontMiddleBackQueue q = new FrontMiddleBackQueue();
+ // [1]
+ q.pushFront(1);
+ // [1, 2]
+ q.pushBack(2);
+ // [1, 3, 2]
+ q.pushMiddle(3);
+ // [1, 4, 3, 2]
+ q.pushMiddle(4);
+ // return 1 -> [4, 3, 2]
+ assertThat(q.popFront(), equalTo(1));
+ // return 3 -> [4, 2]
+ assertThat(q.popMiddle(), equalTo(3));
+ // return 4 -> [2]
+ assertThat(q.popMiddle(), equalTo(4));
+ // return 2 -> []
+ assertThat(q.popBack(), equalTo(2));
+ // return -1 -> [] (The queue is empty)
+ assertThat(q.popFront(), equalTo(-1));
+ }
+}

src/test/java/g1601_1700/s1671_minimum_number_of_removals_to_make_mountain_array/SolutionTest.java

@@ -0,0 +1,20 @@
+package g1601_1700.s1671_minimum_number_of_removals_to_make_mountain_array;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void minimumMountainRemovals() {
+ assertThat(new Solution().minimumMountainRemovals(new int[] {1, 3, 1}), equalTo(0));
+ }
+
+ @Test
+ void minimumMountainRemovals2() {
+ assertThat(
+ new Solution().minimumMountainRemovals(new int[] {2, 1, 1, 5, 6, 2, 3, 1}),
+ equalTo(3));
+ }
+}