leecode_241 Different Ways to Add Parentheses

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]

思路是是先建一个struct，三个成员：第一个数，操作符，第二个数。

将string转化成一个struct的vector来处理，比如："2*3-4*5"

就处理为：2*3

                  3-4

                  4*5

变成一个类似排列组合的问题，计算一个struct的时候，更新前后的操作数，使用bfs就能解决；

后来发现会有重复的项存在，比如 先计算第一个操作符，再计算第三个操作符  与  先计算第三个操作符，再计算第一个操作符，相互重复。

所以计算时必须注意不相邻的两项，如果依次计算（或者把顺序反过来），会产生重复项。

解决方法是记录本次更新的位置i，下次更新的时候只更新（i-1，end）中的一个，避免重复项。

c++实现：

class Solution {
public:
    vector<int> diffWaysToCompute(string input) {
       long long first=0;
       char opt='+';
       long long second=0;
       vector<group> temp;
       queue< pair<vector<group>, int> > que;
       vector<int> res;
       
       for (int i=0;i<input.size();i++){
           int j=i;
           for (j;j<input.size();j++){
                    if (0<=input[j]-'0' && input[j]-'0'<=9) 
                           second=second*10+input[j]-'0';
                    else
                        break;
           }
           
            i=j;
            group g;
            g.first=first;
            g.opt=opt;
            g.second=second;
            temp.push_back(g);
            first=second;
            opt=input[i];
            second=0;
       }
       
        //   for (int i=0;i<temp.size();i++)
        //       cout<<temp[i].first<<temp[i].opt<<temp[i].second<<endl;
       
       if (temp.size()>1)
            temp.erase(temp.begin());
       
   
       que.push(make_pair(temp,0));
       
       while (!que.empty()){
           vector<group> top=que.front().first;
           int ind=que.front().second;
           que.pop();
           
           for (int i=ind;i<top.size();i++){
               vector<group> temp=top;
               long long result_of_group;
               if (temp[i].opt=='+')
                   result_of_group=temp[i].first+temp[i].second;
               if (temp[i].opt=='-')
                   result_of_group=temp[i].first-temp[i].second; 
               if (temp[i].opt=='*')
                   result_of_group=temp[i].first*temp[i].second;
               
               if (i!=0)
                   temp[i-1].second=result_of_group;
               if (i!=top.size()-1)
                   temp[i+1].first=result_of_group;
               temp.erase(temp.begin()+i);
               
               if (temp.size()==0)
                   res.push_back(result_of_group);
               else{
                   int ind_temp=max(i-1,0);
                   que.push(make_pair(temp,ind_temp));
               }
               
           }
       }
       
       sort(res.begin(),res.end());
       return res;
       
    }
    
    
    struct group{
        long long first;
        long long second;
        char opt;
    };
};