动态规划的记忆化搜索和递推两种实现方法的差异分析

1494. 并行课程 II

难度困难107

给你一个整数 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] 。

• 题目输入的图是个有向无环图。

方法一、记忆化搜索

//方法一、记忆化搜索 因为对记忆的memo,有寻址操作的O(1)的时间消耗和递推是一样的
//但是会有栈的一层调用，所以比递推慢一点
class Solution {
public: 
    vector<int> memo;
    int K,N;
    vector<vector<int>> Adj;//preState[i]表示第i个节点之前的状态
    vector<int> cnt,preState;//cnt[num]表示num中1的个数
    vector<bool> visit;
    int dfs(int state,int allState){
        if(allState==(1<<N)-1){
            return 0;
        }
        if(state==0){
            return 16;
        }
        if(memo[allState]!=-1)return memo[allState];
        int ans=16; 
        for(int curSelect=state;curSelect;curSelect=(curSelect-1)&state){ //对于可选择状态的所有子集
            if(cnt[curSelect]<=K){ //State的集合中元素的个数小于等于K 尝试选择

                int addState=0;int nextallState=curSelect|allState;
                for(int i=0;i<N;i++){
                    if(
                        (((nextallState)&(1<<i))==0)&&
                        ((preState[i]&(nextallState))==preState[i])
                    ){
                       addState|=(1<<i);
                    }
                }
                ans=min(ans,dfs((state^curSelect)|addState,nextallState)+1);               
            }
        }
        memo[allState]=ans;
        return ans;
    }
    int minNumberOfSemesters(int n, vector<vector<int>>& relations, int k) {
        K=k;N=n;

        cnt=vector<int> (1<<n,0);
        preState=vector<int>(n,0);
        memo=vector<int>(1<<n,-1);
        for(int i=1;i<(1<<n);i++){
            cnt[i]=cnt[i>>1]+ (i&1);
        }
        //求出每一个节点的入度
        for(int i=0;i<relations.size();i++){
           int pre=relations[i][0]-1;
           int last=relations[i][1]-1;
           preState[last]|=1<<pre; //pre[i]表示选第i课,之前必须选择的状态
        }
        //下面求入度是0的所有的节点的状态或
        int state=0;
        for(int i=0;i<n;i++){
            if(preState[i]==0)
            state|=(1<<i);
        }
//dfs(state,0)，中state表示当前所有可以选择的课程的状态
//dfs(state,0)：0表示从修0状态的课程到所有可有课程都修完(1<<N)所花费的最少学期
        return dfs(state,0); 
    }
};

方法二、递推

class Solution {
public:
    int minNumberOfSemesters(int n, vector<vector<int>>& relations, int k) {
        vector<int> dp((1<<n),16);
        dp[0]=0;
        vector<int> cnt(1<<n);
        //计算每一种状态 有多少bit位上是1
        cnt[0]=0;
        for(int i=1;i<(1<<n);i++){
            cnt[i]=cnt[i>>1]+(i&1);
        }
        vector<int> preSate(n,0);
        int relation_size=relations.size();
        for(int i=0;i<relation_size;i++){
            int pre=relations[i][0]-1;
            int last=relations[i][1]-1;
            preSate[last]|=(1<<pre);
        }
        int state=(1<<n)-1;
        for(int curState=0;curState<=state;curState++){
            if(dp[curState]>n) continue;
            //第一步 对于当前已经选择的课程状态curState 查找修完curState课程后,还有哪些课程可以选择
            int nextSelects=0;
            for(int i=0;i<n;i++){
                if(
                    ((curState&(1<<i))==0)&& //之前没有修过
                    ((preSate[i]&curState)==preSate[i])  //当前课程的所有先修课程都修完 可以选择
                ){
                    nextSelects|=(1<<i);
                }
            }
            //第二步 在可选择的课程nextSelect上进行选择子集和
            for(int curSelect=nextSelects;curSelect;curSelect=((curSelect-1)&nextSelects)){
                    if(cnt[curSelect]<=k)
                    dp[curState|curSelect]=min(dp[curState|curSelect],1+dp[curState]);
            }
        }
        return dp[state];
    }
};

关于文中的状态压缩，状态的子集合求解：

//批量统计i的二进制数中1的个数
for (int i = 0; i < totalState; ++i) {
    cnt[i] = cnt[i >> 1] + (i & 1);
}
/*
cnt[i>>1]表示除了i的最低位不看,其余的bit位上的1的数量
            所以再此基础上架上最低位是否是1的情况即可
*/

//统计单个数num的二进制数中1的个数，32可以为其他数，取决于num的二进制数长度
bitset<32>(num).count()

//遍历state的子集，比如state是011，那么子集是{001, 010, 011}
for (int subMask = state; subMask; subMask = (subMask - 1) & state) {
    operate subMask...
}
//这里相当于 以下操作
/*
以从左到右 为高位到低位的顺序
这里代码思路是先求出，一、含有 state最高位1 的所有子集:
                     求解含有state最高位1的所有子集顺序是：
                     1、先求出含有最高位1的全集
                     2、再依次删除最低位的一个1,得到一个新的含有最高位1的子集
                     3、再依次删除次低位的一个1,得到一个新的含有最高位1的子集
                     4、再依次删除次次低位的一个1,得到一个新的含有最高位1的子集
                     5、依次类推...
                   二、然后按同样方法求出 含有 state次高位1 的子集

*/