蓝桥杯 历届试题 分考场 DFS java实现

问题描述

问题描述
n个人参加某项特殊考试。
为了公平，要求任何两个认识的人不能分在同一个考场。
求至少需要分几个考场才能满足条件。

输入格式
第一行，一个整数n(1 第二行，一个整数m，表示接下来有m行数据
以下m行每行的格式为：两个整数a，b，用空格分开 (1<=a,b<=n) 表示第a个人与第b个人认识。

输出格式
一行一个整数，表示最少分几个考场。

样例输入
5
8
1 2
1 3
1 4
2 3
2 4
2 5
3 4
4 5

样例输出
4

样例输入
5 10
1 2
1 3
1 4
1 5
2 3
2 4
2 5
3 4
3 5
4 5

样例输出
5

思路详解：

用一个二维数组保存两个人是否认识，对于每个人，都有两种选择：1）加入之前已经存在的考场 i，
前提是这个人与考场 i 内的所有人都不认识；2）新开一个人考试，这个人单独在新开的考场中。我们用dfs+回溯来确定最少考场数ans。如果某种方法的考场数已经大于按ans，那么可以提前剪枝。

代码详解

package oj.T3;

import java.util.*;

public class 分考场 {
     
    public static void main(String[] args) {
     
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.nextLine();
        int m = sc.nextInt();
        sc.nextLine();
        int[][] arr = new int[m][2];
        for(int i=0;i<m;i++){
     
            arr[i][0] = sc.nextInt();
            arr[i][1] = sc.nextInt();
            sc.nextLine();
        }
        Solution3 sl = new Solution3();
        System.out.println(sl.f(n,arr));
    }
}

class Solution3{
     
    //最终需要ans个考场
    int ans;
    List<List<Integer>> rooms = new ArrayList<>();
    //know[i][j]:表示i认识j 或者 j认识i
    boolean[][] know;
    //总共有n个人
    int n;

    public int f(int n,int[][] arr){
     
        know = new boolean[n+1][n+1];
        //判断两个人是否认识
        for(int i=0;i<arr.length;i++){
     
            int people1 = arr[i][0];
            int people2 = arr[i][1];
            know[people1][people2] = true;
            know[people2][people1] = true;
        }
        ans = Integer.MAX_VALUE;
        this.n = n;
        dfs(1);
        return ans;
    }

    //index表示第几个人
    public void dfs(int index){
     
        //把所有人都安排好考场后 判断当前安排方法是否是最小
        if(index == n+1){
     
            ans = Math.min(ans,rooms.size());
            return;
        }
        //提前剪枝 
        if(rooms.size() >= ans)
            return;
        //i表示第几个考场
        for(int i=0;i<rooms.size();i++){
     
            //判断index人是否与当前考场中的所有人认识
            //如果index不认识当前考场所有人 则可以加入该考场
            if(check(index,i)){
     
                rooms.get(i).add(index);
                //处理下一个人
                dfs(index+1);
                //回溯
                rooms.get(i).remove(rooms.get(i).size()-1);
            }
        }
        //创建新的考场
        List<Integer> tempRoom = new ArrayList<>();
        tempRoom.add(index);
        rooms.add(tempRoom);
        dfs(index+1);
        rooms.remove(rooms.size()-1);
    }

    //判断第index个人是否可以加入第i个考场
    public boolean check(int index,int i){
     
        List<Integer> CurRoom = rooms.get(i);
        for(int j=0;j<CurRoom.size();j++){
     
            if(know[index][CurRoom.get(j)])
                return false;
        }
        return true;
    }


}

代码参考