算法练习

1.跳跃游戏

给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个下标。

（1）思路：从后往前遍历数组，如果遇到的元素可以到达最后一行，则截断后边的元素。否则继续往前，若最后剩下的元素大于1个，则可以判断为假。否则就是真，时间复杂度O(n)就可以。
（2）代码：

class Solution {
    public boolean canJump(int[] nums) {
        int n=1;
        for(int i=nums.length-2;i>=0;i--){
            if(nums[i]>=n)
            {
                n=1;
            }
            else
            {
                n++;
            }
            if(i==0&&n>1)
            {
                return false;
            }
        }
        return true;
        
    }
}

2.电话号码的字母组合

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

（1）思路：递归枚举所有case，注意输入为空的case。
（2）代码：

class Solution:
    def letterCombinations(self, digits: str) -> List[str]:
        if not digits:
            return []
        KEY = {'2': ['a', 'b', 'c'],
               '3': ['d', 'e', 'f'],
               '4': ['g', 'h', 'i'],
               '5': ['j', 'k', 'l'],
               '6': ['m', 'n', 'o'],
               '7': ['p', 'q', 'r', 's'],
               '8': ['t', 'u', 'v'],
               '9': ['w', 'x', 'y', 'z']}
        ans = []
        def backtrace(i, chars):
            nonlocal ans
            if i >= len(digits):
                ans.append("".join(chars))
                return
            for c in KEY[digits[i]]:
                chars.append(c)
                backtrace(i+1, chars)
                chars.pop()
        backtrace(0, [])
        return ans

3.全排列

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

（1）思路：回溯，每次传入已经放入排序中的索引构成的列表，以及已排序好的列表。
（2）代码：

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        self.ans = []
        self.nums = nums
        self.dfs([], [])
        return self.ans
    
    def dfs(self, alreadyIn, currentLst):
        if (len(self.nums)-1) == len(alreadyIn):
            for i in range(len(self.nums)):
                if i not in alreadyIn:
                    self.ans.append(currentLst + [self.nums[i]])
        for i in range(len(self.nums)):
            if i not in alreadyIn:
                self.dfs(alreadyIn + [i], currentLst + [self.nums[i]])

4.子集

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

（1）思路：从前遍历，遇到一个数，把所有子集加上该数组成新的子集。
（2）代码：

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> list1=new ArrayList<>();
        list1.add(new ArrayList<Integer>());
        for(int i=0;i<nums.length;i++){
            List<Integer> list2=new ArrayList<>();
            list2.add(nums[i]);
            list1.add(list2);
            int length=list1.size()-1;
            for(int j=1;j<length;j++){//从一开始组合
                List<Integer> list3=new ArrayList<>();
                list3.addAll(list1.get(j));
                list3.add(nums[i]);
                list1.add(list3);
            }
        }
        return list1;
    }
}

5. 买卖股票的最佳时机

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

（1）思路：记录今天之前买入的最小值。计算今天之前最小值买入，今天卖出的获利，即今天卖出的最大获利。比较每天的最大获利，取最大值即可。
（2）代码：

class Solution {
    public int maxProfit(int[] prices) {
        if(prices.length <= 1)
            return 0;
        int min = prices[0], max = 0;
        for(int i = 1; i < prices.length; i++) {
            max = Math.max(max, prices[i] - min);
            min = Math.min(min, prices[i]);
        }
        return max;
    }
}