C++博客-夜幻梦回-随笔分类-HDU

hdu 2871 Memory Control——线段树

火碳黑 — Tue, 10 May 2011 14:13:00 GMT

Memory Control

Problem Description

Memory units are numbered from 1 up to N.
A sequence of memory units is called a memory block.
The memory control system we consider now has four kinds of operations:
1.  Reset Reset all memory units free.
2.  New x Allocate a memory block consisted of x continuous free memory units with the least start number
3.  Free x Release the memory block which includes unit x
4.  Get x Return the start number of the xth memory block(Note that we count the memory blocks allocated from left to right)
Where 1<=x<=N.You are request to find out the output for M operations.

Input

Input contains multiple cases.
Each test case starts with two integer N,M(1<=N,M<=50000) ,indicating that there are N units of memory and M operations.
Follow by M lines,each line contains one operation as describe above.

Output

For each “Reset” operation, output “Reset Now”.
For each “New” operation, if it’s possible to allocate a memory block,
output “New at A”,where Ais the least start number,otherwise output “Reject New”.
For each “Free” operation, if it’s possible to find a memory block occupy unit x,
output “Free from A to B”,where A and B refer to the start and end number of the memory block,otherwise output “Reject Free”.
For each “Get” operation, if it’s possible to find the xth memory blocks,
output “Get at A”,where A is its start number,otherwise output “Reject Get”.
Output one blank line after each test case.

Sample Input

6 10
New 2
New 5
New 2
New 2
Free 3
Get 1
Get 2
Get 3
Free 3
Reset

Sample Output

New at 1
Reject New
New at 3
New at 5 
Free from 3 to 4
Get at 1
Get at 5
Reject Get
Reject Free
Reset Now

#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <iostream>
#define maxn 51000
using namespace std;
inline int L(int th)
{
    return (th << 1);
}
inline int R(int th)
{
    return ((th << 1) | 1);
}
struct Tree
{
    int l, r;
    int cover, rely;
    int lm, rm, maxl;
    int getLen()
    {
        return r - l;
    }
    int mid()
    {
        return ((l + r) >> 1);
    }
}stree[maxn * 4];
void build(int l, int r, int th)
{
    //printf("%d %d\n", l, r);
    stree[th].l = l, stree[th].r = r;
    stree[th].cover = stree[th].rely = 0;
    stree[th].lm = stree[th].rm = stree[th].maxl = stree[th].getLen();
    if (l + 1 == r)
    {
        return;
    }
    int m = stree[th].mid();
    if (r <= m)
    {
        build(l, r, L(th));
    }
    else if (l >= m)
    {
        build(l, r, R(th));
    }
    else
    {
        build(l, m, L(th)), build(m, r, R(th));
    }
}
void update(int th, int kind)//rely操作更新
{
    stree[th].rely = 1;
    stree[th].cover = kind;
    if (stree[th].cover == 0)
    {
        stree[th].lm = stree[th].rm = stree[th].maxl = stree[th].getLen();
    }
    else
    {
        stree[th].lm = stree[th].rm = stree[th].maxl = 0;
    }
}
void insert(int l, int r, int th, int kind)
{
    //printf("insert %d, %d\n", l, r);
    if (stree[th].l == l && stree[th].r == r)
    {
        update(th, kind);
        return;
    }
    if (stree[th].rely)
    {
        stree[th].rely = 0;
        update(L(th), stree[th].cover);
        update(R(th), stree[th].cover);
    }
    stree[th].cover = -1;//设置无效区域，在这里体现不上用处，不更新也行,出于习惯跟逻辑需要
    int m = stree[th].mid();
    if (r <= m)
    {
        insert(l, r, L(th), kind);
    }
    else if (l >= m)
    {
        insert(l, r, R(th), kind);
    }
    else
    {
        insert(l, m, L(th), kind);
        insert(m, r, R(th), kind);
    }
    stree[th].lm = stree[L(th)].lm, stree[th].rm = stree[R(th)].rm;
    if (stree[L(th)].lm == stree[L(th)].getLen())
    {
        stree[th].lm += stree[R(th)].lm;
    }
    if (stree[R(th)].rm == stree[R(th)].getLen())
    {
        stree[th].rm += stree[L(th)].rm;
    }
    stree[th].maxl = max(stree[L(th)].maxl, stree[R(th)].maxl);
    stree[th].maxl = max(stree[th].maxl, stree[L(th)].rm + stree[R(th)].lm);
}
int query(int th, int len)
{
    if (stree[th].l + 1 == stree[th].r)
    {
        if (stree[th].maxl >= len)
        {
            return stree[th].l;
        }
        return 0;
    }
    if (stree[th].rely)
    {
        stree[th].rely = 0;
        update(L(th), stree[th].cover);
        update(R(th), stree[th].cover);
    }
    if (stree[th].maxl < len)//该线段最大空白段maxl小于len
    {
        return 0;
    }
    if (stree[L(th)].maxl >= len)//左孩子最大空白段满足len
    {
        return query(L(th), len);
    }
    else if(stree[L(th)].rm + stree[R(th)].lm >= len)//由两孩子的中间合并满足
    {
        return stree[L(th)].r - stree[L(th)].rm;
    }
    else//右孩子满足
    {
        return query(R(th), len);
    }
}
struct Seg
{
    int left, right;
};
vector<Seg>list;
int bsc(int key)
{
    //查找key所在的位置的后一位，
    //如果不存在包含key的线段时：
    //1.key比第一个线段小，返回的是0,0-1就等于-1
    //2.key比起点最大线段还大，则返回这个线段的后一位，key可能被这个线段包含，可能不被这个线段包含，取决于这个线段的右端点
    int l = 0, r = list.size() - 1, m;
    while (l <= r)
    {
        m = (l + r) >> 1;
        if (list[m].left > key)
        {
            r = m - 1;
        }
        else if (list[m].left <= key)//保证l在满足线段的后一位
        {
            l = m + 1;
        }
    }
    return l;
}
void show()
{
    int i;
    for (i = 0; i < list.size(); i++)
    {
        printf("%d:%d %d\n", i, list[i].left, list[i].right);
    }printf("----\n");
}
int main()
{
    int len, x, k, n, m, id;
    Seg tmp;
    while (scanf("%d%d", &n, &m) - EOF)
    {
        build(1, n + 1, 1);
        char op[10];
        list.clear();
        while (m--)
        {
            scanf("%s", op);
            if (*op == 'N')
            {
                scanf("%d", &len);
                k = query(1, len);
                if (k)
                {
                    printf("New at %d\n", k);
                    insert(k, k + len, 1, 1);
                    tmp.left = k, tmp.right = k + len;
                    if (list.size() == 0)
                    {
                        list.push_back(tmp);
                    }
                    else
                    {
                        id = bsc(k);
                        list.insert(list.begin() + id, tmp);
                    }
                    //show();
                }
                else
                {
                    printf("Reject New\n");
                }
            }
            else if (*op == 'F')
            {
                scanf("%d", &x);
                k = bsc(x) - 1;
                if (k == -1 || list[k].right <= x)
                {
                    printf("Reject Free\n");
                }
                else
                {
                    printf("Free from %d to %d\n", list[k].left, list[k].right - 1);
                    insert(list[k].left, list[k].right, 1, 0);
                    list.erase(list.begin() + k, list.begin() + k + 1);
                }
            }
            else if (*op == 'G')
            {
                scanf("%d", &x);
                if (x <= list.size())
                {
                    printf("Get at %d\n", list[x-1].left);
                }
                else
                {
                    printf("Reject Get\n");
                }
            }
            else if (*op == 'R')
            {
                insert(1, n + 1, 1, 0);
                list.clear();
                printf("Reset Now\n");
            }
        }
        printf("\n");
    }
    return 0;
}
/*
3 100
N 1
N 1
N 1
F 1
N 1
F 2
N 1
F 3
N 2
*/

火碳黑 2011-05-10 22:13 发表评论

hdu 1166 敌兵布阵——

火碳黑 — Thu, 05 May 2011 04:14:00 GMT

敌兵布阵

Problem Description

C国的死对头A国这段时间正在进行军事演习，所以C国间谍头子Derek和他手下Tidy又开始忙乎了。A国在海岸线沿直线布置了N个工兵营地, Derek和Tidy的任务就是要监视这些工兵营地的活动情况。由于采取了某种先进的监测手段，所以每个工兵营地的人数C国都掌握的一清二楚,每个工兵营地的人数都有可能发生变动，可能增加或减少若干人手,但这些都逃不过C国的监视。
中央情报局要研究敌人究竟演习什么战术,所以Tidy要随时向Derek汇报某一段连续的工兵营地一共有多少人,例如Derek问:“Tidy,马上汇报第 3个营地到第10个营地共有多少人!”Tidy就要马上开始计算这一段的总人数并汇报。但敌兵营地的人数经常变动，而Derek每次询问的段都不一样，所以Tidy不得不每次都一个一个营地的去数，很快就精疲力尽了，Derek对Tidy的计算速度越来越不满:"你个死肥仔，算得这么慢，我炒你鱿鱼!” Tidy想：“你自己来算算看，这可真是一项累人的工作!我恨不得你炒我鱿鱼呢!”无奈之下，Tidy只好打电话向计算机专家Windbreaker求救,Windbreaker说：“死肥仔，叫你平时做多点acm题和看多点算法书，现在尝到苦果了吧!”Tidy说："我知错了。。。"但 Windbreaker已经挂掉电话了。Tidy很苦恼，这么算他真的会崩溃的，聪明的读者，你能写个程序帮他完成这项工作吗？不过如果你的程序效率不够高的话，Tidy还是会受到Derek的责骂的.

Input

第一行一个整数T，表示有T组数据。
每组数据第一行一个正整数N（N<=50000）,表示敌人有N个工兵营地，接下来有N个正整数,第i个正整数ai代表第i个工兵营地里开始时有ai个人（1<=ai<=50）。
接下来每行有一条命令，命令有4种形式：
(1) Add i j,i和j为正整数,表示第i个营地增加j个人（j不超过30）
(2)Sub i j ,i和j为正整数,表示第i个营地减少j个人（j不超过30）;
(3)Query i j ,i和j为正整数,i<=j，表示询问第i到第j个营地的总人数;
(4)End 表示结束，这条命令在每组数据最后出现;
每组数据最多有40000条命令

Output

对第i组数据,首先输出“Case i:”和回车,
对于每个Query询问，输出一个整数并回车,表示询问的段中的总人数,这个数最多不超过1000000。

Sample Input

1
10
1 2 3 4 5 6 7 8 9 10
Query 1 3
Add 3 6
Query 2 7
Sub 10 2
Add 6 3
Query 3 10
End

Sample Output

Case 1:
6
33
59

分析：这题，最裸的线段树，最裸的树状数组。为了练习segment tree，所以...
直接贴：

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#define maxn 50010
using namespace std;
struct Tree
{
    int l, r, sum;
}tree[maxn * 5];
int p[maxn];
inline int L(int x)
{
    return (x << 1);
}
inline int R(int x)
{
    return (x << 1) | 1;
}
void build(int l, int r, int th)
{
    tree[th].l = l, tree[th].r = r, tree[th].sum = 0;
    if (l == r)
    {
        tree[th].sum = p[l];
        return;
    }
    int m = (l + r) >> 1;
    build(l, m, L(th)), build(m + 1, r, R(th));
    tree[th].sum = tree[L(th)].sum + tree[R(th)].sum;
}
void insert(int l, int r, int th, int num)
{
    if (tree[th].l == l && tree[th].r == r)
    {
        tree[th].sum += num;
        //if (tree[th].sum < 0) tree[th].sum = 0;有点多想了,wa了一次
        return;
    }
    int m = (tree[th].l + tree[th].r) >> 1;
    if (r <= m)
    {
        insert(l, r, L(th), num);
    }
    else if (l > m)
    {
        insert(l, r, R(th), num);
    }
    else
    {
        insert(l, m, L(th), num), insert(m + 1, r, R(th), num);
    }
    tree[th].sum = tree[L(th)].sum + tree[R(th)].sum;
}
int query(int l, int r, int th)
{
    if (tree[th].l == l && tree[th].r == r)
    {
        return tree[th].sum;
    }
    int m = (tree[th].l + tree[th].r) >> 1;
    if (r <= m)
    {
        return query(l, r, L(th));
    }
    else if (l > m)
    {
        return query(l, r, R(th));
    }
    else
    {
        return query(l, m, L(th)) + query(m + 1, r, R(th));
    }
}
int main()
{
    int t, n, i, a, b;
    char op[10];
    scanf("%d", &t);
    int ca = 0;
    while (t--)
    {
        ca++;
        printf("Case %d:\n", ca);
        scanf("%d", &n);
        for (i = 1; i <= n; i++)
        {
            scanf("%d", &p[i]);
        }
        build(1, n, 1);
        while (1)
        {
            scanf("%s", op);
            if (op[0] == 'E') break;
            scanf("%d%d", &a, &b);
            if (op[0] == 'Q')
            {
                int ans = query(a, b, 1);
                printf("%d\n", ans);
            }
            else if (op[0] == 'A')
            {
                insert(a, a, 1, b);
            }
            else
            {
                insert(a, a, 1, -b);
            }
        }

    }
    return 0;
}
/*
10
1 2 3 4 5 6 7 8 9 10
Q 1 1
Q 1 10

3
1 2 3
S 1 100
Q 1 1

*/

火碳黑 2011-05-05 12:14 发表评论

hdu 3584 Cube——三维树状数组

火碳黑 — Wed, 04 May 2011 05:54:00 GMT

Cube

Problem Description

Given an N*N*N cube A, whose elements are either 0 or 1. A[i, j, k] means the number in the i-th row , j-th column and k-th layer. Initially we have A[i, j, k] = 0 (1 <= i, j, k <= N).
We define two operations, 1: “Not” operation that we change the A[i, j, k]=!A[i, j, k]. that means we change A[i, j, k] from 0->1,or 1->0. (x1<=i<=x2,y1<=j<=y2,z1<=k<=z2).
0: “Query” operation we want to get the value of A[i, j, k].

Input

Multi-cases.
First line contains N and M, M lines follow indicating the operation below.
Each operation contains an X, the type of operation. 1: “Not” operation and 0: “Query” operation.
If X is 1, following x1, y1, z1, x2, y2, z2.
If X is 0, following x, y, z.

Output

For each query output A[x, y, z] in one line. (1<=n<=100 sum of m <=10000)

Sample Input

2 5
1 1 1 1  1 1 1
0 1 1 1
1 1 1 1  2 2 2
0 1 1 1
0 2 2 2

Sample Output

1
0
1

题意：在一个三维长方体里把0元素改成1或者把1改成0或者询问某个位置是0还是1.
分析:
    非树状数组莫属，其他数据结构都太帅了，用不着。
    先说说一维上的树状数组，什么问题都得成最简单的开始，理解后才能推广到多维或复杂的。
    把对某个方体的修改操作看做是对某个方体的操作数+1，那一个位置操作数的奇偶性决定了它的值。
树状数组1位置是管1的，2位置是管1到2的,3是管3的，4是管1到4的......所以对一个区间操作，这个区间首先按树状数组的分区规则，会被分成若干个不相交的区间，在树状数组里对应的就是若干不相交的小树。
    比如对1到3操作，会分成分别对[1,2],[3,3]两段的操作；对2到4的操作，可以分成[2,2],[3,3],[4,4]，但是对这种情况，按这种方式去修改树状数组是麻烦的，可以转化成分别对[1,4]操作，再对[1,1]操作，这样[1,1]被修改了两次，所以相当于没修改过(配合这题的奇偶性)，也可处理成对[1,4]的操作数+1，再对[1,1]的操作数-1。
    知道每段的信息保存操作次数，可以通过叠加就知道每个位置的操作数。
比如对1到3操作了一次，c[2] = 1(对应[1,2]的区间)，c[3] = 1(对应[3,3]区间)；再对1操作，则c[1] = 1（对应[1,1]区间）。则1的操作数是c[1] + c[2]。
    到此还不理解的，建议最好看看树状数组的详细结构，然后画一画就应该清楚多了，表达上的不便请原谅，这个算是比较水的，不过对树状数组的理解是有点用处的，还有就是在树状数组上对方块的切割，例如对对2到4的操作需要处理成[1,4]操作，再对[1,1]操作，将这个操作推广到3维。
    一维的是区间管区间，二维是方块管理方块，三维是方体管理方体，本质跟一维一样。

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#define maxn 110
using namespace std;
int c[maxn][maxn][maxn];
int n;
void set()
{
    int i, j, k;
    for (i = 0; i <= n; i++)
    {
        for (j = 0; j <= n; j++)
        {
            for (k = 0; k <= n; k++)
            {
                c[i][j][k] = 0;
            }
        }
    }
}
inline int lowbit(int x)
{
    return x & (-x);
}
void update(int x, int y, int z)//分块更新或操作
{
    int i, j, k;
    for (i = x; i > 0; i -= lowbit(i))
    {
        for (j = y; j > 0; j -= lowbit(j))
        {
            for (k = z; k > 0; k -= lowbit(k))
            {
                c[i][j][k]++;
            }
        }
    }
}
int sum(int x, int y, int z)//向上叠加每个父节点的操作次数
{
    int i, j, k, var = 0;
    for (i = x; i <= n; i += lowbit(i))
    {
        for (j = y; j <= n; j += lowbit(j))
        {
            for (k = z; k <= n; k += lowbit(k))
            {
                var += c[i][j][k];
            }
        }
    }
    return var;
}
int main()
{
    int m, op, x1, y1, z1, x2, y2, z2, ans;
    while (scanf("%d%d", &n, &m) - EOF)
    {
        set();
        while (m--)
        {
            scanf("%d%d%d%d", &op, &x1, &y1, &z1);
            if (op == 1)
            {
                scanf("%d%d%d", &x2, &y2, &z2);
                update(x2, y2, z2);
                update(x2, y1 - 1, z2);
                update(x1 - 1, y2, z2);
                update(x1 - 1, y1 - 1, z2);
                //--------
                update(x2, y2, z1 - 1);
                update(x2, y1 - 1, z1 - 1);
                update(x1 - 1, y2, z1 - 1);
                update(x1 - 1, y1 - 1, z1 - 1);
            }
            else
            {
                ans = sum(x1, y1, z1);
                printf("%d\n", ans % 2);
            }
        }
    }
    return 0;
}
/*
2 100
1 2 2 2 2 2 2
0 1 1 1

1
2 10
1 2 1 2 2
Q 2 2
1 2 1 2 1
Q 1 1
1 1 1 2 1
1 1 2 1 2
1 1 1 2 2
Q 1 1
1 1 1 2 1
Q 2 1
*/

火碳黑 2011-05-04 13:54 发表评论

hdu 3416 Marriage Match IV——双向最短路确定最短路的边+最大流（图边连通度）

火碳黑 — Sat, 23 Apr 2011 13:19:00 GMT

摘要: Marriage Match IV Problem Description Do not sincere non-interference。Like that show, now starvae also take part in a show, but it take place between city A and B. Starvae is in city A and girl... 阅读全文

火碳黑 2011-04-23 21:19 发表评论