POJ - 3436 ACM Computer Factory （ISAP EK Dinic）

最新推荐文章于 2018-04-17 22:17:50 发布
最新推荐文章于 2018-04-17 22:17:50 发布
阅读量792 收藏
点赞数
分类专栏： ACM-图论-网络流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L123012013048/article/details/47217907
版权

题目大意：有N台机器，每台机器能处理相应型态的电脑，处理完后，电脑将变成另一种形态。
每台机器有相应的工作限度，每次至多处理K台
现在问，在一次流水线生产中，最多可以产生多少台完整的电脑（流水线指的是在每一台机器的工作限度下）

解题思路：题目比较难理解，理解题目的话，就比较好做了
首先，将每台机器的点拆成两个点，权值为工作限度
如果机器能处理的电脑的状态全是0的话，就将其和超级源点连接，表示该机器进行第一步加工
如果机器处理完后的形态与另一台机器能处理的最初形态相同，就将其连线，表示下一台机器可以将其处理完的电脑再进一步加工
如果机器处理完后形态都为1，表示完工，将其和超级汇点相连，接着跑最大流

ISAP

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
#define N 1010
#define INF 0x3f3f3f3f

struct Edge {
    int from, to, cap, flow;
    Edge() {}
    Edge(int from, int to, int cap, int flow): from(from), to(to), cap(cap), flow(flow) {}
};
int g[70][70];

struct ISAP {
    int p[N], num[N], cur[N], d[N];
    int t, s, n, m;
    bool vis[N];

    vector<int> G[N];
    vector<Edge> edges;

    void init(int n) {
        this->n = n;
        for (int i = 0; i <= n; i++) {
            G[i].clear();
            d[i] = INF;
        }
        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));
        int m = edges.size();
        G[from].push_back(m - 2);
        G[to].push_back(m - 1);
    }

    bool BFS() {
        memset(vis, 0, sizeof(vis));

        queue<int> Q;
        d[t] = 0;
        vis[t] = 1;
        Q.push(t);

        while (!Q.empty()) {
            int u = Q.front();
            Q.pop();

            for (int i = 0; i < G[u].size(); i++) {
                Edge &e = edges[G[u][i] ^ 1];
                if (!vis[e.from] && e.cap > e.flow) {
                    vis[e.from] = true;
                    d[e.from] = d[u] + 1;
                    Q.push(e.from);
                }
            }
        }
        return vis[s];
    }

    int Augment() {
        int u = t, flow = INF;
        while (u != s) {
            Edge &e = edges[p[u]];
            flow = min(flow, e.cap - e.flow);
            u = edges[p[u]].from;
        }

        u = t;
        while (u != s) {
            edges[p[u]].flow += flow;
            edges[p[u] ^ 1].flow -= flow;
            u = edges[p[u]].from;
        }
        return flow;
    }

    int Maxflow(int s, int t) {
        this->s = s; this->t = t;
        int flow = 0;
        BFS();
        if (d[s] >= n)
            return 0;

        memset(num, 0, sizeof(num));
        memset(cur, 0, sizeof(cur));
        for (int i = 0; i < n; i++)
            if (d[i] < INF)
                num[d[i]]++;
        int u = s;

        while (d[s] < n) {
            if (u == t) {
                flow += Augment();
                u = s;
            }
            bool ok = false;
            for (int i = cur[u]; i < G[u].size(); i++) {
                Edge &e = edges[G[u][i]];
                if (e.cap > e.flow && d[u] == d[e.to] + 1) {
                    ok = true;
                    p[e.to] = G[u][i]; 
                    cur[u] = i;
                    u = e.to;
                    break;
                }
            }

            if (!ok) {
                int Min = n - 1 ;
                for (int i = 0; i < G[u].size(); i++) {
                    Edge &e = edges[G[u][i]];
                    if (e.cap > e.flow)
                        Min = min(Min, d[e.to]);
                }
                if (--num[d[u]] == 0)
                    break;
                num[d[u] = Min + 1]++;
                cur[u] = 0;
                if (u != s)
                    u = edges[p[u]].from;
            }
        }
        return flow;
    }
};

ISAP isap;

#define M 70
#define P 20
int in[M][P], out[M][P], f[M];
int n, m;

bool NullJudge(int cur) {
    for (int i = 1; i <= n; i++)
        if (in[cur][i] == 1)
            return false;
    return true;
}

bool FullJudge(int cur) {
    for (int i = 1; i <= n; i++)
        if (!out[cur][i])
            return false;
    return true;
}

bool connect(int x, int y) {
    for (int i = 1; i <= n; i++)
        if (out[x][i] + in[y][i] == 1)
            return false;
    return true;
}

void init() {

    for (int i = 1; i <= m; i++) {
        scanf("%d", &f[i]);

        for (int j = 1; j <= n; j++)
            scanf("%d", &in[i][j]);

        for (int j = 1; j <= n; j++)
            scanf("%d", &out[i][j]);
    }
    int s = 2 * m + 1;
    int t = 2 * m + 2;
    isap.init(t);

    for (int i = 1; i <= m; i++) {
        isap.AddEdge(i, i + m, f[i]);
        if (NullJudge(i))
            isap.AddEdge(s, i, f[i]);
        if (FullJudge(i))
            isap.AddEdge(i + m, t, f[i]);

        for (int j = 1; j <= m; j++) 
            if (i != j && connect(i, j))
                isap.AddEdge(i + m, j, f[i]);
    }

    int ans[M][P];
    int flow = isap.Maxflow(s, t);
    int cnt = 0;
    for (int i = m + 1; i <= m + m; i++)
        for (int j = 0; j < isap.G[i].size(); j++) {
            int v = isap.G[i][j];
            Edge &e = isap.edges[v];

            if (e.flow > 0 && e.to <= m) {
                ans[cnt][0] = i - m;
                ans[cnt][1] = e.to;
                ans[cnt][2] = e.flow;
                cnt++;
            }
        }

    printf("%d %d\n", flow, cnt);
    for (int i = 0; i < cnt; i++)
        printf("%d %d %d\n", ans[i][0], ans[i][1], ans[i][2]);
}

int main() {
    while (scanf("%d%d", &n, &m) == 2) {
        init();
    }
    return 0;
}

EK

#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
#include <vector>
using namespace std;
#define N 1010
#define INF 0x3f3f3f3f

struct Edge{
    int from, to, cap, flow;
    Edge() {}
    Edge(int from, int to, int cap, int flow): from(from), to(to), cap(cap), flow(flow){}
};

struct EK{
    vector<int> G[N];
    vector<Edge> edges;
    int s, t, n, m, p[N];
    bool vis[N];

    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));
        m = edges.size();
        G[from].push_back(m - 2);
        G[to].push_back(m - 1);
    }

    bool BFS() {
        queue<int> q;
        memset(vis, 0, sizeof(vis));
        vis[s] = 1;
        q.push(s);

        while (!q.empty()) {
            int u = q.front();
            q.pop();

            for (int i = 0; i < G[u].size(); i++) {
                Edge &e = edges[G[u][i]];
                if (!vis[e.to] && e.cap > e.flow) {
                    vis[e.to] = true;
                    p[e.to] = G[u][i];
                    if (e.to == t)
                        return true;
                    q.push(e.to);
                }
            }
        }
        return false;
    }

    int Augment() {
        int flow = INF, u = t;
        while (u != s) {
            Edge &e = edges[p[u]];
            flow = min(flow, e.cap - e.flow);
            u = e.from;
        }

        u = t;
        while (u != s) {
            edges[p[u]].flow += flow;
            edges[p[u] ^ 1].flow -= flow;
            u = edges[p[u]].from;
        }
        return flow;
    }

    int Maxflow(int s, int t) {
        this->s = s; this->t = t;
        int flow = 0;

        while (BFS()) {
            flow += Augment();
        }
        return flow;
    }
};

EK ek;

#define M 70
#define P 20
int in[M][P], out[M][P], f[M];
int n, m;

bool NullJudge(int cur) {
    for (int i = 1; i <= n; i++)
        if (in[cur][i] == 1)
            return false;
    return true;
}

bool FullJudge(int cur) {
    for (int i = 1; i <= n; i++)
        if (!out[cur][i])
            return false;
    return true;
}

bool connect(int x, int y) {
    for (int i = 1; i <= n; i++)
        if (out[x][i] + in[y][i] == 1)
            return false;
    return true;
}

void init() {

    for (int i = 1; i <= m; i++) {
        scanf("%d", &f[i]);

        for (int j = 1; j <= n; j++)
            scanf("%d", &in[i][j]);

        for (int j = 1; j <= n; j++)
            scanf("%d", &out[i][j]);
    }
    int s = 2 * m + 1;
    int t = 2 * m + 2;
    ek.init(t);

    for (int i = 1; i <= m; i++) {
        ek.AddEdge(i, i + m, f[i]);
        if (NullJudge(i))
            ek.AddEdge(s, i, f[i]);
        if (FullJudge(i))
            ek.AddEdge(i + m, t, f[i]);

        for (int j = 1; j <= m; j++) 
            if (i != j && connect(i, j))
                ek.AddEdge(i + m, j, f[i]);
    }

    int ans[M][P];
    int flow = ek.Maxflow(s, t);
    int cnt = 0;
    for (int i = m + 1; i <= m + m; i++)
        for (int j = 0; j < ek.G[i].size(); j++) {
            int v = ek.G[i][j];
            Edge &e = ek.edges[v];

            if (e.flow > 0 && e.to <= m) {
                ans[cnt][0] = i - m;
                ans[cnt][1] = e.to;
                ans[cnt][2] = e.flow;
                cnt++;
            }
        }

    printf("%d %d\n", flow, cnt);
    for (int i = 0; i < cnt; i++)
        printf("%d %d %d\n", ans[i][0], ans[i][1], ans[i][2]);
}

int main() {
    while (scanf("%d%d", &n, &m) == 2) {
        init();
    }
    return 0;
}

Dinic

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
#define N 1010
#define INF 0x3f3f3f3f

struct Edge{
    int from, to, cap, flow;
    Edge() {}
    Edge(int from, int to, int cap, int flow) : from(from), to(to), cap(cap), flow(flow) {}
};

struct Dinic{
    int n, m, s, t;
    vector<Edge> edges;
    vector<int> G[N];
    bool vis[N];
    int d[N], cur[N];

    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));
        int m = edges.size();
        G[from].push_back(m - 2);
        G[to].push_back(m - 1);
    } 

    bool BFS() {
        memset(vis, 0, sizeof(vis));
        queue<int> Q;
        Q.push(s);
        vis[s] = 1;
        d[s] = 0;

        while (!Q.empty()) {
            int u = Q.front();
            Q.pop();
            for (int i = 0; i < G[u].size(); i++) {
                Edge &e = edges[G[u][i]];
                if (!vis[e.to] && e.cap > e.flow) {
                    vis[e.to] = true;
                    d[e.to] = d[u] + 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;
    }

    int Maxflow(int s, int t) {
        this->s = s; this->t = t;
        int flow = 0;
        while (BFS()) {
            memset(cur, 0, sizeof(cur));
            flow += DFS(s, INF);
        }
        return flow;
    }
};

Dinic dinic;



#define M 70
#define P 20
int in[M][P], out[M][P], f[M];
int n, m;

bool NullJudge(int cur) {
    for (int i = 1; i <= n; i++)
        if (in[cur][i] == 1)
            return false;
    return true;
}

bool FullJudge(int cur) {
    for (int i = 1; i <= n; i++)
        if (!out[cur][i])
            return false;
    return true;
}

bool connect(int x, int y) {
    for (int i = 1; i <= n; i++)
        if (out[x][i] + in[y][i] == 1)
            return false;
    return true;
}

void init() {

    for (int i = 1; i <= m; i++) {
        scanf("%d", &f[i]);

        for (int j = 1; j <= n; j++)
            scanf("%d", &in[i][j]);

        for (int j = 1; j <= n; j++)
            scanf("%d", &out[i][j]);
    }
    int s = 2 * m + 1;
    int t = 2 * m + 2;
    dinic.init(t);

    for (int i = 1; i <= m; i++) {
        dinic.AddEdge(i, i + m, f[i]);
        if (NullJudge(i))
            dinic.AddEdge(s, i, f[i]);
        if (FullJudge(i))
            dinic.AddEdge(i + m, t, f[i]);

        for (int j = 1; j <= m; j++) 
            if (i != j && connect(i, j))
                dinic.AddEdge(i + m, j, f[i]);
    }

    int ans[M][P];
    int flow = dinic.Maxflow(s, t);
    int cnt = 0;
    for (int i = m + 1; i <= m + m; i++)
        for (int j = 0; j < dinic.G[i].size(); j++) {
            int v = dinic.G[i][j];
            Edge &e = dinic.edges[v];

            if (e.flow > 0 && e.to <= m) {
                ans[cnt][0] = i - m;
                ans[cnt][1] = e.to;
                ans[cnt][2] = e.flow;
                cnt++;
            }
        }

    printf("%d %d\n", flow, cnt);
    for (int i = 0; i < cnt; i++)
        printf("%d %d %d\n", ans[i][0], ans[i][1], ans[i][2]);
}

int main() {
    while (scanf("%d%d", &n, &m) == 2) {
        init();
    }
    return 0;
}
暗金色
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
POJ3436-ACM Computer Factory
07-30
北大POJ3436-ACM Computer Factory 解题报告+AC代码
POJ-ACM Computer Factory（EK算法模板）
wjhshuai的博客
01-07 180
题目大意： 有n台机器，P种零件，每种零件有 0  和  1  两种状态，接下来有n行，每行第一个表示机器的效率，其余表示每台机器对于P零件的需求 0 表示不需要，1表示需要，2表示无所谓。现在需要找一些生产线可以把全部的零件制造出来（使零件的状态为1，起始状态为0）。求这些的生产线的最大生产量，并记录有几条生产线和每条生产线的路径 作为一道比较简单的网络流的题目！ 这道题的主要问题为：
POJ3436 ACM Computer Factory【EK算法】
weixin_34005042的博客
10-14 75
题意： 每个电脑需要P个组成部分，现有N的机器，每个机器都可以对电脑进行加工，不过加工的前提是某些部分已经存在，加工后会增加某些部分。且在单位时间内，每个机器的加工都有一个最大加工容量，求能得到的最大的流量，并且输出流经的所有路径。 思路： 最大流，EK算法。先建图，这里用邻接矩阵能比较简洁，由于每个机器(点)有权值，所以拆点，中间由与其权值想等的边连接，然后两两匹配，看是否能构成边。 代...
POJ3436 ACM Computer Factory（最大流/Dinic）题解
努力，奋斗
04-17 334
ACM Computer FactoryTime Limit: 1000MS Memory Limit: 65536KTotal Submissions: 8944 Accepted: 3267 Special JudgeDescriptionAs you know, all the computers used for ACM contests must be identical, so the...
ACM Computer Factory--最大流EK()算法
bless295的博客
08-17 460
ACM Computer Factory Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 7026   Accepted: 2486   Special Judge Description As you know, all the computers use
poj3436-ACM Computer Factory
smartxxyx的专栏
05-22 1820
这题的关键在于建图，然后最大流算法，而建图的关键在于拆点。将每个点拆为两个点，两点之间的流为performance。和其他点相连的边容量为INF。
poj-ACM.zip_ 1706 References_ACM_ACM习题
09-24
本文件是ACM里的一些题目的源码、原题和习题的分析及详细解答。欢迎各位下载
poj-1028-Web-Navigation.zip_poj
09-21
poj 1028 Web Navigation 的代码，已通过!
poj-problem.rar_poj
09-22
poj的结题报告，里面有一些详细的说明。poj的结题报告，里面有一些详细的说明
poj-1009.rar_poj
09-23
POJ 北大在线代码判断,参考答案请参考
[ACM模板]Network Flows网络流 ISAP
vcvycy的专栏
10-11 209
#include #include #include #include #include #include #include #include using namespace std; struct EDGE{ int from,to,flow,cap; EDGE(int x=0,int y=0,int z=0){from=x;to=y;flow=0;cap=z;} }; /* 用法:
POJ 3436 ACM Computer Factory EK .
BRCOCOLI的博客
08-18 250
题目地址：http://poj.org/problem?id=3436 写了起码4hour+.... 假设两个超级汇点源点，到000，和111点 因为p最大只有10，所以一个整数就能保存 保存点比较麻烦，一开始想的是map 给每个点一个id，但是两个相同的点，比如说010，不能看成同一个点，因为机器都不同，等下路径都找不了了 所以用in[]，out[]保存出来的点和进去的点，当out[u
ISAP算法
ACM之梦
03-25 587
struct EDGE{ int v,next,c,f; }E[maxn<<1]; int head[maxn],tol; int gap[maxn],dep[maxn],pre[maxn],cur[maxn]; void Init(){ memset(head,-1,sizeof head); tol=0; } void add_edge(int u,int v,in
POJ3436 ACM Computer Factory
weixin_30794491的博客
10-19 130
POJ3436 ACM Computer Factory Time Limit:1000MS Memory Limit:65536K Total Submissions:3345 Accepted:1112 Special Judge Description As you know, all the computer...
POJ3436--ACM Computer Factory--拆点EK算法求最大流
SCUT_Pein
02-06 556
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 are historically produced at the same
kuangbin求带飞网络流 ACM Computer Factory（最大流节点型）
Coldplay
08-26 1152
A - ACM Computer Factory Time Limit:1000MS     Memory Limit:65536KB     64bit IO Format:%lld & %llu Submit Status Description As you know, all the computers used for ACM contests mus
POJ 3680 Intervals(区间k覆盖问题)
静静地码
09-04 2006
题目大意：给出N个区间，每个区间都有相应的收益。限制是每个数最多被覆盖k次 问如何选择区间，才能使得受益最大解题思路：区间k覆盖问题，首先点和边很多，所以离散化 接着是源点连接第一个点，容量为k，费用为0(保证每个数最多被覆盖k次) 最后一个点连接汇点，容量为k，费用为0 剩下的是点之间的关系了 我们按从小到达排序，然后每个点之间连一条边，容量至少大于等于k(因为源点到第一个点已经限制了是
UVA - 11613 Acme Corporation(最小费用流)
静静地码
08-25 1867
题目大意：A公司生产一种元素，给出该元素在未来M个月中每个月的单位售价，最大生产量，生产成本，最大销售量和最大存储时间，和每月存储代价，问这家公司在M个月内所能赚大的最大利润解题思路：这题建图还是比较简单的。主要说一下怎么跑出答案吧。我用的是MCMF，建边的时候，费用我用的是相反数，所以得到最小费用后要去相反数 MCMF的时候，用一个数组纪录了到达汇点时所花费的最小价值，因为取的是相反数，所以当价
UVALive - 2531 The K-League(最大流＋枚举)
静静地码
08-31 1380
题目大意：有n支队伍进行比赛，每支队伍需要打的比赛次数相同，每场比赛恰好有一支队伍胜，一支队伍败，给出每支队伍目前胜的场数和败的场数，以及每两支队伍还剩下的比赛场数，确定所有可能得冠军的队伍解题思路：枚举每支队伍，然后让该队伍在接下来的所有比赛中都获胜。 建图的话，就比较简单了，源点连向每场比赛，容量为比赛次数 每场比赛连向比赛队伍，容量为比赛次数 接着每支队伍连向汇点，容量为枚举队伍的总胜场
POJ - 1661
最新发布
09-18
根据提供的引用内容，这个问题讨论的是POJ-1661题，这是一个dp问题。题目给定了一系列平台的高度和人的起始位置，要求从起始位置跳到地面的最短时间。通过设置状态dp[i]表示从第i个平台的左边跳到地面所需的最小时间...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值