ZOJ3613 Wormhole Transport(斯坦纳树)

题目链接

题目描述:
若干星球,有些星球上建立了若干个工厂,有些星球是资源星球
一个资源星球只能供应一座工厂,求最大可被供应的工厂数以及在此条件下的最小花费

分析:
有可能一个星球即是资源星球又是工厂建设地吗?应该是有可能的
遇到这种情况,我只要让其中一座工厂在自己的星球上就地取材即可(剩下的工厂还是需要与其他资源星球连通)

还是朴素的斯坦纳树转移

注意一点,所有的状态都要满足一个条件:连通的星球上工厂的个数要大于等于资源的个数,这样才是一个合法的状态

最后再找到所含资源最多,花费最小的合法方案就是答案

tip

注意如果没有合法方案,花费是0:printf("%d %d\n",tt+ans,cost==INF? 0:cost);

#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>

using namespace std;

const int INF=0x3333333;
const int N=205;
int n,m,st[N],tot=0,ans=0;
int er[N],fac[N],rec[N],fac_cnt,rec_cnt;
struct node{
    int y,v,nxt;
};
node way[10010];
int f[N][1100],g[1100];
bool in[N];
queue<int> q;

void add(int u,int w,int z) {
    tot++;way[tot].y=w;way[tot].v=z;way[tot].nxt=st[u];st[u]=tot;
    tot++;way[tot].y=u;way[tot].v=z;way[tot].nxt=st[w];st[w]=tot;
}

void spfa(int S) {
    while (!q.empty()) {
        int now=q.front(); q.pop();
        in[now]=0;
        for (int i=st[now];i;i=way[i].nxt) {
            int y=way[i].y;
            if (f[y][S]>f[now][S]+way[i].v) {
                f[y][S]=f[now][S]+way[i].v;
                if (!in[y]) q.push(y),in[y]=1;
            }
        }
    }
}

int check(int a) {
    int t=0;
    for (int i=1;i<=n;i++) 
        if (a&er[i]) t+=fac[i],t-=rec[i];    
    return t>=0;                                  //工厂>资源 
}

int getnum(int a) {
    int t=0;
    for (int i=1;i<=n;i++)
        if (a&er[i]) t+=rec[i];
    return t;
}

void dp() {
    int cnt=1<<(rec_cnt+4);
    for (int S=1;S<cnt;S++) {
        for (int s=(S-1)&S;s;s=(s-1)&S)
            for (int i=1;i<=n;i++)
                f[i][S]=min(f[i][S],f[i][s]+f[i][S^s]);
        for (int i=1;i<=n;i++)
            if (f[i][S]<INF&&!in[i])
                q.push(i),in[i]=1;
        spfa(S);
    } 

    for (int i=1;i<cnt;i++) 
        for (int j=1;j<=n;j++)
            g[i]=min(g[i],f[j][i]);

    int cost=INF,tt=0;      
    for (int i=1;i<=cnt;i++) 
        if (check(i)) {                             //合法状态 
            for (int j=(i-1)&i;j;j=(j-1)&i) 
                if (check(j)&&check(i^j))
                    g[i]=min(g[i],g[j]+g[i^j]);     //转移合法状态
            int tmp=getnum(i);                      //此状态有多少资源
            if (tmp>tt) tt=tmp,cost=g[i];
            else if (tmp==tt) cost=min(cost,g[i]); 
        }
    printf("%d %d\n",tt+ans,cost==INF? 0:cost);
}

void init() {
    memset(st,0,sizeof(st)); tot=0;
    memset(in,0,sizeof(in));
    memset(er,0,sizeof(er));
    memset(f,0x33,sizeof(f));
    memset(g,0x33,sizeof(g));
    while (!q.empty()) q.pop();
    fac_cnt=0,rec_cnt=0,ans=0;
}

int main()
{
    while (scanf("%d",&n)!=EOF) {
        init();

        for (int i=1;i<=n;i++) {
            scanf("%d%d",&fac[i],&rec[i]);
            if (fac[i]&&rec[i]) fac[i]--,rec[i]--,ans++;      //既有工厂又有资源 
            if (fac[i]) {
                er[i]=1<<fac_cnt; fac_cnt++;
                f[i][er[i]]=0;
            }
            if (rec[i]) {
                er[i]=1<<(rec_cnt+4); rec_cnt++;
                f[i][er[i]]=0;
            }
        }

        scanf("%d",&m);
        for (int i=1;i<=m;i++) {
            int u,w,z;
            scanf("%d%d%d",&u,&w,&z);
            add(u,w,z);
        }
        dp();
    }
    return 0;
}
### ZOJ 1088 线段树 解题思路 #### 题目概述 ZOJ 1088 是一道涉及动态维护区间的经典问题。通常情况下,这类问题可以通过线段树来高效解决。题目可能涉及到对数组的区间修改以及单点查询或者区间查询。 --- #### 线段树的核心概念 线段树是一种基于分治思想的数据结构,能够快速处理区间上的各种操作,比如求和、最大值/最小值等。其基本原理如下: - **构建阶段**:通过递归方式将原数组划分为多个小区间,并存储在二叉树形式的节点中。 - **更新阶段**:当某一段区间被修改时,仅需沿着对应路径向下更新部分节点即可完成全局调整。 - **查询阶段**:利用懒惰标记(Lazy Propagation),可以在 $O(\log n)$ 时间复杂度内完成任意范围内的计算。 具体到本题,假设我们需要支持以下两种主要功能: 1. 对指定区间 `[L, R]` 执行某种操作(如增加固定数值 `val`); 2. 查询某一位置或特定区间的属性(如总和或其他统计量)。 以下是针对此场景设计的一种通用实现方案: --- #### 实现代码 (Python) ```python class SegmentTree: def __init__(self, size): self.size = size self.tree_sum = [0] * (4 * size) # 存储区间和 self.lazy_add = [0] * (4 * size) # 延迟更新标志 def push_up(self, node): """ 更新父节点 """ self.tree_sum[node] = self.tree_sum[2*node+1] + self.tree_sum[2*node+2] def build_tree(self, node, start, end, array): """ 构建线段树 """ if start == end: # 到达叶节点 self.tree_sum[node] = array[start] return mid = (start + end) // 2 self.build_tree(2*node+1, start, mid, array) self.build_tree(2*node+2, mid+1, end, array) self.push_up(node) def update_range(self, node, start, end, l, r, val): """ 区间更新 [l,r], 加上 val """ if l <= start and end <= r: # 当前区间完全覆盖目标区间 self.tree_sum[node] += (end - start + 1) * val self.lazy_add[node] += val return mid = (start + end) // 2 if self.lazy_add[node]: # 下传延迟标记 self.lazy_add[2*node+1] += self.lazy_add[node] self.lazy_add[2*node+2] += self.lazy_add[node] self.tree_sum[2*node+1] += (mid - start + 1) * self.lazy_add[node] self.tree_sum[2*node+2] += (end - mid) * self.lazy_add[node] self.lazy_add[node] = 0 if l <= mid: self.update_range(2*node+1, start, mid, l, r, val) if r > mid: self.update_range(2*node+2, mid+1, end, l, r, val) self.push_up(node) def query_sum(self, node, start, end, l, r): """ 查询区间[l,r]的和 """ if l <= start and end <= r: # 完全匹配 return self.tree_sum[node] mid = (start + end) // 2 res = 0 if self.lazy_add[node]: self.lazy_add[2*node+1] += self.lazy_add[node] self.lazy_add[2*node+2] += self.lazy_add[node] self.tree_sum[2*node+1] += (mid - start + 1) * self.lazy_add[node] self.tree_sum[2*node+2] += (end - mid) * self.lazy_add[node] self.lazy_add[node] = 0 if l <= mid: res += self.query_sum(2*node+1, start, mid, l, r) if r > mid: res += self.query_sum(2*node+2, mid+1, end, l, r) return res def solve(): import sys input = sys.stdin.read data = input().split() N, Q = int(data[0]), int(data[1]) # 数组大小 和 操作数量 A = list(map(int, data[2:N+2])) # 初始化数组 st = SegmentTree(N) st.build_tree(0, 0, N-1, A) idx = N + 2 results = [] for _ in range(Q): op_type = data[idx]; idx += 1 L, R = map(int, data[idx:idx+2]); idx += 2 if op_type == 'Q': # 查询[L,R]的和 result = st.query_sum(0, 0, N-1, L-1, R-1) results.append(result) elif op_type == 'U': # 修改[L,R]+X X = int(data[idx]); idx += 1 st.update_range(0, 0, N-1, L-1, R-1, X) print("\n".join(map(str, results))) solve() ``` --- #### 关键点解析 1. **初始化与构建**:在线段树创建过程中,需要遍历输入数据并将其映射至对应的叶子节点[^1]。 2. **延迟传播机制**:为了优化性能,在执行批量更新时不立即作用于所有受影响区域,而是记录更改意图并通过后续访问逐步生效[^2]。 3. **时间复杂度分析**:由于每层最多只访问两个子树分支,因此无论是更新还是查询都维持在 $O(\log n)$ 范围内[^3]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值