diff --git a/solution/0800-0899/0826.Most Profit Assigning Work/README.md b/solution/0800-0899/0826.Most Profit Assigning Work/README.md index ac375926f274d..468f898113a8b 100644 --- a/solution/0800-0899/0826.Most Profit Assigning Work/README.md +++ b/solution/0800-0899/0826.Most Profit Assigning Work/README.md @@ -190,4 +190,127 @@ function maxProfitAssignment(difficulty: number[], profit: number[], worker: num + + +### 方法二：动态规划 + +我们不妨记 $m = \max(\text{difficulty})$，定义一个长度为 $m + 1$ 的数组 $f$，其中 $f[i]$ 表示难度小于等于 $i$ 的工作中收益的最大值，初始时 $f[i] = 0$。 + +然后我们遍历工作，对于每个工作 $(d, p)$，我们更新 $f[d] = \max(f[d], p)$。 + +接下来，我们从 $1$ 到 $m$ 遍历，对于每个 $i$，我们更新 $f[i] = \max(f[i], f[i - 1])$。 + +最后，我们遍历工人，对于每个工人 $w$，我们将 $f[\min(w, m)]$ 加到答案中。 + +时间复杂度 $O(n + M)$，空间复杂度 $O(M)$。其中 $n$ 是数组 `profit` 的长度，而 $M$ 是数组 `difficulty` 中的最大值。 + + + +#### Python3 + +```python +class Solution: + def maxProfitAssignment( + self, difficulty: List[int], profit: List[int], worker: List[int] + ) -> int: + m = max(difficulty) + f = [0] * (m + 1) + for d, p in zip(difficulty, profit): + f[d] = max(f[d], p) + for i in range(1, m + 1): + f[i] = max(f[i], f[i - 1]) + return sum(f[min(w, m)] for w in worker) +``` + +#### Java + +```java +class Solution { + public int maxProfitAssignment(int[] difficulty, int[] profit, int[] worker) { + int m = Arrays.stream(difficulty).max().getAsInt(); + int[] f = new int[m + 1]; + int n = profit.length; + for (int i = 0; i < n; ++i) { + int d = difficulty[i]; + f[d] = Math.max(f[d], profit[i]); + } + for (int i = 1; i <= m; ++i) { + f[i] = Math.max(f[i], f[i - 1]); + } + int ans = 0; + for (int w : worker) { + ans += f[Math.min(w, m)]; + } + return ans; + } +} +``` + +#### C++ + +```cpp +class Solution { +public: + int maxProfitAssignment(vector& difficulty, vector& profit, vector& worker) { + int m = *max_element(begin(difficulty), end(difficulty)); + int f[m + 1]; + memset(f, 0, sizeof(f)); + int n = profit.size(); + for (int i = 0; i < n; ++i) { + int d = difficulty[i]; + f[d] = max(f[d], profit[i]); + } + for (int i = 1; i <= m; ++i) { + f[i] = max(f[i], f[i - 1]); + } + int ans = 0; + for (int w : worker) { + ans += f[min(w, m)]; + } + return ans; + } +}; +``` + +#### Go + +```go +func maxProfitAssignment(difficulty []int, profit []int, worker []int) (ans int) { + m := slices.Max(difficulty) + f := make([]int, m+1) + for i, d := range difficulty { + f[d] = max(f[d], profit[i]) + } + for i := 1; i <= m; i++ { + f[i] = max(f[i], f[i-1]) + } + for _, w := range worker { + ans += f[min(w, m)] + } + return +} +``` + +#### TypeScript + +```ts +function maxProfitAssignment(difficulty: number[], profit: number[], worker: number[]): number { + const m = Math.max(...difficulty); + const f = Array(m + 1).fill(0); + const n = profit.length; + for (let i = 0; i < n; ++i) { + const d = difficulty[i]; + f[d] = Math.max(f[d], profit[i]); + } + for (let i = 1; i <= m; ++i) { + f[i] = Math.max(f[i], f[i - 1]); + } + return worker.reduce((acc, w) => acc + f[Math.min(w, m)], 0); +} +``` + + + + + diff --git a/solution/0800-0899/0826.Most Profit Assigning Work/README_EN.md b/solution/0800-0899/0826.Most Profit Assigning Work/README_EN.md index 6f2f13975e767..d9edd25f594fc 100644 --- a/solution/0800-0899/0826.Most Profit Assigning Work/README_EN.md +++ b/solution/0800-0899/0826.Most Profit Assigning Work/README_EN.md @@ -190,4 +190,127 @@ function maxProfitAssignment(difficulty: number[], profit: number[], worker: num + + +### Solution 2: Dynamic Programming + +Let's denote $m = \max(\text{difficulty})$ and define an array $f$ of length $m + 1$, where $f[i]$ represents the maximum profit among jobs with difficulty less than or equal to $i$, initially $f[i] = 0$. + +Then, we iterate over the jobs, and for each job $(d, p)$, if $d \leq m$, we update $f[d] = \max(f[d], p)$. + +Next, we iterate from $1$ to $m$, and for each $i$, we update $f[i] = \max(f[i], f[i - 1])$. + +Finally, we iterate over the workers, and for each worker $w$, we add $f[w]$ to the answer. + +The time complexity is $O(n + M)$, and the space complexity is $O(M)$. Here, $n$ is the length of the `profit` array, and $M$ is the maximum value in the `difficulty` array. + + + +#### Python3 + +```python +class Solution: + def maxProfitAssignment( + self, difficulty: List[int], profit: List[int], worker: List[int] + ) -> int: + m = max(difficulty) + f = [0] * (m + 1) + for d, p in zip(difficulty, profit): + f[d] = max(f[d], p) + for i in range(1, m + 1): + f[i] = max(f[i], f[i - 1]) + return sum(f[min(w, m)] for w in worker) +``` + +#### Java + +```java +class Solution { + public int maxProfitAssignment(int[] difficulty, int[] profit, int[] worker) { + int m = Arrays.stream(difficulty).max().getAsInt(); + int[] f = new int[m + 1]; + int n = profit.length; + for (int i = 0; i < n; ++i) { + int d = difficulty[i]; + f[d] = Math.max(f[d], profit[i]); + } + for (int i = 1; i <= m; ++i) { + f[i] = Math.max(f[i], f[i - 1]); + } + int ans = 0; + for (int w : worker) { + ans += f[Math.min(w, m)]; + } + return ans; + } +} +``` + +#### C++ + +```cpp +class Solution { +public: + int maxProfitAssignment(vector& difficulty, vector& profit, vector& worker) { + int m = *max_element(begin(difficulty), end(difficulty)); + int f[m + 1]; + memset(f, 0, sizeof(f)); + int n = profit.size(); + for (int i = 0; i < n; ++i) { + int d = difficulty[i]; + f[d] = max(f[d], profit[i]); + } + for (int i = 1; i <= m; ++i) { + f[i] = max(f[i], f[i - 1]); + } + int ans = 0; + for (int w : worker) { + ans += f[min(w, m)]; + } + return ans; + } +}; +``` + +#### Go + +```go +func maxProfitAssignment(difficulty []int, profit []int, worker []int) (ans int) { + m := slices.Max(difficulty) + f := make([]int, m+1) + for i, d := range difficulty { + f[d] = max(f[d], profit[i]) + } + for i := 1; i <= m; i++ { + f[i] = max(f[i], f[i-1]) + } + for _, w := range worker { + ans += f[min(w, m)] + } + return +} +``` + +#### TypeScript + +```ts +function maxProfitAssignment(difficulty: number[], profit: number[], worker: number[]): number { + const m = Math.max(...difficulty); + const f = Array(m + 1).fill(0); + const n = profit.length; + for (let i = 0; i < n; ++i) { + const d = difficulty[i]; + f[d] = Math.max(f[d], profit[i]); + } + for (let i = 1; i <= m; ++i) { + f[i] = Math.max(f[i], f[i - 1]); + } + return worker.reduce((acc, w) => acc + f[Math.min(w, m)], 0); +} +``` + + + + + diff --git a/solution/0800-0899/0826.Most Profit Assigning Work/Solution2.cpp b/solution/0800-0899/0826.Most Profit Assigning Work/Solution2.cpp new file mode 100644 index 0000000000000..84114264adcf1 --- /dev/null +++ b/solution/0800-0899/0826.Most Profit Assigning Work/Solution2.cpp @@ -0,0 +1,21 @@ +class Solution { +public: + int maxProfitAssignment(vector& difficulty, vector& profit, vector& worker) { + int m = *max_element(begin(difficulty), end(difficulty)); + int f[m + 1]; + memset(f, 0, sizeof(f)); + int n = profit.size(); + for (int i = 0; i < n; ++i) { + int d = difficulty[i]; + f[d] = max(f[d], profit[i]); + } + for (int i = 1; i <= m; ++i) { + f[i] = max(f[i], f[i - 1]); + } + int ans = 0; + for (int w : worker) { + ans += f[min(w, m)]; + } + return ans; + } +}; diff --git a/solution/0800-0899/0826.Most Profit Assigning Work/Solution2.go b/solution/0800-0899/0826.Most Profit Assigning Work/Solution2.go new file mode 100644 index 0000000000000..97a45eef59f55 --- /dev/null +++ b/solution/0800-0899/0826.Most Profit Assigning Work/Solution2.go @@ -0,0 +1,14 @@ +func maxProfitAssignment(difficulty []int, profit []int, worker []int) (ans int) { + m := slices.Max(difficulty) + f := make([]int, m+1) + for i, d := range difficulty { + f[d] = max(f[d], profit[i]) + } + for i := 1; i <= m; i++ { + f[i] = max(f[i], f[i-1]) + } + for _, w := range worker { + ans += f[min(w, m)] + } + return +} diff --git a/solution/0800-0899/0826.Most Profit Assigning Work/Solution2.java b/solution/0800-0899/0826.Most Profit Assigning Work/Solution2.java new file mode 100644 index 0000000000000..134c322057cad --- /dev/null +++ b/solution/0800-0899/0826.Most Profit Assigning Work/Solution2.java @@ -0,0 +1,19 @@ +class Solution { + public int maxProfitAssignment(int[] difficulty, int[] profit, int[] worker) { + int m = Arrays.stream(difficulty).max().getAsInt(); + int[] f = new int[m + 1]; + int n = profit.length; + for (int i = 0; i < n; ++i) { + int d = difficulty[i]; + f[d] = Math.max(f[d], profit[i]); + } + for (int i = 1; i <= m; ++i) { + f[i] = Math.max(f[i], f[i - 1]); + } + int ans = 0; + for (int w : worker) { + ans += f[Math.min(w, m)]; + } + return ans; + } +} diff --git a/solution/0800-0899/0826.Most Profit Assigning Work/Solution2.py b/solution/0800-0899/0826.Most Profit Assigning Work/Solution2.py new file mode 100644 index 0000000000000..7d5e992786776 --- /dev/null +++ b/solution/0800-0899/0826.Most Profit Assigning Work/Solution2.py @@ -0,0 +1,11 @@ +class Solution: + def maxProfitAssignment( + self, difficulty: List[int], profit: List[int], worker: List[int] + ) -> int: + m = max(difficulty) + f = [0] * (m + 1) + for d, p in zip(difficulty, profit): + f[d] = max(f[d], p) + for i in range(1, m + 1): + f[i] = max(f[i], f[i - 1]) + return sum(f[min(w, m)] for w in worker) diff --git a/solution/0800-0899/0826.Most Profit Assigning Work/Solution2.ts b/solution/0800-0899/0826.Most Profit Assigning Work/Solution2.ts new file mode 100644 index 0000000000000..2967c42fd7a26 --- /dev/null +++ b/solution/0800-0899/0826.Most Profit Assigning Work/Solution2.ts @@ -0,0 +1,13 @@ +function maxProfitAssignment(difficulty: number[], profit: number[], worker: number[]): number { + const m = Math.max(...difficulty); + const f = Array(m + 1).fill(0); + const n = profit.length; + for (let i = 0; i < n; ++i) { + const d = difficulty[i]; + f[d] = Math.max(f[d], profit[i]); + } + for (let i = 1; i <= m; ++i) { + f[i] = Math.max(f[i], f[i - 1]); + } + return worker.reduce((acc, w) => acc + f[Math.min(w, m)], 0); +}