动态规划解决LeetCode 964最少运算符问题

1. 问题背景与理解

今天遇到一道有趣的LeetCode题目（编号964），题目要求我们找到用最少的运算符表达特定数字的方法。具体来说，给定一个目标值target和基础值x，我们需要用x的幂次（如x^0, x^1, x^-1, x^2等）通过加减乘除运算组合出target，同时要求使用的运算符数量最少。

这个问题看似简单，但深入思考后发现它涉及动态规划、数学推导和边界条件处理等多个方面。我在解题过程中踩了不少坑，也总结出一些实用的优化技巧，下面就把完整的解题思路和实现过程分享给大家。

2. 核心思路解析

2.1 问题重述与示例分析

首先明确题目要求：给定整数x和target，我们可以使用x的整数次幂（包括负指数）和加减乘除运算符来构造表达式，目标是找到使用运算符数量最少的表达式。

举个例子：

• x=3, target=19
• 最优解：33+33+3/3（共5个运算符）
• 解释：33是x^1x^1=9，两个9相加得18，再加3/3=1，总共使用了5个运算符（两个乘号、一个加号、一个除号和一个加号）

2.2 关键观察点

通过分析发现几个重要性质：

1. 任何target都可以表示为x的各次幂的线性组合
2. 运算符数量与幂次的选择和组合方式密切相关
3. 高次幂可以减少运算符数量，但可能增加余数处理的复杂度

2.3 动态规划思路

这个问题适合用动态规划解决，因为：

• 具有最优子结构：整体最优解包含子问题最优解
• 存在重叠子问题：不同路径可能到达相同的中间状态
• 无后效性：当前决策只影响后续状态，不影响之前状态

定义dp[t]表示表示数字t所需的最少运算符数量。状态转移需要考虑：

1. 直接用x^k表示t（当t是x的幂次时）
2. 用x^k加上余数表示（t = c*x^k + r）
3. 用x^(k+1)减去余数表示（t = x^(k+1) - r）

3. 算法实现细节

3.1 递归关系建立

基于上述观察，可以建立递归关系：

c复制int leastOpsExpressTarget(int x, int target) {
    if (target == 0) return 0;
    if (target == 1) return 1;  // x/x or x^0
    
    int k = log(target) / log(x);
    int power = pow(x, k);
    
    if (power == target) {
        return k == 0 ? 1 : k - 1;
    }
    
    int option1 = k + leastOpsExpressTarget(x, target - power);
    int option2 = (k + 1) + leastOpsExpressTarget(x, power * x - target);
    
    return min(option1, option2) + (k == 0 ? 1 : 0);
}

3.2 边界条件处理

几个关键边界需要注意：

1. target=0：直接返回0（不需要运算符）
2. target=1：需要1个运算符（x/x或x^0）
3. x=1：所有幂次都是1，需要特殊处理
4. k=0：表示使用x^0=1，需要额外运算符

3.3 记忆化优化

原始递归会有大量重复计算，需要添加记忆化：

c复制#define MAX_TARGET 1000000
int memo[MAX_TARGET];

int leastOpsExpressTarget(int x, int target) {
    if (target < MAX_TARGET && memo[target] != -1) {
        return memo[target];
    }
    
    // ...原有逻辑...
    
    if (target < MAX_TARGET) {
        memo[target] = result;
    }
    return result;
}

4. 完整C语言实现

4.1 预处理与辅助函数

c复制#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

#define min(a,b) ((a)<(b)?(a):(b))
#define MAX_TARGET 1000000

int memo[MAX_TARGET];

void initMemo() {
    memset(memo, -1, sizeof(memo));
    memo[0] = 0;
    memo[1] = 1;
}

4.2 主函数实现

c复制int leastOpsExpressTarget(int x, int target) {
    if (x == 1) {
        return target - 1; // 1+1+...+1 (target-1 operators)
    }
    
    if (target < MAX_TARGET && memo[target] != -1) {
        return memo[target];
    }
    
    int k = log(target) / log(x);
    int power = pow(x, k);
    
    while (power > target) {
        k--;
        power = pow(x, k);
    }
    
    if (power == target) {
        int res = (k == 0) ? 1 : (k - 1);
        if (target < MAX_TARGET) memo[target] = res;
        return res;
    }
    
    int option1 = (k == 0 ? 1 : k) + leastOpsExpressTarget(x, target - power);
    int option2 = (k + 1) + leastOpsExpressTarget(x, power * x - target);
    
    int result = min(option1, option2);
    if (target < MAX_TARGET) {
        memo[target] = result;
    }
    return result;
}

4.3 测试用例

c复制int main() {
    initMemo();
    
    printf("x=3, target=19: %d\n", leastOpsExpressTarget(3, 19)); // Expected: 5
    printf("x=5, target=501: %d\n", leastOpsExpressTarget(5, 501)); // Expected: 8
    printf("x=100, target=100000000: %d\n", leastOpsExpressTarget(100, 100000000)); // Expected: 3
    
    return 0;
}

5. 复杂度分析与优化

5.1 时间复杂度

原始递归：O(2^n)
记忆化后：O(n) （n为target大小）
实际运行：由于k的取值限制，实际复杂度约为O(log n)

5.2 空间复杂度

记忆化数组：O(n)
递归栈：O(log n)

5.3 进一步优化方向

1. 迭代法代替递归：避免栈溢出风险
2. 数学优化：对于x^k接近target的情况，可以提前终止
3. 预处理x的幂次：避免重复计算pow(x,k)

6. 常见问题与调试技巧

6.1 典型错误案例

1. 忽略x=1的特殊情况：

   • 错误表现：无限递归或错误结果
   • 解决方法：单独处理x=1的情况

2. 浮点数精度问题：

   • log和pow可能产生精度误差
   • 解决方法：使用整数运算或添加容错

3. 记忆化数组越界：

   • target过大导致数组访问越界
   • 解决方法：动态分配或使用哈希表

6.2 调试技巧

1. 打印递归路径：

   c复制printf("target=%d, k=%d, power=%d\n", target, k, power);
   

2. 验证中间结果：

   c复制assert(pow(x,k) <= target);
   assert(pow(x,k+1) > target);
   

3. 边界测试：

   • x=2, target=1
   • x=3, target=0
   • x=100, target=100

7. 算法扩展与变种

7.1 支持更多运算符

如果允许使用括号，可以进一步减少运算符数量。例如：

• 原式：33+33+3/3（5个运算符）
• 使用括号：3*(3+3)+3/3（5个运算符，数量相同但结构不同）

7.2 多基数表达式

如果允许使用多个基数（如同时用2和3），问题会变得更加复杂，可能需要使用多维动态规划。

7.3 运算符成本差异

如果不同运算符有不同的成本（如乘法比加法昂贵），需要调整状态转移方程中的成本计算方式。

8. 个人实现心得

在实际编码中，我发现几个关键点值得注意：

1. 幂次计算的准确性：

   • 直接使用log和pow可能因为浮点精度导致错误
   • 我的解决方法是添加while循环修正k值

2. 记忆化大小的选择：

   • 过小的数组会导致大量冲突
   • 过大的数组会浪费内存
   • 折中方案是使用动态扩容的哈希表

3. 运算符计数的细节：

   • x^1直接写作x（0个运算符）
   • x^0需要写作x/x（1个运算符）
   • 这些边界情况需要特别处理

这个题目很好地展示了如何将数学洞察与算法设计相结合。通过分析问题的数学结构，我们可以设计出高效的动态规划解法。同时，实现过程中的各种边界条件和优化技巧也让我对动态规划有了更深的理解。