2021-07-20：最小区间。你有 k 个 非递减排列 的整数列表。找到一个 最小 区间，使得 k 个列表中的每个列表至少有一个数包含在其中。我们定义如果 b-a ＜ d-c 或者在 b-a ==

2021-07-20：最小区间。你有 k 个 非递减排列 的整数列表。找到一个 最小 区间，使得 k 个列表中的每个列表至少有一个数包含在其中。我们定义如果 b-a < d-c 或者在 b-a == d-c 时 a < c，则区间 [a,b] 比 [c,d] 小。

福大大 答案2021-07-20：

[[4,10,15,24,26], [0,9,12,20], [5,18,22,30]]
有序表：0,4,5。序号： 1,1,1。有序表差值为5。
有序表：4,5,9。序号：1,2,1。有序表差值为5。
有序表：5,9,10。序号：2,2,1。有序表差值为5。
有序表：9,10,18。序号：2,2,2。有序表差值为9。
有序表：10,12,18。序号：2,3,2。有序表差值为8。
有序表：12,15,18。序号：3,3,2。有序表差值为6。
有序表：15,18,20。序号：3,4,2。有序表差值为5。
有序表：18,20,24。序号：4,4,2。有序表差值为6。
有序表：20,22,24。序号：4,4,3。有序表差值为4。差值最小，这个就是需要的返回值。
有序表：x,22,24。序号：5,4,3。结束了。

代码用golang编写。代码如下：

package main

import (

    "fmt"

    "sort"

)

func main() {

    nums := [][]int{{4, 10, 15, 24, 26}, {0, 9, 12, 20}, {5, 18, 22, 30}}

    ret := smallestRange(nums)

    fmt.Println(ret)

}

type Node struct {

    value int

    arrid int

    index int

}

func smallestRange(nums [][]int) []int {

    N := len(nums)

    orderSet := make([]*Node, 0)

    for i := 0; i < N; i++ {

        orderSet = append(orderSet, &Node{nums[i][0], i, 0})

    }

    set := false

    a := 0

    b := 0

    for len(orderSet) == N {

        sort.Slice(orderSet, func(i, j int) bool {

            if orderSet[i].value != orderSet[j].value {

                return orderSet[i].value < orderSet[j].value

            } else {

                return orderSet[i].arrid < orderSet[j].arrid

            }

        })

        min := orderSet[0]

        max := orderSet[len(orderSet)-1]

        if !set || (max.value-min.value < b-a) {

            set = true

            a = min.value

            b = max.value

        }

        min = orderSet[0]

        orderSet = orderSet[1:]

        arrid := min.arrid

        index := min.index + 1

        if index != len(nums[arrid]) {

            orderSet = append(orderSet, &Node{nums[arrid][index], arrid, index})

        }

    }

    return []int{a, b}

}

执行结果如下：

左神java代码

2021-07-20：最小区间。你有 k 个 非递减排列 的整数列表。找到一个 最小 区间，使得 k 个列表中的每个列表至少有一个数包含在其中。我们定义如果 b-a ＜ d-c 或者在 b-a ==的相关教程结束。