四月排名赛

以下只是部分题解，简单题跳过。

题目链接：
B Team Formation
题意：
给一个n个数的数组，求a[i]^a[j]>max(a[i],a[j])的(i,j)对数。
分析：
考虑两个数a和b异或值大于max(a,b)的充分条件(b>a).只需考虑b在a的二进制最高位的二进制相应位上的数字
是不是0。例如2和5,2化成二进制是10,5化成二进制是101，因为5在2的二进制最高位的相应位上是0,1^0=1,
至少会得到11…，所以肯定大于10..是可行的，再考虑4和5，即100和101，因为5在4的最高位上数字是1，最高位
异或值是0，所以得到的结果肯定比1..小。
先将所有数从小到大排序，然后每次判断一个数和之前比它小的数符合条件的数对数量，只需扫描一下相应的二进制位和并且这一位为0的最高位数字个数。

比赛的时候我是在线处理的，每输入一个数就判断一下，包括比它大的数，但是这样有一个很严重的问题，大于这个数的数可能在这个数的最高位上是1，那么这时的异或值就大的数要小了！

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <climits>
using namespace std;
const int MAX_N=100010;

int T,n;
long long vis[70];
long long data[MAX_N],ans;

int main()
{
    //freopen("Bin.txt","r",stdin);
    scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        memset(vis,0,sizeof(vis));
        ans=0;
        for(int i=0;i<n;i++){
            scanf("%lld",&data[i]);
        }
        sort(data,data+n);
        for(int i=0;i<n;i++){
            long long tmp=data[i];
            int len=0,bit[70];
            memset(bit,0,sizeof(bit));
            while(tmp){
                bit[++len]=tmp%2;
                tmp/=2;
            }
            for(int j=1;j<len;j++){
                if(bit[j]==0) ans+=vis[j];
            }
            vis[len]++;
        }
        printf("%lld\n",ans);
    }
    return 0;
}

题目链接：
C Beauty of Array
题意：
定义一个数组的beauty为这个数组中不相同的数字之和。给出一个n个数的数组，求这个数组的
所有连续子串的beauty值之和。数据范围：n<=100000, a[i]<=1000000
分析：
用pre[i]表示到a[i]的所有以a[i]为结尾的连续子串的beauty值之和。
假设之前a[i]出现的位置是pos[a[i]],那么计算从pos[a[i]]+1到i的子串时，每次都要加上一个a[i]，而其余的数值之和就是pre[i-1]了！只有在pos[a[i]]+1到i这一串计算以a[i]为结尾的连续子串时才需要用上a[i],之前就不需要了！
最后再把所有的pre[i]相加即是最终结果。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <climits>
using namespace std;
const int MAX_N=100010;
const int MAX_M=1000010;

int T,n;
long long data[MAX_N],pre[MAX_N],pos[MAX_M];

int main()
{
    freopen("Cin.txt","r",stdin);
    scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        for(int i=1;i<=n;i++){
            scanf("%lld",&data[i]);
        }
        memset(pos,0,sizeof(pos));
        for(int i=1;i<=n;i++){
            pre[i]=pre[i-1]+data[i]*(i-pos[data[i]]);
            pos[data[i]]=i;
        }
        long long ans=0;
        for(int i=1;i<=n;i++){
            ans+=pre[i];
        }
        printf("%lld\n",ans);
    }
    return 0;
}

题目链接：
E May Day Holiday
题意：
已知五一劳动节连放5天假，可以和周末继续，比如5月1是周二那么就连续放6天假，5月1日是周一那就连放9天假！
给出一个年份year(1928 <= year <= 9999),输出这一年放几天假？
分析：
直接根据公式
int ans=(day+1+2*month+3*(month+1)/5+year+year/4-year/100+year/400)%7;
算出这一年的5月1日时周几（周日时ans=0），然后答案就固定了。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <climits>
using namespace std;
const int month=5;
const int day=1;

int T;
int year;


int main()
{
    freopen("Ein.txt","r",stdin);
    scanf("%d",&T);
    while(T--){
        scanf("%d",&year);
        int ans=(day+1+2*month+3*(month+1)/5+year+year/4-year/100+year/400)%7;
        //printf("ans=%d\n",ans);
        if(ans==1){
            printf("9\n");
        }else if(ans==2||ans==0){
            printf("6\n");
        }else {
            printf("5\n");
        }
    }
    return 0;
}

题目链接：
F Convert QWERTY to Dvorak
题意：
给出两副键位不一样的键盘，输入在一个键盘敲打的字符，输出同样的键位在另一个键盘的输出。区分大小写。
分析：
简单的映射。注意转义字符’\”’即可。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <climits>
using namespace std;
const int MAX_N=110;
const int MAX_M=10010;

char s1[MAX_N]="_-+=QqWwEeRrTtYyUuIiOoPp{[}]AaSsDdFfGgHhJjKkLl:;\"'ZzXxCcVvBbNnMm<,>.?/\0";
char s2[MAX_N]="{[}]\"'<,>.PpYyFfGgCcRrLl?/+=AaOoEeUuIiDdHhTtNnSs_-:;QqJjKkXxBbMmWwVvZz\0";

char read[MAX_M];

int main()
{
    freopen("Fin.txt","r",stdin);
    //puts(s1);
    //puts(s2);
    int len1=strlen(s1);
    while(gets(read)!=NULL){
        int len=strlen(read);
        for(int i=0;i<len;i++){
            int find=-1;
            for(int j=0;j<len1;j++){
                if(read[i]==s1[j]){
                    find=j;
                    break;
                }
            }
            if(find==-1) putchar(read[i]);
            else putchar(s2[find]);
        }
        printf("\n");
    }
    return 0;
}

题目链接:
H 汉诺塔II
题意：
汉诺塔的变形，有4根柱子，其中一号柱子从低到高从大到小叠加n个盘子，需要将这些盘子移动到四号柱子，
每次移动只能移动一个盘子，并且叠放在柱子上只能是小盘子放在大盘子上面。问最少移动步数？(1<=n<=64)
分析：
一开始我是考虑先将n-2个盘子移动到一根柱子上，最少需要ans[n-2]次，然后将第n-1个盘子移到一根空的柱子上面
步数加一，再将最后第n个盘子放在另外一根柱子上，步数加一，再将第n-1个盘子移到第n个盘子上面步数+1，
最后再将n-2个盘子移到第n-1个盘子上面同样需要ans[n-2]次，所以可以得到ans[n]=2*ans[n-2]+3;
但是这样连样例都过不了！后来又发现可能在中间过程的时候就有最优解。
也就是将j个最小的盘子移到二号柱子上(ans[j])，将i-1-j个次小的盘子移到三号柱子上((1<<(i-1-j))-1步)，
再将第i个盘子移到四号柱子上(1步),接着将i-1-j个次小的盘子移到四号柱子上(1<<(i-1-j)-1步)，最后将
小的j个盘子移到四号柱子上(ans[j]步)，总共是ans[i]=ans[j]*2+((1<<(i-1-j))-1)*2+1步，过程区最小值即可。

比赛时没考虑到在计算最后一个ans[64]时ans[j]*2+((1<<(i-1-j))-1)*2+1会爆long long，
很弱智的一个错误愣是没想出来反正当时整个人都傻了。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <climits>
using namespace std;
const long long mod=(long long)(1e9);

long long ans[70]={0,1,3};

void init()
{
    for(int i=3;i<=64;i++){
        ans[i]=0x7fffffff;
        for(int j=1;j<i-1;j++){
            long long t=((long long)1<<(i-1-j))-1;
            if(t*2+ans[j]*2+1<0) continue;
            ans[i]=min(ans[i],t*2+ans[j]*2+1);
        }
    }
}

int main()
{
    freopen("Hin.txt","r",stdin);
    init();
    int n;
    while(~scanf("%d",&n)){
        printf("%lld\n",ans[n]);
    }
    return 0;
}

题目链接：
I Buy Tickets
题意：
有n个人排队，输入每个人插入队列的位置，输出最终的队列顺序。
分析：
从后往前插入队列，第i个人要插入的位置pos[i]其实是所有中剩余位置的第pos[i]个！
线段树的单点更新和区间查询！！！

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#define lson(x) (x<<1)
#define rson(x) ((x<<1)|1)
using namespace std;

const int maxn=200010;

int n;
int pos[maxn],val[maxn],ans[maxn];

struct SegTree{
    int left,right,num;
}segtree[maxn<<2];

inline void build(int left,int right,int cur)
{
    segtree[cur].left=left;
    segtree[cur].right=right;
    segtree[cur].num=right-left+1;
    if(left==right) return;
    int mid=(left+right)>>1;
    build(left,mid,lson(cur));
    build(mid+1,right,rson(cur));
}

inline int query(int t,int cur)
{
    int left=segtree[cur].left;
    int right=segtree[cur].right;
    if(left==right)
    {
        segtree[cur].num=0;
        return left;
    }
    int tmp;
    int lsum=segtree[lson(cur)].num;
    if(t<=lsum) tmp=query(t,lson(cur));
    else tmp=query(t-lsum,rson(cur));
    segtree[cur].num=segtree[lson(cur)].num+segtree[rson(cur)].num;
    return tmp;
}

int main()
{
    while(~scanf("%d",&n))
    {
        for(int i=0;i<n;i++)
            scanf("%d%d",&pos[i],&val[i]);
        build(1,n,1);
        for(int i=n-1;i>=0;i--)
        {
            int t=query(pos[i]+1,1);
            ans[t]=val[i];
        }
        for(int i=1;i<=n;i++)
            printf("%d ",ans[i]);
        printf("\n");
    }
    return 0;
}

题目链接：
J Travel
题意：
有n个点，m条无向边，Q次查询，每次查询输出连通的点对路径单边最大值不大于limit的点对数。(a,b)和(b,a)是不同的点对。
分析：
很容易往最短路上想，实际上是并查集。
先把所有的边和查询按照权值从小到大排序。
将每次将所有不大于limit的路径并进并查集中，只需考虑并查集中元素个数。可能有多个集合。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <climits>
#include <cmath>
#include <set>
using namespace std;
const int MAX_N=20010;
const int MAX_M=100010;
const int MAX_Q=5010;

int T,n,m,Q;
int num[MAX_N],pre[MAX_N];

struct Edge{
    int a,b,val;
    bool operator < (const Edge& rhs) const {
        return val<rhs.val;
    }
}edge[MAX_M];

struct Query{
    int limit,ans,index;
}query[MAX_Q];

bool cmp1(const Query x,const Query y)
{
    return x.limit<y.limit;
}

bool cmp2(const Query x,const Query y) 
{
    return x.index<y.index;
}

inline void read()
{
    scanf("%d%d%d",&n,&m,&Q);
    for(int i=0;i<m;i++){
        scanf("%d%d%d",&edge[i].a,&edge[i].b,&edge[i].val);
    }
    for(int i=0;i<Q;i++){
        scanf("%d",&query[i].limit);
        query[i].index=i;
    }
}

inline void init()
{
    for(int i=1;i<=n;i++){
        pre[i]=i;
        num[i]=1;
    }
}

inline int find(int x)
{
    return pre[x]==x?x:pre[x]=find(pre[x]);
}

int main()
{
    freopen("Jin.txt","r",stdin);
    scanf("%d",&T);
    while(T--){
        read();
        sort(edge,edge+m);
        sort(query,query+Q,cmp1);
        init();
        set<int> ancestor;
        for(int i=0,j=0;j<Q;j++){
            while(i < m && edge[i].val <= query[j].limit)
            {
                int fa=find(edge[i].a);
                int fb=find(edge[i].b);
                if(fa!=fb){
                    num[fa]+=num[fb];
                    pre[fb]=fa;
                    ancestor.erase(fb);
                    if(ancestor.find(fa)==ancestor.end())
                    {
                        ancestor.insert(fa);
                    }
                }
                i++;
            }
            int res=0;
            for(set<int> :: iterator it =ancestor.begin();it!=ancestor.end();it++)
            {
                int tmp=num[(*it)];
                res+=tmp*(tmp-1);
            }
            query[j].ans=res;
        }
        sort(query,query+Q,cmp2);
        for(int i=0;i<Q;i++){
            printf("%d\n",query[i].ans);
        }
    }
    return 0;
}