add first problems of graph 997

Author: Ashwagandha-coder

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

@@ -1,7 +1,8 @@
 package com.github.contest
 
+import com.github.contest.dp.countVowels
+import com.github.contest.graph.findJudge
 import com.github.contest.heap.customStructure.MinHeap
-import java.util.PriorityQueue
 
 
 /**
@@ -10,35 +11,45 @@ import java.util.PriorityQueue
 
 fun main() {
 
-    val heap = MinHeap<Int>()
-    heap.offer(3)
-    heap.offer(1)
-    heap.offer(2)
-    heap.offer(5)
+    findJudge(
+        5,
+        arrayOf(
+            intArrayOf(1, 3),
+            intArrayOf(2, 3),
+            intArrayOf(4, 3),
+            intArrayOf(4, 1),
+            intArrayOf(5, 3),
+            intArrayOf(5, 1),
+            intArrayOf(5, 4)
+        )
+    )
 
+}
 
-    println(heap.poll())
+fun vowels() {
 
+    /**
+     * a a a
+     * aa
+     * aa
+     * aaa
+     * count - 10
+     */
 
-//    halveArrayTest(intArrayOf(3, 8, 20))
+    countVowels("aaa")
 
 }
 
 
-fun halveArrayTest(nums: IntArray): Int {
-    val heap = PriorityQueue<Double>(reverseOrder())
-    nums.forEach { heap.offer(it.toDouble()) }
-    val sum = nums.sum().toDouble()
+fun heapWork() {
+
+    val heap = MinHeap<Int>()
+    heap.offer(3)
+    heap.offer(1)
+    heap.offer(2)
+    heap.offer(5)
+
 
-    val halve = sum / 2
-    var halvest = 0.0
-    var operations = 0
-    while (halvest < halve) {
-        val element = heap.poll() / 2
-        heap.offer(element)
-        halvest += element
-        operations++
-    }
+    println(heap.poll())
 
-    return operations
-}
+}

contest/src/main/java/com/github/contest/dp/DpLeetcode.kt

@@ -321,4 +321,43 @@ fun countVowels(word: String): Long {
     }
 
     return totalVowels
+}
+
+/**
+ *
+ */
+
+fun maxTwoEvents(events: Array<IntArray>): Int {
+    val n = events.size
+    events.sortBy { it[0] } // Sort by start time
+    val dp = IntArray(n)
+    var maxVal = 0
+    for (i in n - 1 downTo 0) {
+        maxVal = maxOf(maxVal, events[i][2])
+        dp[i] = maxVal
+    }
+    var res = 0
+    for (i in 0 until n) {
+        val start = events[i][0]
+        val end = events[i][1]
+        val value = events[i][2]
+        val nextIndex = findNextNonOverlapping(events, end)
+        val nextValue = if (nextIndex == n) 0 else dp[nextIndex]
+        res = maxOf(res, value + nextValue)
+    }
+    return res
+}
+
+private fun findNextNonOverlapping(events: Array<IntArray>, end: Int): Int {
+    var left = 0
+    var right = events.size
+    while (left < right) {
+        val mid = left + (right - left) / 2
+        if (events[mid][0] <= end) {
+            left = mid + 1
+        } else {
+            right = mid
+        }
+    }
+    return left
 }

contest/src/main/java/com/github/contest/graph/GraphLeetcode.kt

@@ -1,2 +1,19 @@
 package com.github.contest.graph
 
+/**
+ * 997. Find the Town Judge
+ */
+
+fun findJudge(n: Int, trust: Array<IntArray>): Int {
+    if (trust.isEmpty() && n == 1) return 1
+    val inEdges = IntArray(n + 1)
+    for (person in trust) {
+        inEdges[person[0]]--
+        inEdges[person[1]]++
+    }
+
+    for (person in inEdges.indices) {
+        if (inEdges[person] == n - 1) return person
+    }
+    return -1
+}