2015_12

http://acm.hust.edu.cn/vjudge/contest/view.action?cid=77250#problem/L password123　　

L - City 

给n*m的矩阵，矩阵的值表示该格点有共多少条边，边是相邻两个格点之间，相邻是上下左右四个方向。矩阵中只有一个-1，要求这个点的边数。

做法，通过i+j的奇偶可以将矩阵分成两个部分，就像国际象棋盘，然后对于一条边，它会对奇数部分贡献1，对偶数部分贡献1，所以统计一下黑格子，白格子的和，他们应该相等。

所以差值就是-1的格子的边数。

#include<cstdio>
#include<cstdlib>
int main(){
    int t,n,m,x;
    while(~scanf("%d",&t)){
        while(t--){
            scanf("%d%d",&n,&m);
            int s1=0,s2=0;
            for(int i=0;i<n;i++){
                for(int j=0;j<m;j++){
                    scanf("%d",&x);
                    if(x==-1) continue;
                    if((i+j)&1){
                        s1+=x;
                    }
                    else{
                        s2+=x;
                    }
                }
            }
            printf("%d
",abs(s1-s2));
        }
    }
    return 0;
}

K - Concert Tour

有n个城市，一共工作m天，输入一个n*m的矩阵，get【i】【j】表示在 i 城市 在 第 j 天工作能挣的钱，再输入cost矩阵 cost i j ，表示 i 城市 到 j 城市的花费。

用dp i j 表示 第j 天 在 i 工作所能获得的最大钱

第一天去某个城市是不花钱的，所以dp 【i】【1】就是get

枚举天数，对每一天枚举所在城市，这个状态可以推到n个状态，因为下一天可以去任意一个城市，

#include<cstdio>
#include<algorithm>
using namespace std;
const int M=1e2+10;
const int inf=0x3f3f3f3f;
int get[M][64];
int cost[M][M];
int dp[M][64];
int main(){
    int t,n,m;
    while(~scanf("%d",&t)){
        while(t--){
            scanf("%d%d",&n,&m);
            for(int i=1;i<=n;i++){
                for(int j=1;j<=m;j++){
                    scanf("%d",&get[i][j]);
                    dp[i][j]=-inf;
                }
            }
            for(int i=1;i<=n;i++){
                for(int j=1;j<=n;j++){
                    scanf("%d",&cost[i][j]);
                }
            }
            for(int i=1;i<=n;i++){
                dp[i][1]=get[i][1];
            }
            for(int j=1;j<=m;j++){
                for(int i=1;i<=n;i++){
                    for(int k=1;k<=n;k++){
                        dp[k][j+1]=max(dp[k][j+1],dp[i][j]+get[k][j+1]-cost[i][k]);
                    }
                }
            }
            int ans=-inf;
            for(int i=1;i<=n;i++){
                ans=max(ans,dp[i][m]);
            }
            printf("%d
",ans);
        }
    }
    return 0;
}

 J - Blanket

m个人，下标0——m-1，有n次覆盖，每次输入a，b，所有下标%b《a的人覆盖一次，最后输出被覆盖0到n次的人数

a，b都是16，n次操作重复的很多，统计一下，最后就是16*16个覆盖，但是次数可能多次，

然后就是区间累加了，左++右--的方法

#include<cstdio>
#include<cstring>
#define mt(a,b) memset(a,b,sizeof(a))
const int M=1e6+10;
int mat[32][32];
int dp[M];
int ans[M];
int main(){
    int t,n,m,a,b;
    while(~scanf("%d",&t)){
        while(t--){
            scanf("%d%d",&n,&m);
            mt(mat,0);
            for(int i=0;i<n;i++){
                scanf("%d%d",&a,&b);
                mat[a][b]++;
            }
            for(int i=0;i<m;i++){
                dp[i]=0;
            }
            for(a=1;a<=16;a++){
                for(b=a;b<=16;b++){
                    int cnt=mat[a][b];
                    if(!cnt) continue;
                    if(b==1){
                        dp[0]+=cnt;
                        continue;
                    }
                    int id=0;
                    while(id<m){
                        dp[id]+=cnt;
                        if(id+a<m){
                            dp[id+a]-=cnt;
                        }
                        id+=b;
                    }
                }
            }
            int val=0;
            for(int i=0;i<=n;i++){
                ans[i]=0;
            }
            for(int i=0;i<m;i++){
                val+=dp[i];
                ans[val]++;
            }
            for(int i=0;i<=n;i++){
                printf("%d
",ans[i]);
            }
        }
    }
    return 0;
}

 I - The Programmers

p 个人，s个城市，c是每个城市能容纳的参赛人数，m是边数，输入m对u，v，表示u人能去v城市比赛。

就是个二分图最大匹配，如果c==1，那就是最简单的二分匹配，现在是c，用最大流解最大匹配的建图 源点到每个人，人到城市（输入），都是流量1，城市到汇点，都是流量c

最大流就是最大匹配数。

#include<cstdio>
#include<cstring>
#include<queue>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
const int inf=0x3f3f3f3f;
class Dinic { ///最大流 O(MV^2*ME)
    typedef int typef;///流量的类型
    static const int ME=1e6+10;///边的个数
    static const int MV=1e3+10;///点的个数
    int temp[MV],cur[MV],level[MV],path[MV];
    bool used[MV];
    queue<int> q;
    typef flow;
    bool bfs(int s,int t) {
        mt(level,-1);
        while(!q.empty()) q.pop();
        q.push(s);
        level[s]=1;
        while(!q.empty()) {
            int u=q.front();
            q.pop();
            for(int i=g.head[u]; ~i; i=g.e[i].next) {
                int v=g.e[i].v;
                if(level[v]==-1&&g.e[i].flow) {
                    level[v]=level[u]+1;
                    q.push(v);
                    if(v==t) return true;
                }
            }
        }
        return false;
    }
    struct G {
        struct E {
            int u,v,next;
            typef flow;
        } e[ME];
        int le,head[MV];
        void init() {
            le=0;
            mt(head,-1);
        }
        void add(int u,int v,typef flow) {
            e[le].u=u;
            e[le].v=v;
            e[le].flow=flow;
            e[le].next=head[u];
            head[u]=le++;
        }
    } g;
public:
    typef getflow() {
        return flow;
    }
    void init() {
        g.init();
    }
    void add(int u,int v,typef flow) {
        g.add(u,v,flow);
        g.add(v,u,0);
    }
    void solve(int s,int t) {
        int p,tempp;
        typef now;
        bool flag;
        flow=0;
        while(bfs(s,t)) {
            for(int i=0; i<MV; i++) {
                temp[i]=g.head[i];
                used[i]=true;
            }
            p=1;
            path[p]=s;
            while(p) {
                int u=path[p];
                if(u==t) {
                    now=inf;
                    for(int i=1; i<p; i++) {
                        now=min(now,g.e[cur[path[i]]].flow);
                    }
                    flow+=now;
                    for(int i=1; i<p; i++) {
                        int j=cur[path[i]];
                        g.e[j].flow-=now;
                        g.e[j^1].flow+=now;
                        if(!g.e[j].flow) tempp=i;
                    }
                    p=tempp;
                } else {
                    flag=false;
                    for(int i=temp[u]; ~i; i=g.e[i].next) {
                        int v=g.e[i].v;
                        if(used[v]&&g.e[i].flow&&level[u]+1==level[v]) {
                            cur[u]=i;
                            temp[u]=g.e[i].next;
                            flag=true;
                            path[++p]=v;
                            break;
                        }
                    }
                    if(flag) continue;
                    p--;
                    used[u]=false;
                }
            }
        }
    }
} g;
int main(){
    int t,P,S,C,m,u,v;
    while(~scanf("%d",&t)){
        while(t--){
            scanf("%d%d%d%d",&P,&S,&C,&m);
            g.init();
            int start=0,to=P+S+1;
            while(m--){
                scanf("%d%d",&u,&v);
                g.add(u,v+P,1);
            }
            for(int i=1;i<=P;i++){
                g.add(start,i,1);
            }
            for(int i=1;i<=S;i++){
                g.add(i+P,to,C);
            }
            g.solve(start,to);
            printf("%d
",g.getflow());
        }
    }
    return 0;
}

E - Zeroes

定义  fzero 是一个数阶乘最后0的个数   输入 LR，问L到R之间的数，他们的fzero有多少种不同的值

打表发现每遇到一个5的倍数，就会多一种，那就算一下LR之间有多少个5的倍数了

#include<cstdio>
typedef unsigned long long LL;
LL l,r;
int main(){
    while(~scanf("%llu%llu",&l,&r),l|r){
        while(true){
            if(l%5==0) break;
            l--;
        }
        while(true){
            if(r%5==0) break;
            r--;
        }
        printf("%llu
",(r-l)/5+1);
    }
    return 0;
}

 B - Combination

求 n个中选 i 个的情况数中奇数的个数，其中 i 从0-n，n从 l 到 r ，l r 输入

打表，lmh推出的前n项和公式  分奇偶两种，然后我根据公式直接dfs，加记忆化勉强卡过

#include<cstdio>
#include<map>
using namespace std;
typedef unsigned long long LL;
map<LL,LL> mp;
LL dfs(LL x){
    if(x==0) return 0;
    LL res=mp[x];
    if(res) return res;
    if(x&1){
        res=2*dfs(x/2)+dfs(x/2+1);
    }
    else{
        res=3*dfs(x/2);
    }
    mp[x]=res;
    return res;
}
LL L,R;
int main(){
    mp.clear();
    mp[1]=1;
    while(~scanf("%llu%llu",&L,&R),L|R){
        printf("%llu
",dfs(R+1)-dfs(L));
    }
    return 0;
}

 A - Volume Control

输入n，问 0-n任选两个数共有多少种不同的乘积，

首先，有单调性，n越大，能生成的乘积越多，并且小的值能生成的，大的值一定能

所以可以维护一个9e8的bool数组表示是否出现过，从小到大处理，这样处理大的值的时候，之前小的值生成的标记就利用起来了 听所vector《bool》是按位的 还可以（maxn）长知识

#include<cstdio>
#include<vector>
using namespace std;
vector<bool> v(900000010);
int ans[30010];
int main(){
    v.clear();
    int tmp=1;
    for(int i=1;i<=30000;i++){
        for(int j=1;j<=i;j++){
            int mul=i*j;
            if(!v[mul]){
                tmp++;
                v[mul]=true;
            }
        }
        ans[i]=tmp;
    }
    int t,n;
    while(~scanf("%d",&t)){
        while(t--){
            scanf("%d",&n);
            printf("%d
",ans[n]);
        }
    }
    return 0;
}

end