算法：最大兼容性评分 【回溯 vs KM】

该题来自第251场力扣周赛第三题，难度为中，考察回溯法或KM算法

题目:最大兼容性评分

有一份由 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

解题思路

毫无疑问这是一道求最优解的题目，学生和导师是一一对应的，如果使用贪心策略很有可能不是最优解。首先可以对数据先做一步处理，将两个m*n的二维数组转化成m*m矩阵scores，元素的值scores[i][j]代表第i个学生与第j个导师匹配时相同的题数，而后将问题视为以下描述：

对于一个M*M的整数矩阵，求任意M个元素的和的最大值，要求每个元素所在的行与列不重复。

对于这个问题，可以很直观的看出与熟知的八皇后算法条件较为类似，因此第一反应都会是选择回溯法来解决。但回溯法的缺点也很明显，如果问题的M值过大，将会导致时间复杂度非常高。而对于此类问题，其实实际上可以看做二分图的最大匹配问题，因此还有更巧妙的解法：KM算法（匈牙利算法的进阶版，实现带权二分图的最优匹配）

回溯法

回溯法大家应该基本上都清楚，上过课都知道其模板，直接套就完事了~

class Solution {

    private int ans = 0;

    public int maxCompatibilitySum(int[][] students, int[][] mentors) {
        int m = students.length;
        int n = students[0].length;
        int[][] scores = new int[m][m];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < m; j++) {
                for (int k = 0; k < n; k++) {
                    scores[i][j] += students[i][k] == mentors[j][k] ? 1 : 0;
                }
            }
        }
        boolean[] visited = new boolean[m];
        dfs(m, scores, 0, 0, visited);
        return ans;
    }

    private void dfs(int m, int[][] scores, int i, int sum, boolean[] visited) {
        if (i >= m) {
            ans = Math.max(ans, sum);
        } else {
            for (int j = 0; j < m; j++) {
                if (visited[j]) continue;
                visited[j] = true;
                dfs(m, scores, i + 1, sum + scores[i][j], visited);
                visited[j] = false;
            }
        }
    }
}

执行结果：

KM算法

回溯法（全排列模板）的时间复杂度是O(m!)，如果不是因为这道题的条件是m <= 8，基本上不太可能提交通过……相比之下KM算法的效率会比较高，它通过设置期望（也叫标杆），在递归中逐步优化出最优解，当当前期望无法满足优化时适当降低期望，一来一去节省了很多像回溯法中不必要的操作。具体KM算法与匈牙利算法的解析请自行百度哈哈

class Solution {

    public int maxCompatibilitySum(int[][] students, int[][] mentors) {
        int m = students.length;
        int n = students[0].length;
        int[][] scores = new int[m][m];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < m; j++) {
                for (int k = 0; k < n; k++) {
                    scores[i][j] += students[i][k] == mentors[j][k] ? 1 : 0;
                }
            }
        }
        return KM(m, scores);
    }

    /** KM算法 */
    private int KM(int m, int[][] scores) {
        int[] match = new int[m];  //映射：mentor->匹配的student
        int[] sExcept = new int[m];  //student的期望值
        int[] mExcept = new int[m];  //mentor的期望值
        for (int i = 0; i < m; i++) {
            match[i] = -1; //初始化为-1
            for (int j = 0; j < m; j++) {
                sExcept[i] = Math.max(sExcept[i], scores[i][j]); //最大化student各自的期望
            }
        }
        for (int i = 0; i < m; i++) {
            while (true) {
                boolean[] sVisited = new boolean[m]; //过滤被匹配的student
                boolean[] mVisited = new boolean[m]; //过滤被匹配的mentor
                if (dfs(i, m, scores, match, sExcept, mExcept, sVisited, mVisited)) break;
                for (int j = 0; j < m; j++) {
                    if (sVisited[j]) sExcept[j]--;
                    if (mVisited[j]) mExcept[j]++;
                }
            }
        }
        int ans = 0;
        for (int i = 0; i < m; i++) {
            ans += scores[match[i]][i];
        }
        return ans;
    }

    /** 匈牙利算法 */
    private boolean dfs(int i, int m, int[][] scores, int[] match, int[] sExcept, int[] mExcept, boolean[] sVisited, boolean[] mVisited) {
        sVisited[i] = true;
        for (int j = 0; j < m; j++) {
            if (mVisited[j]) continue;
            int temp = scores[i][j] - sExcept[i] - mExcept[j];
            if (temp >= 0) {
                mVisited[j] = true;
                if (match[j] == -1 || dfs(match[j], m, scores, match, sExcept, mExcept, sVisited, mVisited)) {
                    match[j] = i;
                    return true;
                }
            }
        }
        return false;
    }
}

执行结果：

总结

结果对比很明显，当问题规模较大时，KM算法的效率会明显优于普通的回溯算法，如果规模限制更高一些，这就是一道的middle偏上的题了。