用程序解密爱因斯坦经典难题

爱因斯坦曾在20世纪初提过一个经典问题，据说世界上有98%的人回答不出来
问题：在一条街上，有5座房子，喷了5中颜色。每个房子住着不同国籍的人。每个人喝不同的饮料，抽不同品牌的香烟，养不同的宠物。
问题是：谁养鱼？
提示：1.英国人住红色房子
2.瑞典人养狗
3.丹麦人喝茶
4.绿色房子在白色房子左边
5.绿房子主人喝咖啡
6.抽PallMall香烟的人养鸟
7.黄色房子的主人抽Dunhill香烟
8.住在中间房子的人喝牛奶
9.挪威人住第一间房
10.抽Bleeds香烟的人住在养猫的人隔壁
11.养马的人住抽Dunhill香烟的人隔壁
12.抽BlueMaster的人喝啤酒
13.德国人抽Prince香烟
14.挪威人住蓝色房子隔壁
15.抽Bleeds香烟的人有一个喝水的邻居

 

作为程序员我并不想用推理的方式解密，而是通过程序来计算出答案，大致思路是，得到所有可能情况的组合，遍历所有的组合，找到满足所有条件的组合。这样养鱼的人就一目了然，难点就在于如何把这些条件转换成计算机可以识别的代码。（注：程序使用语言C#）

假设5个房子从左到右的编号为1,2,3,4,5，每个房子拥有一个颜色，而5个国籍的人分别和5个房子绑定，再加上人本身的3个习惯（抽烟，喝，宠物），所以可以看做每个国籍的人都拥有5个属性，构造一个“人”的类

    class Person    {        public int index { get; set; }        public Color color { get; set; }        public Drink drink { get; set; }        public Cigarette cigarette { get; set; }        public Pet pet { get; set; }    }

index表示这个人的位置，也就是他在第几间房子里，index的范围在1-5之间，color表示这个房子的颜色，剩下的4个属性用枚举定义

 

 enum Color    {        Red,        White,        Yellow,        Green,        Blue    }    enum Drink    {        Tea,        Milk,        Coffee,        Bear,        Water    }    enum Cigarette    {        PallMall,        Dunhill,        Bleeds,        BlueMaster,        Prince    }    enum Pet    {        Fish,        Dog,        Bird,        Cat,        Horse    }

这样一来，由这5个属性就可以组合成5^5=3125种不同的情况，接下来定义一个“人”的集合，这个集合包括所有可能的情况，用5个循环嵌套赋值

 static void Foreach(ref List<Person> list)        {            for (int i_index = 0; i_index < 5; i_index++)            {                for (int i_color = 0; i_color < 5; i_color++)                {                    for (int i_drink = 0; i_drink < 5; i_drink++)                    {                        for (int i_cig = 0; i_cig < 5; i_cig++)                        {                            for (int i_pet = 0; i_pet < 5; i_pet++)                            {                                list.Add(new Person()                                {                                    index = i_index + 1,                                    color = (Color)i_color,                                    drink = (Drink)i_drink,                                    cigarette = (Cigarette)i_cig,                                    pet = (Pet)i_pet                                });                            }                        }                    }                }            }        }

观察条件就会发现其实有些情况根本就不会存在，比如绿房子主人喝咖啡所以如果某人的Color属性等于Green的话那么他的Drink属性一定等于Coffee，所以Color=Green和Drink=Bear或其他Drink这些组合都是不存在的。也就是说绿房主人不可能喝除咖啡以外的饮料，反过来说，喝咖啡的人也不可能不住绿房子，再看看这些类似的条件：5.绿房子主人喝咖啡6.抽PallMall香烟的人养鸟 7.黄色房子的主人抽Dunhill香烟 8.住在中间房子的人喝牛奶 12.抽BlueMaster的人喝啤酒 9.挪威人住第一间房和14.挪威人住蓝色房子隔壁由9和14这两2个条件可以推导出2号房的颜色是蓝色，根据这些约束条件画了个草图

连线表示2个属性是关联的，通过这个可以在开始构造的集合里面，排除掉这些不可能存在的情况，比如2-Blue，则表示不可能存在index=2并且color!=Blue的情况，或者

color=Blue并且index!=2的情况，依次类推，观察草图的连线，将不符合条件的情况全部从集合里排除

            //9.挪威人住第一间房            //14.挪威人住蓝色房子隔壁            list = list.Except(list.Where(p => (p.index == 2 && p.color != Color.Blue) || (p.index != 2 && p.color == Color.Blue))).ToList();            //8.住在中间房子的人喝牛奶            list = list.Except(list.Where(p => (p.index == 3 && p.drink != Drink.Milk) || (p.index != 3 && p.drink == Drink.Milk))).ToList();            //7.黄色房子的主人抽Dunhill香烟            list = list.Except(list.Where(p => (p.color == Color.Yellow && p.cigarette != Cigarette.Dunhill) || (p.color != Color.Yellow && p.cigarette == Cigarette.Dunhill))).ToList();            //5.绿房子主人喝咖啡            list = list.Except(list.Where(p => (p.color == Color.Green && p.drink != Drink.Coffee) || (p.color != Color.Green && p.drink == Drink.Coffee))).ToList();            //12.抽BlueMaster的人喝啤酒            list = list.Except(list.Where(p => (p.drink == Drink.Bear && p.cigarette != Cigarette.BlueMaster) || (p.drink != Drink.Bear && p.cigarette == Cigarette.BlueMaster))).ToList();            //6.抽PallMall香烟的人养鸟            list = list.Except(list.Where(p => (p.cigarette == Cigarette.PallMall && p.pet != Pet.Bird) || (p.cigarette != Cigarette.PallMall && p.pet == Pet.Bird))).ToList();

这个时候list的数量已经由之前的3125骤减至227了，等等，还有个约束条件绿色房子在白色房子左边也就是说index属性等于1并且color属性等于white的情况是不可能出现的，因为index=1&&color=white表示白色房子是第一间房子，这样它的左边就不可能有房子了，进一步过滤

 //4.绿色房子在白色房子左边 list = list.Except(list.Where(p => p.index == 1 && p.color == Color.White)).ToList();

暂时就只发现这么多了， 如果你还可以推理出更多的过滤条件就再好不过了，约束越多，list的数量就会越少，接下来的遍历就会越轻松。最终目的是要得到满足所有条件的5个国籍人的组合，每一个组合就是一个解答，再来分析1.英国人住红色房子 2.瑞典人养狗 3.丹麦人喝茶 9.挪威人住第一间房 13.德国人抽Prince香烟
英国人住红色房子，那么我们只要从集合里面过滤出color=red的就可以了，值得注意的是瑞典人养狗，那么英国人就不可能养狗了，同理英国人也不可能喝茶了，而瑞典人的房子也不可能是红色的了……以此类推，

            List<Person> England = list.Where(p => p.index != 1 && p.color == Color.Red && p.pet != Pet.Dog && p.drink != Drink.Tea && p.cigarette != Cigarette.Prince).ToList();            List<Person> Sweden = list.Where(p => p.index != 1 && p.color != Color.Red && p.pet == Pet.Dog && p.drink != Drink.Tea && p.cigarette != Cigarette.Prince).ToList();            List<Person> Denmark = list.Where(p => p.index != 1 && p.color != Color.Red && p.pet != Pet.Dog && p.drink == Drink.Tea && p.cigarette != Cigarette.Prince).ToList();            List<Person> Norway = list.Where(p => p.index == 1 && p.color != Color.Red && p.pet != Pet.Dog && p.drink != Drink.Tea && p.cigarette != Cigarette.Prince).ToList();            List<Person> Germany = list.Where(p => p.index != 1 && p.color != Color.Red && p.pet != Pet.Dog && p.drink != Drink.Tea && p.cigarette == Cigarette.Prince).ToList();

到这里得到了满足条件的英国人，瑞典人，丹麦人，挪威人和德国人的集合，他们的数量分别是18，12，18，7，18，共18*12*18*7*18=489888种组合，接下来的工作就是遍历每个组合，在剩下的条件里去验证。遍历5个国籍人的集合，从每个集合里面取一个人出来，把这5个人存到一个List<Person>里面，表示一个组合，如果验证成功则表示这个组合是解答

static List<List<Person>> Work(List<Person> England, List<Person> Sweden, List<Person> Denmark, List<Person> Norway, List<Person> Germany)        {            List<List<Person>> Result = new List<List<Person>>();            int count = 1;            long total = England.Count * Sweden.Count * Denmark.Count * Norway.Count * Germany.Count;            foreach (var e in England)            {                foreach (var s in Sweden)                {                    foreach (var d in Denmark)                    {                        foreach (var n in Norway)                        {                            foreach (var g in Germany)                            {                                List<Person> l = new List<Person>();                                l.Add(e);                                l.Add(s);                                l.Add(d);                                l.Add(n);                                l.Add(g);                                if (TestDistinct(l) && Test(l))                                {                                    Result.Add(l);                                }                                Console.WriteLine(string.Format("测试第{0}/{1}个结果,百分比：{2}%", count, total, count * 100 / total));                                count++;                            }                        }                    }                }            }                       return Result;        }

 

 通过剩下的条件验证：

static bool Test(List<Person> list)        {            //4.绿色房子在白色房子左边            if (list.Single(p => p.color == Color.Green).index >= list.Single(p => p.color == Color.White).index) return false;            //10.抽Bleeds香烟的人住在养猫的人隔壁            var p1 = list.Single(p => p.cigarette == Cigarette.Bleeds);            var p2 = list.Single(p => p.pet == Pet.Cat);            if (p1.index != p2.index - 1 && p1.index != p2.index + 1) return false;            //11.养马的人住抽Dunhill香烟的人隔壁            var p3 = list.Single(p => p.pet == Pet.Horse);            var p4 = list.Single(p => p.cigarette == Cigarette.Dunhill);            if (p3.index != p4.index - 1 && p3.index != p4.index + 1) return false;            //15.抽Bleeds香烟的人有一个喝水的邻居            var p5 = list.Single(p => p.cigarette == Cigarette.Bleeds);            var p6 = list.Single(p => p.drink == Drink.Water);            if (p5.index != p6.index - 1 && p5.index != p6.index + 1) return false;            return true;        }

先从集合中找到相应特征的2个人，通过比较2个人的index属性判断是否为邻居关系。当然在验证之前必须要保证每个人拥有的属性是唯一的，因为之前只是判断了每个国籍的人可能出现的所有情况，并没有组合起来判断，假设在这个集合中有2个人的color属性都是Green，这种情况肯定是不存在的，所以在验证前就应该排除掉，像这样

if (list.Count(p => p.index == 1) != 1) return false;            if (list.Count(p => p.index == 2) != 1) return false;            if (list.Count(p => p.index == 3) != 1) return false;            if (list.Count(p => p.index == 4) != 1) return false;            if (list.Count(p => p.index == 5) != 1) return false;            if (list.Count(p => p.color == Color.Red) != 1) return false;            if (list.Count(p => p.color == Color.White) != 1) return false;            if (list.Count(p => p.color == Color.Yellow) != 1) return false;……return true;

 

最后，将所有满足条件的List<Person>放到一起，输出结果：

if (Result.Count == 0)                Console.WriteLine("未得到任何结果！");            else            {                Console.WriteLine("得到" + Result.Count + "个结果");                for (int i = 0; i < Result.Count; i++)                {                    Console.WriteLine("******************第" + (i + 1) + "个解答******************");                    Console.WriteLine(string.Format("英国人住第{0}间房子，颜色：{1}，喝{2}，抽{3}，养{4}", Result[i][0].index, Result[i][0].color, Result[i][0].drink, Result[i][0].cigarette, Result[i][0].pet));                    Console.WriteLine(string.Format("瑞典人住第{0}间房子，颜色：{1}，喝{2}，抽{3}，养{4}", Result[i][1].index, Result[i][1].color, Result[i][1].drink, Result[i][1].cigarette, Result[i][1].pet));                    Console.WriteLine(string.Format("丹麦人住第{0}间房子，颜色：{1}，喝{2}，抽{3}，养{4}", Result[i][2].index, Result[i][2].color, Result[i][2].drink, Result[i][2].cigarette, Result[i][2].pet));                    Console.WriteLine(string.Format("挪威人住第{0}间房子，颜色：{1}，喝{2}，抽{3}，养{4}", Result[i][3].index, Result[i][3].color, Result[i][3].drink, Result[i][3].cigarette, Result[i][3].pet));                    Console.WriteLine(string.Format("德国人住第{0}间房子，颜色：{1}，喝{2}，抽{3}，养{4}", Result[i][4].index, Result[i][4].color, Result[i][4].drink, Result[i][4].cigarette, Result[i][4].pet));                }            }

 

 

好了，到这里程序已经编写完成了，激动人心的时刻来了，开始运行，遍历所有组合大约用时2分钟，答案就是 

 

共7个解答。

这里得到了7个解答，是因为条件4的判断是绿色房子在白色房子左边，而不一定是非要挨着的，如果绿色房子紧挨在白色房子左边，那么只需把代码改成

if (list.Single(p => p.color == Color.Green).index != list.Single(p => p.color == Color.White).index - 1) return false;

最后得到的结果是只有一个的。

这道题目，我后来用c++重写过，用的更简洁的思路，不需要任何推理。

注：该文章为作者maidou0921原创，csdn系首发，转载请注明出处http://blog.csdn.net/maidou0921/article/details/8192662。