Compass Card Sales（模拟）

Compass Card Sales

时间限制: 3 Sec  内存限制: 128 MB
提交: 35  解决: 13
[提交] [状态] [讨论版] [命题人:admin]

题目描述

Katla has recently stopped playing the collectible card game Compass. As you might remember, Compass is a game where each card has a red, a green and a blue angle, each one between 0 and 359, as well as an ID. Since she has stopped playing, Katla has decided to sell all her cards. However, she wants to keep her deck as unique as possible while selling off the cards.
Can you help her figure out the order in which she should sell the cards?
To decide how unique a card is in the deck, she proceeds as follows. For each of the three colors she finds the closest other card in both directions, and then computes the angle between these two other cards. 
For instance if she has three cards with red angles 42,90 and 110, then the uniqueness values of their red angles are 340, 68, and 312, respectively. If two cards A and B have the same angle, B is considered the closest to A in both directions so that the uniqueness value of A (and B) for that color is 0.
By summing the uniqueness values over the three colours, Katla finds how unique each card is. When selling a card, Katla sells the currently least unique card (smallest uniqueness value). 
If two cards have the same uniqueness value, she will sell the one with the higher ID first. After each card is sold, the uniqueness values of the remaining cards are updated before selling the next card.

输入

The first line of input contains an integer n, the number of cards (1 ≤ n ≤ 105 ). Then follows n lines. Each of these n lines contains 4 integers r, g, b, id (0 ≤ r, g, b < 360, 0 ≤ id < 231 ),giving the red, green and blue angles as well as the ID of a card. No two cards have the same ID

输出

Output n lines, containing the IDs of the cards in the order they are to be sold, from first (least unique) to last (most unique).

样例输入

3
42 1 1 1
90 1 1 2
110 1 1 3

样例输出

2
3
1
思路：模拟！！！

 #include<bits/stdc++.h>
 using namespace std;
 const int maxn=1e5+;
 struct node
 {
     int score,id;
     node() {};
     node(int score,int id):score(score),id(id) {};
     bool operator<(const node &rhs)const
     {
         if(score!=rhs.score) return score<rhs.score;
         return id>rhs.id;
     }

 };
 map<int,int> ma;
 set<node> ans;
 set<int> res[][];
 vector<int> angle[];
 int tmp[maxn],ele[maxn][],vis[][];
 int l[][],r[][],sc[][];
 int cal_ang(int c,int x)
 {
     if(vis[c][x]>=) return ;
     int ang=,ll=l[c][x],rr=r[c][x];
     ang+=ll<x?x-ll:+x-ll;
     ang+=rr>x?rr-x:+rr-x;
     return ang;
 }
 int cal(int x)
 {
     int ans=;
     for(int i=;i<;i++) ans+=sc[i][ele[x][i]];
     return ans;
 }
 void update(int x)
 {
     for(int i=;i<;i++)
     {
         int ang=ele[x][i];
         --vis[i][ang];
         if(vis[i][ang]==)
         {
             int ll=l[i][ang],rr=r[i][ang];
             l[i][rr]=ll,r[i][ll]=rr;
             int tp=cal_ang(i,ll);
             if(sc[i][ll]!=tp)
             {
                 sc[i][ll]=tp;
                 for(auto v:res[i][ll])
                 {
                     ans.erase(ans.find(node(tmp[v],ele[v][])));
                     tmp[v]=cal(v);
                     ans.insert(node(tmp[v],ele[v][]));
                 }
             }
             tp=cal_ang(i,rr);
             if(sc[i][rr]!=tp)
             {
                 sc[i][rr]=tp;
                 for(auto v:res[i][rr])
                 {
                     ans.erase(ans.find(node(tmp[v],ele[v][])));
                     tmp[v]=cal(v);
                     ans.insert(node(tmp[v],ele[v][]));
                 }
             }
         }
         if(vis[i][ang]==)
         {
             for(auto v:res[i][ang])
             {
                 sc[i][ang]=cal_ang(i,ang);
                 if(tmp[v]!=cal(v))
                 {
                     ans.erase(ans.find(node(tmp[v],ele[v][])));
                     ans.insert(node(tmp[v]=cal(v),ele[v][]));
                 }
             }
         }
     }
 }
 int main()
 {
     int n,cnt;
     scanf("%d",&n);
     for(int i=;i<=n;i++)
     {
         for(int j=;j<;j++) scanf("%d",&ele[i][j]);
         for(int j=;j<;j++)
         {
             if(!vis[j][ele[i][j]]) angle[j].push_back(ele[i][j]);
             res[j][ele[i][j]].insert(i);
             vis[j][ele[i][j]]++;
         }
         ma[ele[i][]]=i;
     }
     for(int i=;i<;i++)
     {
         sort(angle[i].begin(),angle[i].end());
         for(int j=;j+<angle[i].size();j++)
         {
             l[i][angle[i][j+]]=angle[i][j];
             r[i][angle[i][j]]=angle[i][j+];
         }
         l[i][angle[i][]]=angle[i][angle[i].size()-];
         r[i][angle[i][angle[i].size()-]]=angle[i][];
         for(int j=;j<angle[i].size();j++)
         {
             sc[i][angle[i][j]]=cal_ang(i,angle[i][j]);
         }
     }
     for(int i=;i<=n;i++)
     {
         tmp[i]=cal(i);
         ans.insert(node(tmp[i],ele[i][]));
     }
     while(ans.size())
     {
         auto it=ans.begin();
         cnt=ma[it->id];
         printf("%d\n",ele[cnt][]);
         ans.erase(it);
         for(int i=;i<;i++) res[i][ele[cnt][i]].erase(cnt);
         update(cnt);
     }
     return ;
 }