记一道有趣的Twitter面试题

　　微信上的“程序员的那些事”想必是很多码农们关注的公众账号之一，我也是其粉丝，每天都会看看里面有没有什么趣事，前段时间“程序员的那些事”分享了一篇博文《我的Twitter技术面试失败了》挺有意思，链接如下http://mp.weixin.qq.com/mp/appmsg/show?__biz=MjM5OTA1MDUyMA==&appmsgid=10000710&itemidx=1&sign=fab77147279ef685c50e39cc06623e5d&uin=MjM3Mjc1NTIwMA%3D%3D&key=38b17fed399880fb7129f69083fd038240b4873f89a22a1bf82803ef35479ff9dda602589570716d1a73ae7c3e9f739d&devicetype=android-17&version=25000105&lang=zh_CN。

　　里面说到了一道算法题，给出一个数组，将其转化为二维坐标系的点，并且连接每个点形成一个“容器”状的图形，问“容器”能装多少水（详情参照上面的链接）。这道题吸引我的原因是，每当说到算法题，许多公司总是喜欢考一些查找、排序、大数据处理等等，没什么多新意，也考不了程序员的思维能力（面试前复习下《数据结构》即可）；而这道题很有新意，引发了我做一做的欲望，顺便也开拓一下思维，毕竟在实际工作中还是很少用到算法的。

　　第一次解题：思路很自然地想到从左到右遍历数组，确定左右底部的位置（即一个“蓄水区域”），进行一次容积的计算，然后将指针移动到此“蓄水区域”的右侧，继续确定下一个“蓄水区域” 的左右底部位置，再进行一次容积的计算...直到数组最右端，代码如下：

 /*
  * waterHolder.c
  *
  *  Created on: 2013-11-5
  *      Author: pengyiming
  *      Description: 1，输入如下的非负数组(2, 5, 1, 2, 4)，将其转化到二维坐标系中的点((2, 0), (2, 1), (5, 1), (5, 2), (1, 2), (1, 3), (2, 3), (2, 4), (4, 4), (4, 5))
  *                   2，连接上述个点形成一个"容器"
  *                   试问"容器"可装多少水，以1x1方格为单位
  *      Answer: 第一次遍历，从左向右遍历数组，找出左右侧最高点
  *              第二次遍历，遍历左右侧最高点之间的数组，计算容积
  */

 #include <stdio.h>

 /* 宏begin */
 #define TRUE 1
 #define FALSE 0
 /* 宏end */

 /* 输入数据begin */
 static const unsigned int WATER_BUCKET[] = { , , , , , , , ,  };
 /* 输入数据end */

 int main(int argc, char *argv[])
 {
     int volume = ;

     // "容器"左右侧高度，底部高度
     int leftHeight = ;
     int bottomHeight = ;
     int rightHeight = ;

     // "容器"左右侧高度，底部高度位置
     int leftPos = ;
     int bottomPos = ;
     int rightPos = ;

     // "容器"左侧高度，底部高度确定状态
     int leftPosOK = FALSE;
     int bottomPosOK = FALSE;

     // 遍历数组以获取"容器"中的每个蓄水区域
     int length = sizeof(WATER_BUCKET) / sizeof(unsigned int);
     while (TRUE)
     {
         int i;
         for (i = rightPos; i < length; i++)
         {
             // 寻找左侧位置
             if (!leftPosOK && WATER_BUCKET[i] >= leftHeight)
             {
                 leftHeight = WATER_BUCKET[i];
                 leftPos = i;

                 bottomHeight = WATER_BUCKET[i];
             }

             // 寻找底部位置，确定左侧位置
             if (!bottomPosOK && (WATER_BUCKET[i] < bottomHeight))
             {
                 bottomHeight = WATER_BUCKET[i];
                 bottomPos = i;

                 leftPosOK = TRUE;
                 rightHeight = WATER_BUCKET[i];
             }

             // 寻找右侧位置，确定底部位置
             if (leftPosOK && (WATER_BUCKET[i] > rightHeight))
             {
                 rightHeight = WATER_BUCKET[i];
                 rightPos = i;

                 bottomPosOK = TRUE;

                 // 优化：若右侧高度已经大于等于左侧高度，则已确定右侧位置，无需遍历完数组
                 if (rightHeight >= leftHeight)
                 {
                     break;
                 }
             }

             printf("loop : left = %d, right = %d, bottom = %d\n", leftPos, rightPos, bottomPos);
         }

         if (bottomPos > leftPos
                 && rightPos > bottomPos)
         {
             volume += countVolume(leftPos, rightPos, bottomPos);

             // 重置并计算下一个"蓄水区域"
             leftHeight = ;
             bottomHeight = ;
             rightHeight = ;

             leftPos = rightPos;
             bottomPos = rightPos;

             leftPosOK = FALSE;
             bottomPosOK = FALSE;
         }
         else
         {
             // 可能在"容器"中有多个蓄水区域，遍历可能需要多次，设定一个变量标识是否找到蓄水区域，当找不到时退出
             break;
         }
     }

     printf("total volume = %d\n", volume);

     return ;
 }

 int countVolume(int leftPos, int rightPos, int bottomPos)
 {
     printf("count volume : left = %d, right = %d, bottom = %d\n", leftPos, rightPos, bottomPos);

     if (WATER_BUCKET[leftPos] == WATER_BUCKET[bottomPos]
           || WATER_BUCKET[rightPos] == WATER_BUCKET[bottomPos])
     {
         return ;
     }

     // "容器"能装多少水取决于最短一侧的高度
     int minHeight = WATER_BUCKET[leftPos];
     if (minHeight > WATER_BUCKET[rightPos])
     {
         minHeight = WATER_BUCKET[rightPos];
     }

     int volume = ;
     int i;
     for (i = leftPos + ; i < rightPos; i++)
     {
         volume += minHeight - WATER_BUCKET[i];
     }

     return volume;
 }

　　上述算法通过了链接中及我自己列举的测试用例，说明上述代码确实能工作，但是其中掺杂了太多奇怪的boolean变量来帮助确定左右底部的位置，这使得代码可读性不好，且逻辑不够清晰，最近发完版后又闲下来了，重新理解了一下链接中的解题思路，确实比这段算法的思路清晰很多。

　　第二次解题：第一次遍历确定“容器”最高点，从而将“容器”一分为二，接下来只要分别确定“容器”左右侧最高点，并计算左右侧容积即可（“容器”左右侧最高点必定小于“容器”最高点，根据“木桶原理”，用左右侧最高点计算容积）。

　　多插一句，给出的数组是线性的，但是不见得非要从左到右遍历去解决问题，可以试一试上面这种分治的思路，线性的数组一分为二，分别通过左右两侧的子遍历来解决问题，代码如下：

 /*
  * waterHolder2.c
  *
  *  Created on: 2013-11-19
  *      Author: pengyiming
  *      Description: 1，输入如下的非负数组(2, 5, 1, 2, 4)，将其转化到二维坐标系中的点((2, 0), (2, 1), (5, 1), (5, 2), (1, 2), (1, 3), (2, 3), (2, 4), (4, 4), (4, 5))
  *                   2，连接上述个点形成一个"容器"
  *                   试问"容器"可装多少水，以1x1方格为单位
  *      Answer: 第一次遍历，遍历整个数组，找出最高点
  *              第二次遍历，分为两个子遍历最高点左右侧的数组，计算容积
  */

 #include <stdio.h>

 /* 宏begin */
 /* 宏end */

 /* 输入数据begin */
 static const unsigned int WATER_BUCKET[] = { , , , , , , , ,  };
 /* 输入数据end */

 int main(int argc, char *argv[])
 {
     int length = sizeof(WATER_BUCKET) / sizeof(unsigned int);
     int volume = ;

     int maxPos = findMaxPos(length);

     volume += countLeftVolume(maxPos);
     volume += countRightVolume(length, maxPos);
     printf("total volume = %d\n", volume);
 }

 int findMaxPos(int length)
 {
     int max = ;
     int maxPos = ;
     int i;
     for (i = ; i < length; i++)
     {
         if (WATER_BUCKET[i] > max)
         {
             max = WATER_BUCKET[i];
             maxPos = i;
         }
     }

     return maxPos;
 }

 int countLeftVolume(int maxPos)
 {
     int volume = ;
     int leftMax = ;
     int i;
     for (i = ;i < maxPos; i++)
     {
         if (leftMax >= WATER_BUCKET[i])
         {
             volume += leftMax - WATER_BUCKET[i];
         }
         else
         {
             leftMax = WATER_BUCKET[i];
         }
     }

     printf("left volume = %d\n", volume);
     return volume;
 }

 int countRightVolume(int length, int maxPos)
 {
     int volume = ;
     int rightMax = ;
     int i;
     for (i = length - ; i > maxPos; i--)
     {
         if (rightMax >= WATER_BUCKET[i])
         {
             volume += rightMax - WATER_BUCKET[i];
         }
         else
         {
             rightMax = WATER_BUCKET[i];
         }
     }

     printf("right volume = %d\n", volume);
     return volume;
 }

　　上述算法也通过了链接中及我自己列举的测试用例，如果大家还有什么更好的解法，欢迎不啬赐教！