热门智力题 过桥问题和倒水问题

winston

过桥问题和倒水问题都是笔试面试中的热门智力题，不但微软、GOOGLE、百度、腾讯等公司采用，甚至在IQ测试与公务员考试中都能见到。本文不但教你如何快速用手算来解决这两种问题，并且教你如何用程序代码来计算这两种问题。绝对让你大有收获。
一．过桥问题在漆黑的夜里，四位旅行者来到了一座狭窄而且没有护栏的桥边。如果不借助手电筒的话，大家是无论如何也不敢过桥去的。不幸的是，四个人一共只带了一只手电筒，而桥窄得只够让两个人同时通过。如果各自单独过桥的话，四人所需要的时间分别是1，2，5，8分钟；而如果两人同时过桥，所需要的时间就是走得比较慢的那个人单独行动时所需的时间。问题是，你如何设计一个方案，让用的时间最少。
这个题目被微软、GOOGLE、百度、华硕、建设银行等很多公司用作笔试题或面试题。当然也有用在IQ测试中。
解答其实也容易，能者多劳这四个字就足以形容解答方案了——用时短的人必须要多跑几趟以便传递手电筒。
设这四个人叫做A，B，C，D，他们所需要的时间分别是1，2，5，8分钟。
第一步：A和B过桥，花费2分钟。
第二步：A回来，花费1分钟。
第三步：C和D过桥，花费8分钟。
第四步：B回来，花费2分钟。
第五步：A和B过桥，花费2分钟。
这样只要花费2+1+8+2+2=15分钟，下面再来考虑如何用程序来解决这类问题，在写程序之前还有个细节要考虑下，比如A，B，C，D四个人所需要的时间分别是1，8，9，10分钟。
方案一
第一步：A和B过桥，花费8分钟。
第二步：A回来，花费1分钟。
第三步：C和D过桥，花费10分钟。
第四步：B回来，花费8分钟。
第五步：A和B过桥，花费8分钟。
一共要8+1+10+8+8=35分钟。
方案二
第一步：A和B过桥，花费8分钟。
第二步：A回来，花费1分钟。
第三步：A和C过桥，花费9分钟。
第四步：A回来，花费1分钟。
第五步：A和D过桥，花费10分钟。
一共要8+1+9+1+10=29分钟。
因此可以得出更加细化的解决方案——要么是最快者将最慢的2个送过桥，要么是最快的2个将最慢的2个送过桥。即将过桥的人按其过桥的时间从小到大排列，设为A，B，…… Y，Z。其中A和B是最快的二个，Y和Z是最慢的二个。那么就有二种方案：
方案一 最快者将最慢的2个送过桥
第一步：A和Z过桥，花费Z分钟。
第二步：A回来，花费A分钟。
第三步：A和Y过桥，花费Y分钟。
第四步：A回来，花费A分钟。
这四步后总人数就减小2个，花费时间为A + A + Y + Z分钟。
方案二 最快的2个将最慢的2个送过桥
第一步：A和B过桥，花费B分钟。
第二步：A回来，花费A分钟。
第三步：Y和Z过桥，花费Z分钟。
第四步：B回来，花费B分钟。
这四步后总人数同样减小2个，花费时间为A + B + B + Z分钟。
这样，每次比较一下这二种方案就能将总人数减小2。然后我们再考虑一些边界情况：
有三个人过桥设为A，B，C（已经排好序，下同）。应该花费A + B + C分钟。
有二个人过桥设为A，B。那么肯定是花费B分钟。
有一个人过桥设为A。肯定花费A分钟。

分析至此，代码很容易写出，对输入的数据可以用快速排序来排下序（关于qsort的使用，可以参见《使用VC库函数中的快速排序函数》）。
//热门智力题 - 过桥问题

1. #include<iostream.h>
2. #include<stdlib.h>
3. const int MAXN = 1000;
4. int cmp(const void *x,const void *y)
5. {
6.         return *(int *)x-*(int *)y;
7. }
8. int main()
9. {
10.         cout<<"热门智力题 - 过桥问题"<<endl;
11.         cout<<"  --by MoreWindows( http://blog.csdn.net/MoreWindows )--\n"<<endl;  
13.         int n, i, sum, a[MAXN];
14.         cout<<"请输入人数：";
15.         cin>>n;
16.         cout<<"请输入每个人过桥时间，以空格分开"<<endl;
17.         for (i = 0; i < n; i++)
18.                 cin>>a[i];
19.         qsort(a, n, sizeof(a[0]), cmp);
20.         sum = 0;
21.         for (i = n - 1; i > 2; i = i - 2)
22.         {  
23.                 //最小者将最大2个送走或最小2个将最大2个送走
24.                 if (a[0] + a[1] + a[1] + a[i] < a[0] + a[0] + a[i - 1] + a[i])
25.                         sum = sum + a[0] + a[1] + a[1] + a[i];
26.                 else
27.                         sum = sum + a[0] + a[0] + a[i - 1] + a[i];       
28.         }
29.         if (i == 2)
30.                 sum = sum + a[0] + a[1] + a[2];
31.         else if (i == 1)
32.                 sum = sum + a[1];
33.         else
34.                 sum = a[0];
35.         cout<<"最短过桥时间为："<<sum<<endl;
36.         return 0;
37. }

复制代码

程序运行结果如下：



二．倒水问题这个题目的版本非常之多，有微软版的，腾讯版的，新浪版的等等，最常见的是给你一个容量为5升的桶和一个容量为3升的桶，水不限使用，要求精确得到4升水。

解法肯定有很多，可以用宽度优先搜索（BFS），也可以用穷举法。穷举法实现比较方便，其基本思想是用：用小桶容量的倍数对大桶的容量进行取余。比如3升的桶和5升的桶得到4升水可以这样做：

3 % 5 = 3

6 % 5 = 1

9 % 5 = 4

成功得到4升水。（PS：上面的过程用如何用文字描述了？）

同样，用7升的桶和11升的桶得到2升水可以这样做：

7 % 11 = 7

14 % 11 = 3

21 % 11 = 10

28 % 11 = 6

35 % 11 = 2

成功得到2升水。

哈哈，有了这个基本思想在用笔算答案时简直是遇神杀神，遇佛杀佛，又方便又快速！如果要求用程序来实现如何做了？easy，将倒水问题的基本思想用易于编程的话来翻译下——不断用小桶装水倒入大桶，大桶满了立即清空，每次判断下二个桶中水的容量是否等于指定容量。有了这个倒水问题的编程指导方针后代码非常容易写出：

1. //热门智力题 - 打水问题
2. //基本思想：用小桶容量的倍数对大桶的容量进行取余。
3. //指导方针：不断用小桶装水倒入大桶，大桶满了立即清空，
4. //每次判断下二个桶中水的容量是否等于指定容量。
5. #include<iostream>
6. #include <vector>
7. #include<string>
8. using namespace std;
9. const string OPERATOR_NAME[7] = {
10.         "装满A桶","装满B桶",
11.         "将A桶清空","将B桶清空",
12.         "A桶中水倒入B桶","B桶中水倒入A桶",
13.         "成功"
14. };
15. int main()
16. {
17.         cout<<"热门智力题 - 打水问题"<<endl;
18.         cout<<"  --by MoreWindows( http://blog.csdn.net/MoreWindows )--\n"<<endl;
20.         int    a_volume, b_volume, goal_volume;
21.         vector<string> record;       //记录操作步数
22.         int    ai;
23.         int    i, a_water, b_water;
25.         cout<<"请输入A桶容量，B桶容量，目标容量：";
26.         cin>>a_volume>>b_volume>>goal_volume;
27.         a_water = b_water = 0; //A桶，B桶中有多少升水
28.         char szTemp[30];
29.         while (true)
30.         {
31.                 if (a_water == 0)//A桶没水,就装满水
32.                 {
33.                         a_water = a_volume;
34.                         sprintf(szTemp, "         A:%d  B:%d", a_water, b_water);
35.                         record.push_back(OPERATOR_NAME[0] + szTemp);//fill A
36.                 }
37.                 else
38.                 {
39.                         //如果A桶的水比(B桶容量-B桶的水)要多
40.                         if (a_water > b_volume - b_water)
41.                         {
42.                                 //A桶的水==A桶的水+B桶的水-B桶容量
43.                                 a_water = a_water + b_water- b_volume;
44.                                 b_water = b_volume;                 //B桶的水装满了
45.                                 sprintf(szTemp, "  A:%d  B:%d", a_water, b_water);
46.                                 record.push_back(OPERATOR_NAME[4] + szTemp);//A->B       
47.                                 if (a_water == goal_volume)
48.                                         break;
49.                                 b_water = 0;                        //将B桶清空
50.                                 sprintf(szTemp, "       A:%d  B:%d", a_water, b_water);
51.                                 record.push_back(OPERATOR_NAME[3] + szTemp);
52.                         }
53.                         else
54.                         {
55.                                 //B桶的水==A桶的水+B桶的水
56.                                 b_water += a_water;       
57.                                 a_water = 0;
58.                                 sprintf(szTemp, "  A:%d  B:%d", a_water, b_water);
59.                                 record.push_back(OPERATOR_NAME[4] + szTemp);//A->B
60.                                 if (b_water == goal_volume)
61.                                         break;
62.                         }
63.                 }
64.         }
65.         record.push_back(OPERATOR_NAME[6]);        //success
66.         cout<<"\n---------------------------------------------------"<<endl;
67.         cout<<"一个可行的倒水方案如下"<<endl;
68.         vector<string>::iterator pos;
69.         for (pos = record.begin(); pos != record.end(); pos++)
70.                 cout<<*pos<<endl;
71.         cout<<"---------------------------------------------------"<<endl;
72.         return 0;
73. }

复制代码

程序运行结果如下：

注意这里只是给出一个可行的倒水方案，不一定是最优解。另外倒水问题要注意下像用2升的桶和4升的桶得到3升水这种不可解的情况，这种不可解情况在用本文中对倒水问题所总结的基本思想计算时会得到循环数列。其根本原因是二个桶容量的最大公约数无法被目标容量所整除，如6升的桶和9升的桶无法得到2升水是因为6和9的最大公约数是3即GCD(6，9)=3而3无法整除2。
倒水问题也也容易推广到多个桶的情况，分析方法和上文差不多，这里就不再赘述了。

过桥问题和倒水问题就讲解到此，相信以后这二类问题都不会再困扰大家了^_^。

转载请标明出处，原文地址：http://blog.csdn.net/morewindows/article/details/7481851
如果觉得本文对您有帮助，请点击‘顶’支持一下，您的支持是我写作最大的动力，谢谢。