回溯法与枚举法

1 回溯法应用

回溯法,顾名思义,生活中有一类人,很执拗,比如我,不到黄河心不死,到了黄河怎么办?往回走呗,难不成跳下去?

回溯法解决的问题有全排列,全组合,枚举什么的。

比如,给定一串不重复字母,让你按字典顺序进行排列,这是个全排列的问题,很好理解,但编程很麻烦。如果给定的字母可以重复,让你按字典的顺序排列,这个问题是不是更复杂了呢?

回溯法,跟数一样,随机取出一个元素,此时情况有N种,则有N个这有的节点,然后在剩下的集合中,又随机取个数,此时情况可能有N-1种(可能小于N-1如果有重复的项),重复上面的生成节点的过程。当处理到最后一个元素或者当前的路径以及不满足要求了,就往回走了,递归回来。

回溯构建数的时候,取出了那个元素,下一个集合就没有这个元素了。

2 回溯法固化模板

回溯法就相当于搜索一棵树,使用深度优先搜索数的方法。

def dfs(输入):
    if 当前状态为边界:
        记录或输出
        return 

    for i in range(len(输入)):#横向遍历所有子节点
        目前遍历的当前子节点
        if 子状态满足约束条件:
            dfs(子状态)
        

3 题集

3.1 字符串排列(全排列问题)

题目描述

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

解题思路:字典排序,重复元素的全排列。深度优先搜索,即为空是返回.先从N个样本中取一个,接在递归在剩下的样本中取,为什么要递归?因为这样再取完以后会退回到上一级.

重复原始处理,排好序后,如果取到的这个,和上个相似,就continue.

假设根就是空,第一层会有N个子节点,对重复的取一个X,然后从集合中去掉取出的这一个X(重复的也去掉一个),迭代。

class Solution:
    def Permutation(self, ss):
        if not ss:
            return []
        ss = sorted(ss)
        temp = []
        N = len(ss)
        def dfs(ss,cur):
            if not ss:
                if len(cur) == N:
                    temp.append(cur)
                return
        for i in range(len(ss)):
            if i > 0:
                if ss[i] == ss[i-1]:
                    continue
            if len(ss) == N:
                cur = ss[i]
            else:
                cur = cur+ss[i]
            if i+1 < len(ss) and i>0:
                ss1 = ss[:i]+ss[i+1:]
            elif i==0:
                ss1 = ss[i+1:]
            else:
                ss1 = ss[:i]
            dfs(ss1, cur)
        dfs(ss,'')
        return temp

3.2 矩阵中的路径

题目描述

请设计一个函数,用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始,每一步可以在矩阵中向左,向右,向上,向下移动一个格子。如果一条路径经过了矩阵中的某一个格子,则之后不能再次进入这个格子。 例如 a b c e s f c s a d e e 这样的3 X 4 矩阵中包含一条字符串"bcced"的路径,但是矩阵中不包含"abcb"路径,因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后,路径不能再次进入该格子。

解题思路:首先输入的是字符串‘ csadee’,需要映射成矩阵(嗯,绕了很长时间)。因为起始位置是随机的,所以需要遍历所有的矩阵作为起始位置。为了节约时间,我们需要剪枝,即如果当前位置的值不等于path,那就可以直接返回。

还需要注意一个约束,就是不能往回走,最开始我的代码是:

class Solution:
    def __init__(self):
        self.flag = False
    def hasPath(self, matrix, rows, cols, path):
        if not matrix:            
            return False
        for j in range(rows):
            for i in range(cols):
                self.hasp(matrix,j,i,path[:], rows)
                if self.flag:
                    return True
        return False

    def hasp(self,matrix, curr, curc, path, rows, cols):
        if not path:
            self.flag = True
            return
        if curr<0 or curc<0 or curr>rows-1 or curc>cols-1:
            return
        index = curr * cols + curc
        if matrix[index] == path[0]:
              
            self.hasp(matrix, curr-1, curc, path[1:], rows, cols)
            
            self.hasp(matrix, curr + 1, curc, path[1:], rows, cols)
            
            self.hasp(matrix, curr , curc - 1, path[1:], rows, cols)
            
            self.hasp(matrix, curr , curc + 1, path[1:], rows, cols)

本地跑属于False的也会返回True,什么原因呢?因为我重复了曾经的路径,贴上正确的代码:

class Solution:
    def __init__(self):
        self.flag = False
    def hasPath(self, matrix, rows, cols, path):
        if not matrix:            
            return False
        for j in range(rows):
            for i in range(cols):
                self.hasp(matrix,j,i,path[:], rows, cols,[(j,i)])
                if self.flag:
                    return True
        return False

    def hasp(self,matrix, curr, curc, path, rows, cols,history):
        if not path:
            self.flag = True
            return
        if curr<0 or curc<0 or curr>rows-1 or curc>cols-1:
            return
        index = curr * cols + curc
        if matrix[index] == path[0]:
            if (curr-1, curc) not in history:            
                self.hasp(matrix, curr-1, curc, path[1:], rows, cols,history+[(curr-1, curc)])
            if (curr + 1, curc) not in history: 
                self.hasp(matrix, curr + 1, curc, path[1:], rows, cols,history+[(curr + 1, curc)])
            if (curr , curc-1) not in history: 
                self.hasp(matrix, curr , curc - 1, path[1:], rows, cols,history+[(curr, curc-1)])
            if (curr , curc+1) not in history: 
                self.hasp(matrix, curr , curc + 1, path[1:], rows, cols,history+[(curr , curc+1)])

3.2 矩阵中的路径

题目描述

地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动,每一次只能向左,右,上,下四个方向移动一格,但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如,当k为18时,机器人能够进入方格(35,37),因为3+5+3+7 = 18。但是,它不能进入方格(35,38),因为3+5+3+8 = 19。请问该机器人能够达到多少个格子?

解题思路:数位之和,我想到的就是把它转换成str,然后按位读取str,转换成int并求和。感觉这道题很简单啊,思路也对,时间复杂度总是超了。我原来的思路跟上道题一样,边界条件改了(超出矩阵和数位之和),其实条件就只为(0,0)。调了很久,后来知道是走过的路径应该设置为全局变量。当初没有设置为全局变量。

正确代码:

class Solution:
    def movingCount(self, threshold, rows, cols):
        self.row, self.col = rows, cols
        self.dict = []
        
        self.search(threshold, 0, 0)
        return len(self.dict)

    def search(self, threshold, i, j):
        ss = 0
        for k in str(i)+str(j):
            ss = ss+int(k)
        if ss > threshold:
            return
        self.dict.append((i,j))
        if i != self.row - 1 and (i+1,j) not in self.dict:
            self.search(threshold, i + 1, j)
        if j != self.col - 1 and (i,j+1) not in self.dict:
            self.search(threshold, i, j + 1)

 

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值