树的难题

题目大意

一颗树有n个结点,每个结点有黑白灰其中一种颜色。
要求你删去树中若干条边,使得形成的森林中每一颗树都没有白色结点或至多有一个黑色结点。删去一条边的代价为该边的边权,最小化代价。

树形DP

注意到一个合法的联通块的任意子联通块也符合条件。
所以树形DP,设f[i],g[i],h[i]表示将以i为根的子树分成合法森林,i结点所在联通块有0个黑点、1个黑点、0个白点的最小代价。
转移方程很容易了。具体见代码。
注意叶子节点如果不是黑色的g值为正无穷。
然后g的转移涉及需要从一个g转移过来的情况,可以先全部不从g转移过来,然后找到每个儿子更换成从g转移所造成影响,找到影响最大的那个,然后从其的g转移过来。
最后我爆栈了,懒得打人工。

#include<cstdio>
#include<algorithm>
#define fo(i,a,b) for(i=a;i<=b;i++)
using namespace std;
typedef long long ll;
const int maxn=300000+10;
const ll inf=1000000000000000;
ll f[maxn],g[maxn],h[maxn],dis[maxn*2];
int c[maxn],fi[maxn],go[maxn*2],next[maxn*2];
int i,j,k,l,t,n,m,tot,ca;
void add(int x,int y,int z){
    go[++tot]=y;
    dis[tot]=z;
    next[tot]=fi[x];
    fi[x]=tot;
}
void dfs(int x,int y){//0 black 1 white 2 gray
    bool leaf=1;
    f[x]=g[x]=h[x]=0;
    if (!c[x]) f[x]=inf;
    else if (c[x]==1) h[x]=inf;
    int t=fi[x],k=0,l=0;
    while (t){
        if (go[t]!=y){
            dfs(go[t],x);
            leaf=0;
            if (c[x]){
                f[x]+=min(f[go[t]],min(g[go[t]],h[go[t]])+dis[t]);
                if (!k||min(f[k],min(g[k],h[k])+l)-g[k]<min(f[go[t]],min(g[go[t]],h[go[t]])+dis[t])-g[go[t]]){
                    k=go[t];
                    l=dis[t];
                }
            }
            g[x]+=min(f[go[t]],min(g[go[t]],h[go[t]])+dis[t]);
            if (c[x]!=1) h[x]+=min(h[go[t]],min(f[go[t]],g[go[t]])+dis[t]);
        }
        t=next[t];
    }
    if (c[x]) g[x]=g[x]-min(f[k],min(g[k],h[k])+l)+g[k];
    if (leaf&&c[x]) g[x]=inf;
}
int read(){
    int x=0;
    char ch=getchar();
    while (ch<'0'||ch>'9') ch=getchar();
    while (ch>='0'&&ch<='9'){
        x=x*10+ch-'0';
        ch=getchar();
    }
    return x;
}
int main(){
    ca=read();
    while (ca--){
        n=read();
        fill(fi+1,fi+n+1,0);
        tot=0;
        fo(i,1,n) c[i]=read();
        fo(i,1,n) 
            if (c[i]<2) c[i]=1-c[i];
        fo(i,1,n-1){
            j=read();k=read();l=read();
            add(j,k,l);add(k,j,l);
        }
        dfs(1,0);
        printf("%lld\n",min(f[1],min(g[1],h[1])));
    }
}
在实现哈夫曼的过程中,通常会遇到构造、编码解码相关的技术难。以下是一些常见问题及其可能的解决方法: ### 构造哈夫曼的难 1. **节选择与合**:构造哈夫曼的核心在于每次从所有可用节中选取权值最小的两个节将它们合生成一个新节作为父节。这个过程需要使用优先队列(如最小堆)来高效地获取最小权值的节。 - 实现时可以使用 `PriorityQueue` 或手动维护一个堆结构[^1]。 2. **动态更新节集合**:每次合后,需要将新生成的节重新插入到可用节集合中,移除已经使用的两个节。如果处理不当,可能会导致重复使用或遗漏某些节。 - 使用合适的数据结构(如链表或动态数组)可以帮助更高效地管理节集合。 3. **构建结构**:最终需要将这些节组织成一棵的二叉,每个节包含左子节右子节。构造过程中需要注意指针的正确指向。 ### 编码与解码的难 1. **生成哈夫曼编码**:在完成哈夫曼的构造后,需要通过遍历生成每个叶子节对应的二进制编码。通常采用递归方式对进行深度优先遍历。 - 从根节出发,向左子节走则添加 `0`,向右子节走则添加 `1`,直到到达叶子节为止。 - 示例代码如下: ```python def generate_huffman_codes(node, prefix="", code_dict=None): if code_dict is None: code_dict = {} if node.left is None and node.right is None: code_dict[node.value] = prefix else: generate_huffman_codes(node.left, prefix + "0", code_dict) generate_huffman_codes(node.right, prefix + "1", code_dict) return code_dict ``` 2. **解码效率问题**:哈夫曼解码需要根据编码规则逐位读取匹配哈夫曼路径,直到找到对应字符。如果数据量较大,逐位操作可能导致性能瓶颈。 - 可以通过预处理建立一个反向映射表,将编码字符串直接映射到字符,从而提高解码效率。 ### 其他常见问题 - **权值重复处理**:当多个节具有相同的权值时,合顺序会影响最终生成的哈夫曼结构。可以通过设定额外的排序规则(如按节值排序)确保唯一性。 - **内存占用优化**:对于大规模输入数据,频繁创建销毁节可能会增加内存开销。建议使用对象池或缓存机制减少内存分配次数。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值