2020-09-04

class Solution:
    def judgePoint24(self, nums: List[int]) -> bool:
        TARGET = 24
        EPSILON = 1e-6
        ADD, MULTIPLY, SUBTRACT, DIVIDE = 0, 1, 2, 3

        def solve(nums: List[float]) -> bool:
            if not nums:
                return False
            if len(nums) == 1:
                return abs(nums[0] - TARGET) < EPSILON
            for i, x in enumerate(nums):
                for j, y in enumerate(nums):
                    if i != j:
                        newNums = list()
                        for k, z in enumerate(nums):
                            if k != i and k != j:
                                newNums.append(z)
                        for k in range(4):
                            if k < 2 and i > j:
                                continue
                            if k == ADD:
                                newNums.append(x + y)
                            elif k == MULTIPLY:
                                newNums.append(x * y)
                            elif k == SUBTRACT:
                                newNums.append(x - y)
                            elif k == DIVIDE:
                                if abs(y) < EPSILON:
                                    continue
                                newNums.append(x / y)
                            if solve(newNums):
                                return True
                            newNums.pop()
            return False

        return solve(nums)

class Solution:
    def judgePoint24(self, nums: List[int]) -> bool:
        if len(nums) == 1:
            return math.isclose(nums[0], 24)
        return any(self.judgePoint24([x] + rest)
                    for a, b, *rest in itertools.permutations(nums)
                    for x in {a+b, a-b, a*b, b and a/b})

class Solution:
    def isValid(self, s: str) -> bool:
        # 把一个list当做栈使用
        ls = []
        parentheses = "()[]{}"
        for i in range(len(s)):
            si = s[i]
            # 如果不是括号则继续
            if parentheses.find(si) == -1:
                continue
            # 左括号入栈
            if si == '(' or si == '[' or si == '{':
                ls.append(si)
                continue
            if len(ls) == 0:
                return False
            # 出栈比较是否匹配
            p = ls.pop()
            if (p == '(' and si == ')') or (p == '[' and si == ']') or (p == '{' and si == '}'):
                continue
            else:
                return False

        if len(ls) > 0:
            return False
        return True

import sys
n, m, k = list(map(int, input().split()))
nums = []
price = []
weight = []
va = []
for i in range(n):
    p, w, v =list(map(int, input().split()))
    nums.append([p,w,v])
    price.append(p)
    weight.append(w)
    va.append(v)

nums.sort(key=lambda x:(-x[2],x[0],x[1]))

count = 0

for i in range(n):
    if m>=nums[i][1] and k>=nums[i][0]:
        m = m - nums[i][1]
        k = k - nums[i][0]
        count += 1
sys.stdout.write(str(count))

---

顺时针打印矩阵

class Solution:
    def printMatrix(self,matrix):
        res = []
        while matrix:
            res += matrix.pop(0)
            if matrix:
                matrix = self.helpme(matrix)
        return res

    def helpme(self,matrix):
        row = len(matrix)
        col = len(matrix[0])
        new_mat = []

        for i in range(col):
            temp = []
            for j in range(row):
                temp.append(matrix[j][col -1-i])
            new_mat.append(temp)
        return new_mat

背包问题

def track(d, c, w):  # 输出最优路径
    x = []
    for i in range(len(w), 1, -1):  # m[n][c]为最优值，如果m[n][c]=m[n-1][c] ,说明有没有第n件物品都一样
        if d[i][c] != d[i - 1][c]:
            x.append(w[i - 1])
            c = c - w[i - 1]
    if d[1][c] > 0:
        x.append(w[0])

    return x


if __name__ == '__main__':
    c = int(input())  # 输入一个限制条件，例如背包的体积为c
    # w = sys.stdin.readline().strip().split(' ')  # 每个物品的体积
    w = eval(input())
    # w = list(map(int, w))
    # v = sys.stdin.readline().strip().split(' ')  # 对应每个物体的价值
    v = eval(input())
    # v = list(map(int, v))
    # w,v = input().split(',')
    dp = [[0] * (c + 1) for i in range(len(w) + 1)]  # 动态规划矩阵

    for i in range(1, len(w) + 1):
        for j in range(1, c + 1):
            if j >= w[i - 1]:
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w[i - 1]] + v[i - 1])  # 动态转移方程
            else:
                dp[i][j] = dp[i - 1][j]

    print(max(dp[len(w)]))  # 输出最大值

    print(track(dp, c, w))  # 输出最优路径

回文数

class Solution:
    def isPalindrome(self, x: int) -> bool:
        if x < 0 or (x % 10 == 0 and x != 0):
            return False
        new = 0
        while x > new:
            temp = x % 10
            x //= 10
            new = new * 10 + temp
        if x == new or x == new // 10:
            return True
        return False