Improved task 3470

Author: javadev

src/main/kotlin/g3401_3500/s3470_permutations_iv/Solution.kt

@@ -1,115 +1,70 @@
 package g3401_3500.s3470_permutations_iv
 
 // #Hard #Array #Math #Enumeration #Combinatorics
-// #2025_03_06_Time_21_ms_(25.81%)_Space_47.38_MB_(6.45%)
+// #2025_03_06_Time_3_ms_(100.00%)_Space_46.15_MB_(6.45%)
 
 class Solution {
-    private fun helper(a: Int, b: Int): Long {
-        var res: Long = 1
-        for (i in 0..<b) {
-            res *= (a - i).toLong()
-            if (res > INF) {
-                return INF
+    fun permute(n: Int, k: Long): IntArray {
+        val perm = LongArray(n + 1)
+        perm[1] = 1L
+        for (i in 2..n) {
+            if (perm[i - 1] > 10_000_000_000_000_000) {
+                perm[i] = perm[i - 1]
+            } else {
+                perm[i] = ((i + 2) / 2) * perm[i - 1]
             }
         }
-        return res
-    }
-
-    private fun solve(odd: Int, even: Int, r: Int, req: Int): Long {
-        if (r == 0) {
-            return 1
-        }
-        val nOdd: Int
-        val nEven: Int
-        if (req == 1) {
-            nOdd = (r + 1) / 2
-            nEven = r / 2
-        } else {
-            nEven = (r + 1) / 2
-            nOdd = r / 2
-        }
-        if (odd < nOdd || even < nEven) {
-            return 0
+        val used = BooleanArray(n + 1)
+        val result = IntArray(n)
+        var index = 0
+        // Deal with the edge cases first
+        if (n < 3) {
+            if (k > n) return intArrayOf()
+            if (k == 2L) return intArrayOf(2, 1)
+            if (n == 1) return intArrayOf(1)
+            return intArrayOf(1, 2)
         }
-        val oddWays = helper(odd, nOdd)
-        val evenWays = helper(even, nEven)
-        var total = oddWays
-        if (evenWays == 0L || total > INF / evenWays) {
-            total = INF
+        val firstCycle = (((k.toLong() - 1L) / perm[n - 2]).toInt()) + 1
+        var odd = 2
+        if (n % 2 == 0) {
+            if (firstCycle > n) return intArrayOf()
+            result[index++] = firstCycle
+            used[firstCycle] = true
+            if (firstCycle % 2 == 0) {
+                odd = 1
+            }
         } else {
-            total *= evenWays
-        }
-        return total
-    }
-
-    fun permute(n: Int, k: Long): IntArray {
-        var k = k
-        val ans: MutableList<Int> = ArrayList<Int>()
-        var first = false
-        val used = BooleanArray(n + 1)
-        var odd = (n + 1) / 2
-        var even = n / 2
-        var last = -1
-        for (i in 1..n) {
-            if (!used[i]) {
-                var odd2 = odd
-                var even2 = even
-                val cp = i and 1
-                val next = (if (cp == 1) 0 else 1)
-                if (cp == 1) {
-                    odd2--
-                } else {
-                    even2--
-                }
-                val r = n - 1
-                val cnt = solve(odd2, even2, r, next)
-                if (k > cnt) {
-                    k -= cnt
-                } else {
-                    ans.add(i)
-                    used[i] = true
-                    odd = odd2
-                    even = even2
-                    last = cp
-                    first = true
-                    break
-                }
+            val first = firstCycle * 2 - 1
+            if (first > n) {
+                return intArrayOf()
             }
+            result[index++] = first
+            used[first] = true
         }
-        if (!first) {
-            return IntArray(0)
-        }
-        for (z in 1..<n) {
-            for (j in 1..n) {
-                if (!used[j] && ((j and 1) != last)) {
-                    var odd2 = odd
-                    var even2 = even
-                    val cp = j and 1
-                    if (cp == 1) {
-                        odd2--
-                    } else {
-                        even2--
-                    }
-                    val r = n - (z + 1)
-                    val next = (if (cp == 1) 0 else 1)
-                    val cnt2 = solve(odd2, even2, r, next)
-                    if (k > cnt2) {
-                        k -= cnt2
-                    } else {
-                        ans.add(j)
-                        used[j] = true
-                        odd = odd2
-                        even = even2
-                        last = cp
-                        break
+        var rem = ((k - 1L) % perm[n - 2]) + 1L
+        fun findNum(start: Int, nth: Int): Int {
+            var toFind = nth
+            for (i in start..n step 2) {
+                if (used[i] == false) {
+                    toFind--
+                    if (toFind == 0) {
+                        return i
                     }
                 }
             }
+            return -1
         }
-        return ans.stream().mapToInt { i: Int? -> i!! }.toArray()
-    }
-
-    companion object {
-        private const val INF = 1000000000000000000L
+        for (i in n - 3 downTo 1) {
+            val nextNum = ((rem - 1) / perm[i]).toInt()
+            val nextDigit = findNum(odd, nextNum + 1)
+            result[index++] = nextDigit
+            used[nextDigit] = true
+            rem = ((rem - 1L) % perm[i]) + 1L
+            odd = 3 - odd
+        }
+        result[index++] = findNum(odd, 1)
+        odd = 3 - odd
+        result[index] = findNum(odd, 1)
+        return result
     }
 }