BZOJ 2539 [Ctsc2000]丘比特的烦恼 带权二分图的最佳匹配

最新推荐文章于 2018-05-31 19:48:00 发布
最新推荐文章于 2018-05-31 19:48:00 发布
阅读量1.6k 收藏
点赞数
分类专栏： 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/budlele/article/details/38494007
版权

2539: [Ctsc2000]丘比特的烦恼

Time Limit: 1 Sec  Memory Limit: 128 MB
Submit: 407  Solved: 137
[ Submit][ Status]

Description

 

　　随着社会的不断发展，人与人之间的感情越来越功利化。最近，爱神丘比特发现，爱情也已不再是完全纯洁的了。这使得丘比特很是苦恼，他越来越难找到合适的男女，并向他们射去丘比特之箭。于是丘比特千里迢迢远赴中国，找到了掌管东方人爱情的神——月下老人，向他求教。

　　月下老人告诉丘比特，纯洁的爱情并不是不存在，而是他没有找到。在东方，人们讲究的是缘分。月下老人只要做一男一女两个泥人，在他们之间连上一条红线，那么它们所代表的人就会相爱——无论他们身处何地。而丘比特的爱情之箭只能射中两个距离相当近的人，选择的范围自然就小了很多，不能找到真正的有缘人。

　　丘比特听了月下老人的解释，茅塞顿开，回去之后用了人间的最新科技改造了自己的弓箭，使得丘比特之箭的射程大大增加。这样，射中有缘人的机会也增加了不少。

　　情人节(Valentine's day)的午夜零时，丘比特开始了自己的工作。他选择了一组数目相等的男女，感应到他们互相之间的缘分大小，并依此射出了神箭，使他们产生爱意。他希望能选择最好的方法，使被他选择的每一个人被射中一次，且每一对被射中的人之间的缘分的和最大。

　　当然，无论丘比特怎么改造自己的弓箭，总还是存在缺陷的。首先，弓箭的射程尽管增大了，但毕竟还是有限的，不能像月下老人那样，做到“千里姻缘一线牵”。其次，无论怎么改造，箭的轨迹终归只能是一条直线，也就是说，如果两个人之间的连线段上有别人，那么莫不可向他们射出丘比特之箭，否则，按月下老人的话，就是“乱点鸳鸯谱”了。

　　作为一个凡人，你的任务是运用先进的计算机为丘比特找到最佳的方案。

 

Input

　　输入文件第一行为正整数k，表示丘比特之箭的射程，第二行为正整数n(n<30)，随后有2n行，表示丘比特选中的人的信息，其中前n行为男子，后n行为女子。每个人的信息由两部分组成：他的姓名和他的位置。姓名是长度小于20且仅包含字母的字符串，忽略大小写的区别，位置是由一对整数表示的坐标，它们之间用空格分隔。格式为Name x y。输入文件剩下的部分描述了这些人的缘分。每一行的格式为Name1 Name2 p。Name1和Name2为有缘人的姓名，p是他们之间的缘分值(p为小于等于255的正整数)。以一个End作为文件结束标志。每两个人之间的缘分至多只被描述一次。如果没有被描述，则说明他们缘分值为1。

Output

　　输出文件仅一个正整数，表示每一对被射中的人之间的缘分的总和。这个和应当是最大的。

Sample Input

2

3

0 0 Adam

1 1 Jack

0 2 George

1 0 Victoria

0 1 Susan

1 2 Cathy

Adam Cathy 100

Susan George 20

George Cathy 40

Jack Susan 5

Cathy Jack 30

Victoria Jack 20

Adam Victoria 15

End

Sample Output

65

HINT

Source

[ Submit][ Status]



最小费用流版

#include <cstdlib>
#include <cctype>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>
#include <iostream>
#include <sstream>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <fstream>
#include <numeric>
#include <iomanip>
#include <bitset>
#include <list>
#include <stdexcept>
#include <functional>
#include <utility>
#include <ctime>

using namespace std;

#define PB push_back
#define MP make_pair
#define CLR(vis) memset(vis,0,sizeof(vis))
#define MST(vis,pos) memset(vis,pos,sizeof(vis))
#define MAX3(a,b,c) max(a,max(b,c))
#define MAX4(a,b,c,d) max(max(a,b),max(c,d))
#define MIN3(a,b,c) min(a,min(b,c))
#define MIN4(a,b,c,d) min(min(a,b),min(c,d))
#define PI acos(-1.0)
#define INF 0x7FFFFFFF
#define LINF 1000000000000000000LL
#define eps 1e-8

typedef long long ll;
typedef unsigned long long ull;

const int maxn=222;

struct Edge{
    int from,to,cap,flow,cost;
};

struct MCMF{
    int n,m,s,t;
    vector<Edge> edges;
    vector<int> G[maxn];
    int inq[maxn];
    int d[maxn];
    int p[maxn];
    int a[maxn];
    int flow,cost;

    void init(int n)
    {
        this->n=n;
        for(int i=0;i<n;i++)
            G[i].clear();
        edges.clear();
        flow=0,cost=0;
    }


    void addedge(int from,int to,int cap,int cost)
    {
        Edge p;
        p.from=from,p.to=to,p.cap=cap,p.flow=0,p.cost=cost;
        edges.push_back(p);
        p.from=to,p.to=from,p.cap=0,p.flow=0,p.cost=-cost;
        edges.push_back(p);
        m=edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }

    bool BellmanFord(int s,int t,int &flow,int &cost)
    {
        for(int i=0;i<n;i++)
            d[i]=INF;
        memset(inq,0,sizeof(inq));
        d[s]=0;inq[s]=1;p[s]=0;a[s]=INF;

        queue<int> Q;
        Q.push(s);
        while(!Q.empty())
        {
            int u=Q.front();Q.pop();
            inq[u]=0;
            for(int i=0;i<G[u].size();i++)
            {
                Edge &e=edges[G[u][i]];
                if(e.cap>e.flow && d[e.to]>d[u]+e.cost)
                {
                    d[e.to]=d[u]+e.cost;
                    p[e.to]=G[u][i];
                    a[e.to]=min(a[u],e.cap-e.flow);
                    if(!inq[e.to])
                    {
                        Q.push(e.to);
                        inq[e.to]=1;
                    }
                }
            }
        }
        if(d[t]==INF)
            return false;
        flow+=a[t];
        cost+=d[t]*a[t];
        int u=t;
        while(u!=s)
        {
            edges[p[u]].flow+=a[t];
            edges[p[u]^1].flow-=a[t];
            u=edges[p[u]].from;
        }
        return true;
    }

    void Mincost(int s,int t)
    {
        while(BellmanFord(s,t,flow,cost));
    }

};

vector< pair< string ,pair<int ,int > > > p;
int k,n;

string change(string st)
{
    string s=st ;
    for(int i=0;i<s.size();i++)
        if(s[i]>='A'&& s[i]<='Z')
            s[i]=s[i]+('a'-'A');
    return s ;
}

int find_index(string s)
{
    for(int i=1;i<=2*n;i++)
        if(p[i].first==s)
          return i;
}

bool check(int x0,int y0)
{
    int x1=p[x0].second.first;
    int y1=p[x0].second.second;
    int x2=p[y0].second.first;
    int y2=p[y0].second.second;
    if((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)>k*k)
        return false;
    for(int i=1;i<=2*n;i++)
    {
        if(i!=x0 && i!=y0)
        {
            if(p[i].second.first>=min(x1,x2) && p[i].second.first<=max(x1,x2))
            {
                if(p[i].second.second>=min(y1,y2) && p[i].second.second<=max(y1,y2))
                {
                    int x=p[i].second.first-x1,y=p[i].second.second-y1;
                    int a=p[i].second.first-x2,b=p[i].second.second-y2;
                    if(x*b == a*y)
                        return false;
                }
            }
        }
    }
    return true;
}

int main()
{
    p.clear();
    p.PB( MP("0",MP(0,0)) );
    int S,T;
    cin>>k>>n;
    MCMF e;
    S=0,T=2*n+1;
    e.init(T+1);

    string s;
    int x,y;
    for(int i=1;i<=2*n;i++)
    {
        scanf("%d%d",&x,&y);
        cin>>s;
        s=change(s);
        p.PB( MP(s,MP(x,y)));
    }

    int val[maxn][maxn];

    for(int i=1;i<=2*n;i++)
        for(int j=1;j<=2*n;j++)
            val[i][j]=1;
    string s1;
    int z;
    while(true)
    {
        cin>>s;
        if(s=="End")
            break;
        cin>>s1;
        scanf("%d",&z);
        s=change(s),s1=change(s1);
        x=find_index(s);
        y=find_index(s1);
        val[x][y]=val[y][x]=z;
    }

    for(int i=1;i<=n;i++)
        e.addedge(S,i,1,0);
    for(int i=n+1;i<=2*n;i++)
        e.addedge(i,T,1,0);
    for(int i=1;i<=n;i++)
    {
        for(int j=n+1;j<=2*n;j++)
        {
            if(check(i,j))
                e.addedge(i,j,1,-val[i][j]);
        }
    }
    e.Mincost(S,T);
    cout<<-e.cost<<endl;

    return 0;
}



KM算法版

裸的KM啊。。有tricks啊。。坑爹啊。。。WA了几个小时啊。。。。。输入的缘份值可能为0啊。。。。注孤生啊。。。。

#include <cstdlib>
#include <cctype>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>
#include <iostream>
#include <sstream>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <fstream>
#include <numeric>
#include <iomanip>
#include <bitset>
#include <list>
#include <stdexcept>
#include <functional>
#include <utility>
#include <ctime>

using namespace std;

#define PB push_back
#define MP make_pair
#define CLR(vis) memset(vis,0,sizeof(vis))
#define MST(vis,pos) memset(vis,pos,sizeof(vis))
#define MAX3(a,b,c) max(a,max(b,c))
#define MAX4(a,b,c,d) max(max(a,b),max(c,d))
#define MIN3(a,b,c) min(a,min(b,c))
#define MIN4(a,b,c,d) min(min(a,b),min(c,d))
#define PI acos(-1.0)
#define INF 0x7FFFFFFF
#define LINF 1000000000000000000LL
#define eps 1e-8

typedef long long ll;
typedef unsigned long long ull;

const int maxn=33;

int n,k;

struct KM{

    int nx,ny;
    int w[maxn][maxn];
    int lx[maxn],ly[maxn],match[maxn];
    bool sx[maxn],sy[maxn];

    void init(int x,int y)
    {
        nx=x;
        ny=y;
    }

    bool path(int u)
    {
        sx[u]=1;
        for(int v=1;v<=ny;v++)
        if(!sy[v] && lx[u]+ly[v]==w[u][v])
        {
            sy[v]=1;
            if(match[v]==-1||path(match[v]))
            {
                match[v]=u;
                return 1;
            }
        }
        return 0;
   }
   int km(bool maxsum)
   {
      int i,j;
      if(!maxsum)
        for(i=1;i<=nx;i++)
            for(j=1;j<=ny;j++)
                w[i][j]=-w[i][j];
      for(i=1;i<=nx;i++)
      {
        lx[i]=-INF;
        ly[i]=0;
        for(j=1;j<=ny;j++)
            lx[i]=max(lx[i],w[i][j]);
      }
      memset(match,-1,sizeof(match));
      for(int u=1;u<=nx;u++)
        while(1)
        {
            memset(sx,0,sizeof(sx));
            memset(sy,0,sizeof(sy));
            if(path(u))break;
            int dx=INF;
            for(i=1;i<=nx;i++)
                if(sx[i])
                    for(j=1;j<=ny;j++)
                        if(!sy[j])dx=min(lx[i]+ly[j]-w[i][j],dx);
            for(i=1;i<=ny;i++)
                 if(sx[i])lx[i]-=dx;
            for(i=1;i<=ny;i++)
                 if(sy[i])ly[i]+=dx;
        }
      int sum=0;
      for(i=1;i<=ny;i++)
        sum+=w[match[i]][i];
      if(!maxsum)
      {
        sum=-sum;
        for(i=1;i<=nx;i++)
            for(j=1;j<=ny;j++)
                w[i][j]=-w[i][j];
      }
      return sum;
    }
};

vector< pair< string ,pair<int ,int > > > p;

string change(string st)
{
    string s=st ;
    for(int i=0;i<s.size();i++)
        if(s[i]>='A'&& s[i]<='Z')
            s[i]=s[i]+('a'-'A');
    return s ;
}

int find_index(string s)
{
    for(int i=1;i<=2*n;i++)
        if(p[i].first==s)
          return i;
}

bool check(int x0,int y0)
{
    int x1=p[x0].second.first;
    int y1=p[x0].second.second;
    int x2=p[y0].second.first;
    int y2=p[y0].second.second;
    if((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)>k*k)
        return false;
    for(int i=1;i<=2*n;i++)
    {
        if(i!=x0 && i!=y0)
        {
            if(p[i].second.first>=min(x1,x2) && p[i].second.first<=max(x1,x2))
            {
                if(p[i].second.second>=min(y1,y2) && p[i].second.second<=max(y1,y2))
                {
                    int x=p[i].second.first-x1,y=p[i].second.second-y1;
                    int a=p[i].second.first-x2,b=p[i].second.second-y2;
                    if(x*b == a*y)
                        return false;
                }
            }
        }
    }
    return true;
}

int main()
{
    cin>>k>>n;

    p.clear();
    p.PB( MP("0",MP(0,0)) );

    KM e;
    e.init(n,n);

    string s;
    int x,y;
    for(int i=1;i<=2*n;i++)
    {
        scanf("%d%d",&x,&y);
        cin>>s;
        s=change(s);
        p.PB( MP(s,MP(x,y)));
    }
    int val[maxn][maxn];
    CLR(val);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            val[i][j]=1;
    string s1;
    int z;
    while(true)
    {
        cin>>s;
        if(s=="End")
            break;
        cin>>s1;
        scanf("%d",&z);
        s=change(s),s1=change(s1);
        x=find_index(s);
        y=find_index(s1);

        int a,b;

        if(x>n)
            a=y,b=x%n;
        if(y>n)
            a=x,b=y%n;
        if(b==0)
            b=n;
        val[a][b]=z;
    }


    for(int i=1;i<=n;i++)
    {
        for(int j=n+1;j<=2*n;j++)
        {
            int tmp=0;
            tmp=j%n;
            if(tmp==0)
                tmp=n;
            if(check(i,j))
            {
                e.w[i][tmp]=val[i][tmp];
            }
            else
            {
                e.w[i][tmp]=-10000;
            }

        }
    }
    int ans=e.km(1);
    cout<<ans<<endl;

    return 0;
}



Clearle
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CTSC 2011 无穷图的桥(BZOJ 2307) 题解.ppt
03-17
CTSC 2011 无穷图的桥(BZOJ 2307) 题解.ppt
P1500 丘比特的烦恼
qq_43544481的博客
01-29 202
题目描述 随着社会的不断发展，人与人之间的感情越来越功利化。最近，爱神丘比特发现，爱情也已不再是完全纯洁的了。这使得丘比特很是苦恼，他越来越难找到合适的男女，并向他们射去丘比特之箭。于是丘比特千里迢迢远赴中国，找到了掌管东方人爱情的神——月下老人，向他求教。 月下老人告诉丘比特，纯洁的爱情并不是不存在，而是他没有找到。在东方，人们讲究的是缘分。月下老人只要做一男一女两个泥人，在他们之间连上一条红线...
BZOJ2539: [Ctsc2000]丘比特的烦恼
weixin_30448685的博客
05-08 90
BZOJ2539: [Ctsc2000]丘比特的烦恼 Description 随着社会的不断发展，人与人之间的感情越来越功利化。 最近，爱神丘比特发现，爱情也已不再是完全纯洁的了。 这使得丘比特很是苦恼，他越来越难找到合适的男女，并向他们射去丘比特之箭。 于是丘比特千里迢迢远赴中国，找到了掌管东方人爱情的神——月下老人，向他求教。 月下老人告诉丘比特，纯洁的爱情并不是不存在，而是他...
★☆【二分圖最佳匹配】丘比特的煩惱
void* ptr = &OI;
02-01 1759
随着社会的不断发展，人与人之间的感情越来越功利化。最近，爱神丘比特发现，爱情也已不再是完全纯洁的了。这使得丘比特很是苦恼，他越来越难找到合适的男女，并向他们射去丘比特之箭。于是丘比特千里迢迢远赴中国，找到了掌管东方人爱情的神——月下老人，向他求教。 　　月下老人告诉丘比特，纯洁的爱情并不是不存在，而是他没有找到。在东方，人们讲究的是缘分。月下老人只要做一男一女两个泥人，在他们之间连上一条红线，那么
bzoj 2539: [Ctsc2000]丘比特的烦恼 （KM算法）
clover_hxy的博客
04-22 753
题目描述传送门题解KM的裸题吧，就是细节比较恶心。。。。代码#include<iostream> #include<algorithm> #include<cstring> #include<cstdio> #include<cmath> #include<map> #define N 103 #define inf 1000000000 using namespace std; double di
【二分图最佳匹配】丘比特的烦恼
wu_yihao的专栏
02-04 1676
丘比特的烦恼(Cupid.exe) 　　随着社会的不断发展，人与人之间的感情越来越功利化。最近，爱神丘比特发现，爱情也已不再是完全纯洁的了。这使得丘比特很是苦恼，他越来越难找到合适的男女，并向他们射去丘比特之箭。于是丘比特千里迢迢远赴中国，找到了掌管东方人爱情的神——月下老人，向他求教。 　　月下老人告诉丘比特，纯洁的爱情并不是不存在，而是他没有找到。在东方，人们讲究的是缘分。月下老人
BZOJ全代码
02-05
BZOJ平台全部代码，解压到一个文件夹在打开使用。BZOJ平台全部代码，解压到一个文件夹在打开使用。
BZOJ第一部分
11-03
BZOJ原题-BZOJP1000-P2000的题目，下载后可以离线做题。
BZOJ3230相似子串测试数据
08-19
BZOJ3230相似子串的测试数据，希望能够帮到大家。
bzoj problem
08-21
八中OJ所有题目
图论(KM算法)：COGS 290. [CTSC2008] 丘比特的烦恼
weixin_30477293的博客
03-28 79
290. [CTSC2008] 丘比特的烦恼 ★★★ 输入文件：cupid.in 输出文件：cupid.out 简单对比 时间限制：1 s 内存限制：128 MB 　　随着社会的不断发展，人与人之间的感情越来越功利化。最近，爱神丘比特发现，爱情也已不再是完全纯洁的了。这使得丘比特很是苦恼，他越来越难找到合适的男女，并向他们射去丘比特之箭。于是丘比特千里迢迢远赴中国，找...
[BZOJ2539][Ctsc2000]丘比特的烦恼（KM+计算几何）
zyf2000
04-18 957
题目描述传送门题目大意：这题说了题目大意就没意思了。题解KM裸题（笑 http://www.lydsy.com/JudgeOnline/wttl/thread.php?tid=4169代码#include<algorithm> #include<iostream> #include<cstring> #include<cstdio> #include<cmath> #include<map> us
【最大费用流】【最优匹配】丘比特的烦恼 Vijos 1169
Jiangzh_MZOI
03-29 2201
Vijos-P1169丘比特的烦恼 Accepted 描述 随着社会的不断发展，人与人之间的感情越来越功利化。最近，爱神丘比特发现，爱情也已不再是完全纯洁的了。这使得丘比特很是苦恼，他越来越难找到合适的男女，并向他们射去丘比特之箭。于是丘比特千里迢迢远赴中国，找到了掌管东方人爱情的神——月下老人，向他求教。 月下老人告诉丘比特，纯洁的爱情并不是不存在，而是他没有找到
[BZOJ2162]男生女生（二分图带权独立集+dp）
AZUI _ oi memories
05-30 865
题意：懒得写了，比较麻烦。 强行嵌套的题真没意思。。 开始我看见数据范围n=50，第一问求什么完全子图，我以为是个搜索减枝，然后第二问那个dp我想了想，列了几个方程发现不是很对，然后又没有部分分，我就弃疗了。。 其实想一想应该是想得出来的，主要是考试的时候写了第二题的很麻烦的做法，被折腾得没精力了，就没怎么想。。第一问其实很简单，二分图完全子图是P类的。我们求出这个二分图的补图，补图中的边就
二分图常见模型
C'est la vie.
08-12 4033
最小点覆盖最小的点集使得其相连的边能覆盖所有边。König定理：最小点覆盖=最大匹配证明很简单，在得到最大匹配之后，一条边必然只有两种情况，两点都是匹配点，只有一个是匹配点。又因为对于一条匹配边来说，其两点上不可能同时连有非匹配点（即第二种情况的边），那么只需要把匹配边上两点的其中一点（含有第二种情况的点）包含到点集里，其另一点就可以通过选择的这个点来覆盖了（因为匹配边之间都是独立的）。POJ 30
[bzoj2539][网络流-费用流]丘比特的烦恼
Rose_max的博客
03-23 259
Description 随着社会的不断发展，人与人之间的感情越来越功利化。最近，爱神丘比特发现，爱情也已不再是完全纯洁的了。 这使得丘比特很是苦恼，他越来越难找到合适的男女，并向他们射去丘比特之箭。于是丘比特千里迢迢远赴中国， 找到了掌管东方人爱情的神——月下老人，向他求教。月下老人告诉丘比特，纯洁的爱情并不是不存在，而是他没 有找到。在东方，人们讲究的是缘分。月下老人只...
【刷题】BZOJ 2539 [Ctsc2000]丘比特的烦恼
weixin_30511107的博客
05-31 108
Description 随着社会的不断发展，人与人之间的感情越来越功利化。最近，爱神丘比特发现，爱情也已不再是完全纯洁的了。这使得丘比特很是苦恼，他越来越难找到合适的男女，并向他们射去丘比特之箭。于是丘比特千里迢迢远赴中国，找到了掌管东方人爱情的神——月下老人，向他求教。月下老人告诉丘比特，纯洁的爱情并不是不存在，而是他没有找到。在东方，人们讲究的是缘分。月下老人只要做一男一女两个泥人，在他们之间...
bzoj2908数据下载
最新发布
10-14
BZOJ 2908 题目是一个数据下载任务。这个任务要求下载指定的数据文件，并统计文件中小于等于给定整数的数字个数。 为了完成这个任务，首先需要选择一个合适的网址来下载文件。我们可以使用一个网络爬虫库，如Python...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值