Leetcode刷题 2021.03.02

Leetcode256 粉刷房子

假如有一排房子，共 n 个，每个房子可以被粉刷成红色、蓝色或者绿色这三种颜色中的一种，你需要粉刷所有的房子并且使其相邻的两个房子颜色不能相同。

当然，因为市场上不同颜色油漆的价格不同，所以房子粉刷成不同颜色的花费成本也是不同的。每个房子粉刷成不同颜色的花费是以一个 n x 3 的矩阵来表示的。

例如，costs[0][0] 表示第 0 号房子粉刷成红色的成本花费；costs1 表示第 1 号房子粉刷成绿色的花费，以此类推。请你计算出粉刷完所有房子最少的花费成本。

此类dp问题看多了，简单一点的题目也马上就会了，就是常规的dp题。优化成O(1)的空间复杂度

class Solution {
    public int minCost(int[][] costs) {
        int n = costs.length;
        if (n == 0) return 0;
        int[] dp = new int[3];
        //dp[i][j]表示刷到第号房子使用j种颜色的最小代价
        dp[0] = costs[0][0];
        dp[1] = costs[0][1];
        dp[2] = costs[0][2];

        for(int i = 1; i < n; i++){
            int temp0 = dp[0];
            int temp1 = dp[1];
            int temp2 = dp[2];
            //根据题意更新即可，因为不能连续刷一样的，所以根据上一次的颜色，刷两种不同颜色的取最小值即可
            dp[0] = Math.min(temp1, temp2) + costs[i][0];
            dp[1] = Math.min(temp0, temp2) + costs[i][1];
            dp[2] = Math.min(temp0, temp1) + costs[i][2];
        }

        return Math.min(dp[0], Math.min(dp[1], dp[2]));
    }
}

Leetcode150 逆波兰表达式求值

根据 逆波兰表示法，求表达式的值。

*有效的运算符包括 +, -, , / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

记得上学的时候被逆波兰折磨的够呛，所以看到这题就本能地直接略过了，其实是很简单的一道题，就是栈的应用而已。

class Solution {
    public int evalRPN(String[] tokens) {
        Deque<String> stack = new ArrayDeque<>();
        for(int i = 0; i < tokens.length; i++){
        	//如果是运算符直接入栈
            if (!tokens[i].equals("+") && !tokens[i].equals("-") && !tokens[i].equals("*") &&!tokens[i].equals("/")){
                stack.push(tokens[i]);
            }else{
            //否则弹出栈里的两个元素，根据要求做运算即可
                int num1 = Integer.parseInt(stack.pop());
                int num2 = Integer.parseInt(stack.pop());
                int temp = 0;
                if (tokens[i].equals("+")){
                    temp = num2 + num1;
                }else if (tokens[i].equals("-")){
                    temp = num2 - num1;
                }else if (tokens[i].equals("*")){
                    temp = num2 * num1;
                }else{  
                    temp = num2 / num1;
                }
                stack.push(String.valueOf(temp));
            }
        }
        return Integer.parseInt(stack.pop());
    }
}

Leetcode398 随机数索引

给定一个可能含有重复元素的整数数组，要求随机输出给定的数字的索引。 您可以假设给定的数字一定存在于数组中。

注意：
数组大小可能非常大。 使用太多额外空间的解决方案将不会通过测试。

蓄水池抽样，不是很了解，-_-||。直接用map暴力解了。

class Solution {
    Map<Integer, List<Integer>> map;
    Random random = new Random();
    public Solution(int[] nums) {
        map = new HashMap<>();
        //遍历数组根据元素添加相应的索引
        for(int i = 0; i < nums.length; i++){
            List<Integer> list = map.get(nums[i]);
            if (list == null){
                list = new ArrayList<>();
                map.put(nums[i], list);
            }
            list.add(i);
        }
    }
    
    public int pick(int target) {
        List<Integer> list = map.get(target);
        //用random.nextInt(n),随机返回一个[0,n)之间的整数
        return list.get(random.nextInt(list.size()));
    }
}