BestCoder Round #77 (div.2) A B C D

链接：戳这里

so easy  

 Time Limit: 2000/1000 MS (Java/Others)   Memory Limit: 65536/65536 K (Java/Others)

问题描述
已知一个包含 nn 个元素的正整数集合 SS，设 f(S)为集合 S  中所有元素的异或(XOR)的结果。
如：S={1,2,3}, 则 f(S) = 0。


给出集合 S，你需要计算 将所有 f(s) 进行异或后的值, 这里s⊆S.
输入描述
多组测试数据。第一行包含一个整数T(T≤20) 表示组数。


每组测试数据第一行包含一个数 n(1≤n≤1,000) 表示集合的大小，第二行为 n 的数表示集合元素。第 i(1≤i≤n) 个数 1000,000,0000≤ai ≤1000,000,000 且数据保证所给集合中没有重复元素。
输出描述
对于每组测试数据，输出一个数，表示将所有的 f(s) 的异或之后的值。
输入样例
1
3
1  2  3
输出样例
0
Hint
样例中，S={1,2,3}, 它的子集有∅, {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}

题意：子集的抑或总和

思路：由于n>1的时候都是偶数出现的  为0

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
#include<vector>
#include <ctime>
#include<queue>
#include<set>
#include<map>
#include<stack>
#include<cmath>
#define mst(ss,b) memset((ss),(b),sizeof(ss))
#define maxn 0x3f3f3f3f
#define MAX 1000100
///#pragma comment(linker, "/STACK:102400000,102400000")
typedef long long ll;
typedef unsigned long long ull;
#define INF (1ll<<60)-1
using namespace std;
int T;
int n,a[100100];
int main(){
    scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        for(int i=1;i<=n;i++) scanf("%d",&a[i]);
        if(n==1) cout<<a[1]<<endl;
        else cout<<0<<endl;
    }
    return 0;
}

xiaoxin juju needs help  

 Time Limit: 2000/1000 MS (Java/Others)   Memory Limit: 65536/65536 K (Java/Others)

问题描述
xiaoxin巨从小就喜欢字符串，六年级的时候他就知道了什么是回文串。这时，xiaoxin巨说到：如果一个字符串 SS 是回文串，那么该字符串从前往后看和从后往前看是一样一样的。


六年级的暑假，xiaoxin很快就做完了暑假作业，然后到腾讯做起了实习生。这日，leader给了xiaoxin一个字符串，请xiaoxin帮忙写一个函数来生成所有可能的回文串，可以任意改变字符串的顺序但是不可以扔掉某个字符。并且leader告诉xiaoxin，每生成一个不一样的回文串就可以得到一颗西瓜糖。


请你帮忙计算xiaoxin的leader最多需要买多少颗西瓜糖呢？
输入描述
多组测试数据。第一行包含一个整数 T(T≤20) 表示组数。每组测试数据给出一个只包含小写字母的字符串 S(1≤length(S)≤1,000)
输出描述
对于每组测试数据，输出一个数, 表示leader需要买的西瓜糖的个数，结果对 1,000,000,007 取模。
输入样例
3
aa
aabb
a
输出样例
1
2

1

题意：给出一个字符串,要求该字符串可以组成多少种回文串

思路：回文串左右两边都一样,所以只需要对(n/2)排列组合就可以了,这里取模的话注意有除法,我用的费马小

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
#include<vector>
#include <ctime>
#include<queue>
#include<set>
#include<map>
#include<stack>
#include<cmath>
#define mst(ss,b) memset((ss),(b),sizeof(ss))
#define maxn 0x3f3f3f3f
#define MAX 1000100
///#pragma comment(linker, "/STACK:102400000,102400000")
typedef long long ll;
typedef unsigned long long ull;
#define INF (1ll<<60)-1
#define mod 1000000007
using namespace std;
ll fac[100100];
ll ppow(ll k,ll n) {
    ll c=1;
    while(n) {
        if(n%2) c=(c*k)%mod;
        k=(k*k)%mod;
        n>>=1;
    }
    return c;
}
ll C(ll a,ll b) {
    return (((fac[b]*ppow((fac[a]*fac[b-a])%mod,mod-2)))%mod)%mod;
}
int T;
string s;
ll a[30];
int main(){
    scanf("%d",&T);
    fac[0]=1;
    for(int i=1;i<1010;i++) fac[i]=(fac[i-1]*i)%mod;
    while(T--){
        cin>>s;
        mst(a,0);
        int n=s.size();
        for(int i=0;i<n;i++){
            int x=s[i]-'a';
            a[x+1]++;
        }
        int num=0,sum=0;
        for(int i=1;i<=26;i++){
            if(a[i]%2==0) {
                a[i]/=2;
                continue;
            }
            if(a[i]%2==1) {
                if(num==0) a[i]/=2;
                num++;
            }
        }
        if(num>1) cout<<0<<endl;
        else {
            ll ans=1;
            int L=n/2;
            for(int i=1;i<=26;i++){
                if(a[i]){
                    ll tmp=C(a[i],L);
                    ///ll tmp=CCC(L,a[i]);
                    L-=a[i];
                    ans*=tmp;
                    ans%=mod;
                }
            }
            printf("%I64d\n",ans);
        }
    }
    return 0;
}

India and China Origins

 Time Limit: 2000/2000 MS (Java/Others)   Memory Limit: 65536/65536 K (Java/Others)

问题描述
很久以前，中国和印度之间并没有喜马拉雅山相隔，两国的文化交流很频繁。随着喜马拉雅山海拔逐渐增加，两个地区的交流也越来越少，最终没有了来往。

假设当时的地形和我画的一样，蓝色部分代表海洋，而且当时人们还没有发明轮船。黄色部分代表沙漠，而且沙漠上经常有野鬼散步，所以人们不敢到沙漠中行走。黑色的格子表示山峰，这些山峰都无比高大，所以人无法穿过。白色格子代表平原，人可以在平原上自由行走。人每次可以向相邻的四个格子走动。


此外，我们的考古学家发现还有一些山峰会逐渐形成，通过研究发现，位置在 (x,y) （保证该位置之前没有山峰）的地方在 i 年后出现了山峰。现在给你若干个位置出现山峰的时间，你可以计算出中国和印度之间的联系最早被彻底切断的时间吗？
输入描述
多组测试数据, 第一行为组数T(T≤10)。每组测试数据第一行包含两个数 N,M(1≤N,M≤500), 表示地图的大小。接下来 N 行长度为 M的 01 字符串。0代表白色格子，1 代表山峰。接下来有 Q(1≤Q≤N×M) 行，第 i(1≤i≤Q) 两个整数 (x,y),0≤x<N,0≤y<M 表示在第 i 年 (x,y)出现了一座山峰。
输出描述
对于每组测试数据，输出一个数, 表示两国最早失联的时间。如果最终两国之间还有联系则输出 -1。
输入样例
1
4 6
011010
000010
100001
001000
7
0 3
1 5
1 3
0 0
1 2
2 4
2 1
输出样例
4
Hint


从上图可以看到，两国在第四年彻底失去了联系。

题意：中国和印度需要联通,但是上面有山峰阻挡,山峰随着时间的推移会越来越多,问在哪一个时间两国无法联通

思路：二分时间,然后用并查集去处理0和(n*m+1)是否联通,(1~n*m)是图上的点,显然并查集很好处理连通块的问题

O( n*m*log(n*m) )

代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
#include<vector>
#include <ctime>
#include<queue>
#include<set>
#include<map>
#include<stack>
#include<cmath>
#define mst(ss,b) memset((ss),(b),sizeof(ss))
#define maxn 0x3f3f3f3f
#define MAX 1000100
///#pragma comment(linker, "/STACK:102400000,102400000")
typedef long long ll;
typedef unsigned long long ull;
#define INF (1ll<<60)-1
using namespace std;
int T,n,m,q;
string s[555];
int a[555][555];
int x[555*555],y[555*555];
int xx[4]={-1,0,1,0};
int yy[4]={0,1,0,-1};
int vis[555][555];
int fa[250010];
int find(int x){
    if(x!=fa[x])
        fa[x]=find(fa[x]);
    return fa[x];
}
void Union(int x,int y){
    int xx=find(x);
    int yy=find(y);
    if(xx!=yy) fa[xx]=yy;
}
bool judge(){
    mst(vis,0);
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            vis[i][j]=a[i][j];
        }
    }
    for(int i=0;i<=n*m+1;i++) fa[i]=i;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(vis[i][j]) continue;
            for(int k=0;k<4;k++){
                int X=i+xx[k];
                int Y=j+yy[k];
                if(Y<1 || Y>m) continue;
                if(vis[X][Y]) continue;
                if(X==0) Union(0,(i-1)*m+j);
                else if(X==n+1) Union(n*m+1,(i-1)*m+j);
                else {
                    Union((i-1)*m+j,(X-1)*m+Y);
                }
            }
        }
    }
    if(find(0)==find(n*m+1)) return true;
    return false;
}
bool solve(int k){
    for(int i=1;i<=k;i++) a[x[i]][y[i]]=1;
    int t=0;
    if(judge()) t=1;
    for(int i=1;i<=k;i++) a[x[i]][y[i]]=0;
    if(t) return true;
    return false;
}
int main(){
    scanf("%d",&T);
    while(T--){
        scanf("%d%d",&n,&m);
        mst(a,0);
        for(int i=0;i<n;i++) cin>>s[i];
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(s[i][j]=='1') a[i+1][j+1]=1;
                else a[i+1][j+1]=0;
            }
        }
        scanf("%d",&q);
        for(int i=1;i<=q;i++){
            scanf("%d%d",&x[i],&y[i]);
            x[i]++;
            y[i]++;
        }
        if(solve(q)){
            cout<<-1<<endl;
            continue;
        }
        int l=1,r=q,mid,ans=0;
        while(l<r){
            mid=(l+r)/2;
            if(solve(mid)) l=mid+1;
            else r=mid,ans=mid;
        }
        cout<<ans<<endl;
    }
    return 0;
}

Bomber Man wants to bomb an Array.  

 Time Limit: 4000/2000 MS (Java/Others)   Memory Limit: 65536/65536 K (Java/Others)

问题描述
给一个长度为 N 的一维格子和一些炸弹的位置，请你计算 “最大总破坏指数”。

每个炸弹都有向左和向右的破坏力，如果一个炸弹向左和向右的破坏力分别为 L 和 R,
那么该炸弹将炸毁L+R+1 个格子（左边L个，炸弹所在格子，右边R个）。
破坏指数的计算方式为：所有炸弹炸毁的格子数的乘积。假设第 ii 个炸弹炸毁了 X​i个格子，
那么总破坏指数就是 X1​​ ∗X2 ∗....Xm。

现在告诉你每个炸弹的位置，你需要计算 最大的总破坏指数，注意：每个格子最多只允许被炸一次。
输入描述
多组测试数据，第一行为一个整数 T(T≤11)。
每组测试数据第一行为两个整数 N,M(1≤N≤2000,1≤M≤N)，分别表示格子总数和炸弹总数 。
第二行是 M个互不相同的数表示每个炸弹所在的位置。
输出描述
对于每组测试数据，输出 floor(10^6 * log2(最大破坏指数)) (floor表示向下取整)。
输入样例
2
10 2
0 9
10 3
0 4 8
输出样例
4643856
5169925
Hint
Sample 1 :


Sample 2: 

题意：给出一维长度n,格子上有m个炸弹,要求自己设定炸弹的l,r使所有炸弹爆炸的总乘积最大

思路：看了卿神的思路,哎,赤裸裸的暴力,感觉复杂度就是O(n*m) 常数大一点好像

dp[i][j] 表示第i个炸弹炸到j格子的当前最大总乘积

dp[i][j]=max(dp[i][j],(j-k)*dp[i-1][k])  枚举每i-1个炸弹能炸的长度,其实也就是区间[  a[i-2]+1~a[i-1],  a[i-1]+1~a[i]  ]

这里加一个炸弹m+1  放在n+2  就是方便计算第m个炸弹炸到n+1之前的最大值

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
#include<vector>
#include <ctime>
#include<queue>
#include<set>
#include<map>
#include<stack>
#include<iomanip>
#include<cmath>
#define mst(ss,b) memset((ss),(b),sizeof(ss))
#define maxn 0x3f3f3f3f
#define MAX 1000100
///#pragma comment(linker, "/STACK:102400000,102400000")
typedef long long ll;
typedef unsigned long long ull;
#define INF (1ll<<60)-1
using namespace std;
long double dp[2001][2001];
int n,m;
int a[2001];
int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        mst(dp,0);
        scanf("%d%d",&n,&m);
        for(int i=1;i<=m;i++) {
            scanf("%d",&a[i]);
            a[i]++;
        }
        sort(a+1,a+m+1);
        for(int i=1;i<=a[1];i++) dp[1][i]=1.0;
        a[++m]=n+2;
        for(int i=2;i<=m;i++){
            for(int j=a[i-1]+1;j<=a[i];j++){
                for(int k=a[i-2]+1;k<=a[i-1];k++){
                    dp[i][j]=max(dp[i][j],(j-k)*dp[i-1][k]);
                }
            }
        }
        long double ans=floor(1000000.0*log2(dp[m][n+1]));
        ///cout<<setprecision(0)<<ans<<endl;
        printf("%.0lf\n",ans);

    }
    return 0;
}