1375 - The Best Name for Your Baby

我有话说：
个人认为这是一道比较难的动态规划题目。因为无论从状态定义，还是状态转移方程，都很抽象。求最小字典序的字符串。很醉啊。
好了，评价完了。下面讲讲解决的办法。
1.第一步，简化文法。我们把所有的转换规则都先变成S->AB这种形式。总数不超过maxn*maxlen；
2.状态定义：dp[i][L]表示符号i能变成的、长度为L且字典序最小的字符串。
3.转移方程：dp[i][L]=min{dp[j][p]+dp[k][L-p]|存在规则i->jk,0<=p<=L};
4.算法入门经典上说这在逻辑上是没有问题的，但是可能会无限递归。如果有两个规则A->BC,B->AC,那么计算dp(A,L)时需要调用dp(B,L)，而计算dp(B,L)时又需要调用dp(A,L)……
5. 上述情况只有在p=0或p=L才会出现所以大多数情况可以按L从大到小计算。
6. 对于dp[i][L]如果有满足状态dp[j][0]有定义(当然，此时它肯定为空串)，且有规则S->ij或者S->ji,那么用dp[i][L]更新dp[S][L]。

#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <map>
#include <queue>
#include <string>
using namespace std;
const int maxn=50+5;
const int maxlen=20+5;
const int maxs=50*20+52+5;
//我们首先把所有规则如S->ABaA;拆成三个规则：S->AP1;P1->BP2;P2->aP3;所以对于一个长度为x字符串可以拆分成x-1条规则.
//拆分后所有的大小写字母都称为符号symbol所以就会有maxn*（maxlen-1）

int n,L,ns;
string rule[maxn];
string sym[maxs];
int car[maxs],cdr[maxs];
string dp[maxs][maxlen];//状态定义:dp[i][j]表示初始为编号i的字符串变成长度为j的最小字典序的不可操作字符串
bool is_all_terminal(const string& s)
{
    for(int i=0;i<s.length();i++)
        if(!(s[i]>='a'&&s[i]<='z'))return false;
    return true;
}
string min(const string& a,const string& b)
{
    if(a=="-")return b;
    return a<b?a:b;
}
struct Node{
    int x;
    string s;
    Node(int x,string s):x(x),s(s){}
    //越小的串越有可能得到更优的解，所以应当排在前面。
    bool operator < (const Node& rhs)const{
         return s>rhs.s;
    }
};
struct Transform{
    int target,empty;
    Transform(int t,int e):target(t),empty(e){}//;
};
vector<Transform>tr[maxs];
bool vis[maxs];
//对于dp[i][L]如果有满足状态dp[j][0]有定义(当然，此时它肯定为空串)，且有规则S->ij或者S->ji,那么用dp[i][L]更新dp[S][L]。
void search (int len)
{
    memset(vis,0,sizeof(vis));
    priority_queue<Node>q;
    for(int i=0;i<ns;i++)
    {
        if(dp[i][len]!="-"){
            q.push(Node(i,dp[i][len]));
        }
    }

    while(!q.empty())
    {
        Node u=q.top();q.pop();
        int x=u.x;
        string s=u.s;
        if(vis[x])continue;
        vis[x]=true;
        for(int i=0;i<tr[x].size();i++)
        {
            int target=tr[x][i].target;
            int empty=tr[x][i].empty;
            if(dp[empty][0]==""&&(dp[target][len]=="-"||s<dp[target][len]))
            {
                dp[target][len]=s;
                q.push(Node(target,s));
            }
        }
    }
}
map<string,int>symid2;
int ID(const string& s)
{
    if(!symid2.count(s)){
        sym[ns]=s;
        symid2[s]=ns++;
    }
    return symid2[s];
}
void add_intermediate_symbol(const string& S)
{
    int s=ID(S);
    if(S.length()<2)return;
    int h=ID(S.substr(0,1));
    int t=ID(S.substr(1,S.length()-1));
    tr[h].push_back(Transform(s,t));
    tr[t].push_back(Transform(s,h));
    car[s]=h;cdr[s]=t;
}
int main()
{
    while(cin>>n>>L&&n)
    {
        symid2.clear();
        ns=0;
        ID("");//保证sym[0]="";
        for(int i=0;i<maxs;i++)tr[i].clear();

        for(int i=0;i<n;i++)
        {
            cin>>rule[i];
            int left=ID(rule[i].substr(0,1));
            int right=ID(rule[i].substr(2));
            tr[right].push_back(Transform(left,ID("")));//S=AbC  AbC can be transformed to S
            int len=rule[i].length();
            for(int j=2;j<len;j++)//wronged:for(int j=2;j<rule[j].length();j++)
            {
                add_intermediate_symbol(rule[i].substr(j));
            }
        }
        for(int i=0;i<ns;i++)
            for(int j=0;j<=L;j++)
                dp[i][j]="-";
        dp[0][0]="";

        for(int j=0;j<=L;j++)
        {
            for(int i=0;i<ns;i++)
            {
                if(sym[i].length()==j&&is_all_terminal(sym[i]))dp[i][j]=sym[i];
                if(sym[i].length()<2)continue;//wrong。如果没有添加这一语句，那么后续处理时:
                //因为没有可能得到长度小于2的符号，只有长度1或者0两种情况。0不可能变换，1的话
                //那么s1,s2中（一定有一个是空串）不，应该说压根就不存在
                int s1=car[i],s2=cdr[i];
                for(int p=1;p<j;p++)
                {
                    if(dp[s1][p]!="-"&&dp[s2][j-p]!="-"){
                        dp[i][j]=min(dp[i][j],dp[s1][p]+dp[s2][j-p]);
                    }
                }
            }
            search(j);
        }
        cout<<dp[ID("S")][L]<<endl;
    }
    return 0;
}