hdu1733 分层网络流

初识网络流的渣渣根本看不出这是一个网络流。

知道是网络流之后，想到如果分层处理，每一层表示一个时间节点，层与层之间有关系的边要相连，注意拆点进行限制，超级源点向有人的节点流1，这样判断最大流与总人数是否相等。

开始我用的二分，想通过二分搞出那个临界的时间节点。。结果T了。

后来又学习了一下残余网络：

—在一个网络流图上，找到一条源到汇的路径（即找到了一个流量）后，对路径上所有的边，其容量都减去此次找到的流量，对路径上所有的边，都添加一条反向边，其容量也等于此次找到的流量，这样得到的新图，就称为原图的“残余网络”

所以可以一层一层添加，一次一次求最大流，直到满足条件。但其实这样也很慢。。。只是比之前的快了一些而已

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
using namespace std;

int dir[5][2] = {{0,0},{1,0},{-1,0},{0,1},{0,-1}};
int map[18][18],n,m,num,sd;
char ts[20];
struct Ren
{
	int x,y;
}rens[300],xin;

const int maxnode = 200000 + 5;
const int maxedge = 2*1000000 + 5;
const int oo = 1000000000;
int node, src, dest, nedge;
int head[maxnode], point[maxedge], next1[maxedge], flow[maxedge], capa[maxedge];//point[x]==y表示第x条边连接y，head，next为邻接表，flow[x]表示x边的动态值，capa[x]表示x边的初始值
int dist[maxnode], Q[maxnode], work[maxnode];//dist[i]表示i点的等级
void init(int _node, int _src, int _dest){//初始化，node表示点的个数，src表示起点，dest表示终点
    node = _node;
    src = _src;
    dest = _dest;
    for (int i = 0; i < node; i++) head[i] = -1;
    nedge = 0;
}
void addedge(int u, int v, int c1, int c2){//增加一条u到v流量为c1，v到u流量为c2的两条边
    point[nedge] = v, capa[nedge] = c1, flow[nedge] = 0, next1[nedge] = head[u], head[u] = (nedge++);
    point[nedge] = u, capa[nedge] = c2, flow[nedge] = 0, next1[nedge] = head[v], head[v] = (nedge++);
}
bool dinic_bfs(){
    memset(dist, 255, sizeof (dist));
    dist[src] = 0;
    int sizeQ = 0;
    Q[sizeQ++] = src;
    for (int cl = 0; cl < sizeQ; cl++)
        for (int k = Q[cl], i = head[k]; i >= 0; i = next1[i])
            if (flow[i] < capa[i] && dist[point[i]] < 0){
                dist[point[i]] = dist[k] + 1;
                Q[sizeQ++] = point[i];
            }
    return dist[dest] >= 0;
}
int dinic_dfs(int x, int exp){
    if (x == dest) return exp;
    for (int &i = work[x]; i >= 0; i = next1[i]){
        int v = point[i], tmp;
        if (flow[i] < capa[i] && dist[v] == dist[x] + 1 && (tmp = dinic_dfs(v, min(exp, capa[i] - flow[i]))) > 0){
            flow[i] += tmp;
            flow[i^1] -= tmp;
            return tmp;
        }
    }
    return 0;
}
int dinic_flow(){
    int result = 0;
    while (dinic_bfs()){
        for (int i = 0; i < node; i++) work[i] = head[i];
        while (1){
            int delta = dinic_dfs(src, oo);
            if (delta == 0) break;
            result += delta;
        }
    }
    return result;
}
//建图前,运行一遍init()；
//加边时，运行addedge(a,b,c,0),表示点a到b流量为c的边建成（注意点序号要从0开始）
//求解最大流运行dinic_flow(),返回值即为答案

int check(int temp)
{
	int i,j,k,p,q,ans,flag=0,tim,man;
	man=num;
	init(2+temp*sd*2+sd,0,temp*sd*2+1+sd);
	for(i=0;i<num;i++)
		addedge(0,(rens[i].x-1)*m+rens[i].y,1,0);
	for(k=1;k<=temp;k++)
	{
		for(i=1;i<=n;i++)
			for(j=1;j<=m;j++)
			{
				if(map[i][j]==1)
				{
					addedge((k-1)*sd*2+(i-1)*m+j,temp*sd*2+1+sd,oo,0);
				}
				else
				{
					for(p=0;p<5;p++)
					{
						xin.x=i+dir[p][0];
						xin.y=j+dir[p][1];
						if(map[xin.x][xin.y]!=-1)
						{
							addedge((k-1)*sd*2+(i-1)*m+j,(k-1)*sd*2+sd+(xin.x-1)*m+xin.y,1,0);
						}
					}
				}
				addedge((k-1)*sd*2+(i-1)*m+j+sd,(k-1)*sd*2+(i-1)*m+j+sd*2,1,0);
			}
		ans=dinic_flow();
		man-=ans;
		if(man==0)
		{
			flag=1;
			tim=k-1;
			break;
		}
	}
	if(flag==0)
		return -1;
	else
		return tim;
	
}



int main()
{
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		int i,j,ans;
		memset(map,-1,sizeof(map));
		num=0;
		sd=n*m;
		for(i=1;i<=n;i++)
		{
			scanf("%s",ts);
			for(j=0;ts[j];j++)
			{
				if(ts[j]=='.')
					map[i][j+1]=0;
				else if(ts[j]=='@')
					map[i][j+1]=1;
				else if(ts[j]=='X')
				{
					map[i][j+1]=0;
					rens[num].x=i;
					rens[num].y=j+1;
					num++;
				}
			}
		}	
		ans=check(260);
		printf("%d\n",ans);
	}
	return 0;
}