LeetCode第157场周赛

LeetCode第157场周赛

十一出去玩了，没做周赛，现在有空了补一下
———————————————————————————————————————————————

1217. 玩筹码

数轴上放置了一些筹码，每个筹码的位置存在数组 chips 当中。
你可以对 任何筹码 执行下面两种操作之一（不限操作次数，0 次也可以）：
将第 i 个筹码向左或者右移动 2 个单位，代价为 0。 将第 i 个筹码向左或者右移动 1 个单位，代价为 1。
最开始的时候，同一位置上也可能放着两个或者更多的筹码。

返回将所有筹码移动到同一位置（任意位置）上所需要的最小代价。
示例 1：
输入：chips = [1,2,3] 输出：1 解释：第二个筹码移动到位置三的代价是 1，第一个筹码移动到位置三的代价是 0，总代价为 1。
示例 2：
输入：chips = [2,2,2,3,3] 输出：2 解释：第四和第五个筹码移动到位置二的代价都是 1，所以最小总代价为 2。
提示：
1 <= chips.length <= 100 1 <= chips[i] <= 10^9
思路：奇数位置和偶数位置个数更少的就是代价

public int minCostToMoveChips(int[] chips) {
    int cnt = 0;
    for (int i : chips)
        cnt += i % 2;
    return Math.min(cnt, chips.length - cnt);      
}

1218. 最长定差子序列

给你一个整数数组 arr 和一个整数 difference，请你找出 arr 中所有相邻元素之间的差等于给定 difference 的等差子序列，并返回其中最长的等差子序列的长度。
示例 1：
输入：arr = [1,2,3,4], difference = 1 输出：4 解释：最长的等差子序列是 [1,2,3,4]。 示例 2：
输入：arr = [1,3,5,7], difference = 1 输出：1 解释：最长的等差子序列是任意单个元素。 示例 3：
输入：arr = [1,5,7,8,5,3,4,2,1], difference = -2 输出：4 解释：最长的等差子序列是
[7,5,3,1]。
提示：
1 <= arr.length <= 10^5
-10^4 <= arr[i], difference <= 10^4
思路：简单的动态规划，dp[i] = dp[i - difference] + 1

public int longestSubsequence(int[] arr, int difference) {
    HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
    int res = 0;
    for (int i = 0;i < arr.length;i++) {
        Integer cnt = map.getOrDefault(arr[i] - difference, 0);
        map.put(arr[i], cnt + 1);
        res = Math.max(res, cnt + 1);
    }
    return res;              
}

1219. 黄金矿工 为了使收益最大化，

矿工需要按以下规则来开采黄金： 每当矿工进入一个单元，就会收集该单元格中的所有黄金。 矿工每次可以从当前位置向上下左右四个方向走。 每个单元格只能被开采（进入）一次。 不得开采（进入）黄金数目为 0 的单元格。
矿工可以从网格中 任意一个 有黄金的单元格出发或者是停止。
示例 1：
输入：grid = [[0,6,0],[5,8,7],[0,9,0]] 输出：24 解释： [[0,6,0], [5,8,7],
[0,9,0]] 一种收集最多黄金的路线是：9 -> 8 -> 7。 示例 2：
输入：grid = [[1,0,7],[2,0,6],[3,4,5],[0,3,0],[9,0,20]] 输出：28 解释：
[[1,0,7], [2,0,6], [3,4,5], [0,3,0], [9,0,20]] 一种收集最多黄金的路线是：1 -> 2
-> 3 -> 4 -> 5 -> 6 -> 7。
提示：
1 <= grid.length, grid[i].length <= 15 0 <= grid[i][j] <= 100 最多 25
个单元格中有黄金。
思路：暴力DFS，一发入魂

int[] dx = {1,-1,0,0};
int[] dy = {0,0,1,-1};
int res = 0;
public void dfs(int[][] grid,int i,int j,boolean[][] flag, int cur) {
    cur += grid[i][j];
    res = Math.max(res, cur);
    flag[i][j] = false;
    for (int d = 0;d < 4;d++) {
        if (i + dx[d] >= 0 && i + dx[d] < grid.length && j + dy[d] >=0 && j + dy[d] < grid[0].length) {
            if (flag[i + dx[d]][j + dy[d]]) {
                flag[i + dx[d]][j + dy[d]] = false;
                dfs(grid, i + dx[d], j + dy[d], flag, cur);
                flag[i + dx[d]][j + dy[d]] = true;
            }					
        }
    }
}
public int getMaximumGold(int[][] grid) {
    boolean[][] flag = new boolean[grid.length][grid[0].length];
    for (int i = 0;i < grid.length;i++) 
        for (int j = 0;j < grid[0].length;j++) 
            flag[i][j] = grid[i][j] > 0 ? true : false;
    for (int i = 0;i < grid.length;i++) {
        for (int j = 0;j < grid[0].length;j++) {
            if (grid[i][j] > 0) {
                flag[i][j] = false;
                dfs(grid, i, j, flag, 0);
                flag[i][j] = true;
            }
        }
    }			
    return res;	
}

1220. 统计元音字母序列的数目

给你一个整数 n，请你帮忙统计一下我们可以按下述规则形成多少个长度为 n 的字符串：
字符串中的每个字符都应当是小写元音字母（‘a’, ‘e’, ‘i’, ‘o’, ‘u’） 每个元音 ‘a’ 后面都只能跟着 ‘e’ 每个元音
‘e’ 后面只能跟着 ‘a’ 或者是 ‘i’ 每个元音 ‘i’ 后面 不能 再跟着另一个 ‘i’ 每个元音 ‘o’ 后面只能跟着 ‘i’
或者是 ‘u’ 每个元音 ‘u’ 后面只能跟着 ‘a’ 由于答案可能会很大，所以请你返回 模 10^9 + 7 之后的结果。
示例 1：
输入：n = 1 输出：5 解释：所有可能的字符串分别是：“a”, “e”, “i” , “o” 和 “u”。 示例 2：
输入：n = 2 输出：10 解释：所有可能的字符串分别是：“ae”, “ea”, “ei”, “ia”, “ie”, “io”,
“iu”, “oi”, “ou” 和 “ua”。 示例 3：
输入：n = 5 输出：68
提示：
1 <= n <= 2 * 10^4
思路：简单的动态规划思想，由于当前字母的来源是确定的，如a只可能来源于e、i、u结尾的字符串，我们只需要每次迭代地将可能的来源所拥有的字符串数目相加之和，赋值给当前字母状态，最后统计所有可能的状态之和就可以了。

int mod = 1000000007;
public int countVowelPermutation(int n) {
    if(n == 1) return 5;
    long[][] dp = new long[n + 1][5];
    //a : e
    //e ： a i
    //i : a e o u
    //o : i u
    //u : a
    Arrays.fill(dp[1], 1);
    long res = 0;
    for (int i = 2;i <= n;i++) {
        res = 0;
        dp[i][0] = (dp[i - 1][1] + dp[i - 1][2] + dp[i - 1][4]) % mod;
        dp[i][1] = (dp[i - 1][0] + dp[i - 1][2]) % mod;
        dp[i][2] = (dp[i - 1][1] + dp[i - 1][3]) % mod;
        dp[i][3] = dp[i - 1][2] % mod;
        dp[i][4] = (dp[i - 1][2] + dp[i - 1][3]) % mod;
    }
    for (int j = 0;j < 5;j++)
        res = (res + dp[n][j]) % mod;
    return (int)res % mod;
}