leetcode 321 拼接最大数

解法没什么好说的, 用set记录一下已经遍历过的下标组合, 避免重复遍历导致需要遍历的候选下标对无限膨胀。

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @param {number} k
 * @return {number[]}
 */
let numso1 = undefined
let numso2 = undefined
let ko = undefined
var maxNumber = function(nums1, nums2, k) {
    numso1 = [...nums1]
    numso2 = [...nums2]
    nums1.length = 0
    nums2.length = 0
    ko = k
    return bfs()
};

function findMaxIdx(nums, idx, len) {
    let end = nums.length - len
    let maxIdx = idx
    for(let i = idx; i < end; i++) {
        if(nums[i] > nums[maxIdx]) maxIdx = i
    }
    return maxIdx
}

function bfs(k){
    let pairs = [[0, 0]]
    let ans = []
    const set = new Set()
    while(ko > 0) {
        let arr = []
        let maxNum = -2
        for(let pi= 0; pi < pairs.length; pi++) {
            let p = pairs[pi]
            let key = `${p[0]}:${p[1]}`
            if(set.has(key)) continue
            set.add(key)
            let idx1 = p[0]
            let idx2 = p[1]
            let len1 = Math.max(0, ko - (numso2.length - idx2) - 1)
            let maxIdx1 = findMaxIdx(numso1, idx1, len1)
            let maxNum1 = maxIdx1 < numso1.length ? numso1[maxIdx1] : -1
            if(maxNum1 > maxNum) {
                arr.length = 0
                maxNum = maxNum1
                arr = [[maxIdx1 + 1, idx2]]
            } else if(maxNum1 === maxNum) {
                arr.push([maxIdx1 + 1, idx2])
            }


            let len2 = Math.max(0, ko - (numso1.length - idx1) - 1)
            let maxIdx2 = findMaxIdx(numso2, idx2, len2)
            let maxNum2 = maxIdx2 < numso2.length ? numso2[maxIdx2] : -1
            if(maxNum2 > maxNum) {
                maxNum = maxNum2
                arr.length = 0
                arr = [[idx1, maxIdx2 + 1]]
            } else if(maxNum2 === maxNum) {
                arr.push([idx1, maxIdx2 + 1])
            }
        }
        ans.push(maxNum)
        pairs.length = 0
        pairs = [...arr]
        arr.length = 0
        ko--
    }
    return ans
}