• UVA12125 March of the Penguins (最大流+拆点)


    题意:

    有N个点,每个点有ni个企鹅,这个点最多能跳着离开mi次.企鹅每次最多能跳D单位远,每两点之间有坐标距离..要你求出哪些点可以聚集所有的企鹅

    分析:

    因为每个点最多离开mi次,说明这个点有结点容量(允许通过的最大容量),故拆点i*2,i*2+1;详细见代码

    // File Name: 12125.cpp
    // Author: Zlbing
    // Created Time: 2013/4/23 20:42:02
    
    #include<iostream>
    #include<string>
    #include<algorithm>
    #include<cstdlib>
    #include<cstdio>
    #include<set>
    #include<map>
    #include<vector>
    #include<cstring>
    #include<stack>
    #include<cmath>
    #include<queue>
    using namespace std;
    #define CL(x,v); memset(x,v,sizeof(x));
    #define INF 0x3f3f3f3f
    #define LL long long
    #define REP(i,r,n) for(int i=r;i<=n;i++)
    #define RREP(i,n,r) for(int i=n;i>=r;i--)
    const int MAXN=200+100;
    struct Edge{
        int from,to,cap,flow;
    };
    bool cmp(const Edge& a,const Edge& b){
        return a.from < b.from || (a.from == b.from && a.to < b.to);
    }
    struct node{
        int x,y,n,m;
    }P[MAXN];
    struct Dinic{
        int n,m,s,t;
        vector<Edge> edges;
        vector<int> G[MAXN];
        bool vis[MAXN];
        int d[MAXN];
        int cur[MAXN];
        void init(int n){
            this->n=n;
            for(int i=0;i<=n;i++)G[i].clear();
            edges.clear();
        }
        void AddEdge(int from,int to,int cap){
            edges.push_back((Edge){from,to,cap,0});
            edges.push_back((Edge){to,from,0,0});//当是无向图时,反向边容量也是cap,有向边时,反向边容量是0
            m=edges.size();
            G[from].push_back(m-2);
            G[to].push_back(m-1);
        }
        bool BFS(){
            CL(vis,0);
            queue<int> Q;
            Q.push(s);
            d[s]=0;
            vis[s]=1;
            while(!Q.empty()){
                int x=Q.front();
                Q.pop();
                for(int i=0;i<G[x].size();i++){
                    Edge& e=edges[G[x][i]];
                    if(!vis[e.to]&&e.cap>e.flow){
                        vis[e.to]=1;
                        d[e.to]=d[x]+1;
                        Q.push(e.to);
                    }
                }
            }
            return vis[t];
        }
        int DFS(int x,int a){
            if(x==t||a==0)return a;
            int flow=0,f;
            for(int& i=cur[x];i<G[x].size();i++){
                Edge& e=edges[G[x][i]];
                if(d[x]+1==d[e.to]&&(f=DFS(e.to,min(a,e.cap-e.flow)))>0){
                    e.flow+=f;
                    edges[G[x][i]^1].flow-=f;
                    flow+=f;
                    a-=f;
                    if(a==0)break;
                }
            }
            return flow;
        }
        //当所求流量大于need时就退出,降低时间
        int Maxflow(int s,int t,int need){
            this->s=s;this->t=t;
            int flow=0;
            while(BFS()){
                CL(cur,0);
                flow+=DFS(s,INF);
                if(flow>need)return flow;
            }
            return flow;
        }
        //最小割割边
        vector<int> Mincut(){
            BFS();
            vector<int> ans;
            for(int i=0;i<edges.size();i++){
                Edge& e=edges[i];
                if(vis[e.from]&&!vis[e.to]&&e.cap>0)ans.push_back(i);
            }
            return ans;
        }
        void Reduce(){
            for(int i = 0; i < edges.size(); i++) edges[i].cap -= edges[i].flow;
        }
        void ClearFlow(){
            for(int i = 0; i < edges.size(); i++) edges[i].flow = 0;
        }
    };
    
    Dinic solver;
    int main()
    {
        int cas;
        scanf("%d",&cas);
        while(cas--)
        {
            int N;
            double D;
            scanf("%d%lf",&N,&D);
            int sum=0;
            REP(i,1,N){
                scanf("%d%d%d%d",&P[i].x,&P[i].y,&P[i].n,&P[i].m);
                sum+=P[i].n;
            }
                solver.init(2*N+1);
            int s=0;
            int t;
                REP(j,1,N)
                {
                    solver.AddEdge(j*2,j*2+1,P[j].m);
                    solver.AddEdge(s,j*2,P[j].n);
                }
                REP(j,1,N)
                    REP(k,j+1,N)
                    {
                        if(sqrt((P[j].x-P[k].x)*(P[j].x-P[k].x)+(P[j].y-P[k].y)*(P[j].y-P[k].y))<=D)
                        {
                            solver.AddEdge(j*2+1,k*2,INF);
                            solver.AddEdge(k*2+1,j*2,INF);
                        }
                    }
                vector<int> ans;
            REP(i,1,N)
            {
                t=i*2;
                solver.ClearFlow();
                int ret=solver.Maxflow(s,t,INF);
                if(ret==sum)
                    ans.push_back(i-1);
            }
            if(ans.size())
            {
                for(int i=0;i<ans.size();i++)
                {
                    if(i==0)printf("%d",ans[i]);
                    else printf(" %d",ans[i]);
                }
                printf("\n");
            }
            else printf("-1\n");
        }
        return 0;
    }
  • 相关阅读:
    hive:(group by, having;order by)的使用;group by+多个字段,以及wiki说的group by两种使用限制验证
    hive parition的使用,分dynamic和static两种
    saiku运行时报错max_length_for_sort_data 需要set higher
    kettle文件自动化部署(shell脚本执行):命令行参数传入
    saiku显示不出新的cube(加载的cube,saiku会保存到缓存中,不重新加载)
    黑暗网络购物让你隐形參与犯罪
    Swift开发实例:苹果Swift编程语言新手教程中文版+FlappyBird,2048游戏源代码
    自己定义控件-DragButton
    无锁编程实战演练
    使用hint优化Oracle的运行计划 以及 SQL Tune Advisor的使用
  • 原文地址:https://www.cnblogs.com/arbitrary/p/3039311.html
Copyright © 2020-2023  润新知