算法的脑力风暴。。

母亲说"冬"是节，所以今天下午后没有看书学习，跑去游戏机房狂玩Drifting。
回来后给读书的、考研的、工作的朋友们发个祝福。。

习惯性到CSDN看看贴子，发现有个标题很特别，叫"如何提高编程速度"
http://community.csdn.net/Expert/TopicView3.asp?id=5248357
区区没有回复这个贴子，因为这个问题本身有问题。。
<<<<<
楼主的post内容如下：
作　　者：         dirtysalt (李纳斯)
等　　级：        
信 誉 值：         100
所属论坛：         C/C++ C语言
问题点数：         20
回复次数：         18
发表时间：         2006-12-22 9:35:59
我看了网上一位网友的帖子，做百度笔试题
求123456789字典顺序中一个特定的数

他们居然只用5分钟就想出来，花了20分钟解决
我，我居然花半个小时考虑，用了一个半小时才完全写正确

问题出来了，如何提高编程速度
<<<<<

一看又是百度的面试题，就知道都考的是算法了。题目没看明白。楼主表述不清，
还好，后来又补了一贴，区区才明白他问什么

<<<<<
回复人：dirtysalt(李纳斯) ( 一级(初级)) 信誉：100     2006-12-22 15:45:10     得分:0
我针对的并不是某个问题来问你们。只是当我看到同样的人做这道题目时，我有些感概。
具体题目是编写一个函数int getline(int n)
对于n=1 返回123456789
n=2返回123456798
n=3 123456879
以此类推
这个问题是百度一道面试题，我已经做完了，所以不需要劳烦大家。
只是看到别人花很少时间就写完，我有些感概。
我发现我的毛病，一些程序中小问题，导致调试时间很长，所以速度下降
我想知道你们是怎么解决这个问题的，如何提高编程速度（当然，按Jamesonang(Jameson Ang) 说就是要在好的算法下，尽快完成程序)。
<<<<<

题目的意思就是对一个字符串"123456789"来一个字典序全排列，然后按输入求出第N个排列。。
信手打开命令行，输入perl -e "print 9*8*7*6*5*4*3*2*1"
结果是 362880。。不知道百度的人对时间和空间复杂度要求是什么。这个问题规模不大。

所以先用脚本来写一个吧~
下面这个perl程序是随手写出来的，不考虑效率，在区区的机器上运行6秒左右可以算出所有的结果

#perl
my @arr = 1..9;
my @permute;

sub make_permute{
    my ($head_str,$idx,$arr) = @_;
    if ( 8 == $idx){
        push @permute, $head_str . $arr->[0];
        return;
    }
    for $num (0..@$arr-1){
        ($arr->[$num],$arr->[0]) = ($arr->[0],$arr->[$num]);
        my $h = shift @$arr;
        make_permute($head_str . $h, $idx+1, $arr);
        unshift @$arr, $h;
        ($arr->[$num],$arr->[0]) = ($arr->[0],$arr->[$num]);
    }
}

make_permute("",0,@arr);
@permute = sort {$a <=> $b} (@permute);
#my $FH;
#open $FH,">","./out.txt";
#print $FH "$_ " for (@permute);  #打印到文件
#print  "$_ " for (@permute);     #打印到
####

其实在思考题目时，这个perl程序并没有完全写出来，运行6秒应该也算是超时才对，
不过，这个脚本很容易实现，而且可以拿来当测试使用。。

如果对这个程序优化一下，速度可以提高很多的，第一个perl程序很烂，是因为最近没怎么
用perl，所以有些生疏。正常的perl黑客，应该可以不费吹灰之力写出下面的版本：

#perl
my $top = 9;
my @arr = 1..$top;
my @permute;
sub make_permute{
    my ($head_str,$idx,$arr) = @_;
    if ( $top-1 == $idx){
        push @permute, $head_str . $arr->[0];
        return;
    }
    for $num (0..@$arr-1){
        my @tarr = @$arr;
        my $h = splice @tarr,$num,1;
        make_permute($head_str . $h, $idx+1, @tarr);
    }
}
make_permute("",0,@arr);
#########################

改进过的程序可以对付小规模的问题，更易于调试。代码不但简洁了，速度也变快了，区区
的机子算出所有的362880个排列只需要3.9秒~~~

也就是说，虽然未必在时空上达到题目要求，但的确有可能有人几分钟就先拿到结果（不是区区，
版本一和版本二上的修改，花了区区不少时间）~

那现在我们假设时间要求是1秒吧~这个算法行得通么？应该没问题，如果对perl的运行效率和内存
字符串的操作有深入理解，应该知道如果用C语言来实现，可以优化到一秒内的

/***********************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define TOP 9

char *num_str;
char *long_permute;
int   long_idx;

int factor(int n_){
    return n_==1?1:factor(n_-1)*n_;
}

void fill_n(char *arr_, int n){
    int i;
    for(i=0; i<n; ++i){
        arr_[i] = '0'+i+1;
    }
    arr_[i] = 0;
}

void make_permute(int deep_){
    int i,k;
    char t;
    if(TOP-1 == deep_){
        strcpy(long_permute+long_idx, num_str);
        long_idx += TOP+1;
        return;
    }

    for(i=0; i < (TOP - deep_); ++i){
        t = num_str[deep_+i];
        for( k=deep_+i; k>deep_ ; --k){
            num_str[k] = num_str[k-1];
        }
        num_str[deep_] = t;

        make_permute(deep_+1);
       
        for( k=deep_; k<deep_+i; ++k){
            num_str[k] = num_str[k+1];
        }
        num_str[deep_+i] = t;
    }
}
void output(void){
        FILE *outfile;
        int i,len;
        len = factor(TOP);
        outfile = fopen("out1.txt","w");
        for(i=long_idx=0; i<len; ++i, long_idx += TOP+1 ){
            fprintf(outfile,"%s ",long_permute+long_idx);
        }   
}
int main(void){
    num_str = malloc( (TOP+1) * sizeof(char) );
    long_permute    = malloc( factor(TOP) * sizeof(char) * (TOP+1) );
    long_idx        = 0; 
    fill_n(num_str,TOP);
   
    make_permute(0);
   
    output();
    return 0;
   
}
/***********************************************/

在区区的机器上，这个C程序只用0.3秒就把所有的排列输出到out1.txt。。呵呵。。看来
最简单的方法在时间上都能满足要求了。。
上面的三个程序，并不是为了表明C比perl要快3.9/0.3-1倍，因为在最后一个C版程序中，
区区自行管理内存，省去了很多不必要的操作，这个在perl当中也是可以优化实现的。。

写了一大堆程序之后，回来原先贴子上的话题：怎么加快编程速度。。
那区区认为，通过上面的例子就知道，如果你手头有很好的工具语言，有类似问题的解决
经验，对自己所用的语言有很深入的理解，有很广的知识面，而且还经常编程，经常调试，
编程的速度自然而然就快了~~~

上面的算法，是区区连想都没想就已经存有的。全排列是以往做过的东西。

！！没有结束~
如果只是这样，那也太丢人了，C版的程序是很快，但是里面有个大得可怕的常数：
long_permute    = malloc( factor(TOP) * sizeof(char) * (TOP+1) );
这条语句得占去好多MB的内存，如果对空间复杂度也有要求咋办？

不过还好，也没什么紧张的，因为上面那几个程序区区一开始在思考时都没有去写，区区
开头就在思考时空复杂度都很小的算法——————要不然，这道题应该没什么意思了~

其实准确地说，区区是在找规律：123456789、串、字典序、全排列，全都是有规律的说~
列了列草图，从小的做起吧
1  0

12 0
21 1

123 000
132 001
213 010
231 011
312 100
321 101

1234  0000
1243  0001
1324  0010
1342  0011
1423  0100
1432  0101
2134  0111
2143  1000

一开始很直觉地去找寻2进制数与排列的关系。。在长度1-3倒是隐约发现一个共同点：某位上
如果置1，排列上就与前一字符互换。很开心，只是一试就有个规律。开始求证么？NONONO，
四位排列也不多，所以也画出来。…………很快可以看出来，这个规律不对。

回头一想：当然不对，一个以阶乘增长，一个以乘幂增长。。。
等等~~~区区再回头一想：增长……阶乘增长————不正是规律么？
1 2 6 24
再看头一个字符出现的次数，呵呵……正好。。。
一个串的字典序排位，第一个字符与剩余字串排列数目(阶乘)有关，剩余字符串可以递推~
公式：对于长度为N的字符串，求第K的排列时，首字符应该是 ceil( K / ((N-1)!) )号字符

心算检验~~正确，写代码吧。。

#perl
sub factor{
    return $_[0] == 1 ? 1 : factor($_[0]-1) * $_[0];
}
sub k_of_dict{
    my ($n,$k,$arr) = @_;
   
    for(my $i=0; $i<$n-1; ++$i){
        my $t = $k/factor($n-$i-1);
        $k = $k % factor($n-$i-1);
        next if int($t)==0;
        splice @$arr, $i, $t+1 , $arr->[$i+$t], @{$arr}[$i..$i+$t-1];
    }
}

#my $top=9;#输出到文件。
#my $FH;
#open $FH,">","out2.txt";
#my $len = factor($top);
#for (my $i=0;$i<$len;++$i){
#    my @arr = 1..$top;
#    k_of_dict($top,$i,@arr);
#    print $FH @arr," ";
#}
###############################################

最后的这个程序，对于输出单个字典位置上的字符串，无论时间还是空间复杂度上，都不再
与N的阶乘有关。。相比与之前的版本，不再需要多余的内存了。。如果进一步发掘，可以找
出更好的算法。

丰富的数据结构知识、数学建模知识、分析统计可以找出更好的算法~~



本来如果还有时间，是打算写一个飞速的C版本。
但是完成这四个程序，脑力体操做得也很累~~

我们毕竟和那天常常在线做ACM题目的黄金圣斗士们不同，他们天天在为竞赛做准备的。。
台上一分钟，台下十年功，如果有人可以五分钟做出来，那说明他天份高，下苦功吧。

                                    P.S：想这道题还没写Blog花时间，唉~