0711#b站模拟题

1.小红的区间翻转（out of time 71.4%）

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int count_flips(vector<int>& a, vector<int>& b) {
    int n = a.size();
    int l = 0, r = n - 1;

    while (l < n && a[l] == b[l]) {
        l++;
    }
    while (r >= 0 && a[r] == b[r]) {
        r--;
    }

    if (l >= r) {
        return 1;
    }

    int count = 0;

    for (int i = 0; i <= l; ++i) {
        for (int j = r; j < n; ++j) {
            vector<int> temp = a;
            reverse(temp.begin() + i, temp.begin() + j + 1);
            if (temp == b) {
                ++count;
            }
        }
    }

    return count;
}

int main() {
    int n;
    cin >> n;

    vector<int> a(n), b(n);
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }
    for (int i = 0; i < n; ++i) {
        cin >> b[i];
    }

    cout << count_flips(a, b) << endl;

    return 0;
}

2.两个字符串的最小 ASCII 删除总和

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

int minASCIIDeleteSum(string s1, string s2) {
    int m = s1.length();
    int n = s2.length();
    vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));

    for (int i = 1; i <= m; ++i) {
        dp[i][0] = dp[i-1][0] + s1[i-1];
    }
    for (int j = 1; j <= n; ++j) {
        dp[0][j] = dp[0][j-1] + s2[j-1];
    }

    for (int i = 1; i <= m; ++i) {
        for (int j = 1; j <= n; ++j) {
            if (s1[i-1] == s2[j-1]) {
                dp[i][j] = dp[i-1][j-1];
            } else {
                dp[i][j] = min(dp[i-1][j] + s1[i-1], dp[i][j-1] + s2[j-1]);
            }
        }
    }

    return dp[m][n];
}

int main() {
    string s1, s2;
    cin >> s1 >> s2;

    cout << minASCIIDeleteSum(s1, s2) << endl;

    return 0;
}

3.最长同值路径

#include <iostream>
#include <vector>
#include <queue>
#include <sstream>
#include <string>
#include <algorithm>

using namespace std;

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

TreeNode* deserialize(const vector<string>& data) {
    if (data.empty() || data[0] == "null") return NULL;

    TreeNode* root = new TreeNode(stoi(data[0]));
    queue<TreeNode*> q;
    q.push(root);
    int i = 1;
    while (!q.empty() && i < data.size()) {
        TreeNode* node = q.front();
        q.pop();
        if (data[i] != "null") {
            node->left = new TreeNode(stoi(data[i]));
            q.push(node->left);
        }
        i++;
        if (i < data.size() && data[i] != "null") {
            node->right = new TreeNode(stoi(data[i]));
            q.push(node->right);
        }
        i++;
    }
    return root;
}

int longestUnivaluePathHelper(TreeNode* node, int& maxLen) {
    if (!node) return 0;
    int leftLen = longestUnivaluePathHelper(node->left, maxLen);
    int rightLen = longestUnivaluePathHelper(node->right, maxLen);
    int leftPath = 0, rightPath = 0;
    if (node->left && node->left->val == node->val) {
        leftPath = leftLen + 1;
    }
    if (node->right && node->right->val == node->val) {
        rightPath = rightLen + 1;
    }
    maxLen = max(maxLen, leftPath + rightPath);
    return max(leftPath, rightPath);
}

int longestUnivaluePath(TreeNode* root) {
    int maxLen = 0;
    longestUnivaluePathHelper(root, maxLen);
    return maxLen;
}

int main() {
    int n;
    cin >> n;
    vector<string> data(n);
    for (int i = 0; i < n; ++i) {
        cin >> data[i];
    }

    TreeNode* root = deserialize(data);
    cout << longestUnivaluePath(root) << endl;

    return 0;
}