LeetCode括号的分数（栈、树形结构、贡献率三种解法）

题目描述

这道题的题意还是比较好理解的，一个 （） 就是一分，外层再套有括号则分数翻倍。
这道题我们可能会立马想到LeetCode有一道判断有效括号的题目。可能就会想到利用栈。所以首先想到栈能否解决这个问题

方法一：栈方法

在判断有效括号一题中，我们遇到 ‘(’ 就入栈，遇到 ‘)’ 就将栈顶的 ‘(’ 出栈，直到遍历完整个字符串，栈如为empty，那么就是有效的。说明 () 是有序成对出现。
但是在这道题中，我们还是将()，入栈出栈就会有问题。

根据题目我们可知道，只有连续的左右括号（类似于“()”）的情况，才能算分数，外层的括号只能使分数加倍，如果按照上面方法使用栈，当遇到“( ( ( ) ) )”的情况，所得到的分数是3，也就是一共有三对括号，但是并没有考虑括号的嵌套。该题目中，括号的嵌套和一对括号是不同的，所以我们绝对不可能套用上述逻辑解决。
所以，我们要对于该逻辑加以改进，上述的问题是我们将括号从栈中pop()以后，就不会存在括号的嵌套，所以我们要弥补的就是这个问题！！

当我们遇到 ’ ( ’ 时，我们就开始记录该括号中的值，当遇到该 ’ ( ’ 的 ’ ) ’ 时候，我们就将记录下来的值×2，就可以得到该对括号的分数。

在代码中再次进行阐述。

class Solution {
public:
    int scoreOfParentheses(string s) {
        stack<int> st;	//栈，记录每对括号中的分值
        int ret = 0;	//记录最终结果
        for (auto c : s) 
        {
            if (c == '(') 	//左括号push(0),表示该对括号此时分值为0
            {
                st.push(0);
            } 
            else 
            {
                int v = st.top();//遇到右括号，先将栈顶元素取出
                st.pop()；
                if(v == 0)//栈顶元素为0，代表形成连续成对括号，分值+1
                {
                    if(st.empty())//先判断一下，此时栈是否为空，为空则此时已获得一段的结果，保存在ret中
                        ret += 1;
                    else 		//不为空，则更新外层括号分值
                        st.top() += 1;
                }
                else	//栈顶元素不为0，说明形成嵌套括号，则需要将改括号内的分值×2，并加给外层以更新外层分值
                {
                    if(st.empty())	//判断是否为空，同上
                        ret += 2*v;
                    else   
                        st.top() += 2*v;
                }
            }
        }
        return ret;	//返回最终结果
    }
};

稍微优化

每次都要判断栈是否为空太麻烦了，我们可以统一一下操作，提前push(0) ，当作ret（最外层结果），这样从里往外一层一层叠加结果的时候，就可以把最终结果放入栈中。
代码如下：

class Solution {
public:
    int scoreOfParentheses(string s) {
        stack<int> st;
        //int ret = 0;
        st.push(0);
        for (auto c : s) 
        {
            if (c == '(') 
            {
                st.push(0);
            } 
            else 
            {
                int v = st.top();
                st.pop();
                if(v == 0)
                {
                    // if(st.empty())
                    //     ret += 1;
                    //else
                        st.top() += 1;
                }
                else
                {
                    // if(st.empty())
                    //     ret += 2*v;
                    //else   
                        st.top() += 2*v;
                }
            }
        }
        return st.top();
    }
};

方法二：递归

其实，各级括号是有层次结构的，就像树一样，每一对括号都是属于不同层。
什么是不同层？

红色的括号在最外层，绿色的括号在第二层，黑色的括号在第三层。更加形象的就是树结构。

树结构，我们就可以考虑使用递归了。
遇到 （，我们就可以判断，如果下面一个字符是），那么分值+1，如果下面一个字符还是（，那么我们就可以递归获取它括号中的分值再×2。
理论还是很简单的，最终要的是一些小细节，这些细节会在代码中呈现。

class Solution {
public:
    int index = 0;	//要使用全局的指针指向字符串
    int size = 0;
    int scoreOfParentheses(string s) {
        size = s.size();
        int ret = 0;
        //为什么有 s[index]=='(' 条件
        //因为当遇到连续的)),说明已经该层已经结束，要返回上一层
        while(index < size && s[index]=='(')
        {
            index++; //我们要看下一个字符是什么，是左括号还是右括号
            if(s[index] == ')')
                ret += 1;   //左括号，那么形成了连续的一对括号，则+1
            else
                //右括号说明形成了嵌套括号，我们则递归计算出嵌套括号内部的分值，然后×2相加
                ret += scoreOfParentheses(s)*2; 
            //到此时，s[index]一定指向的是)，说明一段已经计算完毕
            //index++,如果再次指向(，说明还有下一段，我们要继续计算
            //如果再次指向),说明出现了连续的))，就是要返回上一层了。 
            //这里是为了while循环处的判断
            index++;
        }
        return ret;
    }
};

方法三：计算每一部分的贡献率

这个方法虽然写在最后，但是是我第一个想出来的办法。效率也是三种方法中最高的。

首先我们还是要明确一点，分数只有连续的一对括号提供。嵌套的括号只提供分数的倍数

每一对连续的括号最终的分值取决于左侧有几个“落单”的左括号。如图：

分析原因

其实我本来觉得不需要分析原因，应该是一目了然，但是为了文章的完整性，还是要解释一下下。
还是强调一下：
首先我们还是要明确一点，分数只有连续的一对括号提供。嵌套的括号只提供分数的倍数
而我们得到一个连续括号被几个嵌套括号包围只需要计算出，左侧有几个“落单”的左括号，只有落单的左括号，右边才有对应的右括号，这样才能有嵌套括号包围着成对括号。
（上述可能有点拗口，大家多读几遍，我下面再给出一张图解释）

成对括号左侧只有一个落单左括号，说明右侧也只有一个落单右括号形成一个包围着成对括号的嵌套括号。

成对括号左侧有两个落单左括号，说明右侧也有两个落单右括号形成一个包围着成对括号的嵌套括号。

class Solution {
public:
    int scoreOfParentheses(string s) {
        int size = s.size();
        int index = 0;
        int multi = 0;	//计算倍数（左侧有几个落单左括号）
        int ret = 0;
        while(index < size)
        {
            if(s[index] == '(')	//遇到左括号，multi++
                multi ++;
            else
            {
                multi --;		//遇到右括号，抵消左括号，multi--
                if(s[index-1] == '(')
                    ret += (1<<multi );	//计算一个成对括号的贡献值
            }
            index++;
        }
        return ret;
    }
};

结语

好久没写题解博客了，感觉自己有些话都说不清楚，语言的表达都不如之前流畅了。以后还是要保持写题解的习惯（我写题解太慢了，哈哈哈，这又写了半个下午），希望大家多多支持。