【CF】C. Glass Carving(二分 + 树状数组 + 优先队列 + 数组计数)

这题简直蛋疼死。。。。。

A了一下午

#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long LL;
const int maxn = 200005;
int h,w,n;
int C1[maxn],C2[maxn];
int vis1[maxn] = {0},vis2[maxn] = {0};
priority_queue<int,vector<int>,less<int> >q1;
priority_queue<int,vector<int>,less<int> >q2;
int lowbit(int x){
    return x & -x;
}
int sum(int C[],int x){
    int ret = 0;
    while(x > 0){
        ret += C[x];
        x -= lowbit(x);
    }
    return ret;
}
void add(int x,int d,int n,int C[]){
    while(x <= n){
        C[x] += d;
        x += lowbit(x);
    }
}
int main(){
    memset(C1,0,sizeof(C1));
    memset(C2,0,sizeof(C2));
    scanf("%d%d%d",&w,&h,&n);
    int max_width  = w;
    int max_height = h;
    int oh = 0, ow = 0;
    vis1[h] ++; q1.push(h);
    vis2[w] ++; q2.push(w);
    h ++;
    w ++;
    add(1,1,h,C1);  add(h,1,h,C1);
    add(1,1,w,C2);  add(w,1,w,C2);
    for(int i = 0; i < n; i++){
        char str[7];
        int d;
        scanf("%s%d",str,&d);
        d ++;
        if(str[0] == 'H'){
            int l = 1,r = d - 1;
            int e1,e2;
            int v = sum(C1,d);
            while(l < r){
                int mid = (l + r) >> 1;
                int ans = sum(C1,mid);
                if(ans >= v)
                    r = mid;
                else
                    l = mid + 1;
            }
            e1 = l;
            add(d,1,h,C1);
            v = sum(C1,d) + 1;
            l = d + 1;
            r = h;
            while(l < r){
                int mid = (l + r) >> 1;
                int ans = sum(C1,mid);
                if(ans < v)
                    l = mid + 1;
                else
                    r = mid;
            }
            e2 = l;
            int d1 = d - e1,d2 = e2 - d;
            vis1[d1 + d2]--;
            if(!vis1[d1]) q1.push(d1);
            if(!vis1[d2]) q1.push(d2);
            vis1[d1] ++;
            vis1[d2] ++;
            while(!q1.empty()){
                int t = q1.top(); q1.pop();
                if(vis1[t]){
                    max_height = t;
                    q1.push(t);
                    break;
                }
            }
        }
        else if(str[0] == 'V'){
            int l = 1,r = d - 1;
            int e1,e2;
            int v = sum(C2,d);
            while(l < r){
                int mid = (l + r) >> 1;
                int ans = sum(C2,mid);
                if(ans < v)
                    l = mid + 1;
                else
                    r = mid;
            }
            e1 = l;
            add(d,1,w,C2);
            v = sum(C2,d) + 1;
            l = d + 1;
            r = w;
            while(l < r){
                int mid = (l + r) >> 1;
                int ans = sum(C2,mid);
                if(ans < v)
                    l = mid + 1;
                else
                    r = mid;
            }
            e2 = l;
            int d1 = d - e1,d2 = e2 - d;
            vis2[d1 + d2]--;
            if(!vis2[d1]) q2.push(d1);
            if(!vis2[d2]) q2.push(d2);
            vis2[d1] ++;
            vis2[d2] ++;
            while(!q2.empty()){
                int t = q2.top(); q2.pop();
                if(vis2[t]){
                    max_width = t;
                    q2.push(t);
                    break;
                }
            }
        }
        printf("%I64d\n",(LL)max_width * max_height);
    }
    return 0;
}
时间: 2024-11-09 04:57:01

【CF】C. Glass Carving(二分 + 树状数组 + 优先队列 + 数组计数)的相关文章

CF#609E|二分+树状数组

队友发了一道cf的题过来,然后..一上午就做了一道题.. CF#609E 题目地址 复习树状数组求逆序数1 复习树状数组求逆序数2 参考博客1 参考博客2 题目大意:每次可以移动相邻的结点,求最小能够出现1~k子序列的交换次数 思路: 最小交换次数,首先想到与逆序数有关,以前做过类似的题,3 2 1,交换成 1 2 3的最小次数,就是求 3 2 1这个序列的逆序数=3 这题稍微有点变化,就是3 2 1 中间可能还存在 其它数字,比如 3 4 5 2 1,要我们求 出现 3 2 1 的最小交换次数

11525 - Permutation(二分+树状数组)

题目链接:点击打开链接 题意:从1~k的所有排列中找到第n个排列, n由公式给出. 思路:可以发现, 这个公式就是康托展开公式(康托展开百科:点击打开链接). 那么s[i]的意思就是i个数中当前数排在第几. 如此, 可以用二分+树状数组快速求解, 和一道BC题目神似. 细节参见代码: #include<cstdio> #include<cstring> #include<algorithm> #include<iostream> #include<st

Codeforces 374D Inna and Sequence 二分+树状数组

题目链接:点击打开链接 给定n个操作,m长的序列a 下面n个数 if(co>=0)则向字符串添加一个co (开始是空字符串) else 删除字符串中有a的下标的字符 直接在序列上搞,简单模拟 #include<stdio.h> #include<iostream> #include<string.h> #include<set> #include<vector> #include<map> #include<math.h&

【bzoj2527】[Poi2011]Meteors 整体二分+树状数组

题目描述 有N个成员国.现在它发现了一颗新的星球,这颗星球的轨道被分为M份(第M份和第1份相邻),第i份上有第Ai个国家的太空站. 这个星球经常会下陨石雨.BIU已经预测了接下来K场陨石雨的情况.BIU的第i个成员国希望能够收集Pi单位的陨石样本.你的任务是判断对于每个国家,它需要在第几次陨石雨之后,才能收集足够的陨石. 输入 第一行是两个数N,M. 第二行有M个数,第i个数Oi表示第i段轨道上有第Oi个国家的太空站. 第三行有N个数,第i个数Pi表示第i个国家希望收集的陨石数量. 第四行有一个

【51nod】 第K大区间2(二分+树状数组)

[51nod] 第K大区间2(二分+树状数组) 第K大区间2 ﹡    LH (命题人) 基准时间限制:1.5 秒 空间限制:131072 KB 分值: 160 定义一个长度为奇数的区间的值为其所包含的的元素的中位数.中位数_百度百科 现给出n个数,求将所有长度为奇数的区间的值排序后,第K大的值为多少. 样例解释: [l,r]表示区间的值 [1]:3 [2]:1 [3]:2 [4]:4 [1,3]:2 [2,4]:2 第三大是2 Input 第一行两个数n和k(1<=n<=100000,k&l

【BZOJ3110】【整体二分+树状数组区间修改/线段树】K大数查询

Description 有N个位置,M个操作.操作有两种,每次操作如果是1 a b c的形式表示在第a个位置到第b个位置,每个位置加入一个数c 如果是2 a b c形式,表示询问从第a个位置到第b个位置,第C大的数是多少. Input 第一行N,M 接下来M行,每行形如1 a b c或2 a b c Output 输出每个询问的结果 Sample Input 2 5 1 1 2 1 1 1 2 2 2 1 1 2 2 1 1 1 2 1 2 3 Sample Output 1 2 1 HINT

【BZOJ-2527】Meteors 整体二分 + 树状数组

2527: [Poi2011]Meteors Time Limit: 60 Sec  Memory Limit: 128 MBSubmit: 831  Solved: 306[Submit][Status][Discuss] Description Byteotian Interstellar Union (BIU) has recently discovered a new planet in a nearby galaxy. The planet is unsuitable for colo

【bzoj3110】[Zjoi2013]K大数查询 整体二分+树状数组区间修改

题目描述 有N个位置,M个操作.操作有两种,每次操作如果是1 a b c的形式表示在第a个位置到第b个位置,每个位置加入一个数c.如果是2 a b c形式,表示询问从第a个位置到第b个位置,第C大的数是多少. 输入 第一行N,M接下来M行,每行形如1 a b c或2 a b c 输出 输出每个询问的结果 样例输入 2 5 1 1 2 1 1 1 2 2 2 1 1 2 2 1 1 1 2 1 2 3 样例输出 1 2 1 题解 整体二分+树状数组区间修改 当年naive的树套树题解 前两天由于要

Codeforces Round #470 (Div 2) B 数学 C 二分+树状数组 D 字典树

Codeforces Round #470 B. Primal Sport 数学题,对 x2 和 x1 分解质因子即可. #include<bits/stdc++.h> using namespace std; #pragma comment(linker, "/STACK:102400000,102400000") #define rep(i,a,b) for (int i=a; i<=b; ++i) #define per(i,b,a) for (int i=b;

cf 602 D 二分+树状数组

This is the harder version of the problem. In this version, 1≤n,m≤2⋅1051≤n,m≤2⋅105. You can hack this problem if you locked it. But you can hack the previous problem only if you locked both problems. You are given a sequence of integers a=[a1,a2,…,an