題意：
? ? ? 一個人他有n個任務，每個任務都有一些限制：
?(1)只能在一個星期中指定的日子去做，比如周1 2 6啥的
?(2)總工作量有幾天，就是一共要工作幾天
?(3)必須在幾周之內完成，就是你可以在能干活的日子里面選擇那天去干活，但是不能超過規定的星期。
然后問，是否可以不沖突的干完所有的活？


思路：
? ? ? 題目一般，沒啥難度，做法也很多，說下最大流的做法吧，建圖：
虛擬超級遠點 s ,超級匯點t，拆點，把所有天數都拆開，就是第一周的星期1和第二周的星期一不是同一個點。


s連接所有任務 流量是天數
任務連接所有滿足限制（2）（3）的已經拆開了的天 ?流量是INF
所有拆開的天數連接t，流量1.


然后一邊最大流就行了，如果不想最大流可以把每個任務在拆成天數個點，就是比如任務一需要3天完成，那么就把他拆成三個一天的任務，然后建圖差不多，一遍二分匹配就行了，時間復雜度肯定允許，如果只是為了AC還有很多別的方法，題目不難，就說這么多吧。






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


#define N_node 20 + 350 + 1 + 5
#define N_edge (20 * 350 + 20 + 350) * 2 + 100
#define INF 1000000000


using namespace std;


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


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


DEP xin ,tou;
STAR E[N_edge];
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;
}


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));
? ? deep[s] = 0;
? ? xin.x = s ,xin.t = 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 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;
? ? ? ? int c = E[k].cost;
? ? ? ? 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 t ,n ,i ,j ,maxk ,s;
? ? int tmp[10];
? ? scanf("%d" ,&t);
? ? while(t--)
? ? {
? ? ? ? scanf("%d" ,&n);
? ? ? ? memset(list ,0 ,sizeof(list));
? ? ? ? tot = 1 ,maxk = 0 ,s = 0;
? ? ? ? for(i = 1 ;i <= n ;i ++)
? ? ? ? {
? ? ? ? ? ? for(j = 1 ;j <= 9 ;j ++)
? ? ? ? ? ? scanf("%d" ,&tmp[j]);
? ? ? ? ? ? if(maxk < tmp[9]) maxk = tmp[9];
? ? ? ? ? ? s += tmp[8];
? ? ? ? ? ? add(0 ,i ,tmp[8]);
? ? ? ? ? ? for(j = 1 ;j <= 7 ;j ++)
? ? ? ? ? ? if(tmp[j])
? ? ? ? ? ? {
? ? ? ? ? ? ? ? for(int k = 1 ;k <= tmp[9] ;k ++)
? ? ? ? ? ? ? ? add(i ,j + (k-1) * 7 + n ,INF);
? ? ? ? ? ? }
? ? ? ? }
? ? ? ? for(i = 1 ;i <= 7 ;i ++)
? ? ? ? for(j = 1 ;j <= maxk ;j ++)
? ? ? ? add((j - 1) * 7 + i + n, maxk * 7 + n + 1 ,1);
? ? ? ? int Flow = ?DINIC(0 ,maxk * 7 + n + 1 ,maxk * 7 + n + 1);
? ? ? ? Flow == s ? puts("Yes") : puts("No");
? ? }
? ? return 0;


}

總結

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

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