[leetcode]397. Integer Replacement

[leetcode]397. Integer Replacement第四次周赛第二题

Given a positive integer n and you can do operations as follow:If n is even, replace n with n/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:8Output:3Explanation:8 -> 4 -> 2 -> 1Example 2:Input:7Output:4Explanation:7 -> 8 -> 4 -> 2 -> 1or7 -> 6 -> 3 -> 2 -> 1

这题很多人拿到手都是觉得直接递归就好，我也是，直接写出递归算法如下：

int integerReplacement(int n) {    if (n == 1) return 0;    if (n % 2 == 0) return 1 + integerReplacement(n/2);    else {        if (n == INT_MAX) return 1 + integerReplacement(n-1);        else return min(1+integerReplacement(n+1), 1+integerReplacement(n-1));    }}

可是这个是不对的，在INT_MAX上是错的，这样算出来是33步，而实际应该是32步。这里我犯的错误就是，任何数都可以加一减一，这个处理规律不应该也受到integer边界的限制。而事实上，INT一共32位，除去符号位，最大值就是31个1，也就是2^31-1，所以INT_MAX加1就是2^31，连续除以31次2，直接就是1了，一共32步，这么走才是最快的。所以这里使用递归的时候，单独处理INT_MAX可以如下：

 int integerReplacement(int n) {    if (n == 1) {        return 0;    } else if (n == 2147483647) {        return 2 + integerReplacement((n >> 1) + 1);    }    if (n % 2 == 0) {        return integerReplacement(n >> 1) + 1;    }    else {        return min(integerReplacement(n + 1) + 1, integerReplacement(n - 1) + 1);    }}

这样就对了。再没有办法先加一，可以先除二再加一，结果是一样的。同时这种讨论也让人发现，其实当n为奇数的时候，也不是非要同时计算n+1和n-1的可能后果，可以通过一些预判减少后面的计算，避免计算量指数化发展。从二进制的角度出发，考虑连续的最后两位，如果是奇数可能是01或者11，这两种情况是可以知道怎么做最快的，要点就是如何更快的做更多的除法，显然，01应该减一，11应该加一，效果不言而喻。从这一点来说，我们可以将递归调整为如下：

public:     int integerReplacement(int n) {        if (n == 1) {            return 0;        } else if (n == INT_MAX) {            return 2 + integerReplacement((n >> 1) + 1);        }        if (n % 2 == 0) {            return integerReplacement(n >> 1) + 1;        }        else {            return numTrailingOnes(n) > 1 ? integerReplacement(n + 1) + 1 : integerReplacement(n - 1) + 1;        }    }private:     int numTrailingOnes(int num) {        int shift = 0;        while (((num >> shift) & 1) == 1) {            shift++;        }        return shift;    }

这样的调整在时间上节省了很多的计算，十分必要。

当然这种用递归做子问题有很多重叠的时候，动态规划dynamic programming经常被拿出来用，这里也可以很方便的写出，如下：

int integerReplacement(int n) {    int dp[n + 1];    dp[0] = 0;    dp[1] = 0;    for (int i = 2; i <= n; i++) {    if (i % 2 == 0) {    dp[i] = dp[i / 2] + 1;    }    else {       if (i == INT_MAX) dp[i] = 2 + dp[i/2+1];    dp[i] = min(dp[i - 1], dp[(i + 1) / 2] + 1) + 1;    }    }    return dp[n];}

可这在百万千万级的时候就肯定超内存了，dp的方法不太适合这种大范围整数的问题，大家自行体会。