More Problems

Author: JustAnotherSoftwareDeveloper

solutions/src/ChampagneTower.kt

@@ -0,0 +1,34 @@
+/**
+ * https://leetcode.com/problems/champagne-tower/
+ */
+class ChampagneTower {
+
+    fun champagneTower(poured: Int, query_row: Int, query_glass: Int): Double {
+        val dp = mutableListOf<MutableList<Double>>()
+        for (i in 0..query_row) {
+            dp.add(mutableListOf())
+            for (j in 0..i) {
+                dp[i].add(0.0)
+            }
+        }
+        dp[0][0] = poured.toDouble()
+        dp.forEachIndexed { index,row ->
+            if (index != dp.lastIndex) {
+                row.forEachIndexed { index2, amount ->
+                    val newAmount : Double = if (amount > 1.0) {
+                        (amount-1.0)/2.0
+                    }
+                    else  {
+                        0.0
+                    }
+                    dp[index+1][index2]+=newAmount
+                    dp[index+1][index2+1]+=newAmount
+                }
+            }
+
+        }
+        return minOf(dp[query_row][query_glass],1.0)
+
+    }
+
+}

solutions/src/CherryPickup.kt

@@ -0,0 +1,40 @@
+import java.util.*
+
+
+/**
+ * https://leetcode.com/problems/cherry-pickup/
+ */
+class CherryPickup {
+    fun cherryPickup(grid: Array<IntArray>): Int {
+        val n = grid.size
+        val dp = Array(n + 1) { Array(n + 1) { IntArray(n + 1) } }
+        for (i in 0..n) {
+            for (j in 0..n) {
+                Arrays.fill(dp[i][j], Int.MIN_VALUE)
+            }
+        }
+        dp[1][1][1] = grid[0][0]
+        for (x1 in 1..n) {
+            for (y1 in 1..n) {
+                for (x2 in 1..n) {
+                    val y2 = x1 + y1 - x2
+                    if (dp[x1][y1][x2] > 0 || y2 < 1 || y2 > n || grid[x1 - 1][y1 - 1] == -1 || grid[x2 - 1][y2 - 1] == -1) {
+                        continue
+                        // have already detected || out of boundary || cannot access
+                    }
+                    val cur = Math.max(Math.max(dp[x1 - 1][y1][x2], dp[x1 - 1][y1][x2 - 1]), Math.max(dp[x1][y1 - 1][x2], dp[x1][y1 - 1][x2 - 1]))
+                    if (cur < 0) {
+                        continue
+                    }
+                    dp[x1][y1][x2] = cur + grid[x1 - 1][y1 - 1]
+                    if (x1 != x2) {
+                        dp[x1][y1][x2] += grid[x2 - 1][y2 - 1]
+                    }
+                }
+            }
+        }
+        return if (dp[n][n][n] < 0) 0 else dp[n][n][n]
+    }
+
+}
+

solutions/src/TestBed.kt

@@ -3,9 +3,10 @@ import kotlin.time.measureTime
 
 fun main(args: Array<String>) {
     println(measureTime {
-        val tester =  OutOfBoundsPaths()
+        val tester =  ChampagneTower()
         val results = listOf(
-                tester.findPaths(1,3,3,0,1)
+                tester.champagneTower(1,1,1),
+                tester.champagneTower(2,1,1)
 
         )
         println(results.map { it })

solutions/src/ThreeEqualParts.kt

@@ -0,0 +1,45 @@
+/**
+ * https://leetcode.com/problems/three-equal-parts/
+ */
+class ThreeEqualParts {
+    fun threeEqualParts(A: IntArray): IntArray? {
+        var numOne = 0
+        for (i in A) {
+            if (i == 1) numOne++
+        }
+        val noRes = intArrayOf(-1, -1)
+        if (numOne == 0) return intArrayOf(0, 2)
+        if (numOne % 3 != 0) return noRes
+
+        //find index of starting 1 of third string
+        var idxThird = 0
+        var temp = 0
+        for (i in A.indices.reversed()) {
+            if (A[i] == 1) {
+                temp++
+                if (temp == numOne / 3) {
+                    idxThird = i
+                    break
+                }
+            }
+        }
+        val res1 = findEndIdx(A, 0, idxThird)
+        if (res1 < 0) return noRes
+        val res2 = findEndIdx(A, res1 + 1, idxThird)
+        return if (res2 < 0) noRes else intArrayOf(res1, res2 + 1)
+    }
+
+    //right is the pattern to compare to.
+    //return EndIdx of left pattern that matches right side.
+    private fun findEndIdx(A: IntArray, left: Int, right: Int): Int {
+        var left = left
+        var right = right
+        while (A[left] == 0) left++
+        while (right < A.size) {
+            if (A[left] != A[right]) return -1
+            left++
+            right++
+        }
+        return left - 1
+    }
+}