A Plug for UNIX UVA - 753

最新推荐文章于 2020-11-10 11:40:37 发布

carut

最新推荐文章于 2020-11-10 11:40:37 发布

阅读量145

点赞数

分类专栏： # 紫书第十一章图论模型和算法

本文链接：https://blog.csdn.net/zpf1998/article/details/104425441

版权

问题

分析

添加两个节点，一个源节点，一个宿节点
解法1:首先用floyd算出所有的转换器之间的连接关系，然后将插头和插座看作点，转换器作为边，容量是INF，连接源点和每个插头，每个插座和宿节点，容量是1，计算最大流量
解法2：不适用Floyd，直接构图，每个出现过的插头或者插座都看作一个节点，将转换器看作边，容量INF，添加源节点，宿节点
解法1：
EK :

//
// Created by Zhao Pengfei on 2020/2/16.
//
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <vector>
#include <utility>
#include <map>
#include <string>
#include <queue>
using namespace std;
const int maxn=105,Inf=0x3f3f3f3f;

struct Edge{
   
    int from,to,cap,flow;
    Edge(int u,int v,int c,int f):from(u),to(v),cap(c),flow(f){
   }
};

struct EdmondsKarp{
   
    int n,m;
    vector<Edge> edges;
    vector<int> G[4*maxn];
    int a[4*maxn];
    int p[4*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));
        m=edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }

    int MaxFlow(int s,int t){
   
        int flow=0;
        while(true){
   
            memset(a,0,sizeof(a));
            queue<int> Q;
            Q.push(s);
            a[s]=Inf;
            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(!a[e.to] && e.cap>e.flow){
   
                        p[e.to]=G[x][i];
                        a[e.to]=min(a[x],e.cap-e.flow);
                        Q.push(e.to);
                    }
                }
                if(a[t]) break;   //到达了t，提前退出
            }
            if(!a[t]) break;   //没有增广路了
            for(int u=t;u!=s;u=edges[p[u]].from){
   
                edges[p[u]].flow+=a[t];
                edges[p[u]^1].flow-=a[t];
            }
            flow+=a[t];
        }
        return flow;
    }
};

int kase,id,n,m,k,recept[4*maxn],plug[4*maxn],g[4*maxn][4*maxn];
map<string,int> str2int;
vector<string> int2str;
string s1,s2;
int ID(string &s){
   
    if(str2int.count(s)) return str2int[s];
    int2str.push_back(s);
    return str2int[s]=int2str.size()-1;
}

int