[Swift]LeetCode1187. 使数组严格递增 | Make Array Strictly Increasing

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（www.zengqiang.org）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/11484999.html
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

Given two integer arrays arr1 and arr2, return the minimum number of operations (possibly zero) needed to make arr1 strictly increasing.

In one operation, you can choose two indices 0 <= i < arr1.length and 0 <= j < arr2.length and do the assignment arr1[i] = arr2[j].

If there is no way to make arr1 strictly increasing, return -1.

 

Example 1:

Input: arr1 = [1,5,3,6,7], arr2 = [1,3,2,4]
Output: 1
Explanation: Replace 5 with 2, then arr1 = [1, 2, 3, 6, 7].

Example 2:

Input: arr1 = [1,5,3,6,7], arr2 = [4,3,1]
Output: 2
Explanation: Replace 5 with 3 and then replace 3 with 4. arr1 = [1, 3, 4, 6, 7].

Example 3:

Input: arr1 = [1,5,3,6,7], arr2 = [1,6,3,3]
Output: -1
Explanation: You can't make arr1 strictly increasing.

 

Constraints:

• 1 <= arr1.length, arr2.length <= 2000
• 0 <= arr1[i], arr2[i] <= 10^9

---

给你两个整数数组 arr1 和 arr2，返回使 arr1 严格递增所需要的最小「操作」数（可能为 0）。

每一步「操作」中，你可以分别从 arr1 和 arr2 中各选出一个索引，分别为 i 和 j，0 <= i < arr1.length 和 0 <= j < arr2.length，然后进行赋值运算 arr1[i] = arr2[j]。

如果无法让 arr1 严格递增，请返回 -1。

 

示例 1：

输入：arr1 = [1,5,3,6,7], arr2 = [1,3,2,4]
输出：1
解释：用 2 来替换 5，之后 arr1 = [1, 2, 3, 6, 7]。

示例 2：

输入：arr1 = [1,5,3,6,7], arr2 = [4,3,1]
输出：2
解释：用 3 来替换 5，然后用 4 来替换 3，得到 arr1 = [1, 3, 4, 6, 7]。

示例 3：

输入：arr1 = [1,5,3,6,7], arr2 = [1,6,3,3]
输出：-1
解释：无法使 arr1 严格递增。

 

提示：

• 1 <= arr1.length, arr2.length <= 2000
• 0 <= arr1[i], arr2[i] <= 10^9

---

Runtime: 644 ms

Memory Usage: 50.4 MB

class Solution {
    func makeArrayIncreasing(_ arr1: [Int], _ arr2: [Int]) -> Int {
        let len1:Int = arr1.count
        var arr2 = arr2.sorted(by:<)
        arr2.append(-1)
        var ar:[Int] = [Int]()
        for i in 0..<(arr2.count - 1)
        {
            if arr2[i] != arr2[i + 1]
            {
                ar.append(arr2[i])
            }
        }
        arr2 = ar
        let len2:Int = arr2.count
        var f:[[Int]] = [[Int]](repeating:[Int](repeating:0,count:2002),count:2002)
        for i in 0..<len1
        {
            for j in 0...len2
            {
                f[i][j] = 10000000
                f[i][j] = 10000000
            }
        }
        for j in 0...len2
        {
            f[0][j] = 1
        }
        f[0][0] = 0
        for i in 1..<len1
        {
            if arr1[i] > arr1[i - 1]
            {
                f[i][0] = min(f[i][0], f[i - 1][0])
            }
            var l:Int = 0
            var r:Int = len2 - 1
            var ind:Int = -1
            while(l <= r)
            {
                var mid:Int = (l + r) / 2
                if arr2[mid] < arr1[i]
                {
                    l = mid + 1
                    ind = mid
                }
                else
                {
                    r = mid - 1
                }
            }
            if ind != -1
            {
                f[i][0] = min(f[i][0], f[i - 1][ind + 1])
            }
            for j in 1...len2
            {
                if arr2[j - 1] > arr1[i - 1]
                {
                    f[i][j] = min(f[i][j], f[i - 1][0] + 1)
                }
                if j > 1
                {
                    f[i][j] = min(f[i][j], f[i - 1][j - 1] + 1)
                }
            }
        }
        var ans:Int = f[len1 - 1][0];
        for j in 1...len2
        {
            ans = min(ans, f[len1 - 1][j])
        }
        return ans == 10000000 ? -1 : ans
    }
}

---

696ms

class Solution {
    func makeArrayIncreasing(_ arr1: [Int], _ arr2: [Int]) -> Int {
        var hash = [Key:Int]()
        let result = _makeArrayIncreasing(arr1, Array(Set(arr2)).sorted(), 0, Int.min, &hash)
        return result != Int.max ? result : -1
    }
    
    func _makeArrayIncreasing(_ arr1: [Int], 
                              _ arr2: [Int], 
                              _ index: Int, 
                              _ currMin: Int,
                              _ hash: inout [Key:Int]) -> Int {
        guard index < arr1.count else { return 0 }
        
        let key = Key(index,currMin)
        if let cached = hash[key] { return cached }
        
        let keepValue = arr1[index] > currMin ? _makeArrayIncreasing(arr1,arr2,index+1,arr1[index],&hash) : Int.max
        
        let swapValue: Int
        let swapIndex = bSearch(arr2, 0, arr2.count-1, currMin)
        
        if swapIndex != -1 {
            let swapRecursion = _makeArrayIncreasing(arr1,arr2,index+1,arr2[swapIndex],&hash)
            if swapRecursion != Int.max {
                swapValue = 1 + swapRecursion
            } else {
                swapValue = Int.max
            }    
        } else {
            swapValue = Int.max
        }
        
        let result = keepValue == Int.max && swapValue == Int.max ? Int.max : min(keepValue, swapValue)
        hash[key] = result
        return result
    }
    
    func bSearch(_ array: [Int], _ min: Int, _ max: Int, _ value: Int) -> Int {
        guard min <= max else { return -1 }
        
        let index = min + (max - min) / 2
        
        if array[index] <= value {
            return bSearch(array,index+1,max,value)
        } 
        else { // array[index] > value
            if index > 0, array[index-1] > value {
                return bSearch(array,min,index-1,value)    
            }
            return index
        }
        
    }
}

struct Key: Hashable {
    let index: Int
    let currMin: Int
    
    init(_ index: Int, _ currMin: Int) {
        self.index = index
        self.currMin = currMin
    }
}

---

712ms

class Solution {
    func makeArrayIncreasing(_ arr1: [Int], _ arr2: [Int]) -> Int {    
       let n1 = arr1.count
        let s2 = Set<Int>(arr2)
        var a3 = Array(s2)
        a3 = a3.sorted()
        let n3 = a3.count

        var dp = [[Int]](repeating: [Int](repeating: Int.max/2, count: n3), count: n1)
        var dp1 = [Int](repeating: Int.max/2, count: n1)
        for i in 0..<n3 {
            dp[0][i] = (arr1[0] != a3[i] ? 1 : 0)
        }
        dp1[0] = 0

        for i in 1..<n1 {
            var cur = dp[i-1][0]
            for j in 1..<n3 {
                dp[i][j] = min(dp[i][j], cur + (arr1[i] != a3[j] ? 1 : 0))
                cur = min(cur, dp[i-1][j])
            }

            for j in 0..<n3 {
                if a3[j] > arr1[i-1] {
                    dp[i][j] = min(dp[i][j], dp1[i-1] + (arr1[i] != a3[j] ? 1 : 0))
                }
            }

            for j in 0..<n3 {
                if a3[j] < arr1[i] {
                    dp1[i] = min(dp1[i], dp[i - 1][j])
                }
            }

            if arr1[i - 1] < arr1[i] {
                dp1[i] = min(dp1[i], dp1[i - 1])
            }

        }

        var res = Int.max/2
        for i in 0..<n3 {
            if dp[n1-1][i] >= 0 {
                res = min(res, dp[n1-1][i])
            }
        }
        if dp1[n1 - 1] >= 0 {
            res = min(res, dp1[n1 - 1])
        }
        return res >= Int.max/2 ? -1 : res
    }
}