爱因斯坦智力题算法的分析

前些天，试着编程解一下爱因斯坦出过一道著名的智力题，多年前就见过，当时尝试编程解决，失败了。经过几年编程实践，不参考别人的，看能不能独立写出一个比较好的算法。

//有五个具有五种不同颜色的房间；每个房间裏分别住著一个不同国籍的人；每个人都在喝一种特定品牌的饮料，
// 抽一特定品牌的香烟，养一特定的宠物；没有任意两个人在抽相同品牌的香烟，或喝相同品牌的饮料，或养相同的宠物。

//1.英国人住在红色的房子裏；
//2.瑞典人养狗作为宠物；
//3.丹麦人喝茶；
//4.绿房子紧挨著白房子，在白房子的左边；
//5.绿房子的主人喝咖啡；
//6.抽 Pall Mall 牌香烟的人养鸟；
//7.黄色房子裏的人抽 Dunhill 牌香烟；
//8.住在中间那个房子裏的人喝牛奶；
//9.挪威人住在第一个房子裏(最左边)；
//10.抽 Blends 香烟的人和养猫的人相邻；
//11.养马的人和抽 Dunhill 牌香烟的人相邻；
//12.抽 BlueMaster 牌香烟的人喝啤酒；
//13.德国人抽 Prince 牌香烟；
//14.挪威人和住蓝房子的人相邻；
//15.抽Blends 香烟的人和喝矿泉水的人相邻；

如今以不可同日而语之犀利眼光，一眼发现这些条件真面目，不过是一个个Predicate委托而已。当然先建五个枚举：

enum Color
{
Red,Green,Yellow,Blue,White
}

enum Nation
{
Britain,Norway,Danmark, Sweden,Germany
}

enum Pet
{
Bird,Horse,Cat,Dog,Fish
}

enum Drink
{
Tea, Beer, Coffee, Water,Milk
}

enum Smoke
{
Blends, BlueMaster, PallMall, DunHill, Prince
}

又刷刷刷地敲出了这样的代码：

3. Danish.Drink == Drink.Tea;

4. var guyInGreen = AllPeople.First(g=>g.HColor==HColor.Green);
var guyInWhite = AllPeople.First(g=>g.HColor==HColor.White);
guyInWhite.Position - guyInGreen.Position == 1;

5. guy = AllPeople.Where(g=>g.HColor==HColor.Green||g.Drink ==Drink.Coffee);
if(guy.Count() > 1) throw;
if(guy.HColor == Green) guy.Drink = Coffee;
……

写了几段，就意识到不对劲了。主要是每个条件最后一句，是该判断呢，还是该赋值呢？比如说如果一个人，住在红房子里，那他一定是英国人。那就要看这个人有哪些属性已经确定了。

而且，如果既现在既不确定哪个住红房子，也不知道谁是英国人，怎么办？经过反复思考，我想每个条件，除了能提供判断，以及合适时赋值，还要提供推断，即可能的方案以供尝试。先选一种方案，然后下个条件再判断现在的状态是否合法，是的话再提出一组方案，不然就选上一条件中的下一个方案。

想到这里，算法的轮廓大致浮现了出来。每个条件，将成为一个个Condition类的实例。而另一个领域模型，之前没有想到的类，已经呼之欲出，即将登上舞台成为主角。导演，自然是偶了。

这场好戏，现在该考虑故事背景了。想在潘多拉星球上拍神雕侠侣，大概观众会吐血，当然更别说种山楂树，观众不吐我都要吐了。在上下班路上，内心经过痛苦的斗争，偶决定放弃风花雪月的属性，因为给每个属性创建状态标识的成本太高。于是偶移师海阔天空的大自然，不加雕琢的Dictionary成了这部戏的主要外景。

class Guy
{
public Dictionary Properties = new Dictionary(6);
......
}

class PN   //PropertyName
{
public const string Color = "Color";

public const string Pet = "Pet";

public const string Nation = "Nation";

public const string Drink = "Drink";

public const string Smoke = "Smoke";

public const string Postion = "Postion";

public static IEnumerable GetNames()
{
yield return Postion;
yield return Nation;
yield return Color;
yield return Drink;
yield return Pet;
yield return Smoke;
}
}

Guy类的主要函数，就是围绕Guy.Properties这个属性字典进行操作，如何封装取决于Condition类的实现。对于条件中单独一个属性，本来可以用 KeyValuePair<string,int>表示，不过太长，所以自己写了个Property类。要是类型能定义别名就好了。看题目中的条件，不少都是根据位置作判断的，所以位置是特殊的属性，如果能用来作Guy的主键，应该可以事半功倍。

下面，期待中的主角露出了庐山真面目，完全是我们以抽象思维创作出来艺术形像。其实很简单，但没艺术细胞的想不出，不会创作的写不出，大家认为呢？

class Attempt
{
public Guy[] Guys = new Guy[2];
public Property[] Properties = new Property[2];

public void Act()
{
Guys[0].SetProperty(Properties[0]);
if(Guys[1] !=null) Guys[1].SetProperty(Properties[1]);
}

public void RollBack()
{
Guys[0].RemoveProperty(Properties[0]);
if (Guys[1] != null) Guys[1].RemoveProperty(Properties[1]);
}

public Attempt(Property[] properties, Guy[] guys)
{
Guys = guys;
Properties = properties;
}

public Attempt(Property[] properties, Guy guy)
{
Guys[0] = Guys[1] = guy;
Properties = properties;
}

public Attempt(Property property, Guy guy)
{
Guys[0] = guy;
Properties[0] = property;
}
}

接着来参观下为主角量身打造的舞台吧，大导演拍大片，当然要打造大舞台，比世博园还大，看个样子就行了 :)

abstract class Condition
{
protected Property[] Properties = new Property[2];

protected Condition(Property p1, Property p2);

protected Condition() { }

public abstract MatchResult Match(IList guys, ref IList attempts);

}
///
/// 同人条件
///
class SameGuyCondition : Condition
{
public SameGuyCondition(Property p1, Property p2);

public override MatchResult Match(IList guys, ref IList attempts);
}
///
/// 相邻条件
///
class AdjacentCondition : Condition
{
RelativePosition Relation;  //default is both

public AdjacentCondition(Property p1, Property p2);

public AdjacentCondition(Property p1, Property p2, RelativePosition relation);

public override MatchResult Match(IList guys, ref IList attempts);
}

这场戏分十几场来拍，有了前面的准备，剧本一气呵成：

class Puzzle
{
static IList conditions = new List();

public static void Start()
{
......

AddCondition(PN.Nation, Nation.Britain, PN.Color, Color.Red);
AddCondition(PN.Nation, Nation.Sweden, PN.Pet, Pet.Dog);
AddCondition(PN.Nation, Nation.Danmark, PN.Drink, Drink.Tea);
AddCondition(PN.Color, Color.Green, PN.Color, Color.White, RelativePosition.Left);
AddCondition(PN.Color, Color.Green, PN.Drink, Drink.Coffee);
AddCondition(PN.Smoke, Smoke.PallMall, PN.Pet, Pet.Bird);
AddCondition(PN.Color, Color.Yellow, PN.Smoke, Smoke.DunHill);
AddCondition(PN.Postion, 3, PN.Drink, Drink.Milk);
AddCondition(PN.Nation, Nation.Norway, PN.Postion, 1);
AddCondition(PN.Smoke, Smoke.Blends, PN.Pet, Pet.Cat, RelativePosition.Both );
AddCondition(PN.Pet, Pet.Horse, PN.Smoke, Smoke.DunHill, RelativePosition.Both);
AddCondition(PN.Smoke, Smoke.BlueMaster, PN.Drink, Drink.Beer);
AddCondition(PN.Smoke, Smoke.Prince, PN.Nation, Nation.Germany);
AddCondition(PN.Nation, Nation.Norway, PN.Color, Color.Blue, RelativePosition.Both);
AddCondition(PN.Drink, Drink.Water, PN.Smoke, Smoke.Blends, RelativePosition.Both);

......
}
}

看上去万事俱备，只欠东风了。事实上要借到东风，还须一些神通，最后一步还有一道难题，这么多场景如何串联在一起？这种戏偶以前从未拍过，考验功底的时候到了。在僵局的时刻，“搜索树”在脑中灵光一现，对，听这名字就是我要的。虽然不知所谓，也从未用过，但“树”我懂的啊。实话说，偶很讨厌写这些树啊图啊的，不过关键时刻，难不倒偶的。

class StepNode
{
///
/// The number of stage in the search tree, each stage match a condition
///
public Int32 Index;

StepNode[] Steps;

public StepNode Parent;

public Attempt Action;
///
/// The index indicates which step should be continued now, the previous steps has failed.
///
Int32 currentStepIndex;

Boolean Ending
{
get
{
if (Steps == null) return true;
return currentStepIndex >= Steps.Length;
}
}

public StepNode Next()
{
StepNode nextNode;
if (Ending)
{
if (Action != null) Action.RollBack();
nextNode = Parent.Next();
}
else nextNode = Steps[currentStepIndex];
currentStepIndex++;
return nextNode;
}

public StepNode Expand(IList attempts)
{
if (attempts != null || attempts.Count > 0)
{
Steps = new StepNode[attempts.Count];

for (int i = 0; i < attempts.Count; i++)
{
Steps[i] = new StepNode { Parent = this, Index = Index + 1, Action = attempts[i] };
}
}
else
{
Steps = new StepNode[] {
new StepNode { Parent = this, Index = Index + 1 }
};
}
return this;
}
}

class Puzzle
{
static IList conditions = new List();
static IList attempts = new List();
static IList guys;

public static void Start()
{
guys = GuyRuler.Init();

#region Init conditions
... ...
#endregion

var root = new StepNode();

GoFrom(root);
}

static void GoFrom(StepNode node)
{
if (node.Index >= conditions.Count) return;

if (node.Action != null) node.Action.Act();
var result = conditions[node.Index].Match(guys, ref attempts);

if (result == MatchResult.Fail)
{
if (node.Action != null) node.Action.RollBack();
node = node.Parent.Next();
}
else
{
node = node.Expand(attempts).Next();
}

GoFrom(node);
}
}

非常顺利，人就要敢于尝试和突破。照例，杀青前，测试下结果：





有点奇特是吧，结果差距怎么这么大？可千万别被迷惑了，由于输出结果时用了Enum的反射，这是个绝对的性能杀手。在我Core7200处理器,32位Win7电脑上，真正计算过程不到2ms!

附源代码下载，里面几个类都重写了ToString方法，在VS下调试时相当方便，这是其它开发环境望尘莫及的。怎么样，还是不够快啊。那好，下期再来优化它。