1947. 最大兼容性评分和

1947. 最大兼容性评分和https://leetcode.cn/problems/maximum-compatibility-score-sum/

难度中等24

有一份由 n 个问题组成的调查问卷，每个问题的答案要么是 0（no，否），要么是 1（yes，是）。

这份调查问卷被分发给 m 名学生和 m 名导师，学生和导师的编号都是从 0 到 m - 1 。学生的答案用一个二维整数数组 students 表示，其中 students[i] 是一个整数数组，包含第 i 名学生对调查问卷给出的答案（下标从 0 开始）。导师的答案用一个二维整数数组 mentors 表示，其中 mentors[j] 是一个整数数组，包含第 j 名导师对调查问卷给出的答案（下标从 0 开始）。

每个学生都会被分配给 一名 导师，而每位导师也会分配到 一名 学生。配对的学生与导师之间的兼容性评分等于学生和导师答案相同的次数。

• 例如，学生答案为[1, 0, 1] 而导师答案为 [0, 0, 1] ，那么他们的兼容性评分为 2 ，因为只有第二个和第三个答案相同。

请你找出最优的学生与导师的配对方案，以 最大程度上 提高 兼容性评分和 。

给你 students 和 mentors ，返回可以得到的 最大兼容性评分和 。

示例 1：

输入：students = [[1,1,0],[1,0,1],[0,0,1]], mentors = [[1,0,0],[0,0,1],[1,1,0]]
输出：8
解释：按下述方式分配学生和导师：
- 学生 0 分配给导师 2 ，兼容性评分为 3 。
- 学生 1 分配给导师 0 ，兼容性评分为 2 。
- 学生 2 分配给导师 1 ，兼容性评分为 3 。
最大兼容性评分和为 3 + 2 + 3 = 8 。

示例 2：

输入：students = [[0,0],[0,0],[0,0]], mentors = [[1,1],[1,1],[1,1]]
输出：0
解释：任意学生与导师配对的兼容性评分都是 0 。

提示：

• m == students.length == mentors.length
• n == students[i].length == mentors[j].length
• 1 <= m, n <= 8
• students[i][k] 为 0 或 1
• mentors[j][k] 为 0 或 1

通过次数5,304提交次数9,391

class Solution {
    int ans = 0;
    public int maxCompatibilitySum(int[][] students, int[][] mentors) {

        
        int len = students.length;
        int[][] matix = new int[len][len];
        for(int i=0;i<students.length;i++)
        {
            for(int j=0;j<mentors.length;j++)
            {
                int sorce = 0;
                for(int k=0;k<students[0].length;k++)
                {
                    if(students[i][k]==mentors[j][k]) sorce++;
                }
                matix[i][j] = sorce;
            }
        }
        int queue = students.length;; //学生的个数
        int num = 0;  //分数摆放方法的个数
        int [] cols = new int[queue];  //每一列的分数在该列中的行号

        bahuanghou(queue,num,cols,matix);
        return ans;
    }

    // 八皇后问题
    void bahuanghou(int queue,int n,int[] cols,int[][]matix)
    {
        //所有都行都选出了，得一种方法
        if(n==queue)
        {
            int sum =0;
            for(int i=0;i<cols.length;i++)
            {
                sum += matix[i][cols[i]];
            }
            ans = ans>sum?ans:sum;
            return;
        }
        for(int i=0;i<queue;i++)
        {
            cols[n]=i;
            if (judge(n,cols)==true) bahuanghou(queue,n+1,cols,matix);
        }
    }
    boolean judge(int n,int[]cols){
        //同列或者斜线都会有冲突
        //1、同列
        //2、斜线对应
        for (int i = 0; i < n; i++) {
            if (cols[i]==cols[n]){
                return false;
            }
        }
        return true;
    }
}