leetcode题解python版：56-60

56、合并区间
给出一个区间的集合，请合并所有重叠的区间
解：先排序，然后从左到右遍历,依次加入栈，再比较一下前后两个区间是否交叉即可

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        n=len(intervals)
        if not intervals or n==1:
            return intervals
        i=1
        intervals.sort()
        ans=[]
        for i in range(n):
            if not ans:
                ans.append(intervals[i])
            else:
                a=ans[-1]
                if a[1]>=intervals[i][0]:
                    ans.pop()
                    ans.append([a[0],max(a[1],intervals[i][1])])
                else:
                    ans.append(intervals[i])
        return ans

执行用时：52 ms, 击败了65.21%的用户
内存消耗：14.6 MB, 击败了62.50%的用户

57、插入区间
给出一个无重叠的 ，按照区间起始端点排序的区间列表。
在列表中插入一个新的区间，你需要确保列表中的区间仍然有序且不重叠（如果有必要的话，可以合并区间）。
解：往上一题的条件凑，先判断它是否会和原区间两个端点发生交叉，如果不会就直接插入。如果会就按左端点排序，看它应该插入哪个位置i，找到位置i后从i-1开始进行区间合并，最后输出结果

class Solution:
    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
        if not intervals:
            return [newInterval]
        if newInterval[1]<intervals[0][0]:
            intervals.insert(0,newInterval)
            return intervals
        if newInterval[0]>intervals[-1][1]:
            intervals.append(newInterval)
            return intervals
        ans=[]
        for i in range(len(intervals)):
            if intervals[i][0]>=newInterval[0]:
                break
            else:
                ans.append(intervals[i])
        if i==len(intervals)-1 and newInterval[0]>intervals[i][0]:
            i=i+1
        if i>0:
            if intervals[i-1][1]>=newInterval[0]:
                ans.pop()
                ans.append([intervals[i-1][0],max(newInterval[1],intervals[i-1][1])])
            else:
                ans.append(newInterval)
        else:
            ans.append(newInterval)
        for k in range(i,len(intervals)):
            a=ans[-1]
            if a[1]>=intervals[k][0]:
                ans.pop()
                ans.append([a[0],max(a[1],intervals[k][1])])
            else:
                ans.append(intervals[k])
        return ans

执行用时：44 ms, 击败了83.23%的用户
内存消耗：15.3 MB, 击败了49.57%的用户

58、最后一个单词的长度
给定一个仅包含大小写字母和空格 ’ ’ 的字符串 s，返回其最后一个单词的长度。如果字符串从左向右滚动显示，那么最后一个单词就是最后出现的单词。
如果不存在最后一个单词，请返回 0 。
说明：一个单词是指仅由字母组成、不包含任何空格字符的 最大子字符串。

解：先排除空或者都是空格的情况，再从右到左读取即可。

class Solution:
    def lengthOfLastWord(self, s: str) -> int:
        n=len(s)
        if not s or s==" "*n:
            return 0
        i=n-1
        for j in range(n-1,-1,-1):
            if s[j]==' ' and i==j:
                i=i-1
            elif s[j]==' ' and i!=j:#单词后的第一个' '
                return i-j
            elif j==0:#从右到左的第一个单词会到0
                return i-j+1

执行用时：40 ms, 击败了67.39%的用户
内存消耗：13.6 MB，击败了78.98%的用户

58、螺旋矩阵 II
给定一个正整数 n，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。
解：与54题基本相同，只要弄清楚坐标就行了.

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        num=0
        ans=[[0 for _ in range(n)] for _ in range(n)]
        for i in range(n):
            for j in range(i,n-i):
                num=num+1
                ans[i][j]=num
            if num==n*n:
                break
            for j in range(i+1,n-i):
                num=num+1
                ans[j][n-i-1]=num
            for j in range(n-i-2,i-1,-1):
                num=num+1
                ans[n-i-1][j]=num
            for j in range(n-i-2,i,-1):
                num=num+1
                ans[j][i]=num
        return ans

执行用时：36 ms, 击败了88.79%的用户
内存消耗：13.6 MB, 击败了80.71%的用户

60、 第k个排列
给出集合 [1,2,3,…,n]，其所有元素共有 n! 种排列。

按大小顺序列出所有排列情况，并一一标记，当 n = 3 时, 所有排列如下：
“123”
“132”
“213”
“231”
“312”
“321”
给定 n 和 k，返回第 k 个排列。
说明：
给定 n 的范围是 [1, 9]。
给定 k 的范围是[1, n!]。
解：以1开头的排列有n-1!个，是前k个排列，由此可以对k先除以n-1!,确定第1位，再除以n-2!，确定第2位，由此类推可以求出最后的结果。

class Solution:
    def getPermutation(self, n: int, k: int) -> str:
        numlist=[]
        flist=[]
        for i in range(n):
            numlist.append(str(i+1))
            if i>1:
                flist.append(flist[i-1]*i)
            else:
                flist.append(1)
        s=""
        k=k-1
        for i in range(n):
            l=k//flist[n-i-1]
            k=k%flist[n-i-1]
            s=s+numlist.pop(l)
        return s

执行用时：44 ms, 击败了60.68%的用户
内存消耗：13.7 MB, 击败了60.00%的用户