发表于 | 分类于

题目链接：leetcode

思路：排序

1
2
3
4
5
6
class Solution(object):
    def largestNumber(self, num):
        comp=lambda a,b:1 if a+b>b+a else -1 if a+b<b+a else 0
        num=map(str,num)
        num.sort(cmp=comp,reverse=True)
        return str(int("".join(num)))

发表于 | 分类于

题目链接:leetcode

思路：

  • 使用动态规划，knight的生命值最少为1
  • 初始条件，dp[-1][-1] = max(1-dungeon[-1][-1],1);
    dp[i][-1] = max(dp[i+1][-1]-dungeon[i][-1],1)
    dp[-1][j] = max(dp[-1][j+1] -dungeon[-1][j],1)
  • 转移方程，dp[i][j] = max(min(dp[i+1][j],dp[i][j+1])-dungeon[i][j],1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Solution(object):
    def calculateMinimumHP(self, dungeon):
        """
        :type dungeon: List[List[int]]
        :rtype: int
        """
        #dp[i][j] 
        if not dungeon or not dungeon[0]:return 0
        m,n = len(dungeon),len(dungeon[0])
        dp = [[0]*n for _ in range(m)]
        dp[-1][-1] = max(1-dungeon[-1][-1],1)
        for i in range(m-2,-1,-1):
            dp[i][n-1] = max(dp[i+1][n-1]-dungeon[i][n-1],1)
        
        for j in range(n-2,-1,-1):
            dp[m-1][j] = max(dp[m-1][j+1] -dungeon[m-1][j],1)
            
        for i in range(m-2,-1,-1):
            for j in range(n-2,-1,-1):
                dp[i][j] = max(min(dp[i+1][j],dp[i][j+1])-dungeon[i][j],1)
        return dp[0][0]

发表于 | 分类于

题目链接：leetcode

思路：

  • 不存在循环小数
  • 存在循环小数，形如1.2(3456)
  • 存在循环小数，形如1.(3456)
  • 使用字典存储余数mod，每次循环更新余数，如果字典中存在，说明循环了，再构造字符串
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class Solution(object):
    def fractionToDecimal(self, numerator, denominator):
        """
        :type numerator: int
        :type denominator: int
        :rtype: str
        """
        prefix = '-' if numerator*denominator < 0 else ''
        numerator = abs(numerator)
        denominator = abs(denominator)
        divide = numerator//denominator
        mod = numerator%denominator
        if mod == 0:return prefix+str(divide)
        d = {}
        stack = []
        i = -1
        while True:
            if mod == 0:
                return prefix+str(divide)+'.'+''.join(stack)
            mod *= 10
            i += 1
            if mod in d:
                idx = d[mod]
                return prefix+str(divide)+'.'+''.join(stack[:idx])+'('+''.join(stack[idx:])+')'
            
            if mod < denominator:
                stack.append('0')
                d[mod] = i
            else:
                stack.append(str(mod//denominator))
                d[mod] = i
                mod = mod%denominator

发表于 | 分类于

题目链接：leetcode链接

思路：中序遍历迭代型，非递归

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        stack = []
        res = []
        while True:
            if root:
                stack.append(root)
                root = root.left
            else:
                if len(stack) == 0:
                    break
                root = stack.pop()
                res.append(root.val)
                root = root.right
        return res

发表于 | 分类于

题目链接：leetcode链接

思路：二叉搜索树的中序遍历实现。
二叉搜索树性质：

  • 若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值；
  • 若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值；
  • 任意节点的左、右子树也分别为二叉查找树；
  • 没有键值相等的节点。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# Definition for a  binary tree node
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class BSTIterator(object):
    def __init__(self,root):
        self.stack = []
        self.root = root
    
    def next(self):
        while self.root:
            self.stack.append(self.root)
            self.root = self.root.left
        self.root = self.stack.pop()
        node = self.root
        self.root = self.root.right
        return node.val
    
    def hasNext(self):
        if self.root or len(self.stack) > 0:
            return True
        return False
        

# Your BSTIterator will be called like this:
# i, v = BSTIterator(root), []
# while i.hasNext(): v.append(i.next())

发表于 | 分类于

创建了一个项目，然后通过下面的命令 push 到了 GitHub 上。如何再将这个项目 push 到其他远程仓库呢？

1
2
git remote add github https://github.com/zhuanli/test.git
git push -u github master

  • 1.使用 git remote add 命令
1
2
3
4
5
6
7
git remote
github

git remote -v
github  https://github.com/zhuanli/test.git (fetch)
github  https://github.com/zhuanli/test.git (push)
git remote add oschina https://git.oschina.net/zhuanli/test.git
  • 2.使用 git remote set-url 命令
1
2
3
4
5
6
git remote rm oschina
git remote set-url --add github https://git.oschina.net/zhuanli/test.git
git remote -v
github  https://github.com/zhuanli/test.git (fetch)
github  https://github.com/zhuanli/test.git (push)
github  https://git.oschina.net/zhuanli/test.git (push)
  • 3.修改配置文件

打开 .git/config 找到 [remote “github”]，添加对应的 url 即可.

1
2
3
4
[remote "github"]
    url = https://github.com/zxbetter/test.git
    fetch = +refs/heads/*:refs/remotes/github/*
    url = https://git.oschina.net/zxbetter/test.git

2和3在 push 的时候比较方便。但是在 pull 的时候只能从第一个 url 地址拉取代码。而1则不存在这种问题（可能要解决冲突）。

发表于 | 分类于

链接地址：leetcode链接

思路 ：通过’.’把字符串分割成数组，再进行比较

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class Solution(object):
    def compareVersion(self, version1, version2):
        """
        :type version1: str
        :type version2: str
        :rtype: int
        """
        v1 = [int(i) for i in version1.split('.')]
        v2 = [int(i) for i in version2.split('.')]
        if len(v1)>len(v2):
            for i in range(len(v2)):
                if v1[i] > v2[i]:
                    return 1
                elif v1[i] < v2[i]:
                    return -1
            if max(v1[len(v2):]) > 0:return 1
            else:return 0
        elif len(v1) < len(v2):
            for i in range(len(v1)):
                if v1[i] > v2[i]:
                    return 1
                elif v1[i] < v2[i]:
                    return -1
            if max(v2[len(v1):]) > 0:return -1
            else:return 0
        else:
            for i in range(len(v1)):
                if v1[i] > v2[i]:
                    return 1
                elif v1[i] < v2[i]:
                    return -1
            return 0

发表于 | 分类于

链接地址：leetcode链接

思路：使用基数排序可以使时间复杂度为O(n)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import math
class Solution(object):
    def maximumGap(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if not nums or len(nums)<2:return 0
        self.radixSort(nums)
        maxgap = 0
        for i in range(1,len(nums)):
            if nums[i]-nums[i-1]>maxgap:
                maxgap = nums[i]-nums[i-1]
        return maxgap
    
    def radixSort(self,nums,base=10):
        k = int(math.ceil(math.log(max(nums)+1,base)))
        for i in range(1,k+1):
            bucket = [[] for _ in range(base)]
            for num in nums:
                bucket[num//(base**(i-1))%base].append(num)
            del nums[:]#del nums[:]表示删除数组内的整数,nums变量还存在为[];del nums表示删除整个数组,nums变量不存在了
            for each in bucket:
                nums.extend(each)

发表于 | 分类于

题目链接：leetcode162链接

思路：
最左端和最右端元素均无限小，则数组中一定存在一个峰元素。因为如果是单调增或单调减，那起点或终点为波峰。

要找到峰元素，我们只需找到刚刚开始下降而未下降的位置，可以使用二分法，nums[mid] 与 nums[mid+1] 进行比较可以知道刚刚开始下降而未下降的位置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution(object):
    def findPeakElement(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        l,r = 0,len(nums)-1
        while l<r:
            mid = (l+r)//2
            if nums[mid]>nums[mid+1]:
                r=mid
            else:
                l=mid+1
        return l

发表于 | 分类于

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

请找出其中最小的元素。

注意数组中可能存在重复的元素。

示例 1：

输入: [1,3,5]
输出: 1

示例 2：

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Solution(object):
    def findMin(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        l,r=0,len(nums)-1
        while l<r:
            mid = (l+r)//2
            if nums[mid] < nums[r]:
                r = mid
            elif nums[mid] > nums[r]:
                l = mid + 1
            else:#nums[l] <= nums[mid] <= nums[r]),r=r- 1
                r -= 1
        return nums[l]