递归专项- 记忆化搜索397. 整数替换-优快云博客

本文链接：https://blog.youkuaiyun.com/zhangkai1992/article/details/121447464

该博客讨论了一个关于正整数n通过偶数除法或奇数加减1达到1的最小替换次数问题。文章指出在递归解决方案中可能出现的数据溢出问题，并提出了一种优化策略：当n为奇数时，通过计算1+(n-1)/2来避免溢出。给出了相应的Java代码实现，并展示了如何利用已计算过的值存储在映射中以减少重复计算。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目

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

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

示例 1：

输入：n = 8
输出：3
解释：8 -> 4 -> 2 -> 1
示例 2：

输入：n = 7
输出：4
解释：7 -> 8 -> 4 -> 2 -> 1
或 7 -> 6 -> 3 -> 2 -> 1
示例 3：

输入：n = 4
输出：2
提示：

1 <= n <= 231 - 1

改题即使用常规的递归即可解决问题，不过需要注意这里面可能会出现数据溢出的问题，所以当n是奇数，使用n+1的时候，非常容易出现溢出问题。那这时候我们应该怎么解决呢？
如归n是奇数，那么n+1一定是偶数，那么再下面一次就一定是执行(n+1)/2，为了保证不溢出，怎么计算(n + 1)/ 2

（n + 1)/ 2 = 1 + (n-1) / 2, 这样就可以确保数据不会溢出了。

代码如下：

public int integerReplacementDgV2(int n, Map<Integer, Integer> map) {

            if (n == 1) {
                map.put(n, 0);
                return 0;
            }

            long yushu = n % 2;
            int sumOdd = 0;
            int sumJishu1 = 0;
            int sumJishu2 = 0;
            if (yushu == 0) {
                sumOdd += 1;
                if (map.get(n / 2) != null) {
                    sumOdd += map.get(n / 2);
                } else {
                    sumOdd += integerReplacementDgV2(n / 2, map);
                }
                map.put(n, sumOdd);
                return sumOdd;
            }
            sumJishu1 += 2;
            if (map.get(1 + (n-1)/2) != null) {
                sumJishu1 += map.get(1 + (n-1)/2);
            } else {
                sumJishu1 += integerReplacementDgV2(1 + (n-1)/2, map);
            }

            sumJishu2 += 2;
            if (map.get((n - 1)/2) != null) {
                sumJishu2 += map.get((n - 1)/2);
            } else {
                sumJishu2 += integerReplacementDgV2((n - 1)/2, map);
            }

            int min = Math.min(sumJishu1, sumJishu2);
            map.put(n, min);
            return min;
        }