匈牙利算法

匈牙利算法

这是一道牛客网上的算法题，核心为匈牙利算法

匈牙利算法思想:先到先得,能让则让，代码如下

import java.util.Scanner;
import java.util.ArrayList;

public class Main{
    
    static int max=0;
    public static void main(String[] args){
        //标准输入
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            //输入正偶数
            int n=sc.nextInt();
            //用于记录输入的n个整数
            int[] arr=new int[n];
            //用于存储所有的奇数
            ArrayList<Integer> odds=new ArrayList<>();
            //用于存储所有的偶数
            ArrayList<Integer> evens=new ArrayList<>();
            for(int i=0;i<n;i++){
                arr[i]=sc.nextInt();
                //将奇数添加到odds
                if(arr[i]%2==1){
                    odds.add(arr[i]);
                }
                //将偶数添加到evens
                if(arr[i]%2==0){
                    evens.add(arr[i]);
                }
            }
            //下标对应已经匹配的偶数的下标，值对应这个偶数的伴侣
            int[] matcheven=new int[evens.size()];
            //记录伴侣的对数
            int count=0;
            for(int j=0;j<odds.size();j++){
                //用于标记对应的偶数是否查找过
                boolean[] v=new boolean[evens.size()];
                //如果匹配上，则计数加1
                if(find(odds.get(j),matcheven,evens,v)){
                    count++;
                }
            }
            System.out.println(count);
        }   
    }
    
    //判断奇数x能否找到伴侣
    private static boolean find(int x,int[] matcheven,ArrayList<Integer> evens,boolean[] v){
        for(int i=0;i<evens.size();i++){
            //该位置偶数没被访问过，并且能与x组成素数伴侣
            if(isPrime(x+evens.get(i))&&v[i]==false){
                v[i]=true;
                /*如果i位置偶数还没有伴侣，则与x组成伴侣，如果已经有伴侣，并且这个伴侣能重新找到新伴侣，
                则把原来伴侣让给别人，自己与x组成伴侣*/
                if(matcheven[i]==0||find(matcheven[i],matcheven,evens,v)){
                    matcheven[i]=x;
                    return true;
                }
            }
        }
        return false;
    }
    //判断x是否是素数
    private static boolean isPrime(int x){
        if(x==1) return false;
        //如果能被2到根号x整除，则一定不是素数
        for(int i=2;i<=(int)Math.sqrt(x);i++){
            if(x%i==0){
                return false;
            }
        }
        return true;
    }
}

下面是对算法中的参数、方法说明

odds 奇数集合
evens 偶数集合

int[] matcheven=new int[evens.size()]; 下标对应已经匹配的偶数的下标，值对应这个偶数的伴侣
下标为几就是第几个偶数 有值就对应着第几个奇数 没有对应的数默认为0 这个数组从始至终就只有一次创建

boolean[] v=new boolean[evens.size()]; 用于标记对应的偶数是否查找过  默认值为false

对奇数组遍历
每一个数创建新的标记数组 相当于每一次遍历偶数数组都是没有查过
find(odds.get(j),matcheven,evens,v)传入当前奇数 偶数对应的奇数 偶数集合 偶数是否遍历过

find函数是整个算法的核心 里面采用递归调用 当能匹配的偶数已经匹配其他的奇数了 就递归调用奇数能否在匹配其他的偶数
是一个奇数对偶数组的遍历 每次调用结束会确定matcheven数组里面一个偶数对应的一个值
 private static boolean find(int x,int[] matcheven,ArrayList<Integer> evens,boolean[] v){
        for(int i=0;i<evens.size();i++){
            //该位置偶数没被访问过，并且能与x组成素数伴侣
            if(isPrime(x+evens.get(i))&&v[i]==false){
                v[i]=true;
                /*如果i位置偶数还没有伴侣，则与x组成伴侣，如果已经有伴侣，并且这个伴侣能重新找到新伴侣，
                则把原来伴侣让给别人，自己与x组成伴侣*/
                if(matcheven[i]==0||find(matcheven[i],matcheven,evens,v)){
                    matcheven[i]=x;
                    return true;
                }
            }
        }
        return false;
    }

下面是分析过程

假设有如上的对应规则
第一次执行的顺序应该是
拿到A1 matcheven里面全0 v里面全false
传入find方法
遍历B集合
拿到B1 进行判断if(isPrime(x+evens.get(i))&&v[i]==false) 不满足匹配规则
再拿到B2 符合判断 if(matcheven[i]==0||find(matcheven[i],matcheven,evens,v)
matcheven里面也全为0 也符合第二个判断 所以将matcheneven[1]=A1

第二轮遍历
传入A2 matcheven里面全0 v里面全false
拿到B1判断不符合
拿到B2判断符合
但是在判断第二个条件时 matcheven数组不为0 
则继续递归调用find 传入A1 matcheven evens v 这时候的v[1]已结为true了
所以A1在遍历到B2时条件已结不符合了 最终遍历到B4才能满足 修改matcheven[3]为A1
递归返回 可以找到另一个匹配返回true A2的第二个判断也成立 修改matcheven[1]为A2