๐๋ฌธ์ ๋ณด๋ฌ๊ฐ๊ธฐ
๐จ๐ปํ์ด ๊ณผ์
์์ ์ ๋ ฌ๊ณผ ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ํตํด ํ์์ต๋๋ค. ์ฒ์์๋ DFS๋ก ํ ์ ์์ ๊ฒ ๊ฐ๋จ ์๊ฐ์ ๋์ ํ๋ ค๊ณ ํ๋๋ฐ, ์ค๋ณต๋๋ ๊ณ์ฐ์ด ๋๋ฌด ๋ง์ ์๊ฐ ์ด๊ณผ๊ฐ ๋ ๊ฒ ๊ฐ๋จ ์๊ฐ์ด ๋ค์ด ๊ทธ ํ์ด๋ ํฌ๊ธฐํ์ต๋๋ค. ์๋ฌดํผ, ์ ๊ฐ ์ด๋ป๊ฒ ํ์๋์ง ์ฒ์ฒํ ์ค๋ช ํด ๋๋ฆฌ๋๋ก ํ๊ฒ ์ต๋๋ค.
1. ๊ฐ์ ์ ๋ณด ๋ฐ ์ง์ ์ฐจ์ ์ค์
ํ์ ๋ถํ์์ ์์ ๋ถํ์ผ๋ก ๊ฐ์ ์ด ๊ฐ๋ฆฌํค๋๋ก ๋ฐฉํฅ์ ์ค์ ํ์๊ณ , ํ์ํ ๋ถํ ๊ฐ์ ์ ๋ณด๋ ๊ฐ์ด ๊ด๋ฆฌํ์์ต๋๋ค.
#include <vector>
using namespace std;
using Part = pair<int, int>; // <๋ถํ ๋ฒํธ, ํ์ํ ๊ฐ์>
int main() {
int N, M;
cin >> N >> M;
// ๊ฐ์ ์ ๋ณด ๋ฐ ์ง์
์ฐจ์ ์ ๋ณด ๋ฑ๋ก
vector<vector<Part>> parts(N + 1, vector<Part>());
vector<int> inDegrees(N + 1);
int upperPart, lowerPart, count;
for (int i = 0; i < M; i++) {
cin >> upperPart >> lowerPart >> count;
parts[lowerPart].emplace_back(upperPart, count);
inDegrees[upperPart]++;
}
//...
}
๋ฌธ์ ์ ๋์์๋ ์์ ๋ฅผ ํตํด ๊ทธ๋ํ๋ฅผ ๊ตฌ์ฑํ๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
2) 2์ฐจ์ DP ๋ฐฐ์ด์ ํตํ ๊ธฐ๋ณธ ๋ถํ ๊ฐ์ ๊ธฐ์ต
2์ฐจ์ ๋ฐฐ์ด DP๋ฅผ ์ ์ธํฉ๋๋ค. DP[i][j]์ ๋ป์ i๋ฒ ๋ถํ์ 1๊ฐ ๋ง๋๋๋ฐ ํ์ํ j๋ฒ ๋ถํ์ ์ ์ฒด ๊ฐ์๋ผ๋ ๋ป์ด์ฃ .
์๋ฅผ ๋ค์ด, 6๋ฒ ๋ถํ์ ๋ง๋๋ ๋ฐ ํ์ํ 1๋ฒ ๋ถํ์ ์ด ๊ฐ์ DP[6][1] = 4 ๊ฐ ๋ ๊ฒ๋๋ค. ์ด์ ๊ฐ์ ๋ฐฉ์์ผ๋ก ์ ์ฅํด ์ค ๊ฒ๋๋ค.
๊ทธ๋ฌ๊ธฐ ์ํด, 1๋ฒ ๋ถํ๋ถํฐ N๋ฒ ๋ถํ๊น์ง ์ํํ๋ฉฐ ์ง์ ์ฐจ์๊ฐ 0์ธ ๋ถํ i๋ฅผ ์ฐพ์ต๋๋ค.
์ง์ ์ฐจ์๊ฐ 0์ด๋ผ๋ ๊ฒ์ ๊ธฐ๋ณธ ๋ถํ์ด๋ผ๋ ๊ฒ์ ์๋ฏธํ๊ธฐ ๋๋ฌธ์ด์ฃ .
๋ถํ i๋ฅผ ์ฐพ์๋ค๋ฉด, ์์ ์ ๋ ฌ์ ์ํ ํ(Queue)์ ์ง์ด ๋ฃ์๊ณผ ๋์์, DP[i][i] = 1๋ก ์ด๊ธฐํ ํด์ฃผ๋๋ก ํฉ๋๋ค.
*(๊ธฐ๋ณธ ๋ถํ์ธ ์๊ธฐ ์์ ์ ๋ง๋๋ ๋ฐ ํ์ํ ๊ฐ์๋ 1์ด๊ธฐ ๋๋ฌธ์ด์ฃ .)
vector<vector<int>> dp(N + 1, vector<int>(N + 1));
queue<int> nextParts;
for (int i = 1; i <= N; i++) {
if (inDegrees[i] == 0) {
dp[i][i] = 1;
nextParts.push(i);
}
}
์์์ ๋ดค๋ ์์ ๋ฅผ ํ ๋๋ก ์ด ๊ณผ์ ์ ์งํํด์ค๋ค๋ฉด, ๋ค์๊ณผ ๊ฐ์ 2์ฐจ์ ๋ฐฐ์ด์ด ๋ ๊ฒ๋๋ค.
์ด์ ์์ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ์ ์ฉํด ์ค์๋ค.
for (int i = 1; i <= N; i++) {
int lowerPart = nextParts.front();
nextParts.pop();
for (const auto& upperLevel : parts[lowerPart]) {
int upperPart = upperLevel.first;
int upperPartCount = upperLevel.second;
// -------์ค์-------
for (int i = 1; i <= N; i++)
dp[upperPart][i] += dp[lowerPart][i] * upperPartCount;
// -------์ค์-------
if (--inDegrees[upperPart] == 0)
nextParts.push(upperPart);
}
}
DP[i] ํ์๋ i๋ฒ ๋ถํ 1๊ฐ๋ฅผ ๋ง๋ค๊ธฐ ์ํด ํ์ํ, ๋ชจ๋ ๋ถํ ์ฌ๋ฃ ๊ฐ์๊ฐ ๋ค์ด์์ต๋๋ค.
์์ ์์ 5๋ฒ ๋ถํ์ ๋ง๋ค๊ธฐ ์ํด์ , 1๋ฒ ๋ถํ 2๊ฐ์ 2๋ฒ ๋ถํ 2๊ฐ๊ฐ ํ์ํ๋ค๊ณ ๋์ ์์ต๋๋ค.
๊ทธ๋ ๋ค๋ฉด 1๋ฒ ๋ถํ์ ๋ง๋๋ ๋ฐ ํ์ํ i ๋ฒ์งธ ๋ถํ * 2 ํ ๊ฐ์ 5๋ฒ ๋ถํ์ ๋ง๋๋ ๋ฐ ํ์ํ i ๋ฒ์งธ ๋ถํ ๊ฐ์์ ๋ํด์ค์ผ๊ฒ ์ฃ . ๋ง์ฐฌ๊ฐ์ง๋ก 2๋ฒ ๋ถํ์ ๋ง๋๋ ๋ฐ ํ์ํ i ๋ฒ์งธ ๋ถํ * 2 ํ ๊ฐ์ 5๋ฒ ๋ถํ์ ๋ง๋๋ ๋ฐ ํ์ํ i ๋ฒ์งธ ๋ถํ ๊ฐ์์ ๋ํด์ฃผ๋ฉด ๋ ๊ฒ๋๋ค.
์ด๊ฑธ ์ฝ๋ ์์ผ๋ก ๋ํ๋ธ ๊ฒ ๋ค์ ์ฝ๋์ ๋๋ค.
for (int i = 1; i <= N; i++)
dp[upperPart][i] += dp[lowerPart][i] * upperPartCount;
์ด ๋ถ๋ถ๋ง ์ถ๊ฐํด์ฃผ๊ณ , ๋๋จธ์ง๋ ์์ ์ ๋ ฌ์ ํด์ฃผ๋ฉด ๋ฉ๋๋ค.
์์ ์ ๋ ฌ์ด ๋๋ฌ๋ค๋ฉด, dp[N]์ ํด๋นํ๋ ํ์์ 0์ ์ ์ธํ ๊ฐ๋ค์ ์ฐจ๋ก๋๋ก ์ถ๋ ฅํด์ฃผ๋ฉด ๋ฉ๋๋ค.
* dp[N][5] = 0 ์ด๋ผ๋ ๊ฒ์ 5๋ฒ ๋ถํ์ด ๊ธฐ๋ณธ ๋ถํ์ด ์๋๋ผ๋ ๊ฑธ ๋ปํ๊ธฐ ๋๋ฌธ์ด์ฃ .
โ๏ธ์์ค ์ฝ๋ ๋ฐ ๊ฒฐ๊ณผ
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
using Part = pair<int, int>; // <๋ถํ ๋ฒํธ, ํ์ ๊ฐ์>
#define FAST_IO ios::sync_with_stdio(false); cout.tie(NULL); cin.tie(NULL);
vector<int> Solution(const vector<vector<Part>>& parts, vector<int>& inDegrees, int N) {
vector<vector<int>> dp(N + 1, vector<int>(N + 1));
queue<int> nextParts;
for (int i = 1; i <= N; i++) {
if (inDegrees[i] == 0) {
dp[i][i] = 1;
nextParts.push(i);
}
}
for (int i = 1; i <= N; i++) {
int lowerPart = nextParts.front();
nextParts.pop();
for (const auto& upperLevel : parts[lowerPart]) {
int upperPart = upperLevel.first;
int upperPartCount = upperLevel.second;
for (int i = 1; i <= N; i++)
dp[upperPart][i] += dp[lowerPart][i] * upperPartCount;
if (--inDegrees[upperPart] == 0)
nextParts.push(upperPart);
}
}
return dp[N];
}
int main() {
FAST_IO
int N, M;
cin >> N >> M;
vector<vector<Part>> parts(N + 1, vector<Part>());
vector<int> inDegrees(N + 1);
int upperPart, lowerPart, count;
for (int i = 0; i < M; i++) {
cin >> upperPart >> lowerPart >> count;
parts[lowerPart].emplace_back(upperPart, count);
inDegrees[upperPart]++;
}
vector<int> answers = Solution(parts, inDegrees, N);
for (int i = 1; i <= N; i++) {
if (answers[i] != 0)
cout << i << " " << answers[i] << "\n";
}
return 0;
}
'๐คAlgorithm > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[BOJ] 3055๋ฒ | ํ์ถ (C++) (1) | 2024.01.31 |
---|---|
[BOJ] 2357๋ฒ | ์ต์๊ฐ๊ณผ ์ต๋๊ฐ (C++) (1) | 2024.01.24 |
[BOJ] 11779๋ฒ | ์ต์๋น์ฉ ๊ตฌํ๊ธฐ 2 (C++) (1) | 2023.12.20 |
[BOJ] 2623๋ฒ | ์์ ํ๋ก๊ทธ๋จ (C++) (1) | 2023.12.19 |
[BOJ] 1516๋ฒ | ๊ฒ์ ๊ฐ๋ฐ (C++) (1) | 2023.12.19 |