20130719CF比赛141div2

额。。。。有点坑：

A. Flipping Game

第一题的意思是说给你n个数，这些数是由0和1组成的，然后你可以采用一次操作：选择i和j之间的数x，把它变成1-x，也就是把0变成1，把1变成0.然后求在一次操作之后，最大的可能的1的个数有多少。不说话，直接爆搜走起：

#include 
#include 
#include 
#include 
#include 

B. Hungry Sequence

special judge...

第一次直接没仔细读题，直接写了一个sp[i]= sp[i-1]+1(sp[i]%sp[i-1]!=0).果断WA了。后来仔细看，是i < j必须满足。n到2n输出...

#include 
#include 
#include 
#include 
#include 

C. Magic Five

这道题应该用快速幂来求，若是对于项数很多的等比数列，因为求和公式中包含了除号，所以不能直接取mod，应该进行快速幂的转化

例如求sum=2^1+2^2+2^3+2^4+2^5+2^6+2^7 .......

共有n项

这是的公式就为 若n%2==0     T(n)=T(n/2)+T(n/2)*2^(n/2);

               若n%2==1     T(n)=T(n/2)+T(n/2)*2^(n/2)+ 2^n;

对于此题来讲 先把所给的循环位上的和求出来，做为基底，然后利用快速幂上面的公式求解接可以了

因为比如说12507 12507  和为2^2+2^3+ 2^2*2^len+2^3*2^len == (2^2+2^3)+(2^2+2^3)*len;这样的话就可以直接把一个序列的和all当作基底来处理了...

（不过这个公式没有找到证明啊）：

#include
#include
#include
#include
#include
#include
using namespace std;
const __int64 mod=1000000007;
__int64 all;
int Pow(__int64 n,int num)      //快速幂求num^n
{
    if(n==0)
        return 1;
    if(n==1)
        return num;
    __int64
    tmp=Pow(n/2,num)%mod;
    tmp=tmp*tmp%mod;
    if(n%2==1)
        tmp=tmp*num%mod;
    return (int)tmp;
}
__int64 len;
int q;
int fun(int n)               
{
    if(n==1)
        return all;
    __int64 tmp=fun(n/2);
    
    tmp = (tmp+tmp*Pow(n/2,q))%mod;
    
    if(n%2==1)
    
        tmp = ( tmp+Pow((n-1)*len,2)*all%mod )%mod;
        
    return (int)tmp;

}

char a[2000000];
int main()
{
    int n,ans;
    while(scanf("%s",a)!=EOF)
    {
        cin>>n;
        ans=0;
        len=strlen(a);
        q=Pow(len,2)%mod;
        all=0;
        for(int i=0; i

D. Block Tower

special judge。先把所有能建房子的地方全部建成绿色，因为红色要以蓝色为边才能建起来。所以我们先把能建蓝色的全部建成蓝色。然后在一蓝色为点DFS走入，向上下左右走，能联通的地方在回来的时候改建红色。

#include
#include
#include
#include
#include
#include
using namespace std;
struct xl
{
    int x,y;
    char z;
} q[5000005];
char a[505][505];
int vis[505][505];
int dx[4]= {1,0,-1,0};
int dy[4]= {0,-1,0,1};
int n,m,i,j,len,k;
void dfs(int ans,int num)//暴搜
{
    int i;
    len++;
    vis[ans][num]=1;
    for(i=0; i<4; i++)
    {
        if(a[ans+dx[i]][num+dy[i]]=='.'&&vis[ans+dx[i]][num+dy[i]]==0)
        {
            dfs(ans+dx[i],num+dy[i]);
        }
    }
    if(len > 1)//判断是否建红色建筑
    {
        q[k].x=ans;
        q[k].y=num;
        q[k].z='D';
        k++;
        q[k].x=ans;
        q[k].y=num;
        q[k].z='R';
        k++;
        a[ans][num]='R';
    }
    len--;
}
int main()
{
    char c;
    scanf("%d%d",&n,&m);
    memset(vis,0,sizeof(vis));
    for(i=1; i<=n; ++i)
    {
        c=getchar();
        for(j=1; j<=m; ++j)
            scanf("%c",&a[i][j]);
    }
    k = 0;
    for(i = 1; i <= n; ++i)
    {
        for(j = 1; j <= m; ++j)
        {
            if(a[i][j]=='.')//建蓝色建筑
            {
                q[k].x=i;
                q[k].y=j;
                q[k].z='B';
                k++;
            }
        }
    }
    for(i=1; i<=n; ++i)
    {
        for(j=1; j<=m; ++j)
        {
            if(vis[i][j]==0&&a[i][j]=='.')
            {
                len=0;
                dfs(i,j);
            }
        }
    }
    printf("%d\n",k);
    for(i=0; i

E. Axis Walking

听闻是神DP，这。转来别人的解释：

给你一串数，从0开始，每次选某个数，然后向前移动ai长度，这里有些位置不能走，最后问你走到总长度的路有多少条。

小结：很裸的状压dp，不过得用sum数组优化下。

dp[i]=sum{dp[i^(1<

#include
#include
#define N 1000000007
#define maxn 1<<25
using namespace std;
int n,k;
int a[25],b[3],dp[maxn],sum[maxn];
int DP()
{
    dp[0]=1;//只能从0开始
    for(int i=1;i<(1<N)//这里没用%
                dp[i]-=N;
            }
        }
    }
    return dp[(1<