洛谷P15801、P14919、P1352、P2052

最新推荐文章于 2026-06-25 18:32:41 发布

原创最新推荐文章于 2026-06-25 18:32:41 发布 · 411 阅读

10 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#算法

P15801

题意

给定一棵包含 n 个结点的有根二叉树，结点依次以 1,2,…,n 编号，根结点编号为 1。

对于结点 i，其左儿子的编号记为 $l_{i}$ ，右儿子编号记为 $r_{i}$ 。特别地，如果左儿子不存在则 $l_{i}$ =0，如果右儿子不存在则 $r_{i}$ =0。

树中每个结点都对应一棵以其为根的子树。请你求出给定有根树的所有 n 棵子树中，有多少棵子树是完全二叉树。

输入格式

第一行，一个正整数 n，表示有根二叉树结点数量。

接下来 n 行，每行两个正整数 $l_{i},r_{i}$ ，表示结点 i 的左儿子编号和右儿子编号。

输出格式

输出一行，一个整数，表示所有子树中完全二叉树的数量。

思路

判断以u为根节点的二叉树是否为完全二叉树用“如果左子树和右子树高度一致，那么左子树是满二叉树且右子树是完全二叉树的是完全二叉树”和“如果左子树比右子树高一层，那么左子树是完全二叉树且右子树是满二叉树的是完全二叉树”。因此dp[u]表示为以u为根的二叉树是什么，0表示啥也不是，1表示不是满二叉树的完全二叉树，2表示是满二叉树。

代码

#include<bits/stdc++.h>
using namespace std;
struct node{
    int l;
    int r;
}a[100005];
long long n, ans = 0;
long long dp[100005], h[100005];
void dfs(long long u, long long depth){
    h[u] = depth;
    dp[u] = 0;
    if (a[u].l){
        dfs(a[u].l, depth + 1);
        h[u] = max(h[u], h[a[u].l]);
    }
    if (a[u].r){
        dfs(a[u].r, depth + 1);
        h[u] = max(h[u], h[a[u].r]);
    }
    if (a[u].l == 0 && a[u].r == 0){
        dp[u] = 2;
    }
    else if (a[u].l == 0 && a[u].r){
        dp[u] = 0;
    }
    else if (a[u].l && a[u].r == 0 && h[a[u].l] == depth + 1){
        dp[u] = 1;
    }
    else if (h[a[u].l] == h[a[u].r]){
        if (dp[a[u].l] == 2 && dp[a[u].r] == 2){
            dp[u] = 2;
        }
        else if (dp[a[u].l] == 2 && dp[a[u].r] == 1){
            dp[u] = 1;
        }
    }
    else if (h[a[u].l] == h[a[u].r] + 1){
        if (dp[a[u].l] > 0 && dp[a[u].r] == 2){
            dp[u] = 1;
        }
    }
    ans += (dp[u] > 0);
}
int main(){
    cin >> n;
    for (long long i = 1; i <= n; i++){
        cin >> a[i].l >> a[i].r;
    }
    dfs(1, 1);
    cout << ans;
    return 0;
}

P14919

题意

给定一棵有 n 结点的有根树 T，结点依次以 1,2,…,n 编号，根结点编号为 1。方便起见，编号为 i 的结点称为结点 i。

初始时 T 中的结点均为白色。你需要将 T 中的若干个结点染为黑色，使得所有叶子到根的路径上至少有一个黑色结点。将结点 i 染为黑色需要代价 $c_{i}$ ，你需要在满足以上条件的情况下，最小化染色代价之和。

叶子是指 T 中没有子结点的结点。

输入格式

第一行，一个正整数 n，表示结点数量。

第二行，n−1 个正整数 $f_{2},f_{3},...,f_{n}$ ，其中 $f_{i}$ 表示结点 i 的父结点的编号，保证 $f_{i}< i$ 。

第三行，n 个正整数 $c_{1},c_{2},...,c_{n}$ ，其中 $c_{i}$ 表示将结点 i 染为黑色所需的代价。

输出格式

一行，一个整数，表示在满足所有叶子到根的路径上至少有一个黑色结点的前提下，染色代价之和的最小值。

思路

不是二叉树，所以用动态数组 $t_{i}$ （t随便一个名称）存储i节点的子节点。DFS（深度优先搜索）遍历，dp[u]表示在以u为根的二叉树中，保证所有叶子到根的路径上至少有一个黑色结点需要的最少代价。
状态转移方程（伪代码，v为子节点）：dp[u] = max(sum{dp[v]}, c[u]);

代码

#include<bits/stdc++.h>
using namespace std;
int n;
long long c[100005], f;
long long dp[100005];
vector<int> t[100005];
void dfs(int u){
    for (long long i = 0; i < t[u].size(); i++){
        dfs(t[u][i]);
        dp[u] += dp[t[u][i]];
    }
    dp[u] = min(dp[u], c[u]);
    if (dp[u] == 0){
        dp[u] = c[u];
    }
}
int main(){
    cin >> n;
    for (int i = 2; i <= n; i++){
        cin >> f;
        t[f].push_back(i);
    }
    for (int i = 1; i <= n; i++){
        cin >> c[i];
    }
    dfs(1);
    cout << dp[1];
    return 0;
}

P1352

题意

某大学有 n 个职员，编号为 1…n。

他们之间有从属关系，也就是说他们的关系就像一棵以校长为根的树，父结点就是子结点的直接上司。

现在有个周年庆宴会，宴会每邀请来一个职员都会增加一定的快乐指数 $r_{i}$ ，但是呢，如果某个职员的直接上司来参加舞会了，那么这个职员就无论如何也不肯来参加舞会了。

所以，请你编程计算，邀请哪些职员可以使快乐指数最大，求最大的快乐指数。

输入格式

输入的第一行是一个整数 n。

第 2 到第 (n+1) 行，每行一个整数，第 (i+1) 行的整数表示 i 号职员的快乐指数 ri。

第 (n+2) 到第 2n 行，每行输入一对整数 l,k，代表 k 是 l 的直接上司。

输出格式

输出一行一个整数代表最大的快乐指数。

思路

dp[u][0/1]表示第u个职员参加/不参加，状态转移方程（伪代码，v为子节点）：
dp[u][0] = sum{max(dp[v][0], dp[v][1])};
dp[u][1] = sum{dp[v][0]} + r[u];

代码

#include<bits/stdc++.h>
using namespace std;
int n;
int a, b, sum;
int dp[6005][2], r[6005], v[6005];
vector<int> f[6005];
void dfs(int u){
    int s1 = 0, s2 = 0;
    for (int i = 0; i < f[u].size(); i++){
        int v = f[u][i];
        dfs(v);
        s1 += max(dp[v][0], dp[v][1]);
        s2 += dp[v][0];
    }
    dp[u][0] = s1;
    dp[u][1] = s2 + r[u];
}
int main(){
    cin >> n;
    for (int i = 1; i <= n; i++){
        cin >> r[i];
    }
    for (int i = 1; i < n; i++){
        cin >> a >> b;
        f[b].push_back(a);
        v[a] = b;
    }
    for (int i = 1; i <= n; i++){
        if (v[i] == 0){
            sum = i;
            break;
        }
    }
    dfs(sum);
    cout << max(dp[sum][0], dp[sum][1]);
    return 0;
}

P2052

题意

在 W 星球上有 n 个国家。为了各自国家的经济发展，他们决定在各个国家之间建设双向道路使得国家之间连通。但是每个国家的国王都很吝啬，他们只愿意修建恰好 n−1 条双向道路。

每条道路的修建都要付出一定的费用，这个费用等于道路长度乘以道路两端的国家个数之差的绝对值。例如，在下图中，虚线所示道路两端分别有 2 个、4 个国家，如果该道路长度为 1，则费用为 $1\times \left | 2-4 \right |= 2$ 。图中圆圈里的数字表示国家的编号。

由于国家的数量十分庞大，道路的建造方案有很多种，同时每种方案的修建费用难以用人工计算，国王们决定找人设计一个软件，对于给定的建造方案，计算出所需要的费用。请你帮助国王们设计一个这样的软件。

输入格式

输入的第一行包含一个整数 n，表示 W 星球上的国家的数量，国家从 1 到 n 编号。

接下来 n−1 行描述道路建设情况，其中第 i 行包含三个整数 $a_{i}$ ， $b_{i}$ 和 $c_{i}$ ，表示第 i 条双向道路修建在 $a_{i}$ 与 $b_{i}$ 两个国家之间，长度为 $c_{i}$ 。

输出格式

输出一个整数，表示修建所有道路所需要的总费用。

思路

根据道路只有n-1条，所以这是一个树，暂且以1为根节点，dfs遍历以每一个节点为根的树的节点数，可以算出其他节点数，以此算出总费用。

代码

#include<bits/stdc++.h>
using namespace std;
long long n, a, b, c, ans = 0;
long long dp[1000005];
vector<pair<long long, long long>> g[1000005];
void dfs(long long u, long long fa){
    dp[u] = 1;
	for (long long i = 0; i < g[u].size(); i++){
        long long v = g[u][i].first;
        long long w = g[u][i].second;
        if (v == fa){
            continue;
        }
        dfs(v, u);
        dp[u] += dp[v];
        ans += w * abs((n - dp[v]) - dp[v]);
    }
}
int main(){
    cin >> n;
    for (long long i = 1; i < n; i++){
        cin >> a >> b >> c;
        g[a].push_back({b, c});
        g[b].push_back({a, c});
    }
    dfs(1, 0);
    cout << ans;
    return 0;
}