題意：
? ? ?有n個插孔，m個電器，q種轉換器（轉換器可以無限用），然后問你最多有多少個電器能充電。


思路：
? ? ? 比較簡單，就是在建圖的時候要考慮下，我用了兩種方法做的，一個是最大流，這個方法我的建圖是這樣，先給每個用電器虛擬出來一個點n，每個插座虛擬出來兩個點（限流）m，然后給每個插座或者是插頭的類型虛擬出來一個點，這樣就ok了，建圖是這樣
s ? ? ? ? -> 所有用電器 ? ? ? 1
所有用電器->他所連接的種類 ? ?1
種類 ? ? ?->種類 ? ? ? ? ? ? INF ? 這個是轉換器
種類 ? ? ?->插座 ? ? ? ? ? ? ?1
插座到 ? ?->插座 ? ? ? ? ? ? ?1 ? ?限流
插座 ? ? ?-> t ? ? ? ? ? ? ? ?1
然后一遍s到t的最大流


另一種方法是用二分匹配，這個方法我們可以這樣想，建立二分圖，左邊是用電器，右邊是插座，然后用電器和插座能連的條件是可以直接或者間接連接上，這個地方可以用搜索搞定，這樣在處理所有連接關系的時候的時間復雜度一共是n^2的，一開始想用Floyd了，考慮到那樣的話最壞的情況會達到500*500*500就沒用，通過搜索建立間接之后就可以直接匈牙利匹配了，下面是兩種方法的代碼。




DINIC
#include<map>
#include<queue>
#include<stdio.h>
#include<string>
#include<string.h>


#define N_node 700 + 10
#define N_edge 700 * 700 + 50
#define INF 1000000000


using namespace std;


typedef struct
{
? ? int to ,cost ,next;
}STAR;


typedef struct
{
? ? int x ,t;
}DEP;


STAR E[N_edge];
DEP xin ,tou;
map<string ,int>mark;
int deep[N_node];
int list[N_node] ,listt[N_node] ,tot;


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 to = E[k].to ,c = E[k].cost;
? ? ? ? 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(flow == nowflow)
? ? ? ? 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;
}


int main ()
{
? ? int n ,m ,q ,i;
? ? char str1[25+5] ,str2[25+5];
? ? while(~scanf("%d" ,&n))
? ? {
? ? ? ? memset(list ,0 ,sizeof(list));
? ? ? ? tot = 1;
? ? ? ? mark.clear();
? ? ? ? int nowid = 0;
? ? ? ? int s = 0 ,t = 705;
? ? ? ? for(i = 1 ;i <= n ;i ++)
? ? ? ? {
? ? ? ? ? ? scanf("%s" ,str1);
? ? ? ? ? ? if(!mark[str1]) mark[str1] = ++nowid;
? ? ? ? ? ? add(mark[str1] + 200 ,mark[str1] + 600 ,1);
? ? ? ? ? ? add(mark[str1] + 600 ,i + 100 ,1);
? ? ? ? ? ? add(i + 100 ,t ,1);
? ? ? ? }
? ? ? ? scanf("%d" ,&m);
? ? ? ? for(i = 1 ;i <= m ;i ++)
? ? ? ? {
? ? ? ? ? ? scanf("%s %s" ,str1 ,str2);
? ? ? ? ? ? if(!mark[str2]) mark[str2] = ++nowid;
? ? ? ? ? ? add(s ,i ,1);
? ? ? ? ? ? add(i ,mark[str2] + 200 ,1);
? ? ? ? }
? ? ? ? scanf("%d" ,&q);
? ? ? ? for(i = 1 ;i <= q ;i ++)
? ? ? ? {
? ? ? ? ? ? scanf("%s %s" ,str1 ,str2);
? ? ? ? ? ? if(!mark[str1]) mark[str1] = ++nowid;
? ? ? ? ? ? if(!mark[str2]) mark[str2] = ++nowid;
? ? ? ? ? ? add(mark[str1] + 200 ,mark[str2] + 200 ,INF);
? ? ? ? }
? ? ? ? printf("%d\n" ,m - DINIC(s ,t ,705));
? ? }
? ? return 0;
}


匈牙利+DFS
#include<map>
#include<stdio.h>
#include<string>
#include<string.h>


#define N_node 500
#define N_edge 500 * 500 + 10
#define INF 100000000


using namespace std;


typedef struct
{
? ? int to ,next;
}STAR;


STAR E[N_edge];
int mkdfs[N_node] ,mkgx[N_node];
int list[N_node] ,tot;
int _map[N_node][N_node];
int cz[N_node] ,dq[N_node];
map<string ,int>mark;


void add(int a ,int b)
{
? ? E[++tot].to = b;
? ? E[tot].next = list[a];
? ? list[a] = tot;
}


void DFS(int s ,int now)
{
? ? for(int k = list[now] ;k ;k = E[k].next)
? ? {
? ? ? ? int to = E[k].to;
? ? ? ? if(mkdfs[to]) continue;
? ? ? ? mkdfs[to] = _map[s][to] = 1;
? ? ? ? DFS(s ,to);
? ? }
? ? return ;
}


int DFS_XYL(int x)
{
? ? for(int k = list[x] ;k ;k = E[k].next)
? ? {
? ? ? ? int to = E[k].to;
? ? ? ? if(mkdfs[to]) continue;
? ? ? ? mkdfs[to] = 1;
? ? ? ? if(mkgx[to] == -1 || DFS_XYL(mkgx[to]))
? ? ? ? {
? ? ? ? ? ? mkgx[to] = x;
? ? ? ? ? ? return 1;
? ? ? ? }
? ? }
? ? return 0;
}


int main ()
{
? ? int n ,m ,q ,i ,j ,a ,b;
? ? char str1[30] ,str2[30];
? ? while(~scanf("%d" ,&n))
? ? {
? ? ? ? mark.clear();
? ? ? ? int nowid = 0;
? ? ? ? for(i = 1 ;i <= n ;i ++)
? ? ? ? {
? ? ? ? ? ? scanf("%s" ,str1);
? ? ? ? ? ? if(!mark[str1]) mark[str1] = ++nowid;
? ? ? ? ? ? cz[i] = mark[str1];
? ? ? ? }
? ? ? ? scanf("%d" ,&m);
? ? ? ? for(i = 1 ;i <= m ;i ++)
? ? ? ? {
? ? ? ? ? ? scanf("%s %s" ,str1 ,str2);
? ? ? ? ? ? if(!mark[str2]) mark[str2] = ++nowid;
? ? ? ? ? ? dq[i] = mark[str2];
? ? ? ? }
? ? ? ? memset(list ,0 ,sizeof(list));
? ? ? ? tot = 1;
? ? ? ? scanf("%d" ,&q);
? ? ? ? for(i = 1 ;i <= q ;i ++)
? ? ? ? {
? ? ? ? ? ? scanf("%s %s" ,str1 ,str2);
? ? ? ? ? ? if(!mark[str1]) mark[str1] = ++nowid;
? ? ? ? ? ? if(!mark[str2]) mark[str2] = ++nowid;
? ? ? ? ? ? add(mark[str1] ,mark[str2]);
? ? ? ? }
? ? ? ? memset(_map ,0 ,sizeof(_map));
? ? ? ? for(i = 1 ;i <= nowid ;i ++)
? ? ? ? {
? ? ? ? ? ? memset(mkdfs ,0 ,sizeof(mkdfs));
? ? ? ? ? ? _map[i][i] = 1;
? ? ? ? ? ? DFS(i ,i);
? ? ? ? }
? ? ? ? memset(list ,0 ,sizeof(list));
? ? ? ? tot = 1;
? ? ? ? for(i = 1 ;i <= m ;i ++)
? ? ? ? for(j = 1 ;j <= n ;j ++)
? ? ? ? if(_map[dq[i]][cz[j]]) add(i ,j);
? ? ? ? int ans = 0;
? ? ? ? memset(mkgx ,255 ,sizeof(mkgx));
? ? ? ? for(i = 1 ;i <= nowid ;i ++)
? ? ? ? {
? ? ? ? ? ? memset(mkdfs ,0 ,sizeof(mkdfs));
? ? ? ? ? ? ans += DFS_XYL(i);
? ? ? ? }
? ? ? ? printf("%d\n" ,m - ans);
? ? }
? ? return 0;
}















《新程序員》：云原生和全面數字化實踐50位技術專家共同創作，文字、視頻、音頻交互閱讀

總結

以上是生活随笔為你收集整理的POJ1087DFS+匈牙利或者DINIC的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。