博客园_hoodlum1980 [ 发发 ] 的技术博客

ZOL1096 （Subway）和 ZOL1086（Octal Fractions）

2011-12-19T20:22:00Z

（一）ZOL 1096：Subway

链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1096

题意：给出下列参数（所有参数均为小于等于1000的正整数），求地铁列车从一个站点到下一个站点之间的最短时间（精确到 0.1 秒）。

d - 地铁站之间的距离（米）;

m - 列车的最大速度（米 / 秒）;

a1 - 最大加速度（绝对值）（米 / 秒^2);

j1 - 最大 jerk （绝对值）（米 / 秒^3).

备注：最后一个条件中的 Jerk 就是加速度对时间的导数：d/dt (a); 相当于列车所受的合力对时间的变化率，该限制条件用于防止车厢内站立的乘客摔倒。

分析：此题的重点在于考察数学和物理基础，编程本身倒不重要。对这道题目，要求求列车运行的最短时间，显然，列车应该尽可能快的加速到最大速度，然后尽可能快的减速到停止。这个结论是很显然的。由于这是OnlineJudge 题目，所以我们也不必此结论做严格的数学证明。（如果不是这样，即列车没有尽可能快的加速，那么其 v- t 曲线就会位于最佳曲线的下方，为了保证面积相等，则其时间一定要超过最佳曲线）

可以绘制出列车运行的速度曲线 v = v( t )，根据物理知识，上诉条件相当于下列表达式：

∫ v dt = d; (列车走过的距离，即 v( t ) 曲线和横轴围成的面积)

v ≤ m;

| d(v)/dt | ≤ a1;

| d^2(v)/dt^2 | ≤ j1;

根据前面的假设，v(t) 在起始阶段一定是以最大的 j1 在加速。因此：

（1）全力加速： v(t) = 1/2 * j1 * t^2; 曲线 v 为一段抛物线。设持续时间为 t1；加速度 a = j1 * t;

（2）当到达t1时，假设此时达到了最大加速度 a1。然后保持加速度为 a1 不变，进入匀加速直线运动阶段，此时曲线 v 为斜率为 a1 的直线。加速度 a = a1；设持续时间为 t3；

（3）在此速度上继续加速，但尽全力降低加速速度，直到最大速度 m。曲线 v 依然是抛物线，只是开口方向相反。持续时间依然为 t1；加速度 a = - j1 * ( t - t1 - t3);

（4）已最大速度 m 进入匀速直线运动。曲线 v 是水平线段，加速度 a = 0；设该段的持续时间为 t2；

（5）全力减速，抛物线，和（3）对称，持续时间为 t1。

（6）以最大减速速度 -a1 进行匀减速直线运动，斜率为 -a1 的直线线段，和（2）对称，持续时间为 t3。

（7）继续全力减速，直到停止在下一个站点，和（1）对称，持续时间为 t1。

注意上诉过程包含了 4 个含有参数 j1 的抛物线片段，先解释下 j1 的物理含义，假设列车运行在光滑轨道上，只受到一个牵引力，则在这些时间段上，牵引力变化的最快，加速度变化的最快（乘客最容易因为惯性发生摇晃）。物理量 Jerk 表示的是加速度变化的速度，根据牛顿第二定律，也就是物体所受合力的变化速度。举个例子，列车如果正在用最大牵引力进行全力加速，这时候乘客倾向于向后倾倒，乘客需要用很大力气紧紧抓住车厢内的扶手，为了让乘客保持稳定，这个牵引力不应该猛然撤去，而应该逐渐减小（相当于上面的曲线片段3），如果在全力加速时一瞬间撤去牵引力，乘客就会感觉很不稳定很不舒服（上海地铁中这种现象很常见，乘客应该有所体会，在列车加速时非常不稳，也就是列车受力的变化速度太快，即 j 太大了，很显然我想上海地铁应该是达不到本题目中要求的这么理想化的）。同理，如果列车在静止状态或者匀速状态，牵引力也应该逐渐加大，而不是一瞬间加到最大（这会对列车产生“猛推”效果，造成乘客在车厢内摇晃）。

最大加速度 a1 的物理含义表征的是牵引或者制动时的最大合力，不考虑刹车的话也就相当于发动机的最大输出牵引力（注：不是功率）。

上诉过程的速度 v（t）曲线如下图所示（注意：图形中的背景色表示的仅是片段的物理运动性质，但不代表相互衔接的曲线一定来自相同函数，下面的 case 图与此相同）：

很显然，曲线是关于垂直中心线轴对称的。求上诉曲线的积分即和 t 轴围成的面积很容易，抛物线由四个片段组成，它们能拼合成两个面积为（m * t1）的矩形。斜率为 ±a1 的匀加速直线运动部分，是两个梯形，它们也能拼合成一个面积为（m * t3）的矩形。最后中间的匀速直线运动部分，是一个面积为（m * t2）的矩形。因此，对于上诉过程有：

d = ∫ v dt = m * ( t1 * 2 + t3 + t2 ); // 两个站点之间的距离

min ( t ) = t1 * 4 + t3 * 2 + t2; // 最短运行时间

注意：这是一种运动种类最多的“理想状况”，即距离 d 足够长，使得可以加速到最大速度 m； a1 要足够小，使得可以“割断”抛物线，出现斜线部分。实际上由于四个参数的值是任意给出的整数，这些参数可能只有一部分真正的对结果产生了限制作用，因此我们必须考虑下面的四种实际 case，如下图所示：

（1）case 1：受到距离 d 的限制，不受 m，a1 的限制。曲线只有四个抛物线片段。

根据：∫ v dt = max(v) * t1 * 2 = (j1 * t1^2) * t1 * 2 = d; （受到距离 d 的限制）

结果：min(t) = t1 * 4 = [ (d / 2 j1) ^ (1/3) ] * 4;

条件1：max(v) = j1 * t1^2 ≤ m; （不会受到最大速度 m 的限制）

条件2：max(a) = j1 * t1 ≤ a1; （不会受到最大加速度 a1 的限制）

　（2）case 2：受到最大速度 m 的限制，即能加速到最大速度m（此种情况可认为不受距离 d 的限制，当然也可以说 m 太小），同时也不受 a1 的限制。曲线由四个抛物线片段加一段水平线段组成。

根据：1/2 * j * (t1 ^ 2) = m / 2; （受到最大速度 m 的限制）

求出：t1 = sqrt (m / j1); 以及 t2 = (d - m * t1 * 2)/m;

结果：min(t) = t1 * 4 + t2;

条件1：m * t1 * 2 ≤ d; （不会受到距离 d 的限制）

条件2：max(a) = j1 * t1 ≤ a1; （不会受到最大加速度 a1 的限制）

　（3）case 3：受到最大加速度 a1 的限制，同时受到距离 d 的限制，所以不能加速到最大速度 m （即不会受到最大速度 m 的限制）。曲线由四个抛物线片段加上两段斜率绝对值为 a1 的倾斜线段组成。则由下列方程：

j1 * t1 = a1; （受到 a1 的限制）

max(v) = j1 * (t1^2) + a * t3;

d = max(v) * (t1 * 2 + t3);

结果：min(t) = t1 * 4 + t3 * 2;

条件1：max(v) ≤ m; （不受到最大速度 m 的限制）

条件2：t3 ≥ 0; （关于 t3 的负数解在后面讨论）

整理上面的方程式，我们得到一个关于 t3 的一元二次方程如下：

a1 t3^2 + [ 3 (a1^2) / j1 ] t3 + [ 2 ( a1^3 ) / ( j1^2 ) - d ] = 0;

可以根据一元二次方程的求根公式求出上面的 t3，解有两个，显然应该舍弃其中为负数的根，取正数根。

【注意】这里 t3 的被舍弃的负数解的数学和物理意义是什么？在给出代码后将继续讨论这个问题。

（4）case 4：就是前面分析过的所有运动都包括。受到 a1 的限制因此有斜线段部分，受到 m 的限制因此有水平线段部分。但不受到距离 d 的限制（即能加速到最大速度）。有：

j1 * t1 = a1; （受到最大加速度 a1 的限制）

m = j1 * (t1^2) + a * t3; （受到最大速度 m 的限制）

t2 = ( d - m * t1 * 2 - m * t3 ) / m; （不受到距离 d 的限制）

结果：min(t) = t1 * 4 + t3 * 2 + t2;

case 4 需要满足的条件实际上不需要列出，因为如果前面的case都不满足条件，则一定会落入case 4。这里为了完备，我依然给出case 4需要满足的条件：

条件1：max ( v ) / 2 = 1/2 * j1 * (t1^2) ≤ m/2; （为了能达到最大加速度a1，要有足够的加速空间，因此 m 必须足够大）。

条件2：m * ( t1*2 + t3 ) ≤ d; （为了达到最大速度，必须有足够长的距离，因此 d 必须足够大）。

/***************************************************************/

好了，现在我们已经考虑了四种 case，有没有任何遗漏的 case （要注意如果有就意味着 WA！）？考虑下斜线段出现的条件是不是一定要达到最大加速度 a1？是的，因为如果没有达到最大加速度 a1 就进入某个斜率小于 a1 的斜线段，那么如果我们继续走抛物线（因为这时速度上还有继续加速的空间，而加速度还没有上升到最大值 a1，所以抛物线是可继续的），就能更快达到最大速度，因此最终使用的时间一定会更短（假设在某点有两条岔路，一条是高速公路，一条是坑坑洼洼的土路，它们都是可选的，你选哪一条？）！

总结：注意上面的所有条件中都有等于号，等于即表示 case 和 case 之间的临界点。上面的 case 的排序是根据编码实现比较方便的情况，从 case 1 可以比较容易演化到后续的 case（但其他 case 之间的演化，参数之间的相互作用要稍复杂一些），例如：处于 case1 时，如果把 m 水平线向下移动（减小 m），就会从 case1 转入 case2；如果把表示斜率的那条射线向水平方向的 t 轴方向转动（减小 a1 ），就会从 case1 转入 case3；或者把距离拉长（增大 d），则曲线将向上浮动，最大速度将增大，如果先遇到 m 限制，则从 case1 转入 case2，如果先遇到 a1 限制，则从 case1 转入 case3。如果前面的case不能符合条件，则最终一定会落入位于后面的case（这里我依然是基于我个人的编程经验和直观印象，最好应该更严谨一点）。case1是最特殊也是最简单的情况。最后的结果是一个四元函数（超过了比较容易直观理解的维度）：

min ( t ) = f (d, m, a1, j1);

可以想象根据上面的求解过程，它类似分段函数，在不同范围内是关于不同变量的函数。

最后我们对上诉 case 给出下列表格：

CASES	起到限制作用的参数	运动组成	最短时间
case 1	d	抛物线	t1*4
case 2	m	抛物线, 水平线(匀速)	t1*4 + t2
case 3	d, a1	抛物线, 斜线(匀加速)	t14 + t32
case 4	m, a1	抛物线, 斜线(匀加速), 水平线(匀速)	t14 + t32 + t2

注意参数 j1 的用法和其他三个参数不同，它是直接应用到抛物线函数中的参数，是唯一被直接使用的参数（其他三个参数主要起到限制作用），所有 case 都会包含四个抛物线片段，所以上表中 j1 不会在“起到限制作用的参数”中列出。前面已经提到过，这是基于直观印象的结果，我们尚未（也并无必要）从数学上去证明这一点。

最后给出该题目的代码，实际上就是从上诉推导过程直接翻译过来，代码本身没有任何难度。

#include <stdio.h>
#include <math.h>

double GetMinTime(int d, int m, int a, int j)
{
    double t1, t2, t3;

    /* case 1: 受限于路程d。全程 O(t^2) 加速，只有抛物线的四个片段组成 */
    t1 = pow(d*0.5/j, 1.0/3.0);
    if(j * t1 <= a && j * t1 * t1 <= m)
    {
        return t1 * 4;
    }

    /* case 2: case 1 的基础加上 v = m 的匀速运动。可以加速到最大速度m。*/
    t1 = sqrt(m*1.0/j);
    if(j*t1 <= a && m*t1*2 <= d)
    {
        t2 = d*1.0/m - t1*2;
        return t1 * 4 + t2;
    }

    /* case 3: 受限于最大加速度a。全称加速，不能加速到最大速度m */
    /* 含有两段匀加速直线运动 O(t^2) and O(t) */
    t1 = a*1.0/j;
    double aa = a;
    double bb = a*a*3.0/j;
    double cc = a*a*a*2.0/(j*j) - d;
    
    t3 = (sqrt(bb*bb - 4*aa*cc) - bb)/(aa*2);
    double vmax = a*a*1.0/j + a*t3;
    /* double s = vmax * (t1 * 2 + t3); */

    if(t3 >= 0 && vmax <= m)
    {
        return t1 * 4 + t3 * 2;
    }

    /* case 4: 受限于最大速度m。中途匀速 */
    t3 = m*1.0/a - a*1.0/j;
    t2 = d*1.0/m - (t1*2 + t3);
    /* 此处必定满足：t1>=0, t2>=0, t3>=0 */
    return t1 * 4 + t3 * 2 + t2;
}

int main(int argc, char* argv[])
{
    double time;
    int d, m, a, j;
    while(scanf("%d %d %d %d", &d, &m, &a, &j) != EOF)
    {
        time = GetMinTime(d, m, a, j);
        time = ((int)(time*10 + 0.5)) * 0.1; /* 对 0.1 以下的小数四舍五入 */
        printf("%.01f\n", time);
    }
    return 0;
}

最后，这道题目的序号是1096，位于第一个 problem sets 内，可以说排序是非常靠前的，但 AC 数量目前只有 172 ，提交数量只有 558，可见这些数据还是反映了其“难度”，但是难度主要在于数学和物理知识基础上，和编程本身，算法等技巧上倒是没有太大关系。

【补充讨论】case3 中 t3 的负数解的数学意义。

在case 3中，求解 t3 的一元二次方程现在提出一个问题，为什么出现负数解，其数学和物理意义是什么，该方程是由 d，a1，j1 （不受到 m 的限制）组成的表达式为系数。由于方程的前两个系数必定为正数，因此其中的一个根一定是负数（如果存在解）。那么为什么存在负数解，它的意义是什么？

首先，在数学上，列出该方程的前提是，t3 >=0，最终列车经过抛物线和匀加速直线运动，到达下一个站点。我们对 d，a1，j1 代入具体数值，构造出一正一负的两个解。参数是：

a1 = 2; j1 = 2; d = 12;

这时候抛物线部分是标准抛物线 y = x^2;

可以解出 t1 = 1;

关于 t3 的方程是 t3^2 + 3 * t3 - 4 = (t3 - 1) (t3 + 4) = 0; 因此 t3 = 1 或者 t3 = -4；

可以在数学上绘制出 t3 的这两个解的情况的 v-t 曲线，如下图所示：

图中红色线条部分就是 t3 = -4 的情况。图中的红色箭头表示的是积分方向。因此可见上面的曲线积分中，抛物线（t1）和斜线段（t3）之间由于积分方向不同，存在一些相互抵销作用。从而最终能积到面积 d。这是 t3 的负数解在数学上的含义。但是在物理意义上这样是很难理解的，因为从抛物线片段后，出现了“负时间”，即时间倒流，最终列车停下来时是出发前 4 秒中。因为向着 t 轴负方向，所以 a = dv/dt 并未发生突变。而这种情况在物理意义上比较难以理解。

为了更好理解，换一种方式，把上图中的斜线段部分全部向 t 的正方向映射（由于做了镜面映射，dx = -dx' 所以对应线段上的积分方向同时会被改变），从而上图会演化成下面的图形：

在上图中，如果把 t3 视作正数，则意味着加速度在每个衔接点处发生突变（即列车受到无穷大作用力，或者列车质量忽略不计，可看作没有质量没有惯性的质点），显然这也是超现实的。如果不考虑图中的积分方向，则曲线形成的面积显然比 d 大，因此图中标示出了积分方向，实际上两部分是相互抵销作用（斜线部分的积分是 24，抛物线部分的积分是 -12，因此最终两者累加结果是 d = 12）。

尽管 t3 的负数解在物理上没有令人满意的含义，但这就是满足 v 的积分 = d 的数学上的另一种可能情况。

（二）ZOL 1086： Octal Factions

链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1086

题意：给出一个八进制的小数，转换为 10 进制小数。输出格式是：0.d1d2d3 ... dk [8] = 0.D1D2D3 ... Dm [10]；

例如对八进制小数0.75，转换为10进制，输出格式：0.75 [8] = 0.953125 [10]。

分析：整数的进制转换的方法非常简单，而这道题目是小数进制转换，把 8 进制转换到 10 进制的直接方法是：

Decimal = d1 * 8^(-1) + d2 * 8^(-2) + ... + dk * 8 ^(-k)

例如对 0.75 （8进制），十进制小数 = 7 / 8 + 5 / 64 = 0.963125;

但是仅仅从题目给出的样例输出来看，语言本身的内置数据类型 double 的精度可能已经不能满足要求了，因此这道题目看起来还是类似大数运算一类的题目，需要借助一个数组来存储数位。但是如果用上面的直接转换方法从 8 进制转换到 10 进制，用数组的方法，在编码实现上是很不方便的。所以考虑以 2 进制小数作为中介，即先把 8 进制转换到 2 进制小数，再转换到 10 进制。后面我们就能看到，这样我们就能很方便的利用数组来保存和给出具有任意精度（取决于数组大小，当然，如果追求更高精度也会引入少许时间和空间的代价）的结果。

把 8 进制小数转换到 2 进制小数的方法非常简单，只需要把8进制小数的每一位用三位二进制数表示即可，例如 0.75 [8] = 0.111 101 [2]; 设 d1 = (b1 b2 b3) [2], d2 = (b4 b5 b6) [2]：

则对应的：0.d1 d2 d3 ... dk [8] = 0.b1 b2 b3 b4 b5 b6 ... b(3k) b(3k+1) b(3k+2) [2]

这是显然的，因为：d1 = b1 * 4 + b2 * 2 + b3，...

所以 d1 * 8^(-1) + d2 * 8^(-2) + ... + dk * 8 ^(-k) = (b1*4 + b2*2 + b3) / 8 + ... = b1/2 + b2/4 + b3/8 + ... = 0.b1b2b3b4...[2];

再把这个二进制小数转换到 10 进制。为了精度需要，这里我引入一个数组：

unsigned char Dec[K]; // K 是一个常数，表征精度

这个数组的意义是，如果10进制小数是 0.D1D2D3 ... Dm [10]，则 Dec[i] = D(i+1); 最终的10进制小数将是这样：

0. Dec[0] Dec[1] Dec[2] ...

打印时只需要在前面加上“0.”前缀，然后从 0 索引开始依次输出其元素即可。

这里必须注意到二进制小数的小数点后第 k 位的基数 (0.5 ^ k) 的一个很重要的特征，即 (0.5 ^ k) 的小数点后的位数个数是 k（之后将全部是 0）。例如：

0.5，0.25，0.125，0.0625，...

注意这个序列，b[ i + 1 ] = b[ i ] / 2; 由于末尾数永远是5，因此每一次除以 2 都会导致递增一位。因此引入另一个辅助存储空间，用于存储 2 进制小数的从小数点后第 1 位到第 K 位的基数（K 取决于需要的精度），显然这是一个矩阵，例如如果取 K = 6，则定义矩阵 A ：

unsigned char A[6][8];

经过初始化计算后，A 的内容如下：

5, 0, 0, 0, 0, 0, 0, 0, // A[0]: 0.5

2, 5, 0, 0, 0, 0, 0, 0, // A[1]: 0.25

1, 2, 5, 0, 0, 0, 0, 0, // A[2]: 0.125

0, 6, 2, 5, 0, 0, 0, 0, // A[3]: 0.0625

0, 3, 1, 2, 5, 0, 0, 0, // A[4]: 0.03125

0, 1, 5, 6, 2, 5, 0, 0, // A[5]: 0.015625

它的右上角元素全是0，应该算是一个下三角矩阵。其意义是 A[k] 是二进制小数第 k+1 位的基数，即 A[k] = 1/2^(k+1); 小数位长度是 Length (A[k]) = k+1;

这个矩阵类似做菜时事先准备的材料，在求解之前先计算好备用。

求解过程如下，首先把结果 Dec 数组全部清零，然后对 8 进制的小数的每一位小数，当作三位二进制数，如果对应的位为 1，就把该位的基数（ A[k] ）逐位累加到结果数组 Dec。最后我们在从后（远离小数点的那一侧）向前处理进位即可，这个过程称为规整，即大数算法中最后的步骤。

代码如下：

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

/* 计算结果 0.N[0] N[1] ... */
unsigned char Dec[48];

unsigned char A[48][56]; /* A[k] = 1/( 2^(k+1) ) */

/* A[k] 's digit length = (k + 1) */

void Init()
{
    int i, j, carry = 0;
    A[0][0] = 5;
    for(i = 1; i < 48; i++)
    {
        for(j = 0; j < (i+1); j++)
        {
            A[i][j] = (A[i-1][j] + carry) / 2;
            carry = (A[i-1][j] & 1) * 10;
        }
    }
}

/* 返回 digit 数位长度*/
int Convert(char* pOctNum)
{
    /* 位索引 */
    int testNum[] = { 4, 2, 1 };
    int index = 0, length = 0;
    int i, j, carry, digit;
    char* p = pOctNum + 2; /* Ignore "0." */

    memset(Dec, 0, sizeof(Dec));
    while(*p)
    {
        digit = *p - '0';
        for(j = 0; j < 3; j++)
        {
            if(digit & testNum[j])
            {
                length = index*3 + j + 1;
                for(i = 0; i < length; i++)
                    Dec[i] += A[index*3 + j][i];
            }
        }
        ++p;
        ++index;
    }

    /* 归整数位 */
    for(i = length; i > 0; --i)
    {
        if(Dec[i] > 9)
        {
            carry = Dec[i]/10;
            Dec[i-1] += carry; 
            Dec[i] = Dec[i] - carry * 10;
        }
    }
    return length;
}


int main(int argc, char* argv[])
{
    int length, i;
    char line[256];
    Init();
    while(gets(line) != NULL && line[0] != 0)
    {
        length = Convert(line);
        printf("%s [8] = 0.", line);
        for(i = 0; i < length; i++)
        {
            printf("%d", Dec[i]);
        }
        printf(" [10]\n");
    }
    return 0;
}

总结：

（1）上面的方法，引入的辅助数据是二进制小数的基数，这是因为二进制小数在数位上只有 0 ，1 两种可能，这样实际上就是提供的结果就是，我们是否累加某一个基数到结果中。考虑如果我们用辅助空间存储的直接就是 8 进制小数的基础，则首先，我们要准备这样的基数的代码实现就比较麻烦（准备过程同样是大数除以一个小整数的大数运算！！）。另一点很不便的就是每个基数的小数的位长度和所在位之间没有直接的函数关系（而2进制小数的基数具有这样一个直接关系），我们还需要用对应的某一位上的数字去乘以这个基数再进行累加（而二进制小数的基数直接累加即可）。当然主要的麻烦在于第一点。第二点本来就位于大数算法中的过程之中，所以倒不显得困难。

（2）思考上面的累加过程然后规整数位，有一个累加进位的过程，但该过程是不可能使进位持续到整数部分的，即，假设一个小数的进制为 k ( k >= 2 )，则如果小数点后每一位都是最大数字（k - 1），则这个小数在无限长循环下等于1。即：

1 = 0.99999...[10] = 0.11111...[2] = 0.77777...[8];

该小数为数列的求和：

f (n) = (k-1) * (k^-1 + k^-2 + ... k ^ -n) = (1 - k^-n) ;

n 趋向无穷大时，lim f(n) = 1;

（3）题目中并没有明确指明或者暗示我们最终结果的精度，我们如果想要得到更高精度可以把数组取得更大，同时会增加内存需求。因此 K 的取值需要逐渐调整然后提交去“试验”。最初我取 K 值为 256，空间需求略大。最终代码中取 K = 48，结果就内存就已经降低到了ZOL上 C 语言的典型内存需求（120 KB左右）。

【注】本文插图由 GrafEq 和 Photoshop CS 共同绘制。

本文链接

有关进程空间，全局变量，静态变量

2011-11-23T15:13:00Z

【创新性声明】本文没有本质上的创新性内容。属于一些实验和总结，有少量主观推测成分（有待进一步证实）。写这一类文章是非常危险的，因为有很多东西可能是我们不了解和比较模糊的，这很可能会出现错误的主观臆测，不仅仅是令明真相者贻笑大方的问题，更可怕的在于传播“错误”，这是我最为诚惶诚恐的一点。比如，我之前见到我指点过他的sun先生对于Photoshop中置换滤镜中的他的那些主观错误结论已经传遍网络，尽管可能没有太多人能关注到这个层面，但是我还是为这些错误的观点在网络上比比皆是而深感遗憾。正因为此，这篇文章我受限于个人水平，也不能100%确保自己不犯下认知性错误，因此此本（1）需要更专业的人的监督和意见，（2）可能随着我自己认知的变化而进行修订和变更。

最近在一些回复中提到了一些静态变量，线程安全性，递归函数调用的问题。尽管大概情况我已经清楚，但感觉自己在某些细节方面还稍显模糊，因此在这个问题应该从底层上做一个重新的总结，把一些比较容易产生模糊的问题总结下。

（1）全局变量，和静态变量位于进程空间什么位置。

为此，我用 VC6 新建了一个 Windows Console Application 。并输入代码如下：

#include <stdio.h>
#include <stdlib.h>
//#include <process.h>
#include <tchar.h>
#include <windows.h>

typedef HANDLE (WINAPI *FuncPtr)(
    LPSECURITY_ATTRIBUTES lpThreadAttributes,
    SIZE_T dwStackSize,
    LPTHREAD_START_ROUTINE lpStartAddress,
    LPVOID lpParameter,
    DWORD dwCreationFlags,
    LPDWORD lpThreadId
    );

class TestClass
{
public:
    TestClass()
    {
        printf("TestClass's constructor.\n");
    }
    ~TestClass()
    {
        printf("TestClass's destructor.\n");
    }
};

TestClass g_class;

int g_Temp1 = 0x11223344;
int g_Temp2;
int g_Array[4];
int g_Temp3;


//The default size for the reserved and initially committed stack memory 
//is specified in the executable file header. 
DWORD WINAPI threadProc(LPVOID lpParameter)
{
    int a = 0;
    int threadIndex = (int)lpParameter;
    printf("%p: auto variable on new thread's stack (thread: %d)\n", &a, threadIndex);
    return 0;
}

int main(int argc, char* argv[])
{
    static int nStatic1 = 0x12345678;
    static int nStatic2 = 0x00abcdef;
    static int nStatic3;

    int a = g_Temp1 & 0xffff;
    char* pConstData = "Hello World"; 

    //pConstData[1] = 0; //内存访问冲突（不可写）

    char* pHeap1 = (char*)malloc(32);
    char* pHeap2 = (char*)malloc(32);

    printf("---enter main----\n");
    HMODULE hModule = GetModuleHandle(_T("Kernel32.dll"));
    printf("%p: Module (Kernel32.dll)\n", hModule);

    FuncPtr pFunc = CreateThread;
    printf("%p: FuncPtr (CreateThread)\n", pFunc);
    
    DWORD tid1, tid2;
    HANDLE hThread1 = CreateThread(NULL, 0, threadProc, (LPVOID)1, CREATE_SUSPENDED, &tid1);
    HANDLE hThread2 = CreateThread(NULL, 0, threadProc, (LPVOID)2, CREATE_SUSPENDED, &tid2);
    
    ResumeThread(hThread1);
    WaitForSingleObject(hThread1, 5000);
    CloseHandle(hThread1);
    ResumeThread(hThread2);
    WaitForSingleObject(hThread2, 5000);
    CloseHandle(hThread2);
    
    printf("%p: auto variable on main thread's stack\n", &a);
    printf("%p: memory alloc on heap: pHeap1 (32 bytes)\n", pHeap1);
    printf("%p: memory alloc on heap: pHeap2 (32 bytes)\n", pHeap2);
    printf("%p: address of const data(\"hello world\")\n", pConstData);
    printf("%p: global variable g_Temp1 (initialized)\n", &g_Temp1);
    printf("%p: global variable g_Temp2 (not initialized)\n", &g_Temp2);
    printf("%p: global variable g_Array (not initialized)\n", g_Array);
    printf("%p: global variable g_Temp3 (not initialized)\n", &g_Temp3);
    printf("%p: static variable nStatic1 (initialized)\n", &nStatic1);
    printf("%p: static variable nStatic2 (initialized)\n", &nStatic2);
    printf("%p: static variable nStatic3 (not initialized)\n", &nStatic3);
    free(pHeap1);
    free(pHeap2);
    printf("---leave main----\n");
    return 0;
}

在这个例子里我添加了全局变量，auto 类型的栈上临时变量，函数内的静态变量，以及新创建的线程的栈上的变量等。此程序产生的输入如下：

 1 TestClass's constructor.
 2 ---enter main----
 3 7C800000: Module (Kernel32.dll)
 4 7C810647: FuncPtr (CreateThread)
 5 0052FFB0: auto variable on new thread's stack (thread: 1)
 6 0062FFB0: auto variable on new thread's stack (thread: 2)
 7 0012FF7C: auto variable on main thread's stack
 8 00370FE0: memory alloc on heap: pHeap1 (32 bytes)
 9 00371038: memory alloc on heap: pHeap2 (32 bytes)
10 00423148: address of const data("hello world")
11 00425B40: global variable g_Temp1 (initialized)
12 00428D78: global variable g_Temp2 (not initialized)
13 00428D68: global variable g_Array (not initialized)
14 00428D64: global variable g_Temp3 (not initialized)
15 00425B44: static variable nStatic1 (initialized)
16 00425B48: static variable nStatic2 (initialized)
17 00428D60: static variable nStatic3 (not initialized)
18 ---leave main----
19 TestClass's destructor.

首先，我们可以看到一个类的实例作为全局变量，它的构造函数在进入入口点函数（main）之前被调用，在main函数之后被析构。这显示这个过程应该是包装在main函数外层的函数，也就是 CRT 做的。

上面的输出给出了各个变量在进程空间中的地址（虚拟内存地址），因此我们再对照一下编译后的PE文件的 SectionHeader 的信息，使用我编写的文件格式查看器打开编译后的EXE文件，如下图所示：

根据PE文件中的信息:

ImageBase = 0x0040 0000;

SectionAlignment = 0x1000;

FileAlignment = 0x1000;

可以根据 section header 的信息知道，各个段在进程空间中的地址是（对比程序输出，可知全局变量和常量字符串在那个段范围内）:

section	From	To	Characteristics	备注
.text	00421790	00422790	可执行，可读	代码段
.rdata	00423000	00424777	可读	初始化数据段（常量）
.data	00425000	0042A730	可读，可写	初始化数据段（全局和静态变量）
.idata	0042B000	0042B7CC	可读，可写
.reloc	0042C000	0042CEC9	可读，可丢弃	基址重定位

上表是根据PE文件中的信息给出了进程空间中各个段的地址范围。因此我们根据运行时的输出情况，可以很容易的确定哪些变量具体位于进程空间的那个段中。例如针对这个具体的实例来说，全局变量和函数内静态变量位于 .data 段，常量字符串位于 .rdata 。

注意由于 SectionAlignment 和 FileAlignment 是相同的，因此文件中的内容和映射后，节之间的相对位置是没有变化的。节的特性被设置给内存页，因此如果代码中试图对内存执行没有权限的操作，例如对常量字符串的地址进行写入，系统就会告知错误。可以看到 section 的起始地址使用 sectionAlignment （默认 0x1000）对齐。数据段默认不具有共享属性，被映射以后数据是该进程空间所私有的。但共享的段则在所有进程实例中共享。可以设定某个段为共享，当使用一个DLL时，则数据通过DLL来给所有进程共享，共享意味着在所有进程空间中，该段被映射到相同的物理内存页。例如《windows 核心编程》中有一个例子，当创建多个进程实例，对话框上能实时更新的显示出当前实例的个数。（同时这也是作为用于控制只能运行一个进程实例的方法之一）：

// Tell the compiler to put this initialized variable in its own Shared 
// section so it is shared by all instances of this application.
//
#pragma data_seg("Shared")
volatile LONG g_lApplicationInstances = 0;
#pragma data_seg()

// Tell the linker to make the Shared section readable, writable, and shared.
#pragma comment(linker, "/Section:Shared,RWS")

可以看出常量字符串代码中的"Hello World”位于.rdata节，该节是不可写的。全局变量和静态变量都位于.data节，可读可写。代码中已初始化的数据在节内位于靠近节前部地址较低的地方，未初始化的数据靠地址较高的地方。对于程序中的基本类型变量例如整形等，实际上它们从文件中被读入内存后就已具有了初值，相当于完成了初始化。但对于一个类的实例来说，对其初始化需要调用其构造函数。这些都需要在进入入口点函数之前完成。

因此现在我们可以明确：

char str[] = "Hello World";

含义是 str 数组是位于栈上的数组，然后从初始化段（只读）拷贝字符串内容到栈上的数组。（编译器可能对其用 DWORD 进行拷贝）

char *str = "Hello World";

str 是位于栈上的一个指针，指向初始化段的只读数据。

初学者一般不太容易立即区分出上面的代码在底层上的区别：前者是栈上的数组，数组空间在栈上分配。编译器会插入代码，在运行时把数据从只读数据段拷贝到栈上空间。所以前者的 str 是可写的。后者是栈上的一个指针变量，指向只读数据段上的某个位置（在C++里面这样的赋值合法，是为了照顾成千上万的已有 C 代码）。后者的 str 是不可写的。如果试图修改它，在编译上是通过的，但运行时属于不确定行为。

我先后创建两个新的线程，是为了观察新线程的栈的位置，可以看到在这个例子中，在创建时我没有指定栈的大小，默认是 1MB。从低地址往高地址数，主线程的栈在进程空间中相当靠前，（中间的空隙属于堆），然后是那些 sections，然后此处剩下很大的一段空隙又基本上全部是属于堆。然后是新创建的线程的栈（默认 1MB），它们的地址看起来已经相当高。然后是那些被影射进来的DLL，系统 DLL 都经过了 Rebase，一般位于比较高地址的地方（靠近 2GB 边界），最后是系统控制的空间边界（0x80000000）。当然，默认情况下，是程序员和系统各占 4GB 空间的一半，但可以通过启动的配置参数让程序员负责的空间达到 3GB。因此上面的范例的进程空间大体如下图所示：

当然这个图只是针对这个控制台程序例子的特例而绘制，只是给出该例子中进程空间的示意图。图中箭头表示的是栈的增长方向。当一个进程中运行多个线程时，它们各自拥有独立的栈。当然这些栈之间由于位于相同的地址空间，所以它们彼此是可见的。因此一个线程可以把自己的栈上地址传递给其他线程进行处理，但这种地址随着线程退出就会失效，因此必须做线程同步，即阻塞式等待。例如不能使用 PostMessage 传递栈上的地址给其他窗口的窗口过程，而使用 SendMessage 是可行的。

当我们提到并发性和多线程安全，通常在针对一个函数讲时，是进程空间内的多个线程同时调用该函数是否会引发问题。并发还指多个线程对同一资源的访问和使用，例如数据库，文件等。如果一个函数是可重入的，则它不能直接或简介的使用，引用静态，全局性变量（尤其是对这些共享性变量的读写不是原子性的，且这些变量的值的准确性如果对于使用者来说是关键的状态性数据，则会引入诸如“脏读”等问题），也不能直接或简介调用不可重入的函数。栈上的一个 auto 类型变量是多线程安全的，是因为栈是属于线程的，彼此独立，因此 auto 类型变量对于线程来说相当于“私有数据”。对于递归函数，每一层递推都会在栈上增加一层 stackframe，因此函数内的临时变量位于其各自调用所属的 stackframe 中，也相当于彼此独立。

（2）系统调度，消息队列的基本单位。

这里我们提及的是进程和线程，不再考虑线程以下的概念。考虑下面的问题：

2.1 拥有消息队列的基本单位是什么？A。窗口；B。线程。

答案是线程。但通常我们更容易把消息队列和窗口关联在一起，这仅仅是因为事件驱动给我们的一种主观表象。由于调度的基本单位是线程，因此处理消息和拥有消息队列的基本单位也是线程。系统派送消息的目标，是把消息送到创建窗口的线程所拥有的消息队列。然后该线程被调度得到时间片，由消息循环（DispatchMessage）间接调用该窗口的窗口过程函数。但一个线程不一定拥有消息队列，例如只专注于运算不负责接受消息控制的后台线程，只有线程调用 PeekMessage，GetMessage 一类的函数时，系统才会为这个线程创建消息队列。拥有消息队列的线程也不一定会创建窗口，但是创建窗口的线程就会接收到和窗口有关的各种消息。

总结一下，线程中根据其功能又可以大致的分为主线程（或者在GUI程序中通俗的理解为 UI 线程）和后台线程。消息中的一部分属于窗口消息，这些消息是和一个具体的窗口关联并以创建该窗口的线程的消息队列作为目标的（最终线程的消息循环负责引发对窗口过程的调用，即 DispatchMessage），但并不是所有的消息都会和具体窗口关联。例如普通的线程消息（而一个线程也可能不会创建任何窗口）。窗口消息中的一部分又可以属于对话框消息。

2.2 比较特殊的几个消息：WM_MOUSEMOVE, WM_TIMER, WM_PAINT, WM_QUIT; (待完成）

线程消息分为三种类型：incoming sent message; posted message; input message; 在标准术语里面，第一种被称为非队列消息，后两种称为队列消息，也就是被理解为“位于消息队列中的消息”。

参考资料：

（1）《程序员的自我修养》，俞甲子等。

（2）“Billy Belceb 病毒教程Win32篇”（选自《看雪学院五周年纪念收藏版》）, Billy Belceb。

（3）《windows核心编程》, Jeffery Richer.

（4）《Tho Old New Things》, Raymond Chen.

（5）《The C++ Programming Language》，BS。

　　　　【补充说明】

　　　　本文已有的评论，因为涉及到有具体所指的个人主观性意见，于技术探讨交流上没有任何积极意义，因此不在技术博客保留，已转移到163博客的以下地址进行备份性保留（可以点击以下地址观看原有评论）：

　　　　http://blog.163.com/jinfd@126/blog/static/62332277201211104431759/

　　　　我欢迎一切针对技术本身的意见和负面批评，并对所有评论进行保留，但以上内容不包括和技术无关的主题（例如无实质内容的评论，明显针对人的主观评价等）。

　　　　--hoodlum1980，2012年2月1日。

本文链接

ZOL 简单题集合（三）

2011-11-18T12:17:00Z

（1）ZOL1045. HangOver (0.1)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1045

在桌子边码扑克牌，给出表示扑克牌延伸出桌子的距离的浮点数，问需要多少张牌。

#include <stdio.h>
int GetCardCount(double c)
{
    int result = 1;
    double dx = 0.5;
    while(dx < c)
    {
        result++;
        dx += 1.0/(result + 1.0);
    }
    return result;
}
int main(int argc, char* argv[])
{
    double c;
    int result;
    while(1)
    {
        scanf("%lf", &c);
        if(c < 0.001) break;
        result = GetCardCount(c);
        printf("%d card(s)\n", result);
    }
    return 0;
}

（2）ZOL1061. Web Navigation (0.2)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1061

模拟浏览器的前进后退功能，给出初始时刻的当前页面，然后经过一系列命令：访问某个url，前进，后退，如果命令有效，输出当前页面。

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

char sForw[100][72];
int pForw;
char sBack[100][72];
int pBack;

int main(int argc, char* argv[])
{
    int n, i;
    char curUrl[72], line[96];
    
    scanf("%d", &n);

    for(i = 0; i < n; i++)
    {
        //case和case之间的空行
         gets(line);
        strcpy(curUrl, "http://www.acm.org/");
        pForw = -1;
        pBack = -1;
        while(1)
        {
            gets(line);
            if(strcmp(line, "BACK") == 0)
            {
                //If the backward stack is empty, the command is ignored.
                if(pBack < 0) printf("Ignored\n");
                else
                {
                    //Push the current page on the top of the forward stack.
                    ++pForw;
                    strcpy(sForw[pForw], curUrl);
                    
                    //Pop the page from the top of the backward stack, 
                    //making it the new current page.
                    strcpy(curUrl, sBack[pBack]);
                    --pBack;

                    printf("%s\n", curUrl);
                }
            }
            else if(strcmp(line, "FORWARD") == 0)
            {
                //If the forward stack is empty, the command is ignored.
                if(pForw < 0) printf("Ignored\n");
                else
                {
                    //Push the current page on the top of the backward stack. 
                    ++pBack;
                    strcpy(sBack[pBack], curUrl);

                    //Pop the page from the top of the forward stack, 
                    //making it the new current page.
                    strcpy(curUrl, sForw[pForw]);
                    --pForw;
                    printf("%s\n", curUrl);
                }
            }
            else if(strncmp(line, "VISIT", 5) == 0)
            {
                //Push the current page on the top of the backward stack, 
                ++pBack;
                strcpy(sBack[pBack], curUrl);
                
                //and, make the URL specified the new current page. 
                strcpy(curUrl, line + 6);

                //The forward stack is emptied.
                pForw = -1;
                printf("%s\n", curUrl);
            }
            else if(strcmp(line, "QUIT") == 0)
            {
                break;
            }
        }
        //case 和 case 之间用空行隔开
         //注意这个if条件，如果没有，则导致PE！（多打印一个空行）
         if(i < n - 1) printf("\n"); 
    }
    return 0;
}

（3）ZOL1067. Color Me Less (0.1)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1067

给出16个RGB值作为关键颜色，对后续给出的颜色，要求用欧几里德距离最短的方式，被映射到哪个关键颜色上。

include <stdio.h>

typedef struct _tagColor
{
    int r;
    int g;
    int b;
} Color;

Color colors[16];

int GetMappedIndex(int r, int g, int b)
{
    unsigned int distance = 0xFFFFFFFF;
    unsigned int temp;
    int i, index = -1;
    for(i = 0; i < 16; i++)
    {
        temp = (r-colors[i].r) * (r-colors[i].r);
        temp += (g-colors[i].g) * (g-colors[i].g);
        temp += (b-colors[i].b) * (b-colors[i].b);
        if(temp < distance)
        {
            distance = temp;
            index = i;
        }
    }
    return index;
}

int main(int argc, char* argv[])
{
    int i, r, g, b;
    for(i = 0; i < 16; i++)
    {
        scanf("%d %d %d", 
            &colors[i].r, &colors[i].g, &colors[i].b);
    }
    while(1)
    {
        scanf("%d %d %d", &r, &g, &b);
        if(r == -1) break;
        i = GetMappedIndex(r, g, b);
        printf("(%d,%d,%d) maps to (%d,%d,%d)\n",
            r, g, b, colors[i].r, colors[i].g, colors[i].b);
    }
    return 0;
}

（4）ZOL1123. Triangle Encapsulation（0.5）

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1123

依次给出一个三角形按逆时针方向排列的三个顶点的坐标（所有坐标范围在 -9 ~ 9 之间），要求求平面上被这个三角形完全围在内部的所有整数坐标的点。而且这道题目对输出格式有特别要求，不好描述，就是输出的点排列的就像他们在笛卡尔座标中的位置那样。

解法：首先这道题目求解一个点是否在三角形，可以用常规的点在多边形内的射线法。但还可以用线段旋转方向（即叉积）来判断，如果点P在三角形ABC内部，则AB，BC，CA旋转到P的时针方向必然全都相同。如果在外部，则必定不满足这个条件。而且此题还明确说明，三个点ABC是逆时针排列的，所以三条边从逆时针转过去，转到P点如果都是“右转”，则说明点P在三角形内。如果P在三角形的边上，叉积为0。因此只要遍历三角形的外接矩形内的所有整数坐标点，依次判断即可。最后为了按题目要求的格式进行输出，采用一个辅助队列缓存所有解，最后得到了最左侧的点的位置以后，所有解的打印位置也就确定了。

#include <stdio.h>

#ifndef __min
#define __min(a, b) ((a)<(b)? (a):(b))
#endif

#ifndef __max
#define __max(a, b) ((a)>(b)? (a):(b))
#endif

//
typedef struct _tagPOINT
{
    char x;
    char y;
} POINT;

POINT pts[90];

int pts_top; //Queue 指针

// (Pi->Pk) * (Pi->Pj) 从 PI-PK 转向 PI-PJ 的方向
// > 0: 左转
// < 0: 右转
// = 0: 共线
int Direction(int xi, int yi,
              int xj, int yj,
              int xk, int yk)
{
    return (xk-xi)*(yj-yi) - (xj-xi)*(yk-yi);
}

int main(int argc, char* argv[])
{
    //三角形的三个顶点（逆时针方向）
    int x0, y0, x1, y1, x2, y2, x, y;
    int left, top, right, bottom;
    int min_x, i, j, cur_y;

    printf("Program 4 by team X\n");

    while(scanf("%d %d %d %d %d %d",
        &x0, &y0, &x1, &y1, &x2, &y2) != EOF)
    {
        //初始化case
        pts_top = -1;
        min_x  = 10;

        left = __min(__min(x0, x1), x2);
        top = __max(__max(y0, y1), y2);
        right = __max(__max(x0, x1), x2);
        bottom = __min(__min(y0, y1), y2);

        //在矩形整数阵列中搜寻三角形内部的点
         for(y = top; y >= bottom; y--)
        {
            for(x = left; x <= right; x++)
            {
                if( Direction(x0, y0, x1, y1, x, y) <= 0) continue;
                if( Direction(x1, y1, x2, y2, x, y) <= 0) continue;
                if( Direction(x2, y2, x0, y0, x, y) <= 0) continue;

                //这是一个内部的点
                   ++pts_top;
                pts[pts_top].x = x;
                pts[pts_top].y = y;

                //更新最左的点
                  if(x < min_x) min_x = x;
            }
        }

        //打印输出结果！
         cur_y = -10; //当前y坐标
         for(i = 0; i <= pts_top; i++)
        {
            //换行了?
            if(pts[i].y != cur_y) 
            {
                cur_y = pts[i].y;

                //不是第一行，则换行！
                  if(i > 0) printf("\n");

                //本行前面的前导打印多少个空格？
                  for(j = 0; j < ( pts[i].x - min_x ) * 9; j++)
                    printf(" ");
            }
            else
            {
                //没有换行，则在两个点之间打印一个空格
                   if(i > 0) printf(" ");
            }
            printf("(%2d, %2d)", pts[i].x, pts[i].y);
        }

        //case结束后还需要输出一个空行！
         printf("\n\n");
    }
    printf("End of program 4 by team X\n");
    return 0;
}

（5）ZOL1244. Definite Values (0.2)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1244

最开始只有变量 a 有确定值，执行一系列赋值语句后，要求按字典顺序，输出所有有确定值的变量。如果任何变量都没有确定值，输出 none 。但这个题题目里没有明确的说清楚，就是所有变量名都是单字母，有了这个假设这个题目其实非常简单。但如果我们不考虑这一点，而是变量名任意，那显然还要建立符号表，又要变得更麻烦。

#include <stdio.h>

char variables[26];

int main(int argc, char* argv[])
{
    char line[32];
    int n, i, nCase = 0, charCount;
    while(1)
    {
        scanf("%d", &n);
        if(n == 0) break;

        getchar(); /* 取走回车符号 */
        ++nCase;

        /* Init: a is definite. */
        variables[0] = 1; 
        for(i = 1; i < 26; i++)
            variables[i] = 0;

        for(i = 0; i < n; i++)
        {
            gets(line);
            variables[line[0]-'a'] = variables[line[4]-'a'];
        }

        printf("Program #%d\n", nCase);
        charCount = 0;
        for(i = 0; i < 26; i++)
        {
            if(variables[i] > 0)
            {
                line[charCount] = 'a' + i;
                charCount++;
            }
        }
        if(charCount > 0)
        {
            for(i = 0; i < charCount; i++)
            {
                printf("%c ", line[i]);
            }
            printf("\n\n");
        }
        else printf("none\n\n");
    }
    return 0;
}

（6）ZOL1858. Soundex (0.2)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1858

把单词按照发音归类，给出一个单词的拼写，按照规则求出这个单词的一个发音归类代码。

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

void GetSoundexCode(char* buf, const char* word)
{
    int i;
    char last_code = -1, cur_code;;
    char* strs[6] = { "BFPV", "CGJKQSXZ", "DT", "L", "MN", "R" };
    char* pDest = buf;
    const char* pSrc = word;
    while(*pSrc)
    {
        cur_code = -1;
        for(i = 0; i < 6; i++)
        {
            if(strchr(strs[i], *pSrc) != NULL)
            {
                cur_code = '1' + i;
                break;
            }
        }
        if(last_code != cur_code && cur_code > 0)
        {
            *pDest = cur_code;
            ++pDest;    
        }
        last_code = cur_code;
        ++pSrc;
    }
    //null-terminator!
    *pDest = 0;
}

int main(int argc, char* argv[])
{
    char line[24], code[24];
    while(gets(line) != NULL)
    {
        GetSoundexCode(code, line);
        printf("%s\n", code);
    }
    return 0;
}

备注：题目后面括号内的数字为我的主观认定难度值。

本文链接

[发布] QQGame 连连看辅助工具（限制功能版）

2011-11-18T11:12:00Z

前几天想起了这个想法，然后最近两天开发了这个工具，就是用于 QQGame 中的连连看的辅助工具。本来是想把全部代码都公开的，但是我在调试程序的时候注意到腾讯在qqgame中宣传卖那些游戏道具。所以我的想法就改变了下，不想影响腾讯卖这些道具来赚钱，所以我把原来完整功能版的版本又加上了一些限制。

辅助工具实现的功能包括：全自动点击，自动重排（当方块无解时），显示可点击方块提示（相当于官方的指南针功能），模拟单步点击。

首先进入 QQGame，连连看，开始游戏后如下图所示：

启动工具后的界面如下图所示，点击任务栏按钮即可。具体用法参考任务栏的tooltip和压缩包中的简要说明。

最后我为这个版本加了以下限制，使他不至于惹上“影响别人赚钱”的嫌疑（虽然我一向非常鄙视腾讯）。主要限制如下：

（1）自动点击的速度限制在 1 秒一次点击，但可以暂时体验 500 ms 速度。更快的点击速度全部被禁用！
　　　　（2）提示数量超过16个（相当于道具中的指南针）时，每次需要输入验证码才能继续。
　　　　（3）快速连击“消掉一对方块”的次数如果超过10次，则需要输入验证码才能继续。此处快速连击是指两次点击时间间隔小于 1 秒。

作为兴趣，验证码对话框是我今天加上去的，显然这个手段也是我和腾讯学习来的，如下图所示：

这个对话框比较简单，我用代码动态生成一个图片显示在上面，当然题目也是动态生成的，题目主要是 100 以内的加减乘除法。图片中我放了随机的贝塞尔彩色线条作为干扰。问题里面的每个字符采用了位置和角度的轻微抖动，但是没有经过变形，因为我是用 GDI 函数绘制的文本。

下面介绍下这个辅助工具的一些内容，首先我寻找到游戏中的窗口后，需要确定的棋盘网格的内容，最早我的想法是用4到5个关键点采样来检测方块。但是后来我实际开发时发现，比较幸运的是，能选取特定的方块坐标，可以仅仅用一个采样点就能区分出所有方块。满足这样高区分度条件的采样点一共有四个，被我用代码寻找了出来。检测方块时，相比之前的“快速美女找茬”工具，这次我用了效率更高些的直接对位图数据块寻址来检测。当然，这要求对位图中的像素定位（即在内存数据块中定位到某个位置的某个通道）需要非常熟悉，我在自己的博客中介绍过多次，这里就不重复了。

确定了棋盘网格的内容后，就是这个工具的核心，即寻解的方法。从这点上来说，其实程序的寻解和人的寻解本质上并没有什么不同，只不过两者的侧重点稍有区别。在程序中，在确定棋盘网格的过程中，我就建立了对每一种方块都建立了一个双向链表（采用双向链表的原因是因为随着寻解的过程，需要频繁的进行节点脱链操作），去存储他们的坐标。这样的目的是不需要反复的盲目扫描棋盘，而是把精力集中到判断两个方块是否有通路就可以了。游戏中的方块多达 40 多种，所以我用一个指针数组来存储所有链表的 Head。取决于游戏的设计，链表数量较多，但长度较短（例如为 4 ）。所以尽管寻解算法的时间复杂度相对与链表长度为 O(n^2)，但整个求解过程依然是感觉很快，后台运算的线程感觉是瞬间就退出的，以至于我觉得哪怕是用户需要的时候再算时间都来得及，根本不需要另起一个线程来求解了。当完全不使用定时器延时时，令我感到吃惊的是，仿佛是就点了一下，然后所有方块就全部消失的无影无踪了，这根本违背了我们平时观看到的场景印象。由于方块消失的太快，整个游戏窗口都弥漫在一团烟雾效果中。

下面我给出的是连连看的“通路”判断方法，这是所有连连看的共同游戏规则。不管是什么连连看游戏，你都能在代码中看到这个函数，只不过可能形式有多种多样而已。由于分别在两个方向上检测，所以两部分的代码惊人的一致，这也可能让我这样有完美主义倾向的人感觉不爽，想把两部分代码合并成一个循环（我们把网格指针的偏移作为变量，分别存放到一个含有两个元素的数组中即可，例如如果我们要在水平方向上移动，偏移量是+-1，在垂直方向上移动，偏移量是+-行宽度），这当然是可以的，但我想可能会牺牲掉一部分代码可读性。下面的代码非常简洁，它的主题是来自我以前发表在 BCCN上的 TC2.0版的连连看（DOS贴图版）中的代码：

//连连看游戏的核心算法
BOOL CanConnect(char map[11][19], int row1, int col1, int row2, int col2)
{
    int path, i, j, left, right, top, bottom;
    int min1, min2, max1, max2;
    //-----------------查找水平方向----------------------------
    min1 = max1 = col1;
    min2 = max2 = col2;
    while(min1 - 1 >= 0 && map[row1][min1 - 1] == 0) min1--;
    while(min2 - 1 >= 0 && map[row2][min2 - 1] == 0) min2--;
    left = __max(min1, min2);

    while(max1 + 1 < 19 && map[row1][max1 + 1] == 0) max1++;
    while(max2 + 1 < 19 && map[row2][max2 + 1] == 0) max2++;
    right = __min(max1, max2);

    //检查两条水平线之间是否有可连通的垂直线
     for(i = left; i <= right; i++)
    {
        path = 0;
        for(j = __min(row1, row2) + 1; j < __max(row1, row2); j++)
        {
            path += map[j][i];
            if(path > 0) break;
        }
        if(path == 0)
            return TRUE;
    }

    //-----------------查找垂直方向----------------------------
    min1 = max1 = row1;
    min2 = max2 = row2;
    while(min1 - 1 >= 0 && map[min1 - 1][col1] == 0) min1--;
    while(min2 - 1 >= 0 && map[min2 - 1][col2] == 0) min2--;
    top = __max(min1, min2);
    
    while(max1 + 1 < 11 && map[max1 + 1][col1] == 0) max1++;
    while(max2 + 1 < 11 && map[max2 + 1][col2] == 0) max2++;
    bottom = __min(max1, max2);

    //检查两条垂直线之间是否有可连通的水平线
     for(j = top; j <= bottom; j++)
    {
        path = 0;
        for(i = __min(col1, col2) + 1; i < __max(col1, col2); i++)
        {
            path += map[j][i];
            if(path > 0) break;
        }
        if(path == 0)
            return TRUE;
    }
    return FALSE;
}

下面是后台线程的代码，调用了上面的方法，过程类似绘制“金刚石”图形（所有顶点彼此连线），和冒泡排序一类的时间复杂度相同。

//用于寻找可点击方块的后台线程，进入线程时，map 已经初始化好了
DWORD WINAPI MyThread(LPVOID lpParameter)
{
    PMYTHREAD_PARAMS pMyParams = (PMYTHREAD_PARAMS)lpParameter;
    int i;
    HWND hwnd = pMyParams->hWndUI;
    PCELLPOS pNode1, pNode2;
    BOOL bAllListIsNull;
    BOOL bFind_One_Solution; //是否找到了一个解
     while( !bThreadStopSignal )
    {
        bAllListIsNull = TRUE;
        bFind_One_Solution = FALSE;

        //此处暴力的盲目搜索就是了~。~ 有时间的话需要让此处更“智能化”！
         //pCellPos[0]就是代表空白位置的链表，永远为 NULL （浪费掉了）
         for(i = 1; i < CELL_TYPE_COUNT; i++)
        {
            //在链表中搜索是否可点击类似金刚石画法，时间复杂度：O(n^2)
            if(pCellPos[i] != NULL)
            {
                bAllListIsNull = FALSE; //存在链表不为空
                   pNode1 = pCellPos[i];
                while(pNode1 != NULL)
                {
                    pNode2 = pNode1->pNext;
                    while(pNode2 != NULL)
                    {
                        if(CanConnect(map, pNode1->row, pNode1->col, pNode2->row, pNode2->col))
                        {
                            //找到了一对可点击方块
                                 map[pNode1->row][pNode1->col] = 0;
                            map[pNode2->row][pNode2->col] = 0;
                            
                            CLICKINFO cInfo;
                            cInfo.row1 = pNode1->row;
                            cInfo.col1 = pNode1->col;
                            cInfo.row2 = pNode2->row;
                            cInfo.col2 = pNode2->col;
                            SendMessage(hwnd, WM_CLICKINFO_FIND, (WPARAM)pMyParams->bIsAutoClick, (LPARAM)(&cInfo));
                            
                            RemoveNodeFromList(&pCellPos[i], pNode1);
                            RemoveNodeFromList(&pCellPos[i], pNode2);

                            bFind_One_Solution = TRUE;                        
                            break;
                        }

                        //由于两个Node都已经被释放了，所以必须立即结束对当前链表中的搜索。
                            if(bFind_One_Solution)
                            break;

                        pNode2 = pNode2->pNext;
                    }

                    if(bFind_One_Solution)
                        break;
                    pNode1 = pNode1->pNext;
                }
            }
        }

        //已经没有方块了？
         if(bAllListIsNull)
        {
            //发送消息，所有解已经搜索完毕，游戏可以胜利清空所有方块
              PostMessage(hwnd, WM_SOLUTION_COMPLETE, 0, 0);
            break;
        }
        //对所有链表都搜索完毕了，但找不到解，需要重排！
         else if(!bFind_One_Solution)
        {
            PostMessage(hwnd, WM_NEED_RERANGE, 0, 0);
            break;
        }
    }
    bThreadRunning = FALSE;
    return 0;
}

最后这里的双向链表，还有队列等辅助数据结构当然都可以选用STL中的模板，而我没有用STL，此处全部是自写的。这样的好处可能就是非常直观吧，所有代码都在自己的眼皮底下，比较放心罢了。这里给出几个双向链表操作函数，实际上非常简单非常简短。

//释放某一个链表，最后把表头置为NULL
void FreeList(PCELLPOS* ppHead)
{
    PCELLPOS pTmp = NULL;
    PCELLPOS pNode = *ppHead;
    while(pNode != NULL)
    {
        pTmp = pNode->pNext;
        free(pNode);
        pNode = pTmp;
    }
    (*ppHead) = NULL;
}

//把一个新节点挂接到指定链表上，如果链表为空，则会被创建！
void AddNodeToList(PCELLPOS* ppHead, int row, int col)
{
    PCELLPOS pNewNode = (PCELLPOS)malloc(sizeof(CELLPOS));
    pNewNode->row = row;
    pNewNode->col = col;
    pNewNode->pForward = NULL;
    pNewNode->pNext = NULL;

    if(*ppHead == NULL)
    {
        *ppHead = pNewNode;
        return;
    }
    else
    {
        //找到tail节点，然后挂接上去！
         PCELLPOS pCur = *ppHead;
        while(pCur->pNext != NULL)
            pCur = pCur->pNext;

        pNewNode->pForward = pCur;
        pCur->pNext = pNewNode;
    }
}

//从链表中把指定的节点除去，如果是最后一个节点，则会导致该链表被置为 NULL
void RemoveNodeFromList(PCELLPOS* ppHead, PCELLPOS pNode)
{
    //是表头吗
    if(pNode == *ppHead)
    {
        *ppHead = pNode->pNext;
    }

    // [Forward] <--> [X] <--> [Next]
    // [Forward] <-----------> [Next]

    if(pNode->pForward != NULL)
        pNode->pForward->pNext = pNode->pNext;
    
    if(pNode->pNext != NULL)
        pNode->pNext->pForward = pNode->pForward;

    free(pNode);
}

其中，提示可点击方块时，没有直接用窗口 DC 或者屏幕 DC，我用的是 SetWindowRgn 方法（如果用 LayeredWindow 的 COLOR_KEY 会有闪烁，所以改为用 Window RGN）。

最后，暂时发布工具的可执行文件，该工具是采用VS2005 + WIN32 Platform SDK开发，完全绿色的。但它在关闭的时候会在自身所在文件夹下面防止一个 INI 配置文件，实际上我在程序里已经写好了所有默认值，但把 INI 文件放在程序所在位置，也是为了让用户知道那些地方可以配置。但有一项我写死在代码里面了，就是方块样本集合位图的行容量固定为 8，这样的目的是我可以对除法和取余（MOD）用位操作来实现。

下载链接：http://files.cnblogs.com/hoodlum1980/LLKHelper.rar

相同性质文章：《快速“美女找茬”（辅助工具）》

【补充说明】 by hoodlum1980 @ 2011-11-20

我发现有些人在肆无忌惮的使用“秒杀”级别的疑似外挂。所以也促使我进行改进。主要是加了系统全局性热键，程序自身的快捷键（因为按键的反应速度要比鼠标点击快），在比拼秒杀速度的时候取消开启线程，而是合并到 UI 线程一次性完成。改进搜索解的循环方式，从每次复位改为轮转式。最终我发现实际上成了反应速度的比拼。假使秒杀耗时是 0.1 秒（具体到底多少可能也无法精确测量），那么如果谁反应速度稍微快 0.1 秒，先行启动，就会赢。所以同为秒杀速度，由于秒杀耗时极短，远小于人能观察出的时间间隔，所以在算法上可能已经很难拼出优势来了。比如从其他方向下手进行改进。当然我也考虑了自动对别人应用各种障碍型道具，但是如果起跑反应慢一点的话，实际上一切都没用，因为你根本不会有应用道具的时间，游戏已经被对方结束了。反正已经够快了，估计暂时就这样了~。~

本文链接

ZOL3505 ( Yet Another Set of Numbers ) 解题报告

2011-11-09T19:16:00Z

ZOL 3505：Yet Another Set of Numbers

　　　　地址：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3505

　　　　题意：有一个数字集合，集合中的数遵循以下规则：

　　　　( 1 ). 每个数字的最高位不是 0 ;

　　　　( 2 ). 每个数字包含最多 N 位，且只有 0，1，2，3 这四个数字可能出现（0 < N < 20）;

　　　　( 3 ). 每个数字的相邻位不同（例如：301是有效的，300不是）;

　　　　( 4 ). 数字比较大小和他们的字符串比较方法相同（例如：1 < 123 < 20 < 21 < 3）.

　　　　问题是，给出这个集合中的一个数字 B，从数字 B 开始，在这个集合中向前数数到第 K 个数字时输出这个数字（K > 0）;

　　　　原文叙述：求满足以下条件的数字A：在集合中恰好有 ( K - 1 ) 个数字大于 A 小于 B （题目保证存在解）;

　　　　时空限制：Time Limit: 2 Seconds; Memory Limit: 65,536 KB;

　　　　例如：当 N = 2 时，这个集合中一共有 12 个数字，依次是：

　　　　1 < 10 < 12 < [ 13 ] < 2 < 20 < 21 < 23 < [ 3 ] < 30 < 31 < 32; ----（序列中A和B用方括号标示）

　　　　当 B = 3 时，K = 5 时，从集合中的 3 向前数到第 5 个数字时是 13，因此应该输出 13。

　　　　（1）第一个解法，模拟法（Result：TLE）

　　　　我想到的第一个解法是，观察这个序列的规律，然后用模拟数数的方法，依次向前数，数到第 K 个为止即可。

　　　　考虑集合中最大的一个数字的字符串表示，显然是以下形式 "3232..."（长度为 N）。

　　　　因此可以给出下面的模拟数数的第一个解，模拟法代码如下： ( X. 以下代码算法时间超出题目限制 )

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

int length; /*当前数字的字符串长度*/
char Num[24];

/*检测当前数字是否合法*/
int IsNumValid()
{
    int i;
    
    // 第一位不能为0
    if(Num[0] == '0')
        return 0;

    //相邻位不能相同
     for(i = 0; i < (length - 1); i++)
    {
        if(Num[i] == Num[i+1])
            return 0;
    }
    return 1;
}


void GetNextNum(int N)
{
    char _MaxChars[4] = "32";
    int i;
    do
    {
        /* 如果最后一个字符是0，则去掉结尾的0 */
        if(Num[length - 1] == '0')
        {
            Num[length - 1] = 0;
            length--;
            continue;
        }

        //ELSE: 当前字符递减后，立即扩展到 N 的长度
         Num[length - 1] = Num[length - 1] - 1;
        for(i = length; i < N; i++)
        {
            Num[i] = _MaxChars[ (i - length) & 1 ];    
        }
        length = N;
    }
    while( !IsNumValid() );
}


int main(int argc, char* argv[])
{
    int N = 0; /*字符串最大长度, 0 < N < 20 */
    int K = 0; /*往下数第K个数字*/    
    int index; /*往下数多少个*/
    while(scanf("%d %d", &N, &K) != EOF)
    {
        scanf("%s", Num);        
        length = strlen(Num);        
        for(index = 0; index < K; index++)
        {
            GetNextNum(N);
        }
        printf("%s\n", Num);
    }
    return 0;
}

　　　　但第一个方法提交后超时。显然，如果 N 比较大，这个集合中的数字数量是非常大的，因此这时 K 也可以取得很大。而这个方法是一个笨方法，是一个一个数字向前找，且还要进行数字合法校验，时间效率很低。当 N 和 K 都比较大时，这个方法在速度上显然不能满足要求。因此不能使用笨方法，必须找出这个序列中蕴藏的内在规律。

　　　　（2）速度更快的解法：使用三叉树模型（Result：MLE）

　　　　观察这个序列的规律，考虑数字用字符串进行比较的特点，比较时，越高（靠左）的位越重要，越低的位则不重要。因此考虑把每一位看作一个节点，则低位属于高位的子节点，父子节点彼此属于相邻的位，显然有每个节点含有三个子节点（由于每一位上只能在 0，1，2，3 中选择，且不能与父节点数字相同），因此形成一个满的三叉树。

　　　　每个节点代表了序列中的一个数字，把从根节点到该节点的路径所经过的节点依次输出，就是这个数字的字符串表示。当 N = 2 时，该树如下图所示：

题意中的规则（2）规定了树的高度，规则（1）和（3）使该树从完全四叉树变成完全三叉树，规则（1）去掉了“0” 子树，规则（3）缩减了子节点个数。

考虑两个树节点 N1 和 N2 之间的排序关系（比较时，深度小的节点比深度大的节点重要），注意和字符串比较算法进行对比：

（a）如果 N1 节点位于 N2 的路径上，则路径短的节点小；( eg. 123 < 1230 )

　　　　（b）如果 N1 和 N2 在节点 N' 处开始分离（从根节点到 N’ 处路径重合），则进入 N' 左侧子树的小于进入 N' 右侧子树的。( eg. 121230 < 123 )

　　　　（c）从前两点可知，此树前序遍历（先遍历当前节点的所有子节点，然后访问当前节点），即为数集合的有序排列。（对比：二叉查找树的中序遍历为有序序列）

图中节点圆圈中的黑色数字就是用于组成输出数字的位（num）。为了统计树中每个子树所代表的子序列中的数字个数，我们在每个节点上加一个属性 sum，表示以该节点为根的子树所表征的数字组成的子序列的数字个数，在图中用节点旁边的红色数字表示。显然，节点的 sum，就是以该节点为根的子树所包含的所有节点的数目，因为每个节点都一对一的代表集合中一个数字，用节点路径表示（类似贪心算法中的霍夫曼编码和霍夫曼树的关系）。由于输出节点路径时，根节点无需输出 ( dummy node )，因此根节点用阴影填充，和子节点的连线用虚线表示。

显然，最底层的所有叶子节点（深度为 N + 1）仅代表一个数字，其 sum = 1，对非叶子节点，其三个子节点的 sum 值相同，再加上自身节点代表的数字，因此有：

Node.sum = Node.Child[0].sum * 3 + 1 ;

　　　　因此对于本题目来说，可以创建这样一个三叉树，对于给定的数字 B，设它对应的是树中的节点 B，从 B 节点开始，向前回退寻找目标节点 A。

　　　　为了清楚的描述算法，我用节点游标的形式来阐述该算法（在代码中可以是一个节点的指针，表示当前所处的位置），并做如下定义：

(a). K 的逻辑含义是，代表当前节点和目标节点 A 的“距离”。寻找过程中 K 的值将不断减小，直到为 K = 0 ，表示到达目标节点A。

　　　　(b). 游标指向的改变称为 “移动到” 某个节点。

　　　　(c). 如果节点需要处理（即调整 K 值），称为“访问” ( visit ) 该节点。

　　　　(d). 如果节点不需要处理（即不需要调整 K 值），称为“经过” ( pass ) 该节点。

　　　　则算法（2）的基本步骤（GetNodeBySteps ）如下：

　　　　(2.1). 令游标指向起始节点 B; （这是准备工作，接下来将“向前”寻找节点 A）

　　　　(2.2). 如果所在节点已经是兄弟节点中的老大（位于最左侧），则（向上）“访问”其父节点，令 K = K - 1; 跳到（2.6）; （请思考为什么此处 K 的递减值是 1 而不是 Node.sum？）

　　　　(2.3). 如果所在节点有哥哥节点，则（向左）移动到它的哥哥节点; （接下来在（2.4）和（2.5）中一定能找到一个可访问节点，请思考这是为什么？）

　　　　(2.4). 如果 Node.sum <= K ，则“访问”该节点，令 K = K - Node.sum，跳到（2.6）; （备注：Node.sum < K 时说明 A 不位于该节点为根的子树中）

　　　　(2.5). 如果 Node.sum > K，（备注：说明 A 位于 Node 为根的子树中）则连续的（向下）移动到当前节点的（最右侧）最幼子节点，直到找到符合（2.4）中的条件（Node.Sum <= k）的节点为止，然后用和（2.3）的相同方法“访问”它：令 K = K - Node.sum; （这是一个嵌在内部的 while 循环）

　　　　(2.6). 如果 K != 0，则重复（2.2）~ （2.5）。直到 K = 0 为止，此时我们到达的节点就是目标节点 A，输出节点 A 的路径就是问题的解;（这是最外层的 while 循环）

总结上面的探查方法：如果一个节点是被访问节点，则绝不会再进入它的任何子树；当寻找下一个可访问节点时，如果左侧有哥哥节点，则一定先探查哥哥节点（如果哥哥节点没有超越目标，则访问它；否则进入它的幼子子树继续探查），否则访问父节点（此时父节点必是可访问节点）。

上面的语言接近伪码，括号内的描述属于导航时的逻辑方向或备注性说明。显然（2.2）~（2.6）整体是一个 while 循环，其中（2.5）是嵌在其内的又一个 while 循环。上诉步骤即对应的是代码中的 GetNodeBySteps 方法，参数 step 即 K。

【思考】：为何（2.2）向父节点回退时的访问和（2.4）和（2.5）中的访问方法不同，前者令 K 递减 1，后者令 K 递减 Node.sum。

　　　　（提示：前者，当子节点向父节点“回退”时，子节点为根的子树位于其父节点所代表的子树中。后者则进入到了另一个独立的子树。）

　　　　第二个解法的代码（三叉树方法），如下所示： ( X. 以下代码内存使用超出题目限制 )

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

typedef struct _NODE
{
    char index;  /* 在兄弟节点中的排行索引 */
    char num;    /* 节点数字, 只能取下列值 0,1,2,3，为 'R' 时表示 root */
    
    int sum;     /* 1 + 3 + 9 + ... + 3^k */

    _NODE* parent;   /* 父节点 */
    _NODE* child[3]; /* 子节点 */
} NODE, *PNODE;

/* 递归函数： N - 树的深度（不含根节点的深度） */
void AddChildren(PNODE pNode)
{
    int i, _num = 0;;
    PNODE pChild = NULL;
    pNode->sum = pNode->sum * 3 + 1;

    if(pNode->child[0] == NULL)
    {
        for(i = 0; i < 3; i++)
        {
            pChild = (PNODE)malloc(sizeof(NODE));
            memset(pChild, 0, sizeof(NODE));
            pChild->parent = pNode;
            pChild->index = i;
            pChild->sum = 1;
            
            /* 回避父节点数字 */
            if(pNode->num == _num) _num++;
            pChild->num = _num++;

            pNode->child[i] = pChild;
        }
    }
    else
    {
        for(i = 0; i < 3; i++)
            AddChildren(pNode->child[i]);
    }
}

PNODE CreateTree(int depth)
{
    int i;
    PNODE pRoot = (PNODE)malloc(sizeof(NODE));
    memset(pRoot, 0, sizeof(NODE));
    pRoot->num = 0; /*根节点数字为0，可以让第一层子节点为1，2，3 */
    pRoot->sum = 1;
    for(i = 0; i < depth; i++)
    {
        AddChildren(pRoot);
    }
    pRoot->num = 'R';
    return pRoot;
}

/* 释放树占用的内存（递归函数） */
void FreeTree(PNODE pNode)
{
    int i;
    for(i = 0; i < 3; i++)
    {
        if(pNode->child[i] != NULL)
        {
            FreeTree(pNode->child[i]);
        }
    }
    free(pNode);
}

/* 从节点 pStart 向前追溯到某个节点 */
PNODE GetNodeBySteps(PNODE pRoot, PNODE pStart, int step)
{
    int remainStep = step;
    int index;
    PNODE pCurNode = pStart, pNextNode = NULL;

    while(remainStep > 0)
    {
        /*找到下一个不大于 remainStep 距离的节点*/
        index = pCurNode->index;
        if(index == 0)
        {
            /* 向上返回一层时，只-1 */
            pCurNode = pCurNode->parent;
            remainStep--;
            continue;
        }
        pNextNode = pCurNode->parent->child[ index - 1];
        while(pNextNode->sum > remainStep)
        {
            /* 向下进入最右侧的最小子节点分支 */
            pNextNode = pNextNode->child[2];
        }
        pCurNode = pNextNode;
        remainStep -= pCurNode->sum;                
    }
    return pCurNode;
}

/* path: 字符串形式例如“12301” */
PNODE GetNodeByPath(PNODE pRoot, char* path)
{
    int i;
    char *p = path;
    PNODE pCur = pRoot;
    while(*p)
    {
        for(i = 0; i < 3; i++)
        {
            if(pCur->child[i]->num == (*p - '0'))
            {
                pCur = pCur->child[i];
                break;
            }
        }
        ++p;
    }
    return pCur;
}

/* 借助辅助栈，输出找到的节点的路径（从根节点到该节点）*/
void OutputNodePath(PNODE pNode)
{
    char stack[24];
    int top = 0;
    PNODE pCur = pNode;
    while(pCur->parent != NULL)
    {
        stack[top++] = pCur->num;
        pCur = pCur->parent;
    }
    while(top > 0)
    {
        printf("%d", stack[ top - 1 ]);
        --top;
    }
    printf("\n");
}

int main(int argc, char* argv[])
{
    int depth, step;
    char path[24];
    PNODE pRoot, pStart, pDest;
    while(scanf("%d %d\n", &depth, &step) != EOF)
    {
        gets(path);
        pRoot = CreateTree(depth);
        pStart = GetNodeByPath(pRoot, path);
        pDest = GetNodeBySteps(pRoot, pStart, step);
        OutputNodePath(pDest);
        FreeTree(pRoot);
    }
    return 0;
}

　　　　【分析】为什么算法（2）比算法（1）快？

　　　　算法（1）永远是一个一个数字向前数，步进值（step）永远为 1 ; 当初我想改进算法（1）时发现，如果不借助数据结构，很难在原基础上进行改进。集合中的数也很难用数学公式计算或总结（这也是采用模拟法的原因）。

　　　　算法（2）是在树中导航，注意树节点越往上（深度越小），节点的 sum 值越大（而且是随着深度减小，以极快的指数速度增长），所以算法（2）的数数方式是跳跃式的，而且能用很快速度探索到一个理想的 Step 值（该 Step 足够大，又满足 Step <= K ，即向目标迈进的步子足够大，而又不会超越目标节点），该 Step 由树节点的 sum 值表示，然后直接越过该子树所代表的子集合，无需遍历该子集合（所有数字或树节点）。因此访问的节点在树中的深度越浅（越靠近树根），则以该节点为根的子树的规模就越大，代表着跨越的数字个数就越多。由于每个节点最多只有两个哥哥节点，在同一深度向前移动时所消耗的时间不多，因此算法能以很快的速度上升到跨度尽可能大的可访问节点。因此算法（2）在时间上比算法（1）高效的多。

　　　　算法（2）的另一种形象理解是：

　　　　B > A，则水平方向 B 位于 A 子树的下方或 A 的右侧子树。则存在一个深度最大（设深度为 d ）的公共子树 T ，满足 A, B ∈ T 。

　　　　现在从节点 B 出发，寻找节点 A。由于 A 比 B 小，因此 B 不可能是 T 的根。

　　　　(a). 如果 A 不是 T 的根，则必然 A 和 B 分别位于 T 的左右两个子树。因此从 B 所在的右侧子树上浮到（d+1）深度后，继续向前移动到 A 所在的左侧子树，然后靠右侧下沉到 A 。（搜寻路线类似梯形）

　　　　(b). 如果 A 是 T 的根，则靠左上浮到 A 。

　　　　上诉两种情况，在水平方向上在各个深度上都可能呈现一些向左的水平步进。因此在 向前向上探寻时，探寻路径呈“锯齿形”。向下探寻时则是“直线”式下降。对平均情况，探索路径的长度（时间）和树的高度 N 为线性关系。

Figure 1. 节点 B 到节点 A 的探寻路径；

　　　　如 Figure 1 所示。图中红色虚线箭头相连得到的路径，即为从 B 到 A 的探寻路径。图中 A 和 B 的最深公共子树 T 是数字“10”所在节点，同时 T 被用粗线表示。灰色节点为可访问节点，斜线表示的节点为位于搜索路线上，但是被经过（Pass）的节点。图中 N = K = 4；从 A 到 B 的序列是：{ 1021, 1023, 103, 1030, 1031 } ;

　　　　【缺陷】但算法（2）的结果是内存超出限制（MLE）。理由实际上同（1），当 N 很大时，树非常庞大。由于它是一个满三叉树，所以节点数量是一个等比数列的和：

　　　　Sum = ∑ ( 3 ^ i ) = 1 + 3 + 9 + 27 + ... + 3^N = ( 3 ^ ( N + 1) - 1 ) / 2 ;

　　　　　　　　----( 高度为 N + 1 的三叉树的所有节点数量 ) ;

　　　　从上式粗略估算可知内存需求极大，产生 MLE 也就不足为奇了，考虑极限情况：

　　　　假设 N = 19，则此树共含有 1,743,392,200 个节点。设每个节点占用 24 Bytes 则：在内存中建立该树需要：38.97 GB ！！！ @_@ ...

　　　　（1）和（2）的解法一个超时一个超内存限制，都是因为该集合的元素数量非常大导致的。既要利用（2）中的三叉树模型的时间效率，但又不能采用在内存中完整建立树的方法，因此导出下面的第三个解法。

　　　　（3）正确解：虚拟树 / 树枝法（Result：AC）

　　　　为了时间效率，依然采用三叉树的模型，但是不能在内存中完整建树，因此启发我们，可以在内存中仅仅保留一条树枝，该树枝最长的长度（叶子在树中所处的深度）为 N。考察解法（2）中的方法，无非是在树之间进行导航，即从某个节点到其父节点，左侧的哥哥节点，右下方的幼子节点。同时，由于此树满足，相同深度的所有节点的 sum 值相同。因此我们可以仅用一条树枝即完成（2）中的算法。

　　　　方法是：在内存中不建立整个树，而是仅仅存储一个当前树枝。树枝长度可伸缩，最大为N。树枝采用一个线性表结构保存，可以使用数组或链表（为了代码简便我们使用数组）。每个节点依然含有两个属性： num 和 sum。如果说算法（2）中的树是内存中的实际树（物理树），则算法（3）中的树是仅存在于思维模型中的“虚拟树”。

　　　　一个树枝在树中的位置，以及它在数组中的存储状态如下图所示，图中树枝部分用实体粗线条表示，整个树由于不在内存中，因此用虚线表示：

　　　　为了实现算法，我们必须很容易的确定该树枝在完整的树模型中的位置和形态。即容易实现以下问题：

　　　　（3.1）求出某个节点在同辈兄弟中的排行索引（ Index_In_Siblings ），∈ { 0，1，2 } ;

　　　　（3.2）求出某个节点的哥哥节点（左侧）的 num （ Num_Of_Elder_Brother ），∈ { 0，1，2，3 } ;

　　　　（3.3）求出某个节点的幼子节点（右下）的 num （ Num_Of_Right_Child ），∈ { 0，1，2，3 } ;

　　　　其中（3.1）和（3.2）可以通过本节点的 num 和其父节点的 num 推断得出。（3.3）可以从本节点的 num 求出。

　　　　算法执行过程中，随着游标在树中的节点之间移动，树枝在树中的伸展形态（在树中的位置和树枝的长度）也同时发生变化，当寻找到目标节点 A 以后，树枝静止在最终状态，根据方法返回的树枝长度即可确定最终的树枝。目标节点 A 即为最终树枝的末端叶子节点。

　　　　因此解法（3）三叉树树枝法算法与（2）相同，但解决了空间复杂度的问题，代码如下： ( √. 以下代码是可接受的 )

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

typedef struct _NODE
{
    int num;    /* 节点数字, 取值 0,1,2,3 */
    int sum;    /* 1 + 3 + 9 + ... + 3^k */
} NODE, *PNODE;

NODE nodes[20]; //树枝

//初始化树枝各个节点的 sum 值
void InitSums(int N)
{
    int i;
    //叶子节点
     nodes[N-1].sum = 1;
    for(i = N - 2; i >=0 ; --i)
    {
        nodes[i].sum = nodes[i + 1].sum * 3 + 1;
    }
}

//初始化树枝各个节点的 num 值
//path: "1231"

int InitNodesByPath(char *path)
{
    int depth = 0;
    char *p = path;
    while(*p)
    {
        nodes[depth].num = (*p - '0');
        ++depth;
        ++p;
    }
    return depth - 1;
}

//输出指定深度节点的路径（从根节点到该节点）
void OutputNodePath(int depth)
{
    int i;
    for(i = 0; i <= depth; i++)
    {
        printf("%d", nodes[i].num);
    }
    printf("\n");
}

//获取节点在兄弟节点中的排行索引
int GetIndexInSibling(int depth)
{
    if(depth == 0) 
        return (nodes[depth].num - 1);
    else if(nodes[depth-1].num > nodes[depth].num)
    {
        return nodes[depth].num;
    }
    else
    {
        return nodes[depth].num - 1;
    }
}

//返回哥哥节点的数字
int GetBrother(int depth)
{
    int result = nodes[depth].num - 1;
    if(depth > 0 && nodes[depth-1].num == result)
    {
        --result;
    }
    return result;
}

//返回幼子的数字
int GetRightChild(int depth)
{
    int result = 3;
    if(nodes[depth].num == 3)
        result = 2;
    return result;
}

//从节点A开始向前追溯到节点B，返回对应深度
//nStart: 节点A的深度
//step：节点A和B之间的距离

int GetNodeBySteps(int nStart, int nStep)
{
    int remainStep = nStep;
    int depth = nStart;

    while(remainStep > 0)
    {
        //回退到父节点
        if(GetIndexInSibling(depth) == 0)
        {
            //向上返回一层时，只-1
            depth--;
            remainStep--;
            continue;
        }
        //进入哥哥节点
         nodes[depth].num = GetBrother(depth);
        while(nodes[depth].sum > remainStep)
        {
            //向下进入最右侧的最小子节点分支
              nodes[depth + 1].num = GetRightChild(depth);
            depth++;
        }
        remainStep -= nodes[depth].sum;
    }
    return depth;
}

int main(int argc, char* argv[])
{
    int N, K;
    char path[24];
    int nStart, nDest;
    
    while(scanf("%d %d\n", &N, &K) != EOF)
    {
        gets(path);
        InitSums(N);
        nStart = InitNodesByPath(path);
        nDest = GetNodeBySteps(nStart, K);
        OutputNodePath(nDest);
    }
    return 0;
}

　　　　以上代码提交后的结果是 AC。运行消耗是时间 120 ms，空间 180 KB。空间需求微不足道可以说是O（1），但用时是解排行榜单上的其他 C++ 优秀解法用时（40ms ~ 60ms）的两三倍。一可能是我用了很多很小的函数，没有inline，多少带来一些函数调用的开销，二是可能别人的算法要比我更快更好。

　　　　【分析】为什么可以使用树枝的方法？

　　　　此题目中，树的规模非常大，所以逼迫我们使用了树枝法，那么为什么可以不在内存中建立树呢，这是因为树自身具有的内在规律，即节点不是完全随机和独立的，而是存在下面的关系，假设树根深度为 1，树的高度（叶子节点的深度）为（N + 1），则深度为 d 的节点：Node.sum = ( 3 ^ (N + 2 - d ) - 1 ) / 2; 对于非叶子节点，有三个子节点，按升序排列并与父节点不重复。因为有了这些已知条件，使我们能推断出我们需要的节点的信息，因此不需要一个完整的树来存储它。

　　　　【说明】本文所有插图，使用 Microsoft Office Visio 绘制。

本文链接

ZOL 简单题集合（二）

2011-11-08T19:59:00Z

对以下简单题，我同时给出一个我主观认为的难度值（0.1~1.0之间）。

(1). ZOL1072: Microprocessor Simulation. (Difficulty: 0.2)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1072

微处理器模拟，它含有两个累加器，代码和内存统一寻址，即冯诺依曼结构，比较简单。

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

char mem[256];    /* 256 words 内存 */
char A;            /* A 累加器 */
char B;            /* B 累加器 */

int PC;            /*程序计数器，code取址用*/

void Run()
{
    int flag_STOP = 0;
    int code, addr;
    char tmp;
    PC = 0;

    do
    {
        /* reset PC */
        if(PC >= 0xF0)
            break;

        /* 取指令 */
        code = mem[PC];
        ++PC;

        switch(code)
        {
            /* LD: Load accumulator A with the contents of memory 
               at the specified argument.*/
        case 0: 
            addr = mem[PC] * 16 + mem[PC+1];
            PC += 2;
            A = mem[addr];
            break;

            /* ST: Write the contents of accumulator A to the memory
               location specified by the argument.*/
        case 1:
            addr = mem[PC] * 16 + mem[PC+1];
            PC += 2;
            mem[addr] = A;
            break;

            /* SWP: Swap the contents of accumulators A and B. */
        case 2:
            tmp = A;
            A = B;
            B = tmp;
            break;

            /* ADD: Add the contents of accumulators A and B. The 
               low word of the sum is stored in A, and the high 
               word in B. */
        case 3:
            tmp = A + B;
            A = (tmp & 0x0F);
            B = (tmp >> 4);
            break;

            /* INC: Increment accumulator A. Overflow is allowed; 
               that is, incrementing F yields 0. */
        case 4:
            if(A == 0x0F) A = 0;
            else A++;
            break;

            /* DEC: Decrement accumulator A. Underflow is allowed; 
               that is, decrementing 0 yields F.*/
        case 5:
            if(A == 0) A = 0x0F;
            else A--;
            break;

            /* BZ: If accumulator A is zero, the next command to be 
               executed is at the location specified by the argument. 
               If A is not zero, the argument is ignored and nothing 
               happens. */
        case 6:
            addr = mem[PC] * 16 + mem[PC+1];
            PC += 2;
            if(A == 0)
            {
                PC = addr;
            }
            break;

            /* BR: The next command to be executed is at the location 
               specified by the argument. */
        case 7:
            addr = mem[PC] * 16 + mem[PC+1];
            PC = addr;
            break;

            /* STP: Stop execution of the program. */
        case 8:
            flag_STOP = 1;
            break;
        }
    }
    while(!flag_STOP);
}

char CharToNum(char c)
{
    if(c >= '0' && c <= '9') return (c - '0');
    else return (c - 'A' + 10);
}

char NumToChar(char c)
{
    if(c >= 0 && c <= 9) return (c + '0');
    else return (c + 'A' - 10);
}

int main(int argc, char* argv[])
{
    char line[264];
    int i, j;

    do
    {
        /* 读取一次完整的输入 */
        i = 0;
        do
        {
            gets(line);
            for(j = 0; j < strlen(line); j++)
            {
                mem[i] = CharToNum(line[j]);
                i++;
            }
        }
        while(i < 256);

        /*结束输入的标志*/
        if(mem[0] == 8)
            break;

        Run();

        /* output */
        for(j = 0; j < 256; j++)
        {
            printf("%c", NumToChar(mem[j]));
        }
        printf("\n");
    }
    while(1);
    return 0;
}

(2). ZOL1414: Num Steps. (Difficulty: 0.2)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1414

一个网格如下图所示，给出一个坐标（x，y），要求输出其数字，如果没有数字则输出 "No Number”;

#include <stdio.h>
int main(int argc, char* argv[])
{
    int count, i;
    int x, y, num;
    scanf("%d", &count);
    for(i = 0; i < count; i++)
    {
        scanf("%d %d", &x, &y);
        if(x - y == 0 || x - y == 2)
        {
            num = ((x >> 1) << 2) + (x & 1) - (x - y);
            printf("%d\n", num);
        }
        else
            printf("No Number\n");
    }
    return 0;
}

(3). ZOL1170: String Matching. (0.3)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1170

求出两个字符串的相似值（一个化简后的分数）。

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

char szLine[512];

//得到两个字符串的相同字符个数
int SameLetterCount(const char* s1, const char* s2)
{
    int count = 0;
    const char *p1 = s1;
    const char *p2 = s2;
    while(*p1 && *p2)
    {
        if(*p1 == *p2) count++;
        ++p1;
        ++p2;
    }
    return count;
}

//此方法的时间复杂度应该是O(n ^ 2)
void GetAppx(const char* s1, const char* s2, int* pAppx, int* pTotalLen)
{
    int appx = 0, tmp_appx = 0, index;

    int len1 = strlen(s1);
    int len2 = strlen(s2);

    *pTotalLen = len1 + len2;

    if(strcmp(s1, s2) == 0)
    {
        *pAppx = *pTotalLen;
        return;
    }

    for(index = -(len2 - 1); index <= len1 - 1; ++index)
    {
        if(index <= 0)
            tmp_appx = SameLetterCount(s1, s2 - index);
        else
            tmp_appx = SameLetterCount(s2, s1 + index);

        if(tmp_appx > appx)
            appx = tmp_appx;
    }
    *pAppx = appx * 2;
}

// 辗转相除法，求最大公约数
int GetGcd(int a, int b)
{
    int tmp;
    while(b > 0)
    {
        tmp = a % b;
        a = b;
        b = tmp;
    }
    return a; 
}

int main(int argc, char* argv[])
{
    char* pBlank = NULL;
    int totalLen = 0, appx = 0, gcd = 0;
    while( 1 )
    {
        gets(szLine);
        if(strcmp(szLine, "-1") == 0)
            break;

        //在空格处截断字符串
         pBlank = strchr(szLine, ' ');
        *pBlank = 0; 

        GetAppx(szLine, pBlank + 1, &appx, &totalLen);

        if(appx == 0)
            printf("appx(%s,%s) = 0\n", szLine, pBlank + 1);
        else if(appx == totalLen)
            printf("appx(%s,%s) = 1\n", szLine, pBlank + 1);
        else
        {
            //化简分数
              gcd = GetGcd(totalLen, appx);
            totalLen /= gcd;
            appx /= gcd;

            printf("appx(%s,%s) = %d/%d\n", 
                szLine, pBlank + 1, appx, totalLen);
        }
    }
    return 0;
}

(4). ZOL1240: IBM Minus One (0.1)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1240

超级简单，把字符串中每个字符用其字母序后面的字符替换。

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

//把每个字母向后旋转一格，c = c + 1, Z->A
void Transfer(char* s)
{
    char* p = s;
    while(*p)
    {
        if(*p == 'Z') *p = 'A';
        else *p = *p + 1;
        ++p;
    }
}

int main(int argc, char* argv[])
{
    char line[56];
    int count = 0, i;

    scanf("%d\n", &count);
    for(i = 0; i < count; i++)
    {
        gets(line);
        Transfer(line);
        printf("String #%d\n%s\n\n", i+1, line);
    }
    return 0;
}

(5) ZOL1295: Reverse Text (0.1)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1295

反转字符串，即 CRT 中的 strrev。

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

void reverse(char* str)
{
   char tmp;
   int left = 0;
   int right = strlen(str) - 1;
   while(left < right)
   {
       tmp = str[left];
       str[left] = str[right];
       str[right] = tmp;
       ++left;
       --right;
   }
}

int main(int argc, char* argv[])
{
    char str[256];
    int n, i;
    scanf("%d\n", &n);
    for(i=0; i<n; i++)
    {
        gets(str);
        /*scanf("%s", str);*/
        reverse(str);
        printf("%s\n", str);
    }
    return 0;
}

(6). ZOL1383: Binary Numbers (0.2)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1383

输出一个数字二进制表示中 1 所在的位。（注意输出格式）

#include <stdio.h>

int main(int argc, char* argv[])
{
    int count = 0, i, num, iDigit;
    //是否需要在该位前输出一个空格
    int bNeedSpace;

    scanf("%d", &count);
    for(i = 0; i < count; i++)
    {
        scanf("%d", &num);
        iDigit = 0;
        bNeedSpace = 0;
        while(num != 0)
        {
            if(num & 1)
            {
                if(bNeedSpace) printf(" ");
                printf("%d", iDigit);
                bNeedSpace = 1;
            }
            num = (num >> 1);
            ++iDigit;
        }
        if(i < count - 1)
            printf("\n");
    }
    return 0;
}

(7). ZOL1814: Candy Sharing Game (0.2)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1814

分糖果游戏，学生围成一圈，每次把手里的一半糖果分给右侧的人，如果任何人糖果为奇数，则再分给他一颗，直到所有人持有糖果数相同。模拟法。

#include <stdio.h>

//students: 每个学生持有的糖果数（逆时针方向）
//n: 学生个数
//rounds：游戏轮次
//candy：游戏结束时每个学生手里的糖果数
void Play(int* students, int n, int* rounds, int* candy)
{
    int i, students0, tmp_candy, left_candy;
    int bGameOver;
    *rounds = 0;
    while(1)
    {
        students0 = students[0];
        bGameOver = 1;
        for(i = 0; i < n; i++)
        {
            left_candy = (i == (n-1))? students0 : students[i+1];
            students[i] = (students[i] + left_candy)/2;
            //如果是奇数，立即再给他一个糖果
              if(students[i] & 1)
                students[i]++;
            
            if(i == 0)
                tmp_candy = students[0]; //初始化
              else if(bGameOver && students[i] != tmp_candy)
            {
                bGameOver = 0;
            }
        }
        (*rounds)++;
        if(bGameOver) break;
    }

    //最终结果
    *candy = students[0];
}

int main(int argc, char* argv[])
{
    int students[1024];
    int n, i;
    int rounds, candy;

    while(1)
    {
        scanf("%d", &n);
        if(n == 0) break;
        for(i=0; i<n; i++)
            scanf("%d", (students + i));

        Play(students, n, &rounds, &candy);
        printf("%d %d\n", rounds, candy);
    }
    return 0;
}

(8). ZOL2680: Clock (0.3)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=2680
给出 5 个时刻，按时钟的时针，分针夹角从小到大排序，输出中间的时刻。显然，整数分钟（不考虑秒）时刻，时针分针的夹角是 0.5 角度的整数倍，因此为回避浮点数，采用 0.5 度为指针夹角的基本单位（一个圆周为 360 度）。由于需要输出的只是排序后的中间元素，排序时只要排好一半即可。

#include <stdio.h>

typedef struct tagTime
{
    int angle; //夹角以0.5度为单位
     int hour;
    int minute;
} TIME;

typedef TIME Item;

Item items[5];

int lessthan(Item t1, Item t2)
{
    if     (t1.angle < t2.angle) return 1;
    else if(t1.angle > t2.angle) return 0;
    else if(t1.hour < t2.hour) return 1;
    else if(t1.hour > t2.hour) return 0;
    else if(t1.minute < t2.minute) return 1;
    else return 0;
}


/*交换a[]的i，j项*/
void exchange(Item a[], int i, int j)
{
    int _angle = a[i].angle;
    int _hour = a[i].hour;
    int _minute = a[i].minute;

    a[i].angle = a[j].angle;
    a[i].hour = a[j].hour;
    a[i].minute = a[j].minute;

    a[j].angle = _angle;
    a[j].hour = _hour;
    a[j].minute = _minute;
}


 /*选择排序*/
// stopIndex: 当排序到索引stopIndex，即可停止排序
void SelectionSort(Item a[], int left, int right, int stopIndex)
{
    int i, j, min;
    //for(i = left; i < right; i++) //完整排序
    for(i = left; i <= stopIndex; i++)
    {
        min = i;
        for(j = i + 1; j <= right; j++)
            if(lessthan(a[j], a[min])) min = j;
        exchange(a, i, min);
    }
}

//以 0.5度 为单位（eg. 180 units = 90 度，720 units = 360 度）
int GetAngle(int hour, int minute)
{
    int hour2 = (hour > 12) ? (hour - 12) : hour;
    int a1 = 60 * hour2 + minute;
    int a2 = minute * 12;
    int result = a2 - a1;
    if(result < 0)
        result = -result;
    if(result > 360)
        result = 720 - result;
    return result;
}

int main(int argc, char* argv[])
{
    int i, j, count;
    char line[48];
    scanf("%d\n", &count);
    for(i = 0; i < count; i++)
    {
        gets(line);
        for(j = 0; j < 5; j++)
        {
            items[j].hour = ( line[j*6] - '0' ) * 10
                + ( line[j*6+1] - '0' );
            items[j].minute = ( line[j*6 + 3] - '0' ) * 10
                + ( line[j*6+4] - '0' );
            items[j].angle = GetAngle(items[j].hour, items[j].minute);
        }
        SelectionSort(items, 0, 4, 2);
        printf("%02d:%02d\n", items[2].hour, items[2].minute);
    }
    return 0;
}

(9). ZOL3191: Strange Clock (0.2)
http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3191

给出时针的角度，输出该时刻处于几点钟。

#include <stdio.h>

int main(int argc, char* argv[])
{
    int hourBig, hourSmall;
    int bExactly; //注意 gcc 没有定义过 bool 类型
    int degree;

    while( 1 )
    {
        scanf("%d", &degree);
        if(degree == -1) break;

        bExactly = (degree - (degree / 30 * 30) == 0);
        hourBig = (degree < 120 ? 3 : 15) - (degree / 30);
        hourSmall = (hourBig == 0) ? 11 : (hourBig - 1);

        if(bExactly)
            printf("Exactly %d o'clock\n", hourBig);
        else
            printf("Between %d o'clock and %d o'clock\n", hourSmall, hourBig);
    }
    return 0;
}

(10). ZOL3247: Hello World (0.3)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3247

给出一个点阵，要求输出字符图形（每一行输入由 5 个字节组成，代表一个字符，每个字节代表该字符的一列，即每个字符实际上7 * 5 像素，注意行和 bit 之间的对应关系，低位对应的是上方像素，高位对应下方像素，所有字节的最高位为 0，表示最后一行没有任何像素，注意最后一行不能输出一长串空格，而是要输出成空行即直接换行，否则将导致 PE），备注：可使用 strtol 把16进制字符串转换成整数。

#include <stdio.h>

char map[80][5];

char CharToInt(char c)
{
    if(c >= '0' && c <= '9')
        return (c - '0');
    else if(c >= 'A' && c <= 'F')
        return (c + 10 - 'A');
    else
        return 0;
}

int main(int argc, char* argv[])
{
    char line[24];
    int test_count, char_count, i, j, k, col;
    scanf("%d", &test_count);
    for(i = 1; i <= test_count; i++)
    {
        scanf("%d\n", &char_count);
        for(j = 0; j < char_count; j++)
        {
            gets(line);
            for(k = 0; k < 5; k++)
            {
                map[j][k] = CharToInt( line[k*3] ) * 16 
                    + CharToInt( line[k*3+1] );
            }
        }

        //output the string
        printf("Case %d:\n\n", i);

        //j: rows index
        for(j = 0; j < 8; j++)
        {
            if(j < 7)
            {
                for(k = 0; k < char_count; k++)
                {
                    //输出一个字符的某一行（五列）
                        for(col = 0; col < 5; col++)
                     {
                        if( map[k][col] & (1 << j) )
                            printf("#");
                        else
                            printf(" ");
                      }
                      //字符和字符之间的空列
                         if(k < char_count - 1)
                         printf(" ");
                 }
            }
            //一行结束，换行
              printf("\n");
        }
    }
    return 0;
}

(11). ZOL3322: Who is older ? (0.1)
http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3322

给出两个人的生日，比较年龄谁大，超级简单，直接比较字符串即可。

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

int main(int argc, char* argv[])
{
    char line[36];
    int n, i, result;
    scanf("%d\n", &n);
    for(i = 0; i < n; i++)
    {
        gets(line);
        line[10] = 0;
        result = strcmp(line, line + 11);
        if(result < 0)
            printf("javaman\n");
        else if(result > 0)
            printf("cpcs\n");
        else
            printf("same\n");
    }
    return 0;
}

(12). ZOL3487: Ordinal Numbers (0.1)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3487

给出一个数字，根据规则，给出其序数后缀表示。

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

void GetPostfix(const char* line, char* postfix)
{
    int len = strlen(line);
    //十位上的字符
    char c = '0';
    if(len > 1)
        c = line[len-2];

    //If the tens digit of a number is 1, then write
    //"th" after the number. For example: 13th, 19th, 112th, 9311th. 
    if(c == '1')
    {
        strcpy(postfix, "th");
    }
    else
    {
        //If the tens digit is not equal to 1, then use
        //"st" if the units digit is 1, 
        //"nd" if the units digit is 2, 
        //"rd" if the units digit is 3, and 
        //"th" otherwise: 
        //For example: 2nd, 7th, 20th, 23rd, 52nd, 135th, 301st. 

        switch(line[len-1])
        {
        case '1': strcpy(postfix, "st"); break;
        case '2': strcpy(postfix, "nd"); break;
        case '3': strcpy(postfix, "rd"); break;
        default:  strcpy(postfix, "th"); break;
        }
    }
}

int main(int argc, char* argv[])
{
    int count = 0, i;
    char line[48], postfix[4];

    scanf("%d\n", &count);
    for(i = 0; i < count; i++)
    {
        gets(line);
        GetPostfix(line, postfix);
        printf("%s%s\n", line, postfix);
    }
    return 0;
}

(13). ZOL3542: Hexadecimal View (0.1)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3542

给出一行字符串（全部是可打印字符），输出 16 进制视图。备注：字符大小写的互相转换也可使用 touppder / tolower 。

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

void OutputHexView(char* s)
{
    char *p = s;
    int i, linenum = 0;
    char line[16];
    int len = strlen(s);
    int linecount = (len + 15)/16;  //需要打印的总行数
    for(linenum = 0; linenum < linecount; ++linenum)
    {
        memset(line, 0, 16);
        strncpy(line, p, 16);
        p += 16;
        printf("%04x: ", (linenum << 4) & 0xffff);
        for(i = 0; i < 16; i++)
        {
            if(line[i] == 0)
                printf("  ");   //没有字符（最后一行的 padding 部分）
              else
                printf("%02x", line[i]);

            if(i & 1) 
                printf(" ");   //每两个字符之间有一个空格间隔
        }
        for(i = 0; i < 16; i++)
        {
            if(line[i] == 0)
            {
                break;
            }
            else if(line[i] >= 'a' && line[i] <= 'z') // islower( line[i] )
            {
                printf("%c", line[i] + 'A' - 'a');    // toupper( line[i] )
            }
            else if(line[i] >= 'A' && line[i] <= 'Z')
            {
                printf("%c", line[i] + 'a' - 'A');   // tolower;
            }
            else
            {
                printf("%c", line[i]);
            }
        }
        printf("\n");
    }
}

int main(int argc, char* argv[])
{
    char line[4100];
    while( gets(line) != NULL )
    {
        OutputHexView(line);
    }
    return 0;
}

(14). ZOL3317: Murder in Restaurant (0.3)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3317

给出一个旅馆的入住信息表，客人数和房间数，给出每个客人的试图入住日期和离店日期（都用整数表示），尝试给客人分配一个最小房号（从1开始计数）的房间，要求输出每个客人的入住房号，如果该客人来时没有房间则输出 0。

解法：把客人按照入住时间升序排序，然后依次分配房间号。（有些类似贪心法中的申请会议室）

#include <stdio.h>

int Rooms_Leave[100];      /* 每个元素表示第 i 个房间退房的日期 */
int Renters_RoomNo[100];   /* 每个元素分配给第 i 个客人的房间号 */

typedef struct tagRENTER
{
    int index;     //客人索引（0 base）
     int EnterDate; //入住日期
     int LeaveDate; //离店日期
} RENTER, *PRENTER;

typedef RENTER Item;

Item items[100];

int less_than(Item t1, Item t2)
{
    if (t1.EnterDate < t2.EnterDate) return 1;
    else return 0;
}


/*交换a[]的i，j项*/
void exchange(Item a[], int i, int j)
{
    if(i != j)
    {
        int _index = a[i].index;
        int _EnterDate = a[i].EnterDate;
        int _LeaveDate = a[i].LeaveDate;

        a[i].index = a[j].index;
        a[i].EnterDate = a[j].EnterDate;
        a[i].LeaveDate = a[j].LeaveDate;

        a[j].index = _index;
        a[j].EnterDate = _EnterDate;
        a[j].LeaveDate = _LeaveDate;
    }
}

 /*选择排序*/
void SelectionSort(Item a[], int left, int right)
{
    int i, j, min;
    for(i = left; i < right; i++)
    {
        min = i;
        for(j = i + 1; j <= right; j++)
            if(less_than(a[j], a[min])) min = j;
        exchange(a, i, min);
    }
}


int main(int argc, char* argv[])
{
    int renter_count, room_count, i, j;

    while( 1 )
    {
        scanf("%d %d", &renter_count, &room_count);
        
        if(renter_count == 0)
            break;

        for(i = 0; i < renter_count; i++)
        {
            Rooms_Leave[i] = 0;
            Renters_RoomNo[i] = 0;
            items[i].index = i;
            scanf("%d %d", &items[i].EnterDate, &items[i].LeaveDate);
        }

        /* 给每个客人分配房间 */
        SelectionSort(items, 0, renter_count - 1);
        for(i = 0; i < renter_count; i++)
        {
            for(j = 0; j < room_count; j++)
            {
                if(Rooms_Leave[j] <= items[i].EnterDate)
                {
                    Rooms_Leave[j] = items[i].LeaveDate;
                    Renters_RoomNo[ items[i].index ] = j + 1;
                    break;
                }
            }
        }

        /* output result */
        for(i = 0; i < renter_count; i++)
        {
            printf("%d\n", Renters_RoomNo[i]);
        }
    }
    return 0;
}

(15). ZOL2850: Beautiful Meadow ( 0.1 )

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=2850

给出一个 N * M 的网格，每个 cell 的值是 0 或 1。如果所有 cell 都是1，或有任何为 0 的 cell 相邻（即共享某条边），则输出No，否则输出Yes。

#include <stdio.h>

int main(int argc, char* argv[])
{
    int row, col, i, j, tmp, sum;
    int bMowedAdjacent;
    char map[100][100];
    while(1)
    {
        scanf("%d %d", &row, &col);
        if(row == 0)
            break;

        bMowedAdjacent = 0;
        sum = 0;
        for(i = 0; i < row; i++)
        {
            for(j = 0; j < col; j++)
            {
                scanf("%d", &tmp);
                map[i][j] = tmp;
                if(tmp == 0)
                {
                    if(j > 0 && map[i][j-1] == 0)
                        bMowedAdjacent = 1;
                    else if(i > 0 && map[i-1][j] == 0)
                        bMowedAdjacent = 1;
                }
                else
                    sum += tmp;
            }
        }
        if(bMowedAdjacent || sum == row * col) printf("No\n");
        else printf("Yes\n");
    }
    return 0;
}

(16). ZOL1094: Matrix Chain Multiplication ( 0.3 )

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1094

虽然题目是算法经典命题-矩阵乘法链，但是此题目考察的绝不是动态规划（DP），而是给出一个矩阵乘法加括号的表达式，求该方案所需的乘法运算数。如果矩阵乘法不相容，则输出 "error"。此题目的输入非常标准，无需考虑表达式的括号不匹配等问题。也无需考虑例如 "ABC" 这种没有加括号的表达式（输入一定给出的是 "((AB)C)" ）。如果是只有单个矩阵，则一定没有括号。这种输入的标准化使我们无需检测特殊情况（例如 "(A)", "ABC", ")AB" 等），可以仅仅用表达式中的括号去推动表达式的解析。

解法是：准备两个辅助栈，一个装入矩阵信息（操作数），一个装入括号（由于输入表达式一定括号匹配，因此第二个辅助栈实际上不需要，但为了保持逻辑完整性依然保留），每次遇到“）”符号，则从操作数栈中弹出两个矩阵，如果相容，则累加这两个矩阵相乘的代价，然后把结果信息 (row, col) 再次入栈。

#include <stdio.h>

typedef struct _tagMatrixInfo
{
    int row;
    int col;
} MatrixInfo;

MatrixInfo matrix[26];

/* szExpression: 形如"(A(BC))"; 返回值：乘法次数，-1 代表不相容 */
int GetResult(char* szExpression)
{
    char *p = szExpression;
    char c;
    
    char brackets[512];   /* 括号的栈 */
    int pBrackets = -1;   /* 栈顶指针 */

    MatrixInfo nums[512]; /* 操作数栈 */
    int pNums = -1;       /* 栈顶指针 */
    
    int row0, col0, row1, col1;
    int count = 0;        /* 返回的结果：总乘法次数 */
    while(*p)
    {
        c = *p;
        ++p;
        if(c >= 'A' && c <= 'Z') /* push in stack */
        {
            ++pNums;
            nums[pNums].row = matrix[c-'A'].row;
            nums[pNums].col = matrix[c-'A'].col;
        }
        else if(c == '(')
        {
            brackets[++pBrackets] = c;
        }
        else if(c == ')')
        {
            /* 从栈中弹出两个操作数 */
            row0 = nums[pNums - 1].row;
            col0 = nums[pNums - 1].col;
            row1 = nums[pNums].row;
            col1 = nums[pNums].col;
            pNums -= 2;
            pBrackets--; /* 弹出一个'(' */
            
            /* 两个操作数是否相容？ */
            if(col0 != row1)
                return -1;

            count += row0 * col0 * col1;

            /* 结果信息 push 到操作数栈中 */
            ++pNums;
            nums[pNums].row = row0;
            nums[pNums].col = col1;
        }
    }
    return count;
}
int main(int argc, char* argv[])
{
    int n, i, result;
    char cNum, line[1024];
    scanf("%d\n", &n);
    for(i = 0; i < n; i++)
    {
        scanf("%c ", &cNum);
        scanf("%d %d\n", &matrix[cNum-'A'].row, &matrix[cNum-'A'].col);
    }
    while(gets(line) != NULL)
    {
        result = GetResult(line);
        if(result < 0) printf("error\n");
        else printf("%d\n", result);
    }
    return 0;
}

本文链接

ZOL1010（Area）解题报告

2011-11-04T13:17:00Z

ZOL 1010. Area.

题目地址：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1010

基本题意：此题目给出 n 个点的坐标 (xi，yi ) ，要求求出这些点按顺序围成的多边形的面积。同时要求检测出不合法的多边形（例如非相邻边彼此相交的情况）。

此题求面积不难，样例很容易就过了，但是提交 10+ 次基本都是 WA ，几乎失去信心。做题最郁闷的就是你不知道问题到底出在什么地方，可能改了很多次都没有试对地方。后来跑到 88 的算法版搜了下，看到别人的代码，然后事后总结实际还是卡在了什么样的多边形是 Impossible 的，这个检测代码没有写好，耐心不够导致。

（1）求面积很简单，类似求某个曲线的区间积分

用所有多边形的边和X轴围成的梯形的面积累加起来就可以了。例如某条边 ( P1 - P2 ) 和在它在 x 轴的投影 ( p1' - P2' ) 所围成的梯形面积是：

S [ p1->p2 ] = 1/2 * ( y1 + y2 ) * ( x2 - x1 ) ;　　----（I）

这个式子拆开后就是：

S [ p1->p2 ] = 1/2 * ( -x1 * y1 + x2 * y2 - x1 * y2 + x2 * y1 ) ; ---- ( 注：蓝色部分的 xi * yi 累加后被消掉 )

由于每个边都被累加一遍，每个点参与了组成边两次（前一条边的终点和后一条边的起始点），所以每个顶点自身坐标的乘积 ( xi * yi ) 累加的时候都被消掉了！最后就是累加所有的式（I）：

　　　　Area = ∑ 1/2 * ( -x( i ) * y( i + 1 ) + x( i + 1 ) * y( i ) ) ;

　----( i = 1,2,...,n，且P(n+1) = P(0) );　　　　 ----（II）

上面的式子，括号内是两个矢量的叉积 P[ i + 1 ] × P[ i ]。因此式II实际上是依次累加相邻点的叉积，最后在除以2。考虑叉积的含义，是以两个矢量为相邻边的平行四边形（由 O(0,0), P1, P2, (P1 + P2) 四个点组成）的面积（在平面坐标中用三角形面积相减可以很容易推导出该含义），因此这个方法的物理意义就非常明显了，我们可以直观的假定原点位于多边形内部，显然依次把相邻点和原点围成的三角形的面积累加起来就是这些点组成的多边形的面积。因此 1/2 ( P[ i + 1 ] X P[ i ] ) 就是三角形 O - P[ i + 1 ] - P[ i ] 的面积（平行四边形面积的一半，O 表示原点）。当然，由于叉积有符号，所以原点位于多边形外部也成立，只是在内部更直观，更容易理解。

备注：我们可以把存储顶点的数组扩充一个元素，然后把 P( n+1 ) 赋值为 P( 0 )，这样我们对上式的循环中就不必对顶点索引使用取模运算（MOD）。我自己写的代码采用的（I）这种计算方法，我参考的代码采用（II）中的计算方法，两者计算量相差不大，但后者不太直观，所以我就稍微解释了下两者本质是相同的。

注意式（I）中的梯形面积是有符号的，和 P1，P2 的点顺序相关( S[ p1->p2 ] = -S[ p2->p1 ] ) ，因此 Area 的符号和顶点顺序有关，所以最后别忘了对计算结果求绝对值。

（2）麻烦在于，什么样的多边形是 Impossible 的

做题的时候肯定我们就会着重考虑这一点。因为不管任何多边形，按照（1）都能算出个面积，但是多边形是否是有效的需要单独判断。设多边形有 n 个顶点和边，则：

2.1） n < 3 时，显然是 Impossible，因为一个点或一个线段不能组成多边形。

2.2） n > 3 时，依次判断每条边和它的所有非相邻边不能相交（包含交点位于某一条线段上的情况），保证这一点即可。

2.3） n = 3 时，是三角形，无须做 2.2 中的检测。如果三角形的三个点共线的话，是不是应该输出 Impossible，我们没有考虑也 AC 了（即我们会对这种情况认为是有效的而输出 0.00），估计 OL平台的测试输入也没有考虑这种情况。

下面我们考虑2.2中的检测：

总的边数为 n，则每条边的非相邻边为（n-3）条，所以检测完所有边的情况类似冒泡排序，以及绘制多边形所有顶点的连接线的金刚石图形，需要耗费O（n^2)的时间复杂度。

相邻边必然是相交于顶点的所以不用检测，即使相邻边向内重叠了，比如连续的三个顶点：（0，0），（0，5），（0，3）这种情况也不必担心，因为在下一条边检测时也会检测出相交情况的。

判断两个线段是否相交属于算法中的计算几何部分，主要原理是如果两个线段相交，则从任何一个线段角度看，另一个线段的两个端点都位于它自己的两侧（该线段以任一端点为原点旋转到经过另一个线段的两个端点的时针方向相反）。两个矢量的相对旋转方向利用矢量叉积求出。

我原来还考虑了浮点数和 0 的比较判断，实际上最后从提交结果发现无需考虑这个问题，直接和 0 比就是了。

（3）对顶点坐标的存储

为了检测多边形是不是Impossible的，就必须要存储所有顶点的坐标。如果不需要判断这个，就不需要任何额外的存储空间。那样就简洁多了。当然那样的话这道题也就毫无任何难度，也失去了对计算几何的考察点。

我看了我参考的解法，我居然没有想到像他开一个维度为1000的数组，ft！我是用了一个链表来存储所有的边。。。。汗。。。（当然应该用STL就可以，我习惯了自己写链表的代码），所以我的代码比我参考的那个人的多好多。。。（他的代码好简短！）

另外，由于我用链表存储的是线段，相当于每个顶点被我存储了两次，所以实际上还是浪费了一倍的堆上内存。另外还要加上链表使用的指针占用的空间。当然优点是动态内存管理相比静态数组在内存的使用上要灵活一些，这就无须多做解释了。

检测边是否相交实际上和那个人的代码的原理基本一致，这部分代码我基本是照着《算法导论》上的伪码直译过来的。

我提交的代码如下：

#include <stdio.h>
#include <stdlib.h>

//#define ZEROVALUE 0.00000000000001

#ifndef __max
#define __max(a,b)  (((a) > (b)) ? (a) : (b))
#endif

#ifndef __min
#define __min(a,b)  (((a) < (b)) ? (a) : (b))
#endif

typedef struct _LINE
{
    double x1;
    double y1;
    double x2;
    double y2;
    _LINE* pNext;
} LINE;


//以Pi为原点，从 PiPj 到 PiPk 的方位（返回值的符号表示顺时针 or 逆时针）
double Direction(double xi, double yi, //原点
                 double xj, double yj, //线段1结束点
                 double xk, double yk) //线段2结束点
{
    return (xk - xi) * (yj - yi) - (xj - xi) * (yk - yi);
}

//如果点 Pk 位于线段 PiPj 所在直线上，则它是否位于该线段内
int OnSegment(double xi, double yi,  
               double xj, double yj, //线段1结束点
               double xk, double yk) //线段2结束点
{
    if(xk >= __min(xi, xj) && xk <= __max(xi, xj)
        && yk >= __min(yi, yj) && yk <= __max(yi, yj))
        return 1;
    else
        return 0;
}

//判断两个线段P1P2，P3P4是否相交
int intersect(double x1, double y1,
              double x2, double y2,
              double x3, double y3,
              double x4, double y4)
{
    double d1 = Direction(x3, y3, x4, y4, x1, y1);
    double d2 = Direction(x3, y3, x4, y4, x2, y2);
    double d3 = Direction(x1, y1, x2, y2, x3, y3);
    double d4 = Direction(x1, y1, x2, y2, x4, y4);

    if(    ((d1 > 0 && d2 < 0) || (d1 < 0 && d2 > 0))
        && ((d3 > 0 && d4 < 0) || (d3 < 0 && d4 > 0)) )
        return 1; //相交

    else if(d1 == 0 && OnSegment(x3, y3, x4, y4, x1, y1))
        return 1;
    else if(d2 == 0 && OnSegment(x3, y3, x4, y4, x2, y2))
        return 1;
    else if(d3 == 0 && OnSegment(x1, y1, x2, y2, x3, y3))
        return 1;
    else if(d4 == 0 && OnSegment(x1, y1, x2, y2, x4, y4))
        return 1;
    else
        return 0; //绝对不相交
}


/* 增加线段到链表尾部 */

void AddLine(LINE** ppHead, LINE** ppTail,
             double x1, double y1,
             double x2, double y2)
{
    LINE *pNode = (LINE*)malloc(sizeof(LINE));
    pNode->pNext = NULL;
    pNode->x1 = x1;
    pNode->y1 = y1;
    pNode->x2 = x2;
    pNode->y2 = y2;

    if(*ppTail != NULL)
    {
        (*ppTail)->pNext = pNode;    
    }
    else
    {
        *ppHead = pNode;
    }
    *ppTail = pNode;
}

void FreeList(LINE** ppHead, LINE** ppTail)
{
    LINE* pNode = (*ppHead);
    while(pNode != NULL)
    {
        LINE* tmp = pNode->pNext;
        free(pNode);
        pNode = tmp;
    }
    *ppHead = NULL;
    *ppTail = NULL;
}

/* 检查是否这一系列点围成的多边形是否合法 */

int CheckValid(LINE* pHead)
{
    int index = 0; /* 当前正循环到的边的索引 */
    LINE* pCur = pHead;
    LINE* pTest;

    while(pCur != NULL)
    {
        pTest = NULL;
        if(pCur->pNext != NULL)
            pTest = pCur->pNext->pNext;

        while(pTest != NULL)
        {
            //最后一条边(n-1) -- (0)，不与第一条边 (0) -- (1) 检测
            if(index == 0 && pTest->pNext == NULL)
                break;
            
            /* 非相邻边相交？ */
            if(intersect(pCur->x1, pCur->y1, pCur->x2, pCur->y2,
                pTest->x1, pTest->y1, pTest->x2, pTest->y2))
            {
                return 0;
            }
            pTest = pTest->pNext;
        }
        pCur = pCur->pNext;
        ++index;
    }    
    return 1;
}


int main(int argc, char* argv[])
{
    LINE *pHead = NULL, *pTail = NULL;
    int i, n = 0, figure = 1;
    double x0, y0, x1, y1, x2, y2;
    double area = 0;

    //int test = intersect(0, 1, 1, 0, 1, -1, 0, 0.5);

    while(1)
    {
        scanf("%d", &n);
        if(n <= 0)
            break;

        //打印一个空行
        if(figure > 1)
            printf("\n");

        area = 0;
        scanf("%lf %lf", &x0, &y0);
        x1 = x0;
        y1 = y0;
        for(i = 1; i <= n; i++)
        {
            if(i < n)
                scanf("%lf %lf", &x2, &y2);
            else
            {
                x2 = x0;
                y2 = y0;
            }
            area += (y1 + y2) * (x2 - x1) * 0.5;

            AddLine(&pHead, &pTail, x1, y1, x2, y2);

            x1 = x2;
            y1 = y2;
        }

        if(area < 0)
            area *= -1;

        if(n < 3)
            printf("Figure %d: Impossible\n", figure);
        else if(!CheckValid(pHead))
            printf("Figure %d: Impossible\n", figure);
        else
            printf("Figure %d: %.02lf\n", figure, area);

        FreeList(&pHead, &pTail);

        figure++;
    }
    return 0;
}

另附上我参考的代码：

发信人: dynamic (programming@math), 信区: ACMICPC
标  题: Re: 1010里的错误多边形有多少可能性？
发信站: 逸仙时空 Yat-sen Channel (Wed Apr  9 20:55:07 2003), 站内信件

我的程序



//zju 1010
//by dynamic
//on sunday july 28th



#include <stdio.h>

double det(double x1,double y1,double x2,double y2,double x3,double y3)
{
        return x1*y2+x2*y3+x3*y1-x2*y1-x3*y2-x1*y3;
}



int main()
{
        int n,i,j,count=0,temp;
        double x[1000],y[1000],area;
        while(1)
        {
                scanf("%d",&n);
                if (n==0) return 0;
                count++;
                if (count>1) printf("\n");
                printf("Figure %d: ",count);
                for(i=0;i<n;i++) scanf("%lf%lf",&x[i],&y[i]);
                if (n<3){
                        printf("Impossible\n");
                        continue;
                }
                for(i=0;i<n;i++)
                        for(j=(i+1)/n;j<i-1;j++){
                                temp=(i+1)%n;
                                if (det(x[j],y[j],x[i],y[i],x[j+1],y[j+1])*det(x[j],y[j],x[temp],y[temp],x[j+1],y[j+1])<=0&&
                                        det(x[i],y[i],x[j],y[j],x[temp],y[temp])*det(x[i],y[i],x[j+1],y[j+1],x[temp],y[temp])<=0) {
                                        printf("Impossible\n");
                                        goto quit;
                                }
                         }
                area=0;
                for(i=0;i<n;i++){
                        area+=x[i]*y[(i+1)%n];
                        area-=y[i]*x[(i+1)%n];
                }
                if (area<0) area*=-1;
                printf("%.2lf\n",area/2);
quit:;
        }
}

参考资料：

1. 《算法导论》，第33章（计算几何学）33.1 节（线段的性质）。

本文链接

修改 EXE 文件的图标

2011-07-09T19:16:00Z

【关键字】VC++，修改EXE文件的图标

在很多年前很著名的熊猫烧香病毒，就有这样一个行为，是搜索硬盘上的可执行文件并感染它们，其典型外观症状就是程序的图标变成了熊猫烧香。本文讲解的是修改EXE文件（可执行文件）的图标，可以看做是我写PE文件的Directoried相关文章的一个后续应用，本文性质属于技术可行性研究。考察下windows系统上的文件可以发现下面的特征：

（1）应用程序的可执行文件可以有自己定义的图标，通常位于其资源中，资源管理器使用资源中的图标显示它们，如果没有资源，就显示成系统默认的可执行文件图标。

（2）DLL中虽然可以含有图标资源，但系统一律都是用统一的DLL图标去显示他们。

（3）快捷方式的图标可以随意指定来源，通常是来自其指向的目标文件。用户可以随意修改快捷方式的图标。

（4）就是系统中注册的文档类型，比如doc，txt等等后缀名的文件，其图标是注册在注册表中的，通常也就是来自于打开他们的默认程序中。

再考察下上面的四种显示的图标，其中（2）取决于系统，无法修改也没有必要修改。（1）的图标修改比较困难，因为必须修改PE文件本身，我们通常需要借助专门的资源编辑工具（例如vs.net）打开才能修改。本文讲述的是修改（1）也就是EXE文件的图标。

现在介绍一下我的代码的原理，就是图标是多个图像组成的，每个图像的数据被存放在PE文件中。我在PE文件中定位到这些数据，然后用用户选择的其他图标数据，把这里的数据覆盖。这样PE文件里的图标就被彻底换掉了。我在这里并未校验内存是否写越界，因为如果不出意外，我替换的是标准图标，（通常索引图像的调色板都是满的，比如4bpp的图像调色板是16个颜色，8bpp的图像调色板是256个颜色），所以基本不会发生越界导致破坏PE文件的问题。由于只改动图标，所以PE文件修改后依然能正常运行。为了防止意外，在修改之前我会对PE文件进行备份。还原时就用备份的文件重新覆盖回来即可。

下图显示的是用我写的工具查看 PE 文件的一些Directory，用它打开windows的记事本程序，可以看到记事本文件中的图标在PE文件的资源表中的位置：

注意，图标节点（Icon）是位于第一级子结点深度，其 Entry.Id 为 3。下面含有多个子结点，每一个子结点都是一个图像，每个子结点到达叶子以后，就是图像数据，它们由三部分组成，分别是 BitmapInfoHeader ，调色板（如果是索引图像）， XOR Mask 数据， AND Mask 数据（Mask 数据的扫描行宽度都必须以 4 Bytes 对齐）。如果你熟悉 ICO 的文件格式，这里就不用我介绍了，可以参考 ICO 文件格式的资料。

当我定位到这里以后，剩下的任务就是把这里的数据替换掉。为此，我把PE文件的内容先整体加载到内存中，然后定位到图像数据，并用已经选择的一个图标尝试替换其数据，这里我使用的方法是，用户选择的图标中的图像，比如和PE文件中的图像一致才替换，所谓一致，是指三个数据的完全相同（宽度，高度，位深度），实际上如果用户选择的图标图像（复制的源）如果小于被覆盖的数据的大小，是没有问题的，即相当于PE文件中在图像数据后面会有一些字节成了无用的垃圾数据），比如我们用 32 * 32， 8 BPP 的图像数据覆盖掉 48 * 48， 8 BPP 的数据是不会出问题的，但是这里我们也应该同时修改 GroupIcon 中的图标高度和宽度信息，以和实际图像数据相符。但反过来，如果用大数据覆盖小数据是绝对不行的，因为我们绝对不能在超出我们已知内容的范围以外去写东西，那将可能产生对PE文件的破坏，甚至使他无法运行。

每个Icon节点下面还有一层“语言”目录，然后才到达真正的叶子节点（即图像的BitmapInfoHeader入口处）。所以这里我依然使用一个递归函数去找到最终的叶子节点，然后用 memcpy 覆写这里的数据。最后，我们把整个PE文件重写保存到硬盘上即可。

这里提供关键代码，即以下两个函数，在第一个函数中，我使用了 ImageRvaToVa 去在PE文件中定位到相应的数据结构（例如Directory）的地址。下面代码中有很多对返回值的校验等，所以显得比较杂乱些。

//换图标
BOOL ChangeIcon(HWND hDlg)
{
TCHAR szPath_App[MAX_PATH];
TCHAR szPath_Ico[MAX_PATH];

GetDlgItemText(hDlg, IDC_EDIT_APPPATH, szPath_App, MAX_PATH);
if(_tcslen(szPath_App) == 0)
{
MessageBox(hDlg, _T("请输入程序的路径"), _T("warning"), MB_OK | MB_ICONWARNING);
return FALSE;
}

GetDlgItemText(hDlg, IDC_EDIT_ICOPATH, szPath_Ico, MAX_PATH);
if(_tcslen(szPath_Ico) == 0)
{
MessageBox(hDlg, _T("请输入图标的路径"), _T("warning"), MB_OK | MB_ICONWARNING);
return FALSE;
}

//先把程序全部读入内存
HANDLE hFile = CreateFile(szPath_App,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);

if(hFile == INVALID_HANDLE_VALUE)
{
MessageBox(hDlg, _T("打开程序文件失败。"), _T("warning"), MB_OK | MB_ICONWARNING);
return FALSE;
}

DWORD dwBytesRead = 0;
DWORD dwAppFileSize = GetFileSize(hFile, NULL);

PBYTE lpBaseAddress = (PBYTE)malloc(dwAppFileSize);
if(lpBaseAddress == NULL)
{
CloseHandle(hFile);
MessageBox(hDlg, _T("内存不足。"), _T("warning"), MB_OK | MB_ICONWARNING);
return FALSE;
}

if(!ReadFile(hFile, lpBaseAddress, dwAppFileSize, &dwBytesRead, NULL) || dwBytesRead != dwAppFileSize)
{
CloseHandle(hFile);
free(lpBaseAddress);
MessageBox(hDlg, _T("读取APP文件失败。"), _T("warning"), MB_OK | MB_ICONWARNING);
return FALSE;
}
CloseHandle(hFile); //关闭文件

//
// 加载图标
//

if(!g_IcoFile.LoadFile(szPath_Ico))
{
free(lpBaseAddress);
MessageBox(hDlg, _T("读取ICO文件失败。"), _T("warning"), MB_OK | MB_ICONWARNING);
return FALSE;
}

//现在准备路径
TCHAR szPath_AppBackup[MAX_PATH];
TCHAR szPath_AppModified[MAX_PATH];

//TCHAR szDriver[4], szDir[MAX_PATH], szFilename[MAX_PATH], szExt[8];
//_tsplitpath(szPath_App, szDrive, szDir, szFilename, szExt);

_stprintf(szPath_AppBackup, _T("%s.Backup"), szPath_App);
_stprintf(szPath_AppModified, _T("%s.Modified"), szPath_App);

if(!CopyFile(szPath_App, szPath_AppBackup, TRUE))
{
free(lpBaseAddress);
MessageBox(hDlg, _T("备份APP文件失败。"), _T("warning"), MB_OK | MB_ICONWARNING);
return FALSE;
}

//
// 在内存中替换 ICON （覆写内存数据）
//

int totalImgCount = 0, replacedImgCount = 0;

PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)lpBaseAddress;
PIMAGE_NT_HEADERS pNtHeaders = (PIMAGE_NT_HEADERS)(lpBaseAddress + pDosHeader->e_lfanew);

BOOL bFindIcon = FALSE;
//资源表的rva
DWORD rva_resTable = pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress;
if(rva_resTable > 0)
{
//this->LoadResTable(lpBaseAddress, pNtHeaders, rva_resTable);
PIMAGE_RESOURCE_DIRECTORY pResTable = (PIMAGE_RESOURCE_DIRECTORY)ImageRvaToVa(
pNtHeaders,
lpBaseAddress,
rva_resTable,
NULL);

PIMAGE_RESOURCE_DIRECTORY_ENTRY pEntries = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((DWORD)pResTable + sizeof(IMAGE_RESOURCE_DIRECTORY));

//寻找 Icon 子节点（在第一层上）
for(int i = 0; i < (pResTable->NumberOfNamedEntries + pResTable->NumberOfIdEntries); i++)
{
//this->AddChildNode(hItem_Res, lpBaseAddress, pNtHeaders, (DWORD)pResTable, pEntries + i, 1);
if(!pEntries[i].NameIsString && pEntries[i].Id == 3) //找到了Icon？
{
bFindIcon = TRUE;

//
// 现在遍历每个Icon 并尝试替换叶子节点上的图标数据
//

DWORD tableAddress = (DWORD)pResTable;
PIMAGE_RESOURCE_DIRECTORY pDir = (PIMAGE_RESOURCE_DIRECTORY)(tableAddress + pEntries[i].OffsetToDirectory);
PIMAGE_RESOURCE_DIRECTORY_ENTRY pEntries_Icon = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((DWORD)pDir + sizeof(IMAGE_RESOURCE_DIRECTORY));

totalImgCount = pDir->NumberOfNamedEntries + pDir->NumberOfIdEntries;

for(int j = 0; j < totalImgCount; j++)
{
OverwriteIcon(lpBaseAddress, pNtHeaders, tableAddress, pEntries_Icon + j, &replacedImgCount);
}
break;
}
}
}

if(!bFindIcon)
{
free(lpBaseAddress);
MessageBox(hDlg, _T("程序文件中没有图标，所以无须替换。"), _T("warning"), MB_OK | MB_ICONWARNING);
return FALSE;
}

//保存到修改后的内容到 APP.exe.Modified

HANDLE hFile2 = CreateFile(szPath_AppModified,
GENERIC_WRITE,
FILE_SHARE_READ,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL);

if(hFile2 == INVALID_HANDLE_VALUE)
{
free(lpBaseAddress);
MessageBox(hDlg, _T("保存修改后的程序文件失败。"), _T("warning"), MB_OK | MB_ICONWARNING);
return FALSE;
}

DWORD dwBytesTotal = dwAppFileSize;
DWORD dwBytesToWrite = 0, dwBytesWritten = 0;
PBYTE pBytePos = lpBaseAddress;

while(dwBytesTotal > 0)
{
dwBytesToWrite = min(1024, dwBytesTotal);
WriteFile(hFile2, pBytePos, dwBytesToWrite, &dwBytesWritten, NULL);
dwBytesTotal -= dwBytesToWrite;
pBytePos += dwBytesToWrite;
}
CloseHandle(hFile2);

//释放内存
free(lpBaseAddress);
lpBaseAddress = NULL;

g_IcoFile.Clear();

if(!CopyFile(szPath_AppModified, szPath_App, FALSE))
{
MessageBox(hDlg, _T("替换程序文件失败。"), _T("warning"), MB_OK | MB_ICONWARNING);
return FALSE;
}

DeleteFile(szPath_AppModified);

TCHAR szMsg[256];
_stprintf(szMsg, _T("替换程序图标成功! \r\n其中图像总数 %ld 个，成功替换 %ld 个。"),
totalImgCount, replacedImgCount);
MessageBox(hDlg, szMsg, _T("success"), MB_OK | MB_ICONINFORMATION);
return TRUE;
}

//【递归函数】一个Icon的子结点，但不是叶子节点，递归到叶子节点后进行数据覆盖

void OverwriteIcon(LPVOID lpBaseAddress,
PIMAGE_NT_HEADERS pNtHeaders,
DWORD tableAddress,
PIMAGE_RESOURCE_DIRECTORY_ENTRY pEntry,
int* pReplacedCount)
{
//再确定节点类型（目录还是叶子）
if(pEntry->DataIsDirectory)
{
PIMAGE_RESOURCE_DIRECTORY pDir = (PIMAGE_RESOURCE_DIRECTORY)(tableAddress + pEntry->OffsetToDirectory);
PIMAGE_RESOURCE_DIRECTORY_ENTRY pEntries = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((DWORD)pDir + sizeof(IMAGE_RESOURCE_DIRECTORY));
for(int i = 0; i <(pDir->NumberOfNamedEntries + pDir->NumberOfIdEntries); i++)
{
OverwriteIcon(lpBaseAddress, pNtHeaders, tableAddress, pEntries + i, pReplacedCount);
}
}
else
{
//已经叶子节点！
PIMAGE_RESOURCE_DATA_ENTRY pDataEntry = (PIMAGE_RESOURCE_DATA_ENTRY)(tableAddress + pEntry->OffsetToData);

//具体的资源属于位于：pData->OffsetToData，这是一个RVA（不是相对于资源表头部的偏移！！！）
//去定位到实际的资源数据

PBYTE lpIconData = (PBYTE)ImageRvaToVa(pNtHeaders, lpBaseAddress, pDataEntry->OffsetToData, NULL);

/*_stprintf(nodeText, _T("FileAddr: %08X; RVA: %08X; Size = %ld Bytes; "),
pData - (DWORD)lpBaseAddress,
pDataEntry->OffsetToData,
pDataEntry->Size);*/

PBITMAPINFOHEADER pBmInfoHdr = (PBITMAPINFOHEADER)lpIconData;

int imgIndex = g_IcoFile.GetImageIndex(pBmInfoHdr->biWidth, pBmInfoHdr->biHeight, pBmInfoHdr->biBitCount);

if(imgIndex >= 0)
{
//覆盖BitmapInfoHeader部分
int bytesCopy = sizeof(BITMAPINFOHEADER) + g_IcoFile.m_pImages[imgIndex].nPaletteSize * sizeof(RGBQUAD);
memcpy(lpIconData, g_IcoFile.m_pImages[imgIndex].lpInfo, bytesCopy);
lpIconData += bytesCopy;

//覆盖XOR Mask部分
bytesCopy = g_IcoFile.m_pImages[imgIndex].nSize_XOR;
memcpy(lpIconData, g_IcoFile.m_pImages[imgIndex].lpXOR, bytesCopy);
lpIconData += bytesCopy;

//覆盖And Mask部分
bytesCopy = g_IcoFile.m_pImages[imgIndex].nSize_AND;
memcpy(lpIconData, g_IcoFile.m_pImages[imgIndex].lpAND, bytesCopy);
lpIconData += bytesCopy;

//增加替换图像数
*pReplacedCount = *pReplacedCount + 1;
}
}
}

下面是该Demo程序的截图：点击替换图标按钮后，尝试替换，替换后程序依然可以正常执行，并未对程序本身有其他任何破坏作用。点击还原按钮，用于还原成原来的EXE文件。当然，由于重要系统文件有系统服务进行文件保护，所以通常不能替换。可以选择一些不重要的EXE文件进行测试，并且本程序仅修改的是 EXE 在资源管理器里的视图图标。而程序运行起来以后的图标（例如标题栏，系统托盘等图标可能是运行时设置，其来源也可能不位于被修改的PE文件，例如来自其他DLL，则这些运行时图标是未能替换的，除非你找到了它们的所在并真正换掉了它们）。

在本范例中，我同时使用了我在 Photoshop ICO 文件格式插件中编写的一个类（CIcoFile），它早期也曾用于图像文件数据查看器，在本例中用于加载 ICO 文件。

下面是本范例程序的完整源码下载连接，为了方便测试，我同时提供了一个含有多个图像（从 128 * 128 到 16 * 16 ）的绿色小青蛙的 ICO 文件，位于Debug输出目录。以下源码由VS2005，使用VC++，Win32 SDK开发（无MFC）：

http://files.cnblogs.com/hoodlum1980/ChgAppIcon.rar

　　　　--------------------------------------------

　　　　【后续补充】: 一个方便查找图标来源的小工具 -- ListIcons

　　　　在开发完成 Photoshop ICO 格式插件后，我发现有一个不方便的地方，就是如果一个程序下面包含的 DLL 和 EXE 比较多，那么就很难确定到底图标位于那个文件中，如果一个一个打开来试验，显然效率很低。在文本范例中，我提到了如果要修改某些图标，必须找到它们位于何处。如果我们知道这个图标来自哪里（哪个DLL/EXE文件），哪么我们根据资源表的结构就可以很方便的定位到其数据，然后有针对性的修改它。（我在这个范例中是暴力的一股脑的把一个PE文件中的所有图标都替换掉了）。因此我又开发了下面这个工具。

这个工具可以打开一个文件夹，然后尝试在这个文件夹下面的所有PE文件中查找图标，并加载到一个ListView（根据来自的文件启用了分组）中显示出来。由于需要ListView的分组功能，因此操作系统要求在WinXP以上。如下图所示是我加载 XP 系统的 system32 文件夹下的所有PE文件中的图标：

通过这个工具可以更快的找到图标的位置。在这里我没有实现把图标导出的功能，如果你需要导出图标，可以使用 ICONPRO 或者我开发的 PS ICO 插件（当然使用该插件需要先安装Photoshop）。

为了效率考虑，我在实现这个工具时，没有递归遍历子文件夹。也就是说，程序只会尝试加载用户选定的文件夹根目录下的文件。如果下面的文件过多，例如 system32 下面有 1700 多个 PE 文件，这时我会启用多线程，为用户显示一个进度条对话框。

该工具的源码和编译版本下载连接如下：

http://files.cnblogs.com/hoodlum1980/ListIcons.rar

--hoodlum1980， ON 2011-8-11。

【补充：已知问题 (已解决) 】

　　　　ListIcons 工具中使用 CreateIconFromResource 函数创建一个图标后，会产生 GDI 对象泄露，具体原因不详。根据 MSDN 的描述，暂时没有找到产生 GDI 对象泄露的原因。该问题导致反复添加含有大量图标的文件夹时，系统会显示异常。

　　　　而且MSDN上的例子 ICONPRO 也有该 GDI 对象泄露问题（只是这个问题不显著而已，只要不停切换导入图标对话框上的选中图标，即可看到GDI对象个数缓慢上升到 10000 ）。看来这个问题是由 CreateIconFromResource 这个 API 函数引入的。

　　　　【补充2：对GDI对象泄露的问题的解决】

　　　　经过我的研究发现，实际上GDI对象泄露的现象是由于 CreateIconFromResource 这个函数默认的把图标当作 Shared 方式导致的，一旦图标被其他进程用“共享”方式获取（备注："共享" 在此处的含义是指多个进程创建、获取、申请和使用的对象在底层上是 同一个对象 ），哪么这个进程不管是否调用 DestroyIcon 之类的函数都是不起作用的。

　　　　我估计，系统可能把共享方式的图标当作“长期使用”的，也就是可能多个进程都需要频繁的使用他们，因此共享方式的GDI对象不会被释放。这对于系统级别的GDI对象是有意义的，例如 GetStockObject 等获取到的 GDI 对象（例如白色话刷，黑色画笔等）实际上是长期在系统中生存的。这是由于这些对象的使用非常频繁，因此长期持有他们可以节省系统运行时效率。

　　　　因此，共享方式的潜在要求是：程序通过共享方式申请或创建得到的GDI对象的数量不宜太多（备注：不要太多，根据 GDI 对象达到 10000 以后即造成系统绘制异常考虑，这里我认为数量在1000以下是可以的，当然这还和具体环境有关），如果太多，本质上等同于 GDI 对象泄露。因为共享对象是当进程退出时才被释放。所以小批量的共享对象不会产生问题，但是大批量（成百上千）的共享 GDI 对象持有在某个进程中，并随着运行持续增加，（当GDI对象达到和接近10000时）则一定会导致如同 GDI 对象泄露所产生的系统无法正常绘制的现象（例如弹出的菜单背景呈现黑色，标题栏等界面元素无法正常重绘等，这可能是由于系统无法成功创建新的 GDI 对象资源导致的）。

　　　　而 CreateIconFromResource 这个函数无法指定不用 Shared 方式创建图标，换句话说，这个API创建的图标一定是 Shared 方式的，即使你已经调用 FreeLibary 释放了相应的 Module，这些对象依然在你的进程中存在。因此当大批量的从大量 DLL 中加载图标时，就会产生GDI对象泄露的现象。

　　　　解决方法：

　　　　对这个问题的解决办法时，改用其他 API 函数创建图标，这里我使用的是 LoadImage 函数。这个函数的最后一个参数是一个 Flag，可以指定 LR_SHARED 标志，即相当于共享方式，适用于需要频繁加载的对象（不释放）。如果在代码中指定了 LR_SHARED ，则同样会产生 CreateIconFromResource 遇到的问题。

　　　　因此解决方法是，把 CreateIconFromResouce 函数换成 LoadImage，并一定不要使用 LR_SHARED 标志。

　　　　但在MSDN中指出，某些图标如果不用 Shared 方式加载，则不会加载成功。因此我在代码中先用非共享方式加载图像，如果失败，再尝试用一次共享方式。但测试发现，还没有发现这种比较特殊的只能用共享方式加载的图标。

其他事项：

　　　　有的资源中的图标不包含任何图像，因此不管用什么 API 和方法都无法导出，例如：

　　　　 c:\windows\system32\ieframe.dll 中 ID 为 101,104,108,109,114,115,117
　　　　c:\windows\system32\shdocvw.dll 中 ID 为 101,104,107,108,109,114,115,117

【补充3】关于程序标题栏图标的说明

一般程序在资源管理器中显示的静态图标，是位于其PE文件中的Icon。而程序运行起来以后，在标题栏以及任务栏按钮左侧也会有一个图标，这个即是运行时的图标，通常可以通过 SetIcon 设置这个图标，系统用这个图标绘制到标题栏上。因此，只要找到这些图标的位置，我们就可以修改标题栏和任务栏按钮上的图标。

但对有一种情况是例外的，即不是系统绘制的非客户区（NC）。例如，完全 DirectUI 的窗口，其整个窗口都是用户自己绘制的，这种窗口容易观察出来，因为这些窗口在外观上会体现的比较个性化，和系统中的统一外观有所不同。这样我们可能无法替换其“标题栏图标”，因为其可能是“伪标题栏”。用户自己绘制，当然不一定要使用一个 Icon。如果不是Icon，哪么我想很可能是使用了其他 Bitmap 图像资源，或者是从自带的一些图片文件在运行时加载的。因此这种情况下，即无法使用替换 Icon 的方式改变图标。（本质原因是因为非系统绘制）

系统标题栏的一个特征是：标题栏图标是一个点击区域，在标题栏图标上左键单击（或者在标题栏的非图标区域右键单击）会弹出系统菜单。

-- hoodlum1980 2011-8-22。

本文链接

[发布] 多选控件和时钟控件

2011-06-24T10:10:00Z

关键字：自定义控件（Custom Control)，C++，WIN32 SDK

本文发布的是我在工作中开发的自定义控件。第一个是多选控件，该控件主要启发来自于 ExplorerBar，即资源管理器左侧的 DirectDraw 部分，例如打开文件夹，位于左侧的那个可以扩展收缩的多面板组成的“文件夹任务”等。本控件的开发需求主要是用于在很多个Items中进行快速方便的选择和定位，因此我称它为多选控件。从外观上来看，它是由一些列面板从上到下的方式排列而成（我们把一个Group称为控件的一个Child，即第一层子结点的LineSize = 1），它和 Outlook 侧边栏的主要区别是，outlook侧栏是多个面板共享一个公用的较大客户区，即同一时刻通常仅可见一个面板（这一点类似TabControl），显然这个特征有时是我们需要的，但有时是我们不希望的。即 ExploerBar 和本控件则是多个面板同时可见的。比如说，TabPage上通常是按照功能分组归类到多个页面，这些页面彼此之间独立性较强，互相不依赖，因此在同一时刻只见到一个页面是比较符合用户意愿的。而我们要做的多选空间，他们都是本质上相同的，因此我希望随意组合式的多页面展示，这样可以给我们一个灵活又广阔的全局和局部视角组合，这种特点就是ExploreBar的特点。

因此总结下这个控件的诞生需求：是我们需要多选，多个面板保证灵活和快速定位的需求，即我们需要对Items进行一些分类并放入面板，可以任何折叠。使得提供灵活的视图。面板内部，由于Items的特征小而多，因此采用类似ListView的图标视图的做法，将他们从左到右进行布局。这样就可以比 TreeView 节省垂直方向的空间（因为Treeview每个节点都要占据一行），在这个控件里主要是各个元素之间都有边框，元素之间的间隔，边距等元素，这些元素显然会浪费一些空间。

本控件的组织架构是有顶层的代表窗口的一个类来管理的，下设Group集合。每个Group下面含有Items。每个Item为最基本单位，类似一个CheckBox。每个 Group 由Header和“客户区”组成。点击Header可以对其展开和折叠，同时左侧的按钮采用的是七帧图片得到旋转动画。截图如下所示：

另一个控件是时钟控件，该控件模仿的是 windows mobile 系统上的闹钟设置控件。主要用于设置时刻（例如闹钟），里面内置两个属性，Hour 和 minute，没有日期。因此这是它和 DateTimePicker 的主要区别。用户可以用鼠标拖动分针和时针，进行时刻的设置。时钟控件由于主要时为用户设置时间而提供，因此绘制上追求的原则是高效和对时间清楚的示意性，而不在于界面的美观和华丽，因此它在外观上显得“朴素”。控件内默认的分针拖动单位是5分钟（也可以设置为最小的 1 分钟分辨率，则拖动时的运动会更加平稳），指针捕捉误差缓冲为 3 分钟左右。

此两个控件都采用了内存绘制技术用于防止闪烁。

由于开发的比较紧急，因此尤其多选控件还缺乏足够的测试，可能有些接口方法还需要进一步改进，一些接口也有待于增加。具体用法由于精力所限，我就不在这里用代码做示范了，可以参考 Demo 项目的代码。在发行文件夹里有一个MulSelCtl.h 头文件，模仿windows sdk的做法我已经定义了一些对应的宏。因为时间原因，我还没有写出具体的说明文档。

最后增加一些技术总结：

（1）读写文本文件时，应该尽量避免使用unicode版本的函数（fgetws等），因为读写中文时可能乱码。因此本控件中先把 unicode 转换到ansi 再和文件进行交互。

（2）写文本文件时，应该把“\r\n"转换成单个”\n“，否则写入文本文件时，由于底层函数自作主张的翻译，会把\r\n写成\r\r\n。在文本框文本和文件之间交换数据时，这一点尤其需要注意。

（3）自定义控件要写成DLL被其他进程加载和使用，则ClassStyle中需要添加CS_GLOBAL样式，否则其他进程无法创建其实例。

（4）自定义控件由于可能被创建出多个实例，因此其窗口过程不能使用 Static 变量持有和窗口实例相关的内部数据（状态）。这一点和我们写普通窗口（主窗口，模态对话框）过程时不同，因为它们通常时进程范围内唯一的，因此可以使用 Static 变量持有窗口数据，这一点尤其要注意。正确做法时在注册窗口类时，告知系统为每个窗口保留其窗口数据额外空间的大小，在 WM_NCCREATE 时分配和填写数据。

Demo项目和控件发行包（*.h, *.lib, *.dll）的下载连接如下：

http://files.cnblogs.com/hoodlum1980/MulSelCtl.rar

本文链接

修改WM手机铃声大小的小程序

2011-03-09T11:10:00Z

我用的多普达S1手机，偶然发生手机的来电铃声忽然非常小的情况，在外面基本听不到电话。每次为了调整回来，都要baidu很久才能找到应该如何修改。为此，我就自己写了这个小程序，用于帮助我手工修改注册表的过程。这样我就不需要记住那个很难记住的注册表位置，设置起来也比用手机上的注册表编辑软件要方便的多。这个程序是用 VS2005 + WindowsMobile 6 SDK，C++语言开发的。它的本质非常简单，就是查询，修改注册表信息，因此这里就不贴代码了，使用C#也可以开发。

程序截图如下：

这个小程序的下载连接：

http://files.cnblogs.com/hoodlum1980/WMRingVol.rar

【参考资料：】

（1）网页《WM6.1注册表修改详细介绍，一定有你需要的，有增大铃声音量的方法哦》：

【备注：】

（1）本程序修改的注册表位置主要位于以下位置：

HKEY_CURRENT_USER\\ControlPanel\\SoundCategories\\

（2）我将其同时发布在PDAFANS论坛的地址是：

http://bbs.pdafans.com/thread-1046881-1-1.html

本文链接