๋ฌธ์ ๋งํฌ
https://school.programmers.co.kr/learn/courses/30/lessons/1837
๋ค์ํ ์์ธ์ผ๋ก ์ธํด ์ค๋ฅ๊ฐ ๋ฐ์ํ ์ ์๋ GPS๋ก ํ์ ํ ์ง๋์จ ๊ฑฐ์ ์ ์ ๋ณด๊ฐ ์ฃผ์ด์ก์ ๋,
์ต์ํ์ ๊ฒฝ๋ก๋ง ์์ ํด์ ๊ฐ๋ฅํ ๊ฒฝ๋ก๊ฐ ๋๋๋ก ๋ง๋ค์ด๋ณด์.
ํ์ด
- ๋ด๊ฐ ๋ ์ฌ๋ฆฐ ์์ด๋์ด
์ผ๋จ ๋ ธ๋์ ๊ฐ์ ์ ๋ํ ์ ๋ณด๊ฐ ์ฃผ์ด์ก๊ธฐ ๋๋ฌธ์ ๋๋ ๋น์ฐํ ๊ทธ๋ํ ํ์์ ์ด์ฉํด์ผํ๋ค๊ณ ์๊ฐํ๋ค.
๋๋ DFS๋ฅผ ์ด์ฉํด์ ๊น์ด๊ฐ k์ธ ๊ฒฝ๋ก๋ฅผ ํ์ ํ ๋ค์, ํ์ํ ๊ฒฝ๋ก์ ์ฃผ์ด์ง GPS ๊ฒฝ๋ก๊ฐ ๊ฐ์์ง๋ ค๋ฉด ๋ช ๊ฐ์ ์ ๋ณด๋ฅผ ์์ ํด์ผํ๋ ์ง ํค์๋ ธ๋ค.
์ด๋ ์์ ํด์ผํ๋ ์๊ฐ ๊ฐ์ฅ ์ ์ ๊ฒ์ ์ ๋ต์ผ๋ก ์ฒ๋ฆฌํ๋ คํ๋ค.
์ด ๋ฐฉ๋ฒ์ด ํ๋ฆฐ ๋ฐฉ๋ฒ์ ์๋๋ค. ์ฃผ์ด์ง ํ ์คํธ์ผ์ด์ค๋ ๋ชจ๋ ํต๊ณผํ์ง๋ง, ์ฃผ์ด์ง๋ ๋ ธ๋์ ๊ฐ์ ์ ์๊ฐ ๋ง์์ง ์๋ก ๊ฒฝ์ฐ์ ์๊ฐ ๋ง์์ ธ์ ์๊ฐ์ด๊ณผ๊ฐ ๋ฐ์ํ๋ค.
์ฌ๊ธฐ์ ๋ ๋์๊ฐ์ง ๋ชปํ๊ณ ํ ์๊ฐ ์ ๋๋ฅผ ๊ณ ๋ฏผํ๋ค๊ฐ ๊ฒฐ๊ตญ ๊ตฌ๊ธ์ ํ์ ๋น๋ ธ๋ค.
3๋จ๊ณ ๋ฌธ์ ๊ฐ ๋ง๋ ์ถ์ ์ ๋๋ก ์ด๋ ค์ด ๋ฌธ์ ์๋ค. ์ง๊ธ๊น์ง ํ์ด๋ณธ ๋ฐ๋ก ์นด์นด์ค ๋ฌธ์ ๊ฐ ๋์ฒด๋ก ์์ค์ด ๋์ ๋ฏํ๋ค.
์ฐธ๊ณ ํ ๋งํฌ
https://ansohxxn.github.io/programmers/130/
๊ณต๋ถํ๋ ์๋นต๋ง๋์ ํ์ด๋ฅผ ์ฐธ๊ณ ํด์ ํ์๋ค. ์ค๋ช ์ ๋๋ฌด ์ํด๋์ผ์ ์ ์ฝ๊ฒ ์ดํดํ ์ ์์๋ค.
- ํ์ด ์๊ณ ๋ฆฌ์ฆ
์ ๋ต์ DFS, BFS ๋๋ค ์๋ DP์๋ค. ๋๋ DP๋ฅผ ์ธ๊ฑฐ๋ผ๊ณค ์๊ฐ๋ ๋ชปํ๋๋ฐ ํ์ด๋ฅผ ๋ณด๋ ์ดํด๊ฐ๋๋ค.
DP[์๊ฐ][์์น] ๋ก ๋ฐฐ์ด์ ๋ง๋ค์ด์, ํด๋น ์๊ฐ์ ํด๋น ์์น๊น์ง ์ค๊ธฐ์ํด ์์ ํ ์ต์ ํ์๋ฅผ ์ ์ฅํ๋ค.
์ต์ข ์ ์ผ๋ก DP[K][๋ง์ง๋ง ์ ์ ] ์ ์ ์ฅ๋์ด์๋ ๊ฐ์ด ์ ๋ต์ด ๋ ๊ฒ์ด๋ค.
DP[ t ][ pos ] ๊ฐ์ ์ ํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ๋ค.
1. t - 1 ์ด์๋ pos ์์น, ์ฆ ๊ฐ์ ์์น์ ์์๋ ๊ฒฝ์ฐ
2. t - 1 ์ด์ ์ธ์ ํ ์์น์์ pos๋ก ์จ ๊ฒฝ์ฐ
๋ ๊ฒฝ์ฐ ์ค์ ์์ ํ์๊ฐ ์ต์๊ฐ ๋๋ ๊ฐ์ ์ฐพ๋๋ค. ์ด๋์ ๊ฐ์ Min์ด๋ผ๊ณ ํ์.
pos๊ฐ GPS์ ์ฐํ t์ด์ผ ๋์ ์์น์ ์ผ์นํ๋ค๋ฉด ์์ ์ด ํ์์์ผ๋ฏ๋ก
DP[ t ][ pos ] = Min์ด ๋๋ค
๋ง์ฝ ์ผ์นํ์ง ์๋๋ค๋ฉด ์์ ์ด ํ์ํ๋ฏ๋ก
DP[ t ][ pos ] = Min + 1์ด ๋๋ค.
์์ ๋ด์ฉ์ ์ฝ๋๋ก ์์ฑํ๋ฉด ์๋์ ๊ฐ๋ค.
int Min = DP[t-1][pos]; //์ ์๋ฆฌ์ ๋จธ๋ฌผ๋ ์ ๊ฒฝ์ฐ
for(int i = 0; i<Edge[pos].size(); i++)
Min = min(Min, DP[t-1][Edge[pos][i]]); //์ธ์ ํ ์ ์ ์์ ์์ ๊ฒฝ์ฐ
if(pos != gps_log[t-1]) //์ฃผ์ด์ง ๊ฒฝ๋ก์ ๋ค๋ฅผ ๊ฒฝ์ฐ
DP[t][pos] = Min + 1; //์์ ํด์ผํ๋ฏ๋ก + 1
else DP[t][pos] = Min;
๊ฐ์ ๋ฐฉ์์ผ๋ก t๊ฐ k๊ฐ ๋ ๋๊น์ง์ DP๊ฐ์ ๊ตฌํ ๋ค,
DP[ k ][ ์ฃผ์ด์ง ๋ง์ง๋ง ์์น ] ๊ฐ ์ฒ์์ ์ด๊ธฐํํ ๊ฐ์ธ INF๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๋ค๋ฉด, ํด๋น ์์น์๋ ๋๋ฌํ ์ ์๋ค๋ ๋ป์ด๋ฏ๋ก answer = - 1์ด ๋๋ค.
k ๋ ์ต๋ 100 ์ด๋ฏ๋ก ๋ชจ๋ ๊ฒฝ๋ก๋ฅผ ์์ ํ๋ค๊ณ ํด๋ 98ํ์ ์์ ์ด ๋ฐ์ํ๋ค.
๊ทธ๋์ INF ๊ฐ์ 100๋ณด๋ค ํฐ ์๋ก ์ด๊ธฐํ ์์ผ์ฃผ๋ฉด ๋๋ค.
์ฝ๋ ์์ฑ
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000;
const int MAX_N = 200 + 5;
int solution(int n, int m, vector<vector<int>> edge_list, int k, vector<int> gps_log){
int answer = 0;
vector<int> Edge[MAX_N];
vector<vector<int>> DP(k + 1, vector<int>(n + 1, INF));
for(auto list : edge_list){
Edge[list[0]].push_back(list[1]);
Edge[list[1]].push_back(list[0]);
}
DP[1][gps_log[0]] = 0; //์์์ ์ ์์ ์ด ๋ถ๊ฐ๋ฅ
for(int t = 2; t<=k; t++){ //์๊ฐ
for(int pos = 1; pos <= n; pos++){ //๋ชจ๋ ์ ์ ์ํ
int Min = DP[t-1][pos]; //์ ์๋ฆฌ์ ๋จธ๋ฌผ๋ ์ ๊ฒฝ์ฐ
for(int i = 0; i<Edge[pos].size(); i++)
Min = min(Min, DP[t-1][Edge[pos][i]]); //์ธ์ ํ ์ ์ ์์ ์์ ๊ฒฝ์ฐ
if(pos != gps_log[t-1]) //์ฃผ์ด์ง ๊ฒฝ๋ก์ ๋ค๋ฅผ ๊ฒฝ์ฐ
DP[t][pos] = Min + 1; //์์ ํด์ผํ๋ฏ๋ก + 1
else DP[t][pos] = Min;
}
}
answer = DP[k][gps_log[k-1]];
if(answer >= INF)
answer = -1;
return answer;
}
|
cs |
//์ ์ญ๋ณ์๋ฅผ ์ฌ์ฉํ ์ ํจ์ ๋ด์์ ์ด๊ธฐํํ๋ ์ฝ๋๊ฐ ์์ด์ผ ํ๋ค.
๋ผ๋ ๊ฒฝ๊ณ ๋ฌธ์ด ์์์ง๋ง ๋ฌด์ํ๊ณ Edge ๋ฒกํฐ๋ฅผ ์ ์ญ๋ณ์๋ฅผ ์ ์ธํ๋ค๊ฐ ๊ณ์ ํ๋ ธ๋ค..
๋์ ํ ์ด๋๊ฐ ํ๋ ธ๋์ง ๋ชป์ฐพ๋ค๊ฐ ํน์๋ ํด์ ์ง์ญ๋ณ์๋ก ์ ์ธํ๋๋ ๋งํ๋ค.
๋ค์๋ถํฐ๋ ํ๋ผ๋ ๋๋ก ํ์.
'ํ๋ก๊ทธ๋๋จธ์ค > 3๋จ๊ณ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค Lv3] : ํฉ์น ํ์ ์๊ธ (0) | 2022.07.13 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค Lv3] : ๊ธ๊ณผ ์ ์ด๋ฐํ๊ธฐ (0) | 2022.07.11 |
[ํ๋ก๊ทธ๋๋จธ์ค Lv3] : ๋ถ๋ ์ฌ์ฉ์ (0) | 2022.07.07 |
[ํ๋ก๊ทธ๋๋จธ์ค Lv3] : ํ ํธ์ง (0) | 2022.07.07 |
[ํ๋ก๊ทธ๋๋จธ์ค Lv3] : [1์ฐจ] ์ ํ๋ฒ์ค (0) | 2022.07.06 |