——Nim取子问题变形后的解决方案

全文下载链接：海盗分金问题分析与解决.pdf

Author: Zealot Ke(kejie[at]kuxun.cn)
Date: 2010/7/30

背景

强哥邮件发出一个题目

1. 有5个海盗,特别的残忍,特别的聪明
2. 他们抢了100个金币,要进行分配,每个人都想分配足够多的金币,他们寸步不让.分配顺序是:5号海盗->4号海盗…1号海盗,即是:先由5号海盗决定如何分配,若分配不均,5号被扔下海,4号海盗再决定如何分配,依次类推.
3. 如果没有二分之一或以上的海盗同意,分配人将被其他人扔下大海.
4. 假如你是5号海盗,你会如何分配金币.确保自己不会被扔下大海,而且让其他4个海盗心服口服.

定义问题

5号海盗必须按照上述规则，找出最优分配方案，否则将被其他人扔下大海。

当前状态

正确分配方案还没出来，必须尽快找出最优解。

分析

典型的nim取子问题的变形，采用倒推方式即可找到最优解。

制定解决方案

倒推方法如下所示

1. 如果只有一个海盗，如何分配？
2. 如果有两个海盗，如何分配？
3. 如果有n个海盗，每个海盗至少需要几个人同意？找出n-1个海盗情况下的分配方案中，需要收买多少海盗？最低需要多少金币？

实现解决方案

倒推方法实现如下表所示，每一行表示一种人数情况下的分配方案，也即，最后一行给出5号海盗的分配方案。

分配方案倒推分析表

注意：从表中可以看出聪明是大前提，当然残忍也是。nim取子游戏向来是君子游戏，没有这个前提的话，后面的海盗不按套路出牌就不可能有最优解。

标准化解决方案

从上表不难看出规律，也即，自己拿尽可能多的金币，同时保证后面的人依次分配0、1交错的金币数。规范化命题如下
*命题: 假设对于n个聪明、残忍的海盗（n≥1），抢了Gold个金币，要进行分配，每个人都想分配足够多的金币，他们寸步不让。分配顺序是：n号海盗->n-1号海盗…1号海盗，即是：先由n号海盗决定如何分配，若分配不均，n号被扔下海，n-1号海盗再决定如何分配，依次类推。在该规则下，n号海盗最佳分配方案应当如此（为简单，避免使用地板函数，按n为奇偶数分类讨论）：
不妨假设ones为得到1个金币海盗数，zeros为得到0个金币的海盗数。

1. 当n为奇数时，ones=zeros=(n-1)/2，分配方案为Gold-ones,0,1…0,1
2. 当n为偶数时，ones=( n-2)/2,zeros=n/2，分配方案为Gold-ones,0,1…1,0

该命题从上述分析中的规律中得出，不是定理，更不是公理，作为标准化解决方案需要严格证明。

证明：
注释：使用跳跃数学归纳法证明，跳跃的step为2。
先证明n为奇数时命题是否成立。
当n=1时，显然该命题成立
假设当n=m(m>1)时命题成立，则分配方案为
Ones(m) = Zeros(m) = (m-1)/2
Proposal(m) = Gold-Ones(m),0,1,…,0,1
= Gold-(m-1)/2, 0, 1, …,0,1
当n=m+1时，显然命题成立，理由如下
Ones(m+1) = (m+1-2)/2=(m-1)/2，Zeros(m+1) = (m+1)/2
注意：a) m+1为偶数，计算ones和zeros需要换个公式b) 对比n=m情形，仅仅是多了个0。
Proposal(m+1) = Gold-Ones(m+1),0,1,…,0,1,0
= Gold-(m-1)/2, 0, 1, …,0,1,0
对比Ones(m),Ones(m+1),Zeros(m),Zeros(m+1)可以看出仅仅是在Proposal(m)序列后面添个0。这会导致Proposal(m+1)与Proposal(m)两个序列中，0、1交错序列刚好错位，对应金币分配方案中则为：m+1号海盗分配方案就是把Proposal(m)中没有得到金币的人每人给1个金币实现自己金币最大化，同时保证同意的人数大于等于2。
综上所述，当n为奇数时，该命题成立。
再证明n为偶数时命题是否成立。
当n=2时，命题成立（大于的最小偶数只能是2）
归纳方法同1。
综合1、2分析，该命题成立。
证毕。

该标准化解决方案用程序实现如下
说明：该程序考虑了金币数量远小于海盗数量时，最先出来分配的部分海盗都得喂鲨鱼去了。

$ cat nim.c
#include 

const int g_first = 2;
const int g_zero = 0;
const int g_one = 1;

int print_proposal(int *gold, int *pirate, int *ones, int *zeros, int *status) {
        int             ret = 1;
        int             number = 0;
        int             remain = *gold - *ones;
        if (*pirate <= 0) {
                printf(".\n");
                return 0;
        }
        if (remain <= 0) {
                number = 0;     /* not enough gold, killed by others, regenerate proposal */
                ret = 1;        /* conitnue */

                /* regenerate proposal */
                if (*pirate % 2 == 0) {
                        *ones = (*pirate - 2) / 2;
                        *zeros = *pirate / 2;
                } else {
                        *ones = *zeros = (*pirate - 1) / 2;
                }
        } else if (*status == g_one) {
                number = 1;
                *ones--;
                *status = g_zero;
        } else if (*status == g_zero) {
                number = 0;
                *zeros--;
                *status = g_one;
        } else {
                number = remain;
                *status = g_zero;
        }
        if (*status != g_first && *ones <= 0 && *zeros <= 0) {
                ret = 0;
        }

        printf("%d ", number);
        *pirate = *pirate - 1;

        return ret;
}

int main()
{
        int             gold;
        int             pirate;
        int             ones;
        int             zeros;
        int             temp;
        int             status;         /* process first, zero or one */
        printf("Please Enter gold and pirate number:\n");
        while (scanf("%d %d", &gold, &pirate) == 2) {
                if (pirate < 1 || gold < 1)
                        break;

                if (pirate % 2 == 0) {
                        ones = (pirate - 2) / 2;
                        zeros = pirate / 2;
                } else {
                        ones = zeros = (pirate - 1) / 2;
                }

                status = g_first;
                printf("Proposal(%d, %d) is: ", gold, pirate);
                temp = pirate;
                while (print_proposal(&gold, &temp, &ones, &zeros, &status))
                        ;
                if (pirate == 1)
                        printf(".\n");

                printf("\n");
                printf("Please Enter gold and pirate number:\n");
        }
        return 0;
}

程序运行结果如下所示

$ gcc nim.c -o nim
$ ./nim
Please Enter gold and pirate number:
100 1
Proposal(100, 1) is: 100 .

Please Enter gold and pirate number:
100 2
Proposal(100, 2) is: 100 0 .

Please Enter gold and pirate number:
100 3
Proposal(100, 3) is: 99 0 1 .

Please Enter gold and pirate number:
100 4
Proposal(100, 4) is: 99 0 1 0 .

Please Enter gold and pirate number:
100 5
Proposal(100, 5) is: 98 0 1 0 1 .

Please Enter gold and pirate number:
0


决定下一步

本问题到此为止，暂时没有下一步动作。

总结

这个结论告诉我们

1. 最先掌握分配权的人，看似最危险，胆小的人可能会担心所有人都不支持你，你就只能下海去喂鲨鱼了。其实，他优先掌握了主动权，天下武功，唯快不破，掌握市场先机很重要。
2. 越快越好，但不能快过了头。100个金币，1000个海盗的话，最先出来分配的人必然死掉。同样的，20年前搞酒店搜索，率先占据主动权，快得一塌糊涂那也没戏。

完。

这本书讲述的内容就像名称里说的那样，从程序员观点来研究和发掘计算机系统的架构和潜力，包括信息计算的基础理论，也包括大量硬件、体系结构、操作系统层的知识，并结合编程开发提供了相应的参考信息。是一本难得的好书。

从写作上来讲，这本书也非常不错。全书自底向上，从信息理论入手，逐步扩展到硬件、汇编、操作系统，网络编程，最后到应用软件层（以http server为例分析并发编程）。而开篇第一章就把整本书的脉络概括了，后面每一章都只不过是第一章每一小节的细化。因此，阅读起来全局把握上很轻松，而这也恰恰是非常关键的一点。

整本书非常厚，800多页，大而全，但终究是一本系统级的书，更深入的细节还是只有比较概念性的介绍。比如汇编程序，虚拟存储器管理，基于事件触发的并发网络编程等等。本书每一章都可以独立成书，深入分析。实际上，我们的大学四年中的教材基本上就是这样独立编排的。所以这本书可以算是一个系统性的参考，用于辅助在头脑中建立整机的意识。具体到某一个特定的领域，需要找更详细的资料阅读才能有更好的理解。

最后，书中的习题看上去非常不错，而且都有细致的答案供参考。受限于公交上阅读环境，没有仔细看这部分。以后可以研究研究。

不过限于书中知识点大而全，对cs专业的学生来说，更好的选择是大一买下来显摆，大二消遣，大三把玩，大四送给小师妹。不是这本书不够深入，只是我觉得相比四年的课程来讲，这本书中的内容在cs毕业生眼里是必须精通的，没必要放到毕业后再继续学习这些基础。现在看看这本书，我也只能后悔没早点买到。

哦，对了，书中开篇介绍了一些非常有意思的实验题，比正文有趣多了。

1. 下载
   Download the latest madwifi snapshot. // Google it

2. 解压
   $ tar zxvf madwifi-hal-0.10.5.6-current.tar.gz

3. 编译安装madwifi // 首先通过apt安装编译环境
   $ sudo aptitude install build-essential linux-headers-$(uname -r)
   $ make
   $ sudo make install

4. 安装module
   $ sudo modprobe ath_pci

5. 使网卡每次开机时都加载, make it load every time you boot
   $ sudo vi /etc/modules
   添加一行，如下
     ath_pci

6. 重新启动机器
   $ sudo reboot

注释 && 备忘
1. 为保证生效，重启前确认已屏蔽ath5k（默认驱动程序有可能是这个）
   检查是否已安装ath5k
   $ lsmod |grep ath5k
   有，则添加到blacklist
   $ cat /etc/modprobe.d/blacklist.conf
     blacklist ath5k
2. 确认安装驱动是否成功
   $ lsmod | grep ath_pci
     ath_pci               201176  0
     wlan                  193392  5 wlan_wep,wlan_scan_sta,ath_rate_sample,ath_pci
     ath_hal               300768  3 ath_rate_sample,ath_pci
3. 硬件型号查看
   $ lspci |grep Ethernet
     00:19.0 Ethernet controller: Intel Corporation 82566MM Gigabit Network Connection (rev 03)
     03:00.0 Ethernet controller: Atheros Communications Inc. AR242x 802.11abg Wireless PCI Express Adapter (rev 01)
4. ath5k是madwifi替代品，除非ath5k下无法连接无线，不建议使用madwifi

单件模式确保一个类只有一个实例，并提供一个全局的访问点。 –《Head First 设计模式》

有些时候，我们恰好需要这样一种设计，保证我们实例化的类在进程地址空间内只有一个实例，有了Singleton，一切似乎都简单明了，其实暗藏杀机。

1. C++实现Singleton模式简单示例

简单的C++实现示例代码

class Singleton {
    public:
        static Singleton* GetInstance(void) {
            if (Singleton::m_instance == NULL) {
                Singleton::m_instance = new Singleton();
            }
            return Singleton::m_instance;
        }
    private:
        static Singleton* m_instance;
        Singleton() {}
};

使用gtest测试，简单地测试一下每次调用GetInstance是否返回同一地址

#include 
#include 

#include 
using namespace std;
#define NEW_COUNT 4096

class Singleton {
    public:
        static Singleton* GetInstance(void) {
            if (Singleton::m_instance == NULL) {
                Singleton::m_instance = new Singleton();
            }
            return Singleton::m_instance;
        }
    private:
        static Singleton* m_instance;
        Singleton() {}
};

Singleton* Singleton::m_instance = NULL;

TEST(Singleton, sample) {
    Singleton* init_instance = Singleton::GetInstance();
    ASSERT_NE(init_instance, (Singleton*)NULL);

    Singleton* p = NULL;
    ASSERT_EQ(p, (Singleton*)NULL);

    for (int i = 0; i < NEW_COUNT; ++i) {
        p = Singleton::GetInstance();
        ASSERT_EQ(init_instance, p);
    }
}

int main(int argc, char **argv)
{
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

测试结果显示没有问题：
$ ./singleton
[==========] Running 1 test from 1 test case.
[----------] Global test environment set-up.
[----------] 1 test from Singleton
[ RUN ] Singleton.sample
[ OK ] Singleton.sample (1 ms)
[----------] 1 test from Singleton (1 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test case ran. (2 ms total)
[ PASSED ] 1 test.

当然，这种测试没有太大意义。给出测试结果，主要用于之后的对比。

2. python程序中调用Singleton模式的C++代码
初次接触Singleton后发现，使用Singleton模式的C++代码融合到python中有意想不到的惊喜：如果有某个类初始化需要很长时间，而之后调用的速度都很快的话，使用Singleton模式，然后在python中多次调用时，不会出现重复的初始化操作。
简单地尝试了一下

首先在singleton.cpp中添加了一行输出，标识一次初始化操作：

Singleton* Singleton::GetInstance(void) {
    if (Singleton::m_instance == NULL) {
        Singleton::m_instance = new Singleton();
        std::cout << "initialize here." << std::endl;
    }
    return Singleton::m_instance;
}

封装的代码如下
$ cat _pysingleton.cpp -n

#include 

#include "singleton.h"

using namespace std;

PyObject * GetInstance(PyObject *self, PyObject *args) {
    Singleton::GetInstance();
    return Py_BuildValue("s", NULL);
}

static PyMethodDef _pysingletonMethods[] = {
    {"GetInstance", GetInstance, METH_VARARGS, "get instance."},
    {NULL, NULL},
};

PyMODINIT_FUNC init_pysingleton(void) {
    PyObject * m;
    m = Py_InitModule("_pysingleton", _pysingletonMethods);
}

编译出来共享库_pysingleton.so
$ cat Makefile -n

CC                =       g++
FLAGS           =       -ggdb -O2 -Wall
INC               =       -I/usr/include/python2.5
LIB               =       -lgtest -lpython2.5
LLIB              =

%.o:%.cpp
        $(CC) $(FLAGS) $(INC) -c $<

_pysingleton.so: singleton.o _pysingleton.o
        $(CC) -shared $(CFLAGS) $(LLIB) $(INCLUDE) $^ -o $@

clean:
        rm -f *.so
        rm -f *.o
        rm -f *.pyc
        rm -f singleton

写个简单的python脚本测试一下在单一进程空间里，是否真的只调用一次
$ cat pysingleton.py -n

#!/usr/bin/env python
# -*- coding: utf-8 -*-

''' sample for pysingleton
'''

import os
import sys
import _pysingleton

class PySingleton:
    def __init__(self):
        _pysingleton.GetInstance()

def main():
    ''' main function
    '''
    for i in xrange(3):
        PySingleton()
    print 'Done'

if __name__ == '__main__':
    main()

结果是
$ ./pysingleton.py
initialize here.
Done

3. 多线程中使用Singleton模式
多线程里就会遇到一个double-check问题 (double-check-lock problem, DCLP)
首先，静态变量m_instance作用域是全局的，处于临界区，在多线程需要加锁。这一点很好理解。
但是，简单的在if外面加锁势必会影响性能，毕竟只有第一次调用才会生效，每次都有一次锁操作太费时，也没必要。
于是，就会有double-check方法了，伪代码为
if (Singleton::m_instance == NULL) // first check
lock
if (Singleton::m_instance == NULL) // second check
从这里可以看出，double-check有效地避免了重复锁操作问题。
然而，问题还没有结束。采用double-check的话，又会引入另一个问题。在这里
Singleton::m_instance = new Singleton();
编译器可能会做个优化，首先将一个有效的内存地址返回给m_instance，然后再调用构造函数初始化。这样很有下一次double-check中首次检查通过，但是得到的内存地址指向的是一个未经初始化的类。后果怎么样，只有天知道了。
更多细节，参考这里：http://www.ibm.com/developerworks/library/j-dcl.html

a. 最简单的修改方法是
Singleton* temp = new Singleton();
m_instance = temp;
但是一个自作聪明地编译器还是会把结果优化成难以想象的样子
b. 另一个方法就是使用volatile关键字，用以声明不受编译器优化的影响
比如 Singleton* volatile temp = new Singleton();
但是远远不够，temp是volatile，但是*temp呢，temp->foo,temp->bar...这些成员呢？所以，要改的话，得把全世界都改成volatile，除了那个lock-_-|||

4. 以上都只考虑单核，再考虑一下多核机器，问题将会更加复杂

总结：珍爱生命，远离Singleton。尤其是不要把Singleton放进通用库中，还有C++中那个叫template的高级玩意儿，都搞在一起老天都很难保证会发生些什么。

附
1. 这里也在讨论单例模式：Why Singletons Are Controversial
2. 代码托管到Google Code，欢迎围观、讨论、批评、挑bug：点此进入（http://code.google.com/p/zldemo/source/browse/#svn/trunk/blog/singleton_everything）
(墙内用户请不要使用https访问)
--EOF--

p.s. 从 DBA Notes偷来EOF，顿感清爽不少

把思考从媒体中夺取过来，反而使得我们更加客观。人云亦云，信息过载。面对大量信息的介入，我们也会思考，但会思考得很冲动，不知不觉主观上也会偏离正确的方向。冲动消费只会浪费金钱，冲动思考则会浪费智商。任何媒体，无论是电视、报纸还是网络，从来都不是客观的。大量吸收这些信息，而不加深入思考和判断，只会让我陷入别人的思维陷阱中。

媒介影响我们思想的一个典型例子就是”80后”这个词。从某个”阴谋家”创造”80后”这个词之后，太多的人受到了相关的误导。而作为”80后”的我们又会怎么看呢？其实每个人心里都会有些自己的看法。相比那些”阴谋家”眼中”80后”的弱智行为，堕落状态，”80前”又能好的到哪里去呢？文化大革命中摧残人性的某些人，应该是一大群人，相比”80后”，不会感到汗颜吗？历史永远在进步，有理由相信新一代人整体上是会超越前一代人的。同样，我们也应当相信今天”脑残”、”弱智”、”不思进取”的”90后”将会超越我们尴尬的”80后”一代。历史将会用时间来证明这一点。

回到主题，无论是”堕落的80后”，还是”脑残的90后”，都是被动接受的误导。客观的看待问题，不是一味的获取外界信息，更要有独立自主的思想。靠大量信息作为训练样本，基于统计方法得出结论，那是机器人。人，当有信仰，有独立的判断能力，而不受外界因素干扰。

所以，我决定：从今天起，努力做一个客观的人。

补充：

罗马不是一天建成的，习惯的改变需要不断的总结和改进，记录下来后经常反省和查看都是必须的。推荐Evernote软件，方便在便携设备上查看，同时也非常适合多平台间信息同步。比如”2009年个人总结“，我就同步到itouch上的evernote中，上厕所时就看看…

Search Everything是速度最快的文件搜索软件。百G盘几十万个文件，可以在几秒钟之内完成索引；文件名搜索瞬间呈现结果。支持中文，支持正则表达式，可以通过HTTP或FTP分享搜索结　　果。如果不满意Windows自带的搜索工具、Total Commander的搜索、Google 桌面搜索或搜索，如果正在使用或放弃了Locate32，都值得推荐这款体积小巧、免安装、免费、速度极快的文件搜索工具。

Search Everything 截图

最喜欢的几大特点

1. 体积小
2. 速度快
3. 支持正则匹配等复杂搜索条件
4. 实时更新（安装软件比较明显：能实时看到新增加的文件）
5. 支持远程部署(http/ftp等方式)

对我来说不算致命的几个限制

1. 仅支持NTFS格式的硬盘分区
2. 仅支持文件名搜索

在windows vista/win7中都会有受限于UAC，每次启动时都会弹出提示框。取消UAC自然不合适，Search Everything官网的FAQ已经给出了解决办法：Make Vista launch UAC restricted programs at startup with Task Scheduler。
基本思想是：把Search Everything配置到计划任务里，每次系统启动时自动打开Search Everything，最关键的一点是计划任务中可以设置“以最高权限运行”。
具体步骤可以参考上述网址，该网页中步骤极其详细，其实只有简单的几步而已。

我的配置如下

1. 创建计划任务
   

   第一步 创建任务

2. 简单设置计划任务名称等信息。关键是设置“以最高权限执行” 计划任务
   

   第二步 设置计划任务，关键是“以最高权限运行”

3. 创建触发器，选择系统启动时触发操作
   

   第三步 创建触发器

4. 设定操作：启动程序Search Everything
   

   第四步 设置操作

• 2010年1月，Blog迁移到Linode VPS上，彻底解决了古董机的mysql、apache、ip不稳定的问题：Blog使用美帝VPS：Linode服务介绍。
• 2009年8月15日，水木上淘到一个p3 CPU的古董机，100大洋(RMB)，并开始运行Blog

程序，ADSL环境。该古董配置：GenuineIntel Pentium III (Katmai) 501.159MHz/3个内存条共386M/8G硬盘。系统是Debian etch，linux 2.6.28。运行Blog服务使用的是apache2/php5/mysql5/wordpress2.8。

• 2006年3月，开始写Blog，貌似是在hitidea.org上: zealot.hitidea.org。该博客服务由Berg童鞋提供，并友情支持了域名绑定。

–
此文不间断更新中……

linode.com logo

突然购买Linode.com服务，直接原因是一时头脑发热。根本原因是ADSL里放Blog太不靠谱了，ip经常更换，因此，需要时不时的更新DNS解析（DNS重新解析不会立即生效，慢则需要好几个小时）。观察了一周，服务、速度、稳定性都非常不错。

换用Linode后Google Analytics中的change项终于变绿了：

Blog rate in Google Analytics

在家里ADSL环境下使用古董机就是这样浪费生命的

1. 话说以前Blog是架在这样一台100大洋(RMB)的古董机上：GenuineIntel Pentium III (Katmai) 501.159MHz/3个内存条共386M/8G硬盘/Ethernet controller: Realtek Semiconductor Co., Ltd. RTL-8139/8139C/8139C+/VGA compatible controller: Matrox Graphics, Inc. MGA G400/G450。系统是Debian etch，linux 2.6.28。
2. 运行Blog服务使用的是apache2/php5/mysql5/wordpress2.8，瓶颈在CPU上，一次请求apache占用CPU就超过60%。试探性使用nginx，这才发现需要配置factcgi，可耻地失败鸟。
3. Mysql平均每个月挂掉2次，好在每次mysql check/repair都顺利的修复了。即使没有mysql crash，备份也还是很必要的。第一次crash后我就加了简单的自动备份脚本，每天凌晨自动备份，最多保留9份拷贝。
4. 由于家里上网时ADSL，ip时常被更换，所以得记录ip，方便随时随地远程访问。在Google App Engine上起个服务记录访问ip，过滤掉公司的ip。家里的台式机上每隔一分钟访问一下这个ip。每次ip变换后就手动修改blog域名的dns解析。Dns解析开放api访问就好了。

鉴于上述种种不可饶恕的浪费时间行为，忍痛买了国外的vps。而且以后配置wordpress上twitter插件也很容易了。选Linode很偶然，上网看见@Fenng的Blog使用这个，应该不会太烂，价格也可以接受。这里也有一个推荐，介绍也很详细：http://www.blogkid.net/linode。

注册Linode非常简单，特别注意的是亚洲访问速度较快的data center是旧金山的Fremont ，不要选错了。不过即使错了，也不用担心，我就选错了。在support页面咨询了一下客服，一顿饭功夫人家就帮忙换了个data center，自己只需要按照说明点三个按钮：关机、迁移、重启。

Blog迁移异常顺利，不到1小时完成了所有工作。系统选用Debian 5.0，候选系统也超多。LAMP安装工具使用apt，参考这里：“How To Set Up A Ubuntu/Debian LAMP Server”。

使用国外vps，最大好处是配置twiter插件，搭建某推的api都非常容易。以前用自己的台式机时，每次都想方设法修改代码，强制使用tor代理，而且速度贼慢。

现在空间、带宽冗余很多，有空整点好玩的东西，呵呵。
AD：需要注册的话，可以点这个推广的refer链接：http://www.linode.com/?r=2e236898b83cd7963f1cb6136e7b00cb9f13d1d8，按照说明应该会给我返利。

Btw：最后跑题说另一个使用虚拟化服务的case，twitter架构中考虑突发事件带来的访问洪峰问题时，购买了云计算服务。好处是避免了自行购买的设备长期闲置，导致浪费。Linode同样可以按需购买相应服务，升降级都很方便。

补充：使用的Linode 360配置如下

• RAM: 360MB
• Storage: 16GB
• Transfer: 220GB

对比过去
踏踏实实做事真的很难，也是很多年轻人被抱怨的一个很大因素，而我更是如此。摒弃浮躁，踏实做事，该来的总会来。

2009年发生了什么
重新提起对数学和英语的兴趣，并开始系统的学习。除此之外，发现了很多问题，并独立思考解决方案。当然，方案和想法不是想出来，更多是在学习中去挖掘。过去一年中从各种途径获取了推荐的非常不错的书籍以及其他信息，并从中学习到很多知识，关于软件项目、个人管理、编程技能……
关于工作，2009年公司被收购，总体来说一切都在往好的方向发展，准确来说是转变。努力尝试从一个旁观者姿态来看的话，发现一路过来跌宕起伏，一次次的转变都静悄悄地降临在自己身上，乍一看不可思议，却也非常自然去走过来，感觉很奇妙。
关于感情，过去一年和亲友交流少了些。有些东西一旦放松就有可能逐渐远去，真的在乎就不能回避，甚至忽视。不过，上半年被QQ、MSN、GTalk、校内等社交网络中无关信息打扰地太严重了，2010年得认真解决这个问题。感谢那些却始终惦记着我的人。
2009也是一个令人失望的一年，眼睁睁看着这个国家的文明一次次倒退，却无能为力。能做的只是顺着众网民的大流：微动力，广天下。

2009年最兴奋的事
看见好书，立马上网下订单，而不用像上学时那样苦苦纠结。不过，现在书累计重量接近我的小冰箱了，下次搬家将会很郁闷。

2010年目标
1. 学习和提高
a) 数学和英语，这两个都是基础，目前已经开始实施，按部就班，按需微调，暂时不需目标来指导。尽量做到平均每周能有4天中独立出一段有价值的时间来学习数学和英语。
b) 编程经验，感觉过去一年看了太多的书，写的代码相对来说却不够。不过，按照提交的工作计划，2010年将会极大改善，我个人很期待。当然，09年积累下来的知识，包括个人管理经验，以及对软件项目认识的加深等，将会非常有益于将来的工作安排，不至于总是被计划外的事情和意外折腾地措手不及。
c) 调整好作息，善待自己。今年对厨艺稍微研究了一阵子，已经能自己带饭上班了。在这个只有母乳相对来说比较安全的国家，安全饮食根本不现实，只希望自己能尽力做到最好吧，没有什么比健康更重要了。
2. 改进和突破点
a) 多与亲友交流。除了编程，还有很多事情能让生活变得有趣，不要让任何一个理由抢占了分享的乐趣。
b) 多锻炼，小区跑步的人不少，天气好些时，可以尝试开始锻炼，并养成1个习惯用于健身（骑自行车上班不算）。
c) 至少参加1次公益活动，内容不限。
d) 至少养成1个好习惯，除之前提及的不算，内容不限，可以是工作管理、作息规范、锻炼等。
3. 重复一点：善于休息。
一句话感想：有啥也别有病，没啥也别没精神。

p.s. 2010怎么发音

How Are We Going To Say “2010″

图片来自：http://tc50tweets.techcrunch.com/story/396885318/how-are-we-going-to-say-%E2%80%9C2010%E2%80%B3-a-website-comes-just-in-the-nick-of-time

outlook 2007

本文主要针对outlook，不是因为outlook多么强大，而是很多公司考虑到保密问题都会自己建立邮件服务器。并且，公司内沟通经常使用约会、会议邀请等功能，也只有采用outlook那一大坨东西。
Outlook最大的麻烦就一个字：慢。用过outlook的人都应该有所体会。想要改善outlook速度只有一个办法：删掉所有的邮件。真的，删掉，全部删掉。一年前看到outlook数据文件达到400多兆时，我就毫不犹豫的选择了这个方法。后来，删掉这些邮件确实没有什么不好的影响。
日常管理时，尽量做到每收一封邮件就删掉。即使保留部分邮件，也应该控制保存时间尽量不要超过一周。
删掉后那些信息上哪找去？每一封邮件都有不同信息，需要放到不同地方，但绝对不应该原封不动地躺在收件箱里。
1）    通知公告类，看完就删
2）    垃圾邮件，删除
3）    需要确认某项操作的，回复，删除。
4）    报警、出错信息，加入todo，删除。
5）    有任务分配的邮件，加入todo，删除。
6）    邮件内容超长，标记未读，有时间再看；看完后，删除。（更好的方案是，转存到手机上，然后删除。我用的是evernote，直接集成到outlook中，不到1秒钟就可以完成转存工作）
7）    有重要信息，比如合作方联系方式（多在签名档中）。存到wiki，然后删除。这样做好处很多，首先，累积的邮件会使outlook变得极其臃肿，速度会大幅下降；其次，wiki很方便地与同事共享；最后，也是最重要一点，你离职的话需多久时间整理这些信息？事实上，离职后都会忘了处理这些信息。我就经历过这种痛苦，接手某项工作后，很多一部分精力都在查找各合作方的联系方式、以及相关的合作文档。
8）    其他，尽量删除吧。
关于存档，用outlook管理的话不推荐使用存档，存档会让你的outlook慢如蜗牛。我采用的方法是，笔记本上处理完邮件后立即删除。在公司的台式机上接受所有邮件，但不做任何处理，必要时会查询。事实上，基本上一个月也很难查1、2次。（只有一台电脑的话可以再启用另一个简单、便于查询的邮件工具来备份所有邮件，比如foxmail）

参考资料：
1）    这本书中有专门章节来讨论邮件处理技巧：《时间管理—给系统管理员》，http://www.douban.com/subject/2253513/。
2）    Zenhabits也有专门的讨论，可以参考，基本上思想差不多：http://zenhabits.net/2007/01/email-zen-clear-out-your-inbox/

1) Don’t check email first thing in the morning, or have it constantly on. This is a tip offered by many blogs, so nothing new here. Checking email first thing will get you stuck in email for awhile. Instead, do your most important thing for the day, or the thing you’ve been procrastinating on the most. Then check email. Better yet, do 2 or 3 things first. Also, if you are constantly checking email throughout the day, or it notifies you as soon as an email comes in, you will be constantly distracted and not able to focus on the task before you. I check once an hour, but you might have different needs.
2) When you check your email, dispose of each one, one at a time, right away. Make a decision on what needs to be done on each email.
2a) Is it junk or some forwarded email? Trash it immediately.
2b) Is it a long email that you just need to read for information? File it in a Read folder (or tag it Read and archive) or print it to read on the road (while waiting in line, for example).
2c) If the email requires action, make a note of the action on your to-do or GTD lists to do later. Also note to check the email for info if necessary. Then archive the email. You can easily find it later when you need to do that task.
2d) If you can respond to it in a minute or two, do so immediately. Don’t put it off. If you wait, you’ll end up with a backlog of emails to respond to, and you may never get around to it. I respond quickly, with a short note, and send it right away. That way I’m viewed as responsive and on top of things.
2e) If you need to follow up on the email later, or are waiting for a response, note it on a Waiting For list. Don’t just leave it in your inbox as a reminder.
3) I have only one folder: Archive. When I respond to an email, or finish reading it if it doesn’t need response, or note it on my to-do list, I archive it. Simple as that. You could add a Read folder if you want. I usually print longer ones to read later, like during lunch or while waiting for something. Other people have an Action folder or a Waiting For folder, but I find that that’s just an additional inbox (or “bucket” as GTD’s David Allen calls it) that you have to constantly check. I don’t like to check extra folders. I have my to-do lists and my Waiting For list, and that’s good enough. So it’s as simple as pressing “Archive” on an email, and if I need to find it later, Gmail’s search is so good that it’s easy to find. I’ve never had any problems with this system.
Email Zen is that easy: check email at regular periods, take action on each email right away (or note it on a list to do later) and archive.