力扣10.29 - 悦读

879. 盈利计划

集团里有 n 名员工，他们可以完成各种各样的工作创造利润。

第 i 种工作会产生 profit[i] 的利润，它要求 group[i] 名成员共同参与。如果成员参与了其中一项工作，就不能参与另一项工作。

工作的任何至少产生 minProfit 利润的子集称为盈利计划。并且工作的成员总数最多为 n 。

有多少种计划可以选择？因为答案很大，所以返回结果模 10^9 + 7 的值。

数据范围

1 <= n <= 100
0 <= minProfit <= 100
1 <= group.length <= 100
1 <= group[i] <= 100
profit.length == group.length
0 <= profit[i] <= 100

分析

令 $d p [i] [j] [k]$ 表示前 $i$ 种工作，恰好 $j$ 个人，至少盈利 $k$ 的计划个数
考虑第i个状态选or不选，状态转移如下：

不选： $d p [i] [j] [k] = d p [i - 1] [j] [k]$
选： $d p [i] [j] [k] + = d p [i - 1] [j - g ro u p [i]] [k - p ro f i t [i]]$

最后答案为 $\sum_{i=0}^{n-1}dp[group.size()][i][ minprofit]$

代码

typedef long long LL;
class Solution {
public:
    const static int N = 105, mod = 1e9 + 7;
    int dp[N][N][N]; // 前i种工作共j名参加至少利润k的个数
    int profitableSchemes(int n, int minProfit, vector<int>& group, vector<int>& profit) {
        dp[0][0][0] = 1;
        for(int i = 0; i < group.size(); i ++ ) {
            for(int j = 0; j <= n; j ++ ) {
                for(int k = 0; k <= minProfit; k ++ ) {
                    dp[i + 1][j][k] = dp[i][j][k];
                    if(j >= group[i]) {
                        dp[i + 1][j][k] += dp[i][j - group[i]][max(0, k - profit[i])];
                    }
                    dp[i + 1][j][k] %= mod;
                }
            }
        }
        LL res = 0;
        for(int i = 0; i <= n; i ++ ) {
            res += dp[group.size()][i][minProfit];
            res %= mod;
        }
        return res;
    }
};

1774. 最接近目标价格的甜点成本

你打算做甜点，现在需要购买配料。目前共有 n 种冰激凌基料和 m 种配料可供选购。而制作甜点需要遵循以下几条规则：

必须选择一种冰激凌基料。
可以添加一种或多种配料，也可以不添加任何配料。
每种类型的配料最多两份。

给你以下三个输入：

baseCosts ，一个长度为 n 的整数数组，其中每个 baseCosts[i] 表示第 i 种冰激凌基料的价格。
toppingCosts，一个长度为 m 的整数数组，其中每个 toppingCosts[i] 表示一份第 i 种冰激凌配料的价格。
target ，一个整数，表示你制作甜点的目标价格。
你希望自己做的甜点总成本尽可能接近目标价格 target 。

返回最接近 target 的甜点成本。如果有多种方案，返回成本相对较低的一种。

数据范围

n == baseCosts.length
m == toppingCosts.length
1 <= n, m <= 10
1 <= baseCosts[i], toppingCosts[i] <= 104
1 <= target <= 104

分析

由于数据规模比较小，dfs即可，时间复杂度为 $O(n3^m)$

代码

class Solution {
public:
    const static int N = 15, M = 1e5 + 5;
    int res = -0x3f3f3f3f;
    void dfs(int sum, int target, vector<int>& toppingCosts, int idx) {
        if(abs(sum - target) == abs(res - target)) {
            if(res > sum) res = sum;
        } else if(abs(sum - target) < abs(res - target)) {
            res = sum;
        }
        if(idx >= toppingCosts.size()) return ;
        dfs(sum , target, toppingCosts, idx + 1);
        dfs(sum + toppingCosts[idx], target, toppingCosts, idx + 1);
        dfs(sum + toppingCosts[idx] * 2, target, toppingCosts, idx + 1);
    }
    int closestCost(vector<int>& baseCosts, vector<int>& toppingCosts, int target) {
        int n = baseCosts.size();
        for(int i = 0; i < n; i ++ ) {
            dfs(baseCosts[i], target, toppingCosts, 0);
        }        
        return res;
    }
};

685. 冗余连接 II

在本问题中，有根树指满足以下条件的有向图。该树只有一个根节点，所有其他节点都是该根节点的后继。该树除了根节点之外的每一个节点都有且只有一个父节点，而根节点没有父节点。

输入一个有向图，该图由一个有着 n 个节点（节点值不重复，从 1 到 n）的树及一条附加的有向边构成。附加的边包含在 1 到 n 中的两个不同顶点间，这条附加的边不属于树中已存在的边。

结果图是一个以边组成的二维数组 edges 。每个元素是一对 [ui, vi]，用以表示有向图中连接顶点 ui 和顶点 vi 的边，其中 ui 是 vi 的一个父节点。

返回一条能删除的边，使得剩下的图是有 n 个节点的有根树。若有多个答案，返回最后出现在给定二维数组的答案。

数据范围

n == edges.length
3 <= n <= 1000
edges[i].length == 2
1 <= ui, vi <= n

分析

并查集，由于这题是有向图，需要对并查集动下手脚，每次只将子节点归到父节点中，因此不能对子节点进行路径压缩

int fa = find(a), fb = find(b);
pre[fb] = fa;

这是原来的并查集
需要改成

int fa = find(a);
pre[b] = fa;

代码

class Solution {
public:
    const static int N = 1005;
    int pre[N];
    void init(int n) {
        for(int i = 1; i <= n; i ++ ) pre[i] = i;
    }
    int find(int x) {
        return x == pre[x] ? x : pre[x] = find(pre[x]);
    }
    vector<int> findRedundantDirectedConnection(vector<vector<int>>& edges) {
        int n = edges.size();
        for(int i = n - 1; i >= 0; i -- ) {
            init(n);
            for(int j = n - 1; j >= 0; j -- ) {
                if(i == j) continue;
                int a = edges[j][0], b = edges[j][1];
                int fa = find(a);
                pre[b] = fa;
            }
            int cnt = 0;
            for(int j = 1; j <= n; j ++ ) {
                if(pre[j] == j) cnt ++ ;
            }
            if(cnt > 1) continue;
            return edges[i];
        }
        return {-1, -1};
    }
};