kuangbin专题八 HDU4009 Transfer water (无定根最小树形图)

本文介绍了一种解决特定场景下的最小树形图问题的方法,包括如何将额外成本(如水泵价格)融入边权,使用超级源点进行计算,并通过不断缩点来找到最低花费方案。

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

题意:
在山上有N户人家,每家的坐标为(xi, yi, zi)。每户人家要吃水,要么自己打井,花费为X*zi,要么从别人的家引水渠代价为 两家的曼哈顿距离*Y,如果这家的海拔比供水的低,还要另外再买一个价值为C的水泵。然后有N个k,表示的是每户人家可以引水渠到哪一家,现在问每家都有水喝的最低花费是多少。
题解:
一开始我纠结于如何在最小树形图中判断水泵到底安不安装,后来别人说直接把水泵的价格放进去单边权值就可以了,还有一点就是因为是不定根,所以我们要弄个超级源点,超级源点到各个点的权值为各个点打井的权值,然后就可以了,那个“poor XiaoA”其实是不会出现的。。因为最坏的情况,每家都可以自己打水井。
题外话:
有时候自己傻逼起来是真的可怕。。。把MAXN*MAXN放到点的结构体那里了,导致一直超时,对着模板都还能打错。。。妈的还有就是括号多了也看不清楚。。哎

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
#define INF 0x3f3f3f3f
const int MAXN=1000+7;
struct node1
{
    int u,v,w;
}map[MAXN*MAXN];
struct point
{
    int x,y,z;
}p[MAXN];
int pre[MAXN];
int ID[MAXN];
int IN[MAXN];
int vis[MAXN];
int n,m,X,Y,Z;
int zhuliu_mst(int root,int V,int E)
{
    int res=0;
    while(true)
    {
        for(int i=0;i<V;i++) IN[i]=INF;
        for(int i=0;i<E;i++)
        {
            int u=map[i].u;
            int v=map[i].v;
            if(map[i].w<IN[v]&&u!=v)
            {
                pre[v]=u;
                IN[v]=map[i].w;
            }
        }
        for(int i=0;i<V;i++)//实际上这个判断每个点没入边是没必要的,因为可以自家打井 
        if(i!=root&&IN[i]==INF)
        return -1;
        int cnt=0;
        memset(ID,-1,sizeof(ID));
        memset(vis,-1,sizeof(vis));
        IN[root]=0;
        for(int i=0;i<V;i++)
        {
            res+=IN[i];
            int v=i;
            while(vis[v]!=i&&ID[v]==-1&&v!=root)
            {
                vis[v]=i;
                v=pre[v];
            }
            if(v!=root&&ID[v]==-1)
            {
                for(int u=pre[v];u!=v;u=pre[u])
                {
                    ID[u]=cnt;
                }
                ID[v]=cnt++;
            }
        }
        if(cnt==0) break;
        for(int i=0;i<V;i++)
        {
            if(ID[i]==-1)
            ID[i]=cnt++;
        }
        for(int i=0;i<E;i++)
        {
            int u=map[i].u;
            int v=map[i].v;
            map[i].u=ID[u];
            map[i].v=ID[v];
            if(ID[u]!=ID[v])
            map[i].w-=IN[v];
        }
        V=cnt;
        root=ID[root];
    }
    return res;
}
int main()
{
    while(~scanf("%d%d%d%d",&n,&X,&Y,&Z))
    {
        if(n==0&&X==0&&Y==0&&Z==0)
        break;      
        m=0;
        for(int i=1;i<=n;i++)
        scanf("%d%d%d",&p[i].x,&p[i].y,&p[i].z);
        for(int i=1;i<=n;i++)
        {
            int k,v;
            scanf("%d",&k);
            for(int j=1;j<=k;j++)
            {
                scanf("%d",&v);
                map[m].u=i;
                map[m].v=v;
                map[m].w=(abs(p[i].x-p[v].x)+abs(p[i].y-p[v].y)+abs(p[i].z-p[v].z))*Y;
                if(p[i].z<p[v].z)
                map[m].w+=Z;
                m++;
            }
        }   
        for(int i=1;i<=n;i++)
        {
            map[m].u=0;
            map[m].v=i;
            map[m].w=p[i].z*X;
            m++;
        }
        int ans=zhuliu_mst(0,n+1,m);//如果从点是1算的话,还是用n+1吧。。不然每次算完缩点之后的个数都要-1,麻烦 
        if(ans==-1)
        printf("poor XiaoA\n");//这句话不会出现的。。因为可以自家打井,但是还是写上去吧 
        else
        printf("%d\n",ans);
    }
} 
<think>好的,我需要帮助用户了解Kuangbin的划分树相关资料或教程。首先,我要明确划分树的基本概念,确保自己理解正确。划分树是一种基于线段树的数据结构,主要用于解决区间第K小查询问题。它的核心思想是将区间递归划分,并在每个节点保存排序后的子区间,从而快速定位目标值。 接下来,我需要查阅用户提供的引用内容,看看是否有相关引用可以支持回答。引用[1]提到树链剖分,虽然不直接相关,但可能涉及树结构的处理。引用[2]和[3]讨论了树状数组和线段树在树结构中的应用,这可能与划分树的空间复杂度或实现细节有关。引用[4]关于Tarjan算法,可能与划分树的应用场景不同,暂时不考虑。 然后,我需要组织回答结构。用户希望了解Kuangbin的划分树实现,可能包括算法原理、实现步骤、代码示例以及复杂度分析。根据系统级指令,要使用正确的中文和LaTeX格式,例如数学表达式用$...$,独立公式用$$...$$。 考虑到用户可能需要代码示例,我需要编写Python或伪代码来展示划分树的构建和查询过程。同时,要确保引用相关文献,比如引用[3]提到的线段树家族处理子链的能力,可能在划分树的优化中有所体现。 另外,用户要求生成相关问题,我需要围绕划分树的应用、优化、复杂度等方面提出问题。例如,划分树与其他数据结构(如线段树)的区别,或者如何处理动态数据等。 最后,检查所有LaTeX语法是否正确,如区间划分的数学表达式是否正确使用$符号,代码块是否用三个反引号标注,引用标识是否自然添加在相关段落末尾。确保回答结构清晰,分步骤解释划分树的原理和实现,帮助用户逐步理解。</think>### Kuangbin划分树详解 划分树(Partition Tree)是一种基于线段树的扩展数据结构,主要用于解决**静态区间第K小查询**问题。其核心思想是将区间递归划分,并在每个节点保存排序后的子区间信息,利用二分思想快速定位目标值。 #### 一、算法原理 1. **预处理阶段**: - 将原始数组$[a_1,a_2,...,a_n]$排序得到$sorted\_arr$ - 递归地将当前区间划分为左右子区间: $$left\_part = [sorted\_arr中前mid个元素]$$ $$right\_part = [sorted\_arr中剩余元素]$$ - 记录每个元素在划分过程中进入左子区间的次数(通过`to_left`数组) 2. **查询阶段**: - 根据当前节点的划分信息,判断目标值在左/右子区间 - 通过`to_left`数组快速计算子区间内的元素数量 #### 二、代码实现(Python示例) ```python class PartitionTree: def __init__(self, arr): self.n = len(arr) self.tree = [] self.to_left = [] sorted_arr = sorted(arr) self.build(0, 0, self.n-1, arr, sorted_arr) def build(self, depth, l, r, arr, sorted_arr): if l == r: if len(self.tree) <= depth: self.tree.append([]) self.to_left.append([0]*(self.n+1)) self.tree[depth].append(arr[l]) return # 划分过程(关键步骤) mid = (l + r) // 2 median = sorted_arr[mid] # 统计进入左子树的元素数量[^3] to_left = 0 left_part, right_part = [], [] for num in arr[l:r+1]: if num < median or (num == median and to_left <= mid - l): left_part.append(num) to_left += 1 else: right_part.append(num) # 合并左右部分 merged = left_part + right_part # 存储当前层数据 if len(self.tree) <= depth: self.tree.append([]) self.to_left.append([0]*(self.n+1)) self.tree[depth][l:r+1] = merged self.to_left[depth][l] = 0 cnt = 0 for i in range(l, r+1): if merged[i-l] < median or (merged[i-l] == median and cnt <= mid - l): cnt += 1 self.to_left[depth][i+1] = cnt # 递归构建子树 self.build(depth+1, l, mid, merged[:mid-l+1], sorted_arr) self.build(depth+1, mid+1, r, merged[mid-l+1:], sorted_arr) ``` #### 三、复杂度分析 - 预处理时间复杂度:$O(n \log n)$ - 查询时间复杂度:$O(\log n)$ - 空间复杂度:$O(n \log n)$(与线段树的空间消耗类似)[^2] #### 四、应用场景 1. 静态区间第K小查询(如OJ题目POJ2104) 2. 高维空间最近邻搜索的降维处理 3. 数据压缩中的分块编码
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值