题意:

      有一n个冰块,每个冰块上都有一些企鹅,所有的企鹅要跳到一个冰块上去,但是由于起跳是的后坐力原因导致每个冰块最多条mi次,最后问你所有的企鹅都跳到一个冰块上去的那块冰块可以是哪一块,输出所有肯能的终点冰块。

思路:

      比较简单,我们可以枚举终点,首先把终点拿出来,剩下的点拆点,拆成两个,限流是最多的跳跃次数,然后起点连接每个拆了的点的左侧的点,终点就是当前枚举的点,然后最大流判断下就行了,提醒下,建图的时候注意,不要多虚拟出来一些没用的点,一开始我的第一感觉就是三重的,后来在敲的时候突然感觉两重就够了,也就是最多200个点就行,还有就是当前枚举的重点的冰块上的企鹅不用动,别的没什么,因为比较简单,我就不解释太多了,不清楚的自己画画建出来的图应该很容易懂。

#include<queue>

#include<stdio.h>

#include<string.h>

#define N_node 200 + 10

#define N_edge 100000

#define INF 1000000000

using namespace std;

typedef struct

{

    int to ,cost ,next;

}STAR;

typedef struct

{

    int x ,t;

}DEP;

typedef struct

{

    double x ,y;

    int p ,c;

}NODE;

NODE node[N_node];

STAR E[N_edge];

DEP xin ,tou;

int list[N_node] ,listt[N_node] ,tot;

int deep[N_node] ,Ans[N_node];

int canlink[110][110];

void add(int a ,int b ,int c)

{

    E[++tot].to = b;

    E[tot].cost = c;

    E[tot].next = list[a];

    list[a] = tot;

    E[++tot].to = a;

    E[tot].cost = 0;

    E[tot].next = list[b];

    list[b] = tot;

}

int minn(int x ,int y)

{

    return x < y ? x : y;

}

bool BFS_DEEP(int s ,int t ,int n)

{

    memset(deep ,255 ,sizeof(deep));

    xin.x = s ,xin.t = 0;

    queue<DEP>q;

    q.push(xin);

    deep[s] = 0;

    while(!q.empty())

    {

        tou = q.front();

        q.pop();

        for(int k = list[tou.x] ;k ;k = E[k].next)

        {

            xin.x = E[k].to;

            xin.t = tou.t + 1;

            if(deep[xin.x] != -1 || !E[k].cost)

            continue;

            deep[xin.x] = xin.t;

            q.push(xin);

        }

    }

    for(int i = 0 ;i <= n ;i ++)

    listt[i] = list[i];

    return deep[t] != -1;

}

int DFS_Flow(int s ,int t ,int flow)

{

    if(s == t) return flow;

    int nowflow = 0;

    for(int k = listt[s] ;k ;k = E[k].next)

    {

        listt[s] = k;

        int c = E[k].cost;

        int to = E[k].to;

        if(!c || deep[to] != deep[s] + 1)

        continue;

        int tmp = DFS_Flow(to ,t ,minn(c ,flow - nowflow));

        nowflow += tmp;

        E[k].cost -= tmp;

        E[k^1].cost += tmp;

        if(nowflow == flow) break;

    }

    if(!nowflow) deep[s] = 0;

    return nowflow;

}

int DINIC(int s ,int t ,int n)

{

    int ans = 0;

    while(BFS_DEEP(s ,t ,n))

    {

        ans += DFS_Flow(s ,t ,INF);

    }

    return ans;

}

double Get_Dis(NODE a ,NODE b)

{

    double x = (a.x - b.x) * (a.x - b.x);

    double y = (a.y - b.y) * (a.y - b.y);

    return x + y;

}

int main ()

{

    int t ,n ,i ,j ,sump;

    double dis;

    scanf("%d" ,&t);

    while(t--)

    {

        scanf("%d %lf" ,&n ,&dis);

        sump = 0;

        for(i = 1 ;i <= n ;i ++)

        {

            scanf("%lf %lf %d %d" ,&node[i].x ,&node[i].y ,&node[i].p ,&node[i].c);

            sump += node[i].p;

        }

        memset(canlink ,0 ,sizeof(canlink));

        for(i = 1 ;i <= n ;i ++)

        for(j = i + 1 ;j <= n ;j ++)

        {

            if(Get_Dis(node[i] ,node[j]) <= dis * dis)

            canlink[i][j] = canlink[j][i] = 1;

        }

        int ansid = 0;

        for(int now = 1 ;now <= n ;now ++)

        {

            memset(list ,0 ,sizeof(list));

            tot = 1;

            for(i = 1 ;i <= n ;i ++)

            {

                if(i == now) continue;

                add(0 ,i ,node[i].p);

                add(i ,i + n ,node[i].c);

            }

            for(i = 1 ;i <= n ;i ++)

            for(j = i + 1 ;j <= n ;j ++)

            {

                if(canlink[i][j])

                {

                    if(i == now) add(j + n ,now ,INF);

                    else if(j == now) add(i + n ,now ,INF);

                    else add(i + n ,j ,INF) ,add(j + n ,i ,INF);

                }

            }

            int flow = DINIC(0 ,now ,n + n);

            if(flow == sump - node[now].p)

            Ans[++ansid] = now;

        }

        if(!ansid) printf("-1\n");

        else

        {

            for(i = 1 ;i <= ansid ;i ++)

            if(i == ansid) printf("%d\n" ,Ans[i] - 1);

            else printf("%d " ,Ans[i] - 1);

        }

    }

    return 0;

}

POJ3498最大流,枚举终点,企鹅,基础最大流的更多相关文章

  1. 十八、Java基础--------IO流体系以及字符流

    在上一章节中详细介绍集合框架的相关知识,在接下来的几篇文章中将讲述Java中另一个及其重要的知识——IO流,本文主要是讲述IO流的一些基本概念以及字符流的相关应用. IO流 介绍IO流之前先介绍一下什 ...

  2. java基础IO流综合加习题

    IO流初学者在学习时都有一点迷糊,今天我们就讲讲IO流,希望通过讲解可以帮助大家 IO流分为字节流,字符流,缓冲流.我们只要记住这三个就可以了. 1*字节流有:字节输入流(FileInputStrea ...

  3. 关于Java中面向对象章节、IO 流中的重点基础知识。

    一.面向对象的三大特征,以及作用. 答:面向对象的三大特征即,封装性.继承性.多态性. 其分别的作用为 : 封装作用:将数据封装起来,提高数据的安全性, 继承作用:提高代码的复用性,减少冗余代码. 多 ...

  4. Java基础---Java---IO流-----对象的序列化、管道流、RandomAccessFile、数据类型的流对象DataStream、ByteArrayStream

    ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化. ObjectOutputStream 和 ObjectInputStream ...

  5. Java基础IO流(二)字节流小案例

    JAVA基础IO流(一)https://www.cnblogs.com/deepSleeping/p/9693601.html ①读取指定文件内容,按照16进制输出到控制台 其中,Integer.to ...

  6. Java 基础 IO流(转换流,缓冲)

    一,前言 在学习字符流(FileReader.FileWriter)的时候,其中说如果需要指定编码和缓冲区大小时,可以在字节流的基础上,构造一个InputStreamReader或者OutputStr ...

  7. Java基础-IO流对象之压缩流(ZipOutputStream)与解压缩流(ZipInputStream)

    Java基础-IO流对象之压缩流(ZipOutputStream)与解压缩流(ZipInputStream) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 之前我已经分享过很多的J ...

  8. Java基础-IO流对象之随机访问文件(RandomAccessFile)

    Java基础-IO流对象之随机访问文件(RandomAccessFile) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.RandomAccessFile简介 此类的实例支持对 ...

  9. Java基础-IO流对象之内存操作流(ByteArrayOutputStream与ByteArrayInputStream)

    Java基础-IO流对象之内存操作流(ByteArrayOutputStream与ByteArrayInputStream) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.内存 ...

随机推荐

  1. Codeforces Round #683 (Div. 2, by Meet IT)

    A 初始情况\(1\) ~ \(n\)堆分别有 \(1\) ~ \(n\) 个糖果,第\(i\)次操作给除了所选堆的糖果数 \(+ i\), 找到一种方案可以使得所有堆糖果数相同,输出操作次数和每次选 ...

  2. VMware 虚拟机安装(使用CentOS镜像)

    (1)启动虚拟机,点击"文件"-->"新建虚拟机",选择安装类型,推荐"典型".       (2)选择稍后安装操作系统       ...

  3. 微服务分布式事务之LCN、TCC

    在亿级流量架构之分布式事务解决方案对比中, 已经简单阐明了从本机事务到分布式事务的演变过程, 文章的最后简单说明了TCC事务, 这儿将会深入了解TCC事务是原理, 以及理论支持, 最后会用Demo举例 ...

  4. Python读写配置文件模块--Configobj

    一.介绍 我们在项目的开发过程中应该会遇到这样的问题:我们的项目读取某个配置文件,然后才能按照配置的信息正常运行服务,当我们需要对修改服务的某些信息时,可以直接修改这个配置文件,重启服务即可,不用再去 ...

  5. Java 8 Stream API 详解

    Java 8 中的 Stream 是对集合(Collection)对象功能的增强,它专注于对集合对象进行各种非常便利.高效的聚合操作(aggregate operation),或者大批量数据操作 (b ...

  6. MIT 6.824拾遗(一)聊聊basic-paxos

    前言 The Paxos algorithm, when presented in plain English, is very simple. ------ Lamport,<Paxos Ma ...

  7. Go 语言入门教程,共32讲,6小时(已完结)

    Go语言入门教程,共32讲,6小时(完结) 在B站:https://www.bilibili.com/video/BV1fD4y1m7TD/

  8. CQGUI框架之阴影圆角窗口实现

    CQGUI框架之阴影圆角窗口实现 大家好,我是IT文艺男,来自一线大厂的一线程序员 今天给大家讲解基于C++/Qt的CQGUI框架的阴影圆角窗口实现,实现效果如下图所示:: CQGUI开发环境:: M ...

  9. java例题_37 有 n 个人围成一圈,顺序排号。从第一个人开始报数(从 1 到 3 报数),凡报到 3 的人退出圈子, 3 问最后留下的是原来第几号的那位。

    1 /*37 [程序 37 报数] 2 题目:有 n 个人围成一圈,顺序排号.从第一个人开始报数(从 1 到 3 报数),凡报到 3 的人退出圈子, 3 问最后留下的是原来第几号的那位. 4 */ 5 ...

  10. java进阶(41)--反射机制

    文档目录: 一.反射机制的作用 二.反射机制相关类 三.获取class的三种方式 四.通过反射实例化对象 五.通过读属性文件实例化对象 六.通过反射机制访问对象属性 七.通过反射机制调用方法 ---- ...