2013腾讯编程马拉松初赛第五场（3月25日）

4525 威威猫系列故事——吃鸡腿

Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 65535/32768 K (Java/Others)
Problem Description
　　威威猫不是一只普通的猫，普通的猫喜欢吃鱼，但威威猫最喜欢吃鸡腿。他每天都在不停的吃啊吃，吃了一只又一只鸡腿。现在他遇到了一个难题，如果他的体重太胖那么他的主人就不给他吃鸡腿了，所以他需要你的帮助。
　　威威猫的身体由n个器官构成，由于他的身体很特殊所以他的增长也很特殊（不要问为什么，喜欢吃鸡腿的猫已经够奇怪了）。他的增长有个k1和k2系数，而且每天的增长量和前一天有关，我们假设这n个器官在第i天的数值分别是a(i,1), a(i,2), a(i,3) …… a(i,n)，那么，第i+1天他每个器官的数值就会变成:
　　a(i+1,1) = k1 * a(i,1) + k2 * a(i,2)
　　a(i+1,2) = k1 * a(i,2) + k2 * a(i,3)
　　……
　　a(i+1,n) = k1 * a(i,n) + k2 * a(i,1)
　　威威猫的体重等于他的所有器官的数值之和，并且他还拥有一个特殊的机能，就是会自动检测自己的体重，如果他的体重比K大，那么就会自动停止生长（为了每天都能吃到鸡腿），由于威威猫的特殊身体构造他的体重是可能会变成负数的。
　　现在我给你n个器官的初始数值和他的增长系数k1,k2，请问他几天之后会停止生长，如果他永远无法停止生长那么就输出”inf”。(引号不用输出)
Input
输入数据第一行是一个正整数T，表示有T组测试数据；
每组数据的第一行包含4个数字n,k1,k2,k，代表威威猫有n个器官，他的生长系数是k1,k2，当体重超过k的时候他就停止生长。
接下来的一行是n个数ai，代表威威猫每个器官第一天的数值是多少。
[Technical Specification]
T <= 100
1 <= n <= 10000
-100 <= k1, k2 <= 100
1 <= k <= 10 ^ 18
1 <= ai <= 1000（1 <= i <= n）
Output
对于每组测试数据，请首先输出”Case #X: “，X代表测试用例的编号，然后输出一个数ans，代表ans天之后他会停止生长，如果不会停止就输出inf.
具体可参见sample output。
Sample Input
2
5 1 1 10
1 1 1 1 1
5 1 1 500
1 1 1 1 1
Sample Output
Case #1: 2
Case #2: 7
Source
2013腾讯编程马拉松初赛第五场（3月25日）

#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
using namespace std;
int T,Case=0;
int main(){
    cin>>T;
    while(T--){
        ++Case;
        int n,K1=0,K2=0;
        __int64 sum1=0,sum=0,K;
        scanf("%d%d%d%I64d",&n,&K1,&K2,&K);
        __int64 tmp;
        for(int i=1;i<=n;++i){
            scanf("%I64d",&tmp);
            sum+=tmp;
        }
        sum1=sum;
        printf("Case #%d: ",Case);
        for(int i=0;;++i){
            if(sum1>K){ printf("%d\n",i); break; }
            sum=sum1,sum1=sum*(K1+K2);
            if((sum >0 &&(K1+K2)>0 && sum1 <0)) { printf("%d\n",i+1); break; }
            if(sum<0&&(K1+K2)<0&&sum1<0){ printf("%d\n",i+1); break; }
            if(i>100000) { printf("inf\n"); break; }
        }
    }
    return 0;
}

4526 威威猫系列故事——拼车记

Time Limit: 500/200 MS (Java/Others) Memory Limit: 65535/32768 K (Java/Others)
Total Submission(s): 1381 Accepted Submission(s): 478
Problem Description
　　话说威威猫有一次去参加比赛，虽然学校离比赛地点不太远，但威威猫还是想坐出租车去。大学城的出租车总是比较另类，有“拼车”一说，也就是说，你一个人坐车去，还是一堆人一起，总共需要支付的钱是一样的（每辆出租上除司机外最多坐下4个人）。刚好那天同校的一群Acmer在校门口扎堆了，大家果断决定拼车去赛场。
　　问题来了，一辆又一辆的出租车经过，但里面要么坐满了乘客，要么只剩下一两个座位，众Acmer都觉得坐上去太亏了，威威猫也是这么想的。
　　假设N名Acmer准备拼车，此时为0时刻，从校门到目的地需要支付给出租车师傅D元（按车次算，不管里面坐了多少Acmer），假如S分钟后恰能赶上比赛，那么S分钟后经过校门口的出租车自然可以忽略不计了。现在给出在这S分钟当中经过校门的所有的K辆出租车先后到达校门口的时间Ti 及里面剩余的座位Zi (1 <= Zi <= 4)，Acmer可以选择上车几个人（不能超过），当然，也可以选择上0个人，那就是不坐这辆车。
　　俗话说，时间就是金钱，这里威威猫把每个Acmer在校门等待出租车的分钟数等同于花了相同多的钱（例如威威猫等待了20分钟，那相当于他额外花了20元钱）。
　　在保证所有Acmer都能在比赛开始前到达比赛地点的情况下，聪明的你能计算出他们最少需要花多少元钱么？
Input
输入第一行为T，表示有T组测试数据。每组数据以四个整数N , K , D , S开始，具体含义参见题目描述，接着K行，表示第i辆出租车在第Ti分钟到达校门，其空余的座位数为Zi（时间按照先后顺序）。
[Technical Specification]
T <= 50
N <= 100
K <= 100
D <= 100
S <= 100
1 <= Zi <= 4
1<= T(i) <= T(i+1) <= S
Output
对于每组测试数据，输出占一行，如果他们所有人能在比赛前到达比赛地点，则输出一个整数，代表他们最少需要花的钱（单位：元），否则请输出“impossible”。
Sample Input
1
2 2 10 5
1 1
2 2
Sample Output
14
Source
2013腾讯编程马拉松初赛第五场（3月25日）

//这是个背包问题
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cstdio>
using namespace std;
#define INF 0x3f3f3f3f
const int MAXN = 110;
int n,K,D,s,dp[MAXN][MAXN];
int cas,t[MAXN],z[MAXN];
int main(){
    scanf("%d",&cas);
    while(cas--){
        scanf("%d%d%d%d",&n,&K,&D,&s);
        t[0]=0;
        for(int i=1;i<=K;++i) scanf("%d%d",&t[i],&z[i]);//K 个车辆的信息
        for(int i=0;i<MAXN;++i) dp[i][0]=0;
        for(int i=0;i<MAXN;++i)
            for(int j=1;j<MAXN;++j) dp[i][j]=INF;
        for(int i=1;i<=K;++i)
            for(int j=1;j<=n;++j){
                dp[i][j]=dp[i-1][j];
                for(int k=1;k<=z[i];++k)
                    dp[i][j]=min(dp[i][j],dp[i-1][j-k]+t[i]*k+D);
            }
        if(dp[K][n]==INF) printf("impossible\n");
        else printf("%d\n",dp[K][n]);
    }
    return 0;
}

4527 小明系列故事——玩转十滴水

Time Limit: 500/200 MS (Java/Others) Memory Limit: 65535/32768 K (Java/Others)
Total Submission(s): 774 Accepted Submission(s): 314
Problem Description
　　小明最近喜欢上了一个名为十滴水的游戏。
　　
　　游戏是在一个6*6的方格内进行的，每个格子上有一滴水或者没有水滴。水滴分为四个等级1~4。初始时你有十滴水，通过把水加入格子内的水滴，会让水滴升1级。你也可以把水放到空格子内，这样会在这个格子里面产生一个1级的水滴。当水滴等级大于4时则会爆裂为四个小水滴，并向四个方向飞溅。每个飞溅的小水滴碰到其他水滴后会融入其中，使其升一级或者爆裂，以此类推。飞溅的小水滴互不干扰，运动速度相等(1秒可以移动一个格子的距离)。水滴爆裂后就消失掉了。
　　
Input
题目包含多组测试用例；
对于每组数据，首先是6行，每行有6个整数数字，每个数字的范围为0~4；当数字为0时，表示空格子，当数字为1~4时，表示1~4级的水滴；
然后第七行是一个整数m，表示有m个操作；接下来是m行，每行有两个整数x, y ，表示在(x,y)放入一滴水。
特别说明：每次都是在全部的水滴静止后才进行下一次操作，也就是说只有在方格内没有任何飞溅的小水滴时才能放入一滴水。
[Technical Specification]
1 <= m <= 10
1 <= x, y <= 6
Output
对于每组测试数据，请输出m个操作之后6*6方格内水滴的样子，每组数据的输出后面跟着一个空行。
Sample Input
0 0 0 4 0 4
0 0 0 0 0 0
1 0 0 4 0 4
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 1 0 0
1
1 6
0 0 0 4 0 4
0 2 0 4 0 4
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
1
1 6
2 2 0 2 0 3
3 3 0 1 3 1
2 2 2 4 0 4
2 4 4 2 2 3
3 3 2 4 0 1
1 3 4 3 0 1
6
5 3
5 3
3 3
3 2
2 1
6 3
Sample Output
0 0 0 0 0 0
0 0 0 0 0 0
2 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 2 0 0
0 0 0 0 0 0
0 3 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 4 0 2 0 3
0 0 0 4 3 2
0 0 0 0 0 0
0 0 0 0 4 4
0 0 0 0 0 4
4 0 0 0 0 3
Hint
第一组数据：
(1,6)爆裂，然后在第二秒(1,4)(2,6)爆裂，在第四秒，两滴水同时到达(3,4), (3,4)变成了6，爆裂，然后在第七秒(3,1)(6,4)变成了2。
Source
2013腾讯编程马拉松初赛第五场（3月25日）

//宽搜  深搜比较难处理同时性
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
using namespace std;
int bo[7][7],m,flag;
struct Node{ int x,y,f; }s,t;
int dx[]={0,0,1,-1};
int dy[]={1,-1,0,0};
queue<Node> q,qq;

inline bool Judge(int x,int y){ return x>=1&&x<=6&&y>=1&&y<=6; }

void Get_ID(int x,int y){
    bo[x][y]=0;
    for(int i=0;i<4;++i){
        s.x=x+dx[i],s.y=y+dy[i],s.f=i;
        if(Judge(s.x,s.y)) qq.push(s);
    }
}

void BaoZha(int x,int y){
    while(!q.empty()) q.pop();
    while(!qq.empty()) qq.pop();
    bo[x][y]=0;
    for(int i=0;i<4;++i){
        s.x=x+dx[i],s.y=y+dy[i],s.f=i;
        if(Judge(s.x,s.y)) q.push(s);
    }
    while(1){
        flag=0;
        while(!q.empty()){
            flag=1;
            s=q.front();q.pop();
            if(bo[s.x][s.y]==0){
                t.x=s.x+dx[s.f],t.y=s.y+dy[s.f],t.f=s.f;
                if(Judge(t.x,t.y)) qq.push(t);
            }
            if(bo[s.x][s.y]>0) ++bo[s.x][s.y];
        }
        for(int i=1;i<=6;++i)
            for(int j=1;j<=6;++j)
                if(bo[i][j]>4) flag=1,Get_ID(i,j);
        swap(q,qq);
        if(!flag) break;
    }
}

int main(){
    while(~scanf("%d",&bo[1][1])){
        for(int i=1;i<=6;++i)
            for(int j=1;j<=6;++j)
                if(i==1&&j==1) continue;
                else scanf("%d",&bo[i][j]);
        scanf("%d",&m);
        for(int x,y,i=1;i<=m;++i){
            scanf("%d %d",&x,&y);
            if((++bo[x][y])>4) BaoZha(x,y);
        }
        for(int i=1;i<=6;++i){
            for(int j=1;j<=6;++j)
                if(j==1) printf("%d",bo[i][j]);
                else printf(" %d",bo[i][j]);
            printf("\n");
        }
        printf("\n");
    }
    return 0;
} 

4528 小明系列故事——捉迷藏

Time Limit: 500/200 MS (Java/Others) Memory Limit: 65535/32768 K (Java/Others)
Total Submission(s): 1815 Accepted Submission(s): 542
Problem Description
　　小明的妈妈生了三个孩子，老大叫大明， 老二叫二明， 老三…， 老三自然就叫小明了。
　　一天，小明的妈妈带小明兄弟三人去公园玩耍，公园里面树木很多，有很多地方可以藏身， 于是他们决定玩捉迷藏。经过几轮的猜拳后，第一轮是小明来找其他两个人，游戏规则很简单：
　　只要小明可以在规定的时间内找到他们就算小明获胜，并且被发现的两个人猜拳决定谁在下一轮负责找人；如果在规定的时间内只找到一个人，那么没有被发现的人获胜，被找到的人下一轮负责找人；如果在规定的时间内一个人都没有找到，则小明失败了，下一轮还是他来找人。现在小明想知道，在规定时间内，自己是否可以找到所有的人，现在他想请你来帮忙计算一下。
　　为了简单起见，把公园看成是n行m列的矩阵，其中’S’表示小明，’D’表示大名，’E’表示二明，’X’表示障碍物，’.’表示通路。这里，我们把发现定义为，可以直接看到对方， 也就是说两个人在同一行或者同一列，并且中间没有障碍物或者没有其他人就可以看到对方。并且假设，大明，二明藏好以后就不会再改变位置，小明每个单位时间可以从当前的位置走到相邻的四个位置之一，并且不会走出公园。
Input
测试数据第一行是一个正整数T，表示有T组测试数据。
每一组测试数据首先是三个正整数n,m,t，分别表示行数、列数和规定的时间，接下来n行，每行m个上述的字符，并且保证有且只有一个’S’，一个’E’，一个’D’。
[Technical Specification]
T < 200
3 <= n, m <= 100
0 <= t <= 100
Output
每组先输出一行Case c:(c表示当前的组数，从1开始计数)；
接下来一行，如果小明可以在规定时间内找到所有的人，则输出最少需要的时间，否则输出-1。
Sample Input
3
5 6 3
XXD…
….E.
….X.
….S.
……
5 6 3
XDX…
….E.
……
….S.
……
5 6 8
XXDX..
.XEX..
……
….S.
……
Sample Output
Case 1:
-1
Case 2:
3
Case 3:
-1
Source
2013腾讯编程马拉松初赛第五场（3月25日）

//搜索
#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
using namespace std;

#define MAXN 105
char map[MAXN][MAXN];
int vis[MAXN][MAXN][2][2];
struct Node{
    int x,y,step,flag1,flag2;
    Node (int x=0,int y=0,int step=0,int flag1=0,int flag2=0):
        x(x),y(y),step(step),flag1(flag1),flag2(flag2) { }
}now,nex;
queue<Node> q,qq;
int T,n,m,t;

inline void read(int &x){
    x=0; int f=1; char c=getchar();
    while(c>'9'||c<'0'){ if(c=='-') f=-1; c=getchar(); }
    while(c>='0'&&c<='9'){ x=x*10+c-'0'; c=getchar(); } x*=f;
}

int dx[]={0,0,1,-1};
int dy[]={1,-1,0,0};

inline bool Judge(int x,int y,int f1,int f2){
    return x>=1&&x<=n&&y<=m&&y>=1&&map[x][y]!='E'&&map[x][y]!='D'
        &&map[x][y]!='X'&&vis[x][y][f1][f2]==0;
}

void solve(int sx,int sy){
    q.push(Node(sx,sy,0,0,0));
    vis[sx][sy][0][0]=1;
    while(!q.empty()){
        now=q.front();q.pop();
        int x=now.x,y=now.y,step=now.step;
        for(int i=x+1;i<=n;++i)
            if(map[i][y]=='E') { now.flag2=1;break;}
            else if(map[i][y]=='D') { now.flag1=1;break;}
            else if(map[i][y]=='X') break;
        for(int i=x-1;i>=1;--i)
            if(map[i][y]=='E') { now.flag2=1;break;}
            else if(map[i][y]=='D') { now.flag1=1;break;}
            else if(map[i][y]=='X') break;
        for(int i=y+1;i<=m;++i)
            if(map[x][i]=='E') { now.flag2=1;break;}
            else if(map[x][i]=='D') { now.flag1=1;break;}
            else if(map[x][i]=='X') break;
        for(int i=y-1;i>=1;--i)
            if(map[x][i]=='E') { now.flag2=1;break;}
            else if(map[x][i]=='D') { now.flag1=1;break;}
            else if(map[x][i]=='X') break;

        if(now.flag1==1&&now.flag2==1){ printf("\n%d\n",now.step); return ; }

        for(int i=0;i<4;++i){
            nex=now;
            nex.x=now.x+dx[i] , nex.y=now.y+dy[i] , nex.step=now.step+1;
            if(nex.step>t) break;
            if(Judge(nex.x,nex.y,nex.flag1,nex.flag2)) {
                vis[nex.x][nex.y][nex.flag1][nex.flag2]=1;
                q.push(nex);
            }
        }
    }
    printf("\n%d\n",-1); return ;
}

int main(){
    read(T);
    int Case=0;
    while(T--){
        read(n),read(m),read(t);
        int sx,sy;
        while(!q.empty()) q.pop();
        memset(map,'0',sizeof map );
        memset(vis,0,sizeof vis );
        for(int i=1;i<=n;++i) scanf("%s",map[i]+1);
        for(int i=1;i<=n;++i)
            for(int j=1;j<=m;++j)
                if(map[i][j]=='S') sx=i,sy=j;
        printf("Case %d:",++Case);
        solve(sx,sy);
    }
    return 0;
}

4529 郑厂长系列故事——N骑士问题

Time Limit: 6000/3000 MS (Java/Others) Memory Limit: 65535/32768 K (Java/Others)
Total Submission(s): 591 Accepted Submission(s): 289
Problem Description
　　郑厂长不是正厂长
　　也不是副厂长
　　他根本就不是厂长
　　还是那个腾讯公司的码农
　　一个业余时间喜欢下棋的码农
　　
　　最近，郑厂长对八皇后问题很感兴趣，拿着国际象棋研究了好几天，终于研究透了。兴奋之余，坐在棋盘前的他又开始无聊了。无意间，他看见眼前的棋盘上只摆了八个皇后，感觉空荡荡的，恰好又发现身边还有几个骑士，于是，他想把这些骑士也摆到棋盘上去，当然棋盘上的一个位置只能放一个棋子。因为受八皇后问题的影响，他希望自己把这些骑士摆上去之后，也要满足每2个骑士之间不能相互攻击。
　　现在郑厂长想知道共有多少种摆法，你能帮助他吗？
骑士的下法：
　　每步棋先横走或直走一格，然后再往外斜走一格；或者先斜走一格，最后再往外横走或竖走一格（即走“日”字）。可以越子，没有”中国象棋”的”蹩马腿”限制。
Input
输入第一行为一个整数T(1<=T<=8)，表示有T组测试数据；
每组数据首先是一个整数N(1<=n<=10)，表示要摆N个骑士上去；
接下来是一个8*8的矩阵来描述一个棋盘，’.’表示这个位置是空的，’*’表示这个位置上已经放了皇后了；
数据中的初始棋盘保证是一个合法的八皇后摆法。
Output
对每组数据，请在一行内输出一个整数，表示合法的方案数。
Sample Input
2
1
*…….
….*…
…….*
…..*..
..*…..
……*.
.*……
…*….
2
*…….
….*…
…….*
…..*..
..*…..
……*.
.*……
…*….
Sample Output
56
1409
Source
2013腾讯编程马拉松初赛第五场（3月25日）

//状压DP
#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
#define MAXN 1<<8
int n,dp[2][20][MAXN][MAXN],g[MAXN],cnt[MAXN],mt1[MAXN][MAXN],mt2[MAXN][MAXN];
/*
状态压缩DP，用dp[i][j][p][q]表示第i-1行状态为p,第i-2行状态为q，前i行放j个
骑士时的合法方案数
，设前i-1行放j个骑士，第i行放cnt[i]个骑士，
则有递推方程dp[i][cnt[i]+j][p][q]+=dp[i-1][j][p][q]，
初始化dp[i][0][0][0]=1。因为dp数组略大，所以可用滚动数组来降低空间复杂度 
*/

void init(){
    for(int i=0;i<MAXN;++i){
        for(int j=0;j<8;++j)
            if(i&(1<<j)) cnt[i]++;
        for(int j=0;j<MAXN;++j){
            if(((i>>2)&j)||((j>>2)&i)) mt1[i][j]=1;
            //i状态会不会以“横日”走法影响j状态 
            if(((i>>1)&j)||((j>>1)&i)) mt2[i][j]=1;
            //i状态会不会以“竖日”走法影响j状态 
        }
    }
}

void solve(){
    int cur=0;
    memset(dp,0,sizeof dp );
    dp[0][0][0][0]=1;
    for(int i=0;i<8;++i){
        cur^=1;
        for(int j=0;j<=n;++j)
            for(int p=0;p<MAXN;++p)
                for(int q=0;q<MAXN;++q){
                     if(dp[cur^1][j][p][q]==0) continue;
                     for(int z=0;z<MAXN;++z){
                         if((z&g[i])!=z) continue;
                         if(cnt[z]+j>n) continue;
                         if(i>=1&&mt1[q][z]) continue;
                         if(i>=2&&mt2[p][z]) continue;
                         dp[cur][cnt[z]+j][q][z]+=dp[cur^1][j][p][q];
                     }
                }
        memset(dp[cur^1],0,sizeof dp[cur^1] );
    }
    int ans=0;
    for(int i=0;i<MAXN;++i)
        for(int j=0;j<MAXN;++j)
            ans+=dp[cur][n][i][j];
    printf("%d\n",ans);
} 

int main(){
    int t; char temp[10];
    init();
    scanf("%d",&t);
    while(t--){
        memset(g,0,sizeof g );
        scanf("%d",&n);
        for(int i=0;i<8;++i){
            scanf("%s",temp);
            for(int j=0;j<8;++j){
                g[j]<<=1;
                if(temp[j]=='.') g[j]|=1;
            }
        }
        solve();
    }
    return 0;
}