A.

#include <bits/stdc++.h>
using namespace std;
int minInsertions(string s) {
    int n = s.size();
    vector<vector<int>> dp(n, vector<int>(n, 0));
    for (int len = 2; len <= n; len ++ )
        for (int i = 0; i <= n - len; i ++ ) {
            int j = i + len - 1;
            if (s[i] == s[j]) dp[i][j] = dp[i + 1][j - 1];
            else dp[i][j] = min(dp[i + 1][j], dp[i][j - 1]) + 1;
        }
    return dp[0][n - 1];
}
int main() {
    string s;
    cin >> s;
    cout << minInsertions(s);
    return 0;
}

B.

#include <bits/stdc++.h>
using namespace std;
int Indfggfsa = 0x3f3f3f3f;
deque<int> vec;
int n;
bool flag = 0;
void dfs(int sumA, int sumB, int k) {
    if (k == n) {
        if (sumA >= sumB) flag = 1;
        return;
    }
    if (k % 2 == 0) {
        int cfront = vec[0], cback = vec[vec.size() - 1];
        vec.pop_front();
        dfs(sumA + cfront, sumB, k + 1);
        vec.push_front(cfront);
        vec.pop_back();
        dfs(sumA + cback, sumB, k + 1);
        vec.push_back(cback);
    } else {
        int cfront = vec[0], cback = vec[vec.size() - 1];
        if (cfront > cback) {vec.pop_front(); dfs(sumA, sumB + cfront, k + 1); vec.push_front(cfront);}
        else {vec.pop_back(); dfs(sumA, sumB + cback, k + 1); vec.push_back(cback);}
    }
}
int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(nullptr);
    cin >> n;
    for (int i = 0; i < n; i ++ ) {
        int x;
        cin >> x;
        vec.push_back(x);
    }
    dfs(0, 0, 0);
    cout << (flag ? "true" : "false");
    return 0;
}

C.

#include <bits/stdc++.h>
using namespace std;
int minScoreTriangulation(vector<int>& values) {
    int n = values.size();
    vector<vector<int>> dp(n, vector<int>(n, 0));
    for (int length = 2; length < n; length ++ )
        for (int i = 0; i + length < n; i ++ ) {
            int j = i + length;
            dp[i][j] = INT_MAX;
            for (int k = i + 1; k < j; k ++ ) dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j] + values[i] * values[k] * values[j]);
        }
    return dp[0][n - 1];
}
int main() {
    int n;
    cin >> n;
    vector<int> values(n);
    for (int i = 0; i < n; i ++ ) cin >> values[i];
    cout << minScoreTriangulation(values);
    return 0;
}

D.

#include <bits/stdc++.h>
using namespace std;
int minCost(int n, vector<int>& cuts) {
    cuts.push_back(0);
    cuts.push_back(n);
    sort(cuts.begin(), cuts.end());
    int m = cuts.size();
    vector<vector<int>> dp(m, vector<int>(m, 0));
    for (int len = 2; len < m; len ++ )
        for (int i = 0; i + len < m; i ++ ) {
            int j = i + len;
            dp[i][j] = INT_MAX;
            for (int k = i + 1; k < j; k ++ ) dp[i][j] = min(dp[i][j], cuts[j] - cuts[i] + dp[i][k] + dp[k][j]);
        }
    return dp[0][m - 1];
}
int main() {
    int n, m;
    cin >> n >> m;
    vector<int> cuts(m);
    for (int i = 0; i < m; i ++ ) cin >> cuts[i];
    cout << minCost(n, cuts);
    return 0;
}

E.

#include <bits/stdc++.h>
using namespace std;
int maxCoins(vector<int>& nums) {
    int n = nums.size();
    vector<vector<int>> dp(n + 2, vector<int>(n + 2, 0));
    vector<int> balloons(n + 2, 1);
    for (int i = 1; i <= n; i ++ ) balloons[i] = nums[i - 1];
    for (int len = 1; len <= n; len ++ )
        for (int i = 1; i <= n - len + 1; i ++ ) {
            int j = i + len - 1;
            for (int k = i; k <= j; k ++ ) dp[i][j] = max(dp[i][j], balloons[i - 1] * balloons[k] * balloons[j + 1] + dp[i][k - 1] + dp[k + 1][j]);
        }
    return dp[1][n];
}
int main() {
    int n;
    cin >> n;
    vector<int> nums(n);
    for (int i = 0; i < n; i ++ ) cin >> nums[i];
    cout << maxCoins(nums);
    return 0;
}

I.

#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> adj;
vector<int> color;
vector<unordered_set<int>> subtree_colors;
vector<int> result;
void dfs(int u, int parent) {
    subtree_colors[u].insert(color[u]);
    for (int v : adj[u]) {
        if (v == parent) continue;
        dfs(v, u);
        if (subtree_colors[u].size() < subtree_colors[v].size()) swap(subtree_colors[u], subtree_colors[v]);
        for (int c : subtree_colors[v]) subtree_colors[u].insert(c);
    }
    result[u] = subtree_colors[u].size();
}
int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    int n;
    cin >> n;
    color.resize(n + 1);
    for (int i = 1; i <= n; i ++ ) cin >> color[i];
    adj.resize(n + 1);
    for (int i = 0; i < n - 1; i ++ ) {
        int a, b;
        cin >> a >> b;
        adj[a].push_back(b);
        adj[b].push_back(a);
    }
    subtree_colors.resize(n + 1);
    result.resize(n + 1);
    dfs(1, -1);
    for (int i = 1; i <= n; i ++ ) cout << result[i] << " ";
    return 0;
}

J.

#include <bits/stdc++.h>
using namespace std;
const int N = 5010;
string a, b;
int f[N][N], n, m;
int main() {
    ios_base::sync_with_stdio(0);
    cin >> a >> b;
    n = a.size();
    m = b.size();
    for(int i = 0; i <= m; i ++ ) f[0][i] = i; 
    for(int i = 0; i <= n; i ++ ) f[i][0] = i; 
    for(int i = 1; i <= n; i ++ )
        for(int j = 1; j <= m; j ++ ) {
            f[i][j] = min(f[i - 1][j] + 1, f[i][j - 1] + 1);
            if(a[i - 1] == b[j - 1]) f[i][j] = min(f[i][j], f[i - 1][j - 1]);
            else f[i][j] = min(f[i][j], f[i - 1][j - 1] + 1);
        }
    cout << f[n][m];
    return 0;
}

L.

 #include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, x, h[N], s[N], dp[N], ans;
int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> n >> x;
    for (int i = 1; i <= n; i ++ ) cin >> h[i];
    for (int i = 1; i <= n; i ++ ) cin >> s[i];
    for (int i = 1; i <= n; i ++ )
        for (int j = x; j >= h[i]; j -- )
            dp[j] = max(dp[j], dp[j - h[i]] + s[i]);
    for (int j = x; j >= 0; j -- ) ans = max(ans, dp[j]);
    cout << ans;
    return 0;
}

M.

#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int main() {
    int n;
    cin >> n;
    vector<vector<char>> a(n, vector<char>(n));
    for (int i = 0; i < n; i ++ )
        for (int j = 0; j < n; j ++ ) cin >> a[i][j];
    vector<vector<int>> dp(n, vector<int>(n, 0));
    dp[0][0] = (a[0][0] == '.') ? 1 : 0;
    for (int i = 1; i < n; i ++ ) {
        if (a[i][0] == '.') dp[i][0] = dp[i - 1][0];
        else dp[i][0] = 0;
    }
    for (int j = 1; j < n; j ++ ) {
        if (a[0][j] == '.') dp[0][j] = dp[0][j - 1];
        else dp[0][j] = 0;
    }
    for (int i = 1; i < n; i ++ ) {
        for (int j = 1; j < n; j ++ ) {
            if (a[i][j] == '.') dp[i][j] = (dp[i - 1][j] + dp[i][j - 1]) % MOD;
            else dp[i][j] = 0;
        }
    }
    cout << dp[n - 1][n - 1];
    return 0;
}

—— 本文来自火龙信奥（义乌睿码科技）：义乌青少年信息学奥赛与编程教育平台，专注 CSP-J/S、NOIP、GESP 竞赛培训，线上线下融合教学，助力编程升学。网址：hlcoding.com