[BZOJ1018][SHOI2008]堵塞的交通traffic（线段树维护连通性）

最新推荐文章于 2019-02-22 09:13:32 发布
最新推荐文章于 2019-02-22 09:13:32 发布
阅读量833 收藏
点赞数
分类专栏： 题解 线段树 省选 文章标签： BZOJ SHOI 线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Clove_unique/article/details/50955019
版权
题解 同时被 3 个专栏收录
1097 篇文章 3 订阅
订阅专栏
省选
211 篇文章 0 订阅
订阅专栏
线段树
70 篇文章 0 订阅
订阅专栏

题目描述

传送门

题解

『郁闷』现在写一道题都要以半天为单位计算时间了= =
数据结构是一个要填的大坑= =之前学过的也只能算是草草学过，没有大量的练习来填坑是不会有提高的= =光打模板题没什么意思= =那么考验码力的时候到了= =

这道题让我明白了怎样用线段树维护连通性。就这道题来说，线段树中的每一个结点都用六个结构体维护一个矩形的连通性（分别是左上右上，左下右下，左上右下，左下右上，左上左下和右上右下），然后update和query的时候会有一些非常奇怪的合并。
主要是想明白一点：判断(x1,y1)(x2,y2)是否连通，所求的路径不一定是在[y1,y2]这个区间里，有可能在区间外面绕一圈又回来了，所以每次query其实需要查询3个区间，然后取一些奇怪的并集。
思路是很好懂的，但是细节十分吃屎= =比如说怎样考虑使每一种情况不重不漏，思维逻辑的缜密十分重要。
再有就是代码能力。刚开始的时候想都没想怒写400行代码，然后发现TLE了。其实是写了很多冗余的东西。后来考虑合并和简化之后又WA一组，最终是一个手残错误= =可见有了思路能否实现也是一个大问题。

代码

贴上可怕的7k代码，TLE

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;

const int max_n=1e5+5;
const int max_tree=max_n*5;

int n,x1,y1,x2,y2;
struct hp{
    int luru,lurd,ldru,ldrd,luld,rurd;
}tree[max_tree];
struct hq{
    int l,r;
}num[max_tree];
bool up[max_n],down[max_n],list[max_n];

char opt[10];


inline void update(int now){

    bool a,b;

    //luru
    a=tree[now<<1].luru && tree[now<<1|1].luru && up[ num[now<<1].r ];
    b=tree[now<<1].lurd && tree[now<<1|1].ldru && down[ num[now<<1].r ];
    tree[now].luru=a||b;

    //lurd
    a=tree[now<<1].luru && tree[now<<1|1].lurd && up[ num[now<<1].r ];
    b=tree[now<<1].lurd && tree[now<<1|1].ldrd && down[ num[now<<1].r ];
    tree[now].lurd=a||b;

    //ldru
    a=tree[now<<1].ldru && tree[now<<1|1].luru && up[ num[now<<1].r ];
    b=tree[now<<1].ldrd && tree[now<<1|1].ldru && down[ num[now<<1].r ];
    tree[now].ldru=a||b;

    //ldrd
    a=tree[now<<1].ldru && tree[now<<1|1].lurd && up[ num[now<<1].r ];
    b=tree[now<<1].ldrd && tree[now<<1|1].ldrd && down[ num[now<<1].r ];
    tree[now].ldrd=a||b;

    //luld
    a=tree[now<<1].luld;
    b=tree[now<<1].luru && tree[now<<1].ldrd && tree[now<<1|1].luld && up[ num[now<<1].r ] && down[ num[now<<1].r ];
    tree[now].luld=a||b;

    //rurd
    a=tree[now<<1|1].rurd;
    b=tree[now<<1|1].luru && tree[now<<1|1].ldrd && tree[now<<1].rurd && up[ num[now<<1].r ] && down[ num[now<<1].r ];
    tree[now].rurd=a||b;
}

inline void build(int now,int l,int r){
    int mid=(l+r)>>1;
    num[now].l=l; num[now].r=r;

    if (l==r){
        tree[now].luru=true;
        tree[now].lurd=false;
        tree[now].ldru=false;
        tree[now].ldrd=true;
        tree[now].luld=false;
        tree[now].rurd=false;

        return;
    }

    build(now<<1,l,mid);
    build(now<<1|1,mid+1,r);

    update(now);
}

inline void change(int now,int l,int r,int x){
    int mid=(l+r)>>1;

    if (l==r){
        tree[now].luru=true;
        tree[now].lurd=list[l];
        tree[now].ldru=list[l];
        tree[now].ldrd=true;
        tree[now].luld=list[l];
        tree[now].rurd=list[l];

        return;
    }

    if (x<=mid)
      change(now<<1,l,mid,x);
    else
      change(now<<1|1,mid+1,r,x);

    update(now);
}

inline bool query(int now,int l,int r,int lrange,int rrange,int order){
    int mid=(l+r)>>1;

    if (lrange<=l&&r<=rrange){

        switch(order){
            case 1:{
                return tree[now].luru;
                break;
            }
            case 2:{
                return tree[now].ldrd;
                break;
            }
            case 3:{
                return tree[now].lurd;
                break;
            }
            case 4:{
                return tree[now].ldru;
                break;
            }
            case 5:{
                return tree[now].luld;
                break;
            }
            case 6:{
                return tree[now].rurd;
                break;
            }
        }

    }

    bool pd1=false,pd2=false;
    bool al,bl,cl,dl,el,fl,ar,br,cr,dr,er,fr;

    if (lrange<=mid){

        pd1=true;
        al=query(now<<1,l,mid,lrange,rrange,1);
        bl=query(now<<1,l,mid,lrange,rrange,2);
        cl=query(now<<1,l,mid,lrange,rrange,3);
        dl=query(now<<1,l,mid,lrange,rrange,4);
        el=query(now<<1,l,mid,lrange,rrange,5);
        fl=query(now<<1,l,mid,lrange,rrange,6);

    }
    if (mid+1<=rrange){

        pd2=true;
        ar=query(now<<1|1,mid+1,r,lrange,rrange,1);
        br=query(now<<1|1,mid+1,r,lrange,rrange,2);
        cr=query(now<<1|1,mid+1,r,lrange,rrange,3);
        dr=query(now<<1|1,mid+1,r,lrange,rrange,4);
        er=query(now<<1|1,mid+1,r,lrange,rrange,5);
        fr=query(now<<1|1,mid+1,r,lrange,rrange,6);

    }


    if (pd1&&pd2){

        switch(order){
            case 1:{
                return al&&ar&&up[ num[now<<1].r ] || cl&&dr&&down[ num[now<<1].r ];
                break;
            }
            case 2:{
                return dl&&cr&&up[ num[now<<1].r ] || bl&&br&&down[ num[now<<1].r ];
                break;
            }
            case 3:{
                return al&&cr&&up[ num[now<<1].r ] || cl&&br&&down[ num[now<<1].r ];
                break;
            }
            case 4:{
                return dl&&ar&&up[ num[now<<1].r ] || bl&&dr&&down[ num[now<<1].r ];
                break;
            }
            case 5:{
                return el || al&&bl&&er&&up[ num[now<<1].r ]&&down[ num[now<<1].r ];
                break;
            }
            case 6:{
                return fr || ar&&br&&fl&&up[ num[now<<1].r ]&&down[ num[now<<1].r ];
                break;
            }
        }

    }

    if (pd1&&!pd2){

        switch(order){
            case 1:{
                return al;
                break;
            }
            case 2:{
                return bl;
                break;
            }
            case 3:{
                return cl;
                break;
            }
            case 4:{
                return dl;
                break;
            }
            case 5:{
                return el;
                break;
            }
            case 6:{
                return fl;
                break;
            }
        }

    }

    if (!pd1&&pd2){

        switch (order){
            case 1:{
                return ar;
                break;
            }
            case 2:{
                return br;
                break;
            }
            case 3:{
                return cr;
                break;
            }
            case 4:{
                return dr;
                break;
            }
            case 5:{
                return er;
                break;
            }
            case 6:{
                return fr;
                break;
            }
        }

    }

    if (!pd1&&!pd2) return false;
}

inline bool ask(int x1,int y1,int x2,int y2){

    //1:luru 2:ldrd 3:lurd 4:ldru 5:luld 6:rurd

    bool a,b,c,d,e,f;

    a=query(1,1,n,x1,x2,1);
    b=query(1,1,n,x1,x2,2);
    c=query(1,1,n,x1,x2,3);
    d=query(1,1,n,x1,x2,4);

    e=query(1,1,n,1,x1,6);
    f=query(1,1,n,x2,n,5);

    if (y1==0&&y2==0){

        return a || d&&e || c&&f || b&&e&&f;

    }
    if (y1==1&&y2==1){

        return b || c&&e || d&&f || a&&e&&f;

    }
    if (y1==0&&y2==1){

        return c || a&&f || b&&e || d&&e&&f;

    }
    if (y1==1&&y2==0){

        return d || a&&e || b&&f || c&&e&&f;

    }

}

int main(){
//  freopen("input.txt","r",stdin);

    scanf("%d",&n);

    memset(up,0,sizeof(up));
    memset(down,0,sizeof(down));

    build(1,1,n);

    while (scanf("%s",opt)!=EOF){

        if (opt[0]=='E') break;

        scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
        swap(x1,y1);
        swap(x2,y2);
        if (x1>x2){
            swap(x1,x2);
            swap(y1,y2);
        }
        --y1; --y2;
//      cout<<x1<<" "<<y1<<" "<<x2<<" "<<y2<<endl;

        if (opt[0]=='O'){
            if (x1==x2){
                list[x1]=true;

                change(1,1,n,x1);
            }
            else{
                if (y1==0){
                    up[x1]=true;

                    change(1,1,n,x1);
                    change(1,1,n,x2);
                } 
                else{
                    down[x1]=true;

                    change(1,1,n,x1);
                    change(1,1,n,x2);
                } 
            }
        }

        if (opt[0]=='C'){
            if (x1==x2){
                list[x1]=false;

                change(1,1,n,x1);
            }
            else{
                if (y1==0){
                    up[x1]=false;

                    change(1,1,n,x1);
                    change(1,1,n,x2);
                } 
                else{
                    down[x1]=false;

                    change(1,1,n,x1);
                    change(1,1,n,x2);
                } 
            }
        }

        if (opt[0]=='A'){
            bool ans=ask(x1,y1,x2,y2);
            if (ans) printf("Y\n");
            else printf("N\n");
        }
    }

    /*
    for (int i=1;i<n;++i)
      printf("%d%c",up[i]," \n"[i==n-1]);
    for (int i=1;i<n;++i)
      printf("%d%c",down[i]," \n"[i==n-1]);
    for (int i=1;i<=n;++i)
      printf("%d%c",list[i]," \n"[i==n]);
    */

}

AC代码

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;

const int max_n=1e5+5;
const int max_tree=max_n*5;

int n,x1,y1,x2,y2;
struct hp{
    int luru,lurd,ldru,ldrd,luld,rurd;
}tree[max_tree];
struct hq{
    bool a,b,c,d,e,f;
};
int num[max_tree];
bool up[max_n],down[max_n],list[max_n];

char opt[10];


inline void update(int now){

    bool a,b;

    //luru
    a=tree[now<<1].luru && tree[now<<1|1].luru && up[ num[now<<1] ];
    b=tree[now<<1].lurd && tree[now<<1|1].ldru && down[ num[now<<1] ];
    tree[now].luru=a||b;

    //lurd
    a=tree[now<<1].luru && tree[now<<1|1].lurd && up[ num[now<<1] ];
    b=tree[now<<1].lurd && tree[now<<1|1].ldrd && down[ num[now<<1] ];
    tree[now].lurd=a||b;

    //ldru
    a=tree[now<<1].ldru && tree[now<<1|1].luru && up[ num[now<<1] ];
    b=tree[now<<1].ldrd && tree[now<<1|1].ldru && down[ num[now<<1] ];
    tree[now].ldru=a||b;

    //ldrd
    a=tree[now<<1].ldru && tree[now<<1|1].lurd && up[ num[now<<1] ];
    b=tree[now<<1].ldrd && tree[now<<1|1].ldrd && down[ num[now<<1] ];
    tree[now].ldrd=a||b;

    //luld
    a=tree[now<<1].luld;
    b=tree[now<<1].luru && tree[now<<1].ldrd && tree[now<<1|1].luld && up[ num[now<<1] ] && down[ num[now<<1] ];
    tree[now].luld=a||b;

    //rurd
    a=tree[now<<1|1].rurd;
    b=tree[now<<1|1].luru && tree[now<<1|1].ldrd && tree[now<<1].rurd && up[ num[now<<1] ] && down[ num[now<<1] ];
    tree[now].rurd=a||b;
}

inline void build(int now,int l,int r){
    int mid=(l+r)>>1;
//    cout<<now<<endl;

    if (l==r){
        tree[now].luru=true;
        tree[now].lurd=false;
        tree[now].ldru=false;
        tree[now].ldrd=true;
        tree[now].luld=false;
        tree[now].rurd=false;
        num[now]=r; 

        return;
    }

    num[now]=r;
    build(now<<1,l,mid);
    build(now<<1|1,mid+1,r);

    update(now);
}

inline void change(int now,int l,int r,int x){
    int mid=(l+r)>>1;

    if (l==r){
        tree[now].luru=true;
        tree[now].lurd=list[l];
        tree[now].ldru=list[l];
        tree[now].ldrd=true;
        tree[now].luld=list[l];
        tree[now].rurd=list[l];

        return;
    }

    if (x<=mid)
      change(now<<1,l,mid,x);
    else
      change(now<<1|1,mid+1,r,x);

    update(now);
}

inline hq query(int now,int l,int r,int lrange,int rrange){
    int mid=(l+r)>>1;

    hq ans;
    hq L,R;
    bool pd1=false,pd2=false;

    if (lrange<=l&&r<=rrange)
      return ans=(hq){tree[now].luru,tree[now].ldrd,tree[now].lurd,
                      tree[now].ldru,tree[now].luld,tree[now].rurd};

    if (lrange<=mid){
        pd1=true;
        L=query(now<<1,l,mid,lrange,rrange);
    }
    if (mid+1<=rrange){
        pd2=true;
        R=query(now<<1|1,mid+1,r,lrange,rrange);
    }

    if (pd1&&pd2){

        bool a,b,c,d,e,f;

        a=L.a&&R.a&&up[ num[now<<1] ] || L.c&&R.d&&down[ num[now<<1] ];
        b=L.d&&R.c&&up[ num[now<<1] ] || L.b&&R.b&&down[ num[now<<1] ];
        c=L.a&&R.c&&up[ num[now<<1] ] || L.c&&R.b&&down[ num[now<<1] ];
        d=L.d&&R.a&&up[ num[now<<1] ] || L.b&&R.d&&down[ num[now<<1] ];

        e=L.e || L.a&&L.b&&R.e&&up[ num[now<<1] ]&&down[ num[now<<1] ];
        f=R.f || R.a&&R.b&&L.f&&up[ num[now<<1] ]&&down[ num[now<<1] ]; 

        return ans=(hq){a,b,c,d,e,f};
    }

    if (pd1&&!pd2)
      return ans=(hq){L.a,L.b,L.c,L.d,L.e,L.f};

    if (!pd1&&pd2)
      return ans=(hq){R.a,R.b,R.c,R.d,R.e,R.f};

    if (!pd1&&!pd2) return ans=(hq){false,false,false,false,false,false};
}

inline bool ask(int x1,int y1,int x2,int y2){

    hq now,l,r;

    now=query(1,1,n,x1,x2);
    l=query(1,1,n,1,x1);
    r=query(1,1,n,x2,n);

    if (y1==0&&y2==0)
      return now.a || now.d&&l.f || now.c&&r.e || now.b&&l.f&&r.e;
    if (y1==1&&y2==1)
      return now.b || now.c&&l.f || now.d&&r.e || now.a&&l.f&&r.e;
    if (y1==0&&y2==1)
      return now.c || now.a&&r.e || now.b&&l.f || now.d&&l.f&&r.e; 
    if (y1==1&&y2==0)
      return now.d || now.a&&l.f || now.d&&r.e || now.c&&l.f&&r.e;
}

int main(){
    scanf("%d",&n);

    memset(up,0,sizeof(up));
    memset(down,0,sizeof(down));

    build(1,1,n);
    int cnt=0;

    while (scanf("%s",opt)!=EOF){

        if (opt[0]=='E') break;

        scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
        swap(x1,y1);
        swap(x2,y2);
        if (x1>x2){
            swap(x1,x2);
            swap(y1,y2);
        }
        --y1; --y2;

        if (opt[0]=='O'){
            if (x1==x2){
                list[x1]=true;

                change(1,1,n,x1);
            }
            else{
                if (y1==0){
                    up[x1]=true;

                    change(1,1,n,x1);
                    change(1,1,n,x2);
                } 
                else{
                    down[x1]=true;

                    change(1,1,n,x1);
                    change(1,1,n,x2);
                } 
            }
        }

        if (opt[0]=='C'){
            if (x1==x2){
                list[x1]=false;

                change(1,1,n,x1);
            }
            else{
                if (y1==0){
                    up[x1]=false;

                    change(1,1,n,x1);
                    change(1,1,n,x2);
                } 
                else{
                    down[x1]=false;

                    change(1,1,n,x1);
                    change(1,1,n,x2);
                } 
            }
        }

        if (opt[0]=='A'){
            cnt++;
            bool ans=ask(x1,y1,x2,y2);
            if (ans) printf("Y\n");
            else printf("N\n");
        }
    }
    return 0;
}

总结

用线段树维护连通性有了新的经验。
对冗余的简化。
码力++

Clove_unique
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
bzoj 3730. 震波（动态点分治 + vector树状数组）
01-06
因为子树树形被破坏，在做减法时，子节点子树对父节点的贡献不能用子树维护的信息 + 连向父节点的边的贡献得到，考虑在每个节点再维护一个线段树，按距离建树用来统计子树内的节点到其父节点距离为 p 的点权和，这样...
bzoj1018
weixinding的专栏
09-04 2127
1018: [SHOI2008]堵塞的交通traffic Time Limit: 3 Sec  Memory Limit: 162 MB Submit: 617  Solved: 165 [Submit][Status][Discuss] Description 有一天，由于某种穿越现象作用，你来到了传说中的小人国。小人国的布局非常奇特，整个国家的交通系统可以被看成是一个2行C列的矩
BZOJ 1018 线段树维护图的连通性问题
weixin_34064653的博客
03-12 115
思路： 我们可以搞一棵线段树 对于一段区间有6种情况需要讨论 左上右下、左上右上、左下右下、左下右上 这四种比较好维护 用左上右下举个例子吧 就是左儿子的左上右下&左区间到右区间下面有路&右儿子的左下右下 或者是左儿子的左上右上&左区间到右区间上面有路&右儿子的左上右下 还有两种 区间的左（右）端点上下能不能联通 需要维护 这种就是左儿子的...
【BZOJ】3995: [SDOI2015]道路修建-线段树维护连通性
远行客
02-22 183
线段树维护连通性
BZOJ_1018_[SHOI2008]_交通堵塞traffic_(线段树)
aquz77529的博客
07-06 175
描述 http://www.lydsy.com/JudgeOnline/problem.php?id=1018 \(2*n\)的距形,起初没有边相连,之后有三种操作: 1.加边. 2.删边. 3.询问某两个点是否联通. 分析 这题太神了... 用线段树维护连通性... 放弃解释清楚了... 1 #include <bits/...
卡牌操作 线段树维护区间连通性
rgnoH的博客
09-12 467
NKOJ3777 卡牌操作问题描述 有n张卡片在桌上一字排开，每张卡片上有两个数，第i张卡片上，正面的数为a[i]，反面的数为b[i]。现在，有m个熊孩子来破坏你的卡片了！ 第i个熊孩子会交换c[i]和d[i]两个位置上的卡片。 每个熊孩子捣乱后，你都需要判断，通过任意翻转卡片（把正面变为反面或把反面变成正面，但不能改变卡片的位置），能否让卡片正面上的数从左到右单调不降。 输入格式
wangjunrui666#bzoj-problem##5165. 树上倍增1
07-25
您需要写一个树上倍增算法，以实现如下操作：A x 新建一个节点，将它作为x节点的儿子，编号为当前节点总数+1。保证询问不超过1000次输出格式对于每一个Q操作，
wangjunrui666#bzoj-problem##2453. 维护队列1
07-25
接下来M行，每行的形式为“Q L R”或“R x c”，“Q L R”表示A想知道从队列第L个弹珠到第R个弹珠中，一共有多少不同颜色的弹珠，“R x c”表示A
BZOJ第一部分
11-03
BZOJ原题-BZOJP1000-P2000的题目，下载后可以离线做题。
BZOJ全代码
02-05
BZOJ平台全部代码，解压到一个文件夹在打开使用。BZOJ平台全部代码，解压到一个文件夹在打开使用。
[BZOJ1018] [SHOI2008]堵塞的交通traffic（线段树维护连通性）
私は Mocha!!
03-10 329
传送门：http://www.lydsy.com/JudgeOnline/problem.php?id=1018 之前挖的坑，现在填吧。 之前一眼看觉得是LCT，一看时限 3s ？？？？ n非常大是log级别的，并查集肯定不可行， 貌似时限开大也不能用lct因为不是树？（也许是我弱 那么就滚去膜题解了了。 这题其实是线段树维护连通性的经典问题。 突破点就在于只有两行。 那么我们...
bzoj3995: [SDOI2015]道路修建【线段树维护最小生成树】
cdsszjj的博客
02-28 394
Description 某国有2N个城市，这2N个城市构成了一个2行N列的方格网。现在该国政府有一个旅游发展计划，这个计划需要选定L、R两列(L&lt;=R)，修建若干条专用道路，使得这两列之间（包括这两列）的所有2(R-L+1)个城市中每个城市可以只通过专用道路就可以到达这2(R-L+1)个城市中的任何一个城市。这种专用道路只能在同一行相邻两列的城市或者同一列的两个城市之间修建，且修建需要花费...
【bzoj1018】 堵塞的交通 线段树维护连通性
Oxer的专栏
07-12 1553
真是道神题，想写了一个月终于今天晚上把它解决了。想一下也真心不容易。我们用线段树维护这样几个量。 （懒得画了，原谅我盗图。。。） 我们用线段树维护这六个量，然后用一个数组a[x][0][0]表示第1行x位置与x+1位置的连通性,a[x][1][0]表示第二行x位置和x+1位置的连通性，a[x][0][1]表示第一行x位置与第二行x位置的连通性。线段树的合并和查询写的比较巧妙，具体细节可以参
BZOJ1018堵塞的交通traffic 线段树维护连通性
HbFS-
08-27 559
在地图上建线段树 [ l , r ] 区间上的线段树节点维护区域间四个顶点的连通性 随手画图差不多就是这四个顶点六条边的连通性 在查询的时候要判断一下左上和左下的点会不会经过左边区域而变得联通起来，右边也是一样 细节很多，挺难写的 #include #include #include #define N 1000500 using namespace std; stru
BZOJ 1018|SHOI 2008|堵塞的交通|线段树
とある黄鱼のOIブログ
04-21 748
咦，一道自带题解的题目？题目的坐标表示成(r,c)，r=row，行号，c=column，列号。 因此x1,x2只有取1和2两种情况………考虑线段树维护一格的连通性，合并区间如图： 令总的为r，左半区间a，右半区间b，修改了mid(x,y)。 那么对于r0(上);r1(下);r2(左);r3(右);r4(右下);r5(右上)r_0(上);r_1(下);r_2(左);r_3(右);r_4(右下
【bzoj1018】[SHOI2008]堵塞的交通traffic 线段树维护连通性
DQS的树洞
03-27 821
Description有一天，由于某种穿越现象作用，你来到了传说中的小人国。小人国的布局非常奇特，整个国家的交通系统可以被看成是一个2行C列的矩形网格，网格上的每个点代表一个城市，相邻的城市之间有一条道路，所以总共有2C个城市和3C-2条道路。 小人国的交通状况非常槽糕。有的时候由于交通堵塞，两座城市之间的道路会变得不连通，直到拥堵解决，道路才会恢复畅通。初来咋到的你决心毛遂自荐到交通部某份差事，部
Dynamic Connectivity Problem（动态连通性问题）
Tec Blog
10-25 1055
动态连通性问题
[BZOJ3196]二逼平衡树（线段树套splay）
zyf2000
04-29 2769
花费了不知多少页来描述我们的心情 却不知为何填不满一行的空白
【codevs1279】Guard 的无聊
zyf2000
01-13 1853
茕茕白兔，东奔西顾。衣不如新，人不如故。
bzoj 1040 zjoi2008 骑士 树形dp
最新发布
08-08
我们可以使用树形dp来解决这个问题，具体来说，我们可以将这个图看作是一棵树，每个点的父节点是它的前驱或者后继，然后我们从根节点开始，依次向下遍历，对于每个节点，我们可以考虑它的两个儿子，如果它的两个儿子...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值