Leetcode--回溯算法（组合总数，全排列）

今天在Leetcode的某个评论区看到一张图片，终于让我对不知如何下手的回溯算法清晰了一些，总结下来就是第一遍将所以的数据拿出来，剩下的通过回溯调用的办法，依次的加上去，不符合条件的直接进行剪枝，所以需要进行return条件的设置，进行剪枝。不过还需要多联系，共勉吧

组合总和

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。

示例 1：

输入：candidates = [2,3,6,7], target = 7 输出：[[2,2,3],[7]] 解释： 2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。 7 也是一个候选， 7 = 7 。

思路：还是使用回溯算法进行遍历，主要是控制结束条件

class Solution(object):
    def combinationSum(self, candidates, target):
        """
        :type candidates: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        res = []
        if not candidates or (len(candidates) == 1 and candidates[0] > target):
            return res   # 如果列表为空或者一个数且大于target,直接返回
        n = len(candidates)  
​
        def backtrack(i, sum, list):    
            if sum > target or i == n:  # 当和大于target 或者 最后一个数的时候，返回
                return
            if sum == target:    # 和为target,将它加到加到列表里
                res.append(list)
                return
            else:
                for m in range(i, n):  # 当和小于target,进行循环
                  
                    if sum > target:  # 在过程中，sum>target,return
                        break
                    backtrack(m, sum + candidates[m], list + [candidates[m]])  
                                              # list 不断的存放累加
​
        backtrack(0, 0, [])
        return res

全排列

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案

示例 1：

输入：nums = [1,2,3] 输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

思路：我们要注意到结果和nums的长度都是一样，换了位置而已，轮流取一个加进去，在递归调用，拿去数据

class Solution(object):
    def permute(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        res = []
​
        def backtrack(nums, list1):  
            if not nums:      # 当不为nums
                res.append(list1)
                return
            for i in range(len(nums)):
                backtrack(nums[:i] + nums[i + 1:], list1 + [nums[i]])
​
        backtrack(nums, [])
        return res

删除排序链表中的重复元素

给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 。

示例 1：

输入：head = [1,1,2] 输出：[1,2] 示例 2：

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def deleteDuplicates(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if head==None:
            return None  # 当为空时直接返回
        else:
            node = head    # node指向head头结点 
            while(node.next!= None):  # 不是最后一个节点
                if node.val==node.next.val:    # 由于是排好序了的，相同下一个数据等于本数据
                    node.next = node.next.next  # 改变指针到下一个的下一个
                else:
                    node = node.next  # 不然就指针向后移动进行遍历
        return head