leetcode：数组三数之和

 数组篇，三道类似的题

1、

 solution 1：

最直接的就是for循环，但是必然不行啊。思路肯定是双指针。

思路1：左右指针移动，逻辑判断移动到最佳位置。第一想法就是判断移动条件，移动的距离小于高度增加的大小则移动，最后计算面积。

 def maxArea(self,height):
        l=0
        r = len(height)-1
        minl = 0
        maxr = r
        h=0
        while(l<r):
            if ((height[l]-height[minl])>(l-minl)):
                minl = l
            if((height[r]-height[maxr])>(maxr-r)):
                maxr = r
            if((height[l]-height[minl])==(l-minl) and (height[r]-height[maxr])==(maxr-r)):
                minl = l
            l = l + 1
            r = r-1
        if(height[minl]>height[maxr]):
            h= height[maxr]
        else:
            h = height[minl]

        return h*(maxr-minl)

直到遇到这个 arr=[1,8,6,2,5,4,8,25,7]，按照我的逻辑选的是8~25,面积是48。正确答案是8~7面积是49.这让我意识到，最终还是应该以面积为判断依据（其实看了一下答案）

 solution 2：

双指针是没问题的，问题出在移动逻辑，反正都要循环一下，应该是每次移动一个指针，记录最大面积的变换，

    def ma(self,height):
        l=0
        r = len(height)-1
        minl = 0
        maxr = r
        s = 0
        maxs=(r-l)*min(height[l],height[r])
        if(len(height)<3):
            return (r-l)*min(height)
        while(l<r):

            if(height[l]<height[r]):
                l=l+1
            else:
                r= r-1
            s = (r - l) * min(height[l], height[r])
            if (maxs < s):
                maxs = s
        return maxs

2、

 solution1：

思路1，肯定还是双指针关键在于怎么用。经过上一题，搬用，每次移动一个左右指针，判断和与目标的差是否存在于两个指针中间，再判断是否重复

class Solution:
    def threeSum(self,nums):
        nums.sort()
        l = 0
        r = len(nums)-1
        res=[]
        print(nums)
        while(l<r):
            d = 0 - nums[l]-nums[r]
            loc = np.where(np.array(nums)==d)[0]
            for i in range(len(loc)):
                if(loc[i]>l and loc[i]<r):
                    tar = [nums[l], nums[loc[i]], nums[r]]
                    if tar not in res:
                        res.append(tar)
            if(nums[l]+nums[r])<0:
                l=l+1
            else:
                r= r-1

        return res

直到遇到了一个数组，我发现会比正确答案少几个，存在bug：左右两个指针都有可能跟其他两个数配对，每次必然移动其中一个后，会丢掉它其他的可能性

solution2：

前提是遍历每一个数，确定一个数去寻找其他两个的可能性，三个数需要两层

class Solution2:
    def threeSum(self,nums):
        nums.sort()
        res=[]
        #print(nums)
        if(len(nums)<3):
            return res
        for i in range(len(nums)):
            l = i+1
            r = len(nums) - 1
            while(l<r):
                d = nums[i]+nums[l]+nums[r]
                if(d==0):
                    tar = [nums[i], nums[l], nums[r]]
                    l=l+1
                    if tar not in res:
                        res.append(tar)
                elif(d>0):
                    r =r-1
                else:
                    l=l+1

        return res

3、

这个跟三个数之和一个思路，简单改一下就行了，纯属练习。

class Solution:
    def threeSumClosest(self, nums,target):
        nums.sort()
        mind = 9999
        for i in range(len(nums)):
            l = i+1
            r = len(nums) - 1
            while(l<r):
                sum = nums[i]+nums[l]+nums[r]
                if(abs(sum-target)<abs(mind-target)):
                    mind = sum
                if(sum==target):
                    return sum
                elif(sum>target):
                    r=r-1
                else:
                    l=l+1

        return mind