算法点滴

倒序输出字符串中的单词

乾坤一笑 — Sun, 02 Apr 2006 13:22:00 GMT

看roo的Blog，上面有一篇《反转字符数组中的单词，如“This is a test”，反转后“test a is This” 》。

【问 题】
    将一个字符数组中的单词顺序反转，要求不借助其它字符数组或者指针链表，保存反转后的字符数组，单词间以空格分隔。

【思 路】
先将字符数组全部反转，“This is a test”--> “tset a si sihT”, 再将单词逐个反转，最后得到要求的数组。

他的思路很清晰，就是先把一个字符串全部翻转，再逐个反转单词。其实我觉得还有更好的方法，完全可以省掉空间和时间上的浪费，一遍扫过就可以了。代码如下：

//
// Write by Spark
// 2006-04-02
//
#include <stdio.h>

int main(int argc, char *argv[])
{
    char str[] ="This is a test";
    int len = sizeof(str);
    char * p1, * p2, * p3;

    p1 = str + len - 2;   
    while(p1 != str)
    {
        p3 = p1; //remember start position

        // find the space char
        while(*p1 != ' ' && p1 != str)
        {            
            p1--;
        }		

        // output a section
        p2 = (p1 == str ? p1 : p1+1);
        for (;p2!=p3;p2++)
            printf("%c", *p2);
        printf("%c", *p3);
        
        // output the space char
        if (p1==str)
            break;
    	p1--;
        printf(" ");
    }
	
	return 0;
}

-------------
乾坤一笑写于2006年04月02日转载请标明出处和原文链接

位图算法－找中值

乾坤一笑 — Sun, 02 Apr 2006 05:43:00 GMT

Blog许久没有更新了，原因是没有素材。:) 今天借老杨的树《算法征集》开朵小花吧:p

本人在一个工程任务中,需要完成“在9个整数中，找到中值”。
比如：1,3,5,7,9,2,4,6,8 的中值是5。

看似非常简单的一个小问题，但由于每秒钟需要调用大约10万多
次，因此我需要一个快速算法，不考虑空间浪费，只要求比较语
句尽可能的少。

我这里用是位图算法，最差情况需要线性扫描数组2遍，空间复杂度为2O。当数据分布过分的稀疏的话，可能复杂度为nO。:( 不过，总体来说比O²的算法要快一些吧）下面是随手写的一段代码，只是为了演示算法，写的不够规范，有很多地方可以优化，见谅见谅。:P

//
// Sample for vector arithmetic
// Write by spark
// 2006-04-02
//

#include <stdio.h>

int arr[] = {1,3,5,7,9,2,4,6,8};            

#define MAX_NUM             (9)             //arr[]中的最大数
#define MIN_NUM             (1)             //arr[]中的最小数
                                                  //为了构建位图使用

#define ARR_MAX_INDEX       (sizeof(arr)/sizeof(arr[0]))   //arr[]中元素个数 
#define VEC_MAX_INDEX       ((MAX_NUM)+1)                  //创建0~MAX_NUM的位图，这里可以优化，改为创
                                                                   //建MIN_NUM~MAX_NUM的位图,以节省空间。


int main(int argc, char *argv[])
{
    int vector_flag[VEC_MAX_INDEX] = {0};      //这里很浪费空间。:) 
                                               //对空间有限制的话可以把32个flag压缩到一个int里
    int i, j, k;
    int middle_index;

    // set flag
    for (i=0; i<ARR_MAX_INDEX; i++)
    {
        vector_flag[arr[i]] = 1;
    }
   
    // search middle
    middle_index = (ARR_MAX_INDEX+1) / 2;       //注:这里假设arr[]中没有重复的值，否则要改
                                                       //变middle_index的算法。
    i=MIN_NUM-1; j=0;
    while(j<middle_index && i<VEC_MAX_INDEX)
    {
        i++;
        if (vector_flag[i]==1) 
        {
            j++;
        }
    }

    // print result
    printf("middle number is : %d", i);

    return 0;
}

欢迎拍砖，欢迎去老杨的家拍其他人的砖:p
-------------
乾坤一笑写于2006年04月02日转载请标明出处和原文链接

"取3个字符串共有的字母集合"的算法题

乾坤一笑 — Tue, 29 Nov 2005 15:00:00 GMT

今天终于把挂了4天的问题单搞定。回头想想，这几天的日子真可以用寝食难安来形容啊。看来想在公司混点钱也不容易，要费把子力气。晚上到vckbase上溜达，看到一道算法题目，不大的题目。于是就抽空磨磨刀了，快生锈了，嘿嘿。

取3个字符串共有的字母集合有没有好算法?4个呢,5个呢...
                             —— 一个ID叫做[1_]的朋友问！

没有仔细考虑算法，凭着直觉，抓起editplus和gcc就开始做，边做边构思，偶似乎又回到了9年前...（多么令人向往的高中生活，555）大约20分钟后，码出了下面这个砖块，偶抛出来了啊，小心……^_^

/*-----------------------------------------------------------*\
| 题目：取3个字符串共有的字母集合有没有好算法?4个呢,5个呢...        |
| ------------                                                |
| 备注：题意不是很清晰，我就以可见ascii码为例做做吧。:)             |
|       先来个不超过8个字串的通用做法:p                              |
| author: Spark Song                                          |
| date  : 2005-11-29                                          |
\*-----------------------------------------------------------*/
#include <stdio.h>
#include <string.h>

#define CHR_BEGIN  (0x20)
#define CHR_END    (0x7E) 
#define ARR_SIZE   (CHR_END+1)
unsigned char flag_set[ARR_SIZE];


//test str
unsigned char str1[] = "hello, world! hi, hoho! I do not know! ";
unsigned char str2[] = "every night I have a dream !";
unsigned char str3[] = "Bye bye, I am so sleepy.";

void filtrate(unsigned char * str, int order);

int main(int argc, char *argv[])
{
    int i;
    unsigned char flag;
    //initialize
    memset(flag_set, 0, sizeof(flag_set));
    
    //do ....
    filtrate(str1, 0);
    filtrate(str2, 1);
    filtrate(str3, 2);

    flag = (0x1 | 0x2 | 0x4);
    //output
    printf("Now, the char left are: \n");
    for (i = CHR_BEGIN; i<=CHR_END; i++)
        if ((flag_set[i] & flag) == flag)
            printf("%c", (unsigned char)i);
	printf("\n");
    return 0;
}

void filtrate(unsigned char * str, int order)
{
    int i, j, k;
    unsigned char * p;
    for (p = str; *p != '\0'; p++)
        flag_set[*p] |= (1<<order);
}

输出结果如下：

Now, the chars left are:
 Ie

这段下意识精神状态下写出的代码最能反映我当前的健康状况了，hoho。等明天睡清醒的时候来检查一下，看看最近参加打羽毛球、乒乓球、游泳等体育活动是不是确实增强了偶的体质！：）

-------------
乾坤一笑写于2005年11月29日转载请标明出处和原文链接

"asp无组件上传"算法的改进

乾坤一笑 — Sun, 21 Aug 2005 05:50:00 GMT

依旧是post到CSDN blog上的老文章，有鉴于偶的那栋宅子常年废弃，已经荒芜了，所以把家具搬到此处，嘿嘿。这个算法比较有借鉴性，自己收藏一下。

"asp无组件上传"算法的改进
乾坤一笑[smileonce]        2004-10-25

"asp无组件上传"算法的改进前几天帮朋友faintbear修改一个“asp无组件上传”的代码，得了几点心得，写在此处，或许还有点用处。

我没有开发过asp程序，只是临时报佛脚，修改了一下控制语句，所以，这里不再给出asp代码，只是说明一下思路。(你最好在看这篇文章前先浏览一下faintbear的《asp无组件上传的原理 (转) 》这篇文章，重复的部分我不再叙述了)

大体是这样的，一个form表单中可能post多个文本，居各简单的例子：
<form method="post" action="upload.asp" enctype="multipart/form-data">
<label>
<input type="file" name="file1" />
</label>
<br />
<input type="text" name="id" value="234523894"/>
<br />
<input type="text" name="name" value="Faint Bear"/>
<br />
<input type="text" name="friend" value="Smile Once"/>
<br />
<input type="submit" value="Submit"/>
<input type="reset" value="Reset"/>
</form>

-----------------------------7d429871607fe
Content-Disposition: form-data; name="file1"; filename="G:\homepage.txt"
Content-Type: text/plain
宝玉：http://www.webuc.net
-----------------------------7d429871607fe
Content-Disposition: form-data; name="id"
234523894
-----------------------------7d429871607fe--
Content-Disposition: form-data; name="name"
Faint Bear
-----------------------------7d429871607fe--
Content-Disposition: form-data; name="friend"
Smile Once
-----------------------------7d429871607fe--

由于file1可能非常大，而诸如id、name、friend这些要提交的域又非常多，而且file1、id、name、friend的相对位置又不确定(原文中是把这些条目的顺序写死的)，如何才能更好的划分流的块呢？

我的思路是：首先按条目来划分块，就是file1、id、name、friend各一块；之后，如果是file类型的，再根据其大小细分成若干块。基本上是这样的结构：
              --------------------------
                         file1   ------------
                                         No.1 block
                                  ------------
                                         No.2 block
                                  ------------
                                         No. ..... .. block
                                  ------------
              --------------------------
                         id
              --------------------------
                         name
              --------------------------
                         friend
              --------------------------

这样就井然有序，既确保的结构的清晰，又解决的大文件上传的问题。

-------------
乾坤一笑写于2004年10月25日转载请标明出处和原文链接

天平称小球问题

乾坤一笑 — Sun, 21 Aug 2005 05:35:00 GMT

本文最早发表于vckbase 竞赛版(后该版面取消)，后藏于CSDN blog（偶早已不维护）。这个经典算法，丢弃了实为可惜，所以还是捡回来放于此处吧。

天平称小球问题

乾坤一笑[smileonce] 2004-7-11

天平称小球问题有很多经典的范式解法，在这里我们谈论着只是其中最为广泛应用的一种——三进制编码解法。

为什么想起了使用三进制？其实很好理解。让我们考虑一下小球的状态，有：没放在天平上、在天平左盘、在天平右盘三种。我们不妨用一些数码来表示这三种状态:
0——没放在天平上
1——放在天平左盘
2——放在天平右盘
这样，我们就可以用一个数码串来表示某个小球被称量的过程，比如某个小球的编码是210120，就表明这个小球，第一次称量在右盘，第二次在左盘，第三次不在天平上，第四次在左盘，第五次在右盘，第六次不在天平上。很简单吧，仅仅用一个数码串就把小球复杂的称量过程表示出来了。

为了方便说明，下面都以“12小球称3次”来描述这个问题，不过，你很容易就能够推广到“M个小球称N次的情形”。好，闲言少叙，书归正传。

假设我们已经把12个小球编上不重复的3进制编码，称量的时候我们完全按照编码操作，第0步，我们把12个小球上的编码第0位为1的放在天平左边，编码第0位为2的放在天平的右边，编码第0位为0的则不放在天平上，记下称量结果；第1步，我们把12个小球上的编码第1位为1的放在天平左边，编码第1位为2的放在天平的右边，编码第0位为1的不放在天平上，记下称量结果；如此下去，编码有N位，我们就称量N次，得到N组结果。

考察一下结果的状态：天平平衡、天平左边轻于右边、天平左边重于右边。咦？怎么也是3种。（hia hia，无巧不成书嘛，好戏还在后面）我们用0来表示天平平衡，用1来表示天平左边轻于右边，用2来表示天平左边重于右边；这样，称量了N次，我们就得到了一个N位的结果编码，它也是三进制编码。注意：这个编码有可能和某个小球的编码相同呢！：）

你似乎隐隐约约已经意识到了什么了吧。好，现在就把问题挑明：得到的结果编码，和非标准小球的编码一样，或者有直接的对应关系。（这个关系是什么？往下看）

如果我们确定了一组小球的称量方法（对应于12个小球的3进制编码），现在反过来考虑，原来某一步放天平左盘的小球现在放在天平右盘，原来放天平左盘的小球现在放在天平右盘，原来没放在天平上的小球应然不放在天平上。那么这样得到的小球编码（也是12个）和原来的重复吗？显然不重复，我们把由这种对应关系得到的编码叫做对偶码(这里下个定义：把编码中的每一位数码，1换成2，2换成1，0不变，得到新编码叫做原编码的对偶码。如22102的对偶码是11201，或者说22101和11201互为对偶码)。这时候，你会考虑这样一个问题了——3位的3进制编码有多少个？答案是有3^3=27个（记做3^N），比上面提到的24个编码还多3个。为什么要研究这个对称码？因为我们把A,B,C,D球放在左盘，把A’,B’,C’,D‘球放到右盘——与我们把A’,B’,C’,D‘球放在左盘，把A,B,C,D球放到右盘，其称量意义是一样的，得到结果是一样的，我们要避免这种重复操作。所以说，实现这种算法，很重要的一点是选码——在互为一对对偶码的编码中选择一个来给小球编号。
到这里，我想你一定猜出来了——27比上面的24个编码多出的3个是什么码？他们是000，111，222。000和自身为对偶码，111和222互为对偶码。为什么要去掉他们3个？我想还是不放在这里说明了，要解决这个问题你得看看后面的数学证明先！

于是，我们得出结论：如果正确选择了一组3进制码，分别用来给小球编号，那么严格按照小球编码的称量过程得到的结果代码，必然是非标准球的代码，或者是他的对偶码。（由于我们给小球的编码中，任意两个小球的编码不互为对偶码，所以，我们的称量操作唯一确定了非标准小球）此结论的证明方法过于繁复（我用word打了4页），所以放在文后供打包下载。

下面说说程序实现编码的具体过程。

参考上图，我们首先取得用一个code数组来存放编码，为了节省空间，在我的程序里code数组存放的是十进制编码，我用GetTheBall.num2Code()和GetTheBall.code2Num()来实现三进制和十进制之间的相互转换。我们首先把编码全部存入数组，然后去掉000,111,222这三个编码，然后再剩余的编码中再删掉一半，得到的12个编码标记给小球就行了。对于1开头的编码我们选择的是比111大的所有编码，对于2开头的编码，我们划去“1开头我们选的那部分编码”的对偶码，对于0开头的编码，我们选择的是从左向右的编码位中，第一个不为0的数码是1的编码（此处酷似好难理解，其实第一个不为0的数码不是1就是2，我们删掉了是2的那一半）。
好了，数数看，看好删了一半剩了一半。按照上图的编码方式，经过操作得到的结果码，如果在小球编码中，那个编码的小球就是非标准球，且比标准球轻。如果结果码不在小球编码中，那么结果码是非标准球的对偶码，非标准球比标准球重。

偶的代码如下（java source）:

////:BalanceWeightsBalls.java

/**
    * 天平找非标准球问题
    *
    * 题目： 12个小球中有一个的重量与其他的不等，要求用一个天平经过3次
    * 秤量取出重量特殊的一个，请用代码模拟秤量的过程。
    *
    * 解答： 称小球问题的正规通用解法也3、4种，不过我还是比较推崇3进制法，
    * 因为它有一种料敌在先的快感！
    *
    * 说明： 本程序并不局限于12球称3次,本程序给出的是一种通用算法，你也可
    * 以测试一下39个球称4次，120球称5次等等等等。：）
    *
    *author FreeDebug
 */

/**
    * Balance类模拟了天平，并用private保护了用户指定的小球重量的数据，
    * 所以，本次仿真非常真实，童叟无欺！^_^
 */
class Balance {
    //-- 用小球的重量构造天平:)
    public Balance(int ballMax, int abnormalBallNum, int abor) {
        ballWeight = new int[ballMax];
        for (int i=0; i<ballMax; i++ )
            ballWeight[i] = 10;
        if (abor == 1) ballWeight[abnormalBallNum] = 5; // lighter than normal
        else ballWeight[abnormalBallNum] = 15;          // weighter than normal
    }
    //-- 称重量。左边的球重量之和小于右边的，返回1；否则返回2。
    public static int weigh( int[] left, int[] right) {
        int leftWeight  = 0,
            rightWeight = 0;
        for ( int i = 0; i < left.length; i++ )
            leftWeight += ballWeight[left[i]];
        for ( int i = 0; i < right.length; i++ )
            rightWeight += ballWeight[right[i]];
        return leftWeight == rightWeight ? 0 : ( leftWeight < rightWeight ? 1 : 2);
    }
    private static int[] ballWeight;
}

/**
    * 嘿嘿，全部核心操作都在这里，仔细看哟！
 */
class GetTheBall {

    public GetTheBall(int mBall, int mTime) {
        maxBall = mBall;
        maxTime = mTime;
    }

    public int[] code2Num( int code ) {
        int[] rs = new int[maxTime];
        int iTmp = code;
        for (int i=0; i<maxTime; i++) {
            rs[maxTime-1-i] = iTmp % 3;
            iTmp /= 3;
        }
        return rs;
    }

    public int num2Code( int[] num ) {
        int rs = 0,
            o  = 1;
        for (int i=0; i<maxTime; i++) {
            rs += num[maxTime-1-i]*o;
            o *= 3;
        }
        return rs;
    }

    public int getAllelomorph( int code ) {
        int rs;
        int[] num = new int[maxTime];
        num = code2Num( code );
        for (int i=0; i<maxTime; i++)
            if ( num[i] == 1 ) num[i] = 2;
            else if ( num[i] == 2 ) num[i] = 1;
        rs = num2Code( num );
        return rs;
    }

    public static int powerOf3( int order ) {
        int rs = 1;
        for (int i=0; i<order; i++) {
            rs *= 3;
        }
        return rs;
    }

    public void coreWork () {
        int maxCode = maxBall*2+3;
        int[] code = new int[maxCode];
        int[] ball = new int[maxBall];
        int count = 0;
        int[] buf;
    //---- Codes ....
        for( int i=0; i<maxCode; i++) code[i] = i;
        //--- 00xxxx…
        count = powerOf3(maxTime-2);
        code[0] = -1;
        for( int i=0; i<count; i++) {
            buf = code2Num( code[i] );
            for ( int j=0; j<buf.length; j++){
                if (buf[j] == 2) code[i] = -1;
                if (buf[j] != 0) break;
        }
        }
        //--- 01xxxx…  ==> good
        //--- 02xxxx…
        for( int i=count*2; i<count*3; i++ )
            code[i] = -1;
        //--- 100000… ~ 111111… & del allelomorph in 2xxxxx…
        for( int i=count*3; i<count*3+(count*3-1)/2+1; i++)
            code[i] = -1;
        //--- 1xxxx…2 ~ 122222… ==> good
        //--- 2xxxx…0 ~ 22222…1 ==> del allelomorphi(i)
        for (int i=count*3+(count*3-1)/2+1; i<count*6; i++)
            for (int j=count*6; j<count*9; j++)
                if ( getAllelomorph(i) == j) code[j] = -1;
        //---- del 222222 ====>
        code[code.length-1] = -1;

    //---  Marks ball ...
        count = 0;
        for ( int i=0; i<maxCode; i++)
            if (code[i] != -1) {
                ball[count++] = code[i];
            }

    //---  Weighs ball ...
        int[] left  = new int[maxBall];
        int[] right = new int[maxBall];
        int[] weighResult = new int[maxTime];
        for (int i=0; i<maxTime; i++){
            int leftCount  = 0,
                rightCount = 0;
            for (int j=0; j<maxBall; j++) {
                buf = code2Num( ball[j] );
                if (buf[i] == 1) left[leftCount++]   = j;
                if (buf[i] == 2) right[rightCount++] = j;
            }
            P.rintln("第 " + (i+1) +" 次称量:");
            P.rint("放在做在天平左盘的小球编号  : ");
            for (int j=0; j<leftCount; j++ ) P.rint(" "+(left[j]+1));
            P.rintln(" ");
            P.rint("放在做在天平左盘的小球编号 : ");
            for (int j=0; j<rightCount; j++ ) P.rint(" "+(right[j]+1));
            P.rintln(" ");
            weighResult[i] = Balance.weigh( left, right );
            if ( weighResult[i] == 0) P.rintln( " 称量结果：左盘和右盘一样重 ");
                else if (weighResult[i] == 1) P.rintln( " 称量结果：左盘轻于右盘 " );
                     else P.rintln(" 称量结果：左盘重于右盘 ");
            P.rintln(" ");
        }
        int wRs;
        boolean light = false;
        wRs = num2Code( weighResult );
        for (int i =0; i<maxBall; i++) {
            if (code[ball[i]] == wRs) {
                P.rint(" 非标准球的编号是："+(i+1));
                P.rintln( " 它比标准球轻！");
            } else if (getAllelomorph(code[ball[i]]) == wRs ) {
                        P.rint(" 非标准球的编号是："+(i+1) );
                        P.rintln(" 它比标准球重！");
                   }
        }
    }
    private int maxBall;  //=12
    private int maxTime;  //=3
}

//---- predigest print function call
class P {
    public static void rint(String s) {
        System.out.print( s );
    }
    public static void rintln(String s) {
        System.out.println( s );
    }
}

public class BalanceWeightsBalls {
    public static void main(String[] args) {
        P.rintln("天平称小球问题");
        P.rintln(" ");
        int maxBall = 12;            //输入要称的小球数目
        int maxTime = 3;             //输入题目规定的称量的次数
        int abormalBall = 9;         //输入非标准球的编号，编号从1开始记，1<= abormalBall <= maxBall
        int abor = 2;                //输入非标准球比标准球是轻还是重,1表示比标准球轻，2表示比标准球重

        //根据上面用户的设定信息构造Balance类（天平）
        if (abormalBall<1 || abormalBall>maxBall) P.rint("输入错误，非标准球编号错误！");
        if (!(abor==1 || abor==2)) P.rint("输入错误，非标准球轻重设置错误");
        Balance bal = new Balance(maxBall, abormalBall-1, abor );

        //由于Balance类用private修饰小球的信息，所以GetTheBall类
        //并只知道那个小球是非标准球，以及它比标准球轻还是重。
        //GetTheBall类只能通过Balance.weigh()方法来得到每一次的称量结果。
        //这样做确保了仿真的公正性。

        if ( !(( GetTheBall.powerOf3(maxTime) - 3 ) / 2 == maxBall) ) {
            P.rintln("题目有误，无法称量出非标准球，或者 "+maxTime
               +" 并不是在 "+maxBall+" 个球中找出一个非标准球的最小的称量次数");
        }else {
            GetTheBall gtb = new GetTheBall( maxBall, maxTime );
            gtb.coreWork();  //好了，看看结果吧!
        }
    }
}
////:~

好了，讲到这里就告一段落了。其实，要想领会透彻这个算法的含义，为什么要这么编码，这么编码为什么正确，还必须经过严格的数学证明才行。

用三进制法解决天平称小球问题，我得道于我的师兄安兴华，本文所附的数学证明也非本人所作，可能是源于COI国家队的某个高手，我不清楚作者名姓，那篇文章也是个残本，可能有误，放在这里是为了给初学的朋友提供些资料。所以发现问题请不吝指点，知道原始出处和原著作者的请与我联系。
我的源码(java版)
相关的数学证明

-------------
乾坤一笑写于2004年7月11日转载请标明出处和原文链接

这是一道难题么？（翻转unsigned char中的位）

乾坤一笑 — Sat, 11 Jun 2005 06:53:00 GMT

昨天处理汉字字模的时候遇到一个小问题，花了10分钟居然没有写正确。后来把问题发给其他同事，发现很多同事在这个方面大多都有缺陷。或许你比偶强，那么测试一下基本功吧:p （大家不妨把自己的代码贴于此处，也好让偶沾沾光，多学几种算法:p）

问题：写一个函数，接受一个unsigned char的参数，返回一个unsigned char。函数要完成的功能是：把这个8bit的数从高到低翻转过来。比如0x80转换为0x01, 0xA4转换为0x25。
0xA4是 10100100 翻转过来就是 00100101，也就是0x25。

------------
相关参考：
Panic BLOG：《反转一个字节的算法》
周星星 BLOG：《测试“反转一个字节的算法”的速度》
Panic BLOG：《效率的边界－－几种反转字节算法分析》
Panic BLOG: 《旧事重提，反转一个字节的算法讨论》

热烈推荐： A*算法（启发式搜索的入门篇，必看）

乾坤一笑 — Sun, 20 Mar 2005 16:08:00 GMT

在搜索式算法中，A*算法算是个分水岭。因为它引入了启发式估价函数，从“瞎搜”转化到了“有目标的搜索”。学会了A*算法，在搜索算法方面就过了一个坎儿了。当然，后面还有一个坎儿就算是动态规划了。

偶认为，在偶学搜索算法中经历的3个坎儿，分别是Alpha-剪枝、A*算法、动态规划。剪枝法有效的缩小了搜索的范围，有具体的程序结构可以套用，所以容易些；A*算法，虽然也可以套用程序结构，但是作为其算法核心的估值函数，灵活度很大，变化万千，所以它是不易掌握的；动态规划，仅仅规定了算法的总纲，并没有固定格式的限制，也成型的招式可以套用，必须从思想上去把握，所以更是难学。从有招到无招，从有剑到无剑，路自然是要一步一步的走过来的。

小P翻译的这篇文章，让偶想起幸福的高中时代，想起了同学们的音容笑貌，想起昔日集训时的同学……往事不堪回首，而今几多忧愁。是故天将降大任于是人也，必先苦其心智、劳其体肤、空乏其身、行拂乱其所为，所以动心忍性，增益起所不能。

做为coder，算法关是一定要过的，算法关的第一关就是“搜索算法”。所以，不管其它人说中国程序员是多么浮躁和无知，偶们也无须去分辩。我们认认真真的学习、编写代码、研究老外的先进技术，经过我们一代人的努力，就一定会填平和西方列强之间的沟壑，到那时历史将会为我们平反。今天看到小P翻译的文章，不禁为默默无闻、敬业踏实的程序员所感动；七猫随即就给出了A*算法的源码，足见其平日研究有多广；我身边都是些这样的人，奋斗又怎么会没有动力呢？

闲言少叙，推荐文章先。

Panic翻译的文章《A*寻路初探 GameDev.net 》
七猫附贴的源码 寻路者

统计x转化为2进制的位中为1的个数

乾坤一笑 — Wed, 05 Jan 2005 22:14:00 GMT

算法题：计算Date增量

乾坤一笑 — Thu, 09 Dec 2004 15:15:00 GMT

算法题：用户给一个数据,这个数和1900年1月1日.进行计算. 比如:用户给30.输出的日期就是:1900年1月31日.

汉诺塔的108种实现！

乾坤一笑 — Sun, 28 Nov 2004 16:20:00 GMT