bzoj 1862/1056 [HAOI2008]排名系统

原题链接：http://www.lydsy.com/JudgeOnline/problem.php?id=1862

很恶心的 一道题，我也不晓得自己是第几次写这题了%>_<%。

写了两种方法，平衡树+哈希和平衡树+map。哈希函数是抄别人的。比较了一下还是哈希快一些。

题意很简单，就不说了。

具体思路是，平衡树维护排名，map建立姓名和分数一一对应的关系。

求rank时题意默认是越先提交得分排名越靠前(相同得分的条件下)。

具体如下：

平衡树+map

 

  1 #include<algorithm>
  2 #include<iostream>
  3 #include<cstdlib>
  4 #include<cstring>
  5 #include<cstdio>
  6 #include<string>
  7 #include<map>
  8 using std::min;
  9 using std::map;
 10 using std::string;
 11 const int Max_N = 260000;
 12 char src[Max_N][12];
 13 typedef char State[100];
 14 struct Node{
 15     int v, s, t, id;
 16     Node *ch[2];
 17     inline void set(int _v = 0, int _s = 0, int _t = 0, int _id = 0, Node *p = NULL){
 18         ch[0] = ch[1] = p;
 19         v = _v, s = _s, t = _t, id = _id;
 20     }
 21     inline void push_up(){
 22         s = ch[0]->s + ch[1]->s + 1;
 23     }
 24     inline int cmp(int _v, int _t) const{
 25         if (v == _v){
 26             return t == _t ? -1 : _t > t;
 27         }
 28         return v > _v;
 29     }
 30 };
 31 struct SizeBalanceTree{
 32     Node stack[Max_N];
 33     Node *root, *null, *tail;
 34     Node *store[Max_N];
 35     int top;
 36     void init(){
 37         tail = &stack[0];
 38         null = tail++;
 39         null->set();
 40         root = null;
 41         top = 0;
 42     }
 43     inline Node *newNode(int v, int t, int id){
 44         Node *p = null;
 45         if (top) p = store[--top];
 46         else p = tail++;
 47         p->set(v, 1, t, id, null);
 48         return p;
 49     }
 50     inline void rotate(Node* &x, int d){
 51         Node *k = x->ch[!d];
 52         x->ch[!d] = k->ch[d];
 53         k->ch[d] = x;
 54         k->s = x->s;
 55         x->push_up();
 56         x = k;
 57     }
 58     inline void Maintain(Node* &x, int d){
 59         if (x->ch[d] == null) return;
 60         if (x->ch[d]->ch[d]->s > x->ch[!d]->s){
 61             rotate(x, !d);
 62         } else if (x->ch[d]->ch[!d]->s > x->ch[!d]->s){
 63             rotate(x->ch[d], d), rotate(x, !d);
 64         } else {
 65             return;
 66         }
 67         Maintain(x, 0), Maintain(x, 1);
 68     }
 69     inline void insert(Node* &x, int v, int t, int id){
 70         if (x == null){
 71             x = newNode(v, t, id);
 72             return;
 73         } else {
 74             x->s++;
 75             int d = x->cmp(v, t);
 76             insert(x->ch[d], v, t, id);
 77             x->push_up();
 78             Maintain(x, d);
 79         }
 80     }
 81     inline void del(Node*  &x, int v, int t){
 82         if (x == null) return;
 83         x->s--;
 84         int d = x->cmp(v, t);
 85         if (-1 == d){
 86             if (!x->ch[0]->s || !x->ch[1]->s){
 87                 store[top++] = x;
 88                 x = x->ch[0]->s ? x->ch[0] : x->ch[1];
 89             } else {
 90                 Node *ret = x->ch[1];
 91                 for (; ret->ch[0] != null; ret = ret->ch[0]);
 92                 x->v = ret->v, x->t = ret->t, x->id = ret->id;
 93                 del(x->ch[1], ret->v, ret->t);
 94             }
 95         } else {
 96             del(x->ch[d], v, t);
 97         }
 98         if (x != null) x->push_up();
 99     }
100     inline int find(Node *x, int v, int t){
101         int k = 0, cur = 0;
102         for (; x != null;){
103             int d = x->cmp(v, t);
104             k = x->ch[0]->s;
105             if (-1 == d) break;
106             else if (!d) x = x->ch[0];
107             else cur += k + 1, x = x->ch[1];
108         }
109         return cur + k + 1;
110     }
111     inline int rank(Node *x, int k){
112         for (; x != null;){
113             int t = x->ch[0]->s;
114             if (k == t + 1) break;
115             else if (k <= t) x = x->ch[0];
116             else k -= t + 1, x = x->ch[1];
117         }
118         return x->id;
119     }
120     inline void insert(int v, int t, int id){
121         insert(root, v, t, id);
122     }
123     inline void del(int v, int t){
124         del(root, v, t);
125     }
126     inline int find(int v, int t){
127         return find(root, v, t);
128     }
129     inline int rank(int k){
130         return rank(root, k);
131     }
132 }sbt;
133 struct node{ 
134     int v, t, id; 
135     node(){};
136     node(int _v, int _t, int _id) :v(_v), t(_t), id(_id){}
137 };
138 map<string, node > stri;
139 void gogo(char *s, int v, int t, int &tot){
140     string str(s);
141     if (stri.count(str) != 0){
142         sbt.del(stri[str].v, stri[str].t);
143         stri[str].v = v, stri[str].t = t;
144         sbt.insert(v, t, stri[str].id);
145         return;
146     }
147     strcpy(src[++tot], s);
148     sbt.insert(v, t, tot);
149     node ret(v, t, tot);
150     stri[str] = ret;
151 }
152 int main(){
153 #ifdef LOCAL
154     freopen("in.txt", "r", stdin);
155     freopen("out.txt", "w+", stdout);
156 #endif
157     sbt.init();
158     State s1, buf;
159     int n, v, tot = 0;
160     scanf("%d\n", &n);
161     for (int i = 1; i <= n; i++){
162         gets(buf);
163         if (buf[0] == '+'){
164             sscanf(&buf[1], "%s %d", s1, &v);
165             gogo(s1, v, i, tot);
166         } else if (buf[0] == '?' && isalpha(buf[1])){
167             sscanf(&buf[1], "%s", s1);
168             printf("%d\n", sbt.find(stri[s1].v, stri[s1].t));
169         } else {
170             int ed;
171             sscanf(&buf[1], "%d", &v);
172             ed = min(v + 9, tot);
173             for (int j = v; j <= ed; j++) {
174                 printf("%s%c", src[sbt.rank(j)], j != ed ? ' ' : '\n');
175             }
176         }
177     }    
178     return 0;
179 }
View Code

 

平衡树+哈希

  1 #include<algorithm>
  2 #include<iostream>
  3 #include<cstdlib>
  4 #include<cstring>
  5 #include<cstdio>
  6 #include<string>
  7 #include<map>
  8 using std::min;
  9 using std::pair;
 10 using std::string;
 11 typedef char State[100];
 12 typedef unsigned long long ull;
 13 const int Max_N = 260000;
 14 struct Node{
 15     int v, s, t, id;
 16     Node *ch[2];
 17     inline void
 18     set(int _v = 0, int _s = 0, int _t = 0, int _id = 0, Node *p = NULL){
 19         ch[0] = ch[1] = p;
 20         v = _v, s = _s, t = _t, id = _id;
 21     }
 22     inline void push_up(){
 23         s = ch[0]->s + ch[1]->s + 1;
 24     }
 25     inline int cmp(int _v, int _t) const{
 26         if (v == _v){
 27             return t == _t ? -1 : _t > t;
 28         }
 29         return v > _v;
 30     }
 31 };
 32 struct SizeBalanceTree{
 33     Node stack[Max_N];
 34     Node *root, *null, *tail;
 35     Node *store[Max_N];
 36     int top;
 37     void init(){
 38         tail = &stack[0];
 39         null = tail++;
 40         null->set();
 41         root = null;
 42         top = 0;
 43     }
 44     inline Node *newNode(int v, int t, int id){
 45         Node *p = null;
 46         if (top) p = store[--top];
 47         else p = tail++;
 48         p->set(v, 1, t, id, null);
 49         return p;
 50     }
 51     inline void rotate(Node* &x, int d){
 52         Node *k = x->ch[!d];
 53         x->ch[!d] = k->ch[d];
 54         k->ch[d] = x;
 55         k->s = x->s;
 56         x->push_up();
 57         x = k;
 58     }
 59     inline void Maintain(Node* &x, int d){
 60         if (x->ch[d] == null) return;
 61         if (x->ch[d]->ch[d]->s > x->ch[!d]->s){
 62             rotate(x, !d);
 63         } else if (x->ch[d]->ch[!d]->s > x->ch[!d]->s){
 64             rotate(x->ch[d], d), rotate(x, !d);
 65         } else {
 66             return;
 67         }
 68         Maintain(x, 0), Maintain(x, 1);
 69     }
 70     inline void insert(Node* &x, int v, int t, int id){
 71         if (x == null){
 72             x = newNode(v, t, id);
 73             return;
 74         } else {
 75             x->s++;
 76             int d = x->cmp(v, t);
 77             insert(x->ch[d], v, t, id);
 78             x->push_up();
 79             Maintain(x, d);
 80         }
 81     }
 82     inline void del(Node*  &x, int v, int t){
 83         if (x == null) return;
 84         x->s--;
 85         int d = x->cmp(v, t);
 86         if (-1 == d){
 87             if (!x->ch[0]->s || !x->ch[1]->s){
 88                 store[top++] = x;
 89                 x = x->ch[0]->s ? x->ch[0] : x->ch[1];
 90             } else {
 91                 Node *ret = x->ch[1];
 92                 for (; ret->ch[0] != null; ret = ret->ch[0]);
 93                 x->v = ret->v, x->t = ret->t, x->id = ret->id;
 94                 del(x->ch[1], ret->v, ret->t);
 95             }
 96         } else {
 97             del(x->ch[d], v, t);
 98         }
 99         if (x != null) x->push_up();
100     }
101     inline int find(Node *x, int v, int t){
102         int k = 0, cur = 0;
103         for (; x != null;){
104             int d = x->cmp(v, t);
105             k = x->ch[0]->s;
106             if (-1 == d) break;
107             else if (!d) x = x->ch[0];
108             else cur += k + 1, x = x->ch[1];
109         }
110         return cur + k + 1;
111     }
112     inline int rank(Node *x, int k){
113         for (; x != null;){
114             int t = x->ch[0]->s;
115             if (k == t + 1) break;
116             else if (k <= t) x = x->ch[0];
117             else k -= t + 1, x = x->ch[1];
118         }
119         return x->id;
120     }
121     inline void insert(int v, int t, int id){
122         insert(root, v, t, id);
123     }
124     inline void del(int v, int t){
125         del(root, v, t);
126     }
127     inline int find(int v, int t){
128         return find(root, v, t);
129     }
130     inline int rank(int k){
131         return rank(root, k);
132     }
133 }sbt;
134 #define BASE 133
135 #define MOD 299997
136 #define MAXN 500000
137 int now[Max_N], _time[Max_N];
138 struct HashSet{
139     int head[MAXN];
140     int tot, next[MAXN];
141     ull hash[MAXN];
142     char src[Max_N][12];
143     inline ull GetHash(char *s){
144         ull re = 0;
145         while (*s != '\0') re = re * BASE + *s++;
146         return re;
147     }
148     inline int Insert(char *s) {
149         ull _hash = GetHash(s);
150         int x = _hash % MOD;
151         for (int i = head[x]; i; i = next[i]){
152             if (hash[i] == _hash) return i;
153         }
154         next[++tot] = head[x];
155         hash[tot] = _hash;
156         head[x] = tot;
157         strcpy(src[tot], s);
158         return tot;
159     }
160 }map;
161 int main(){
162 #ifdef LOCAL
163     freopen("in.txt", "r", stdin);
164     freopen("out.txt", "w+", stdout);
165 #endif
166     int n, v;
167     sbt.init();
168     State s1, buf;
169     scanf("%d\n", &n);
170     for (int i = 1; i <= n; i++){
171         gets(buf);
172         if (buf[0] == '+'){
173             sscanf(&buf[1], "%s %d", s1, &v);
174             int x = map.Insert(s1);
175             if (now[x])    sbt.del(now[x], _time[x]);
176             now[x] = v, _time[x] = i;
177             sbt.insert(now[x], _time[x], x);
178         } else if (buf[0] == '?' && isalpha(buf[1])){
179             sscanf(&buf[1], "%s", s1);
180             int x = map.Insert(s1);
181             printf("%d\n", sbt.find(now[x], _time[x]));
182         } else {
183             int ed;
184             sscanf(&buf[1], "%d", &v);
185             ed = min(v + 9, map.tot);
186             for (int j = v; j <= ed; j++) {
187                 printf("%s%c", map.src[sbt.rank(j)], j != ed ? ' ' : '\n');
188             }
189         }
190     }
191     return 0;
192 }
View Code

 

posted @ 2015-05-03 19:53  GadyPu  阅读(323)  评论(2)  编辑  收藏  举报