POJ_2060_Taxi Cab Scheme【最小路径覆盖】

/*
Taxi Cab Scheme
Time Limit: 1000MS        Memory Limit: 30000K
Total Submissions: 6460        Accepted: 2720

Description
Running a taxi station is not all that simple. Apart from the obvious demand for a
centralised coordination of the cabs in order to pick up the customers calling to get a cab as soon
as possible,there is also a need to schedule all the taxi rides which have been booked in advance.
Given a list of all booked taxi rides for the next day, you want to minimise the number of cabs
needed to carry out all of the rides.
For the sake of simplicity, we model a city as a rectangular grid. An address in the city is denoted
 by two integers: the street and avenue number. The time needed to get from the address a, b to c, d
  by taxi is |a - c| + |b - d| minutes. A cab may carry out a booked ride if it is its first ride of
  the day, or if it can get to the source address of the new ride from its latest,at least one minute
   before the new ride's scheduled departure. Note that some rides may end after midnight.

Input
On the first line of the input is a single positive integer N, telling the number of test scenarios
to follow. Each scenario begins with a line containing an integer M, 0 < M < 500, being the number
of booked taxi rides. The following M lines contain the rides. Each ride is described by a departure
 time on the format hh:mm (ranging from 00:00 to 23:59), two integers a b that are the coordinates
 of the source address and two integers c d that are the coordinates of the destination address. All
 coordinates are at least 0 and strictly smaller than 200. The booked rides in each scenario are
  sorted in order of increasing departure time.

Output
For each scenario, output one line containing the minimum number of cabs required to carry out all
 the booked taxi rides.

Sample Input

2
2
08:00 10 11 9 16
08:07 9 16 10 11
2
08:00 10 11 9 16
08:06 9 16 10 11

Sample Output

1
2
题意：出租车公司有n个预约, 每个预约有时间和地点, 地点分布在二维整数坐标系上, 地点之间的行驶时间为两点间的曼哈顿距离
（|x1 - x2| + |y1 - y2|）。一辆车可以在运完一个乘客后运另一个乘客, 条件是此车要在预约开始前一分钟之前到达出发地, 问最少需要几辆车搞定所有预约。

给出一些预约的起始时间，出发地和目的地，问至少需要多少车可以满足所有的预约
对于任何一对预约，如果前一预约的结束时刻加上到达下一个预约的所需时间小于下一个预约

的起始时间，就在两个预约之间连一条边，题目就转化为求该图的最小路径覆盖

不懂的看这个知识点

*/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define inf 0x3f3f3f3f
int match[610];
int map[610][610];
bool vis[610];
int n;
struct Node
{
	int start;
	int end;
	int a,b,c,d,e,f;
}edge[1220];
int cmp(const void *a,const void *b)
{
	return (*(Node *)a).start - (*(Node *)b).start;
}
int dfs(int x)
{
	int i;
	for(i=1;i<=n;i++)
	{
		if(!vis[i] && map[x][i])
		{
			vis[i] = true;
			if(!match[i] || dfs(match[i]))
			{
				match[i] = x;
				return 1;
			}
		}
	}
	return 0;
}
int main()
{
	int T;
	scanf("%d",&T);
	while(T--)
	{
		int i,j;
		scanf("%d",&n);
		for(i=1;i<=n;i++)
		{
			scanf("%d:%d%d%d%d%d",&edge[i].a,&edge[i].b,&edge[i].c,&edge[i].d,&edge[i].e,&edge[i].f);
			edge[i].start = edge[i].a*60+edge[i].b; //起始时间
			edge[i].end = edge[i].start + abs(edge[i].e-edge[i].c) + abs(edge[i].f-edge[i].d);//结束时间
		}
		qsort(edge+1,n,sizeof(edge[0]),cmp);
		memset(map,0,sizeof(map));
		for(i=1;i<n;i++)
		{
			for(j=i+1;j<=n;j++)
			{
				int t = abs(edge[i].e-edge[j].c) + abs(edge[i].f-edge[j].d);
				if(edge[i].end+t < edge[j].start)//前一预约的结束时刻加上到达下一个预约的所需时间  小于下一个预约的起始时间， 
				{
					map[i][j] = 1;
				}
			}
		}
		memset(match,0,sizeof(match));
		int ans = 0;
		for(i=1;i<=n;i++)
		{
			memset(vis,false,sizeof(vis));
			if(dfs(i))
			{
				ans ++ ;
			}
		}
		printf("%d\n",n-ans);
	}
	return 0;
}