FOJ 11月月赛题解

抽空在vjudge上做了这套题。剩下FZU 2208数论题不会。

FZU 2205

这是个想法题，每次可以在上一次基础上加上边数/2的新边。

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <string.h>
#include <stdio.h>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <cassert>
#include <sstream>
using namespace std;

const int N=2001;

int f[N];
int main () {
    f[1]=0;
    for (int i=2;i<=1000;i++) {
        f[i]=f[i-1]+i/2;
    }
    int T;
    cin>>T;
    while (T--) {
        int n;
        cin>>n;
        cout<<f[n]<<endl;
    }
    return 0;
}

FZU 2206

乍看不知道什么东西，直接在机器上跑几个数字可以试出来结论。

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <string.h>
#include <stdio.h>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <cassert>
#include <sstream>
using namespace std;

const int N=501;
const int INF=0x3f3f3f3f;


int main () {
    //freopen("out.txt","r",stdin);
    int T;
    scanf("%d",&T);
    for (int cas=1;cas<=T;cas++) {
        long long n;
        scanf("%I64d",&n);
        if (n<20150001LL) cout<<n+2014<<endl;
        else cout<<20152014<<endl;
    }
    return 0;
}

FZU 2207

会用倍增算LCA的话，这题也肯定会做。

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <string.h>
#include <stdio.h>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <cassert>
#include <sstream>
using namespace std;

const int N=2001;

vector<int>e[N];
int fa[N][13];
int dep[N];
void dfs(int u,int f,int d) {
    dep[u]=d;
    for (int i=0;i<e[u].size();i++) {
        int v=e[u][i];
        if (v==f) continue;
        dfs(v,u,d+1);
        fa[v][0]=u;
    }
}

void calc(int n) {
    for (int j=1;j<=12;j++) {
        for (int i=1;i<=n;i++) {
            fa[i][j]=fa[fa[i][j-1]][j-1];
        }
    }
}

int kthA(int u,int k) {
    for (int i=12;i>=0;i--) {
        if (k>=(1<<i)){
            k-=(1<<i);
            u=fa[u][i];
        }
    }
    return u;
}

int lca(int u,int v) {
    if (dep[u]<dep[v]) swap(u,v);
    int d=dep[u]-dep[v];
    u=kthA(u,d);
    if (u==v) return u;
    for (int i=12;i>=0;i--) {
        if (fa[u][i]==fa[v][i])
            continue;
        u=fa[u][i];
        v=fa[v][i];
    }
    return fa[u][0];
}
int main () {
    int T;
    scanf("%d",&T);
    while (T--) {
        int n,m;
        scanf("%d %d",&n,&m);
        for (int i=0;i<=n;i++)
            e[i].clear();
        for (int i=1;i<n;i++) {
            int u,v;
            scanf("%d %d",&u,&v);
            e[u].push_back(v);
            e[v].push_back(u);
        }
        dfs(1,-1,1);
        calc(n);
        static int cas=1;
        printf("Case #%d:
",cas++);
        while (m--) {
            int u,v,k;
            scanf("%d %d %d",&u,&v,&k);
            int ans=lca(u,v);
            if (k==1) {
                printf("%d
",u);
                continue;
            }
            else if (k==dep[u]-dep[ans]+dep[v]-dep[ans]+1) {
                printf("%d
",v);
                continue;
            }
            if (dep[u]-dep[ans]+1>=k) {
                int ret=kthA(u,k-1);
                printf("%d
",ret);
            }
            else {
                int to=dep[u]-dep[ans]+dep[v]-dep[ans]+1-k;
                int ret=kthA(v,to);
                printf("%d
",ret);
            }
        }
    }
    return 0;
}

FZU 2208

数论题，不会

FZU 2209

分层图。

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <string.h>
#include <stdio.h>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <cassert>
#include <sstream>
using namespace std;

const int N=501;
const int INF=0x3f3f3f3f;
int get(int n,int u,int k) {
    return k*n+u;
}
struct Edge {
    int to,next,len;
    Edge() {}
    Edge(int _to,int _next,int _len):to(_to),next(_next),len(_len) {}
} edge[250000];
int idx=1,head[N];
inline void addedge(int u,int v,int l) {
    edge[++idx]=Edge(v,head[u],l);
    head[u]=idx;
}
int dis[N][N],in[N];
bool vis[N];
bool spfa(int s,int n,int *dis) {
    fill(dis,dis+N,INF);
    memset(vis,false,sizeof(vis));
    memset(in,0,sizeof(in));
    dis[s]=0;
    vis[s]=true;
    queue<int> que;
    que.push(s);
    in[s]=1;
    while (!que.empty()) {
        int u=que.front();
        que.pop();
        vis[u]=false;
        for (int k=head[u];k;k=edge[k].next) {
            int v=edge[k].to;
            if (dis[v]>dis[u]+edge[k].len) {
                dis[v]=dis[u]+edge[k].len;
                if (!vis[v]) {
                    vis[v]=true;
                    in[v]++;
                    if (in[v]>n) return false;
                    que.push(v);
                }
            }
        }
    }
    return true;
}
int main () {
    //freopen("out.txt","r",stdin);
    int T;
    scanf("%d",&T);
    for (int cas=1;cas<=T;cas++) {
        int n,m,k;
        scanf("%d %d %d",&n,&m,&k);
        idx=1;memset(head,0,sizeof head);
        for (int i=1;i<=m;i++) {
            int u,v;
            scanf("%d %d",&u,&v);
            int d;
            for (int i=0;i<24;i++) {
                scanf("%d",&d);
                int uu=get(n,u,i);
                int vv=get(n,v,(i+d)%24);
                addedge(uu,vv,d);
                uu=get(n,v,i);
                vv=get(n,u,(i+d)%24);
                addedge(uu,vv,d);
            }
        }
        for (int i=0;i<24;i++) {
            spfa(get(n,1,i),n*24,dis[i]);
        }
        printf("Case #%d:",cas);
        while (k--) {
            int v,s;
            scanf("%d %d",&v,&s);
            //cout<<"from "<<get(n,1,s)<<endl;
            int ret=0x3f3f3f3f;
            for (int i=0;i<24;i++) {
                int p=get(n,v,i);
                ret=min(ret,dis[s][p]);
            }
            if (ret==0x3f3f3f3f) ret=-1;
            printf(" %d",ret);
        }
        puts("");
    }
    return 0;
}

FZU 2210

建立一个虚拟节点，连向所有粮仓，枚举所有禁止的城市，从虚拟节点dfs，更新答案。

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <string.h>
#include <stdio.h>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <cassert>
#include <sstream>
using namespace std;

const int N=2001;

vector<int>e[N];
int in[N];
bool vis[N];
int fob;
int cnt;
void dfs(int u) {
    if (u==fob||vis[u]) return;
    vis[u]=true;cnt++;
    for (int i=0;i<e[u].size();i++) {
        int v=e[u][i];
        dfs(v);
    }
}
int main () {
    int n,m;
    while (scanf("%d %d",&n,&m)!=EOF) {
        for (int i=0;i<=n;i++){
            e[i].clear();
            in[i]=0;
        }
        for (int i=1;i<=m;i++) {
            int u,v;
            scanf("%d %d",&u,&v);
            e[u].push_back(v);
            in[v]++;
        }
        for (int i=1;i<=n;i++) {
            if (in[i]==0)
                e[0].push_back(i);
        }
        int ret=n+1,val=0;
        for (int i=n;i>=1;i--) {
            fob=i;
            memset(vis,false,sizeof vis);
            cnt=0;
            dfs(0);
            cnt--;
            if (n-cnt>=val) {
                val=n-cnt;
                ret=i;
            }
        }
        cout<<ret<<endl;
    }
    return 0;
}

FZU 2211

费用流，把所有蘑菇拆成两个点，根据时间关系，互相连边。农田的限制在于源点出来的流的大小。

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <string.h>
#include <stdio.h>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <cassert>
#include <sstream>
using namespace std;

const int N=5010;
const int INF=0x3f3f3f3f;

struct Edge{
    int to,next,f;
    long long c;
    Edge(){}
    Edge(int _to,int _nxt,int _f,long long _c):to(_to),next(_nxt),f(_f),c(_c){}
}edge[N<<2];

int head[N],idx;
bool vis[N];
long long dis[N];
int pree[N],prev[N];
void addedge(int u,int v,int flow,long long cost){
    edge[++idx]=Edge(v,head[u],flow,cost);
    head[u]=idx;
    edge[++idx]=Edge(u,head[v],0,-cost);
    head[v]=idx;
}
bool spfa(int s,int e){
    memset(vis,0,sizeof(vis));
    memset(pree,-1,sizeof(pree));
    memset(prev,-1,sizeof(prev));
    for (int i=0;i<N;i++) dis[i]=~0ULL>>3;
    dis[s]=0;
    vis[s]=true;
    queue<int>que;
    que.push(s);
    while (!que.empty()){
        int cur=que.front();
        que.pop();
        vis[cur]=false;
        for (int k=head[cur];k;k=edge[k].next){
            if (edge[k].f){
                int n=edge[k].to;
                if (dis[n]>dis[cur]+edge[k].c){
                    dis[n]=dis[cur]+edge[k].c;
                    prev[n]=cur;
                    pree[n]=k;
                    if (!vis[n]){
                        vis[n]=true;
                        que.push(n);
                    }
                }
            }
        }
    }
    if (dis[e]>=INF) return 0;
    return 1;
}
long long minCostMaxFlow(int src,int sink){
    long long cur,min_val;
    long long ansf=0,ansc=0;
    while (spfa(src,sink)){
         cur=sink;
         min_val=INF;
         while (prev[cur]!=-1){
            if (min_val>edge[pree[cur]].f)
                min_val=edge[pree[cur]].f;
            cur=prev[cur];
         }
         cur=sink;
         while (prev[cur]!=-1){
            edge[pree[cur]].f-=min_val;
            edge[pree[cur]^1].f+=min_val;
            cur=prev[cur];
         }
         ansc+=dis[sink]*min_val;
         ansf+=min_val;
    }
    return ansc;
}

int s[N],t[N],v[N];
int main () {
    int T;
    scanf("%d",&T);
    for (int cas=1;cas<=T;cas++) {
        int n,m;
        scanf("%d %d",&n,&m);
        for (int i=1;i<=m;i++) {
            scanf("%d %d %d",s+i,t+i,v+i);
        }
        idx=1;memset(head,0,sizeof head);
        for (int i=1;i<=m;i++) {
            for (int j=1;j<=m;j++) {
                if (t[i]<s[j]) {
                    addedge(i+m,j,INF,0);
                }
            }
        }
        int s=m+m+1,t=m+m+1+1;
        for (int i=1;i<=m;i++) {
            addedge(0,i,INF,0);
            addedge(i,i+m,1,-v[i]);
            addedge(i+m,t,INF,0);
        }
        addedge(s,0,n,0);
        long long ret=-minCostMaxFlow(s,t);
        cout<<ret<<endl;
    }
    return 0;
}