# Score of Parentheses using Tree

• Difficulty Level : Medium
• Last Updated : 13 Oct, 2021

Given a string str which contains pairs of balanced parentheses, the task is to calculate the score of the given string based on the given rules:

1. “()” has a score of 1.
2. “x y” has a score of x + y where x and y are individual pairs of balanced parentheses.
3. “(x)” has a score twice of x (i.e), the score is 2 * score of x.

Examples:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: str = “()()”
Output:
Explanation:
Here input is of the form “xy” which makes the total score = score of x + score of y
and hence, score = 1 + 1 = 2

Input: str = “(())”
Output:
Explanation:
Here input is of the form “(x)” which makes the total score = 2 * score of x
and hence, score = 2 * 1 = 2

Input: str = “(()()())”
Output:
Explanation:
Here input is of the form “(xyz)” which makes the total score = 2 * (score of x +
score of y + score of z) and hence 2*(1 + 1 + 1) = 6

Approach: The idea is to use a tree data structure to solve this problem along with Recursion.

• The root node of our tree structure will represent the outermost pair of our input parentheses.
• For every pair of balanced parentheses included inside the outermost parentheses, we will add a child to our root node.
• This process of declaring a child to a root node will be recursive and hence it will create a node in our tree structure for every pair of balanced parentheses in a hierarchy.
• Every balanced pair of parentheses will be considered as outermost (recursively) and generate a node and hence will allow us to calculate the score.
• When computing score, each leaf node of our tree will be considered with a score of 1 and to get the score of its respective root node we need to add the scores of each child node and double that aggregate.
• The diagram below shows the recursive structure of the tree generated and we start from the bottom to calculate the scores at each level until we reach the outermost ending parentheses.

Below is the implementation of the above approach:

## C++

 `// C++ program to find the score of``// parentheses using Tree` `#include ``#include ` `using` `namespace` `std;` `// Customized tree class or struct,``// contains all required methods.``class` `TreeNode {``    ``TreeNode* parent = NULL;``    ``vector children;` `public``:``    ``// Function to add a child into``    ``// the list of children``    ``void` `addChild(TreeNode* node)``    ``{``        ``children.push_back(node);``    ``}` `    ``// Function to change the parent``    ``// pointer to the node passed``    ``void` `setParent(TreeNode* node)``    ``{``        ``parent = node;``    ``}` `    ``// Function to return the parent``    ``// of the current node``    ``TreeNode* getParent()``    ``{``        ``return` `parent;``    ``}` `    ``// Function to compute the score recursively.``    ``int` `computeScore()``    ``{` `        ``// Base case``        ``if` `(children.size() == 0)``            ``return` `1;` `        ``int` `res = 0;` `        ``// Adds scores of all children``        ``for` `(TreeNode* curr : children)``            ``res += curr->computeScore();` `        ``if` `(parent == NULL)``            ``return` `res;``        ``else``            ``return` `2 * res;``    ``}``};` `// Function to create the tree structure``TreeNode* computeTree(string s)``{` `    ``TreeNode* current = ``new` `TreeNode();``    ``TreeNode* root = current;` `    ``// Creating a node for every "()"``    ``for` `(``int` `i = 0; i < s.size(); i++) {` `        ``// If we find "(" we add a node as``        ``// a child``        ``if` `(s[i] == ``'('``) {``            ``TreeNode* child = ``new` `TreeNode();``            ``child->setParent(current);``            ``current->addChild(child);``            ``current = child;``        ``}` `        ``// On finding ")" which confirms that``        ``// a pair is closed, we go back``        ``// to the parent``        ``else` `{` `            ``current = current->getParent();``        ``}``    ``}``    ``return` `root;``}` `// Driver code``int` `main()``{``    ``string s = ``"(()(()))"``;` `    ``// Generating the tree``    ``TreeNode* root = computeTree(s);` `    ``// Computing the score``    ``cout << root->computeScore();``    ``return` `0;``}`

## Java

 `// Java program to find the score of``// parentheses using Tree``import` `java.util.*;``public` `class` `Main``{``    ``// Customized tree class or struct,``    ``// contains all required methods.``    ``static` `class` `TreeNode {``        ` `        ``public` `TreeNode parent = ``null``;``        ``public` `Vector children = ``new` `Vector();``        ` `        ``// Function to add a child into``        ``// the list of children``        ``public` `void` `addChild(TreeNode node)``        ``{``            ``children.add(node);``        ``}``         ` `        ``// Function to change the parent``        ``// pointer to the node passed``        ``public` `void` `setParent(TreeNode node)``        ``{``            ``parent = node;``        ``}``         ` `        ``// Function to return the parent``        ``// of the current node``        ``public` `TreeNode getParent()``        ``{``            ``return` `parent;``        ``}``         ` `        ``// Function to compute the score``        ``// recursively.``        ``public` `int` `computeScore()``        ``{``             ` `            ``// Base case``            ``if` `(children.size() == ``0``)``                ``return` `1``;``                 ` `            ``int` `res = ``0``;``             ` `            ``// Adds scores of all children``            ``for``(TreeNode curr : children)``                ``res += curr.computeScore();``      ` `            ``if` `(parent == ``null``)``                ``return` `res;``            ``else``                ``return` `2` `* res;``        ``}``    ``}``    ` `    ``// Function to create the tree structure``    ``static` `TreeNode computeTree(String s)``    ``{``        ``TreeNode current = ``new` `TreeNode();``        ``TreeNode root = current;``         ` `        ``// Creating a node for every "()"``        ``for``(``int` `i = ``0``; i < s.length(); i++)``        ``{``             ` `            ``// If we find "(" we add a node as``            ``// a child``            ``if` `(s.charAt(i) == ``'('``)``            ``{``                ``TreeNode child = ``new` `TreeNode();``                ``child.setParent(current);``                ``current.addChild(child);``                ``current = child;``            ``}``      ` `            ``// On finding ")" which confirms that``            ``// a pair is closed, we go back``            ``// to the parent``            ``else``            ``{``                ``current = current.getParent();``            ``}``        ``}``        ``return` `root;``    ``}``    ` `    ``public` `static` `void` `main(String[] args) {``        ``String s = ``"(()(()))"``;``     ` `        ``// Generating the tree``        ``TreeNode root = computeTree(s);``      ` `        ``// Computing the score``        ``System.out.print(root.computeScore());``    ``}``}` `// This code is contributed by suresh07.`

## Python3

 `# Python3 program to find the score of``# parentheses using Tree`` ` `# Customized tree class or struct,``# contains all required methods.``class` `TreeNode:``    ` `    ``def` `__init__(``self``):``        ``self``.parent ``=` `None``        ``self``.children ``=` `[]` `    ``# Function to add a child into``    ``# the list of children``    ``def` `addChild(``self``, node):``        ` `        ``self``.children.append(node);``    ` `    ``# Function to change the parent``    ``# pointer to the node passed``    ``def` `setParent(``self``, node):``    ` `        ``self``.parent ``=` `node;`` ` `    ``# Function to return the parent``    ``# of the current node``    ``def` `getParent(``self``):``    ` `        ``return` `self``.parent;`` ` `    ``# Function to compute the score recursively.``    ``def` `computeScore(``self``):``        ` `        ``# Base case``        ``if` `(``len``(``self``.children) ``=``=` `0``):``            ``return` `1``;`` ` `        ``res ``=` `0``;`` ` `        ``# Adds scores of all children``        ``for` `curr ``in` `self``.children:``        ` `            ``res ``+``=` `curr.computeScore();`` ` `        ``if` `(``self``.parent ``=``=` `None``):``            ``return` `res;``        ``else``:``            ``return` `2` `*` `res;``    ` `# Function to create the tree structure``def` `computeTree(s):`` ` `    ``current ``=` `TreeNode();``    ``root ``=` `current;`` ` `    ``# Creating a node for every "()"``    ``for` `i ``in` `range``(``len``(s)):`` ` `        ``# If we find "(" we add a node as``        ``# a child``        ``if` `(s[i] ``=``=` `'('``):``            ` `            ``child ``=` `TreeNode();``            ``child.setParent(current);``            ``current.addChild(child);``            ``current ``=` `child;`` ` `        ``# On finding ")" which confirms that``        ``# a pair is closed, we go back``        ``# to the parent``        ``else``:`` ` `            ``current ``=` `current.getParent();``            ` `    ``return` `root;` `# Driver code``if` `__name__``=``=``'__main__'``:``    ` `    ``s ``=` `"(()(()))"``;`` ` `    ``# Generating the tree``    ``root ``=` `computeTree(s);`` ` `    ``# Computing the score``    ``print``(root.computeScore())``    ` `    ``# This code is contributed by rutvik_56`

## C#

 `// C# program to find the score of``// parentheses using Tree``using` `System;``using` `System.Collections;` `class` `GFG{``    ` `// Customized tree class or struct,``// contains all required methods.``class` `TreeNode``{``    ``public` `TreeNode parent = ``null``;``    ``public` `ArrayList children = ``new` `ArrayList();``    ` `    ``// Function to add a child into``    ``// the list of children``    ``public` `void` `addChild(TreeNode node)``    ``{``        ``children.Add(node);``    ``}``    ` `    ``// Function to change the parent``    ``// pointer to the node passed``    ``public` `void` `setParent(TreeNode node)``    ``{``        ``parent = node;``    ``}``    ` `    ``// Function to return the parent``    ``// of the current node``    ``public` `TreeNode getParent()``    ``{``        ``return` `parent;``    ``}``    ` `    ``// Function to compute the score``    ``// recursively.``    ``public` `int` `computeScore()``    ``{``        ` `        ``// Base case``        ``if` `(children.Count == 0)``            ``return` `1;``            ` `        ``int` `res = 0;``        ` `        ``// Adds scores of all children``        ``foreach``(TreeNode curr ``in` `children)``            ``res += curr.computeScore();`` ` `        ``if` `(parent == ``null``)``            ``return` `res;``        ``else``            ``return` `2 * res;``    ``}``};`` ` `// Function to create the tree structure``static` `TreeNode computeTree(``string` `s)``{``    ``TreeNode current = ``new` `TreeNode();``    ``TreeNode root = current;``    ` `    ``// Creating a node for every "()"``    ``for``(``int` `i = 0; i < s.Length; i++)``    ``{``        ` `        ``// If we find "(" we add a node as``        ``// a child``        ``if` `(s[i] == ``'('``)``        ``{``            ``TreeNode child = ``new` `TreeNode();``            ``child.setParent(current);``            ``current.addChild(child);``            ``current = child;``        ``}`` ` `        ``// On finding ")" which confirms that``        ``// a pair is closed, we go back``        ``// to the parent``        ``else``        ``{``            ``current = current.getParent();``        ``}``    ``}``    ``return` `root;``}`` ` `// Driver code``public` `static` `void` `Main()``{``    ``string` `s = ``"(()(()))"``;``    ` `    ``// Generating the tree``    ``TreeNode root = computeTree(s);`` ` `    ``// Computing the score``    ``Console.Write(root.computeScore());``}``}` `// This code is contributed by pratham76`
Output:
`6`

Time Complexity: O(N), where N is the length of the input string.
Space Complexity: O(N), where N is the length of the input string.

My Personal Notes arrow_drop_up