Edit Step Ladders+uva+简单dp

最新推荐文章于 2017-06-24 16:52:00 发布

974792789

最新推荐文章于 2017-06-24 16:52:00 发布

阅读量611

点赞数

CC 4.0 BY-SA版权

分类专栏： dp

本文链接：https://blog.youkuaiyun.com/u012870383/article/details/40536235

dp 专栏收录该内容

84 篇文章

订阅专栏

本文详细阐述了如何通过最长升子序列模型计算给定字典中最长编辑步梯的长度，涉及字典排序、字符串匹配及算法优化。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Problem C: 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 w₁, w₂, ... w_n such that the transformation from w_i to w_i+1 is 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

解决方案：如果直#include<cstdio>
#include<cmath>
#include<cstring>
#include<iostream>
using namespace std;
char word[25005][20];
int dps[25005];
int L[25005];
bool judge1(int ii,int jj)
{
    int cnt=0;
    for(int i=0; i<L[ii]; i++)
    {
        if(word[ii][i]!=word[jj][i])
        {
            cnt++;
        }
    }
    if(cnt==1) return true;
    else return false;
}
bool judge2(int ii,int jj)
{
    int i=0,j=0,cnt=0;
    for(i=0; i<L[jj]; )
    {
        if(word[jj][i]==word[ii][j])
        {
            i++,j++;
        }
        else
        {
            cnt++;
            i++;
        }
    }
    if(cnt>=2) return false;
    else return true;

}

int main()
{
    int len=1;
    while(gets(word[len]))
    {
        L[len]=strlen(word[len]);
        len++;
    }
    int Max=1;
    for(int i=1; i<len; i++)
    {
        dps[i]=1;
        for(int j=1; j<i; j++)
        {
            if((L[i]==L[j]))
            {
                if(judge1(i,j))
                {
                    dps[i]=max(dps[i],dps[j]+1);
                }
            }
            else if(L[i]+1==L[j])
            {
                if(judge2(i,j))
                {
                    dps[i]=max(dps[i],dps[j]+1);
                }
            }
            else if(L[i]==L[j]+1)
            {
                if(judge2(j,i))
                {
                   dps[i]=max(dps[i],dps[j]+1);
                }

            }

        }
        if(dps[i]>Max) Max=dps[i];
    }
    printf("%d\n",Max);
    return 0;
}

接用最长升子序列的模型的话，能AC完全靠RP了，就是不要把所有判断都写入一个函数，分开写，然后以差点爆表的时间过了。这题其实还有更优化的方法。

code：