1327๋ฒ: ์ํธ ๊ฒ์
ํ์ค์ด๋ ์ํธ ๊ฒ์์ ํ๋ ค๊ณ ํ๋ค. ์ํธ ๊ฒ์์ 1๋ถํฐ N๊น์ง ์ ์๋ก ์ด๋ฃจ์ด์ง N์๋ฆฌ์ ์์ด์ ์ด์ฉํ๋ค. ์ด ๊ฒ์์์ K๊ฐ ์ฃผ์ด์ง๋ค. ์ด๋ค ์๋ฅผ ๋ค์ง์ผ๋ฉด, ๊ทธ ์๋ถํฐ ์ค๋ฅธ์ชฝ์ผ๋ก K๊ฐ์ ์๋ฅผ ๋ค์ง
www.acmicpc.net
๋ฌธ์
ํ์ค์ด๋ ์ํธ ๊ฒ์์ ํ๋ ค๊ณ ํ๋ค. ์ํธ ๊ฒ์์ 1๋ถํฐ N๊น์ง ์ ์๋ก ์ด๋ฃจ์ด์ง N์๋ฆฌ์ ์์ด์ ์ด์ฉํ๋ค. ์ด ๊ฒ์์์ K๊ฐ ์ฃผ์ด์ง๋ค. ์ด๋ค ์๋ฅผ ๋ค์ง์ผ๋ฉด, ๊ทธ ์๋ถํฐ ์ค๋ฅธ์ชฝ์ผ๋ก K๊ฐ์ ์๋ฅผ ๋ค์ง์ด์ผ ํ๋ค. ์๋ฅผ ๋ค์ด, ์์ด์ด 5 4 3 2 1 ์ด์๊ณ , ์ฌ๊ธฐ์ K๊ฐ 3์ผ ๋, 4๋ฅผ ๋ค์ง์ผ๋ฉด 5 2 3 4 1์ด ๋๋ค. ๋ฐ๋์ K๊ฐ์ ์๋ฅผ ๋ค์ง์ด์ผํ๊ธฐ ๋๋ฌธ์, ์ฒ์ ์ํ์์ 2๋ 1์ ์ ํํ๋ ๊ฒ์ ๋ถ๊ฐ๋ฅํ๋ค.
์ ๋ ฅ์ผ๋ก ๋ค์ด์จ ์์ด์ ์ค๋ฆ์ฐจ์์ผ๋ก ๋ง๋ค๋ ค๊ณ ํ๋ค. ๊ฒ์์ ์ต๋ํ ๋นจ๋ฆฌ ๋๋ด๊ณ ์ถ์ ๋, ์๋ฅผ ์ต์ ๋ช ๊ฐ ์ ํํด์ผ ํ๋์ง ๊ตฌํด๋ณด์.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์์ด์ ํฌ๊ธฐ N๊ณผ K๊ฐ ์ฃผ์ด์ง๋ค. ๋์งธ ์ค์ ์์ด์ ๋ค์ด๊ฐ๋ ์๊ฐ ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ์ ๋ต์ ์ถ๋ ฅํ๋ค. ๋ง์ฝ ์ค๋ฆ์ฐจ์์ผ๋ก ๋ง๋ค ์ ์์ผ๋ฉด -1์ ์ถ๋ ฅํ๋ค.
์ ํ
- 2 ≤ K ≤ N ≤ 8

ํ์ด๊ณผ์
๋ฌธ์ ์์ ์๊ตฌํ๋ ๋ฐ๋ฅผ ์ด๋ป๊ฒ ๊ตฌํํ ์ง ๋ง๋งํ๋ ๋ฌธ์ ๋ ์ค๋๋ง์ด์๋ ๊ฑฐ ๊ฐ๋ค.
๋จธ๋ฆฌ๋ก๋ ์ดํด๊ฐ ๋์ง๋ง ์ด๋ป๊ฒ ์ฝ๋๋ฅผ ๊ตฌํํด์ผํ ์ง ๋ง๋งํ ๋ฌธ์ ์๋ค.
๊ทธ๋์ ์ฒ์์๋ "๋ฌธ์ ์ ์ ๊ทผ์ ํ ๋ ๊ท์น์ฑ์ด ์์๊น? ์๋๋ฉด ์ด๋ ํ ์กฐ๊ฑด์๋ ์ด๋ป๊ฒ ์ ํ์ ํด์ผํ๋?" ๋ฑ๋ฑ ์๊ฐ๋ค์ ํ๋ฉด์ ๋ค๋ฐฉ๋ฉด์ผ๋ก ๋ฌธ์ ์ ๋ํด์ ๊ณ ๋ฏผ์ ํด๋ดค์๋๋ฐ ๊ท์น์ฑ์ด ๋๋ ทํ๊ฒ ๋ณด์ด๋ ๊ท์น์ ๋ฐ๊ฒฌํ์ง ๋ชปํ์๋ค.
๊ทธ๋์ ๊ณ ๋ฏผ์ ํ๋ค๊ฐ ๋ฌธ์ ์ ๊ฑธ๋ ค์๋ ์ ํ ์กฐ๊ฑด์ด 2 ≤ K ≤ N ≤ 8 ํ์์ผ๋ก ์๊ฐ๋ณด๋ค ๋์ง์๋ค๋ ๊ฒ์ ํ์ธ ํ ์ ์์๊ณ ,
๊ทธ๋ฆฌ๋ํ์์ผ๋ก ๋๋ ค๋ณด์๋ผ๋ ์๊ฐ์ผ๋ก ํ์ด๋ฅผ ์งํํ์ฌ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ์์ต๋๋ค.
๊ธฐ๋ณธ ๋ก์ง์ ๊ฐ๋ ์ ๋ชจ๋ ๋ฐฉ๋ฒ์ ๋ค ๋์์ ๋ฌธ์ ์์ ์ํ๋ ์ค๋ฆ์ฐจ์์ผ๋ก ๋ง๋๋ ํ์์ ๋๊ฐ์ง๋ง
dp์ฒ๋ผ ์ด์ ์ ๊ฐ์์ ํ์ฌ์ ๊ฐ์ด ๋์๋ค๋ฉด count๋ฅผ 1 ์ฆ๊ฐ์์ผ์ ์ ์ฅํ๋ ๋ฐฉ์์ผ๋ก ๋ฌธ์ ๋ฅผ ์งํํ์ฌ ์ค๋ฆ์ฐจ์์ ๋ ฌ์ด ๋ ๋๊น์ง ๋ฌดํ์ด ๋ฐ๋ณตํ๊ณ ๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ๋ค ๋์์์๋ ์ค๋ฆ์ฐจ์ ์ ๋ ฌ์ด ๋์ง์์๋ค๋ฉด -1์ ์ถ๋ ฅ์ํค๊ณ ์ข ๋ฃํ๋ ๋ฐฉ์์ผ๋ก ํ์ด๋ฅผ ์งํํ์์ต๋๋ค.
code
#include <iostream>
#include <algorithm>
#include <string>
#include <queue>
#include <map>
int n, k;
int bfs(std::string s)
{
int cnt;
std::queue <std::pair<std::string, int> > que;
std::map <std::string, int> map;
std::string answer, current, temp;
for (int i = 1; i <= n; i++) {
answer += i + '0';
}
que.push(std::make_pair(s, 0));
while (!que.empty())
{
current = que.front().first;
cnt = que.front().second;
if (current == answer) return cnt;
for (int i = 0; i <= s.length() - k; i++) {
temp = current.substr(i, k);
std::reverse(temp.begin(), temp.end());
temp = current.substr(0, i) + temp + current.substr(i + k, s.length() - i - k);
if (map[temp] != true) {
map[temp] = true;
que.push(std::make_pair(temp, cnt + 1));
}
}
que.pop();
}
return (-1);
}
int main(void)
{
char c;
std::string s;
std::cin >> n >> k;
for (int i = 0; i < n; i++)
{
std::cin >> c;
s += c;
}
std::cout << bfs(s) << "\n";
return (0);
}
ํ๊ธฐ
๋ฌธ์ ๋ฅผ ์ด๋ป๊ฒ ์ ๊ทผ์ ํด์ผํ ์ง ๋ง๋งํ๋ ๋ฌธ์ ์๋ ๊ฑฐ ๊ฐ๋ค.
๋ฌธ์ ๋ฅผ ๋ค ํด๊ฒฐํ๊ณ ๋ฐ๋ผ๋ณด๋ ๋ก์ง ์์ฒด๋ ๋ณต์กํ์ง๋ ์์ง๋ง ๊ทธ ๊ณผ์ ์ด ํ๋ค์๋ ๋ฌธ์ ์๋ค.
'Algorithm > ๋ฌธ์ ํ์ด' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฐฑ์ค] 2294๋ฒ - ๋์ 2 (C++) (0) | 2023.08.26 |
---|---|
[๋ฐฑ์ค] 2293๋ฒ - ๋์ 1 (C++) (0) | 2023.08.26 |
[๋ฐฑ์ค] 14916๋ฒ - ๊ฑฐ์ค๋ฆ๋ (C++) (0) | 2023.08.24 |
[๋ฐฑ์ค] 1043๋ฒ - ๊ฑฐ์ง๋ง (C++) (0) | 2023.08.22 |
[๋ฐฑ์ค] 11286๋ฒ - ์ ๋๊ฐ ํ (C++) (0) | 2023.08.21 |