String 翻转算法

我有一个字符串

s

包含不同类型的括号：

（）

和

[]

。我如何平衡这种类型的字符串与尽可能少的反转数？我可以用任何其他支架替换任何支架

例如：

[）（]

的成本是2，它变成了

[（）]

。

[]的成本（

是1，它变成了

[]）

[（]）

是不平衡的

一个更复杂的示例：

）[）（[）（））]

可以在4次更改中转换为

（[）[（（））]

，但也可以在3个步骤中转换为

[（）（（））]

，这是使其平衡的最少修改次数

---

如何解决这个问题？

我提出的第一种方法是

O（n^3）

动态规划

让

match（i，j）

作为

（）

或

[]

，你必须进行的替换次数，以使

s[i]

和

s[j]

成为

（）

或

[]

。因此

match（i，j）

可以是

0

、

1

或

2

考虑

dp[i][j]=平衡括号数组中从i到j的子序列的最小成本。现在您将
dp[i][i+1]
定义为：

dp[i][i + 1] = match(i, i + 1)

现在一般的规则是，在代码< > dp[i+1] [j- 1 ] +匹配（i，j）< /> >和<代码> min（dp[i] [j]，dp[i] [p] +dp[p+2] [j]）/<代码>对于任何<代码> i 。显然，结果将被保存在<代码> dp[1 ] [n] < /Cord>中。C++有一个解决方案（我还将在大约15分钟内上传一个python程序，当我完成它的时候——python:P不太强大）
#包括
#包括
使用名称空间std；
int dp[100][100]；
字符串s；
int n；
int匹配（字符a、字符b）{
如果（a=='（'&&b=='）'）{
返回0；
}
如果（a=='['&&b==']'）{
返回0；
}
如果（（a='）'| | a=']'）和&（b='（'| | b='['））{
返回2；
}
返回1；
}
int main（）{
cin>>s；
n=s.长度（）；
s=”“+s；
对于（int i=0；我请更具体地说明替换操作。具体可以用什么替换什么？相同类型的括号可以互换吗？或者可以用相同类型的括号替换每个括号吗？可以用“（“）”、“]”、“[”）”替换“（“，”）”、“[”）”替换“（“，”）”、“[”、“[”）”替换“（“，”，“[”。也就是说，正如我所说的，任何一个括号都可以。我不太明白，你能添加一个测试用例（输入>输出）吗？@AxelH，添加了一个。
）[（[）（））]
可以在
[（）（（））]
中修改，只需3个步骤。太棒了，伙计
#include <iostream>
#include <string>
using namespace std;

int dp[100][100];
string s;
int n;

int match(char a, char b) {
    if (a == '(' && b == ')') {
        return 0;
    }
    if (a == '[' && b == ']') {
        return 0;
    }
    if ((a == ')' || a == ']') && (b == '(' || b == '[')) {
        return 2;
    }
    return 1;
}

int main() {
    cin >> s;
    n = s.length();
    s = " " + s;
    for (int i = 0; i <= n; ++i) {
        for (int j = 0; j <= n; ++j) {
            dp[i][j] = 0x3f3f3f3f;
        }
    }    

    for (int i = 1; i < n; ++i) {
        dp[i][i + 1] = match(s[i], s[i + 1]);
    }

    for (int k = 3; k <= n; k += 2) {
        for (int i = 1; i + k <= n; ++i) {
            int j = i + k;
            dp[i][j] = min(dp[i][j], dp[i + 1][j - 1] + match(s[i], s[j]));
            for (int p = i + 1; p <= j; p += 2) {
                dp[i][j] = min(dp[i][j], dp[i][p] + dp[p + 1][j]);
            }
        }
    }
    cout << dp[1][n] << '\n';
    /*for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= n; ++j) {
            cout << dp[i][j] << ' ';
        }
        cout << '\n';
    }*/
    return 0;
}

s = input()
n = len(s)
inf = 0x3f3f3f3f

def match(x, y):
    if x == '(' and y == ')':
        return 0
    if x == '[' and y == ']':
        return 0
    if (x == ')' or x == ']') and (y == '(' or y == '['):
        return 2
    return 1

# dp[i][j] = min. cost for balancing a[i], a[i + 1], ..., a[j]
dp = [[inf for j in range(n)] for i in range(n)]

for i in range(n - 1):
    dp[i][i + 1] = match(s[i], s[i + 1])

for k in range(3, n, 2):
    i = 0
    while i + k < n:
        j = i + k
        dp[i][j] = min(dp[i][j], dp[i + 1][j - 1] + match(s[i], s[j]))
        for p in range(i + 1, j, 2):
            dp[i][j] = min(dp[i][j], dp[i][p] + dp[p + 1][j])
        i += 1

print(dp[0][n - 1])
#for i in range(n):
#    for j in range(n):
#        print(dp[i][j], end = ' ')
#    print()