Question

在O(n*log K)时间,你如何对平均长度为K的分类清单进行分类?

Answer 1

如对贵问题的评论所述,O(nlog(k)是不可能的,但这里的计算方法是在上有效地完成你的任务。

Take the first element of each list and create a heap (of size k). Pop the smallest element. Find the array from the element came (let s say it came from list number i). Take the next element from list i and push it in heap. For each element that go in the merged list, we spent log(k) time. So the time complexity is O(N*logk) where N is total number of the elements in all the K lists.

- 由:

Answer 2

玉米是关键。让我们相信N是需要统一的要素的总数,K是载有这些内容的集装箱的数量:

你用单一病媒照亮了所有顺序,但记得在哪里附上了这些顺序。较好的是,如果你根据第一要素的价值加以分类,就会加快下一段。
然后,你会合一顺序(结果:如果你使用C++,则会合并)。每一次合并都是Na + Nb,因此每个步骤都是N。你们必须采取标志性步骤。

因此NlogK。

Answer 3

我认为,有可能实现O(N*log(K)),但并非最糟糕的情况。

审议这些清单:

{0,1,2,3,4,5,6,7,8,9,10},
{10,11,12,13,14,15,16,17,18,19,20},
{20,21,22,23,24,25,26,27,28,29,30}

我的人类大脑可以轻松地整理这些清单,而不阅读任何价值,因此,应当采用能够做到的算法。我们需要合并,同时利用经过修改的双轨搜索来寻找各种价值。

在最坏的情况下,你获得O(N*K),因为必须比较每个价值。例:

{0,2,4,6,8},
{1,3,5,7,9}

我在戈马的解决办法是,只有我知道分类名单通常有与K相对较小的重叠区域时,我才会使用这种办法:

// variation of binary search that finds largest
// value up to and including max
func findNext(a []int, imin int, vmax int) int {
    imax := len(a) - 1
    best := -1
    for imin <= imax {
        imid := imin + ((imax - imin) / 2)
        if a[imid] == vmax {
            return imid
        } else if a[imid] < vmax {
            best = imid
            imin = imid + 1
        } else {
            imax = imid - 1
        }
    }
    return best
}

func sortNSortedLists(in [][]int) []int {
    var out []int
    cursors := make([]int, len(in))
    for {
        // Find the array indices that have the smallest
        // and next to smallest value (may be same) at
        // their current cursor.
        minIdx1 := -1
        minIdx2 := -1
        minVal1 := math.MaxInt32
        minVal2 := math.MaxInt32
        for i, cursor := range cursors {
            if cursor >= len(in[i]) {
                continue
            }
            if in[i][cursor] < minVal1 {
                minIdx2 = minIdx1
                minVal2 = minVal1
                minIdx1 = i
                minVal1 = in[i][cursor]
            } else if in[i][cursor] < minVal2 {
                minIdx2 = i
                minVal2 = in[i][cursor]
            }
        }
        if minIdx1 == -1 {
            // no values
            break
        }
        if minIdx2 == -1 {
            // only one array has values, so append the
            // remainder of it to output
            out = append(out, in[minIdx1][cursors[minIdx1]:]...)
            break
        }

        // If inVal1 is smaller than inVal2,
        // append to output all values from minVal1 to minVal2 found in
        // the minIdx1 array, and update the cursor for the minIdx1 array.
        if minVal1 < minVal2 {
            firstCursor := cursors[minIdx1]
            lastCursor := findNext(in[minIdx1], firstCursor, minVal2)
            if lastCursor != -1 {
                out = append(out, in[minIdx1][firstCursor:lastCursor+1]...)
                cursors[minIdx1] = lastCursor+1
                continue
            }
        }
        // Append the single value to output
        out = append(out, minVal1)
        cursors[minIdx1]++
    }
    return out
}

Answer 4

你们能够适应工作。合并利用了将已经分类的清单纳入新的分类清单的方便性。

友情链接