网易校招笔试第三题匈牙利算法

问题
A公司和B公司有n个合作的子项目，每个子项目由A公司和B公司各一名员工参与。一名员工可以参与多个子项目。

一个员工如果担任了该项目的项目经理，它需要对所参与的该项目负责。一个员工也可以负责多个项目。

A公司和B公司需要保证所有子项目都能有人负责，问最少需要指定几名项目经理？

输入描述
第一行为A公司的的人员id列表， 0< id数量 < 10000，用空格切分
第二行为B公司的人员id列表， 0< id数量 < 10000，用空格切分
第三行为有已经有多少个匹配数子项目合作关系n
下面有n行，每一行为每个子项目的合作对应关系，为两个id，第一个为A公司的员工id，第二个为B公司的员工id，用空格区分

输出描述
一个整数，A公司和B公司合起来至少需要指定几名项目经理

示例
输入
0 1 2
3 4 5
6
0 4
0 3
1 3
1 4
2 5
2 4
输出
3

思想
这是一种二分图的匹配问题如何用最少的节点覆盖全部路径，可利用匈牙利算法。需要利用一个数组match[]记录匹配情况也需要boolean类型判断是否存在增广路径。

我们需要构建二维矩阵保存节点间的增广路径，先判断节点是否存在增广路径，然后判断他是否覆盖到i点或者它的原节点是否能找到增广路径，如果有则把它覆盖到match对应的位置上。

代码

package class11;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Scanner;

public class xiongyalisuanfa {

	public static void main(String[] args){
        Scanner reader = new Scanner(System.in);
        String staffA = reader.nextLine();
        String staffB = reader.nextLine();
        int n = reader.nextInt();
        String[] sa = staffA.split(" ");
        String[] sb = staffB.split(" ");
        int[] a = new int[sa.length];
        int[] b = new int[sb.length];
        int length = sa.length+sb.length;
        int[] match = new int[length];
        int[][] map = new int[length][length];
        HashMap<Integer,Integer> num =new HashMap<>();
        boolean[] visited = new boolean[length];
        int count = 0;
        for(int i =0;i<length;i++){
            //Arrays.fill()将数组中的值用value填满
            Arrays.fill(match,-1);
            Arrays.fill(visited,false);
            Arrays.fill(map[i],-1);
        }
        for(int i = 0;i<a.length;i++){
            a[i] = Integer.valueOf(sa[i]);
            num.put(a[i],i);
        }
        for(int i= 0;i<b.length;i++){
            b[i] = Integer.valueOf(sb[i]);
            num.put(b[i],i+a.length);
        }
        for(int i=0;i<n;i++){
            int xi = reader.nextInt();
            int yi = reader.nextInt();
            map[num.get(xi)][num.get(yi)] = 1;
            map[num.get(yi)][num.get(xi)] = 1;
        }
        process(num,match,a,b,length,visited,map);
        for(int i = 0;i<length;i++){
            if(match[i]!=-1) count++;
        }
        System.out.println(count/2);
    }
    public static void setvisited(boolean[] visited){
        for(int i = 0;i<visited.length;i++){
            visited[i] = false;
        }
    }
    public static boolean findpath(HashMap<Integer,Integer> num,int x,int[]match,int length,boolean[] visited,int[][]map){
        for(int i = 0;i<length;i++){
        	//顶点x在增广路径上
            if(!visited[i]&&map[x][i] == 1){
                visited[i] = true;
                //match[i]是未覆盖点或者match[i]的原匹配点X能找到增广路径
                if(match[i] ==-1||findpath(num,match[i],match,length,visited,map)){
                    match[x] = i;
                    match[i] = x;
                    return true;
                }
            }
        }
        return false;
    }
    public static void process(HashMap<Integer,Integer>num,int[]match,int[] a,int[]b,int length,boolean[] visited,int[][] map1){
        for(int i = 0;i<a.length;i++){
            if(match[num.get(a[i])] ==-1){
                setvisited(visited);
                findpath(num,num.get(a[i]),match,length,visited,map1);
            }
        }
        for(int i = 0;i<b.length;i++){
            if(match[num.get(b[i])] == -1){
                setvisited(visited);
                findpath(num,num.get(b[i]),match,length,visited,map1);
            }
        }
    }

}