2015_8

 c 统计有几个cool单词，cool的定义就是至少两个字母，每个字母出现的次数都不同。

 

#include<cstdio>
#include<cstring>
#include<set>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
set<int> s;
char a[32];
int b[32];
int test(){
    mt(b,0);
    for(int i=0;a[i];i++){
        b[a[i]-'a']++;
    }
    s.clear();
    int c=0;
    for(int i=0;i<26;i++){
        if(b[i]){
            c++;
            s.insert(b[i]);
        }
    }
    return s.size()==c&&c>1;
}
int main(){
    int n,cas=1;
    while(~scanf("%d",&n)){
        int ans=0;
        while(n--){
            scanf("%s",a);
            ans+=test();
        }
        printf("Case %d: %d\n",cas++,ans);
    }
    return 0;
}

 

 

 d 有向图，两个人从1走到n，问花费之和最小。一条边第一次走花费是d，第二次走花费是d+a。

最小费用最大流 ，两个人相当于流量2，原来一条边变为两条，流量都为1，费用一个d，一个d+a，源点连1，流量2，费用0，n连汇点，流量2，费用0.

 

#include<cstdio>
#include<cstring>
#include<queue>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
const int inf=0x3f3f3f3f;
class MaxFlowMinCost { ///最小费用最大流 o(ME)
    typedef int typef;///流量的类型
    typedef int typec;///费用的类型
    static const int ME=10010;///边的个数
    static const int MV=510;///点的个数
    queue<int> q;
    int cur[MV],pre[MV];
    bool used[MV],sign[MV];
    typef flow;
    typec cost,dist[MV];
    bool spfa(int s,int t) {
        mt(used,0);
        mt(sign,0);
        mt(dist,0);
        used[s]=sign[s]=true;
        while(!q.empty()) q.pop();
        q.push(s);
        while(!q.empty()) {
            int u=q.front();
            q.pop();
            used[u]=false;
            for(int i=g.head[u]; ~i; i=g.e[i].next) {
                if(g.e[i].flow<1) continue;
                int v=g.e[i].v;
                typec c=g.e[i].cost;
                if(!sign[v]||dist[v]>dist[u]+c) {
                    dist[v]=dist[u]+c;
                    sign[v]=true;
                    pre[v]=u;
                    cur[v]=i;
                    if(used[v]) continue;
                    used[v]=true;
                    q.push(v);
                }
            }
        }
        return sign[t];
    }
    struct G {
        struct E {
            int v,next;
            typef flow;
            typec cost;
        } e[ME];
        int le,head[MV];
        void init() {
            le=0;
            mt(head,-1);
        }
        void add(int u,int v,typef flow,typec cost) {
            e[le].v=v;
            e[le].flow=flow;
            e[le].cost=cost;
            e[le].next=head[u];
            head[u]=le++;
        }
    } g;
public:
    void init() {
        g.init();
    }
    void add(int u,int v,typef flow,typec cost) {
        g.add(u,v,flow,cost);
        g.add(v,u,0,-cost);
    }
    void solve(int s,int t) {
        flow=cost=0;
        while(spfa(s,t)) {
            int temp=t;
            typef now=inf;
            while(temp!=s) {
                now=min(now,g.e[cur[temp]].flow);
                temp=pre[temp];
            }
            flow+=now;
            temp=t;
            while(temp!=s) {
                int id=cur[temp];
                cost+=now*g.e[id].cost;
                g.e[id].flow-=now;
                g.e[id^1].flow+=now;
                temp=pre[temp];
            }
        }
    }
    typef getflow() {
        return flow;
    }
    typec getcost() {
        return cost;
    }
}g;
int main(){
    int n,m,u,v,d,a,cas=1;
    while(~scanf("%d%d",&n,&m)){
        g.init();
        while(m--){
            scanf("%d%d%d%d",&u,&v,&d,&a);
            g.add(u,v,1,d);
            g.add(u,v,1,d+a);
        }
        int s=0,t=n+1;
        g.add(s,1,2,0);
        g.add(n,t,2,0);
        g.solve(s,t);
        printf("Case %d: %d\n",cas++,g.getcost());
    }
    return 0;
}

 

 

e 计算led灯的花费，根据输入算时间差乘上这段时间内比分所需的led灯数量，模拟一下

 

#include<cstdio>
#include<cstring>
const int M=16;
char a[M],b[M];
char s[]="START";
char e[]="END";
int get_val(char a,char b){
    return (a-'0')*10+(b-'0');
}
int get_time(){
    return get_val(b[0],b[1])*3600+get_val(b[3],b[4])*60+get_val(b[6],b[7]);
}
int c[]={6,2,5,5,4,5,6,3,7,6};
int get_cost(int x){
    if(!x) return 6;
    int res=0;
    while(x){
        res+=c[x%10];
        x/=10;
    }
    return res;
}
int main(){
    int x,pre,now,ans,home,guest,cas=1;
    while(~scanf("%s%s",a,b)){
        pre=now;
        now=get_time();
        if(!strcmp(a,s)){
            ans=home=guest=0;
            continue;
        }
        ans+=(get_cost(home)+get_cost(guest))*(now-pre);
        if(!strcmp(a,e)){
            printf("Case %d: %d\n",cas++,ans);
            continue;
        }
        scanf("%s%d",a,&x);
        if(a[0]=='h'){
            home+=x;
        }
        else{
            guest+=x;
        }
    }
    return 0;
}

 

 h 机器人有3种操作，左转右转前进一步，LRF，如果是？则可能是三种中任意一种，问操作完后x坐标和y坐标可能达到的最大值最小值分别是多少。

dp[i][j][k] 表示第i个操作后，求j方向，当前在k方向的最值。 0123表示东北西南。j=0求x最大值，j=1求y最大值，j=2求x最小值，j=3求y最小值。

k是指当前方向。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int inf=0x3f3f3f3f;
const int M=1024;
int dp[M][4][4];
char a[M];
int turn_left(int x){
    return (x+1)%4;
}
int turn_right(int x){
    return (x+4-1)%4;
}
void update_turn(int i,int j,int k,int next){
    if(j<2){
        dp[i+1][j][next]=max(dp[i+1][j][next],dp[i][j][k]);
    }
    else{
        dp[i+1][j][next]=min(dp[i+1][j][next],dp[i][j][k]);
    }
}
void update_left(int i,int j,int k){
    int next=turn_left(k);
    update_turn(i,j,k,next);
}
void update_right(int i,int j,int k){
    int next=turn_right(k);
    update_turn(i,j,k,next);
}
int get_cost(int x,int y){
    if(x==y) return 1;
    if((x+y)&1) return 0;
    return -1;
}
void update_front(int i,int j,int k){
    if(j<2){
        dp[i+1][j][k]=max(dp[i+1][j][k],dp[i][j][k]+get_cost(j,k));
    }
    else{
        dp[i+1][j][k]=min(dp[i+1][j][k],dp[i][j][k]-get_cost(j,k));
    }
}
int la;
int get_min(int j){
    int res=inf;
    for(int k=0;k<4;k++){
        res=min(res,dp[la][j][k]);
    }
    return res;
}
int get_max(int j){
    int res=-inf;
    for(int k=0;k<4;k++){
        res=max(res,dp[la][j][k]);
    }
    return res;
}
int main(){
    int cas=1;
    while(~scanf("%s",a)){
        la=strlen(a);
        for(int i=0;i<=la;i++){
            for(int j=0;j<4;j++){
                for(int k=0;k<4;k++){
                    dp[i][j][k]=inf;
                    if(j<2){
                        dp[i][j][k]=-inf;
                    }
                }
            }
        }
        for(int j=0;j<4;j++){
            dp[0][j][0]=0;
        }
        for(int i=0;i<la;i++){
            for(int j=0;j<4;j++){
                for(int k=0;k<4;k++){
                    if(dp[i][j][k]==inf||dp[i][j][k]==-inf) continue;
                    if(a[i]=='L'){
                        update_left(i,j,k);
                    }
                    else if(a[i]=='R'){
                        update_right(i,j,k);
                    }
                    else if(a[i]=='F'){
                        update_front(i,j,k);
                    }
                    else{
                        update_left(i,j,k);
                        update_right(i,j,k);
                        update_front(i,j,k);
                    }
                }
            }
        }
        printf("Case %d: %d %d %d %d\n",cas++,get_min(2),get_max(0),get_min(3),get_max(1));
    }
    return 0;
}

 

 i 纯bfs题

#include<cstdio>
#include<cstring>
#include<queue>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
const int M=16;
struct Q{
    int x,y,step;
}A,B,C,pre,now;
queue<Q> q;
bool vis[M][M];
int dx[]={-1,0,1,1,1,0,-1,-1};
int dy[]={-1,-1,-1,0,1,1,1,0};
bool inside(int x,int y){
    return x>=1&&x<=8&&y>=1&&y<=8;
}
int bfs(){
    mt(vis,0);
    vis[A.x][A.y]=true;
    A.step=0;
    while(!q.empty()) q.pop();
    q.push(A);
    while(!q.empty()){
        pre=q.front();
        q.pop();
        if(pre.x==B.x&&pre.y==B.y) return pre.step;
        if(pre.x==C.x&&pre.y==C.y) continue;
        for(int i=0;i<8;i++){
            int tx=pre.x+dx[i];
            int ty=pre.y+dy[i];
            if(!inside(tx,ty)||vis[tx][ty]) continue;
            vis[tx][ty]=true;
            now.x=tx;
            now.y=ty;
            now.step=pre.step+1;
            q.push(now);
        }
    }
    return -1;
}
int main(){
    int cas=1;
    while(~scanf("%d%d%d%d%d%d",&A.x,&A.y,&B.x,&B.y,&C.x,&C.y)){
        printf("Case %d: %d\n",cas++,bfs());
    }
    return 0;
}

 

 k 暴力就2的10次方，所以dfs是可以接受的，注意确定赢了就不要在继续射了。

#include<cstdio>
#include<cstring>
#define mt(a,b) memset(a,b,sizeof(a))
double a[16],b[16];
char c[16];
double mat[8][8];
void dfs(int A,int B,int ca,int cb,double p){
    if(ca==5&&cb==5){
        mat[A][B]+=p;
        return ;
    }
    if(A>B){
        if(A-B>5-cb){
            mat[A][B]+=p;
            return ;
        }
    }
    if(B>A){
        if(B-A>5-ca){
            mat[A][B]+=p;
            return ;
        }
    }
    if(ca==cb){
        dfs(A+1,B,ca+1,cb,p*a[ca+1]);
        dfs(A,B,ca+1,cb,p*(1-a[ca+1]));
    }
    else{
        dfs(A,B+1,ca,cb+1,p*b[cb+1]);
        dfs(A,B,ca,cb+1,p*(1-b[cb+1]));
    }
}
int main(){
    int cas=1;
    while(~scanf("%lf",&a[1])){
        for(int i=2;i<=5;i++){
            scanf("%lf",&a[i]);
        }
        for(int i=1;i<=5;i++){
            scanf("%lf",&b[i]);
        }
        scanf("%s",c);
        mt(mat,0);
        dfs(0,0,0,0,1);
        printf("Case %d: %.2f%%\n",cas++,mat[c[0]-'0'][c[2]-'0']*100);
    }
    return 0;
}

 

 

 

 

end