腾讯2014实习生招聘一道附加题 DP和分治两种解法

          题目：给定n块木板A[1,,....n]，每块木板高度不等，宽度相等，用这些木板排列成一面木板墙。木板排列好后，求解木板墙中最大的矩形面积。设计算法求得木板墙最大的矩形面积，并分析算法效率。

         例：下图中，木板墙的最大面积为深颜色区域的4*3 ：

           看到这个题，我第一反应就是这跟求一个数组的最大和子串差不多，用动态规划的方法可以在O(n)时间内解决。一开始我企图用与求最大和子串几乎一模一样的方法去求解，发现总有些情况是无法全面考虑。但是从问题的形式上来看，这个问题应该具有最优子结构，是可以用动态规划求解的，思考过程如下(小字不用看，是我开始想错的，留在这里表明自己思路是怎样跑偏的)：

           假设F(i)（0<i<n）是在包含第0，.......,到第i块木板的情况下，所能求得的最大面积，设height(i)为此时求得最大面积所取的高。那么F(i + 1) 的取值：

            F(i + 1) =  F(i) + height[i - 1]; A[i] >= height(i - 1) 这种情况是很显然的。//显然这里分类是做了多余的事，而且没有考虑height(i - 1)等于0时的情况

           那么在A[i] < height(i - 1)时。

           我设想，能不能像求最大和子串那样，将 F(i + 1) 表示成F(i)（而与F(i-1),,,F(1)无关）的函数呢，那样就可以像求最大和子串一样求解了，从这个题目中看，是不行的。

           举个例子，当A[] = {2,3,4,3,2}  (设i从1开始)，显然F(1) = 2, F(2) = 4, F(3) = 6 ,height(1) = 2,height(2) = 2,height(3) = 2(此时可取2也可取3，F(3)都是6，显然我们应该取较小的2)，F(4) = 9，height(4) = 3。显然A[5] < height(4),F(5)等于10，而这个10是无法由F(4)求出来的，也就是说，F(i + 1)是无法表示成未知数只为F(i)的函数的(在这一点上，本题与求数组最大子串和0-1背包问题是不同的，在这两个题中，目前的状态都只与前一个有关；本题与编程之美上“饮料供货”问题类似）。那要确定F(i + 1)的值，需要哪些信息呢？

           还是以A[] = {2,3,4,3,2}(i从1开始)为例，在i = 4时，height(4) = 3，虽然此时是以3为高求出F(4)=9，而如果以高为2求得的最大面积只能是8，但是从F(5)（通过高为2取得）的情况来看，其实高为2的时候才是最有潜力的，所以要求得后来的最大值，我们要把这些“潜力股”都保存下来。最简单的方法就是，把当n = i时，通过每一个小于等于A[i]的高度所能达到的面积都记下来（最大的那个值当然就是F(i)）；在计算F(i + 1)时，根据前面所有保存的值，采用不同的高度，求得这一块木板通过这些高度所能得到的面积，所有面积中的最大值为F(i + 1);

                   假设函数area[i,h]为在第i块木板处，采用h作为高度所能得到的面积，则其最大值即为F(i)。可将F(i+1)表示为：

                                                 F(i + 1) = max{ area[i,k] + k }; k = (0,,,,,A[i] - 1)

                      根据上述思路，实现该程序得额外用一个Area[n][MaxHeight]来存储信息；时间复杂度方面，要对A[]进行一次遍历，遍历时循环里面还要根据所有的Height从所有可能的Area里面选出最大的，复杂度为O(n*MaxHeight)。代码如下：

 

//为了方便，我将数组长度和最大高度定义成了宏
#define N 8
#define MaxHeight 100

int maxArea(int a[])
{
    int area[N + 1][MaxHeight + 1] = {{0}}; //
    int i,j,temp = 0;
    int h[N + 1] = {0};  //h[i]用来存取在i处取到最大值时所用的高
    int b[N + 1] = {0};  //将a存储在b中，下标从1开始

    for(i = N; i > 0; i-- )
        b[i] = a[i - 1];

    int MaxArea = b[1];
        h[1] = b[1];

    for(i = 1; i <= b[1]; i++)
        area[1][i] = i;   //对area数组初始化
     
     for(i = 2; i <= N; i++)
         {
           temp = 0;
           for(j = 1; j <= b[i]; j++)
              {
                area[i][j] = area[i - 1][j] + j;
                if(area[i][j] > temp)
                 {
                   temp = area[i][j];
                   h[i] = j;
                 }

              }
           MaxArea = MaxArea > temp ? MaxArea : temp;
            //printf("\n%d",MaxArea);
         }
    return MaxArea;
}

 本博客里面所有代码都只通过少量数据测试，跪求指正拍砖

          另外一种思路就是分治法，面对这种问题，分治法必然是屡试不爽的，哈哈。在这里，我的思路是，首先遍历A[i]（设其一共有n个元素，且每个元素都非负），找到其中最小的数（记为Min）的下标，然后以其为分割点分成左右两半进行递归求解最大面积。假设左边的面积所求得的最大面积为LMaxArea，右边求得的最大面积为RMaxArea，则最终要求的最大面积MaxArea = max(RMaxArea,LMaxArea,n*Min)，时间复杂度为O(nlogn)，代码如下：

//用来返回找到的最小值的位置
int find(int a[],int l, int u)
{
    int i ;
    int index = l;
    int m = a[l];

    for(i = l; i <= u; i++)
        if(a[i] < m)
           {
             m = a[i];
             index = i;
           }
    printf("%d\n",index);
    return index;
}


int Max(int a,int b,int c)
{
   int d = a > b ? a : b;
   return c > d ? c : d;
}
 
 
int MaxArea(int a[],int l, int u)
{
    if(l == u)
        return a[l];
    int lmax = 0, rmax = 0;
    int index = find(a,l,u);    
    if(index == l)  //防止越界
          {
            lmax = a[l];
            rmax = MaxArea(a,l + 1,u);
        }
    else if(index == u)
        {
            lmax = MaxArea(a,l,u - 1);
            rmax = a[u];
        }
    else
        {
            lmax = MaxArea(a,l,index - 1);
            rmax = MaxArea(a,index + 1,u);
        }

    return Max(lmax,rmax,a[index] * (u - l + 1));
}
 
 
int main()
{
	a[8] = {6,4,5,0,2,7,1,2}
	printf("%d\n",MaxArea(a,0,7));
	return 0;
}