leetcode: Longest Valid Parentheses分析和实现

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了leetcode: Longest Valid Parentheses分析和实现相关的知识,希望对你有一定的参考价值。

  题目大意:给出一个只包含字符‘(‘和‘)‘的字符串S,求最长有效括号序列的长度。

  


  很有趣的题目,有助于我们对这种人类自身制定的规则的深入理解,可能我们大多数人都从没有真正理解过怎样一个括号序列是有效的,因此解题也无从说起。整道题目的难度在于我们对有效括号序列的理解和定义。下面给出我自己的定义:、

  定义1:空括号序列是有效的。

  定义2:对于一对左右括号,若左括号出现在右括号的左边,且左右括号之间(不包含两端)的括号序列是有效的,那么称该左括号到该右括号(包含)这一段序列是有效的。且称该左括号和右括号匹配。

  定义3:若一个括号序列中每一个左括号都有与之匹配的右括号,而每一个右括号也有与之匹配的左括号,则称该括号序列是有效的。定义3是对定义2的一个扩展。

  对于定义的正确性与个人思维方式有关故不做说明,我一直认为无法证明是错误的东西,就是正确的,至少你能直接拿过来使用。下面给出一些记号的定义:S[x~y]表示由S[x],S[x+1],...,S[y-1],S[y]按先后顺序组成的子序列;n表示S的长度。后面不再对这些记号做说明。

  


  命题1:对于任意一个有效括号序列P,其中每一个左括号唯一匹配一个右括号,同时右括号也唯一匹配左括号。

  证明:定义3已经给出了有效序列中每个左括号与某个右括号匹配,只是缺少唯一性的证明,下面进行说明。假设对于某个下标为A的左括号同时下标为B与下标为C的两个右括号相匹配。不妨假设B<C。则由于A和B相匹配,由定义2可以得出序列P[A+1~C-1]是有效序列,而A+1<=B<=C-1,故能为找到下标为D的左括号,使得A+1<=D<B成立,且D与B想匹配(定义3)。可以重复上面的过程找到下标为E的右括号使得D<E<B,且D与E相匹配,从而无限推导下去,但是我们所考察的有效区间从A,C转为A,B,之后转为E,B,这是一个不断递减的过程,因此这个重复动作总会在某个点失败,而这时候就能反证假设错误,故唯一性得证。

 

  命题1‘:若P和P[x~y]均为有效序列,那么在P中下标为x的左括号必然与下标为y的右括号唯一匹配。

  证明:首先由于P[x~y]是有效序列,因此显然在P中下标为x的左括号与下标为y的右括号是匹配的。而由命题1即可直接得出匹配的唯一性。

 

  命题2:对于一段括号序列S[x~y]是有效的等价于:若对于任意满足x <= i <= y的整数i,有S[x~i]中左括号数不少于右括号数以及S[i~y]中右括号数不少于左括号数两个性质同时成立。

  证明:

  对于必要性,由于S[x~y]中每一个左括号都有对应的右括号与之唯一相匹配,因此对于任意满足x <= i <= y的整数i,有S[x~i]中左括号数不少于右括号数(否则S[x~i]中多余的右括号则在S[x~y]没有与之匹配的左括号)。而S[i~y]中右括号数不少于左括号数性质也可以类似推出。

  而对于充分性,利用数学归纳法。当y = x + 1时,命题显然成立,因为满足这一条件的子序列只可能是"()"。现假设y <= x + t时(t >= 1),命题成立。对于任意在S[x~y]之间出现的左括号,记其下标为L。由于S[L~y]中右括号不少于左括号数,因此必能找到最小的下标R,使得L<R且S[L~R]中出现的左括号数和右括号数数量一致。下面验证L和R是匹配的。首先L<R是不言而喻的,只要证明S[L+1~R-1]是有效的。由于下标R最小,因此可以得到对于任意满足L<m<R的整数m,都有S[L~m]中左括号数多于右括号数,否则与R的定义相悖。而同样能保证L是最大的满足L<R且S[L~R]中左括号与右括号数目一致的下标(利用反证法,设可以找到L<K<R使得S[K~R]中左括号与右括号数目一致,那么必然有S[L~K-1]中左括号与右括号数目一致),故对应的可以得出S[m~R]中右括号多于左括号数。利用这两个性质可以等价得出:对于任意满足L+1<=m<=R-1的整数m,都有S[L+1~m]中左括号数多于右括号数且S[m~R-1]中右括号多于左括号数。而(R-1)-(L+1)=R-L-2且y<=x+t+2可以推出R<=L+t,因此利用前面数学归纳法得到的结论(假设y <= x + t时命题成立)可以推出S[L+1~R-1]有效,即S[L~R]是有效的,再借助定义3可以得出序列S[x~y]是有效的。命题得证。

  

  命题3:若S[A~B]是有效序列,且S[B+1~C]是有效序列,则S[A~C]也是有效序列。

  证明:S[A~B]有效且S[B+1~C]是有效序列,则S[A~C]必然满足命题2右边的性质,故S[A~C]是有效序列。

 

  命题3‘:若S[A~C]是有效序列,且对于A<B<C,S[A~B]是有效序列,则S[B+1~C]是有效序列。

  证明:依旧是利用命题2右边的性质可以直接得出S[B+1~C]是有效序列。


  本来考虑的时候是希望能利用命题2给出的结论进行快速计算,后来发现动态规划似乎更加简单,也更容易证明。创建长度为n的数组DP,令DP[i]记录以下标i作为左边界的最大有效括号序列的长度,可以发现下面的递推关系:

  1.若S[i]是右括号,则DP[i]=0

  2.若S[i]是左括号,且S[i+1]是右括号,则DP[i]=2+DP[i+2]

  3.若S[i]是左括号,且S[i+1]是左括号,且S[DP[i+1]+i+1]是右括号,则DP[i]=DP[i+1]+2+DP[DP[i+1]+i+2]

  4.若S[i]是左括号,且S[i+1]是左括号,且S[DP[i+1]+i+1]是左括号,则DP[i]=0

  下面进行正确性的说明。

  1的正确性不言而喻。

  对于2,由于序列S[i~i+1+DP[i+2]]满足命题2右边的条件,因此序列有效。假设存在j > i + 1 + DP[i+2],使得S[i~j]有效,那么命题3‘将导出S[i+2~j]是有效序列这样一个结论,这与DP的定义相悖。

  对于3,同样序列满足S[i~i+1+DP[i+1]]命题2右边的条件,因此序列有效。根据命题1‘,此时S[i]与S[DP[i+1]+i+1]唯一匹配。若我们忽略S[i+1~i+DP[i+1]]部分内容,则可以归结为情况2,利用相同的思路证明即可。

  对于4,能与左括号S[i]匹配的右括号的下标j只可能位于i+1与DP[i+1]+i+1(否则命题3‘将导出与DP的定义相悖的结论)。而由于j不可能是DP[i+1]+i+1,因此j取i+1与DP[i+1]+i之间。但是由于i+1与DP[i+1]+i之间的任意下标为k的右括号,都必然会导出S[i~k]中左括号数多于右括号数目的现象,因此不存在与S[i]相匹配的右括号。

  利用上面的递推公式和动态规划的技术,可以在O(n)的时间复杂度和空间复杂度内得到最终结果,最长的有效序列的长度。


 

  下面给出实际代码:

技术分享
 1 package cn.dalt.leetcode;
 2 
 3 /**
 4  * Created by dalt on 2017/8/26.
 5  */
 6 public class LongestValidParentheses {
 7     private static final char LEFT = ‘(‘;
 8     private static final char RIGHT = ‘)‘;
 9 
10     public int longestValidParentheses(String s) {
11         int n = s.length();
12         char[] data = s.toCharArray();
13         int[] dp = new int[n + 1];
14         int max = 0;
15         for (int i = n - 1; i >= 0; i--) {
16             int nextIndex = i + 1;
17             //condition 1
18             if (data[i] == RIGHT) {
19                 dp[i] = 0;
20             }
21             //check for not exceeding the bound
22             else if (nextIndex >= n) {
23                 dp[i] = 0;
24             } 
25             //condition 2
26             else if (data[nextIndex] == RIGHT) {
27                 dp[i] = dp[i + 2] + 2;
28             } 
29             //condition 3 and 4
30             else if (data[nextIndex] == LEFT) {
31                 int endIndex = dp[nextIndex] + nextIndex;
32                 //check for not exceeding the bound
33                 if (endIndex >= n || data[endIndex] == LEFT) {
34                     dp[i] = 0;
35                 } 
36                 //conditon 4
37                 else {
38                     //DP[i]=DP[i+1]+2+DP[DP[i+1]+i+2]
39                     dp[i] = dp[nextIndex] + 2 + dp[endIndex + 1];
40                 }
41             }
42 
43             if (dp[i] > max) {
44                 max = dp[i];
45             }
46         }
47         return max;
48     }
49 }
View Code

 

  技术分享

 

以上是关于leetcode: Longest Valid Parentheses分析和实现的主要内容,如果未能解决你的问题,请参考以下文章

LeetCode - 32. Longest Valid Parentheses

[LeetCode]32. Longest Valid Parentheses

LeetCode 32. Longest Valid Parentheses

LeetCode 32. Longest Valid Parentheses

LeetCode 32. Longest Valid Parentheses

[leetcode-32-Longest Valid Parentheses]