HDU 5560 5561 5562 5563 (Bestcoder#77 div2 A B C D)

A so easy
求一个集合所有子集元素的异或；
分析可以发现 一个有N个元素的集合，每个元素出现的次数是2^(N-1); 对于异或，任意一个数和自己偶数次异或的答案都是0；任意个0异或也是0；所以当N>1时，答案为0，当N==1时，答案为a[0]；

代码

#include <iostream>
#include <stdio.h>
using namespace std;

int main()
{
    int n,x;
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for(int i=0;i<n;i++)
            scanf("%d",&x);
        if(n==1)
            printf("%d\n",x);

        else
            printf("0\n");
    }
    return 0;
}

B xiaoxin juju needs help

很明确的是：
1.如果字母个数为奇数的超过两个直接输出0；
2.如果可以构成回文，只需考虑对称的一半。
例： aaaabbccccdddd。
它的一半是 aabccdd
两种想法：
一、
先把A(7,7)算出来，再去除重复的情况。
设字符串长度为n，出现过的每个字母的个数为cnt[i];
那么答案就是 n! /cnt[0]! /cnt[1]! … /cnt[i]! % mod (i<25)；
对于 (a/b) % mod ，需要用转换成 （a * k ) % mod ( k=1/b );
由费马小定理：b^(p-1) mod p=1; ( p 为素数 )
所以 b^(p-2)*a mod p= 1;
b^(p-2) mod p =1/b;
所以可以用 b^(p-2) 代 1/b;
逆元相关博客推荐：

http://blog.csdn.net/acdreamers/article/details/8220787

AC代码：

#include <stdio.h>
#include <string.h>
#include <string>
using namespace std;
#define ll long long
const int M=1000000007;
char s[1111];
int cnt[30];
ll f[555];
ll pow_mod(ll a,ll  n) //快速pow ( log(n) )
{
    ll t = 1;
    while(n)
    {
        if(n & 1) t = t*a %M;
        a = a*a%M;
        n >>= 1;
    }
    return t;
}

int main()
{
    f[0]=1;
    for(int i=1;i<=500;i++)  //把 fact 预先处理出来节省时间，当然你也可以打表
        f[i]=f[i-1]*i%M;
    int t;
    scanf("%d",&t);
    while(t--)
    {
        memset(cnt,0,sizeof(cnt));
        scanf("%s",s);
        int len=strlen(s);
        for(int i=0;i<len;i++)
            cnt[s[i]-'a']++;
        int c=0;
        for(int i=0;i<26;i++)
        {
            c += cnt[i]&1;
            cnt[i]/=2;
        }
        if(c>1)
        {
            printf("0\n");
            continue;
        }
        ll ans=f[len/2];
        for(int i=0;i<26;i++)
            if(cnt[i])
                ans = ans * pow_mod(f[cnt[i]],M-2) % M;  //关键语句
        printf("%I64d\n",ans);
    }
    return 0;
}

二、组合数，对于每个字母，直接选，比如上面的例子，就是 C(7,2)*C(5,1)*C(4,2)*C(2,2)，相当于在 n个位置上为每种字母选一个座位。

AC代码：

#include <cstdio>
#include <cstring>
using namespace std;
#define mod 1000000007

int a[33];
char s[1111];
long long c[1111][1111];

int main () {
    memset (c, 0, sizeof c);
    c[0][0] = 1;
    for (int i = 1; i <= 1000; i++) c[i][0] = 1;
    for (int i = 1; i <= 1000; i++)
        for (int j = 1; j <= i; j++)
            c[i][j] = (c[i-1][j]+c[i-1][j-1]) % mod;
    int t;
    scanf ("%d", &t);
    while (t--) {
        scanf ("%s", s);
        memset (a, 0, sizeof a);
        int l = strlen (s);
        for (int i = 0; i < l; i++) {
            a[s[i]-'a']++;
        }
        int cnt = 0;
        int sum = 0;
        for (int i = 0; i < 26; i++) {
            if (a[i]&1)
                cnt++;
            a[i] /= 2;
            sum += a[i];
        }
        if (cnt > 1) {
            printf ("0\n");
            continue;
        }

        long long ans = 1;
        for (int i = 0; i < 26; i++) {
            ans = ans *c[sum][a[i]] % mod;
            sum -= a[i];
        }
        printf("%I64d\n",ans);
    }
    return 0;
}

C 两种方法，bfs+二分，或者利用并查集判断是否联通，首先把所有的山峰都加到图中，然后逆序处理每个操作： 对某次操作，在图中删除该位置的山峰，然后判断两个点是否联通，一旦联通就得到了结果。 这里需要对China和India分别新建一个对应的节点。
bfs+二分比较直接。二分查询q个query，时间复杂度为 log(n) * m * bfs的复杂度。
对于一个query，判断从第0行能否到第n-1行.
注意输入0和-1两种答案的情况

#include <iostream>
#include <queue>
#include <string.h>
#include <stdio.h>
using namespace std;
struct node
{
    int x,y;
}Q[250005],cur,Next;
int n,m,s,a[505][505];
int vis[505][505];
int dir[4][2]={{0, 1}, {0, -1}, {1, 0}, {-1, 0}};

void init(int k)
{
    memset(vis,0,sizeof(vis));
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++)
            if(a[i][j]==1)
                vis[i][j]=1;
    for(int i=1;i<=k;i++)
        vis[Q[i].x][Q[i].y]=1;
}

int BFS(int k)
{
    init(k);
    for(int i=0;i<m;i++)
    {
        if(!vis[0][i])
        {
            queue<node>q;
            cur.x=0;
            cur.y=i;
            q.push(cur);
            vis[0][i]=1;
            while(!q.empty())
            {
                cur=q.front();
                q.pop();
                for(int j=0;j<4;j++)
                {
                    Next.x=cur.x+dir[j][0];
                    Next.y=cur.y+dir[j][1];
                    if(Next.x<0 || Next.x>=n ||Next.y<0 || Next.y>=m || vis[Next.x][Next.y] )
                        continue;
                    if(Next.x == n-1) return 1;
                    vis[Next.x][Next.y]=1;
                    q.push(Next);
                }
            }
        }
    }
    return 0;
}


int main () {
    int t;
    scanf ("%d", &t);
    while (t--) {
        scanf ("%d%d", &n, &m);
        char tmp[555];
        for(int i=0;i<n;i++)
        {
            scanf("%s",tmp);
            for(int j=0;j<m;j++)
                a[i][j]=tmp[j]-'0';
        }
        scanf ("%d", &s);
        for (int i = 1; i <= s; i++) {
            scanf ("%d%d", &Q[i].x, &Q[i].y);
        }
        if (!BFS (0)) {
            printf ("0\n");
            continue;
        }
        int l = 1, r = s;
        while (l<r) {
            int mid = (l+r)>>1;
            if (BFS (mid))
                l = mid+1;
            else r = mid;
        }
        if (!BFS (l))
            printf ("%d\n", l);
        else
            printf ("-1\n");
    }
    return 0;
}

D
dp[i]表示 前i个格子的最大爆炸数。
最后答案要等于 1e6 * log2(X) ( 注意到 log2(x1*x2*x3*··· )= log2(x1)+log2(x2)+log2(x3)+····;)
最主要的是要明确一个性质：
一个炸弹的爆炸范围不能超过另外一个炸弹，也就是说炸弹a[i]，炸不到a[i+1]之后和a[i-1]之前的格子。

dp[i]=max{ dp[i] , dp[j] + log2( i - j)} ；
可以这么想：
首先保证 i，j之间只有一个炸弹。
那么对于[j,i]之间的这些格子，是由前面的炸弹炸掉，还是由后面的炸弹炸掉呢？枚举所有情况，最后必定可以得出答案

#include <iostream>
#include <cmath>
#include <stdio.h>
#include <string.h>
using namespace std;
#define maxn 2005
double lg2[maxn];
int a[maxn];
double dp[maxn];
int main()
{
    for(int i=0;i<=2000;i++)
        lg2[i]=log2(i*1.0);
    int n,m,t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        memset(a,0,sizeof(a));
        memset(dp,0,sizeof(dp));
        int x;
        for(int i=0;i<m;i++)
        {
            scanf("%d",&x);
            a[++x]=1;
        }
        for(int i=2;i<=n;i++) 
            a[i]+=a[i-1];
        for(int i=1;i<=n;i++)  
            for(int j=0;j<i;j++)  //注意这里要从0开始，因为a[0]=0；
                if(a[i]==a[j]+1)
                    dp[i]=max(dp[i],dp[j]+lg2[i-j]);

        printf("%.0lf\n",floor(dp[n]*1e6));
    }
    return 0;
}