HDU-4160 Doll 最小路径覆盖

/*
题意：给出n个箱子，箱子可以放在箱子里边，但是要满足放在里边的箱子的长要小于外边的长，宽要满足小于外边的宽，高要满足小于外边的高。求露在外边的箱子最多有多少个。
思路：思路：最小路径覆盖，如果满足条件：wi < wj , li < lj , and hi < hj，那么i->j连边，然后就是求最大匹配。

最小路径覆盖=顶点数-最大匹配。
*/

#include "stdio.h"
#include "string.h"
#include "queue"
#include "algorithm"
using namespace std;
const int maxn = 505;
const int inf = 1<<30;
int nx,ny;
int dis;
int map[maxn][maxn];              //二分图
int cx[maxn],cy[maxn];            //cx[i] 表示左集合i顶点所匹配到的右集合顶点序号   cy[i]表示右集合i顶点所匹配到的左集合顶点序号 
int dx[maxn],dy[maxn];			  //dx[i] 表示左集合i顶点的距离标号		dy[i] 表示右集合i顶点的距离标号 
bool vis[maxn];					  //寻找增广路时 的标记数组
struct Node
{
	int w,l,h;
}doll[maxn];
bool cmp( Node a, Node b )
{
	return a.w < b.w ;
}

//Hopcroft-Karp算法 有点类似dinic 都是先对图BFS分层再沿层数DFS找增广路
//====================================核心
bool searchpath()
{
	queue<int>que;
	dis = inf;
	memset( dx,-1,sizeof(dx) );
	memset( dy,-1,sizeof(dy) );
	for( int i = 1; i <= nx; i ++  )
	{
		if( cx[i] == -1 )
		{
			que.push(i);
			dx[i] = 0;
		}
	}
	while( !que.empty() )
	{
		int u = que.front(); que.pop();
		if( dx[u] > dis )	break;
		for( int v = 1; v <= ny; v ++ )
		{
			if( map[u][v] && dy[v] == -1 )
			{
				dy[v] = dx[u] + 1;
				if( cy[v] == -1 )
					dis = dy[v];
				else
				{
					dx[cy[v]] = dy[v] + 1;
					que.push(cy[v]);
				}
			}
		}
	}
	return dis != inf;
}

int findpath( int u )
{
	for( int v = 1; v <= ny; v++ )
	{
		if( map[u][v] && !vis[v] && dy[v] == dx[u] + 1 )
		{
			vis[v] = 1;
			if( cy[v] != -1 && dy[v] == dis )
				continue;
			if( cy[v] == -1 || findpath( cy[v] ) )
			{
				cy[v] = u;
				cx[u] = v;
				return true;
			}
		}
	}
	return false;
}

int MaxMatch()
{
	int ans = 0;
	int i;
	//memset(cx,-1,sizeof(cx));
	//memset(cy,-1,sizeof(cy));
	for( i = 1; i <= nx; i++ )   //初始化
	{
		cx[i]  = -1;
	}
	for( i = 1; i <= ny; i++ )
	{
		cy[i] = -1;
	}
	while( searchpath() )
	{		
		//memset(vis,0,sizeof(vis));
		for( i = 1; i <= ny; i++ )  //初始化
		{
			vis[i] = 0; 
		}
		for( i = 1; i <= nx; i++ )
		{
			if( cx[i] == -1 )
			{
				ans += findpath(i);
			}
		}
	}
	return ans;
}
//====================================

int main()
{
	int i,j;
	while( scanf("%d",&nx)!=EOF , nx )
	{
		ny = nx;
		// memset(map,0,sizeof(map));
		for( i = 1; i <= nx; i ++ )   //初始化
		{
			for( j = 1; j <= ny; j ++ )
			{
				map[i][j] = 0;
			}
		}
		for( i = 1; i <= nx; i ++ )
		{
			scanf("%d%d%d",&doll[i].w,&doll[i].l,&doll[i].h );
		}
		sort( doll+1,doll+nx+1,cmp );
		for( i = 1; i <= nx; i ++ )
		{
			for( j = 1; j <= i; j ++ )
			{
				if( doll[j].w < doll[i].w && doll[j].l < doll[i].l && doll[j].h < doll[i].h )
				{
					map[i][j] = 1;
				}
			}
		}
		printf("%d\n",nx-MaxMatch() );
	}
	return 0;
}