LeetCode周赛157

1217. Play with Chips

奇数移动cost1，偶数移动cost0

class Solution {
public:
    int cnt[2];
    int minCostToMoveChips(vector<int>& chips) {
        for (int i = 0; i < chips.size(); i++)
            cnt[chips[i] & 1]++;
        return min(cnt[0],cnt[1]);
    }
};

1218. Longest Arithmetic Subsequence of Given Difference

最长等差子序列，dp

class Solution {
public:
    
    int longestSubsequence(vector<int>& arr, int difference) {
        unordered_map<int, int>dp;
        int re = 0;
        for (int i = 0; i < arr.size(); i++) {
            dp[arr[i]] = max(1, dp[arr[i] - difference] + 1);
            re = max(re, dp[arr[i]]);
        }
        return re;
    }
};

1219. Path with Maximum Gold

回溯最大金矿数，dfs + backtracking
这里不用标记也可以，直接把已访问grid置0，再恢复

class Solution {
public:
    int re = 0;

    bool marked[16][16];
    int getMaximumGold(vector<vector<int>>& grid) {
        for (int i = 0; i < grid.size(); i++) {
            for (int j = 0; j < grid[0].size(); j++) {
                if (grid[i][j] != 0)
                    dfs(i, j, 0,grid);
            }
        }
        return re;
    }
    void dfs(int i, int j, int v,vector<vector<int>>& grid) {
        v = v + grid[i][j];
        re = max(re, v);
        marked[i][j] = true;
        if (i + 1 < grid.size() && marked[i + 1][j] == false && grid[i + 1][j] != 0)
            dfs(i +1, j, v,grid);
        if (j + 1 < grid[0].size() && marked[i][j + 1] == false && grid[i][j + 1] != 0)
            dfs(i, j + 1, v, grid);
        if (i - 1 >= 0 && marked[i - 1][j] == false && grid[i - 1][j] != 0)
            dfs(i - 1, j, v, grid);
        if (j - 1 >= 0 && marked[i][j - 1] == false && grid[i][j - 1] != 0)
            dfs(i, j - 1, v, grid);
        marked[i][j] = false;
    }
};

1220. Count Vowels Permutation

统计由该规则下序列个数，可见每个字母前导是有限制的，因此dp，万物皆可dp→ →

const int maxn = 1e9 + 7;
class Solution {
public:
    long long dp[5], pre[5];
    int countVowelPermutation(int n) {
        for (int i = 0; i < 5; i++)
            pre[i] = 1;
        for (int i = 1; i < n; i++) {
            dp[0] = (pre[1] + pre[2] + pre[4]) % maxn;
            dp[1] = (pre[0] + pre[2]) % maxn;
            dp[2] = (pre[1] + pre[3]) % maxn;
            dp[3] = pre[2];
            dp[4] = (pre[3] + pre[2]) % maxn;
            for (int j = 0; j < 5; j++)
                pre[j] = dp[j];
        }
        return (pre[0] + pre[1] + pre[2] + pre[3] + pre[4]) % maxn;
    }
};