hdu3338 最大流
題意:?
? ? ? ? ? ?給你一個N*M的網格,上面有的有一些數字,要求填充數字,滿足的規則是這樣:
答案不唯一,只要滿足和的關系就可以,還有就是只能用1--9之間的數字填充,而且每一行或一列可以重復使用某個數字,觀察每個要填充的點我們會發現,其實該點只于他所在的"行和"限制和所在的"列和"限制,我們可以把點分為三類,白色填充,左下半有數,右下半
有數 ,(其他的沒用,不用管 ,左下和右上都有數的一定要拆成兩個點),只要權衡好這三類點就ok了,那么我們可以直接添加 超級遠點s ,超級匯點e ,左下進右上出(也可以反過來);題目要求是1--9 ,最大流可能會產生0所以直接0--8,輸出的時候在+1就行.題意既然說是保證有解,那么最大流肯定會滿流,最后每個點流多少就輸出多少+1就ok;
建圖:
(1)s 和所有左下有數的點連 ,流量是左下的數字減去他下面空白行的個數(因為是0--8每個都少了1 ,一共有多少個就少多少個)
(2)所有左下角有數的點和他下面的這一列的空白點相連,流量 8
(3)所有右上角有數的被他所在的這一列空白的連接,記住是被連接,(方向別反了),還有注意一點就是如果該點左下角有數了,那么一定要拆點,不然會沖突,流量是8;
(4)第三步中所有被連接的點在連接e,流量是該點右上角的數 - 這一行的空白格子個數.原因和(1) 一樣.
? ? ? 建圖后直接一遍最大流,然后根據流量情況就能輸出答案了, 題目是?Special Judge ..所以隨便跑一遍就行了,還有就是別用DINIC,會超時,就算我把點都離散化了依然超時,我用的是
SAP之前沒用過,隨便找了個模板改改用的. 當某個點有兩個值時一定要拆點.同時可以離散化去優化. ?
下面是代碼,第一個是TLE代碼(DINIC),第二個是AC代碼(SAP);
// 超時的DINIC
#include<stdio.h>
#include<string.h>
#include<queue>
#define N_node 100 * 100 * 2 + 100
#define N_edge 500000
#define N 100 + 5
#define inf 1000000000
using namespace std;
typedef struct
{
? ?char node[8];
}NODE;
typedef struct
{
? ?int to ,next ,cost;
}STAR;
typedef struct
{
? ?int x ,dep;
}DEP;
NODE map[N][N];
STAR E[N_edge];?
DEP xin ,tou;
int list[N_node] ,tot;
int list2[N_node] ,deep[N_node];
int X[N*N*2+100];
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.dep = 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.dep = tou.dep + 1;
? ? ? ? ?if(deep[xin.x] != -1 || !E[k].cost)
? ? ? ? ?continue;
? ? ? ? ?deep[xin.x] = xin.dep;
? ? ? ? ?q.push(xin);
? ? ? }
? ?}
? ?for(int i = 0 ;i <= n ;i ++)
? ?list2[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 = list2[s] ;k ;k = E[k].next)
? ?{
? ? ? list2[s] = k;
? ? ? int to = E[k].to;
? ? ? int c = E[k].cost;
? ? ? if(deep[to] != deep[s] + 1 || !c)
? ? ? continue;
? ? ? int temp = DFS_FLOW(to ,t ,minn(c ,flow - nowflow));
? ? ? nowflow += temp;
? ? ? E[k].cost -= temp;
? ? ? E[k^1].cost += temp;
? ? ? 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 i ,j ,n ,m ,s ,e;
? ?while(~scanf("%d %d" ,&n ,&m))
? ?{
? ? ? int sum_n = 0;
? ? ? for(i = 1 ;i <= n ;i ++)
? ? ? for(j = 1 ;j <= m ;j ++)
? ? ? {
? ? ? ? ?scanf("%s" ,map[i][j].node);
? ? ? ? ?if(map[i][j].node[0] == '.')
? ? ? ? ?{
? ? ? ? ? ? sum_n ++;
? ? ? ? ? ? continue;
? ? ? ? ?}
? ? ? ? ?if(map[i][j].node[0] != 'X')
? ? ? ? ?sum_n ++;
? ? ? ? ?if(map[i][j].node[4] != 'X')
? ? ? ? ?sum_n ++;
? ? ? }
? ? ? ? ??
? ? ? s = 0 ,e = sum_n + 1;
? ? ? sum_n = 0;
? ? ? memset(X ,255 ,sizeof(X)); ? ? ? ? ? ? ? ? ? ? ?
? ? ? memset(list ,0 ,sizeof(list)) ,tot = 1;
? ? ? for(i = 1 ;i <= n ;i ++)
? ? ? for(j = 1 ;j <= m ;j ++)
? ? ? {
? ? ? ? ?if(map[i][j].node[3] == 'X' || map[i][j].node[0] == '.') continue;
? ? ? ? ?char t_str[8];
? ? ? ? ?for(int ii = 0 ;ii <= 7 ;ii ++)
? ? ? ? ?t_str[ii] = map[i][j].node[ii];
? ? ? ? ?int a ,b ,mk = 0;
? ? ? ? ?if(X[(i-1)*m+j] == -1) X[(i-1)*m+j] = ++sum_n;
? ? ? ? ?int now = ?X[(i-1)*m+j];
? ? ? ? ?if(t_str[0] != 'X')
? ? ? ? ?{
? ? ? ? ? ? mk = 1;
? ? ? ? ? ? int temp = (t_str[0]-48)*100+(t_str[1]-48)*10+(t_str[2]-48)*1;?
? ? ? ? ? ? for(int ii = i + 1 ;ii <= n ;ii ++)
? ? ? ? ? ? {
? ? ? ? ? ? ? ?if(map[ii][j].node[0] != '.')
? ? ? ? ? ? ? ?break;
? ? ? ? ? ? ? ?temp --;
? ? ? ? ? ? ? ?if(X[(ii - 1) * m + j] == -1) X[(ii - 1) * m + j] = ++sum_n;
? ? ? ? ? ? ? ?b = X[(ii - 1) * m + j]; ? ? ??
? ? ? ? ? ? ? ?add(now ,b ,8);
? ? ? ? ? ? }
? ? ? ? ? ? add(s ,now ,temp);
? ? ? ? ?}
? ? ? ? ?
? ? ? ? ?if(t_str[4] != 'X')
? ? ? ? ?{ ? ? ? ? ? ? ? ? ? ?
? ? ? ? ? ? if(mk) now = ++sum_n;
? ? ? ? ? ? int temp = (t_str[4]-48)*100+(t_str[5]-48)*10+(t_str[6]-48)*1;
? ? ? ? ? ? for(int jj = j + 1 ;jj <= m ;jj ++)
? ? ? ? ? ? {
? ? ? ? ? ? ? ?if(map[i][jj].node[0] != '.')
? ? ? ? ? ? ? ?break;
? ? ? ? ? ? ? ?temp --;
? ? ? ? ? ? ? ?if(X[(i - 1) * m + jj] == -1) X[(i - 1) * m + jj] = ++sum_n;
? ? ? ? ? ? ? ?a = X[(i - 1) * m + jj];
? ? ? ? ? ? ? ?add(a ,now ,8);
? ? ? ? ? ? }
? ? ? ? ? ? add(now ,e ,temp);
? ? ? ? ?}
? ? ? }
? ? ??
? ? ? DINIC(s ,e ,sum_n + 1);
? ? ? for(i = 1 ;i <= n ;i ++)
? ? ? for(j = 1 ;j <= m ;j ++)
? ? ? {
? ? ? ? ?if(j != 1) printf(" ");
? ? ? ? ?if(map[i][j].node[0] != '.')
? ? ? ? ?printf("_");
? ? ? ? ?else
? ? ? ? ?{
? ? ? ? ? ? int k = list[X[(i - 1) * m + j]];
? ? ? ? ? ? int c = E[k].cost;
? ? ? ? ? ? printf("%d" ,8 - c + 1);
? ? ? ? ?}
? ? ? ? ?if(j == m) printf("\n");
? ? ? }
? ?}
? ?return 0;
}
??
//SAP ac
#include<stdio.h>
#include<string.h>
#include<queue>
#define N 100 + 5
using namespace std;
typedef struct
{
? ?char node[8];
}NODE;
NODE map[N][N];
int X[50000];
//***********************************************
const int MAXN=50000;//點數的最大值
const int MAXM=1000000;//邊數的最大值
const int INF=0x3f3f3f3f;
struct Node
{
? ? int from,to,next;
? ? int cap;
}edge[MAXM];
int tol;
int head[MAXN];
int dep[MAXN];
int gap[MAXN];//gap[x]=y :說明殘留網絡中dep[i]==x的個數為y
int nn;//n是總的點的個數，包括源點和匯點
void init()
{
? ? tol=0;
? ? memset(head,-1,sizeof(head));
}
void addedge(int u,int v,int w)
{
? ? edge[tol].from=u;
? ? edge[tol].to=v;
? ? edge[tol].cap=w;
? ? edge[tol].next=head[u];
? ? head[u]=tol++;
? ? edge[tol].from=v;
? ? edge[tol].to=u;
? ? edge[tol].cap=0;
? ? edge[tol].next=head[v];
? ? head[v]=tol++;
}
void BFS(int start,int end)
{
? ? memset(dep,-1,sizeof(dep));
? ? memset(gap,0,sizeof(gap));
? ? gap[0]=1;
? ? int que[MAXN];
? ? int front,rear;
? ? front=rear=0;
? ? dep[end]=0;
? ? que[rear++]=end;
? ? while(front!=rear)
? ? {
? ? ? ? int u=que[front++];
? ? ? ? if(front==MAXN)front=0;
? ? ? ? for(int i=head[u];i!=-1;i=edge[i].next)
? ? ? ? {
? ? ? ? ? ? int v=edge[i].to;
? ? ? ? ? ? if(dep[v]!=-1)continue;
? ? ? ? ? ? que[rear++]=v;
? ? ? ? ? ? if(rear==MAXN)rear=0;
? ? ? ? ? ? dep[v]=dep[u]+1;
? ? ? ? ? ? ++gap[dep[v]];
? ? ? ? }
? ? }
}
int SAP(int start,int end)
{
? ? int res=0;
? ? BFS(start,end);
? ? int cur[MAXN];
? ? int S[MAXN];
? ? int top=0;
? ? memcpy(cur,head,sizeof(head));
? ? int u=start;
? ? int i;
? ? while(dep[start]<nn)
? ? {
? ? ? ? if(u==end)
? ? ? ? {
? ? ? ? ? ? int temp=INF;
? ? ? ? ? ? int inser;
? ? ? ? ? ? for(i=0;i<top;i++)
? ? ? ? ? ? ? ?if(temp>edge[S[i]].cap)
? ? ? ? ? ? ? ?{
? ? ? ? ? ? ? ? ? ?temp=edge[S[i]].cap;
? ? ? ? ? ? ? ? ? ?inser=i;
? ? ? ? ? ? ? ?}
? ? ? ? ? ? for(i=0;i<top;i++)
? ? ? ? ? ? {
? ? ? ? ? ? ? ? edge[S[i]].cap-=temp;
? ? ? ? ? ? ? ? edge[S[i]^1].cap+=temp;
? ? ? ? ? ? }
? ? ? ? ? ? res+=temp;
? ? ? ? ? ? top=inser;
? ? ? ? ? ? u=edge[S[top]].from;
? ? ? ? }
? ? ? ? if(u!=end&&gap[dep[u]-1]==0)//出現斷層，無增廣路
? ? ? ? ? break;
? ? ? ? for(i=cur[u];i!=-1;i=edge[i].next)
? ? ? ? ? ?if(edge[i].cap!=0&&dep[u]==dep[edge[i].to]+1)
? ? ? ? ? ? ?break;
? ? ? ? if(i!=-1)
? ? ? ? {
? ? ? ? ? ? cur[u]=i;
? ? ? ? ? ? S[top++]=i;
? ? ? ? ? ? u=edge[i].to;
? ? ? ? }
? ? ? ? else
? ? ? ? {
? ? ? ? ? ? int min=nn;
? ? ? ? ? ? for(i=head[u];i!=-1;i=edge[i].next)
? ? ? ? ? ? {
? ? ? ? ? ? ? ? if(edge[i].cap==0)continue;
? ? ? ? ? ? ? ? if(min>dep[edge[i].to])
? ? ? ? ? ? ? ? {
? ? ? ? ? ? ? ? ? ? min=dep[edge[i].to];
? ? ? ? ? ? ? ? ? ? cur[u]=i;
? ? ? ? ? ? ? ? }
? ? ? ? ? ? }
? ? ? ? ? ? --gap[dep[u]];
? ? ? ? ? ? dep[u]=min+1;
? ? ? ? ? ? ++gap[dep[u]];
? ? ? ? ? ? if(u!=start)u=edge[S[--top]].from;
? ? ? ? }
? ? }
? ? return res;
}
//**************************************
int main ()
{
? ?int i ,j ,n ,m ,s ,e;
? ?while(~scanf("%d %d" ,&n ,&m))
? ?{
? ? ? int sum_n = 0;
? ? ? for(i = 1 ;i <= n ;i ++)
? ? ? for(j = 1 ;j <= m ;j ++)
? ? ? {
? ? ? ? ?scanf("%s" ,map[i][j].node);
? ? ? ? ?if(map[i][j].node[0] == '.')
? ? ? ? ?{
? ? ? ? ? ? sum_n ++;
? ? ? ? ? ? continue;
? ? ? ? ?}
? ? ? ? ?if(map[i][j].node[0] != 'X')
? ? ? ? ?sum_n ++;
? ? ? ? ?if(map[i][j].node[4] != 'X')
? ? ? ? ?sum_n ++;
? ? ? }
? ? ? ? ?
? ? ? s = 0 ,e = sum_n + 1;
? ? ? sum_n = 0;
? ? ? memset(X ,255 ,sizeof(X)); ? ? ? ? ? ? ? ? ? ? ?
? ? ? memset(head ,255 ,sizeof(head));
? ? ? tol = 0;
? ? ? for(i = 1 ;i <= n ;i ++)
? ? ? for(j = 1 ;j <= m ;j ++)
? ? ? {
? ? ? ? ?if(map[i][j].node[3] == 'X' || map[i][j].node[0] == '.') continue;
? ? ? ? ?char t_str[8];
? ? ? ? ?for(int ii = 0 ;ii <= 7 ;ii ++)
? ? ? ? ?t_str[ii] = map[i][j].node[ii];
? ? ? ? ?int a ,b ,mk = 0;
? ? ? ? ?if(X[(i-1)*m+j] == -1) X[(i-1)*m+j] = ++sum_n;
? ? ? ? ?int now = ?X[(i-1)*m+j];
? ? ? ? ?if(t_str[0] != 'X')
? ? ? ? ?{
? ? ? ? ? ? mk = 1;
? ? ? ? ? ? int temp = (t_str[0]-48)*100+(t_str[1]-48)*10+(t_str[2]-48)*1;?
? ? ? ? ? ? for(int ii = i + 1 ;ii <= n ;ii ++)
? ? ? ? ? ? {
? ? ? ? ? ? ? ?if(map[ii][j].node[0] != '.')
? ? ? ? ? ? ? ?break;
? ? ? ? ? ? ? ?temp --;
? ? ? ? ? ? ? ?if(X[(ii - 1) * m + j] == -1) X[(ii - 1) * m + j] = ++sum_n;
? ? ? ? ? ? ? ?b = X[(ii - 1) * m + j]; ? ? ??
? ? ? ? ? ? ? ?addedge(now ,b ,8);
? ? ? ? ? ? }
? ? ? ? ? ? addedge(s ,now ,temp);
? ? ? ? ?}
? ? ? ? ?
? ? ? ? ?if(t_str[4] != 'X')
? ? ? ? ?{ ? ? ? ? ? ? ? ? ? ?
? ? ? ? ? ? if(mk) now = ++sum_n;
? ? ? ? ? ? int temp = (t_str[4]-48)*100+(t_str[5]-48)*10+(t_str[6]-48)*1;
? ? ? ? ? ? for(int jj = j + 1 ;jj <= m ;jj ++)
? ? ? ? ? ? {
? ? ? ? ? ? ? ?if(map[i][jj].node[0] != '.')
? ? ? ? ? ? ? ?break;
? ? ? ? ? ? ? ?temp --;
? ? ? ? ? ? ? ?if(X[(i - 1) * m + jj] == -1) X[(i - 1) * m + jj] = ++sum_n;
? ? ? ? ? ? ? ?a = X[(i - 1) * m + jj];
? ? ? ? ? ? ? ?addedge(a ,now ,8);
? ? ? ? ? ? }
? ? ? ? ? ? addedge(now ,e ,temp);
? ? ? ? ?}
? ? ? }
? ? ??
? ? ? nn = sum_n + 1 + 1;
? ? ? SAP(s ,e);
? ? ? for(i = 1 ;i <= n ;i ++)
? ? ? for(j = 1 ;j <= m ;j ++)
? ? ? {
? ? ? ? ?if(j != 1) printf(" ");
? ? ? ? ?if(map[i][j].node[0] != '.')
? ? ? ? ?printf("_");
? ? ? ? ?else
? ? ? ? ?{
? ? ? ? ? ? int k = head[X[(i - 1) * m + j]];
? ? ? ? ? ? int c = edge[k].cap;
? ? ? ? ? ? printf("%d" ,8 - c + 1);
? ? ? ? ?}
? ? ? ? ?if(j == m) printf("\n");
? ? ? }
? ?}
? ?return 0;
}???
??
總結
以上是生活随笔為你收集整理的hdu3338 最大流的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： hdu 1044 BFS(压缩图)+DF
- 下一篇： system , DOS 命令