BZOJ 1826: [JSOI2010]缓存交换

题目：http://www.lydsy.com/JudgeOnline/problem.php?id=1826 

分析：

  贪心+堆或者平衡树（以下统一称为树）。越在后面，切换他是最好的。。。

  1.当已经在树上的时候，换掉之前已在树上的该主存块，换成当前主存块的下一个出现的位置。
  2.当前可用的cache足够的时候，直接插入到树中。
  3.每次需要切换cache的时候，都切掉距离当前位置最远的那个主存块，然后将当前的cache的下一次出现的位置更新到树上。

  先离散化，然后使用池子法从后往前扫，这样就可以统计每个主存块下一次出现的位置，插入的时候，直接插入的是当前主存块的下一个他出现的位置

329452

yejinru

1826

Accepted

7048 kb

404 ms

C++/Edit

4397 B

2012-12-16 10:32:33

 

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <map>

using namespace std;

const int X = 100005;

#define debug puts("here");

int tot;

struct node{
    int l,r,s,val;
    void init(int _val){
        l = r = 0;
        s = 1;
        val = _val;
    }
}sbt[X];

void left_rotate(int &t){
    int k = sbt[t].r;
    sbt[t].r = sbt[k].l;
    sbt[k].l = t;
    sbt[k].s = sbt[t].s;
    sbt[t].s = sbt[sbt[t].l].s+sbt[sbt[t].r].s+1;
    t = k;
}

void right_rotate(int &t){
    int k = sbt[t].l;
    sbt[t].l = sbt[k].r;
    sbt[k].r = t;
    sbt[k].s = sbt[t].s;
    sbt[t].s = sbt[sbt[t].l].s+sbt[sbt[t].r].s+1;
    t = k;
}

void maintain(int &t,bool ok){
    if(!ok){
        if(sbt[sbt[sbt[t].l].l].s>sbt[sbt[t].r].s)
            right_rotate(t);
        else if(sbt[sbt[sbt[t].l].r].s>sbt[sbt[t].l].s){
            left_rotate(sbt[t].l);
            right_rotate(t);
        }
        else return;
    }
    else{
        if(sbt[sbt[sbt[t].r].r].s>sbt[sbt[t].l].s)
            left_rotate(t);
        else if(sbt[sbt[sbt[t].r].l].s>sbt[sbt[t].l].s){
            right_rotate(sbt[t].r);
            left_rotate(t);
        }
        else return;
    }
    maintain(sbt[t].l,0);
    maintain(sbt[t].r,1);
    maintain(t,0);
    maintain(t,1);
}

void insert(int &t,int val){
    if(!t){
        t = ++tot;
        sbt[t].init(val);
        return;
    }
    sbt[t].s++;
    if(val<sbt[t].val)
        insert(sbt[t].l,val);
    else
        insert(sbt[t].r,val);
    maintain(t,val>=sbt[t].val);
}

int del(int &t,int val){
    if(!t)  return 0;
    sbt[t].s--;
    if(val==sbt[t].val||(val<sbt[t].val&&!sbt[t].l)||(val>sbt[t].val&&!sbt[t].r)){
        if(sbt[t].l&&sbt[t].r){
            int pos = del(sbt[t].l,val+1);
            sbt[t].val = sbt[pos].val;
            return pos;
        }
        else{
            int pos = t;
            t = sbt[t].l+sbt[t].r;
            return pos;
        }
    }
    return del(val<sbt[t].val?sbt[t].l:sbt[t].r,val);
}

int find_max(int t){
	while(sbt[t].r)
		t = sbt[t].r;
	return sbt[t].val;
}

int find(int t,int val){
	if(!t)
		return 0;
	if(sbt[t].val==val)
		return true;
	if(sbt[t].val>val)
		return find(sbt[t].l,val);
	return find(sbt[t].r,val);
}

int a[X],n;
map<int,int> ma;
int po[X],tol,Next[X];

int main(){
	int n,m;
	int inf = 100000000;
	while(cin>>n>>m){
		tot = 0;
		ma.clear();

		int cnt = 0;
		int x,y;
		int root = 0;
		tol = n;

		for(int i=1;i<=n;i++){
			scanf("%d",&a[i]);
			if(ma[a[i]]==0)	//使用map离散化
				ma[a[i]] = ++cnt;
			po[i] = ++tol;
		}

		for(int i=n;i;i--){
			x = ma[a[i]];
			Next[i] = po[x];	//池子法，从后往前扫
			po[x] = i;
		}

		cnt = 0;
		int ans = 0;
		for(int i=1;i<=n;i++){
			if(find(root,i)){	//已存在树中，直接删除后更新
				del(root,i);
				insert(root,Next[i]);
			}
			else{
				ans ++;
				if(cnt==m)		//cache数不够了，需要删除
					del(root,find_max(root));
				else			//够用的话，但是需要插入，cache已使用的数目加一
					cnt ++;
				insert(root,Next[i]);//插入当前主存块的下一个位置
			}
		}
			
		cout<<ans<<endl;
	}
	return 0;
}