PKU 2564 Edit Step Ladders

Description

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+1 is an edit step for all i from 1 to n-1.

Input

For a given dictionary, you are to compute the length of the longest edit step ladder. The input to your prog <script src="http://hi.images.csdn.net/js/blog/tiny_mce/themes/advanced/langs/zh.js" type="text/javascript"></script> <script src="http://hi.images.csdn.net/js/blog/tiny_mce/plugins/syntaxhl/langs/zh.js" type="text/javascript"></script> ram 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 "stdafx.h"
//============================================================================
// Name        : acmcpp.cpp
// Author      : Yubo Chow
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <queue>
#include <math.h>
#include <algorithm>
#include <set>
#include <limits.h>
#include <float.h>
#include <bitset>
#include <cmath>
#include <vector>
#include <map>
#include <list>
#include <string.h>
using namespace std;

int len[25000];
int dp[25000];

typedef struct {
  int s;
  int child[26];
} node;

node trie[25000 * 16];
int p = 0;

int find(const char *word, int x = 0) {
  if (!word[0] && trie[x].s >= 0) {
    return dp[trie[x].s];
  }
  if (trie[x].child[*word - 'a']) {
    return find(word + 1, trie[x].child[*word - 'a']);
  }
  return 0;
}

void insert(const char *word, int num, int x = 0) {
  if (!word[0]) {
    trie[x].s = num;
    return;
  }
  if (!trie[x].child[*word - 'a']) {
    trie[x].child[*word - 'a'] = ++p;
    memset(trie[p].child, 0, sizeof(trie[0].child));
    trie[p].s = -1;
  }

  return insert(word + 1, num, trie[x].child[*word - 'a']);
}

int main() {
#ifndef ONLINE_JUDGE
  freopen("case.txt", "r", stdin);
#endif

  memset(trie[0].child, 0, sizeof(trie[0].child));
  trie[0].s = -1;
  char word[218];
  int num = 0;
  int ret = 0;
  while (gets(word) && word[0]) {
    dp[num] = 1;
    // modify a letter.
    for (int i = 0; word[i]; ++i) {
      char this_word = word[i];
      for (char j = 'a'; j < this_word; ++j) {
        word[i] = j;
        dp[num] = max(1 + find(word), dp[num]);
      }
      word[i] = this_word;
    }

    // add a letter
    char new_word[218];
    strcpy(new_word + 1, word);
    for (int i = 0; word[i]; ++i) {
      for (char j = 'a'; j <= word[i]; ++j) {
        new_word[i] = j;
        dp[num] = max(1 + find(new_word), dp[num]);
      }
    }
    // delete a letter
    for (int i = 0; word[i]; ++i) {
      if (word[i + 1] < word[i]) {
        strcpy(new_word, word);
        for (int j = i; word[j]; ++j) {
          new_word[j] = word[j + 1];
        }
        dp[num] = max(1 + find(new_word), dp[num]);
      }
    }
    // set result
    ret = max(ret, dp[num]);
    // insert to trie;
    insert(word, num);

    num++;
  }

  cout << ret << endl;

  return 0;
}