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 ?rst 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).
1 #include<bits/stdc++.h>
2 using namespace std;
3 const int maxn=1e5+100;
4 struct node
5 {
6 int score,id;
7 node() {};
8 node(int score,int id):score(score),id(id) {};
9 bool operator<(const node &rhs)const
10 {
11 if(score!=rhs.score) return score<rhs.score;
12 return id>rhs.id;
13 }
14
15 };
16 map<int,int> ma;
17 set<node> ans;
18 set<int> res[3][400];
19 vector<int> angle[3];
20 int tmp[maxn],ele[maxn][4],vis[3][400];
21 int l[3][400],r[3][400],sc[3][400];
22 int cal_ang(int c,int x)
23 {
24 if(vis[c][x]>=2) return 0;
25 int ang=0,ll=l[c][x],rr=r[c][x];
26 ang+=ll<x?x-ll:360+x-ll;
27 ang+=rr>x?rr-x:360+rr-x;
28 return ang;
29 }
30 int cal(int x)
31 {
32 int ans=0;
33 for(int i=0;i<3;i++) ans+=sc[i][ele[x][i]];
34 return ans;
35 }
36 void update(int x)
37 {
38 for(int i=0;i<3;i++)
39 {
40 int ang=ele[x][i];
41 --vis[i][ang];
42 if(vis[i][ang]==0)
43 {
44 int ll=l[i][ang],rr=r[i][ang];
45 l[i][rr]=ll,r[i][ll]=rr;
46 int tp=cal_ang(i,ll);
47 if(sc[i][ll]!=tp)
48 {
49 sc[i][ll]=tp;
50 for(auto v:res[i][ll])
51 {
52 ans.erase(ans.find(node(tmp[v],ele[v][3])));
53 tmp[v]=cal(v);
54 ans.insert(node(tmp[v],ele[v][3]));
55 }
56 }
57 tp=cal_ang(i,rr);
58 if(sc[i][rr]!=tp)
59 {
60 sc[i][rr]=tp;
61 for(auto v:res[i][rr])
62 {
63 ans.erase(ans.find(node(tmp[v],ele[v][3])));
64 tmp[v]=cal(v);
65 ans.insert(node(tmp[v],ele[v][3]));
66 }
67 }
68 }
69 if(vis[i][ang]==1)
70 {
71 for(auto v:res[i][ang])
72 {
73 sc[i][ang]=cal_ang(i,ang);
74 if(tmp[v]!=cal(v))
75 {
76 ans.erase(ans.find(node(tmp[v],ele[v][3])));
77 ans.insert(node(tmp[v]=cal(v),ele[v][3]));
78 }
79 }
80 }
81 }
82 }
83 int main()
84 {
85 int n,cnt;
86 scanf("%d",&n);
87 for(int i=1;i<=n;i++)
88 {
89 for(int j=0;j<4;j++) scanf("%d",&ele[i][j]);
90 for(int j=0;j<3;j++)
91 {
92 if(!vis[j][ele[i][j]]) angle[j].push_back(ele[i][j]);
93 res[j][ele[i][j]].insert(i);
94 vis[j][ele[i][j]]++;
95 }
96 ma[ele[i][3]]=i;
97 }
98 for(int i=0;i<3;i++)
99 {
100 sort(angle[i].begin(),angle[i].end());
101 for(int j=0;j+1<angle[i].size();j++)
102 {
103 l[i][angle[i][j+1]]=angle[i][j];
104 r[i][angle[i][j]]=angle[i][j+1];
105 }
106 l[i][angle[i][0]]=angle[i][angle[i].size()-1];
107 r[i][angle[i][angle[i].size()-1]]=angle[i][0];
108 for(int j=0;j<angle[i].size();j++)
109 {
110 sc[i][angle[i][j]]=cal_ang(i,angle[i][j]);
111 }
112 }
113 for(int i=1;i<=n;i++)
114 {
115 tmp[i]=cal(i);
116 ans.insert(node(tmp[i],ele[i][3]));
117 }
118 while(ans.size())
119 {
120 auto it=ans.begin();
121 cnt=ma[it->id];
122 printf("%d\n",ele[cnt][3]);
123 ans.erase(it);
124 for(int i=0;i<3;i++) res[i][ele[cnt][i]].erase(cnt);
125 update(cnt);
126 }
127 return 0;
128 }
View Code
