ZOJ1499 Increasing Sequences [ dp / 构造最优解 / 高精度 ]

　　题目地址：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1499

　　题意是说给一个长度最大为80的数字序列，要求划分成多个数字，使数字序列是严格递增的。找出使最后一个数最小的解，多解时输出第一个数最大的，还有多解就输出第二个数最大的，etc。

　　这题是要构造最优解的dp问题。在只询问最优值是多少的dp问题中，我们往往只记录子问题的值的信息，而在需要构造一个具体解的问题中，我们要保存更多的信息，以帮助我们从最终状态的最优值返回找到一条路径。这里要记录的往往是从前面哪一个状态转移得到当前状态的，即父亲信息。在这个问题中，我没有记录路径信息，具体怎么做的接着看吧。

　　这个问题中，我们dp数组第一维记录位置信息pos，即“dp到第几位了”，第二维记录如果在这一位后加一个逗号，且前一个逗号在第j+1位后时的是否存在一个满足要求的最优解，有的话，存入最后一个数的值（高精度表示，即第j位到第pos的数字构成的数），否则存INF（高精度的INF）。即是说dp[pos][j]表示：在第一位数字到第pos位数字组成的前缀子序列中，最后一个逗号打在第j位前面（第pos位后的逗号可省略，因为它是子序列最后一位）时是否存在一个满足题意的可行解（== -1？），最优解的最后一个数时多少（dp[pos][j]不等于-1时）。

　　这显然是一个可以递归定义的子问题。怎么递归呢？如果第j+1位后（即第j位前，位数按从高到低定义）存在一个可行解，即存在一个k>=j+1,使得dp[j+1][k] != -1，且dp[j+1][k] < num[j...pos]。那么dp[pos][j]就存在可行解，且解的最后一位是num[j...pos]（第j位到第pos位构成的数）。

　　这个转移很好进行，最高位的状态初始化为转移的“内核”，从次高位开始转移，直到最低位。每一位pos枚举前一个“断点”j的位置，判断是否有可行解，有的话更新dp数组。最后我们在dp[0][0...len-1]中找到使dp[0][k]不为-1的k中，使dp[0][k]最小的所有位置k1,k2,...,ks.假设这些dp[0][ki]都取得最小值minans，那么这些解就是满足条件（使最后一个数最小）的可行解。这里所有使dp[0][k]不为-1的k，都是满足序列严格递增的条件的，从我们的转移描述就可以看出。现在我们如何构造满足是第一个数最大，相同时第二个数最大。。。的最优解呢？看下文。

　　现在我们知道最后一个逗号可以打在第k1,k2,...,ks前面，对这些位置的前一个位置k1+1,k2+1,...,ks+1查看满足dp[ki+1][j]不等于-1的所有j，表示倒数第2个逗号可以到在这些位置j前面，依次递推，这是一个广度优先搜索的过程，意在找出所有使得序列最后一个数取最小值的合法序列中的所有中间状态，成为标记状态。我们从这些任一个状态都可以通过一条仅有标记状态构成的路径回到最后的最优状态。在所有的标记状态中，从前到后贪心的构造一条路径（即第一个数最大，多解时，选第二个数最大，etc）即是最后的结果。

　　这题的高精度我写的巨恶心，贴上代码会被喷吧。

//zzy2012.8.19AC
//dp
#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;

#define sf scanf
#define pf printf
#define pfn printf("\n");
#define ll long long
#define INF (1LL<<62)

typedef struct{
    ll num[10];
    ll k;
}node;

char s[81];
node dp[80][80],nn[80];
ll flag[80][80],mm[80],len;

void ini(){
    for(ll i=0; i<80; i++){
        mm[i] = 0;
        nn[i].k = 0;
        for(ll k=0; k<10; k++)
            nn[i].num[k] = 0;
        for(ll j=0; j<80; j++){
            dp[i][j].k = 9;
            for(ll k=0; k<10; k++)
                dp[i][j].num[k] = 9999999999LL;
            flag[i][j] = 0;
        }
    }
}

void invert(){
    char ss[80];
    for(ll i=0; i<len; i++) ss[i] = s[i];
    for(ll i=0; i<len; i++) s[len-1-i] = ss[i];
}

ll cmp(node &n1,node &n2){
    if(n1.k < n2.k) return -1;
    if(n1.k > n2.k) return 1;
    for(ll i=n1.k; i>=0; i--){
        if(n1.num[i] < n2.num[i])   return -1;
        else if(n1.num[i] > n2.num[i]) return 1;
    }
    return 0;
}

void copy(node &n1,node &n2){
    n1.k = n2.k;
    for(ll i=0; i<=n1.k; i++)
        n1.num[i] = n2.num[i];
}

void add(node &nd,ll d){
    nd.num[0] += d;
    ll i = 0;
    if(nd.k < 9) nd.num[nd.k+1] = 0;
    while(i<=nd.k){
        if(nd.num[i] >= 10000000000LL){
            nd.num[i+1] += nd.num[i] / 10000000000LL;
            nd.num[i] %= 10000000000LL;
        }
        i++;
    }
    if(nd.k < 9 && nd.num[nd.k+1] > 0)
        nd.k ++;
}

node fact(node nd){
    while(nd.k>0 && nd.num[nd.k] == 0){
        nd.k --;
    }
    return nd;
}

void DP(){
    for(ll i = len - 1; i>=0; i--){
        node temp;
        temp.k = 0;
        ll base = 1;
        for(ll j=0; j<10; j++) temp.num[j] = 0;
        for(ll j = i; j<len; j++){
            if(base == 10000000000LL){
                temp.k ++;
                temp.num[temp.k] = 0;
                base = 1;
            }
            temp.num[temp.k] += (s[j] - '0') * base;
            base *= 10;
            node temp2 = fact(temp);
            if(j+1==len){
                copy(dp[i][j], temp2);
                break;
            }
            for(ll k = j+1; k<len; k++){
                if(cmp(dp[j+1][k], temp2) == -1){
                    copy(dp[i][j], temp2);
                    break;
                }
            }
        }
    }
}

void back_search(){
    node min;
    min.k = 9;
    for(ll k=0; k<10; k++)
        min.num[k] = 9999999999LL;
    for(ll i=0; i<len; i++){
        if(cmp(dp[0][i], min) == -1)
            copy(min, dp[0][i]);
    }
    mm[0] = 1;
    add(min,1);
    copy(nn[0],min);
    for(ll i=0; i<len; i++){
        if(mm[i] == 0) continue;
        for(ll j=i; j<len; j++){
            if(cmp(dp[i][j], nn[i]) == -1){
                flag[i][j] = 1;
                if(j+1 == len) continue;
                mm[j+1] = 1;
                if(cmp(dp[i][j], nn[j+1]) == 1) copy(nn[j+1], dp[i][j]);
            }
        }
    }
}

void print(){
    ll stack[80],top = 0,pos = len-1;
    while(pos >= 0){
        node max;
        max.k = 0;
        max.num[0] = 0;
        ll pos2 = 0;
        for(ll i=pos; i>=0; i--){
            if(flag[i][pos] == 0) continue;
            if(cmp(dp[i][pos], max) != -1){
                copy(max, dp[i][pos]);
                pos2 = i-1;
            }
        }
        stack[top++] = pos2;
        pos = pos2;
    }
    pos = len-1;
    ll pointer = 0;
    while(pointer < top){
        ll ed = stack[pointer++];
        while(pos > ed){
            printf("%c",s[pos]);
            -- pos;
        }
        if(ed >= 0) printf(",");
    }
    printf("\n");
}

int main()
{
    while(gets(s)){
        len = strlen(s);
        if(len == 1 && s[0] == '0') break;
        ini();
        invert();
        DP();
        back_search();
        print();
    }
    return 0;
}