Merge pull request #156

add new problems 21.02

Author: Ashwagandha-coder

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

@@ -1,7 +1,7 @@
 package com.github.contest
 
 
-import com.github.contest.backtracking.findDifferentBinaryString
+import com.github.contest.heap.maxSubsequence
 import java.util.TreeMap
 
 
@@ -11,8 +11,39 @@ import java.util.TreeMap
 
 fun main() {
 
-    findDifferentBinaryString(arrayOf("00", "01"))
+    maxSubsequence(intArrayOf(-1, -2, 3, 4), 3).apply { this.printArray() }
+}
+
+fun generateTesting() {
+    val sequence = sequenceOf(3, 5, 6, 7, 7, 8, 8, 8, 9, 3)
+    sequence.map { it * 2 }
+        .filter { it > 3 }
+        .filter { it > 2 }
+        .constrainOnce()
+
+
+}
+
+fun generateSequence() {
+    var counter = 0
+    val numbers = generateSequence {
+        if (counter < 5) {
+            counter++
+            counter
+        } else null
+    }
+
+    println(numbers.toList())
+}
+
+fun doing() {
+    val collection = mutableListOf(listOf(5), listOf(2), listOf(4))
+    val other = mutableListOf(3, 5, 10)
+    val res = collection.flatMap {
+        it.asReversed()
+    }
 
+    println(res)
 }
 
 

contest/src/main/java/com/github/contest/binaryTree/BinaryTreeAlternativeSolution.kt

@@ -0,0 +1,31 @@
+package com.github.contest.binaryTree
+
+/**
+ * 1261. Find Elements in a Contaminated Binary Tree
+ * Alternative Solution
+ * DFS + SET
+ */
+
+class FindElementsAlternativeSolution(root: TreeNode?) {
+
+    private val values: MutableSet<Int> = mutableSetOf()
+
+    init {
+        recover(root, 0)
+    }
+
+
+    private fun recover(node: TreeNode?, value: Int) {
+        if (node == null) return
+
+        node.`val` = value
+        values.add(value)
+
+        recover(node.left, 2 * value + 1)
+        recover(node.right, 2 * value + 2)
+    }
+
+    fun find(target: Int): Boolean {
+        return values.contains(target)
+    }
+}

contest/src/main/java/com/github/contest/binaryTree/BinaryTreeLeetcode.kt

@@ -1,2 +1,36 @@
 package com.github.contest.binaryTree
 
+import java.util.LinkedList
+
+/**
+ * 1261. Find Elements in a Contaminated Binary Tree
+ */
+
+class TreeNode(var `val`: Int) {
+    var left: TreeNode? = null
+    var right: TreeNode? = null
+}
+
+class FindElements(private val root: TreeNode?) {
+
+    fun find(target: Int): Boolean = bfs(target)
+
+    private fun bfs(target: Int): Boolean {
+        if (target == 0 && root != null) return true
+        val queue = LinkedList<Pair<Int, TreeNode?>>()
+        queue.offer(0 to root)
+        while (queue.isNotEmpty()) {
+            val size = queue.size
+            for (i in 0 until size) {
+                val (index, node) = queue.poll()
+                if (index == target) return true
+                if (index > target) return false
+                node?.left?.let { queue.offer((index * 2 + 1) to it) }
+                node?.right?.let { queue.offer((index * 2 + 2) to it) }
+            }
+        }
+
+        return false
+    }
+
+}

contest/src/main/java/com/github/contest/binaryTree/BinaryTreeProdVariant.kt

@@ -0,0 +1,25 @@
+package com.github.contest.binaryTree
+
+/**
+ * 1261. Find Elements in a Contaminated Binary Tree
+ * Prod Variant
+ */
+
+class FindElementProdVariant(root: TreeNode?) {
+
+    private val values = buildSet {
+        fun dfs(root: TreeNode?, value: Int) {
+            if (root == null) return
+
+            root.`val` = value
+            add(value)
+
+            dfs(root?.left, value * 2 + 1)
+            dfs(root?.right, value * 2 + 2)
+        }
+        dfs(root, 0)
+    }
+
+    fun find(target: Int): Boolean = values.contains(target)
+
+}

contest/src/main/java/com/github/contest/heap/HeapLeetcode.kt

@@ -286,4 +286,27 @@ fun findDiagonalOrder(nums: List<List<Int>>): IntArray {
     }
 
     return result
-}
+}
+
+/**
+ * 2099. Find Subsequence of Length K With the Largest Sum
+ */
+
+fun maxSubsequence(nums: IntArray, k: Int): IntArray {
+    val heap = PriorityQueue<Pair<Int, Int>>(compareBy { it.first })
+    for (i in nums.indices) {
+        heap.offer(Pair(nums[i], i))
+        if (heap.size > k) {
+            heap.poll()
+        }
+    }
+
+    val indices = mutableListOf<Pair<Int, Int>>()
+    while (heap.isNotEmpty()) {
+        indices.add(heap.poll())
+    }
+
+    indices.sortBy { it.second }
+
+    return indices.map { it.first }.toIntArray()
+}

contest/src/main/java/com/github/contest/heap/HeapProdVariant.kt

@@ -41,5 +41,63 @@ fun findDiagonalOrderProdVariant(nums: List<List<Int>>): IntArray {
 }
 
 
+fun findDiagonalOrderProdVariantII(nums: List<List<Int>>): IntArray {
+    PriorityQueue { a: Pair<Int, Pair<Int, Int>>, b: Pair<Int, Pair<Int, Int>> ->
+        if (a.second.first != b.second.first) a.second.first - b.second.first
+        else b.first - a.first
+    }.apply {
+        nums.forEachIndexed { row, _ ->
+            nums[row].forEachIndexed { col, num ->
+                offer(row to (row + col to num))
+            }
+        }
+    }.apply {
+        return mutableListOf<Int>().also {
+            while (this.isNotEmpty()) it.add(this.poll().second.second)
+        }.toIntArray()
+    }
+}
+
+/**
+ * 2099. Find Subsequence of Length K With the Largest Sum
+ * Prod Variant
+ */
+
+fun maxSubsequenceProdVariant(nums: IntArray, k: Int): IntArray {
+    val heap = PriorityQueue<Pair<Int, Int>>(compareBy { it.first })
+
+    nums.forEachIndexed { index, num ->
+        heap.offer(index to num)
+        if (heap.size > k) heap.poll()
+    }
+
+    return mutableListOf<Pair<Int, Int>>()
+        .apply { heap.forEach { add(it) } }
+        .sortedBy { it.second }
+        .map { it.first }
+        .toIntArray()
+}
+
+fun maxSubsequenceProdVariantII(nums: IntArray, k: Int): IntArray =
+    nums.mapIndexed { index, num -> num to index }
+        .let { pairs ->
+            PriorityQueue<Pair<Int, Int>>(compareBy { it.first })
+                .apply {
+                    pairs.forEach {
+                        offer(it)
+                        if (size > k) poll()
+                    }
+                }.let { heap ->
+                    List(heap.size) { heap.poll() }
+                        .sortedBy { it.second }
+                        .map { it.first }
+                        .toIntArray()
+                }
+        }
+
+
+
+
+