Codeforces 611D New Year and Ancient Prophecy (Good Bye 2015 D题)

题意

• 给你一个数字组成的字符串
• 把它分成几个子串，使得每个串组成的数，没有前导0，且位置在前的字符串组成的数要严格小于位置在后的字符串
• 问你有多少种不同的分法

思路

• dp，dp(i,j)表示以i结尾的子串，它划分后，最后一个串长度小于等于j的分法数。
• 当更新dp(i,j)时，我们看子串str(0, i-j)，它能不能放一个j长的子串，也就是说，如果以i-j结尾的，j长子串 < 以i结尾，j长子串时，那么dp(i,j) = dp(i,j-1) + dp(i-j, j)，不行，则dp(i,j) = dp(i,j-1) + dp(i-j, j-1)
• 当然，转移中还需要考虑有没有前导0，这个比较简单就不说了
• 最后的问题，就是我们如何快速的比较以i-j结尾的，j长子串和以i结尾，j长子串
• 由于所有子串的个数不会超高n^2个，所以我们的想法就是给长度相同的子串，赋一个权值，使得权值大的，子串字典序也大，那么等比较时，我只要比较这个权值即可
• 具体怎么赋权值，把所有后缀排序即可，然后用相邻位置的后缀子串的字符依次比较，如果字符一直相同，则让该长度下，以当前两个后缀起始点为开头的子串权值相同，直至后面的后缀的字符>前面的结束，这之后的权值都更新为当前的最大。

实现

#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
typedef long long ll;
typedef pair<int,int> pii;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
const int maxn = 5005;
const int mod = 1000000007;

int dp[maxn][maxn];
int id[maxn][maxn];

vector<pair<string,int> > vec;

int n;
int m = 1;
char strtmp[maxn];
string str;


int main(){
    scanf("%d",&n);
    getchar();
    gets(strtmp);
    str = strtmp;
    vector<string> v;
    for (int i=0;i<n;i++){
        vec.pb(mp(str.substr(i,n-i),i));
    }
    sort(vec.begin(),vec.end());
    for (int i=0;i<vec[0].fi.length();i++)
        id[vec.begin()->se][i+1] = 0;
    for (int i=1;i<vec.size();i++){
        int j = i-1;
        int k;
        for (k=0;k<vec[j].fi.length();k++){
            if (vec[i].fi[k] != vec[j].fi[k]){
                break;
            }
            id[vec[i].se][k+1] = id[vec[j].se][k+1];
        }
        for (;k<vec[i].fi.length();k++)
        {
            id[vec[i].se][k+1] = m;
        }
        m++;        

    }

    dp[0][1] = 1;
    for (int i=1;i<n;i++){
        for (int len=1;len<=i+1;len++){
            dp[i][len] = dp[i][len-1];
            if (len-1 > i)
                continue;
            int j = i - len + 1;
            if (str[j] == '0')
                continue;
            if (j == 0){
                dp[i][len] = (dp[i][len] + 1) % mod;
                continue;
            }


            if (j - len >= 0){
                if (id[j][len] > id[j-len][len]){
                    dp[i][len] = (dp[j-1][len] + dp[i][len]) % mod;
                }
                else{
                    dp[i][len] = (dp[j-1][len-1] + dp[i][len]) % mod;
                }
            }
            else
            {
                dp[i][len] = (dp[j-1][j] + dp[i][len]) % mod;
            }

        }
    }
    cout << dp[n-1][n] << "\n";
    return 0;
}