Leetcode题解（十一）

31、Next Permutation

题目

这道题目的意思是给定一个序列，找出其按照字典顺序的下一个顺序，如果给定顺序是字典中的最后一个顺序，其下一个顺序则为字典中的第一个顺序。比如：

1,2,3,4,5-----注，后面的顺序去掉逗号

12354

12435

12453

12534

12543

13245

通过上面的例子可以发现规律，在得到13245序列时，其实是从12543的右往左做比较，如果左边比右边数字大，继续往左比较，直到左边数字比右边小，比如12543中，2的右边都是递增的，直到2比5小，因此在543中从右往左找到第一个比2大的数3，交换2,3得到13542，然后将3之后的数字从小到大排序就是所得序列，代码如下：

 class Solution {
 public:
     void nextPermutation(vector<int>& nums) {
         const int size = nums.size();
         int temp,left,right;
         if(size <= )
             return;

         if( == size)
         {
             temp = nums[];
             nums[] = nums[];
             nums[] = temp;
             return;
         }

         int index = size--;//从倒数第二个开始

         while (index>=)
         {
             if(nums[index] >= nums[index + ])//等号很重要，比如（5,1,1）的情况
                 index--;
             else
                 break;
         }

         if(index>=)
         {
             right = size - ;
             while(right > index)
             {
                 if(nums[right] <= nums[index])//等号很重要，比如（5,1,1）的情况
                     right--;
                 else
                     break;
             }

             if(right>index)
             {
                 temp = nums[right];
                 nums[right] = nums[index];
                 nums[index] = temp;
             }
             left = (++index);
         }
         else
             left = ;

         right = size-;

         while (left <= right)
         {
             temp = nums[right];
             nums[right] = nums[left];
             nums[left] = temp;
             left++;
             right--;
         }

     }
 };

-----------------------------------------------------------------------------------------------------分割线-----------------------------------------------------------------------

32、Longest Valid Parentheses

题目

这道题在具体实现的时候，大家第一反应肯定是要用到stack结构，因为在这种成对匹配的题型中，stack是首选的数据结构。仔细分析题目可得知，题目要求找出最长的合法括号对子串，这道题难点在于需要分析会出现的错误种类，经过分析总结，可以得出如下的错误种类：

1、当遍历到字符串当前字符s[index] ==')'并且stack是空的，也就是说，字符串s从0到index-1的字符都能两两匹对，比如“()()())xxxxx”中，index=6时就是这种情况，针对这种情况，如果我事先已经知道了index之前的字符串中合法子串的最大长度，为max，那么从index+1又可看作是一个新的、从"0"开始处理的字符串s';并且问题规模比之前的s更小了；

2、第二种错误种类不能从当前字符来判断，这种错误类型是这中模式s="--------(----(----",s中多出了两个左括号，其他部分都是刚好匹配的合法串；

通过上面的描述，下面用比较正规的描述一下这几种错误：

a、假设X是左右括号刚好匹配的字符串，比如"()()"、"(())"等，X可以是空串，s'是s的子串，s'也可以是空串；

b、错误模式一：s = “X)s'”;

c、错误模式二：s = “X(s'”；

d、除了这两种类型，没有其他的错误类型了；

有人会问s="X)(s'"是哪一种，其实这种错误时两种错误的结合，拆分为"X)"和"(s‘"即可；

针对错误模式一，只需要保存好X的长度，然后从s’开始下一轮算法执行，而s'是比s规模更小的串；

针对错误模式二，需要比较s'的最长合法子串和X的长度，然后进行比较，比如s="--------(----(----",我只需要在栈中保存好这两个多余的左括号的下标，然后从字符串的末尾开始，从栈中弹出栈顶下标（其实就是s中第二个多余字符的下标）index，end-index就是合法字符串的长度，及第二个左括号右边那部分的长度，接着end赋值为index-1，重复如此计算得到最后的结果；

代码如下：

 class Solution {
 public:
     int longestValidParentheses(string s) {
         if(""==s)
             return ;
         stack<int> myStack;
         int index = ;
         int res=;
         int start=,end;
         int temp;

         while (s[index]!='\0')
         {
             if('(' == s[index])
             {
                 myStack.push(index);
             }
             else
             {
                 if(myStack.empty())//错误模式一
                 {
                     if(index - start > res)
                         res = index - start;
                     start = index+;
                 }
                 else
                 {
                     myStack.pop();
                 }
             }
             index++;
         }
         end =index-;
         if(myStack.empty())
         {
             if(end - start+ > res )
                 res = end -start+;

             return res;
         }
         while(!myStack.empty())
         {
             temp = myStack.top();
             myStack.pop();
             if(end - temp > res)
                 res = end -temp;

             end = temp-;
         }

         if(end - start+ > res)
             res = end -start+;
         return res;
     }
 };