问题描述：现在有非常大量的一堆对象，比如有几十亿甚至上百亿个。对象本身是什么可以忽略，每个对象都有唯一标识符和一个正整数属性值，属性值范围有限（不大于一亿）。在单核机器上，内存和磁盘空间充足，用什么方法可以最快地输出属性值最小的若干（如一万）个对象，要求输出结果按照属性值排序。

先说个题外话。前几天面试的时候，问了一个用栈模拟队列的题目，被candidate反问：这种问题在工作中会遇到么？有用么？

这个问题其实很好，值得我仔细思考。大体上来讲，我在面试的时候可能会这么几类问题（聊项目经验之类的除外）：

1. 某个编程语言的基础知识，如果candidate自称熟悉某语言；
2. 常见的数据结构，用来大概了解candidate的基本功；
3. 基本的编程题目，考察他的写代码能力；
4. 数学或算法问题，一方面了解candidate的基本功，另一方面看看他的思维能力和解决问题的能力；
5. 一些从实际工作中抽象出来的，相对而言比较开放的题目，主要是看他分析问题和解决问题的能力。

今天这个题目是我最近比较喜欢的一个问题，是曾经在工作中遇到过的。

先来看看题目中出现的数字带来什么信息。

• 对象的个数（设为n），十亿甚至百亿：也就是10^9到10^10这样的量级，已经接近甚至超过32位整数的范围。即使每个对象只占用1字节，总共也需要1G到10G的空间。
• 对象属性值的范围，正整数，一亿：相对于个数，属性值的范围还是相当有限的，最多有100M个各不相同的值，可以用32位整数表示。
• 要求选取的对象个数（设为m），一万左右：相对于个数来说是非常非常小的。

可见，单单保存所有的属性值也需要4G到40G的空间。标识符最少也得用64位整数表示，又需要8G到80G的空间。

在这种特殊的要求下，怎么处理是最高效的呢？来看看以下的几种方法。

方法一：快速选择/线性选择算法

快速选择和线性选择算法都是平均时间复杂度O(n)的选择算法，当然线性选择算法在最坏情况下也能保证O(n)时间，缺点是实现起来比较复杂。简单起见，我就用快速选择算法。

快速选择算法类似于快速排序，用一个轴值将数组分成两部分，一部分全都比轴值小，而另一部分全都比轴值大。然后看看两部分分别包含多少个元素，从而确定第m大的元素应该再哪一半，然后对那一半递归处理，直到找到第m大的元素。

但是将快速选择算法应用到本题时，遇到主要问题是内存恐怕不够。

如果在内存中放入所有的对象，我们需要12G到120G内存，取决于对象的个数是十亿还是一百亿。进入内存后，还需要至少两次遍历才可以找到第m大的元素。另外加载数据时需要有一次完整的文件遍历。

如果内存中无法放入所有的对象，那就比较麻烦了，在头几次二分递归的时候可能需要动用硬盘来缓存数据，磁盘IO将成为可怕的瓶颈。累加起来相当于至少两次全文件的读遍历和写遍历。实际上，在确定了第m大的对象后，可能还需要遍历一次整个文件，找出比它小的对象。

方法二：堆排序算法

堆排序也是一个很好的可以用于部分排序的算法，C++ STL就用堆排序来实现partial_sort。

在内存中维护一个大小为m的最大值堆（没错，是最大值堆），遍历整个文件，每拿到一个对象，拿它与堆顶的属性值比较一下，如果新对象的属性值大就直接丢弃，否则用它取代堆顶元素。平均来讲，这样处理的时间复杂度是n * log m。

方法三：哈希算法

我们注意到，虽然对象的个数非常大，但属性值的范围非常小（相对来讲）。如果在值域范围上建立一个哈希表，只需要100M个格子，如果一个格子存储一个32位整数，只需要400M内存。

哈希表总是会有冲突的，在这个问题中，冲突是必然的，平均每个属性值上会有10到100个不同的对象。但处理冲突的办法非常简单，因为我们不需要在哈希表中记录每个对象，只需要记录这个属性值对应的对象的个数。

开辟一个能存放100M个32位整数的数组（为保险起见，可以用64位整数，但总共也只需要800M内存），数组的下标对应于属性值（实际操作中可能要减一）。然后遍历整个文件，每拿到一个对象，将对应的数组元素值加一。

文件遍历完后，过一下这个数组，可以找出第m大的对象的属性值，这个值就是一个边界。然后再遍历一次原始文件，把属性值小于等于边界的对象都放到内存中（注意在相等时，会有个数的限制）。最后把内存中的m个对象按照属性值排一下序再输出即可。

这样最多只需要遍历两次文件，使用O(n)时间就可以完成题目的要求。

到底哪个方法快？

上面提到了三种算法，到底哪一个最快呢？说说你的看法吧？

我以前一直觉得哈希法是最快的，它对内存的需求量适中，算法是线性时间。但后来又仔细想了想，觉得不太对。这里实际上不完全是内存中的运算了，瓶颈主要是在磁盘IO上。

让我们来比较一下三种算法：

1. 快速选择算法（所有对象可以全进内存）：只需要一次文件读遍历，内存操作是O(n)时间（系数至少为2，可能会很大）。
2. 快速选择算法（只有部分对象可进内存）：平均需要三次文件读遍历，两次写遍历，内存操作是O(n)时间（系数至少为2，可能会很大）。
3. 堆排序算法：需要一次文件读遍历，内存操作是O(n * log m)时间，这里m取10000的话，大概是13。当然实际数值会少于13，因为并不是每个对象都需要进入堆中。
4. 哈希算法（所有对象可以全进内存）：需要一次文件读遍历，在内存中要开辟大小为O(n)和O(m)的两块缓冲区，内存操作时间为O(n)（系数大约为2）。
5. 哈希算法（只有部分对象可进内存）：需要两次文件读遍历，内存操作是O(n)时间（系数小于2）。

题目的本意就是几乎不可能让所有对象都进入内存。虽然堆排序的内存操作时间复杂度偏高，却只需要一次磁盘遍历操作，其消耗的时间应该要小于哈希算法的。你是否同意呢？

最近做了个实验，生成了十亿个对象，每个对象有一个64位整数作为标识符，还有一个不超过一亿的随机整数作为属性值。生成的文件用文本格式存储，占用18G磁盘空间。我没有实验快速选择算法，只是比较了堆排序和哈希。实验结果是：

• 单纯遍历一次文件，包括逐行读取，把属性值解析成整数：耗时34分钟；
• 堆排序算法：耗时40分钟；
• 哈希算法：耗时73分钟。

这三个时间的相对值是否在你的预料之中呢？

当然，如果把硬盘换成SSD恐怕结果又完全不同了，有兴趣的童鞋可以试一试。

最近工作忙，没时间思考复杂的问题了。正好要招人就得有面试的嘛，自己也温习一下，要不然怎么去问别人。

今天复习一下二叉树的遍历，前序（pre-order，NLR）、中序（in-order，LNR）、后序（post-order，LRN）、层序（level-order），用和不用递归。

概念就不用多解释了，前、中、后是指根结点的访问时机，在左、右子树之前、中间、或之后。层序就是从根结点开始从上至下、从左到右地依次访问。

一棵二叉树

如上图所示的一棵二叉树，对应的遍历结果分别是：

• 前序（NLR）：A B D C E G H F I
• 中序（LNR）：D B A G E H C F I
• 后序（LRN）：D B G H E I F C A
• 层序：A B C D E F G H I

一、用递归处理二叉树的前序、中序和后序遍历

递归真是一个迷人东西，它可以把复杂的逻辑变得异常简洁，这也是自然界的表现形式之一。基于递归的前、中、后序遍历二叉树的程序几乎完全相同，用两个递归调用分别处理左、右子树，剩下的事情就是打印根结点。为节省篇幅，直接把三个程序写在一起，用一个参数来控制是哪种遍历方式，也可以更方便地看出三者之间的区别。

1
2
3
4
5
6
7
def VisitTree_Recursive(root, order):

  if root:

    if order == 'NLR': print(root.data)

    VisitTree_Recursive(root.left, order)

    if order == 'LNR': print(root.data)

    VisitTree_Recursive(root.right, order)

    if order == 'LRN': print(root.data)

二、非递归的前序、中序遍历

如果不用递归呢？实际上我们要做的就是自己维护一个栈（数据结构）来保存需要但尚未来得及处理的数据。

前序和中序都是非常简单的，当遇到一个非空的根结点时，打印其数据（如果是前序遍历），并将其压栈，然后递归地（这里用循环来模拟递归）处理其左子结点；当没有左子结点时，从栈中弹出之前遇到的某个根结点（它没有做子结点，或者左子结点已经处理完毕，需要再处理右子结点），打印数据（如果是中序遍历），然后继续处理右子结点。同样地，把两种遍历方式写在一起以便比较。

1
2
3
4
5
6
7
8
9
10
11
def VisitTree(root, order):

  s = []

  while root or s:

    if root:

      if order == 'NLR': print(root.data)

      s.append(root)

      root = root.left

    else:

      root = s.pop()

      if order == 'LNR': print(root.data)

      root = root.right

三、非递归的后序遍历

后序遍历要稍微复杂一点点，在前序和中序遍历的程序中，当我们准备进入根结点的右子树时，根结点就被扔出栈外了。但在后序遍历时，我们仍需保留它，直到右子树处理完毕。

首先想到的改动就是在上面的程序的第9行到11行，不要从栈s中将根结点弹出，而是直接开始处理右子结点。但这就会带来一个问题：什么时候弹出根结点？实际上当左子树遍历完成、或者右子树遍历完成时，我们都会在栈里看到根结点，为了区分这两种状态，添加一个临时变量记录前一次访问的结点，如果前一个结点是根结点的右子树，就说明左右子树全都遍历完成了。非常简单。

1
2
3
4
5
6
7
8
9
10
11
12
13
def VisitTreeLRN(root):

  s = []

  pre = None

  while root or s:

    if root:

      s.append(root)

      root = root.left

    elif s[-1].right != pre:

      root = s[-1].right

      pre = None

    else:

      pre = s.pop()

      print(pre.data)

四、非递归的层序遍历

层序遍历可以写成递归吗？还真没研究过。非递归的时候，层序遍历使用的是队列，而非栈。

处理过程非常简明，遇到一个结点，打印信息，然后依次将左、右子结点加入队列等待后续处理。

1
2
3
4
5
6
7
8
9
10
from collections import deque



def VisitTree_LevelOrder(root):

  if not root: return

  q = deque([root])

  while q:

    root = q.popleft()

    print(root.data)

    if root.left: q.append(root.left)

    if root.right: q.append(root.right)

附录

上面的python代码基于v2.7。另外可以用下面这段代码来定义最简单的二叉树结点类，生成最上面图示的二叉树：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Node:

  def __init__(self, data, left = None, right = None):

    self.data = data

    self.left = left

    self.right = right



g = Node('G')

h = Node('H')

e = Node('E', g, h)

i = Node('I')

f = Node('F', None, i)

c = Node('C', e, f)

d = Node('D')

b = Node('B', d)

a = Node('A', b, c)

root = a

1. 求二叉树中两结点的最小公共祖先
2. 在循环有序数组中查找指定元素

还记得在Windows下用MFC或WTL写用户界面程序的时候，为了给可改变大小的对话框加上背景图案，需要对设计师提供的图片进行裁剪。把图片切成九块，其中四个角是不拉伸的，四条棱边可以在一个方向上拉伸，中间区域则可任意拉伸。其过程是相当烦琐的。在Mac下，一切都变的及其简单，UIImage类已经为我们提供了处理拉伸的方法。

以下内容适用于iOS 2.0+，或在iOS 5.0+中使用替换的方法。

UIImage有一个叫做端帽（end cap）的概念，利用它来指定图片中哪一部分（通常在图片的中央）是可以拉伸的，哪些部分（四周一圈）不可拉伸。在iOS 5.0以前，通过stretchableImageWithLeftCapWidth:topCapHeight:来得到可以按照指定方式拉伸的图片。特别要注意的一点，我在第一次用它的时候没有注意到，就是这个方法并不会改变当前的UIImage实例，而是会返回一个新的实例。这样的设计可能是为了让通过imageNamed方法得到的UIImage实例能够最大限度地复用吧。

stretchableImage方法有两个整数参数，分别用来指定图片的左边和上边分别有多少点（points）是不能被拉伸的（端帽宽度）。并没有参数用来指定右边和下边的端帽宽度，开始我误以为右边和下边的端帽宽度就分别等于左边和上边的端帽宽度，然而仔细阅读官方文档之后发现并非如此：

The middle (stretchable) portion is assumed to be 1 pixel wide. The right end cap is therefore computed by adding the size of the left end cap and the middle portion together and then subtracting that value from the width of the image:

rightCapWidth = image.size.width - (image.leftCapWidth + 1);

The middle (stretchable) portion is assumed to be 1 pixel wide. The bottom end cap is therefore computed by adding the size of the top end cap and the middle portion together and then subtracting that value from the height of the image:

bottomCapHeight = image.size.height - (image.topCapHeight + 1);

原来已经规定了中间可拉伸区域必须是1x1的，因此右边和下边的端帽宽度就由图片的宽度和高度、左边和上边的端帽宽度决定。在设计非对称图案时需要注意一下。

从iOS 5.0开始，stretchableImage方法被弃用，取而代之的是resizableImageWithCapInsets:。后者只需要一个UIEdgeInsets类型的参数，通过此参数，可以设置四个端帽的宽度。而中心剩余的部分都是可以拉伸的（不再局限于1x1大小）。

下面这个程序片段给试图添加了三个UIImageView，分别显示原始大小的图片、无端帽拉伸之后的图片、和指定了正确的端帽宽度（用stretchableImage）后拉伸的图片。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
- (void)viewDidLoad

{

  [super viewDidLoad];

  // Do any additional setup after loading the view, typically from a nib.

  

  UIImage* image = [UIImage imageNamed:@"circle.png"];

  UIImage* stretchableImage = [image stretchableImageWithLeftCapWidth:10
                                                         topCapHeight:10];
  

  UIImageView* imageView1 = [[[UIImageView alloc] initWithImage:image]

                             autorelease];

  imageView1.center = CGPointMake(20, 20);

  [self.view addSubview:imageView1];

  

  UIImageView* imageView2 = [[[UIImageView alloc] initWithImage:image]

                             autorelease];

  imageView2.frame = CGRectMake(0, 0, 260, 200);

  imageView2.center = CGPointMake(160, 120);

  [self.view addSubview:imageView2];

  

  UIImageView* imageView3 = [[[UIImageView alloc]

                              initWithImage:stretchableImage]

                             autorelease];

  imageView3.frame = CGRectMake(0, 0, 260, 200);

  imageView3.center = CGPointMake(160, 340);

  [self.view addSubview:imageView3];

}

运行后效果如下图示：

UIImage拉伸示意（左上角：原始图片；上：直接拉伸；下：按照端帽拉伸）

1. iPhone开发：自定义控件RangeSlider（范围滑动条）
2. iPhone开发：隐藏系统状态栏
3. iPhone开发：在UIAlertView中显示进度条

前几天在写app的最后阶段要进行本地化（localization），其中要做的一件事就是创建语言文件（Localizable.strings）。要在控制台运行genstrings命令来扫描源代码中NSLocalizedString宏所使用到的文字。由于使用的是黑苹果（安装过程参见这里和这里），在运行genstrings时遇到了“Unable to Determine UUID”的错误，解决方法倒也容易。

运行genstrings的语句是：

genstrings ./Classes/*.m

得到了这样的错误信息：

genstrings[3851:10b] _CFGetHostUUIDString: unable to determine UUID for host. Error: 35

虽然想不通这么个小程序为什么需要UUID，但解决方法是：进入目录/Library/Preferences/SystemConfiguration，用root权限修改其中的NetworkInterfaces.plist文件，在控制台的操作命令为：

cd /Library/Preferences/SystemConfiguration

sudo vi NetworkInterfaces.plist

给这个文件中添加一个IEEE80211相关的dict（原本会有其他一些dict，不用管它们），内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<dict>

  <key>BSD Name</key>

  <string>en3</string>

  <key>IOBuiltin</key>

  <false/>

  <key>IOInterfaceType</key>

  <integer>6</integer>

  <key>IOInterfaceUnit</key>

  <integer>3</integer>

  <key>IOLocation</key>

  <string></string>

  <key>IOMACAddress</key>

  <data>ABbPoF5V</data>

  <key>IOPathMatch</key>

  <string>IOService:/AppleACPIPlatformExpert/PCI0@0/AppleACPIPCI/P0P3@1C,2/IOPCI2PCIBridge/pci14e4,4311@0/AirPort_Brcm43xx/IO80211Interface</string>

  <key>SCNetworkInterfaceType</key>

  <string>IEEE80211</string>

</dict>

添加好后保存此文件，然后重启系统。问题就解决了。

1. Dell E6400安装MacOS雪豹10.6
2. C++中的常量指针和指针常量

Chromatron，翻译过来是彩色显像管。顾名思义，这个游戏是关于光线反射的。在网络中还流传着很多这个游戏的Flash版，都是山寨的，抄袭了这个游戏的关卡和操作方式。

这是个相当古老的游戏了，好多年前就玩了它的第一代和第二代，后来又陆续玩了第三代和第四代。第三代有几关是前些日子才玩出来的，整理一下留作纪念。

游戏的官方网站是：http://silverspaceship.com/chromatron/，可以下载到Chromatron第一代到第四代的最新版本，Windows系统和Mac OS都支持哦。

我这里也提供Windows版的下载：

1. Chromatron 1代 v1.14
2. Chromatron 2代 v1.5
3. Chromatron 3代 v1.1
4. Chromatron 4代 v1.0

这个游戏中除了反射镜、三棱镜等传统光学元件外，还有一些现实中不一定存在的非常神奇的元件，比如多普勒仪（Doppler），如果红色光线从一端射入，另一端就会射出绿色光线，类似地，绿色光线会变成蓝色，而蓝色会变成红色。如果反过来使用，颜色的变化也反之。再比如量子纠缠分光器（Quantum Tangler），它将输入的光线变成两条向相反方向射出的光线，并且这两条光线是量子纠缠的，其中一条光线被多普勒仪改变颜色时，另外那条光线就会变为相反的颜色。又如可移动的光线传送器（Mobile Teleporter），成对使用时，可以将其中一个接收到的光线传送到另一个。还有逻辑门（Logic Gate）、互补器（Complementor）等等。所有的元件如下图示。

Chromatron中的各种光学元件

别的关卡都可以不谈，但有一关是一定要说一下的，这一关太有趣了。虽然它也有传统的解法，但其中有一种解法却非常神奇。见下图：

Chromatron 2代49关：反馈消除

注意到那几个没有光线经过的反射镜了吗？看起来它们摆在那儿是多余的，但一旦移动它们，你就输了。游戏中对这一关的说明是：

If the complementor is presented with a logical impossibility, it shuts down in all directions.

想亲自尝试一下？赶紧通过上面的链接下载下来玩吧。

最后放上我的各关解法，需要的可以参考之。用的时候，找到你要解决的关卡（比如3代第9关），复制对应的解法代码（如3-09-nIIAnqNtOvNPtNsJOx），注意复制的时候要包括开头的3-09-，而代码首尾都不要包含任何其他字符（如空格、回车等）。在游戏中进入此关卡，按Ctrl-V即可。如果你要向别人分享你的解法，就可以在游戏中进入关卡，按Ctrl-C，然后在任何文本编辑器中按Ctrl-V粘贴。

1-01-hI

1-02-hXioDr

1-03-nJtNcl

1-04-rODFCJ

1-05-ibOmsU

1-06-hvhThWhs

1-07-ortYCq

1-08-iUczmB

1-09-HHmrpfHjyZmP

1-10-ilCSNZbNCAbWIZOADOaDcxyTiDtKoqjjzKuBpk

1-11-oEcQOyyq

1-12-DathEiOn

1-13-JpNKxtbLHniczJJDyx

1-14-sasWOjsRIkdcbG

1-15-HWoItJhNHAcgJCIthCsB

1-16-ntbgIJINrisKnxNjnbcM

1-17-JfIvCKmTchcNINNKsCEhioOB

1-18-NjcAtyiFCddq

1-19-CZOOrZ

1-20-dmClHANHySoeawIg

1-21-ObsunsMFxA

1-22-caiVoeaOKeFpbKDebE

1-23-cnHFIjynclHbcpoDypnZphOyOi

1-24-bJNtmNHrOyCouoPumRrK

1-25-hBDIoWdKoeHOQKEP

1-26-hZDPcznv

1-27-MHjPuzGUAcIVph

1-28-uKjOMVQrzPaxavco

1-29-mUbqlGoAyYyUImocxicl

1-30-onJDnZHbye

1-31-bZHrovbphiNg

1-32-BMjktMJdzzCsOS

1-33-OBDzOnsYsHOEysevDknZtNiRLodrikeG

1-34-cpbfCqOBgz

1-35-azBKzwCWaqIIDCiSFuAnHl

1-36-Fpcnyajzgz

1-37-xlhKdbDA

1-38-hZsKPYOEtVDLNywTMADx

1-39-hxEbOVuljjNjoSCbDNfVxggVxKosnIPjczxryFgO

1-40-ernOODhZ

1-41-IDtyxV

1-42-tHBTgBOBiNjQiLFpgxOv

1-43-HboDmHGXxJdhoHwBOe

1-44-gMgqCeOMDMtYulMVdCyT

1-45-EwbauFwHilxwhgdepkdaNd

1-46-hNCIbwNzIRHTnytMjQhu

1-47-coBvxonWDnbUfVaoOLaSuzKuFpympo

1-48-sUjtcnzJuEsYNY

1-49-DwMGMKrsgEBHhNtGdtdnng

1-50-CbNiHScQhwxKoEzwDVCZhTwJxM

2-01-BRgqgZhjqZ

2-02-mDGXzupcMGJagFoXNowP

2-03-coOEOBOy

2-04-OIBOixHtovzwIjqTJnFd

2-05-NYCrtYIJnrxw

2-06-tGiPDLccFMes

2-07-hLIyng

2-08-hLIyni

2-09-hxCbMFFMtIBMhs

2-10-QurbNejIBwuxwm

2-11-MRxubKyCirupoUHo

2-12-DAyiOD

2-13-izoVhgCUNgyKHTDOuCbD

2-14-cnoDMP

2-15-MAOCimBv

2-16-NUrUopHNDOgOOezxoP

2-17-bZCGxNxUgiINLl

2-18-hLHUIjci

2-19-oRynHThKOmyTPG

2-20-nwrMySNXbuOl

2-21-hbhfifirjrfP

2-22-cmhCHUxIpiootwHHjQIIgSMNjvihsP

2-23-tJjcIwygDBsBhH

2-24-CGimHIxONJ

2-25-skMzBEMHwPgycXBwhzPkEpOlIOEtzRjzpe

2-26-twPYiBnmHGzvMGnh

2-27-tvNLCHoGxkye

2-28-sDytMHwluzGVebpnHhgcpbbRFi

2-29-clckDDcj

2-30-nkgDIgbpmqDzclaXJRcYPuocdtdU

2-31-sJxihFELtJNxiTfV

2-32-wRHnNNjliUsEIhnbdxNU

2-33-szsNtgFMbEIcHCmMJo

2-34-jPMNBKuEilIGIcJOKslCnoyG

2-35-oQNcxvcCyCMRoUHk

2-36-yEMFCUpiBvjObEQrcouLxUKQ

2-37-yUbuomwCcCGYhHhv

2-38-OCBzMBBHeruLCuNAmqsCMvesiBtGjDzYolwIikaoJS

2-39-eserbLCSbCIybT

2-40-hxsTnaNdOnDD

2-41-tsMUIcIeNMNOcMHktCoeEKdGukumoY

2-42-sZDkiOMUtfzhJFIocw

2-43-cwwAaIHLbhxIxRGWdxKBpluGdUty

2-44-HWNNIdNxIINUIwersRnbyhhNntDxImsp

2-45-NxiEOnDhtvCozvKfjgziICJgFM

2-46-rXtwAngxbagKbCCyHT

2-47-hsuHDhyGETNXbS

2-48-hIwQHFerNyjjzwCvIzdBdExaJLpvHV

2-49-yDaCritKcoHrusoqKzjzhCJc

2-50-OtMzBDBwNdCsNurGuGjHtvjJQKPYubIIochxDhNLsPcCCbym

3-01-oCcmcO

3-02-JeHgwAgrMvETdMuBuL

3-03-gOCggnjMBFOSyZdJCGsU

3-04-omoZINqLBA

3-05-bWhYuOsUyGnKOANZ

3-06-oSgPOEHqyUiDbsCH

3-07-HTxZclzhontQHP

3-08-IyDlnJcAnMIwsRcjyreAeB

3-09-nIIAnqNtOvNPtNsJOx

3-10-ynHFHJxfbvHBcDnVnZuG

3-11-ILnubXIOnxOIsHDyOzsEOCtG

3-12-NtaShFCqMFaQIwtjjijP

3-13-NLCWhNergM

3-14-ORbesbzmHFDRmEHIhMoEoG

3-15-yeMvcoxeImmMoSPQyEjPtRNrgfhF

3-16-sFMVrrgzCTNXBLhJEfiruljr

3-17-DwhODD

3-18-xDMTBNjxunbBbfCqxZhMMPPJiLNxPNrxjtCrsF

3-19-ikgShbhJjqjjjDiWhzlYntiE

3-20-ulhNDxoSMP

3-21-yWIQnAuGITEZjfnljJca

3-22-DCsUhIOmDD

3-23-tINyjioIzwaQHAng

3-24-OeHsHWburUBGxMbYniyIoajMbI

3-25-sBNrCwNzOvhIsLtHiNduCr

3-26-sFBLCbNjxXphHbtXjluljycp

3-27-bvnZHqHtxYeroPyRMwsLwPBZIOKxjdGWhu

3-28-HGbYOdhNMNxtDliHoQs

3-29-CpMRpcbgsznxaiBw

3-30-szMJCJNJbKIJiABKtwnyneDSxQJdtchrcv

3-31-teCGNPDEOGCbistNiUtYjf

3-32-bKHswSoQHocSihoUyCbAIs

3-33-CdNhtZphHbjhyDCUcpOE

3-34-DJpidIxOhBOCirOVhXtosXIdsCaOCdDR

3-35-NxtdoWHOFe

3-36-wAGWIMNZnZHNJfNlniovtVoGjz

3-37-erjtMVupirPdtdBLyrssPjshtfCXMRrXNRqTNXPf

3-38-DPaOCWbHCdcAtKiSdq

3-39-OwDHrXbVyHiqMUGXtIplxB

3-40-ewtOrqCZOaDwMTOyDEhLBQidtuizsXPQtZjeeuNp

3-41-MRBNBxjGNHuBuvPjCWnwyCbREybLrJhDxO

3-42-KRwlHrwPaVxbxtGXbBbLydGVctJDyRdxoFcpebpfpjplpn

3-43-mqciyuKuoDNf

3-44-tGBKiWuAhNMPCbtXurjzDxMV

3-45-DNcaulxjNOhvtkpgtaiscEHICTMzoUBx

3-46-PyBKaCbfDhbZMzoCzBjkuzzZjO

3-47-sJspinOzHTbXtjNuckEw

3-48-uECVirMYMDMWNyCDNKMKNiCtMxOdtsiFtKiRtYjiukjAtejL

3-49-BPMTIeIkxIoWnGtwiEdisD

3-50-OnNlCrNyCICbioCWtYDnjijWiUtwtIiChgNKCNixtiesEiey

4-01-OqHQhHOi

4-02-OHDxoYCboSHbci

4-03-tZGYsVyb

4-04-wSHIbeHCxA

4-05-xZcDjwuGPYiSaL

4-06-xlEUbLcoHqFjQtmD

4-07-JGIyOmDSCKtyjeNe

4-08-EECqbeaPiTzvjiCb

4-09-NLOGsA

4-10-DzuKhWGUzYuCHwoNjP

4-11-bzqNaAHNBvxZcttfjQ

4-12-iTzizm

4-13-omxIgMjNMNrfCFPf

4-14-EuMHNaCygGhGBBPAtQiVtYjc

4-15-cAtXGWgxcwOnyY

4-16-CgiRaQFpINaPHH

4-17-MxHetHAniWJlgVsnImzKjsAgOX

4-18-tZycopjhbhCudEKz

4-19-DzdqhLwWckcicg

4-20-MwCSMEEqhSsNrxHebKBwsJjAzTdhcXzbbAbebIaH

4-21-cgaBNbbebmNOaqJCcOPUdHdOea

4-22-xibtDkssqFIj

4-23-CDugPmMLclcf

4-24-EmCjaSxIuBBZhzaIpmcMbQOp

4-25-jPiRsFDUtGPmJFuEichGumJzHPHF

4-26-hENUIMCUttOsnwsXnztaIOJd

4-27-CJCcrtyTHqgRbgoRpcaP

4-28-tiBLaDHTamySiGjjjQ

4-29-BRNK

4-30-rUrPPtCf

4-31-COjlMyNPHPHFMGmVmPsqirJoOROUuBtOtRudCwJWNc

4-32-HFmkbHHcddyVoDhzxL

4-33-iWtGHZuIbLHyssjNGXNvtfKIoNbHdsbGdncMer

4-34-jwcluoCDDA

4-35-GZwQwRGYbHcSoGoHmE

4-36-QLxlCWbEyqovMWzjQKiStwKkcx

4-37-hyNkbuniDkCduKMB

4-38-IjOxsGnWjIBz

4-39-MLHqxwcEiVqMyEcQEntLtjurer

4-40-ndbvng

4-41-DjMwnfNFnXjDnZHtNEJBtglNsm

4-42-bWeserNKtghqCeinhMIKJeJGNFbagp

4-43-NyCsxMBPbWiopmEhgz

4-44-BymdtBjMyHFcNp

4-45-iobIyECWIMchiihg

4-46-uDCotJaOCbHnGVHmbdiWzvjltHjP

4-47-tQNwxXiWCvwXcdci

4-48-nLMVriNgCtIkIRcCBKcTyUtYjgjkoSjG

4-49-BEssOXjClPmBCjsjJlMzhzENiVdEoRDVeser

4-50-BCMCcCHODwNHNOuaFpGZjhnGEbIRrKzadshHsHne

如果没玩过这个游戏，那就赶快开始吧！

1. 利用等概率Rand5产生等概率Rand3

前些日子写app的时候遇到一个需求，希望有一个类似于UISlider的东西，但能够选取一个范围，也就是所谓的Range Slider。在网上也能找到很多相关的代码，不过本着学习的态度，还是自己琢磨了一下。

就当是为以后写复杂控件做的练习吧。

以下内容适用于iOS 2.0+。

需求决定一切，在介绍我的这个Range Slider之前，先把我的需求（或者说我这个Range Slider的功能）介绍一下。它最多只算是个toy，还有很多需要完善的地方。不过聊胜于无，以后继续努力呗。

这是一个水平方向的（浮点）数值范围选择器：

• 可以为它设置数值的最小值（minimumValue）和最大值（maximumValue），分别对应于滑动条最左端和最右端的数值。
• 可以设置范围的最小值（minimumSpan）和最大值（maximumSpan），因为我可能会要求选择的数值区间长度不太短或不太长。
• 可以获取或设置当前选择的数值范围（smallValue和largeValue），对应于界面上左右两个滑块的位置。
• 左右两个滑块都可以相互独立地左右滑动；一个滑块滑动时，另一个滑块会根据需要自动调整。比如当向左滑动左边的滑块时，如果选取的范围已经达到范围最大值（maximumSpan），右边的滑块就会跟着向左滑动。反之亦然。
• 两个滑块中间的条块也是可以滑动的，移动它的时候，两个滑块会一起左右移动（不改变选取范围的长度）。
• 当滑块或者滑条移动时，此控件的UIControlEventValueChanged事件会被触发。
• 可以用程序修改当前的选择范围，UI会跟着调整，但不会触发上述事件，以免在某些情况下陷入死循环。
• 以左滑块为例，当它滑动到最左边后，如果手指继续做向左滑动的动作，当前选择的范围不会变化，但会通过另一个量（offsetTrend）来表达这种趋势。在某些情况下，应用程序可能会需要得到这样的信息，以便当用户在slider边缘继续往外滑动时，进行一些特殊的处理。右滑块和滑条都有同样的功能。
• 可以为这个控件设置委托（delegate），当滑块或者滑条将要开始滑动、或者滑动结束的时候，委托的对象都会收到相应的消息。当然，会有一个只读的量（isDragging）用来查询是否有滑块或者滑条在滑动中。
• slider的背景条、滑块、滑条的图案都可以被替换。

我的这个Range Slider暂不支持的功能包括但不限于：

• 不支持纵向的滑动模式（或许可以直接利用旋转整个控件达到此目的）。
• 没有为自定义UI样式提供足够的接口。虽然背景和滑块的图片都能替换，但并不支持为每一个对象实例单独替换图片。比起SDK中的UISlider，这方面的功能是相当薄弱的。

说了这么多，来看看它的样子吧。外表很简单，我用的背景、滑块和滑条图片都跟UISlider是一样的：

我的Range Slider

实现起来蛮简单的，因为SDK已经提供了足够的支持。我的这个类就叫做RangeSlider，继承自UIControl类。另外我还定义了它的委托类，叫做RangeSliderDelegate。二者的接口如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
#import <UIKit/UIKit.h>



@protocol RangeSliderDelegate;



@interface RangeSlider : UIControl {

@private

    id<RangeSliderDelegate> delegate_;



    float minimumValue_;

    float maximumValue_;

    float minimumSpan_;

    float maximumSpan_;

    float smallValue_;

    float largeValue_;

    float offsetTrend_;

    int insetWidthLeft_;

    int rangeWidth_;



    UIImageView* selectionView_;

    UIImageView* smallHandle_;

    UIImageView* largeHandle_;



    BOOL isTrackingSmallHandle_;

    BOOL isTrackingLargeHandle_;

    BOOL isTrackingSelection_;

    BOOL isDragging_;

}



// The delegate object.

@property(nonatomic, assign) id<RangeSliderDelegate> delegate;



// The minimum value of the slider.

// The default value is 0.0.

@property(nonatomic, assign) float minimumValue;



// The maximum value of the slider.

// The default value is 1.0.

@property(nonatomic, assign) float maximumValue;



// The minimum span of the selected range.

// The default value is 0.1.

@property(nonatomic, assign) float minimumSpan;



// The maximum span of the selected range.

// The default value is 1.0.

@property(nonatomic, assign) float maximumSpan;



// The lower bound of the selected range.

@property(nonatomic, assign, setter=setSmallValue:) float smallValue;



// The higher bound of the selected range.

@property(nonatomic, assign, setter=setLargeValue:) float largeValue;



// A Boolean value that indicates whether the user has begun dragging.

@property(nonatomic, assign, readonly) BOOL isDragging;



// Initialization with frame, also specify the inset of left and right edge.

- (id)initWithFrame:(CGRect)frame insetLeft:(int)insetLeft insetRight:(int)insetRight;



// Move the current selection.

- (void)moveSelection:(float)offset;



// Gets offset trend, it will be reset to 0 after call finished.

- (float)getAndResetOffsetTrend;



// Converts slider value to x coor.

- (float)xForValue:(float)value;



// Converts x coor to slider value.

- (float)valueForX:(float)x;



@end

1
2
3
4
5
6
7
8
9
10
11
12
@protocol RangeSliderDelegate<NSObject>

@optional



// Tells the delegate when the slider is about to start dragging.

// The delegate might not receive this message until dragging has occurred over a small distance.

- (void)rangeSliderWillBeginDragging:(RangeSlider*)rangeSlider;



// Tells the delegate when dragging ended in the range slider.

// This message is sent when the user's finger touches up after dragging.

- (void)rangeSliderDidEndDragging:(RangeSlider*)rangeSlider;



@end

接口中的大部分内容都在需求和功能介绍部分见过了。另外有两个方法，xForValue和valueForX，它们用来在Range Slider内部的坐标值和用户数值之间做转换，内容如下（这里的insetWidth是在UI上做的小伎俩，主要是为了保证滑块滑到最两端时也能有充足的空间来接受用户的点击）：

1
2
3
4
5
6
7
- (float)xForValue:(float)value {

    return insetWidthLeft_ + rangeWidth_ * (value - minimumValue_) / (maximumValue_ - minimumValue_);

}



- (float)valueForX:(float)x {

    return minimumValue_ + (x - insetWidthLeft_) * (maximumValue_ - minimumValue_) / rangeWidth_;

}

我就不贴完整的.m源文件了，只是逐个介绍一下重要的方法。

首先看初始化方法initWithFrame，和更新显示的方法updateSelectionView。这个没啥好说的，就是初始化成员变量，创建好相关的图片：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
- (id)initWithFrame:(CGRect)frame insetLeft:(int)insetLeft insetRight:(int)insetRight {

    self = [super initWithFrame:frame];

    if (self != nil) {

        // Set the initial state.

        minimumValue_ = 0.0f;

        maximumValue_ = 1.0f;

        minimumSpan_ = 0.1f;

        maximumSpan_ = 0.7f;

        smallValue_ = minimumValue_;

        largeValue_ = minimumValue_ + maximumSpan_;

        offsetTrend_ = 0.0f;

        insetWidthLeft_ = insetLeft;

        rangeWidth_ = frame.size.width - insetLeft - insetRight;



        isTrackingSmallHandle_ = NO;

        isTrackingLargeHandle_ = NO;

        isTrackingSelection_ = NO;

        isDragging_ = NO;



        float centerY = frame.size.height / 2.0f;



        // Background image.

        UIImageView* background = [[[UIImageView alloc] initWithImage:[UIImage imageNamed:@"rangeslider-bg.png"]]

                                  autorelease];

        background.frame = CGRectMake(insetWidthLeft_, 0, rangeWidth_, background.frame.size.height);

        background.center = CGPointMake(background.center.x, centerY);

        [self addSubview:background];



        // Selection image.

        selectionView_ = [[[UIImageView alloc] initWithImage:[UIImage imageNamed:@"rangeslider-select.png"]

                                            highlightedImage:[UIImage imageNamed:@"rangeslider-select-hover.png"]]

                          autorelease];

        selectionView_.center = CGPointMake(0, centerY);

        [self addSubview:selectionView_];



        // Left handle for small value selection.

        smallHandle_ = [[[UIImageView alloc] initWithImage:[UIImage imageNamed:@"rangeslider-handle.png"]

                                          highlightedImage:[UIImage imageNamed:@"rangeslider-handle-hover.png"]]

                        autorelease];

        smallHandle_.center = CGPointMake(0, centerY);

        [self addSubview:smallHandle_];



        // Right handle for small value selection.

        largeHandle_ = [[[UIImageView alloc] initWithImage:[UIImage imageNamed:@"rangeslider-handle.png"]

                                          highlightedImage:[UIImage imageNamed:@"rangeslider-handle-hover.png"]]

                        autorelease];

        largeHandle_.center = CGPointMake(0, centerY);

        [self addSubview:largeHandle_];



        [self updateSelectionView];

    }



    return self;

}

1
2
3
4
5
6
7
8
- (void)updateSelectionView {

    smallHandle_.center = CGPointMake([self xForValue:smallValue_], smallHandle_.center.y);

    largeHandle_.center = CGPointMake([self xForValue:largeValue_], largeHandle_.center.y);

    selectionView_.frame = CGRectMake(smallHandle_.center.x,

                                      selectionView_.frame.origin.y,

                                      largeHandle_.center.x - smallHandle_.center.x,

                                      selectionView_.frame.size.height);

}

接下来看最重要的部分，就是处理触摸事件的方法。这些方法继承自基类UIControl，分别是beginTrackingWithTouch:withEvent:，continueTrackingWithTouch:withEvent:，和endTrackingWithTouch:withEvent:。

beginTracking和endTracking都很简单，在beginTracking的时候判断是哪个东西被拖动，让其进入高亮状态，修改成员变量记录当前的状态；在endTracking的时候取消高亮，恢复状态。

在continueTracking方法中，先获取手指移动的坐标偏移量，将其换算成数值的偏移量，然后就直接调用相应的设置函数修改已选择的数值区域。

注意rangeSliderWillBeginDragging和rangeSliderDidEndDragging这两个消息的回调时机。手指刚刚按在滑块上的时候，beginTracking被调用，但这时并不表示用户开始已经开始拖动了，他可能只是按了一下，马上就抬起来。所以当手指按住滑块并有了第一次微小的位移时，continueTracking被调用，这时就可以确定用户是在进行拖动操作。这时候才发送rangeSliderWillBeginDragging消息。最后当手指离开滑块时，拖动操作结束，发送rangeSliderDidEndDragging消息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
- (BOOL)beginTrackingWithTouch:(UITouch*)touch withEvent:(UIEvent*)event {

    CGPoint touchPoint = [touch locationInView:self];

    if (CGRectContainsPoint(largeHandle_.frame, touchPoint)) {

        largeHandle_.highlighted = YES;

        isTrackingLargeHandle_ = YES;

    }

    else if (CGRectContainsPoint(smallHandle_.frame, touchPoint)) {

        smallHandle_.highlighted = YES;

        isTrackingSmallHandle_ = YES;

    }

    else if (CGRectContainsPoint(selectionView_.frame, touchPoint)) {

        selectionView_.highlighted = YES;

        isTrackingSelection_ = YES;

    }

    else {

        return NO;

    }



    isDragging_ = NO;

    return YES;

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
- (BOOL)continueTrackingWithTouch:(UITouch*)touch withEvent:(UIEvent*)event {

    if (!isTrackingSmallHandle_ && !isTrackingLargeHandle_ && !isTrackingSelection_) {

        return NO;

    }



    if (!isDragging_) {

        isDragging_ = YES;

        if ([self.delegate respondsToSelector:@selector(rangeSliderWillBeginDragging:)]) {

            [self.delegate rangeSliderWillBeginDragging:self];

        }

    }



    float prev = [self valueForX:[touch previousLocationInView:self].x];

    float curr = [self valueForX:[touch locationInView:self].x];

    float offset = curr - prev;



    if (isTrackingSmallHandle_) {

        self.smallValue = smallValue_ + offset;

    }

    else if (isTrackingLargeHandle_) {

        self.largeValue = largeValue_ + offset;

    }

    else if (isTrackingSelection_) {

        [self moveSelection:offset];

    }



    [self sendActionsForControlEvents:UIControlEventValueChanged];

    return YES;

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
- (void)endTrackingWithTouch:(UITouch*)touch withEvent:(UIEvent*)event {

    isTrackingSmallHandle_ = NO;

    isTrackingLargeHandle_ = NO;

    isTrackingSelection_ = NO;



    selectionView_.highlighted = NO;

    smallHandle_.highlighted = NO;

    largeHandle_.highlighted = NO;



    if (isDragging_) {

        isDragging_ = NO;

        if ([self.delegate respondsToSelector:@selector(rangeSliderDidEndDragging:)]) {

            [self.delegate rangeSliderDidEndDragging:self];

        }

    }

}

最后就是修改smallValue、largeValue和整个选取范围的方法，这些方法会在滑动过程中由上面的continueTrackingWithTouch:withEvent:调用，也可以由其他程序直接调用。

不但要保证smallValue和largeValue都在最小值和最大值范围之内，还要根据最小范围和最大范围的限制来进行适当的调整。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
- (void)setSmallValue:(float)value {

    smallValue_ = value;



    smallValue_ = MIN(MAX(smallValue_, minimumValue_), maximumValue_ - minimumSpan_);

    if (smallValue_ < largeValue_ - maximumSpan_) {

        largeValue_ = smallValue_ + maximumSpan_;

    }

    else if (smallValue_ > largeValue_ - minimumSpan_) {

        largeValue_ = smallValue_ + minimumSpan_;

    }



    offsetTrend_ = value - smallValue_;



    [self updateSelectionView];

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
- (void)setLargeValue:(float)value {

    largeValue_ = value;



    largeValue_ = MAX(MIN(largeValue_, maximumValue_), minimumValue_ + minimumSpan_);

    if (largeValue_ < smallValue_ + minimumSpan_) {

        smallValue_ = largeValue_ - minimumSpan_;

    }

    if (largeValue_ > smallValue_ + maximumSpan_) {

        smallValue_ = largeValue_ - maximumSpan_;

    }



    offsetTrend_ = value - largeValue_;



    [self updateSelectionView];

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
- (void)moveSelection:(float)offset {

    float span = largeValue_ - smallValue_;

    float prevSmallValue = smallValue_;

    smallValue_ += offset;

    largeValue_ += offset;

    if (smallValue_ < minimumValue_) {

        smallValue_ = minimumValue_;

        largeValue_ = smallValue_ + span;

    }

    else if (largeValue_ > maximumValue_) {

        largeValue_ = maximumValue_;

        smallValue_ = largeValue_ - span;

    }



    offsetTrend_ = prevSmallValue + offset - smallValue_;



    [self updateSelectionView];

}

好了，基本上就这么些代码，还是很简单的。不放完整的程序文件了，只要了解了基本的处理方法，就可根据自己的需求去实现了。

1. iPhone开发：在UIAlertView中显示进度条
2. iPhone开发：可拉伸的图片
3. 利用等概率Rand5产生等概率Rand3

这个问题其实不难，只是很多时候，尤其在没有任何提示的时候，容易想错。条件概率的题目一定要看清楚条件信息。

问题描述：老王有两个孩子，已知至少有一个孩子是在星期二出生的男孩。问：两个孩子都是男孩的概率是多大？【假设生男生女的概率相等】

刚看到题目的时候，我也愣了一下：一个孩子星期二出生，对于另一个孩子是不是男孩有什么影响吗？

先说一下，这道题的答案是 13 / 27，如果你算出来的不是这个数，那建议你继续往下看看。

思维缜密的项目经理的解题思路

项目经理小李，虽然数学功底不深，编程技术不精，但有个很大的好处是处事不惊，有条不紊。看到题目之后，略加思索，就用最简单的办法弄懂了这个问题，并求出了结果。

首先看如果只知道老王有两个孩子，其他信息都不知道的情况下，两个孩子都是男孩的概率显然是1/4。

再来看看没有“星期二”这个条件的情况，题目变成：老王有两个孩子，已知至少有一个孩子是男孩，问两个孩子都是男孩的概率是多大？那结果显然是1/3。因为在“至少有一个男孩”这样的条件下，只有三种可能：兄妹俩、姐弟俩、兄弟俩。这三种情况是等概率的，而只有一种情况是两个男孩，因此是1/3。

最后再把星期二也考虑进来。还是在上面的基础上扩展，先按照两个孩子的四种可能的性别组合进行划分，然后在每种组合里看看满足有至少一个周二男孩的情况数目：

• 姐妹俩：不用看了，不满足至少有一个周二男孩的条件。
• 兄妹俩：那哥哥一定是周二出生的了，妹妹出生的星期数有7种可能。
• 姐弟俩：弟弟一定是周二出生，姐姐出生的星期数有7种可能。
• 兄弟俩：兄弟二人出生的星期数总共有7 * 7 = 49种可能，但其中有6 * 6 = 36种都不满足至少有一个人是周二出生的条件，因此实际上有49 - 36 = 13种可能。

因此，满足条件的情况（这里的情况是指综合考虑孩子的性别和出生星期数）总数为7 + 7 + 13 = 27。而其中有13中可能对应于两个孩子都是男孩。因此题目所求概率是17 / 23。

没错，17 / 23就是这道题的答案，出现这样的数字是因为已知条件所提供的信息使得样本空间发生了变化（变小了一点儿）。这就是条件概率带来的影响。

博学多才的数据挖掘专家的解题思路

小陈是一个有丰富的数据挖掘和机器学习经验的专家，在听到这个题目的时候，想都没想，干脆地说：“这题简单，用贝叶斯公式就能搞定”。

根据题目，可以认定两个事件，事件A是：至少有一个周二出生的男孩；事件B是：两个孩子都是男孩。题目要求的是P(B|A)即在事件A发生的条件下，事件B发生的概率。根据贝叶斯公式，容易知道：

$P(B|A)=\frac{P(AB)}{P(A)}=\frac{P(A|B)P(B)}{P(A)}$

依次算出等号右边的各个概率值：

• 在已知两个孩子都是男孩的条件下，至少有一个是周二出生的男孩：$P(A|B)=1-{(\frac{6}{7})}^2=\frac{13}{49}$
• 两个孩子都是男孩：$P(B)=\frac{1}{4}$
• 至少有一个孩子是周二出生的男孩：$P(A)=1-{(\frac{1}{2}\times \frac{6}{7}+\frac{1}{2})}^2=\frac{27}{196}$

因此可以求出：$P(B|A)=\frac{P(A|B)P(B)}{P(A)}=\frac{13}{49}\times \frac{1}{4}\div \frac{27}{196}=\frac{13}{27}$

苦逼的无证程序员的解题方法

无证程序员小周看到题目后，二话不说，写了一小段程序（Python）来计算概率的近似值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from random import Random



def IsTwoBoys(rand):

  genders = ('M', 'F')

  weekdays = tuple(range(1, 8))

  while True:

    children = [(rand.choice(genders), rand.choice(weekdays)) for i in xrange(2)]

    if ((children[0][0] == 'M') and children[0][1] == 2) or

        (children[1][0] == 'M')) and children[1][1] == 2)):

      return True if children[0][0] == children[1][0] == 'M' else False



cnt = 1000000

twoboys = 0

rand = Random()

for i in xrange(cnt):

  if IsTwoBoys(rand):

    twoboys += 1

print 'p(twoboys) =', twoboys, '/', cnt, '=', float(twoboys) / cnt

运行结果，题目所求概率值近似为：0.48213，与13 / 27 = 0.(481)非常接近。

1. 等概率随机排列数组（洗牌算法）
2. 单次遍历，等概率随机选取问题
3. 利用不均匀硬币产生等概率
4. 单次遍历，带权随机选取问题（一）
5. 单次遍历，带权随机选取问题（二）

前两天同事的朋友给出了一个怪怪的题目，说是考验我们的智商，结果最后让我们大跌眼镜。

题目很简单：怎样让四个不同的数11、12、13和14，通过简单的数学运算得到46，可以使用加减乘除和括号。同时还给了一条重要提示：不能按照正常的思路思考。

虽然说不能按照正常思路思考，但看到这个题目后还是立刻祭出了n年前写的算24点的程序，这个程序（以后有时间可以好好介绍一下）的扩展版支持由任意2到7个数字通过四则运算求出任意目标数。把四个数字和目标数输入进去，果然无解。不过很快发现，如果数字可以重复，能够得到下面两个最简单的解：

• 使用两次11：$11+13+11\times(14-12)=46$
• 使用两次12：$(11+12)\times(12+14)/13=46$

可惜出题人并不允许使用重复的数字，要求给定的每个数字必须用且仅用一次。

后来我就想会不会用到其他进制，搞IT的，总得玩玩什么二进制、八进制、十六进制之类的。但是应该采用哪个进制呢？想了好久，总算让我找到一个解：

• $14+12\times(13-11)=46_{oct}$

也就是把46按照八进制数来考虑。结果出题人告知：“是十进制的46”。看来进制转换的路走不通了，于是我又想出了其他一堆更不靠谱的解：

• $(11+12)\ll(14-13)=46$
• $(11+12)\times\left\lceil\frac{14}{13}\right\rceil=46$
• $\sum_{i=13}^{14}{(11+12)}=46$
• $(11+12)\times\left|\left\{13,14\right\}\right|=46$
• $(11+12)\times\left(e^{14i\pi}-e^{13i\pi}\right)=46$

很明显越来越扯了，每个解法都引入了四则运算之外的运算符或者函数，都不是正确的解。

在苦思不得其解之后，出题人给出了他的答案，我们都震惊了。不过说实在的，我上面给的八进制的解跟答案非常接近了，只怪我没有深入理解出题人的告知。

正确答案是：

• $11_{bin}+12_{oct}+13_{dec}+14_{hex}=46_{dec}$

原来，出题人说“是十进制的46”，其内在含义是说：其他数字不一定是十进制。哈哈！

今天这个问题是，在一个iPhone程序中，我要在后台做大量的数据处理，希望在界面上显示一个进度条（Progress Bar）使得用户了解处理进度。这个进度条应该是在一个模态的窗口中，使界面上其他控件无法被操作。怎么用最简单的方法来实现这个功能？UIAlertView是一个现成的模态窗口，如果能把进度条嵌入到它里面就好了。

以下内容适用于iOS 2.0+。

我们知道，如果要显示一个alert窗口（比如用来显示错误或警告信息、询问用户是否确认某操作等等），只要简单地创建一个UIAlertView对象，再调用其show方法即可。示意代码如下：

1
2
3
4
5
6
7
UIAlertView* alertView = [[[UIAlertView alloc] initWithTitle:@"Title"

                                                     message:@"Message"

                                                    delegate:nil

                                           cancelButtonTitle:@"OK"

                                           otherButtonTitles:nil]

                          autorelease];

[alertView show];

如果要添加一个进度条，只要先创建并设置好一个UIProgressView的实例，再利用addSubbiew方法添加到alertView中即可。

在实际应用中，我可能需要在类中保存进度条的对象实例，以便更新其状态，因此先在自己的ViewController类中添加成员变量：

1
2
3
4
5
6
7
8
9
//  MySampleViewController.h

#import <UIKit/UIKit.h>



@interface MySampleViewController : UIViewController {

@private

    UIProgressView* progressView_;

}



@end

接下来写一个叫做showProgressAlert的方法来创建并显示带有进度条的alert窗口，其中高亮的部分就是把进度条添加到alertView中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
- (void)showProgressAlert:(NSString*)title withMessage:(NSString*)message {

    UIAlertView* alertView = [[[UIAlertView alloc] initWithTitle:title

                                                         message:message

                                                        delegate:nil

                                               cancelButtonTitle:nil

                                               otherButtonTitles:nil]

                              autorelease];



    progressView_ = [[UIProgressView alloc] initWithProgressViewStyle:UIProgressViewStyleBar];
    progressView_.frame = CGRectMake(30, 80, 225, 30);
    [alertView addSubview:progressView_];


    [alertView show];

}

为了让数据处理的子进程能够方便地修改进度条的值，再添加一个简单的方法：

1
2
3
- (void)updateProgress:(NSNumber*)progress {

    progressView_.progress = [progress floatValue];

}

另外，数据处理完毕后，我们还需要让进度条以及alertView消失，由于之前并没有保存alertView的实例，可以通过进度条的superview访问之：

1
2
3
4
5
6
7
8
9
10
11
12
13
- (void)dismissProgressAlert {

    if (progressView_ == nil) {

        return;

    }



    if ([progressView_.superview isKindOfClass:[UIAlertView class]]) {

        UIAlertView* alertView = (UIAlertView*)progressView_.superview;

        [alertView dismissWithClickedButtonIndex:0 animated:NO];

    }



    [progressView_ release];

    progressView_ = nil;

}

假设处理数据的方法叫processData，当然它会在一个单独的线程中运行，下面的片段示意了如何更新进度条状态，以及最后如何让它消失。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
- (void)processData:(int)total {

    for (int i = 0; i < total; ++i) {

        // Update UI to show progess.

        float progress = (float)i / total;

        NSNumber* progressNumber = [NSNumber numberWithFloat:progress];

        [self performSelectorOnMainThread:@selector(updateProgress:)

                               withObject:progressNumber

                            waitUntilDone:NO];



        // Process.

        // do it.

    }



    // Finished.

    [self performSelectorOnMainThread:@selector(dismissProgressAlert)

                           withObject:nil

                        waitUntilDone:YES];

    // Other finalizations.

}

在实际使用中，带进度条的alert view大概长得是这样的：

带进度条的alert窗口

参考：

• UIProgressView in UIAlertView?

1. iPhone开发：可拉伸的图片
2. iPhone开发：自定义控件RangeSlider（范围滑动条）
3. iPhone开发：隐藏系统状态栏

最近在写iPhone上的程序，第一次在Mac下进行开发，也是第一次写手机上的程序，虽然之前看了少许相关的书籍，但在开发的过程中还是遇到了很多的问题。在这个系列中记录一些遇到的实际的问题，方便淡忘了之后再次查阅。

今天的问题是怎么在App中隐藏系统状态栏（Status Bar）。

以下内容适用于iOS 3.2+。

一、始终隐藏状态栏

如果在App中需要状态栏一直是隐藏着的，可以在<YOUR_APP>AppDelegate的application:didFinishLaunchingWithOptions:函数中进行设置，比如下面这段示意代码可以让状态栏以淡出的方式隐藏起来：

1
2
3
4
5
6
7
8
9
10
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {

    // Override point for customization after application launch.

    [application setStatusBarHidden:NO withAnimation:UIStatusBarAnimationFade];


    // Add the view controller's view to the window and display.

    [self.window addSubview:viewController.view];

    [self.window makeKeyAndVisible];



    return YES;

}

相关的方法或属性是UIApplication的：

• setStatusBarHidden:withAnimation:（iOS 3.2+）
• statusBarHidden（iOS 2.0+）

另外还有一个方法setStatusBarHidden:animated:，已经不推荐使用了（deprecated in iOS 3.2）。

二、App启动时就隐藏状态栏

用了上面的方法之后，App在运行过程中，状态栏确实被隐藏起来了，但是我发现在App启动的那个瞬间，还是可以看到状态栏的，然后一闪即过。虽然时间很短暂，看着还是很不舒服。为了让状态栏从启动的时候就隐藏起来，可以修改<YOUR_APP>-Info.plist。如果在Xcode中修改，在根结点Infomation Property List下面新加一项“Status bar is initially hidden”（不用手动输入，可以直接在下拉菜单中选取）。这是个BOOL类型的键值，将Value栏中的复选框勾选上即可。

在Info.plist中设置状态栏为隐藏

也可以以文本方式修改，在根节点中添加UIStatusBarHidden键值，值设为true即可：

1
2
<key>UIStatusBarHidden</key>

<true/>

三、在运行过程中隐藏或显示状态栏

与第一段中的方法一样，只是可以在任何地方调用。只要利用UIApplication类的静态方法sharedApplication拿到application实例即可。

1. iPhone开发：可拉伸的图片
2. iPhone开发：自定义控件RangeSlider（范围滑动条）
3. iPhone开发：在UIAlertView中显示进度条
4. 隐藏磁盘分区Q

之前有一段时间特别喜欢玩魔方，从二阶到七阶，在桌子上摆了长长的一排。后来听说九阶和十一阶也有卖的了，心中甚是痒痒，可惜囊中羞涩啊。

特别喜欢高阶魔方的一个原因，就是它们每个面上的小方格数很多（就像人们都喜欢高分辨率的显示屏一样），可以玩的花样也就多了很多。今天分享一下我的一个七阶魔方花样作品：混乱中的秩序——五阶数独。

看一看照片，你能发现其中的规律么？

七阶魔方花样（你能看出其中的规律么？）

如果边角处看不清楚，那再来看看六个面的特写：

七阶魔方花样，六个面特写——混乱中亦有规律

是不是有点儿意思？

规律是这样的，一个面周围一圈棱边的小方格颜色是一样的，六个面六种颜色。中间五乘五的二十五个小方格，恰好包含除了棱边之外的五种颜色，且每个颜色恰好出现五次。并且每个横行、竖列和两条对角线上的五个方格中都不出现重复颜色。这是不是跟五阶对角线数独非常像呢？

怎么设计这样的花样？关键在于，什么样的花样可以用魔方表现出来？

七阶魔方面块的不同位置

上面这张图是七阶魔方的一个面的示意。由于我的这个花样方案中不用考虑棱块和角块，再除去不会动的面心，剩下的24个方格由于旋转对称性可以分成四个等价的分区（图中用四种颜色表示）。每个分区中都有六个不同的位置，用不同的字母表示。根据魔方的运动规律，不同字母位置的方块是永远都不会互换的，就是说字母A永远不会跑到其他字母所在的位置去；但是任意两个（也可以是不同面的）相同字母位置的方块都是可以互换的（只考虑颜色的话，可以做到互换后不改变任何其他方块）。每个面都有六种不同的字母，每个字母出现四次。因此只要设计出来的花样满足：“每个字母在六个面中总共对应4 * 6 = 24个方格，在这些方格中每种颜色都恰好出现4次”，那这种花样就一定可以转的出来。

接着来设计花样，先找一个五阶对角线数独的分布，用下面这段随意写出的Python代码就可以搞定。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
def FillBoard(board, n, xy):

  x = xy % n

  y = xy // n

  if y >= n:

    print('Find a possible solution.')

    return True



  existValues = set()

  existValues = existValues.union([board[y][xx] for xx in range(n)])

  existValues = existValues.union([board[yy][x] for yy in range(n)])

  if x == y:

    existValues = existValues.union([board[xx][xx] for xx in range(n)])

  if x + y == n - 1:

    existValues = existValues.union([board[xx][n-xx-1] for xx in range(n)])



  validValues = [v for v in range(1, n+1) if v not in existValues]



  if not validValues: return False

  for v in validValues:

    board[y][x] = v

    if FillBoard(board, n, xy+1): return True

    board[y][x] = None

  return False



def GenerateBoard(n):

  board = [[None for x in range(n)] for y in range(n)]

  if not FillBoard(board, n, 0):

    print('No solution.')

  return board



cnt = 5

board = GenerateBoard(cnt)

用程序找到第一组解是：

1
2
3
4
5
[1, 2, 3, 4, 5]

[2, 4, 5, 3, 1]

[5, 3, 2, 1, 4]

[3, 1, 4, 5, 2]

[4, 5, 1, 2, 3]

下面来确定每个数字在每一面所对应的颜色。首先六个面的面心是不能动的，因此每个面的2号颜色就都确定了。接着要考虑每个面的底色（就是棱块和角块的颜色），这个颜色不能随便选，要考虑魔方六个面的位置关系。我所选定的方案是，面心色蓝、红、绿、橙、黄、黑分别的对应于棱角色黑、蓝、黄、绿、橙、红。最后给每个面分配第1、3、4、5号颜色，稍微注意一下限制条件就好了。最后得到六个面的配色方案（程序中的W对应于黑色）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def ApplyColor(board, colors):

  newboard = [[colors[v] for v in row] for row in board]

  return newboard



def DrawBoard(board):

  for row in board:

    print(row)



allcolors = (

  ['B Center', 'R', 'B', 'O', 'W', 'Y'],

  ['R Center', 'G', 'R', 'B', 'W', 'Y'],

  ['G Center', 'O', 'G', 'R', 'W', 'Y'],

  ['O Center', 'G', 'O', 'B', 'W', 'Y'],

  ['Y Center', 'R', 'Y', 'O', 'B', 'G'],

  ['W Center', 'R', 'W', 'O', 'G', 'B'],

  )

for colors in allcolors:

  print('Colors:', colors)

  colorboard = ApplyColor(board, colors)

  DrawBoard(colorboard)

  print()

最后一步就是纯体力活——转魔方。这里就不详细说了，基本的过程是先把棱块和角块转好，最后就可以随意调换每个面中部的颜色了。因为图案看起来乱乱的，转的时候很容易忘记哪边已经转好哪边还没转，只能是小心仔细慢慢进行。

1. U盘检测软件：ChipGenius，MyDiskTest
2. 单次遍历，带权随机选取问题（一）
3. 《塞尔达传说：黎明公主》攻略：角色介绍
4. 2011.5.15我们的婚礼（二）——迎亲篇
5. 检测单向链表是否存在环

问题描述：Fibonacci数（Fibonacci Number）的定义是：F(n) = F(n - 1) + F(n - 2)，并且F(0) = 0，F(1) = 1。对于任意指定的整数n（n ≥ 0），计算F(n)的精确值，并分析算法的时间、空间复杂度。

假设系统中已经提供任意精度长整数的运算，可以直接使用。

这其实是个老生常谈的问题了，不过可能在复杂度分析的时候，很多人忽略了一些事情。另外这个问题恰好有几种复杂度迥异的算法，在刚刚介绍完算法复杂度之后，正好来直观地理解一下。

一、递归法

一个看起来很直观、用起来很恐怖的算法就是递归法。根据Fibonacci的递推公式，对于输入的n，直接递归地调用相同的函数分别求出F(n - 1)和F(n - 2)，二者相加就是结果。递归的终止点就是递推方程的初值，即n取0或1的时候。

程序（in Python）写出来那也是相当的简洁直观（为了跟后面的程序区分开来，这里取名SlowFibonacci）。

1
2
3
4
def SlowFibonacci(n):

  assert n >= 0, 'invalid n'

  if n < 2: return n  # F(0) = 0, F(1) = 1

  return SlowFibonacci(n - 1) + SlowFibonacci(n - 2)

这个算法的时间复杂度有着跟Fibonacci类似的递推方程：T(n) = T(n - 1) + T(n - 2) + O(1)，很容易得到T(n) = O(1.618 ^ n)（1.618就是黄金分割，$(1+\sqrt5)/2$）。空间复杂度取决于递归的深度，显然是O(n)。

二、递推法

虽然只是一字之差，但递推法的复杂度要小的多。这个方法就是按照递推方程，从n = 0和n = 1开始，逐个求出所有小于n的Fibonacci数，最后就可以算出F(n)。由于每次计算值需要用到前两个Fibonacci数，更小的数就可以丢弃了，可以将空间复杂度降到最低。算法如下：

1
2
3
4
5
6
7
def NormFibonacci(n):

  assert n >= 0, 'invalid n'

  if n == 0: return 0

  (prev, curr) = (0, 1)  # F(0), F(1)

  for i in xrange(n - 1):

    (prev, curr) = (curr, prev + curr)

  return curr

显然时间复杂度是O(n)，空间复杂度是O(1)。

比较一下递归法和递推法，二者都用了分治的思想——把目标问题拆为若干个小问题，利用小问题的解得到目标问题的解。二者的区别实际上就是普通分治算法和动态规划的区别。

三、矩阵法

算Fibonacci数精确值的最快的方法应该就是矩阵法，看过的人都觉得这个方法很好。如果你跟我一样，曾经为记住这个方法中的矩阵而烦恼，那今天就来看看怎么进行推导。其实方法非常简单，想清楚了也就自然而然地记住了。

我们把Fibonacci数列中相邻的两项：F(n)和F(n - 1)写成一个2x1的矩阵，然后对其进行变形，看能得到什么：

$\begin{bmatrix}F_n\\F_{n-1}\end{bmatrix}=\begin{bmatrix}F_{n-1}+F_{n-2}\\F_{n-1}\end{bmatrix}=\begin{bmatrix}1\times F_{n-1}+1\times F_{n-2}\\1\times F_{n-1}+0\times F_{n-2}\end{bmatrix}=\begin{bmatrix}1&1\\1&0\end{bmatrix}\times\begin{bmatrix}F_{n-1}\\F_{n-2}\end{bmatrix}$

是不是非常自然呢？把等式最右边继续算下去，最后得到：

$\begin{bmatrix}F_n\\F_{n-1}\end{bmatrix}=\begin{bmatrix}1&1\\1&0\end{bmatrix}^{n-1}\times\begin{bmatrix}F_{1}\\F_{0}\end{bmatrix}=\begin{bmatrix}1&1\\1&0\end{bmatrix}^{n-1}\times\begin{bmatrix}1\\0\end{bmatrix}$

因此要求F(n)，只要对这个二阶方阵求n - 1次方，最后取结果方阵第一行第一列的数字就可以了。

看起来有点儿化简为繁的感觉，但关键点在于，幂运算是可以二分加速的。设有一个方阵a，利用分治法求a的n次方，有：

$a^n=\begin{cases}a^{n/2}\times a^{n/2}&,\text{ if }x\text{ is even}\\a^{(n-1)/2}\times a^{(n-1)/2}\times a&,\text{ if }x\text{ is odd}\end{cases}$

可见复杂度满足T(n) = T(n / 2) + O(1)，根据Master定理可得：T(n) = O(log n)。

在实现的时候，可以用循环代替递归实现这里的二分分治，好处是降低了空间复杂度（用递归的话，空间复杂度为O(log n)）。下面的Python程序直接利用的numpy库中的矩阵乘法（当然这个库也实现了矩阵的幂运算，我把它单独写出来是为了强调这里的分治算法）。另外如果不用第三方库，我也给出了矩阵乘法的简单实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from numpy import matrix



def MatrixPower(mat, n):

  assert n > 0, 'invalid n'

  res = None

  temp = mat

  while True:

    if n & 1:

      if res is None: res = temp

      else: res = res * temp

    n >>= 1

    if n == 0: break

    temp = temp * temp

  return res



def FastFibonacci(n):

  assert n >= 0, 'invalid n'

  if n < 2: return n  # F(0) = 0, F(1) = 1

  mat = matrix([[1, 1], [1, 0]], dtype=object)

  mat = MatrixPower(mat, n - 1)

  return mat[0, 0]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
def DotProduct(x, y):

  n = len(x)

  assert len(y) == n, 'x and y must have the same length'

  s = 0

  for i in xrange(n):

    s += x[i] * y[i]

  return s



def MatrixMultiply(x, y):

  # x is a m*a matrix, y is a a*n matrix.

  # x * y is a m*n matrix.

  m = len(x)

  n = len(y[0])

  a = len(x[0])

  assert len(y) == a



  # transpose y

  y = [[y[i][j] for i in xrange(a)] for j in xrange(n)]



  res = [[DotProduct(x[j], y[i]) for i in xrange(n)] for j in xrange(m)]

  return res



def MatrixPower(mat, n):

  assert n > 0, 'invalid n'

  res = None

  temp = mat

  while True:

    if n & 1:

      if res is None: res = temp

      else: res = MatrixMultiply(res, temp)

    n >>= 1

    if n == 0: break

    temp = MatrixMultiply(temp, temp)

  return res



def FastFibonacci(n):

  assert n >= 0, 'invalid n'

  if n < 2: return n  # F(0) = 0, F(1) = 1

  mat = [[1, 1], [1, 0]]

  mat = MatrixPower(mat, n - 1)

  return mat[0][0]

二阶方阵相乘一次可以看成是常数时间（虽然这个常数会比较大），因此整个算法的时间复杂度是O(log n)，空间复杂度是O(1)。

四、运行时间大比拼

至此，我们得到的时间复杂度分别是O(1.618 ^ n)、O(n)和O(log n)的算法，让我们来直观地比较比较它们。

用Python的timeit模块对以上三个算法的运行时间进行了测量，记录了每个算法对于不同的n的每千次运算所消耗的时间（单位是秒），部分数据记录在fibonacci_data。利用Mathematica可以很方便地对这些数据进行拟合，对于较小的n，用三个复杂度表达式分别去拟合，得到的效果都非常好。尤其值得注意的是，对于第一个算法，我用a * b ^ n去拟合，结果得到b等于1.61816，这与黄金分割数的正确值相差无几。

• 递归法拟合结果：0.000501741 * 1.61816 ^ n，RSquare = 0.999993。
• 递推法拟合结果：0.000788421 + 0.000115831 * n，RSquare = 0.999464。
• 矩阵法拟合结果：-0.0114923 + 0.0253609 log(n)，RSquare = 0.986576。

下图是n ≤ 35时，三种算法的千次运行耗时比较。其中红色为O(1.618 ^ n)的递归法；蓝色为O(n)的递推法；绿色为O(log n)的矩阵法。散点为实际测量到的运行时间，实线为拟合方程的曲线。

三种算法的运行时间比较

当n > 10的时候，指数时间就已经超出画面范围了。另外在这张图里，身为对数时间复杂度的矩阵法似乎没有任何优势，其耗时远远高于线性时间复杂度的递推法。这是因为n还不够大，体现不出log(n)的优势。在考虑更大的n之前，先来看看指数时间复杂度会增大到什么程度。

三种算法的运行时间比较（对数坐标轴）

五、大整数情况下的复杂度

Python内置了大整数支持，因此上面的程序都可以直接接受任意大的n。当整数在32位或64位以内时，加法和乘法都是常数时间，但大整数情况下，这个时间就不能忽略了。

先来看一下Fibonacci数的二进制位数。我们知道Fibonacci数的通项公式是：

$F_n=\frac{1}{\sqrt5}\left(\frac{1+\sqrt5}{2}\right)^n-\frac{1}{\sqrt5}\left(\frac{1-\sqrt5}{2}\right)^n$

当n充分大（其实都不需要很大）的时候，第二项就可以忽略不计了。把第一项对2取对数，就可以得到Fibonacci数的二进制位数的近似表达式，大概是$\log_2{1.618}\times n-0.5\log_2{5}/2=\log_2{1.618}\times n-1.161=O(n)$。由此可以算出，F(47)是32位有符号整数可以表达的最大的Fibonacci数，F(93)是64位有符号整数可以表达的最大的Fibonacci数。上面图中的n在36以内，不需要动用大整数运算，复杂度也比较符合之前的结论。但对于更大的n，之前的复杂度就不再适用了。

指数复杂度的算法就不管了，还不等用到大整数，它就已经慢到不行了。

来看看O(n)时间复杂度的递推法。每次递推的时候都要计算两个Fibonacci数之和，第i次运算时，这两个Fibonacci数分别有O(i)个二进制位，完成加法需要O(i)的时间。因此总的时间大约是：

$\sum_{i=1}^n{O(i)}=O(n^2)$

可见对于很大的n，递推法的时间复杂度实际上是O(n ^ 2)的，空间复杂度是O(n)用来存储Fibonacci数的各个二进制位。

再看矩阵法，注意到矩阵运算中有乘法，两个长度为n的大整数相乘，传统算法是O(n ^ 2)时间复杂度，较好的Karatsuba算法是O(n ^ (log 3 / log 2))时间，更快的快速傅立叶变换法是O(n log n)时间。Python 2.5中使用的是Karatsuba算法（Python 3里面似乎是快速傅立叶变换法）（参见Python源码中的算法分析 之 大整数乘法）。以Karatsuba算法为例，矩阵法的时间复杂度递推方程为：$T(n)=T(n/2)+O(n^{\log_2{3}})$，应用Master定理求得$T(n)=O(n^{\log_2{3}})$。因此对于很大的n，矩阵法的时间复杂度为O(n ^ 1.585)，空间复杂度O(n)。

利用Mathematica对大n情况下这两种算法每千次运行时间进行拟合，分别得到：

• 递推法大整数拟合结果：0.0131216 + 0.000102101 * n + 2.44765 * 10 ^ -7 * n ^ 2，RSquare = 0.999482。
• 矩阵法大整数拟合结果：0.171487 + 9.74496 * 10 ^ -7 * n ^ 1.51827，RSquare = 0.998395。

看一下n在4000以内时，两种复杂度的对比情况：

递推法（蓝色）与矩阵法（绿色）运行时间比较（大整数）

从图中可以看出，递推法的增长速度也是很快的，当n增大到60多的时候，它的运行时间就超过矩阵法了。矩阵法的增长速度非常慢，看起来像是线性的，让我们把n调的更大来看一下。

矩阵法的运行时间（更大的n）

六、更快的算法？

试了试Mathematica中的Fibonacci函数，发现其运算速度相当惊人，估计时间复杂度在O(n log n)上下，而且对于相同的n，运算速度远远高于我的矩阵法。可惜我还不了解它的算法，只是在帮助文档里看到：

Fibonacci[n] uses an iterative method based on the binary digit sequence of n.

来看看它到底有多快：

矩阵法（绿色）与Mathematica Fibonacci函数（橙色）运行时间比较

好吧，这个问题留待以后慢慢研究。

最后相关的Mathematica命令文件放在这里：fibonacci_timecost

1. 单次遍历，带权随机选取问题（一）
2. 利用不均匀硬币产生等概率
3. 利用等概率Rand5产生等概率Rand3
4. 单次遍历，带权随机选取问题（二）
5. 单次遍历，等概率随机选取问题

平时设计或者阅读一个算法的时候，必然会提到算法的复杂度（包括时间复杂度和空间复杂度）。比如我们说一个二分查找算法的平均时间复杂度为O(log n)，快速排序可能是O(n log n)。那这里的O是什么意思？这样的表达是否准确呢？

今天来复习一下与算法复杂度相关的知识：函数渐进阶，记号O、Ω、θ和o；Master定理。

先插一句，在算法复杂度分析中，log通常表示以2为底的对数。

算法复杂度（算法复杂性）是用来衡量算法运行所需要的计算机资源（时间、空间）的量。通常我们利用渐进性态来描述算法的复杂度。

用n表示问题的规模，T(n)表示某个给定算法的复杂度。所谓渐进性态就是令n→∞时，T(n)中增长最快的那部分。严格的定义是：如果存在$\widetilde{T}(n)$，当n→∞时，有

$\frac{T(n)-\widetilde{T}(n)}{T(n)} \to 0$

就说$\widetilde{T}(n)$是T(n)当n→∞时的渐进性态。

比如T(n) = 2 * n ^ 2 + n log n + 3，那么显然它的渐进性态是 2 * n ^ 2，因为当n→∞时，后两项的增长速度要慢的多，可以忽略掉。引入渐进性态是为了简化算法复杂度的表达式，只考虑其中的主要因素。当比较两个算法复杂度的时候，如果他们的渐进复杂度的阶不相同，那只需要比较彼此的阶（忽略常数系数）就可以了。

总之，分析算法复杂度的时候，并不用严格演算出一个具体的公式，而是只需要分析当问题规模充分大的时候，复杂度在渐进意义下的阶。记号O、Ω、θ和o可以帮助我们了解函数渐进阶的大小。

假设有两个函数f(n)和g(n)，都是定义在正整数集上的正函数。上述四个记号的含义分别是：

• f(n) = O(g(n))：$\exists c>0,n_0\in\mathbb{N},\forall n\geq n_0,f(n)\leq c g(n)$；f的阶不高于g的阶。
• f(n) = Ω(g(n))：$\exists c>0,n_0\in\mathbb{N},\forall n\geq n_0,f(n)\geq c g(n)$；f的阶不低于g的阶。
• f(n) = θ(g(n))：$\iff f(n)=O(g(n))\&\&f(n)=\Omega(g(n))$；f的阶等于g的阶。
• f(n) = o(g(n))：$\forall\varepsilon > 0,\exists n_0\in \mathbb{N},\forall n\geq n_0,f(n)/g(n) < \varepsilon$；f的阶低于g的阶。

可见，记号O给出了函数f(n)在渐进意义下的上界（但不一定是最小的），相反，记号Ω给出的是下界（不一定是最大的）。如果上界与下界相同，表示f(n)和g(n)在渐进意义下是同阶的（θ），亦即复杂度一样。

列举一些常见的函数之间的渐进阶的关系：

• $\log n!=\Theta(n\log n)$
• $\log n^2=\Theta(\log n)$
• $\log n^2=O(\sqrt n)$
• $n=\Omega(\log^2n)$
• $\log^2n=\Omega(\log n)$
• $2^n=\Omega(n^2)$
• $2^n=O(3^n)$
• $n!=o(n^n)$
• $2^n=o(n!)$

有些人可能会把这几个记号跟算法的最坏、最好、平均情况复杂度混淆，它们有区别，也有一定的联系。

即使问题的规模相同，随着输入数据本身属性的不同，算法的处理时间也可能会不同。于是就有了最坏情况、最好情况和平均情况下算法复杂度的区别。它们从不同的角度反映了算法的效率，各有用处，也各有局限。

有时候也可以利用最坏情况、最好情况下算法复杂度来粗略地估计算法的性能。比如某个算法在最坏情况下时间复杂度为θ(n ^ 2)，最好情况下为θ(n)，那这个算法的复杂度一定是O(n ^ 2)、Ω(n)的。也就是说n ^ 2是该算法复杂度的上界，n是其下界。

接下来看看Master定理。

有些算法在处理一个较大规模的问题时，往往会把问题拆分成几个子问题，对其中的一个或多个问题递归地处理，并在分治之前或之后进行一些预处理、汇总处理。这时候我们可以得到关于这个算法复杂度的一个递推方程，求解此方程便能得到算法的复杂度。其中很常见的一种递推方程就是这样的：

设常数a >= 1，b > 1，f(n)为函数，T(n)为非负整数，T(n) = a T(n / b) + f(n)，则有：

1. 若$f(n)=O(n^{\log_b a-\varepsilon}),\varepsilon > 0$，那么$T(n)=\Theta(n^{\log_b a})$。
2. 若$f(n)=\Theta(n^{\log_b a})$，那么$T(n)=\Theta(n^{\log_b a}\log n)$
3. 若$f(n)=\Omega(n^{\log_b a+\varepsilon}),\varepsilon > 0$，并且对于某个常数c < 1和充分大的n有$a f(n/b)\leq c f(n)$，那么$T(n)=\Theta(f(n))$。

比如常见的二分查找算法，时间复杂度的递推方程为T(n) = T(n / 2) + θ(1)，显然有$n^{\log_b a}=n^0=\Theta(1)$，满足Master定理第二条，可以得到其时间复杂度为T(n) = θ(log n)。

再看一个例子，T(n) = 9 T(n / 3) + n，可知$n^{\log_b a}=n^2$，令ε取1，显然满足Master定理第一条，可以得到T(n) = θ(n ^ 2)。

来一个稍微复杂一点儿例子，T(n) = 3 T(n / 4) + n log n。$n^{\log_b a}=O(n^{0.793})$，取ε = 0.2，显然当c = 3 / 4时，对于充分大的n可以满足a * f(n / b) = 3 * (n / 4) * log(n / 4) <= (3 / 4) * n * log n = c * f(n)，符合Master定理第三条，因此求得T(n) = θ(n log n)。

运用Master定理的时候，有一点一定要特别注意，就是第一条和第三条中的ε必须大于零。如果无法找到大于零的ε，就不能使用这两条规则。

举个例子，T(n) = 2 T(n / 2) + n log n。可知$n^{\log_b a}=n^1$，而f(n) = n log n，显然不满足Master定理第二条。但对于第一条和第三条，也无法找到大于零的ε使得$n \log n=O(n^{1-\varepsilon})$或者$n \log n=\Omega(n^{1+\varepsilon})$，因此不能用Master定理求解，只能寻求别的方式求解。比如可以利用递归树求出该算法的复杂度为$T(n)=O(n \log^2{n})$。简单的说一下计算过程：

递归树的建立过程，就像是模拟算法的递推过程。树根对应的是输入的规模为n的问题，在递归处理子问题之外，还需要n log n的处理时间。然后根据递推公式给根节点添加子节点，每个子节点对应一个子问题。这里需要两个子节点，每个节点处理规模为n / 2的问题，分别需要(n / 2) * log(n / 2)的时间。因此在第二层一共需要n * (log n - 1)的时间。第三层节点就是将第二层的两个节点继续分裂开，得到四个各需要(n / 4) * log(n / 4)时间的节点，总的时间消耗为n * (log n - 2)。依此类推，第k（设树根为k = 0）层有2 ^ k的节点，总的时间为n * (log n - k)。而且可以知道，这棵树总共有log n层（最后一层每个节点只处理规模为1的子问题，无须再分治）。最后将每一层消耗的时间累加起来，得到：

$\sum_{k=0}^{\log n}{n(\log n-k)}=\frac{1}{2}n\log n(\log n + 1)=O(n\log^2{n})$

1. 单次遍历，带权随机选取问题（二）

第三章 深海鱼族的传说（最后的影之碎片）

新的旅行

回到卡卡里科村，林克遇见塔洛，他看到了林克的英雄之弓，又闹着要林克表演箭术，并要林克射中西北山丘房子顶上的一根木棒，就算是救世主。

要看清那么远的物体也还是有点勉强，林克只好到商店买了一副鹰眼（Hawkeye），有了这个就能够看清楚远处的物体了。林克一箭射中目标，孩子们都非常佩服林克，并给了林克一片心之碎片（射箭的时候不使用鹰眼才能得到心之碎片）。

买到了鹰眼

告别了孩子们，林克来到巴恩斯的炸弹商店，在这可以买到炸弹，利用它林克炸开村口泉水旁的一个石头，出现了一个山洞，林克进入后使用钢之靴潜入水中得到一个心之碎片，出来后在炸开的山洞正上方还有一个巨石，使用炸弹箭将其炸开，会发现另一个心之碎片。林克在村里做好了补给，准备继续去寻找失踪的伊莉娅。

拿到一个心之碎片

死寂的王城

走出卡卡里科村，林克来到海拉尔平原，经过艾尔丁大桥，没走多远，第三堵黑暗之墙前出现在林克面前，进入黑暗世界，不远处发现了伊莉娅留下的包裹，随后追随伊莉娅的气味，进入了海拉尔城堡（Hyrule Castle），跟着气味来到一间酒吧前，门是开着的。林克钻了进去，看到了伊莉娅，眼前还有一个陌生种族的病人，听到旁边的卫兵说这个可能是佐拉（Zora）族的后裔，通过他们的谈话还得知海利亚湖（Hylia Lake）是佐拉鱼人出没的地区，林克在桌子的地图上看到了海利亚湖的位置，既然伊莉娅安然无恙，那么就动身前往海利亚湖吧。来到海利亚大桥上，林克发现桥上撒满了火药，原来兽人们早就埋伏在了这里，兽人从两边点燃了火药，林克进退两难，底下又是海利亚湖，看来只有跳下去了，林克迅速把附近的箱子推到桥边，然后爬上去坠入了海利亚湖。

海利亚湖

冰湖，母爱

林克上岸后，来到一座奇怪的房屋前，听到房前的人说不远处有一个兽人弓箭手时常骚扰他，林克当然不会放过这个兽人弓箭手，看来这不是一个普通的弓箭手，他召唤来一只巨大的飞龙，骑到飞龙背上与林克周旋，就是这样林克也不会退缩，获胜后米德娜将飞龙驯服了。飞龙带着林克飞进了一个山洞，这里地势险要，稍不注意就会撞到峭壁上。飞出山洞，林克来到了佐拉河上游（Upper Zora’s River），这里的河床都结冰了，林克跳下河床，沿着冰川向东前进，随后米德娜会带着林克攀登上北边的冰川，到达冰川顶部后，进入最北边的洞穴。这里又遇到了三个黑暗使者，消灭后出现了这个地区的黑暗空洞。接下来来到已经被冰冻的佐拉王国，米德娜记起了死亡山上的一块炙热的巨石，传送回死亡山，米德娜发动魔法将巨石传送到佐拉王座处，炙热的巨石将整个冰河都融化了，随后佐拉女皇鲁特拉（Rutela）的亡魂出现，她向林克表示感谢，她还请求林克找到并解救王子拉里斯（Ralis），难道就是海拉尔城中那个正被伊莉娅照顾的佐拉人？女皇承诺如果林克完成任务的话，会赐予林克水中呼吸的能力。林克一路返回到海利亚湖，上岸后发现一个洞穴，林克进入后找到最后一个光之精灵，它将最后一个光之石交给林克。

完全结冰的海利亚湖

死亡山上炙热的巨石，利用它来融化湖水

拉内鲁地区

再见影子虫

林克又踏上了收集光之泪的旅程，在精灵之泉的右边道路上不远的地方就有一只，往北尽头处的湖边还有一只，南边的草丛中藏有一只，把草打掉就可以看到。林克向西边游去，在一个小半岛上也有一只，向海利亚湖的南边游去，上岸后林克发现灌木，在遇到阴影怪物的南边，在一排有空隙的石头中，来回跳跃，会发现一支正在挖洞的虫。米德娜告诉他可以在这里召唤之前被收服的飞龙，飞龙带着林克飞进之前的那个洞穴，整个洞穴里一共有四支小虫子，林克用感知可以轻松发现到处乱飞的虫，让飞龙撞击虫子收集光之泪（用Z键锁定目标，然后快速抓住，在飞行时不能转身，如果没有抓住所有虫子就回到河的尽头话，就不得不重来一次了）。来到佐拉河上游，林克看到这里的女主人正被虫子吓得发抖，消灭虫子后，林克在河对岸找到嚎叫之岩，记下金狼出现的位置后，林克继续收集光之泪。林克顺着河向佐拉原住地（Zora’s Domain）游去，在水域西边的斜坡上有一只，在湖东边靠近雪峰的冰峰道路旁，米德娜会帮助林克攀登上去，途中会有一只虫子，往回走在小梯子处转身向高处的岩石跳上，顺着小路林克来到佐拉王座，虫子就在左边的墙上，林克撞击墙壁惊动虫子，然后杀掉获得光之泪。林克回到佐拉河上游，东南角的水道有两个佐拉亡魂，他们会带林克进入水道，游出来到了海拉尔城的外边，进入城中，来到酒馆外面，打碎角落的箱子就能发现一只虫子。虫子消灭完了，但是光之泪还有一颗，会在哪里呢？此时米德娜会带林克来到最后一只虫子的地方——海利亚湖的正中间。这是一只巨大的母虫，看来她就是罪魁祸首，母虫全身带电的时候，没有办法攻击，林克只好先躲到水里等她冲下来，待其身上电消失后，林克跳到她身上一阵狂咬，没多久虫子就会倒在水里，林克跳到她身上发动群体攻击将其消灭，结束战斗后得到了最后的光之泪。最后一位光之精灵拉内鲁（Lanayru）也变回了原形，他告诉林克，这个世界本来就是黑暗与光明交替的世界，光明离不开黑暗，黑暗也离不开光明，一旦力量失去了平衡，这个世界就会陷入混乱。

光之精灵拉内鲁（Lanayru）向林克讲述这个世界光与影的故事

这是林克？

护送马车

林克暂时不能完全理解拉内鲁的话，不过林克知道此时他还有重任在身。变回人形的林克从精灵洞窟出来后，一直沿着桥走，到达一间屋子边，在这里花10元坐大炮去到湖的上端。上去后找路回到海拉尔城，城外可以遇到金狼，见到它后，不死勇士会再次出现教授林克新的绝技。进城后可以花点时间在王城里晃晃，之前有捉到金色虫子的话还可以去王城城下町的东南街道的虫子屋里换个更大的钱包。之后林克一路来到特尔玛（Telma）的酒馆，终于可以和伊莉娅团聚了，但是她确显得不那么高兴，原来拉里斯的状况很糟糕，不及时救治可能会有生命危险，特尔玛记起卡卡里科村有位医术高明的人，一定就是牧师雷那多了，准备好马车，护送的责任自然落到了林克身上，途中的桥上再次遇到兽人首领阻挡林克一行的去路，下场当然不会很好过，这次他穿上了盔甲，用剑砍是没辙了，不过林克的骑射技术也不是盖的，林克又一次将他打败。之后道路还比较忙碌，林克一边要防止飞鸟放炸弹（要用弓箭将它们清理干净，不然马车会不断的转圈），还要防止马车被兽人射手的火箭烧着（马车着火后，要及时用回力标灭火），最后林克安全将他们送到了卡卡里科村，王子得救了。

护送马车（感觉这里还挺难的，一定要要组织飞鸟放炸弹）

潜水服

此时佐拉女王应约出现，带着林克来佐拉王的墓穴，将佐拉之铠（Zora Armor）交给了林克，从此林克就可以在水中自由的呼吸行动了（摇杆上代表上浮，下代表下潜，A加速）。回到村中，来到巴恩斯的炸弹商店，他又研制出了新型的炸弹，这种炸弹可以在水里爆炸（要穿上铁鞋，脚沾地后才能使用），林克买下后马不停蹄地来到海利亚湖（可以炸开墓地湖中的石头走捷径），穿上佐拉之铠跳入湖中。林克游到水底，找到入口，但是被一个巨石堵住了，林克发现底下有一个裂缝，放个水炸弹将其炸开，水柱一下冲了出来，再放个水炸弹，借助水柱的冲力，炸弹会浮上去把巨石炸开，顺着洞一直往里游，林克来到了湖底神殿（Lakebed Temple）。

穿上潜水服，向湖底出发！

湖底神殿迷宫

湖底神殿迷宫地图

来到海利亚湖底部找到一堵有岩石的墙壁，在下面的水泡中放置一枚水炸弹，随后水泡会把炸弹浮上去并把岩石炸开，然后就可以进入迷宫了。顺着水道一直游到尽头上岸后向北前进，爬上梯子向前跳抓住天花板上的机关打开通向北边的门。

房间2：放出炸弹箭炸下天花板上的钟乳石使其落下，创造一条前进的路后朝北前进进入房间3。穿盔甲的怪物，要闪到后面才能伤害它，有了飞爪以后可以直接将它的甲夺走再杀。

房间3：房间中间有一个可以转动的楼梯，目前没办法控制，只能先从东边或西边的出口出去。一开始从梯子下去，在底部朝右边走，一直走到屋子的南边，然后跳过去抓住黄色的机关，可以转动台阶。再上到上层，到屋子上层的东边，同样抓住机关，这下可以通过底面西边的门来到房间4了。注意东北面的箱子里有地图。

房间4：用炸弹箭射下天花板上的钟乳石后，穿过隧道舷梯向右。通过岩石可以到达中央的石柱，可以看到附近还有一个钟乳石，往那边走，在箱子里能得到一把小钥匙，然后回到房间3，来到上层西边的门前，得到欧库，打开门进入房间5。

房间5：天花板上有钟乳石，打下来后可以借助其爬到墙上的藤蔓上。然后看到开关，跳过去抓住将它打开，接着向西北面移动。在西面林克能看到破损的墙壁， 先不管它，通过门来到南面，在南面的门处的箱子内可以得到小钥匙。有了这个，回到刚才看到的破墙那，炸开就可以通向房间6。

房间6：当林克到达水闸控制室这里，顺着屋子中间的洞来到北边。一路向前到达顶部的房间内，爬上梯子打开机关，开始放水。当水流入屋子后，可以直接跳进水中，找到水中心台子上的另一个机关，拉动机关让水流到房间3内。通过南面的门在水车下可以发现一个小精灵。

房间4：房间内的第三层开始转动，跳上去通过北面的门到达房间7。

房间7：这里有个装有小钥匙的箱子，拿到后返回房间4，通过转动的平台到达西面的门，从这里进入房间7，向前打开门可到达房间8。

房间8：在尽头有个岩石阻挡了去路，换上负重靴，下到水中，在石头下安置水炸弹，即可通过并前往房间9。

房间9：这里天花板上有一个小BOSS：青蛙。注意在他跳起来后地上的影子，躲开影子然后攻击他的舌头使其张开嘴，这时再向嘴里射炸弹箭便能将其消灭，并且还能得到道具飞爪（Clawshot）。用飞爪攻击屋子南面门上的机关使门打开后，回到房间3。

房间3：用飞爪可以在房间中心的吊灯上发现心之碎片，同样用飞爪也能在箱子内得到20卢比。然后到上层的西面使用飞爪击中机关，使楼梯转动，形成一个水渠，让进入房间的流水流向东面的出口。

房间10：熟练运用飞爪不断爬高，到达上层的出口进入房间11（另外藤条也可以用飞爪抓）。

房间11：利用飞爪朝东面移动进入房间12。

房间12：一直前进沿着旋梯上到顶部，途中的断处可以用飞爪通过，之后跳到机关上开始放水。这里有个箱子可以用飞爪上去后取得指南针。返回房间10。用飞爪击打东面的机关，下到下面的平台上，从东面的门到达房间13。

房间13：房间13有三条渠道，都通往南面。另外这里有2条路可以通往房间14，其中一条过去后发现拿不到钥匙，需要返回再朝左下游找到另一条路，接着可从上方跳到房间14并取得大钥匙，然后回到房间3水中台子上的通往最终房间的大门。

BOSS战：水底兽——摩菲尔（Twilit Aquatic——Morpheel）

穿上钢之靴降到水底后会遇到摩菲尔，第一阶段的时候会见到象海葵一样的它，远离周围的触手并保持在飞爪射程之内，然后将在其触手内不断移动的眼球抓出来进行攻击，中途摩菲尔会释放一些炸弹鱼进行干扰，如果抓到炸弹鱼的话要迅速离开其爆炸范围，几次攻击之后摩菲尔会露出本体。此后脱掉钢之靴游到摩菲尔的上方，找准时机锁定Boss的额头，用飞爪抓住其头顶处的眼睛后进行攻击，三次之后就可战胜摩菲尔。

湖底神殿迷宫中的机关

BOSS：水底兽——摩菲尔（Twilit Aquatic——Morpheel）第一阶段

BOSS：水底兽——摩菲尔（Twilit Aquatic——Morpheel）现出原形

参考：

• 《塞尔达传说：黄昏公主》图文全攻略 by WiiBbs 攻研部 Szh、三代鬼彻、天堂的翅膀
• 《塞尔达传说 黄昏公主》完美攻略研究 by www.cngba.com 鸡蛋
• Wii《塞尔达传说：黎明公主》流程攻略

1. 《塞尔达传说：黎明公主》攻略：剧情介绍
2. 《塞尔达传说：黎明公主》攻略：角色介绍
3. 《塞尔达传说：黎明公主》攻略：第二章 死亡山颠的咆哮
4. 《塞尔达传说：黎明公主》攻略：初章 英雄传说的扉页
5. U盘检测软件：ChipGenius，MyDiskTest

前几天在Matrix67的博客里看到了这个益智小游戏：Manufactoria，抽空玩了玩，虽然关卡不算多，但非常有趣。

这是个程序设计类的游戏，感觉就像是个状态机吧（有限自动机？），从纸带上读取数据，具有分支和写数据的功能，利用简单的几种元件组装成一台可以识别特定模式或者完成指定运算的机器。

游戏的背景大概是一家工业机器人（Industrial Robotics）生产厂请你（机器人工程师，Robotics Engineer）来测试和修复他们制造的机器人，所谓的“测试”就是对机器人内部纸带上的红蓝色点进行检测，判断其是否满足指定的模式；“修复”就是对纸带上的红蓝色点进行处理或者运算，产生指定的结果。这个游戏还支持自定义关卡，看到过有人提出求最大公约数之类的问题。

不知道别人是怎么思考的，反正我是先画想好用什么算法，然后在纸上画状态图把细节尤其是边界条件考虑清楚，然后开始布局，通过验证之后再不断地优化（减少使用的元件数量）。

开头几关非常简单，玩了七八关之后，每开启新的一关就在想，这怎么可能实现啊，但解决了之后又发现其实很简单。主要还是开始没有适应它的这种工作方式吧。

我的建议是每个程序员都应该玩一下这个游戏，我甚至考虑可以把它用在第一轮面试上，跟candidate随便聊聊天，让他玩一两关看看他的思路如何。

Matrix67的这篇博客是一年多之前发的了，后来我又找到了这个游戏的官方网站（http://pleasingfungus.com/#!/Manufactoria），发现游戏版本更新了，细节上有不少改进，增加了不少测试用例，统计出来的运行时间也有所变化（另外要注意的是，在新版本中如果想让两个传送带正交于某个方格，需要按Shift键，否则就会替换）。

（如果上面的Flash无法加载，可以尝试我在这里上传的：Manufactoria.swf。）

分享一下我在各关的解法（进入一个关卡，点击磁盘图标，在文本框中粘贴解法代码即可；注意贴入的代码中的关卡序号不需要与当前所在的关卡序号一致，游戏会自动跳转到正确的关卡，除非你还没有激活那一关）。另外很多关卡都有无数种解法，我一般会尽量优化使之元件个数最少（比较测试时间没有太大意义，一旦下一个版本的测试用例变化，测试时间就不一样了）。

下面这张图是游戏当前版本（v1.30）的关卡分布图，为了方便查找，我特意用红色字体添加了关卡序号在每关图标的左上角处。其中第29到31关是隐藏关，要通过了第24关才能显示出来。

Manufactoria主界面（添加了关卡序号）

我的各关卡解决方案（第30和31关没有时间优化了，其他关都是尽可能优化过的）：

?lvl=1&code=c12:6f3;c12:7f3;c12:8f3;

?lvl=2&code=c12:8f3;p12:6f2;c12:7f3;

?lvl=3&code=p12:5f3;c13:5f0;p11:6f2;c11:5f3;p11:8f2;c11:7f3;c11:9f3;c11:10f2;

?lvl=4&code=p12:6f3;c11:6f2;c12:7f3;c12:8f3;

?lvl=5&code=p12:4f3;c12:6f3;c12:7f3;c12:8f3;c12:9f3;c12:10f3;p11:4f6;p13:4f4;p11:5f6;p13:5f4;c12:5f3;

?lvl=6&code=c12:4f3;p12:5f2;p12:6f2;c12:8f3;c12:9f3;c12:10f3;p12:7f7;c13:7f0;c11:7f1;c11:6f1;c11:5f2;

?lvl=7&code=c12:8f3;c12:9f3;c12:10f3;c11:3f3;c11:6f1;c12:5f3;c12:6f3;c13:3f3;c13:6f1;c12:7f3;p12:4f3;p11:4f6;p11:5f0;p13:4f4;p13:5f2;

?lvl=8&code=p12:6f3;b11:6f3;r13:6f3;c11:7f2;c13:7f0;c12:7f3;c12:8f3;

?lvl=9&code=c12:7f3;c12:8f3;c12:9f3;p12:5f3;g11:5f2;y13:5f0;c12:6f3;

?lvl=10&code=g12:4f3;p12:5f3;b11:5f2;r13:5f0;y12:6f3;c12:7f3;c12:8f3;c12:9f3;c12:10f3;

?lvl=11&code=c12:8f3;c12:9f3;p12:5f3;p13:5f3;c11:5f2;c14:5f0;c12:6f3;c12:7f3;

?lvl=12&code=r12:4f3;r12:5f3;r12:6f3;c12:7f3;c12:8f3;c12:9f3;c12:10f3;

?lvl=13&code=c12:10f3;c12:11f3;c12:12f3;q12:2f7;y12:3f3;r12:4f2;c12:5f1;c12:7f3;c12:8f3;y13:2f0;q13:3f6;p13:4f6;q13:5f4;b13:6f3;q13:7f4;r13:8f1;b14:3f3;c14:4f0;c12:9f3;

?lvl=14&code=c12:10f3;c12:11f3;c12:12f3;q12:2f7;y12:3f3;c12:7f3;c12:8f3;y13:2f0;q13:3f6;q13:7f4;c14:4f0;c12:9f3;p13:4f2;r14:3f3;r13:6f3;b13:8f1;r12:4f2;q13:5f2;b14:5f1;

?lvl=14&code=c12:10f3;c12:11f3;c12:12f3;c12:8f3;c12:9f3;r12:4f3;p13:5f2;r13:7f3;q13:8f4;b13:9f1;b12:6f1;c12:5f2;q13:4f0;q13:6f4;q12:2f7;y13:2f0;y12:3f3;c13:3f1;

?lvl=15&code=c11:5f3;c13:5f3;c13:6f0;p11:11f3;c12:11f3;i11:12f7;c10:11f3;c10:12f2;p12:4f2;c12:3f3;c10:7f3;c10:8f2;c10:9f3;p11:7f3;c11:8f3;p11:9f3;c12:7f3;c12:8f0;c12:9f3;c12:10f0;c11:6f3;c12:6f0;c10:10f2;c11:10f3;p12:5f1;

?lvl=16&code=c12:4f3;p12:5f2;p12:6f3;c12:7f3;c12:8f3;c12:9f3;c12:10f3;p13:6f7;

?lvl=17&code=y12:4f3;c12:7f3;c12:8f3;c12:9f3;c12:10f3;p12:6f3;i12:5f7;p11:6f4;b11:7f1;p11:5f1;r10:5f2;q11:4f1;

?lvl=18&code=c10:4f2;b10:5f1;c11:4f2;p11:5f3;c12:4f3;p12:5f3;c13:4f0;p13:5f3;c14:4f0;r14:5f1;y12:3f3;q12:6f2;p12:7f3;p11:7f3;p13:7f3;y10:7f1;y14:7f1;c10:6f1;c14:6f1;c12:8f3;c12:9f3;c12:10f3;c12:11f3;

?lvl=19&code=c12:10f3;c12:11f3;c12:12f3;c12:6f3;c12:8f3;c12:9f3;g12:3f3;y12:4f3;q12:5f0;i12:2f7;c12:7f3;p15:3f3;b14:3f3;r16:3f3;c16:4f0;c15:4f0;y14:4f3;c13:5f0;q14:5f7;p14:6f1;r13:6f2;b15:6f0;c9:2f2;r9:3f1;c10:2f2;p10:3f1;c10:4f1;c10:5f1;c10:6f1;c11:2f2;b11:3f1;b11:4f0;p11:5f0;r11:6f0;b13:1f2;g13:2f2;p14:1f3;q14:2f1;r15:1f0;c15:2f3;

?lvl=20&code=c12:12f3;c12:6f3;c12:8f3;c9:2f2;r9:3f1;c10:2f2;p10:3f1;c10:4f1;c10:5f1;c10:6f1;c11:2f2;b11:3f1;b11:4f0;p11:5f0;r11:6f0;g12:3f3;y12:4f3;q12:5f0;i12:2f7;g13:2f2;q14:2f1;c15:2f3;p14:1f3;b13:1f2;r15:1f0;p15:3f3;b14:3f3;r16:3f3;c16:4f0;c15:4f0;y14:4f3;c13:5f0;q14:5f7;p14:6f1;r13:6f2;b15:6f0;y12:7f3;p11:7f7;p13:7f7;c11:8f1;c13:8f1;p12:9f3;q11:9f0;q13:9f6;p10:9f2;p14:9f0;r10:8f3;r14:10f1;b10:10f1;b14:8f3;q12:10f2;q12:11f2;

?lvl=21&code=c12:7f3;c12:8f3;c12:9f3;c12:10f3;c12:11f3;c12:12f3;c12:6f3;p12:3f3;c12:4f3;c12:5f3;y12:2f3;r8:2f2;p9:2f1;p9:3f4;b9:4f1;b10:1f3;p10:2f6;i10:3f1;c11:3f0;q11:2f1;

?lvl=22&code=c12:11f3;c12:12f3;c12:9f3;c12:10f3;c10:5f2;c10:7f1;g11:2f2;p11:3f0;y11:4f1;q11:6f7;q11:8f7;p12:3f3;c12:5f3;q12:6f7;q12:8f7;y13:3f0;q13:6f7;q13:8f7;c14:5f0;c14:7f1;c12:2f3;r12:4f3;r14:8f1;r10:8f1;p12:7f0;g10:6f1;c11:5f2;c13:5f0;y14:6f1;

?lvl=23&code=c12:12f3;c12:10f3;c12:11f3;c12:9f3;p12:4f3;p10:4f2;r10:3f3;b10:5f1;p14:4f0;r14:5f1;b14:3f3;c12:8f3;c11:3f2;c13:3f0;p12:6f3;b11:6f2;r13:6f0;y12:3f3;g12:2f3;g13:5f2;g11:5f0;q13:4f6;q11:4f0;q12:5f6;q12:7f2;

?lvl=24&code=c12:9f3;c12:10f3;c12:11f3;c12:6f3;c12:7f3;c12:8f3;c12:12f3;b10:3f3;c10:4f2;r10:5f1;p11:4f6;q11:5f4;y12:3f3;p12:4f3;c12:5f3;p13:4f4;q13:5f2;r14:3f3;c14:4f0;b14:5f1;q13:3f6;q11:3f0;c12:2f3;c11:2f2;c13:2f0;

?lvl=25&code=y12:5f3;p12:6f3;r11:6f2;b13:6f0;q12:7f2;c12:8f3;c12:9f3;

?lvl=26&code=y12:5f3;p12:6f3;c13:6f0;b11:6f2;q12:7f2;c12:8f3;c12:9f3;

?lvl=27&code=c12:10f3;g12:4f3;y12:5f3;p12:6f3;b11:6f2;q13:6f6;p14:6f0;b14:5f3;c13:5f0;r14:7f1;g13:7f2;q12:7f6;p12:8f3;b11:8f2;r13:8f0;q12:9f2;

?lvl=28&code=y12:3f3;c12:9f3;c12:10f3;c12:11f3;q11:5f5;p12:5f3;q13:5f1;c12:4f3;b11:4f2;r13:4f0;y10:5f3;y14:5f3;c10:6f2;c14:6f0;b11:6f2;r13:6f0;p12:6f3;c12:8f3;q12:7f2;

?lvl=29&code=p12:5f3;c12:9f3;c12:10f3;c12:11f3;p11:3f1;c11:4f1;q11:5f4;p13:3f1;c13:4f1;q13:5f2;r10:4f3;p10:5f2;b10:6f1;b14:4f3;p14:5f0;r14:6f1;q12:6f0;q12:7f0;c12:8f3;g12:3f3;c12:4f3;

?lvl=30&code=c12:4f3;g14:5f3;q11:5f1;q13:5f5;c14:7f3;q15:8f5;q13:8f1;g12:8f3;g16:8f3;c11:9f3;c13:9f3;c15:10f0;c14:10f0;c12:10f3;c12:12f2;c13:12f2;c14:12f2;c15:12f2;c16:12f2;c17:12f2;c18:12f1;c18:11f1;c18:10f1;c18:9f1;c18:8f1;c18:7f1;c18:6f1;c18:5f1;c18:4f1;c18:3f0;c17:3f0;c16:3f0;c15:3f0;c14:3f0;c13:3f0;q12:11f7;p12:5f7;c11:6f0;c14:6f3;p14:8f3;b13:7f2;r15:7f0;q12:9f3;g13:10f0;y11:10f2;b13:4f0;r11:4f2;q12:6f7;c14:9f2;c15:9f1;q16:10f3;c16:9f3;c17:10f3;c17:11f0;c16:11f0;c15:11f1;c9:12f2;c10:11f3;p10:12f7;q10:13f3;c11:11f0;q11:13f3;c6:9f3;c6:10f2;g7:8f3;q7:9f3;c7:10f2;b8:7f2;q8:8f1;c9:5f3;g9:6f3;c9:7f3;p9:8f3;c10:6f0;r10:7f0;q10:8f5;c9:9f2;c10:9f1;c11:8f2;c8:10f2;c9:10f2;c10:10f2;c8:9f3;g12:2f0;y11:2f3;c11:3f2;c12:3f3;c10:5f0;

?lvl=31&code=c18:5f1;c18:4f1;c18:3f0;c17:3f0;c16:3f0;c15:3f0;c14:3f0;r13:2f3;g12:2f2;g13:3f0;c12:3f0;p10:3f0;c11:3f0;q10:2f2;q10:4f6;r11:4f1;b11:2f3;g10:1f0;g10:5f2;i9:4f7;b6:8f3;g7:7f3;p7:8f3;b8:6f2;q8:7f1;b8:8f3;c9:6f3;p9:7f3;c9:8f2;r10:6f0;q10:7f5;c10:8f1;c11:7f2;b11:8f3;g12:7f3;p12:8f3;b13:6f2;q13:7f1;r13:8f3;c14:6f3;p14:7f3;c14:8f2;c14:9f0;r15:6f0;q15:7f5;c15:8f1;r15:9f0;g16:7f3;c16:8f3;c9:5f3;c11:5f2;c12:5f2;c13:5f2;c14:5f3;p15:10f0;r15:11f0;c16:9f3;c16:10f0;b6:11f2;p7:11f3;q7:12f3;r8:11f0;c8:12f2;q9:12f5;c7:10f3;r14:11f1;c14:10f0;c13:10f0;c12:10f0;c11:10f0;c10:10f0;c9:10f0;c8:10f0;b13:9f3;r11:9f3;c9:11f2;c10:11f2;c11:11f2;c12:11f2;c13:11f3;i13:12f5;c13:13f2;c14:13f2;c15:13f2;c16:13f2;c17:13f2;c18:13f1;c18:12f1;c18:11f1;c18:10f1;c18:9f1;c18:8f1;c18:7f1;c18:6f1;q10:12f6;c10:13f2;c11:13f2;g11:12f2;c14:12f2;c15:12f2;c16:12f2;c17:12f1;c17:11f1;c17:10f1;c17:9f1;c17:8f1;c17:7f1;c17:6f1;c17:5f0;c16:5f0;c15:5f0;g12:12f2;r8:9f3;b6:9f3;c6:10f2;i9:3f6;c8:4f2;c9:1f3;c9:2f3;c8:3f3;

～～～～～～～～～～ 分隔符 ～～～～～～～～～～

以下内容有剧透，三思而后看。

～～～～～～～～～～ 分隔符 ～～～～～～～～～～

Level 1: Robotoast! ACCEPT: Move robots from the entrance (top) to the exit (bottom)!

没有任何悬念，用3个元件，耗时32764（注意这是v1.30里的计时单位，在老版本中大概是0:02）。

Level 2: Robocoffee! If a robot's string starts with blue, accept. Otherwise, reject!

要求接受以蓝色开头的机器人。也没有任何可以商量的，3个元件，耗时24572。

Level 3: Robolamp! ACCEPT: if there are three or more blues!

要求接受纸带中有至少3个蓝点的机器人。8个元件，112570时间。

Level 4: Robofish! ACCEPT: if a robot contains NO red!

要求接受没有红点的机器人。4个元件，32764时间。

Level 5: Robobugs! ACCEPT: if the tape has only alternating colors!

如果纸带上的颜色是交替出现的（没有连续的红色或蓝色）就接受。6个元件，32900时间。

Level 6: Robocats! ACCEPT: if the tape ends with two blues!

如果最后两个颜色是蓝色则接受。11个元件，182272时间。

Level 7: Robobears! ACCEPT: Strings that begin and end with the same color!

如果第一个和最后一个色点颜色相同则接受。注意没有色点和只有一个色点这两种特殊情况。15个元件，176136时间。

Level 8: RC Cars! OUTPUT: The input, but with the first symbol at the end!

把第一个色点放到最后去。7个元件，49144时间。

Leve 9: Robocars! OUTPUT: Replace blue with green, and red with yellow!

把蓝色和红色分别换成了绿色和黄色。7个元件，229374时间。

Level 10: Robostilts! OUTPUT: Put a green at the beginning and a yellow at the end!

在色带的最前端放一个绿色，末尾处放一个黄色。毫无悬念，9个元件，53244时间。

Level 11: ACCEPT: With blue as 1 and red as 0, accept odd binary strings!

只接受奇数数字，也就是最后一位是蓝色的。至于空色带就无所谓了，严格来讲应该是不接受，但至少这个版本里没有这样的测试数据。8个元件，167931时间。

Level 12: Soldiers! OUTPUT: With blue as 1 and red as 0, multiply by 8!

要把输入的数字乘以8，程序员对这个应该是得心应手了，再末尾添加三个0（红色）即可。7个元件，65520时间。

Level 13: Officers! OUTPUT: With blue as 1 and red as 0, add 1 to the binary string!

给输入的数字做加1操作。开始的时候感觉是无法完成的，但仔细想想就很简单。加1操作，从二进制的角度来看，就是把末尾的1都变成0，最后一个0变成1。主要的难点是要从最后一位往前加，所以要不端地循环，每次都处理最后一个没有处理过的色点。另外在优化的时候发现，可以先把末尾的1变成黄色，这样就不需要再另外使用分隔符号了。分隔符用来标记字串的中止以及当前处理到的位置。

19个元件，81580时间。

Level 14: Generals! OUTPUT: Substract 1 from the binary string! (Input >= 1)

减1操作，跟第13关其实是一样的，红色和蓝色互换就好了。19个元件，79750时间。

但这一关还可以再稍微调整一下布局，变成18个元件，81686时间。

Level 15: Robotanks! ACCEPT: With blue as 1 and red as 0, accept binary strings > 15!

要求接受大于15的数字。也就是要求大于或等于16，即1后面至少有四个二进制位。于是就是要判断第一个蓝色后面是否至少有四个色点，不论颜色。25个元件，19958时间。

Level 16: Robospies! ACCEPT: With blue as 1 and red as 0, accept natural powers of four!

要求接受4的幂，也就是第一个蓝色后面必须恰好有偶数（包括0）个红色色点。注意要忽略掉开头的红色。8个元件，57372时间。

Level 17: Androids! ACCEPT: Some number of blue, then the same number of red!

要求纸带上的色点必须是若干个蓝色后面跟着同样数量的红色。开始也是觉得很难，主要是没有办法计数。当然解决办法就是一次一次循环，每次循环中判断一对红蓝色点。对于这种需要循环处理的问题，我一般都用一个黄色作为分隔符作为字符串的终结标记。12个元件，63041时间。

Level 18: Robo-children! ACCEPT: An equal number of blue and red, in any order!

判断色带上蓝色和红色的数量是否恰好相等。依旧是每次循环检查一对。23个元件，266582时间。

Level 19: Police! OUTPUT: Put a yellow in the middle of the (even-length) string!

输入的色带上有偶数个色点（不用判断是否满足），要求在中间位置插入一个黄色。这一关开始想了好久，排满了整个棋盘才搞定，后来一直优化到40个元件。想到了两种方案，一种是在颜色串的首尾各放一个色点，每次循环的时候让两个色点分别向中间移动一格，直到二者相遇。另一种是用起始位置放两个色点，每次循环的时候一个色点往后移动一格，另一个色点往后移动两个。我最后的优化版是采用第二种方法的。40个元件，291584时间。

如果输入的色带上有奇数个色点，那我的算法会在中间色点的后方插入黄色。

Level 20: Judiciary! ACCEPT: (Even-length) strings that repeat midway through!

判断色带上的色点（偶数个）是否恰好前半部分与后半部分的排列完全一样。比如如果前半部分是红蓝红红蓝，后半部分也必须是红蓝红红蓝。这一关我是直接利用了第19关和第29关（恰好我是先完成了第29关才回过头玩的这关），即先给这个颜色串的中间位置添加一个黄色（直接照搬第19关的布局），然后利用第29关的布局判断黄色分割的两个子串是否完全一致。

52个元件，319428时间。

Level 21: Teachers! ACCEPT: X blue, then X red, then X more blue, for any X!

要求色带上恰好是有若干个蓝色，跟着同样数目的红色和另外同样数目个蓝色。也可以是一个色点都没有。跟第17关的算法完全一样，只要再考虑考虑布局即可。

20个元件，76590时间。

Level 22: Politicians! ACCEPT: If there are exactly twice as many blues as red!

判断色带上蓝色是否恰好是红色的两倍。这一关其实跟第18关没有太大区别，一个简单高效的解决办法就是先把蓝色减半，然套用第18关的布局来检测减半后的蓝色是否与红色数目相等。

给蓝色减半的时候，比较传统的办法是用一个黄色作为色串终止符，从头开始，每读到一个红色就写一个红色，读到两个蓝色之后写一个蓝色。或着稍微变化一下，不用额外的黄色作终止符，而是在遍历的时候直接用黄色替换红色，用一个绿色替换两个蓝色。

用29个元件，296870时间。

Level 23: Academics! OUTPUT: Reverse the input string!

把输入的颜色串反转。基本的方法就是把第一个色点放到色串的最后，再把第二个色点放到倒数第二位。除了用一个黄色标记色串的终止外，在用一个绿色分割尚未处理的色串和部分反转了的色串。

用25个元素，227328时间。

Level 24: Engineers! ACCEPT: Perfectly symmetrical strings!

判断颜色串是否是对称的。也比较简单啦，每次用第一个色点做分支，在每个分支里判断最后一个色点，如果跟第一个一样则继续，否则丢弃。用25个元件，47696时间。

Level 25: Roborockets! OUTPUT: Swap blue for red, and red for blue!

把红蓝颜色互换。毫无悬念，7个元件，229374时间。

Level 26: Roboplanes! OUTPUT: All of the blue, but none of the red!

保留输入中的所有蓝色，丢掉红色。跟第25关唯一的区别就是遇到红色后不再写回到色带上。7个元件，22526时间。

Level 27: Rocket Planes! OUTPUT: The input, but with all blues moved to the front!

把输入中的蓝色都移动到红色的前面。

这一关有点儿意思，我最后设计的方法是直接利用第23关反转输入的方法。在第23关的布局中，中轴线左边是针对第一个是蓝色的处理，右边是针对第一个是红色的处理。在这一关里依旧保留右半边，但把左半边改成遇到蓝色就直接写一个蓝色回去。最后的效果就是不断地把红色往最后写，直到红色全都聚集到后半部分。

用16个元件，12390时间。

Level 28: Robomecha! OUTPUT: The input, but with the last symbol moved to the front!

把最后一个色点放到最前面。很简单，19个元件，606214时间。

Level 29: Seraphim! ACCEPT: Two identical strings, separated by a green!

判断由绿色点分开的两个色串是否完全相等。也挺简单的，补一个绿色作为终止符，取出色串一的第一个颜色，把其他的写回纸带，判断色串二的第一个颜色跟它是否一样；这时候两个色串都去掉了第一个颜色，而且刚好色串二跟色串一交换了顺序，再重复用同样的方法判断下去即可。21个元件，166182时间。

Level 30: Ophanim! ACCEPT: Read the tape as two numbers, A and B, split by a green: accept if A > B!

由绿色点分开的两个色串，从二进制数字的角度判断是否前一个数大于后一个数。

我用的方法是求B - A，当然不用记录完整的结果，只要记录借位状态即可。不过我没有再进行优化，现在用了88个元件，60617时间。估计能优化掉一小半的元件。

Level 31: Metatron! OUTPUT: Read the tape as two numbers, A and B, split by a green: output A + B!

计算被绿色分开的两个数字之和。基本上就是从最低位逐位加上去。同样是还没有优化，应该能减少一半以上的元件。现在用120个元件，108630时间。

之前在网上看到有好多人在讨论这道题，据说是一道Google的面试题。

问题描述：有两个长度均为 n 的整数数组 A 和 B，现在要从这两个数组中各抽出 s 个数字，分别构成两个新的数组 C 和 D，要求数组 C 和 D 的内积最大。

用数学语言描述一下题目，就是已知：$A=\left[a_1,a_2,\cdots,a_n\right]$，$B=\left[b_1,b_2,\cdots,b_n\right]$；

求：$C=\left[c_1,c_2,\cdots,c_s\right]$，$D=\left[d_1,d_2,\cdots,d_s\right]$，满足：$\forall c_i\in C,c_i\in A$，$\forall d_i\in D,d_i\in B$；

要使得 C、D 的内积（$C\cdot D=c_1d_1+c_2d_2+\dots+c_sd_s$）最大。

一、先考虑只有正数的情况：

当 s = 1 时，题目就退化成，从 n 个正整数中选取一个，从另外 n 个正整数中选取一个，使得乘积最大。显然，两次选取的都应该是那些数中最大的。

当 s > 1 时，我们分两步考虑，先考虑选取哪些数，再考虑这些数怎么配对。

1. 相信很多人都可以轻松地得出这样的结论：从 A 中选取最大的 s 个数构成 C，从 B 中选取最大的 s 个数构成 D，才有可能使得 C、D 内积最大。因为如果用A中的某个较小的数替换 C 中的任何一个数字，都会导致对应的乘积变小，从而整个内积变小。对于 D 也是类似的。

2. 对于选定的 C 和 D，如何配对呢？显然，应该让 C 中最大的数与 D 中最大的数相乘，C 中第二大的数与 D 中第二大的数相乘，以此类推。这个命题的证明也是很简单的，考虑任意两对数字：$c_i\leq c_j$，$d_k\leq d_l$，显然有

$\begin{array}{cl} & (c_id_k+c_jd_l)-(c_id_i+c_jd_k) \\ = & c_i(d_k-d_l)-c_j(d_k-d_l) \\ = & (c_i-c_j)(d_k-d_l) \\ \geq & 0 \end{array}$

因此，如果 A、B 全部都是正整数，那只需要分别排序后，从大到小选取 s 个数即可。

二、接下来考虑只有负数的情况：

只有负数跟只有正数是类似的，因为两个负数相乘的结果与这两个负数的绝对值相乘是一样的。根据上面的分析，我们只要对 A、B 分别排序后，从小到大（即绝对值从大到小）选取 s 个数即可。

三、再考虑两个数组一个全是正数，另一个全是负数的情况：

不妨设 A 中全是正数，B 中全是负数。

当 s = 1 时，题目就退化成，从 n 个正整数中选取一个，从另外 n 个负整数中选取一个，使得乘积最大。显然，两次选取的都应该是那些数中绝对值最小的（即最小的正数和最大的负数）。

当 s > 1 时，还是分两步考虑。

1. 很容易证明，应该从两个数组中分别选取绝对值最小的 s 个数（即正数数组中最小的 s 个数，负数数组中最大的 s 个数）。因为如果剩余的任何数字替换进来，都会导致对应的乘积的绝对值变大，乘积本身变小，从而整个内积变小。值得注意的是，很多人在这里容易出错，他们没有考虑到乘积为负数时，绝对值越大，乘积本身越小。

2. 对于选定的 C 和 D，如何配对呢？根据上面【一、2.】中的式子可以知道，我们还是要让最大的那对数相乘，第二大的那对数相乘，……。这里需要注意，也是很多人容易出错的地方，最大的那对数是正数中的最大值（绝对值也最大）和负数中的最大值（绝对值最小）。与全是正数时不同的一点是，两个数组都是正数时，最大的那对数的乘积恰好也是最大的；但一正一负的时候，最大的那对数的乘积并不一定是最大，最小的一对数的乘积也不一定是最小，但他们累加起来一定是最大的。比如 [1, 2] 和 [-1, -2]，正确的配对应该是2 * -1 + 1 * -2 = -4，而不是1 * -1 + 2 * -2 = -5。

四、几种特殊情况都考虑完了，最后就是正负数任意混合的一般情况。根据上面的分析，我们终归是要对 A 和 B 分别排序的，排序之后将两个数组的下标对齐，可以将两个数组分成三个部分，第一个部分中两个的数组元素都是负数（负数部分），第二个部分中一个数组元素都是负数而另一个都是正数（异号部分），第三个部分中两个数组的元素都是正数（正数部分），如下所示：

$\begin{matrix} A:&[&-&|&+&|&+&]\\ B:&[&-&|&-&|&+&] \end{matrix}$

由于负数部分和正数部分都产生正的乘积，我们需要同时考虑这两个部分。每次从这两个部分各选出绝对值最大的一对数，将乘积更大的那对从 A、B 中转移到 C、D 中，然后继续比较。

如果负数部分和正数部分都取完了，还缺 m 对数，那就从异号部分选取最小的 m 个正数，和最大的 m 个负数，对应配对即可。

算法示意：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
def MinInnerProduct(A, B, n, s):

  if not len(A) == len(B) == n or not 0 <= s <= n:

    raise Exception('Invalid arguments.')



  A.sort()

  B.sort()

  (C, D, sum) = ([], [], 0)

  (i, j) = (0, n - 1)



  while len(C) < s:

    val1 = A[i] * B[i]

    val2 = A[j] * B[j]

    if val1 < 0 and val2 < 0:

      break

    if val1 >= val2:

      C.append(A[i])

      D.append(B[i])

      sum += val1

      i += 1

    else:

      C.append(A[j])

      D.append(B[j])

      sum += val2

      j -= 1



  j -= s - len(C) - 1

  while len(C) < s:

    C.append(A[i])

    D.append(B[j])

    sum += A[i] * B[j]

    i += 1

    j += 1



  return (C, D, sum)

算法的空间复杂度为 O(s)，即用来存储 C、D 的空间；时间复杂度为 O(n log n)。

============ 并不华丽的分割线 ============

最后说个题外的事情。这是最后一篇从以前“钟磬居”网站备份回来的算法文章了。当年的钟磬居有如昙花一现，好多文章都只存在于Google Reader的缓存中了。让我没想到的是，刚才搜一个东西的时候，搜索结果第一条竟然是这篇文章。当然不是你看到的这一篇，而是之前发在钟磬居中被转载出去的。一字不差啊，连我加的粗体都还在，也保留了我当时文章中的一个错误（这里已经修正）。当时的钟磬居跟现在的GoCalf一样，看的人不算太少，但没有人评论。想起中学时喜欢的一句话“纵是昙花一现，也有一个月下赏花人，应无所憾”。送给逝去的钟磬居，鼓励一下自己。继续努力。

再次强调，本文不是转载，是原文，是从已经关闭了的网站中恢复回来的原文。GoCalf网站中，如无特殊说明，一律原创。

1. 任务调度问题：资源占用与释放
2. 利用等概率Rand5产生等概率Rand3
3. 在循环有序数组中查找指定元素
4. 单次遍历，带权随机选取问题（一）
5. 单次遍历，带权随机选取问题（二）

据说这是微软的一道面试题，谁知道呢。

问题描述：找出二叉树上任意两个指定结点的最近共同父结点（LCA，Least Common Ancestor）。

这算不上是一道算法题了，主要还是看数据结构基本知识和编程能力。

首先考虑最简单的情况——二叉树结点数据结构中有父指针。

这是不是非常简单呢？只要分别从两个结点出发向上走到树根，得到两个结点的分支路径，求出这两条路径相互重合部分的最靠下的结点，就是所求的LCA。这只需要 O(h) 的时空代价（设h是树高，n是树结点数目，平均情况下h = log(n)，最坏情况h = n）。

如果想再稍微节省一点儿时间和空间，可以先找出第一条分支路径，并用这些结点建立哈希表，然后从另外一个指定结点开始向上走到树根，每次遇到一个结点就到哈希表中查一下，一旦发现某个结点存在于哈希表中，这个结点就是所求的LCA。这个方法的代码示意如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def FindLCA(node1, node2):

  # Special cases.

  if not node1 or not node2:

    return None

  if node1 is node2:

    return node1



  # Get the first branch path.

  ancestors1 = set()

  while node1:

    ancestors1.add(node1)

    node1 = node1.parent



  # Check if any ancestor of node2 is in the first branch path.

  while node2:

    if node2 in ancestors1:

      return node2    # Got it, the LCA.

    node2 = node2.parent



  # These two nodes have no common ancestor.

  return None

这样确实很简单，但实际情况是，通常二叉树结点中并没有父结点指针，这时候就要遍历二叉树找到这两个结点，并找出它们的LCA。

实际上，在遍历二叉树的时候，很容易就能够记录下根结点到任何结点的分支路径，只要有了分支路径，就可以对比找出LCA。

我们采取前序遍历，即N-L-R的顺序，使用堆栈来避免递归并且记录完整的分支路径。那么，在二叉树中查找指定结点的算法可以这样写：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class Dir:

  (Undef, Left, Right) = range(3)



def FindNodes(root, nodeSet, findAll=True):

  if not root or not nodeSet:

    return None



  pathDict = {}

  path = []

  curr = root

  while curr or path:

    while curr:   # Go down along left branch

      path.append((curr, Dir.Left))

      if curr in nodeSet:

        pathDict[curr] = list(path)

        nodeSet.remove(curr)

        if not nodeSet or not findAll:

          return pathDict

      curr = curr.left

    (curr, dir) = path.pop()

    while dir == Dir.Right:   # Back from right branch

      if not path: return pathDict

      (curr, dir) = path.pop()

    path.append((curr, Dir.Right))  # Trun to right from left

    curr = curr.right



  return pathDict

其中Dir这个类相当于是一个枚举，用来定义当前的分支方向。FindNodes除了需要二叉树根结点外，还需要一个待查找的结点集合。这个函数可以在二叉树中找到所有（或第一个）待查找结点的分支路径，并返回一个字典（结点 --> 路径）。

可以看出，FindNodes函数按照前序顺序遍历整个二叉树，查找指定结点。每遇到一个结点，首先判断它是不是我们要找的，如果不是就沿着左边的分支下降到底，然后转入右侧分支。

有了FindNodes函数的支持，我们就可改写前面的FindLCA函数，即先遍历二叉树求出两个结点的分支路径，然后比较这两条路径找出LCA：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
def FindLCA(root, node1, node2):

  # Special cases.

  if not root or not node1 or not node2:

    return None

  if node1 is node2:

    return node1



  # Try to find the two nodes in the tree, and get their branch paths.

  nodeSet = set([node1, node2])

  pathDict = FindNodes(root, nodeSet)

  if nodeSet:

    return None



  path1 = [i[0] for i in pathDict[node1]]

  path2 = [i[0] for i in pathDict[node2]]



  # Compare the two paths, find out the LCA.

  lca = None

  minLen = min(len(path1), len(path2))

  for i in xrange(minLen):

    if path1[i] is not path2[i]:

      break

    lca = path1[i]



  return lca

遍历二叉树查找所有指定的结点需要 O(n) 时间，O(h) 额外空间；对比两条分支路径需要 O(h) 的时间，因此总的时间代价为 O(n)，空间代价为 O(h)。

1. 在循环有序数组中查找指定元素
2. 利用等概率Rand5产生等概率Rand3
3. 程序基本功之遍历二叉树
4. 计算斐波纳契数，分析算法复杂度
5. 单次遍历，带权随机选取问题（一）

据说这是2009年Google暑期实习招聘的笔试题。

问题描述：有n个任务，第i个任务运行时需要使用 R[i] 的资源，运行完毕后需要占用 O[i] 的资源（O[i] <= R[i]），假设现在我们总共有s的资源，要求设计一个调度算法，能保证所有任务能顺利执行；如果无法执行完，需要说明理由。

举例：比如有n = 2个任务，R[1] = 10，O[1] = 2，R[2] = 5，O[2] = 3，总资源s = 10。如果先执行任务1，剩余资源10 - 2 = 8，可以执行任务2；反过来先执行任务2，剩余资源10 - 3 = 7，7 < r[1] = 10，无法执行任务1。

这道题的解法很简单，按照 R - O 从大到小排序就是可行的调度顺序，如果按照这个顺序无法执行完所有任务，那么其他任何顺序也都不行；反之，如果存在某个顺序使得所有任务能顺利执行，那么这个顺序一定也可以。

先看算法，稍后再做证明。

1
2
3
4
5
6
7
8
9
10
11
12
def ScheduleTasks(R, O, n, s):

  # R: request

  # O: occupancy

  # R - O: temporal = request - occupancy

  tasks = [(i, R[i], O[i], R[i] - O[i]) for i in xrange(n)]

  tasks.sort(key=operator.itemgetter(-1), reverse=True)

  for i in xrange(n):

    (taskId, req, occ, temp) = tasks[i]

    if req > s or occ > s:

      return (False, tasks)

    s -= occ

  return (True, tasks)

显然这是贪心法，那么贪心法是否一定能得到可行解呢？

假设存在一个可行解（任务的执行顺序）为：T1, T2, …, Tn。设其中存在两个相邻的任务 Ti 和 Ti+1，满足 R[i] - O[i] < R[i+1] - O[i+1]。

设执行任务j前的资源剩余量为s’，因为这是一个可行解，任务j和任务k都可以顺利执行，因此有：s’ - O[i] >= R[i+1]。

联列这两个式子可以得到：s’ >= R[i+1] + O[i] > R[i] + O[i+1]，即s’ - O[i+1] > R[i]，可见交换任务 Ti 和 Ti+1 的执行顺序后依旧是可行解。

以此类推，对于任何i（1 <= i < n），如果 R[i] - O[i] < R[i+1] - O[i+1]，我们都可以将这两个任务的顺序交换，最终得到的执行顺序是可行解。

综上所述，按照 R - O 从大到小排列所有的任务是可行解。

1. 求内积最大的子数组

问题描述：在单向链表中，每个结点都包含一个指向下一个结点的指针，最后一个结点的这个指针被设置为空。但如果把最后一个结点的指针指向链表中存在的某个结点，就会形成一个环，在顺序遍历链表的时候，程序就会陷入死循环。我们的问题就是，如何检测一个链表中是否有环，如果检测到环，如何确定环的入口点（即求出环长，环前面的链长）。

一种比较耗空间的做法是，从头开始遍历链表，把每次访问到的结点（或其地址）存入一个集合（hashset）或字典（dictionary），如果发现某个结点已经被访问过了，就表示这个链表存在环，并且这个结点就是环的入口点。这需要O(N)空间和O(N)时间，其中N是链表中结点的数目。

如果要求只是用O(1)空间、O(N)时间，应该怎么处理呢？

其实很简单，想象一下在跑道上跑步：两个速度不同的人在操场跑道上一圈一圈地跑，他们总会有相遇的时候。因此我们只需要准备两个指针，同时从链表头出发，一个每次往前走一步，另一个每次往前走两步。如果链表没有环，那么经过一段时间，第二个（速度较快的）指针就会到达终点；但如果链表中有环，两个指针就会在环里转圈，并会在某个时刻相遇。

大家也许会问，这两个指针要在环里转多少圈才能相遇呢？会不会转几千几万圈都无法相遇？实际上，第一个（速度慢的）指针在环里转满一圈之前，两个指针必然相遇。不妨设环长为L，第一个指针P1第一次进入环时，第二个指针P2在P1前方第a个结点处（0 < a < L），设经过x次移动后两个指针相遇，那么应该有0+x = a + 2x (mod L)，显然x = L-a。下面这张图可以清晰地表明这种关系，经过x = L-a次移动，P1向前移动了L-a个位置（相当于后退了a），到达P1′处，而P2向前移动了2L-2a个位置（相当于后退了2a），到达P2′处，显然P1′和P2′是同一点。

慢指针（P1）转一周之内，必然与快指针（P2）相遇

在知道链表内有环后，求环长是一件非常简单的事情，只要从刚才那个相遇点开始，固定P2，继续移动P1，直到P1与P2再次相遇，所经过的步数就是环长。

怎么求环前面那段子链的长度呢？很简单，让P1和P2都回到链表起点，然后让P2先往前走L次（每次往前走一步），然后P1和P2再同时往前走，当它们再次相遇时，P1所走的步数就是环前面的子链长度。

算法示意：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
def CheckRing(head):

  l1 = 0  # length of the chain before the ring

  l2 = 0  # length of the ring



  # Check if there is a ring.

  pos1 = head

  pos2 = head

  while pos2 and pos2.next:

    pos1 = pos1.next

    pos2 = pos2.next.next

    l1 += 2

    if pos2 and pos1 == pos2:

      l2 = 1

      break

  if not l2:

    if pos2: l1 += 1

    return (l1, l2)  # l2 should be 0



  # Calc the length of the ring.

  pos1 = pos2.next

  while pos1 != pos2:

    pos1 = pos1.next

    l2 += 1



  # Calc the length of the chain before the ring.

  l1 = 0

  pos1 = head

  pos2 = head

  for i in xrange(l2):

    pos2 = pos2.next

  while pos1 != pos2:

    pos1 = pos1.next

    pos2 = pos2.next

    l1 += 1

  return (l1, l2)

1. 在循环有序数组中查找指定元素
2. 利用不均匀硬币产生等概率
3. 计算斐波纳契数，分析算法复杂度
4. 单次遍历，带权随机选取问题（一）
5. 求二叉树中两结点的最小公共祖先

第二章 死亡山巅的咆哮（大地的子民）

打倒达巴巴之后，林克得到一个完整的心之容器（加一格血）。

米德娜出现并将林克传送回法隆之泉处，顺路来到柯洛处，可以补充一点灯油，之前关上的栅栏打开了，过去后就来到海拉尔平原（Hyrule Field）。

海拉尔平原

森林复苏

顺路一直往平原的北面走，途中会遇到一位滑稽的邮递员，他告诉林克，他奔波于世界各地为大家送邮件，无论以后林克在哪里，他都会及时把邮件送到。从北面的小径离开海拉尔平原后，林克来到第二堵黑暗之墙的面前，米德娜带着林克进入了黑暗世界，林克又变成了狼的形态。顺着路没走多远便发现了塔洛掉下的剑，林克嗅了嗅，可以通过感知追踪孩子们留下的气味，跟随气味一直来到一断桥处，这里又遇见了暗影使者，打倒后，天空出现了黑暗空洞，米德娜告诉林克，她可以发动魔法让林克在两个黑暗空洞之间来回传送。前方没路了，林克只好让米德娜开启传送门回到森之神殿之前的那片地区，还记得当时看到的遗留在路旁的桥体吗?在桥体处，米德娜发动魔法，将桥体移到之前的断桥处修通道路，过桥之后顺着路走可以进入卡卡里科村（Kakariko Village）。

林克来到海拉尔平原（Hyrule Field）

卡卡里科村

被黑暗覆盖的小镇

刚刚到村口又遇到了暗影使者，比较有难度的是其中一个始终与另两个保持一定距离，林克只好先把远处的一个杀掉再迅速把其余两个同时干掉。此时泉水处出现了第三位光之精灵，但是由于黑暗力量的笼罩，它还无法现出真身，它交给林克第二个光之容器，让林克收集散落在卡卡里科村的光之泪。进入卡卡里科村后，发现这里面基本每个房子里都有携带光之泪的虫子。不过林克还是很担心孩子们，他顺着气温来到村子门口的一座建筑前，但是林克在狼形态下是无法开门的，他围着房子转了转，米德娜告诉林克可以借助树枝跳到屋顶，这个主意不错，来到屋顶后，林克从中间的洞跳了下去。孩子们都在这里，林克一下安心了，不过这里还有一些林克不认识的人，林克通过感知听到了他们的谈话，原来都是村里的居民，他们都很害怕，不过柯林坚信林克一定会回来救他们，米德娜嘲笑林克，林克要保护的人就在眼前，但是现在的林克却无能为力，没办法，林克只好暂时离开。林克捡起地上的木棍，到火台上点燃后，把房内的蜡烛全部引燃（可以发现三只虫子），房子中间的雕像移开，出现了一条地道，林克顺着地道出了房间。

卡卡里科村（Kakariko Village）被黑暗覆盖，需要收集光之泪

通过地道林克来到了卡卡里科墓地（Graveyard），发现这里有携带着光之泪的虫子，杀掉后，林克回到村子里，来到商店（General Store）的房子右边，林克发现大楼的底部有个小洞，钻进去找到虫子，干掉它收集到光之泪，再原路出来。林克来到商店南边，走上坡道，这里是艾尔德旅馆（Elde Inn）。跃进旅馆的阳台，跳到下面的地板上，虫子藏在壁炉里不出来，聪明的林克从壁炉里取出一支木棒，再跳到桌子附近的火炬那里点燃，然后引燃壁炉，把烟囱里的虫子给驱赶出来，另一支虫子要进入旅馆大厅，走上楼梯，在客房里找到。出来后林克来到住宅区（Residential House），在街的西面，这个房子里有另一只虫，穿过南边的2间房子，发现有个可以跳上的坡道，然后跳过一个个房顶，直到有虫子的那间房子的屋顶，林克发现这里房顶有个裂缝，可以从这下到房子内。林克把木箱子推向墙壁后，虫子从下面窜了出来，杀了它得到光之泪后，米德娜会带着林克跳出去。林克来到巴恩斯的炸弹商店（Barnes Bomb shop），在这个大型建筑物的北面，找到一些可以攀爬的箱子，然后爬上屋顶。然后可以看到炸弹商店的一扇窗户，林克勇猛地撞碎玻璃跳了进去，直接来到楼上然后撞击书架，就会有虫子飞出来，得到光之泪后爬上棚架，林克发现了出口。从炸弹商店的窗口爬出来，林克发现自己已经上到了西北山丘（The Northwestern Hills），顺着路向上，林克来到一个标着"Danger!"的建筑物面前。进到房子里面，林克发现这里到处都是火药，虫子也藏在角落里，林克没有办法，只好在地上捡起一根木棍，引燃木棍后，用它来把壁炉点着，火星蹦了出来，火药被点燃了，林克见状赶紧原路跑开。刚一出房子，只听身后一声巨响，连屋带虫一起化为了灰烬，林克也得到了三颗光之泪。林克顺着斜坡上到了山顶，这里的房里可以找到一条虫子，村里已经没有虫子了，但是光之泪还没有收集全，看来有虫子飞到了更远的地方去了。林克只好从村子北面的一个大山洞出村，一路来到死亡山（Death Mountain）的脚下。

在屋顶上看到炸弹商店的一扇窗户，可以撞碎玻璃跳进去

死亡山

在米德娜的帮助下跳上了一个峭壁，林克顺着路往山上走，一路上还要躲过一连串的热泉。林克在这片区域中找到了三只虫子，解决掉后继续前进，不远处有一个嚎叫之岩（Howling Shrine），林克隐约听到嚎叫之岩会发出狼的嚎声，狼形态下的林克跟着听到的声音也嚎叫了起来，原来是林克的嚎声引起了远方金狼的共鸣，难道就是上次教林克绝技的那只狼？带着疑问，林克继续前进，再次遇到了黑暗使者，这次数量增加到了四个，但是林克还是轻松取胜，之后便开启了死亡山的黑暗空洞。光之泪还没收集齐，林克只好继续前进，米德娜带着林克不断向上跳，来到一个盆地处，跳下去解决掉虫子，最后一颗光之泪终于到手了，卡卡里科村净化完成，村子又重新回到了光明的怀抱。

死亡山

大地之民族

林克回到村口的泉水处，第三位光之精灵艾尔丁（Eldin）也恢复了其真实的形态，艾尔丁告诉林克，死亡山上的戈隆一族有着能够帮助林克的宝物，看来林克只有上山去拜访戈隆一族了。

恢复了真实的形态的第三位光之精灵艾尔丁（Eldin）

村里的村民和小孩们都被解救出来了，柯林非常高兴，他就知道林克会来救大家，可是马洛和塔洛还是很不服气，怪林克那么晚才来，这时当初在房子看到的陌生人上前来自我介绍，原来他叫雷那多（Renado），是村里的牧师，另外一位就是炸弹店的老板巴恩斯，雷那多告诉林克，孩子们在这里很安全，让林克放心去找伊莉娅。林克也很担心伊莉娅，于是继续上路，林克再次前往死亡山，刚爬上峭壁，却发现有个戈隆人挡路，两句话不对戈隆人毫不客气地将林克撞了下来，看来暂时是没法上去了，只得离开。回到村里，雷那多告诉林克，奥东村的村长布有办法对付挡路的戈隆人。那不是林克的家乡么，很久没回去了，林克也挺想念大家的，于是打算回奥东村一趟，顺便找村长布想办法帮忙。林克正在犯愁，离家乡那么远，怎么回去呢？正在这时艾普娜出现，可能是很久没见了，艾普娜有点兴奋，林克跳到艾普娜背上试图让她安静下来，骑上之后，按屏幕下方出现的提示做就可以了，一开始是利用左手手柄左右晃动，最后一下则是按A（看见“SEIZE”提示时），将马驯服，艾普娜又变得跟往常一样温和了。

艾普娜过于兴奋，林克跳到她背上试图让她安静下来

奥东村

相扑！！

林克骑着艾普娜飞奔，很快便回到了法隆森林，经过奥东之泉时，林克想起了在死亡山上遇到金狼的事情，来到奥东之泉看到了金狼蹲在那里，林克走上前，金狼又是二话没说扑了上来，一阵眩晕后，不死勇士再次出现，看来林克又可以学到新的技能了。学会新的技能后，林克回到奥东村，径直来到村长布的家，林克向村长表明了来意，布将林克带到了里屋，他准备给林克传授摔跤的技能，聪明的林克没一会儿就学会了（第一局很容易，只要闪避后按住A攻击就可以了；第二局则要闪避后，挥动右手手柄击打对手，然后再按A攻击），学会了摔跤，就不怕戈隆人了，当林克正准备离去，村长又将自己的宝物钢之靴（Iron Boots）交给了林克，这对林克将来的冒险大有帮助。告别村长，林克打算去拜访老朋友农场主，农场主看到林克回来了也很高兴，他有件神秘的礼物准备送给林克，但条件是要林克打破他的赶羊纪录，这对林克来说再简单不过了，打破他的纪录后林克得到了一块心之碎片。随后告别农场主，该是继续冒险的时候了。

勇敢的少年

林克回到卡卡里科村，刚进村子就看见兽人来袭，带头的兽人首领凶残地撞向贝思，柯林挺身而出推开了贝思，自己却被兽人首领撞到并抓走了。愤怒的林克快马加鞭地追赶了上去，第一场强制马上战！一路追到海拉尔平原上，兽人头领会不断招呼喽啰来阻拦林克，不过都被林克轻松搞定（如果怕麻烦又臂力超群的话，可以挥剑来斩射来的箭，然后完全无视小怪），林克在重创兽人首领后，其带着柯林向艾尔丁大桥逃去，林克追了上去，这时又出现了兽人弓箭手，用火箭点燃了早已准备好的草堆封住了桥头两边的去路，一场生死决斗在所难免，单挑战中，接近头目时注意快速回避，同时狂挥右手的手柄，成功的话一击就可以KO。兽人首领也不是林克的对手，最后林克挥剑将兽人首领击落桥下，林克带着受伤的柯林回到卡卡里科村，林克看着柯林非常难过，柯林告诉林克，他已经将林克作为自己的目标，将来也要像林克一样勇敢强壮，柯林的话给了林克很大的鼓舞，林克振作起来，再次来到死亡山脚下。

与兽人首领之间的一场马上战斗

在艾尔丁大桥上与兽人首领生死决斗

骑马战胜兽人的林克，英姿飒爽

上山

准备上山，上山前记得到村子新开的杂货店（入口第一间）买个铁盾牌，后面迷宫里会有很多敌人会火系攻击，现在的木盾很容易会被火烧掉。上山后林克穿上了重力靴，加上布所教授的摔跤技巧，挡路的戈隆人就拿林克没办法了。一路前进，途中还会遇到一些好斗的戈隆人，但是也有好心的戈隆人会帮林克跳上峭壁，峭壁喷出上的蒸汽，只要林克穿上钢之靴就能顺利通过。一直来到山顶的洞穴中，这里会遇到戈隆族的领袖，林克表明了来意，但是显然林克想要的宝物没在这里，但是戈隆族长告诉林克，戈隆矿山（Goron Mines）是他们世代守护的地方，现在被黑暗势力所侵吞了，而且他们有位伙伴被黑暗势力魔化了并关在矿山最深处，希望林克能帮助他们救出同伴，驱赶黑暗势力。林克爽快答应下，但是族长还是不太放心，要考验一下林克的实力，戈隆族长果然很强，一下就将林克推下擂台，林克只好穿上钢之靴后再上去挑战，战胜戈隆族长后，他终于放心的让林克进入了戈隆矿山。

戈隆矿山迷宫

戈隆矿山迷宫地图

房间1：林克进入戈隆矿山，这里到处都是炙热的岩浆，利用钢之靴可以关闭喷火的机关，不过有时间限制，必须快速通过。北面的门要先从右边的路上到第二层，用同样的方法按下按钮关闭第二个喷火机关后快速通过，之后再用钢之靴站到门旁边的开关上打开门进入房间2。

房间2：这里先用钢之靴压下开关可以启动磁力机，穿着钢之靴站在其磁力范围内的话会被吸上去，利用它到房间西南角能够得到一把小钥匙，之后用它打开东边的门前往房间3。

房间3：这里的火蜥蜴只有攻击它们的尾巴时才能对其造成伤害，当它们向你吐火的时候，绕着它们跑，抓住时机使用旋转剑法。去房间3的西北角，然后从外面绕过去后可以见到链子开关，穿上钢之靴能够将之拉出来，然后迅速绕回来在墙关闭之前朝东面进入房间4。

房间4：来到房间4，这个房间要先用钢之靴沉入水底，然后穿过水低铁丝网上的洞，到最北面的按钮可以激活磁场，这样钢之靴就可以吸附在天花板上行动，不过只能在有磁矿的墙面上行走，继续前进来到5号房间。

房间5：这里能见到一位戈隆长老，他将大钥匙的一部分交到林克手上，并告诉林克，想要打开关押他们同伴的大门还必须找到剩下的两部分钥匙。林克接过钥匙后从长老后面的楼梯上到二层，途中可以遇到戈隆矿山的欧库。利用钢之靴通过有水的房间后回到房间3，在西北角有个心之碎片，然后回到东南边找到门，跳下去回到房间2。这时林克来到房间2的上部，可以开启另一个磁力机，于是便能向北边前进进入房间6。

房间6：把里面的敌人都解决掉，西北角的水里能够找到一把小钥匙，之后过去找到开关，可以激活磁场上到天花板上，沿着天花板走到高台上然后跳下来，启动另一个机关之后脱掉钢之靴跳下，在进入磁力范围时再穿上钢之靴就能被磁力吸到对面的墙壁上，之后走到平台上击打状态转换水晶，可以打开大门，林克迅速进入，再次穿上钢之靴走到高台上，林克在右边的高台找到一个心之碎片，来到左边砍断绳索放下大门，就是去房间7的路。

房间7：跳下进入房间7，这里正东面有把小钥匙，有了它林克就能打开通往西面的门了前往房间8了。

房间8：来到房间8，在右边的平台上有一把小钥匙，拿到之后可以前往房间9。

房间9：到房间9找到第二位长老，他会给林克大钥匙的第二部分，之后从长老后面的楼梯上去回到房间8的上层，然后前往房间10。

房间10：在房间10里，林克遇到小BOSS，一个狂暴的戈隆勇士，穿上钢之靴与其战斗，把他打在地上缩作一团时，可以冲上前将其丢下岩浆，不过他还不肯轻易罢休，看来还得费点力气，战胜后，林克进入南面的小房间内，这里的箱子内可以拿到英雄之弓（Hero’s Bow），看来这就是牧师雷那多告诉林克的戈隆族的宝物，林克用它射断面前平台上的绳索，于是就能进入到南面的房间11了。

房间11：房间11里有很多石像，正当林克上前查看时，石像被激活了，用箭射它们上部的红水晶能让其停止攻击，之后就可以将它们往外拉。林克在房间的东面能够得到指南针，继续前进走西面的房间来到房间12。

房间12：林克见到了最后一位长老，并得到最后一部分的大钥匙，得到大钥匙后，就可以去矿山深处解救狂暴的戈隆族同伴了。

房间13：林克前进来到房间13，这里的天花板上有许多火焰虫，用弓箭将它们射掉，来到门前，利用旁边的开关，上到天花板上，林克会发现在门的上面有一个状态水晶，掏出弓箭射击水晶即可打开门。

房间7：一路回到房间7，到之前有个活动石像的地方，就在房间最东面。用弓箭干掉它并将其拉出来，通过背后的路来到房间7的高处，打开磁力机，林克穿上钢之靴吸附到磁力机上，用弓箭射断东北方的桥索来到房间14，消灭所有的怪后，林克站到了关押狂暴的戈隆族人的门前。

戈隆矿山迷宫房间7

BOSS战：福里乌斯（Twilit Iginiter——Fryus）

进门后看到福里乌斯，林克先用弓箭射其头顶发光的宝石，射中后他会痛苦得到处乱撞，林克迅速上前抓住他的脚链并换上钢之靴向后拖，福里乌斯会绊倒在地上，这时迅速上前挥砍其头顶的宝石，几个回合后，福里乌斯头顶的宝石破碎了，控制他的黑暗力量消失了，之后米德娜出现，带着林克回到了戈隆矿山的外面。

BOSS：福里乌斯（Twilit Iginiter——Fryus）

福里乌斯头顶的宝石破碎，控制他的黑暗力量消失，他恢复正常

参考：

• 《塞尔达传说：黄昏公主》图文全攻略 by WiiBbs 攻研部 Szh、三代鬼彻、天堂的翅膀
• 《塞尔达传说 黄昏公主》完美攻略研究 by www.cngba.com 鸡蛋
• Wii《塞尔达传说：黎明公主》流程攻略

1. 《塞尔达传说：黎明公主》攻略：剧情介绍
2. 《塞尔达传说：黎明公主》攻略：角色介绍
3. 《塞尔达传说：黎明公主》攻略：第三章 深海鱼族的传说
4. 《塞尔达传说：黎明公主》攻略：初章 英雄传说的扉页
5. U盘检测软件：ChipGenius，MyDiskTest

问题描述：有一枚不均匀的硬币，已知抛出此硬币后，正面向上的概率为p（0 < p < 1）。请利用这枚硬币产生出概率相等的两个事件。

这个问题跟之前的利用等概率Rand5产生等概率Rand3非常像，但却简单的多。几个月前还为这个事情头疼了一下，现在想来真是不应该。

某一次抛出硬币，正面向上的概率是p，反面向上的概率是1 - p，当p不等于0.5时，这两个事件的概率就不一样了。怎么能凑出等概率呢？还是要利用概率的加法和乘法法则。这里用乘法，也就是连续的独立事件。

连续抛两次硬币，正反面的出现有四种情况，概率依次为：

1. 两次均为正面：p * p
2. 第一次正面，第二次反面：p * (1 - p)
3. 第一次反面，第二次正面：(1 - p) * p
4. 两次均为反面：(1 - p) * (1 - p)

这不，中间两种情况的概率是完全一样的。于是问题的解法就是连续抛两次硬币，如果两次得到的相同则重新抛两次；否则根据第一次（或第二次）的正面反面情况，就可以得到两个概率相等的事件。

用Python程序模拟一下这个过程，首先是一个叫做UnbalancedCoin的类，用来模拟这枚不均匀的硬币。Flip方法表示抛一次硬币，返回值True代表正面，False代表反面。根据要求，这个函数返回True和False的概率分别是p和1 - p。函数MakeEqualProb利用参数coin（这枚不均匀硬币）构造出两个事件（依旧用True和False表示），并且这两个事件的概率都是0.5。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from random import Random



class UnbalancedCoin:

  def __init__(self, p, rand=None):

    assert 0.0 < p < 1.0, 'invalid p'

    self._p = p

    if rand is None:

      rand = Random()

    self._rand = rand



  def Flip(self):

    return self._rand.random() < self._p



def MakeEqualProb(coin):

  while True:

    a = coin.Flip()

    if a != coin.Flip():

      return a

对于不同的p值，模拟实验十万次，得到如下的（结果为True的）概率分布，其中蓝线是不均匀硬币抛出后正面向上的概率，红线是构造出来的两个事件之一（第一次正面向上，第二次反面向上）的概率。

Python程序模拟实验得到的不均匀硬币产生的概率与自定义事件的概率

如果问题改变一下，把“一枚”改成“一种”，那解决办法就更简单有趣了，把两枚同样的不均匀硬币正面相对粘在一起，就可以得到一个均匀的组合币，抛出这枚组合币就可以得到等概率的两个事件。

1. 单次遍历，等概率随机选取问题
2. 等概率随机排列数组（洗牌算法）
3. 单次遍历，带权随机选取问题（一）
4. 单次遍历，带权随机选取问题（二）
5. 条件概率：两个都是男孩的概率

如果你喜欢订阅几大校园BBS全站十大，强烈推荐gdh做的十大博客（需翻墙）：

• 水木十大：http://smthot.blogspot.com/
• 小百合十大：http://lilytop.blogspot.com/
• 饮水思源十大：http://sjtutop.blogspot.com/
• 日月光华十大：http://fudantop.blogspot.com/

之前就一直用Google Reader订阅着水木的十大，不过非常郁闷的是水木RSS中的文章不完整，稍微长点儿文章就被截断了，再有就是图片附件都看不到，要点开进入到水木才能看得到。但经常有很不错的文章，却因为种种原因被删除或者合集了，再想看到原文原图就很困难了，带来了不少遗憾。

gdh同学利用Google Blogspot和Google Picasa制作了四个博客，分别收集了清华水木社区、南大小百合、上海交通大学饮水思源和复旦大学日月光华的全站十大，不但保留了文章全文，还存储了图片，几乎是与这几个个BBS同步更新的，非常方便。欢迎大家前往以上博客参观，猛烈点击小广告，也可以直接把上述地址扔到Google Reader中进行订阅。

原文地址：水木十大博客

还是同样的问题：有一组数量未知的数据，每个元素有非负权重。要求只遍历一次，随机选取其中的一个元素，任何一个元素被选到的概率与其权重成正比。

在前一篇文章中介绍了概率分布的理论值，并用比较简洁高效的函数实现了选取一个元素的方法。现在来看一个神奇的算法，以及相关的证明和实现。

算法很简单：对于任意的i（1 <= i <= n），按照如下方法给第i个元素分配一个键值key（其中r_i是一个0到1之间等概率分布的随机数）：

$key(i)=r_i^{1/w_i}$

之后，如果要随机选取一个元素，就去key最大的那个；如果要选取m个元素，就取key最大的m个。

真不知道是怎么想出来的这样的方法，不过还是先来关注一下证明的过程。

m=1证明

对于m=1的证明过程会介绍得详细些，主要是怕我自己过几天就忘记了。概率达人可以直接秒杀之。

m=1时，第i个元素被选取到的概率，就等于它所对应的键值key(i)是最大值的概率，即：

$p_i=p(\forall j\neq i,key(j) < key(i))$

把key(i)的计算公式代入，但要注意公式中的r_i并不是一个固定的数值，而是随机变量。不考虑计算机数值表示的精度，可以假设r_i是一个在0到1之间的连续均匀概率分布，因此如果要计算key(i)是最大的概率，必须要对r_i所有的可能值进行概率累加，也就是积分。于是上面的概率表达式就被写成：

$p_i=\int_0^1p(\forall j\neq i,r_j^{1/w_j} < r_i^{1/w_i})\mathrm{d}r_i$

再看式子中的$\forall$，它表示每一个j都要满足后面的条件，而各个j之间相互独立，因此可以写成概率乘积，于是得到：

$p_i=\int_0^1\prod_{j\neq i}{p(r_j^{1/w_j} < r_i^{1/w_i})}\mathrm{d}r_i$

对于给定的j，$r_j^{1/w_j} < r_i^{1/w_i}\Rightarrow r_j < r_i^{w_j/w_i}$，另外r_j也是个均匀概率分布，将概率密度函数代入可以得到：

$p(r_j < r_i^{w_j/w_i})=\int_0^{r_i^{w_j/w_i}}1\mathrm{d}r_j=r_i^{w_j/w_i}$

因此，上面的概率算式就变成（其中w就是前一篇文章中提到的所有元素的权重之和）：

$p_i=\int_0^1\prod_{j\neq i}{r_i^{w_j/w_i}}\mathrm{d}r_i=\int_0^1r_i^{(w-w_i)/w_i}\mathrm{d}r_i=\frac{w_i}{w}$

最后的结果跟前一篇文章中的理论值相等，证明完毕。

m>=1证明

当m取任意值时，概率公式变得非常复杂，在前一篇文章中使用了第i个元素不被选到的概率来简化表达式。现在的证明也从同样的角度进行。

第i个元素不被选到的概率，显然等于这n个元素中，至少存在m个元素的键值大于key(i)，与之前的讨论一样，不妨设这m个元素的下标（按键值从大到小）依次为j₁, j₂, ..., j_m，$\forall 1\leq k\leq m,j_k\notin\{i,j_1,j_2,\cdots,j_{k-1}\}$，满足$\forall 1\leq t_k\leq n,t_k\notin\{j_1,j_2,\cdots,j_{k}\},key(j_k) > key(t_k)$。注意j_k和t_k的取值范围，为了简单起见，下面的式子中就不再重复了。

$\bar{p}_i(m)=p(\exists j_1,j_2,...,j_m\neq i,key(j_1) > key(j_2) > ... > key(j_m) > key(i))$

为了能够进一步求解，必须把这个连等式拆开。这里要非常小心，各个j_k并不是相互独立的，比如当j₁改变的时候，j₂的取值范围也会随之变化，依此类推。拆开之后的式子如下：

$\begin{array}{rrrl}\bar{p}_i(m)=p( & \exists j_1( & & \forall t_1,key(j_1) > key(t_1),\\ & & \exists j_2( & \forall t_2,key(j_2) > key(t_2),\\ & & & ...,\\ & & & \exists j_m(\forall t_m,key(j_m) > key(t_m))\\ & & ) & \\ & ) & & \\ ) & & & \end{array}$

看起来还是相当恐怖的，一层套一层。注意等式右边已经没有显式地关于i的信息了，这些信息被隐含在j_k和t_k的取值范围中，切记。对每个j_k，把key(j_k)的式子代进去，转换成积分；同时把$\forall t_k$转换为$\prod_{t_k}$。这些在m=1的证明中都提到过了。新出现的是$\exists j_k$，这个显然适用概率加法，因为j_k取不同的值对应于不同的互斥方案。经过这些变换得到：

$\begin{array}{rrrl}\bar{p}_i(m)= & \sum_{j_1}( & & \int_0^1\prod_{t_1}p(r_{j_1}^{1/w_{j_1}} > r_{t_1}^{1/w_{t_1}})\mathrm{d}r_{j_1}\times\\ & & \sum_{j_2}( & \int_0^1\prod_{t_2} p(r_{j_2}^{1/w_{j_2}} > r_{t_2}^{1/w_{t_2}})\mathrm{d}r_{j_2}\times\\ & & & ...\times\\ & & & \sum_{j_m}(\int_0^1\prod_{t_m} p(r_{j_m}^{1/w_{j_m}} > r_{t_m}^{1/w_{t_m}})\mathrm{d}r_{j_m})\\ & & ) & \\ & ) & & \\ \end{array}$

其中的积分式在之前已经见过了，其运算过程如下（注意t_k的取值范围）：

$\begin{array}{rl} & \int_0^1\prod_{t_k}p(r_{j_k}^{1/w_{j_k}} > _{t_k}^{1/w_{t_k}})\mathrm{d}r_{j_k} \\ & \\ = & \int_0^1\prod_{t_k}r_{j_k}^{w_{t_k}/w_{j_k}}\mathrm{d}r_{j_k} \\ & \\ = & \int_0^1r_{j_k}^{(\sum_{t_k}w_{t_k})/w_{j_k}}\mathrm{d}r_{j_k} \\ & \\ = & \frac{w_{j_k}}{(\sum_{t_k}w_{t_k})+w_{j_k}} \\ & \\ = & \frac{w_{j_k}}{w-(w_{j_1}+w_{j_2}+...+w_{j_{k-1}})} \end{array}$

最终，概率计算式子变成：

$\bar{p}_i(m)=\sum_{j_1}\left(\frac{w_{j_1}}{w}\sum_{j_2}\left(\frac{w_{j_2}}{w-w_{j_1}}\sum_{j_3}\left(\frac{w_{j_2}}{w-w_{j_1}-w_{j_2}}\cdots\sum_{j_m}\frac{w_{j_m}}{w-\sum_{k=1}^{m-1}w_{j_k}}\right)\right)\right)$

与前一篇文章中的理论值完全一样。

呼，可怕的推导过程。

程序实现

虽然证明过程异常恐怖，但实现起来却很简单。实际运算中，只要维持一个大小为m的最小堆（没错，是最小堆）来保存当前已知的最大的m个键值，每拿到一个新的元素，算出对应的键值，如果它比堆中的最小值大，就可以放入堆中替换掉最小值。Python实现函数如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from random import Random

from heapq import *



def WeightedRandomSample(m=1, rand=None):

  assert m > 0, 'invalid m'

  selection = []

  heap = []

  if rand is None:

    rand = Random()

  while True:

    # Outputs the current selection and gets next item

    (item, weight) = yield selection

    if weight <= 0: continue

    key = rand.random() ** (1.0 / weight)

    if len(selection) < m:

      heap.append((key, len(selection)))

      selection.append(item)

      if len(selection) == m:

        heapify(heap)

    else:

      if key > heap[0][0]:

        index = heap[0][1]

        heapreplace(heap, (key, index))

        selection[index] = item

每次拿到一个新的元素，通过key = rand.random() ** (1.0 / weight)产生一个与其权重有关的随机键值key。当元素个数小于m时，直接将新的元素放入堆空间中（但并不建堆），这样只用O(1)时间；当遇到第m个元素后，堆空间放满了，这时候进行建堆操作（heapify(heap)），需要O(m)时间；之后每拿到一个新的元素，用O(1)时间从堆顶拿出最小值与新元素的键值比较，如果后者更大就用后者替换掉堆顶元素，对堆进行必要的操作（O(log m)时间）以保持其结构（heapreplace(heap, (key, index))）。

关于Python中的堆可以参考：http://docs.python.org/library/heapq.html。

总体来看，整段程序用时O(n * log m)，占用O(m)辅助空间。这样的处理比较适用于m << n的情况。当m与n接近时，可以用n个辅助空间存储所有元素的键值，当遍历结束后用O(n)时间对这n个元素执行快速选择算法，选出m个最大的元素即可，耗时O(n)，辅助空间O(n)。

用同样一组具有等差分布权重的元素调用WeightedRandomSample十万次，得到如下的概率分布，与理论分布非常接近。

用WeightedRandomSample函数随机选取m个元素，第i个元素被选中的概率

1. 单次遍历，带权随机选取问题（一）
2. 单次遍历，等概率随机选取问题
3. 利用等概率Rand5产生等概率Rand3
4. 等概率随机排列数组（洗牌算法）
5. 算法的复杂度与Master定理

在单次遍历，等概率随机选取问题中已经剧透了今天的内容，那就是带权随机选取（Weighted Random Sample）问题。

问题描述：有一组数量未知的数据，每个元素有非负权重。要求只遍历一次，随机选取其中的一个元素，任何一个元素被选到的概率与其权重成正比。

设元素总数为n，当然在遍历结束前n是未知的。设第i（1 <= i <= n）个元素的权重为w_i（> 0），则权重总和为$w=\sum_{i=1}^{n}{w_i}$，也是在遍历结束时才知道的。根据题目要求，第i个元素被选取的概率应该等于$p_i=\frac{w_i}{w}$。

虽然加了个权重，但解法依旧非常简单，在单次遍历，等概率随机选取问题中的RandomSelect函数上稍作修改就得到本问题的解法，依旧是O(n)时间，O(1)辅助空间：

1
2
3
4
5
6
7
8
9
10
11
12
13
from random import Random



def WeightedRandomSelect(rand=None):

  selection = None

  totalweight = 0.0

  if rand is None:

    rand = Random()

  while True:

    # Outputs the current selection and gets next item

    (item, weight) = yield selection

    totalweight += weight

    if rand.random() * totalweight < weight:

      selection = item

其中Python的random.random()返回[0, 1)之间的随机小数。

看一下是否满足概率要求。如果最终被选取的是第i（1 <= i <= n）个元素，那必须是遍历到它的时候，恰好被选中，即rand.random() * totalweight < weight，其概率为：

$\frac{w_i}{w}=\frac{w_i}{\sum_{k=1}^{i}{w_k}}$

另外，还要在处理以后的任何一个元素时，第i个元素都没有被替换掉，即对于任意的j（i < j <= n），第j个元素都不会被选中，其概率为：

$\frac{w-w_j}{w}=\frac{\sum_{k=1}^{j-1}{w_k}}{\sum_{k=1}^{j}{w_k}}$

因此，第i个元素最终被选取的概率为：

$p_i=\frac{w_i}{\sum_{k=1}^{i}{w_k}}\times\frac{\sum_{k=1}^{i}{w_k}}{\sum_{k=1}^{i+1}{w_k}}\times\frac{\sum_{k=1}^{i+1}{w_k}}{\sum_{k=1}^{i+2}{w_k}}\times\cdots\times\frac{\sum_{k=1}^{n-1}{w_k}}{\sum_{k=1}^{n}{w_k}}=\frac{w_i}{\sum_{k=1}^{n}{w_k}}$

下面这段程序调用WeightedRandomSelect对一组具有等差数列权重的元素进行选取。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# Sample code to use WeightedRandomSelect function

# Use an arithmetic sequence as weights

n = 10

# weights are [1, 2, 3, ..., 10]

weights = [i + 1 for i in xrange(n)]

repeat = 100000

occurrences = [0 for i in xrange(n)]

rand = Random()

for i in xrange(repeat):

  selector = WeightedRandomSelect(rand)

  selector.next()

  selection = None

  for item in xrange(n):

    selection = selector.send((item, weights[item]))

  occurrences[selection] += 1

print occurrences

某次运行结果为：

[1723, 3644, 5405, 7326, 9027, 10903, 12678, 14784, 16345, 18165]

而对于这组权重的概率理论值为：

1 : 2 : 3 : 4 : 5 : 6 : 7 : 8 : 9 : 10

= 0.0181818 : 0.0363636 : 0.0545455 : 0.0727273 : 0.0909091 : 0.109091 : 0.127273 : 0.145455 : 0.163636 : 0.181818

可见程序是正确的。

扩展：选取m个元素，概率理论值

来看看选取多个元素的问题。当选取多个元素时，可以认为选取过程是逐步进行的，即无放回的多次选取。每一次选取时，任何一个元素被选中的概率都与其权重成正比，但总的权重则又剩余的元素集合决定。

当m=2的时候，第i个元素被选中可以是两种情况：第一次就被选中；第一次未被选中，第二次被选中。可以得到其概率为这两种情况的概率之和，即：

$p_i(2)=\frac{w_i}{w}+\sum_{j\neq i}\left(\frac{w_j}{w}\times\frac{w_i}{w-w_j}\right)$

值得注意的是，即便w_i和w不变，如果其他元素的概率分布不同，最后得到的结果也不同，因此上面这个式子无法把其中的求和化简掉。

从另一方面来看，第i个元素被选中的概率等于1减去它不被选中的概率。用$\bar{p}$表示不被选中的概率，则有：

$\bar{p}_i(2)=\sum_{j\neq i}\left(\frac{w_j}{w}\times\frac{w-w_j-w_i}{w-w_j}\right)$

显然，$p_i(2)+\bar{p}_i(2)=1$。

当m>2时，其概率表达式将会变得异常复杂，因为跟概率分布有关，所以算式无法化简。未被选中的概率计算式要稍微简单些，大概是这个样子的：

$\bar{p}_i(m)=\sum_{j_1}\left(\frac{w_{j_1}}{w}\sum_{j_2}\left(\frac{w_{j_2}}{w-w_{j_1}}\sum_{j_3}\left(\frac{w_{j_2}}{w-w_{j_1}-w_{j_2}}\cdots\sum_{j_m}\frac{w_{j_m}}{w-\sum_{k=1}^{m-1}w_{j_k}}\right)\right)\right)$

其中，$\forall 1\leq k\leq m,j_k\notin\{i,j_1,j_2,\cdots,j_{k-1}\}$。

对于给定的一组权重，可以用下面这段程序计算出任意m、i（程序中的i是从0开始的）对应的概率数值（请无视其coding style）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def Foo(weights, ids, totalweight, m, i, times):

  if times == m: return 1

  p = 0.0

  for j in ids:

    ids.remove(j)

    p += float(weights[j]) / totalweight \

         * Foo(weights, ids, totalweight - weights[j], m, i, times + 1)

    ids.add(j)

  return p



def CalcSampleProbability(weights, m, i):

  n = len(weights)

  assert 0 <= i < n, 'invalid i'

  assert 0 < m <= n, 'invalid m'

  ids = set(xrange(n))

  ids.remove(i)

  p = Foo(weights, ids, sum(weights), m, i, 0)

  return 1 - p

可惜算法的复杂度非常高，CalcSampleProbability需要O(n^m)时间来完成一次计算。期待高手改进。

来看一下等权重、等差数列权重和等比数列权重的n选m概率分布图（图中i依旧采用1 <= i <= n的取值范围）：

等值权重随机选取m个元素，第i个元素被选中的概率

等差分布权重随机选取m个元素，第i个元素被选中的概率

等比分布权重随机选取m个元素，第i个元素被选中的概率

Mathematica提供了RandomSample函数，支持带权选取，当然它是在遍历之前就已经知道元素个数的。给它一组等差分布的权重，可以看出十万次随机选取后得到的概率分布与上面的理论分布非常接近。

Mathematica RandomSample随机选取m个元素，第i个元素被选中的概率

苦苦思考了好几天，但并没有想到一个直观的方法可以给之前的RandomSample加上权重处理。因为那概率式子太复杂，实在不知道该怎么去凑。不过在下一篇文章中将会介绍一个神奇的算法（当然不是我想出来的），并且会给出我的证明。

现在发文章的速度越来越慢了，实在因为能力有限，每次为了一两个式子都要演算很久。再接再厉。

1. 单次遍历，带权随机选取问题（二）
2. 单次遍历，等概率随机选取问题
3. 等概率随机排列数组（洗牌算法）
4. 利用等概率Rand5产生等概率Rand3
5. 利用不均匀硬币产生等概率

初章 英雄传说的扉页（被神选中的少年）

如你期望那样，你将扮演Link，拯救Zelda公主和Hyrule王国的年轻英雄。在黎明公主中，你将与横行在Hyrule王国的暗影军团战斗。凭借Hyrule大地神奇的力量和你自己的勇气，在一个个迷宫里消灭无数的敌人吧！那么，现在就开始我们的旅程！

奥东村（Ordon Village）

奥东村（Ordon Village）外，法隆森林（Faron Woods）的泉水旁，我们的主角林克（Link）与村里唯一的剑士，也即林克的导师鲁斯尔（Rusl）在谈论着夜晚的异常与广阔的海拉尔（Hyrule）世界，鲁斯尔问林克是否知道黎明之时（Twilight Time），年轻的林克显然还不知道这些，因为他还没走出过法隆森林，鲁斯尔也打算让林克到外面的世界去看看，让他后天把送给贵族的东西到带海拉尔城去。在天黑前两人回到了村子里。

林克与导师鲁斯尔在谈论着夜晚的异常与广阔的海拉尔世界

牧羊

过了一会，一位村民跑来告诉林克，艾普娜不见了，林克赶到奥东之泉（Ordon Spring），看见了青梅竹马伊莉娅（Ilia）与艾普娜，原来是伊莉娅帮林克给艾普娜擦拭干净，伊莉娅告诉林克，艾普娜有点烦躁不安，林克拔起湖边（马蹄状）的草，吹起了悠扬的口哨，艾普娜顿时安静了下来，林克骑上艾普娜，试了一下感觉，真是一匹出色的马驹。回到村里，林克四处逛了一下（与大家说说话吧，不过现在还不能进到任何屋子里），然后来到奥东牧场（Ordon Ranch），农场主请林克帮忙把倔犟的羊群赶回羊圈。完成任务并不困难，赶羊的乐趣大家很快就能体会到了。按A键能惊吓羊支，让它们更快的移动，不过兔子急了也会咬人的哦！小心它们调头攻击你！完成后，农场主提供农场让林克练习骑马跳，在接近栅栏一段距离的时候按A加速，到达栅栏时马会自动跳过去，练习得差不多了，天色也渐渐晚了，林克骑着艾普娜跳过农场大门径直回了家。一天的生活结束了，此时的林克还不知道之后的自己即将要担负起拯救两个世界的重任。

奥东牧场的农场主请林克帮忙把倔犟的羊群赶回羊圈

孕妇的篮子，离家出走的猫

第二天一早，林克被村里的小孩们给叫醒了，本来打算骑着艾普娜到处逛一下的，但是鲁斯尔的儿子柯林（Collin）让林克到村里看看有什么可以帮助大家的，也让艾普娜休息一天，看来将会是忙碌的一天啊。刚进村就有村民要林克帮忙除掉屋后大树顶上的马蜂窝，林克当然爽快答应，没走两步看到汉奇（Hanch）站在一处高台上，和他对话（按Z然后按A），练习攀登（接近树藤按前，上下左右移动）。林克攀爬上去，汉奇让林克试着吹响灌木召唤隼鹰并且告诉林克他们家的猫咪老是在湖边打转不肯回家。林克跳到（对准方向按前就可以了）旁边的高台上，用灌木吹起了口哨，一只隼鹰飞到了林克的手臂上，此时可以命令隼鹰飞到指定的地方。首先帮村民搞定马蜂窝吧，让隼鹰撞落村里最高树上的马蜂窝，爬到树上在原来挂马蜂窝的地方可以拣到15个卢比。在湖边看到了柯林的妈妈正在犯愁，原来是前段时间不小心将婴儿摇篮掉到河中被水冲走了，林克当然不能坐视不管，顺着河往下游游去，看到水中一个巨石上有只猴子举着婴儿摇篮，林克爬到岸上，举起石头向猴子砸去，但是仿佛距离不够，看来只有暂时先返回村子了。回到村里林克想起了汉奇的话，看来可以让隼鹰帮忙把婴儿摇篮抓回来，爬上汉奇站的高台，从旁边的高台跳到屋顶上，然后再跳到另一个高台上，隐约可以看到远处的猴子，召唤隼鹰瞄准猴子，隼鹰果然漂亮地将婴儿摇篮给夺了回来。带着婴儿摇篮回到柯林妈妈那里，她高兴万分，让林克跟她一起回家，因为有神秘的礼物要送给林克。来到她家门口，原来是一副钓鱼竿，有了钓鱼竿，林克可以到湖边去放松一下了，来到刚才看到的有小猫的湖边钓鱼。按-号调出道具栏，将钓竿装备到B（装备到右手手柄的左右下也可以，使用前会道具切换到B），在河边按B使用钓竿，按B把鱼竿甩进水里，然后等待，当浮标被拉下水后，把右手的Wii手柄举高，出现HIT，继续保持举高的姿势，直到钓上鱼。林克钓上来的第一条鱼就引起了小猫的注意，刚钓上第二条时，小猫叼着鱼就开跑，一路跑回了家，林克追了过去，店主塞拉（Sera）为了感谢林克，送给林克一瓶牛奶，牛奶可以让林克感到体力充沛，不过这个瓶子将来更有其他的用处。出门来到农场山脚下的村长布（Bo）的家门口，正在与布谈话时，听到农场主的喊声，回头望去，原来是山羊跑出了农场，朝山坡下冲了过来，林克凭借着敏捷的反应，顺手抓住山羊的角，然后将其摔翻在地上，山羊就乖乖地返回牧场。村里最高的房顶上可以拣到10个卢比，看到牧场方向的平台上还有10个，这时召唤隼鹰，让隼鹰把附近的鸡给带上来，然后可以借助鸡滑翔到对面的平台上。这时拣到的卢比也超过了30个了，可以去商店买弹弓了。商店有弹弓，蜜蜂幼虫（B装备钓竿的情况下，使用蜜蜂幼虫，可以拿去钓鱼，需要空瓶子装）和回复药（需要空瓶子装）出售。

林克凭借着敏捷的反应，顺手抓住山羊的角，然后将其摔翻在地上

陪孩子们玩

做了那么多的事情，林克也累了，回家休息一下吧，在家门口遇到了鲁斯尔，鲁斯尔告诉林克在他家中放了一个箱子。林克迫不及待地想回去看看究竟是什么东西，可没走两步又被家门口的3个小孩马洛（Malo）、塔洛（Talo）、贝思（Beth）吵着要林克表演弹弓技术，帅气的林克当然会满足他们的愿望，和装备钓竿的方法一样装备弹弓，使用弹弓后按住B拉开弹弓，用右手的Wii手柄瞄准目标，放开B射击，按Z可以锁定近处的目标。分别打完靶子和稻草人后，小孩们被林克高超的技艺所折服。终于可以回家了，房子前的藤条上居然出现了魔蜘蛛，用弹弓将其击落。一进门就看到了鲁斯尔给林克的箱子，赶紧打开看看，一把木剑!林克终于有武器了。林克激动得出门想练练剑，刚好小孩们又吵着要林克表演剑术，不过好像他们产生了分歧，贝思很喜欢林克的表演，马洛却觉得林克不过是表演些雕虫小技。按他们的请求耍出剑招：

1. 平挥：把wiimote从一边甩到另一边（左右挥动）；
2. 直斩：从上往下甩wiimote；
3. 直刺：按住Z和前（前倾nunchunk的模拟摇杆），挥动wiimote；
4. 旋转攻击：左右挥动nunchunk；
5. 跳斩：用Z键锁定后按A。

在林克一阵刀光剑影之后，小孩们都惊呆了，贝思更是对林克赞不绝口。这时那只拣走婴儿摇篮的猴子又出现了，引起小孩们的好奇，塔洛追着猴子进了法隆森林。

林克表演剑术

法隆森林

救出被捉的孩子

跟过去发现塔洛跟随猴子到吊桥对面去了，回去骑上心爱的艾普娜，林克也追进了法隆森林，穿过法隆森林泉左边的山洞，来到一个岔路口，看来跟丢了，往左边走，看到一个了隐居商人柯洛（Coro），他送给林克一盏煤油灯，用100块买油瓶子（重点是装油的瓶子，只能买一次）。回到岔路口，林克用煤油灯烧开蜘蛛网，进入山洞，洞中有很多台柱是可以用灯点燃的，有煤油灯的帮助，林克穿过漆黑的山洞，来到一处开阔地，林克在北面的洞口干掉几个小喽啰，路上有两根柱子，看起来可以跳过去，但实际上并不能，人类还是没法做到的。进入洞中，在最深处的宝箱里面得到一把钥匙，林克又点燃箱子左右的灯柱，出现了一个隐藏宝箱，可以得到第一块心之碎片，每收集满5个心之碎片，林克的生命值可以增加一颗心，即一个心之容器。然后回到之前的那片开阔地，到东面干掉两个守卫后用刚得到的钥匙开门进去，不远出碰到一只小鹦鹉，此处可以补充生命值和灯油，不过就算是救世主的林克来光顾也不是免费的，旁边还有一个箱子就是让顾客消费后自己投币的，如果林克购买了物品而不老实买单的话，鹦鹉可不会放林克离开的。继续前进，林克一路杀进去，没多远就看到了关押小猴子和塔洛的笼子，轻松干掉两个守卫后，林克砍坏笼子救出了小猴子和塔洛，塔洛告诉林克，要不是小猴子一直骚扰魔物，他可能都被杀害了，正是因此小猴子也被魔物抓住关到了笼子里。林克带着塔洛回到了村里，自己也回家休息了。

关押小猴子和塔洛被关押在笼子中

一大早农场主又要拜托林克赶羊，不过这次是要在3分钟之内赶完20只，完成后，林克在农场的山脚下遇到了伊莉娅，伊莉娅看到艾普娜的脚受伤了，便生气地带着艾普娜离去了，林克只好独自回家。路上遇到柯林要林克带他去奥东之泉看艾普娜，之后又遇到了那三个调皮的小孩拦路要林克把木剑给他们玩，不答应他们的话是过不去的，看来没办法了只好暂时借他们玩玩。来到奥东之泉，伊莉娅却紧闭大门不让林克进去，看来她还在生气，柯林告诉林克有个地方的小洞可以通往奥东之泉里面。回到路上有松鼠的地方，林克找到小洞钻了过去。林克答应伊莉娅会好好照顾艾普娜，伊莉娅也才同意将艾普娜交给林克，正在此时，一群凶悍的野猪骑士破门而入，将林克打昏在地，并带走了伊莉娅和柯林。醒来后的林克感觉到了事情的严重，于是急忙朝法隆森林深处追了过去，穿过吊桥，发现一堵黑暗之墙挡住了去路，林克感觉到了不寻常的力量，刚想靠近黑暗之墙调查一番，却被一只巨大的手抓入了黑暗世界。来到黑暗世界中的林克被一种强大的力量变成了狼的形态，涉世未深的林克承受不住这股强大的力量，便昏迷了过去……

一群凶悍的野猪骑士破门而入，将林克打昏在地，并带走了伊莉娅和柯林

海拉尔城堡

脱出黄昏世界

林克从昏迷中醒来后惊奇得发现自己变成了狼的形态，而起被锁在一间牢房里。此时一个神秘的独眼生物出现，林克下意识得提高了警觉，不过它却帮林克解开了锁链，暂时看来它不是敌人，它说要想逃出这个地方就得听它的话，对准牢笼边的木箱挥动右手手柄或者按住Z按A，将其击碎，然后在松软的泥土处按右手手柄的下，挖洞离开牢笼。神秘生物毫不客气得骑到了林克背上，救世主被人骑的滋味一定很不爽，但是为了逃出这个地方只有暂时忍气吞声了。神秘生物的头部可以长出一只手打开一些吊环机关（按住Z按A），看来它的来头不小啊，林克发现这个黑暗世界与光明世界是相通的，光明世界里的人们在黑暗世界中看来便是灵魂，通过狼的感知（按右手手柄的左或者右进入感应模式，感应模式下视觉会缩小，但能看见很多平时看不见的东西），林克可以听到他们的谈话。继续探索下水道，有很多机关和钱在等着你。小心这里的敌人并不好对付，掉下水的话尽快上岸，如果在水中被攻击的话是很惨的。在几个拉索机关后，进入一座桥的废墟，小心头上飞来飞去的怪鸟，最好杀死它们后再前进，灵活利用Z锁定然后攻击，很容易杀死它们。跟着神秘生物的提示，林克一直来到一个螺旋楼梯的高塔处，这里它会带林克飞过一些断口的地方，一路上到顶部，通过门来到城堡外部，神秘生物带着林克经过房顶来到一座塔内。在塔顶林克见到了一位黑衣人，难道自己被神秘生物欺骗了?这也许就是幕后指使者，正当林克猜测时，黑衣人转过身来，原来她就是伟大的塞尔达（Zelda）公主。从塞尔达公主口中得知神秘生物叫做米德娜（Midna），原来这一切都是一个叫做赞特（Zant）的魔法师所策划的整个阴谋，塞尔达公主为了子民不受到迫害，而被囚禁在这里，塞尔达公主告诉林克赶快离开这里，以免被赞特的手下发现，林克只好逃出塔外，在屋顶米德娜发动魔法将林克传送回光明世界。

变成狼形态的林克与米德娜

奥东村

寻找剑与盾

林克发现自己被传送到了奥东之泉，但是回到光明世界的林克仍然是狼的形态，米德娜要林克搞到一面盾和一把剑，为变成人的时候做准备。回到家门口林克发现在狼的形态下可以听懂动物的语言。来到村中水车处，林克偷听到了两位村民的对话，得知小孩们被魔物俘走了，但林克忘了自己是处于狼的形态，正想上前听得再清晰一些，结果被村民发现，两人以为是魔物来了，匆忙逃进屋内。林克没有办法开门进去，看来只好走房顶的窗口进去了，但是水车旁边的高台上有村民带着隼鹰守夜，林克只好先跳到商店屋顶再从背后吓走高台上的村民，然后通过水车跳到对面的房顶上，从窗口进去。进去后发现墙上有面盾牌，撞下取得后从旁边的窗口离开。谁有武器呢？林克想了想，导师鲁斯尔那一定有把，前往鲁斯尔的家，但是就算是导师也认不出林克了，挥舞着剑不停的驱赶眼前的这只野兽，看来只有从旁边绕过去了，进入感应模式，能看见地上有些地方一闪一闪的，代表这些地方是可以挖的，在靠屋子的闪光处挖，进去拿到剑后赶紧离开吧，因为现在大家都不欢迎林克。

在导师鲁斯尔家里找到剑

法隆地区

第一位光之精灵

带着剑和盾，林克一心只想救出塞尔达公主，一路狂奔，经过奥东之泉时却遇到了暗影使者（Shadow Being），林克轻松将其击倒，消灭暗影使者后，光之精灵奥多那（Ordona）出现，告诉林克世界上一共有四位光之精灵，要想让世界恢复正常，必须要依靠四位光之精灵的力量，奥多那让林克去找到另外三位光之精灵。

要想让世界恢复正常，必须要依靠四位光之精灵的力量

第二位光之精灵

世界正在被黑暗吞噬，刻不容缓，林克和米德娜来到黑暗之墙外，米德娜问林克是否做好了进入黑暗世界的准备，这根本没有思考的余地，林克坚定的点了点头。刚一进入黑暗世界便遇到三只黑暗使者，当它们死剩一只时，会全体复活。米德娜告诉林克，要同时击倒三个暗影使者才能将他们彻底消灭，米德娜会教林克发动群体攻击技能。按住B键会产生一个攻击范围，放开，范围内的敌人会全部被杀死，但一次杀三只，难度比较大，建议杀剩下两只的时候，再使用范围攻击。

解决后第二位光之精灵出现，它交给林克光之容器（Vessel of Light），让林克去收集光之泪（Tears of Light）。

收集光之泪

林克根据地图上的白色标记，利用感知发现并消灭掉那些虫子后便可收集到光之泪，因为找到它们难度并不大，所以这里不具体说明。提示：

1. 开感应模式才能看见影子虫；
2. 影子虫是有些在屋子里的，找不到的话进附近的屋子找；
3. 有些要和附近的鬼魂对话才会出现；
4. 有突然出现潜入地底的情况，挖地或者等待会出现；
5. 森林的中心位置会有毒雾（瘴气），林克没有办法前进，只有借助米德娜的传送才能通过，如果是晚上的话中途会看见幽灵的灯，进感应模式，将它杀死可以获得鬼魂之魂；
6. 杀完虫子别忙着走，要记得拿光之泪。

收集完所有的光之泪后法隆地区（Faron Province）的黑暗褪去，森林被净化了，光之精灵法隆（Faron）恢复了原形，没有了黑暗力量的压迫，林克也变回了人形，身上换成了系列经典的绿色套装，法隆告诉林克，他是被光之神选中的英雄，林克再次肩负起拯救世界的重任。

光之精灵

前往森之神殿

之后林克来到柯洛处，柯洛会给林克一把钥匙，用来打开岔路处的锁，穿过山洞来到瘴气覆盖的地方。没有了米德娜的帮忙，林克只好拿出灯来趋散瘴气，不过猴子却出现并抢走了林克的灯，林克气愤得以为猴子在这种时候还来捣乱，不过猴子其实是来帮助林克引路的，看来误会它了。跟着小猴子穿过瘴气，林克一路向前，突然看见有一只金色的狼蹲坐在路中间，林克走过去，狼却扑了过来，一阵眩晕之后，林克发现自己在一个陌生的空间中，看到眼前站着一位不死勇士（Undead Warrior），林克正在困惑之时，不死勇士开口了，原来他是专门守候在这里给救世主传授绝技，他会教给林克终结刺（Ending Blow），学会后林克返回到现实当中，眼前就是森之神殿（Forest Temple）的入口。

用灯来趋散瘴气

森之神殿迷宫

森之神殿迷宫地图

房间1：林克刚进入森之神殿。左边的蔓腾上去有宝箱。走了不远，又看到不走运的猴子被关在笼子里，再次将其救出。之后射死蜘蛛爬上藤条进入房间2。

房间2：这里林克会遇到蜘蛛炸弹，用它可以帮助炸开一些腐坏的门以及挡路的石头。当炸弹蜘蛛试图接近你，你用你的盾的阻止他们攻击你的话，他们会后退然后最终爆炸。在它们作出这些行动之前，你可以抓住他们。抓住一只扔向房间北面的大的岩石墙上，靠近他们洞穴的地方，你将会得到装着20卢比的箱子。到中间的高台上，你将会面对一个大的蜘蛛，这些家伙将会防御你的攻击，但如果你只是简单的按着按钮Z，然后等他们暴跳，然后相互殴打。你将不费吹灰之力消灭他们。点燃灯柱，前面升降梯会升起形成一条路，然后进入对面到房间3。

房间3：林克正要过桥的时候桥会被打断，只得原路返回到房间2。回到中间高台处，向西面走，刚才救的猴子会会荡秋千，帮你前往西面的高台。按前跳跃捉住猴子后，出现A指令按A放手就可以到对面进入到房间4。

林克正要过桥的时候，桥被打断了

房间4：先去右边利用蜘蛛炸弹将石头炸掉后，可以得到欧库（Ooccoo），是一个流落人间的天空人，她能帮助林克逃离迷宫并且再回到离开处（在迷宫中使用母亲，会被传送出迷宫，在迷宫外使用儿子会回到使用母亲的地方，十分之方便），之后向北进入房间3的左边吊桥，通过后到对面的房间5取得一把小钥匙（Small Key），之后再回到房间4。打开西面的门进入房间6。

房间6：下面的柱子上有一只被关住的猴子，（用前加A）撞柱子的话可以将笼子撞下来打碎，救出猴子后，带着两只猴子回到中间的房间2。

房间2：在两只猴子的帮助下可以向西面到房间7。

房间7：这个房间有2个霸王花，普通攻击无法将其消灭，可以从2楼拿蜘蛛炸弹扔下来消灭掉它们，南面的那个后面的箱子里有心之碎片。之后再用2楼的蜘蛛炸弹炸开东面挡路石头（拿着跳过去扔），之后可以进入房间8。

房间8：进入后可以在台子上看到下面两个柱子，其中左边的柱子上有个箱子，像之前救第2只猴子那样将其撞下可以得到小钥匙。从水里游过去上岸后点燃左右的两个灯柱后会有梯子升起，这样就可以爬上去救出第3只猴子了。回到房间7，然后向南边走进入房间9。

点燃左右的两个灯柱后会有梯子升起

房间9：这里会遇到一个食人花和霸王花的合成体，要先砍掉它的脑袋，然后将蜘蛛炸弹扔入肚子消灭后可以取回被他吞下的钥匙，之后可以救回第4只猴子。

房间3：带着4只猴子到房间3通过之前断开的吊桥来到房间10见到了小BOSS——被影子虫依附的猴子王。

在4只猴子的帮助下通过之前断开的吊桥

房间10：此战比较简单，看到BOSS扔出回旋镖后迅速撞击他所站的柱子，BOSS会因为站不稳而没接到回旋镖并被回旋镖打下，此时攻击它的屁股，反复几次后战胜并取得道具回旋镖（Gale Boomerang），之后朝进来的门上面的机关使用回旋镖可以回到房间3。

当小BOSS没接到回旋镖并被回旋镖打下后，赶紧过去攻击它的屁股

房间3：现在可以控制这里桥的转向（利用回旋镖吹动桥上的风叶），先去右边救被困的猴子（用回旋镖将绳子打断即可）。此后可以回到之前救第三只猴子的地方将灯熄灭，降下最里面的梯子后得到心之碎片。

房间2：回到房间2，用回旋镖将天花板上挂着的东西悉数击落，其中的宝箱里有道具指南针，利用他可以观察迷宫中宝箱、Boss和猴子的位置。从吊桥房间左边的吊桥过去到房间4。

房间4：按照地上标记指示的顺序将风车图腾激活可以取得大钥匙（Big Key）。然后对直走进入房间5，再朝东进入房间13。

房间13：救下上层的猴子后回到房间5，走北面的门进入房间11。

房间11：之前被救的猴子都在这里，首先利用回旋镖为动力转动东面的吊桥以到达最东面的门进入房间12。

房间12：在房间的最南面的箱子里有一把小钥匙，而最东面的路被挡住了，利用回旋镖从北面水中的石头上取来蜘蛛炸弹，记得先锁定蜘蛛炸弹再将第2目标锁到石头上可以炸开，上去后能救到猴子。拿着刚取得的小钥匙回到房间5并走西面打开门进入房间14。

房间12中要救的小猴子

房间14：注意地板下面的怪，可以用回旋镖将其卷出来，救到最后一只猴子后去房间11，他们会帮林克通过中间的大断崖到对面进入Boss房间15。Boss房间前精灵标志的地方，打烂罐子会出现精灵，记得用瓶子装，带在身上，可以自动复活一次。

BOSS站：食人花——达巴巴（Twilit Parasite——Diababa）

进入房间，首先出现的是两个超级巨型食人花，利用其下两个台子上的蜘蛛炸弹再配合回旋镖可以将炸弹送到食人花的嘴巴里，很快就能将之干掉，但是战斗并没有结束，随后食人花的头部出现，这时之前的台子会被达巴巴的躯体挡住，但是不一会儿，之前的战胜的那只大猴子会出现并为林克提供炸弹蜘蛛，有了这个随后就可以轻松获胜了。

BOSS：食人花——达巴巴（Twilit Parasite——Diababa）

用回旋镖将蜘蛛炸弹送到食人花的嘴巴里

参考：

• 《塞尔达传说：黄昏公主》图文全攻略 by WiiBbs 攻研部 Szh、三代鬼彻、天堂的翅膀
• 《塞尔达传说 黄昏公主》完美攻略研究 by www.cngba.com 鸡蛋
• Wii《塞尔达传说：黎明公主》流程攻略

1. 《塞尔达传说：黎明公主》攻略：角色介绍
2. 《塞尔达传说：黎明公主》攻略：剧情介绍
3. 《塞尔达传说：黎明公主》攻略：第二章 死亡山颠的咆哮
4. 《塞尔达传说：黎明公主》攻略：第三章 深海鱼族的传说
5. U盘检测软件：ChipGenius，MyDiskTest

几年前的事情了。有一次去北邮玩，看到校园里有卖U盘的摊位，问了问价格，8GB的金士顿U盘99块钱。正好头一天有个同事跟我说最近U盘降价了，8GB才99，于是心里一痒痒就买了一个。回来用着就感觉不对劲，读写速度超慢不说，放的东西多了之后就有好多读不出来。赶紧找了软件来检测，果然是假货，是用4GB的假冒机芯改装的。今天分享一下检测用的软件和方法。

先介绍一下在没有软件的时候怎么判断是否是真的金士顿U盘。直观上可以仔细观察U盘上的标签、防伪标识、防伪电话等等，制作粗糙的一般都是假冒的。除此之外可以注意两点：

• 当真的金士顿U盘接到电脑上后，电脑中显示的卷标应该是“Kingston”（刚买来的应该是这样），而假冒的一般会是“可移动磁盘”之类的；
• 真的金士顿U盘在读写的时候，背部的小灯会闪烁，但假冒的一般不会亮。

下面介绍第一个小软件：ChipGenius。它可以识别出U盘（或其他USB设备）的主控芯片型号、制造商、品牌等信息。这个软件绿色小巧，便于携带，是外出选购U盘是必不可少的工具之一。下面两张图是真假金士顿U盘用此软件识别后的对比，真的U盘是公司发的，假的是我在北邮买的。

正牌8G金士顿U盘在ChipGenius中的检测结果

冒牌扩容8G金士顿U盘在ChipGenius中的检测结果

可见，关键的区别就在产品制造商（Product Vendor）和产品型号（Product Model）上，正牌的应该是Kingston DataTraveler 2.0，而假冒的通常都是USB 2.0 Flash Disk之类的东西。

有一点比较奇怪的是，我在英文Vista上运行该软件，显示版本是2.64，在中文Xp上运行，则显示2.70，呵呵，无视之。

如果只是芯片是冒牌货我也忍了，最可气的是芯片的实际容量只有4GB。接下来介绍的这个软件就可以检测出来，叫做MyDiskTest。这个软件功能很强，我最喜欢的就是扩容检测和坏块扫描了，速度很快，比我自己写的程序一点一点扫描快多了。另外它还可以进行速度测试和坏块屏蔽。不说废话，直接上对比图，还是我的一真一假两只U盘。

正牌8G金士顿U盘在MyDiskTest中的检测结果

冒牌扩容8G金士顿U盘在MyDiskTest中的检测结果

可见，我这个假冒的U盘是用杂牌的4G机芯改装出来的。由于是在校园里路边买的，虽然要了收据（号称是海龙的来这里搞活动），但收据上的摊位也是假的。目前只好暂时用MyDiskTest把坏块屏蔽掉使用了（否则写入的文件超过4G后的内容将无法写入但又不会报错，直到读出来的时候才会发现内容全部是0×00）。

好在两个软件都非常小，这里就直接提供下载吧（压缩包内有详细使用说明，就不多说了）：

• ChipGenius v2.64 （113K） MD5：2628f1748e558bd71ab661ae1ab27aa5
• MyDiskTest v2.50 （610K） MD5：7d4bfeb1e01f748fe3bd2b6a590bd83b

真想哪天背着本本出来去街边买个U盘，现场检测，揭穿这些奸商的把戏。

1. 《塞尔达传说：黎明公主》攻略：角色介绍
2. 2011.5.15我们的婚礼（二）——迎亲篇
3. 2011.5.15我们的婚礼（三）——准备篇
4. 2011.5.15我们的婚礼（一）——出发篇
5. 2011.5.15我们的婚礼（四）——仪式篇

又是一道概率问题，不过跟之前的题目一样，这也是一道非常简单的题目。

问题描述：假设我们有一堆数据（可能在一个链表里，也可能在文件里），数量未知。要求只遍历一次这些数据，随机选取其中的一个元素，任何一个元素被选到的概率相等。O(n)时间，O(1)辅助空间（n是数据总数，但事先不知道）。

如果元素总数为n，那么每个元素被选到的概率应该是1/n。然而n只有在遍历结束的时候才能知道，在遍历的过程中，n的值还不知道，可以利用乘法规则来逐渐凑出这个概率值。在《利用等概率Rand5产生等概率Rand3》中提到过，如果要通过有限步概率的加法和乘法运算，最终得到分子为1、分母为n的概率，那必须在某一次运算中引入一个n在分母上，而分母和分子上其他的因数则通过加法、乘法、约分等规则去除。

很容易能够想到这样一个简单的式子来凑出1/n：

$p_i=\frac{1}{i}\times\frac{i}{i+1}\times\frac{i+1}{i+2}\times\cdots\times\frac{n-1}{n}=\frac{1}{n}$

下面用一段Python程序来实现这个过程，这里设计了一个类，叫做RandomSelector，提供方法AddItem，在遍历数据的时候把每个元素通过这个函数传进来，最后通过SelectedItem获取随机选择的元素。这么做主要是为了强调事先不知道元素的总数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from random import Random



class RandomSelector:

  def __init__(self, rand=None):

    self._selectedItem = None

    self._count = 0

    self._rand = rand

    if self._rand is None:

      self._rand = Random()



  def SelectedItem(self):

    return self._selectedItem



  def Count(self):

    return self._count



  def AddItem(self, item):

    if self._rand.randint(0, self._count) == 0:

      self._selectedItem = item

    self._count += 1

在Python 2.5中，yield不仅是个语句，更是一个表达式（详见PEP 342 -- Coroutines via Enhanced Generators，查阅Generator和Coroutine，中文叫做“生成器”和“协程”），利用yield可以把程序写的更简洁一些：

1
2
3
4
5
6
7
8
9
10
11
12
13
from random import Random



def RandomSelect(rand=None):

  selection = None

  count = 0

  if rand is None:

    rand = Random()

  while True:

    # Outputs the current selection and gets next item

    item = yield selection

    if rand.randint(0, count) == 0:

      selection = item

    count += 1

下面这段程序示意了如何调用RandomSelect函数来测验其随机效果：

1
2
3
4
5
6
7
8
9
10
11
12
13
# Sample code to use RandomSelect function

n = 10

repeat = 100000

occurrences = [0 for i in xrange(n)]

rand = Random()

for i in xrange(repeat):

  selector = RandomSelect(rand)

  selector.next()

  selection = None

  for item in xrange(n):

    selection = selector.send(item)

  occurrences[selection] += 1

print occurrences

十个元素，重复十万次，理论上每个元素会被选中恰好一万次。某次实验结果如下：

[10020, 10084, 10003, 10008, 9985, 10145, 9987, 9925, 9955, 9888]

可见每个元素被选中的次数相差不大，是等概率的。

如果用C#，就可以利用IEnumerable来实现，比如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public static bool RandomSelect<tsource>(

    IEnumerable<tsource> source,

    Random random,

    out TSource selectedItem)

{

    if (source == null)

    {

        throw new ArgumentNullException("source");

    }

    if (random == null)

    {

        random = new Random();

    }



    selectedItem = default(TSource);

    int count = 0;

    foreach (TSource item in source)

    {

        if (random.Next(++count) == 0)

        {

            selectedItem = item;

        }

    }



    return (count > 0);

}

核心代码也就那么两三行而已，时间复杂度为O(n)（并且只遍历一次），空间复杂度为O(1)。其中Python的random.randint(x, y)返回[x, y]之间的随机整数；C#的Random.Next(x)返回[0, x)之间的随机整数。

看一下概率，如果最终被选取的是第i个元素（1 <= i <= n），那就必须是遍历到它的时候，恰好被选中（random.randint(0, i - 1) == 0或者Random.Next(i) == 0），并且从此之后都恰好再也没有被其他元素替换掉。这些事件彼此独立，计算概率的方法正好是上面提到的式子，最终的概率就是1/n。

OK，问题解决了。结束之前再做个简单的扩展，改成等概率随机选取m个元素（可知每个元素被选中的概率都是m/n）。

解决办法也非常简单，只要在上面的代码中，把selectedItem（selection）改成一个长度为m的数组，稍作调整就可以了。

这里就给出Python的程序片段：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from random import Random



def RandomSample(m=1, rand=None):

  selection = []

  count = 0

  if rand is None:

    rand = Random()

  while True:

    # Outputs the current selection and gets next item

    item = yield selection

    if len(selection) < m:

      selection.append(item)

    else:

      idx = rand.randint(0, count)

      if idx < m:

        selection[idx] = item

    count += 1