算法学习day3--递归与回溯_算法写法 输入: 输出: 第一步 第二步

递归与回溯

递归的基本性质：函数调用本身
将大规模的问题不断地变小，再进行推导的过程
回溯：利用递归的性质
从问题的本身出发，不断的尝试。返回一步甚至多步再做选择，直到抵达终点的过程

递归

经典案例：汉诺塔
算法思想
要懂得如何将一个问题的规模变小
再利用从小规模问题中得到的结果
结合当前的值或者情况，得出最终的结果
通俗理解
将要实现的递归函数，看成已经实现好的
直接利用解决一个子问题
思考：如何根据子问题的解以及当前面对的情况得出答案
递归算法是自顶向下，动态规划是自底向上

递归写法结构总结：

第一步：判断输入或者状态是否非法
第二步：判读递归是否应当结束
第三步：缩小问题规模
第四步：整合结果
leecode247.中心对称数||
n=1 0 1 8
n=2 11 69 88 96 注意00不合法(但n增大需要增加)
n=3 在1的上面加2
n=4 在2的上面加2
临界情况： n0 返回""，n1 返回0,1,8
需要注意的是 如果加上2后长度没达到，可以俩端添加0

时间复杂度的分析

1. 迭代法分析
2. 公式法 T(n)=a.T(n/b)+f(n) 时间复杂度 Math.max(O(nlog以b为底a ，f(n) ) )

回溯

一步一步向前试探评估，再决定是否继续，可避免走弯路

回溯的精华
出现非法的情况时，可退到之前的情景，可返回一步或多步
再去尝试别的路径和方法

回溯写法结构总结

第一步：判断输入或者状态是否非法
第二步：判断递归是否应当结束
遍历所有出现的情况
第三步：尝试下一步的可能性
递归
第四步：回溯到上一步

leecode39.组合总和

//给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。 
// candidates 中的数字可以无限制重复被选取。 
// 说明： 
// 所有数字（包括 target）都是正整数。 
// 解集不能包含重复的组合。 
//
// 示例 1： 
// 输入：candidates = [2,3,6,7], target = 7,
//所求解集为：
//[[7], [2,2,3]]

import java.util.*;

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    List<List<Integer>> result=new ArrayList<>();
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        LinkedList<Integer> one=new LinkedList<>();
        dfs(candidates,target,0,one);
        return result;
    }
    public void dfs(int[] candidates,int target,int begin,LinkedList<Integer> one){
        if(target==0) {
            result.add(new ArrayList<>(one));
            return ;
        }else if(target<0) return ;
        int len=candidates.length;
        if(len==0) return;
        for (int i = begin; i <len ; i++) {
            one.add(candidates[i]);
            dfs(candidates,target-candidates[i],i,one);
            one.removeLast();
        }
    }
}
//leetcode submit region end(Prohibit modification and deletion)
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
33
34
35
36

leecode 字符串的全排列
这道题主要就是要在上一次操作结束的基础上进行下一次操作，结束后，要变回未操作时的状态，完全符合回溯算法的需求
所以在操作的时候对于字符串s要不定位类的成员变量，要不就需要一直传递
通过一个标识符来表示需要操作第几个字母。对于每一个位置，可以填写其他各个位置的字母，但是不能重复
所以对于每一次操作第n位字母 (调用dfs方法)，新建一个set来去重 ，刚好是去重当前位置的字母
每次n==n-1时，本次交换结束，添加到list中，并且返回

//输入：s = "abc"
//输出：["abc","acb","bac","bca","cab","cba"]
//里面不能有重复元素
class Solution {
    List<String> list=new ArrayList<>();
    char[] chars;
    int len=0;
    public String[] permutation(String s) {
        chars = s.toCharArray();
        len=chars.length;
        dfs(0);
        return list.toArray(new String[chars.length]);
    }
    public  void dfs(int n){
        if(n==len-1) {
            list.add(String.valueOf(chars));
            return;
        }
        //因为需要在同一条件的同一级去重  这个是精髓
        Set<Character> set=new HashSet<>();
        for (int i = n; i <len ; i++) {
            if(set.contains(chars[i])) continue;
            set.add(chars[i]);
            change(n,i);
            dfs(n+1);
            change(n,i);
        }
    }
    public void change(int a,int b){
        char temp=chars[a];
        chars[a]=chars[b];
        chars[b]=temp;
    }
}

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
33
34
35

leecode52.N皇后 ||