[Swift]LeetCode397. 整数替换 | Integer Replacement

原文地址：https://www.cnblogs.com/strengthen/p/10305720.html 

Given a positive integer n and you can do operations as follow: 

1. If n is even, replace n with n/2.
2. If n is odd, you can replace n with either n + 1 or n - 1. 

What is the minimum number of replacements needed for n to become 1? 

Example 1:

Input:
8

Output:
3

Explanation:
8 -> 4 -> 2 -> 1 

Example 2:

Input:
7

Output:
4

Explanation:
7 -> 8 -> 4 -> 2 -> 1
or
7 -> 6 -> 3 -> 2 -> 1

---

给定一个正整数 n，你可以做如下操作：

1. 如果 n 是偶数，则用 n / 2替换 n。
2. 如果 n 是奇数，则可以用 n + 1或n - 1替换 n。
n 变为 1 所需的最小替换次数是多少？

示例 1:

输入:
8

输出:
3

解释:
8 -> 4 -> 2 -> 1

示例 2:

输入:
7

输出:
4

解释:
7 -> 8 -> 4 -> 2 -> 1
或
7 -> 6 -> 3 -> 2 -> 1

---

8ms

class Solution {
    func integerReplacement(_ n: Int) -> Int {
        var step = 0
        var n = n
        
        while n > 1 {
            if n % 2 == 0{
                n /= 2
            }
            else {
                if n > 3 && n & 3 == 3 {
                    n += 1
                }
                else {
                    n -= 1
                }
            }
            step += 1
        }

        return step
    }
    
    func integerReplacement(_ n: Int, _ step: Int) -> Int {
        if n == 1 {
            return step
        }
        
        if n % 2 == 0 {
            return integerReplacement(n / 2, step + 1)
        }
        
        let step1 = integerReplacement(n+1, step+1)
        let step2 = integerReplacement(n-1, step+1)
        
        return min(step1, step2)
    }
}

---

12ms

class Solution {
    func integerReplacement(_ n: Int) -> Int {
        var fin = n
        var steps = 0
        while fin != 1 {
            if fin % 2 == 0 {
                fin = fin / 2
                steps += 1
            } else {
                steps += 1
                if (fin - 1) / 2 % 2 == 0 || fin - 1 == 2 {
                    fin -= 1
                } else {
                    fin += 1
                }
            }
        }
        return steps
    }
}

---

16ms

class Solution {
    typealias Node = (val: Int, len: Int)
   
    func insert(_ c: inout [Node], _ n: Node) {
        if c.count == 0 { c.append(n); return }
        for i in 0..<c.count {
            if c[i].len > n.len { c.insert(n, at: i); return }
        }
        c.append(n)
    }
    
    func integerReplacement(_ n: Int) -> Int {
        var c: [Int:Int] = [:]
        var d: [Int] = [n]
        c[n] = 0
        if n == 1 { return 0 }
        while true {
            let dold = d
            d = []
            for k in dold {
                let len = c[k]!
                if k % 2 == 1 {
                    // odd
                    let next1 = k - 1
                    let next2 = k + 1
                    if next1 == 1 || next2 == 1 { return len + 1 }
                    if c[next1] == nil { c[next1] = len + 1 }
                    else { c[next1] == min(len + 1, c[next1]!)}
                    if c[next2] == nil { c[next2] = len + 1 }
                    else { c[next2] == min(len + 1, c[next2]!)}
                    if !d.contains(next1) { d.append(next1) }
                    if !d.contains(next2) { d.append(next2) }
                } else {
                    let next = k/2
                    if next == 1 { return len + 1 }
                    if c[next] == nil { c[next] = len + 1 }
                    else { c[next] == min(len + 1, c[next]!)}
                    if !d.contains(next) { d.append(next) }
                }
            }
        }
        
        return 0
    }
}

---

32ms

class Solution {
    func integerReplacement(_ n: Int) -> Int {
        if n <= 1 {
            return 0
        }
        var m = n
        var count = 0
        while m != 1 {
            if (m & 3) == 3 && m != 3 {
                m += 1
            }else if (m & 1) == 1 {
                m -= 1
            }else {
                m = m >> 1
            }
            count += 1
        }
        return  count
    }
}

---

40ms

class Solution {
    func integerReplacement(_ n: Int) -> Int {
        if n == 1 {return 0}
        if n % 2 == 0 {return 1 + integerReplacement(n / 2)}
        else
        {
            var t:Int = n
            return 2 + min(integerReplacement((t + 1) / 2), integerReplacement((t - 1) / 2))
        }

    }
}