蓝桥杯第六天_力扣和蓝桥杯哪个难

1力扣题目43

1思路

• 题目要求不允许使用int（）函数，是为了让单纯再字符串条件下实现乘法，但是还是可以在单独字符中使用，其目的考验增加额外数由于相乘导致的进位
• 我们可以倒着相乘，如果进位就记下，在下一次迭代时增加
• 然后经过事件复杂度O（n2）的运算，可以成功迭代完毕
• 最后加上为0的情况，在开头增添意外的字符串0

代码

class Solution:
    def multiply(self, num1: str, num2: str) -> str:
        if num1 == '0' or num2 == '0':
            return '0'

        result = [0] * (len(num1) + len(num2))
        rst_str = ['0'] * (len(num1) + len(num2))
        for i in range(len(num1)-1,-1,-1):
            for j in range(len(num2) - 1, -1, -1):
                nm = str(int(num1[i]) * int(num2[j]))
                l = len(nm) - 1
                for k in range(j+i+1,j+i-len(nm)+1,-1):
                    result[k] += int(nm[l])
                    if result[k] >= 10:
                        result[k-1] += result[k]//10
                        result[k] %= 10
                    l -= 1
                    rst_str[k] = str(result[k])
        rst_str[0] = str(result[0])

        if rst_str[0] == '0':
            rst_str = rst_str[1:]
        return ''.join(rst_str)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

这应该算是暴力算法吧

二力扣题库47

1思路

• 学题解的，名字叫回溯模板如下

• 回溯法 采用试错的思想，它尝试分步的去解决一个问题。在分步解决问题的过程中，当它通过尝试发现现有的分步答案不能得到有效的正确的解答的时候，它将取消上一步甚至是上几步的计算，再通过其它的可能的分步解答再次尝试寻找问题的答案。回溯法通常用最简单的递归方法来实现，在反复重复上述的步骤后可能出现两种情况：

• 找到一个可能存在的正确的答案；

• 在尝试了所有可能的分步方法后宣告该问题没有答案。
  

2代码

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        result = []
        visited = [False] * len(nums)
        def backtrack(tmp):
            if len(tmp) == len(nums):
                result.append(tmp)
                return 
            for i in range(len(nums)):
                if visited[i]:
                    continue
                visited[i] = True
                backtrack(tmp + [nums[i]])
                visited[i] = False
            return result
        return backtrack([])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

三力扣53

1思路

• 这篇题目和之前做过的最大的水杯容器很类似，都取一个max来在迭代中比较新解和旧街，可参考我第三天的博客
• 这道和拿到不同的是我们还要加入一个量minest来记录这个迭代过程中，新解总数减去这个最小值，这个最小值储存的是我们前面所以连续的子序列的最小和，这样我们就不用从中间记录
• 加入的minest是直接让我们加的和是从头到尾，然后通过减去minest得到跨国某个减小的子序和

2代码

class Solution(object):
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        max_sum,minest,total,res=0,0,0,max(nums)
        if res<0:
            return res
        for i in nums:
            total += i
            if total < minest:
                max_sum = max(max_sum, total - minest)
                minest = total
            else:
                max_sum = max(max_sum, total - minest)
        return max_sum
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

第一个有点难，希望下次分享有大佬能给我思路，回溯也不太熟，多连吧