題意：
? ? ? ?有k個任務，兩個機器，第一個機器有n個模式，第二個機器有m個模式，每個任務要么在第一個機器的一個模式下工作，要么在第二個機器的一個模式下工作，機器每切換一個模式需要重啟一次，兩個機器一開始都處于第0個模式下，問完成這k個任務至少切換多少次模式（任務完成順序無所謂）。


思路：
? ? ? 把每個任務的兩個點連成一條邊，然后就是說每個邊肯定要先則這條邊的兩個端點中的一個，所有的邊都要這樣做，這不就是最少頂點覆蓋了嗎，直接一遍二分匹配就行了，或者是一遍最大流，線面是兩種方法的代碼，題目比較簡單，就說這么多吧。


二分匹配，匈牙利（最少頂點覆蓋=最大匹配數）


#include<stdio.h>
#include<string.h>


#define N_node 200 + 10
#define N_edge 1000 + 100


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


STAR E[N_edge];
int list[N_node] ,tot;
int mkdfs[N_node] ,mkgx[N_node];


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


int DFS_XYL(int s)
{
? ? for(int k = list[s] ;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] = s;
? ? ? ? ? ? return 1;
? ? ? ? }
? ? }
? ? return 0;
}


int main ()
{
? ? int n ,m, k ,a ,b ,c ,i;
? ? while(~scanf("%d" ,&n) && n)
? ? {
? ? ? ? scanf("%d %d" ,&m ,&k);
? ? ? ? memset(list ,0 ,sizeof(list));
? ? ? ? tot = 1;
? ? ? ? for(i = 1 ;i <= k ;i ++)
? ? ? ? {
? ? ? ? ? ? scanf("%d %d %d" ,&a ,&b ,&c);
? ? ? ? ? ? if(!b || !c) continue;
? ? ? ? ? ? add(b + 1 ,c + 1);
? ? ? ? }
? ? ? ? memset(mkgx ,255 ,sizeof(mkgx));
? ? ? ? int Ans = 0;
? ? ? ? for(i = 1 ;i <= n ;i ++)
? ? ? ? {
? ? ? ? ? ? memset(mkdfs ,0 ,sizeof(mkdfs));
? ? ? ? ? ? Ans += DFS_XYL(i);
? ? ? ? }
? ? ? ? printf("%d\n" ,Ans);
? ? }
? ? return 0;
}








DINIC求最大匹配
#include<queue>
#include<stdio.h>
#include<string.h>


#define N_node 250
#define N_edge 3000
#define INF 1000000000


using namespace std;


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


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


STAR E[N_edge];
DEP xin ,tou;
int list[N_node] ,listt[N_node] ,tot;
int deep[N_node];


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;
}


bool BFS_Deep(int s ,int t ,int n)
{
? ? memset(deep ,255 , sizeof(deep));
? ? xin.x = s ,xin.t = 0;
? ? deep[s] = 0;
? ? queue<DEP>q;
? ? q.push(xin);
? ? 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 minn(int x ,int y)
{
? ? return x < y ? x : y;
}


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)
? ? {
? ? ? ? int to = E[k].to;
? ? ? ? int c = E[k].cost;
? ? ? ? listt[s] = k;
? ? ? ? if(deep[to] != deep[s] + 1 || !c)
? ? ? ? continue;
? ? ? ? int tmp = DFS_Flow(to ,t ,minn(c ,flow - nowflow));
? ? ? ? nowflow += tmp;
? ? ? ? E[k].cost -= tmp;
? ? ? ? E[k^1].cost += tmp;
? ? ? ? if(nowflow == flow)
? ? ? ? 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 ,k ,i ,a ,b ,c;
? ? while(~scanf("%d" ,&n) && n)
? ? {
? ? ? ? scanf("%d %d" ,&m ,&k);
? ? ? ? memset(list ,0 ,sizeof(list));
? ? ? ? tot = 1;
? ? ? ? for(i = 1 ;i <= k ;i ++)
? ? ? ? {
? ? ? ? ? ? scanf("%d %d %d" ,&a ,&b ,&c);
? ? ? ? ? ? if(!b || !c) continue;
? ? ? ? ? ? b ++ ,c ++;
? ? ? ? ? ? add(b ,c + n ,1);
? ? ? ? }
? ? ? ? for(i = 1 ;i <= n ;i ++)
? ? ? ? add(0 ,i ,1);
? ? ? ? for(i = 1 ;i <= m ;i ++)
? ? ? ? add(i + n ,n + m + 1 ,1);
? ? ? ? printf("%d\n" ,DINIC(0 ,m + n + 1 ,m + n + 1));
? ? }
? ? return 0;
}

總結

以上是生活随笔為你收集整理的POJ1325二分匹配或者DINIC(最小路径覆盖)的全部內容，希望文章能夠幫你解決所遇到的問題。

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