Given a string that represents an expression constituting numbers and binary operator +, – and * only. We need to parenthesize the expression in all possible way and return all evaluated values.

Input : expr = “3-2-1” Output : {0, 2} ((3-2)-1) = 0 (3-(2-1)) = 2 Input : expr = "5*4-3*2" Output : {-10, 10, 14, 10, 34} (5*(4-(3*2))) = -10 (5*((4-3)*2)) = 10 ((5*4)-(3*2)) = 14 ((5*(4-3))*2) = 10 (((5*4)-3)*2) = 34

We can solve this problem by parenthesizing all possible valid substring of the expression and then evaluating them, but as we can see that it will involve solving lots of repeating subproblem, to save ourselves we can follow a dynamic programming approach.

We store the result for each substring in a map and if string in recursion is already solved, we return result from map instead of solving that again.

Below code runs a loop in the string and if at any instant, character is operator then we divide the input from there, recursively solve each part and then combine the result in all possible ways.

See the use of c_str() function, this function converts the C++ string into C char array, this function is used in below code because atoi() function expects a character array as an argument not the string. It converts character array to number.

`// C++ program to output all possible values of ` `// an expression by parenthesizing it. ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// method checks, character is operator or not ` `bool` `isOperator(` `char` `op) ` `{ ` ` ` `return` `(op == ` `'+'` `|| op == ` `'-'` `|| op == ` `'*'` `); ` `} ` ` ` `// Utility recursive method to get all possible ` `// result of input string ` `vector<` `int` `> possibleResultUtil(string input, ` ` ` `map< string, vector<` `int` `> > memo) ` `{ ` ` ` `// If already calculated, then return from memo ` ` ` `if` `(memo.find(input) != memo.end()) ` ` ` `return` `memo[input]; ` ` ` ` ` `vector<` `int` `> res; ` ` ` `for` `(` `int` `i = 0; i < input.size(); i++) ` ` ` `{ ` ` ` `if` `(isOperator(input[i])) ` ` ` `{ ` ` ` `// If character is operator then split and ` ` ` `// calculate recursively ` ` ` `vector<` `int` `> resPre = ` ` ` `possibleResultUtil(input.substr(0, i), memo); ` ` ` `vector<` `int` `> resSuf = ` ` ` `possibleResultUtil(input.substr(i + 1), memo); ` ` ` ` ` `// Combine all possible combination ` ` ` `for` `(` `int` `j = 0; j < resPre.size(); j++) ` ` ` `{ ` ` ` `for` `(` `int` `k = 0; k < resSuf.size(); k++) ` ` ` `{ ` ` ` `if` `(input[i] == ` `'+'` `) ` ` ` `res.push_back(resPre[j] + resSuf[k]); ` ` ` `else` `if` `(input[i] == ` `'-'` `) ` ` ` `res.push_back(resPre[j] - resSuf[k]); ` ` ` `else` `if` `(input[i] == ` `'*'` `) ` ` ` `res.push_back(resPre[j] * resSuf[k]); ` ` ` `} ` ` ` `} ` ` ` `} ` ` ` `} ` ` ` ` ` `// if input contains only number then save that ` ` ` `// into res vector ` ` ` `if` `(res.size() == 0) ` ` ` `res.push_back(` `atoi` `(input.c_str())); ` ` ` ` ` `// Store in memo so that input string is not ` ` ` `// processed repeatedly ` ` ` `memo[input] = res; ` ` ` `return` `res; ` `} ` ` ` `// method to return all possible output ` `// from input expression ` `vector<` `int` `> possibleResult(string input) ` `{ ` ` ` `map< string, vector<` `int` `> > memo; ` ` ` `return` `possibleResultUtil(input, memo); ` `} ` ` ` `// Driver code to test above methods ` `int` `main() ` `{ ` ` ` `string input = ` `"5*4-3*2"` `; ` ` ` `vector<` `int` `> res = possibleResult(input); ` ` ` ` ` `for` `(` `int` `i = 0; i < res.size(); i++) ` ` ` `cout << res[i] << ` `" "` `; ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

Output:

-10 10 14 10 34

This article is contributed by **Utkarsh Trivedi**. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Print all possible ways to convert one string into another string | Edit-Distance
- Find all possible ways to Split the given string into Primes
- Form N-copy string with add, remove and append operations
- Count the number of ways to tile the floor of size n x m using 1 x m size tiles
- Count ways to reach the n'th stair
- Count number of ways to reach a given score in a game
- Count possible ways to construct buildings
- Bitmasking and Dynamic Programming | Set 1 (Count ways to assign unique cap to every person)
- Count number of ways to cover a distance
- Count number of ways to partition a set into k subsets
- Bell Numbers (Number of ways to Partition a Set)
- Count number of ways to fill a "n x 4" grid using "1 x 4" tiles
- Ways to arrange Balls such that adjacent balls are of different types
- Count number of ways to reach destination in a Maze
- Ways to write n as sum of two or more positive integers
- Count ways to increase LCS length of two strings by one
- Count number of ways to jump to reach end
- Ways to sum to N using array elements with repetition allowed
- Ways of transforming one string to other by removing 0 or more characters
- Count ways to build street under given constraints