[Swift]LeetCode11. 盛最多水的容器 | Container With Most Water

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9883829.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Given n non-negative integers a1, a2, ..., an , where each represents a point at coordinate (i, ai). n vertical lines are drawn such that the two endpoints of line i is at (i, ai) and (i, 0). Find two lines, which together with x-axis forms a container, such that the container contains the most water.

Note: You may not slant the container and n is at least 2.

The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In this case, the max area of water (blue section) the container can contain is 49.

 Example:

Input: [1,8,6,2,5,4,8,3,7]
Output: 49

---

给定 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

说明：你不能倾斜容器，且 n 的值至少为 2。

图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

---

 双指针法

这种方法背后的思路在于，两线段之间形成的区域总是会受到其中较短那条长度的限制。此外，两线段距离越远，得到的面积就越大。

我们在由线段长度构成的数组中使用两个指针，一个放在开始，一个置于末尾。 此外，我们会使用变量 maxareamaxarea 来持续存储到目前为止所获得的最大面积。 在每一步中，我们会找出指针所指向的两条线段形成的区域，更新 maxareamaxarea，并将指向较短线段的指针向较长线段那端移动一步。

查看下面的例子将有助于你更好地理解该算法：1 8 6 2 5 4 8 3 7

这种方法如何工作？

最初我们考虑由最外围两条线段构成的区域。现在，为了使面积最大化，我们需要考虑更长的两条线段之间的区域。如果我们试图将指向较长线段的指针向内侧移动，矩形区域的面积将受限于较短的线段而不会获得任何增加。但是，在同样的条件下，移动指向较短线段的指针尽管造成了矩形宽度的减小，但却可能会有助于面积的增大。因为移动较短线段的指针会得到一条相对较长的线段，这可以克服由宽度减小而引起的面积减小。

---

 120ms

class Solution {
    func maxArea(_ height: [Int]) -> Int {
        var maxarea:Int = 0, l:Int = 0, r:Int = height.count - 1
        while(l < r)
        {
            maxarea = max(maxarea, min(height[l], height[r]) * (r - l))
            if height[l] < height[r]
            {
                l += 1
            }  
            else
            {
                r -= 1
            }   
        }
        return maxarea
    }
}

---

20ms

class Solution {
    func maxArea(_ height: [Int]) -> Int {
        var left = 0
        var right = height.count - 1
        var maxArea = area(height, left, right)
        while(left < right) {
            if (height[left] < height[right]) {
                left = left + 1
            } else {
                right = right - 1
            }
            let lArea = area(height, left, right)
            if (lArea > maxArea) {
                maxArea = lArea
            }
        }
    return maxArea
    }
    
    func area(_ height: [Int], _ start: Int, _ end: Int) -> Int {
        let x = height[start]
        let y = height[end]
        return (end - start) * (x > y ? y : x)
    }
    
}

---

20ms

class Solution {
        func maxArea(_ height: [Int]) -> Int {
        var result = 0
        
        var left = 0;
        var right = height.count - 1;
        
        while left < right {
            var valleft = height[left]
            var valright = height[right]
            let area = (valleft > valright ? valright : valleft) * (right - left)
            
            if area > result {
                result = area
            }
            
            if valleft > valright {
                right -= 1
            } else {
                left += 1
            }
        }
        return result
    }
}

---

24ms

class Solution {
    func maxArea(_ height: [Int]) -> Int {
        var ans = 0
        
        var i = 0
        var j = height.count - 1
        
        while i < j {
            let h1 = height[i]
            let h2 = height[j]
            
            let area = abs(i - j) * min(h1, h2)
            ans = max(ans, area)
            
            if h1 < h2 { i += 1 }
            else { j -= 1 }
        }
        
        return ans
    }
}

---

28ms

class Solution {
    func maxArea(_ height: [Int]) -> Int {
        var area = 0
        var left = 0
        var right = 0
        
        var i = 0
        var j = height.count - 1
        
        while i < j {
            if left <= right {
                let tmpArea = left * (j - i)
                area = area < tmpArea ? tmpArea : area
                if left < height[i] {
                    left = height[i]
                } else {
                    i += 1
                }
            } else {
                let tmpArea = right * (j - i)
                area = area < tmpArea ? tmpArea : area
                if right < height[j] {
                    right = height[j]
                } else {
                    j -= 1
                }
            }
        }
        return area
    }
}

---

40ms

class Solution {
    func maxArea(_ height: [Int]) -> Int {
        var result = 0
        var i = 0
        var j = height.count - 1
            
        while (i < j) {
            let minHeight = min(height[i], height[j])
            let area = minHeight * (j - i)
            result = max(result, area)
            while (height[i] <= minHeight && i < j) { i += 1 }
            while (height[j] <= minHeight && i < j) { j -= 1 }
            print(i, j)
        }
        return result
    }
}

---

108ms

class Solution {
    func maxArea(_ height: [Int]) -> Int {
        if height.count == 0 { return 0 }
        if height.count == 1 { return height[0] }
        var head = 0
        var tail = height.count - 1
        let sortFunc: (((Int, Int), (Int, Int)) -> Bool) = { (ele1, ele2) -> Bool in
            return ele1.1 < ele2.1
        }

        var maxArea = 0
        for (idx, h) in height.enumerated().sorted(by: sortFunc) {
            while h > height[head] { head += 1 }
            while h > height[tail] { tail -= 1 }

            let dToHead = idx - head
            let dToTail = tail - idx
            let area = max( dToHead * h, dToTail * h )
            if area > maxArea {
                maxArea = area
            }
        }

        return maxArea
    }
}