Codeforces Round #312 (Div. 2) 题解

题目链接：http://codeforces.com/contest/558

A、Lala Land and Apple Trees

题意：在一条数轴上有n棵苹果树，给你每棵苹果树的位置和树上的苹果数。现在你在坐标0点，你可以选一个方向采集该方向上第一个没访问过的苹果树上的所有苹果，采集完后后调头做相同的事，知道目前方向上没有苹果树，问你最多能采集多少苹果

解：按坐标排序，肯定要把苹果树数目最少一侧的苹果树采集完

/*
 * Problem:  
 * Author:  SHJWUDP
 * Created Time:  2015/7/14 星期二 22:50:29
 * File Name: 233.cpp
 * State: 
 * Memo: 
 */
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long int64;

const int MaxA=100+7;

int n;
pair<int, int> p[MaxA];
int main() {
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    //freopen("out", "w", stdout);
#endif
    while(~scanf("%d", &n)) {
        for(int i=0; i<n; i++) {
            scanf("%d%d", &p[i].first, &p[i].second);
        }
        sort(p, p+n);
        int pos=0;
        while(pos<n && p[pos].first<0) pos++;
        int b=n-pos, a=n-b;
        int64 ans=0;
        if(a>b) {
            for(int i=pos; i<n; i++) {
                ans+=p[i].second;
            }
            b++;
            for(int i=pos-1; b-- && i>=0; i--) {
                ans+=p[i].second;
            }
        } else {
            for(int i=pos-1; i>=0; i--) {
                ans+=p[i].second;
            }
            a++;
            for(int i=pos; a-- && i>=0; i++) {
                ans+=p[i].second;
            }
        }
        printf("%I64d
", ans);
    }
    return 0;
}

B、Amr and The Large Array

题意：我们称一个数组中某数字出现最多次数为性质A的程度，如（{1， 1， 2， 2， 1}的性质A的程度为3， {1， 2， 1， 2}为2），问你和原数组性质A程度相同的最短子段的长度

解：~

/*
 * Problem:  
 * Author:  SHJWUDP
 * Created Time:  2015/7/14 星期二 22:50:29
 * File Name: 233.cpp
 * State: 
 * Memo: 
 */
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <map>
#include <vector>

using namespace std;

typedef long long int64;

const int MaxA=1e5+7;

int n;
int arr[MaxA];
int main() {
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    //freopen("out", "w", stdout);
#endif
    while(~scanf("%d", &n)) {
        map<int, vector<int> > M;
        for(int i=0; i<n; i++) {
            scanf("%d", &arr[i]);
            M[arr[i]].push_back(i);
        }
        map<int, int> vis;
        int tmp=-1;
        for(const auto& u : M) {
            if((int)u.second.size()>tmp) {
                vis.clear();
                tmp=(int)u.second.size();
                vis[u.first]=1;
            } else if((int)u.second.size()==tmp) {
                vis[u.first]=1;
            }
        }
        int ans=0x7f7f7f7f;
        int st, ed;
        for(int i=0; i<n; i++) {
            if(vis.find(arr[i])!=vis.end()) {
                vector<int>& u=M[arr[i]];
                if(u.back()-u[0]<ans) {
                    ans=u.back()-u[0];
                    st=u[0];
                    ed=u.back();
                }
            }
        }
        printf("%d %d
", st+1, ed+1);
    }
    return 0;
}

C、Amr and Chemistry

题意：给你n个数，你可以花费1对任一个数x进行（a、x=2*x   b、x=x/2  整除）两种操作，问你最小花费多少使得所有数等大

解：将数字化成二进制，取最长公共前缀，然后消去后面不齐的，问题就变成了n个有长有短的木棒，你可以进行花费来增减任一木棒的长度。。。那么变成所有木棒的中位数长度花费最小了

/*
 * Problem:  
 * Author:  SHJWUDP
 * Created Time:  2015/7/14 星期二 22:50:29
 * File Name: 233.cpp
 * State: 
 * Memo: 
 */
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <map>
#include <vector>

using namespace std;

typedef long long int64;

const int MaxA=1e5+7;

int n;
int arr[MaxA];
vector<int> lis[MaxA];
int main() {
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    //freopen("out", "w", stdout);
#endif
    while(~scanf("%d", &n)) {
        for(int i=0; i<n; i++) {
            scanf("%d", &arr[i]);
            lis[i].clear();
            int x=arr[i];
            do {
                lis[i].push_back(x&1);
                x>>=1;
            } while(x);
        }
        for(int i=0; i<n; i++) reverse(lis[i].begin(), lis[i].end());
        int ed=-1;
        for(int j=0; ed==-1; j++) {
            if(j==(int)lis[0].size()) {
                ed=j;
                break;
            }
            int tmp=lis[0][j];
            for(int i=1; i<n; i++) {
                if(j==(int)lis[i].size() || tmp!=lis[i][j]) {
                    ed=j;
                    break;
                }
            }
        }
        int64 ans=0;
        int64 sum=0;
        for(int i=0; i<n; i++) {
            int pos=-1;
            for(int j=ed; j<(int)lis[i].size(); j++) {
                if(lis[i][j]!=0) {
                    pos=j;
                    break;
                }
            }
            if(pos!=-1) {
                int cnt=(int)lis[i].size()-pos;
                ans+=cnt;
                arr[i]=lis[i].size()-cnt;
            } else  arr[i]=(int)lis[i].size();
            sum+=arr[i];
        }
        sort(arr, arr+n);
        int64 x;
        if(n&1) x=arr[n>>1];
        else x=(arr[n>>1]+arr[n/2-1])>>1;
        for(int i=0; i<n; i++) ans+=abs(x-arr[i]);
        printf("%I64d
", ans);
    }
    return 0;
}

D、Guess Your Way Out! II

题意：题目好长~所幸不是很难懂。。。看原题吧

解：把操作区间全部化成最后一层，然后排排序乱搞的，这题主要考察码力吧？优雅的写法能省很多功夫

/*
 * Problem:  
 * Author:  SHJWUDP
 * Created Time:  2015/7/14 星期二 22:50:29
 * File Name: 233.cpp
 * State: 
 * Memo: 
 */
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <map>
#include <vector>

using namespace std;

typedef long long int64;

const int MaxA=1e5+7;

int h, q;
pair<int64, int64> p[MaxA];
int level, op;
int64 L, R, l, r;///[l, r)为通过肯定判断得出的解区间
int n;
int main() {
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    //freopen("out", "w", stdout);
#endif
    while(~scanf("%d%d", &h, &q)) {
        n=0;
        l=1LL<<(h-1); r=1LL<<h;
        bool ok=1;
        for(int i=0; i<q; i++) {
            scanf("%d%I64d%I64d%d", &level, &L, &R, &op);
            if(!ok) continue;
            L<<=h-level;
            R=(R+1)<<(h-level);
            if(op) {
                l=max(L, l); r=min(R, r);
            } else {
                p[n++]=make_pair(L, R);        //左闭右开区间
            }
        }
        p[n++]=make_pair(r, r);    ///加入这个会降低代码量
                                ///而且[r, r)为空区间，不影响
        sort(p, p+n);
        int flag=-1;
        int64 ans=-1;
        for(int i=0; i<n; i++) {
            int64 x=p[i].first, y=p[i].second;
            if(r<=l) break;
            if(y<=l) continue;
            if(l<x) {
                if(l+1<x || ans!=-1) {
                    flag=0;
                    break;
                }
                ans=l;
            }
            l=y;
        }
        if(flag==0) puts("Data not sufficient!");
        else if(ans==-1) puts("Game cheated!");
        else printf("%I64d
", ans);
    }
    return 0;
}

E、A Simple Task

题意：给你一个串，和一些操作，操作是选定串上的一段区间把他们按升序或降序排序，要你输出在这些操作过后的串

解：由于字符集只有26，对每一种字符，统计它的位置，然后每次排序后修改，用线段树完成统计修改

具体是建26棵线段树，每棵对应一种字符，线段树结点保存该字符在某区间内的出现次数

/*
 * Problem:  
 * Author:  SHJWUDP
 * Created Time:  2015/7/16 星期四 12:22:59
 * File Name: 233.cpp
 * State: 
 * Memo: 
 */
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int MaxA=1e5+7;

struct SegmentTree {
    struct Node {
        int cnt, flag;
    } tree[26][MaxA<<2];

    Node* c;
    int id;
#define lson l, m, rt<<1
#define rson m+1, r, rt<<1|1
#define INIT Node& u=c[rt]; Node& ls=c[rt<<1]; Node& rs=c[rt<<1|1];

    void chID(int _id) {
        id=_id;
        c=tree[id];
    }

    void pushUp(int rt) {
        INIT
        u.cnt=ls.cnt+rs.cnt;
    }

    void pushDown(int l, int m, int r, int rt) {
        INIT
        if(~u.flag) {
            ls.flag=u.flag; ls.cnt=(m-l+1)*u.flag;
            rs.flag=u.flag; rs.cnt=(r-m)*u.flag;
            u.flag=-1;
        }
    }

    void build(char* s, int l, int r, int rt) {
        c[rt].flag=-1;
        if(l==r) {
            c[rt].cnt=s[l]==(id+'a');
        } else {
            int m=(l+r)>>1;
            build(s, lson);
            build(s, rson);
            pushUp(rt);
        }
    }

    int query(int L, int R, int l, int r, int rt) {
        if(L<=l && r<=R) {
            return c[rt].cnt;
        } else {
            int m=(l+r)>>1;
            pushDown(l, m, r, rt);
            int res=0;
            if(L<=m) res+=query(L, R, lson);
            if(m<R) res+=query(L, R, rson);
            return res;
        }
    }

    void update(int L, int R, int x, int l, int r, int rt) {
        if(L<=l && r<=R) {
            c[rt].flag=x;
            c[rt].cnt=(r-l+1)*x;
        } else {
            int m=(l+r)>>1;
            pushDown(l, m, r, rt);
            if(L<=m) update(L, R, x, lson);
            if(m<R) update(L, R, x, rson);
            pushUp(rt);
        }
    }
} st;

int n, q;
char str[MaxA];
int cnt[26];
int main() {
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    //freopen("out", "w", stdout);
#endif
    while(~scanf("%d%d", &n, &q)) {
        scanf("%s", str);
        for(int i=0; i<26; i++) {
            st.chID(i); st.build(str, 0, n-1, 1);
        }
        while(q--) {
            int L, R, op;
            scanf("%d%d%d", &L, &R, &op); L--; R--;
            if(op) {
                int cnt=0;
                for(int i=0; i<26; i++) {
                    st.chID(i); int tmp=st.query(L, R, 0, n-1, 1);
                    if(!tmp) continue;
                    st.update(L, R, 0, 0, n-1, 1);
                    st.update(L+cnt, L+cnt+tmp-1, 1, 0, n-1, 1);
                    cnt+=tmp;
                }
            } else {
                int cnt=0;
                for(int i=25; i>=0; i--) {
                    st.chID(i); int tmp=st.query(L, R, 0, n-1, 1);
                    if(!tmp) continue;
                    st.update(L, R, 0, 0, n-1, 1);
                    st.update(L+cnt, L+cnt+tmp-1, 1, 0, n-1, 1);
                    cnt+=tmp;
                }
            }
        }
        for(int i=0; i<n; i++) {
            for(int j=0; j<26; j++) {
                st.chID(j);
                if(st.query(i, i, 0, n-1, 1)) {
                    putchar('a'+j);
                    break;
                }
            }
        }
        puts("");
    }
    return 0;
}