力扣553

553. 最优除法

给定一组正整数，相邻的整数之间将会进行浮点除法操作。例如， [2,3,4] -> 2 / 3 / 4 。

但是，你可以在任意位置添加任意数目的括号，来改变算数的优先级。你需要找出怎么添加括号，才能得到最大的结果，并且返回相应的字符串格式的表达式。你的表达式不应该含有冗余的括号。

示例：

输入: [1000,100,10,2]
输出: "1000/(100/10/2)"
解释:
1000/(100/10/2) = 1000/((100/10)/2) = 200
但是，以下加粗的括号 "1000/((100/10)/2)" 是冗余的，
因为他们并不影响操作的优先级，所以你需要返回 "1000/(100/10/2)"。

其他用例:
1000/(100/10)/2 = 50
1000/(100/(10/2)) = 50
1000/100/10/2 = 0.5
1000/100/(10/2) = 2

这题我一开始以为是个数学题，过了之后看题解发现还可以动态规划。不过能用数学方法解还是更好啦，那个动态规划代码又臭又长，时间复杂度更是突破天际，我劝你善良……

这玩意就是要给一个算式加括号，让最后得到的结果最大。

而想要让除法的结果最大，只需要让被除数尽量大，除数尽量小。观察测试用例，很容易发现只需要让第一个数当被除数，剩下的数相除的结果当除数即可。

至于除数部分的括号，答案是一个也不用加。可以举个例子：

20/10/2，结果是1，而假如在10/2两边加了括号，相当于减小了这个式子的除数，增大了该式的结果。20/（10/2）=20/5=4。

这很好想，不过尽量说的详细一点吧，毕竟来搜题解的都是官方题解看不懂的？

以下是完整代码：

class Solution {
public:
    string optimalDivision(vector<int>& nums) {
        int n=nums.size();
        string ans;
        if(n==1){
            ans=to_string(nums[0]);
        }
        else if(n==2){
            ans=to_string(nums[0])+"/"+to_string(nums[1]);
        }
        else{
            ans=to_string(nums[0])+"/(";
            for(int i=1;i<n-1;++i){
                ans.append(to_string(nums[i]));
                ans.append("/");
            }
            ans.append(to_string(nums[n-1])+")");
        }

        return ans;
    }
};

另外附上官方的dp代码，可以比较一下复杂度：

struct Node {
    double maxVal, minVal;
    string minStr, maxStr;
    Node() {
        this->minVal = 10000.0;
        this->maxVal = 0.0;
    }
};

class Solution {
public:
    string optimalDivision(vector<int>& nums) {
        int n = nums.size();
        vector<vector<Node>> dp(n, vector<Node>(n));

        for (int i = 0; i < n; i++) {
            dp[i][i].minVal = nums[i];
            dp[i][i].maxVal = nums[i];
            dp[i][i].minStr = to_string(nums[i]);
            dp[i][i].maxStr = to_string(nums[i]);
        }
        for (int i = 1; i < n; i++) {
            for (int j = 0; j + i < n; j++) {
                for (int k = j; k < j + i; k++) {
                    if (dp[j][j + i].maxVal < dp[j][k].maxVal / dp[k + 1][j + i].minVal) {
                        dp[j][j + i].maxVal = dp[j][k].maxVal / dp[k + 1][j + i].minVal;
                        if (k + 1 == j + i) {
                            dp[j][j + i].maxStr = dp[j][k].maxStr + "/" + dp[k + 1][j + i].minStr;
                        } else {
                            dp[j][j + i].maxStr = dp[j][k].maxStr + "/(" + dp[k + 1][j + i].minStr + ")";
                        }
                    }
                    if (dp[j][j + i].minVal > dp[j][k].minVal / dp[k + 1][j + i].maxVal) {
                        dp[j][j + i].minVal = dp[j][k].minVal / dp[k + 1][j + i].maxVal;
                        if (k + 1 == j + i) {
                            dp[j][j + i].minStr = dp[j][k].minStr + "/" + dp[k + 1][j + i].maxStr; 
                        } else {
                            dp[j][j + i].minStr = dp[j][k].minStr + "/(" + dp[k + 1][j + i].maxStr + ")"; 
                        }
                    }
                }
            }
        }
        return dp[0][n - 1].maxStr;
    }
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/optimal-division/solution/zui-you-chu-fa-by-leetcode-solution-lf4c/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。