Leetcode 每日一题 856.括号的分数

题目链接：力扣

---

stack思想

1/ 【我的stack数组】

我的思路：

利用stack<char>结构存储字符串信息，再利用int sum来储存层结构信息以及使用 int temp来计算层元素分数。结果发现，再出现一连串右括号时，无法判断层元素信息。

2/【解答的stack数组】

利用stack<int>结构直接存储分数信息，初始化为0，遇到右括号就弹出与之匹配的左括号，并把分数存储在下一个左括号对应的位置，这个位置在没有匹配到对应右括号之前会一直积分，完美解决了“层”的问题。

官方代码如下：

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

max（2*v，1） ，如果v为0，那么取1；如果v不为0，那么取2*v

---

递归思想

深度优先搜索思想-转换为树结构

这两个方法很相似，只是实现方式不同。

1、 寻找一个单位的平衡括号，最外层只有一个左括号和一个右括号

      例如“（）”，“（（（）（）（）））”，

2、向内部搜取信息

      递归采用了bal==0的方式来判断平衡括号的单位，并切割成小部分，逐层递归分解答案

      深搜的while循环只解决最小单位“（）”的记数问题，其他情况就进行递归。

官方代码如下：

递归：

class Solution {
public:
    int scoreOfParentheses(string s) {
        if (s.size() == 2) {
            return 1;
        }
        int bal = 0, n = s.size(), len;
        for (int i = 0; i < n; i++) {
            bal += (s[i] == '(' ? 1 : -1);
            if (bal == 0) {
                len = i + 1;
                break;
            }
        }
        if (len == n) {
            return 2 * scoreOfParentheses(s.substr(1, n - 2));
        } else {
            return scoreOfParentheses(s.substr(0, len)) + scoreOfParentheses(s.substr(len, n - len));
        }
    }
};

深搜：

class Solution {
    int idx = 0;
    char[] arr;
    public int scoreOfParentheses(String s) {
        arr = s.toCharArray();
        return dfs();
    }
    private int dfs() {
        int res = 0;
        while (idx < arr.length && arr[idx] == '(') {
            idx++; //跳过当前节点 (
            if (arr[idx] == ')') res += 1; // 没有子节点
            else res += dfs() * 2; // 存在子节点
            idx++; //跳过当前节点 )
        }
        return res;
    }
}

作者：hongky
链接：https://leetcode.cn/problems/score-of-parentheses/solution/by-hongky-kjm8/

---

总结：

栈和递归和bfs其实是很相似的，这三种都是由内向外的方法，从最小单元出发，逐步发送信息给更大的单元，关键是如何找到小单元和大单元的区别，才能更好地解决如何从小单元过渡到大单元的问题。栈用的是匹配括号的方法，匹配到一次括号，弹出被匹配的括号，存储到最后一个弹出的括号中；递归和bfs都是在处理return的过程中区别出了大单元和小单元。

---

如有问题， 请多指教