Merge remote-tracking branch 'origin/master'

Author: kkarpyshev

src/easy/141. Linked List Cycle .kt

@@ -1,5 +1,8 @@
 package easy
 
+import HashTableTopic
+import LinkedListTopic
+import TwoPointersTopic
 import utils.ListNode
 
 /**
@@ -12,20 +15,21 @@ import utils.ListNode
  * Return true if there is a cycle in the linked list. Otherwise, return false.
  */
 
-class Easy141 {
+class Easy141 : HashTableTopic, LinkedListTopic, TwoPointersTopic {
 
     fun hasCycle(head: ListNode?): Boolean {
-        if (head == null) return false
-        if (head.next == null || head.next!!.next == null) return false
+        head ?: return false
+        head.next ?: return false
+        head.next?.next ?: return false
         if (head === head.next) return true
         var t1 = head
-        var t2 = head.next!!.next
+        var t2 = head.next?.next
         while (true) {
             when {
                 t1 === t2 -> return true
-                t2!!.next != null && t2.next!!.next != null -> {
-                    t1 = t1!!.next
-                    t2 = t2.next!!.next
+                t2?.next != null && t2.next!!.next != null -> {
+                    t1 = t1?.next
+                    t2 = t2.next?.next
                 }
                 else -> return false
             }

src/hard/1359. Count All Valid Pickup and Delivery Options .kt

@@ -0,0 +1,62 @@
+package hard
+
+import CombinatoricsTopic
+import DynamicProgrammingTopic
+import MathTopic
+
+/**
+ * 1359. Count All Valid Pickup and Delivery Options
+ * https://leetcode.com/problems/count-all-valid-pickup-and-delivery-options/
+ *
+Given n orders, each order consist in pickup and delivery services.
+Count all valid pickup/delivery possible sequences such that delivery(i) is always after of pickup(i).
+Since the answer may be too large, return it modulo 10^9 + 7.
+
+BULLSHIT
+ */
+
+class Hard1359 : MathTopic, DynamicProgrammingTopic, CombinatoricsTopic {
+
+    private val MOD = 1000000007L
+    private lateinit var memo: Array<LongArray>
+
+    private fun totalWays(unpicked: Int, undelivered: Int): Long {
+        if (unpicked == 0 && undelivered == 0) {
+            // We have completed all orders.
+            return 1
+        }
+        if (unpicked < 0 || undelivered < 0 || undelivered < unpicked) {
+            // We can't pick or deliver more than N items
+            // Number of deliveries can't exceed number of pickups
+            // as we can only deliver after a pickup.
+            return 0
+        }
+        if (memo[unpicked][undelivered] != 0L) {
+            // Return cached value, if already present.
+            return memo[unpicked][undelivered]
+        }
+        var ans: Long = 0
+
+        // Count all choices of picking up an order.
+        ans += unpicked * totalWays(unpicked - 1, undelivered)
+        // Handle integer overflow.
+        ans %= MOD
+
+        // Count all choices of delivering a picked order.
+        ans += (undelivered - unpicked) * totalWays(unpicked, undelivered - 1)
+        // Handle integer overflow.
+        ans %= MOD
+        return ans.also { memo[unpicked][undelivered] = it }
+    }
+
+    fun countOrders(n: Int): Int {
+        memo = Array(n + 1) { LongArray(n + 1) }
+        return totalWays(n, n).toInt()
+    }
+}
+
+fun main() {
+    println(Hard1359().countOrders(1))
+    println(Hard1359().countOrders(2))
+    println(Hard1359().countOrders(3))
+}

src/medium/799. Champagne Tower .kt

@@ -0,0 +1,48 @@
+package medium
+
+import DynamicProgrammingTopic
+
+/**
+ * 799. Champagne Tower
+ * https://leetcode.com/problems/champagne-tower/
+ *
+We stack glasses in a pyramid, where the first row has 1 glass, the second row has 2 glasses, and so on until the 100th row.
+Each glass holds one cup of champagne.
+
+Then, some champagne is poured into the first glass at the top.
+When the topmost glass is full, any excess liquid poured will fall equally to the glass immediately to the left and right of it.
+When those glasses become full, any excess champagne will fall equally to the left and right of those glasses, and so on.
+(A glass at the bottom row has its excess champagne fall on the floor.)
+
+For example, after one cup of champagne is poured, the top most glass is full.
+After two cups of champagne are poured, the two glasses on the second row are half full.
+After three cups of champagne are poured, those two cups become full - there are 3 full glasses total now.
+After four cups of champagne are poured, the third row has the middle glass half full, and the two outside glasses are a quarter full, as pictured below.
+
+Now after pouring some non-negative integer cups of champagne, return how full the jth glass in the ith row is (both i and j are 0-indexed.)
+ */
+
+class Medium799 : DynamicProgrammingTopic {
+
+    fun champagneTower(poured: Int, query_row: Int, query_glass: Int): Double {
+        val result = ArrayList<DoubleArray>(query_row + 1)
+        result.add(doubleArrayOf(poured.toDouble()))
+        for (i in 1 until query_row + 1) {
+            val row = DoubleArray(i + 1)
+            for (j in 0 until result[i - 1].size) {
+                val score = maxOf(0.0, result[i - 1][j] - 1) / 2
+                row[j] += score
+                row[j + 1] += score
+            }
+            result.add(i, row)
+        }
+        println(result.map { it.toList() })
+        return minOf(1.0, result[query_row][query_glass])
+    }
+}
+
+fun main() {
+    println(Medium799().champagneTower(1, 1, 1))
+    println(Medium799().champagneTower(2, 1, 1))
+    println(Medium799().champagneTower(100000009, 33, 17))
+}