UVa1375- The Best Name for Your Baby

提示：

1. 这是一个dp题 ， 不要妄想用bfs来写此题 ， 样例都过不了

2. dp方程的含义: d [ i ] [ j ] , 用一个大写字母(i+'A') 扩展成长度为j的字典序最小的字符串(不含大写字母)

此处请思考些时间 ， 怎么转移状态;

3. 下面是我自己的转移方法 ， 与紫书上的不同 ， 紫书上把边拆分成了很多块 ， 但对于初学做这个题的人来说 ， 把边颠过来倒过去就够呛了 ， 所以我的解法在保证时间的情况下尽量去降低代码和理解的难度：

下文中所有的状态指d[i][j] , 所有的边指的是原题中形如"A=Sbs.."的文法

首先考虑转移方程:（分成同层和非同层两个部分）

对于d [ i ] [ j ] ，遍历 i 的每一条边 ， 尝试通过这些边来从非同层的状态转移(有一点抽象 , 想象把一个字符串中的所有大写字母换成另一字符串 ， 并拼接在一起) ， 这就是我们要做的事情 ，类似于每一个大写字母贡献一个长度 ， 然后小写字母呆在原来的位置，  至于非同层状态是指大写字母贡献的那个长度要严格小于 j (即是现在计算的长度)

同层dp , 就是一个dijktra 算法 ， 因为在同一层中d值我们只用较小的状态去更新较大的状态 ， 与dijkstra的思想不谋而合

如果能够同层dp  , i 肯定有这样一些转换边 ， 转换出来的字符串都是大写字母 ， 我们从中选择一个大写字母来p , 用d[p][j]来更新 d[i][j] ， 当然除了p以外的所有大写字母都可以直接或间接的变成空串.

答案就是 d[ 'S'-'A' ][ l ] 

注意: 这个dp的起始需要特殊判断 ， 即要知道哪些大写字母可以转化成空串 ， 我用了一个bellmanFord算法 ， 不知道是否有更简洁的做法呢

//
// main.cpp
// UVa1375_NEW+
//
// Created by Fuxey on 15/10/20.
// Copyright © 2015年 corn.crimsonresearch. All rights reserved.
//

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <list>
#include <stack>
#include <vector>
#include <deque>
#include <set>
#include <map>
#include <string>
#include <algorithm>

using namespace std;

// d[i][j] using uppercase i+'A' to make a the minist string of length j

struct edge
{
int u , all;
string to;
edge(int u = 0,string to = ""):u(u),to(to){}
};

vector<edge> e;

bool zero[30];

inline int id(char c){ return c-'A'; }

vector<int> g[30];

int can[30][30];
string d[30][30];

int main(int argc, const char * argv[]) {

int n , l;

while(cin>>n>>l && n+l)
{
memset(zero, 0, sizeof(zero));
e.clear();
for(int i=0;i<26;i++) g[i].clear();
memset(can, 0, sizeof(can));

while(n--)
{
string op;
cin>>op;
if(op.size()==2) zero[id(op[0])] = 1;
else g[id(op[0])].push_back((int)e.size());
e.push_back(edge(id(op[0]) , op.substr(2,op.size()-2)));
e.back().all = 1;
for(int i=2;i<op.size();i++) if(islower(op[i])) { e.back().all = 0; break; }
}

bool update = true;
for(int i=1;i<=26 && update; i++)
{
update = false;
for(int j=0;j<e.size();j++) if(e[j].all && !zero[e[j].u])
{
bool ok = true;
for(int k=0;k<e[j].to.size();k++) if(!zero[id(e[j].to[k])]) { ok = false; break; }
if(ok) zero[e[j].u] = 1 , update = true;
}
}

for(int i=0;i<e.size();i++) if(e[i].all)
{
bool ok = true;
for(int j=0;j<e[i].to.size();j++) if(!zero[id(e[i].to[j])]) { ok = false; break; }
if(ok) for(int j=0;j<e[i].to.size();j++) can[id(e[i].to[j])][e[i].u] = 1;
else
{
int cnt = 0 , wh = 0;
for(int j=0;j<e[i].to.size();j++) if(!zero[id(e[i].to[j])]) cnt++ , wh = id(e[i].to[j]);
if(cnt==1) can[wh][e[i].u] = 1;
}
}

for(int i=0;i<26;i++) for(int j=0;j<=l;j++) d[i][j] = "{";

for(int i=0;i<26;i++) if(zero[i]) d[i][0] = "";

string now[30]; int book[30];
for(int i=1;i<=l;i++)
{
for(int j=0;j<26;j++) for(int k=0;k<g[j].size();k++) // I am calculating d[j][i]
{
edge& enow = e[g[j][k]];
int cnt = 0;
for(int ll = 0;ll<=i;ll++) now[ll] = "{"; now[0]="";
for(int ll = 0;ll<enow.to.size();ll++)
{
if(islower(enow.to[ll]))
{
cnt++;
for(int q=i;q>=cnt;q--) if(now[q-1]!="{") now[q] = now[q-1]+enow.to[ll]; else now[q] = "{";
now[cnt-1] = "{"; // it is impossible
}
else
{
for(int q = i;q>=cnt;q--)
{
string Min = "{"; // each letter must do something to the answer , or it can not be successful
for(int p = min(q-cnt,i-1);p>=0;p--)if(d[id(enow.to[ll])][p]!="{")
Min = min(Min , now[q-p]+d[id(enow.to[ll])][p]);
now[q] = Min;
}
}
}
d[j][i] = min(d[j][i] , now[i]);
}

// samelevel kind
memset(book, 0, sizeof(book));
for(int j=1;j<=26;j++)
{
string Min = "{" ; int x = 0;
for(int k=0;k<26;k++) if(!book[k] && d[k][i]<=Min) Min = d[k][i] , x = k;
book[x] = 1;

for(int k=0;k<26;k++) if(can[x][k]) d[k][i] = min(d[k][i] , Min);
}
}
if(d[id('S')][l]=="{") cout<<"-\n";
else cout<<d[id('S')][l]<<endl;
}

return 0;
}