728x90

문제 설명

ROR 게임은 두 팀으로 나누어서 진행하며, 상대 팀 진영을 먼저 파괴하면 이기는 게임입니다. 따라서, 각 팀은 상대 팀 진영에 최대한 빨리 도착하는 것이 유리합니다.

지금부터 당신은 한 팀의 팀원이 되어 게임을 진행하려고 합니다. 다음은 5 x 5 크기의 맵에, 당신의 캐릭터가 (행: 1, 열: 1) 위치에 있고, 상대 팀 진영은 (행: 5, 열: 5) 위치에 있는 경우의 예시입니다.

위 그림에서 검은색 부분은 벽으로 막혀있어 갈 수 없는 길이며, 흰색 부분은 갈 수 있는 길입니다. 캐릭터가 움직일 때는 동, 서, 남, 북 방향으로 한 칸씩 이동하며, 게임 맵을 벗어난 길은 갈 수 없습니다.
아래 예시는 캐릭터가 상대 팀 진영으로 가는 두 가지 방법을 나타내고 있습니다.

  • 첫 번째 방법은 11개의 칸을 지나서 상대 팀 진영에 도착했습니다.

  • 두 번째 방법은 15개의 칸을 지나서 상대팀 진영에 도착했습니다.

위 예시에서는 첫 번째 방법보다 더 빠르게 상대팀 진영에 도착하는 방법은 없으므로, 이 방법이 상대 팀 진영으로 가는 가장 빠른 방법입니다.

만약, 상대 팀이 자신의 팀 진영 주위에 벽을 세워두었다면 상대 팀 진영에 도착하지 못할 수도 있습니다. 예를 들어, 다음과 같은 경우에 당신의 캐릭터는 상대 팀 진영에 도착할 수 없습니다.

게임 맵의 상태 maps가 매개변수로 주어질 때, 캐릭터가 상대 팀 진영에 도착하기 위해서 지나가야 하는 칸의 개수의 최솟값을 return 하도록 solution 함수를 완성해주세요. 단, 상대 팀 진영에 도착할 수 없을 때는 -1을 return 해주세요.

제한사항

  • maps는 n x m 크기의 게임 맵의 상태가 들어있는 2차원 배열로, n과 m은 각각 1 이상 100 이하의 자연수입니다.
    • n과 m은 서로 같을 수도, 다를 수도 있지만, n과 m이 모두 1인 경우는 입력으로 주어지지 않습니다.
  • maps는 0과 1로만 이루어져 있으며, 0은 벽이 있는 자리, 1은 벽이 없는 자리를 나타냅니다.
  • 처음에 캐릭터는 게임 맵의 좌측 상단인 (1, 1) 위치에 있으며, 상대방 진영은 게임 맵의 우측 하단인 (n, m) 위치에 있습니다.

입출력

maps answer
[[1,0,1,1,1],[1,0,1,0,1],[1,0,1,1,1],[1,1,1,0,1],[0,0,0,0,1]] 11
[[1,0,1,1,1],[1,0,1,0,1],[1,0,1,1,1],[1,1,1,0,0],[0,0,0,0,1]] -1

문제 풀이

기본적인 완전탐색 문제.

bfs를 이용하여 해결


소스 코드

#include<vector>
#include <queue>
struct pos{
    int y; int x;
};
int dy[] = {1, -1, 0, 0};
int dx[] = {0, 0, 1, -1};
int check[100][100];
using namespace std;
void bfs(int y, int x, vector<vector<int>> maps, int n, int m)
{
    queue<pos> q;
    q.push({y,x});
    check[y][x] = 1;
    while(!q.empty())
    {
        int y = q.front().y;
        int x = q.front().x;
        q.pop();
        for(int i=0;i<4;i++)
        {
            int ny = y + dy[i];
            int nx = x + dx[i];
            if(ny >=0 && nx >=0 && ny < n && nx < m)
            {
                if(!check[ny][nx] && maps[ny][nx])
                {
                    q.push({ny,nx});
                    check[ny][nx] = check[y][x]+1;
                }
            }
        }   
    }
}
int solution(vector<vector<int> > maps)
{
    int answer = 0;
    int n = maps.size();
    int m = maps[0].size();
    bfs(0,0, maps, n,m);
    if(check[n-1][m-1] ==0)
        answer = -1;
    else
        answer = check[n-1][m-1];
    return answer;
}
LIST
728x90

문제 설명

조이스틱으로 알파벳 이름을 완성하세요. 맨 처음엔 A로만 이루어져 있습니다.
ex) 완성해야 하는 이름이 세 글자면 AAA, 네 글자면 AAAA

조이스틱을 각 방향으로 움직이면 아래와 같습니다.

▲ - 다음 알파벳

▼ - 이전 알파벳 (A에서 아래쪽으로 이동하면 Z로)

◀ - 커서를 왼쪽으로 이동 (첫 번째 위치에서 왼쪽으로 이동하면 마지막 문자에 커서)

▶ - 커서를 오른쪽으로 이동

예를 들어 아래의 방법으로 "JAZ"를 만들 수 있습니다.

- 첫 번째 위치에서 조이스틱을 위로 9번 조작하여 J를 완성합니다. - 조이스틱을 왼쪽으로 1번 조작하여 커서를 마지막 문자 위치로 이동시킵니다. - 마지막 위치에서 조이스틱을 아래로 1번 조작하여 Z를 완성합니다. 따라서 11번 이동시켜 "JAZ"를 만들 수 있고, 이때가 최소 이동입니다.

만들고자 하는 이름 name이 매개변수로 주어질 때, 이름에 대해 조이스틱 조작 횟수의 최솟값을 return 하도록 solution 함수를 만드세요.

 

제한 사항

  • name은 알파벳 대문자로만 이루어져 있습니다.
  • name의 길이는 1 이상 20 이하입니다.

입출력

name return
"JEROEN" 56
"JAN" 23

문제 풀이

이 문제는 커서를 왼쪽으로 움직일지 오른쪽으로 움직일지 그때그때 상황에 맞게 움직여야 하기때문에 그리디 문제입니다.

현재 위치에서 오른쪽?왼쪽을 정하는 방법은 target 문자열과 name을 비교하여 다른 문자열이 나오는 크기를 비교해주며

진행하였습니다.


소스 코드

#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

int solution(string name) {
    int answer = 0;
    string target(name.size(), 'A');
    if(name == target) return answer;
    int cur_idx = 0;
    while(true)
    {
        answer +=min(name[cur_idx] - 'A', 'Z'-name[cur_idx] + 1);
        target[cur_idx] = name[cur_idx];
        
        if(target == name) break;
        
        int left_idx=cur_idx;
        int left_cnt =0;
        while(target[left_idx] == name[left_idx])
        {
            left_idx--;
            left_cnt ++;
            
            if(left_idx ==-1)
            {
                left_idx = name.size()-1;
            }
        }
        
        int right_idx = cur_idx;
        int right_cnt=0;
        while(target[right_idx] == name[right_idx])
        {
            right_idx++;
            right_cnt++;
            if(right_idx == name.size())
            {
                right_idx = 0;
            }
        }
        if(left_cnt < right_cnt)
        {
            cur_idx = left_idx;
            answer += left_cnt;
        }
        else
        {
            cur_idx = right_idx;
            answer += right_cnt;
        }
    }
    return answer;
}
LIST
728x90

문제 설명

한자리 숫자가 적힌 종이 조각이 흩어져있습니다. 흩어진 종이 조각을 붙여 소수를 몇 개 만들 수 있는지 알아내려 합니다.

각 종이 조각에 적힌 숫자가 적힌 문자열 numbers가 주어졌을 때, 종이 조각으로 만들 수 있는 소수가 몇 개인지 return 하도록 solution 함수를 완성해주세요.

 

제한사항

  • numbers는 길이 1 이상 7 이하인 문자열입니다.
  • numbers는 0~9까지 숫자만으로 이루어져 있습니다.
  • "013"은 0, 1, 3 숫자가 적힌 종이 조각이 흩어져있다는 의미입니다.

입출력

numbers return
"17" 3
"011" 2

문제 풀이

1. 문자열이 주어졌을때 문자열을 조합해서 만들수 있는 모든 문자열을 만든다.

2. 만들어진 문자열이 소수인지 아닌지 확인한다.

 


소스 코드

 

#include <vector>
#include <string>
#include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
bool selected[7];
vector<char> v;
vector<char> v2;
vector<int> list;
int ans;
bool isPrime(int tmp)
{
    if(tmp == 1 || tmp == 0)
        return false;
    int num = (int)sqrt(tmp);
    for(int i=2;i<=num;i++)
    {
        if(tmp%i ==0)
            return false;
    }
    return true;
}
void dfs(int cnt, int depth)
{
    if(cnt == depth)
    {
        string tmp ="";
        for(auto a : v2)
            tmp += a;
        if(find(list.begin(), list.end(), stoi(tmp)) == list.end())
        {
            list.push_back(stoi(tmp));
            if(isPrime(stoi(tmp)))
                ans++;
        }
        return;
    }
    for(int i=0;i<v.size();i++)
    {
        if(selected[i])continue;
        selected[i] = true;
        v2.push_back(v[i]);
        dfs(cnt, depth+1);
        v2.pop_back();
        selected[i] =false;
    }
}
int solution(string s)
{
    ans = 0;
    for(int i=0;i<s.size();i++)
    {
        v.push_back(s[i]);
    }
    for(int i=1;i<s.size()+1;i++)
    {
        dfs(i,0);
    }
    return ans;
}
LIST
728x90

문제 설명

0 또는 양의 정수가 주어졌을 때, 정수를 이어 붙여 만들 수 있는 가장 큰 수를 알아내 주세요.

예를 들어, 주어진 정수가 [6, 10, 2]라면 [6102, 6210, 1062, 1026, 2610, 2106]를 만들 수 있고, 이중 가장 큰 수는 6210입니다.

0 또는 양의 정수가 담긴 배열 numbers가 매개변수로 주어질 때, 순서를 재배치하여 만들 수 있는 가장 큰 수를 문자열로 바꾸어 return 하도록 solution 함수를 작성해주세요.

제한 사항

  • numbers의 길이는 1 이상 100,000 이하입니다.
  • numbers의 원소는 0 이상 1,000 이하입니다.
  • 정답이 너무 클 수 있으니 문자열로 바꾸어 return 합니다.

입출력

numbers return
[6, 10, 2] "6210"
[3, 30, 34, 5, 9] "9534330"

문제 풀이

문자열을 정렬하는 문제이다.

sort() 함수를 이용해 비교함수를 따로 구현하였다.

문자열은 정렬은 기본적으로 아스키코드 값이 작을 수록, 길이가 짧을 수록 이라는 특징을 가지고 있다

이 문제에서는 두개의 string을 앞뒤로 붙였을때 큰 값이 먼저 와야하기 때문에

bool compare(string a, string b)

{

    return a+b > b+a;

}

다음과 같은 방법을 이용하였다.

 


소스 코드

#include <vector>
#include <string>
#include <algorithm>
#include <iostream>
using namespace std;
bool compare(string a, string b)
{
    return a+b > b+a;
}
string solution(vector<int> numbers)
{
    string ans = "";
    vector<string> nums;
    for(int i=0;i<numbers.size();i++)
    {
        nums.push_back(to_string(numbers[i]));
    }
    sort(nums.begin(), nums.end(), compare);

    if(nums[0] == "0")
        return "0";
    for(int i=0;i<nums.size();i++)
    {
        ans += nums[i];
    }
   
    return ans;
}
LIST
728x90

문제 설명

일반적인 프린터는 인쇄 요청이 들어온 순서대로 인쇄합니다. 그렇기 때문에 중요한 문서가 나중에 인쇄될 수 있습니다. 이런 문제를 보완하기 위해 중요도가 높은 문서를 먼저 인쇄하는 프린터를 개발했습니다. 이 새롭게 개발한 프린터는 아래와 같은 방식으로 인쇄 작업을 수행합니다.

1. 인쇄 대기목록의 가장 앞에 있는 문서(J)를 대기목록에서 꺼냅니다. 2. 나머지 인쇄 대기목록에서 J보다 중요도가 높은 문서가 한 개라도 존재하면 J를 대기목록의 가장 마지막에 넣습니다. 3. 그렇지 않으면 J를 인쇄합니다.

예를 들어, 4개의 문서(A, B, C, D)가 순서대로 인쇄 대기목록에 있고 중요도가 2 1 3 2 라면 C D A B 순으로 인쇄하게 됩니다.

내가 인쇄를 요청한 문서가 몇 번째로 인쇄되는지 알고 싶습니다. 위의 예에서 C는 1번째로, A는 3번째로 인쇄됩니다.

현재 대기목록에 있는 문서의 중요도가 순서대로 담긴 배열 priorities와 내가 인쇄를 요청한 문서가 현재 대기목록의 어떤 위치에 있는지를 알려주는 location이 매개변수로 주어질 때, 내가 인쇄를 요청한 문서가 몇 번째로 인쇄되는지 return 하도록 solution 함수를 작성해주세요.

제한사항

  • 현재 대기목록에는 1개 이상 100개 이하의 문서가 있습니다.
  • 인쇄 작업의 중요도는 1~9로 표현하며 숫자가 클수록 중요하다는 뜻입니다.
  • location은 0 이상 (현재 대기목록에 있는 작업 수 - 1) 이하의 값을 가지며 대기목록의 가장 앞에 있으면 0, 두 번째에 있으면 1로 표현합니다.

입출력

priorities location return
[2, 1, 3, 2] 2 1
[1, 1, 9, 1, 1, 1] 0 5

문제 풀이

1. queue를 이용한 해결

코드에서 priority_queue<int> pq의 경우에는 내림차순 정렬이 default 이다

오름차순으로 정렬하고 싶은 경우에는 priority_queue<int, vector<int> greater<int>> pq; 라고 선언하여 사용 가능하다. 문제에서는 큰값부터 출력해야되므로 내림차순 pq를 사용하였다.

 

 

2. vector만을 이용한 해결

vector만을 이용했을 경우에도 vector를 queue 처럼 사용하였다.

다만 첫 값을 제외했을때 백터에서 그것보다 큰 값이 없을경우를 확인하는 flag2를 만들어서

flag2가 true인 경우 result 값을 증가하는 방법으로 코딩을 해 보았다.

 

1번과 2번 풀이를 비교했을때 큐를 이용해서 해결하는 편이 훨씬 깔끔해보인다.


소스 코드

#include <string>
#include <vector>
#include <queue>
using namespace std;
int solution(vector<int> priorities, int location) {
    int answer = 0;
    queue<pair<int,int>> q;
    priority_queue<int> pq;
    for(int i=0;i<priorities.size();i++)
    {
        q.push({i,priorities[i]});
        pq.push(priorities[i]);
    }
   while(!q.empty())
   {
       int idx = q.front().first;
       int value = q.front().second;
       q.pop();
       
       if(value == pq.top())
       {
           pq.pop();
           answer++;
           
           if(idx == location)
           break;
       }
       else
       {
           q.push({idx, value});
       }
       
   }
    return answer;
}
#include <vector>
#include <algorithm>
using namespace std;
int print(vector<pair<int,int>>& p)
{
    int result = 0;
    bool flag = true;
    while(flag)
    {
        pair<int,int> value = p.front();
        p.erase(p.begin() + 0);
        bool flag2 = true;
        for(int i=0;i<p.size();i++)
        {
            if(p[i].first > value.first)
            {
                p.push_back(value);
                flag2 = false;
                break;
            }
        }
        if(flag2)
        {
            result = value.second;
            break;
        }
    }
    return result;
}
int solution(vector<int> p, int location)
{
    int result = 1;
    vector<pair<int,int>> printer;
    for(int i=0;i<p.size();i++)
    {
        printer.push_back({p[i], i});
    }
    while(location != print(printer))
    {
        result++;
    }
    return result;
}
LIST
728x90

문제 설명

전화번호부에 적힌 전화번호 중, 한 번호가 다른 번호의 접두어인 경우가 있는지 확인하려 합니다.
전화번호가 다음과 같을 경우, 구조대 전화번호는 영석이의 전화번호의 접두사입니다.

  • 구조대 : 119
  • 박준영 : 97 674 223
  • 지영석 : 11 9552 4421

전화번호부에 적힌 전화번호를 담은 배열 phone_book 이 solution 함수의 매개변수로 주어질 때, 어떤 번호가 다른 번호의 접두어인 경우가 있으면 false를 그렇지 않으면 true를 return 하도록 solution 함수를 작성해주세요.

제한 사항

  • phone_book의 길이는 1 이상 1,000,000 이하입니다.
    • 각 전화번호의 길이는 1 이상 20 이하입니다.
    • 같은 전화번호가 중복해서 들어있지 않습니다.

입출력

phone_book return
["119", "97674223", "1195524421"] false
["123","456","789"] true
["12","123","1235","567","88"] false

문제 설명

1. vector<string> v의 정렬

<algorithm> 헤더의 sort(v.begin(), v.end())를 사용하여 정렬했을 경우

문자열이 사전순, 길이순으로 정렬된다.

 

따라서 문제에서 다른 번호의 접두어인 경우를 판별할때 바로 오른쪽의 string 과 비교해보면 구분할 수 있다.

 


소스 코드

#include <vector>
#include <string>
#include <algorithm>
using namespace std;

bool solution(vector<string> phone_book)
{
    bool ans = true;
    sort(phone_book.begin(), phone_book.end());

    for(int i=0;i<phone_book.size()-1;i++)
    {
        if(phone_book[i] == phone_book[i+1].substr(0, phone_book[i].size()))
            return false;
    }
    return ans;
}
LIST
728x90

문제 설명

셀수있는 수량의 순서있는 열거 또는 어떤 순서를 따르는 요소들의 모음을 튜플(tuple)이라고 합니다. n개의 요소를 가진 튜플을 n-튜플(n-tuple)이라고 하며, 다음과 같이 표현할 수 있습니다.

  • (a1, a2, a3, ..., an)

튜플은 다음과 같은 성질을 가지고 있습니다.

  1. 중복된 원소가 있을 수 있습니다. ex : (2, 3, 1, 2)
  2. 원소에 정해진 순서가 있으며, 원소의 순서가 다르면 서로 다른 튜플입니다. ex : (1, 2, 3) ≠ (1, 3, 2)
  3. 튜플의 원소 개수는 유한합니다.

원소의 개수가 n개이고, 중복되는 원소가 없는 튜플 (a1, a2, a3, ..., an)이 주어질 때(단, a1, a2, ..., an은 자연수), 이는 다음과 같이 집합 기호 '{', '}'를 이용해 표현할 수 있습니다.

  • {{a1}, {a1, a2}, {a1, a2, a3}, {a1, a2, a3, a4}, ... {a1, a2, a3, a4, ..., an}}

예를 들어 튜플이 (2, 1, 3, 4)인 경우 이는

  • {{2}, {2, 1}, {2, 1, 3}, {2, 1, 3, 4}}

와 같이 표현할 수 있습니다. 이때, 집합은 원소의 순서가 바뀌어도 상관없으므로

  • {{2}, {2, 1}, {2, 1, 3}, {2, 1, 3, 4}}
  • {{2, 1, 3, 4}, {2}, {2, 1, 3}, {2, 1}}
  • {{1, 2, 3}, {2, 1}, {1, 2, 4, 3}, {2}}

는 모두 같은 튜플 (2, 1, 3, 4)를 나타냅니다.

특정 튜플을 표현하는 집합이 담긴 문자열 s가 매개변수로 주어질 때, s가 표현하는 튜플을 배열에 담아 return 하도록 solution 함수를 완성해주세요.

[제한사항]

  • s의 길이는 5 이상 1,000,000 이하입니다.
  • s는 숫자와 '{', '}', ',' 로만 이루어져 있습니다.
  • 숫자가 0으로 시작하는 경우는 없습니다.
  • s는 항상 중복되는 원소가 없는 튜플을 올바르게 표현하고 있습니다.
  • s가 표현하는 튜플의 원소는 1 이상 100,000 이하인 자연수입니다.
  • return 하는 배열의 길이가 1 이상 500 이하인 경우만 입력으로 주어집니다.

[입출력 예]

s result
"{{2},{2,1},{2,1,3},{2,1,3,4}}" [2, 1, 3, 4]
"{{1,2,3},{2,1},{1,2,4,3},{2}}" [2, 1, 3, 4]
"{{20,111},{111}}" [111, 20]
"{{123}}" [123]
"{{4,2,3},{3},{2,3,4,1},{2,3}}" [3, 2, 4, 1]

문제 풀이

 

두 가지 방법

1. map[key] = value; 를 이용하여

map[string] = 개수

map -> vector -> value 내림 차순 정렬 -> answer에 넣기

 

2. 1번과 동작 원리는 같으나 vector만을 이용해서 구하기

 


소스 코드

#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
#include <map>
using namespace std;
map<string,int> m;

bool compare(pair<string, int> a, pair<string, int> b)
{
    return a.second > b.second;
}
vector<int> solution(string s) {
    vector<int> answer;
    
    for(int i=0;i<s.size();i++)
    {
        if(s[i] >='0' && s[i] <='9')
        {
            string tmp(1,s[i]);
            int idx = i+1;
            while(idx < s.size())
            {
                if(s[idx] != ',' && s[idx] !='}')
                    tmp +=s[idx];
                else
                    break;
                i++;
                idx++;
            }
            m[tmp]++;
        }
    }
    
    vector<pair<string, int>> v (m.begin(), m.end());
    sort(v.begin(), v.end(), compare);
    for(auto i : v)
        answer.push_back(stoi(i.first));
    return answer;
}
#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
vector<string> split(string s)
{
    vector<vector<string>> answer;
    vector<string> v;
    string tmp = "";
    for(int i=1;i<s.size()-1;i++)
    {
        if(s[i] >= '0' && s[i] <='9')
            tmp += s[i];
        else if(s[i] =='}' && tmp.size() > 0)
        {
            v.push_back(tmp);
            tmp = "";
            answer.push_back(v);
        }
        else if(s[i] == ',' && tmp.size() >0)
        {
            v.push_back(tmp);
            tmp = "";
        }
    }
    return answer[answer.size()-1];
}
bool compare(pair<string, int> a, pair<string, int> b)
{
    return a.second > b.second;
}
vector<int> solution(string s)
{
    vector<int> answer;
    vector<string> tmp = split(s);
    vector<pair<string, int>> v;
    vector<string> tmp2;
    for(int i=0;i<tmp.size();i++)
    {
        if(find(tmp2.begin(), tmp2.end(), tmp[i]) == tmp2.end())
        {
            tmp2.push_back(tmp[i]);
            v.push_back({tmp[i], 1});
        }
        else
        {
            for(int g=0;g<v.size();g++)
            {
                if(v[g].first == tmp[i])
                    v[g].second++;
            }
        }
    }

    
    sort(v.begin(), v.end(), compare);
    for(auto a : v)
    {
        answer.push_back(stoi(a.first));
    }
    
    return answer;
}
LIST
728x90

문제 설명

IT 벤처 회사를 운영하고 있는 라이언은 매년 사내 해커톤 대회를 개최하여 우승자에게 상금을 지급하고 있습니다.
이번 대회에서는 우승자에게 지급되는 상금을 이전 대회와는 다르게 다음과 같은 방식으로 결정하려고 합니다.
해커톤 대회에 참가하는 모든 참가자들에게는 숫자들과 3가지의 연산문자(+, -, *) 만으로 이루어진 연산 수식이 전달되며, 참가자의 미션은 전달받은 수식에 포함된 연산자의 우선순위를 자유롭게 재정의하여 만들 수 있는 가장 큰 숫자를 제출하는 것입니다.
단, 연산자의 우선순위를 새로 정의할 때, 같은 순위의 연산자는 없어야 합니다. 즉, + > - > * 또는 - > * > + 등과 같이 연산자 우선순위를 정의할 수 있으나 +,* > - 또는 * > +,-처럼 2개 이상의 연산자가 동일한 순위를 가지도록 연산자 우선순위를 정의할 수는 없습니다. 수식에 포함된 연산자가 2개라면 정의할 수 있는 연산자 우선순위 조합은 2! = 2가지이며, 연산자가 3개라면 3! = 6가지 조합이 가능합니다.
만약 계산된 결과가 음수라면 해당 숫자의 절댓값으로 변환하여 제출하며 제출한 숫자가 가장 큰 참가자를 우승자로 선정하며, 우승자가 제출한 숫자를 우승상금으로 지급하게 됩니다.

예를 들어, 참가자 중 네오가 아래와 같은 수식을 전달받았다고 가정합니다.

"100-200*300-500+20"

일반적으로 수학 및 전산학에서 약속된 연산자 우선순위에 따르면 더하기와 빼기는 서로 동등하며 곱하기는 더하기, 빼기에 비해 우선순위가 높아 * > +,- 로 우선순위가 정의되어 있습니다.
대회 규칙에 따라 + > - > * 또는 - > * > + 등과 같이 연산자 우선순위를 정의할 수 있으나 +,* > - 또는 * > +,- 처럼 2개 이상의 연산자가 동일한 순위를 가지도록 연산자 우선순위를 정의할 수는 없습니다.
수식에 연산자가 3개 주어졌으므로 가능한 연산자 우선순위 조합은 3! = 6가지이며, 그 중 + > - > * 로 연산자 우선순위를 정한다면 결괏값은 22,000원이 됩니다.
반면에 * > + > - 로 연산자 우선순위를 정한다면 수식의 결괏값은 -60,420 이지만, 규칙에 따라 우승 시 상금은 절댓값인 60,420원이 됩니다.

참가자에게 주어진 연산 수식이 담긴 문자열 expression이 매개변수로 주어질 때, 우승 시 받을 수 있는 가장 큰 상금 금액을 return 하도록 solution 함수를 완성해주세요.

 

[제한사항]

  • expression은 길이가 3 이상 100 이하인 문자열입니다.
  • expression은 공백문자, 괄호문자 없이 오로지 숫자와 3가지의 연산자(+, -, *) 만으로 이루어진 올바른 중위표기법(연산의 두 대상 사이에 연산기호를 사용하는 방식)으로 표현된 연산식입니다. 잘못된 연산식은 입력으로 주어지지 않습니다.
    • 즉, "402+-561*"처럼 잘못된 수식은 올바른 중위표기법이 아니므로 주어지지 않습니다.
  • expression의 피연산자(operand)는 0 이상 999 이하의 숫자입니다.
    • 즉, "100-2145*458+12"처럼 999를 초과하는 피연산자가 포함된 수식은 입력으로 주어지지 않습니다.
    • "-56+100"처럼 피연산자가 음수인 수식도 입력으로 주어지지 않습니다.
  • expression은 적어도 1개 이상의 연산자를 포함하고 있습니다.
  • 연산자 우선순위를 어떻게 적용하더라도, expression의 중간 계산값과 최종 결괏값은 절댓값이 2^63 - 1 이하가 되도록 입력이 주어집니다.
  • 같은 연산자끼리는 앞에 있는 것의 우선순위가 더 높습니다.

입출력

expression result
"100-200*300-500+20" 60420
"50*6-3*2" 300

문제 풀이

 

이 문제는 연산자의 우선순위를 재설정하여 연산 결과의 최대값을 구하는 문제이다.

그러면 풀이과정으로

1. 연산자의 우선순위 재설정

-> dfs를 활용하여 모든 경우의 수에 대해 연산 진행

 

2. 연산 결과의 최대값 구하기

-> 연산 결과는 절대값으로 계산!

 

3. 연산 결과의 범위

-> 연산결과는 최대 2^63 -1 까지다. 이 말은 c++에서 long 의 범위를 의미하는것으로 보인다.

    난 여유있게 long long으로 계산함

 

4. 사전작업

-> expression을 숫자 백터와 연산자 백터에 따로 담아 두었다.

(연산자 백터는 항상 숫자 백터 크기보다 1개 작다는것을 주의하자)

-> 연산자 백터에서 중복된 연산자를 제외 한후 dfs를 돌려서 순열을 만들어 모든 우선순위를 구한다.

 

5. 계산하기

-> 연산자 순서대로 계산 후, 처음에 만들었던 숫자백터와 연산자 백터의 크기를 줄여가며 진행한다.

    숫자 백터의 크기가 1 일때 더이상 연산할것이 없으므로 answer 와 절대값 크기비교를 하며 

    모든 경우의 수를 구해본다.

 


소스 코드

#include <vector>
#include <string>
#include <algorithm>
using namespace std;
bool selected[3];
vector<char> oper3;
void cal(char operation, vector<char>& oper, vector<long long>& numbers, long long& sum)
{
    auto it = find(oper.begin(), oper.end(), operation);
    while(it != oper.end())
    {
        int idx = it - oper.begin();
        if(operation == '*')
        {
            numbers[idx] = numbers[idx] * numbers[idx+1];
        }
        else if(operation == '+')
        {
            numbers[idx] = numbers[idx] + numbers[idx+1];
        }
        else
        {
            numbers[idx] = numbers[idx] - numbers[idx+1];
        }
        numbers.erase(numbers.begin() + idx+1);
        oper.erase(oper.begin() + idx);
        it = find(it, oper.end(), operation);
    }
    if(numbers.size() == 1)
    {
        sum = abs(numbers[0]);
    }
    return;
}
void dfs(int depth, vector<char> oper, vector<char> oper2, vector<int> nums, long long& answer)
{
    if(depth == oper2.size())
    {
        long long sum = 0;
        vector<long long> numbers;
        for(auto a : nums)
            numbers.push_back(a);
        for(int i=0;i<oper3.size();i++)
        {
            cal(oper3[i], oper, numbers, sum);
        }
        answer = max(sum, answer);
        return;
    }
    for(int i=0;i<oper2.size();i++)
    {
        if(selected[i])continue;
        selected[i] = true;
        oper3.push_back(oper2[i]);
        dfs(depth+1, oper, oper2, nums, answer);
        oper3.pop_back();
        selected[i] = false;
    }
}
long long solution(string expression)
{
    long long answer = 0;
    vector<int> nums;
    vector<char> oper;
    string ttmp="";
    for(int i=0;i<expression.size();i++)
    {
        if(expression[i] >='0' && expression[i] <= '9')
        {
            ttmp+= expression[i];
        }
        else
        {
            oper.push_back(expression[i]);
            nums.push_back(stoi(ttmp));
            ttmp="";
        }
    }
    nums.push_back(stoi(ttmp));

    vector<char> oper2;
    for(int i=0;i<oper.size();i++)
    {
        if(find(oper2.begin(), oper2.end(), oper[i]) == oper2.end())
        {
            oper2.push_back(oper[i]);
        }
    }

    dfs(0, oper, oper2, nums, answer);
    return answer;
}

 

LIST

+ Recent posts