• HDU-2389 Rain on your Parade (最大匹配,HK函数)


    题意:由于在过m分钟就要下雨,在花园玩的人(都没有带伞),需要在花园找到一把伞来防止淋湿。
    同时每个人只能最多拥有一把伞,且该伞不能和其他人共用。已知伞和人的坐标位置,以及人的行走速度
    问能否使每个人都匹配到一把伞
    输入:有T个测试样例,每个测试样例包含要下雨的时间t,n个人以及其坐标速度信息,m把伞以及其坐标
    思路:读完题之后大概就知道是一道最大匹配问题。以人为左集合点,伞为右集合点。匹配即是该人能否在下雨之前
    到达伞的位置(距离就是欧几里得距离)。这道题如果仅仅使用匈牙利算法是会TLE的,我们要使用其优化后的Hopcroft-Karp算法(O(sqrt(N)*M))

    #include <cstdio>
    #include <iostream>
    #include <cstring>
    #include <queue> 
    #include <cmath>
    #include <algorithm>
    using namespace std;
    const int INF = 0x3f3f3f3f;
    const int maxn = 3500;//点数
    int bmap[maxn][maxn];//二分图
    struct Pos
    {
        int x,y,speed;
    }pos[maxn<<1];
    int cx[maxn];//左集合i匹配的右集合顶点序号
    int cy[maxn];//右集合i匹配的左集合顶点序号                                                                                                                
    int n,m;
    int dis;
    int t;//时间
    int nx,ny;//为匹配个数
    int dx[maxn],dy[maxn];
    bool bmask[maxn];
    //寻找增广路径,HK算法就是从一个点出发想要一次性寻找到多条增广路径
    //所以使用bfs
     bool searchpath()                                                                                                          
     {                                                                                                                          
        queue<int>Q;                                                                                                            
        dis=INF;                                                                                                                
        memset(dx,-1,sizeof(dx));                                                                                               
        memset(dy,-1,sizeof(dy));                                                                                               
        for(int i=1;i<=nx;i++)                                                                                                  
        {                                                                                                                       
           //cx[i]表示左集合i顶点所匹配的右集合的顶点序号                                                                       
           if(cx[i]==-1)                                                                                                        
           {                                                                                                                    
              //将未遍历的节点 入队 并初始化次节点距离为0                                                                       
              Q.push(i);                                                                                                        
              dx[i]=0;                                                                                                          
           }                                                                                                                    
        }                                                                                                                       
        //广度搜索增广路径                                                                                                      
        while(!Q.empty())                                                                                                       
        {                                                                                                                       
           int u=Q.front();                                                                                                     
           Q.pop();                                                                                                             
           if(dx[u]>dis) break;                                                                                                 
           //取右侧节点                                                                                                         
           for(int v=1;v<=ny;v++)                                                                                               
           {                                                                                                                    
              //右侧节点的增广路径的距离                                                                                        
              if(bmap[u][v]&&dy[v]==-1)                                                                                         
              {                                                                                                                 
                 dy[v]=dx[u]+1; //v对应的距离 为u对应距离加1                                                                    
                 if(cy[v]==-1) dis=dy[v];                                                                                       
                 else                                                                                                           
                 {                                                                                                              
                    dx[cy[v]]=dy[v]+1;                                                                                          
                    Q.push(cy[v]);                                                                                              
                 }                                                                                                              
              }                                                                                                                 
           }                                                                                                                    
        }                                                                                                                       
        return dis!=INF;                                                                                                        
     }                                                                                                                          
                                                                                                                                
     //寻找路径 深度搜索                                                                                                        
     int findpath(int u)                                                                                                        
     {                                                                                                                          
        for(int v=1;v<=ny;v++)                                                                                                  
        {                                                                                                                       
           //如果该点没有被遍历过 并且距离为上一节点+1                                                                          
           if(!bmask[v]&&bmap[u][v]&&dy[v]==dx[u]+1)                                                                            
           {                                                                                                                    
              //对该点染色                                                                                                      
              bmask[v]=1;                                                                                                       
              if(cy[v]!=-1&&dy[v]==dis)                                                                                         
              {                                                                                                                 
                 continue;                                                                                                      
              }                                                                                                                 
              if(cy[v]==-1||findpath(cy[v]))                                                                                    
              {                                                                                                                 
                 cy[v]=u;cx[u]=v;                                                                                               
                 return 1;                                                                                                      
              }                                                                                                                 
           }                                                                                                                    
        }                                                                                                                       
        return 0;                                                                                                               
     }                                                                                                                          
                                                                                                                                
     //得到最大匹配的数目                                                                                                       
     int MaxMatch()                                                                                                             
     {                                                                                                                          
        int res=0;                                                                                                              
        memset(cx,-1,sizeof(cx));                                                                                               
        memset(cy,-1,sizeof(cy));                                                                                               
        while(searchpath())                                                                                                     
        {                                                                                                                       
           memset(bmask,0,sizeof(bmask));                                                                                       
           for(int i=1;i<=nx;i++)                                                                                               
           {                                                                                                                    
              if(cx[i]==-1)                                                                                                     
              {                                                                                                                 
                 res+=findpath(i);                                                                                              
              }                                                                                                                 
           }                                                                                                                    
        }                                                                                                                       
        return res;                                                                                                             
     }   
    //伞是可以剩余的,所以建立有向图就行
    bool connect(int i,int j){
        double dis;
        dis = (pos[i].x-pos[j+n].x)*(pos[i].x-pos[j+n].x)+(pos[i].y-pos[j+n].y)*(pos[i].y-pos[j+n].y);
        if(double(t*pos[i].speed)<sqrt(dis)) return false;
        else return true;
    }
    int main(){
        int T,cas;
        cin>>T;
        cas = 0;
        while(T--){
            memset(bmap,0,sizeof(bmap));
            
            cin>>t>>n;
            nx = n;
            for(int i =1;i<=n;i++){
                cin>>pos[i].x>>pos[i].y>>pos[i].speed;
            }
            cin>>m;
            ny = m ;
            for(int i=1;i<=m;i++){
                cin>>pos[i+n].x>>pos[i+n].y;
            }
            for(int i = 1;i<=n;i++){
                for(int j = 1;j<=m;j++){
                    if(connect(i,j)) bmap[i][j] = 1;
                }
            }
            int num = MaxMatch();
            printf("Scenario #%d:
    ", ++cas);
            cout<<num<<endl<<endl;
        }
    }
  • 相关阅读:
    利用connect建立前端开发服务器
    Bootstrap Popover 隐藏的Javasript方法
    Kafka 2.1.0压缩算法性能测试
    关于Kafka java consumer管理TCP连接的讨论
    Java API获取consumer group最新提交位移的时间
    关于Kafka producer管理TCP连接的讨论
    【译】Apache Kafka支持单集群20万分区
    关于Kafka broker IO的讨论
    Kafka 2.0 ConsumerGroupCommand新功能
    关于Kafka high watermark的讨论2
  • 原文地址:https://www.cnblogs.com/Tianwell/p/11338677.html
Copyright © 2020-2023  润新知