Add problem 'Longest Increasing Subsequence' and 'Best Time to Buy and Sell Stock II'

Author: juchanei

jvm/src/main/java/io/github/juchanei/leetcodeJava/LongestIncreasingSubsequence.java

@@ -0,0 +1,105 @@
+package io.github.juchanei.leetcodeJava;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+// https://leetcode.com/problems/longest-increasing-subsequence/
+public class LongestIncreasingSubsequence {
+    private int[] nums = null;
+    private Memo memo = null;
+
+    public int lengthOfLIS(int[] nums) {
+        this.nums = nums;
+        this.memo = new Memo(nums.length + 1, nums.length + 1);
+
+        return recursion(null, 0);
+    }
+
+    // NOTE: pivot 이 아직 선택되지 않은 경우 pivotIndex 를 null 로 한다.
+    private int recursion(Integer pivotIndex, int index) {
+        if (this.memo.contains(pivotIndex, index)) {
+            return this.memo.get(pivotIndex, index);
+        }
+
+        if (this.nums.length == index) return 0;
+
+        int result;
+        if (pivotIndex == null || this.nums[pivotIndex] < this.nums[index]) {
+            result = Math.max(
+                recursion(index, index + 1) + 1,
+                recursion(pivotIndex, index + 1)
+            );
+        } else {
+            result = recursion(pivotIndex, index + 1);
+        }
+
+        return this.memo.setAndGet(pivotIndex, index, result);
+    }
+
+    static class Memo {
+        private final int EMPTY = -1;
+        private final int[][] memo;
+
+        Memo(int size1, int size2) {
+            this.memo = new int[size1][size2];
+            for (int[] l : this.memo) Arrays.fill(l, EMPTY);
+        }
+
+        boolean contains(Integer i, int j) {
+            if (i == null) return false;
+            return this.memo[i][j] != EMPTY;
+        }
+
+        int get(Integer i, int j) {
+            return this.memo[i][j];
+        }
+
+        int setAndGet(Integer i, int j, int value) {
+            if (i == null) return value;
+            return this.memo[i][j] = value;
+        }
+    }
+
+    @Nested
+    class UnitTest {
+        @Test
+        public void example1() {
+            // given
+            int[] nums = {10, 9, 2, 5, 3, 7, 101, 18};
+
+            // when
+            int result = lengthOfLIS(nums);
+
+            // then
+            assertEquals(4, result);
+        }
+
+        @Test
+        public void example2() {
+            // given
+            int[] nums = {0, 1, 0, 3, 2, 3};
+
+            // when
+            int result = lengthOfLIS(nums);
+
+            // then
+            assertEquals(4, result);
+        }
+
+        @Test
+        public void example3() {
+            // given
+            int[] nums = {7, 7, 7, 7, 7, 7, 7};
+
+            // when
+            int result = lengthOfLIS(nums);
+
+            // then
+            assertEquals(1, result);
+        }
+    }
+}

jvm/src/main/kotlin/io.github.juchanei.leetcodeKotlin/BestTimeToBuyandSellStockII.kt

@@ -0,0 +1,94 @@
+package io.github.juchanei.leetcodeKotlin
+
+import org.assertj.core.api.BDDAssertions.then
+import org.junit.jupiter.api.Test
+import java.lang.Integer.max
+
+// https://leetcode.com/explore/interview/card/top-interview-questions-easy/92/array/564/
+class BestTimeToBuyAndSellStockII {
+    fun maxProfit(prices: IntArray): Int {
+        val memo = mutableMapOf<Pair<Int, Int?>, Int>()
+
+        fun search(day: Int, buyPrice: Int? = null): Int {
+            val cache = memo[day to buyPrice]
+            if (cache != null) return cache
+
+            return when {
+                // 기간이 끝났을 때 팔지 못한 주식이 있다면 손해로 책정한다
+                prices.size == day -> {
+                    if (buyPrice == null) {
+                        0
+                    } else {
+                        -buyPrice
+                    }
+                }
+                // 가지고 있는 주식이 없는 경우 오늘 사거나 사지 않는다
+                buyPrice == null -> {
+                    max(
+                        search(day + 1, prices[day]), // buy
+                        search(day + 1) // skip
+                    )
+                }
+                // 가지고 있는 주식의 가격이 오른 상태면 오늘 팔거나 팔지 않는다
+                buyPrice < prices[day] -> {
+                    max(
+                        search(day + 1) + prices[day] - buyPrice, // sell
+                        search(day + 1, buyPrice), // skip
+                    )
+                }
+                // 가지고 있는 주식의 가격이 변동이 없거나 떨어져있으면
+                // 오를때 까지 기다렸다가 팔거나 팔지 않는다
+                else -> {
+                    val nextDay = (day + 1 until prices.size)
+                        .find { prices[day] < prices[it] }
+                        ?: prices.size
+
+                    max(
+                        search(nextDay) + prices[day] - buyPrice, // sell
+                        search(nextDay, buyPrice), // skip
+                    )
+                }
+            }.also {
+                memo[day to buyPrice] = it
+            }
+        }
+
+        return search(0)
+    }
+
+    @Test
+    fun example1() {
+        // given
+        val prices = intArrayOf(7, 1, 5, 3, 6, 4)
+
+        // when
+        val ret = maxProfit(prices)
+
+        // then
+        then(ret).isEqualTo(7)
+    }
+
+    @Test
+    fun example2() {
+        // given
+        val prices = intArrayOf(1, 2, 3, 4, 5)
+
+        // when
+        val ret = maxProfit(prices)
+
+        // then
+        then(ret).isEqualTo(4)
+    }
+
+    @Test
+    fun example3() {
+        // given
+        val prices = intArrayOf(7, 6, 4, 3, 1)
+
+        // when
+        val ret = maxProfit(prices)
+
+        // then
+        then(ret).isEqualTo(0)
+    }
+}