bzoj 3991 [SDOI2015]寻宝游戏

本文介绍了一种用于计算寻宝游戏中最短路径的高效算法。游戏中包含多个村庄及变动的宝物位置,需要实时更新最短路径。通过构建虚拟树结构并使用DFS序列动态维护,实现快速查找及更新。

http://www.elijahqi.win/archives/3341
Description
小B最近正在玩一个寻宝游戏,这个游戏的地图中有N个村庄和N-1条道路,并且任何两个村庄之间有且仅有一条路径可达。游戏开始时,玩家可以任意选择一个村庄,瞬间转移到这个村庄,然后可以任意在地图的道路上行走,若走到某个村庄中有宝物,则视为找到该村庄内的宝物,直到找到所有宝物并返回到最初转移到的村庄为止。小B希望评测一下这个游戏的难度,因此他需要知道玩家找到所有宝物需要行走的最短路程。但是这个游戏中宝物经常变化,有时某个村庄中会突然出现宝物,有时某个村庄内的宝物会突然消失,因此小B需要不断地更新数据,但是小B太懒了,不愿意自己计算,因此他向你求助。为了简化问题,我们认为最开始时所有村庄内均没有宝物

Input
第一行,两个整数N、M,其中M为宝物的变动次数。

接下来的N-1行,每行三个整数x、y、z,表示村庄x、y之间有一条长度为z的道路。
接下来的M行,每行一个整数t,表示一个宝物变动的操作。若该操作前村庄t内没有宝物,则操作后村庄内有宝物;若该操作前村庄t内有宝物,则操作后村庄内没有宝物。

Output
M行,每行一个整数,其中第i行的整数表示第i次操作之后玩家找到所有宝物需要行走的最短路程。若只有一个村庄内有宝物,或者所有村庄内都没有宝物,则输出0。

Sample Input
4 5
1 2 30
2 3 50
2 4 60
2
3
4
2
1
Sample Output
0
100
220
220
280
HINT
1<=N<=100000

1<=M<=100000
对于全部的数据,1<=z<=10^9
Source
Round 1 感谢yts1999上传

结论题 考虑最短距离应该就是两两之间距离*2即可

那么用set模拟虚树建树的过程 每次在set里面动态维护dfs序列 的大小关系那么新插入就相当于找一个dfs序列上与我相邻的两个点 即前驱后继 那么计算答案的时候只需要 将 当前点到前驱后继的答案加上减去前去到后继的距离即可 删除同理 为逆操作

#include<set>
#include<cstdio>
#include<cctype>
#include<algorithm>
#define ll long long
using namespace std;
inline char gc(){
    static char now[1<<16],*S,*T;
    if(T==S){T=(S=now)+fread(now,1,1<<16,stdin);if (T==S) return EOF;}
    return *S++;
}
inline int read(){
    int x=0,f=1;char ch=gc();
    while(!isdigit(ch)) {if (ch=='-') f=-1;ch=gc();}
    while(isdigit(ch)) x=x*10+ch-'0',ch=gc();
    return x*f;
}
const int N=100100;
const int inf=0x3f3f3f3f;
struct node{
    int y,next,z;
}data[N<<1];
int h[N],dep[N],dfn[N],n,m,Log[N],fa[N][20],cnt,num;ll dis[N],ans;bool mark[N];
struct cmp{
    inline bool operator()(const int &a,const int &b){return dfn[a]<dfn[b];}
};
set<int,cmp> s;
set<int,cmp>::iterator it1,it2;
inline void dfs(int x){
    dfn[x]=++cnt;
    for (int i=h[x];i;i=data[i].next){
        int y=data[i].y,z=data[i].z;if(y==fa[x][0]) continue;
        dep[y]=dep[x]+1;dis[y]=dis[x]+data[i].z;fa[y][0]=x;
        for (int j=1;j<=Log[dep[y]];++j) fa[y][j]=fa[fa[y][j-1]][j-1];dfs(y);
    }
}
inline int lca(int x,int y){
    if(dep[x]<dep[y]) swap(x,y);int dis=dep[x]-dep[y];
    for (int i=0;i<=Log[dis];++i) if ((1<<i)&dis) x=fa[x][i];
    if (x==y) return x;
    for (int i=Log[dep[y]];~i;--i) if (fa[x][i]!=fa[y][i]) x=fa[x][i],y=fa[y][i];
    return fa[x][0];
}
inline ll calc(int x,int y){
    return dis[x]+dis[y]-(dis[lca(x,y)]<<1);
}
int main(){
    freopen("bzoj3991.in","r",stdin);
    n=read();m=read();Log[0]=-1;for (int i=1;i<=n;++i) Log[i]=Log[i>>1]+1;
    for (int i=1;i<n;++i){
        int x=read(),y=read(),z=read();
        data[++num].y=y;data[num].next=h[x];h[x]=num;data[num].z=z;
        data[++num].y=x;data[num].next=h[y];h[y]=num;data[num].z=z;
    }dfs(1);cnt=0;
    for (int i=1;i<=m;++i){
        int t=read();
        if (mark[t]){
            --cnt;mark[t]=0;if (cnt<=1) {s.erase(t);puts("0");continue;}
            it1=s.lower_bound(t);it2=s.upper_bound(t);
            if (it1==s.begin()){
                it1=s.end();--it1;
                ans-=calc(t,*it1);ans-=calc(t,*it2);ans+=calc(*it1,*it2);
                s.erase(t);printf("%lld\n",ans);continue;
            }
            if (it2==s.end()){
                --it1;it2=s.begin();
                ans-=calc(t,*it1);ans-=calc(t,*it2);ans+=calc(*it1,*it2);
                s.erase(t);printf("%lld\n",ans);continue;
            }--it1;s.erase(t);
            ans-=calc(t,*it1);ans-=calc(t,*it2);ans+=calc(*it1,*it2);
            printf("%lld\n",ans);
        }else{
            ++cnt;mark[t]=1;if (cnt<=1) {s.insert(t);puts("0");continue;}
            it1=s.lower_bound(t);it2=s.upper_bound(t);
            if (it1==s.begin()){
                it1=s.end();--it1;
                ans+=calc(t,*it1);ans+=calc(t,*it2);ans-=calc(*it1,*it2);
                s.insert(t);printf("%lld\n",ans);continue;
            }
            if (it2==s.end()){
                --it1;it2=s.begin();
                ans+=calc(t,*it1);ans+=calc(t,*it2);ans-=calc(*it1,*it2);
                s.insert(t);printf("%lld\n",ans);continue;
            }--it1;s.insert(t);
            ans+=calc(t,*it1);ans+=calc(t,*it2);ans-=calc(*it1,*it2);
            printf("%lld\n",ans);
        }
    }
    return 0;
}
WP7 Platformer寻宝游戏源码 项目描述 Platformer中的13个类的中心思想分别概述下:   1:PlatformerGame类,它是整个游戏的控制中心,除了告知游戏中所有的对象什么时候响应显示外,还负责内容管道关卡的加载,以及游戏中各种对象的更新。可谓是劳苦功高   2:Level类 ,它是游戏的关卡类。每个关卡对象包含了一个用于存放场景瓷砖信息的多维数组,英雄、游戏开始结束位置的坐标、总分数、游戏剩余时间、一系列宝石僵尸怪的信息。   3:Player类用于实现英雄的加载、绘制更新操作。   4:Enemy类,负责僵尸怪的加载、绘制更新操作。   5:Gem类在游戏中实现一个悬浮在空中的宝石,不同类型的宝石所含的分值也不相同。英雄的主要任务就是收集这些宝石。有关宝石的加载、绘制更新也由Gem类负责。   6:Tile 结构。Tile如同我们现实中的瓷砖一样,我们可以在每个Tile中包含一个游戏元素,这样就可以拼接成我们期望的游戏场景。在Platformer游戏中我们用这些Tile构成形成关卡的场景图。   7:Animation类,望文生义,当然是游戏候中不可或缺的动画类,它主要是解析游戏中包含的众多Sprites(精灵)图片,以实现动画的帧分解。   8: AnimationPlayer类实现了将Animation类定义的精灵图片中的每一帧形成连贯的动画。   9:Circle类专门只用于Gem类的,它定义了一个包围Gem的圆,以实现主角宝石的碰撞检测。   10:RectangleExtension累是Rectangle的一个扩展静态类,同样由于碰撞检测。   11:Program是所有XNA项目的启动类,也是程序的入口。   12:TouchCollectionExtensions类是针对WP7的触摸屏输入而实现的一个扩展类,以检测触摸屏是否存在触点。   13:Accelerometer类对WP7中的加速度传感器做了封装,左右倾斜手机可以实现主角向左或向右的移动。 此源码仅供学习之用
### NOIP2015 运输计划 BZOJ4326 题解分析 #### 问题背景 该问题是经典的图论优化问题之一,主要考察树结构上的路径操作以及高效的数据处理能力。题目要求在一个由 $n$ 个节点组成的无向连通树中找到最优的一边将其改造为虫洞(通过此边不需要耗费时间),从而使得给定的 $m$ 运输路径中的最长耗时最小化。 --- #### 解决方案概述 解决这一问题的核心在于利用 **二分答案** **树上差分技术** 的组合来实现高效的计算过程。以下是具体的技术细节: 1. **二分答案**: 设当前目标是最小化的最大路径长度为 $T_{\text{max}}$。我们可以通过二分的方式逐步逼近最终的结果。每次尝试验证是否存在一种方式将某边改为虫洞后使所有路径的最大值不超过当前设定的目标值 $mid$[^1]。 2. **路径标记与统计**: 使用树上差分的思想对每一路径进行标记并快速统计受影响的情况。假设两点之间的最近公共祖先 (Lowest Common Ancestor, LCA) 是 $r = \text{lca}(u_i, v_i)$,则可以在三个位置分别施加影响:增加 $(u_i + 1), (v_i + 1)$ 同时减少 $(r - 2)$。这种操作能够有效覆盖整路径的影响范围,并便于后续统一查询判断[^1]。 3. **数据结构支持**: 结合线段树或者 BIT (Binary Indexed Tree),可以进一步加速区间修改单点查询的操作效率。这些工具帮助我们在复杂度范围内完成大量路径的同时更新检索需求[^2]。 4. **实际编码技巧**: 实现过程中需要注意一些边界技术要点: - 正确维护 DFS 序列以便映射原树节点到连续编号序列; - 准备好辅助函数用于快速定位 LCA 节点及其对应关系; - 编码阶段应特别留意变量初始化顺序及循环终止逻辑以防潜在错误发生。 下面给出一段基于上述原理的具体 Python 实现代码作为参考: ```python from collections import defaultdict, deque class Solution: def __init__(self, n, edges): self.n = n self.graph = defaultdict(list) for u, v, w in edges: self.graph[u].append((v, w)) self.graph[v].append((u, w)) def preprocess(self): """Preprocess the tree to get dfs order and lca.""" pass def binary_search_answer(self, paths): low, high = 0, int(1e9) best_possible_time = high while low <= high: mid = (low + high) // 2 if self.check(mid, paths): # Check feasibility with current 'mid' best_possible_time = min(best_possible_time, mid) high = mid - 1 else: low = mid + 1 return best_possible_time def check(self, limit, paths): diff_array = [0]*(self.n+1) for path_start, path_end in paths: r = self.lca(path_start, path_end) # Apply difference on nodes based on their relationship. diff_array[path_start] += 1 diff_array[path_end] += 1 diff_array[r] -= 2 suffix_sum = [sum(diff_array[:i]) for i in range(len(diff_array)+1)] # Verify whether any edge can be modified within given constraints. possible_to_reduce_max = False for node in range(1, self.n+1): parent_node = self.parent[node] if suffix_sum[node]-suffix_sum[parent_node]>limit: continue elif not possible_to_reduce_max: possible_to_reduce_max=True return possible_to_reduce_max # Example usage of class methods would follow here... ``` --- #### 总结说明 综上所述,本题的关键突破点在于如何巧妙运用二分策略缩小搜索空间,再辅以恰当的树形结构遍历技术差分手段提升整体性能表现。这种方法不仅适用于此类特定场景下的最优化求解任务,在更广泛的动态规划领域也有着广泛的应用前景[^3]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值