https://www.acmicpc.net/problem/2313
๋ฌธ์
๋ณด์ ๊ฐ๊ฒ์ ์ฌ๋ฌ ๊ฐ์ง์ ๋ณด์์ด ์ง์ด๋์ด ์๋ค. ๊ฐ๊ฐ์ ๋ณด์์ ์ ์๋ก ํํ๋๋ ๊ฐ์น๊ฐ ์๋ค. ๋๋ก๋ ์ ์ฃผ๋ฐ์ ๋ณด์์ด ์๊ธฐ ๋๋ฌธ์ ๊ฐ์น๊ฐ ์์๊ฐ ๋ ์๋ ์๋ค.
๋ณด์๋ค์ ์ด n๊ฐ์ ์ค์ ๋์ด๋์ด ์๋ค. ์ด์ ๋น์ ์ ๊ฐ๊ฐ์ ์ค์์ ๋ช ๊ฐ์ ๋ณด์์ ๊ตฌ๋งคํ๋ ค ํ๋ค. ์ด๋, ๊ฐ ์ค์์ ๋ณด์์ ๊ตฌ๋งคํ ๋ ์ฐ์์ ์ธ ๋ณด์๋ค์ ๊ตฌ๋งคํด์ผ ํ๋ค. ์ฆ, ์ด๋ ํ ์ค์์ 1, 2๋ฒ ๋ณด์์ ๊ตฌ๋งคํ ์๋ ์๊ณ , 2, 3๋ฒ ๋ณด์์ ๊ตฌ๋งคํ ์๋ ์์ง๋ง, 1, 3๋ฒ ๋ณด์์ ๊ตฌ๋งคํ ์๋ ์๋ค.
๊ตฌ๋งคํ๋ ๋ณด์์ ๊ฐ์น์ ์ด ํฉ์ด ์ต๋๊ฐ ๋๋๋ก ๋ณด์์ ๊ตฌ๋งคํ๋ ๋ฐฉ๋ฒ์ ์ฐพ์๋ด๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์ ์ n(1 ≤ n ≤ 1,000)์ด ์ฃผ์ด์ง๋ค. ๋ค์ 2×n๊ฐ์ ์ค์๋ n๊ฐ์ ์ค์ ๋์ด๋ ๋ณด์๋ค์ ๋ํ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋ค. ๋จผ์ ๊ฐ ์ค์ ๋์ด๋ ๋ณด์์ ๊ฐ์ L(1 ≤ L ≤ 1,000)์ด ์ฃผ์ด์ง๊ณ , ๊ทธ ๋ค์ ์ค์ L๊ฐ์ ์ ์๋ค์ด ์ฃผ์ด์ง๋ค. ๊ฐ ์ ์๋ ๊ฐ ๋ณด์์ ๊ฐ์น๋ฅผ ๋ํ๋ธ๋ค. ๋ณด์์ ๊ฐ์น๋ ์ ๋๊ฐ์ด 10,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ์์ด๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ๋ณด์์ ๊ฐ์น์ ์ด ํฉ์ ์ต๋๊ฐ์ ์ถ๋ ฅํ๋ค. ๋ค์ n๊ฐ์ ์ค์๋, ์ค์์ ๋ช ๋ฒ์งธ ๋ณด์๋ถํฐ ๋ช ๋ฒ์งธ ๋ณด์๊น์ง๋ฅผ ๊ตฌ๋งคํ๋์ง๋ฅผ ์ถ๋ ฅํ๋ค.
๋ง์ฝ ์ต๋๊ฐ ๋๋ ๊ฒฝ์ฐ๊ฐ ์ฌ๋ฟ์ด๋ฉด, ๊ตฌ๋งคํ ๋ณด์๋ค์ ์ด ๊ฐ์๊ฐ ์ต์๊ฐ ๋๋ ๋ฐฉ๋ฒ์ ์ถ๋ ฅํ๋ค. ์ด์ ๊ฐ์ ๊ฒฝ์ฐ๋ ์ฌ๋ฟ์ด๋ผ๋ฉด, ์ถ๋ ฅํ n×2๊ฐ์ ์๋ค์ ํ๋์ ์์ด๋ก ์๊ฐํ์ฌ, ์ฌ์ ์์ผ๋ก ๊ฐ์ฅ ์์ ์ค๋ ๊ฒฝ์ฐ๋ฅผ ์ถ๋ ฅํ๋ค.
ํ์ด
์ ๋ ฅ ์กฐ๊ฑด์ ๋ณด๋ฉด ๋ณด์ ๊ฐ์น์ ์ด ํฉ์
์ต๋ n*L*(๋ณด์์ ๊ฐ์น ์ต๋๊ฐ) = 1000*1000*10000 = 10,000,000,000 = 100์ต
23์ต์ ํ์ฐธ ๋๊ธฐ๋ฏ๋ก int๊ฐ ์๋ long long์ผ๋ก ํด์ผํ๋ค
๋ณด์ ๊ฐ ์ค๋ง๋ค dp ์ฐ์ฐ์ ๋ ๋ฆฝ์ ์ผ๋ก ์งํํ์ง๋ง
์ถ๋ ฅ ์ฒซ ์ค์ ์ต์ข ์ผ๋ก ๋์จ ๊ฐ์ ๋ณด์ฌ์ค์ผํ๊ธฐ ๋๋ฌธ์
์ ๋ ฅ์ ์ ๋ถ ๋ค ๋ฐ์์ ์ ์ฅํด๋๊ณ ์์ํด์ผํ๋ค. (ํ์๋ v๋ผ๋ ๋ฒกํฐ๋ฅผ ์ฌ์ฉํ๋ค)
dp[i] : ๋ณด์๊ฐฏ์, i๋ฒ์งธ๊น์ง์ ์ต๋ํฉ
// dp
vector<ci>dp(length); // dp[i] : ๋ณด์๊ฐฏ์, i๋ฒ์งธ๊น์ง์ ์ต๋ํฉ
dp[0] = {1, v[i][0]};
for(int j=1; j<length; j++) {
ci before = dp[j-1];
if(before.second<=0) {
dp[j] = {1, v[i][j]};
} else {
dp[j] = {before.first+1, before.second+v[i][j]};
}
}
๋น๊ต ์กฐ๊ฑด์ด ๊น๋ค๋กญ๋ค.
1. ๋ณด์์ ๊ฐ์น์ ํฉ์ด ์ต๋๊ฐ ๋์ด์ผํจ
2. ๊ฐ์น์ ํฉ์ด ๊ฐ๋ค๋ฉด -> ๋ณด์์ ๊ฐฏ์๊ฐ ์ ์ด์ผํจ
3. ๊ฐ์น๋ ๊ฐ๊ณ ๊ฐฏ์๋ ๊ฐ๋ค๋ฉด -> ๊ทธ๋๋ง ์์ชฝ์ธ๊ฑฐ
// ์ต๋๊ฐ ๋๋ ์ฒซ๋ฒ์งธ ์์น ๊ตฌํ๊ธฐ
int index = 0;
int cnt = dp[index].first;
int max_value = dp[index].second;
for(int j=1; j<length; j++) {
if(dp[j].second>=max_value) {
if(dp[j].second==max_value && dp[j].first>=cnt) {
continue;
}
index = j;
max_value = dp[j].second;
cnt = dp[j].first;
}
}
๊ฒ์ํ์ ์น์ ํ ๋ฐ๋ก ๋ชจ์์ด ์๋ค.
์๋ ๊ธ์ ๋์์๋ ๋ฐ๋ก๋ฅผ ๋ค ์ฑ๊ณตํ๋ฉด ๊ฑฐ์ ์ฑ๊ณต์ด๋ค
https://www.acmicpc.net/board/view/139927
์ฝ๋
// ํ์ด : https://whkakrkr.tistory.com
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> ci;
int main() {
// ์
๋ ฅ
int n;
cin >> n;
vector<vector<int>>v(n);
for(int i=0; i<n; i++) {
int tmp;
cin >> tmp;
v[i] = vector<int>(tmp);
for(int j=0; j<tmp; j++) {
cin >> v[i][j];
}
}
// ํ์ด
ll sum = 0;
vector<ci> ans(n);
for(int i=0; i<n; i++) {
int length = v[i].size();
// dp
vector<ci>dp(length); // dp[i] : ๋ณด์๊ฐฏ์, i๋ฒ์งธ๊น์ง์ ์ต๋ํฉ
dp[0] = {1, v[i][0]};
for(int j=1; j<length; j++) {
ci before = dp[j-1];
if(before.second<=0) {
dp[j] = {1, v[i][j]};
} else {
dp[j] = {before.first+1, before.second+v[i][j]};
}
}
// ์ต๋๊ฐ ๋๋ ์ฒซ๋ฒ์งธ ์์น ๊ตฌํ๊ธฐ
int index = 0;
int cnt = dp[index].first;
int max_value = dp[index].second;
for(int j=1; j<length; j++) {
if(dp[j].second>=max_value) {
if(dp[j].second==max_value && dp[j].first>=cnt) {
continue;
}
index = j;
max_value = dp[j].second;
cnt = dp[j].first;
}
}
sum += max_value;
ans[i] = {index+1-cnt+1, index+1};
}
// ์ถ๋ ฅ
cout << sum << "\n";
for(ci i : ans) {
cout << i.first << " " << i.second << "\n";
}
return 0;
}
'๐๏ธ ICPC Sinchon > Dynamic Programming' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[BOJ][C++] ๋ฐฑ์ค 2421๋ฒ: ์ ๊ธํต (0) | 2024.09.24 |
---|---|
[BOJ][C++] ๋ฐฑ์ค 1577๋ฒ: ๋๋ก์ ๊ฐ์ (0) | 2024.09.16 |
[BOJ][C++] ๋ฐฑ์ค 4883๋ฒ: ์ผ๊ฐ ๊ทธ๋ํ (0) | 2024.09.13 |
[BOJ][C++] ๋ฐฑ์ค 2688๋ฒ: ์ค์ด๋ค์ง ์์ (0) | 2024.09.06 |
[BOJ][C++] ๋ฐฑ์ค 1904๋ฒ: 01ํ์ผ (0) | 2024.08.25 |