LeetCode---2021/8/24

K站中转内最便宜的航班

分析：
  动态规划：令dp[i][j]表示从src开始，经过i站（包括src）到达j的最短距离，根据题意，最多可以经过k + 1站，因此我们最终要求的是dp[1][dst]到dp[k + 1][dst]中的最小值。
  边界条件：因为初始时就位于src，所以经过0站就能到达src，且距离为0，即：dp[0][src]=0。
  转移方程：如果存在一条边x->y，则dp[t][y] = min(dp[t][y], dp[t-1][x] + cost)，也就是说经过t站到达y的最短距离，就等于经过t-1站到达x的最短距离再加上x->y的cost。
代码：

class Solution {
private:
    const int MAX = 1e6 + 5;
public:
    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int k) {
        vector<vector<int>> dp(k + 2, vector<int>(n, MAX));//最多经过k + 1站
        dp[0][src] = 0;
        for(int t = 1; t <= k + 1; t++) {
            for(vector<int>& x : flights){
                int st = x[0], ed = x[1], cost = x[2];
                dp[t][ed] = min(dp[t][ed], dp[t - 1][st] + cost);
            }
        }
        int res = MAX;
        for(int t = 1; t <= k + 1; t++) {
            res = min(res, dp[t][dst]);
        }
        return res == MAX ? -1 : res;
    }
};

生命游戏

分析：
  简单模拟，注意由于出生和死亡是同时发生的，所以需要一个辅助矩阵保存一开始的状态。
代码：

class Solution {
private:
    int dirs[8][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}, {-1, -1},{-1, 1}, {1, -1}, {1, 1}};
    int get(vector<vector<int>>& board, int i, int j) {
        int n = board.size(), m = board[0].size();
        int cnt = 0;
        for(int k = 0; k < 8; k++) {
            int x = i + dirs[k][0];
            int y = j + dirs[k][1];
            if(x >= 0 && x < n && y >= 0 && y < m) {
                if(board[x][y]) {
                    cnt++;
                }
            }
        }
        return cnt;
    }
public:
    void gameOfLife(vector<vector<int>>& board) {
        int n = board.size(), m = board[0].size();
        vector<vector<int>> temp;
        temp.assign(board.begin(), board.end());
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < m; j++) {
                int cnt = get(temp, i, j);
                if(board[i][j]) {
                    if(cnt < 2 || cnt > 3) {
                        board[i][j] = 0;
                    }
                }else {
                    if(cnt == 3) {
                        board[i][j] = 1;
                    }
                }
            }
        }
    }
};

二叉树的所有路径

分析：
  深度优先搜索。
代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void dfs(TreeNode* root, vector<string>& res, string path) {
        if(root) {
            path += to_string(root->val);
            if(root->left == NULL && root->right == NULL) {
                res.push_back(path);
            }else {
                path += "->";
                dfs(root->left, res, path);
                dfs(root->right, res, path);
            }
        }
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> res;
        string path = "";
        dfs(root, res, path);
        return res;
    }
};

删除链表中的节点

分析：
  由于没法得到待删除结点的前一个结点，所以不能使用传统方法进行删除。由于待删除结点不是最后一个结点，因此我们可以将待删除结点的下一个结点的val和next赋给待删除结点，这样遍历的时候就相当于该结点被删除了。
代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void deleteNode(ListNode* node) {
        node->val = (node->next)->val;
        node->next = node->next->next;
        //free(t);
    }
};

完全二叉树的节点个数

分析：
  简单dfs。
代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int cnt = 0;
    void dfs(TreeNode* root) {
        if(root) {
            cnt++;
            dfs(root->left);
            dfs(root->right);
        }
    }
    int countNodes(TreeNode* root) {
        dfs(root);
        return cnt;
    }
};

快乐数

分析：
  难点在于怎么确定该数不是快乐数，如果一个数不是快乐数，那么在上述变换过程中一定会出现循环，也就是1->2->3->2->3…这种情况。因此可以用一个集合维护当前的值，如果出现重复说明该数永远不可能变为1。
代码：

class Solution {
public:
    int get(int n) {
        int sum = 0;
        while(n) {
            int x = n % 10;
            sum += x * x;
            n /= 10;
        }
        return sum;
    }
    bool isHappy(int n) {
        set<int> st;
        st.insert(n);
        while(true) {
            n = get(n);
            if(n == 1) {
                return true;
            }
            if(st.count(n)) {
                return false;
            }else {
                st.insert(n);
            }
        }
        return true;
    }
};

两个数组的交集

分析：
  遍历判断即可。
代码：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int> res;
        set<int> st;
        for(auto x : nums1) {
            if(find(nums2.begin(), nums2.end(), x) != nums2.end()) {
                if(st.count(x) == 0) {
                    res.push_back(x);
                    st.insert(x);
                }
            }
        }
        return res;
    }
};