真帅，问题解决，TC下递归多次会自动退出，放个循环来控制调用递归就解决了。
最终代码：

#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;
 for(;*(p+1);p++)
   if(*p>=*(p+1)) return 1;

 p=a;
 while(*p)      /* 如有大写转成小写 */
   if(*p++<97) *(p-1)+=32;
 return 0;
}

int zifucmp(char *a,char *b)    /* 比较两字符 */
{
 int i=len-1;
 for(;i>=0;i--)
   if(a[i]!=b[i]) return 1;
 return 0;
}

void funsuan(int n)            /* 递归算法 */ 
{
 if((zifucmp(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]=96;
 b[i]=0;
 while(1)
   if(zifucmp(a,b)!=0)
     funsuan(len-1);
   else
     break;

 printf("%s=%ld\n\n",b,sum);
 getch();
 return 0;
}

更改：最坏情况输入最大abcdefghijklmnopqrstuvwxyz，原来是19秒左右出结果，现在6秒内出结果，唉，真得是慢慢改进。

[ 本帖最后由 UserYuH 于 2009-10-31 18:13 编辑 ]

请UserYuH做一下自己代码的效率分析

StarWing83 嗯，一个个数过来的没效率，但这题就是慢慢数也很不好搞，很头疼，只有这样了，有待慢慢改进。

其实我想过用一个数组num[26]存住a ab abc abcd abcde ....的值,这样输入字符串,判断字符串长度,
根据字符串长度选择数值num和起始的判断字符串,如输入amnpz就可以从abcde开始判断了,这样效率会高一点,但我懒得统计
数组num了...

我就觉得这题头疼，谁觉得不头疼的就放个有效代码出来。
我开始的的算法是，26+25+24……+1+1=abc,   ab=26+1=27,   bc=27+25,  但这方法没能实现，要快度可以研究这方法。
怕我的代码出来了，没人继续了，这里说这话是激厉正在思考这题的朋友继续努力，我只是打个头阵，期待好的算法。

UserYuH：此题我已解决，提示：组合数。

我写了Python的代码，就不贴出来了，你再想想，如果需要，我翻译成C然后贴代码～～
另外，abcdefghijklmnopqrstuvwxyz的答案是：67108863

abcdefghijklmnopqrstuvwxyz的答案是：67108863
这个结果和我的一样，我的代码昨天也改进了一点，修改在上面，不是原来的一步步算，是26为一步的算，你说的组合数是怎么说？
ab abc abcd abcde ……这样吗？

我贴出Python代码你分析一下吧：

def c(n, m):
    """
    计算组合数
    """
    list = [1] * (m + 1)
    for i in range(1, n + 1):
        list[0] = 1
        t1 = list[0]
        for j in range(1, min(i, m + 1)):
            t2 = list[j]
            list[j] += t1
            t1 = t2
    return list[m]
def get_ord2(str):
    res = 0
    for i in range(0, len(str)):
        res += c(26, i)
    nchr = lambda s: ord(s) - ord('a')
    pos = (lambda i:
            'a' if i == 0 else chr(ord(str[i - 1]) + 1))
    for i in range(0, len(str)):
        for j in range(26 - nchr(pos(i)) - 1,
                26 - nchr(str[i]) - 1, -1):
            res += c(j, len(str) - i - 1)
    return res
while True:
    print get_ord2(raw_input())

这个是C代码，如果要在TC下编译，请把int换成long：

#include <stdio.h>
#include <string.h>
#define N 27
int main(void)
{
    int dp[N][N];
    char str[N + 1];
    int i, j;
    for (i = 0; i <= 26; ++i)
    {
        dp[i][0] = dp[i][i] = 1;
        for (j = 1; j < i; ++j)
            dp[i][j] = dp[i-1][j-1] + dp[i-1][j];
    }
    while (scanf("%s", &str[1]) == 1)
    {
        int res = 0, len = strlen(&str[1]);
        str[0] = 'a' - 1;
        for (i = 0; i < len; ++i)
        {
            res += dp[26][i];
            for (j = str[i] + 1; j < str[i + 1]; ++j)
                res += dp[26 - (j - 'a') - 1][len - i - 1];
        }
        printf("%d\n", res);
    }
    return 0;
}

好代码，等于26*26画个矩阵图，每行都有规律的递增，每列都有一个初值和一个基数，按这规律我也修改下我的代码，做到结果秒出。

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