uva 11045 My T-shirt suits me

题意：就6种型号的衣服，然后给你n件衣服，n一定是6的倍数，也就是每种类型的衣服的件数是一样的，然后给m个人，每个人能穿两种型号的衣服，给你每个人穿衣的信息，然后判断是否每个人都能找到衣服穿

 

很显然是二分图最大匹配，但是这里有个小问题，就是一种衣服有多件，可能被多个人穿，和二分图匹配有点不同，在最大匹配中每个点是只会出现一次的，这个问题要解决不难就是把相同的衣服拆成多件不同的衣服处理，但是建图的时候就要注意多处理一下,建图完毕后就是纯粹的匈牙利算法

 

//问题一看就是二分图匹配，不过一个种衣服会有多件要怎么处理呢，就把多件相同类型的衣服当做不同衣服来处理
//衣服按照1到6编号，如果第i种衣服有重复的，那么重复的衣服就是i+6，如果再有重复的，就是i+6+6  
//另外，一个员工能穿第i中衣服，不能单单建一条边到i，要建多条边同时指向i，i+6，i+6+6，……
//然后就是裸露的无向图匈牙利算法匹配
#include <cstdio>
#include <cstring>
#define N 70
int g[N][N];  //无向图邻接表
int mat[N],vis[N];
int n,m,nn;
char shirt[7][4]={"","XXL","XL","L","M","S","XS"};

void input()
{
    memset(g,0,sizeof(g));
    scanf("%d%d",&n,&m);
    nn=n/6;

    for(int i=1; i<=m; i++)
    {
        char s1[5],s2[5];
        int t1,t2;
        scanf("%s%s",s1,s2);
        for(int j=1; j<=6; j++)
            if(!strcmp(s1,shirt[j]))
            { t1=j; break;}
        for(int j=1; j<=6; j++)
            if(!strcmp(s2,shirt[j]))
            { t2=j; break;}
        //printf("%d %d\n",t1,t2);
        int u,v1,v2;
        u=n+i;   //当前员工的标号，我们约定前面n号全部留给衣服
        v1=t1;   //第一种型号的衣服
        v2=t2;   //第二种型号的衣服
        for(int c=0; c<nn;c++)  
        {
            int t;
            t=++g[u][0];   
            g[u][t]=v1+6*c;     //建立边<u,v1+6*c>
            t=++g[v1+6*c][0];
            g[v1+6*c][t]=u;     //建立边<v1+6*c,u>
            //第一件衣服的无向边建立完成
            t=++g[u][0];
            g[u][t]=v2+6*c;     //建立边<u,v2+6*c>
            t=++g[v2+6*c][0];
            g[v2+6*c][t]=u;     //建立边<v2+6*c,u>
            //第一件衣服的无向边建立完成
        }
    }
/*
    for(int i=1; i<=n+m; i++)
    {
        printf("%d:",i);
        for(int j=1; j<=g[i][0]; j++)
            printf(" %d",g[i][j]);
        printf("\n");
    }
*/
    return ;

}

int find(int u)
{
    for(int i=1; i<=g[u][0]; i++)
    {
        int v=g[u][i];
        if(!vis[v])
        {
            vis[v]=1;
            if(!mat[v] || find(mat[v]))
            {
                mat[v]=u;
                return 1;
            }
        }
    }

    return 0;
}
void max_match()
{
    int ans=0;
    memset(mat,0,sizeof(mat));
    for(int i=1; i<=n+m; i++)
    {
        memset(vis,0,sizeof(vis));
        ans+=find(i);
    }

    for(int i=1; i<=n+m; i++)
        printf("%d ",mat[i]);
    printf("\n");
    printf("ans=%d\n",ans);

    int flag=1;
    for(int i=n+1; i<=n+m; i++)
        if(!mat[i])
        { flag=0; break;}
    if(flag)
        printf("YES\n");
    else
        printf("NO\n");
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        input();
        max_match();
    }
    return 0;
}

 

 

当然如果理解了匈牙利算法的增广路本质后，是可以转化为最大流来做的，其实就是算法导论里面说的，加一个源点，，源点发射n条边指向L集合的每一个顶点，然后加一个汇点，R集合的m个元素发射m条边全部指向汇点，原本L和R之间的边保持不变，就转化成最大流来解决了