erase 이후에 j증가하면 안된다!

-> 100과 200 계산 이후에
-100 과 300을 계산해야 하므로 erase 이후에는 j값 줄여야 한다

정답 소스코드

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


long long solution(string expression) {
	long long answer = 0;
	vector<long long> num;
	//expression 내부에 있는 연산자들을 순서대로 삽입하자.
	vector<char> location;
	//전체 연산자들
	vector<char>exp = { '+', '-', '*' };
	string n = "";

	for (int i = 0; i < expression.size(); i++)
	{
		if (expression[i] == '+' || expression[i] == '-' || expression[i] == '*')
		{
			num.push_back(stoi(n));
			n = "";
			
			location.push_back(expression[i]);
		}
		else
			n += expression[i];
	}

	num.push_back(stoi(n));
	sort(exp.begin(), exp.end());

	do
	{
		vector<long long> tmp_num = num;
		vector<char> tmp_loc = location;

		//+ - * 모든 연산자를 기준으로 비교해야 하므로.
		for (int i = 0; i < exp.size(); i++)
		{
			//수식에 사용된 연산자들 중에서 동일한 연산자가 사용되는 경우에 대비해서 
			for (int j = 0; j < tmp_loc.size(); j++)
			{
				if (exp[i] == tmp_loc[j])
				{
					if (tmp_loc[j] == '+')
						tmp_num[j] = tmp_num[j] + tmp_num[j + 1];
					else if (tmp_loc[j] == '-')
						tmp_num[j] = tmp_num[j] - tmp_num[j + 1];
					else if (tmp_loc[j] == '*')
						tmp_num[j] = tmp_num[j] * tmp_num[j + 1];

					//+1을 해도 문제가 되지 않는 이유는 어차피 tmp_loc보다
					//size가 1보다 크다는 것이 확정되었기 때문이다. 
					//중위 연산으로 사용되므로 마지막은 반드시 숫자가 오므로
					//문제가 되지 않는다.
					tmp_num.erase(tmp_num.begin() + j + 1);
					tmp_loc.erase(tmp_loc.begin() + j);
					j--;
				}
			}
		}

		if (answer < abs(tmp_num[0]))
			answer = abs(tmp_num[0]);
	} while (next_permutation(exp.begin(), exp.end()));
	//전체 연산자들을 조합함 : 총 6가지의 경우의 수다.
	return answer;
}



int main()
{
	//string s = "50*6-3*2";
	string s = "100-200*300-500+20";
	cout << solution(s);

}

내가 푼 소스코드 - 90점이다..

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

long long solution(string expression) {
    long long answer = 0;
    
    vector<char>totalOprt = {'*', '-', '+'};
    vector<long long> data;
    vector<char> oprt;
    
    sort(totalOprt.begin(), totalOprt.end());
    
    string word;
    for(int i = 0; i< expression.length(); i++)
    {
        //연산자일때와 
        if(expression[i] == '+' || expression[i] == '-'
           || expression[i] == '*')
        {
            data.push_back(stoi(word));
            word = "";
            oprt.push_back(expression[i]);
        }
        //숫자일때
        else
        {
            word += expression[i];
        }
    }
    
    data.push_back(stoi(word));
    
    do
    {
        vector<char>tmpOprt = oprt;
        vector<long long>tmpData = data;
        
        
        for(int i = 0; i < totalOprt.size(); i++)
        {
            for(int j = 0; j < tmpOprt.size(); j++)
            {
                if(totalOprt[i] == tmpOprt[j])
                {
                    
                    if(tmpOprt[j] == '+')
                    {
                        tmpData[j] = tmpData[j] + tmpData[j + 1];
                    }
                    else if(tmpOprt[j] == '*')
                    {
                        tmpData[j] = tmpData[j] * tmpData[j + 1];                     
                    }
                    else if(tmpOprt[j] == '-')
                    {
                        tmpData[j] = tmpData[j] - tmpData[j + 1];                        
                    }
                    
                    //제거작업.
                    tmpData.erase(tmpData.begin() + j + 1);
                    tmpOprt.erase(tmpOprt.begin() + j);
                    
                    
                    j--;
                }
            
            }
            
            ///최대값 뽑아내기
            if(answer < abs(tmpData[0]))
                answer = abs(tmpData[0]);
            
        }
        
        //추가적으로 연산 완료 후 컨테이너 값을 제거해야 한다. 내가 편하게 연산이 가능하다.
        //이렇게 조합돌리면 인덱스에 저장되는 연산자 조합이 달라진다. 
        //인덱스 순에 따라서 우선순위가 결정된다.
        //[0]인덱스 vs 수식에 저장된 컨테이너 있는지 비교 있으며 앞 뒤 숫자와의 연산을 진행한다.
    }while(next_permutation(totalOprt.begin(), totalOprt.end()));
    
   
    
    return answer;
}

//3가지 연산을 가지고 조합

잘못 작성한 부분

-> 조합이 완료 된후에 비교해야 했는데 잘못된 부분에 작성했다.

완료한 코드

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

long long solution(string expression) {
    long long answer = 0;
    
    vector<char>word = {'+', '-','*'};
    vector<long long>num;
    vector<char>order;
    
    string tmp = "";
    
    sort(word.begin(), word.end());
    
    
    for(auto iter : expression)
    {
        if(iter == '+' || iter == '-' || iter == '*')
        {
            order.push_back(iter);
            num.push_back(stoi(tmp));
            tmp = "";
            continue;
        }
        
        tmp += iter;
        
    }
    //마지막 숫자는 따로 추가해야 한다. 
    num.push_back(stoi(tmp));
    
    do
    {
        //조합 시키면서 제거하기에는 그렇다.
        vector<long long>tmpNum = num;
        vector<char>tmpOrder = order;
        
        for(int i = 0; i < word.size(); i++)
        {
            char c = word[i];
            for(int j = 0; j < tmpOrder.size(); j++)
            {
                 if(c == tmpOrder[j])
                 {
                     if(c == '+')
                     {
                         tmpNum[j] = tmpNum[j] + tmpNum[j + 1];
                     }
                     else if(c == '-')
                     {
                         tmpNum[j] = tmpNum[j] - tmpNum[j + 1];
                         
                     }
                     else if(c == '*')
                     {
                         
                         tmpNum[j] = tmpNum[j] * tmpNum[j + 1];
                     }
                     
                     tmpNum.erase(tmpNum.begin() + j + 1);
                     tmpOrder.erase(tmpOrder.begin() + j);
                     j--;
                     
                 }         
            }
            
            
        }
        
        ///최대값 뽑아내기
            if(answer < abs(tmpNum[0]))
                answer = abs(tmpNum[0]);
        
        
    }while(next_permutation(word.begin(), word.end()));
    
    
    
    return answer;
}