ZOJ 3650 Toy Blocks(线段树+DP)

最新推荐文章于 2021-10-26 21:46:46 发布
最新推荐文章于 2021-10-26 21:46:46 发布
阅读量1.9k 收藏 1
点赞数 3
CC 4.0 BY-SA版权
分类专栏： ACM_DP ACM_数据结构 文章标签： query iterator up struct tree ini
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ACM_cxlove/article/details/8040287
本文介绍了一种解决多米诺骨牌问题的方法，利用线段树和动态规划技巧来找出最少推动几个多米诺骨牌可以使所有骨牌倒下的方案。文章详细解释了预处理多米诺骨牌能推倒的最远距离，并通过二分查找和线段树辅助确定最终策略。

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

转载请注明出处，谢谢http://blog.youkuaiyun.com/acm_cxlove/article/details/7854526       by---cxlove

题目：在一个数轴上，某些位置，有一些多米诺，问最少推动几个没有倒下的，可以把所有的都推倒

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=4840 

这题主要参考CWJ的做法，太弱了，哎

感觉如果比赛这种题目，即使有想法，也写不出来，容易乱

http://edward-mj.com/?p=615

首先可能有的位置有多个，那么显然保留最大的，这是要注意的地方 。

对于每一个多米诺，先预处理出能推倒的最左边的位置，以及最右边的位置

这一步又分为两个步骤，首先可以通过二分求出，当前木块倒下能推倒的最左边的位置

第二步是，当前木块倒下，会产生连锁反应，通过线段树的区间最值得到间接能推倒的最左边的位置。

然后是DP过程，主要就是两个转移，往左推和往右推，详见代码

#include<iostream>
#include<cstdio>
#include<map>
#include<cstring>
#include<cmath>
#include<vector>
#include<algorithm>
#include<set>
#include<string>
#include<queue>
#define inf 1<<30
#define M 6000005
#define N 110005
#define maxn 300005
#define eps 1e-8
#define zero(a) fabs(a)<eps
#define Min(a,b) ((a)<(b)?(a):(b))
#define Max(a,b) ((a)>(b)?(a):(b))
#define pb(a) push_back(a)
#define mem(a,b) memset(a,b,sizeof(a))
#define LL long long
#define lson step<<1
#define rson step<<1|1
using namespace std;
class Seg_Tree
{
public:
    struct Node
    {
        int left,right,mx,mn,cover;
    }L[N*4];
    //向上更新
    void Push_Up(int step)
    {
        if(L[step].left==L[step].right) return;
        L[step].mx=max(L[lson].mx,L[rson].mx);
        L[step].mn=min(L[lson].mn,L[rson].mn);
    }
    //向下更新延迟标记，以前更新最小值
    //向下更新操作主要用于最后一次的区间更新，所以最大值不需要管
    void Push_Down(int step)
    {
        if(L[step].cover!=inf)
        {
            L[step].mn=min(L[step].cover,L[step].mn);
            if(L[step].left!=L[step].right)
            {
                L[lson].cover=min(L[step].cover,L[lson].cover);
                L[rson].cover=min(L[step].cover,L[rson].cover);
            }
            L[step].cover=inf;
        }
    }
    void Bulid(int step,int l,int r,int val)
    {
        L[step].left=l;
        L[step].right=r;
        L[step].cover=inf;
        if(l==r)
        {
            L[step].mx=L[step].mn=val;
            return;
        }
        int m=(l+r)/2;
        Bulid(lson,l,m,val);
        Bulid(rson,m+1,r,val);
        Push_Up(step);
    }
    //点更新
    void Update(int step,int pos,int val)
    {
        if(L[step].left==pos&&L[step].right==pos)
        {
            L[step].mx=L[step].mn=val;
            return;
        }
        int m=(L[step].left+L[step].right)/2;
        if(pos<=m) Update(lson,pos,val);
        else if(pos>m) Update(rson,pos,val);
        Push_Up(step);
    }
    //段更新，用到懒惰标记
    void Update(int step,int l,int r,int val)
    {
        if(L[step].left==l&&L[step].right==r)
        {
            L[step].cover=min(L[step].cover,val);
            return;
        }
        int m=(L[step].left+L[step].right)/2;
        if(r<=m) Update(lson,l,r,val);
        else if(l>m) Update(rson,l,r,val);
        else
        {
            Update(lson,l,m,val);
            Update(rson,m+1,r,val);
        }
        Push_Up(step);
    }
    int Query_Max(int step,int l,int r)
    {
        Push_Down(step);
        if(L[step].left==l&&L[step].right==r)
        {
            return L[step].mx;
        }
        int m=(L[step].left+L[step].right)/2;
        if(r<=m) return Query_Max(lson,l,r);
        else if(l>m) return Query_Max(rson,l,r);
        else return max(Query_Max(lson,l,m),Query_Max(rson,m+1,r));
    }
    int Query_Min(int step,int l,int r)
    {

        Push_Down(step);
        if(L[step].left==l&&L[step].right==r)
        {
            return L[step].mn;
        }
        int m=(L[step].left+L[step].right)/2;
        if(r<=m) return Query_Min(lson,l,r);
        else if(l>m) return Query_Min(rson,l,r);
        else return min(Query_Min(lson,l,m),Query_Min(rson,m+1,r));
    }
}seg;
map<int,int>m;
int l[N],r[N],x[N],h[N],cnt;
int dp[N],n;
int DP()
{
    //注意这里的初始化为inf,然后每次更新最小值
    seg.Bulid(1,0,cnt-1,inf);
    for(int i=0;i<cnt;i++)
    {
        //推动这个木块，可以把左边的都推倒，则更新为1
        //更新往左推的
        if(l[i]==0) seg.Update(1,i,i,1);
        else seg.Update(1,i,i,seg.Query_Min(1,l[i]-1,i-1)+1);
        //dp[i-1]为0-(i-1)都处理掉的，然后更新第i个往右推
        int pre=i?(dp[i-1]+1):1;
        seg.Update(1,i,r[i],pre);
        dp[i]=seg.Query_Min(1,i,i);
    }
    return dp[cnt-1];
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        m.clear();
        for(int i=0;i<n;i++)
        {
            int x,h;
            scanf("%d%d",&x,&h);
            if(m.find(x)==m.end()) m[x]=h;
            else if(h>m[x]) m[x]=h;
        }
        map<int,int>::iterator it;
        cnt=0;
        //map离散化，由于每个位置的木块可能有多个，取个最高的
        for(it=m.begin();it!=m.end();it++)
        {
            x[cnt]=it->first;
            h[cnt++]=it->second;
        }
        l[0]=0;
        for(int i=1;i<cnt;i++)
        {
            int low=0,high=i,mid,ans;
            //二分查找，能直接推倒的最左边的
            while(low<=high)
            {
                mid=(low+high)>>1;
                if(x[i]-x[mid]<=h[i])
                {
                    ans=mid;
                    high=mid-1;
                }
                else low=mid+1;
            }
            l[i]=ans;

        }
        seg.Bulid(1,0,cnt-1,0);
        for(int i=0;i<cnt;i++)
        {
            seg.Update(1,i,l[i]);
            //查找他本身能直接推倒的区间内的最左边的，也就是间接能推倒的最左边的
            l[i]=seg.Query_Min(1,l[i],i);
            seg.Update(1,i,l[i]);
        }
        //以下处理能推倒的最右边的，同上
        r[cnt-1]=cnt-1;
        for(int i=cnt-2;i>=0;i--)
        {
            int low=i,high=cnt-1,mid,ans;
            while(low<=high)
            {
                mid=(low+high)>>1;
                if(x[mid]-x[i]<=h[i])
                {
                    ans=mid;
                    low=mid+1;
                }
                else high=mid-1;
            }
            r[i]=ans;
        }
        seg.Bulid(1,0,cnt-1,0);
        for(int i=cnt-1;i>=0;i--)
        {
            seg.Update(1,i,r[i]);
            r[i]=seg.Query_Max(1,i,r[i]);
            seg.Update(1,i,r[i]);
        }
        printf("%d\n",DP());
    }
    return 0;
}


CF1452 B. Toy Blocks (思维)
萧瑟的博客
11-20 982
链接：https://codeforces.com/contest/1452/problem/B You are asked to watch your nephew who likes to play with toy blocks in a strange way. He has n boxes and the i-th box has ai blocks. His game consists of two steps: he chooses an arbitrary box i; he tries t
Summary
热门推荐
ADP+Pi==ATP
07-10 1万+
ATP感觉自己退役之前是用不上机房的空调了【笑
ZOJ 3650 Toy Blocks（DP + 线段树优化转移）
nyist_xiaod
07-22 1122
题目链接：Click here~~ 题意： 给出 n 个多米诺骨牌的 X 坐标以及高度 H，每次你可以选任意一张向左推或向右推，推倒后，会产生连锁反应，问最少几次能把所有的骨牌推倒。 解题思路： 先预处理出每张牌向 左/右 推能推到的最远位置，记为 l[i] 和 r[i]。这步可以通过递推的方法在均摊总复杂度为 O(n) 下得到。 然后 dp[i][dir
ZOJ Toy Blocks
Yukar_syt的专栏
10-07 853
#include #include #include using namespace std; typedef long long lld; const int maxn=100005; struct Node{ lld x; lld h; bool operator <(const Node &t)const { return x<t.x; } }p[maxn]; lld R[
B. Toy Blocks
qq_45719639的博客
11-23 783
B. Toy Blocks 题意 有 n 个盒子，每个盒子有 a_i 个糖果。现在你可以向一些盒子中添加糖果，使得任选一个盒子，将其中的糖果分到其余 n-1 个盒子中，每个盒子的糖果数量相等。问最少需要添加多少糖。 思路 因为必须是n-1的倍数，那最小值肯定是max（n-1），但是这个最小值不一定满足大于等于这n个盒子中糖果的总和，本来我只写了一个while循环，如果max（n-1）小于sum的时候，就让max加一，直到max（n-1）大于sum时跳出循环，本来是过了，但是后来被hack了。 超时代码 #i
Toy Blocks
m0_52398496的博客
10-26 230
DIV2-B 题意： 给一个数组，对于任选数组中的一个数，然后把这个数都分给别的元素，然后别的元素都要相同。然后你可以给数组中的元素增加，求最少加的数。 思考： 明显，删去一个数后就剩下n-1个数，那么数组的总和一定要能整除n-1对吧。这样才能均匀分配，然后再和数组中的最大值取一个max。然后看看缺少多少即可。当然我刚开始想了很久，还傻逼地用了set每次直接加上，但是想了想，当前不够操作的，我为什么一定要加给某个元素？而且我不知道该如何去加，所以干脆就不加，就拿在手里，到时候谁用给谁即可，然后如果够的话，看
CF1452B Toy Blocks
QiuHong 的博客
11-20 435
题意 给定n个盒子a，aia_iai​表示第i个盒子中积木的数量。 可以将一些额外的积木放置到n个盒子中，使得下面的操作成立，将需要的额外的积木的最小值输出。 任意选中一个i，将aia_iai​中的所有积木放到其他n-1个盒子中，存在一种方案能够使n-1个盒子中的积木数量相等。 题解 考虑两种情况 一般的情况，保证 sum mod (n−1)=0sum\ mod \ (n-1) =0sum mod (n−1)=0以保证总量能够被除尽 k=⌈sumn−1⌉ k
Educational Codeforces Round 98 (Rated for Div. 2)------Toy Blocks
小` pi孩
11-21 278
题目 You are asked to watch your nephew who likes to play with toy blocks in a strange way. He has n boxes and the i-th box has ai blocks. His game consists of two steps: he chooses an arbitrary box i; he tries to move all blocks from the i-th box to other b
1452B Toy Blocks
Moyan的博客
11-20 368
题目链接 题意 给定n个盒子a，aia_iai​表示第i个盒子中积木的数量。 可以将一些额外的积木放置到n个盒子中，使得下面的操作成立，将需要的额外的积木的最小值输出。 任意选中一个i，将aia_iai​中的所有积木放到其他n-1个盒子中，存在一种方案能够使n-1个盒子中的积木数量相等。 思路 s为现有积木的总个数 mx为盒子中最大的积木个数 k为将所有积木放到n-1个盒子中的平均值(向上取整) k=⌈sn−1⌉ k = \lceil\frac{s}{n-1}\rceil k=⌈n−1s​⌉ 为了
Educational Codeforces Round 98 (Rated for Div. 2) B. Toy Blocks 贪心
qq_45891413的博客
11-21 268
You are asked to watch your nephew who likes to play with toy blocks in a strange way. He has n boxes and the i-th box has ai blocks. His game consists of two steps: he chooses an arbitrary box i; he tries to move all blocks from the i-th box to other boxe
zoj 1910 Blocks
yzl_rex
03-16 459
#include "iostream" #include "cmath" using namespace std; int main() { int C, N, a, b, c, ans, temp; cin >> C; while (C--) { cin >> N; temp = 0; ans = 1000 * 1000 * 1000; for (a = 1; a *a
Educational Codeforces Round 98 -B - Toy Blocks (思维)
wmy0536的博客
11-20 2441
题目链接 题目大意： n个盒子，每个盒子里有a[i]个球， 对于任意一个盒子，可以把其中的球随意分配到其他（n-1）个盒子当中，使得n-1个盒子中的球数目相等，求 向n个盒子中最少添加多少个球才能实现上述操作 题目思路： 设最少向盒子添加 x个球，n个盒子的所有球的个数为sum 因为每个盒子的最终状态可以确定 是 都相等的 所以设最终状态的数字是ava 有 (sum+x)%(n-1)==0 (sum+x)/(n-1)==ava 设n个盒子中的最大值为ma 有 ma>=ava 联立框1框2，有 ma
Educational Codeforces Round 98 (Rated for Div. 2) B. Toy Blocks
solego’s blog
11-20 455
题意： 给定nnn个盒子，每个盒子有aia_iai​个物品，问你至少需要往这些盒子中添加多少个物品，才能使得无论选择哪一个盒子iii，将aia_iai​分给剩余n−1n-1n−1个盒子，剩余n−1n-1n−1个盒子中的物品数都一样。 数据范围：2≤n≤105,0≤ai≤1092\leq n\leq 10^5, 0\leq a_i\leq 10^92≤n≤105,0≤ai​≤109 题解： 考虑选择第iii个盒子，剩下n−1n-1n−1个盒子中物品最多的盒子为jjj，分完第iii个盒子后每个盒子物品数量为av
Codeforces 1452 B. Toy Blocks（二分）
tomjobs的博客
11-21 2112
You are asked to watch your nephew who likes to play with toy blocks in a strange way. He has ???? boxes and the ????-th box has ???????? blocks. His game consists of two steps: he chooses an arbitrary box ????; he tries to move all blocks from the ????-th
ZOJ 3650(多米诺骨牌 dp + 线段树优化)
乐观之奋斗者
05-30 1648
题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3650 题意： 给你n个骨牌，每个骨牌有一个在x轴上的位置和高度，每个骨牌可以想左推也可以向右推，问最少多少步可以把骨牌全部推倒。 思路： 之前Goodbye 2014 上的E题就是一道多米诺骨牌的题目，虽然跟这道题目不太一样但是
ZOJ - 2850
林伊的博客
03-20 267
 Tom's Meadow Tom has a meadow in his garden. He divides it into N * M squares. Initially all the squares were covered with grass. He mowed down the grass on some of the squares and thinks the meadow ...
zoj1088线段树
最新发布
05-08
### 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、付费专栏及课程。

余额充值