๋จ์ฒด์ฌ์ง ์ฐ๊ธฐ
๋ฌธ์
https://programmers.co.kr/learn/courses/30/lessons/1835
๋ฌธ์ ์ค๋ช
๊ฐ์์ ๋ง์ ์นด์นด์คํ๋ ์ฆ๋ ๋จ์ฒด๋ก ์ํ์ ๋ ๋ฌ๋ค. ์ฆ๊ฑฐ์ด ์๊ฐ์ ๋ณด๋ด๊ณ ๋ง์ง๋ง์ ๋จ์ฒด์ฌ์ง์ ์ฐ๊ธฐ ์ํด ์นด๋ฉ๋ผ ์์ ์ผ๋ ฌ๋ก ๋๋ํ ์ฐ๋ค. ๊ทธ๋ฐ๋ฐ ๊ฐ์๊ฐ ์ํ๋ ๋ฐฐ์น๊ฐ ๋ชจ๋ ๋ฌ๋ผ ์ด๋ค ์์๋ก ์ค์ง ์ ํ๋๋ฐ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ ธ๋ค. ๋ค์ค๋ ํ๋ก๋์ ๋๋ํ ์๊ธฐ๋ฅผ ์ํ๊ณ , ํ๋ธ๊ฐ ๋ฟ์ ๋ถ์ ๋ง์ ์ ์ด ์๋ ๋ผ์ด์ธ์ ํ๋ธ์๊ฒ์ ์ ์ด๋ ์ธ ์นธ ์ด์ ๋จ์ด์ ธ์ ์๊ธฐ๋ฅผ ์ํ๋ค. ์ฌ์ง์ ์ฐ๊ณ ๋์ ๋์์ค๋ ๊ธธ์, ๋ฌด์ง๋ ๋ชจ๋๊ฐ ์ํ๋ ์กฐ๊ฑด์ ๋ง์กฑํ๋ฉด์๋ ๋ค๋ฅด๊ฒ ์๋ ๋ฐฉ๋ฒ์ด ์์ง ์์์๊น ์๊ฐํด๋ณด๊ฒ ๋์๋ค. ๊ฐ ํ๋ ์ฆ๊ฐ ์ํ๋ ์กฐ๊ฑด์ ์ ๋ ฅ์ผ๋ก ๋ฐ์์ ๋ ๋ชจ๋ ์กฐ๊ฑด์ ๋ง์กฑํ ์ ์๋๋ก ์๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ณ์ฐํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
์ ๋ ฅ ํ์
์
๋ ฅ์ ์กฐ๊ฑด์ ๊ฐ์๋ฅผ ๋ํ๋ด๋ ์ ์ n
๊ณผ n
๊ฐ์ ์์๋ก ๊ตฌ์ฑ๋ ๋ฌธ์์ด ๋ฐฐ์ด data
๋ก ์ฃผ์ด์ง๋ค. data
์ ์์๋ ๊ฐ ํ๋ ์ฆ๊ฐ ์ํ๋ ์กฐ๊ฑด์ด N~F=0
๊ณผ ๊ฐ์ ํํ์ ๋ฌธ์์ด๋ก ๊ตฌ์ฑ๋์ด ์๋ค. ์ ํ์กฐ๊ฑด์ ์๋์ ๊ฐ๋ค.
-
1 <= n <= 100
-
data ์ ์์๋ ๋ค์ฏ ๊ธ์๋ก ๊ตฌ์ฑ๋ ๋ฌธ์์ด์ด๋ค. ๊ฐ ์์์ ์กฐ๊ฑด์ ๋ค์๊ณผ ๊ฐ๋ค.
- ์ฒซ ๋ฒ์งธ ๊ธ์์ ์ธ ๋ฒ์งธ ๊ธ์๋ ๋ค์ 8๊ฐ ์ค ํ๋์ด๋ค.
{A, C, F, J, M, N, R, T}
๊ฐ๊ฐ ์ดํผ์น, ์ฝ, ํ๋ก๋, ์ ์ด์ง, ๋ฌด์ง, ๋ค์ค, ๋ผ์ด์ธ, ํ๋ธ๋ฅผ ์๋ฏธํ๋ค. ์ฒซ ๋ฒ์งธ ๊ธ์๋ ์กฐ๊ฑด์ ์ ์ํ ํ๋ ์ฆ, ์ธ ๋ฒ์งธ ๊ธ์๋ ์๋๋ฐฉ์ด๋ค. ์ฒซ ๋ฒ์งธ ๊ธ์์ ์ธ ๋ฒ์งธ ๊ธ์๋ ํญ์ ๋ค๋ฅด๋ค. - ๋ ๋ฒ์งธ ๊ธ์๋ ํญ์
~
์ด๋ค. - ๋ค ๋ฒ์งธ ๊ธ์๋ ๋ค์ 3๊ฐ ์ค ํ๋์ด๋ค.
{=, <, >}
๊ฐ๊ฐ ๊ฐ์, ๋ฏธ๋ง, ์ด๊ณผ๋ฅผ ์๋ฏธํ๋ค. - ๋ค์ฏ ๋ฒ์งธ ๊ธ์๋
0
์ด์6
์ดํ์ ์ ์์ ๋ฌธ์ํ์ด๋ฉฐ, ์กฐ๊ฑด์ ์ ์๋๋ ๊ฐ๊ฒฉ์ ์๋ฏธํ๋ค. ์ด๋ ๊ฐ๊ฒฉ์ ๋ ํ๋ ์ฆ ์ฌ์ด์ ์๋ ๋ค๋ฅธ ํ๋ ์ฆ์ ์์ด๋ค.
- ์ฒซ ๋ฒ์งธ ๊ธ์์ ์ธ ๋ฒ์งธ ๊ธ์๋ ๋ค์ 8๊ฐ ์ค ํ๋์ด๋ค.
์ถ๋ ฅ ํ์
๋ชจ๋ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ฆฌํดํ๋ค.
์์ ์ ์ถ๋ ฅ
n | data | answer |
---|---|---|
2 | [N~F=0,R~T>2] | 3648 |
2 | [M~C<2,C~M>1] | 0 |
์์ ์ ๋ํ ์ค๋ช
์ฒซ ๋ฒ์งธ ์์ ๋ ๋ฌธ์ ์ ์ค๋ช ๋ ๋ฐ์ ๊ฐ์ด, ๋ค์ค๋ ํ๋ก๋์์ ๊ฐ๊ฒฉ์ด 0์ด๊ธฐ๋ฅผ ์ํ๊ณ ๋ผ์ด์ธ์ ํ๋ธ์์ ๊ฐ๊ฒฉ์ด 2๋ณด๋ค ํฌ๊ธฐ๋ฅผ ์ํ๋ ์ํฉ์ด๋ค.
๋ ๋ฒ์งธ ์์ ๋ ๋ฌด์ง๊ฐ ์ฝ๊ณผ์ ๊ฐ๊ฒฉ์ด 2๋ณด๋ค ์๊ธฐ๋ฅผ ์ํ๊ณ , ๋ฐ๋๋ก ์ฝ์ ๋ฌด์ง์์ ๊ฐ๊ฒฉ์ด 1๋ณด๋ค ํฌ๊ธฐ๋ฅผ ์ํ๋ ์ํฉ์ด๋ค. ์ด๋ ๋์์ ๋ง์กฑํ ์ ์๋ ์กฐ๊ฑด์ด๋ฏ๋ก ๊ฒฝ์ฐ์ ์๋ 0์ด๋ค.
์ฝ๋
#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
bool testCase(string arr, string data) {
char a = data[0];
char b = data[2];
char c = data[3];
int d = atoi(&data[4]);
int a_idx; int b_idx;
for (int i = 0; i<8; i++) {
if (arr[i] == a) {
a_idx = i;
continue;
}
if (arr[i] == b)
b_idx = i;
}
int dist = abs(a_idx - b_idx);
switch (c) {
case '=':
if (dist!=d+1)
return false;
break;
case '<':
if (dist>=(d+1))
return false;
break;
case '>':
if (dist<=(d+1))
return false;
break;
}
return true;
}
int setCase(string arr, int num, vector<string>& data) {
do {
int flag = 0;
for (int i = 0; i < data.size(); i++) {
if (!testCase(arr, data[i])) { // ๊ฑฐ์ง
flag = 1;
break;
}
}
if (flag) // ๊ฑฐ์ง์ด๋ฉด ๋ค์๊บผ
continue;
else // ์ ํฉํ๋ฉด num+1
num++;
} while (next_permutation(&arr[0], &arr[8]));
return num;
}
// ์ ์ญ ๋ณ์๋ฅผ ์ ์ํ ๊ฒฝ์ฐ ํจ์ ๋ด์ ์ด๊ธฐํ ์ฝ๋๋ฅผ ๊ผญ ์์ฑํด์ฃผ์ธ์.
int solution(int n, vector<string> data) {
int answer = 0;
string arr = "ACFJMNRT";
vector<vector<char>> line;
answer = setCase(arr, 0, data); // 8! = 40320
return answer;
}
ํ์ด
๋ฌธ์ ์์ ํญ์ 8๋ช ์ด ์ค์ ์๋ ๊ฒ์ผ๋ก ๊ฐ์ ํ๊ธฐ ๋๋ฌธ์, ์ค์ ์๋ ๊ฒฝ์ฐ์ ์๋ 8!์ธ 40320์ด๋ค. data(์กฐ๊ฑด)๋ ์ต๋ 100๊ฐ ๋ค์ด์จ๋ค๊ณ ํ๊ธฐ ๋๋ฌธ์, ๊ฐ ๊ฒฝ์ฐ์ ์ ๋น data๋ฅผ ๋ค ๊ฒ์ฌํด๋ 4032000(<10^6) ์ ์๊ฐ๋ณต์ก๋ ๋ฐ์ ๋ค์ง ์๋๋ค.
๋ฐ๋ผ์, ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ next_permutation ํจ์๋ก ์ดํด๋ณด๋ฉด์ ๋์์ data์ ์ ํฉํ์ง ์ดํด๋ณด๋ ๋ฐฉ๋ฒ์ ํํ์๋ค. ์ฒ์์๋ next_permutation์ผ๋ก ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ฐ๋ก ์ ์ฅํ ํ, data๋ฅผ ์ฒดํฌํด๋ณด๋ ค๊ณ ํ์ง๋ง ์๊ฐ์ด ๋๋ฌด ์ค๋๊ฑธ๋ ธ๋ค. ์ฌ์ค ๋ฌธ์ ์์๋ ๊ฒฝ์ฐ๋ฅผ ๋ชจ๋ ๊ตฌํ๋ ๊ฒ์ด ์๋๋ผ ๊ฒฝ์ฐ์ ์๋ง์ ์๊ตฌํ๊ณ ์์ผ๋ฏ๋ก, string์ ์ง์ ๋ฃ๊ธฐ๋ณด๋ค ์กฐ๊ฑด์ ๋ง๋ ๋ฐ์ดํฐ๊ฐ ์กด์ฌํ๋ฉด ์ซ์๋ฅผ ํ๋์ฉ ์ฌ๋ฆฌ๋ ์์ผ๋ก ๊ตฌ์ฑํ๋ค.
์ฑ์ ๊ฒฐ๊ณผ
๊ต์ฅํ ์ค๋ ๊ฑธ๋ฆฐ๋ค.
๋ค๋ฅธ ์ฌ๋์ ํ์ด
string์ผ๋ก ๋ค๋ฃจ๊ธฐ ์ด๋ ค์์ ๊ทธ๋ฅ index๋ก ๋ฐ๊พธ์ด์ intํ์ผ๋ก ๋ค๋ฃจ๋ ์์ผ๋ก ๋ฌธ์ ๋ฅผ ๋ณํํ ๋ถ๋ค์ด ๋ง์๋ค.
Comment