【贪心】codeforces B. Heidi and Library (medium)

http://codeforces.com/contest/802/problem/B

【题意】

有一个图书馆，刚开始没有书，最多可容纳k本书；有n天，每天会有人借一本书，当天归还；如果图书馆有这个本就直接借到，否则图书馆的人会购买这本书，每本书的价格都是1；如果现在图书馆的书已达上限还需购买，必须舍弃已有的一本书，以后再有人借这本书要重新购买。

问图书馆的人最少要花多少钱购书？

数据范围变成了4000 00.

【思路】

关键是替换原则，每次都替换下一次出现最晚的，因为它占用图书馆的时间最长。

【官方题解】

Here we need to be much more ecient. There are many data structures that one can use. One idea is to
store a queue of remaining requests for each possible book (initializing it at the beginning and removing
requests from the front as they arrive) and an std::set-like structure (based on a balanced binary search
tree; it is also possible to use a priority queue based on a heap) which stores books that are currently at the
library, sorted by their next-request time.

这里我用优先级队列找出每次应该替换哪一个，用队列记录每个图书馆中的元素出现位置的情况，不断更新pq和q。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<string>
 #include<cmath>
 #include<vector>
 #include<algorithm>
 #include<queue>
 #include<map>
 using namespace std;
 typedef long long ll;
 const int maxn=4e5+;
 int a[maxn];
 int b[maxn];
 map<int,int> mp;
 struct Node
 {
     int id;
     int num;
     Node(int iid,int nnum):id(iid),num(nnum){}
 };
 //根据id排序,优先级队列先pop的是排在后面的，也就是下一次出现最晚的
 bool operator<(Node a,Node b)
 {
     return a.id<b.id;
 }
 //每个数都有一个出现位置的队列
 queue<int> q[maxn];
 priority_queue<Node> pq;
 int vis[maxn];
 int n,m;
 int main()
 {
     while(~scanf("%d%d",&n,&m))
     {
         memset(vis,,sizeof(vis));
         for(int i=;i<=n;i++)
         {
             scanf("%d",&a[i]);
         }
         int ans=;
         int cnt=;
         int i;
         for(i=;i<=n;i++)
         {
             if(cnt<m)
             {
                 if(!vis[a[i]])
                 {
                     b[++cnt]=a[i];
                     vis[a[i]]=;
                     ans++;
                 }
             }
             else
             {
                 break;
             }
         }
         if(cnt<m)
         {
             printf("%d\n",ans);
             continue;
         }
         //q[a[k]] 为a[k]从小到大出现位置的队列 ,要从i开始算，以前的都不用记
         for(int k=i;k<=n;k++)
         {
             q[a[k]].push(k);
         }
         for(int k=;k<=cnt;k++)
         {
             if(!q[b[k]].empty())
             {
                 pq.push(Node(q[b[k]].front(),b[k]));
             }
             else
             {
                 //maxn代表后面不出现
                 pq.push(Node(maxn,b[k]));
             }
             //b[1,cnt]中记录的始终是当前图书馆的书，每个元素都不同，是一个一一映射
             mp[b[k]]=k;
         }
         for(;i<=n;i++)
         {
             if(!q[a[i]].empty())
             {
                 q[a[i]].pop();
             }
             if(!vis[a[i]])
             {
                 ans++;
                 Node node=pq.top();
                 pq.pop();
                 //根据node.num映射到对应b中的位置
                 int id=mp[node.num];
                 vis[b[id]]=;
                 b[id]=a[i];
                 vis[a[i]]=;
                 //更新后的映射
                 mp[a[i]]=id;
             }
             //要放在后面，否则会影响前面的pop
             if(!q[a[i]].empty())
             {
                 pq.push(Node(q[a[i]].front(),a[i]));
             }
             else
             {
                 pq.push(Node(maxn,a[i]));
             }
         }
         printf("%d\n",ans);
     }
     return ;
 }