算法设计与分析/数据结构与算法实验4：添加括号数目问题

1.实验目的

(1)掌握动态规划法的处理思路与算法框架。
(2)掌握应用动态规划法解决具体问题的方法。
(3)掌握动态规划法的广泛应用。

2.实验内容

(1)问题描述

括号序列有()、{}和[]组成。
（1）设计一个算法来判断括号序列不合法，如“(([{}]))”是合法的，而“(}{)”、“(}(}”和“({)}”都是不合法的。
（2）如果一个括号序列不合法，设计一个算法，求解使该序列成为合法的括号序列至少需要添加的括号数目。例如，“(}(}”最少需要添加4个括号成为合法括号序列，即变为“(){}(){}”。

(2)输入

输入只有一行。
第一行包含一个字符串，它的长度为。这个字符串仅由小括号、中括号或大括号，即’(’,’)’,’[’,’]’,’{’或’}’组成。字符的下标从0开始。

(3)输出

输出分为两行。
第一行输出True或False。True表示括号序列是合法序列，False表示括号序列不是合法序列。
第二行输出使该序列成为合法的括号序列至少需要添加的括号数目。

3.问题实例分析

  实例：输入参数str=[({}}。
  首先解决问题1。该括号序列是否为一个合法序列？
  可以利用栈这一数据结构进行解决。遍历当前序列，每碰到一个左括号就入栈，放入栈顶。碰到一个右括号时，判断当前右括号与左括号是否匹配。若匹配，则将左括号出栈。若不匹配，则无需遍历后续括号序列，结束遍历，能直接能说明当前括号序列为不合法序列。在遍历完序列后，若栈不为空，则说明还有左括号没被右括号匹配上。同样的，这也是个不合法的括号序列。
  言而简之，当且仅当括号序列能被遍历完且遍历完时栈为空，括号序列才能为合法序列。

  在本实例中，初始时栈为空，首先将第0个字符左中括号“[”入栈，再将第1个字符左小括号“(”入栈，将第2个字符左大括号“{”入栈。第3个字符为“}”，与栈顶的左大括号“{”匹配了，出栈。第4个字符为“}”，与栈顶“(”不匹配，则说明当前序列不是合法序列。
  解决问题2。求解使该序列成为合法序列所需要添加的最少的括号数目。我们也可以自底向上地解决这个问题。
  先将这个问题分解为若干个规模较小且相等的子问题：只有1个括号时使得括号序列合法化所需的括号数目，只有2个括号时使得括号序列合法化所需的括号数目。3个或多个括号合法化时所需的括号数量可以分解为上述的子问题。
  对该子问题进行推广，存在$len$个括号时的括号序列合法化所需的括号数目可以分解为$k$个括号时的括号序列合法化所需的括号数目和$n-k$个括号时的括号序列合法化所需的括号数目。其中，$k\le len$。
  我们创建一个$n\ast n$的二维数组$dp$。当$0\le i\le j\le n-1$时，$d{p}_{i,j}$表示从第$i$个字符到第$j$个字符所需的括号数目。当$i>j$时，$d{p}_{i,j}$无意义。事实上，当$i>j$时的$d{p}_{i,j}$不会被访问、被调用，也不会被计算到。因为字符的下标从0开始，所以$d{p}_{0,n-1}$表示从第0个字符到第$n-1$个字符所需的最小括号数目，即题目所需要的括号数目。
  首先解决最小子问题：只有一个括号时，使括号序列合法化所需要的括号数目。该数目为1。即:$d{p}_{i,i}=1,i=0,1,..,n-1$。此时数组如下：

1
	1
		1
			1
				1

  只有两个字符时，括号匹配问题可以分为两种情况：括号正确地匹配上了是其中一种情况，括号没有正确地匹配上是另一种情况。
  括号正确地匹配上时，不需要额外添加括号，即$d{p}_{i,i+1}=0$。括号没有正确地匹配上时，需要额外添加两个括号，即$d{p}_{i,i+1}=2$。

1	2
	1	2
		1	0
			1	2
				1

  接下来分析3个字符、4个字符、$len$个字符…直到$n$个字符时，括号匹配问题的解决方案。
  当字符串有3个字符时，字符串长度$len=3$。记字符串左指针为$i$，则右指针为$j=i+len-1$。
  同样的，若括号序列左端字符和括号序列右端字符能匹配，则可以去掉左右括号，计算中间的括号序列合法化所需的括号数。即：$d{p}_{i,j}=d{p}_{i+1,j-1}$。
无论括号序列左端字符和括号序列右端字符是否能匹配，则都需要将这个括号序列断成两端，记断开括号序列的位置为$k$，则括号序列可以被断成$i...k$和$k+1...j$两段。整个括号序列的合法化所需的括号数目由这两小段括号序列组成。对于$i\le k\le j-1$，都计算一遍$d{p}_{i,k}+d{p}_{k+1,j}$的值，取其最小值为$d{p}_{i,j}$的值。即：$d{p}_{i,j}=mi{n}_{i\le k\le j-1}(d{p}_{i,k}+d{p}_{k+1,j})$。
  将以上两种情况进行整理。即：

三个字符

1	2	3
	1	2	1
		1	0	1
			1	2
				1

  存在4个、5个、…、$n$、个字符时，用同样的办法进行更新，直到最后算出$d{p}_{0,n-1}$值即为整个序列使其合法化所需的最小的括号数量。
四个字符

1	2	3	2
	1	2	1	2
		1	0	1
			1	2
				1

五个字符

1	2	3	2	3
	1	2	1	2
		1	0	1
			1	2
				1

  言而简之，完整的$dp$数组可以按如下算式进行计算：

  因为题面中没有要求输出括号序列合法化后的方案，所以在本动态规划算法中无需进行根据求解时得到的信息对最优方案进行构造和求解的相关步骤。
  事实上，可以将本题第一问与第二问的做法进行统一：在第二问中，若求得$d{p}_{0,n-1}=0$，则也可以说明该括号序列为合法序列。

4.算法描述及说明

  正如第3节问题实例分析所述，算法的整体流程如下：
  1.将原问题长度为$n$的括号序列$st{r}_{0..n-1}$合法化的所需的最小括号数目分解成子问题：求解使得括号序列$st{r}_{i..j}$合法化所需的最小括号数目。
  2.定义最优值。创建$dp$数组。$d{p}_{i,j}$表示从第$i$个字符到第$j$个字符的所要添加的最少括号数目。$d{p}_{i,j}$的计算式如下：

  3.以自底向上的方式与顺序计算出最优值。问题的“底部”为长度$len=1$的括号序列合法化所需的括号数目与长度$len=2$的括号序列合法化所需的括号数目。其计算式如下：

  大循环中，从括号序列长度$len=3$开始计算，一步步增加括号序列长度$len$，直到$len=n$。大循环中有小循环，小循环针对括号序列起点$i$和终点$j=i+len-1$。每次小循环一步步增加$i$值，直到$j==n$。小循环中还有内循环，$i\le k\le j-1$，为了计算的$d{p}_{i,j}$最小值。问题的底部即为$d{p}_{i,i}$、$d{p}_{i,i+1}$的值，问题的顶部为$d{p}_{0,n-1}$的值。
  在算法结束后对结果进行输出。对于第一问，若$d{p}_{0,n-1}==0$，则该括号序列为合法序列。否则该括号序列为不合法序列。对于第二问，需要添加$d{p}_{0,n-1}$个括号使得该括号序列为合法序列。

5.算法正确性分析

  算法会正确地结束：在运行完成三重循环后，算法会停止。
  符合动态规划的基本要素：最优子结构：若$st{r}_{0..n-1}$的最优完全加括号方式在位置$k$和$k+1$之间将序列断开，则由此确定的子序列$st{r}_{0..k}$和$st{r}_{k+1..n-1}$的完全加括号方式也是最优的。也就是说该问题具有最优子结构性质。在分析该问题的最优子结构性质时，所用的方法具有普遍性。
  利用反证法对算法的正确性进行证明：首先假设由该问题的最优解导出的子问题的解不是最优的，假设存在更优解，则导致矛盾。由于计算过程中，对于$st{r}_{i..j}$中括号序列断开的情况导致的所需的括号数目都进行了求解并取最小值，所以不存在更优解。矛盾。

6.算法时间复杂性分析

算法中存在三重循环。所以时间复杂度为$O(n^3)$。对于$n\le 1000$的数据，可以在大约1s内运行出结果。

7.运行结果展示及其说明

测试样例使用了三组。对于每一组测试样例，都正确地输出了该括号序列是否合法，以及使得括号序列变为合法序列所需的括号数目。

8.心得体会

9.程序源代码

#include<iostream>
#include<stack>
#include<cstring>
using namespace std;
string str;
int dp[1005][1005];
bool check(int i, int j) {
	if ((str[i] == '(') && (str[j] == ')') || (str[i] == '[') && (str[j] == ']') || (str[i] == '{') && (str[j] == '}'))
		return true;
	else return false;
}
int main() {
	cin >> str;
	int maxlen = str.size();
	for (int len = 1; len <= maxlen; len++) {
		for (int l = 0; l + len - 1 < maxlen; l++) {
			int r = l + len - 1;
			if (len == 1)
				dp[l][r] = 1;
			else {
				dp[l][r] = 0x3f3f3f3f;
				if (check(l, r)) {
					dp[l][r] = min(dp[l][r], dp[l + 1][r - 1]);
				}
				for (int k = l; k <= r; k++)
					dp[l][r] = min(dp[l][r], dp[l][k] + dp[k + 1][r]);
			}
		}
	}
	if (dp[0][maxlen - 1] == 0)
		cout << "True\n";
	else
		cout << "False\n";
	cout << dp[0][maxlen - 1];
	return 0;
}