C++博客-From A Start,As An Acmer-随笔分类-数据结构

HDU 4022 Bombing【STL 继续练习】

BUPT-[aswmtjdsj] @ Penalty — Sat, 10 Sep 2011 11:10:00 GMT

今天真是各种sb，弱爆了。
果然以后做网预的时候就应该第一道水题用STL各种水。
闲话少说。
本题题意略，直接说做法。
首先，必需的是离散化。sort+MAP是我的离散化方法，个人觉得这样虽然慢，但是好写。
后面的就八仙过海各显神通了。什么用十字链表模拟啊，什么multiset啊，什么vector啊，什么数组直接标记啊，不一而足，水题就要用水题的方法做。
我是vector做的。
开了200000个vector分别用来存储离散化后的每行及每列中元素的个数。
每次查询的时候，将对应行/或者列的size输出，然后对其中每个元素在另外一边（行/列）用upper/lower_bound查存在性，存在的都删除erase，然后将本行/列清空clear。
一开始就是WA在此处了，因为有重复坐标的点，而set的一般写法无法处理这种情况，想了半天最后用了vector+二分。太蛋疼了。
还RE了一次，因为对于vector来说，erase作为动态删除会使其周围元素的指针改变，会发生内存泄漏、指针悬挂等现象，所以果断要用erase的范围删除操作[low,up)。
没啥说的，复杂度均摊下来很小，因为不会重复统计，所以顶多是NlogN的复杂度，再加上离散化的复杂度，整体NlogN。

老话，STL能做，为啥要手写？出题卡STL的就是sb，不解释；至于什么叫卡STL，各位大牛都懂得。
今天弱爆了，就这样吧。
附代码：

#include <iostream>
#include <cstdio>
#include <set>
#include <map>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;
#define maxn 100005
struct point
{
    int x,y;
    point(){}
    point(int a,int b):x(a),y(b){}
}p[maxn];
int x[maxn],y[maxn];
int n,m;
vector <int> X[maxn],Y[maxn];
map <int,int> MX,MY;
vector <int> ::iterator xlow,xup,ylow,yup,idx,idy;
int main()
{
    while(scanf("%d %d",&n,&m) == 2 && (n || m))
    {
        MX.clear();
        MY.clear();
        for(int i = 1;i <= n;i++)
        {
            if(!X[i].empty())
                X[i].clear();
            if(!Y[i].empty())
                Y[i].clear();
        }
        for(int i = 0;i < n;i++)
        {
            int a,b;
            scanf("%d %d",&a,&b);
            p[i] = point(a,b);
            x[i] = a;
            y[i] = b;
        }
        sort(x,x + n);
        sort(y,y + n);
        int cntx = 1,cnty = 1;
        for(int i = 0;i < n;i++)
        {
            if(MX[x[i]] == 0)
                MX[x[i]] = cntx++;
            if(MY[y[i]] == 0)
                MY[y[i]] = cnty++;
        }
        for(int i = 0;i < n;i++)
        {
            p[i].x = MX[p[i].x];
            p[i].y = MY[p[i].y];
            idx = lower_bound(X[p[i].x].begin(),X[p[i].x].end(),p[i].y);
            X[p[i].x].insert(idx,p[i].y);
            idy = lower_bound(Y[p[i].y].begin(),Y[p[i].y].end(),p[i].x);
            Y[p[i].y].insert(idy,p[i].x);
        }
        for(int i = 0;i < m;i++)
        {
            int mod,d;
            scanf("%d %d",&mod,&d);
            if(mod == 0)
            {
                d = MX[d];
                printf("%d\n",X[d].size());
                if(X[d].empty())
                    continue;
                for(idx = X[d].begin();idx != X[d].end();idx++)
                {
                    int p = *idx;
                    ylow = lower_bound(Y[p].begin(),Y[p].end(),d);
                    yup = upper_bound(Y[p].begin(),Y[p].end(),d);
                    Y[p].erase(ylow,yup);
                }
                X[d].clear();
            }
            else
            {
                d = MY[d];
                printf("%d\n",Y[d].size());
                if(Y[d].empty())
                    continue;
                for(idy = Y[d].begin();idy != Y[d].end();idy++)
                {
                    int p = *idy;
                    xlow = lower_bound(X[p].begin(),X[p].end(),d);
                    xup = upper_bound(X[p].begin(),X[p].end(),d);
                    X[p].erase(xlow,xup);
                }
                Y[d].clear();
            }
        }
        puts("");
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-09-10 19:10 发表评论

HDU 3887 Counting Offspring ［DFS序列＋树状数组］

BUPT-[aswmtjdsj] @ Penalty — Wed, 27 Jul 2011 16:47:00 GMT

Counting Offspring

Time Limit: 15000/5000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 423 Accepted Submission(s): 137

Problem Description

You are given a tree, it’s root is p, and the node is numbered from 1 to n. Now define f(i) as the number of nodes whose number is less than i in all the succeeding nodes of node i. Now we need to calculate f(i) for any possible i.

Input

Multiple cases (no more than 10), for each case:
The first line contains two integers n (0Following n-1 lines, each line has two integers, representing an edge in this tree.
The input terminates with two zeros.

Output

For each test case, output n integer in one line representing f(1), f(2) … f(n), separated by a space.

Sample Input

Sample Output

0 0 0 0 0 1 6 0 3 1 0 0 0 2 0

Author

bnugong

Source

2011 Multi-University Training Contest 5 - Host by BNU

题意是，给一棵树，给每个结点一个标号，问所有存在的结点，它的子树中，结点标号小于它的有多少个。

做法：DFS序列构造＋树状数组查询区间。

竟然忘了DFS的遍历的意义。对一棵树进行DFS遍历，一个结点最多到达两次，一次出，一次入，而这之间的结点标号均为它的子树结点的标号。所以只要用某种方法快速查询其左右标号内含的区间中，比它小的标号个数即可。（别＊2）在肖神的提携下，ym到了树状数组在本题的使用方法。

做法流程。初始化（记得树状数组和DFS记录序列要开点数*2的。。因为这个nc半天，不解释。）－>建图－> DFS（因为HDU坑爹的栈大小，必须手写栈模拟DFS才能过。。第一次手工模拟DFS。。太蛋疼了。。调了无数次。）－>对于每个点查询DFS序列。（既然是离线查询，那么就按照从小到大查吧。凡事要有个序，有序了就好查了。对于每个点的标号，先查它的左右区间是否有比它小的sum(r[i] - 1) - sum(l[i]]).....再把它插入树状数组中，插一次就好，不然结果还得除二。（都是肖神！）
T_T。。记得树状数组和dfs序列都是开到点数*2的，而其他的都是点数大小的。注意初始化和树状数组查询和更新时的范围同理。
代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <stack>
#include <algorithm>
using namespace std;
stack <int> S;
#define maxn 100005
int cnt,p,n,tot,lit[maxn],seq[maxn * 2],l[maxn],r[maxn],tr[maxn * 2];
int bit(int x){return x & -x;}
bool vis[maxn];
struct edge
{
    int p,next;
    edge(){}
    edge(int a,int b):p(a),next(b){}
}v[maxn],e[maxn * 2];
void add(int p,int q)
{
    e[tot] = edge(q,v[p].next);
    v[p].next = tot++;
}
int sum(int x)
{
    int ans = 0;
    for(;x > 0;x -= bit(x))
        ans += tr[x];
    return ans;
}
void mod(int x,int val)
{
    for(;x < cnt;x += bit(x))
        tr[x] += val;
}
void init()
{
    tot = 0;
    for(int i = 1;i <= n;i++)
        v[i].next = -1;
    fill(tr,tr + 2 * n + 1,0);
    fill(vis,vis + n + 1,0);
    while(!S.empty())
        S.pop();
}
void dfs()
{
    cnt = 1;
    S.push(p);
    while(!S.empty())
    {
        int now = S.top();
        if(!vis[now])
        {
            seq[cnt] = now;
            l[now] = cnt++;
            vis[now] = true;
        }
        bool mark = false;
        for(int k = v[now].next;~k;k = e[k].next)
        {
            if(!vis[e[k].p])
            {
                mark = true;
                S.push(e[k].p);
                v[now].next = e[k].next;
                break;
            }
        }
        if(mark)
            continue;
        if(vis[now])
        {
            seq[cnt] = now;
            r[now] = cnt++;
            S.pop();
        }
    }
}
void gao()
{
    for(int i = 1;i <= n;i++)
    {
        lit[i] = sum(r[i] - 1) - sum(l[i]);
        mod(l[i],1);
    }
}
int main()
{
    while(scanf("%d %d",&n,&p) == 2 && (p || n))
    {
        init();
        for(int i = 0;i < n - 1;i++)
        {
            int a,b;
            scanf("%d %d",&a,&b);
            add(a,b);
            add(b,a);
        }
        dfs();
        gao();
        for(int i = 1;i <= n;i++)
        {
            printf("%d",lit[i]);
            putchar((i == n)?'\n':' ');
        }
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-07-28 00:47 发表评论

HDU 3673 David Shopping 【可修改堆】

BUPT-[aswmtjdsj] @ Penalty — Tue, 05 Jul 2011 05:10:00 GMT

2007 Asia Regional Chengdu D题：David Shopping
原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=3673
涉及算法：可修改堆+标记数组（后者不算算法……请勿鄙视）（大牛们都用STL过的，我手写优先队列。。。。蛋都碎了）

题目大意：
    你有一个能放M(M <= 50000)个物品的容器，你可能会遇到N（N <= 100000)个物品。
    规则：
        1.遇到的物品K你如果之前没有遇到过，且你的容器未满，那么把这个物品（编号K），放进容器中，并记录数字1（相当于权值），且记录遇到该物品的时间t。
        2.遇到的物品K如果在你的容器里，那么仅仅把它的标记数字（即所谓权值+1）。
        3.遇到的物品K你如果之前没有遇到过，且你的容器已满，那么就把容器里标记数字最大的容器移除，如果不止一个，那么就把最先进入容器的那一个移除。（移除的物品就相当于没有遇到过，之后遇到算第一次遇到。）
    求解问题：给你M，N，以及一行数字N个K(i)，（K（i）< 2^20,i = 1 to N)，输出共发生移除操作多少次。（TimeLimit：1s）
算法：
模拟优先队列，实现O(Nlog(M))的时间复杂度的算法。
利用堆的性质，实现插入，删除，维持堆的性质操作均为O(logM)的复杂度。
利用外置标记数组，记录关键值对应元素在书中的位置，类似（计数排序）（或者说哈希表，或者说外部索引数组）的思想。（其实我觉得算是骗过去的。因为空间复杂度O(MAX(K(i)))。。。如果K(i)大一点，内存就爆了。。不过现场赛不卡内存，幸好幸好～

#include <iostream>
#include <cstdio>
#define left(x) (x << 1)
#define right(x) ((x << 1) + 1)
#define parent(x) (x >> 1)
using namespace std;
struct heap
{
    int key,t,w;
} h[50005];//key为物品名K，t为入队时间，w为权值
int now,n,m,cnt,fuck[(1 << 21)],pick[100005];//now：初始插入位置，n,m:respectively，cnt:关键计数器，记录出队次数，f**k数组用于计数排序记录某元素在堆/队列中的位置
void init()//初始化
{
    for(int i = 1;i <= n + 1;i++)
    {
        h[i].key = h[i].w = 0;//堆中元素权值为零
        h[i].t = m + 1;//堆中元素入队时间均为最大时间值+1
    }
}
void make(int i)//保持堆的性质，同时更新外部索引数组(O(h) = O(logM))
{
    int large,l,r;
    l = left(i);
    r = right(i);
    if(l <= n && (h[l].w > h[i].w || (h[l].w == h[i].w && h[l].t < h[i].t)))//同时对权值和时间进行对比，维持性质
        large = l;
    else
        large = i;
    if(r <= n && (h[r].w > h[large].w || (h[r].w == h[large].w && h[r].t < h[large].t)))
        large = r;
    if(large != i)
    {
        int tempp = fuck[h[i].key];//先交换外部索引数组中对应元素的位置，再维护堆的性质，保持实时更新
        fuck[h[i].key] = fuck[h[large].key];
        fuck[h[large].key] = tempp;
        swap(h[i],h[large]);
        make(large);
    }
}
void insert(int key,int p,int t)//插入函数，先插入，通过now记录暂时的初始位置，再用保持堆的性质来维护堆且维护元素位置(O(h) = O(logM)，等价于维护堆性质的复杂度)
{
    h[p].key = key;
    h[p].t = t;
    h[p].w = 1;
    fuck[key] = p;
    make(1);
    now ++;
}
void insert2(int key,int t)//同时实现出队和入队操作。（此时为队列已满的情况）(O(h) = O(logM)，等价于维护堆性质的复杂度)
{
    fuck[h[1].key] = -1;//一句话出队，哇卡卡～
    fuck[key] = 1;
    h[1].key = key;
    h[1].t = t;
    h[1].w = 1;
    make(1);
}
int re(int i)//所谓的权值修护（堆的可修改性）(O(h) = O(logM)，等价于维护堆性质的复杂度)
{
    bool mark = false;
    int p = parent(i);//对于权值增加的堆元素，沿路向上，进行反向堆维护，从而使权值更改的元素达到正确的位置，方便之后重新进行维护堆的性质操作
    if(p >= 1 && (h[p].w < h[i].w || (h[p].w == h[i].w && h[p].t > h[i].t)))
    {
        mark = true;
        int tempp = fuck[h[i].key];
        fuck[h[i].key] = fuck[h[p].key];
        fuck[h[p].key] = tempp;
        swap(h[i],h[p]);
        return re(p);
    }//重新堆维护的起始点，某祖先点，或者该点
    if(mark)
        return p;
    else
        return i;
}
void print()//这脑残函数是用来测试sample的。。帮了我大忙阿。。。其实大神们的调试都是各有风格的，而小菜们的调试，如我，都是类似的。。。
{
    cout << endl;
    for(int i = 1;i <= n;i++)
    {
        printf("h[%d] %d %d %d %d\n",i,h[i].key,h[i].w,h[i].t,fuck[h[i].key]);
    }
}
int FIND(int key){return fuck[key];}//索引查找，一句话函数～
void solve()
{
    now = 1;
    cnt = 0;
    int key,pos,Max = 0;
    init();
    for(int i = 1;i <= m;i++)//缓存读入，查找最大key值元素
    {
        scanf("%d",&pick[i]);
        Max = (Max < pick[i]) ? pick[i] : Max;
    }
    for(int i = 0;i <= Max;i++)//通过key值元素的最大值，开适合大小的索引数组（节省内存和时间）
        fuck[i] = -1;
    for(int i = 1;i <= m;i++)
    {
        key = pick[i];
        pos = FIND(key);//查找是否已入队
        if(pos == -1)//新插
        {
            if(now > n)//已满
            {
                cnt ++;
                insert2(key,i);
            }
            else//未满
                insert(key,now,i);
        }
        else//已有
        {
            h[pos].w ++;
            //WA POINT
            make(re(pos));//可修改堆。。。之前一直忘记了这个根本。。。加了修改权值操作之后就过了。。蛋碎。。。。。
        }
        //print();
    }
    printf("%d\n",cnt);
}
int main()
{
    int CAS = 1;
    while(scanf("%d%d",&n,&m) != EOF && (n || m))
    {
        printf("Case %d: ",CAS++);
        solve();
    }
}

//小菜出品，欢迎大牛拍我。。。。

BUPT-[aswmtjdsj] @ Penalty 2011-07-05 13:10 发表评论

BOJ 1295 ACM system 【可修改堆】

BUPT-[aswmtjdsj] @ Penalty — Tue, 05 Jul 2011 05:01:00 GMT

ACM systemLogin and star it!Submit: 283 Accepted:39Time Limit: 3000MS Memory Limit: 65535KDescription
912实验室最近设计了一种能够自动控制进程调度的系统，英文名是Automatic Control Machinery，简称ACM。该系统具有很多优秀的功能，为了方便大家的理解，这里先介绍一下关于进程、进程调度的常识。
1、每个进程需要占用1个或多个单位内存空间，然而令人惊叹的是，在912实验室开发的平台上，一个进程只需要占用1个单位内存！
2、每个进程用三个参量来表示，编号、权值、内存地址(0x00000000~0xFFFFFFFF)。
3、所有的进程都被集中到一个名为“进程池”的地方，ACM系统可以实时的从进程池中选取最高优先级的进程。
4、我们定义进程之间的优先级如下，如果两个进程的权值不同，权值大的优先级高；如果权值相同，编号小的进程优先级高。
现在就要介绍下ACM系统的详细功能了，它总共有4种操作：
1、 Get，返回当前最高优先级的进程信息(编号、权值、内存地址)
2、 Creat ID W ADDRESS，在进程池中创建一个编号为ID，权值为W，地址为ADDRESS的进程
3、 Kill ID，无条件的中止编号为ID的进程
4、 Change ID W，改变编号为ID的进程的权值
由于ACM系统尚在理论研究阶段，所以我们希望热心的你帮忙实现该系统，以具备上述所说的功能。当然，你的系统应该有一定的健壮性，至少能够对错误的操作给出异常提示。

Input
输入包含多组测试数据。
首先第一行输入一个数T(T<=10)，表示总共有T组测试数据。
接下来是每组测试数据，第一行是一个数N(N<=100000)，表示总共有N个不同编号(编号从0到N-1)的进程。然后是一个数n(n& lt;=100)，表示ACM系统启动的时候，需要初始化的n个进程。接着n行，都是id、w、address这样的形式出现，表示这n个进程的详细信息。
紧接着是一个数M(M<=200000)，表示总共有M个操作。接着M行，描述的是下面四种中的某一种操作：
1、 Get
2、 Creat ID W ADDRESS
3、 Kill ID
4、 Change ID W

Output
首先，输出Case X：其中X代表是第X组数据(具体格式参照样例)。
对于Get操作，你需要返回最高优先级进程的信息或异常提示(进程池中无进程)。
对于Creat、Kill、Change操作，如果出现了错误操作(新添加进程的编号已经存在了、新添加进程的地址已经被使用了、中止根本不存在的进程、改变不存在进程的权值)，给出异常提示，并忽略该操作；如果上述三种操作都正确，不需要输出任何东西。
对于所有的异常，只需输出“ERROR！”即可。

Sample Input

2
1
1
0 3 0xAAAAAAAA
3
Creat 0 2 0xFFFFFFFF
Kill 0
Get
3
2
0 1 0x11112222
1 2 0x22221111
5
Get
Change 2 2
Kill 1
Get
Kill 1

Sample Output

Case 1:
ERROR!
ERROR!
Case 2:
1 2 0x22221111
ERROR!
0 1 0x11112222
ERROR!

Hint
巨大的输入输出，推荐scanf和printf

Source
humanjustic

题目链接：http://boj.me/onlinejudge/showproblem.php?problem_id=1295

题目要求：

实现某种数据结构，性质如下。

可用于存储元素，元素有三个属性，编号（整数），权值（整数），地址（十六进制表示的整数）。

元素有偏序关系，权值大者优先，编号小者优先（二级比较）。

能够实现如下功能。

1初始化，可以初始化结构中N个元素（利用三个数值）。

2插入新元素，可返回错误信息。（编号重复的报错，地址重复的报错）

3删除已有元素，可返回错误信息。（编号不存在的报错）

4返回最高优先级元素，可返回错误信息。（结构中为空，即无元素报错）

5改变元素的权值，可返回错误信息。（对应编号不存在的报错）

先说感想：

数据结构神马的，要有想象力，但是又不像贪心题和DP题那样需要YY能力。只要YY出能够优化复杂度的结构来即可。（前提是足够的数据结构知识储备和强大的代码能力）

话说这道题的那个神奇的内存地质。。。十六进制数，让我好好学习了一下scanf、printf读入输出指定格式十六进制数，以及cout的格式输出。编程语言的开创者们真是给想好了各种内部优化，不用小菜我再去纠结格式输出的问题。（不然用字符串存地址，铁定超时啊）

Solution：

直观解，该数据结构为堆。根据CLRS，可实现其build、heapify、increase、maximum、insert、delete等全部操作，这些操作的复杂度均为O(logN)（build除外，O(N * LogN)。

但问题在于，传统heap无法实现对于特定编号元素的O(LogN)的查找。

所以配合HASH（两种偷懒的HASH方式，一为int标记数组，二为map映射，分别为O(1)（标记）,O(LogN)（红黑树））。

具体实现：

int to[]，用标记数组记录对应编号元素（数组下标）在堆中的位置（还是数组下标，不过是堆的）

map add，用map将地址映射，用于记录指定地址的存在性

struct node（为了元素的偏序关系才要这个）

（以下每个函数在操作的同时，要维护to数组和add的HASH）

inc函数，对于堆中特定位置的元素，增加其权值到指定值，再逆向维护堆的性质

insert函数，将新加入的元素插在堆尾，再用inc函数增加权值并维护堆性质

heapify函数，从特定位置起，向下正向维护堆性质

del函数，交换堆尾元素与被删元素，再用heapify维护

change函数，如果是权值增加操作则逆向维护堆，反之则正向维护堆

所有函数实现的过程中通过对to数组和add哈希的查找来判断报错与否

#include <iostream>

#include <cstdio>

#include <map>

#include <cstring>

#include <iomanip>

#define left(i) ((i) << 1)

#define right(i) (((i) << 1) + 1)

#define parent(i) ((i) >> 1)

#define WRONG printf("ERROR!\n")

using namespace std;

typedef unsigned long ul;

struct node

{

    int num,value;

    long long addr;

    node(){}

    node(int _num,int _value,ul _addr)

    {

        num = _num;

        value = _value;

        addr = _addr;

    }

    bool friend operator < (const node &a,const node &b)

    {

        return (a.value < b.value) || (a.value == b.value && a.num > b.num );

    }

    void print()

    {

        printf("%d %d 0x%08X\n",num,value,addr);

        //cout.fill('0');

        //cout << setw(8) << HEX << addr << '\n';

        /*for(int i = 31;i >= 0;i -= 4)

        {

            int temp = 0;

            for(int j = 0;j < 4;j++)

                temp += (((value >> (i - j)) & 1) * (1 << (4 - j)));

            printf("%c",(temp > 9) ? (temp - 10 + 'A') : (temp + '0'));

        }

        printf("\n");*/

    }

};

struct heap

{

    map <ul,int> add;

    int to[100005];

    //map  to;//id to index

    node * ele[100005];

    int size;

    heap(int N){size = 0;for(int i = 0;i <= N;i++)to[i] = 0;}

    bool insert(int num,int value,ul addr)

    {

        if(to[num] != 0 || add[addr] != 0)//id existed || addr existed.

            return false;//judge

        ele[++ size] = new node;

        inc(size,num,value,addr);

        return true;

    }

    bool del(int id)

    {

        int pos;

        //cout << "\t\t\tid : " << to[id] << endl;

        if(to[id] == 0)//delete doesn't exist

            return false;

        //cout << "\t\t\tpos : " << to[id] << " id : " << id << endl;

        pos = to[id];

        to[ele[size] -> num] = pos;

        to[id] = 0;

        //cout << "\t\t\tpos : " << to[id] << " id : " << id << endl;

        add[ele[pos] -> addr] = 0;

        swap(ele[pos],ele[size]);

        delete ele[size];

        ele[size] = NULL;

        size--;

        heapify(pos);

        return true;

    }

    bool top()//empty

    {

        if(size < 1)

            return false;

        else

        {

            ele[1] -> print();

            return true;

        }

    }

    void heapify(int pos)

    {

        int l = left(pos),r = right(pos),big;

        if(l <= size && *ele[pos] < *ele[l])

            big = l;

        else

            big = pos;

        if(r <= size && *ele[big] < *ele[r])

            big = r;

        if(big != pos)

        {

            swap(ele[big],ele[pos]);

            swap(to[ele[big] -> num],to[ele[pos] -> num]);

            /*cout << " ---------------------------" << endl;

            cout << ele[big] -> num  << " id " << ele[pos] -> num << endl;

            cout << " ---------------------------" << endl;*/

            heapify(big);

        }

    }

    void inc(int pos,int id,int value,ul ad)

    {

        ele[pos] -> num = id;

        ele[pos] -> value = value;

        ele[pos] -> addr = ad;

        to[id] = pos;

        add[ad] ++;

        int t = pos,pt = parent(pos);

        while(pt >= 1 && !(*ele[t] < *ele[pt]))

        {

            swap(ele[t],ele[pt]);

            swap(to[ele[t] -> num],to[ele[pt] -> num]);

            t = pt;

            pt = parent(t);

        }

    }

    bool change(int num,int value)

    {

        if(to[num] == 0)

            return false;

        int pos = to[num];

        if(ele[pos] -> value > value)

        {

            ele[pos] -> value = value;

            heapify(pos);

        }

        else if(ele[pos] -> value == value)

            ;

        else

        {

            ele[pos] -> value = value;

            int t = pos,pt = parent(pos);

            while(pt >= 1 && !(*ele[t] < *ele[pt]))

            {

                swap(ele[t],ele[pt]);

                swap(to[ele[t] -> num],to[ele[pt] -> num]);

                t = pt;

                pt = parent(t);

            }

        }

        return true;

    }

};

void solve()

{

    int N,n,m;

    scanf("%d",&N);

    scanf("%d",&n);

    heap s(N);

    for(int i = 0;i < n;i++)

    {

        int a,b;

        ul c;

        scanf("%d %d %X",&a,&b,&c);

        s.insert(a,b,c);

        /*cout << endl <<"--------------------AA" << " size : " << s.size << endl;

        for(int j = 1;j <= s.size;j++)

            s.ele[j] -> print();

        cout <<"--------------------AA" << endl << endl;*/

    }

    scanf("%d",&m);

    for(int i = 0;i < m;i++)

    {

        //cout << "option : " << i + 1 << endl;

        char opt[10];

        scanf("%s",opt);

        //cout << opt << " ";

        if(!strcmp(opt,"Get"))

        {

            if(!s.top())

                WRONG;

        }

        else if(!strcmp(opt,"Creat"))

        {

            int a,b;

            ul c;

            scanf("%d %d %X",&a,&b,&c);

            //printf("%d %d 0x%X\n",a,b,c);

            if(!s.insert(a,b,c))

                WRONG;

        }

        else if(!strcmp(opt,"Kill"))

        {

            int a;

            scanf("%d",&a);

            //printf("%d\n",a);

            if(!s.del(a))

                WRONG;

        }

        else if(!strcmp(opt,"Change"))

        {

            int a,b;

            scanf("%d%d",&a,&b);

            //printf("%d %d\n",a,b);

            if(!s.change(a,b))

                WRONG;

        }

        /*cout << endl <<"--------------------AA" << " size : " << s.size << endl;

        for(int j = 1;j <= s.size;j++)

            s.ele[j] -> print();

        cout <<"--------------------AA" << endl << endl;*/

    }

}

int main()

{

    int t;

    freopen("data.in","r",stdin);

    freopen("data3.out","w",stdout);

   // while(scanf("%d",&t) == 1)

    scanf("%d",&t);

    {

        for(int i = 0;i < t;i++)

        {

            printf("Case %d:\n",i + 1);

            solve();

        }

    }

}

BUPT-[aswmtjdsj] @ Penalty 2011-07-05 13:01 发表评论