#bzoj1846 - 山东省选2008#郁闷的小J（Avl平衡树两法：离散化每种书建树 or 按特定排序建一棵树）

最新推荐文章于 2023-10-05 22:30:48 发布
最新推荐文章于 2023-10-05 22:30:48 发布
阅读量366 收藏
点赞数 1
分类专栏： NOIP 平衡树(Avl)
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/its_elaine/article/details/75027841
版权

问题 A(1846): 【山东省选】郁闷的小J

时间限制: 4 Sec  内存限制: 512 MB

题目描述

小J是国家图书馆的一位图书管理员，他的工作是管理一个巨大的书架。虽然他很能吃苦耐劳，但是由于这个书架十分巨大，所以他的工作效率总是很低，以致他面临着被解雇的危险，这也正是他所郁闷的。

       具体说来，书架由N个书位组成，编号从1到N。每个书位放着一本书，每本书有一个特定的编码。

       小J的工作有两类：

  1. 图书馆经常购置新书，而书架任意时刻都是满的，所以只得将某位置的书拿掉并换成新购的书。
  2. 小J需要回答顾客的查询，顾客会询问某一段连续的书位中某一特定编码的书有多少本。

       例如，共5个书位，开始时书位上的书编码为1，2，3，4，5

       一位顾客询问书位1到书位3中编码为“2”的书共多少本，得到的回答为：1

       一位顾客询问书位1到书位3中编码为“1”的书共多少本，得到的回答为：1

       此时，图书馆购进一本编码为“1”的书，并将它放到2号书位。

       一位顾客询问书位1到书位3中编码为“2”的书共多少本，得到的回答为：0

       一位顾客询问书位1到书位3中编码为“1”的书共多少本，得到的回答为：2

……

       你的任务是写一个程序来回答每个顾客的询问。

输入

  第一行两个整数N，M，表示一共N个书位，M个操作。

       接下来一行共N个整数数A1,A2…AN，Ai表示开始时位置i上的书的编码。

       接下来M行，每行表示一次操作，每行开头一个字符

       若字符为‘C’，表示图书馆购进新书，后接两个整数A(1<=A<=N)，P，表示这本书被放在位置A上，以及这本书的编码为P。

       若字符为‘Q’，表示一个顾客的查询，后接三个整数A，B，K(1<=A<=B<=N)，表示查询从第A书位到第Ｂ书位（包含Ａ和Ｂ）中编码为Ｋ的书共多少本。

（1<=N,M<=100000，所有出现的书的编码为不大于2147483647的正数。）

输出

对每一个顾客的查询，输出一个整数，表示顾客所要查询的结果。

样例输入

5 5
1 2 3 4 5
Q 1 3 2
Q 1 3 1
C 2 1
Q 1 3 2
Q 1 3 1

样例输出

1
1
0
2
朴素地强行直接按照位置来做平衡树是会超时的（后面会给出我的超时代码，可以先拿去交交看）

这里给出两种做法（正解）：


法一：

将询问全部读入，离散化书的编号，

然后按照每书的种类不同，每种书建一棵树，树的内容为此种书摆放的位置。

每次C操作先删去原来位置上那种书的树中节点（数组持续更新记录位置上是哪种书），再在新书的树中加入节点

每次Q操作在书的树中累计区间数。


法二：

定义平衡树的顺序为：

1，书的编号种类。2，书的位置（这个注意看结构体里面的重载就比较清晰了）

按正常建树，

每次C操作把原来那个点删除后插入新点

每次Q操作就像查询排名一样后面的排名-前面的排名（注意是在之前的大小定义下）

想不通就想想这棵树的中序遍历，同一类书在中序里是挨在一起的说。


给出两种代码：

Code:

法一：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
using namespace std;
 
const int Max = 100005;
const int INF = 0x3f3f3f3f;
 
struct Pro{
    int l, r, p;
}Ask[Max];
struct node{
    int num, sum;
    int lc, rc, h;
}Tr[Max << 1];
 
int cnt, Pre, Suc;
int Root[Max], B[Max], S[Max << 1], Shelf[Max];
 
void getint(int & num){
    char c; int flg = 1;    num = 0;
    while((c = getchar()) < '0' || c > '9')   if(c == '-')    flg = -1;
    while(c >= '0' && c <= '9')   {   num = num * 10 + c - 48;    c = getchar();}
    num *= flg;
}
 
int max(int a, int b){  return a < b ? b : a;}
int min(int a, int b){  return a < b ? a : b;}
 
void pushup(int & r){
    Tr[r].sum = Tr[Tr[r].lc].sum + Tr[Tr[r].rc].sum + 1;
    Tr[r].h = max(Tr[Tr[r].lc].h, Tr[Tr[r].rc].h) + 1;
}
 
int zig(int r){
    int t = Tr[r].lc;
    Tr[r].lc = Tr[t].rc, Tr[t].rc = r;
    pushup(r), pushup(t);
    return t;
}
 
int zag(int r){
    int t = Tr[r].rc;
    Tr[r].rc = Tr[t].lc, Tr[t].lc = r;
    pushup(r), pushup(t);
    return t;
}
 
int zigzag(int r){
    Tr[r].rc = zig(Tr[r].rc);
    return zag(r);
}
 
int zagzig(int r){
    Tr[r].lc = zag(Tr[r].lc);
    return zig(r);
}
 
void maintain(int & r){
    if(Tr[Tr[r].lc].h == Tr[Tr[r].rc].h + 2){
        int t = Tr[r].lc;
        if(Tr[Tr[t].lc].h == Tr[Tr[r].rc].h + 1)    r = zig(r);
        else if(Tr[Tr[t].rc].h == Tr[Tr[r].rc].h + 1)   r = zagzig(r);
    }
    else if(Tr[Tr[r].rc].h == Tr[Tr[r].lc].h + 2){
        int t = Tr[r].rc;
        if(Tr[Tr[t].rc].h == Tr[Tr[r].lc].h + 1)    r = zag(r);
        else if(Tr[Tr[t].lc].h == Tr[Tr[r].lc].h + 1)   r = zigzag(r);
    }
    pushup(r);
}
 
void Insert(int & r, int val){
    if(! r){
        r = ++ cnt;
        Tr[r].num = val;
        Tr[r].h = Tr[r].sum = 1;
        return ;
    }
    if(val < Tr[r].num)  Insert(Tr[r].lc, val);
    else Insert(Tr[r].rc, val);
    maintain(r);
}
 
int Dele(int & r, int val){
    int tx;
    if(Tr[r].num == val || (val < Tr[r].num && ! Tr[r].lc) || ( val > Tr[r].num && ! Tr[r].rc)){
        if(! Tr[r].lc || ! Tr[r].rc){
            tx = Tr[r].num;
            r = Tr[r].lc + Tr[r].rc;
            return tx;
        }
        else Tr[r].num = Dele(Tr[r].lc, val);
    }
    else {
        if(val < Tr[r].num)  tx = Dele(Tr[r].lc, val);
        else tx = Dele(Tr[r].rc, val);
    }
    maintain(r);
    return tx;
}
 
int Search(int &r, int pos){
    if(! r) return 0;
    int sum = 0;
    if(Tr[r].num <= pos){
        if(Tr[r].lc)    sum += Tr[Tr[r].lc].sum;
        ++ sum;
    }
    if(Tr[r].num <= pos) sum += Search(Tr[r].rc, pos);
    else sum += Search(Tr[r].lc, pos);
    return sum;
}
 
int main(){
    int N, M, tot;
    getint(N), getint(M);
    for(int i = 1; i <= N; ++ i){
        getint(B[i]); 
        S[i] = B[i];
    }
    char ord[5];
    tot = N;
    for(int i = 1; i <= M; ++ i){
        scanf("%s", ord);
        if(ord[0] == 'Q'){
            getint(Ask[i].l), getint(Ask[i].r);
            getint(Ask[i].p);
            S[++ tot] = Ask[i].p;
        }
        else {
            getint(Ask[i].l), getint(Ask[i].p);
            Ask[i].r = -1;
        }
    }
    sort(S + 1, S + tot + 1);
    int len = unique(S + 1, S + tot + 1) - S;
    int tmp;
    for(int i = 1; i <= N; ++ i){
        tmp = lower_bound(S + 1, S + 1 + len, B[i]) - S;
        Shelf[i] = tmp;
        Insert(Root[tmp], i);
    }
    for(int i = 1; i <= M; ++ i){
        if(Ask[i].r != -1){
            tmp = lower_bound(S + 1, S + 1 + len, Ask[i].p) - S;
            printf("%d\n", Search(Root[tmp], Ask[i].r) - Search(Root[tmp], Ask[i].l - 1));
        }
        else {
            tmp = lower_bound(S + 1, S + 1 + len, Ask[i].p) - S;
            Dele(Root[Shelf[Ask[i].l]], Ask[i].l);
            Shelf[Ask[i].l] = tmp;
            Insert(Root[tmp], Ask[i].l);
        }
    }
    return 0;
}

法二： 

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

const int Max = 100005;
const int INF = 0x3f3f3f3f;

struct bk{
    int biao, pos;
    bk(){}
    bk(int a, int b){biao = a, pos = b;}
	bool operator <(const bk & X)const{
		if(biao == X.biao)	return pos < X.pos;
		return biao < X.biao;
	}
	bool operator == (const bk & X)const{
		return biao == X.biao && pos == X.pos;
	}
};
struct node{
    bk num;
    int lc, rc, h, sum;
}Tr[Max << 1];

int cnt;
int Shelf[Max];

void getint(int & num){
    char c;    int flg = 1;    num = 0;
    while((c = getchar()) < '0' || c > '9')    if(c == '-')    flg = -1;
    while(c >= '0' && c <= '9')    {    num = num * 10 + c - 48;    c = getchar();}
    num *= flg;
}

int max(int a, int b){    return a < b ? b : a;}
int min(int a, int b){    return a < b ? a : b;}

void pushup(int & r){
    Tr[r].h = max(Tr[Tr[r].lc].h, Tr[Tr[r].rc].h) + 1;
	Tr[r].sum = Tr[Tr[r].lc].sum + Tr[Tr[r].rc].sum + 1;
}

int zig(int r){
    int t = Tr[r].lc;
    Tr[r].lc = Tr[t].rc, Tr[t].rc = r;
    pushup(r), pushup(t);
    return t;
}

int zag(int r){
    int t = Tr[r].rc;
    Tr[r].rc = Tr[t].lc, Tr[t].lc = r;
    pushup(r), pushup(t);
    return t;
}

int zigzag(int r){
    Tr[r].rc = zig(Tr[r].rc);
    return zag(r);
}

int zagzig(int r){
    Tr[r].lc = zag(Tr[r].lc);
    return zig(r);
}

void maintain(int & r){
    if(Tr[Tr[r].lc].h == Tr[Tr[r].rc].h + 2){
        int t = Tr[r].lc;
        if(Tr[Tr[t].lc].h == Tr[Tr[r].rc].h + 1)    r = zig(r);
        else if(Tr[Tr[t].rc].h == Tr[Tr[r].rc].h + 1)    r = zagzig(r);
    }
    else if(Tr[Tr[r].rc].h == Tr[Tr[r].lc].h + 2){
        int t = Tr[r].rc;
        if(Tr[Tr[t].rc].h == Tr[Tr[r].lc].h + 1)    r = zag(r);
        else if(Tr[Tr[t].lc].h == Tr[Tr[r].lc].h + 1)    r = zigzag(r);
    }
    pushup(r);
}

void Insert(int & r, bk val){
    if(! r){
        r = ++ cnt;
        Tr[r].num = val;
        Tr[r].h = Tr[r].sum = 1;
        return ;
    }
    if(val < Tr[r].num)    Insert(Tr[r].lc, val);
    else Insert(Tr[r].rc, val);
    maintain(r);
}

bk Dele(int & r, bk val){
    bk tx;
    if(Tr[r].num == val || (val < Tr[r].num && ! Tr[r].lc) || (Tr[r].num < val && ! Tr[r].rc)){
        if(! Tr[r].lc || ! Tr[r].rc){
            tx = Tr[r].num;
            r = Tr[r].lc + Tr[r].rc;
            return tx;
        }
        else Tr[r].num = Dele(Tr[r].lc, val);
    }
    else {
        if(val < Tr[r].num)    tx = Dele(Tr[r].lc, val);
        else tx = Dele(Tr[r].rc, val);
    }
    maintain(r);
    return tx;
}

int Query(int r, bk val){
	if(! r)	return 0;
	if(Tr[r].num < val)	return Tr[Tr[r].lc].sum + 1 + Query(Tr[r].rc, val);
	return Query(Tr[r].lc, val);
}

int main(){
    int R = 0, N, M, A, B, K;
    getint(N), getint(M);
    for(int i = 1; i <= N; ++ i){
        getint(Shelf[i]); 
        Insert(R, bk(Shelf[i], i));
    }
    char ord[10];
    while(M --){
        scanf("%s", ord);
        switch(ord[0]){
            case 'Q':{
                getint(A), getint(B), getint(K);
                printf("%d\n", Query(R, bk(K, B)) - Query(R, bk(K, A)) + (Shelf[B] == K));
                break;
            }
            case 'C':{
                getint(A), getint(K);
                Dele(R, bk(Shelf[A], A));
				Shelf[A] = K;
                Insert(R, bk(K, A));
                break;
            }
        }
    }
    return 0;
}

超时的朴素代码。。。。如下（留做个纪念吧，还是打了一小会儿呢）: 

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

const int Max = 200005;
const int INF = 0x3f3f3f3f;

struct bk{
    int biao, pos;
    bk(){}
    bk(int a, int b){biao = a, pos = b;}
};
struct node{
    bk num;
    int lc, rc, h;
}Tr[Max];

int cnt, Pre, Suc;

void getint(int & num){
    char c;    int flg = 1;    num = 0;
    while((c = getchar()) < '0' || c > '9')    if(c == '-')    flg = -1;
    while(c >= '0' && c <= '9')    {    num = num * 10 + c - 48;    c = getchar();}
    num *= flg;
}

int max(int a, int b){    return a < b ? b : a;}
int min(int a, int b){    return a < b ? a : b;}

void pushup(int & r){
    Tr[r].h = max(Tr[Tr[r].lc].h, Tr[Tr[r].rc].h) + 1;
}

int zig(int r){
    int t = Tr[r].lc;
    Tr[r].lc = Tr[t].rc, Tr[t].rc = r;
    pushup(r), pushup(t);
    return t;
}

int zag(int r){
    int t = Tr[r].rc;
    Tr[r].rc = Tr[t].lc, Tr[t].lc = r;
    pushup(r), pushup(t);
    return t;
}

int zigzag(int r){
    Tr[r].rc = zig(Tr[r].rc);
    return zag(r);
}

int zagzig(int r){
    Tr[r].lc = zag(Tr[r].lc);
    return zig(r);
}

void maintain(int & r){
    if(Tr[Tr[r].lc].h == Tr[Tr[r].rc].h + 2){
        int t = Tr[r].lc;
        if(Tr[Tr[t].lc].h == Tr[Tr[r].rc].h + 1)    r = zig(r);
        else if(Tr[Tr[t].rc].h == Tr[Tr[r].rc].h + 1)    r = zagzig(r);
    }
    else if(Tr[Tr[r].rc].h == Tr[Tr[r].lc].h + 2){
        int t = Tr[r].rc;
        if(Tr[Tr[t].rc].h == Tr[Tr[r].lc].h + 1)    r = zag(r);
        else if(Tr[Tr[t].lc].h == Tr[Tr[r].lc].h + 1)    r = zigzag(r);
    }
    pushup(r);
}

void Insert(int & r, bk val){
    if(! r){
        r = ++ cnt;
        Tr[r].num = val;
        Tr[r].h = 1;
        return ;
    }
    if(val.pos < Tr[r].num.pos)    Insert(Tr[r].lc, val);
    else Insert(Tr[r].rc, val);
    maintain(r);
}

bk Dele(int & r, int pos){
    bk tx;
    if(Tr[r].num.pos == pos || (pos < Tr[r].num.pos && ! Tr[r].lc) || (pos > Tr[r].num.pos && ! Tr[r].rc)){
        if(! Tr[r].lc || ! Tr[r].rc){
            tx = Tr[r].num;
            r = Tr[r].lc + Tr[r].rc;
            return tx;
        }
        else Tr[r].num = Dele(Tr[r].lc, pos);
    }
    else {
        if(pos < Tr[r].num.pos)    tx = Dele(Tr[r].lc, pos);
        else tx = Dele(Tr[r].rc, pos);
    }
    maintain(r);
    return tx;
}

int Query(int R, int l, int r, int k){
    if(! R)    return 0;
    if(Tr[R].num.pos < l)    return Query(Tr[R].rc, l, r, k);
    if(Tr[R].num.pos > r)    return Query(Tr[R].lc, l, r, k);
    bool flg = 0;
    if(Tr[R].num.biao == k)    flg = 1;
    return flg + Query(Tr[R].lc, l, r, k) + Query(Tr[R].rc, l, r, k);
}

int main(){
    int R = 0, N, M, x, A, B, K;
    getint(N), getint(M);
    for(int i = 1; i <= N; ++ i){
        getint(x); 
        Insert(R, bk(x, i));
    }
    char ord[10];
    while(M --){
        scanf("%s", ord);
        switch(ord[0]){
            case 'Q':{
                getint(A), getint(B), getint(K);
                printf("%d\n", Query(R, A, B, K));
                break;
            }
            case 'C':{
                getint(A), getint(K);
                Dele(R, A);
                Insert(R, bk(K, A));
                break;
            }
        }
    }
    return 0;
}






itselaineZ
关注
专栏目录
ACM常用数据结构小结与实现
the CodeRoom of wjfwzzc
09-29 3818
应当说这段时间学校了很多的数据结构，
[SDOI2008] 郁闷的小J
HT008的Blog
03-27 208
题目描述： 雾。 题目分析： 好像是平衡树啊qwq ~~我不管，平衡树辣么长，我才不写呢~~ 我们直接对每个树都建一颗位置线段树就行啦，维护每个位置节点上是否有本书。 别忘了离散化~ 题目链接： Luogu 2464 Ac 代码： #include &lt;cstdio&gt; #include &lt;iostream&gt; #include &lt;alg...
【题解】SDOI-2008 郁闷的小J
测试运算符
01-04 235
话说这题bzoj上没有，丢一个洛谷的连接 点我 这题不是很难，对于每一种书建立一个有序的位置数组，就是这种书出现的位置集合，然后就是维护这个序列有序了 蒟蒻只能想到两种：set和平衡树，set就二分查找，SBT就find 但这题最变态的一点是卡空间！！！ 蒟蒻的SBT结构体在数据极端情况下欲哭无泪 把里面和外面的数组改来改去都A不了 于是蒟蒻使出了浑身解数卡空间： 队列回收空间 ...
【NOI2004】 郁闷的出纳员
06-08 150
题目描述 郁闷的出纳员 【问题描述】 OIER公司是一家大型专业化软件公司，有着数以万计的员工。作为一名出纳员，我的任务之一便是统计每位员工的工资。这本来是一份不错的工作，但是令人郁闷的是，我们的老板反复无常，经常调整员工的工资。如果他心情好，就可能把每位员工的工资加上一个相同的量。反之，如果心情不好，就可能把他们的工资扣除一个相同的量。我真不知道除了调工资他还做什么其它事...
#bzoj2803#普通平衡树（Avl平衡树 or Splay）
ElaineZXY的博客
07-12 331
2803: 普通平衡树 时间限制: 2 Sec  内存限制: 128 MB 题目描述 你需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： 1. 插入一个整数x 2. 删除一个整数x(若有多个相同的数，只删除一个) 3. 查询整数x的排名(若有多个相同的数，输出最小的排名)，相同的数依次排名，不并列排名 4. 查询排名为x的数，排名的概念同3
【SDOI2008】郁闷的小J
袋鼠与蒟蒻
03-17 425
【SDOI2008】郁闷的小JDescription　　小J是国家图书馆的一位图书管理员，他的工作是管理一个巨大的书架。虽然他很能吃苦耐劳，但是由于这个书架十分巨大，所以他的工作效率总是很低，以致他面临着被解雇的危险，这也正是他所郁闷的。　　具体说来，书架由N个书位组成，编号从1到N。每个书位放着一本书，每本书有一个特定的编码。　　小J的工作有两类：　　图书馆经常购置新书，而书架任意时刻都是满的，...
ST03Day2 平衡树
Deep_Kevin的娱乐空间
08-17 162
正题 主要还是用到splay，treap也要会，多打几遍，可以用来可持久化。 板子就不说了，回去多打几遍吧（flag1 AVL树和红黑树也不多说了。 splay的复杂度分析可以回去搞一搞，还挺有意思的，但是老师上课也是直接过（flag2 [bzoj1014]火星人prefix 回去写一写，就是用平衡树来维护区间的hash值，然后在外层套一个二分就可以。(flag3 Gty的游戏 没有加石子我们可以...
学习进度——附《全国青少年信息学奥林匹克系列竞赛大纲》
最新发布
BZ_C25LX 的博客
10-05 1790
1005​ 把不是很会的线段树和树状数组搞懂了，另复习了STL容器、二分、三分。​ 1、树状数组(详见树状数组2.2.3.3)​ 2、线段树（详见线段树2.2.3.3）​ 3、STL部分容器（详见STL2.1.2.13）,vector、栈、队列​ 4、三分算法BZOJ#17 曲线​ 注意:1.涉及浮点数lll从0开始而不是从1.​ 5、二分BZOJ#472 二分法求函数的零点。
常用数据结构小结
qq_40778023的博客
03-26 195
应当说这段时间学习了很多的数据结构，也到了一个总结的时候。fotile96的这篇Blog非常值得推荐，我达不到这个高度，只能给自己和队友做些简单的归纳。　　树状数组　　非常简单的数据结构，只需要一个数组，一切操作基于如下的函数。需要注意的是，树状数组的下标必须从1开始（从0开始会死循环）。它可以做到在O(logn)时间内完成下述的操作。[cpp] view plaincopyprint? int ...
wangjunrui666#bzoj-problem##2439. [中山市选2011] 序列1
07-25
定义“M”形的序列为一个长度为 T 的序列{Si}，满足：存在 1 ，使得S1 一天他看到了一个长度为N 的整数序列
wangjunrui666#bzoj-problem##5165. 树上倍增1
07-25
您需要写一个树上倍增算法，以实现如下操作：A x 新建一个节点，将它作为x节点的儿子，编号为当前节点总数+1。保证询问不超过1000次输出格式对于每一个Q操作，
wangjunrui666#bzoj-problem##1596. [Usaco2008 Jan]电话网络1
07-25
第1行: 1个整数，N第2..N行: 每行为2个用空格隔开的整数A、B，为两块相邻草地的编号第1行: 输出1个整数，即FJ最少建立无线电通讯塔的数目输入说明:F
wangjunrui666#bzoj-problem##4882. [Lydsy1705月赛]卡常生成树1
07-25
为了避免输入数据过于庞大，数据进行了压缩，解压方式可用下面这段代码解释：//在点i与点j之间添加一条边权为w的边第一行包含一个正整数T(1)，表示
wangjunrui666#bzoj-problem##5218. [Lydsy2017省队十连测]友好城市1
07-25
对于两座不同的城市a 和b，如果a 能通过这些单向道路直接或间接到达b，且b 也能如此到达a，那么它们就会被认为是一对友好城市。eland 的交通系统十分特殊，
#NOIP2011#计算系数
ElaineZXY的博客
02-09 1341
【NOIP2011】计算系数 时间限制: 1 Sec  内存限制: 128 MB [提交][状态][我的提交] 题目描述 给定一个多项式(ax + by)^k，请求出多项式展开后x^n y^m项的系数。 输入 输入文件名为 factor.in。 共一行，包含 5 个整数，分别为a，b，k，n，m，每两个整数之间用一个空格隔开。 输出 输
NOIP2017的流水账
ElaineZXY的博客
11-13 429
周五那天下午到的巴蜀，试机，键盘感觉不太爽，我看见低年级的小朋友下课。走楼梯上去，提着电脑包，挺累，发现今年女生特多，没什么感觉。 试机的时候打了树剖，最近树剖练得多，挺顺手，希望能考点会的数据结构题。坐了一会儿，当时在出神，然后感觉有人坐到我旁边来拍我的肩，转头一看，是老朋友了。一个三中的家伙，他高中开始学信息，还是听了我在学才来的。上午约了下午见，果然他就来找我了，聊了一会儿今年的比赛，当然
#NOIP1999#邮票面值设计
ElaineZXY的博客
01-22 391
【NOIP1999】邮票面值设计 时间限制: 1 Sec  内存限制: 64 MB 提交: 131  解决: 63 [提交][状态][我的提交] 题目描述 给定一个信封，最多只允许粘贴N张邮票，计算在给定K（N+K≤40）种邮票的情况下（假定所有的邮票数量都足够），如何设计邮票的面值，能得到最大值MAX，使在1～MAX之间的每一个邮资值都能得到。 输入 第
#NOIP模拟赛#字母选择Choose（并查集）
ElaineZXY的博客
08-26 291
此题贪心为错解，因为是全部更改，所以如果先多次更改了很多小数目，最后可能会一次更改一个很大的数目，这是没有必要的。 正解为并查集，对于首尾对应位置的字母，如果不匹配，则查看当前两个字母的所属集合，根节点的字母数量，将小的接在大的下方，表示小的将全部改成大的。 可以想象为之前改成了某字母，后面又改成了另一字母（大可以直接改成最终字母，这种方案一定合法） 最后遍历，减去不需要更改的。 #inc
bzoj 1040 zjoi2008 骑士 树形dp
08-08
我们可以使用树形dp来解决这个问题，具体来说，我们可以将这个图看作是一棵树，每个点的父节点是它的前驱或者后继，然后我们从根节点开始，依次向下遍历，对于每个节点，我们可以考虑它的两个儿子，如果它的两个儿子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值