LeetCode T11

class Solution:
    def maxArea(self, height):
        n = len(height)
        if n<2:
            return 0
        
        # 如果不止一条柱子
        d = dict()
        result = 0
        for i in range(n):
            if height[i] not in d.keys():
                d[height[i]] = []
                d[height[i]].append(i)
            else:
                d[height[i]].append(i)
                
        # d_k 为以高度为键，所在位置为值(值有多个，所以用列表存储)的字典，并且以高度进行降序排列的列表
        d_k = sorted(d.items(), key=lambda x:x[0])[::-1]

        # 定义边界变量
        left = 0
        right = 0
        
        s = 0
        h = 0
        count = 1
        # 如果最高柱子不止一条，那么首先选取最高的柱子作为高度，最小索引作为左边界，最大索引作为右边界
        if len(d_k[0][1])>1:
            h = d_k[0][0]
            left = d_k[0][1][0]
            right = d_k[0][1][-1]
        else:
            count = 2
            h = d_k[1][0]
            # 第二高的柱子数为1
            if len(d_k[1][1])==1:
                # 最高柱子在右边
                if d_k[0][1][0] > d_k[1][1][0]:
                    right = d_k[0][1][0]
                    left = d_k[1][1][0]
                # 最高柱子在左边
                else:
                    right = d_k[1][1][0]
                    left = d_k[0][1][0]
            # 第二高柱子数不唯一
            else:
                # 最高柱子在左边
                if d_k[1][1][0] > d_k[0][1][0]:
                    right = d_k[1][1][-1]
                    left = d_k[0][1][0]
                # 最高柱子在右边
                elif d_k[1][1][-1] < d_k[0][1][0]:
                    right = d_k[0][1][0]
                    left = d_k[1][1][0]
                # 最高柱子在中间
                else:
                    right = d_k[1][1][-1]
                    left = d_k[1][1][0]
        s = h*(right-left)
        
        # 已确定好左右边界

        # 遍历剩下高度
        # 遍历从几开始，由上面讨论决定
        for t in d_k[count:]:
            
            h = t[0]
            # 如果此高度柱子不唯一
            if len(t[1])>1:
                temp_left = t[1][0]
                temp_right = t[1][-1]
                # 如果临时左边界在确定左边界的左边
                if temp_left<left:
                    left = temp_left
                    s_temp = (right - left)*h

                    # 如果临时左边界与确定右边界围成的面积比确定面积大，更改用临时左边界替换确定边界，作为确实左边界
                    if s_temp >= s:
                        s = s_temp
                        # 如果临时右边界比确定右边界还右，用临时右边界替换确定右边界
                        if temp_right > right:
                            right = temp_right
                            s = h*(right-left)
                    if temp_right > right:
                        right = temp_right
                        s_temp = (right - left)*h
                        if s_temp >= s:
                            s = h*(right-left)
    
                # 如果临时左边界不在确定左边界的左边，只需考虑临时右边界是否在确定右边界的右边
                # 如果在，临时右边界和确定左边界围成的面积比确定面积大，则用临时右边界换掉确定右边界，当做确定右边界
                else:
                    if temp_right > right:
                        right = temp_right
                        s_temp = (right - left)*h
                        if s_temp >= s:
                            s = s_temp
                            
            # 如果此高度柱子唯一
            else:
                temp_e = t[1][0]
                # 如果这柱子在确定左边界左边，而且该柱子与确定右边界围成的面积大于确定面积，则把确定左边界换成该柱子
                if temp_e<left:
                    left = temp_e
                    s_temp = (right - left)*h
                    if s_temp >= s:
                        s = s_temp
                # 如果这柱子在确定右边界右边，而且该柱子与确定左边界围成的面积大于确定面积，则把确定右边界换成该柱子
                if temp_e>right:
                    right = temp_e
                    s_temp = (right-left)*h
                    if s_temp >= s:
                        s = s_temp
        return s