玲珑学院OJ 1130 - 喵哈哈村的魔法大师╳灬兲笙疯癫°月【强连通+可相交最小路径覆盖+背包】-CSDN博客

本文链接：https://blog.csdn.net/mengxiang000000/article/details/72842864

1130 - 喵哈哈村的魔法大师╳灬兲笙疯癫°月

Time Limit：1s Memory Limit：256MByte

Submissions：196Solved：23

DESCRIPTION

 ╳灬兲笙疯癫°月是月大叔的ID，他是一个掌握着429种魔法的魔法大师，最擅长的技能就是搞事，今天他又要开始搞事了。
 现在有一个由n个点，m条边组成的有向图，每个点上面都有一个魔法家族。
 现在月大叔为了通知别人参加他的魔法大会，于是他就要拜访所有的家族。
 由于是有向图，所以可能存在过去，就无法回来的情况，但是没有关系。
 月大叔可以创造传送卷轴，传送卷轴可以传送到任意一个点。
 第i张传送卷轴的造价是aiai元，可以使用cici次，当然每个卷轴只能造一次。
 现在问你月大叔最少需要多少钱，就可以拜访所有的人了。
 注意一开始月大叔就得使用一次传送魔法噢。

INPUT

    输入第一行包含一个正整数 
    
   t(1≤t≤100)t(1≤t≤100) ,表示有t组数据对于每组数据：第一行三个整数n，m，k。表示有 
    
   n(1≤n≤500)n(1≤n≤500)个点， 
    
   m(1≤m≤n∗(n−1)/2)m(1≤m≤n∗(n−1)/2)条边， 
    
   k(1≤k≤500)k(1≤k≤500)种魔法卷轴接下来m行，每行两个整数u,v，表示u到v之间有一条有向边，可能存在自环、重边的情况。接下来k行，每行两个整数 
    
   ai(1≤ai≤500)ai(1≤ai≤500), 
    
   ci(1≤ci≤500)ci(1≤ci≤500)，分别表示卷轴的造价和使用次数。

OUTPUT

    对于每组测试数据的询问，输出有多少对即可。对于每组测试数据的询问，输出最少花多少钱即可如果无解的话，请输出"-1" 
  

SAMPLE INPUT

SAMPLE OUTPUT

4

SOLUTION

思路：

这个题好总和丫。

首先问题的模型就是一个DAG图上课相交最小路径覆盖问题。

但是首先这个题的图由输入可知，给出的图并不是DAG图，所以我们先Tarjan强连通搞出一个DAG图。

然后根据搞出来的DAG图，跑Floyd传递闭包，再建图跑二分匹配，又有最小路径覆盖=n-最大二分匹配数。

那么我们得到的最小路径覆盖数，就是需要传送的最小次数。

那么我们根据k个卷轴的信息，跑一发背包就行了。

Ac代码：

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<vector>
using namespace std;
struct node
{
    int cost,val;
}a[505];
vector<int >mp[505];
int mpp[505][505];
int match[551];
int dp[555*1000];
int stack[5000];
int color[5000];
int dfn[5000];
int low[5000];
int vis[5000];
int sig,cnt,tt;
int n,m,k;
void Floyd()
{
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            for(int k=1;k<=n;k++)
            {
                if(mpp[j][i]==1&&mpp[i][k]==1)mpp[j][k]=1;
            }
        }
    }
}
int find(int u)
{
    for(int i=1;i<=n;i++)
    {
        if(i==u)continue;
        if(mpp[u][i]==1&&vis[i]==0)
        {
            vis[i]=1;
            if(match[i]==-1||find(match[i]))
            {
                match[i]=u;
                return 1;
            }
        }
    }
    return 0;
}
void Dp(int sum)
{
    int tot=0;
    for(int i=0;i<k;i++)
    {
        int cost,val;
        scanf("%d%d",&a[i].cost,&a[i].val);
        tot+=a[i].cost;
    }
    int ans=0x3f3f3f3f;
    for(int i=0;i<=tot;i++)dp[i]=0;
    for(int i=0;i<k;i++)
    {
        for(int j=tot;j>=a[i].cost;j--)
        {
            dp[j]=max(dp[j],dp[j-a[i].cost]+a[i].val);
            if(dp[j]>=sum)ans=min(ans,j);
        }
    }
    if(ans==0x3f3f3f3f)printf("-1\n");
    else
    printf("%d\n",ans);
    return ;
}
void Slove()
{
    int sum=0;
    memset(match,-1,sizeof(match));
    for(int i=1;i<=n;i++)
    {
        memset(vis,0,sizeof(vis));
        if(find(i))sum++;
    }
    Dp(n-sum);
}
void Tarjan(int u)
{
    vis[u]=1;
    dfn[u]=low[u]=cnt++;
    stack[++tt]=u;
    for(int i=0;i<mp[u].size();i++)
    {
        int v=mp[u][i];
        if(vis[v]==0)Tarjan(v);
        if(vis[v]==1)low[u]=min(low[u],low[v]);
    }
    if(dfn[u]==low[u])
    {
        sig++;
        do
        {
            color[stack[tt]]=sig;
            vis[stack[tt]]=-1;
        }
        while(stack[tt--]!=u);
    }
}
void DAG()
{
    cnt=1,sig=0,tt=-1;
    memset(stack,0,sizeof(stack));
    memset(color,0,sizeof(color));
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n;i++)
    {
        if(vis[i]==0)Tarjan(i);
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<mp[i].size();j++)
        {
            int v=mp[i][j];
            if(color[i]!=color[v])
            {
                mpp[color[i]][color[v]]=1;
            }
        }
    }
    n=sig;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d%d",&n,&m,&k);
        memset(mpp,0,sizeof(mpp));
        for(int i=1;i<=n;i++)mp[i].clear();
        for(int i=0;i<m;i++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            mp[x].push_back(y);
        }
        DAG();
        Floyd();
        Slove();
    }
}