并行课程IIJava

文章发布较早，内容可能过时，阅读注意甄别。

# 题目

给你一个整数 n 表示某所大学里课程的数目，编号为 1 到 n ，数组 relations 中， relations[i] = [xi, yi] 表示一个先修课的关系，也就是课程 xi 必须在课程 yi 之前上。同时你还有一个整数 k 。

在一个学期中，你最多可以同时上 k 门课，前提是这些课的先修课在之前的学期里已经上过了。

请你返回上完所有课最少需要多少个学期。题目保证一定存在一种上完所有课的方式。

示例 1：

输入：n = 4, relations = [[2,1],[3,1],[1,4]], k = 2
输出：3
解释：上图展示了题目输入的图。在第一个学期中，我们可以上课程 2 和课程 3 。然后第二个学期上课程 1 ，第三个学期上课程 4 。

示例 2：

输入：n = 5, relations = [[2,1],[3,1],[4,1],[1,5]], k = 2
输出：4
解释：上图展示了题目输入的图。一个最优方案是：第一学期上课程 2 和 3，第二学期上课程 4 ，第三学期上课程 1 ，第四学期上课程 5 。

示例 3：

输入：n = 11, relations = [], k = 2
输出：6

提示：

1 <= n <= 15
1 <= k <= n
0 <= relations.length <= n * (n-1) / 2
relations[i].length == 2
1 <= xi, yi <= n
xi != yi
所有先修关系都是不同的，也就是说 relations[i] != relations[j] 。
题目输入的图是个有向无环图。

# 思路

# 解法

class Solution {
    public int minNumberOfSemesters(int n, int[][] dependencies, int k) {
        int[] pre = new int[n]; // pre[i]表示要修第i门课程需要事先修习的课，用n位的二进制数来表示
        for (int[] dependency : dependencies) {
            dependency[0]--;
            dependency[1]--;
            pre[dependency[1]] |= (1 << dependency[0]);
        }
        int all = 1 << n;
        int[] dp = new int[all];
        for (int i = 0; i < all; i++) dp[i] = n;
        dp[0] = 0;
        for (int state = 0; state < all; state++) {
            int next = 0; // 当前修课状态下接下来能修的课
            for (int i = 0; i < n; i++) if ((state & pre[i]) == pre[i]) next |= 1 << i;
            next &= ~state; // 去重
            for (int sub = next; sub > 0; sub = (sub - 1) & next) { // 枚举所有的子集
                if (Integer.bitCount(sub) <= k) {
                    dp[state | sub] = Math.min(dp[state | sub], dp[state] + 1);
                }
            }
        }
        return dp[(1 << n) - 1];
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 总结

分析出几种情况，然后分别对各个情况实现

#Java