365天挑战LeetCode1000题——Day 094 拆炸弹王位继承顺序循环码排列最少侧跳次数

本文链接：https://blog.youkuaiyun.com/ShowMeTheCod3/article/details/127022193

1652. 拆炸弹

在这里插入图片描述

代码实现（模拟）

class Solution {
public:
    vector<int> decrypt(vector<int>& code, int k) {
        int n = code.size();
        vector<int> ans(n);
        if (k == 0) return ans;
        for (int i = 0; i < n; i++) {
            int tmp = 0;
            int m = i;
            if (k > 0) {
                m = (m + 1) % n;
                tmp = 0;
                for (int j = 0; j < k; j++) {
                    tmp += code[m];
                    m = (m + 1) % n;
                }
                ans[i] = tmp;
            }
            else {
                m = (m - 1 + n) % n;
                tmp = 0;
                for (int j = 0; j > k; j--) {
                    tmp += code[m];
                    m = (m - 1 + n) % n;
                }
                ans[i] = tmp;
            }
        }
        return ans;
    }
};

1600. 王位继承顺序

在这里插入图片描述

代码实现（dfs）

class ThroneInheritance {
private:
    set<string> isDead;
    map<string, vector<string>> children;
    string kingName;
public:
    ThroneInheritance(string kingName) {
        this->kingName = kingName;
    }
    
    void birth(string parentName, string childName) {
        children[parentName].push_back(childName);
    }
    
    void death(string name) {
        isDead.emplace(name);
    }
    
    void dfs(string curName, vector<string>& ans) {
        if (!isDead.count(curName)) ans.push_back(curName);
        for (string childName : children[curName]) {
            dfs(childName, ans);
        }
    }

    vector<string> getInheritanceOrder() {
        vector<string> ans;
        dfs(kingName, ans);
        return ans;
    }
};

/**
 * Your ThroneInheritance object will be instantiated and called as such:
 * ThroneInheritance* obj = new ThroneInheritance(kingName);
 * obj->birth(parentName,childName);
 * obj->death(name);
 * vector<string> param_3 = obj->getInheritanceOrder();
 */

1238. 循环码排列

在这里插入图片描述

代码实现（格雷码）

class Solution {
public:
    vector<int> circularPermutation(int n, int start) {
        vector<int> g(1 << n);    // 分配空间
        for(int i = 0; i < (1 << n); ++i)
            g[i] = i ^ (i >> 1) ^ start;  // 第i个新格雷码为原格雷码异或start
        return g;
    }
};

1824. 最少侧跳次数

在这里插入图片描述

代码实现（dp）

class Solution {
private:
    const int MAX = 10000001;
public:
    int minSideJumps(vector<int>& obstacles) {
        int n = obstacles.size();
        vector<vector<int>> dp(4, vector<int>(n));
        dp[1][0] = MAX;
        dp[2][0] = 0;
        dp[3][0] = MAX;
        for (int i = 1; i < n; i++) {
            dp[1][i] = min(dp[1][i - 1], min(dp[2][i - 1] + 1 +
            (obstacles[i] == 2 && obstacles[i - 1] == 1),
            dp[3][i - 1] + 1 + (obstacles[i] == 3 && obstacles[i - 1] == 1)));
            dp[2][i] = min(dp[2][i - 1], min(dp[1][i - 1] + 1 +
            (obstacles[i] == 1 && obstacles[i - 1] == 2),
            dp[3][i - 1] + 1 + (obstacles[i] == 3 && obstacles[i - 1] == 2)));
            dp[3][i] = min(dp[3][i - 1], min(dp[1][i - 1] + 1 +
            (obstacles[i] == 1 && obstacles[i - 1] == 3),
            dp[2][i - 1] + 1) + (obstacles[i] == 2 && obstacles[i - 1] == 3));
            dp[obstacles[i]][i] = MAX;
            // for (int j = 1; j < 4; j++) {
            //     cout << dp[j][i] << " ";
            // }
            // cout << endl;
        }
        return min(dp[1][n - 1], min(dp[2][n - 1], dp[3][n - 1]));
    }
};