1、树的最长路径(树的直径)
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 10010, M = N * 2, INF = 0x3f3f3f3f;
int n;
int h[N], e[M], w[M], ne[M], idx;
//d1表示向下走的最长路径 d2表示向下走的次长路径 up表示向上走的最长路径
//p1存储最大值和次大值是从哪个边上来的 需要判断父节点的最长边是不是从当前子树上来的
int d1[N], d2[N], p1[N], up[N];
//当某个节点是叶子节点的时候 记为true
bool is_leaf[N];
void add(int a, int b, int c)
{
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}
//向下dfs
int dfs_d(int u, int father)
{
//求最长距离和次长距离,其中次长距离是为祥上深搜做准备的
d1[u] = d2[u] = -INF;
for (int i = h[u]; i != -1; i = ne[i])
{
int j = e[i];
if (j == father) continue;
//dfs_d(1,7) p1[1]=2;
int d = dfs_d(j, u) + w[i];
//对于父节点由很多个子节点,一个子节点对应一个d
//d1[u] 是对父节点而言,所有子节点中最大的d
//d2[u] 是对父节点而言,所有子节点中次大的d
if (d >= d1[u])
{
d2[u] = d1[u], d1[u] = d;
//u是父节点,j是子节点。对于父节点,最长距离是由哪个子节点产生的
p1[u] = j;
}
else if (d > d2[u]) d2[u] = d;
}
//是一个叶子节点
if (d1[u] == -INF)
{
d1[u] = d2[u] = 0;
is_leaf[u] = true;
}
//返回最长路径的长度
return d1[u];
}
//向上dfs
void dfs_u(int u, int father)
{
for (int i = h[u]; i != -1; i = ne[i])
{
int j = e[i];
if (j == father) continue;
//1.dfs_u中处理向下走
//p1[u]=j 记录的是再dfs_d中
//在父节点u处的最长路径是从j这个子节点过来的
//因此在dfs_u中不能与dfs_d重复 则只能从次大值和up[u]更新
if (p1[u] == j) up[j] = max(up[u], d2[u]) + w[i];
else up[j] = max(up[u], d1[u]) + w[i];
//2.dfs_u中处理向上走
dfs_u(j, u);
}
}
int main()
{
cin >> n;
memset(h, -1, sizeof h);
for (int i = 0; i < n - 1; i ++ )
{
int a, b, c;
cin >> a >> b >> c;
add(a, b, c), add(b, a, c);
}
//将1号节点定义为根节点
//向下走的最长距离和次长距离
dfs_d(1, -1);
//向上走的最长距离
dfs_u(1, -1);
//枚举每一个点
//根节点向下走,叶子节点向上走。
int res = d1[1];
for (int i = 2; i <= n; i ++ )
if (is_leaf[i]) res = min(res, up[i]);
else res = min(res, max(d1[i], up[i]));
printf("%d\n", res);
return 0;
}
2、树的中心
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 10010, M = N * 2, INF = 0x3f3f3f3f;
int n;
int h[N], e[M], w[M], ne[M], idx;
//d1表示向下走的最长路径 d2表示向下走的次长路径 up表示向上走的最长路径
//p1存储最大值和次大值是从哪个边上来的 需要判断父节点的最长边是不是从当前子树上来的
int d1[N], d2[N], p1[N], up[N];
bool is_leaf[N];
void add(int a, int b, int c)
{
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}
int dfs_d(int u, int father)
{
d1[u] = d2[u] = -INF;
for (int i = h[u]; i != -1; i = ne[i])
{
int j = e[i];
if (j == father) continue;
int d = dfs_d(j, u) + w[i];
if (d >= d1[u])
{
d2[u] = d1[u], d1[u] = d;
p1[u] = j;
}
else if (d > d2[u]) d2[u] = d;
}
//是一个叶子节点
if (d1[u] == -INF)
{
d1[u] = d2[u] = 0;
is_leaf[u] = true;
}
//返回最长路径的长度
return d1[u];
}
void dfs_u(int u, int father)
{
for (int i = h[u]; i != -1; i = ne[i])
{
int j = e[i];
if (j == father) continue;
//从u这个节点过来 只能从次大值更新
if (p1[u] == j) up[j] = max(up[u], d2[u]) + w[i];
else up[j] = max(up[u], d1[u]) + w[i];
dfs_u(j, u);
}
}
int main()
{
cin >> n;
memset(h, -1, sizeof h);
for (int i = 0; i < n - 1; i ++ )
{
int a, b, c;
cin >> a >> b >> c;
add(a, b, c), add(b, a, c);
}
//向下走的最长距离和次长距离
dfs_d(1, -1);
//xiang
dfs_u(1, -1);
//枚举每一个点
int res = d1[1];
for (int i = 2; i <= n; i ++ )
if (is_leaf[i]) res = min(res, up[i]);
else res = min(res, max(d1[i], up[i]));
printf("%d\n", res);
return 0;
}
3、数字转换(树的最长路径)
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 50010, M = N;
int n;
int h[N], e[M], w[M], ne[M], idx;
//存的是约数之和
int sum[N];
bool st[N];
int ans;
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
int dfs(int u)
{
int d1 = 0, d2 = 0;
for (int i = h[u]; i!=-1; i = ne[i])
{
int j = e[i];
int d = dfs(j)+1;
if (d >= d1) d2 = d1, d1 = d;
else if (d > d2) d2 = d;
}
ans = max(ans, d1 + d2);
return d1;
}
int main()
{
cin >> n;
memset(h, -1, sizeof h);
//i 约数
for (int i = 1; i <= n; i ++ )
//写成j*i<=n 当j和i接近int的最大范围时,可能会溢出
//j倍数 j!=1是因为 x的约数之和不包含本身
for (int j = 2; j <= n / i; j ++ )
sum[i * j] += i;
//判断约数之和是否小于数的本身
//i!=1 sum[i]=0 所有数字变换在不超过n的正整数范围内进行。正整数
for (int i = 2; i <= n; i ++ )
//如果是,以约数之和为父节点,约数为子节点,建立一条有向边
if (sum[i] < i)
{
add(sum[i], i);
st[i]=true;
}
//有多棵树 只需要遍历树根(没有被标记过的就是树根)
for (int i = 1; i <= n; i ++ )
if (!st[i])
dfs(i);
cout << ans << endl;
return 0;
}
4、二叉苹果树(完全二叉树 有依赖的背包问题)
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 110, M = N * 2;
int n, m;
int h[N], e[M], w[M], ne[M], idx;
int f[N][N];
void add(int a, int b, int c)
{
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}
void dfs(int u, int father)
{
for (int i = h[u]; ~i; i = ne[i])
{
if (e[i] == father) continue;
dfs(e[i], u);
//分组背包问题
//e[i]物品组
//体积 从大到小枚举
//假设对于最后的叶子节点,依然按照m枚举,如果使用时超出m的范围
//忽略不用即可
for (int j = m; j>=0; j -- )
//决策 每一个子树的选择方式
for (int k = 0; k + 1 <= j; k ++ )
//f[u][j] 以u为根的子树中,选j条边的最大价值
f[u][j] = max(f[u][j], f[u][j - k - 1] + f[e[i]][k] + w[i]);
}
}
int main()
{
cin >> n >> m;
memset(h, -1, sizeof h);
for (int i = 0; i < n - 1; i ++ )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c), add(b, a, c);
}
dfs(1, -1);
//以1为根的子树中,选择m条边。剩余苹果的最大价值
printf("%d\n", f[1][m]);
return 0;
}
5、战略游戏
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1510;
int n;
int h[N], e[N], ne[N], idx;
int f[N][2];
//判断父节点
bool st[N];
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
void dfs(int u)
{
//f[u][1] = 1 当前位置放上士兵就说明耗费1
//f[u][0]=0 是为了清空。多组测试数据 之前可能使用了f[u][0]
f[u][0] = 0, f[u][1] = 1;
for (int i = h[u]; ~i; i = ne[i])
{
int j = e[i];
dfs(j);
f[u][0] += f[j][1];
f[u][1] += min(f[j][0], f[j][1]);
}
}
int main()
{
while (cin >> n)
{
//多组测试数据 清空 头结点h 下标idx
memset(h, -1, sizeof h);
idx = 0;
//清空父节点标记
memset(st, 0, sizeof st);
for (int i = 0; i < n; i ++ )
{
int id, cnt;
scanf("%d:(%d)", &id, &cnt);
while (cnt -- )
{
int ver;
cin >> ver;
add(id, ver);
//ver有父节点
st[ver] = true;
}
}
int root = 0;
while (st[root]) root ++ ;
dfs(root);
printf("%d\n", min(f[root][0], f[root][1]));
}
return 0;
}
6、皇宫看守
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1510;
int n;
int h[N], w[N], e[N], ne[N], idx;
int f[N][3];
bool st[N];
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
void dfs(int u)
{
f[u][2] = w[u];
//所有子节点f[j][1]和f[j][2]最小值的和
//f[i][1]计算时需要除了被选的子节点之外的所有节点f[j][1]和f[j][2]的最小值之和
//使用sum-k的就等于除k节点之外的其他节点f[j][1]和f[j][2]的最小值之和
int sum = 0;
for (int i = h[u]; ~i; i = ne[i])
{
int j = e[i];
dfs(j);
f[u][0] += min(f[j][1], f[j][2]);
f[u][2] += min(min(f[j][0], f[j][1]), f[j][2]);
sum += min(f[j][1], f[j][2]);
}
f[u][1] = 1e9;
for (int i = h[u]; ~i; i = ne[i])
{
int j = e[i];
f[u][1] = min(f[u][1], sum - min(f[j][1], f[j][2]) + f[j][2]);
}
}
int main()
{
cin >> n;
memset(h, -1, sizeof h);
for (int i = 1; i <= n; i ++ )
{
int id, cost, cnt;
cin >> id >> cost >> cnt;
w[id] = cost;
while (cnt -- )
{
int ver;
cin >> ver;
add(id, ver);
st[ver] = true;
}
}
int root = 1;
while (st[root]) root ++ ;
dfs(root);
//根节点被子节点看到,或者根节点上有守卫 根节点不可能有父节点
cout << min(f[root][1], f[root][2]) << endl;
return 0;
}
解释sum的用处
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1510;
int n;
int h[N], w[N], e[N], ne[N], idx;
int f[N][3];
bool st[N];
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
//不写sum的写法
void dfs(int u)
{
f[u][2] = w[u];
for (int i = h[u]; ~i; i = ne[i])
{
int j = e[i];
dfs(j);
f[u][0] += min(f[j][1], f[j][2]);
f[u][2] += min(min(f[j][0], f[j][1]), f[j][2]);
}
f[u][1] = 1e9;
for (int i = h[u]; ~i; i = ne[i])
{
int j = e[i];
f[u][1] = min(f[u][1], f[u][0] - min(f[j][1], f[j][2]) + f[j][2]);
}
}
int main()
{
cin >> n;
memset(h, -1, sizeof h);
for (int i = 1; i <= n; i ++ )
{
int id, cost, cnt;
cin >> id >> cost >> cnt;
w[id] = cost;
while (cnt -- )
{
int ver;
cin >> ver;
add(id, ver);
st[ver] = true;
}
}
int root = 1;
while (st[root]) root ++ ;
dfs(root);
cout << min(f[root][1], f[root][2]) << endl;
return 0;
}