PKU 3274 Gold Balanced Lineup解题报告

 

1. /*
2.   Title: Gold Balanced Lineup
3.   Author: Jeff
4.   Time:  2008/11/19
5.   Complexity: O(nlogn);
6.   Result: different below/ AC
7.   Reference: 
8.         http://www.cppblog.com/sicheng/archive/2008/09/07/28532.html
9.         http://www.cppblog.com/Hero/archive/2008/08/30/60441.html
10.   Description: 
11.         给出100000个数，求出balance最长范围。
12.         balance的定义是：[i,j]范围内的数的各个位加起来相等。
13.         如 4 2 1各个位加起来分别是 1 1 1相等 
14.         而 4 2 2各个位加起来分别是 1 2 0不相等 
15.   Tips:
16.         一开始无从下手(题目分类是hash, 排序)，还是上网搜了下，结果要
17.         先预处理下，将每个数分解为K位0/1表示的数。 
18.         如：
19.         7 3 
20.         7 6 7 2 1 4 2 
21.         分解：
22.         1 1 1 0 0 1 0
23.         1 1 1 1 0 0 1
24.         1 0 1 0 1 0 0
25.         累加：横方向 
26.         1 2 3 3 3 4 4
27.         1 2 3 4 4 4 5
28.         1 1 2 2 3 3 3
29.         相减：纵方向
30.         0 1 1 1 0 1 1
31.         0 1 1 2 1 1 2
32.         0 0 0 0 0 0 0
33.           -       -
34.         再找两边相等bits的且间隔最长的距离就是结果(因为两边相等说明经过中间
35.         的步骤是满足balance条件的)
36.   p.s. 
37.         注意只有1个balance距离的情况，因为上面可能找不到两个相等的bits，所以
38.         在开头增加一个(0 0 0)' 
39.         同样为节省时间，输入用了getchar()，再化为int 
40. */
41. #include <cstring>
42. #include <cstdio>
43. #include <algorithm>
44. #include <map>
45. #include <vector>
47. using namespace std;
49. const int MAX = 100002;
51. int N, K;
53. struct Node{
54.     int bits[32];
55.     int idx;    
56.     bool operator<(const Node &other)const{
57.         for(int i = 0; i < K; i++)
58.             if(bits[i] < other.bits[i])return true;
59.             else if(bits[i] == other.bits[i])continue;
60.             else return false;
61.         return false;
62.     }
63.     bool operator==(const Node &other)const{
64.         for(int i = 0; i < K; i++)
65.             if(bits[i] != other.bits[i])return false;
66.         return true;
67.     }
68. }node[MAX];
72. int min(int a, int b){
73.     return a < b ? a : b;    
74. }
76. int max(int a, int b){
77.     return a > b ? a : b;    
78. }
80. int main(){
81.     freopen("in.txt", "r", stdin);
82.     freopen("out.txt", "w", stdout);
83.     while(scanf("%d%d", &N, &K) != EOF){
84.         char ch = getchar();
85.         for(int i = 1; i <= N; i++){
86.             while(ch == ' ' || ch == '/n')ch = getchar();
87.             int x = 0;
88.             while(ch != ' ' && ch != '/n'){
89.                 x = x * 10 + ch - '0';
90.                 ch = getchar();    
91.             }
92.             for(int j = 0; j < K; j++){
93.                 node[i].bits[j] = 1 & (x >> j);    
94.             }
95.             node[i].idx = i;
96.         }
97.         memset(&node[0], 0, sizeof(node[0]));
98.         for(int i = 1; i <= N; i++)
99.             for(int j = 0; j < K; j++)
100.                 node[i].bits[j] += node[i-1].bits[j];
102.         for(int i = N; i >= 0; i--)
103.             for(int j = K-1; j >= 0; j--)
104.                 node[i].bits[j] -= node[i].bits[0];
105.                 
106.         
107.         /*for(int i = 0; i < N; i++){
108.             for(int j = 0; j < K; j++)
109.                 printf("%d ", node[i].bits[j]);
110.             printf("/n");    
111.         }
112.         printf("/n"); */
113.         //
114.         //      13248K  407MS    快排 
115.         //
116.         sort(node, node + N + 1);
117.         int min_n = 1 << 28, max_n = 0, ans = 0;
118.         for(int i = 1; i <= N; i++){
119.             if(node[i] == node[i-1]){
120.                 int min_t = min(node[i].idx, node[i-1].idx);
121.                 int max_t = max(node[i].idx, node[i-1].idx);
122.                 if(min_n > min_t)min_n = min_t;
123.                 if(max_n < max_t)max_n = max_t;
124.                 if(ans < max_n - min_n)ans = max_n - min_n;    
125.             }else{
126.                 min_n = 1 << 28;
127.                 max_n = 0;    
128.             }
129.         }
130.         printf("%d/n", ans);
131.         /
132.         /
133.         
134.         /*
135.         /
136.         //        29828K    1797MS     map
137.         /
138.         map<Node, int> mym;
139.         vector<int> l[MAX];
140.         int j = 0;
141.         for(int i = 0; i <= N; ++i) {
142.             if(mym.find(node[i]) == mym.end()) 
143.                 mym[node[i]] = j++;
144.             l[mym[node[i]]].push_back(i);
145.         }
147.         int res = 0;
148.         for(int i = 0; i < j; ++i) {
149.             int min = 123456789, max = -1;
150.             for(int k = 0; k < l[i].size(); ++k) {
151.                 if(l[i][k] > max) max = l[i][k];
152.                 if(l[i][k] < min) min = l[i][k];
153.             }
154.             if(max - min > res) res = max - min;
155.         }
157.         printf("%d/n", res);
158.         //
159.         //
160.         */
161.     }
162.     return 0;    
163. }