牛客题解 | 括号区间匹配

题目

题目链接

解题思路

  1. 状态定义:

    • d p [ i ] [ j ] dp[i][j] dp[i][j] 表示使区间 [ i , j ] [i,j] [i,j] 的括号序列合法所需插入的最少括号数
  2. 转移方程:

    • s [ i ] s[i] s[i] s [ j ] s[j] s[j] 匹配时: d p [ i ] [ j ] = d p [ i + 1 ] [ j − 1 ] dp[i][j] = dp[i+1][j-1] dp[i][j]=dp[i+1][j1]
    • 否则: d p [ i ] [ j ] = min ⁡ ( d p [ i + 1 ] [ j ] + 1 , d p [ i ] [ j − 1 ] + 1 ) dp[i][j] = \min(dp[i+1][j] + 1, dp[i][j-1] + 1) dp[i][j]=min(dp[i+1][j]+1,dp[i][j1]+1)

代码

#include <bits/stdc++.h>
using namespace std;

int dp[105][105];

bool match(char left, char right) {
    return (left == '(' && right == ')') || (left == '[' && right == ']');
}

int main() {
    string s;
    cin >> s;
    int n = s.length();
    
    // 初始化
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            dp[i][j] = n;  // 初始化为最大可能值
        }
        dp[i][i] = 1;  // 单个括号需要插入一个配对括号
    }
    
    // 处理长度为2的情况
    for(int i = 0; i < n-1; i++) {
        if(match(s[i], s[i+1])) {
            dp[i][i+1] = 0;  // 如果匹配,不需要插入
        } else {
            dp[i][i+1] = 2;  // 不匹配,需要插入两个括号
        }
    }
    
    // 区间dp
    for(int len = 3; len <= n; len++) {
        for(int i = 0; i + len - 1 < n; i++) {
            int j = i + len - 1;
            
            // 如果两端匹配
            if(match(s[i], s[j])) {
                dp[i][j] = dp[i+1][j-1];
            } else {
                // 在左端或右端插入一个括号
                dp[i][j] = min(dp[i+1][j] + 1, dp[i][j-1] + 1);
            }
            
            // 枚举分割点
            for(int k = i; k < j; k++) {
                dp[i][j] = min(dp[i][j], dp[i][k] + dp[k+1][j]);
            }
        }
    }
    
    cout << dp[0][n-1] << endl;
    return 0;
}
import java.util.*;

public class Main {
    static int[][] dp = new int[105][105];
    
    static boolean match(char left, char right) {
        return (left == '(' && right == ')') || (left == '[' && right == ']');
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        int n = s.length();
        
        // 初始化
        for(int i = 0; i < n; i++) {
            Arrays.fill(dp[i], n);  // 初始化为最大可能值
            dp[i][i] = 1;  // 单个括号需要插入一个配对括号
        }
        
        // 处理长度为2的情况
        for(int i = 0; i < n-1; i++) {
            if(match(s.charAt(i), s.charAt(i+1))) {
                dp[i][i+1] = 0;
            } else {
                dp[i][i+1] = 2;
            }
        }
        
        // 区间dp
        for(int len = 3; len <= n; len++) {
            for(int i = 0; i + len - 1 < n; i++) {
                int j = i + len - 1;
                
                // 如果两端匹配
                if(match(s.charAt(i), s.charAt(j))) {
                    dp[i][j] = dp[i+1][j-1];
                } else {
                    // 在左端或右端插入一个括号
                    dp[i][j] = Math.min(dp[i+1][j] + 1, dp[i][j-1] + 1);
                }
                
                // 枚举分割点
                for(int k = i; k < j; k++) {
                    dp[i][j] = Math.min(dp[i][j], dp[i][k] + dp[k+1][j]);
                }
            }
        }
        
        System.out.println(dp[0][n-1]);
        sc.close();
    }
}
def match(left: str, right: str) -> bool:
    return (left == '(' and right == ')') or (left == '[' and right == ']')

def solve(s: str) -> int:
    n = len(s)
    dp = [[n] * n for _ in range(n)]  # 初始化为最大可能值
    
    # 初始化单个括号的情况
    for i in range(n):
        dp[i][i] = 1
    
    # 处理长度为2的情况
    for i in range(n-1):
        if match(s[i], s[i+1]):
            dp[i][i+1] = 0
        else:
            dp[i][i+1] = 2
    
    # 区间dp
    for length in range(3, n+1):
        for i in range(n-length+1):
            j = i + length - 1
            
            # 如果两端匹配
            if match(s[i], s[j]):
                dp[i][j] = dp[i+1][j-1]
            else:
                # 在左端或右端插入一个括号
                dp[i][j] = min(dp[i+1][j] + 1, dp[i][j-1] + 1)
            
            # 枚举分割点
            for k in range(i, j):
                dp[i][j] = min(dp[i][j], dp[i][k] + dp[k+1][j])
    
    return dp[0][n-1]

def main():
    s = input().strip()
    print(solve(s))

if __name__ == "__main__":
    main()

算法及复杂度

  • 算法:区间动态规划
  • 时间复杂度: O ( n 3 ) \mathcal{O}(n^3) O(n3),其中 n n n 是字符串长度
  • 空间复杂度: O ( n 2 ) \mathcal{O}(n^2) O(n2),用于存储 d p dp dp 数组
动态规划在解决删除括号问题时,可以按照以下步骤进行: 1. 首先,我们需要理解题目的需求。题目要求我们删除括号,使得剩下的字符串满足以下条件:左括号和右括号的数量相等,且左括号的位置必须在右括号的前面。 2. 接下来,我们可以使用动态规划来解决这个问题。我们可以定义一个三维的dp数组,其中dp[q][w][e]表示考虑s前q个字符,t前w个字符,且s被删除部分左括号数减去右括号数为e时,是否可行(bool类型)。 3. 然后,我们可以从前向后遍历字符串s和t。在每一步中,我们可以考虑两种情况: a. 删除的左括号数目比右括号多:我们可以继续删除左括号,或者删除右括号。即dp[q][w][e] = dp[q-1][w][e+1]或dp[q-1][w][e-1]。 b. 删除的左括号数目与右括号数目相同:我们只能删除右括号。即dp[q][w][e] = dp[q-1][w-1][e-1]。 4. 最后,我们可以根据dp[len1][len2][0]的值来判断是否可行。其中len1和len2分别表示字符串s和t的长度。 综上所述,通过动态规划的思路,我们可以解决删除括号的问题。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [动态规划笔记](https://download.youkuaiyun.com/download/weixin_38617297/13751806)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* *3* [_21303删括号_动态规划](https://blog.youkuaiyun.com/weixin_45619006/article/details/114650172)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值