【算法】分治算法

算法思路

分治算法
分治问题由“分”（divide）和“治”（conquer）两部分组成，通过把原问题分为子问题，再将子问题进行处理合并，从而实现对原问题的求解。我们在排序章节展示的归并排序就是典型的分治问题。
其中“分”即为把大数组平均分成两个小数组，通过递归实现，最终我们会得到多个长度为 1 的子数组；“治”即为把已经排好序的两个小数组合成为一个排好序的大数组，从长度为 1 的子数组开始，最终合成一个大数组。

例题

例1 LeetCode:实现加括号获取结果数

题目描述

给定一个只包含加、减和乘法的数学表达式，求通过加括号可以得到多少种不同的结果。

输入输出样例

输入是一个字符串，表示数学表达式；输出是一个数组，存储所有不同的加括号结果

Input: “2-1-1”
Output: [0, 2]
在这个样例中，有两种加括号结果：((2-1)-1) = 0 和 (2-(1-1)) = 2。

题解1 分治

利用分治思想，我们可以把加括号转化为，对于每个运算符号，先执行处理两侧的数学表达式，再处理此运算符号。注意边界情况，即字符串内无运算符号，只有数字。

vector<int> diffWaysToCompute(string input) {
	vector<int> ways;
	for (int i = 0; i < input.length(); i++) {
		char c = input[i];
		if (c == ’+’ || c == ’-’ || c == ’*’)* {
		//substr函数第一个参数是位置,第二个参数是个数(若没有,则从该位置到末尾)
			vector<int> left = diffWaysToCompute(input.substr(0, i));
			vector<int> right = diffWaysToCompute(input.substr(i + 1));
			for (const int & l: left) {
					for (const int & r: right) {
							switch (c) {
								case ’+’: ways.push_back(l + r); break;
								case ’-’: ways.push_back(l - r); break;
								case ’’: ways.push_back(l * r); break;
							}
					}
			}
		}
	}
	if (ways.empty()) //如果是常数就得到这个数值
		ways.push_back(stoi(input));//将n进制的字符串转化为十进制,stoi(字符串，起始位置，几进制)；
	return ways;
}

我们发现，某些被 divide 的子字符串可能重复出现多次，因此我们可以用 memoization（记忆化） 来去重。或者与其我们从上到下用分治处理 +memoization，不如直接从下到上用动态规划处理。

题解2 动态规划

vector<int> diffWays(string input){
        vector<int> data;
        vector<char> ops;
        int num=0;
        char op=' ';
        istringstream ss(input+"+");
//istringstream对象可以绑定一行字符串，然后以空格为分隔符把该行分隔开来。
        while(ss>>num && ss>>op){
            data.push_back(num);
            ops.push_back(op);
        }
        int n=data.size();//个数

        vector<vector<vector<int>>> dp(n,vector<vector<int>>(n,vector<int>()));
				//三维数组 dp(n,二维数组(n,一维数组))	
//不定数量的vector保存可能的结果；n个vector放不定数量的vector表示这中间加不同的括号会有不同的值
//n个vector<vector<int>>表示0到0,,...,n之间的结果
        for(auto i=0;i<n;i++){//对每一个数字遍历
            for(auto j=i;j>=0;j--){//对该数字前的每一个数字遍历
                if(i==j)//如果相等，递归长度为1，保存这个结果，即这个数字
                    dp[j][i].push_back(data[i]);
                else{
                     for(auto k=j;k<i;k++){//遍历j到i之间的数字
                        for(auto left:dp[j][k]){//左边是j-k的递归结果
                            for(auto right:dp[k+1][i]){//右边的递归结果
                                int val=0;
                                switch (ops[k]){
                                    case '+':val=left+right;break;
                                    case '-':val=left-right;break;
                                    case '*':val=left*right;break;
                                }
                                dp[j][i].push_back(val);                         
                            }
                        }
                    }
                }
            }
        }
        return dp[0][n-1];//保存了两次结果，所以最后是2
    }

完整程序

#include <iostream>
#include <vector>
#include <string>
#include <sstream>  //istringstream
 
using namespace std;
 
class Solution{
public:
    vector<int> diffWaysToCompute(string input){
        vector<int> ways;
        for(auto i=0;i<input.length();i++){
            char c=input[i];
            if(c=='+'||c=='-'||c=='*'){
                /*substr函数第一个参数是位置,第二个参数是个数(若没有,则从该位置到末尾)*/
                vector<int> left=diffWaysToCompute(input.substr(0,i));
                vector<int> right=diffWaysToCompute(input.substr(i+1));
                for(const int& l:left){
                    for(const int& r:right){
                        switch(c){
                            case '+':ways.push_back(l+r);break;
                            case '-':ways.push_back(l-r);break;
                            case '*':ways.push_back(l*r);break;
                        }
                    }
                }
            }
        }
 
        if(ways.empty())
           ways.push_back(atoi(input.c_str()));//或者stio(input)
        return ways;
    }
 
    vector<int> diffWays(string input){
        vector<int> data;
        vector<char> ops;
        int num=0;
        char op=' ';
        istringstream ss(input+"+");
        while(ss>>num&&ss>>op){
            data.push_back(num);
            ops.push_back(op);
        }
        int n=data.size();
        vector<vector<vector<int>>> dp(n,vector<vector<int>>(n,vector<int>()));
        for(auto i=0;i<n;i++){
            for(auto j=i;j>=0;j--){
                if(i==j){
                    dp[j][i].push_back(data[i]);
                }else{
                    for(auto k=j;k<i;k++){
                        for(auto left:dp[j][k]){
                            for(auto right:dp[k+1][i]){
                                int val=0;
                                switch (ops[k]){
                                    case '+':val=left+right;break;
                                    case '-':val=left-right;break;
                                    case '*':val=left*right;break;
                                }
                                dp[j][i].push_back(val);                         
                            }
                        }
                    }
                }
            }
        }
        return dp[0][n-1];
 
    }
 
};
 
int main(int argc,char* argv[]){
    string input="2-1-1";
    vector<int> ans=Solution().diffWays(input);
    for(auto& i:ans)
       cout<<i<<" ";
    cout<<endl;
    return 0;
}

ARGc和ARGv中的ARG指的是参数（外语：ARGuments, argument counter 和 argument value ）

至少有两个参数至主函数：ARGc和ARGv；

第一个是提供给主函数的参数个数，

第二个是参数的字符串数组的指针。