E - Tunnel Warfare HDU - 1540

对这个题目的思考：首先我们已经意识到这个是一个线段树，要利用线段树来解决问题，但是怎么解决呢，这个摧毁和重建的操作都很简单，但是这个查询怎么查呢，

这个是不是要判断这一个点左边和右边最远的距离，然后相加起来就可以了，所以就是维护一个区间最左边和最右边的值，然后把他们合并就是最大值。

这个最左边的值 pre_max = 子左节点的 pre_max

如果这个 pre_max==len 那就可以合并子右节点的 pre_max

最右值同理

这个都知道了就只剩下细心一点写这个题目了。

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <queue>

#include <vector>

#include <algorithm>

#include <string>

#include <stack>

#include <iostream>

#include <map>

#define inf 0x3f3f3f3f

#define inf64 0x3f3f3f3f3f3f3f3f

using namespace std;

const int maxn = 1e5 + ;

typedef long long ll;

struct node

{

    int l, r, len;

    int pre_max, last_max;

}tree[maxn*];

void push_up(int id)

{

    tree[id].pre_max = tree[id << ].pre_max;

    tree[id].last_max = tree[id <<  | ].last_max;

    if (tree[id << ].len == tree[id << ].pre_max) tree[id].pre_max += tree[id<<|].pre_max;

    if (tree[id <<  | ].len == tree[id <<  | ].last_max) tree[id].last_max += tree[id << ].last_max;

    // printf("tree[%d].max=%d tree[%d].min=%d\n", id, tree[id].pre_max, id, tree[id].last_max);

    // printf("tree[%d].max=%d tree[%d].min=%d\n", id << 1, tree[id << 1].pre_max, id << 1, tree[id << 1].last_max);

    // printf("tree[%d].max=%d tree[%d].min=%d\n", id << 1 | 1, tree[id << 1 | 1].pre_max, id << 1 | 1, tree[id << 1 | 1].last_max);

}

void build(int id,int l,int r)

{

    tree[id].l = l;

    tree[id].r = r;

    tree[id].len = r - l + ;

    if(l==r)

    {

        tree[id].last_max = tree[id].pre_max = ;

        return;

    }

    int mid = (l + r) >> ;

    build(id << , l, mid);

    build(id <<  | , mid + , r);

    push_up(id);

}

void update(int id,int pos,int val)

{

    //printf("id=%d pos=%d val=%d\n", id, pos, val);

    int l = tree[id].l;

    int r = tree[id].r;

    if(l==r)

    {

        tree[id].last_max = tree[id].pre_max = val;

        return;

    }

    int mid = (l + r) >> ;

    if (pos <= mid) update(id << , pos, val);

    else update(id <<  | , pos, val);

    push_up(id);

}

int query_pre(int id,int x,int y)

{

    int l = tree[id].l;

    int r = tree[id].r;

    //printf("id=%d l=%d r=%d x=%d y=%d\n", id, l, r, x, y);

    if(x<=l&&y>=r) return tree[id].pre_max;

    int mid = (l + r) >> ;

    int ans = , res = ;

    if (x <= mid) ans = query_pre(id << , x, y);

    if (y > mid) res = query_pre(id <<  | , x, y);

//    printf("id=%d res=%d ans=%d\n", id, res, ans);

    if (ans >= mid - x + ) return ans += res;//这个区间长度就是mid-x+1 因为mid 是在里面的所以要+1

    return ans;

}

int query_last(int id, int x, int y) {

    int l = tree[id].l;

    int r = tree[id].r;

    //printf("id=%d l=%d r=%d x=%d y=%d \n", id, l, r, x, y);

    if (x <= l && y >= r) return tree[id].last_max;

    int mid = (l + r) >> ;

    int ans = , res = ;

    if (x <= mid) ans = query_last(id << , x, y);

    if (y > mid) res = query_last(id <<  | , x, y);

    //printf("Ans=%d res=%d\n", ans, res);

    if (res >= y - mid) res += ans;//区间长度为 y-mid mid不在里面

    return res;

}

int main()

{

    int m, n;

    while(scanf("%d%d", &n, &m)!=EOF)

    {

        stack<int>sta;

        build(, , n);

        while(m--)

        {

            char s[];

            int x;

            scanf("%s", s);

            if(s[]=='D')

            {

                scanf("%d", &x);

                sta.push(x);

                update(, x, );

            }

            else if(s[]=='R')

            {

                if(!sta.empty())

                {

                    int num = sta.top(); sta.pop();

                    update(, num, );

                }

            }

            else if(s[]=='Q')

            {

                scanf("%d", &x);

                int ans = query_pre(, x, n);

                ans += query_last(, , x);

                if(ans) printf("%d\n", ans - );

                else printf("0\n");

            }

        }

    }

    return ;

}

线段树的区间合并

 
对这个题目的思考：这个题目不太会写，对于区间合的基本套路还是不太熟悉，这个题目看了题解之后(推荐题解 题解传送门）还是很清楚的。
我们知道这个是一个区间合并的线段树，和区间息息相关，这个要求长度为 w 的最左边的区间，还要求起点。
长度确定，所以我们就一个域是求最大长度的，因为要最左边的区间，而且我们要求最大长度就有合并操作，
所以我们要确定一个从左边开始最长的和从右边开始最长的，这个就和上面的差不多。
这个就是大致思路，剩下就是一些细节了。
一定要仔细点写，然后wa到哭

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <queue>

#include <vector>

#include <algorithm>

#include <string>

#include <stack>

#include <iostream>

#include <map>

#define inf 0x3f3f3f3f

#define inf64 0x3f3f3f3f3f3f3f3f

using namespace std;

const int maxn = 1e5 + ;

typedef long long ll;

struct node {

    int l, r, lazy, len;

    int pre_max, last_max, max;

}tree[maxn * ];

void push_up(int id) {

    tree[id].pre_max = tree[id << ].pre_max;

    tree[id].last_max = tree[id <<  | ].last_max;

    if (tree[id << ].pre_max == tree[id << ].len) tree[id].pre_max += tree[id <<  | ].pre_max;

    if (tree[id <<  | ].last_max == tree[id <<  | ].len) tree[id].last_max += tree[id << ].last_max;

    tree[id].max = max(max(tree[id<<].max, tree[id<<|].max), tree[id << ].last_max + tree[id <<  | ].pre_max);

    //printf("tree[%d].pre_max=%d tree[%d].last_max=%d\n", id, tree[id].pre_max, id, tree[id].last_max);

}

void build(int id, int l, int r) {

    tree[id].l = l;

    tree[id].r = r;

    tree[id].lazy = -;

    tree[id].len = tree[id].last_max = tree[id].pre_max = tree[id].max = r - l + ;

    //printf("tree[%d].pre_max=%d tree[%d].last_max=%d\n", id, tree[id].pre_max, id, tree[id].last_max);

    if (l == r) return;

    int mid = (l + r) >> ;

    build(id << , l, mid);

    build(id <<  | , mid + , r);

}

void push_down(int id) {

    if (tree[id].lazy != -) {

        tree[id << ].lazy = tree[id <<  | ].lazy = tree[id].lazy;

        if (tree[id].lazy) {

            tree[id << ].last_max = tree[id << ].pre_max = tree[id << ].max = tree[id << ].len;

            tree[id <<  | ].last_max = tree[id <<  | ].pre_max = tree[id <<  | ].max = tree[id <<  | ].len;

        }

        else {

            tree[id << ].last_max = tree[id << ].pre_max = tree[id << ].max = ;

            tree[id <<  | ].last_max = tree[id <<  | ].pre_max = tree[id <<  | ].max = ;

        }

        tree[id].lazy = -;

    }

}

void update(int id, int x, int y, int val) {

    //    printf("id=%d x=%d y=%d val=%d\n", id, x, y, val);

    int l = tree[id].l;

    int r = tree[id].r;

    if (x == l && y == r) {

        tree[id].lazy = val;

        if (val) tree[id].last_max = tree[id].pre_max = tree[id].max = tree[id].len;

        else tree[id].last_max = tree[id].pre_max = tree[id].max = ;

        return;

    }

    push_down(id);

    int mid = (l + r) >> ;

    if (y <= mid) update(id << , x, y, val);

    else if (mid +  <= x) update(id <<  | , x, y, val);

    else {

        update(id << , x, mid, val);

        update(id <<  | , mid + , y, val);

    }

    push_up(id);

}

int query(int id, int val) {

    int l = tree[id].l;

    int r = tree[id].r;

    //printf("id=%d l=%d r=%d\n", id, l, r);

    if (l == r) return l;

    int mid = (l + r) >> ;

    push_down(id);

    if (tree[id << ].max >= val) return query(id << , val);

    //printf("id1=%d\n", id);

    if (tree[id << ].last_max + tree[id <<  | ].pre_max >= val) return mid - tree[id << ].last_max + ;

    //printf("tree[%d].last=%d tree[%d].pre=%d id2=%d\n", id<<1,tree[id<<1].last_max,id<<1|1,tree[id<<1|1].pre_max,id);

    return query(id <<  | , val);

}

int main() {

    int n, m;

    while (scanf("%d%d", &n, &m) != EOF) {

        build(, , n);

        while (m--) {

            int opt, x, y;

            scanf("%d", &opt);

            if (opt == ) {

                scanf("%d", &x);

                if (tree[].max < x) {

                    printf("0\n");

                    continue;

                }

                int ans = query(, x);

                if (ans) update(, ans, ans + x - , );

                printf("%d\n", ans);

            }

            else {

                scanf("%d%d", &x, &y);

                update(, x, x + y - , );

            }

        }

    }

    return ;

}

线段树

 

G - 约会安排

这个题目 ：

如果是 DS 就是普通的查找，如果找到就输出最靠前的时间点，这个和上面的操作很像，然后更新。

如果是 NS 就要进行两次查找，第一次是普通查找，没有找到就是二级查找，这个二级查找就是一种覆盖，然后更新。

如果是 study 那就是清空为0 的操作。

这个就是相当于建了两棵树，一颗女神树，一颗基友树，处理女神树的时候要更新基友树，但是处理基友树就不需要更新女神树。

这个题目一定要注意 输出答案

描述中的“如果找到，就说“X,let’s fly”（此处，X为开始时间）…"
和Output中的 “X,let's fly”
里的“ ’ ”和 “ ' ” 不是一个符号，别复制错了！！！

#include <cstdio>//描述中的“如果找到，就说“X,let’s fly”（此处，X为开始时间）…"

#include <cstdlib>//和Output中的 “X, let's fly”

#include <cstring>//里的“ ’ ”和 “ ' ” 不是一个符号，别复制错了！！！

#include <queue>

#include <vector>

#include <algorithm>

#include <string>

#include <stack>

#include <iostream>

#include <map>

#define inf 0x3f3f3f3f

#define inf64 0x3f3f3f3f3f3f3f3f

using namespace std;

const int maxn = 1e5 + ;

typedef long long ll;

struct node {

    int len;

    int lsum, rsum, sum;//1 级的

    int lmax, rmax, max;//2 级的

}tree[maxn * ];

void build(int id, int l, int r) {

    tree[id].max = tree[id].lmax = tree[id].rmax = r - l + ;

    tree[id].len = tree[id].lsum = tree[id].rsum = tree[id].sum = r - l + ;

    if (l == r) return;

    int mid = (l + r) >> ;

    build(id << , l, mid);

    build(id <<  | , mid + , r);

}

void push_up(int id) {

    tree[id].lsum = tree[id << ].lsum;

    tree[id].rsum = tree[id <<  | ].rsum;

    if (tree[id << ].lsum == tree[id << ].len) tree[id].lsum += tree[id <<  | ].lsum;

    if (tree[id <<  | ].rsum == tree[id <<  | ].len) tree[id].rsum += tree[id << ].rsum;

    tree[id].sum = max(max(tree[id << ].sum, tree[id <<  | ].sum), tree[id << ].rsum + tree[id <<  | ].lsum);

    tree[id].sum = max(tree[id].sum, tree[id].lsum);

    tree[id].sum = max(tree[id].sum, tree[id].rsum);

    tree[id].lmax = tree[id << ].lmax;

    tree[id].rmax = tree[id <<  | ].rmax;

    if (tree[id << ].lmax == tree[id << ].len) tree[id].lmax += tree[id <<  | ].lmax;

    if (tree[id <<  | ].rmax == tree[id <<  | ].len) tree[id].rmax += tree[id << ].rmax;

    tree[id].max = max(max(tree[id << ].max, tree[id <<  | ].max), tree[id << ].rmax + tree[id <<  | ].lmax);

    tree[id].max = max(tree[id].max, tree[id].lmax);

    tree[id].max = max(tree[id].max, tree[id].rmax);

}

void push_down(int id) {

    if(tree[id].max==tree[id].len)

    {

        tree[id << ].max = tree[id << ].lmax = tree[id << ].rmax = tree[id << ].len;

        tree[id <<  | ].max = tree[id <<  | ].lmax = tree[id <<  | ].rmax = tree[id <<  | ].len;

    }

    if(tree[id].max==)

    {

        tree[id << ].max = tree[id << ].lmax = tree[id << ].rmax = ;

        tree[id <<  | ].max = tree[id <<  | ].lmax = tree[id <<  | ].rmax = ;

    }

    if(tree[id].sum==tree[id].len)

    {

        tree[id << ].sum = tree[id << ].lsum = tree[id << ].rsum = tree[id << ].len;

        tree[id <<  | ].sum = tree[id <<  | ].lsum = tree[id <<  | ].rsum = tree[id <<  | ].len;

    }

    if(tree[id].sum==)

    {

        tree[id << ].sum = tree[id << ].lsum = tree[id << ].rsum = ;

        tree[id <<  | ].sum = tree[id <<  | ].lsum = tree[id <<  | ].rsum = ;

    }

}

void update(int id, int l, int r, int x, int y, int val) {

    if (x <= l && y >= r) {

        if (val == ) {

            tree[id].max = tree[id].lmax = tree[id].rmax = ;

            tree[id].sum = tree[id].lsum = tree[id].rsum = ;

        }

        if (val == ) {

            tree[id].sum = tree[id].lsum = tree[id].rsum = ;

        }

        if (val == ) {

            tree[id].max = tree[id].lmax = tree[id].rmax = tree[id].len;

            tree[id].sum = tree[id].lsum = tree[id].rsum = tree[id].len;

        }

        return;

    }

    push_down(id);

    int mid = (l + r) >> ;

    if (x <= mid) update(id << , l, mid, x, y, val);

    if (y > mid) update(id <<  | , mid + , r, x, y, val);

    push_up(id);

}

int query_1(int id, int l, int r, int val) {

    if (l == r) return l;

    int mid = (l + r) >> ;

    push_down(id);

    if (tree[id << ].sum >= val) return query_1(id << , l, mid, val);

    if (tree[id << ].rsum + tree[id <<  | ].lsum >= val) return mid - tree[id << ].rsum + ;

    return query_1(id <<  | , mid + , r, val);

}

int query_2(int id,int l,int r,int val)

{

    if (l == r) return l;

    int mid = (l + r) >> ;

    push_down(id);

    if (tree[id << ].max >= val) return query_2(id << , l, mid, val);

    if (tree[id << ].rmax + tree[id <<  | ].lmax >= val) return mid - tree[id << ].rmax + ;

    return query_2(id <<  | , mid + , r, val);

}

int main()

{

    int t;

    scanf("%d", &t);

    for(int cas=;cas<=t;cas++)

    {

        int n, m, x, y;

        scanf("%d%d", &n, &m);

        build(, , n);

        printf("Case %d:\n", cas);

        while(m--)

        {

            char s[];

            scanf("%s", s);

            if(s[]=='D')

            {

                scanf("%d", &x);

                if(tree[].sum<x)

                {

                    printf("fly with yourself\n");

                    continue;

                }

                int ans = query_1(, , n, x);

                printf("%d,let's fly\n", ans);

                update(, , n, ans, x + ans - , );

            }

            if(s[]=='N')

            {

                scanf("%d", &x);

                if(tree[].sum>=x)

                {

                    int ans = query_1(, , n, x);

                    printf("%d,don't put my gezi\n", ans);

                    update(, , n, ans, x + ans - , );

                    continue;

                }

                if(tree[].max<x)

                {

                    printf("wait for me\n");

                    continue;

                }

                int ans = query_2(,,n,x);

                printf("%d,don't put my gezi\n", ans);

                update(, , n, ans, x + ans - , );

            }

            if(s[]=='S')

            {

                scanf("%d%d", &x, &y);

                update(, , n, x, y, );

                printf("I am the hope of chinese chengxuyuan!!\n");

            }

        }

    }

}

线段树

E - Tunnel Warfare HDU - 1540 F - Hotel G - 约会安排 HDU - 4553 区间合并的更多相关文章

  1. hdu 4453 约会安排(线段树区间合并)

    约会安排 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others)Total Submis ...

  2. M - 约会安排 - hdu 4553

    寒假来了,又到了小明和女神们约会的季节.  小明虽为�丝级码农,但非常活跃,女神们常常在小明网上的大段发言后热情回复“呵呵”,所以,小明的最爱就是和女神们约会.与此同时,也有很多基友找他开黑,由于数量 ...

  3. 约会安排HDU - 4553

    寒假来了,又到了小明和女神们约会的季节.  小明虽为屌丝级码农,但非常活跃,女神们常常在小明网上的大段发言后热情回复"呵呵",所以,小明的最爱就是和女神们约会.与此同时,也有很多基 ...

  4. M - 约会安排 HDU - 4553 线段树 （最长连续段）

    中文题面 思路:维和两个区间  一个是女神区间 一个是基友区间  如果是基友要预约时间 直接在基友区间查询可满足的起点 (这里先判tree[1].m >=length也就是有没有这样的区间满足时 ...

  5. HDU 3308 LCIS (线段树&#183;单点更新&#183;区间合并)

    题意  给你一个数组  有更新值和查询两种操作  对于每次查询  输出相应区间的最长连续递增子序列的长度 基础的线段树区间合并  线段树维护三个值  相应区间的LCIS长度(lcis)  相应区间以左 ...

  6. 约会安排 HDU - 4553（线段树区间查询，区间修改，区间合并）

    题目: 寒假来了,又到了小明和女神们约会的季节.  小明虽为屌丝级码农,但非常活跃,女神们常常在小明网上的大段发言后热情回复“呵呵”,所以,小明的最爱就是和女神们约会.与此同时,也有很多基友找他开黑, ...

  7. HDU 3911 线段树区间合并、异或取反操作

    题目:http://acm.hdu.edu.cn/showproblem.php?pid=3911 线段树区间合并的题目,解释一下代码中声明数组的作用: m1是区间内连续1的最长长度,m0是区间内连续 ...

  8. hdu 1540 Tunnel Warfare 线段树 单点更新，查询区间长度，区间合并

    Tunnel Warfare Time Limit: 1 Sec  Memory Limit: 256 MB 题目连接 http://acm.hdu.edu.cn/showproblem.php?pi ...

  9. hdu 1540 Tunnel Warfare (区间线段树（模板）)

    http://acm.hdu.edu.cn/showproblem.php?pid=1540 Tunnel Warfare Time Limit: 4000/2000 MS (Java/Others) ...

随机推荐

  1. mysql优化之分区

    mysql分区类型 日常开发中我们经常会遇到大表的情况,所谓的大表是指存储了百万级乃至千万级条记录的表.这样的表过于庞大,导致数据库在查询和插入的时候耗时太长,性能低下,如果涉及联合查询的情况,性能会 ...

  2. SVG案例：动态去创建元素createElementNS

    案例一: <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <titl ...

  3. 【three.js第三课】鼠标事件，移动、旋转物体

    1.下载three.js的源码包后,文件夹结构如下: 2.在[three.js第一课]的代码基础上,引入OrbitControls.js文件,此文件主要用于 对鼠标的操作. 该文件位置:在文件结构中 ...

  4. threejs使用各种坑实验过程

    第一次使用threejs到实际项目中,开始的时候心情有点小激动,毕竟是第一次嘛,然而做着做着就感受到这玩意水好深,满满的都是坑,填都填不过来.经过老板20天惨无人道的摧残,终于小有成就. 因为第一次搞 ...

  5. MVC-前端设计

    来源于:https://www.cnblogs.com/miro/p/4030622.html 从前端的UI开始 MVC分离的比较好,开发顺序没有特别要求,先开发哪一部分都可以,这次我们主要讲解前端U ...

  6. SMTP发邮件（直接可用）实例

    string file = "邮件测试.txt";//放在Debug下的一个txt文件. MailAddress from = new MailAddress("自己的邮 ...

  7. kubernetes删除pod，pod一直处于Terminating状态

    删除pod,pod一直处于Terminating状态 [root@yxz-cluster01 deploy_yaml]# kubectl get pod -n yunanbao NAME READY ...

  8. Linux-监控与安全运维之zabbix

    zabbix: Zabbix是一个开源分布式监控平台,包含诸多监控功能,用于构建一个符合企业级的监控解决方案.软件由开源社区提供开发和维护,遵循GPL协议,可以自由传播和使用,但开发团队提供收费的技术 ...

  9. GC日志分析详解

    点击返回上层目录 原创声明:作者:Arnold.zhao 博客园地址:https://www.cnblogs.com/zh94 GC日志分析详解 以ParallelGC为例,YoungGC日志解释如下 ...

  10. myod实验（选做）

    myod实验 实验任务 1 复习c文件处理内容 2 编写myod.c 用myod XXX实现Linux下od -tx -tc XXX的功能 main与其他分开,制作静态库和动态库 编写Makefile ...