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 <= 1)
            return;

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

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

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



        if(index>=0)
        {
            right = size - 1;
            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 = 0;

        right = size-1;

        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 0;
        stack<int> myStack;
        int index = 0;
        int res=0;
        int start=0,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+1;
                }
                else
                {
                    myStack.pop();
                }
            }
            index++;
        }
        end =index-1;
        if(myStack.empty())
        {
            if(end - start+1 > res )
                res = end -start+1;
                
            return res;
        }
        while(!myStack.empty())
        {
            temp = myStack.top();
            myStack.pop();
            if(end - temp > res)
                res = end -temp;

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