dfs+线段树______Snakes(hdu 5692 2016百度之星初赛A)

最新推荐文章于 2019-08-20 16:04:00 发布
最新推荐文章于 2019-08-20 16:04:00 发布
阅读量1.3k 收藏 2
点赞数 1
分类专栏： ACM_日常 文章标签： 线段树 dfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y1196645376/article/details/51675487
版权

Problem Description

百度科技园内有nn个零食机，零食机之间通过n-1n−1条路相互连通。每个零食机都有一个值vv，表示为小度熊提供零食的价值。

由于零食被频繁的消耗和补充，零食机的价值vv会时常发生变化。小度熊只能从编号为0的零食机出发，并且每个零食机至多经过一次。另外，小度熊会对某个零食机的零食有所偏爱，要求路线上必须有那个零食机。

为小度熊规划一个路线，使得路线上的价值总和最大。

Input

输入数据第一行是一个整数T(T\leq 10)T(T≤10)，表示有TT组测试数据。

对于每组数据，包含两个整数n,m(1\leq n,m\leq 100000)n,m(1≤n,m≤100000)，表示有nn个零食机，mm次操作。

接下来n-1n−1行，每行两个整数xx和y(0\leq x,y < n)y(0≤x,y<n)，表示编号为xx的零食机与编号为yy的零食机相连。

接下来一行由nn个数组成，表示从编号为0到编号为n-1n−1的零食机的初始价值v(|v| < 100000)v(∣v∣<100000)。

接下来mm行，有两种操作：0\ x\ y0 x y，表示编号为xx的零食机的价值变为yy；1\ x1 x，表示询问从编号为0的零食机出发，必须经过编号为xx零食机的路线中，价值总和的最大值。

本题可能栈溢出，辛苦同学们提交语言选择c++，并在代码的第一行加上：

#pragma comment(linker, "/STACK:1024000000,1024000000")

Output

对于每组数据，首先输出一行”Case #?:”，在问号处应填入当前数据的组数，组数从1开始计算。

对于每次询问，输出从编号为0的零食机出发，必须经过编号为xx零食机的路线中，价值总和的最大值。

Sample Input 
1
6 5
0 1
1 2
0 3
3 4
5 3
7 -5 100 20 -5 -7
1 1
1 3
0 2 -1
1 1
1 5
Sample Output 
Case #1:
102
27
2
20


分析：很显然这个一个树，视作0为根节点。从0号节点到某一节点有且只有一条可达路径。那么每个节点i可以对应一个路径(从0到i这条路径)。对路径通过后序遍历重新编号为1~n.叶子节点所对应区间为[Ki,Kii].Ki为该节点对应的路径的编号。对于非叶子节点对应区间为[Min,Max],Min是该节点所有孩子节点区间左端点中最小的。Max肯定为自身(因为父节点的路径编号要大于孩子节点的路径编号)。那么这个区间的意义是？ 如果一个节点C的区间为[1,3]那么1,2,3这三个编号对应的路径中都经过节点C。并且可以算出每个路径的值也就是说节点0到每个节点的路径长度.NUM[I] 0~i路径的长度。

那么查询操作求经过X节点的最大路径就是X对应的区间[ L[X],R[X] ]中的这些路径对应NUM值的最大值。注意：这里是找一个区间的最大值。

而修改操作让X节点的值改为Y，也就是将X对应区间[ L[X],R[X] ]中这些路径对应的每个NUM值都加上Y-V[X]。(V[X]为原本X节点的价值)。 注意：这里是修改一个区间的值。

所以我们可以看出来，我们可以先用dfs处理，然后用线段树去优化后面的操作。


代码：

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<vector>
#define ll long long
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
const int MAXN = 100100;
vector<int> edge[MAXN];
int m,n;

struct treenode
{
    int left,right,mid;
    ll maxx,add;
}tree[MAXN<<4];

int L[MAXN],R[MAXN],index;
int w[MAXN];
ll num[MAXN];
void built(int l,int r,int rt)
{
    tree[rt].left = l;
    tree[rt].right = r;
    tree[rt].mid = (l+r)>>1;
    tree[rt].add = 0;
    if(l == r)
    {
        tree[rt].maxx = num[l];
        return;
    }
    built(l,tree[rt].mid,rt<<1);
    built(tree[rt].mid+1,r,(rt<<1)|1);
    tree[rt].maxx = max(tree[rt<<1].maxx,tree[(rt<<1)|1].maxx);
}

void update(int rt,int l,int r,int data)
{
    if(tree[rt].left == l && r == tree[rt].right)
    {
        tree[rt].add += data;
        return;
    }
    if(tree[rt].add != 0)
    {
        tree[rt<<1].add += tree[rt].add;
        tree[(rt<<1)|1].add += tree[rt].add;
        tree[rt].add = 0;
    }
    if(r <= tree[rt].mid)
    {
        update(rt<<1,l,r,data);
    }
    else if( l > tree[rt].mid)
    {
        update((rt<<1)|1,l,r,data);
    }
    else
    {
        update(rt<<1,l,tree[rt].mid,data);
        update((rt<<1)|1,tree[rt].mid+1,r,data);
    }
    tree[rt].maxx = max(tree[rt<<1].maxx + tree[rt<<1].add,tree[(rt<<1)|1].maxx + tree[(rt<<1)|1].add);
}

ll query(int rt,int l,int r)
{
    if(tree[rt].left == l && r == tree[rt].right )
    {
        return tree[rt].maxx + tree[rt].add;
    }
    if(tree[rt].add != 0)
    {
        tree[rt<<1].add += tree[rt].add;
        tree[(rt<<1)|1].add += tree[rt].add;
        tree[rt].add = 0;
    }
    ll ans;
    if(r <= tree[rt].mid)
    {
        ans = query(rt<<1,l,r);
    }
    else if( l > tree[rt].mid)
    {
        ans = query((rt<<1)|1,l,r);
    }
    else
    {
       ans = max(query(rt<<1,l,tree[rt].mid),query((rt<<1)|1,tree[rt].mid+1,r));
    }
    tree[rt].maxx = max(tree[rt<<1].maxx + tree[rt<<1].add,tree[(rt<<1)|1].maxx + tree[(rt<<1)|1].add);
    return ans;
}

void dfs(int now,int pre,ll sum)
{
    sum += w[now];
    int son = 0;
    L[now] = MAXN;
    for(int i = 0 ; i < edge[now].size() ; i ++)
    {
        int next = edge[now][i];
        if(next == pre) continue;
        son ++;
        dfs(next,now,sum);
        L[now] = min(L[now],L[next]);
    }
    R[now] = ++index;
    num[index] = sum;
    if(son == 0)
    {
        L[now] = R[now];
    }
}
int main()
{
    int t,Case = 0;
    cin >> t;
    while(t--)
    {
        printf("Case #%d:\n",++Case);
        cin >> n >> m;
        int u,v;
        for(int i = 0 ; i <= n ; i ++) edge[i].clear();
        for(int i = 0 ; i < n - 1 ; i ++)
        {
            cin >> u >> v;
            edge[u].push_back(v);
            edge[v].push_back(u);
        }
        for(int i = 0 ; i < n ; i ++)
            scanf("%d",&w[i]);
        index = 0;
        dfs(0,0,0);
        built(1,n,1);
        int op;
        for(int i = 0 ; i < m ; i ++)
        {
            scanf("%d",&op);
            if(op == 0)
            {
                int x,y;
                scanf("%d%d",&x,&y);
                int data = y - w[x];
                w[x] = y;
                update(1,L[x],R[x],data);
            }
            else
            {
                int x;
                scanf("%d",&x);
                printf("%lld\n",query(1,L[x],R[x]));
            }
        }
    }
    return 0;
}


上面代码的线段树写略丑。应该是更新的姿势不太对。

下面这个线段树时间要比上面的快很多

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<vector>
#define ll long long
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
const int MAXN = 100100;
vector<int> edge[MAXN];
int m,n;

struct treenode
{
    int left,right,mid;
    ll maxx,add;
}tree[MAXN<<4];

int L[MAXN],R[MAXN],index;
ll w[MAXN],num[MAXN];

void built(int l,int r,int rt)
{
    tree[rt].left = l;
    tree[rt].right = r;
    tree[rt].mid = (l+r)>>1;
    tree[rt].add = 0;
    if(l == r)
    {
        tree[rt].maxx = num[l];
        return;
    }
    built(l,tree[rt].mid,rt<<1);
    built(tree[rt].mid+1,r,(rt<<1)|1);
    tree[rt].maxx = max(tree[rt<<1].maxx,tree[(rt<<1)|1].maxx);
}

void update(int rt,int l,int r,ll data)
{
    if(tree[rt].add != 0)
    {
        if(tree[rt].left != tree[rt].right)
        {
            tree[rt<<1].maxx += tree[rt].add;
            tree[rt<<1].add += tree[rt].add;
            tree[(rt<<1)|1].maxx += tree[rt].add;
            tree[(rt<<1)|1].add += tree[rt].add;
            tree[rt].add = 0;
        }
    }
    if(tree[rt].left == l && r == tree[rt].right)
    {
        tree[rt].maxx += data;
        tree[rt].add += data;
        return;
    }

    if(r <= tree[rt].mid)
    {
        update(rt<<1,l,r,data);
    }
    else if( l > tree[rt].mid)
    {
        update((rt<<1)|1,l,r,data);
    }
    else
    {
        update(rt<<1,l,tree[rt].mid,data);
        update((rt<<1)|1,tree[rt].mid+1,r,data);
    }
    tree[rt].maxx = max(tree[rt<<1].maxx,tree[(rt<<1)|1].maxx);
}

ll query(int rt,int l,int r)
{
    if(tree[rt].add != 0)
    {
        if(tree[rt].left != tree[rt].right)
        {
            tree[rt<<1].maxx += tree[rt].add;
            tree[rt<<1].add += tree[rt].add;
            tree[(rt<<1)|1].maxx += tree[rt].add;
            tree[(rt<<1)|1].add += tree[rt].add;
            tree[rt].add = 0;
        }
    }
    if(tree[rt].left == l && r == tree[rt].right )
    {
        return tree[rt].maxx;
    }
    if(r <= tree[rt].mid)
    {
        return query(rt<<1,l,r);
    }
    else if( l > tree[rt].mid)
    {
        return query((rt<<1)|1,l,r);
    }
    else
    {
       return max(query(rt<<1,l,tree[rt].mid),query((rt<<1)|1,tree[rt].mid+1,r));
    }
}

void dfs(int now,int pre,ll sum)
{
    sum += w[now];
    int son = 0;
    L[now] = MAXN;
    for(int i = 0 ; i < edge[now].size() ; i ++)
    {
        int next = edge[now][i];
        if(next == pre) continue;
        son ++;
        dfs(next,now,sum);
        L[now] = min(L[now],L[next]);
    }
    R[now] = ++index;
    num[index] = sum;
    if(son == 0)
    {
        L[now] = R[now];
    }
}
int main()
{
    int t,Case = 0;
    cin >> t;
    while(t--)
    {
        printf("Case #%d:\n",++Case);
        scanf("%d%d",&n,&m);
        int u,v;
        for(int i = 0 ; i <= n ; i ++) edge[i].clear();
        for(int i = 0 ; i < n - 1 ; i ++)
        {
            scanf("%d%d",&u,&v);
            edge[u].push_back(v);
            edge[v].push_back(u);
        }
        for(int i = 0 ; i < n ; i ++)
            scanf("%lld",&w[i]);
        index = 0;
        dfs(0,0,0);
        built(1,n,1);
        int op;
        for(int i = 0 ; i < m ; i ++)
        {
            scanf("%d",&op);
            if(op == 0)
            {
                int x,y;
                scanf("%d%d",&x,&y);
                ll data = y - w[x];
                w[x] = y;
                update(1,L[x],R[x],data);
            }
            else
            {
                int x;
                scanf("%d",&x);
                printf("%lld\n",query(1,L[x],R[x]));
            }
        }
    }
    return 0;
}





YzlCoder
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
a_snakes_game_in_java.zip_Snakes
09-21
在"A Snakes Game in Java"中，可以看到各个类的职责划分明确。例如，Snake类代表蛇，Food类表示食物，GameBoard类处理游戏逻辑，UI类则负责图形界面的展示。通过阅读源代码，我们可以了解如何将这些组件组合起来，...
snakes_with_class.zip_Snakes
09-23
在压缩包"snakes_with_class.zip_Snakes"中，"license.txt"文件包含了该代码库的授权信息，而"snakes_with_class"可能是实现Snake算法的Matlab类文件。通过阅读和理解这个类的源代码，你可以更好地掌握如何在实际...
2016 百度之星 初赛A
世界很大
05-21 1254
A：hdoj 5690 All X 打个表看了看，发现循环最大不超过k，因为k最大为10000，就先暴力找一下，最多找k次。我们边找边记录结果，若发现相同的就说明找到一个循环节，直接跳出即可。 AC代码：#include <cstdio> #include <cstring> #include <cmath> #include <map> #include <set> #include <ios
Snakes & Ladders
逍遥
03-05 713
题目大意： 题目的大概意思是又N*N的棋盘，编号从1 到 N*N 棋盘中分布着蛇和梯子玩家在位置1处，   然后掷骰子，如果点数在梯子尾则顺着梯子到达梯子头，若掷到蛇头，则滑到蛇尾   问最快到达终点所需掷的次数...   解题思路： bfs，创建两个地图，一个为前一步的地图，一个为这次能走的地图   #include&lt;iostream&gt; #include&lt;cstdi...
poj2588 snakes （并查集判断连通性+几何）
Icefox的博客
09-04 590
最重要的写在最前面:这题要用c++编译器才能过！！！默认的G++过不了！！！坑害多少生灵，╭(╯^╰)╮ 首先要发现，如果上下边界联通则一定过不去。我们把上边界叫做0，下边界叫做n+1，与他们相交的合并进一个集合，两圆相交的也合并进一个集合。看上下边界是否在同一个集合里即可判断能否通过。然后是找最大值的问题。先看起点的最大值，什么样的圆才会影响我们的起点最大值呢？至少，这个圆要与起点线（即左边界）
Bstar2016的一道水题T3
bblss123的博客
05-21 649
SnacksProblem Description 百度科技园内有n个零食机，零食机之间通过n−1条路相互连通。每个零食机都有一个值v，表示为小度熊提供零食的价值。由于零食被频繁的消耗和补充，零食机的价值v会时常发生变化。小度熊只能从编号为0的零食机出发，并且每个零食机至多经过一次。另外，小度熊会对某个零食机的零食有所偏爱，要求路线上必须有那个零食机。为小度熊规划一个路线，使得路线上的价值总和最大
2016"百度之星" - 初赛（Astar Round2A）1001~1006
humeay的博客
06-03 3076
1001 All XProblem Description：F(x,m) 代表一个全是由数字x组成的m位数字。请计算，以下式子是否成立：F(x,m) mod k ≡ c#include<stdio.h> #include<string.h> #include<iostream> #include<algorithm> #include<math.h> #include<queue> #include
snake_test.rar_2D contour_Snakes _active contour_contour
09-22
Active contour, also called snakes, is a framework for delineating an object outline from a possibly noisy 2D image.
snake.m.rar.rar_search image_snake_snake.m_snakes m_snakes matla
07-14
snakes are a variational technique to find the best contour that aligns with an image. The basic routine, snake.m, aligns a sequence of points along a contour to the maximum of an array or image. ...
sdt-tar.gz_distance_distance transform
09-23
The salience distance transform incorporates edge strength information into the distance transform. The output is more robust and informative as input for techniques such as snakes
【图论+线段树】[2016"百度之星" - 初赛(Astar Round2A)]Snacks
weixin_30532987的博客
05-21 95
题目 Problem Description 百度科技园内有n个零食机，零食机之间通过n−1条路相互连通。每个零食机都有一个值v，表示为小度熊提供零食的价值。 由于零食被频繁的消耗和补充，零食机的价值v会时常发生变化。小度熊只能从编号为0的零食机出发，并且每个零食机至多经过一次。另外，小度熊会对某个零食机的零食有所偏爱，要求路线上必须有那个零食机。 为小度熊规划一个路线...
acm.hdu.edu.cn-1107武林采用小型项目式解决方案
weixin_30475039的博客
03-16 310
武林 Time Limit: 10000/5000 MS (Java/Others)Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 1007Accepted Submission(s): 274 Problem Description 在一个有12行12列的方形的武林世界里，少林、武当和峨嵋三派的弟子...
计蒜客（青出于蓝胜于蓝） dfs序+树状数组
scau_rb
03-26 509
武当派一共有 n 人，门派内 n 人按照武功高低进行排名，武功最高的人排名第 1，次高的人排名第 2，... 武功最低的人排名第 n。现在我们用武功的排名来给每个人标号，除了祖师爷，每个人都有一个师父，每个人可能有多个徒弟。我们知道，武当派人才辈出，连祖师爷的武功都只能排行到 pp。也就是说徒弟的武功是可能超过师父的，所谓的青出于蓝胜于蓝。请你帮忙计算每个人的所有子弟（包括徒弟的徒弟，徒弟的徒弟的...
【线段树+dfs序 模板】hdu 5692 ，百毒之星A 题目 snacks dfs 序 +线段树维护最大值
qq_24664053的博客
05-24 598
其实 讲道理这是一道不难的“裸题”现在是 凌晨两点 ，不想打太多字，进入正题吧： 题意中文 ： 百度科技园内有n个零食机，零食机之间通过n−1条路相互连通。每个零食机都有一个值v，表示为小度熊提供零食的价值。由于零食被频繁的消耗和补充，零食机的价值v会时常发生变化。小度熊只能从编号为0的零食机出发，并且每个零食机至多经过一次。另外，小度熊会对某个零食机的零食有所偏爱，要求路线上必须有那个零食机。
Snacks HDU 5692 dfs序列+线段树
weixin_30715523的博客
08-20 113
Snacks HDU 5692 dfs序列+线段树 题意 百度科技园内有n个零食机，零食机之间通过n−1条路相互连通。每个零食机都有一个值v，表示为小度熊提供零食的价值。 由于零食被频繁的消耗和补充，零食机的价值v会时常发生变化。小度熊只能从编号为0的零食机出发，并且每个零食机至多经过一次。另外，小度熊会对某个零食机的零食有所偏爱，要求路线上必须有那个零食机。 为小度熊规划一个路线，使...
Tree HDU - 6394 (倍增+树分块)
untilyouydc
08-15 334
Alice and Bob are playing with a magic tree This magic tree has nn nodes,with n−1n−1 magic paths connecting them into a connected block. Node 11 is at the top of the magic tree (layer 00). Node ii is ...
(一)再见了,我亲密的战友们 人一口福
水上漂的专栏
03-30 2779
 再见了，我亲密的战友们今天，是个阳光明媚的日子。今天，是个难忘的日子-----因为我，即将离开，踏向新的人生征程。昨天聚首，今日离别，我亲密的战友们，请允许我轻轻的，说声再见：再见了，我亲密的战友们。回忆起曾经一起工作，生活的点点滴滴，是那样的历历在目------生活中：大娘水饺，一起共度的快乐晚餐川行天下，共享看似奢侈的套餐还有开年饭，举杯共饮的欢乐时刻……..工作中：我问你答，策划兄弟们耐心细致的讲解你提我改，策划兄弟们不厌其烦的测试你来我往，前后端兄弟们积极配合，让断点飞………休息间：CS之战的激情
HDU 5692 Snacks bfs版本dfs序 线段树
weixin_33681778的博客
05-22 106
Snacks 题目连接： http://acm.hdu.edu.cn/showproblem.php?pid=5692 Description 百度科技园内有n个零食机，零食机之间通过n−1条路相互连通。每个零食机都有一个值v，表示为小度熊提供零食的价值。 由于零食被频繁的消耗和补充，零食机的价值v会时常发生变化。小度熊只能从编号为0的零食机出发，并且每个零食机至多经过一次。另外，小度熊会对某个零...
计蒜客 An Easy Problem On The Trees （2018 ICPC亚洲区域赛网络赛 南京 F）（动态树维护联通块大小）
LP_Cong
09-04 588
In this problem you will be given a tree with NN nodes and N - 1N−1 bidirectional edges. Now you should handle three kinds of operations. 11. Given two integers x, yx,y, you should make a new edge be...
在Linux下用c语言编写一个贪吃蛇小游戏的服务器，能够同时连接多个客户端
最新发布
05-22
", snakes[k].id, snakes[k].score, snakes[k].len); for (n = 0; n < snakes[k].len; n++) { sprintf(buffer + strlen(buffer), "%d,%d;", snakes[k].pos[n].x, snakes[k].pos[n].y); } break; } } write...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值