lintcode刷题笔记（一）

Description

给出一个字符串（假设长度最长为1000），求出它的最长回文子串，你可以假定只有一个满足条件的最长回文串。

样例 1:

输入:"abcdzdcab"
输出:"cdzdc"

样例 2:

输入:"aba"
输出:"aba"

#coding:utf-8

class Solution:
  
    def longestPalindrome(self, s):
        # write your code here
        length = len(s)
        sub="" if length>1 else s
        m = 0
        for i in range(length-1):
            len1,sub1 = expandAroundCenter(s,m,i,i)
            len2,sub2 = expandAroundCenter(s,m,i,i+1)
            if len1>m:
                m = len1
                sub = sub1
            if len2>m:
                m = len2
                sub = sub2
        return sub
                
def expandAroundCenter(s,m,i,j):
    sub=""
    while i>=0 and j<=len(s)-1:
        if s[i]==s[j]:
            if j-i+1>m:
                m = j-i+1
                sub = s[i:j+1]
            i=i-1
            j=j+1        
        else:
            break        
    return m,sub
        
if __name__=="__main__":
    s = Solution()
    print(s.longestPalindrome("abcdzdcab"))
    print(s.longestPalindrome("aba"))
    print(s.longestPalindrome("a"))
    print(s.longestPalindrome("ccc"))
    print(s.longestPalindrome("cc"))
    print(s.longestPalindrome("cccc"))

View Code

（二）. 二分搜索法和log(n)算法（Binary Search & Log(n) Algorithm）

458. Last Position of Target

　　给一个升序数组，找到 target 最后一次出现的位置，如果没出现过返回 -1

　　样例：

　　输入：nums = [1,2,2,4,5,5], target = 2
　　输出：2

　　输入：nums = [1,2,2,4,5,5], target = 6
　　输出：-1

#coding:utf-8

class Solution:
    #获取最右边的
    def lastPosition(self, nums, target):
        start = 0
        end = len(nums)-1
        index = -1
        while start<=end:
            mid = (start+end)//2
            if nums[mid]<=target:
                start = mid+1
            elif nums[mid]>target:
                end = mid-1
            
        if start>0 and nums[start-1]==target:
            index = start-1
        return index
    #获取最左边的    
    def firstPosition(self, nums, target):
        start = 0
        end = len(nums)-1
        index = -1
        while start<=end:
            mid = (start+end)//2
            if nums[mid]<target:
                start = mid+1
            elif nums[mid]>=target:
                end = mid-1
            
        if end1 and nums[end+1]==target:
            index = end+1
        return index
        
if __name__=="__main__":
    s = Solution()
    print(s.lastPosition(nums = [], target = 10))
    print(s.lastPosition(nums = [1,2,2,4,5,5], target = 2))
    print(s.lastPosition(nums = [1,2,2,4,5,5], target = 6))
    print(s.lastPosition(nums = [1,2,2,2,2,2], target = 2))
    
    
    print(s.firstPosition(nums = [1,2,2,4,5,5], target = 2))
    print(s.firstPosition(nums = [1,2,2,4,5,5], target = 6))
    print(s.firstPosition(nums = [1,2,2,2,2,2], target = 2))

458

585. Maximum Number in Mountain Sequence

　　给 n 个整数的山脉数组，即先增后减的序列，找到山顶（最大值）

Example

例1:

输入: nums = [1, 2, 4, 8, 6, 3] 
输出: 8

例2:

输入: nums = [10, 9, 8, 7], 
输出: 10

#coding:utf-8

class Solution:

    def mountainSequence(self, nums):
        # write your code here
        if len(nums)==1:
            return nums[0]
        for i in range(len(nums)-1):
            if nums[i+1]<nums[i]:
                return nums[i]

585

460. Find K Closest Elements

Description

　　给一个目标数 target, 一个非负整数 k, 一个按照升序排列的数组 A。在A中找与target最接近的k个整数。返回这k个数并按照与target的接近程度从小到大排序，如果接近程度相当，那么小的数排在前面。

k是一个非负整数，并且总是小于已排序数组的长度。
给定数组的长度是正整数, 不会超过 $10^44$
数组中元素的绝对值不会超过 $10^44$

Example

样例 1:

输入: A = [1, 2, 3], target = 2, k = 3
输出: [2, 1, 3]

样例 2:

输入: A = [1, 4, 6, 8], target = 3, k = 3
输出: [4, 1, 6]

class Solution:
    """
    @param A: an integer array
    @param target: An integer
    @param k: An integer
    @return: an integer array
    """
    def kClosestNumbers(self, A, target, k):
        # write your code here
        sub=100000
        nearest=-1
        start = 0
        end = len(A)-1
        while start<=end:
            mid = (start+end)//2
            temp = abs(A[mid]-target)
            if temp<sub:
                sub = temp
                nearest = mid
            if A[mid]>target:
                end = mid-1
            elif A[mid]<target:
                start = mid+1
            elif A[mid]==target:
                break
        out=[]
        if nearest!=-1 and k>0:
            out.append(A[nearest])
            i=1
            left,right=nearest-1,nearest+1
            while left>=0 and right<=len(A)-1 and i<k:
                if abs(A[left]-target)<=abs(A[right]-target):
                    out.append(A[left])
                    left = left-1
                else:
                    out.append(A[right])
                    right = right+1
                i = i+1
                
            if i0:
                out.extend(A[right:right+k-i])
            if ilen(A)-1:
                out.extend(A[left:left-(k-i):-1])
        return out
if __name__=="__main__":
    s = Solution()
    print(s.kClosestNumbers( A = [1, 2, 3], target = 2, k = 3))
    print(s.kClosestNumbers(A = [1, 4, 6, 8], target = 3, k = 3))
    print(s.kClosestNumbers(A = [1,4,6,10,20], target = 21, k = 4))
    print(s.kClosestNumbers(A = [1,2,4,5,6,7,8,10], target = 5, k = 0))
    print(s.kClosestNumbers(A = [1,4,8,12,16,28,38], target = 12, k = 4))
    print(s.kClosestNumbers(A = [1,4,6,8], target = 3, k = 3))

460

428. Pow(x,n)

　　实现 pow(x, n). (n是一个整数,不用担心精度，当答案和标准输出差绝对值小于1e-3时都算正确)

Example

样例 1:

输入: x = 9.88023, n = 3
输出: 964.498

样例 2:

输入: x = 2.1, n = 3
输出: 9.261

样例 3:

输入: x = 1, n = 0
输出: 1

#coding:utf-8


class Solution:

    def myPow(self,x,n):
        if n==0:
            return 1
        elif n<0:
            x = 1/x
            n = -n
        return recursive_pow(x,n)
            
def recursive_pow(x,n):            
    if n==1:
        return x
    else:
        half = recursive_pow(x,n//2)
        if n%2==1:
            return half*half*x
        else:
            return half*half
            
if __name__=="__main__":
    s = Solution()
    print(s.myPow(x = 9.88023, n = 3))
    print(s.myPow(x = 2.1, n = 3))
    print(s.myPow( x = 1, n = 0))
    print(s.myPow( x = 2.00000, n = -2147483648))

428

159.Find Minimum Rotated Sorted Array

　　假设一个排好序的数组在其某一未知点发生了旋转（比如0 1 2 4 5 6 7 可能变成4 5 6 7 0 1 2）。你需要找到其中最小的元素

Example

Example 1:

输入：[4, 5, 6, 7, 0, 1, 2]
输出：0
解释：
数组中的最小值为0

Example 2:

输入：[2,1]
输出：1
解释：
数组中的最小值为1

#coding:utf-8
class Solution:
   
    def findMin(self, nums):
        
        length = len(nums)
        if length==1:
            return nums[0]
        elif length>1:
            if nums[0]1]:
                return nums[0]
            else:
                left,right = 0,length-1
                while left<right:
                    mid = (left+right)//2
                    if nums[mid]>nums[left]:
                        left = mid
                    elif nums[mid]<nums[left]:
                        right = mid
                    else:              #mid和left相等时
                        break
            return nums[right]
if __name__=="__main__":
    s = Solution()
    print(s.findMin([4, 5, 6, 7, 0, 1, 2]))
    print(s.findMin([2,1]))

159

140. Fast Power

　　计算an % b，其中a，b和n都是32位的非负整数。

Example

例如 231 % 3 = 2

例如 1001000 % 1000 = 0

Challenge

O(logn)

#coding:utf-8

#原理： (A*B)%p = ((A%p)*(B%p))%p

"""
@param a: A 32bit integer
@param b: A 32bit integer
@param n: A 32bit integer
@return: An integer
 """
class Solution:
  
    def fastPower(self, a, b, n):
        if n==0:
            return 1%b
        elif n==1:
            return a%b
        else:
            half_remainder = self.fastPower(a,b,n//2)
            if n%2==1:
                return (half_remainder*half_remainder*a)%b
            else:
                return (half_remainder*half_remainder)%b
if __name__=="__main__":
    s = Solution()
    print(s.fastPower(2,3,31))
    print(s.fastPower(3,1,0))
    print(s.fastPower(100,1000,1000))

140

75. Find Peak Elements

　　你给出一个整数数组(size为n)，其具有以下特点：

相邻位置的数字是不同的
A[0] < A[1] 并且 A[n - 2] > A[n - 1]

假定P是峰值的位置则满足A[P] > A[P-1]且A[P] > A[P+1]，返回数组中任意一个峰值的位置。

数组保证至少存在一个峰
如果数组存在多个峰，返回其中任意一个就行
数组至少包含 3 个

Example

样例 1:
	输入:  [1, 2, 1, 3, 4, 5, 7, 6]
	输出:  1 or 6
	
	解释:
	返回峰顶元素的下标


样例 2:
	输入: [1,2,3,4,1]
	输出:  3

#coding:utf-8

#参考题解：https://leetcode-cn.com/problems/find-peak-element/solution/hua-jie-suan-fa-162-xun-zhao-feng-zhi-by-guanpengc/
#注意峰值的方向，先上升后下降

"""
@param A: An integers array.
@return: return any of peek positions.
"""
class Solution:

    def findPeak(self, A):
        # write your code here
        length = len(A)
        if length==1:
            return 0
        elif length>2:
            left,right = 0, length-2
            while left<right:
                mid = (left+right)//2
                if A[mid]>A[mid+1]:  #下降趋势
                    right = mid
                elif A[mid]1]: #上升趋势
                    left = mid+1
            return left
if __name__=="__main__":
    s = Solution()
    print(s.findPeak([1, 2, 1, 3, 4, 5, 7, 6]))
    print(s.findPeak([1,2,3,4,1]))

74. First Bad Version

　　代码库的版本号是从 1 到 n 的整数。某一天，有人提交了错误版本的代码，因此造成自身及之后版本的代码在单元测试中均出错。请找出第一个错误的版本号。

你可以通过 isBadVersion 的接口来判断版本号 version 是否在单元测试中出错，具体接口详情和调用方法请见代码的注释部分。

Example

n = 5:
    isBadVersion(3) -> false
    isBadVersion(5) -> true
    isBadVersion(4) -> true

因此可以确定第四个版本是第一个错误版本。

Challenge

调用 isBadVersion 的次数越少越好

Example

n = 5:

    isBadVersion(3) -> false
    isBadVersion(5) -> true
    isBadVersion(4) -> true

因此可以确定第四个版本是第一个错误版本。

Challenge

调用 isBadVersion 的次数越少越好

62. Search in Rotated Sorted Array

　　假设有一个排序的按未知的旋转轴旋转的数组(比如，0 1 2 4 5 6 7 可能成为4 5 6 7 0 1 2)。给定一个目标值进行搜索，如果在数组中找到目标值返回数组中的索引位置，否则返回-1。你可以假设数组中不存在重复的元素。

Example

例1:

输入: [4, 5, 1, 2, 3] and target=1, 
输出: 2.

例2:

输入: [4, 5, 1, 2, 3] and target=0, 
输出: -1.

Challenge

O(logN) 时间限制

class Solution:
    """
    @param A: an integer rotated sorted array
    @param target: an integer to be searched
    @return: an integer
    """
    def search(self, A, target):
        # write your code here
        length = len(A)
        if length>0:
            left,right=0,length-1
            if A[0]==target:
                return 0
            elif A[0]>target:
                while left<=right:
                    mid=(left+right)//2
                    if A[0]<=A[mid]:
                        left = mid+1
                    else:
                        if A[mid]>target:
                            right = mid-1
                        elif A[mid]<target:
                            left = mid+1
                        else:
                            return mid
            else:
                while left<=right:
                    mid=(left+right)//2
                    if A[0]>=A[mid]:
                        right=mid-1
                    else:
                        if A[mid]>target:
                            right = mid-1
                        elif A[mid]<target:
                            left = mid+1
                        else:
                            return mid
        return -1
if __name__=="__main__":
    s = Solution()
    print(s.search([4, 5, 1, 2, 3],1))
    print(s.search([4, 5, 1, 2, 3],0))
    print(s.search([4, 3],3))

（三）. 双指针问题（Two Pointers）

228. Middle of Linked List

　　找链表的中点。

Example

样例 1:

输入:  1->2->3
输出: 2	
样例解释: 返回中间节点的值

样例 2:

输入:  1->2
输出: 1	
样例解释: 如果长度是偶数，则返回中间偏左的节点的值。

Challenge

如果链表是一个数据流，你可以不重新遍历链表的情况下得到中点么？

#coding:utf-8


#Definition of ListNode
class ListNode(object):
    def __init__(self, val, next=None):
        self.val = val
        self.next = next

"""
@param head: the head of linked list.
@return: a middle node of the linked list
"""
class Solution:
    
    def middleNode(self, head):
        # write your code here
        slow = fast = head
        if head:
            while fast.next!=None and fast.next.next!=None:
                slow = slow.next
                fast = fast.next.next
        return slow
if __name__=="__main__":
    s = Solution()
    list1 = ListNode(1,ListNode(2,ListNode(3)))
    list2 = ListNode(1,ListNode(2))
    print(s.middleNode(list1).val)
    print(s.middleNode(list2).val)

228

607 Two Sum III -Data structure design

　　设计b并实现一个 TwoSum 类。他需要支持以下操作:add 和 find。
　　　　add -把这个数添加到内部的数据结构。
　　　　find -是否存在任意一对数字之和等于这个值

Example

样例 1:

add(1);add(3);add(5);
find(4)//返回true
find(7)//返回false

#coding:utf-8

#思路：遍历字典，求sum和遍历元素的差， 判断差是否也在字典中
class TwoSum:
    """
    @param number: An integer
    @return: nothing
    """
    def __init__(self):
        self.numbers=dict()
        
    def add(self, number):
        # write your code here
        if number not in self.numbers:
            self.numbers[number]=1
        else:
            self.numbers[number]+=1

    """
    @param value: An integer
    @return: Find if there exists any pair of numbers which sum is equal to the value.
    """
    def find(self, value):
        # write your code here
        for key in self.numbers:
            target = value-key
            if target in self.numbers:
                if target!=key or self.numbers[target]>1:
                    return True
        return False


#按顺序插入列表，find时前后指针遍历
# class TwoSum:
    # """
    # @param number: An integer
    # @return: nothing
    # """
    # def __init__(self):
        # self.numbers=[]
        
    # def add(self, number):
        # # write your code here
        # length = len(self.numbers)
        # if length==0:
            # self.numbers.append(number)
        # for i in range(length):
            # if self.numbers[i]>number:
                # self.numbers.insert(i,number)
                # break
        # if len(self.numbers)==length:
            # self.numbers.append(number)

    # """
    # @param value: An integer
    # @return: Find if there exists any pair of numbers which sum is equal to the value.
    # """
    # def find(self, value):
        # # write your code here
        # i,j=0,len(self.numbers)-1
        # while i<j:
            # if self.numbers[i]+self.numbers[j]==value:
                # return True
            # elif self.numbers[i]+self.numbers[j]>value:
                # j = j-1
            # else:
                # i = i+1
        # return False
if __name__=="__main__":
    s = TwoSum()
    # s.add(1)
    # s.add(3)
    # s.add(5)
    # print(s.find(4))
    # print(s.find(7))
    
    # s.add(2)
    # s.add(3)
    # print(s.find(4))
    # print(s.find(5))
    # print(s.find(6))
    # s.add(3)
    # print(s.find(6))
    
    s.add(2)
    s.add(2)
    s.add(2)
    print(s.find(6))
    s.add(2)
    print(s.find(4))
    print(s.find(5))
    s.add(1)
    print(s.find(2))
    print(s.find(3))

607

539. Move Zeros

　　给一个数组 nums 写一个函数将 0 移动到数组的最后面，非零元素保持原数组的顺序

　　　　1.必须在原数组上操作
　　　　2.最小化操作数

Example

例1:

输入: nums = [0, 1, 0, 3, 12],
输出: [1, 3, 12, 0, 0].

例2:

输入: nums = [0, 0, 0, 3, 1],
输出: [3, 1, 0, 0, 0].

#coding:utf-8


"""
思路：
快慢指针：假设我们有一个新数组，有 2 根指针分别从老数组和新数组从前往后走，称老数组上的指针为「读指针」，新数组上的指针为「写指针」；只有当读指针所指向的数值非0时，才将读指针所指的数值写入到写指针所指的空间上，然后两根指针再继续向前走；当老数组遍历完时，只要将新数组继续填 0 直到新老数组长度一致即可。题目要求「就地操作」，那么实际上就不需要开这个新数组，只要让两根指针都在原数组上往前走就行：这是因为，读指针由于会跳过非 0 空间，其扫描速度远快于写指针，所有被读指针扫描过的非零值都会通过写指针写入「新的空间」中，因此所有被写指针覆盖掉的非零值，之前必定已经保存过了。该方法时间复杂度 O(n)，空间复杂度 O(1)
"""

"""
@param nums: an integer array
@return: nothing
"""
class Solution:
    
    def moveZeroes(self, nums):
        # write your code here
        i=j=0
        while i<len(nums):
            if nums[i]!=0:
                nums[j]=nums[i]
                j = j+1
            i = i+1
        while j<i:
            nums[j]=0
            j = j+1
        return nums
if __name__=="__main__":
    s = Solution()
    print(s.moveZeroes([0, 1, 0, 3, 12]))
    print(s.moveZeroes([0, 0, 0, 3, 1]))

539

521 Remove Duplicate Numbers in Array

　　给一个整数数组，去除重复的元素。

　　你应该做这些事

　　　　1.在原数组上操作
　　　　2.将去除重复之后的元素放在数组的开头
　　　　3.返回去除重复元素之后的元素个数

Example

例1:

输入:
nums = [1,3,1,4,4,2]
输出:
（nums变为[1,3,4,2,?,?]）
4

解释:
1. 将重复的整数移动到 nums 的尾部 => nums = [1,3,4,2,?,?].
2. 返回 nums 中唯一整数的数量  => 4.
事实上我们并不关心你把什么放在了 ? 处, 只关心没有重复整数的部分.

例2:

输入:
nums = [1,2,3]
输出: 
(nums变为[1,2,3])
3

#coding:utf-8


"""
@param nums: an array of integers
@return: the number of unique integers
"""

#时间复杂度O(n),空间复杂度O(n)
class Solution:
    
    def deduplication(self, nums):
        # write your code here
        nums_set=set()
        i=0
        for num in nums:
            if num not in nums_set:
                nums_set.add(num)
                nums[i]=num
                i = i+1
                
        return i 
        
        
        

#排序后使用双指针，时间复杂度O(nlogn)，空间复杂度O(1)
# class Solution:
    
    # def deduplication(self, nums):
        # # write your code here
        # length = len(nums)
        # if length<=1:
            # return length
        # quicksort(nums,0,length-1)
        # i=j = 1
        # while i<length:
            # if nums[i]!=nums[i-1]:
                # nums[j]=nums[i]
                # j = j+1
            # i = i+1
        # return j
        
        
# def quicksort(nums,start,end):
    # if start<end:
        # pivot = start
        # left,right=start+1,end
        # while left<=right:
            # while left<=right and nums[left]<=nums[pivot]:
                # left = left+1
            # while left<=right and nums[right]>nums[pivot]:
                # right= right-1
            # if left<=right:
                # nums[left],nums[right]=nums[right],nums[left]
        # nums[right],nums[pivot]=nums[pivot],nums[right]
        # quicksort(nums,start,right-1)
        # quicksort(nums,right+1,end)
        
if __name__=="__main__":
    
    s = Solution()
    print(s.deduplication([1,3,1,4,4,2]))
    print(s.deduplication(nums = [1,2,3]))

521

464 Sort Integers II

　　给一组整数，请将其在原地按照升序排序。使用归并排序，快速排序，堆排序或者任何其他 O(n log n) 的排序算法。

Description

中文

English

给一组整数，请将其在原地按照升序排序。使用归并排序，快速排序，堆排序或者任何其他 O(n log n) 的排序算法。

Have you met this question in a real interview?

Example

例1：

输入：[3,2,1,4,5]，
输出：[1,2,3,4,5]。

例2：

输入：[2,3,1]，
输出：[1,2,3]。

"""
@param A: an integer array
@return: nothing
"""
class Solution:
    
    def sortIntegers2(self, A):
        # write your code here
        quicksort(A,0,len(A)-1)
        return A

def quicksort(alist,start,end):
    if start<end:
        pivot=alist[start]
        left,right = start,end
        while left<right:
            while left=pivot:
                right-=1
            alist[left],alist[right]=alist[right],alist[left]
            while leftpivot:
                left+=1
            alist[right],alist[left]=alist[left],alist[right]
        quicksort(alist,start,left-1)
        quicksort(alist,left+1,end)
if __name__=="__main__":
    s = Solution()
    print(s.sortIntegers2([3, 2, 1, 4, 5]))
    print(s.sortIntegers2([2, 3, 1]))

464

608. Two Sum II- Input array is sorted

　　给定一个已经 按升序排列 的数组，找到两个数使他们加起来的和等于特定数。
　　函数应该返回这两个数的下标，index1必须小于index2。注意返回的值不是 0-based

Example

例1:

输入: nums = [2, 7, 11, 15], target = 9 
输出: [1, 2]

例2:

输入: nums = [2,3], target = 5
输出: [1, 2]

class Solution:
    """
    @param nums: an array of Integer
    @param target: target = nums[index1] + nums[index2]
    @return: [index1 + 1, index2 + 1] (index1 < index2)
    """
    def twoSum(self, nums, target):
        # write your code here
        length = len(nums)
        if length>1:
            i,j=0,length-1
            while i<j:
                if nums[i]+nums[j]==target:
                    return i+1,j+1
                elif nums[i]+nums[j]<target:
                    i+=1
                else:
                    j-=1
if __name__=="__main__":
    s = Solution()
    print(s.twoSum(nums = [2, 7, 11, 15], target = 9 ))
    print(s.twoSum(nums = [2,3], target = 5 ))

608

143 Sort Colors II

　　给定一个有n个对象（包括k种不同的颜色，并按照1到k进行编号）的数组，将对象进行分类使相同颜色的对象相邻，并按照1,2，...k的顺序进行排序。

不能使用代码库中的排序函数来解决这个问题
k <= n

Example

样例1

输入: 
[3,2,2,1,4] 
4
输出: 
[1,2,2,3,4]

样例2

输入: 
[2,1,1,2,2] 
2
输出: 
[1,1,2,2,2]

Challenge

一个相当直接的解决方案是使用计数排序扫描2遍的算法。这样你会花费O(k)的额外空间。你否能在不使用额外空间的情况下完成？

#coding:utf-8

#思路参考：https://www.cnblogs.com/libaoquan/p/7226211.html （计数排序/桶排序改进）
#输入[3,2,2,1,4],进行一次遍历后变化过程如下：
# [3, 2, 2, 1, 4]
# [2, 2, -1, 1, 4]
# [2, -1, -1, 1, 4]
# [0, -2, -1, 1, 4]
# [-1, -2, -1, 0, 4]
# [-1, -2, -1, -1, 0]


"""
@param colors: A list of integer
@param k: An integer
@return: nothing
"""
class Solution:
    
    def sortColors2(self, colors, k):
        length = len(colors)
        if length<=1:
            return colors
        #统计计数
        for i in range(length):
            while colors[i]>0:
                index = colors[i]
                if colors[index-1]>0:
                    colors[i]=colors[index-1]
                    colors[index-1]=-1         #表示index出现一次
                elif colors[index-1]<=0:
                    colors[i]=0
                    colors[index-1]-=1         #表示index再次出现
        
        #输出排序结果
        j=length-1
        for i in range(k-1,-1,-1):
            temp = colors[i]
            while temp<0:
                colors[j]=i+1
                temp+=1
                j-=1
        return colors
if __name__=="__main__":
    s = Solution()
    print(s.sortColors2([3,2,2,1,4],4))
    print(s.sortColors2([2,1,1,2,2],2))

143

57. Three Sum

Description:
   Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.
   Elements in a triplet (a,b,c) must be in non-descending order. (ie, a ≤ b ≤ c)
   The solution set must not contain duplicate triplets.

Example 1:
   Input:[2,7,11,15]
   Output:[]

Example 2:
   Input:[-1,0,1,2,-1,-4]
   Output:   [[-1, 0, 1],[-1, -1, 2]]

#coding:utf-8

"""
题目：57 Three Sum
Description:
    Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.
    Elements in a triplet (a,b,c) must be in non-descending order. (ie, a ≤ b ≤ c)
    The solution set must not contain duplicate triplets.

Example 1:
    Input:[2,7,11,15]
    Output:[]
    
Example 2:
    Input:[-1,0,1,2,-1,-4]
    Output:    [[-1, 0, 1],[-1, -1, 2]]
"""


"""
思路：
由于设置了三个变量，故时间复杂度最少是O(n^2)
在开头固定一个变量，然后一前一后 移动指针
和大于零 后指针前移
和小于零 前指针后移
和等于零 放入结果中，再让前后指针移动
"""

"""
@param numbers: Give an array numbers of n integer
@return: Find all unique triplets in the array which gives the sum of zero.
"""
class Solution:
    
    def threeSum(self, numbers):
        # write your code here
        length = len(numbers)
        ret=[]
        if length<3:
            return ret
        quicksort(numbers,0,length-1)
        print(numbers)
        for k in range(length-2):
            if k==0 or numbers[k]!=numbers[k-1]:  #防止重复
                twoSum(numbers,-numbers[k],start=k+1,end=length-1,ret=ret)
        return ret

def quicksort(numbers,start,end):
    if start<end:
        left,right=start,end
        pivot = numbers[start]
        while left<right:
            while left=pivot:
                right-=1
            numbers[right],numbers[left]=numbers[left],numbers[right]
            while leftpivot:
                left+=1
            numbers[right],numbers[left]=numbers[left],numbers[right]
        quicksort(numbers,start,right-1)
        quicksort(numbers,right+1,end)
        
def twoSum(numbers,target,start,end,ret):
    i,j = start,end
    while i<j:
        if numbers[i]+numbers[j]<target:
            i+=1
        elif numbers[i]+numbers[j]>target:
            j-=1
        else:
            if (-target)<numbers[i]:
                temp=[-target,numbers[i],numbers[j]]
            elif (-target)>numbers[j]:
                temp=[numbers[i],numbers[j],-target]
            else:
                temp=[numbers[i],-target,numbers[j]]
            if temp not in ret: #防止重复
                ret.append(temp)
            i+=1
            j-=1

if __name__=="__main__":
    s = Solution()
    # print(s.threeSum([2,7,11,15]))
    # print(s.threeSum([-1,0,1,2,-1,-4]))
    # print(s.threeSum([1,0,-1,-1,-1,-1,0,1,1,1]))
    print(s.threeSum([-2,-3,-4,-5,-100,99,1,4,4,4,5,1,0,-1,2,3,4,5]))

31.Partition Array

Description
   Given an array nums of integers and an int k, partition the array (i.e move the elements in "nums") such that:

       All elements < k are moved to the left
       All elements >= k are moved to the right

   Return the partitioning index, i.e the first index i nums[i] >= k.
   You should do really partition in array nums instead of just counting the numbers of integers smaller than k.
   If all elements in nums are smaller than k, then return nums.length

Example 1:
   Input:
   [],9
   Output:
   0

Example 2:
   Input:
   [3,2,2,1],2
   Output:1
   Explanation:
   the real array is[1,2,2,3].So return 1

Challenge
   Can you partition the array in-place and in O(n)?

#coding:utf-8

"""
Description
    Given an array nums of integers and an int k, partition the array (i.e move the elements in "nums") such that:

        All elements < k are moved to the left
        All elements >= k are moved to the right

    Return the partitioning index, i.e the first index i nums[i] >= k.
    You should do really partition in array nums instead of just counting the numbers of integers smaller than k.
    If all elements in nums are smaller than k, then return nums.length

Example 1:
    Input:
    [],9
    Output:
    0

Example 2:
    Input:
    [3,2,2,1],2
    Output:1
    Explanation:
    the real array is[1,2,2,3].So return 1

Challenge
    Can you partition the array in-place and in O(n)?
"""

"""
思路：类似于快速排序的左右指针
"""

class Solution:
    """
    @param nums: The integer array you should partition
    @param k: An integer
    @return: The index after partition
    """
    def partitionArray(self, nums, k):
        # write your code here
        length=len(nums)
        if length==0:
            return 0
        i,j=0,length-1
        while i<=j:
            while i<=j and nums[i]<k:
                i+=1
            while i<=j and nums[j]>=k:
                j-=1
            if i<j:
                nums[i],nums[j]=nums[j],nums[i]
        return i
if __name__=="__main__":
    s = Solution()
    print(s.partitionArray([],9))
    print(s.partitionArray([3,2,2,1],2))

5. Kth Largest Element
Description

   Find K-th largest element in an array.
   You can swap elements in the array

Example 1:
   Input:
   n = 1, nums = [1,3,4,2]
   Output:
   4

Example 2:
   Input:
   n = 3, nums = [9,3,2,4,8]
   Output:
   4

Challenge
   O(n) time, O(1) extra memory.

#coding:utf-8

"""
题目：5. Kth Largest Element
Description

    Find K-th largest element in an array.
    You can swap elements in the array

Example 1:
    Input:
    n = 1, nums = [1,3,4,2]
    Output:
    4

Example 2:
    Input:
    n = 3, nums = [9,3,2,4,8]
    Output:
    4

Challenge
    O(n) time, O(1) extra memory.
"""
"""
思路：
    快速选择算法 的平均时间复杂度为 O(N){O}(N)O(N)。就像快速排序那样，本算法也是 Tony Hoare 发明的，因此也被称为 Hoare选择算法。

本方法大致上与快速排序相同。简便起见，注意到第 k 个最大元素也就是第 N - k 个最小元素，因此可以用第 k 小算法来解决本问题。

首先，我们选择一个枢轴，并在线性时间内定义其在排序数组中的位置。这可以通过 划分算法 的帮助来完成。

    为了实现划分，沿着数组移动，将每个元素与枢轴进行比较，并将小于枢轴的所有元素移动到枢轴的左侧。

这样，在输出的数组中，枢轴达到其合适位置。所有小于枢轴的元素都在其左侧，所有大于或等于的元素都在其右侧。

这样，数组就被分成了两部分。如果是快速排序算法，会在这里递归地对两部分进行快速排序，时间复杂度为 O(Nlog⁡N)。

而在这里，由于知道要找的第 N - k 小的元素在哪部分中，我们不需要对两部分都做处理，这样就将平均时间复杂度下降到 O(N)。

"""
class Solution:
    """
    @param n: An integer
    @param nums: An array
    @return: the Kth largest element
    """
    def kthLargestElement(self, n, nums):
        # write your code here
        length = len(nums)
        if n>length or n==0:
            return None
        return half_quicksort(nums,n,0,length-1)
        
    
    #方法二，利用二叉堆
    def kthLargestElement2(self, n, nums):
        import heapq
        length = len(nums)
        if n>length or n==0:
            return None
        return heapq.nlargest(n,nums)[n-1]
        
def half_quicksort(nums,k,start,end):
    if k==1 and start==end:
        return nums[start]
    if start<end:
        left,right=start,end
        pivot = nums[start]
        while left<right:
            while left=pivot:
                right-=1
            nums[left],nums[right]=nums[right],nums[left]
            while leftpivot:
                left+=1
            nums[left],nums[right]=nums[right],nums[left]
        
        if end-right>k-1:
            return half_quicksort(nums,k,right+1,end)
        elif end-right1:
            return half_quicksort(nums,k-(end-right+1),start,right-1)
        else:
            return nums[right]
            
if __name__=="__main__":
    s = Solution()
    print(s.kthLargestElement(n = 1, nums = [1,3,4,2]))
    print(s.kthLargestElement(n = 3, nums = [9,3,2,4,8]))
    
    print(s.kthLargestElement2(n = 1, nums = [1,3,4,2]))
    print(s.kthLargestElement2(n = 3, nums = [9,3,2,4,8]))

（四）. 宽度优先搜索和拓扑排序（BFS and Topplogical Sort）

433. Number of Islands

Description

　　Given a boolean 2D matrix, 0 is represented as the sea, 1 is represented as the island. If two 1 is adjacent, we consider them in the same island. We only consider up/down/left/right adjacent.
      Find the number of islands.

Example 1:
   Input:
   [
      [1,1,0,0,0],
      [0,1,0,0,1],
      [0,0,0,1,1],
      [0,0,0,0,0],
      [0,0,0,0,1]
   ]
   Output:3

Example 2:

   Input:
   [
      [1,1]
   ]
   Output:1

lintcode刷题笔记（一）

Description

Example

Example

Description

Example

Example

Example

Example

Challenge

Example

Example

Challenge

Example

Challenge

Example

Challenge

Example

Example

Example

Description

Example

Example

Example

Challenge

你可能感兴趣的:(lintcode刷题笔记（一）)