Score of Parentheses using Tree

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:

Input: str = “()()” 
Output: 2 
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: 2 
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: 6 
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 <iostream>
#include <vector>

using namespace std;

// Customized tree class or struct,
// contains all required methods.
class TreeNode {
    TreeNode* parent = NULL;
    vector<TreeNode*> 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<TreeNode> children = new Vector<TreeNode>();

        // 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

Javascript

       // JavaScript code for the above approach
       // Customized tree class or struct,
       // contains all required methods.
       class TreeNode {
           constructor() {
               this.parent = null;
               this.children = [];
           }

           // Function to add a child into
           // the list of children
           addChild(node) {

               this.children.push(node);
           }

           // Function to change the parent
           // pointer to the node passed
           setParent(node) {
               this.parent = node;
           }

           // Function to return the parent
           // of the current node
           getParent() {
               return this.parent;
           }

           // Function to compute the score recursively.
           computeScore() {
               // Base case
               if (this.children.length === 0) return 1;

               let res = 0;

               // Adds scores of all children
               for (let curr of this.children) res += curr.computeScore();

               if (this.parent === null) return res;
               else return 2 * res;
           }
       }

       // Function to create the tree structure
       function computeTree(s) {
           let current = new TreeNode();
           let root = current;

           // Creating a node for every "()"
           for (let i = 0; i < s.length; i++)
           {

               // If we find "(" we add a node as
               // a child
               if (s[i] === '(')
               {
                   let 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
       let s = '(()(()))';

       // Generating the tree
       let root = computeTree(s);

       // Computing the score
       console.log(root.computeScore());

// This code is contributed by Potta Lokesh.

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.