【bzoj3196】【坑】Tyvj 1730 二逼平衡树 线段树套Treap/Splay

最新推荐文章于 2016-07-31 01:41:01 发布
最新推荐文章于 2016-07-31 01:41:01 发布
阅读量882 收藏
点赞数
分类专栏： ===数据结构=== Treap splay 树套树 ===其它=== 坑 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LOI_DQS/article/details/50357557
版权

Description

您需要写一种数据结构（可参考题目标题），来维护一个有序数列，其中需要提供以下操作：
1.查询k在区间内的排名
2.查询区间内排名为k的值
3.修改某一位值上的数值
4.查询k在区间内的前驱(前驱定义为小于x，且最大的数)
5.查询k在区间内的后继(后继定义为大于x，且最小的数)

Input

第一行两个数 n,m 表示长度为n的有序序列和m个操作
第二行有n个数，表示有序序列
下面有m行，opt表示操作标号
若opt=1 则为操作1，之后有三个数l,r,k 表示查询k在区间[l,r]的排名
若opt=2 则为操作2，之后有三个数l,r,k 表示查询区间[l,r]内排名为k的数
若opt=3 则为操作3，之后有两个数pos,k 表示将pos位置的数修改为k
若opt=4 则为操作4，之后有三个数l,r,k 表示查询区间[l,r]内k的前驱
若opt=5 则为操作5，之后有三个数l,r,k 表示查询区间[l,r]内k的后继

Output

对于操作1,2,4,5各输出一行，表示查询结果

Sample Input

9 6

4 2 2 1 9 4 0 1 1

2 1 4 3

3 4 10

2 1 4 3

1 2 5 9

4 3 9 5

5 2 8 5

Sample Output

2

4

3

4

9

HINT

1.n和m的数据范围：n,m<=50000

2.序列中每个数的数据范围：[0,1e8]

3.虽然原题没有，但事实上5操作的k可能为负数

Source

不知道为什么，老是T

线段树维护treap或splay
我的代码真尼玛长，三百多行…………

先挖坑，以后再填

代码（Treap）：

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

const int SZ = 1000010;
const int INF = 100000010;


int num[SZ];
int n,m;
struct node{
    node *ch[2];
    int sz,v,cnt,r;

    int cmp(int x)
    {
        if(x == v) return -1;
        return x < v ? 0 : 1;
    }

    void setc(node *x,int d) { ch[d] = x; }

    void maintain()
    {
        sz = ch[0] -> sz + ch[1] -> sz + cnt;
    }

}T[SZ],*null;

struct segnode{
    int l,r;
    node *root;
}tree[SZ * 4];

void dfs(node *p)
{
    if(p == null) return ;
    dfs(p -> ch[0]);
    printf("%d %d\n",p -> v,p -> cnt);
    dfs(p -> ch[1]);
}

int Tcnt = 0;

inline node* newnode(int x)
{
    node *k = T + (Tcnt ++);
    k -> ch[0] = k -> ch[1] = null;
    k -> v = x;
    k -> sz = k -> cnt = 1;
    k -> r = rand();
    return k;
}

inline void rotate(node* &p,int d)
{
    node *k = p -> ch[d ^ 1];
    p -> ch[d ^ 1] = k -> ch[d];
    k -> ch[d] = p;
    p -> maintain(); k -> maintain();
    p = k;
}

inline int treap_ask_rank(node *p,int x)
{
    int ans = 0;
    while(p != null)
    {
        int d = p -> cmp(x);
        if(d == -1) return ans + p -> ch[0] -> sz;
        if(d == 1) ans += p -> cnt + p -> ch[0] -> sz;
        p = p -> ch[d];
    }
    return ans;
}

inline int treap_ask_num(node *p,int k)
{
    while(p != null)
    {
        int l = p -> ch[0] -> sz + 1;
        int r = p -> ch[0] -> sz + p -> cnt;
        if(l <= k && k <= r) return p -> v;
        if(k > r) k -= r,p = p -> ch[1];
        else p = p -> ch[0];
    }
}

inline void treap_insert(node* &p,int x)
{
    if(p == null)
    {
        p = newnode(x);
        return ;
    }

    int d = p -> cmp(x);
    if(d == -1)
    {
        p -> cnt ++;
        p -> sz ++;
        return ;
    }
    treap_insert(p -> ch[d],x);

    if(p -> ch[d] -> r < p -> r) rotate(p,d ^ 1);

    p -> maintain();
}

inline void treap_erase(node* &p,int x)
{
    if(p == null) return ;

    int d = p -> cmp(x);
    if(d == -1)
    {
        if(p -> cnt > 1)
        {
            p -> cnt --; p -> sz --; return ;
        }

        if(p -> ch[0] != null && p -> ch[1] != null)
        {
            int dd = p -> ch[0] -> r < p -> ch[1] -> r ? 0 : 1;
            rotate(p,dd ^ 1);
            treap_erase(p -> ch[dd ^ 1],x);
        }
        else
        {
            if(p -> ch[0] != null) p = p -> ch[0];
            else p = p -> ch[1];
        }
    }
    else
        treap_erase(p -> ch[d],x);
    if(p != null) p -> maintain();
}

inline void treap_change(node* &p,int x,int v)
{
    treap_erase(p,x);
/*  puts("erase");
    printf("%d %d %d\n",tree[pos].l,tree[pos].r,x);
    puts("dfs");dfs(tree[pos].root);puts("dfs\n");*/

    treap_insert(p,v);

/*  puts("insert");
    printf("%d %d %d\n",tree[pos].l,tree[pos].r,v);
    puts("dfs");dfs(tree[pos].root);puts("dfs\n");*/
}

inline int treap_ask_pre(node *p,int x)
{
    int ans = -INF;
    while(p != null)
    {
        if(p -> v < x) ans = p -> v,p = p -> ch[1];
        else p = p -> ch[0];
    }
    return ans;
}

inline int treap_ask_suf(node *p,int x)
{
    int ans = INF;
    while(p != null)
    {
        if(p -> v > x) ans = p -> v,p = p -> ch[0];
        else p = p -> ch[1];
    }
    return ans; 
}

inline void treap_build(int pos,int l,int r)
{
    for(register int i = l;i <= r;++ i) 
    {
        treap_insert(tree[pos].root,num[i]);
    }
}


inline void seg_build(int p,int l,int r)
{
    tree[p].l = l; tree[p].r = r;
    tree[p].root = null;
    treap_build(p,l,r);
    if(l == r)
    {
        return ;
    }
    int mid = (l + r) >> 1;
    seg_build(p << 1,l,mid);
    seg_build(p << 1 | 1,mid + 1,r);
}

inline int seg_ask_rank(int p,int l,int r,int x)
{
    if(l <= tree[p].l && tree[p].r <= r)
    {
        int ans = treap_ask_rank(tree[p].root,x);
    //  printf("%d %d %d\n",tree[p].l,tree[p].r,ans);
        return ans;
    }
    int mid = (tree[p].l + tree[p].r) >> 1;
    int ans = 0;
    if(l <= mid) ans += seg_ask_rank(p << 1,l,r,x);
    if(mid < r) ans += seg_ask_rank(p << 1 | 1,l,r,x);
    return ans;
}


inline int seg_ask_num(int p,int l,int r,int k)
{
    int ll = 0,rr = INF,ans;
    while(ll <= rr)
    {
        int mid = (ll + rr) >> 1;
        int tmp = seg_ask_rank(1,l,r,mid) + 1;
        if(tmp <= k) ll = mid + 1,ans = mid;
        else rr = mid - 1;
    }
    return ans;
}

inline void seg_change(int p,int pos,int x)
{
    treap_change(tree[p].root,num[pos],x);
    if(tree[p].l == tree[p].r) return ;
    int mid = (tree[p].l + tree[p].r) >> 1; 
    if(pos <= mid) seg_change(p << 1,pos,x);
    else seg_change(p << 1 | 1,pos,x);
}

inline int seg_ask_pre(int p,int l,int r,int x)
{
    if(l <= tree[p].l && tree[p].r <= r)
    {
        int ans = treap_ask_pre(tree[p].root,x);
//      printf("hahaha %d %d %d %d\n",ans,x,l,r); 
        return ans;
    }
    int ans = -INF;
    int mid = (tree[p].l + tree[p].r) >> 1;
    if(l <= mid) ans = max(ans,seg_ask_pre(p << 1,l,r,x));
    if(mid < r) ans = max(ans,seg_ask_pre(p << 1 | 1,l,r,x));
    return ans;
}

inline int seg_ask_suf(int p,int l,int r,int x)
{
    if(l <= tree[p].l && tree[p].r <= r)
        return treap_ask_suf(tree[p].root,x);
    int ans = INF;
    int mid = (tree[p].l + tree[p].r) >> 1;
    if(l <= mid) ans = min(ans,seg_ask_suf(p << 1,l,r,x));
    if(mid < r) ans = min(ans,seg_ask_suf(p << 1 | 1,l,r,x));
    return ans;
}

inline void init()
{
    null = newnode(-INF);
    null -> sz = null -> cnt = 0;
    null -> r = -INF;
    srand(time(0));
}

inline void scan(int &n)
{
    n = 0;
    char a = getchar();
    bool flag = 0;
    while(a < '0' || a > '9') {if(a == '-') flag = 1; a = getchar();}
    while('0' <= a && a <= '9') n = (n << 3) + (n << 1) + a - '0',a = getchar();
    if(flag) n = -n;
}

int main()
{
//  freopen("3196.in","r",stdin);       freopen("3196.out","w",stdout);     
    init();
    scan(n),scan(m);
    for(int i = 1;i <= n;++ i) scan(num[i]);
    seg_build(1,1,n);
    while(m --)
    {
        int opt;
        scan(opt);
        int l,r,k,pos;
        switch(opt)
        {
            case 1:
                scan(l); scan(r); scan(k);
                printf("%d\n",seg_ask_rank(1,l,r,k) + 1);
                break;
            case 2:
                scan(l); scan(r); scan(k);
                printf("%d\n",seg_ask_num(1,l,r,k));
                break;
            case 3:
                scan(pos); scan(k);
                seg_change(1,pos,k);
                num[pos] = k;
                break;
            case 4:
                scan(l); scan(r); scan(k);
                printf("%d\n",seg_ask_pre(1,l,r,k));
                break;
            case 5:
                scan(l); scan(r); scan(k);
                printf("%d\n",seg_ask_suf(1,l,r,k));
                break;
        }
    //  dfs(tree[1].root); puts("");
    }
    return 0;
}
/*
3 9
9 3 6 
3 3 9


5 10 1 10 3 1 8 


*/

Splay：

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

const int SZ = 1000010;
const int INF = 1000000010;


int num[SZ];
int n,m;
struct node{
    node *f,*ch[2];
    int sz,v,cnt;

    int dir() { return f -> ch[1] == this; }

    int cmp(int x)
    {
        if(x == v) return -1;
        return x < v ? 0 : 1;
    }

    void setc(node *x,int d) { (ch[d] = x) -> f = this; }

    void maintain()
    {
        sz = ch[0] -> sz + ch[1] -> sz + cnt;
    }

}T[SZ],*null;

struct segnode{
    int l,r;
    node *root;
    int sum;
}tree[SZ * 4];

void dfs(node *p)
{
    if(p == null) return ;
    dfs(p -> ch[0]);
    printf("%d %d\n",p -> v,p -> cnt);
    dfs(p -> ch[1]);
}

int Tcnt = 0;

node* newnode(int x,node *fa)
{
    node *k = T + (Tcnt ++);
    k -> f = fa;
    k -> ch[0] = k -> ch[1] = null;
    k -> v = x;
    k -> sz = k -> cnt = 1;
    return k;
}

void rotate(int pos,node *p)
{
    node *fa = p -> f;
    int d = p -> dir();
    fa -> f -> setc(p,fa -> dir());
    fa -> setc(p -> ch[d ^ 1],d); fa -> maintain();
    p -> setc(fa,d ^ 1); p -> maintain();
    if(fa == tree[pos].root) tree[pos].root = p;
}

void splay(int pos,node *p,node *rt = null)
{
    while(p -> f != rt)
    {
        if(p -> f -> f == rt) rotate(pos,p);
        else
        {
            if(p -> dir() == p -> f -> dir()) rotate(pos,p -> f),rotate(pos,p);
            else rotate(pos,p),rotate(pos,p);
        }
    }
    p -> maintain();
}

int splay_ask_rank(node *p,int x)
{
    int ans = 0;
    while(p != null)
    {
        int d = p -> cmp(x);
        if(d == -1) return ans + p -> ch[0] -> sz;
        if(d == 1) ans += p -> cnt + p -> ch[0] -> sz;
        p = p -> ch[d];
    }
    return ans;
}

int splay_ask_num(node *p,int k)
{
    while(p != null)
    {
        int l = p -> ch[0] -> sz + 1;
        int r = p -> ch[0] -> sz + p -> cnt;
        if(l <= k && k <= r) return p -> v;
        if(k > r) k -= r,p = p -> ch[1];
        else p = p -> ch[0];
    }
}

void splay_erase(int pos,node *p,int x)
{
    while(p != null)
    {
        p -> sz --;
        int d = p -> cmp(x);
        if(d == -1) { p -> cnt --; break; }
        p = p -> ch[d];
    }
    if(p -> cnt) return ;
    splay(pos,p);
    if(p -> ch[0] == null) { tree[pos].root = p -> ch[1]; tree[pos].root -> f = null; return ; }
    if(p -> ch[1] == null) { tree[pos].root = p -> ch[0]; tree[pos].root -> f = null; return ; }
    p = p -> ch[0];
    while(p -> ch[1] != null) p = p -> ch[1];
    splay(pos,p,tree[pos].root);
    p -> ch[1] = tree[pos].root -> ch[1]; p -> ch[1] -> f = p;
    p -> f = null; p -> maintain();
    tree[pos].root = p;
}

void splay_insert(int pos,node *p,int x)
{
    if(tree[pos].root == null) { tree[pos].root = newnode(x,null); return ; }
//  printf("rt : %d \n",tree[pos].root -> v);
    while(p != null)
    {
        p -> sz ++;
        int d = p -> cmp(x);
        if(d == -1) { p -> cnt ++;break; }
//      printf("I : %d %d\n",p -> v,d);
        if(p -> ch[d] == null)
        {
            p -> ch[d] = newnode(x,p);
            p = p -> ch[d];
            break;
        }
        p = p -> ch[d];
    }
    splay(pos,p);
}

void splay_change(int pos,node *p,int x,int v)
{
    splay_erase(pos,tree[pos].root,x);
//  puts("erase");
//  printf("%d %d %d\n",tree[pos].l,tree[pos].r,x);
//  puts("dfs");dfs(tree[pos].root);puts("dfs\n");

    splay_insert(pos,tree[pos].root,v);

//  puts("insert");
//  printf("%d %d %d\n",tree[pos].l,tree[pos].r,v);
//  puts("dfs");dfs(tree[pos].root);puts("dfs\n");
}

int splay_ask_pre(node *p,int x)
{
    int ans = -INF;
    while(p != null)
    {
        if(p -> v < x) ans = p -> v,p = p -> ch[1];
        else p = p -> ch[0];
    }
    return ans;
}

int splay_ask_suf(node *p,int x)
{
    int ans = INF;
    while(p != null)
    {
        if(p -> v > x) ans = p -> v,p = p -> ch[0];
        else p = p -> ch[1];
    }
    return ans; 
}

void splay_build(int pos,int l,int r)
{
    for(int i = l;i <= r;i ++) 
    {
        splay_insert(pos,tree[pos].root,num[i]);
    }
}


void seg_update(int p)
{
    tree[p].sum = tree[p << 1].sum + tree[p << 1 | 1].sum;
}

void seg_build(int p,int l,int r)
{
    tree[p].l = l; tree[p].r = r;
    tree[p].root = null;
    splay_build(p,l,r);
    if(l == r)
    {
        tree[p].sum = num[l];
        return ;
    }
    int mid = (l + r) >> 1;
    seg_build(p << 1,l,mid);
    seg_build(p << 1 | 1,mid + 1,r);
    seg_update(p);
}

int seg_ask_rank(int p,int l,int r,int x)
{
    if(l <= tree[p].l && tree[p].r <= r)
    {
        int ans = splay_ask_rank(tree[p].root,x);
    //  printf("%d %d %d\n",tree[p].l,tree[p].r,ans);
        return ans;
    }
    int mid = (tree[p].l + tree[p].r) >> 1;
    int ans = 0;
    if(l <= mid) ans += seg_ask_rank(p << 1,l,r,x);
    if(mid < r) ans += seg_ask_rank(p << 1 | 1,l,r,x);
    return ans;
}


int seg_ask_num(int p,int l,int r,int k)
{
    int ll = 0,rr = INF,ans;
    while(ll <= rr)
    {
        int mid = (ll + rr) >> 1;
        int tmp = seg_ask_rank(1,l,r,mid) + 1;
        if(tmp <= k) ll = mid + 1,ans = mid;
        else rr = mid - 1;
    }
    return ans;
}

void seg_change(int p,int pos,int x)
{
    splay_change(p,tree[p].root,num[pos],x);
    if(tree[p].l == tree[p].r) return ;
    int mid = (tree[p].l + tree[p].r) >> 1; 
    if(pos <= mid) seg_change(p << 1,pos,x);
    if(mid < pos) seg_change(p << 1 | 1,pos,x);
    seg_update(p);
}

int seg_ask_pre(int p,int l,int r,int x)
{
    if(l <= tree[p].l && tree[p].r <= r)
    {
        int ans = splay_ask_pre(tree[p].root,x);
//      printf("hahaha %d %d %d %d\n",ans,x,l,r); 
        return ans;
    }
    int ans = -INF;
    int mid = (tree[p].l + tree[p].r) >> 1;
    if(l <= mid) ans = max(ans,seg_ask_pre(p << 1,l,r,x));
    if(mid < r) ans = max(ans,seg_ask_pre(p << 1 | 1,l,r,x));
    return ans;
}

int seg_ask_suf(int p,int l,int r,int x)
{
    if(l <= tree[p].l && tree[p].r <= r)
        return splay_ask_suf(tree[p].root,x);
    int ans = INF;
    int mid = (tree[p].l + tree[p].r) >> 1;
    if(l <= mid) ans = min(ans,seg_ask_suf(p << 1,l,r,x));
    if(mid < r) ans = min(ans,seg_ask_suf(p << 1 | 1,l,r,x));
    return ans;
}

void init()
{
    null = newnode(-INF,null);
    null -> sz = null -> cnt = 0;
}

void scan(int &n)
{
    n = 0;
    char a = getchar();
    bool flag = 0;
    while(a < '0' || a > '9') {if(a == '-') flag = 1; a = getchar();}
    while('0' <= a && a <= '9') n = (n << 3) + (n << 1) + a - '0',a = getchar();
    if(flag) n = -n;
}

int main()
{
//  freopen("3196.in","r",stdin);       freopen("3196.out","w",stdout);     
    init();
    scan(n),scan(m);
    for(int i = 1;i <= n;++ i) scan(num[i]);
    seg_build(1,1,n);
    while(m --)
    {
        int opt;
        scan(opt);
        int l,r,k,pos;
        switch(opt)
        {
            case 1:
                scan(l); scan(r); scan(k);
                printf("%d\n",seg_ask_rank(1,l,r,k) + 1);
                break;
            case 2:
                scan(l); scan(r); scan(k);
                printf("%d\n",seg_ask_num(1,l,r,k));
                break;
            case 3:
                scan(pos); scan(k);
                seg_change(1,pos,k);
                num[pos] = k;
                break;
            case 4:
                scan(l); scan(r); scan(k);
                printf("%d\n",seg_ask_pre(1,l,r,k));
                break;
            case 5:
                scan(l); scan(r); scan(k);
                printf("%d\n",seg_ask_suf(1,l,r,k));
                break;
        }
//      dfs(tree[1].root); puts("");
    }
    return 0;
}
/*
4 2 2 10 9 4 0 1 1
*/
DQSSS
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
bzoj 3730. 震波（动态点分治 + vector树状数组）
01-06
考虑点分树的做法，在点分树上每个点以距离为下标建一棵线段树，每次询问查询子树的贡献，再暴力向上跳合并父节点来自其它节点的贡献。 因为子树树形被破坏，在做减法时，子节点子树对父节点的贡献不能用子树维护的...
线段树题目
07-16
### 线段树题目详解 #### 1. 线段覆盖问题 - **ZOJ 1610** 和 **POJ 2777**：这两道题都是典型的线段覆盖问题，需要利用线段树来解决。基本思路是通过线段树维护每个区间是否被覆盖的状态。对于每个覆盖请求，更新...
平衡树_王天懿.pptx
09-14
平衡树是一种特殊的二叉树数据结构，主要用于高效地...Treap和Splay Tree是其中两种具有独特特性的平衡树，它们在解决实际问题时提供了不同的优势。在面对特定问题时，理解并灵活运用这些数据结构是解决问题的关键。
wangjunrui666#bzoj-problem##5165. 树上倍增1
07-25
您需要写一个树上倍增算法，以实现如下操作：A x 新建一个节点，将它作为x节点的儿子，编号为当前节点总数+1。保证询问不超过1000次输出格式对于每一个Q操作，
BZOJ第二部分
11-04
【BZOJ第二部分】是针对BZOJ（北京邮电大学在线评测系统）的一个专题，这个专题主要涵盖了BZOJ平台上的P2001到P3000之间的编程题目。对于想要深入学习算法、提升编程能力的IT从业者或学生来说，这是一个宝贵的资源...
【心酸历程】atom上打造C/C++的ide
热门推荐
DQS的树洞
06-08 2万+
退役了，用什么devc啊看了这个东西写个Hello Word 而已，要不要这么震撼？！表示彻底爱上atom了！！！找zyz神犇要到了atom安装包，然后装了这个插件还有其他乱七八糟的，兴致冲冲写了个A+B，然后想运行运行…… 运行！好吧这是个编辑器，不能运行2333然后谋财害命搜索告诉我要装script才能运行script插件的简介是这样： 很开心是不是！！然后装，他说你没github不给装！
CTSC2016滚粗记 前篇
DQS的树洞
05-06 7374
现在的时间是2016年5月5日22:48:48，是CTSC的结束日晚上，也是APIO的开始日晚上。鉴于喜闻乐见狗牌滚粗，于是就写个游记纪念一下吧。day -∞要从R1完了的那天开始说起。教练被R1给吓怕了。他第一次意识到SD变的高手如云，他从未想过省选上有这么多人A题，他没想到分数普遍特别高，他也没想到我能考的这么烂。考试这种事情，尤其是坑爹的OI比赛，变数是很大的。不光知识的储备量，还包括考试策略
【个人整理】NOIP知识点汇总
DQS的树洞
02-21 6986
随便写写，留给学娣们…欢迎补充加*号是选学，加粗为重点，排序不分先后（因为是想到哪写到哪） 基础算法贪心、枚举、分治、二分、倍增、*构造、高精、模拟 图论图 最短路（dijkstra、spfa、floyd），差分约束 最小生成树（kruskal、prim） 并查集（扩展域） 拓扑排序 二分图染色，*二分图匹配 tarjan找scc、桥、割点，缩点 *分数规划 树 树上倍增（LCA） 树的直径、树
PKU四日游（信息科学夏令营）
DQS的树洞
07-27 6422
没什么意思的夏令营… 反正是去了，就写个游记骗访问量吧day-∞“初审结果会在七月上旬公布” 神tm就是七月十号晚上公布的………… 结合上次pkusc的“24时前公布”，然后23：50公布的事情，我不想吐槽pku的办事效率了………… 总之过了初审，要交钱啊，然后就交了，2k啊！！够买十个屁股了！！然后发现……卧槽笔试什么鬼？？这个夏令营不是去写代码的吗？应该是个一等奖就能审过了吧，为什么他们
【个人整理】省选知识点汇总
DQS的树洞
07-31 4486
为啥hzwer写过我还要写呢 我也不知道……可能是黄学长的排版不好看 学省选的，先把我整理的NOIP知识点学完吧 同样的，加粗是重点，星号是选学 欢迎补充~ 图论网络流（dinic，SAP，ISAP选一个，费用流写EK就行。*zkw费用流），二分图 点分治，边分治，*动态点分治 树链剖分，动态树，树分块 虚树，*prufer编码 *仙人掌算法 数据结构带权并查集 Splay（作为平衡树和维护
SDOI2016 R1&&R2 总结&&爆零记
DQS的树洞
07-30 4243
退役两个半月了再谈这个真的好吗……真的应景吗…… 这篇文章主要是自我勉励，还有给之后奋斗省选的学弟学妹们（有生之年能看到loi有学妹奋斗省选，真的感觉值了。如果有，请这位学妹联系我）看看，不要犯和自己一样的错误。SDOI2016 R1这是我的噩梦，是我现在想起来还会心痛的日子。day0报到日。 早上到机房，a，lcy，swc，xczhw早就在机房玩起了魔塔20层。还记得临走的时候，swc在以每秒
【笔记】如何快速生成随机数 RSA算法
DQS的树洞
10-27 4155
今天学了一下随机化贪心，于是也就顺势学了一下随机数生成。以下是扯淡众所周知，系统有一个rand()函数，windows下可以生成32767以内的随机数，linux下可以生成2147483647以内的随机数。它是用线性同余的方法生成。形如：Xn=(aXn-1+b)%c于是每次都要取一个随机数种子，作为X0来递推。一般情况都这么写：srand(time(0));这样以时间作为种子，每一秒的种子就不同，得
APIO2016滚粗记
DQS的树洞
07-28 3477
颓废记！day0CTSC的结束日和APIO的报到日，额好吧是我的颓废日。去拿衣服之后就回房间颓颓颓了，下午和zyk去试机。CTSC的场地全是图书馆，这次去了教学楼里的机房，看见一个机房和其他机房不一样……我：不要这个机房了吧，这个机房的键盘一看就好难用 zyk：那才要这个机房啊，哪个难用试哪个，要不然到时候真分到这里来岂不是狗带啊我想想也是，于是就和他一起进去了……其实好像就这个机房的机子没试了键
【NOIP2014】联合权值 乱搞
DQS的树洞
10-26 2637
只有图QAQ距离为2，边权为1，所以和同一个点相连的其它点之间都会产生联合权值，枚举60分2333可是我们为什么要枚举呢？若当前和节点u相连的节点的权值是wi，此时u又新加了个节点m，权值为wx，那么：ans1为最大值，ans2为总和 ans1=max(ans1,max{wi}*wx); ans2=ans2+w1*wx+w2*wx+...wn*wx=ans2+∑wi*wx；我们发现，只要记录当前节点
NOI导刊游记
DQS的树洞
02-10 2585
现在的时间是：2016年2月10日01:03:10。正好是大年初三，我就随便写写吧…不知道为什么，以前从来没有想过写什么游记什么的，但有了博客就是想写…………虽然没人看吧2333去导刊的时间是1.28~2.5，恰好跟WC的后半段时间重了，NOIP考了rank22，但没去WC，感觉好可惜……这几天的事情就随便写写，记多少写多少吧2333第二次也是最后一次去郑州学习了。day0：早上五点四十五到，我迟到
颓废日常 多图预警
DQS的树洞
04-21 2444
Orzyzy Orzfqk Orzyts OrzClaris %%%fqk %%%Menci %%%sxb %%%yts %%%yzy %%%神犇学弟
【codevs1959】拔河比赛 随机化贪心
DQS的树洞
10-27 1887
题目描述 Description一个学校举行拔河比赛，所有的人被分成了两组，每个人必须（且只能够）在其中的一组，要求两个组的人数相差不能超过1，且两个组内的所有人体重加起来尽可能地接近。输入描述 Input Description数据的第1行是一个n，表示参加拔河比赛的总人数，n<=100，接下来的n行表示第1到第n个人的体重，每个人的体重都是整数（1<=weight<=450）。输出描述 Outp
【留言板】在这聊个天勾搭一下神犇之类的
DQS的树洞
01-04 1691
这里是来自SD lwyz的蒟蒻 DQS欢迎各位神犇来打脸，欢迎互相交流学习本博客目前仅为个人写的OI题目题解以及闲的没事写的乱七八糟的其他事情。想当年只是服务于NOIP啊…现在备战省选了，这个博客也会一点点壮大起来吧SDOI2016 RP++最后Orz一下学长viv&&小绿，Orz毕业学长WTH&&YXR，Orz大神hzwer，Orz将来的大神学弟学妹们…Orz上古神犇留下来的精（ge）神（zhon
NOIP2015滚粗记
DQS的树洞
11-08 1630
不管怎么说，NOIP2015已经结束了…………记一下考试感想之类的吧，这大概是本博客最后一篇关于OI的文章了？11.6： 早八点半，我们坐上的车去诸城…路上补了集妄想学生会，然后和xczhw一块玩KAMI和一个电路的游戏，外面下着雨…为什么每次去诸城总会下雨……到了后我在床上睡了一觉，躺了一下午，晚上去会议室充电+看他们玩电脑，总之这一天没干什么正事。分考场，我和dc分在了同一楼，其他人是另一个楼
等差数列与数据结构——线段树、树状数组解析
"本资源是一份关于BZOJ算术天才⑨与等差数列问题的线段树和树状数组应用的课件，主要针对信息竞赛和OI选手，涵盖了线段树和树状数组的基本概念、优势及在解决实际问题中的应用策略。标签涉及信息竞赛、OI、线段树、...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值