[c++] ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค :: ๋‹จ์ฒด์‚ฌ์ง„์ฐ๊ธฐ (๋ฌธ์ œ ํ’€์ด, ์ฝ”๋“œ, ์นด์นด์˜ค ๋ณธ์„  ๋ฌธ์ œ)

๋‹จ์ฒด์‚ฌ์ง„ ์ฐ๊ธฐ

๋ฌธ์ œ

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 ์ดํ•˜์˜ ์ •์ˆ˜์˜ ๋ฌธ์žํ˜•์ด๋ฉฐ, ์กฐ๊ฑด์— ์ œ์‹œ๋˜๋Š” ๊ฐ„๊ฒฉ์„ ์˜๋ฏธํ•œ๋‹ค. ์ด๋•Œ ๊ฐ„๊ฒฉ์€ ๋‘ ํ”„๋ Œ์ฆˆ ์‚ฌ์ด์— ์žˆ๋Š” ๋‹ค๋ฅธ ํ”„๋ Œ์ฆˆ์˜ ์ˆ˜์ด๋‹ค.

์ถœ๋ ฅ ํ˜•์‹

๋ชจ๋“  ์กฐ๊ฑด์„ ๋งŒ์กฑํ•˜๋Š” ๊ฒฝ์šฐ์˜ ์ˆ˜๋ฅผ ๋ฆฌํ„ดํ•œ๋‹ค.

์˜ˆ์ œ ์ž…์ถœ๋ ฅ

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ํ˜•์œผ๋กœ ๋‹ค๋ฃจ๋Š” ์‹์œผ๋กœ ๋ฌธ์ œ๋ฅผ ๋ณ€ํ˜•ํ•œ ๋ถ„๋“ค์ด ๋งŽ์•˜๋‹ค.

๋ฐ˜์‘ํ˜•