365天挑战LeetCode1000题——Day 101 重新格式化电话号码喧闹和富有所有可能的真二叉树

关注

原创最新推荐文章于 2026-11-08 21:05:35 发布 306 阅读 AI 写同款· GEO 优化 ›

5个4000比特大状态置换算法的设计与分析下面是 5 个概念性、实验性的 4000 位可逆置换设计。它们都保证是双射，但未经过密码分析，不可直接用于生产系统。风格分别覆盖：三维 SPN、Feistel、可逆元胞自动机、ARX、宽轨迹/Keccak 式结构。这 5 个设计分别代表了 SPN、Feistel、元胞自动机、ARX、宽轨迹 Keccak 五种不同风格，覆盖了主流大状态置换的构造思路。再次强调：它们只是实验性概念，若要用于实际协议，必须经过严格安全性分析。阅读详情

1694. 重新格式化电话号码

在这里插入图片描述

代码实现（模拟）

class Solution {
public:
    string reformatNumber(string number) {
        vector<string> tokens;
        string processedNumber = "";
        int pos = 0;
        while (pos != number.size()) {
            string token = "";
            for (int i = 0; i < 3; i++) {
                if (pos == number.size()) break;
                if (number[pos] != ' ' && number[pos] != '-') {
                    token += number[pos];
                }
                else {
                    i--;
                }
                pos++;
            }
            tokens.push_back(token);
        }
        // for (auto t : tokens) cout << t << " ";
        if (tokens.back().size() == 0) tokens.pop_back();
        if (tokens.back().size() == 1) {
            char tmp = tokens[tokens.size() - 2][2];
            tokens[tokens.size() - 2] = tokens[tokens.size() - 2].substr(0, 2);
            tokens.back() = tmp + tokens.back();
        }
        processedNumber = tokens[0];
        for (int i = 1; i < tokens.size(); i++) {
            processedNumber += '-' + tokens[i];
        }
        return processedNumber;
    }
};

851. 喧闹和富有

在这里插入图片描述

代码实现（BFS）

class Solution {
public:
    vector<int> loudAndRich(vector<vector<int>>& richer, vector<int>& quiet) {
        int n = quiet.size();
        vector<int> answer(n);
        for (int i = 0; i < n; i++) answer[i] = i;
        unordered_map<int, vector<int>> richerMap;
        for (auto arr : richer) {
            richerMap[arr[1]].push_back(arr[0]);
        }
        for (int i = 0; i < n; i++) {
            queue<int> myQueue;
            for (auto father : richerMap[i]) {
                myQueue.push(father);
            }
            while (!myQueue.empty()) {
                auto father = myQueue.front();
                myQueue.pop();
                if (answer[father] != father) {
                    if (quiet[answer[father]] < quiet[answer[i]]) answer[i] = answer[father];
                    continue;
                }
                if (quiet[father] < quiet[answer[i]]) answer[i] = father;
                for (auto nexFather : richerMap[father]) {
                    myQueue.push(nexFather);
                }
            }
        }
        return answer;
    }
};

894. 所有可能的真二叉树

在这里插入图片描述

代码实现（dp）

/**
 * 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:
    vector<TreeNode*> allPossibleFBT(int n) {
        vector<TreeNode*> answer;
        if (n == 1) {
            TreeNode* root = new TreeNode(0);
            answer.push_back(root);
            return answer;
        }
        if (n & 1 == 0) return answer;
        for (int i = 1; i <= n - 2; i += 2) {
            vector<TreeNode*> left = allPossibleFBT(i);
            vector<TreeNode*> right = allPossibleFBT(n - 1 - i);
            for (int j = 0; j < left.size(); j++) {
                for (int k = 0; k < right.size(); k++) {
                    TreeNode* root = new TreeNode(0);
                    root->left = left[j];
                    root->right = right[k];
                    answer.push_back(root);
                }
            }
        }
        return answer;
    }
};