牛客-栈：下一个较大元素1，2

题意：返回数组中比当前元素的索引大的且值大的第一个元素。即当查找数组A中的第二个元素A[1]=13时，要从A[2]开始往后找，发现第一个大于13的元素时21，所以将21保存到对应位置；如果没有找到，则保存-1。

注意：数组中的最后一个元素，没有下一个元素了，所以肯定保存-1。

思路：从数组A 从后往前遍历，先将-1压入栈s中，若A中当前元素大于栈顶元素且栈顶元素不为-1，则循环s.pop(); 直到找到一个比当前元素大的栈顶元素或当前栈顶元素为-1，则将栈顶元素保存在vector数组res中，且将当前元素压栈（因为此时栈顶元素为最大的元素）。最后将res输出。

class NextElement {
public:
    vector<int> findNext(vector<int> A, int n) {
        // write code here
        vector<int> result;
        stack<int> s;
        s.push(-1);
        for(int i=n-1; i>=0; --i){
            while(A[i]>=s.top() && s.top()!=-1)
                 s.pop();
            result.push_back(s.top());
            s.push(A[i]);
        }
        reverse(result.begin(), result.end());
        return result;
    }
};

注意：取模运算有这样一个性质：(a+b)%c = ((a%c)+(b%c))%c      

所以(a[i-1]+a[i-2])%1000000007就相当于(a[i-1]%X+a[i-2]%X)%X  ，用X代替1000000007      

这样就使得a[i-1]、a[i-2]、a[i-1]+a[i-2]都没有溢出，之后再与a[i-3]相加之后取模，使得全部结果没有溢出。

 不要用递归！！！会超时，用迭代~

class GoUpstairs {
public:
    int countWays(int n) {
        // write code here
        if(n==1) return 1;
        else if(n==2) return 2;
        else if(n==3) return 4;
        else
          return countWays(n-1)+countWays(n-2)+countWays(n-3);
    }
}; //超时！

class GoUpstairs {
public:
    int countWays(int n) {
        // write code here
        int a[100001];
        a[0] = 0, a[1]=1, a[2]=2, a[3]=4;
        for(int i=4; i<=n; ++i){
            a[i] = ((a[i-1]+a[i-2])%1000000007+a[i-3])%1000000007;
        }
        return a[n];
    }
}; //迭代

 思路：和之前做的最长公共子序列一样，动态规划！

class LCS {
public:
    int findLCS(string A, int n, string B, int m) {
        // write code here
        int dp[n+1][m+1];
        memset(dp, 0, sizeof(dp));
        for(int i=1; i<=n; ++i){
            for(int j=1; j<=m; ++j){
                if(A[i-1] == B[j-1])
                    dp[i][j] = dp[i-1][j-1]+1;
                else
                    dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
            }
        }
        return dp[n][m];
    }
};