uva 10029 Edit Step Ladders

原题：
An edit step is a transformation from one word x to another word y such that x and y are words
in the dictionary, and x can be transformed to y by adding, deleting, or changing one letter. So
the transformation from dig to dog or from dog to do are both edit steps. An edit step ladder is a
lexicographically ordered sequence of words w1,w2,…,wn such that the transformation from wi to
wi+1is an edit step for all i from 1 to n − 1.
For a given dictionary, you are to compute the length of the longest edit step ladder.
Input
The input to your program consists of the dictionary – a set of lower case words in lexicographic order
– one per line. No word exceeds 16 letters and there are no more than 25000 words in the dictionary.
Output
The output consists of a single integer, the number of words in the longest edit step ladder.
Sample Input
cat
dig
dog
fig
fin
fine
fog
log
wine
Sample Output
5
大意：
给你一堆字符串，如果两个字符之间能够通过删除一个字符，增加一个字符，改变一个字符而变换到另外一个字符串，则这两个字符串之间有一条边，现在让你找最长路径。

#include <bits/stdc++.h>

using namespace std;
//fstream in,out;
int dp[25001];
string s[25001],str;
void change(const string &cs,char c,int pos)
{
    str=cs;
    str[pos]=c;
}
void Delete(const string &cs,int pos)
{
    str=cs;
    str.erase(pos,1);
}
void add(const string &cs,char c,int pos)
{
    str=cs;
    str.insert(pos,1,c);
}
void tra(const string &cs,char c,int pos,int flag)
{
    if(flag==0)
        change(cs,c,pos);
    if(flag==1)
        Delete(cs,pos);
    if(flag==2)
        add(cs,c,pos);
}
int BinFind(const string &cs,int r)
{
    int l=0;
    --r;
    while(l<=r)
    {
        int m=(l+r)/2;
        if(s[m]==cs)
            return m;
        if(s[m]<cs)
            l=m+1;
        else
            r=m-1;
    }
    return -1;
}
int main()
{
    ios::sync_with_stdio(false);
    int n=-1,ans=-1;
    while(cin>>s[++n])
    {
        dp[n]=1;
    }
    for(int i=0;i<n;i++)
    {
        for(int k=0;k<3;k++)
        {
            for(int j=0;j<s[i].size();j++)
            {
                for(int l=0;l<26;l++)
                {
                    tra(s[i],'a'+l,j,k);
                    if(str>s[i])
                        break;
                    int mid=BinFind(str,i);
                    if(mid>=0)
                        dp[i]=max(dp[i],dp[mid]+1);
                }
            }
        }
        ans=max(ans,dp[i]);
    }
    cout<<ans<<endl;
    return 0;
}

解答：
上来就想到最长递增子序列问题了，时间复杂度是n^2，结果超时了。联想最长递增子序列问题可以用二分解决，把时间复杂度优化到nlogn。但是最终还是没想出来该怎么解决= =。看了一下别人的解题报告，感觉自己的思路就查一点了，但实际上还是跑远了，没想到枚举按要求改变字符。
枚举每个字符，然后按题目要求改变该字符串，用hash或者是二分在之前的字符串里面查找改变后的字符，然后按照DAG去构造递增最长序列即可。