Merge pull request #154

add new problem and max heap 19.02

Author: Ashwagandha-coder

.idea/other.xml

@@ -1,6 +1,6 @@
 package com.github.contest
 
-import com.github.contest.heap.numberGame
+import com.github.contest.heap.customStructure.MaxHeap
 
 
 /**
@@ -9,7 +9,13 @@ import com.github.contest.heap.numberGame
 
 fun main() {
 
-    numberGame(intArrayOf(5, 4, 2, 3))
+    val maxheap = MaxHeap<Int>()
+
+    for (i in 1..39) maxheap.offer(i)
+
+    while (maxheap.isNotEmpty()) {
+        println(maxheap.poll())
+    }
 
 
 }

contest/src/main/java/com/github/contest/Execute.kt

@@ -58,4 +58,38 @@ private fun isValid(num: Int, pos: Int, arr: IntArray): Boolean {
     if (pos + num + 1 >= arr.size) return false
     if (arr[pos + num + 1] != 0) return false
     return true
+}
+
+/**
+ * 1415. The k-th Lexicographical String of All Happy Strings of Length n
+ * Alternative Solution
+ */
+
+fun getHappyStringAltSolution(n: Int, k: Int): String {
+    val count = intArrayOf(0)
+    val result = StringBuilder()
+    val chars = charArrayOf('a', 'b', 'c')
+
+    fun backtrack(current: StringBuilder) {
+        if (current.length == n) {
+            count[0]++
+            if (count[0] == k) {
+                result.append(current.toString())
+            }
+            return
+        }
+
+        if (count[0] >= k) return
+
+        for (char in chars) {
+            if (current.isEmpty() || current.last() != char) {
+                current.append(char)
+                backtrack(current)
+                current.deleteCharAt(current.length - 1)
+            }
+        }
+    }
+
+    backtrack(StringBuilder())
+    return result.toString()
 }

contest/src/main/java/com/github/contest/backtracking/BacktrackingAlteranativeSolution.kt

@@ -108,3 +108,37 @@ private fun dfs(count: IntArray): Int {
     }
     return sum
 }
+
+/**
+ * 1415. The k-th Lexicographical String of All Happy Strings of Length n
+ */
+
+
+fun getHappyString(n: Int, k: Int): String {
+    val res = mutableListOf<String>()
+    val set = "abc"
+    val subset = StringBuilder()
+    generateHappyString(0, n, set, subset, res)
+    return if (k > res.size) "" else res[k - 1]
+}
+
+private fun generateHappyString(
+    index: Int,
+    n: Int,
+    set: String,
+    subset: StringBuilder,
+    res: MutableList<String>
+) {
+    if (index == n) {
+        res.add(subset.toString())
+        return
+    }
+
+    for (s in set) {
+        if (subset.isEmpty() || subset[subset.length - 1] != s) {
+            subset.append(s)
+            generateHappyString(index + 1, n, set, subset, res)
+            subset.deleteCharAt(subset.length - 1)
+        }
+    }
+}

contest/src/main/java/com/github/contest/backtracking/BacktrackingLeetcode.kt

@@ -22,4 +22,38 @@ private fun isPunishment(num: Int): Boolean {
     }
 
     return backtrack(0, 0)
+}
+
+/**
+ * 1415. The k-th Lexicographical String of All Happy Strings of Length n
+ * Prod Variant
+ */
+
+
+fun getHappyStringProdVariant(n: Int, k: Int): String {
+    val result = StringBuilder()
+    val chars = setOf('a', 'b', 'c')
+    var count = 0
+    fun generateHappyString(current: StringBuilder) {
+        if (current.length == n) {
+            count++
+            if (count == k) result.append(current.toString())
+            return
+        }
+
+        if (count >= k) return
+
+        chars.filter { current.isEmpty() || current.last() != it }.forEach {
+            current.append(it)
+            generateHappyString(current)
+            current.deleteLast()
+        }
+    }
+
+    generateHappyString(StringBuilder())
+    return result.toString()
+}
+
+private fun StringBuilder.deleteLast() {
+    if (isNotEmpty()) deleteCharAt(this.length - 1)
 }

contest/src/main/java/com/github/contest/backtracking/BacktrackingProdVariant.kt

@@ -0,0 +1,66 @@
+package com.github.contest.heap.customStructure
+
+class MaxHeap<T : Comparable<T>> {
+
+    private val heap = mutableListOf<T>()
+    val size get() = heap.size
+
+    fun isEmpty() = heap.isEmpty()
+
+    fun isNotEmpty() = heap.isNotEmpty()
+
+    fun offer(item: T) {
+        heap.add(item)
+        siftUp(heap.size - 1)
+    }
+
+    fun poll(): T? {
+        if (isEmpty()) throw IndexOutOfBoundsException()
+        heap.swap(0, heap.size - 1)
+        val element = heap.removeLast()
+        siftDown(0)
+        return element
+    }
+
+
+    private fun siftUp(index: Int) {
+        var currentIndex = index
+        var parentIndex = parentIndex(currentIndex)
+        while (currentIndex > 0 && heap[currentIndex] > heap[parentIndex]) {
+            heap.swap(currentIndex, parentIndex)
+            currentIndex = parentIndex
+            parentIndex = parentIndex(currentIndex)
+        }
+    }
+
+
+    private fun siftDown(index: Int) {
+        var currentIndex = index
+        while (hasLeftChild(currentIndex)) {
+            var smallestIndex = leftChildIndex(currentIndex)
+            if (hasRightChild(currentIndex) && heap[rightChildIndex(currentIndex)] > heap[smallestIndex]) {
+                smallestIndex = rightChildIndex(currentIndex)
+            }
+            if (heap[currentIndex] > heap[smallestIndex]) break
+            heap.swap(currentIndex, smallestIndex)
+            currentIndex = smallestIndex
+        }
+    }
+
+    private fun MutableList<T>.swap(from: Int, to: Int) {
+        val temp = this[from]
+        this[from] = this[to]
+        this[to] = temp
+    }
+
+    private fun hasLeftChild(index: Int): Boolean = leftChildIndex(index) < heap.size
+
+    private fun hasRightChild(index: Int): Boolean = rightChildIndex(index) < heap.size
+
+    private fun leftChildIndex(index: Int) = (index * 2) + 1
+
+    private fun rightChildIndex(index: Int) = (index * 2) + 2
+
+    private fun parentIndex(index: Int) = (index - 1) / 2
+
+}