C++博客-Yuan-随笔分类-数据结构

zoj 3512 左偏树思维中位数

_Yuan — Wed, 03 Aug 2011 09:35:00 GMT

/*
    给出n<=50000个数的序列a[1]..a[n]，求一个非递减的序列b[1]..b[n]
    使得∑|a[i]-b[i]|最小

    如果只是求一个点x，使得∑|a[i]-b[i]|最小，显然x = a[(n+1)/2]（中位数）---------------OMG
    但现在可以有多个点，如果a[]是递增的，那么令b[i] = a[i]即可了
    现在a[]是无规律的

    左偏树的论文题，看了论文还不完全懂
    做法：
    最后答案的形式是将1..n分成m个连续的区间，每个区间的b[i]是一样的，且不同区间是非递减的
    在检查n时，假设1..n-1已经分成了m个区间了
    现在先把a[n]单独一个区间，显然b[n]=a[n]会是1..n的最优值（因为前面1..n-1是最优的，而第n个
    对答案的贡献为0），但是不一定满足b[n-1]<=b[n]，算法为：
    若b[n-1] <= b[n]，则b[n]就是a[n]了
    否则，需要合并目前最尾的两个区间，直至这两个区间有b[k] <= b[k+1]              -------OMG
    而b[k]显然是每一个区间的中位数了
    合并两个区间求中位数，可用左偏树做最大堆分别维护每个区间的前(ni+1)/2小的数，-------OMG
    则堆顶为每个    区间的中位数了，合并时，将右边区间的那些数合并到左边即可
    O(nlogn)
    左偏树真是神奇漂亮的东西!!

    至于为什么是合并最后两个区间，将第n个数和它之前那个区间的一部分数合起来不行吗？
    假设a[kn-1]是求出来的一个区间，则肯定有a[n-1]     同理，a[n]     即a[k..k'], a[k'..n]，这样也不行，由假设知，肯定a[k'..n]的中位数     （大于的话，a[k'+1..n-1]就不会合并到那里去啦~~）
*/
#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cstring>
#include<cmath>
#include<string>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<set>
#include<list>
#include<numeric>
#include<cassert>
#include<sstream>
#include<ctime>
#include<bitset>
#include<functional>

using namespace std;

const int MAXN = 100010;

struct Node
{
    int key, dist, lc, rc;
};

Node nodes[MAXN];
int alloc;

void initNode()
{
    nodes[0].dist = -1;//0作为NULL节点
    alloc = 1;
}

int newNode(int x)
{
    nodes[alloc].key = x;
    nodes[alloc].dist = 0;
    nodes[alloc].lc = nodes[alloc].rc = 0;
    return alloc++;
}

int merge(int A, int B)
{
    if (A != 0 && B != 0) {
        if (nodes[A].key < nodes[B].key) {//
            swap(A, B);
        }
        nodes[A].rc = merge(nodes[A].rc, B);
        int &lc = nodes[A].lc;
        int &rc = nodes[A].rc;
        if (nodes[lc].dist < nodes[rc].dist) {
            swap(lc, rc);
        }
        nodes[A].dist = nodes[rc].dist + 1;
    } else {
        A = A == 0 ? B : A;
    }
    return A;
}

int pop(int A)
{
    int t = merge(nodes[A].lc, nodes[A].rc);
    nodes[A].lc = nodes[A].rc = 0;//隔离出A后记得将A的儿子也清空
    return t;
}

int a[MAXN];

int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
#endif

    for (int n;scanf("%d", &n), n; ) {
        initNode();
        stack<pair<int,int> > S;
        for (int i = 1; i <= n; i++) {
            scanf("%d", &a[i]);
            pair<int, int> np(newNode(a[i]), 1);//node, len
            while (!S.empty() && nodes[S.top().first].key > nodes[np.first].key) {
                pair<int,int> top = S.top();
                S.pop();
                int n1 = top.second, n2 = np.second;
                np.first = merge(top.first, np.first);
                np.second = n1+n2;
                if ((n1+1)/2 + (n2+1)/2 > (n1+n2+1)/2) {
                    np.first = pop(np.first);
                }
            }
            S.push(np);
        }
        long long ans = 0;
        int id = n;
        while (!S.empty()) {
            int b = nodes[S.top().first].key, num = S.top().second;
            S.pop();
            while (num -- > 0) {
                ans += abs(a[id--] - b);
            }
        }
        printf("%lld\n", ans);
    }
    return 0;
}

_Yuan 2011-08-03 17:35 发表评论

CF70C 用map存分子分母扫描x微调y

_Yuan — Thu, 05 May 2011 02:56:00 GMT

/*
    给出mx,my,w(1<= mx,my<=10^5, 1<= w <= 10^7)
    求minimal{x*y}，1<=x<=mx,1<=y<=my
    使得[1x][1y]这个区域内满足 a*b = rev(a)*rev(b)的点的个数>=w

    我能想到的是
    先预处理出所有rev(a)，从左到右扫描x，加进新的点（即所有满足x*b = rev(x)*rev(b),1<=b<=my）
    然后二分y，找出满足w的最小的y

    也想到将a*b = rev(a)*rev(b)变形为 a/rev(a) = rev(b)/b，但想不下去了，
    不知怎么快速获取所有满足x*b = rev(x)*rev(b)（主要是因为a/rev(a)是浮点数，不知怎么用下标存）

    看了别人的，用map就可以了   →.→
    看了watashi的，是存分子分母（先用gcd约分一下）              ------------------------------OMG

    总体算法就是
    从左到右扫描x，加入所有满足x*b = rev(x)*rev(b)的点
    而满足这个条件的就是满足x/rev(x) = rev(b)/b的，由于之前已经存了mpy[(b,rev(b))]
    满足上面式子点的个数就是mpy[(rev(x),x)]了
    比较神奇的是，他在枚举x时，要获取满足>=w的y，不是二分y的，是通过微调的    -----------OMG
    即若当前的x*y范围内的点>=w,
    y--;
    iw -= mpx[(rev(y),y)];
    mpy[(y,rev(y))]--;
    若

    第一次看到这样微调的，神奇丫~~~~~~~~~
    y从my出发
    一直保持iw>=w，微调至最接近w但>=w
    整个过程，y肯定是递减的~~~
*/
#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cmath>
#include<string>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<set>
#include<list>
#include<numeric>
#include<cassert>
#include<ctime>
#include<bitset>

using namespace std;

const long long INF = 12345678987654321LL;
const int MAXN = 100100;

pair<int,int> r[MAXN];//(i, rev(i))

inline int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

inline int rev(int x) {
    int r = 0;
    while(x > 0) {
        r = r*10 + x % 10;
        x /= 10;
    }
    return r;
}

pair<int,int> inv(pair<int,int> &p) {
    return make_pair(p.second, p.first);
}

void init() {
    for (int i = 1 ; i <= 100000; i++) {
        int t = rev(i);
        int g = gcd(i,t);
        r[i] = make_pair(i/g, t/g);
    }
}

int main()
{
#ifndef ONLINE_JUDGE
    freopen("in","r",stdin);
#endif

    init();
    for (int mx,my,w; ~scanf("%d%d%d", &mx, &my, &w);) {

        map<pair<int,int>, int> mpx, mpy;
        for (int y = 1; y <= my; y++) {
            mpy[r[y]]++;
        }

        long long X = -1, Y = -1;
        long long iw = 0;
        for (long long x = 1, y = my; x <= mx; x++) {//y是从my出发的
            iw += mpy[inv(r[x])];
            mpx[r[x]]++;
            while(iw >= w) {
                iw -= mpx[inv(r[y])];
                mpy[r[y]]--;
                y--;
                if(iw < w) {
                    y++;
                    mpy[r[y]]++;
                    iw += mpx[inv(r[y])];
                    break;
                }
            }
            //一直保持着iw>=w，然后引进新的x时，尝试y--
            //整个过程，y肯定是递减的~~~
            if(iw>=w && (X == -1 || x*y < X*Y) ) {
                X = x;
                Y = y;
            }
        }
        if (X == -1) {
            puts("-1");
        } else {
            printf("%I64d %I64d\n", X, Y);
        }
    }
    return 0;
}

_Yuan 2011-05-05 10:56 发表评论

CF79C

_Yuan — Wed, 04 May 2011 17:10:00 GMT

摘要: /**//* 一个文本串len<=10^5 n<=10个boring串，len<=10 求最长的连续子串，不包含任何一个boring串我之前的做法比较慢 &nbs... 阅读全文

_Yuan 2011-05-05 01:10 发表评论

CF74D 树状数组用map存，神奇丫存分割点.cpp

_Yuan — Mon, 02 May 2011 07:13:00 GMT

摘要: /**//* n<=10^9个位置, q<=10^5个操作操作有三种 (1)插入选择靠右的最长空白的一段，然后插入到中间（若长度为偶数，是指靠右的那个中间位置） &nb... 阅读全文

_Yuan 2011-05-02 15:13 发表评论

jsoi 2010 Word Query电子字典

_Yuan — Fri, 25 Mar 2011 11:45:00 GMT

摘要: /**//* N<=10000个文本串，M<=10000个要查询的串对每个要查询的串，有多少个文本串与该串的编辑距离<=1 若编辑距离为0，输出-1 建立Trie树，对于要查询的串，状态(root... 阅读全文

_Yuan 2011-03-25 19:45 发表评论

Poj 2482 线段树事件点中和

_Yuan — Mon, 19 Apr 2010 14:26:00 GMT

/*
    很直观的想法，用两根线扫描，得到条状区域
    快速求固定高为h的区域比较难，但是求连续的一段却是比较容易
    即[1,x] 这么多个的连加和
    所以建立这样的值： (y,v) (y+h+1,-v)  这样就能中和掉了
    然后用完全二叉树 sum[p]表示根为mid的这一子树的和，maxSum[p]表示以mid根子树中连续的和
*/
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

const int MAXN=10010;

int n,w,h;
int tot;
unsigned int y[MAXN*2];                                    //注意要用unsigned int                       2^31+h会超int
int sum[MAXN*8],maxSum[MAXN*8];

struct Point{
    unsigned int x,y;
    int v;
    bool operator<(const Point &p)const{
        return x<p.x;
    }
}points[MAXN*2];

/*
    向下找到x所在节点，这一路上都要更新
    注意递归写法，不是x==mid 就return
*/
void insert(int p,int left,int right,int x,int c){
    int mid=(left+right)>>1;
    if(x!=mid){
        if(x<mid)insert(2*p,left,mid-1,x,c);
        else insert(2*p+1,mid+1,right,x,c);
    }
    sum[p]+=c;
    maxSum[p]=maxSum[2*p];
    maxSum[p]=max(maxSum[p],sum[p]-sum[2*p+1]);
    maxSum[p]=max(maxSum[p],sum[p]-sum[2*p+1]+maxSum[2*p+1]);
}
int find(unsigned int x){
    int low=1,high=tot;
    while(high>=low){
        int mid=(high+low)>>1;
        if(y[mid]==x)return mid;
        if(y[mid]>x)high=mid-1;
        else low=mid+1;
    }
}

int main(){
    while(~scanf("%d%d%d",&n,&w,&h)){
        w--;h--;                                  //不含边界
        tot=0;
        for(int i=1;i<=n;i++){
            scanf("%u%u%d",&points[i].x,&points[i].y,&points[i].v);
            y[++tot]=points[i].y;y[++tot]=points[i].y+h+1;
            points[n+i].x=points[i].x,points[n+i].y=points[i].y+h+1,points[n+i].v=-points[i].v;
        }
        sort(y+1,y+1+tot);
        tot=unique(y+1,y+1+tot)-(y+1);
        n=n*2;
        sort(points+1,points+1+n);
        memset(sum,0,sizeof(sum));
        memset(maxSum,0,sizeof(maxSum));
        int ans=0,s=1,t=1;
        while(t<=n){                                //注意不要按x坐标扫，会超时
            int x=points[t].x;
            while(s<=n&&x-points[s].x>w)
                insert(1,1,tot,find(points[s].y),-points[s].v),s++;
            while(t<=n&&points[t].x==x)                //把同一列的加进去
                insert(1,1,tot,find(points[t].y),points[t].v),t++;
            ans=max(ans,maxSum[1]);                    //求连续一段的和
        }
        printf("%d\n",ans);
    }
    return 0;
}
/*
3 2 2
0 0 2
2 2 3
4 4 6
*/

_Yuan 2010-04-19 22:26 发表评论

C++博客-Yuan-随笔分类-数据结构

zoj 3512 左偏树 思维 中位数

CF70C 用map存分子分母 扫描x微调y