[SHOI2004]最小生成树,洛谷P4412,线性规划

本文探讨了在特定问题中应用贪心策略和线性规划的方法,通过构造约束条件和使用最小顶标和线性规划技巧,解决了生成树边权值调整的问题。文章详细解释了如何利用单纯形算法进行求解,并提供了实现代码。

正题

      题目链接

      首先,我们需要构造一种贪心的思路:

      1.我们不可能给一条生成树边增加一个数。这样只会使的生成树的权值变大,而且对于不选树边的生成树,相对来说变得可能更小。

     2.我们也不可能给一条非生成树边减去一个数,因为这样会使得不选树边的生成树权值变小,从而变得没有那么优秀。

     那么很好理解上面的两条贪心“法则”之后,我们要构造几组约束,使得答案使我们所需要的。

     我们假设x_i是第i条的边的变化量(当然,生成树边表示减少的,非生成树边是增加的)。

     对于一条非树边,肯定对应着生成树边上的一个路径,使得这条路径与这条非树边成为一个环。

     对于这条路径上的任何一条边i,权值一定小于等于非树边j的权值。

     所以W_i-x_i<=W_j+x_j

     变形金刚\to d_i+d_j>=W_i-W_j

     这个时候,很多人就会选择用最小顶标和(KM,二分图最优匹配)来解决。

     其实,线性规划也是很好做的。

     那么就一共最多有m*n条约束,每条约束有m个非基变量(顺便告诉您们洛谷的边数是假的)。

     但是可能会爆空间(洛谷的编译器十分优秀,不会爆)。

     我们就用map来进行存储,在做单纯形算法之前对偶一下即可。

代码<吸口氧气416ms>

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<map>
#include<cmath>
using namespace std;

int n,m;
int num[55][55],d[1555];
bool tf[1555];
bool we=false;
map<int , double> a[1555];
double eps=1e-8;
int tot=0;

void find_loop(int x,int fa,int end,int T){
    if(x==end){
        we=true;
        return ;
    }
    for(int i=1;i<=n;i++){
        if(tf[num[x][i]] && i!=fa){
            find_loop(i,x,end,T);
            if(we){
                tot++;a[num[x][i]][tot]=a[T][tot]=1;a[0][tot]=d[num[x][i]]-d[T];
                break;
            }
        }	
    }
}

void pivot(int x,int y){
    double temp=a[x][y];a[x][y]=1;
    for(int i=0;i<=tot;i++) if(fabs(a[x][i])>eps)a[x][i]/=temp;
    for(int i=0;i<=m;i++) if(x!=i){
    	if(fabs(a[i][y])<=eps) continue;
        temp=a[i][y];a[i][y]=0;
        for(int j=0;j<=tot;j++) 
            if(fabs(a[x][j])>eps) a[i][j]-=temp*a[x][j];
            else a[x].erase(j);
    }
}

void simplex(){
    double mmin;
    int x,y;
    while(true){
        x=y=0;
        for(int i=1;i<=tot;i++) if(a[0][i]>eps && (y==0 || a[0][i]>a[0][y])) y=i;
        if(y==0) break;
        mmin=(double)1e15;
        for(int i=1;i<=m;i++) if(a[i][y]>eps && a[i][0]/a[i][y]<mmin) x=i,mmin=a[i][0]/a[i][y];
        if(x==0) break;
        pivot(x,y);	
    }
}

int main(){
    scanf("%d %d",&n,&m);
    int x,y;
    for(int i=1;i<=m;i++){
        scanf("%d %d %d",&x,&y,&d[i]);
        num[x][y]=num[y][x]=i;
    }
    for(int i=1;i<=n-1;i++){
        scanf("%d %d",&x,&y);
        tf[num[x][y]]=true;
    }
    for(int i=1;i<=m;i++) a[i][0]=1;
    for(int i=1;i<=n;i++)
        for(int j=1;j<i;j++){
            if(!num[i][j]) continue;
            if(!tf[num[i][j]]){
                we=false;
                find_loop(i,0,j,num[i][j]);
            }
        }
    simplex();
    if(fabs(a[0][0])>eps)printf("%.0lf",-a[0][0]);
    else printf("0");
}

 

<think>首先,用户要求用中文回答问题,所以我必须使用中文。用户的问题是关于“[SHOI2012] 魔法树”的树链剖分详解。 我需要回忆“[SHOI2012] 魔法树”这个题目。这是一个经典的树链剖分问题,涉及路径修改和子树查询。 题目大意:给定一棵树,每个节点有初始值。支持两种操作: 1. 路径加:给从u到v的路径上所有节点加上一个值。 2. 子树查询:查询以u为根的子树中所有节点的值的和。 树链剖分(Heavy-Light Decomposition, HLD)是解决这类问题的有效方法。它将树分解成链,便于用线段树或其他数据结构维护。 树链剖分的关键步骤: - 第一次DFS:计算每个节点的子树大小(size),父节点(parent),深度(depth),重儿子(heavy son)。 - 第二次DFS:分配链顶(top)和DFS序(dfn)。重儿子优先遍历,形成重链。 在树链剖分中,每个节点得到一个DFS序,重链上的节点连续。这样,路径可以被分解成O(log n)条链,每条链在DFS序上是连续的区间。 对于路径加操作: - 从u和v开始,向上跳链,直到它们在同一个链上。每次跳链时,修改当前链上的区间(从当前节点到链顶)。 - 具体地,如果u和v的链顶不同,选择链顶深度较大的节点,修改从该节点到链顶的区间,然后跳到链顶的父节点。 - 当u和v在同一条链上时,修改它们之间的区间。 对于子树查询: - 由于子树在DFS序中是连续的区间(从dfn[u]到dfn[u] + size[u] - 1),所以可以直接查询这个区间。 实现时,通常用一个线段树来维护DFS序上的区间和、区间加。 现在,我需要详细解释树链剖分在本题中的应用。 回答结构: 1. 介绍树链剖分的基本概念。 2. 描述如何应用于“[SHOI2012] 魔法树”。 3. 给出代码框架(伪代码或简化代码)。 4. 最后,提出3-5个相关问题。 用户指定了格式:回答后必须输出“§§相关问题§§”,然后列出问题。第一行必须是“§§相关问题§§”,禁止换行分散。 在示例中,代码是用markdown代码块表示的,所以我应该用类似方式。 完整回答: - 先详细解释树链剖分。 - 然后针对题目给出具体实现。 - 最后输出相关问题。 相关问题应该基于用户的问题和我的回答。可能的主题: 1. 树链剖分的其他应用。 2. 优化或变体。 3. 复杂度分析。 4. 相关题目。 列出3-5个: 1. 树链剖分的时间复杂度是多少? 2. 如何处理子树修改和路径查询? 3. 树链剖分与倍增LCA的区别是什么? 4. 是否有其他树分解方法? 5. 在本题中,如果支持路径查询和子树加,如何修改? 确保问题相关。 现在,写回答。</think>### 树链剖分详解 [SHOI2012] 魔法树 [SHOI2012] 魔法树是一个经典的树链剖分(Heavy-Light Decomposition, HLD)问题。给定一棵 \(n\) 个节点的树,每个节点初始值为 0,支持两种操作: 1. **路径加**:给节点 \(u\) 到 \(v\) 的路径上所有节点增加一个值 \(d\)。 2. **子树查询**:查询以节点 \(u\) 为根的子树中所有节点值的和。 树链剖分通过将树分解为若干条链(重链),并映射到线性序列(DFS 序),从而用线段树高效处理路径和子树操作。以下是详细步骤: #### 1. **树链剖分预处理** - **第一次 DFS**:计算每个节点的父节点(`fa`)、深度(`dep`)、子树大小(`siz`)和重儿子(`son`)。 - 重儿子:子树大小最大的儿子节点。 - **第二次 DFS**:分配 DFS 序(`dfn`)和链顶(`top`)。 - 优先遍历重儿子,形成重链;轻儿子作为新链的起点。 - 记录 DFS 序范围:节点 \(u\) 的子树对应区间 \([dfn[u], dfn[u] + siz[u] - 1]\)。 #### 2. **操作实现** - **路径加操作 `AddPath(u, v, d)`**: - 当 \(u\) 和 \(v\) 不在同一条链上时,将深度较大的节点向上跳至链顶,并修改该链的区间(对应线段树区间加)。 - 当 \(u\) 和 \(v\) 在同一条链上时,直接修改它们之间的区间。 - 时间复杂度:\(O(\log^2 n)\)(每条链跳 \(O(\log n)\) 次,线段树操作 \(O(\log n)\))。 - **子树查询操作 `QuerySubtree(u)`**: - 子树在 DFS 序中是连续区间 \([dfn[u], dfn[u] + siz[u] - 1]\)。 - 直接线段树区间查询。 - 时间复杂度:\(O(\log n)\)。 #### 3. **线段树维护** - 基于 DFS 序建线段树,支持区间加和区间查询。 - 每个节点存储区间和(`sum`)和懒标记(`lazy`)。 #### 代码框架(Python 伪代码) ```python class HLD: def __init__(self, n, graph): self.n = n self.graph = graph self.fa = [-1] * (n+1) # 父节点 self.dep = [0] * (n+1) # 深度 self.siz = [0] * (n+1) # 子树大小 self.son = [-1] * (n+1) # 重儿子 self.top = [-1] * (n+1) # 链顶 self.dfn = [0] * (n+1) # DFS序 self.cnt = 0 # DFS计数器 self.dfs1(1, 0) # 第一次DFS self.dfs2(1, 1) # 第二次DFS self.seg_tree = SegmentTree(n) # 线段树(区间加、区间和) def dfs1(self, u, father): # 计算siz, dep, fa, son self.fa[u] = father self.dep[u] = self.dep[father] + 1 self.siz[u] = 1 max_size = -1 for v in self.graph[u]: if v == father: continue self.dfs1(v, u) self.siz[u] += self.siz[v] if self.siz[v] > max_size: max_size = self.siz[v] self.son[u] = v def dfs2(self, u, top_fa): # 分配dfn和top self.top[u] = top_fa self.dfn[u] = self.cnt self.cnt += 1 if self.son[u] == -1: return self.dfs2(self.son[u], top_fa) # 优先重儿子 for v in self.graph[u]: if v == self.fa[u] or v == self.son[u]: continue self.dfs2(v, v) # 轻儿子作为新链顶 def AddPath(self, u, v, d): # 路径加 while self.top[u] != self.top[v]: if self.dep[self.top[u]] < self.dep[self.top[v]]: u, v = v, u # 修改u到其链顶的区间 l, r = self.dfn[self.top[u]], self.dfn[u] self.seg_tree.update(l, r, d) u = self.fa[self.top[u]] if self.dep[u] > self.dep[v]: u, v = v, u l, r = self.dfn[u], self.dfn[v] self.seg_tree.update(l, r, d) # 修改最后一条链上的区间 def QuerySubtree(self, u): # 子树查询 l, r = self.dfn[u], self.dfn[u] + self.siz[u] - 1 return self.seg_tree.query(l, r) class SegmentTree: # 线段树(简化版) def __init__(self, n): self.n = n self.sum = [0] * (4 * n) self.lazy = [0] * (4 * n) def push_down(self, o, l, r): if self.lazy[o]: mid = (l + r) // 2 self.lazy[o*2] += self.lazy[o] self.lazy[o*2+1] += self.lazy[o] self.sum[o*2] += self.lazy[o] * (mid - l + 1) self.sum[o*2+1] += self.lazy[o] * (r - mid) self.lazy[o] = 0 def update(self, o, l, r, ql, qr, d): # 区间加 if ql <= l and r <= qr: self.sum[o] += d * (r - l + 1) self.lazy[o] += d return self.push_down(o, l, r) mid = (l + r) // 2 if ql <= mid: self.update(o*2, l, mid, ql, qr, d) if qr > mid: self.update(o*2+1, mid+1, r, ql, qr, d) self.sum[o] = self.sum[o*2] + self.sum[o*2+1] def query(self, o, l, r, ql, qr): # 区间查询 if ql <= l and r <= qr: return self.sum[o] self.push_down(o, l, r) mid = (l + r) // 2 res = 0 if ql <= mid: res += self.query(o*2, l, mid, ql, qr) if qr > mid: res += self.query(o*2+1, mid+1, r, ql, qr) return res # 主程序示例 if __name__ == "__main__": n = int(input()) # 节点数 graph = [[] for _ in range(n+1)] for _ in range(n-1): # 建树 u, v = map(int, input().split()) graph[u].append(v) graph[v].append(u) hld = HLD(n, graph) # 处理操作:例如 hld.AddPath(u, v, d) 或 hld.QuerySubtree(u) ``` #### 复杂度分析 - 预处理:两次 DFS,\(O(n)\)。 - 路径加:\(O(\log^2 n)\)(树链剖分分解为 \(O(\log n)\) 条链,每条链线段树操作 \(O(\log n)\))。 - 子树查询:\(O(\log n)\)(线段树区间查询)。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值