leecode 解题总结：241. Different Ways to Add Parentheses

#include <iostream>
#include <stdio.h>
#include <vector>
#include <string>
using namespace std;
/*
问题:
Given a string of numbers and operators, return all possible results from computing all the different possible ways to group numbers and operators. The valid operators are +, - and *.


Example 1
Input: "2-1-1".

((2-1)-1) = 0
(2-(1-1)) = 2
Output: [0, 2]


Example 2
Input: "2*3-4*5"

(2*(3-(4*5))) = -34
((2*3)-(4*5)) = -14
((2*(3-4))*5) = -10
(2*((3-4)*5)) = -10
(((2*3)-4)*5) = 10
Output: [-34, -14, -10, -10, 10]

分析:题目给定一个表达式，通过添加括号的方式来使得生成不同的结果.
返回所有结果，可能存在相同的结果
发现规律：如果是n个数，有n-1个操作符，那么只需要n-1对括号来对每一个操作进行添加括号。
那么问题转化为：究竟如何添加括号的问题，具体是在什么位置上添加括号。
还有一个难点是：n-1对括号生成多少种操作，不一定是n-1种

输入:
2-1-1
2*3-4*5
输出:
0 2
-34 -14 -10 -10 10

关键：
1 参考leecode:https://discuss.leetcode.com/topic/19901/a-recursive-java-solution-284-ms/2 的解法
是遍历所有符号，对于每一个符号，把前面部分结果和后面部分结果，进行笛卡尔积运算。
本质上就是递归，只不过递归每次选择的符号位置不同。递归到最后传入的是一个数字【牛逼】，就把
该数字直接作为结果集返回，用于后续计算。
2对符号的不同处理，不需要强行去添加括号，因为对于符号不同的计算先后顺序=添加括号的作用
*/

class Solution {
public:
    vector<int> diffWaysToCompute(string input) {
		vector<int> results;
        if(input.empty())
		{
			return results;
		}
		int size = input.size();
		string left;
		string right;
		vector<int> leftResult;
		vector<int> rightResult;
		int leftSize = 0;
		int rightSize = 0;
		//以符号分割成左右部分，分别继续递归处理，并计算
		for(int i = 0 ; i < size ; i++)
		{
			if('+' == input.at(i) || '-' == input.at(i) || '*' == input.at(i))
			{
				left = input.substr( 0 , i);
				right = input.substr(i + 1 , size - i - 1);
				//递归处理左右部分
				leftResult = diffWaysToCompute(left);
				rightResult = diffWaysToCompute(right);
				//返回空结果
				if(leftResult.empty() || rightResult.empty())
				{
					return vector<int>();
				}
				leftSize = leftResult.size();
				rightSize = rightResult.size();
				for(int j = 0 ; j < leftSize ; j++)
				{
					for(int k = 0 ; k < rightSize ; k++)
					{
						if('+' == input.at(i))
						{
							results.push_back(leftResult.at(j) + rightResult.at(k));
						}
						else if('-' == input.at(i))
						{
							results.push_back(leftResult.at(j) - rightResult.at(k));
						}
						if('*' == input.at(i))
						{
							results.push_back(leftResult.at(j) * rightResult.at(k));
						}
					}
				}//左右部分结果遍历结束
			}//符号遍历结束
		}//字符串遍历结束
		//如果只有数字，直接压入，后续处理
		if(results.empty())
		{
			results.push_back(atoi(input.c_str()));
		}
		return results;
    }
};

void print(vector<int>& result)
{
	if(result.empty())
	{
		cout << "no result" << endl;
		return;
	}
	int size = result.size();
	for(int i = 0 ; i < size ; i++)
	{
		cout << result.at(i) << " " ;
	}
	cout << endl;
}

void process()
{
	 vector<int> nums;
	 string expression;
	 Solution solution;
	 vector<int> result;
	 while(cin >> expression )
	 {
		 result = solution.diffWaysToCompute(expression);
		 print(result);
	 }
}

int main(int argc , char* argv[])
{
	process();
	getchar();
	return 0;
}