华为OD统一考试- 推荐多样性

题目描述

推荐多样性需要从多个列表中选择元素，一次性要返回 N 屏数据（窗口数量），每屏展示 K 个元素（窗口大小），选择策略：

1. 各个列表元素需要做穿插处理，即先从第一个列表中为每屏选择一个元素，再从第二个列表中为每屏选择一个元素，依次类推
2. 每个列表的元素尽量均分为 N 份，如果不够 N 个，也要全部分配完，参考样例图：（1）从第一个列表中选择 4 条 0 1 2 3，分别放到 4 个窗口中（2）从第二个列表中选择 4 条 10 11 12 13，分别放到 4 个窗口中（3）从第三个列表中选择 4 条 20 21 22 23，分别放到 4 个窗口中（4）再从第一个列表中选择 4 条 4 5 6 7，分别放到 4 个窗口中   ...（5）再从第一个列表中选择，由于数量不足 4 条，取剩下的 2 条，放到 窗口1 和 窗口2（6）再从第二个列表中选择，由于数量不足 4 条并且总的元素数达到窗口要求，取 18 19 放到 窗口3 和 窗口4

输入描述

第一行输入为 N，表示需要输出的窗口数量，取值范围 [1, 10]

第二行输入为 K，表示每个窗口需要的元素数量，取值范围 [1, 100]

之后的行数不定（行数取值范围 [1, 10]），表示每个列表输出的元素列表。元素之间以空格隔开，已经过排序处理，每个列表输出的元素数量取值范围 [1, 100]

输出描述

输出元素列表，元素数量 = 窗口数量 * 窗口大小，元素之间以空格分隔，多个窗口合并为一个列表输出，参考样例：

先输出窗口1的元素列表，再输出窗口2的元素列表，再输出窗口3的元素列表，最后输出窗口4的元素列表

备注

1. 每个列表会保证元素数量满足窗口要求，不需要考虑元素不足情况
2. 每个列表的元素已去重，不需要考虑元素重复情况
3. 每个列表的元素列表均不为空，不需要考虑列表为空的情况
4. 每个列表的元素列表已经过排序处理，输出结果要保证不改变同一个列表的元素顺序
5. 每个列表的元素数量可能是不同的

用例

题目解析

我们可以将最终的窗口集当成一个矩阵windows，该矩阵有 k 行 n 列，矩阵的每一列对应一个窗口。最终按列打印该矩阵，即为题解。

之后就是根据题目给定规则，往这个windos矩阵中填值即可。

由于填值过程是顺序的，即从左往右，从上往下地向windows矩阵中填值，因此我们可以将windows矩阵一维化，即定义为一维数组，数组长度为 k * n。

这样的话，只需要定义一个指针idx，就可以直到当前该往矩阵的哪个位置填值。

读取列表集的规则是：

从列表集的第一个列表开始读，每次读取n个值填到windows中，

• 如果当前列表的剩余元素个数 >= n，那么该列表读取完n个后，列表中还有剩余元素，即不需要像后面的列表借。
• 如果当前列表剩余元素个数 < n，那么该列表读取完后，还需要像后面的列表借。

需要注意的是，如果发生了“借”的动作，比如下面例子：

5

4

0 1 2 3 4 

5 6 7 8  

9 10 11 12 13 14

15 16 17 18 19 

填充windows矩阵第二行时，由于第二个列表元素不足，因此"借"了第三个列表的元素，

那么下一轮填充windows矩阵第三行时，应该从列表集的第几个列表开始？

我理解应该是从第三个列表开始读，即最终读取出来的windows矩阵如下：

因此，在代码实现时，我们需要注意：

假设我们使用level指针指向当前轮次读取的列表的序号

• 当没有发生“借”动作时，当前列表读取完，我们需要level++
• 当发生了"借"动作时，由于当前列表元素不足，我们需要在读取过程中进行一次level++切到下一个列表借元素，当借完填到windows后，此时我们就不需要再次level++，因为当前已经处于了下一轮要读取的列表上。

import Foundation

func ODTest_2_11() {
    print("输入描述")
    print("第一行输入为 N，表示需要输出的窗口数量，取值范围 [1, 10]")
    let N = Int(readLine() ?? "") ?? 0
    print("第二行输入为 K，表示每个窗口需要的元素数量，取值范围 [1, 100]")
    let K = Int(readLine() ?? "") ?? 0
    print("之后的行数不定（行数取值范围 [1, 10]），表示每个列表输出的元素列表。元素之间以空格隔开，已经过排序处理，每个列表输出的元素数量取值范围 [1, 100]")
    var lists: [[Int]] = []
    while true {
        let data = (readLine() ?? "").split(separator: " ").map { Int($0) ?? 0 }
        if data.isEmpty {
            break
        }
        lists.append(data)
    }
    var windows = Array(repeating: 0, count: K * N)

    var level = 0
    var idx = 0
    while idx < windows.count {
        // 当前轮次是否发生了"借"动作
        var flag = false
        // 从第level个列表中取前n个元素
        for i in 0 ..< N {
            windows[idx] = lists[level].removeFirst()
            idx += 1
            // 如果第level个列表没有元素了，则继续切到下一个列表中"借"
            if lists[level].isEmpty && lists.count > 1 {
                lists.remove(at: level)
                level %= lists.count // 防止越界
                flag = true // 发生了"借"动作
            }
        }
        // 如果没有发生"借"动作，则需要切到下一行
        if !flag {
            level = (level + 1) % lists.count // 防止越界
        }
    }
    var ans: [Int] = []
    for j in 0 ..< N {
        for i in 0 ..< K {
            let index = i * N + j
            ans.append(windows[index])
        }
    }
    print("输出描述")
    print("输出元素列表，元素数量 = 窗口数量 * 窗口大小，元素之间以空格分隔，多个窗口合并为一个列表输出，参考样例：")
    print("先输出窗口1的元素列表，再输出窗口2的元素列表，再输出窗口3的元素列表，最后输出窗口4的元素列表")
    print("\(ans.map { String($0) }.joined(separator: " "))")
}