uvalive 3353 Optimal Bus Route Design

题意：

给出n个点，以及每个点到其他点的有向距离，要求设计线路使得每一个点都在一个环中，如果设计的线路拥有最小值，那么这个线路就是可选的。输出这个最小值或者说明最小线路不存在。

思路：

在DAG的最小路径覆盖中，找到的最大匹配数实际是非终点的点的最大数量（每一个匹配对应一个起点），点数减去这个数量就是终点的最少数量，一个终点对应一条路径，所以这个路径覆盖是最小的。

这个题要求每一个点都在一个环中，也就是说找到一个设计线路的方案使之不存在DAG，那么自然就没有终点存在，也就意味着每一个点都可以作为起点，即是每一个点都有匹配，那么终点的数量就为0，所以只要这个图存在完美匹配，那么方案就一定存在。

用匈牙利算法找一下最大匹配，若最大匹配数量为n，那么方案就存在，接下来要找的就是最小的权值，既带权二分图的最小匹配，所以修改KM算法即可。

复杂度O(n^3)。

代码：

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

const int N = 105;
const int inf = 0x3f3f3f3f;

int match[N],mp[N][N];
int link[N];
bool vis[N];
bool vis_x[N],vis_y[N];
int slack[N];
int lx[N],ly[N];

vector<int> g[N];

bool dfs(int u)
{
    vis_x[u] = 1;
    
    for (int j = 0;j < g[u].size();j++)
    {
        int i = g[u][j];
        
        if (vis_y[i]) continue;
        
        int gap = lx[u] + ly[i] - mp[u][i];
        
        if (gap == 0)
        {
            vis_y[i] = 1;
            
            if (match[i] == - 1 || dfs(match[i]))
            {
                match[i] = u;
                
                return true;
            }
        }
        else
        {
            slack[i] = min(gap,slack[i]);
        }
    }
    
    return false;
}

int km(int n)
{
    memset(match,-1,sizeof(match));
    memset(ly,0,sizeof(ly));
    
    for (int i = 1;i <= n;i++)
    {
        lx[i] = mp[i][1];
        
        for (int j = 2;j <= n;j++)
        {
            lx[i] = max(lx[i],mp[i][j]);
        }
    }
    
    for (int i = 1;i <= n;i++)
    {
        memset(slack,inf,sizeof(slack));
        
        while (1)
        {
            memset(vis_x,0,sizeof(vis_x));
            memset(vis_y,0,sizeof(vis_y));
            
            if (dfs(i)) break;
            
            int d = inf;
            
            for (int j = 1;j <= n;j++)
            {
                if (!vis_y[j]) d = min(d,slack[j]);
            }
            
            for (int j = 1;j <= n;j++)
            {
                if (vis_x[j]) lx[j] -= d;
                if (vis_y[j]) ly[j] += d;
            }
        }
    }
    
    int ans = 0;
    
    for (int i = 1;i <= n;i++)
    {
        ans += mp[match[i]][i];
    }
    
    return ans;
}

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

bool hungary(int n)
{
    memset(link,-1,sizeof(link));
    int res = 0;
    for (int i = 1;i <= n;i++)
    {
        memset(vis,0,sizeof(vis));
        if (dfs2(i)) res++;
    }
    
    return res >= n;
}

int main()
{
    int n;
    
    while (scanf("%d",&n) != EOF && n)
    {
        for (int i = 1;i <= n;i++)
        {
            for (int j = 1;j <= n;j++)
                mp[i][j] = -inf;
        }
        
        for (int i = 0;i <= n;i++) g[i].clear();
        
        for (int i = 1;i <= n;i++)
        {
            int a,b;
            
            while (scanf("%d",&a) != EOF)
            {
                if (a == 0) break;
                
                scanf("%d",&b);
                
                mp[i][a] = -b;
                
                g[i].push_back(a);
            }
        }
        
        if (hungary(n))
        {
            printf("%d
",-km(n));
        }
        else
        {
            printf("N
");
        }
    }
    
    return 0;
}