算法整理 & 复习：网络流 24 题

最新推荐文章于 2021-03-30 13:15:57 发布
最新推荐文章于 2021-03-30 13:15:57 发布
阅读量943 收藏 6
点赞数 1
分类专栏： 数据结构与算法 文章标签： 网络流 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SP_FA/article/details/113928715
版权

文章目录



一、最大流 & 最小割问题



1. 模板

P3376 【模板】网络最大流


1.1 Ford-Fulkerson


由于这个算法复杂度玄学，所以会 T 掉两个点。

#include <stdio.h>
#include <string.h>
#include <iostream>
using namespace std;
#define MAXN 5005
#define INF 0x3f3f3f3f

int n, m, s, t;
int vis[MAXN];
int head[MAXN], cnt;

struct node{
    int to, w;
    int next;
}map[MAXN*2];

void add(int u, int v, int w)
{
    map[cnt] = (node){v, w, head[u]};
    head[u] = cnt++;
}

int dfs(int u, int flow)
{
    if (u == t) return flow;
    vis[u] = 1;
    for (int k=head[u];k!=-1;k=map[k].next)
    {
        int v = map[k].to;
        int w = map[k].w;
        int delta = 0;
        if(!vis[v] && w > 0 && (delta = dfs(v, min(flow, w))) != -1)
        {
            map[k].w -= delta;
            map[k ^ 1].w += delta;
            return delta;
        }
    }
    return -1;
}

long long FF(void)
{
    int delta = 0;
    long long ans = 0;
    while ((delta = dfs(s, INF)) != -1)
    {
        memset(vis, 0, sizeof(vis));
        ans += delta;
    }
    return ans;
}

int main(void)
{
    memset(head, -1, sizeof(head));
    cin >> n >> m >> s >> t;
    for (int i=1;i<=m;i++)
    {
        int u, v, w;
        cin >> u >> v >> w;
        add(u, v, w);
        add(v, u, 0);
    }
    cout << FF() << endl;
    return 0;
}

1.2 Edmond-Karp

#include <queue>
#include <string.h>
#include <stdio.h>
#include <iostream>
using namespace std;
#define MAXN 5005
#define INF 0x3f3f3f3f

int n, m, s, t;
int last[MAXN], flow[MAXN];
int head[MAXN], cnt;

struct node{
	int to, w;
	int next;
}map[MAXN*2];

void add(int u, int v, int w)
{
    map[cnt] = (node){v, w, head[u]};
    head[u] = cnt++;
}

bool bfs(void)
{
    memset(last, -1, sizeof last);
    queue <int>que;
    que.push(s);
    flow[s] = INF;
    while (!que.empty())
    {
        int u = que.front();
        que.pop();
        if (u == t) break;
        for (int k=head[u];k!=-1;k=map[k].next)
        {
            int v = map[k].to;
            int w = map[k].w;
            if (w != 0 && last[v] == -1)
            {
                last[v] = k;
                flow[v] = min(w, flow[u]);
                que.push(v);
            }
        }
    }
    return last[t] != -1;
}

long long EK()
{
    long long ans = 0;
    while (bfs())
    {
        ans += flow[t];
        for (int i=t;i!=s;i=map[last[i] ^ 1].to)
        {
            map[last[i]].w -= flow[t];
            map[last[i] ^ 1].w += flow[t];
        }
    }
    return ans;
}

int main(void)
{
    memset(head, -1, sizeof head);
    cin >> n >> m >> s >> t;
    for (int i=1;i<=m;i++)
    {
        int u, v, w;
        cin >> u >> v >> w;
        add(u, v, w);
        add(v, u, 0);
    }
    cout << EK() << endl;
	return 0;
}

1.3 Dinic

#include <queue>
#include <stdio.h>
#include <string.h>
#include <iostream>
using namespace std;
#define MAXN 5005
#define INF 0x3f3f3f3f

int n, m, s, t;
int temp[MAXN], dep[MAXN];
int head[MAXN], cnt;

struct node{
    int to, w, next;
}map[MAXN*2];

void add(int u, int v, int w)
{
    map[cnt] = (node){v, w, head[u]};
    head[u] = cnt++;
}

int bfs()
{
    memset(dep, -1, sizeof dep);
    memcpy(temp, head, sizeof head);
    queue <int> que;
    que.push(s);
    dep[s] = 0;
    while (!que.empty())
    {
        int u = que.front();
        que.pop();
        for (int k=head[u];k!=-1;k=map[k].next)
        {
            int v = map[k].to;
            int w = map[k].w;
            if (w && dep[v] == -1)
            {
                dep[v] = dep[u] + 1;
                que.push(v);
            }
        }
    }
    return dep[t] != -1;
}

int dfs(int u, int flow)
{
    if (u == t)
    {
        return flow;
    }
    int rmnd = flow;
    for (int k=temp[u];k!=-1 && rmnd;k=map[k].next)
    {
        temp[u] = k;
        int v = map[k].to;
        int w = map[k].w;
        if (w && dep[v] == dep[u] + 1)
        {
            int delta = dfs(v, min(rmnd, w));
            rmnd -= delta;
            map[k].w -= delta;
            map[k ^ 1].w += delta;
        }
    }
    return flow - rmnd;
}

long long Dinic(void)
{
    long long ans = 0;
    while (bfs())
    {
        ans += dfs(s, INF);
    }
    return ans;
}

int main(void)
{
    memset(head, -1, sizeof head);
    cin >> n >> m >> s >> t;
    for (int i=1;i<=m;i++)
    {
        int u, v, w;
        cin >> u >> v >> w;
        add(u, v, w);
        add(v, u, 0);
    }
    cout << Dinic() << endl;
    return 0;
}


2. 题目


(1) P2756 飞行员配对方案问题

题目链接


#include <queue>
#include <stdio.h>
#include <string.h>
#include <iostream>
using namespace std;
#define MAXN 10005
#define INF 0x3f3f3f3f

int n, m;
int vis[MAXN], dep[MAXN], temp[MAXN], match[MAXN];
int head[MAXN], cnt = 1;

struct node{
    int to, w, next;
}map[MAXN * 2];

void add(int u, int v, int w)
{
    map[++cnt] = (node){v, w, head[u]};
    head[u] = cnt;
}

bool bfs()
{
    memset(dep, -1, sizeof dep);
    memcpy(temp, head, sizeof head);
    queue <int>que;
    que.push(0);
    dep[0] = 0;
    while (!que.empty())
    {
        int u = que.front();
        que.pop();
        for (int k=head[u];k;k=map[k].next)
        {
            int v = map[k].to;
            int w = map[k].w;
            if (w && dep[v] == -1)
            {
                dep[v] = dep[u] + 1;
                que.push(v);
            }
        }
    }
    return dep[m+1] != -1;
}
 
int dfs(int u, int flow)
{
    if (u == m + 1) return flow;
    int rmnd = flow;
    for (int k=temp[u];k;k=map[k].next)
    {
        temp[u] = k;
        int v = map[k].to;
        int w = map[k].w;
        if (w && dep[v] == dep[u] + 1)
        {
            int delta = dfs(v, min(w, rmnd));
            rmnd -= delta;
            map[k].w -= delta;
            map[k ^ 1].w += delta;
            if (!map[k].w) match[u] = v;
            if (!rmnd) break;
        }
    }
    return flow - rmnd;
}

int Dinic()
{
    int ans = 0;
    while (bfs())
    {
        ans += dfs(0, INF);
    }
    return ans;
}

int main(void)
{
    cin >> n >> m;
    int u, v;
    cin >> u >> v;
    while (u!=-1 && v!=-1)
    {
        add(u, v, 1);
        add(v, u, 0);
        cin >> u >> v;
    }
    for (int i=1;i<=n;i++)
    {
        add(0, i, 1);
        add(i, 0, 0);
    }
    for (int i=n+1;i<=m;i++)
    {
        add(i, m+1, 1);
        add(m+1, i, 0);
    }
    cout << Dinic() << endl;
    for (int i=1;i<=n;i++)
    {
        if (match[i])
        {
            cout << i << " " << match[i] << endl;
        }
    }
    return 0;
}

顺带一提，这道题还可以用二分图匹配来做。

#include <stdio.h>
#include <string.h>
#include <iostream>
using namespace std;
#define MAXN 10005

int n, m, ans;
int vis[MAXN];
int match[MAXN];
int head[MAXN], cnt;

struct node{
    int to, next;
}map[MAXN * 2];

void add(int u, int v)
{
    map[++cnt] = (node){v, head[u]};
    head[u] = cnt;
}

bool Hungary(int u)
{
    for (int k=head[u];k;k=map[k].next)
    {
        int v = map[k].to;
        if (!vis[v])
        {
            vis[v] = 1;
            if (!match[v] || Hungary(match[v]))
            {
                match[v] = u;
                return 1;
            }
        }
    }
    return 0;
}

int main(void)
{
    cin >> n >> m;
    int u, v;
    cin >> u >> v;
    while(u!=-1 && v!=-1)
    {
        add(u, v);
        cin >> u >> v;
    }
    for (int i=1;i<=n;i++)
    {
        memset(vis, 0, sizeof vis);
        ans += Hungary(i);
    }
    cout << ans << endl;
    for (int i=n+1;i<=m;i++)
    {
        if (match[i])
            cout << match[i] << " " << i << endl;
    }
    return 0;
}

(2) P2763 试题库问题

题目链接


#include <stdio.h>
#include <string.h>
#include <queue>
#include <iostream>
using namespace std;
#define MAXN 200005
#define t n+K+1
#define INF 0x3f3f3f3f

int K, n, m, cnt = 1, s = 0;
int dep[MAXN], temp[MAXN * 2], head[MAXN * 2], vis[MAXN];

struct node{
    int to, next, w;
}map[MAXN*2];

void add(int u, int v, int w)
{
    map[++cnt] = (node){v, head[u], w};
    head[u] = cnt;
}

bool bfs(void)
{
    memset(dep, -1, sizeof dep);
    memcpy(temp, head, sizeof head);
    queue <int> que;
    que.push(s);
    dep[s] = 0;
    while (!que.empty())
    {
        int u = que.front();
        que.pop();
        for (int k=head[u];k;k=map[k].next)
        {
            int v = map[k].to;
            int w = map[k].w;
            if (w && dep[v] == -1)
            {
                dep[v] = dep[u] + 1;
                que.push(v);
            }
        }
    }
    return dep[t] != -1;
}

int dfs(int u, int flow)
{
    if (u == t)
    {
        return flow;
    }
    int rmnd = flow;
    for (int k = temp[u];k && rmnd;k=map[k].next)
    {
        int v = map[k].to;
        int w = map[k].w;
        temp[u] = k;
        if (w && dep[v] == dep[u] + 1)
        {
            int delta = dfs(v, min(rmnd, w));
            rmnd -= delta;
            map[k].w -= delta;
            map[k ^ 1].w += delta;
        }
    }
    return flow - rmnd;
}

int Dinic(void)
{
    int ans = 0;
    while (bfs())
    {
        ans += dfs(s, INF);
    }
    return ans;
}

void print(int u)
{
    for (int k=head[u];k;k=map[k].next)
    {
        int v = map[k].to;
        int w = map[k].w;
        if (v == t) continue;
        if (w == 1 && !vis[v])
        {
            cout << v << " ";
            vis[v] = 1;
        }
    }
}

int main(void)
{
    cin >> K >> n;
    for (int i=1;i<=K;i++)
    {
        int knum;
        cin >> knum;
        m += knum;
        add(i+n, t, knum);
        add(t, i+n, 0);
    }
    for (int i=1;i<=n;i++)
    {
        int num;
        cin >> num;
        for (int j=1;j<=num;j++)
        {
            int ki;
            cin >> ki;
            add(i, ki+n, 1);
            add(ki+n, i, 0);
        }
        add(s, i, 1);
        add(i, s, 0);
    }
    if (Dinic() != m)
    {
        cout << "No Solution!";
        return 0;
    }
    for (int i=1;i<=K;i++)
    {
        cout << i << ": ";
        print(i + n);
        cout << endl;
    }
    return 0;
}

当然，这道题也可以用匈牙利算法做，但是不是主流方法，这里就不给出代码了。 （其实是因为没有这么做）



二、最小费用最大流问题



1. 模板


P3381 【模板】最小费用最大流

#include <queue>
#include <stdio.h>
#include <string.h>
#include <iostream>
using namespace std;
#define MAXN 50005
#define INF 1e9

int n, m, s, t, cost;
int vis[MAXN], dis[MAXN];
int head[MAXN],cnt=1;

struct node{
    int to, w, next, f;
}map[MAXN * 2];

void add(int u, int v, int w, int f)
{
    map[++cnt] = (node){v, w, head[u], f};
    head[u] = cnt;
}

bool SPFA()
{
    memset(vis, 0, sizeof vis);
    for (int i=1;i<=n;i++) dis[i] = INF;
    queue <int> que;
    dis[s] = 0;
    que.push(s);
    while (!que.empty())
    {
        int u = que.front();
        que.pop();
        vis[u] = 0;
        for (int k=head[u];k;k=map[k].next)
        {
            int v = map[k].to;
            int w = map[k].w;
            int f = map[k].f;
            if (dis[v] > dis[u] + f && w)
            {
                dis[v] = dis[u] + f;
                if (!vis[v])
                {
                    vis[v] = 1;
                    que.push(v);
                }
            }
        }
    }
    return dis[t] != INF;
}

int dfs(int u, int flow)
{
    if (u == t) return flow;
    int temp = flow;
    vis[u] = 1;
    for (int k=head[u];k && temp;k=map[k].next)
    {
        int v = map[k].to;
        int w = map[k].w;
        int f = map[k].f;
        if (w && dis[v] == dis[u] + f && !vis[v])
        {
            int delta = dfs(v, min(temp, w));
            temp -= delta;
            map[k].w -= delta;
            map[k ^ 1].w += delta;
            cost += delta * f;
        }
    }
    vis[u] = 0;
    return flow - temp;
}

int Dinic(void)
{
    int ans = 0;
    while (SPFA())
    {
        memset(vis, 0, sizeof vis);
        ans += dfs(s, INF);
    }
    return ans;
} 

int main(void)
{
    cin >> n >> m >> s >> t;
    for (int i=1;i<=m;i++)
    {
        int u, v, w, f;
        cin >> u >> v >> w >> f;
        add(u, v, w,  f);
        add(v, u, 0, -f);
    }
    cout << Dinic() << " " << cost << endl;
    return 0;
}


2. 题目


(2) P4015 运输问题

题目链接


#include <queue>
#include <stdio.h>
#include <string.h>
#include <iostream>
using namespace std;
#define MAXN 10005
#define INF 0x3f3f3f3f

int m, n, s = 0, t = 201, cost;
int cnt = 1;
int head[MAXN], dis[MAXN], vis[MAXN], val[MAXN];

struct node{
    int to, w, w2, next, f, f2;
    void init()
    {
        w = w2;
        f = f2;
    }
}map[MAXN*2];

void add(int u, int v, int w, int f)
{
    map[++cnt] = (node){v, w, w, head[u], f, f};
    head[u] = cnt;
}

bool bfs(int q)
{
    memset(dis, 0x3f, sizeof dis);
    memset(vis, 0, sizeof vis);
    queue <int> que;
    que.push(s);
    dis[s] = 0;
    vis[s] = 1;
    while (!que.empty())
    {
        int u = que.front();
        que.pop();
        vis[u] = 0;
        for (int k=head[u];k;k=map[k].next)
        {
            int v = map[k].to;
            int w = map[k].w;
            int f = map[k].f * q;
            if (w && dis[u] + f < dis[v])
            {
                dis[v] = f + dis[u];
                if (!vis[v])
                {
                    vis[v] = 1;
                    que.push(v);
                }
            }
        }
    }
    return dis[t] != INF;
}

int dfs(int u, int flow, int q)
{
    if (u == t)
    {
        return flow;
    }
    int rmnd = flow;
    vis[u] = 1;
    for (int k=head[u];k && rmnd;k=map[k].next)
    {
        int v = map[k].to;
        int w = map[k].w;
        int f = map[k].f * q;
        if (w && dis[v] == dis[u] + f && !vis[v])
        {
            int delta = dfs(v, min(rmnd, w), q);
            //cout << u << " " << v << " " << w << endl;
            rmnd -= delta;
            map[k].w -= delta;
            map[k ^ 1].w += delta;
            cost += delta * f * q;
        }
    }
    vis[u] = 0;
    return flow - rmnd;
}

void Dinic(int k)
{
    cost = 0;
    while (bfs(k))
    {
        memset(vis, 0, sizeof vis);
        dfs(s, INF, k);
    }
}

int main(void)
{
    cin >> m >> n;
    for (int i=1;i<=m;i++)
    {
        cin >> val[i];
        add(s, i, val[i], 0);
        add(i, s, 0, 0);
    }
    for (int j=1;j<=n;j++)
    {
        cin >> val[j+100];
        add(j+100, t, val[j+100], 0);
        add(t, j+100, 0, 0);
    }
    for (int i=1;i<=m;i++)
    {
        for (int j=1;j<=n;j++)
        {
            int f;
            cin >> f;
            add(i, j+100, INF, f);
            add(j+100, i, 0, -f);
        }
    }
    Dinic(1);
    cout << cost << endl;
    for (int i=1;i<=cnt;i++)
    {
        map[i].init();
    }
    Dinic(-1);
    cout << cost;
    return 0;
}


三、最大权闭合子图问题



1. 建图方法


  1. 源点向所有正权点连结一条容量为权值的边

  2. 所有负权点向汇点连结一条容量为权值绝对值的边

  3. 保留原图中所有的边，容量为正无穷

在最小割图上，如果割掉 s s s 和 u u u 之间的边，代表不选择 u u u 进入子图，如果割掉 v v v 和 t t t 之间的边，代表选择 v v v 进入子图。



2. 题目


(3) P2762 太空飞行计划问题

题目链接


#include <stdio.h>
#include <iostream>
#include <string.h>
#include <queue>
using namespace std;
#define MAXN 2500
#define INF 0x3f3f3f3f

int n, m, tot;
int cnt = 1;
int s = 0, t = 101;
int vis[MAXN], head[MAXN], dep[MAXN], temp[MAXN], dis[MAXN];

struct node{
    int to, w, next;
}map[MAXN];

void add(int u, int v, int w)
{
    map[++cnt] = (node){v, w, head[u]};
    head[u] = cnt;
}

bool bfs(void)
{
    memset(dep, -1, sizeof dep);
    memset(dis, -1, sizeof dis);
    memcpy(temp, head, sizeof head);
    queue <int>que;
    que.push(s);
    dep[s] = 0;
    while (!que.empty())
    {
        int u = que.front();
        que.pop();
        for (int k=head[u];k;k=map[k].next)
        {
            int v = map[k].to;
            int w = map[k].w;
            if (w && dep[v] == -1)
            {
                dis[v] = 1;
                dep[v] = dep[u] + 1;
                que.push(v);
            }
        }
    }
    return dep[t] != -1;
}

int dfs(int u, int flow)
{
    if (u == t)
    {
        return flow;
    }
    int rmnd  = flow;
    temp[u] = head[u];
    for (int k=temp[u];k && rmnd;k=map[k].next)
    {
        temp[u] = k;
        int v = map[k].to;
        int w = map[k].w;
        if (w && dep[v] == dep[u] + 1)
        {
            int delta = dfs(v, min(rmnd, w));
            //cout << u << " " << v << " " << w << endl;
            rmnd -= delta;
            map[k].w -= delta;
            map[k ^ 1].w += delta;
        }
    }
    return flow - rmnd;
}

int Dinic(void)
{
    int ans = 0;
    while (bfs())
    {
        ans += dfs(s, INF);
    }
    return ans;
}

void read(void)
{
    cin >> n >> m;
    for (int i=1;i<=n;i++)
    {
        int sponsor;
        cin >> sponsor;
        tot += sponsor;
        add(s, i+50, sponsor);
        add(i+50, s, 0);
        char tools[10000];
        memset(tools,0,sizeof tools);
        cin.getline(tools,10000);
        int ulen=0, tool;
        while (sscanf(tools + ulen,"%d",&tool) == 1)//之前已经用scanf读完了赞助商同意支付该实验的费用
        {//tool是该实验所需仪器的其中一个      
            //这一行，你可以将读进来的编号进行储存、处理，如连边。
            add(i+50, tool, INF);
            add(tool, i+50, 0);
            if (tool==0)
            {
                ulen++;
            }
            else
            {
                while (tool)
                {
                    tool/=10;
                    ulen++;
                }
            }
            ulen++;
        }
    }
    for (int i=1;i<=m;i++)
    {
        int pay;
        cin >> pay;
        add(i, t, pay);
        add(t, i, 0);
    }
}

int main(void)
{
    read();
    int ans =  Dinic();
    for (int i=1;i<=n;i++)
    {
        if (dep[i+50] != -1)
        {
            cout << i << " ";
        }
    }
    cout << endl;
    for (int j=1;j<=m;j++)
    {
        if (dis[j] != -1)
        {
            cout << j << " ";
        }
    }
    cout << endl << tot - ans;
    return 0;
}




持续更新中。。。

SP FA
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
网络流24题总结和题解
weixin_30757793的博客
11-30 239
大体按照难度阵营 t0 1.飞行员配对方案问题 这是个二分图匹配模板 但是这个输出方案套路还是要 掌握起来~ 大概是 我们跑网络流 一定能获得两个东西 1.最大最小可行流数值和最大流数值 2.一个可行的跑的方案 这个方案的特点是按照加边顺序进行增广 也就是说 加边满足字典序时 就可以按字典序跑了 我们得到1 不停地增广 我们得到二 就是寻找跑满流量的正向边 ...
网络流24题（持续更新）和一些好题
m0_53688600的博客
08-12 1555
记录下网络流的学习，以及自己的一些理解 1.DAG最小路径覆盖 题目大意：DAG求最小路径覆盖，输出方案 思路：将n个点看成单独n条路径，接下来拆点，将每个点放在入点出点两个集合中，如果有边x->y，则x出指向y入，初始化时候所有点出点连源点，入点连汇点，最小路径数 = 总路径n - 最大流，最大流就是我们去匹配出入点的最大边数，实质就是匈牙利算法啊 建图示意 ，图中只有1->3一条路径可以从原始n条路径中拼接起来，即3-1=2，最小路径数，我们发现，连向汇点的点如果不和源点联.
网络流经典第二十四题(题目+数据+标程)
10-18
网络流经典二十四题之第二十四题----骑士共存问题 内含pdf题目， 亲测代码， data， 文字版题解
网络流24题
ó
10-12 359
题目列表： &amp;amp;amp;amp;amp;amp;amp;amp;lt;最大流有FF、EK、Dinic算法，最小费用流有SPFA、DIjkstra求解算法等，网络流在于建模，在此不在贴出代码&amp;amp;amp;amp;amp;amp;amp;amp;gt; P2756 飞行员配对方案问题 二分图最大匹配—匈牙利算法，看着模板一顿乱敲即可。 P4016 负载平衡问题 最小费用流 建模：源点s=0，汇点t=n+1，平均值ave（对于样例为12） 源
网络流二十四题
yeleng的博客
10-05 676
1/搭配飞行员: 给n个飞行员，有m个为副驾驶，其他为主驾驶。 每个飞机需要一个副驾驶和一个主驾驶，给出可以一起合作的组合，问最多可以让几架飞机起飞。 建立两列点，一列为主驾驶一列为副驾驶，建立s与t，s向每个主驾驶连一条容量为1（每个主驾驶的人只能用一次），副驾驶连到t容量为1（每个副驾驶只能要一次），然后主驾驶与副驾驶合坐连一条容量为1的边，最大流就是最大合作的数量(二分图匹配应该也可以...
网络流24题题目列表
YouthDance
03-27 7664
转载自： 会根据我个人的能力，逐渐在这个专题中给出所列出的题目的解题报告。 判题系统我使用信息工程学院的。Click Here~ 问题编号 问题名称 问题模型 转化模型 1 飞行员配对方案问题 二分图最大匹配 网络最大流       题解 2 太空飞行计划问题 最大权闭合图 网络最小割    3 最
复习题20201112自己整理1
08-03
【计算机网络知识详解】 1. ISO/OSI七层模型与TCP/IP体系结构 ISO/OSI七层模型包括：应用层、表示层、会话层、传输层、网络层、数据链路层和物理层。各层的主要作用是： - 应用层：为用户提供直接的应用服务，如...
面试题整理面试题整理.zip
07-30
在IT行业中，面试是检验求职者技能和知识的...总的来说，"面试题整理.zip"中的内容应覆盖了这些广泛的IT领域，提供了一个全面的复习指南。通过深入学习和实践这些知识点，应聘者可以大大增加在面试中脱颖而出的机会。
面试题整理精华
04-10
整理的面试题可能来自各种来源，包括但不限于知名企业的面试经历、在线论坛讨论、技术博客等，旨在提供全面而实用的复习材料。 【压缩包子文件的文件名称】：“java面试题整理2017.5” 这份文件名表明了这是一个...
算法：保存用于算法的个人代码
02-16
3. 图论算法：Dijkstra最短路径算法、Floyd-Warshall算法、Kruskal's最小生成树算法等，这些用于处理网络流、最优化问题和图的遍历。 4. 动态规划（Dynamic Programming）：如Fibonacci数列、背包问题、最长公共子...
java面试复习资料整理，涵盖常见的面试题相关的知识
最新发布
02-20
以上只是部分核心知识点，实际的复习资料可能还包括反射、注解、网络编程、I/O流、序列化、JDBC、Spring框架等相关内容。对于每个主题，深入理解和实践都是非常重要的，这将有助于在面试中表现出扎实的技术功底。
网络流题集
热门推荐
夏天的风
07-24 1万+
【HDU】 1532 Drainage Ditches(入门)    [最大流] 3549 Flow Problem(入门)    [最大流] 3572 Task Schedule(基础)    [最大流]任务分配,判断满流 2732 Leapin' Lizards(较难)    [最大流] 3338 Kakuro Extension(较难，好题)    [最大流][数和]神奇最大流行进
各个OJ网络流 题集分布
lyc
09-04 4040
【HDU】 1532Drainage Ditches(基础)    [最大流] 3549 Flow Problem(基础)    [最大流] 3572 Task Schedule    [最大流]任务分配,判断满流 2732 Leapin' Lizards(难)    [最大流] 3338 Kakuro Extension    [最大流][数和]神奇最大流行进列出 2883 keba
网络流题目题单
eternal风度
08-14 195
&#13; 网络流题单 http://www.cnblogs.com/LadyLex/p/7601119.html 感谢xzyxzy 题目 1、练基础 [X] P3376 【模板】网络最大流 https://www.luogu.org/problemnew/show/3376 [X] P3381 【模板】最小费用最大流 https://www.luogu.org/probl...
网络流例题总结
Step by step
08-01 1837
POJ 3436题意： 生产1台电脑需要n个机器，每个机器对运过来的未加工好的机器加工，每个机器每小时有最大的生产电脑量，每台电脑有p个部分，且每台机器只会接受满足条件的未加工好的电脑，问一小时内最大的生产量？ 思路: 属于比较裸的最大流，按照条件建边即可，注意每一台机器有最大的生产量C，这个可以当做流入这台机器的最大流量，但是考虑特殊情况，我们必须去拆点才能建立正确的图，也就是每台机器拆成
【小峰の题单】网络流经典题目
m0_49959202的博客
03-30 386
文章目录【小峰の题单】网络流经典题目1.最大流/最小割/二分图匹配P2756 飞行员配对方案问题「伪模板」主席树最小路径覆盖问题教辅的组成[ZJOI2009]狼和羊的故事[SCOI2007]蜥蜴方格取数问题[ICPC-Beijing 2006]狼抓兔子最长不下降子序列问题[国家集训队]happiness文理分科[清华集训2012]最小生成树[SHOI2007]善意的投票 / [JLOI2010]冠军调查[国家集训队]部落战争[TJOI2013]攻击装置[SHOI2010]最小生成树2.费用流负载平衡问题餐
网络流算法+例题整理
dyt's Blog
02-10 1094
DINIC（无当前弧优化）： void add(int x,int y,int z){ son[++tot]=y,w[tot]=z,nxt[tot]=lnk[x],lnk[x]=tot; } int dfs(int x,int sum){ if (x==T) return sum; for (int j=lnk[x];j!=-1;j=nxt[j]) if (...
网络流24题13. 星际转移问题
Circus
03-05 971
最大流，分层图
网络流 几道习题
秋叶红于二月花
05-07 420
题目来自Luogu省选训练场【网络流——最大流】和【网络流——费用流】。 最大流训练场中前5题是网络流24题原题，就不在此列出。 P2805 [NOI2009]植物大战僵尸 n*m的矩阵上摆放有若干植物，每个植物均有可能保护着若干其它位置的植物，在消灭一棵植物时，需要先消灭所有它右边的植物以及所有保护着它的植物。消灭每棵植物都有一个收益，可能为正也可能为负。问消灭一些植物可获得的最大收益，可以为0...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

SP FA

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值