POJ 3216 Repairing Company(FLOYD+DAG最小路径覆盖)

POJ 3216 Repairing Company(FLOYD+DAG最小路径覆盖)

http://poj.org/problem?id=3216

题意:

       给出Q的街道和M个任务

       然后给出i*j的矩阵..表示第i个地点到第j个地点的距离 其中-1表示不可到达.

       然后接下来M行有 p t d 表示 任务在p地点, 开始时间是t, 完成工作花费时间是d.

       问最少派出多少人可以完成M个任务

分析:

       本题与刘汝佳<<训练指南>>P356例题29基本一样.

       其实如果一个工人做完第一个任务时,还有任务没人做的话且他能及时赶到这个任务的话,那么他可以立马跑到这个新任务处去做这个新任务. 那么这样就可以节省人力.

       把每个任务看成一个节点,如果一个人做i任务结束后还能赶到j任务处去做任务,那么就连一条从i到j的有向边. 最终我们得到了一个DAG图(时间是天然的序,所以该图不会存在环). 注意判断任务i是否存在到j的有向边, 需要判断是否 i的结束时间+i到j的最短路径时间<= j的开始时间. 而i到j的最短路径时间需要用Floyd算法求出.

       对于该DAG,我们要找出其最小路径覆盖(因为最小路径覆盖就是我们需要派遣的最少工人数目).

       DAG的最小路径覆盖=n-二分图的最大匹配数. 即本题转化为求二分图的最大匹配问题了.

AC代码:

#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
#define INF 1e9
using namespace std;
const int maxn= 200+10;
int dist[25][25];

int Q;//地点个数
void floyd()
{
    for(int k=1;k<=Q;k++)
    for(int i=1;i<=Q;i++)
    for(int j=1;j<=Q;j++)
    if(dist[i][k]<INF && dist[k][j]<INF)
        dist[i][j] = min(dist[i][j], dist[i][k]+dist[k][j]);
}

struct Max_Match
{
    int n;
    vector<int> g[maxn];
    bool vis[maxn];
    int left[maxn];

    void init(int n)
    {
        this->n=n;
        for(int i=1;i<=n;i++) g[i].clear();
        memset(left,-1,sizeof(left));
    }

    bool match(int u)
    {
        for(int i=0;i<g[u].size();i++)
        {
            int v=g[u][i];
            if(!vis[v])
            {
                vis[v]=true;
                if(left[v]==-1 || match(left[v]))
                {
                    left[v]=u;
                    return true;
                }
            }
        }
        return false;
    }

    int solve()
    {
        int ans=0;
        for(int i=1;i<=n;i++)
        {
            memset(vis,0,sizeof(vis));
            if(match(i)) ans++;
        }
        return ans;
    }
}MM;

struct Node
{
    int p,t,d;
    //Node(){}
    //Node(int p,int t,int d):p(p),t(t),d(d){}
    bool link(Node& rhs)
    {
        return t+d+dist[p][rhs.p] <= rhs.t ;
    }
}nodes[maxn];

int main()
{
    int n;
    while(scanf("%d%d",&Q,&n)==2 && Q)
    {
        for(int i=1;i<=Q;i++)
        for(int j=1;j<=Q;j++)
        {
            scanf("%d",&dist[i][j]);
            if(dist[i][j]==-1) dist[i][j]=INF;
        }
        floyd();

        MM.init(n);
        for(int i=1;i<=n;i++)
            scanf("%d%d%d",&nodes[i].p, &nodes[i].t, &nodes[i].d);
        for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)if(i!=j)
        if(nodes[i].link(nodes[j]))
            MM.g[i].push_back(j);
        printf("%d\n",n-MM.solve());
    }
    return 0;
}