Python 解决方案

def calculate_bracket_nesting_level(input_sequence):
    """
    计算有效括号序列的最大嵌套深度
    """
    bracket_container = []
    peak_nesting_level = 0
    
    # 定义右括号到左括号的对应关系
    closing_to_opening = {
        ')': '(',
        ']': '[', 
        '}': '{'
    }
    
    # 定义开括号集合
    opening_brackets = set(['(', '[', '{'])
    
    for symbol in input_sequence:
        if symbol in opening_brackets:
            # 遇到开括号，压入容器
            bracket_container.append(symbol)
            # 更新最大嵌套深度记录
            current_depth = len(bracket_container)
            peak_nesting_level = max(peak_nesting_level, current_depth)
            
        elif symbol in closing_to_opening:
            # 遇到闭括号，检查匹配性
            if not bracket_container:
                return 0  # 无匹配的开括号
            
            if bracket_container[-1] != closing_to_opening[symbol]:
                return 0  # 括号类型不匹配
            
            bracket_container.pop()
    
    # 检查是否所有括号都已匹配
    return peak_nesting_level if len(bracket_container) == 0 else 0

def main():
    text_input = input().strip()
    result = calculate_bracket_nesting_level(text_input)
    print(result)

if __name__ == "__main__":
    main()

Java 解决方案

import java.util.*;

public class Main {
    
    /**
     * 分析括号序列的有效性并计算最大嵌套层次
     */
    public static int analyzeBracketDepth(String bracketSequence) {
        LinkedList<Character> bracketStack = new LinkedList<>();
        int maximumDepth = 0;
        
        // 构建括号配对映射表
        Map<Character, Character> bracketPairs = new HashMap<Character, Character>() {{
            put(')', '(');
            put(']', '[');
            put('}', '{');
        }};
        
        // 定义左括号集合
        Set<Character> leftBrackets = Set.of('(', '[', '{');
        
        for (char currentChar : bracketSequence.toCharArray()) {
            if (leftBrackets.contains(currentChar)) {
                // 处理左括号
                bracketStack.addFirst(currentChar);
                int currentDepth = bracketStack.size();
                maximumDepth = Math.max(maximumDepth, currentDepth);
                
            } else if (bracketPairs.containsKey(currentChar)) {
                // 处理右括号
                if (bracketStack.isEmpty()) {
                    return 0; // 右括号无匹配
                }
                
                Character topElement = bracketStack.peekFirst();
                if (!topElement.equals(bracketPairs.get(currentChar))) {
                    return 0; // 括号不匹配
                }
                
                bracketStack.removeFirst();
            }
        }
        
        return bracketStack.isEmpty() ? maximumDepth : 0;
    }
    
    public static void main(String[] args) {
        Scanner inputReader = new Scanner(System.in);
        String inputString = inputReader.nextLine().trim();
        int result = analyzeBracketDepth(inputString);
        System.out.println(result);
        inputReader.close();
    }
}

C++ 解决方案

#include <iostream>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <string>
#include <algorithm>

class BracketValidator {
private:
    std::vector<char> bracket_storage;
    int max_nesting_depth;
    std::unordered_map<char, char> closing_bracket_map;
    std::unordered_set<char> opening_bracket_set;
    
public:
    BracketValidator() : max_nesting_depth(0) {
        // 初始化括号映射关系
        closing_bracket_map[')'] = '(';
        closing_bracket_map[']'] = '[';
        closing_bracket_map['}'] = '{';
        
        // 初始化开括号集合
        opening_bracket_set.insert('(');
        opening_bracket_set.insert('[');
        opening_bracket_set.insert('{');
    }
    
    /**
     * 验证括号序列并计算最大深度
     */
    int validateAndCalculateDepth(const std::string& bracket_string) {
        bracket_storage.clear();
        max_nesting_depth = 0;
        
        for (char bracket_char : bracket_string) {
            if (opening_bracket_set.count(bracket_char)) {
                // 处理开括号情况
                bracket_storage.push_back(bracket_char);
                int current_level = static_cast<int>(bracket_storage.size());
                max_nesting_depth = std::max(max_nesting_depth, current_level);
                
            } else if (closing_bracket_map.count(bracket_char)) {
                // 处理闭括号情况
                if (bracket_storage.empty()) {
                    return 0; // 没有对应的开括号
                }
                
                char top_bracket = bracket_storage.back();
                if (top_bracket != closing_bracket_map[bracket_char]) {
                    return 0; // 括号类型不匹配
                }
                
                bracket_storage.pop_back();
            }
        }
        
        // 检查是否所有括号都已正确配对
        return bracket_storage.empty() ? max_nesting_depth : 0;
    }
};

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    std::string input_sequence;
    std::getline(std::cin, input_sequence);
    
    BracketValidator validator;
    int final_result = validator.validateAndCalculateDepth(input_sequence);
    
    std::cout << final_result << std::endl;
    
    return 0;
}