求出 N 座大楼的外轮廓线

原文地址：点击打开链接

水平面上有 N 座大楼，每座大楼都是矩阵的形状，可以用三个数字表示(start, end, height)，分别代表其在x轴上的起点，终点和高度。大楼之间从远处看可能会重叠，求出 N 座大楼的外轮廓线。

外轮廓线的表示方法为若干三元组，每个三元组包含三个数字 (start, end, height)，代表这段轮廓的起始位置，终止位置和高度。

注意事项

请注意合并同样高度的相邻轮廓，不同的轮廓线在x轴上不能有重叠。

样例

给出三座大楼：

[  [1, 3, 3],  [2, 4, 4],  [5, 6, 1]]

外轮廓线为：

[  [1, 2, 3],  [2, 4, 4],  [5, 6, 1]]

解答时产生2个思路：（合理假设有利于解题）

【提前假设：1：全部大楼的start已按从小到大排序好，2：已知所有大楼中最大的end值为R，最小的start为L】

1：由于大楼三元组start，end都处于同一坐标轴上，因此可做相应的思维转换，“每点上方的高度可视为映射在坐标轴上的元素”，俗称”踩扁“，此后所有大楼轮廓（已处理）可视为一条有R+1长，映射着不同而又有连续性的元素的直线。只需要遍历每一座大楼，如果该大楼的高度比直线映射的元素要大，那么替换高度到相应的直线坐标轴上即可。后续处理该直线，让其成为轮廓三元组只需找到相应的连续元素即可完成。但当轮廓end在某一座大楼坐标中，该end点为轮廓的切割点，按实际来算该点映射有2个元素，但总显示相对高的元素而已。因此需要特别注意。

【优点：1：可忽略大楼的三元组顺序。2：无需判断任何可能性，因为直线上映射的元素替换是由比其高的元素决定的。3：可自动合并相邻同高度轮廓】

【缺点：虽然思维转换让问题本身显得相对容易，但其会影响一定的时间复杂度】

结构定义如下：

[cpp] view plain copy

1. typedef struct mab  
2. {  
3.     int start,end,hight;  
4. } mab;  

思路一代码实现如下：

[cpp] view plain copy

1. void Method_1(mab *p,int len,vector<mab>&v)  
2. {  
3.     int i,f,r=0;  
4.     mab q;  
5.     for(i=0; i<len; ++i)  
6.     {  
7.         if(p[i].end>r)  
8.             r=p[i].end;  
9.     }  
10.     char *t=new char[r+1];  
11.     memset(t,0,r+1);  
12.     for(i=0; i<len; ++i)  
13.         for(f=p[i].start; f<=p[i].end; ++f)  
14.             if(t[f]<p[i].hight)  
15.                 t[f]=p[i].hight;  
16.     for(f=0; f<r+1; ++f)  
17.     {  
18.         if(t[f]>0)  
19.         {  
20.             q.start=f;  
21.             for(i=f; i<r+1; ++i)  
22.                 if(t[i]!=t[f])  
23.                     break;  
24.             f=i-1;  
25.             for(i=0; i<len; ++i)  
26.                 if(p[i].start<f+1&&p[i].end>f+1)  
27.                     break;  
28.             if(i!=len)  
29.                 q.end=f+1;  
30.             else  
31.                 q.end=f;  
32.             q.hight=t[f];  
33.             v.push_back(q);  
34.         }  
35.     }  
36.     delete[] t;  
37. }  

2：两大楼的轮廓之间出现的行为可看为相交，包容，不相交3种。遍历每座大楼判断其与其他大楼之间的关系显然是一件吃力不讨好的事。但对于顺序处理的轮廓来说，却是另外一回事。

把每一座大楼的关系处理成轮廓与某大楼间的关系，是我这思路的重点。然而会得出结论如下：

1：顺序处理n座大楼，得到q个轮廓，第n+1座大楼与第q轮廓只会出现相交与不相交的情况。

2：第q轮廓start若出现于第n+1座大楼start后，则该大楼与第q，q-1轮廓面积上都有相交。因为产生该可能性轮廓的大楼关系为相交或包容。若否，则只可能与第q轮廓相交。

按照以上结论，只需把最后轮廓与目前处理的大楼按唯一的可能性进行处理动作就能完成解题。

【优点：时间复杂度相对较低】

【缺点：必须保证大楼start值已排序，但处理可能性比较费劲】

思路二代码实现如下：

[cpp] view plain copy

1. void Method_2(mab *p,int len,vector<mab>&t)  
2. {  
3.     mab x,xx;  
4.     t.push_back(p[0]);  
5.     int i,l;  
6.     for(i=1; i<len; ++i)  
7.     {  
8.         l=t.size()-1;  
9.         xx=t[l];  
10.         if(p[i].start<xx.start){  
11.             x=t[t.size()-2];  
12.             if(p[i].end<xx.start){  
13.                 if(p[i].hight>x.hight){  
14.                     t[l-1].end=p[i].start;  
15.                     t[l]=p[i];  
16.                     x.start=p[i].end;  
17.                     t.push_back(x);  
18.                     t.push_back(xx);  
19.                 }  
20.             }  
21.             else if(p[i].end>xx.end){  
22.                 if(p[i].hight>xx.hight){  
23.                     if(p[i].hight>x.hight){  
24.                         t[l-1].end=p[i].start;  
25.                         t[l]=p[i];  
26.                     }  
27.                     else if(p[i].hight==x.hight){  
28.                         t[l-1].end=p[i].end;  
29.                         t.pop_back();  
30.                     }  
31.                     else{  
32.                         t[l].hight=p[i].hight;  
33.                         t[l].end=p[i].end;  
34.                     }  
35.                 }  
36.             }  
37.             else{  
38.                 if(xx.hight==p[i].hight)  
39.                     t[l].end=p[i].end;  
40.                 else{  
41.                     x=p[i];  
42.                     x.start=xx.end;  
43.                     t.push_back(x);  
44.                 }  
45.             }  
46.         }  
47.         else{  
48.             if(p[i].end>xx.end){  
49.                 if(p[i].start>xx.end){  
50.                     if(xx.end+1==p[i].start&&xx.hight==p[i].hight)  
51.                         t[l].end=p[i].end;  
52.                     else  
53.                         t.push_back(p[i]);  
54.                 }  
55.                 else{  
56.                     if(p[i].hight>xx.hight){  
57.                         t[l].end=p[i].start;  
58.                         t.push_back(p[i]);  
59.                     }  
60.                     else if(p[i].hight==xx.hight){  
61.                         t[l].end=p[i].end;  
62.                     }  
63.                     else{  
64.                         xx=p[i];  
65.                         xx.start=t[l].end;  
66.                         t.push_back(xx);  
67.                     }  
68.                 }  
69.             }  
70.             else{  
71.                 if(xx.hight<p[i].hight){  
72.                     t[l].end=p[i].start;  
73.                     t.push_back(p[i]);  
74.                     xx.start=p[i].end;  
75.                     t.push_back(xx);  
76.                 }  
77.             }  
78.         }  
79.     }  
80. }