Math log（n）*log（log（n））的渐近复杂性

昨晚我正在解决一个问题，我必须在优先级队列中插入n次。因此，渐近复杂性为n logn。但是n可能会大到10^16，所以我必须做得更好。我找到了一个解决方案，它允许我只需在优先级队列日志中插入n次，其他所有内容都保持不变的时间。因此，复杂性为log（n）*log（log（n））。这是我的渐近复杂性还是可以进一步简化

这是alogrithm。通过使用hashmap计算将插入优先级队列的重复优先级，并在此基础上提供单个计算，我能够降低复杂性

---

通过我的代码，我知道如何将n log n复杂度降低为log n log n可能不是直观的。我必须仔细查看示例，才能发现n被缩减为logn。虽然solvedUpTo过去以与n相同的速率增加，现在通过~nNope，O（logn logn）被简化为该表达式将得到的简化。有时，在数论上下文中会出现O（n log n log n）这样的运行时，并且没有类似于这些数量的更简单的通用函数。

请您的问题包括您用作优先级队列的算法和数据结构。你对算法的复杂度做了一些假设，但这些假设可能不是真的。在科特林。

fun  solve(n:Long, x:Long, y:Long): Long {

    val numCount = mutableMapOf<Long,Long>()

    val minQue: PriorityQueue<Long> = PriorityQueue<Long>()

    addToQueue(numCount,minQue,x,1)
    addToQueue(numCount,minQue,y,1)

    var answer = x + y

    var solvedUpTo = 2L

    while (solvedUpTo < n) {

        val next = minQue.poll()

        val nextCount = numCount.remove(next)!!

        val quantityToSolveFor = min(nextCount,n - solvedUpTo)

        answer = ((answer + ((next + x + y) * quantityToSolveFor))).rem(1000000007)

        addToQueue(numCount,minQue,next + x,quantityToSolveFor)
        addToQueue(numCount,minQue,next + y,quantityToSolveFor)

        solvedUpTo += quantityToSolveFor
    }

    return answer
}

fun <K> addToQueue(numCount: MutableMap<K,Long>, minQue: PriorityQueue<K>, num: K, incrementBy: Long) {

    if (incrementMapAndCheckIfNew(numCount, num, incrementBy)) {
        minQue.add(num)
    }
}

//Returns true if just added
fun <K> incrementMapAndCheckIfNew(map: MutableMap<K,Long>, key: K, incrementBy: Long): Boolean {

    val prevKey = map.putIfAbsent(key,0L)

    map[key] = map[key]!! + incrementBy

    return prevKey == null
}