24-Seol-Munhyeok

[Seol-Munhyeok]

🔗 문제 링크

수식 최대화
https://school.programmers.co.kr/learn/courses/30/lessons/67257

✔️ 소요된 시간

35분

✨ 수도 코드

연산자 별 우선 순위를 permutations를 통해서 모든 순열을 구하고 그 순서에 따라서 실제로 계산을 수행해서 최대값을 찾으면 되는 문제입니다.

문자열로 된 수식을 어떻게 계산할지는 다양한 방법이 있을 거 같은데 저는 스택을 사용했습니다.
수도코드로 나타내면 다음과 같습니다.

피연산자와 연산자를 따로 분리해서 token 배열에 담는다.
연산자 종류(+ - *)의 모든 순열에 대해:
    현재 처리할 연산자를 정한다:
        토큰 리스트를 왼쪽부터 스캔하면서:
            만약 현재 토큰이 “지금 처리할 연산자”라면:
                stack에서 맨 위 피연산자 꺼내고, 다음 숫자랑 계산해서 결과를 다시 push.
            그 외 연산자이거나, 피연산자(숫자)라면:
                그냥 stack에 push.

📚 새롭게 알게된 내용

파이썬은 eval() 이라는 문자열로 된 수식을 바로 계산할 수 있는 함수가 있어서 직접 우선순위에 맞춰 괄호를 주입하고 eval()로 계산하는 날먹이 가능합니다.

def solution(expression):
    operations = [('+', '-', '*'),('+', '*', '-'),('-', '+', '*'),('-', '*', '+'),('*', '+', '-'),('*', '-', '+')]
    answer = []
    for op in operations:
        a = op[0]
        b = op[1]
        temp_list = []
        for e in expression.split(a):
            temp = [f"({i})" for i in e.split(b)]
            temp_list.append(f'({b.join(temp)})')
        answer.append(abs(eval(a.join(temp_list))))
    return max(answer)

그런데 도저히 실전에서는 못 떠올릴 풀이같습니다... 일단 eval() 이라는 함수가 있다는 것만 기억하면 좋을 거 같습니다.

참고로 실무에서는 eval() 함수는 보안 문제로 쓰지 않는다고 합니다.

[hyeokbini]

간단해 보이는데 손이 꽤나 가는 문제였네요... 저도 풀이하는 큰 골자는 문혁님과 비슷했습니다. 연산자 우선순위를 간단히 재귀함수로 뽑아 준 다음, 해당 우선순위에 대해 계산된 값을 이용해 answer를 갱신해나가는 방식입니다.

다만 스택을 사용해서 실제 연산을 하는 부분에서 약간 비효율적인 부분이었나..? 싶은 부분이 한 연산자에 대해 연산을 끝낸 후, 임시 벡터를 이용해 다음 연산자를 위한 세팅을 해주는 부분이 있는데 생각한 걸 전부 구현해보니 reverse랑 while(!empty)가 너무 많이 사용되더라구요. 시간 초과를 감수하고 제출했는데, 일단 정답을 받긴 했습니다. 나중에 더 최적화할 수 있는 부분이 있는지, 깔끔한 로직이 있는지 고민해봐야할 것 같습니다.

또 하나 느낀 점은 next_permutation에 대해서 각 잡고 공부하는 시간을 가져봐야겠다고 느꼈습니다. 코딩테스트에서 순열 / 조합론 문제가 꽤나 자주 등장하는 것 같은데, 그때마다 재귀로 짜긴 하지만 여간 번거로운 게 아니더라구요. 큰 틀 4가지(조합 / 순열 / 중복조합 / 중복순열)에 대해서만이라도 함수로 짜는 법을 미리 연습해 둬야겠습니다.

제출 코드입니다. 고생하셨어요!

수식 최대화 / c++

#include <bits/stdc++.h>

using namespace std;

long long calc(long long a, long long b, char op)
{
    if (op == '+') return a + b;
    if (op == '-') return a - b;
    return a * b;
}

// 계산
long long evaluate(vector<long long> nums, vector<char> ops, vector<char> priority)
{
    for (char p : priority)
    {
        stack<long long> stnum;
        stack<char> stop;

        stnum.push(nums[0]);

        for (int i = 0; i < ops.size(); i++)
        {
            if (ops[i] == p)
            {
                long long a = stnum.top();
                stnum.pop();

                long long b = nums[i + 1];
                stnum.push(calc(a, b, ops[i]));
            }
            else
            {
                stnum.push(nums[i + 1]);
                stop.push(ops[i]);
            }
        }

        // 다음 연산을 위해 초기화하기
        nums.clear();
        ops.clear();

        vector<long long> tempnum;
        vector<char> tempop;

        while (!stnum.empty())
        {
            tempnum.push_back(stnum.top());
            stnum.pop();
        }
        reverse(tempnum.begin(), tempnum.end());

        while (!stop.empty())
        {
            tempop.push_back(stop.top());
            stop.pop();
        }
        reverse(tempop.begin(), tempop.end());

        nums = tempnum;
        ops = tempop;
    }
    return nums[0];
}

vector<char> operators = {'+', '-', '*'};
vector<bool> used(3,false);
long long answer = 0;
vector<char> cur;

// 연산자 순열
void permute(vector<long long>& nums, vector<char>& ops)
{
    if (cur.size() == 3)
    {
        long long res = evaluate(nums, ops, cur);
        answer = max(answer, abs(res));
        return;
    }

    for (int i = 0; i < 3; i++)
    {
        if (!used[i])
        {
            used[i] = true;
            cur.push_back(operators[i]);

            permute(nums, ops);

            cur.pop_back();
            used[i] = false;
        }
    }
}

long long solution(string expression)
{
    vector<long long> nums;
    vector<char> ops;
    string num = "";

    // 숫자/연산자 분리
    for (char c : expression)
    {
        if (isdigit(c))
        {
            num += c;
        }
        else
        {
            nums.push_back(stoll(num));
            num = "";
            ops.push_back(c);
        }
    }
    nums.push_back(stoll(num));

    permute(nums, ops);
    return answer;
}

[mj010504]

0이 가능하다는 것과 long long 타입인 것을 놓쳐서 삽질을 오래했네요. int로는 부족할 수 있다는 것을 항상 명심해야겠습니다.
전 처음에 숫자와 문자 분리하고 c++ next_permutation 함수를 통해 연산자 순열을 만들어서 활용했습니다. 스택을 사용해도 될 것 같긴한데 간단해서 그냥 반복문을 사용하고 배열에서 값을 제거해주고 새로운 값을 대입해주어서 풀이했습니다. 좋은 방법은 아닌 것 같습니다.
수고하셨습니다!!

수식 최대화

#include<bits/stdc++.h>

using namespace std;

long long calc(long long a, long long b, char c) {
    if(c == '*') return a * b;
    if(c == '+') return a + b;
    if(c == '-') return a - b;
}

long long solution(string str) {
    long long res = 0;
    vector<long long> nv; // 숫자
    vector<char> cv;
    set<char> cs; // 연산 기호 집합

     long long num = 0;
    for(int i = 0; i < str.size(); i++) {
        if(str[i] >= '0' && str[i] <= '9') {
             if(num == 0 && str[i] == '0') {
                 nv.push_back(0);
                 continue;
             }
            else num = num * 10 + (str[i] - '0');
        }
        else {
            if(num > 0) {
                nv.push_back(num);
                num = 0;
            }

            if(str[i] == '*' || str[i] == '-' || str[i] == '+') {
                cs.insert(str[i]);
                cv.push_back(str[i]);
            }
        }
    }

    nv.push_back(num);

    vector<char> tv;
    for(auto c : cs) {
        tv.push_back(c);
    }


   do {
    auto tnv = nv;
    auto tcv = cv;

    for(int i = 0; i < tv.size(); i++) {
        char c = tv[i];
        int f = tcv.size();
        for(int j = 0; j < f; j++) {
            if(tcv[j] == c) {
                long long tn = calc(tnv[j], tnv[j + 1], c);
                tnv[j] = tn;
                tnv.erase(tnv.begin() + j + 1);
                tcv.erase(tcv.begin() + j);
                f--;
                j--;
            }
        }
        
     
    }
   
    
    res = max(res, abs(tnv[0]));

   
   } while(next_permutation(tv.begin(), tv.end()));    // 연산자 우선순위 정하기

 
    return res;
}