Added tasks 3309-3312

Author: javadev

README.md

@@ -1816,6 +1816,10 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3312 |[Sorted GCD Pair Queries](src/main/kotlin/g3301_3400/s3312_sorted_gcd_pair_queries)| Hard | Array, Hash_Table, Math, Binary_Search, Prefix_Sum, Counting, Number_Theory, Combinatorics | 734 | 100.00
+| 3311 |[Construct 2D Grid Matching Graph Layout](src/main/kotlin/g3301_3400/s3311_construct_2d_grid_matching_graph_layout)| Hard | Array, Hash_Table, Matrix, Graph | 1423 | 100.00
+| 3310 |[Remove Methods From Project](src/main/kotlin/g3301_3400/s3310_remove_methods_from_project)| Medium | Depth_First_Search, Breadth_First_Search, Graph | 1465 | 100.00
+| 3309 |[Maximum Possible Number by Binary Concatenation](src/main/kotlin/g3301_3400/s3309_maximum_possible_number_by_binary_concatenation)| Medium | Array, Bit_Manipulation, Enumeration | 182 | 73.47
 | 3307 |[Find the K-th Character in String Game II](src/main/kotlin/g3301_3400/s3307_find_the_k_th_character_in_string_game_ii)| Hard | Math, Bit_Manipulation, Recursion | 189 | 50.00
 | 3306 |[Count of Substrings Containing Every Vowel and K Consonants II](src/main/kotlin/g3301_3400/s3306_count_of_substrings_containing_every_vowel_and_k_consonants_ii)| Medium | String, Hash_Table, Sliding_Window | 651 | 100.00
 | 3305 |[Count of Substrings Containing Every Vowel and K Consonants I](src/main/kotlin/g3301_3400/s3305_count_of_substrings_containing_every_vowel_and_k_consonants_i)| Medium | String, Hash_Table, Sliding_Window | 153 | 100.00

src/main/kotlin/g3301_3400/s3309_maximum_possible_number_by_binary_concatenation/readme.md

@@ -0,0 +1,83 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 3309\. Maximum Possible Number by Binary Concatenation
+
+Medium
+
+You are given an array of integers `nums` of size 3.
+
+Return the **maximum** possible number whose _binary representation_ can be formed by **concatenating** the _binary representation_ of **all** elements in `nums` in some order.
+
+**Note** that the binary representation of any number _does not_ contain leading zeros.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3]
+
+**Output:** 30
+
+**Explanation:**
+
+Concatenate the numbers in the order `[3, 1, 2]` to get the result `"11110"`, which is the binary representation of 30.
+
+**Example 2:**
+
+**Input:** nums = [2,8,16]
+
+**Output:** 1296
+
+**Explanation:**
+
+Concatenate the numbers in the order `[2, 8, 16]` to get the result `"10100010000"`, which is the binary representation of 1296.
+
+**Constraints:**
+
+*   `nums.length == 3`
+*   `1 <= nums[i] <= 127`
+
+## Solution
+
+```kotlin
+class Solution {
+    private var result = "0"
+
+    fun maxGoodNumber(nums: IntArray): Int {
+        val visited = BooleanArray(nums.size)
+        val sb = StringBuilder()
+        solve(nums, visited, 0, sb)
+        var score = 0
+        var `val`: Int
+        for (c in result.toCharArray()) {
+            `val` = c.code - '0'.code
+            score *= 2
+            score += `val`
+        }
+        return score
+    }
+
+    private fun solve(nums: IntArray, visited: BooleanArray, pos: Int, sb: StringBuilder) {
+        if (pos == nums.size) {
+            val `val` = sb.toString()
+            if ((result.length == `val`.length && result.compareTo(`val`) < 0) ||
+                `val`.length > result.length
+            ) {
+                result = `val`
+            }
+            return
+        }
+        var cur: String?
+        for (i in nums.indices) {
+            if (visited[i]) {
+                continue
+            }
+            visited[i] = true
+            cur = Integer.toBinaryString(nums[i])
+            sb.append(cur)
+            solve(nums, visited, pos + 1, sb)
+            sb.setLength(sb.length - cur.length)
+            visited[i] = false
+        }
+    }
+}
+```

src/main/kotlin/g3301_3400/s3310_remove_methods_from_project/readme.md

@@ -0,0 +1,135 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 3310\. Remove Methods From Project
+
+Medium
+
+You are maintaining a project that has `n` methods numbered from `0` to `n - 1`.
+
+You are given two integers `n` and `k`, and a 2D integer array `invocations`, where <code>invocations[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> indicates that method <code>a<sub>i</sub></code> invokes method <code>b<sub>i</sub></code>.
+
+There is a known bug in method `k`. Method `k`, along with any method invoked by it, either **directly** or **indirectly**, are considered **suspicious** and we aim to remove them.
+
+A group of methods can only be removed if no method **outside** the group invokes any methods **within** it.
+
+Return an array containing all the remaining methods after removing all the **suspicious** methods. You may return the answer in _any order_. If it is not possible to remove **all** the suspicious methods, **none** should be removed.
+
+**Example 1:**
+
+**Input:** n = 4, k = 1, invocations = \[\[1,2],[0,1],[3,2]]
+
+**Output:** [0,1,2,3]
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/07/18/graph-2.png)
+
+Method 2 and method 1 are suspicious, but they are directly invoked by methods 3 and 0, which are not suspicious. We return all elements without removing anything.
+
+**Example 2:**
+
+**Input:** n = 5, k = 0, invocations = \[\[1,2],[0,2],[0,1],[3,4]]
+
+**Output:** [3,4]
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/07/18/graph-3.png)
+
+Methods 0, 1, and 2 are suspicious and they are not directly invoked by any other method. We can remove them.
+
+**Example 3:**
+
+**Input:** n = 3, k = 2, invocations = \[\[1,2],[0,1],[2,0]]
+
+**Output:** []
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/07/20/graph.png)
+
+All methods are suspicious. We can remove them.
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `0 <= k <= n - 1`
+*   <code>0 <= invocations.length <= 2 * 10<sup>5</sup></code>
+*   <code>invocations[i] == [a<sub>i</sub>, b<sub>i</sub>]</code>
+*   <code>0 <= a<sub>i</sub>, b<sub>i</sub> <= n - 1</code>
+*   <code>a<sub>i</sub> != b<sub>i</sub></code>
+*   `invocations[i] != invocations[j]`
+
+## Solution
+
+```kotlin
+class Solution {
+    private lateinit var graph: Array<IntArray?>
+    private lateinit var suspicious: BooleanArray
+    private lateinit var visited: BooleanArray
+
+    fun remainingMethods(n: Int, k: Int, invocations: Array<IntArray>): List<Int> {
+        pack(invocations, n)
+        suspicious = BooleanArray(n)
+        visited = BooleanArray(n)
+        dfs(k, true)
+        visited.fill(false)
+        for (i in 0 until n) {
+            if (!suspicious[i] && dfs2(i)) {
+                visited.fill(false)
+                dfs(k, false)
+                break
+            }
+        }
+        val rst = ArrayList<Int>()
+        for (i in 0 until n) {
+            if (!suspicious[i]) {
+                rst.add(i)
+            }
+        }
+        return rst
+    }
+
+    fun dfs(u: Int, sus: Boolean) {
+        if (visited[u]) {
+            return
+        }
+        visited[u] = true
+        suspicious[u] = sus
+        for (v in graph[u]!!) {
+            dfs(v, sus)
+        }
+    }
+
+    fun dfs2(u: Int): Boolean {
+        if (suspicious[u]) {
+            return true
+        }
+        if (visited[u]) {
+            return false
+        }
+        visited[u] = true
+        for (v in graph[u]!!) {
+            if (dfs2(v)) {
+                return true
+            }
+        }
+        return false
+    }
+
+    private fun pack(edges: Array<IntArray>, n: Int) {
+        val adj = IntArray(n)
+        for (edge in edges) {
+            adj[edge[0]]++
+        }
+        graph = arrayOfNulls<IntArray>(n)
+        for (i in 0 until n) {
+            graph[i] = IntArray(adj[i])
+        }
+        for (edge in edges) {
+            graph[edge[0]]!![--adj[edge[0]]] = edge[1]
+        }
+    }
+}
+```