java数据结构与算法刷题-----LeetCode70：爬楼梯

java数据结构与算法刷题目录（剑指Offer、LeetCode、ACM）-----主目录-----持续更新(进不去说明我没写完)：https://blog.csdn.net/grd_java/article/details/123063846

1. 我的思考过程：

1. 分析已知条件，试图寻找解题思路

1. 一共n个台阶，每次可爬1或2个台阶
2. 爬楼梯，不是1就是2
3. 爬到最后，要不剩下0个台阶，表示爬完，要不剩下1个或两个，如果是1个，就只有爬一个台阶这一条选择。如果是两个，那么可以两次都走1个台阶爬完，或者一次性爬两个台阶，一共两个选择。

2. 分析结果和已知条件的关系函数方程f(n)

1. 要的结果是，一共几种方案，也就是每次爬楼梯有多少选择。
2. 如果只有1个台阶，那么只有1个方案。f(1) = 1
3. 如果只有2个台阶，那么有2个方案。f(2) = 2
4. 如果有3个台阶，那么也有两个选择，要么先走1个,剩余2个，要么先走2个，剩余1个。f(3) = f(2)+f(1)
5. 如果有4个台阶，那么初始也有两个选择，要么先走一个，剩余3个。要么先走2个，剩余2个，f(4) = f(3)+f(2)
6. 所以可以推出关系方程为f(1) = 1,f(2) = 2,f(n)=f(n-1)+f(n-2)

3. 根据关系方程，确定代码思路

1. 递归，如果n=1直接f(1)=1.如果n=2，直接f(2) = 2，如果大于2，直接f(n) = f(n-1)+f(n-2)
2. 缓存回溯（也算动态规划），一般像这样，获得f(n)需要前面f(n-1)分支的方程，都会有重复演算的资源浪费问题。我们可以回溯，比如f(4) = f(3)+f(2),而f(3) = f(2)+f(1)。可以发现f(2)计算了两次，我们可以缓存起来，遇到算过的，不要重复计算，直接取值
3. 动态规划，因为f(n) = f(n-1)+f(n-2)，只要知道f(1)和f(2)，就可以依次向下推出f(3),f(4)，所以直接自左向右动态规划即可

2. 代码

public abstract class Test{
    //递归
    public static int climbStairs1(int n) {
        if(n<=2) return n;
        return climbStairs1(n-1)+climbStairs1(n-2);
    }

    //回溯
    private static HashMap<Integer,Integer> hashMap = new HashMap<>();
    public static int climbStairs2(int n) {
        if(n<=2){
            if(hashMap.get(n)!=null) return hashMap.get(n);
            hashMap.put(n,n);
            return n;
        }
        if(hashMap.get(n)!=null) return hashMap.get(n);
        int result= climbStairs2(n - 1) + climbStairs2(n - 2);
        hashMap.put(n,result);
        return result;

    }
    //动态规划
    public static int climbStairs3(int n) {
        if(n<=2) return n;
        int arr[] = new int[n+1];
        arr[1] = 1;
        arr[2] = 2;
        for(int i = 3;i<=n;i++){
            arr[i] = arr[i-1]+arr[i-2];
        }
        return arr[n];
    }
    //动态规划再次优化
    public static int climbStairs4(int n) {
        if(n<=2) return n;
        int a = 1,b=2,result = 0;
        for(int i = 3;i<=n;i++){
            result = a+b;
            a = b;
            b = result;
        }
        return result;
    }

    public static void main(String[] args) {
        int n = 6;
        System.out.println(climbStairs1(n));
        System.out.println(climbStairs2(n));
        System.out.println(climbStairs3(n));
        System.out.println(climbStairs4(n));
    }

}

刷题一定要坚持，总结套路，不单单要把题做出来，要举一反三，也要参考别人的思路，学习别人解题的优点，找出你觉得可以优化的点。

1. 单链表解题思路：双指针、快慢指针、反转链表、预先指针

1. 双指针：对于单链表而言，可以方便的让我们遍历结点，并做一些额外的事
2. 快慢指针：常用于找链表中点，找循环链表的循环点，一般快指针每次移动两个结点，慢指针每次移动一个结点。
3. 反转链表：通常有些题，将链表反转后会更好做，一般选用三指针迭代法，递归的空间复杂度有点高
4. 预先指针：常用于找结点，比如找倒数第3个结点，那么定义两个指针，第一个指针先移动3个结点，然后两个指针一起遍历，当第一个指针遍历完成，第二个指针指向的结点就是要找的结点

2. 数组解题思路：双指针、三指针，下标标记

1. 双指针：多用于减少时间复杂度，快速遍历数组
2. 三指针：多用于二分查找，分为中间指针，左和右指针
3. 下标标记：常用于在数组范围内找东西，而不想使用额外的空间的情况，比如找数组长度为n，元素取值范围为[1,n]的数组中没有出现的数字，遍历每个元素，然后将对应下标位置的元素变为负数或者超出[1,n]范围的正数，最后没有发生变化的元素，就是缺少的值。