POJ 3436 ACM Computer Factory 最大流输出路径

最新推荐文章于 2019-08-30 17:06:00 发布
最新推荐文章于 2019-08-30 17:06:00 发布
阅读量866 收藏
点赞数
分类专栏： 最大流-最小割 文章标签： poj 最大流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/discreeter/article/details/52160156
版权

题目：http://poj.org/problem?id=3436

题意：题意真心很难懂啊。。。产品有p个状态，给定n个机器，给出每个机器要求加工前的状态是什么，且给出加工后的状态是什么。产品初始时状态全部为0，完成加工时状态全部为1。加工前有三种状态，为0和1状态要求产品的对应位置也要是0和1,2状态的话可以随意，加工后只有0和1状态

思路：拆点建图，然后在从汇点出发搜索残余网络中的反向边，建图时所有反向边的容量全部为0，而残余网络中容量不为0的反向边对应的正向边必定有流量经过，统计这些边就好了

总结：不拆点的话会有bug，但题目数据较弱，也可以过。输出路径时重复输出了，，，

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <cmath>
#include <queue>
using namespace std;

typedef long long ll;
typedef pair<int, int> P;
const int INF = 0x3f3f3f3f;
const int N = 210;
struct edge
{
    int to, cap, id, next;
} g[N*N*10];
struct node
{
    int v, u, cap;
}e;
vector<node> vec;
int head[N], pre[N], cur[N], gap[N], level[N];
int cnt, nv, cas = 0;
int arr[N], brr[N][N], crr[N][N];
int ss, tt;
int n, m;
bool vis[N];
void add_edge(int v, int u, int cap)
{
    g[cnt].to = u, g[cnt].cap = cap, g[cnt].id = 0, g[cnt].next = head[v], head[v] = cnt++;
    g[cnt].to = v, g[cnt].cap = 0, g[cnt].id = 1, g[cnt].next = head[u], head[u] = cnt++;
}
int sap(int s, int t)
{
    memset(level, 0, sizeof level);
    memset(gap, 0, sizeof gap);
    memcpy(cur, head, sizeof head);
    gap[0] = nv;
    int v = pre[s] = s, flow = 0, aug = INF;
    while(level[s] < nv)
    {
        bool flag = false;
        for(int &i = cur[v]; i != -1; i = g[i].next)
        {
            int u = g[i].to;
            if(g[i].cap > 0 && level[v] == level[u] + 1)
            {
                flag = true;
                pre[u] = v;
                v = u;
                aug = min(aug, g[i].cap);
                if(v == t)
                {
                    flow += aug;
                    while(v != s)
                    {
                        v = pre[v];
                        g[cur[v]].cap -= aug;
                        g[cur[v]^1].cap += aug;
                    }
                    aug = INF;
                }
                break;
            }
        }
        if(flag) continue;
        int minlevel = nv;
        for(int i = head[v]; i != -1; i = g[i].next)
        {
            int u = g[i].to;
            if(g[i].cap > 0 && minlevel > level[u])
                minlevel = level[u], cur[v] = i;
        }
        if(--gap[level[v]] == 0) break;
        level[v] = minlevel + 1;
        gap[level[v]]++;
        v = pre[v];
    }
    return flow;
}
bool judge1(int a[], int n)
{
    for(int i = 1; i <= n; i++)
        if(a[i] == 1)
            return false;
    return true;
}
bool judge2(int a[], int b[], int n)
{
    for(int i = 1; i <= n; i++)
        if(a[i] != b[i] && a[i] != 2) return false;
    return true;
}
bool judge3(int a[], int n)
{
    for(int i = 1; i <= n; i++)
        if(a[i] != 1) return false;
    return true;
}
void dfs(int v) //初始时所有的反向边容量全部为0，跑完最大流后反向边不为0的说明流经了对应的正向边
{
    vis[v] = true;
    for(int i = head[v]; i != -1; i = g[i].next)
    {
        if(g[i].id == 1 && g[i].cap > 0)
        {
            if(v != tt && g[i].to != ss && abs(v - g[i].to) != m)
            {
                e.v = g[i].to - m, e.u = v, e.cap = g[i].cap;
                vec.push_back(e);
            }
            if(! vis[g[i].to])
                dfs(g[i].to);
        }
    }
}
int main()
{
    while(~ scanf("%d%d", &n, &m))
    {
        cnt = 0;
        memset(head, -1, sizeof head);
        for(int i = 1; i <= m; i++)
        {
            scanf("%d", &arr[i]);
            for(int j = 1; j <= n; j++)
                scanf("%d", &brr[i][j]);
            for(int j = 1; j <= n; j++)
                scanf("%d", &crr[i][j]);
        }
        ss = 0, tt = 2 * m + 1;
        for(int i = 1; i <= m; i++)
        {
            add_edge(i, m + i, arr[i]);
            printf("%d %d\n", i, i + m);
            if(judge1(brr[i], n))
                add_edge(ss, i, arr[i]), printf("%d %d\n", ss, i);
            if(judge3(crr[i], n))
                add_edge(m + i, tt, arr[i]), printf("%d %d\n", m + i, tt);
            for(int j = 1; j <= m; j++)
            {
                if(j == i) continue;
                if(judge2(brr[j], crr[i], n))
                    add_edge(m + i, j, arr[i]), printf("%d %d\n", m + i, j);
            }
        }
        nv = tt + 1;
        printf("%d", sap(ss, tt));
        memset(vis, 0, sizeof vis);
        dfs(tt);
        printf(" %d\n", vec.size());
        for(int i = 0; i < vec.size(); i++)
            printf("%d %d %d\n", vec[i].v, vec[i].u, vec[i].cap);
        vec.clear();
    }
    return 0;
}

直接遍历残余网络求路径

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <cmath>
#include <queue>
using namespace std;

typedef long long ll;
typedef pair<int, int> P;
const int INF = 0x3f3f3f3f;
const int N = 210;
struct edge
{
    int to, cap, id, next;
} g[N*N*10];
struct node
{
    int v, u, cap;
}e;
vector<node> vec;
int head[N], pre[N], cur[N], gap[N], level[N];
int cnt, nv, cas = 0;
int arr[N], brr[N][N], crr[N][N];
int ss, tt;
int n, m;
bool vis[N];
void add_edge(int v, int u, int cap)
{
    g[cnt].to = u, g[cnt].cap = cap, g[cnt].id = 0, g[cnt].next = head[v], head[v] = cnt++;
    g[cnt].to = v, g[cnt].cap = 0, g[cnt].id = 1, g[cnt].next = head[u], head[u] = cnt++;
}
int sap(int s, int t)
{
    memset(level, 0, sizeof level);
    memset(gap, 0, sizeof gap);
    memcpy(cur, head, sizeof head);
    gap[0] = nv;
    int v = pre[s] = s, flow = 0, aug = INF;
    while(level[s] < nv)
    {
        bool flag = false;
        for(int &i = cur[v]; i != -1; i = g[i].next)
        {
            int u = g[i].to;
            if(g[i].cap > 0 && level[v] == level[u] + 1)
            {
                flag = true;
                pre[u] = v;
                v = u;
                aug = min(aug, g[i].cap);
                if(v == t)
                {
                    flow += aug;
                    while(v != s)
                    {
                        v = pre[v];
                        g[cur[v]].cap -= aug;
                        g[cur[v]^1].cap += aug;
                    }
                    aug = INF;
                }
                break;
            }
        }
        if(flag) continue;
        int minlevel = nv;
        for(int i = head[v]; i != -1; i = g[i].next)
        {
            int u = g[i].to;
            if(g[i].cap > 0 && minlevel > level[u])
                minlevel = level[u], cur[v] = i;
        }
        if(--gap[level[v]] == 0) break;
        level[v] = minlevel + 1;
        gap[level[v]]++;
        v = pre[v];
    }
    return flow;
}
bool judge1(int a[], int n)
{
    for(int i = 1; i <= n; i++)
        if(a[i] == 1)
            return false;
    return true;
}
bool judge2(int a[], int b[], int n)
{
    for(int i = 1; i <= n; i++)
        if(a[i] != b[i] && a[i] != 2) return false;
    return true;
}
bool judge3(int a[], int n)
{
    for(int i = 1; i <= n; i++)
        if(a[i] != 1) return false;
    return true;
}
int main()
{
    while(~ scanf("%d%d", &n, &m))
    {
        cnt = 0;
        memset(head, -1, sizeof head);
        for(int i = 1; i <= m; i++)
        {
            scanf("%d", &arr[i]);
            for(int j = 1; j <= n; j++)
                scanf("%d", &brr[i][j]);
            for(int j = 1; j <= n; j++)
                scanf("%d", &crr[i][j]);
        }
        ss = 0, tt = 2 * m + 1;
        for(int i = 1; i <= m; i++)
        {
            add_edge(i, m + i, arr[i]);
            if(judge1(brr[i], n))
                add_edge(ss, i, arr[i]);
            if(judge3(crr[i], n))
                add_edge(m + i, tt, arr[i]);
            for(int j = 1; j <= m; j++)
            {
                if(j == i) continue;
                if(judge2(brr[j], crr[i], n))
                    add_edge(m + i, j, arr[i]);
            }
        }
        nv = tt + 1;
        printf("%d", sap(ss, tt));

        for(int i = m + 1; i <= 2 * m; i++)
            for(int j = head[i]; j != -1; j = g[j].next)
            {
                if(i - m == g[j].to || g[j].to == tt) continue;//不是和自身相连，另外一端不是汇点
                if(g[j^1].cap > 0) //反向边容量大于0
                {
                    e.v = i - m, e.u = g[j].to, e.cap = g[j^1].cap;
                    vec.push_back(e);
                }
            }
        printf(" %d\n", vec.size());
        for(int i = 0; i < vec.size(); i++)
            printf("%d %d %d\n", vec[i].v, vec[i].u, vec[i].cap);
        vec.clear();
    }
    return 0;
}



霜刃未曾试
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
POJ3436-ACM Computer Factory
07-30
【标题】"POJ3436 - ACM Computer Factory"是一个经典的在线编程竞赛题目，源自北京大学的编程平台POJ（Problem Set）。这个题目主要考察选手的算法设计与实现能力，尤其是图论中的广度优先搜索（BFS）以及在解决...
POJ一些ACM题的代码
07-22
【标题】"POJ一些ACM题的代码"揭示了这个压缩包主要包含的是与ACM（国际大学生程序设计竞赛）相关的编程代码，特别强调了是针对POJ（Problem Online Judge）平台的题目。POJ是中国最早的在线评测系统之一，为参赛者...
LA 2957 最大流，最短时间，输出路径
weixin_34354173的博客
03-12 122
题目链接：https://icpcarchive.ecs.baylor.edu/index.php?option=com_onlinejudge&Itemid=8&category=159&page=show_problem&problem=958 题意：n个星球，用最短的时间把k个超级计算机从s运到t； 其中，每个隧道是双向的，一个隧道里面只能有一个飞船在使用...
【最大流 && 输出路径】POJ - 3436 ACM Computer Factory
ACMer 梁剑锋 的博客
09-20 289
Problem Description 输入p, n代表一个机器由p个部件(0代表没有该部件，1代表有)，n代表有n种转换方式。接下来n行每行输入，a[i], in[i][1] … in[i][p], out[i][1]…out[i][p]。例如：15 0 0 0 0 1 0，机器人身上的部件满足0 0 0可以转换成0 1 0，最大可以转换15台。问你最后产生1 1 1的机器人有几
poj 3436 ACM Computer Factory 【图论-网络流-最大流-EK-输出路径】
逝去的时光
04-19 853
ACM Computer Factory Time Limit: 1000MS Memory Limit: 65536K Special Judge Description As you know, all the computers used for ACM contests must be id
POJ-3436-ACM Computer Factory（最大流+输出路径，矩阵的遍历）
永远鲜红の幼月的博客
08-19 384
题目链接：http://poj.org/problem?id=3436 Description As you know, all the computers used for ACM contests must be identical, so the participants compete on equal terms. That is why all these computers ar...
POJ-3436(网络流+最大流+输出路径)
08-30 181
ACM Computer Factory POJ-3436 题目就是一个工厂n个加工机器，每个机器有一个效率w，q个材料入口，q个材料出口，每个口有三个数表示状态，1表示一定有入/出的材料，0表示没有入/出的材料，2表示可能有入的材料。如果一个机器入口全是0，代表这是起始机器，如果一个机器出口全是1，那么代表这是末尾机器。 将每个机器i拆成两点i和i+n分别代表进和出 建立超级源点，连...
poj-ACM.zip_ 1706 References_ACM_ACM习题
最新发布
09-24
【标题】"poj-ACM.zip_ 1706 References_ACM_ACM习题" 提供的是一份关于ACM（国际大学生程序设计竞赛，简称ICPC）的资源包，其中包含了ACM竞赛中的习题源码、原题、分析以及详细的解答。这些资源对于准备参加ACM竞赛...
ACM.zip_ACM_poj_poj3187_poj3669
09-23
标题 "ACM.zip_ACM_poj_poj3187_poj3669" 提供的信息表明，这个压缩包包含的是与ACM（国际大学生程序设计竞赛）相关的编程题目解决方案，具体是POJ（Programming Online Judge）平台上的两道题目，编号分别为poj3187...
poj 3901 The Computer Game.md
11-17
poj 3901 The Computer Game.md
POJ 3436-ACM Computer Factory（最大流输出路径-Edmond-Karp算法）
Some.
02-13 1028
ACM Computer Factory Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 7445   Accepted: 2664   Special Judge Description As you know, all the computers used
拆点最大流-POJ-3436-ACM Computer Factory
懒鬼的私人泳池
04-25 490
ACM Computer Factory Time Limit: 1000MS Memory Limit: 65536K Total Submissions: 6674 Accepted: 2345 Special JudgeDescriptionAs you know, all the computers used for ACM contests must be
Gym 101606K Knightsbridge Rises（最大流+输出路径）
LP_Cong
04-04 535
High-rise buildings in the wealthy retail district of Knightsbridge are usually built with exotichoisting machines known, in construction circles, as cranes.While it is common to mount these devices o...
网络流 最大流+拆点+路径输出
H_ang的博客
03-28 799
题目链接：http://poj.org/problem?id=3436 题目大意： 电脑公司生产电脑有N个机器，每个机器单位时间产量为Qi。 电脑由P个部件组成，每个机器工作时只能把有某些部件的半成品电脑(或什么都没有的空电脑）变成有另一些部件的半成品电脑或完整电脑(也可能移除某些部件）。求电脑公司的单位时间最大产量，以及哪些机器有协作关系，即一台机器把它的产品交给哪些机器加工。 Sample i...
【最大流+输出路径】POJ-3436 ACM Computer Factory
JSure的代码库
09-22 1126
ACM Computer Factory Time Limit: 1000MS   Memory Limit: 65536K Special Judge         Description As you know, all the computers used for ACM contests must be identical,
POJ 2914 Minimum Cut 全局最小割
弱智就要多努力
09-16 2296
题目：http://poj.org/problem?id=2914 题意：给定一个无向图，两点之间可以有很多边连接，问至少去掉多少条边可以把图分成两个不相连的子图 思路：可以把边数直接看成一条带权边，全局最小割模板题。 转自大牛博客： 算法基于这样一个定理：对于任意s, t   V ∈ ，全局最小割或者等于原图的s-t 最小割，或者等于将原图进行 Contract(s,  t)操作所得的
poj 3469 最大流-最小割 SAP算法模板
弱智就要多努力
06-05 1348
题目：http://poj.org/problem?id=3469 题意：有双核处理器，有n个任务，给出每个任务在分别在两个处理核心上工作的花费，然后有m行，每行给出两个任务，如果两个任务不在同一个处理核心上工作，那么将有额外的花费。求最小花费 思路：最小割。之前用dinic算法做的，加上当前弧优化6000ms。省赛的时候yjj看到我的最大流板子是 dinic，说到你怎么用这个
dinic模板 当前弧+多路增广
弱智就要多努力
04-21 957
题目：http://poj.org/problem?id=3469 实测发现，当前弧、多路增广和当前弧+多路增广这三种优化其实差不多。。。但还是留个模板吧只有当前弧：#include <iostream> #include <cstdio> #include <cstring> #include <algorithm> #include <queue> using namesp
LightOJ 1398 Winger Trial 最大流
弱智就要多努力
06-10 940
题目：http://www.lightoj.com/volume_showproblem.php?problem=1398 题意：一个L * W的矩形场地，在第一象限，左下为（0,0），右上为（L,W），上面有n个机器人，给出了它们的坐标，当距离机器人的距离小于等于d时，机器人会拦截。求当一个人从矩形左侧穿过矩形走到右侧时，最少会被拦截几次 思路：刚开始想从左到右直接建图，结果
acm部分模板
01-29
在图论部分模板中，主要包括了图的表示方法、常见的图遍历算法（如DFS和BFS）、最短路径算法（如Dijkstra算法和Floyd-Warshall算法）、最小生成树算法（如Prim算法和Kruskal算法）以及网络流算法（如最大流最小割...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值