1040: [ZJOI2008]骑士 基环+内向树 DP

本文介绍了一种使用树形动态规划(DP)的方法来解决一类特殊的选择问题。该问题在一个树状结构中,通过增加一条边形成一个二元环,并在此基础上探讨如何通过删除这条额外边来进行两次树形DP,以找到最优解。文章提供了完整的C++代码实现。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

不错的一道题目。
首先如果这是一棵树,那么本题就成了没有上司的舞会QAQ。。
加入一条边后唯一多的影响就是,这条边的两个端点不能同时选,其他条件是一样的。那么我们就删去这条边跑两次树形DP就行啦。。

一开始写的时候记录前驱节点。。然后发现找不到二元环QAQ。。
记录一下边就好了。。

#include<iostream>
#include<cstdio>
#include<cstring>
#define ll long long
#define N 1000005
using namespace std;
int cnt=1;
ll ans,f[N][2];
int n,root1,root2,v[N],head[N];
bool vis[N];
int list[N<<1],next[N<<1],flag[N<<1];
inline int read()
{
    int a=0,f=1; char c=getchar();
    while (c<'0'||c>'9') {if (c=='-') f=-1; c=getchar();}
    while (c>='0'&&c<='9') {a=a*10+c-'0'; c=getchar();}
    return a*f;
}
inline void insert(int x,int y)
{
    next[++cnt]=head[x];
    head[x]=cnt;
    list[cnt]=y;
    flag[cnt]=1;
}
void dfs(int x,int from)
{
    vis[x]=1;
    for (int i=head[x];i;i=next[i])
        if (!vis[list[i]]) dfs(list[i],i);
        else if ((from^1)!=i&&!root1)
            root1=x,root2=list[i],flag[i]=flag[i^1]=0;
}
void dp(int x,int fa)
{
    f[x][1]=v[x]; f[x][0]=0;
    for (int i=head[x];i;i=next[i])
        if (list[i]!=fa&&flag[i])
        {
            dp(list[i],x);
            f[x][0]+=max(f[list[i]][0],f[list[i]][1]);
            f[x][1]+=f[list[i]][0];
        }
}
int main()
{
    n=read();
    for (int i=1;i<=n;i++)
    {
        v[i]=read();
        int u=read();
        insert(i,u); insert(u,i);
    }
    for (int i=1;i<=n;i++)
        if (!vis[i])
        {
            root1=root2=0;
            dfs(i,0);
            dp(root1,0);
            ll tmp=f[root1][0];
            dp(root2,0);
            tmp=max(tmp,f[root2][0]);
            ans+=tmp;
        }
    cout << ans;
    return 0;
}
### 内向的数据结构实现与应用 #### 定义 内向是一种特殊的图结构,其中包含 \(n\) 个节点和 \(n\) 条边。这种图的特点是一个连接多个子,而每个节点的出度恰好为 1[^2]。 #### 特性分析 由于每个节点的出度固定为 1,这意味着所有的节点都会沿着唯一的路径最终进入一个。这一特性使得我们可以将整个图分解成两部分: - **上的节点**:这些节点构成了核心循结构。 - **挂载在上的子**:每条从出发的分支实际上是一颗普通的。 为了有效解决问题,通常需要先定位的位置并将其作为特殊处理的核心区域。 --- #### 实现方法 以下是于深度优先搜索 (DFS) 的一种常见算法用于检测以及构建内向: ```python from collections import defaultdict, deque def find_cycle_and_tree(n, edges): graph = defaultdict(list) # 构建邻接表 for u, v in edges: graph[u].append(v) visited = [0] * n # 记录访问状态: 0=未访问, 1=正在访问, 2=已完全访问 cycle_nodes = [] # 存储构成的节点 def dfs(node, path): if visited[node] == 1: # 如果当前节点已经在路径中,则发现了一个 start_of_cycle = node while True: current_node = path.pop() cycle_nodes.append(current_node) if current_node == start_of_cycle: break return True if visited[node] == 2: # 已经完全访问过该节点 return False visited[node] = 1 # 标记为正在访问 path.append(node) for neighbor in graph[node]: if dfs(neighbor, path.copy()): return True visited[node] = 2 # 标记为完全访问 return False # 寻找 for i in range(n): if not cycle_nodes and visited[i] != 2: if dfs(i, deque([])): break # 将视为单个节点,其余部分按普通处理 tree_structure = {} for node in range(n): if node not in cycle_nodes: parent = None for nei in graph[node]: if nei in cycle_nodes or nei in tree_structure.values(): parent = nei break if parent is not None: tree_structure[node] = parent return cycle_nodes, tree_structure # 测试输入 edges = [(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)] # 形成一个简单的内向 cycle, tree = find_cycle_and_tree(5, edges) print("Cycle Nodes:", cycle) print("Tree Structure:", tree) ``` 上述代码通过 DFS 遍历寻找,并记录下中的节点及其对应的子关系。对于非节点,它们会被映射到其父节点上形成一棵标准的状结构。 --- #### 应用场景 1. **网络拓扑优化**: 在计算机网络设计中,有时需要确保某些设备之间存在冗余链路以提高可靠性,同时又不引入过多复杂性。此时可以通过识别内向来简化模型。 2. **任务调度问题**: 当面对一组相互依赖的任务时(即 A 可能依赖于 B 而 B 同样可能间接依赖回 A),利用内向可以帮助快速判断是否存在死锁情况。 3. **动态规划加速**: 对于一些涉及大量重复计算的问题,在预处理阶段如果能够提前解析出潜在的形依赖链条,则可以在后续迭代过程中显著减少不必要的运算量。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值