Gec‘s 算法之路

目录

爬楼梯

思路：

​​​​​​​代码：

全排列

思路：

代码：

---

爬楼梯

2024-07-31 23:00

（LeetCode 70，easy）

面对n级台阶，一次只能选择跳1阶或者2阶，问总共有多少种跳法？

思路：

标准动态规划路子，官网提示是前一步的到达方式，借此可以考虑我已经到达了n-1th阶台阶，我对于最后的nth台阶只有一种跳法，如果到了n-2th台阶，那我就有两种跳法。。。对于1st的台阶，我只有一种跳法，对于2nd的台阶，我有两种跳法。。。

初步写出动态方程：

dp(n) = dp(n-1) + 1

然后发现报错了，后面根据直觉又改成：

dp(n) = dp(n - 1) + dp(n - 2)

这次倒是对了，只不过栈溢出，超时了；

于是改用dp数组记录每阶台阶的跳法：

dp[i] = dp[i -1] + dp[i - 2]; dp[0] = 1; dp[1] = 2; 

开始还是不太理解为什么nth = n-1th + n-2th这样的结构，总是认为到了最后还有两阶时可以跳1阶和2阶，但我忘了强调前提，于是我开始试着从另一个角度看：

n阶台阶最后一步无非就是跳1阶或者2阶，至此，如果跳1阶，那么之前n-1阶方法就是所有方法，如果跳两阶，那么之前n-2阶的方法就是所有方法，两者肯定有重复的部分，但是就是最后一步一个是1阶，一个是2阶，造就了两种跳法集合的不同，也就产生了到n阶的所有可能性。

​​​​​​​代码：

class Solution {

    private int[] dp = null;

    public int climbStairs(int n) {

        if(n <= 0)
            return 0;
        if(n == 1)
            return 1;
        if(n == 2)
            return 2;

        if(dp == null){
            dp = new int[n + 1];
            dp[1] = 1;
            dp[2] = 2;
        }

        for(int i = 3; i < n + 1; i ++){
            dp[i] = dp[i - 1] + dp[i - 2];
        }

        return dp[n];

    }
}

---

全排列

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

思路：

肯定想的是高中公式，但那是求总共排列数有n!个，全罗列出来的话我能想到的也就是穷举，类似一个不断回溯的过程，思路很简单，代码难写啊！！

首先确定backTrack方法签名，排列数组是肯定需要的，另一个参数肯定要存储“已选择”的排列数，所以需要一个List，也可以存到类变量里；

接着确定数据结构：

List<List<Integer>> result; // 存取结果

List<Integer> currPermute; // 存储每次的排列

然后确定终止条件，即排列数到底了；

currPermute.size() >= arr.length;

接着把当前排列add到结果集中，注意Java的引用复制！

 result.add(new LinkedList(currPermute));

// currPermute.clear();

// 这里做了一步傻缺操作，想着清空集合为下一次做准备，记住，回溯不需要清空！

然后就是遍历当前选择了

for(int i = 0; i < arr.length; i ++){

        // 注意这里也要有一个contains判断

        currPermute.contains(arr[i]);

最后就是遍历

backTrack(arr, currPermute); 

‼️最最后一定要回溯，即删除当前选择，想象成每一次循环都分支出arr.length长度减去已存在元素数量的循环，每次上层的index，i，就会代表当前的分支，例如1，2，3；1，3，2；中的“1”就是最底层方法栈里的循环i，下一层就代表2开头，再下一层就是3；下一个方法栈则再剩余元素上继续挑选；

代码：

class Solution {
    private List<List<Integer>> allPermute = new ArrayList();
    private List<Integer> currPermute = new ArrayList();

    public List<List<Integer>> permute(int[] nums) {
        if(nums == null){
            return null;
        }

        backTrack(nums, currPermute);
        return allPermute;
    }

    private void backTrack(int[] arr){

        // 终止条件
        if(arr.length <= currPermute.size()){
            allPermute.add(new ArrayList(currPermute));
            // currPermute = new ArrayList();
            return;
        }

        for(int i = 0; i < arr.length; i ++){
            if(currPermute.contains(arr[i]))
                continue;

            currPermute.add(arr[i]);

            backTrack(arr, currPermute);

            currPermute.remove(currPermute.size() - 1);
        }
    }
}

---

最长递增子序列