让电脑像人脑一样思考，谁养鱼问题断言推理解法

记得第一次接触这个所谓的“爱因斯坦谜题”的时候，也花了很多时间做了一个比较难看的解法，大体上就是将不可能的条件筛掉一部分，然后再穷举。这样的解法可以说是相当难看的，因为只要题目的条件稍微变变，程序又要改一大堆。也是受限于当时的技术条件，的确很难实现一个比较通用的解题器。
不过在时过境迁的今天，利用新思想和新技术，我们能不能交出一份漂亮的答卷呢？
答案是肯定的。

我设计的第一个版本的思路是这样的，穷举所有的情况，然后将已知线索作为筛选器来检查每一种情况，如果有一种情况符合所有的线索，则就是最终答案。
类似于排列组合这种运算，老实说还真没有什么现成的方案，还是老老实实的笛卡尔积再筛选吧。
利用多重from表达式，我们能很方便的得到N个集合的笛卡尔积。
房子有五种宠物，五种颜色，五种国籍，五种香烟和五种饮料，将将它们互相得到一个每个房子的可能结果集，再对这个结果集进行五次自身的笛卡尔积，最终的结果筛去不满足前提条件的结果（有相同的颜色或宠物）。
第一个程序很快做出来了，结果跑了几十分钟还没有结果，猜想是结果集太大了。
其实用脚趾头想想都知道这个结果集的大小几乎是天文数字，我的笔记本是不可能算出来的，看来不能有侥幸心理。。。。

改，这一次使用一种先进的算法，计算五种宠物、五种颜色等的全排列，然后计算这些全排列的结果的笛卡尔积，这样得出来的结果不存在有相同颜色的房子这样的问题，结果集可以缩小一个很大的数量级。
计算全排列我使用了一种非常简单不通用的算法，难看就难看点，先解决问题吧：

public static IEnumerable<T[]> GetCustomPermutation<T>( this T[] array )
{
return from item1 in array
from item2 in array.Where( item => !item.Equals( item1 ) )
from item3 in array.Where( item => !( item.Equals( item1 ) || item.Equals( item2 ) ) )
from item4 in array.Where( item => !( item.Equals( item1 ) || item.Equals( item2 ) || item.Equals( item3 ) ) )
from item5 in array.Where( item => !( item.Equals( item1 ) || item.Equals( item2 ) || item.Equals( item3 ) || item.Equals( item4 ) ) )
select new T[] { item1, item2, item3, item4, item5 };

}

第二个程序就这样诞生了，运行。。。。。还是没有结果。。。。。
优化，避免延迟执行。。。。
还是没戏。。。。
看来还是结果集太大了。
我算算，五个东西的全排列，嗯，是5!=120，五个这样全排列的笛卡尔积的结果集大小是120^5，心算一下就知道这至少是个百亿级别的数了。

所以暴力的穷举就这样可耻的失败了。。。。。。

好吧，看来不给程序加上智能是不可能做到的了。

要给程序加上智能，就要将原来纯粹的判断改为智能的判断，原来的判断是这样的：

public static IEnumerable<Predicate<Conjecture>> GetKnownConditions()
{

//1、The Brit lives in the red house
yield return conjecture => conjecture.Any( house => house.Nationality == "Brit" && house.Color == "red" );

//2、The Swede keeps dogs as pets
yield return conjecture => conjecture.Any( house => house.Nationality == "Swede" && house.Pet == "dogs" );

//3、The Dane drinks tea
yield return conjecture => conjecture.Any( house => house.Nationality == "Dane" && house.Drinks == "tea" );

//4、The green house is on the immediate left of the white house as you stare at the front of the 5 houses
yield return conjecture => conjecture.Any( house => house.Color == "green" && house.IsImmediateLeftOf( _house => _house.Color == "white" ) );

//5、The green house owner drinks coffee
yield return conjecture => conjecture.Any( house => house.Color == "green" && house.Drinks == "coffee" );

//6、The person who smokes Pall Mall raises birds
yield return conjecture => conjecture.Any( house => house.Smokes == "Pall Mall" && house.Pet == "birds" );

//7、The owner of the yellow house smokes Dunhill
yield return conjecture => conjecture.Any( house => house.Color == "yellow" && house.Smokes == "Dunhill" );

//8、The man living in the house right in the center drinks milk
yield return conjecture => conjecture.Any( house => house.IsCenter && house.Drinks == "milk" );

//9、The Norwegian lives in the first house
yield return conjecture => conjecture.Any( house => house.Nationality == "Norwegian" && house.Index == 0 );

//10、The man who smokes Blends lives next to the one who keeps cats
yield return conjecture => conjecture.Any( house => house.Smokes == "Blends" && house.IsImmediateOf( _house => _house.Pet == "cats" ) );

//11、The man who keeps horses lives next to the one who smokes Dunhill
yield return conjecture => conjecture.Any( house => house.Pet == "horses" && house.IsImmediateOf( _house => _house.Smokes == "Dunhill" ) );

//12、The owner who smokes Bluemaster drinks juice
yield return conjecture => conjecture.Any( house => house.Smokes == "Bluemaster" && house.Drinks == "juice" );

//13、The German smokes Prince
yield return conjecture => conjecture.Any( house => house.Nationality == "German" && house.Smokes == "Prince" );

//14、The Norwegian lives next to the blue house
yield return conjecture => conjecture.Any( house => house.Nationality == "Norwegian" && house.IsImmediateOf( _house => _house.Color == "blue" ) );

//15、The man who smokes Blend has a neighbor who drinks water.
yield return conjecture => conjecture.Any( house => house.Smokes == "Blends" && house.IsImmediateOf( _house => _house.Drinks == "water" ) );

}

现在不能再这样判断了，要能够智能的提出断言，例如，如果发现一个房子是红色的，就断言里面住着英国人。好吧，这真是一个大工程，我只摘取部分代码：

public class Question
{

private class Clue0 : ClueBase
{
protected override bool Apply( Conjecture conjecture )
{
if ( conjecture.ExistColors.Distinct().Count() != conjecture.ExistColors.Count() )
throw new Exception();
if ( conjecture.ExistNationalities.Distinct().Count() != conjecture.ExistNationalities.Count() )
throw new Exception();
if ( conjecture.ExistDrinks.Distinct().Count() != conjecture.ExistDrinks.Count() )
throw new Exception();
if ( conjecture.ExistSmokes.Distinct().Count() != conjecture.ExistSmokes.Count() )
throw new Exception();
if ( conjecture.ExistPets.Distinct().Count() != conjecture.ExistPets.Count() )
throw new Exception();

if ( conjecture.ExistColors.Count() == 4 )
conjecture.First( house => house.Color == null ).Color = Conjecture.allColors.Except( conjecture.ExistColors ).First();

if ( conjecture.ExistNationalities.Count() == 4 )
conjecture.First( house => house.Nationality == null ).Nationality = Conjecture.allNationalities.Except( conjecture.ExistNationalities ).First();

if ( conjecture.ExistDrinks.Count() == 4 )
conjecture.First( house => house.Drinks == null ).Drinks = Conjecture.allDrinks.Except( conjecture.ExistDrinks ).First();

if ( conjecture.ExistSmokes.Count() == 4 )
conjecture.First( house => house.Smokes == null ).Smokes = Conjecture.allSmokes.Except( conjecture.ExistSmokes ).First();

if ( conjecture.ExistPets.Count() == 4 )
conjecture.First( house => house.Pet == null ).Pet = Conjecture.allPets.Except( conjecture.ExistPets ).First();

return false;
}
}

//1、The Brit lives in the red house
private class Clue1 : ClueBase
{
protected override bool Apply( Conjecture conjecture )
{
var house = conjecture.FirstOrDefault( item => item.Color == "red" );
if ( house != null )
{
house.Nationality = "Brit";
return true;
}

house = conjecture.FirstOrDefault( item => item.Nationality == "Brit" );
if ( house != null )
{
house.Color = "red";
return true;
}

return false;
}
}

//2、The Swede keeps dogs as pets
private class Clue2 : ClueBase
{
protected override bool Apply( Conjecture conjecture )
{
var house = conjecture.FirstOrDefault( item => item.Nationality == "Swede" );
if ( house != null )
{
house.Pet = "dogs";
return true;
}

house = conjecture.FirstOrDefault( item => item.Pet == "dogs" );
if ( house != null )
{
house.Nationality = "Swede";
return true;
}

return false;
}
}

//...

//15、The man who smokes Blend has a neighbor who drinks water.
private class Clue15 : ClueBase
{
protected override bool Apply( Conjecture conjecture )
{

var house = conjecture.FirstOrDefault( item => item.Smokes == "Blends" );

if ( house != null )
{

Func<HouseConditon, HouseConditon, bool> check = ( left, right ) =>
{
if ( left == null )
{
right.Drinks = "water";
return true;
}

if ( left.Drinks == "water" )
return true;

if ( left.Drinks != null )
{
right.Drinks = "water";
return true;
}

return false;
};

if ( check( house.GetImmediateLeft(), house.GetImmediateRight() ) )
return true;
if ( check( house.GetImmediateRight(), house.GetImmediateLeft() ) )
return true;
}

house = conjecture.FirstOrDefault( item => item.Drinks == "water" );

if ( house != null )
{

Func<HouseConditon, HouseConditon, bool> check = ( left, right ) =>
{
if ( left == null )
{
right.Smokes = "Blends";
return true;
}

if ( left.Smokes == "Blends" )
return true;

if ( left.Smokes != null )
{
right.Smokes = "Blends";
return true;
}

return false;
};

if ( check( house.GetImmediateLeft(), house.GetImmediateRight() ) )
return true;
if ( check( house.GetImmediateRight(), house.GetImmediateLeft() ) )
return true;
}

return false;
}
}

public static IEnumerable<IClue> GetClues()
{
yield return new Clue1();
yield return new Clue2();
yield return new Clue3();
yield return new Clue4();
yield return new Clue5();
yield return new Clue6();
yield return new Clue7();
yield return new Clue8();
yield return new Clue9();
yield return new Clue10();
yield return new Clue11();
yield return new Clue12();
yield return new Clue13();
yield return new Clue14();
yield return new Clue15();

yield return new Clue0();
}

}

请注意Clue0，这个其实是写在题目开头的已知条件，即所有房子颜色、宠物等都不相同。

Clue的基类型ClueBase负责捕获异常，并实现接口。

public interface IClue
{
bool IsApplied { get; }
bool TryApply( Conjecture conjecture );
}

public abstract class ClueBase : IClue
{

public bool IsApplied
{
get;
set;
}

public virtual bool TryApply( Conjecture conjecture )
{
try
{
IsApplied = Apply( conjecture );
return true;
}
catch
{
return false;
}
}

protected abstract bool Apply( Conjecture conjecture );

public override string ToString()
{
if ( IsApplied )
return "Applied";
else
return "NotApply";
}
}

好了，断言的冲突的问题采用异常来解决，即如果一个断言说A房子里住的是挪威人，而另一个断言已经宣布这个里面住的是英国人了，这样就造成了冲突，让它抛异常吧。这个逻辑写在了房子的属性里：

/// <summary>
/// 代表一个房子的所有情况
/// </summary>
public class HouseConditon
{

private string _color = null;
public string Color
{
get { return _color; }
set
{
if ( _color != null && _color != value )
throw new Exception();
_color = value;
}
}

private string _nationality = null;
public string Nationality
{
get { return _nationality; }
set
{
if ( _nationality != null && _nationality != value )
throw new Exception();
_nationality = value;
}
}

private string _drinks = null;
public string Drinks
{
get { return _drinks; }
set
{
if ( _drinks != null && _drinks != value )
throw new Exception();
_drinks = value;
}
}

private string _smokes = null;
public string Smokes
{
get { return _smokes; }
set
{
if ( _smokes != null && _smokes != value )
throw new Exception();
_smokes = value;
}
}

private string _pet = null;
public string Pet
{
get { return _pet; }
set
{
if ( _pet != null && _pet != value )
throw new Exception();
_pet = value;
}
}

internal HouseConditon( Conjecture conjectur, int index )
{
Conjecture = conjectur;
Index = index;
}

public Conjecture Conjecture { get; private set; }

public int Index { get; private set; }

/// <summary>
/// 获取紧挨在左边的房子
/// </summary>
/// <returns></returns>
public HouseConditon GetImmediateLeft()
{
if ( Index <= 0 )
return null;
else
return Conjecture[Index - 1];

}

/// <summary>
/// 获取紧挨在右边的房子
/// </summary>
/// <returns></returns>
public HouseConditon GetImmediateRight()
{
if ( Index >= 4 )
return null;
else
return Conjecture[Index + 1];

}

public override string ToString()
{
return string.Format( "{0,10}; {1,7}; {2,7}; {3,10}; {4,7}", Nationality, Color, Drinks, Smokes, Pet );
}
}

那个Conjecture其实就是房子状态的集合，具体如下：

/// <summary>
/// 代表一种假设
/// </summary>
public class Conjecture : IEnumerable<HouseConditon>
{

private HouseConditon[] _houses;

public Conjecture()
{
_houses = new HouseConditon[5].Initialize( i => new HouseConditon( this, i ) );
}

public HouseConditon this[int index]
{
get { return _houses[index]; }
}

#region IEnumerable<House> 成员

public IEnumerator<HouseConditon> GetEnumerator()
{
return ( (IEnumerable<HouseConditon>) _houses ).GetEnumerator();
}

#endregion

#region IEnumerable 成员

System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return GetEnumerator();
}

#endregion

public override string ToString()
{
return string.Format( "First: {0}\nSecond:{1}\nThird: {2}\nForth: {3}\nFifth: {4}\n", this[0], this[1], this[2], this[3], this[4] );
}

public Conjecture Clone()
{
var instance = new Conjecture();

for ( int i = 0; i < 5; i++ )
{
instance[i].Nationality = this[i].Nationality;
instance[i].Color = this[i].Color;
instance[i].Drinks = this[i].Drinks;
instance[i].Pet = this[i].Pet;
instance[i].Smokes = this[i].Smokes;
}
return instance;
}

public static readonly string[] allColors = new string[] { "red", "green", "white", "yellow", "blue" };
public static readonly string[] allDrinks = new string[] { "tea", "coffee", "milk", "juice", "water" };
public static readonly string[] allSmokes = new string[] { "Pall Mall", "Blends", "Bluemaster", "Dunhill", "Prince" };
public static readonly string[] allNationalities = new string[] { "Brit", "Swede", "Dane", "Norwegian", "German" };
public static readonly string[] allPets = new string[] { "dogs", "cats", "birds", "horses", "fish" };

public IEnumerable<string> ExistColors
{
get { return from house in this where house.Color != null select house.Color; }
}

public IEnumerable<string> ExistNationalities
{
get { return from house in this where house.Nationality != null select house.Nationality; }
}

public IEnumerable<string> ExistDrinks
{
get { return from house in this where house.Drinks != null select house.Drinks; }
}

public IEnumerable<string> ExistSmokes
{
get { return from house in this where house.Smokes != null select house.Smokes; }
}

public IEnumerable<string> ExistPets
{
get { return from house in this where house.Pet != null select house.Pet; }
}

}

好了，万事俱备，写一个程序跑跑。

但是发现在一片空白之下，通过这样的推理，程序只能找出三个房屋属性的确定位置，比如说喝牛奶的房子在中间。

解决的办法很简单，当电脑发现不能通过规则得到进一步的结果的时候，就猜一个。

猜测之后再去匹配规则，如果还不能得到进一步的结果，那么就再猜。

猜测的函数很简单：

private static void Guess( Conjecture conjecture )
{

Console.WriteLine( "Hmmmmmm...Guess!..." );

begin:

var house = conjecture[random.Next( 5 )];

switch ( random.Next( 4 ) )
{
case 0:
if ( house.Nationality == null )
{
var nationalities = Conjecture.allNationalities.Except( conjecture.ExistNationalities ).ToArray();
house.Nationality = nationalities[random.Next( nationalities.Length )];
return;
}
else
goto begin;

case 1:
if ( house.Color == null )
{
var colors = Conjecture.allColors.Except( conjecture.ExistColors ).ToArray();
house.Color = colors[random.Next( colors.Length )];
return;
}
else
goto begin;

case 2:
if ( house.Drinks == null )
{
var drinks = Conjecture.allDrinks.Except( conjecture.ExistDrinks ).ToArray();
house.Drinks = drinks[random.Next( drinks.Length )];
return;
}
else
goto begin;

case 3:
if ( house.Smokes == null )
{
var smokes = Conjecture.allSmokes.Except( conjecture.ExistSmokes ).ToArray();
house.Smokes = smokes[random.Next( smokes.Length )];
return;
}
else
goto begin;

}
}

这里没有写猜测宠物并不是出于什么特别的原因，而是因为懒的缘故，电脑猜这么几个东西已经足够得到结论了。

最终的程序样子是这样的：

Conjecture conjecture = new Conjecture();

var clues = Question.GetClues().ToArray();

int applies = 0;

Stack<Conjecture> stack = new Stack<Conjecture>();

while ( applies < 15 )
{

var statusString = conjecture.ToString() + applies;

if ( !clues.All( item => item.TryApply( conjecture ) ) || ( applies = clues.Count( item => item.IsApplied ) ) == 0 )
{
conjecture = new Conjecture();
clues = Question.GetClues().ToArray();
Console.WriteLine( "ooooooooops......my god....." );
continue;
}

applies = clues.Count( item => item.IsApplied );
if ( statusString == conjecture.ToString() + applies )
{
Guess( conjecture );
clues = Question.GetClues().ToArray();
}

Console.WriteLine( conjecture );

}

Console.WriteLine( "Found a result!!!" );
Console.WriteLine( conjecture );
Console.WriteLine();

Console.ReadLine();

哈哈，执行一把，在我的破本本上平均十几秒钟就能找到结果。很不错了，最关键的是，这是用人脑子的方式思考问题的程序。

性能不是这个程序的主要诉求，这个程序的革命性意义在于，15条线索（规则），都是独立于主逻辑之外的，我们可以随时新增和修改线索，这个程序同样能找到合理的解答。

当然这个程序还狠不完美，断言的代码冗余很严重。而这个问题，在表达式树出现后，呵呵，，，，，显然用表达式树来描述线索，再分析表达式树来创建断言函数。将使得这个程序更上一层楼。但我很懒，有兴趣的同学可以自己试试看哦。。。。