MemSQL Start[c]UP 2.0 - Round 2

反正晚上睡不着，熬到1点开始做比赛，6个题目只做了2个题目，而且手速还比较慢，待提升空间还很大呢。

A题：给定两个0，1串(len<=100000), 但是不是普通的二进制串，而是q进制串，q = (√5 + 1)/2,比较这两个串的大小。

分析：q的长度很大，即使用大数似乎也不怎么合理，其实我写了半天大数，用最大长度数据测试发现根本出不了结果，也许我写的太挫了，也学时间就耗在上面了。

最终只能另想方法，而且题目中也说明了q^2 = q+1,所以很容易想到利用这个来做这个题， 观察到对于一个串中连续2个1，可以转化为高位的1个1，而且大小不变。这个题目比较大小的难点在于，会存在100 和011相等的情况，也就是不能通过一步步比较最高位来判断大小，低位也会影响。所以关键在于如何消除这种影响，我想到的方法就是从低位开始将连续2个1消去，变成高位1，如00110变成01000就好了，但是有一个问题就是遇到这种情况，001110，不止2个1连着，这样如果将最低2个1消除，会使得高位有2个1,001(2)000,这事就应该将连续一段最后两个1消除。这样做了一次之后还不够，需要反过来在做一次，比如这种情况，01111100，第一遍之后变成10011100，反过来遇到连续2个1，则变成高位，第二遍变成10100100，至于为什么这样做，因为第一遍之后会给后面的连续的1空出至少2个空间，这样第二遍的时候就不会有高位2个1的情况。

具体实现用到了bitset，只是因为最近学到了它，想熟练一下只用。

代码：

 //Template updates date: 20140718
 #include <bits/stdc++.h>
 #define in freopen("solve_in.txt", "r", stdin);
 using namespace std;

 const int maxn =  + ;
 bitset<maxn> a, b;
 void solve(bitset<maxn> &x) {
    for(int i = ; i < maxn - ; i++) {
         if(x[i] && x[i+] && !x[i+]) {
             x[i] = x[i+] =;
             x[i+] = ;
             i++;
         }
     }
     for(int i = maxn-; i >= ; i--) {
         if(x[i] && x[i+]) {
             x[i+] = ;
             x[i] = x[i+] = ;
         }
     }
 }
 int main() {

     cin>>a>>b;
     solve(a);
     solve(b);
     for(int i = maxn-; i >= ; i--){
         if(a[i] > b[i]){
                 puts(">");
             return ;
         }
         else if(a[i] < b[i]){
             puts("<");
             return ;
         }
     }
     puts("=");
     return ;
 }

B题：有2个服务器，每个服务器上分别存储则会2个表，分别有m，n行，其中每个服务器会有很多分区，第一个服务器上第i个分区存储着ai行，第二个服务器第i个分区存储着bi行。

每次操作可以将任何分区上的行复制到其他任何分区，且花费为复制过去的行的数目。求最少的花费，使得对于第1个服务器上表的每行和第2个服务器上的表每个行都至少同时出现在一个分区上。

分析：

先对a[i], b[i]排序，suma[i]表示第一个服务器上前i个分区的行之和，sumb[i]类似。

问题可以这样考虑，第一个服务器上行最终状态是分成了x堆，第二个服务器上行移动到这些堆里面，这里花费为x*sumb[n],第一个服务器的花费应当是，a[i]中最大的x个作为不动分区，其他分区移动到这x个堆上面，花费为suma[x-1],枚举x，去最小值。

同理，可对第二个服务器作为x个堆算出最优值。

代码：

 //Template updates date: 20140718
 #include <bits/stdc++.h>

 #define  in  freopen("solve_in.txt", "r", stdin);
 using namespace std;
 const int maxn =  + ;
 double a[maxn], b[maxn], sum1[maxn], sum2[maxn];

 int main() {

     int n, m;
     cin>>m>>n;
     double ans = 1e25;
     for(int i = ; i <= m; i++) {
         scanf("%lf", &a[i]);
         sum1[i] = sum1[i-]+a[i];
     }
     for(int i = ; i <= n; i++) {
         scanf("%lf", b+i);
         sum2[i] = sum2[i-]+b[i];
     }
     sort(a+, a+m+);
     sort(b+, b+n+);
     for(int i = ; i <= m; i++) {
         sum1[i] = sum1[i-]+a[i];
     }
     for(int i = ; i <= n; i++) {
         sum2[i] = sum2[i-]+b[i];
     }
     for(int i = ; i <= m; i++) {
         double tmp = sum2[n]*i+sum1[m-i];
         ans = min(ans, tmp);
     }
     for(int i = ; i <= n; i++) {
         double tmp = sum1[m]*i+sum2[n-i];
         ans = min(ans, tmp);
     }
     printf("%.0f\n", ans);
     return ;
 }

C题：有n支选票，投给ai，如果要这个人把票投给自己，那么需要花费bi，自己的标号为0。求最少的花费，使得自己选票比选票数目最多的那个人还要多。

分析：研究了半天别人代码，发现大抵方法是这样的：首先统计每个人得到的票数，及花费。然后将每个人票花费从小到大排序，统计出每个人的票数排序。

然后就是枚举我需要得到的票数i了，每次从票数比我多的人中减去一票，如果没有达到i，那么才弄个剩下的票数中选出花费最小的一些票。

更新剩下的票数，并选出最小的一些个时用到了树状数组，看了@JayYe的代码，自己仿写了一遍，我不会这一题啊。自己看了还不是很理解~~GG

另外， 好像还可以用三分？

树状数组实现代码：

值得学习的是， 里面查询最小k个的花费时的函数，二进制位从高到低枚举，每次cnt + num[res] < k ,则说明该高位应该加进去。

 #include <bits/stdc++.h>
 #define in freopen("solve_in.txt", "r", stdin);
 #define lson rt<<1, l, m
 #define rson rt<<1|1, m+1, r
 #define lowbit(x) ((x)&(-(x)))
 using namespace std;
 const int maxn = +;
 const int maxm = +;

 map<int, multiset<int> > mps;
 typedef map<int, multiset<int> > :: iterator it;

 int n;
 int x[maxn], y[maxn], cost[maxn], pos[maxm], val[maxm], num[maxm];
 int sz[maxn], r[maxn];
 int cnt, tot;
 bool cmp(int a, int b) {
     return sz[a] > sz[b];
 }
 void update(int x, int v) {
     int tmp = cost[x];
     while(x < maxm) {
         num[x] += v;
         val[x] += v*tmp;
         x += lowbit(x);
     }
 }
 int query1(int x) {
     int res = ;
     while(x > ) {
         res += num[x];
         x -= lowbit(x);
     }
     return res;
 }
 int query2(int x) {
     int res = ;
     while(x > ) {
         res += val[x];
         x -= lowbit(x);
     }
     return res;
 }
 int findup(int x) {
     int res = ;
     int tmp = ;
     for(int i = ; i >= ; i--) {
         res += (<<i);
         if(res >= tot || tmp + num[res] >= x)
             res -= (<<i);
         else tmp += num[res];
     }
     return res + ;
 }
 #define bug puts(">>>>>>>>>>>><<<<<");
 int main() {

     cin>>n;
     for(int i = ; i < n; i++) {
         scanf("%d%d", x+i, y+i);
         if(x[i])
             mps[x[i]].insert(y[i]);
     }
     for(int i = ; i < n; i++) {
         cost[++tot] = y[i];
     }
     sort(cost+, cost+tot+);
     tot = unique(cost+, cost+tot+)-cost;
     for(int i = ; i < tot; i++) {
         pos[cost[i]] = i;
     }
     for(int i = ; i < n; i++) {
         update(pos[y[i]], );
     }
     for(it s = mps.begin(); s != mps.end(); s++) {
         r[cnt++] = s->first;
         sz[s->first] = (s->second).size();
     }
     sort(r, r+cnt, cmp);
     int j = ;
     int nn = , ans = 0x7f0f0f0f, ccost = ;
     for(int i = n; i >= ; i--) {
         while(j < cnt && sz[r[j]] >= i) j++;
         for(int k = ; k < j; k++) {
             nn++;
             int tmp = *mps[r[k]].begin();
             ccost += tmp;
             mps[r[k]].erase(mps[r[k]].begin());
             update(pos[tmp], -);
         }
         int cc = ccost;
         int kk = max(i-nn, );
         if(kk > ) {
             int p = findup(kk);
             int t1 = query2(p-);
             cc += t1 + (kk-query1(p-))*cost[p];
         }
         ans = min(ans, cc);
     }
     printf("%d\n", ans);
     return ;
 }