用剑对话

不如用酒对话

用酒对话

不如用茶对话

用茶对话

不如用白开水对话

用白开水对话

不如用空气对话

        去年此时，从南浔回来，我跟朋友说，再也不在江南旅游了。可几天前，朋友约我去西塘看看，他说，或许真如广告讲的，那是一个活着的古镇，说不定真不同于南浔盆景式的呆板无趣的死的古镇。我倒不怎么相信，只是因为喜欢跟那几个朋友出去鬼混，竟违了当初的誓言，又去江南古镇走了一遭。

        没进到景区里面，你是始终觉不出到了昔日水气扑鼻的水乡的，这点倒没出我所料，不觉在心里嘀咕：这算什么活着的古镇，肯定又是个盆景。当我们穿进一个狭窄的小弄后，我的情绪才稍稍被点燃了一些。哦，青石板，被多少人踩过的青石板，稍稍勾起了我的想象。或许很多年前，一个下雨的夜晚，一位落魄的诗人，也踩过这些石板。

        跟随自己的脚步声——尽管嘈杂的人声几乎赶绝了它们，但我心中的古镇总是响着“哒哒”的跫音——往弄堂的尽头走去，水气，我渴望的水气，终于能激活我的鼻子了。我加快脚步，赶到桥上，一条乌篷船恰好从桥洞中溜过。放眼望去，前头是桥，后头是桥，两侧酒旗招摇，似乎还真有点那个味道。不过，我的心理防线可没这么容易被摧垮，望着两畔觥筹交错的繁华景象，我没有把自己意淫为古时的某个骚人，或把酒吟诗，或大放阙词，恰恰相反，作为一个一穷二白的年轻人，不仅穷钱，而且穷才，我在想万一生计没着落，来这里当服务员不知怎么样。或许你会怪我，你这人太现实了，这时候说这个，真扫兴。然而我却并不现实，事实上还是个彻头彻尾的理想主义者，我报考了基础数学的研究生，而我却并不是一个很有数学才能的人，当前基础也较差，仅仅因为爱好便准备与数学相伴一生，不是生在贵族的我，只能说有点冲动。

        说到生计这事，我想起在西塘看到有个人，坐在临水的躺椅上，修改一张建筑设计图。这让我想到两种情况，一种是他即使趁难得的国庆长假出来游玩一下，还是被工作上的事困扰着，这是比较难受的；另一种是他在这里获得了灵感，而他又很爱设计，所以愉快地创作着自己的杰作，这是很吸引我的。我奢望自己能有后一种经历，或在古镇中，或在奇山上，或在大海边，心灵舒展，精神愉悦，思维毫无拘束地驰骋，结出美妙的数学定理。据说数学家皮尔逊就是这样的，只有离开书桌他才能思考。

        看上去我好像要准备夸赞西塘了，而你会在心里轻蔑地说：老是来这一套，要夸就直接夸嘛，还起了个忽悠人的标题。事实上你误会了，前面我根本未费多少笔墨渲染西塘的风景风情，我还是认为，古镇的风景已经变成盆景了，不值一书。就像那天下午我们焦急地等待着夜幕降临，因为白天喧闹的古镇被扭曲了，听说夜晚的西塘才美。而好不容易到了晚上，竟下起了雨，妙甚，我牵念的雨中水乡的画卷莫非要隐现了。可是没有撑着油纸伞走过双桥的行人，也听不到烟雨廊棚偶尔漏下的几滴雨珠的叮咚，更没有欸乃的桨声，这算不得真正的水乡古镇。于是我们早早地回到了旅馆。

        在旅馆只能看看一些无聊的电视，实在不甘心，不甘心之极。约摸十点，我和朋友准备出去吃酒。对于小小的盆景，我们早已熟悉道路，走过这座桥，穿过那个巷，径直出了景区。景区外是再寻常不过的小镇，跟中国千千万万个寻常的小镇没多少两样。我们胡乱走了一下，碰到一个夜排档，坐下，把酒瓶子放桌上，犹豫再三地点了些下酒菜，就吃起来了。

        吃酒回来，往床上一摔，很快进入了烦躁的梦乡。没有桨声灯影入梦，尽是些生活琐事的拼缀。迷迷糊糊地睡到第二天九点多，草草洗漱一番，便迫不及待地要回家了。当汽车开动时，我又矫情地说了一句，江南，以后死也不看了。话刚说完，突然眼前浮现出一个画面来：

        临水的人家升起了炊烟，家家门外泊了一条小船，有几艘小船上，几个小孩在玩耍，还有个淘气的孩子爬到了旁边一棵桑树上。沿河看去，有人在杀鱼，有人在洗菜。廊棚底下的小店，有老人在喝茶闲聊，也有人过来打酱油。桥上，有匆匆赶回家吃饭的人……

        突然我恍若明白了，任何风景，离开生活，必然会断气，而像西塘、南浔这些古镇，已经失去了原先的生态，即使勉强营造出生活的场景来，毕竟不是自然的，因此让人觉得气息奄奄。

        我又想起在西塘看到的一位少女，和一位老奶奶坐在老屋门前的长凳上，随便聊些家常，然后那少女起身要走，老奶奶跟她道别：以后再来。少女点点头，跨上肩包，缓缓地走出了西塘。 我那时多么羡慕这位少女，她小时候一定是在这里长大，她一定非常熟悉这里的生活，她一定曾深刻感受过生活着的西塘。

The Laestrygonians and the Cyclops

Angry Poseidon

Do not fear them

The likes of these you will not encounter on your path…

Unless you carry them in your heart.

高大的食人族和独眼巨人

还有暴躁的海神波塞冬

你都不必惧怕

它们不会出现在你的路途上

除非你在心中携带着它们……

         —— 《伊萨卡》（Ithaca）

卡瓦菲斯（Constantine Cavafy，1863-1933，希腊）

    “在我的车库里有一条喷火的龙。”

    假如我非常肯定地对你这么说，你一定想亲眼看一下。几个世纪以来流传着无数关于龙的故事，但从没有真凭实据。这可是个好机会！

    “带我看看。”你说。我带你到我的车库。你往里看，看到的是一个梯子，一些空的油漆桶和一辆旧的三轮车，但没有龙。

    “龙在哪里？”你问道。

    “噢，它就在这儿。”我回答说，胡乱地挥了挥手，“我忘了说明，它是一条看不见的龙。”

    你建议在车库地板上撒上面粉以获取龙的爪印。

    “好主意，”我说：“但龙是浮在空中的。”

    然后你想用一个红外线探测仪检测龙喷出的看不见的火。

    好主意，但看不见的火也不会发热。

    你想对龙喷漆使它现身。

    “好主意，但它是非物质的龙，油漆无处可粘。”

    如此如此。你每提出一种物理检测方法，我就找个特殊理由来说明你的办法不会有效。

    现在，一条看不见的、无实体的、浮在空中的、喷着没有热度的火的龙与根本没有龙之间有什么区别呢？如果没有办法反驳我的争辩，没有可以让人信服的试验来反对它，说我的龙确实存在意味着什么呢？你不能证明我的假设不成立，这与能证实它成立是完全不同的两回事。不能检验的观点和无法证伪的断言实际上毫无价值，不论它们在给我们以启示或是在激起我们的好奇心方面有些什么用处。

注：什么是科学，什么是非科学？卡尔·萨根不是已经说得很清楚了嘛。遗憾的是，经常能碰到很多人，他们的思想里面依然潜伏着神秘主义和迷信观念，即使是那些受过良好的自然科学教育的人。这不能不说是教育的失败。我们的科学教育，尽管传授了科学的知识，却完全忽略了更重要的东西，即科学的研究方法和科学的精神。一个人对世界的看法，基本上取决于他观察这个世界的方式。

        Toplanguage 邮件列表里 Jun Yang 先生写下的这段话，令我充分认识到自己的一些缺点，特贴于此处，以为警醒、鞭笞：

        遇到问题 A，经验 B 会有效；遇到问题 C，经验 D 会有效……

        至于为什么经验 B 对问题 A 会有效，是不是在所有场景下都会有效，是否还存在更有效的解法，大多数情况下，我们未必会深入去思考挖掘。于是，在遇到了与自己以前经历过的问题相似的场景时，我们就会条件反射地基于已有经验，设计出一个解决方案，大多数情况下这个方案 work 得很好。但也会在很多情况下，这个方案虽然能 work，却并不是最优解，甚至自己都未必能说得清楚为什么给出这样的方案。

        最近在工作中，需要为编译器的语法规则设计相应的数据结构，自己就有了这样的感觉。在做设计的过程中，有的时候，是旧有经验在作祟，有的时候，则是因为偷懒的情绪占了上风，自己会满足于浅尝辄止，对某个问题给出一个未经深思熟虑的解决方案，而随着设计过程的推进，暴露出来的信息越来越多，那时就会发现已有的设计不能很好地满足一些场景的要求，因而需要对已有的设计进行调整，但是在调整时，自己往往会发现，对于已经作出的设计，为什么当时自己选择那样的接口，定义那样的数据成员，自己并不能给出清晰明确的解释，这就说明在作出当时的设计的时候，自己并未将问题想清楚，也未将自己给出的设计想清楚，而是基于一些已有的经验，给出了一个差强人意的方案而已。

        在这方面，我的老大做得比我好很多，对于一个问题，他往往是在对其想得非常清楚之后，才会着手去做。以前的技术讨论会上，凡是他提出的设想和方案，几乎很少会有被我们驳倒的，因为只要是他在会议上提出来的东西，几乎方方面面，各种可能，他都已经去思考过了。至于在工作经验的积累过程上，他也经常会作深入的思考和挖掘。一般来说，凡是他解决过的问题，只要不是太 detail 的，跟他讨论起来，他往往能够对答如流，而能够做到这一点正是因为他在储备这些经验的时候已经作足了功夫。而自己在储备经验的时候则往往不会花费太多精力。一个典型的场景就是我和老大同时遇到一个问题，有的时候，我能更快地给出答案和解法，但是过了一段时间，又遇到了类似的问题，我却可能会忘了当时解决问题的思路，需要重新进行思考，而我的老大往往能够直接从他的经验体系中找出当时的解法思路。遇到一个问题，我往往能较快地给出一个解决方案，但细究起来，我就时有被卡住的场景；而我的老大，虽然给出问题答案所需的时间会长一些，但一般他给出的答案，往往都经得起推敲。外人看来，我干起活来很快，效率蛮高，但是自己心里清楚，这种效率是以损失扎实性为代价的。

In Chinese context,I can write without thinking,but always feel nothing to say. What lead to this, is lack of thought.Oppositely,in English context,there are a lot of thing I want to tell you,but as you known,my English is so so so poor,so that I can't express my "abundant thought" well enough. What a embarrassed place I have stood in! It makes me bethink of a wisdom from a french writer whose name is Michel de Montaigne. Montaigne said: if a man can't express his thought well,he dosen't know himself in fact! And I don't want to be a man who dosen't know himself,so I will try to express myself in English.

But,as you know,my English is so poor,how can I to do that? There are no way except practise. So I create a topic named "bullshit", on this topic, I can say anything what I want to say,and dispense with think of phrasing and syntax. Of course you will say: according your galling English ability,I even can't understand what you are saying. That is nothing,because even I,also don't understand myself to say. That's why I call these "bullshit",the main character of bullshit is,the author don't know what he said. So take it easy,my friends,it's all nonsense.

From this day forth,I will write an "essay" per day,then make my blog to be a rubbish collection. What an interesting thing,don't you think so? But don't forget,when I was 3 years old,even the Chinese,I couldn't say,and even so,I exerted all my strength to cry out: Mum!Mum! Because I felt hungry.

// ZJU Online Judge
// Problem 2106 Tick and Tick
// Algorithm: 
// ---- 稍加分析,可以发现对时间离散化计数行不通,因为要想达到精度,则必定超时.
// ---- 既然离散地统计不行,那就改为统计时间段. 试想,指针之间的夹角是关于时、分、秒的线性函数,
// ---- 如果时、分确定,那么我们就得到关于秒的线性不等式组,其解集必定是一些区间的交或并.
// ---- 容易从区间的交或并中统计出“快乐时光”的长度. 具体如下:
// ---- 设当前的时间为 H:M:S, 其中 0 <= H < 12, 0 <= M < 60, 0 <= S < 60, H,M皆为整数, S为实数
// ---- 于是时针、分针、秒针相对于时刻 0:0:0 的转角分别为
// ----      A(H) = 30H + M/2 + S/120;
// ----      A(M) = 6M + S/10;
// ----      A(S) = 6S;
// ---- 设题目中的临界夹角为 D,则“快乐时光”是同时满足以下不等式的解:
// ----      D <= | A(H) - A(M) | <= 360-D;   (1)
// ----      D <= | A(H) - A(S) | <= 360-D;   (2)
// ----      D <= | A(M) - A(S) | <= 360-D;   (3)
// ---- 上面各式的绝对值中的形式为 bS - a,(a,b为常数,b>0) 故解的形式为
// ---- [ (a+D)/b, (a+360-D)/b) ] 并 [ (a+D-360)/b, (a-D)/b ], 即两个闭区间的并集.
// ---- 设由式(i)得到的解集为 Si1 并 Si2, 那么“快乐时光”在时、分确定的情况下，其秒的解集为
// ---- [0,60] 交 (S11 并 S12) 交 (S21 并 S22) 交 (S31 并 S32)
// ---- 上面的集合容易化成 S1 并 S2 并 S3 并 S4 并 S5 并 S6 并 S7 并 S8 的形式,其中 S1,S2,...皆为闭区间.
// ---- 求区间的并的总长度没有困难,而这个总长度就是由时、分确定的“快乐时光”的长度.
// Author: obtuseSword
// Date: 2008-08-29
// Compiler: Visual Studio 2005


#include <iostream>
#include <iomanip>
using namespace std;

// 区间结构
struct Segment{ double a,b; };

// 由两个区间求出它们的交（区间）
Segment operator *(Segment S1,Segment S2){
        Segment seg;
        seg.a = max(S1.a,S2.a);
        seg.b = min(S1.b,S2.b);
        if( seg.a >= seg.b )
                seg.a = seg.b = 0.0;
        return seg;
}

// “快乐时光”临界角度
double D;

// 从 D <= bS - a <= D1 中解出区间
Segment makeSeg1(double,double);
// 从 D <= a - bS <= D1 中解出区间
Segment makeSeg2(double,double);


//--------------------------- 主函数 ---------------------------//
int main(){
        while( cin >> D, D != -1 ){
                double totLen = 0.0;  // “快乐时光”总长度
                // 枚举时、分
                for(int H = 0; H < 12; H++){
                        for(int M = 0; M < 60; M++){
                                Segment S[3][2];
                                // 获得基本解区间
                                double a, b;
                                a = 30.0 * H - 5.5 * M, b = 11.0/120;
                                S[0][0] = makeSeg1(a,b), S[0][1] = makeSeg2(a,b);
                                a = 30.0 * H + 0.5 * M, b = 719.0/120;
                                S[1][0] = makeSeg1(a,b), S[1][1] = makeSeg2(a,b);
                                a = 6.0 * M, b = 5.9;
                                S[2][0] = makeSeg1(a,b), S[2][1] = makeSeg2(a,b);
                                // 将解集转化为区间的并，并累计“快乐时光”的长度
                                for(int i = 0; i < 2; i++)
                                for(int j = 0; j < 2; j++)
                                for(int k = 0; k < 2; k++){
                                        Segment TS = S[0][i] * S[1][j] * S[2][k];
                                        totLen += TS.b - TS.a;
                                }
                        }
                }
                // 输出“快乐时光”的比例
                cout<<setprecision(3)<<fixed
                        << totLen / 432.0 <<endl;
        }

        return 0;
}
//---------------------------------------------------------------//


// 从 D <= bS - a <= D1 中解出区间
Segment makeSeg1(double a,double b){
        Segment seg;
        seg.a = (D+a)/b, seg.b = (360.0-D+a)/b;
        if( seg.a < 0.0 )
                seg.a = 0.0;
        if( seg.b > 60.0 )
                seg.b = 60.0;
        if( seg.a >= seg.b )
                seg.a = seg.b = 0.0;
        return seg;
}

// 从 D <= a - bS <= D1 中解出区间
Segment makeSeg2(double a,double b){
        Segment seg;
        seg.a = (a+D-360.0)/b, seg.b = (a-D)/b;
        if( seg.a < 0.0 )
                seg.a = 0.0;
        if( seg.b > 60.0 )
                seg.b = 60.0;
        if( seg.a >= seg.b )
                seg.a = seg.b = 0.0;
        return seg;
}

       【证明】

         根据 Fermat's Little Theorem，a^4 = 1 (mod 5)，如果 a 不被 5 整除的话。

         所以我们考虑方程 x^4 + 131 = 3 y^4 两侧对 5 的剩余系：

         131 = 1 (mod 5)，x^4 = 0,1 (mod 5)，故 x^4 + 131 = 1,2 (mod 5)；

         而 3 y^4 = 0,3 (mod 5)。

         方程两边同时除以 5 ，总是得到不同的余数，显然方程无整数解。

// ACM-ICPC 2008 World Final
// Problem G Net Loss
// Algorithm: 利用微分学中多元函数极值存在的条件
// ---- 这种纯数学题很无趣.
// Author: obtuseSword
// Date: 2008-07-09
// Compiler: Visual Studio 2005


#include <stdio.h>

int deg;
double c, X[13], Y[13], P[11];
double a0, a1, b0, b1;

double myPow(double a,int p){
        if( p == 1 )
                return a;
        else if( p % 2 )
                return a * myPow(a*a,p/2);
        else
                return myPow(a*a,p/2);
}

void getXY(void){
        for(int i = 1; i <= deg + 2; i++){
                double tmp = myPow(c,i);
                X[i] = ( tmp + ( i % 2 ? 1 : -1 ) ) / i;
                Y[i] = ( 1 - tmp ) / i;
        }
}

void approximate(void){
        double A = 0.0, B = 0.0, C = 0.0, a[3][3], d;

        getXY();
        for(int i = 0; i <= deg; i++){
                A += P[i] * ( X[i+1] + Y[i+1] );
                B += P[i] * ( X[i+2] + c * Y[i+1] );
                C += P[i] * ( Y[i+2] - c * Y[i+1] );
        }

        a[0][0] = X[1] + Y[1];
        a[0][1] = X[2] + c * Y[1];
        a[0][2] = Y[2] - c * Y[1];
        a[1][0] = X[2] + c * Y[1];
        a[1][1] = X[3] + c*c * Y[1];
        a[1][2] = c * ( Y[2] - c * Y[1] );
        a[2][0] = Y[2] - c * Y[1];
        a[2][1] = c * ( Y[2] - c * Y[1] );
        a[2][2] = c * ( c * Y[1] - 2 * Y[2] ) + Y[3];

        d = a[0][0] * a[1][1] * a[2][2] + a[0][1] * a[1][2] * a[2][0]
          + a[0][2] * a[1][0] * a[2][1] - a[0][0] * a[1][2] * a[2][1]
          - a[0][1] * a[1][0] * a[2][2] - a[0][2] * a[1][1] * a[2][0];
        a0 = A * ( a[1][1] * a[2][2] - a[1][2] * a[2][1] )
           - B * ( a[0][1] * a[2][2] - a[0][2] * a[2][1] )
           + C * ( a[0][1] * a[1][2] - a[0][2] * a[1][1] );
        a0 /= d;
        a1 = - A * ( a[1][0] * a[2][2] - a[1][2] * a[2][0] )
           + B * ( a[0][0] * a[2][2] - a[0][2] * a[2][0] )
           - C * ( a[0][0] * a[1][2] - a[0][2] * a[1][0] );
        a1 /= d;
        b1 = A * ( a[1][0] * a[2][1] - a[1][1] * a[2][0] )
           - B * ( a[0][0] * a[2][1] - a[0][1] * a[2][0] )
           + C * ( a[0][0] * a[1][1] - a[0][1] * a[1][0] );
        b1 /= d;
        b0 = a0 + c * ( a1 - b1 );
}

int main()
{
        for(int theCase = 1; scanf("%d",&deg), deg; theCase++){
                for(int i = deg; i >= 0; i--)
                        scanf("%lf",P+i);
                scanf("%lf",&c);
                approximate();
                printf("Case %d: %.3lf %.3lf %.3lf %.3lf\n",theCase,a1,a0,b1,b0);
        }

        return 0;
}

        近日复习高等代数，开卷便遇多项式，时见“域扩张”思想，其应用得最为光辉之处当推对于“古典代数学基本定理”的证明。

        所谓域扩张的思想，说的是，有一关于域 P 的命题，不好搞，不妨先考虑比 P “更大”的域 P1 (包含 P 或 P 的同构 )，利用其中更丰富的性质或更透彻的结构得到一些结论，然后转回到域 P 中。

        举个简单的例子：实系数多项式 f(x) 恒为正，则必存在两个实系数多项式 f1(x),f2(x)，满足
                                                  f(x)  =  f1(x)^2  +  f2(x)^2.

        命题虽简，如若仅于实数域中思之，却难下手。这时候不妨借来“透视仪”，将其透析到复数域中，发现一副骨架：任何实系数多项式，如果复数 a 为其根，则 a 的共轭（此处记为 con(a) ）亦为其根矣。

        回首一看，f(x) 恒为正，故无实根，于是，若 a1,a2,...,an 为该多项式的 n 个互不共轭的虚根，那么有形式

         f(x) = c (x-a1)...(x-an) (x-con(a1))...(x-con(an)) = c * p(x) * con(p)(x)

        其中 p(x) = (x-a1)...(x-an)，con(p)(x) = (x-con(a1))...(x-con(an))，即对 p(x) 的系数“取共轭”得到多项式 con(p)(x)。由于 p(x) 为复系数多项式，可表示为 p1(x) + i p2(x)，p1(x),p2(x) 皆为实系数多项式。众所周知，p(x) * con(p)(x) 即为 p(x) 的模的平方，即 p1(x)^2+p2(x)^2，此时已灯火阑珊也哉。


【注】 本例中的 f(x) 若满足非负性，命题也是成立的。 假如 x0 是其一 k 重实根，则 f(x) = (x-x0)^k g(x).  易知 k 为偶数，如若不然，则对所有 x > x0，有 g(x) >= 0，对所有 x < x0，有 g(x) <= 0，再由多项式函数的连续性，必定有 g(x0) = 0，这表明 f(x) 的根 x0 的重数大于 k，矛盾。 那么我们可以分析出 f(x) 的结构：

对于 g(x)，我们已经证明 g(x) = g1(x)^2 + g2(x)^2，显然也有形式 f(x) = f1(x)^2 + f2(x)^2.

        再举一例：数域 P 上的多项式 f(x),g(x),h(x) 满足

        则有 (x^2+1) | gcd( f(x), g(x) ).

        证明：   将 f(x),g(x),h(x) 看作多项式函数，令 x = i (单位虚数)，代入 (1),(2) 两式，有

        两式相加、相减，分别得到以下两式

        于是得到 f(i) = g(i) = 0.  类似地，令 x = -i，便可得 f(-i) = g(-i) = 0.  这表明 i,-i 是 gcd( f(x), g(x) ) 的复根，也就是说，(x-i)(x+i) = (x^2+1) | gcd( f(x), g(x) ).    命题得证.

        当然，此例还有更直接、简洁的证明：   首先，(2)-(1)，有 2f(x) - 4g(x) = 0，故 f(x) = 2g(x).  
        接着， (1)+(2)，同时以 g(x) 替换 f(x)，得  (x^2+1)h(x) = -3xg(x).

// ZJU Online Judge
// Problem 2253 Fill the Grid
// Algorithm: 记忆化搜索
// Author: obtuseSword
// Date: 2008-06-12
// Compiler: Visual Studio 2005

#include <iostream>
#include <iomanip>
#include <map>
using namespace std;

//========================= 大整数 ===========================//

typedef unsigned long long Integer;   // 语言直接支持的整数类型

const Integer _B = 1000000000000000000;  // 大整数的基

// 大整数类型
class BigInt{
public:
        Integer high, mid, low;  // 大整数从高到低三位

        BigInt(void){
                high = mid = low = 0;
        }

        BigInt(Integer n){
                high = mid = 0, low = n;
        }

        void operator =(Integer n){
                high = mid = 0, low = n;
        }

        void print(void){
                if( high )
                        cout<<high<<setw(18)<<setfill('0')<<mid
                                <<setw(18)<<setfill('0')<<low<<endl;
                else if( mid )
                        cout<<mid<<setw(18)<<setfill('0')<<low<<endl;
                else
                        cout<<low<<endl;
        }
};

// 大整数加法
BigInt operator +(BigInt a, BigInt b){
        BigInt c;
        Integer tmp = a.low + b.low;
        c.low = tmp % _B;
        tmp = a.mid + b.mid + tmp / _B;
        c.mid = tmp % _B;
        c.high = a.high + b.high + tmp / _B;
        return c;
}

//======================== 大整数结束 ========================//


//======================== 全局变量 ==========================//

map<unsigned,BigInt> answer; // 临时答案 Hash 表

// 以下两个数组供状态表示和转换时使用
const unsigned vec[] =
        {1,10,1E2,1E3,1E4,1E5,1E6,1E7,1E8,1E9,1E10};
const unsigned digits[] =
        {0,111111111,222222222,333333333,444444444,555555555,666666666,777777777,888888888,999999999};

//======================= 全局变量结束 =======================//


//=========================== 函数 ===========================//

// 返回某种状态对应的方案数
BigInt count(unsigned state){
        // 如果已记忆，直接返回答案
        if( answer.count(state) )
                return answer[state];
        // 计数主体
        BigInt ans = 0;
        unsigned tmp = state;
        unsigned digit = state % 10, preDigit;
        for(unsigned i = 0; tmp; i++){
                tmp /= 10;
                preDigit = tmp % 10;
                if( digit > preDigit )
                        ans = ans + count(state - vec[i]);
                digit = preDigit;
        }
        // 保存并返回答案
        return answer[state] = ans;
}

int main()
{
        int m, n;               // m 行 n 列
        BigInt ans_tab[10][10]; // 最终答案表

        // 生成最终答案表
        answer.clear();
        answer[11] = 1;
        for(int i = 1; i < 10; i++)
                answer[i] = 1;
        for(m = 1; m < 10; m++)
                for(n = m; n < 10; n++)
                        ans_tab[m][n] = count( digits[n] % vec[m] );

        // 接受询问
        while( cin>>m>>n, m ){
                if( m > n )
                        swap(m,n);
                ans_tab[m][n].print();
        }

        return 0;
}

//========================= 函数结束 =========================//

能够自由自在地思考数学，是我最大的梦想。

什么功名，什么权位，什么利禄，

无非是个无穷小量。

在世俗的喧嚣中，我的心灵难以宁静；

惟有遨游在数学的海洋，

仿佛沐浴着神圣之光，充满信仰。

Java 程序设计课的期末作业是写一个小游戏，我就写了个支持人机对弈的五子棋游戏，机器人的智能还算可以。大家有兴趣可以下载 源代码 或 Java 可执行文件（.jar）看看。

注：源代码使用 eclipse 编辑，JDK 需要 1.5 以上版本。

“我知道一数论学家，他仅在素数的日子和妻子同房：在月初，这是挺不错的，2，3，5，7； 但是到月终的日子就显得难过了，先是素数变稀，19，23，然后是一个大的间隙，一下子就蹦到了 29 …… ”