经过努力，由原来的一步步算，到26为一步算，再到现在的层层累加算，终于可以秒出，改进真难呀，改得代码都变长了。
·
·

#include <stdio.h>
#include <string.h>

int len,flag=0;
long sum=0,m;
char a[27],b[27];

int panduan(char *a)  /* 判断字符串是否为升序 */
{
char *p=a;
while(*p)      /* 如有大写转成小写 */
   if(*p++<97) *(p-1)+=32;
p=a;
for(;*(p+1);p++)
   if(*p>=*(p+1)) return 1;
return 0;
}

void chushi(char *b,int len)  /* 取字符最大长度的有序值 */
{
 long n=0,j,jishu=26,js,ji[27];
 int i,k,m=26;
 sum=jishu+1;
 for(i=0;i<27;i++)
   ji[i]=1;
 for(i=2;i<len;i++)
   {
    for(n=k=0,j=jishu;k<m;k++,j-=js)
      {js=ji[k],ji[k]=j-js,n+=ji[k];}
    jishu=n;
    sum+=n;
    m--;
   }
 if(a[0]>b[0])
   {
    for(n=k=0,j=jishu;k<a[0]-(b[0]+1);k++,j-=js)
      {js=ji[k],ji[k]=j-js,n+=ji[k];}
    sum+=n;
   }
 for(i=0;i<len;i++)
   b[i]+=i+(a[0]-('a'-1));
}

void funsuan(int n)            /* 递归算零头 */
{
if((strcmp(a,b))==0)
    return;
if(n+1==len)
   {
    if(m==1000){m=0;return;}
    if(len!=1)
      {
       if(a[n-1]!=b[n-1] || !flag)
     {
      flag=1;
      sum+='z'+1-b[n];
      b[n]+='z'+1-b[n];
     }
       else if(flag)
     {
      flag=0;
      sum+=a[n]-b[n];
      b[n]+=a[n]-b[n];
     }
      }
    else
      {
       sum+=a[0]-b[n];
       b[n]+=a[0]-b[n];
      }
    m++;
    if(b[n]>'z')
      {
       funsuan(n-1);
       b[n]=b[n-1]+1;
       funsuan(n);
      }
    else funsuan(n);
   }
else
   {
    b[n]++;
    if(b[n]>=b[n+1]-1)
       {
        funsuan(n-1);
    b[n]=b[n-1]+1;
       }
   }
}

int main(void)
{
int i;
while(1)
   {
    gets(a);
    if(panduan(a))
      printf("input error!\n");
    else
     break;
   }
len=strlen(a);
for(i=0;i<len;i++)
   b[i]='a'-1;
b[i]=0;
if(len>1)chushi(b,len);
while(1)
  {if(strcmp(a,b)!=0)
      funsuan(len-1);
   else break;
  }
printf("%s=%ld\n\n",b,sum);
getch();
return 0;
}

[ 本帖最后由 UserYuH 于 2009-11-1 21:19 编辑 ]

所以你应该研究一下，为啥我的代码比你的短这么多。

汗~我还没写出代码呢

你的代码很短，很精练，我也深入了解，要不我的代码也不能达到秒出，我只是想把我的代码写的完善点，所以加了又加，代码长了点，下次再写这种题代码一定能很短，就像之前说的，慢慢改进，我也慢慢进步。

我考虑的也多了，有容错在里头，
如输入：bca  或字符串长度超出26个，会提示错误信息，
如输入:Abc  大小写均可。
但这不重要了，主要是算法。

应该是在一个 杨辉三角 中找规律，现在已经有些眉目了。呵，看来这题还真的有意思。

我操，这不是汉诺塔的问题吗？
  前几天看老谭书上介绍的。这叫递推？与递归相反的。

TO:UserYuH 我们修改一下题目，不再是abcd。。。z，而是改为数字。数字最大可能有为1000个，分别对应以前的字母，1为a，2为b，以此类推，规则相同，比如输入26 2 1 2 输出27（输入数据解释见下），那么此题怎么做呢？你的代码能不能秒出呢？另：为了防止大数字溢出，结果对10000取模就可以了。你可以针对这道题目再写一份代码么？当作ACM赛题写，不用管容错。

输入：
数据分多组，每组数据一行，每行第一个数字d为字母表内的字母数，第二个数字n为输入串的长度，之后有n个数字a[i], (1 <= a[i] <= d）。表示输入的字符串，每个数字代表一个字母，比如输入26 2 1 2，表示当前字母表有26个字母，输入两个字母的字符串，如果用英文字母表示，该串为ab。

输出：
根据上述规则，输出字符串对应的数字，对10000取模就可以了。

示例输入：
26 2 1 2

示例输出：
27

TOLS：哪里有汉诺塔的痕迹？我怎么没看出来？

TO广陵：确切地说，是通过排列组合寻找的规律而已……

我的代码取零头那对原题最坏情况还可以达到妙出，对于你新说的题最坏情况就不行，但我有另一种有效的方法了，我再调试，调试好了用来试下你新出的题。

1