Bootstrap

力扣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 ] dp[i][j][k] dp[i][j][k]表示前 i i i种工作,恰好 j j j个人,至少盈利 k k k的计划个数
考虑第i个状态选or不选,状态转移如下:

  • 不选: d p [ i ] [ j ] [ k ] = d p [ i − 1 ] [ j ] [ k ] dp[i][j][k]=dp[i-1][j][k] dp[i][j][k]=dp[i1][j][k]
  • 选: d p [ i ] [ j ] [ k ] + = d p [ i − 1 ] [ j − g r o u p [ i ] ] [ k − p r o f i t [ i ] ] dp[i][j][k]+=dp[i-1][j-group[i]][k-profit[i]] dp[i][j][k]+=dp[i1][jgroup[i]][kprofit[i]]

最后答案为 ∑ i = 0 n − 1 d p [ g r o u p . s i z e ( ) ] [ i ] [ m i n p r o f i t ] \sum_{i=0}^{n-1}dp[group.size()][i][ minprofit] i=0n1dp[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 ( n 3 m ) O(n3^m) O(n3m)

代码

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};
    }
};
;