vusundevil
New member
#920, #Number of Music Playlist, #LeetCode, #C ++ ## 920. Số danh sách phát nhạc (LeetCode C ++)
Đưa ra một danh sách các số nguyên `n`` playlist`, trong đó mỗi số nguyên đại diện cho thời lượng của một bài hát trong vài phút.Chúng ta cần tìm số lượng cách chia các bài hát thành danh sách phát `m` sao cho tổng thời lượng của các bài hát trong mỗi danh sách phát là ** bằng **.
**Ví dụ:**
`` `
Đầu vào:
Danh sách phát = [30, 20, 15, 40]
m = 2
Đầu ra:
3
Giải thích:
3 danh sách phát là:
[30, 20, 15], [40]
[30, 40], [20, 15]
[20, 30, 15], [40]
`` `
**Giải pháp:**
Chúng ta có thể sử dụng lập trình động để giải quyết vấn đề này.Đặt `dp [j]` là số lượng cách phân chia các bài hát `i` đầu tiên thành danh sách phát` j` sao cho tổng số thời lượng của các bài hát trong mỗi danh sách phát là ** bằng nhau **.
Các trường hợp cơ sở là:
* `dp [0] [0] = 1`
* `dp [1] = 1` với tất cả` i> = 1`
Đối với `i> 0` và` j> 1`, chúng ta có thể chia các bài hát `i` đầu tiên thành danh sách phát` j` theo các cách sau:
1. Chúng ta có thể đặt bài hát đầu tiên vào một danh sách phát riêng biệt và chia các bài hát `i - 1` còn lại thành danh sách phát` j - 1`.Điều này cung cấp cho chúng ta `dp [i - 1] [j - 1]` Cách để làm điều này.
2. Chúng ta có thể đưa bài hát đầu tiên vào danh sách phát với bất kỳ bài hát `i - 1` nào còn lại.Điều này mang lại cho chúng ta `dp [i - 1] [j]` các cách để làm điều này.
Do đó, mối quan hệ tái phát cho `dp [j]` là:
`` `
dp [j] = dp [i - 1] [j - 1] + dp [i - 1] [j]
`` `
Chúng ta có thể sử dụng cách tiếp cận từ dưới lên để tính toán các giá trị của `dp [j]` với tất cả `i` và` j`.Sau đây là việc triển khai trong C ++:
`` `C ++
#include <bit/stdc ++. H>
sử dụng không gian tên STD;
int main () {
int n, m;
cin >> n >> m;
Vector <Int> Danh sách phát ;
for (int i = 0; i <n; i ++) {
CIN >> danh sách phát ;
}
vector <vector <int >> dp (n + 1, vector <int> (m + 1, 0));
DP [0] [0] = 1;
for (int i = 1; i <= n; i ++) {
DP [1] = 1;
}
for (int i = 2; i <= n; i ++) {
for (int j = 2; j <= m; j ++) {
dp [j] = dp [i - 1] [j - 1] + dp [i - 1] [j];
}
}
cout << dp [n] [m] << endl;
trả lại 0;
}
`` `
** Độ phức tạp về thời gian: ** O (n*m)
** Độ phức tạp không gian: ** O (n*m)
=======================================
#920, #Number of Music Playlists, #LeetCode, #C++ ## 920. Number of Music Playlists (Leetcode C++)
Given a list of `n` integers `playlist`, where each integer represents the duration of a song in minutes. We need to find the number of ways to divide the songs into `m` playlists such that the sum of the durations of the songs in each playlist is **equal**.
**Example:**
```
Input:
playlist = [30, 20, 15, 40]
m = 2
Output:
3
Explanations:
The 3 playlists are:
[30, 20, 15], [40]
[30, 40], [20, 15]
[20, 30, 15], [40]
```
**Solution:**
We can use dynamic programming to solve this problem. Let `dp[j]` be the number of ways to divide the first `i` songs into `j` playlists such that the sum of the durations of the songs in each playlist is **equal**.
The base cases are:
* `dp[0][0] = 1`
* `dp[1] = 1` for all `i >= 1`
For `i > 0` and `j > 1`, we can divide the first `i` songs into `j` playlists in the following ways:
1. We can put the first song in a separate playlist and divide the remaining `i - 1` songs into `j - 1` playlists. This gives us `dp[i - 1][j - 1]` ways to do this.
2. We can put the first song in a playlist with any of the remaining `i - 1` songs. This gives us `dp[i - 1][j]` ways to do this.
Therefore, the recurrence relation for `dp[j]` is:
```
dp[j] = dp[i - 1][j - 1] + dp[i - 1][j]
```
We can use a bottom-up approach to compute the values of `dp[j]` for all `i` and `j`. The following is the implementation in C++:
```c++
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> playlist;
for (int i = 0; i < n; i++) {
cin >> playlist;
}
vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
dp[1] = 1;
}
for (int i = 2; i <= n; i++) {
for (int j = 2; j <= m; j++) {
dp[j] = dp[i - 1][j - 1] + dp[i - 1][j];
}
}
cout << dp[n][m] << endl;
return 0;
}
```
**Time Complexity:** O(n * m)
**Space Complexity:** O(n * m)
Đưa ra một danh sách các số nguyên `n`` playlist`, trong đó mỗi số nguyên đại diện cho thời lượng của một bài hát trong vài phút.Chúng ta cần tìm số lượng cách chia các bài hát thành danh sách phát `m` sao cho tổng thời lượng của các bài hát trong mỗi danh sách phát là ** bằng **.
**Ví dụ:**
`` `
Đầu vào:
Danh sách phát = [30, 20, 15, 40]
m = 2
Đầu ra:
3
Giải thích:
3 danh sách phát là:
[30, 20, 15], [40]
[30, 40], [20, 15]
[20, 30, 15], [40]
`` `
**Giải pháp:**
Chúng ta có thể sử dụng lập trình động để giải quyết vấn đề này.Đặt `dp [j]` là số lượng cách phân chia các bài hát `i` đầu tiên thành danh sách phát` j` sao cho tổng số thời lượng của các bài hát trong mỗi danh sách phát là ** bằng nhau **.
Các trường hợp cơ sở là:
* `dp [0] [0] = 1`
* `dp [1] = 1` với tất cả` i> = 1`
Đối với `i> 0` và` j> 1`, chúng ta có thể chia các bài hát `i` đầu tiên thành danh sách phát` j` theo các cách sau:
1. Chúng ta có thể đặt bài hát đầu tiên vào một danh sách phát riêng biệt và chia các bài hát `i - 1` còn lại thành danh sách phát` j - 1`.Điều này cung cấp cho chúng ta `dp [i - 1] [j - 1]` Cách để làm điều này.
2. Chúng ta có thể đưa bài hát đầu tiên vào danh sách phát với bất kỳ bài hát `i - 1` nào còn lại.Điều này mang lại cho chúng ta `dp [i - 1] [j]` các cách để làm điều này.
Do đó, mối quan hệ tái phát cho `dp [j]` là:
`` `
dp [j] = dp [i - 1] [j - 1] + dp [i - 1] [j]
`` `
Chúng ta có thể sử dụng cách tiếp cận từ dưới lên để tính toán các giá trị của `dp [j]` với tất cả `i` và` j`.Sau đây là việc triển khai trong C ++:
`` `C ++
#include <bit/stdc ++. H>
sử dụng không gian tên STD;
int main () {
int n, m;
cin >> n >> m;
Vector <Int> Danh sách phát ;
for (int i = 0; i <n; i ++) {
CIN >> danh sách phát ;
}
vector <vector <int >> dp (n + 1, vector <int> (m + 1, 0));
DP [0] [0] = 1;
for (int i = 1; i <= n; i ++) {
DP [1] = 1;
}
for (int i = 2; i <= n; i ++) {
for (int j = 2; j <= m; j ++) {
dp [j] = dp [i - 1] [j - 1] + dp [i - 1] [j];
}
}
cout << dp [n] [m] << endl;
trả lại 0;
}
`` `
** Độ phức tạp về thời gian: ** O (n*m)
** Độ phức tạp không gian: ** O (n*m)
=======================================
#920, #Number of Music Playlists, #LeetCode, #C++ ## 920. Number of Music Playlists (Leetcode C++)
Given a list of `n` integers `playlist`, where each integer represents the duration of a song in minutes. We need to find the number of ways to divide the songs into `m` playlists such that the sum of the durations of the songs in each playlist is **equal**.
**Example:**
```
Input:
playlist = [30, 20, 15, 40]
m = 2
Output:
3
Explanations:
The 3 playlists are:
[30, 20, 15], [40]
[30, 40], [20, 15]
[20, 30, 15], [40]
```
**Solution:**
We can use dynamic programming to solve this problem. Let `dp[j]` be the number of ways to divide the first `i` songs into `j` playlists such that the sum of the durations of the songs in each playlist is **equal**.
The base cases are:
* `dp[0][0] = 1`
* `dp[1] = 1` for all `i >= 1`
For `i > 0` and `j > 1`, we can divide the first `i` songs into `j` playlists in the following ways:
1. We can put the first song in a separate playlist and divide the remaining `i - 1` songs into `j - 1` playlists. This gives us `dp[i - 1][j - 1]` ways to do this.
2. We can put the first song in a playlist with any of the remaining `i - 1` songs. This gives us `dp[i - 1][j]` ways to do this.
Therefore, the recurrence relation for `dp[j]` is:
```
dp[j] = dp[i - 1][j - 1] + dp[i - 1][j]
```
We can use a bottom-up approach to compute the values of `dp[j]` for all `i` and `j`. The following is the implementation in C++:
```c++
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> playlist;
for (int i = 0; i < n; i++) {
cin >> playlist;
}
vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
dp[1] = 1;
}
for (int i = 2; i <= n; i++) {
for (int j = 2; j <= m; j++) {
dp[j] = dp[i - 1][j - 1] + dp[i - 1][j];
}
}
cout << dp[n][m] << endl;
return 0;
}
```
**Time Complexity:** O(n * m)
**Space Complexity:** O(n * m)