250 ：

递推，从左下角到右下角走一条，剩下的都是子结构

const int mod =  1000000007;

long long dp[1000010] , s[1000010];

class

TrafficCongestion{

    public :

    int theMinCars(int n) {

        long long ans = 0;

        dp[0] = 1;

        dp[1] = 1; s[0] = 1; s[1] =2;

        REP(i,2,n) {

            dp[i] = (1 + s[i-2] + s[i-2] ) % mod;

            s[i] = (s[i-1] + dp[i]) % mod;

        }

        return dp[n];

    }

};

500pt:

给你从小到大n种数字的个数，让你判断由全部的数字组成的序列中lisnum = k的有多少个。。lisnum就是一个序列递增的段数

dp[i][j] 表示前i种数产生了j个lisnum的数量，然后放上i+1种数时需要枚举放几个数放在那些递增段的后面，这样子放并不会增加lisnum的数量，假设放t个数在递增段的后面

那么现在总共有sum+1-j+t个位置是会增加lisnum的，我们要将剩下的cnt[i+1] - t个数放到这些位置去，就是高中的隔板法了

#include <cstdio>

#include <cstring>

#include <vector>

using namespace std;

typedef long long lld;

const int mod = 1000000007;

int dp[2][1500];

int C[1500][1500];

class LISNumber {

    public :

    int count(vector <int> cnt, int K) {

        C[0][0] = 1;

        for(int i = 1; i < 1500; i++) {

              C[i][0] = C[i][i] = 1;

             for(int j = 1; j < i; j++) {

                  C[i][j] = C[i-1][j] + C[i-1][j-1];

                  if(C[i][j] >= mod) C[i][j] -= mod;

             }

        }

        dp[0][cnt[0]] = 1; int sum=cnt[0];

        for(int i = 1; i < cnt.size(); i++) {

            memset(dp[i&1],0,sizeof(dp[0]));

            for(int j = 0; j <= K; j++) if(dp[(i-1)&1][j]) {

                for(int t = 0; t <= min(cnt[i],j); t++) {

                    int box = sum + 1 - j + t;

                    int balls = cnt[i] - t;

                    dp[i&1][j+balls] += (lld)dp[(i-1)&1][j] * C[j][t] % mod * C[box-1+balls][balls] % mod;

                    if(dp[i&1][j+balls] >= mod) dp[i&1][j+balls] -= mod;

                }

            }

            sum+=cnt[i];

        }

        return dp[(cnt.size()-1)&1][K];

    }

};

// Powered by FileEdit

// Powered by TZTester 1.01 [25-Feb-2003]

// Powered by CodeProcessor