문제점 : one이 가능한 모든 것들을 잡아버림

class Solution {
public:
    string originalDigits(string s) 
    {
        vector<int> map(26);
        string ans = "";
        
        for(int i=0; i<s.size(); i++)
            map[s[i]-97] += 1;
        
        
        for(int i=0; i<s.size(); i++)
        {
            if(map['z'-97] > 0 && map['e'-97] > 0 && map['r'-97] > 0 && map['o'-97] > 0)
            {
                map['z'-97]--; 
                map['e'-97]--; 
                map['r'-97]--;
                map['o'-97]--;
                ans += '0';
            }
            else if(map['o'-97] > 0 && map['n'-97] > 0 && map['e'-97] > 0)
            {
                map['o'-97]--; 
                map['n'-97]--; 
                map['e'-97]--;
                ans += '1';
            }
            else if(map['t'-97] > 0 && map['w'-97] > 0 && map['o'-97] > 0)
            {
                map['t'-97]--; 
                map['w'-97]--; 
                map['o'-97]--;
                ans += '2';
            }
            else if(map['t'-97] > 0 && map['h'-97] > 0 && map['r'-97] > 0 && map['e'-97] > 1)
            {
                map['t'-97]--; 
                map['h'-97]--; 
                map['r'-97]--;
                map['e'-97] -=2;
                ans += '3';
            }
            else if(map['f'-97] > 0 && map['o'-97] > 0 && map['u'-97] > 0 && map['r'-97] > 0)
            {
                map['f'-97]--; 
                map['o'-97]--; 
                map['u'-97]--;
                map['r'-97]--;
                ans += '4';
            }
            else if(map['f'-97] > 0 && map['i'-97] > 0 && map['v'-97] > 0 && map['e'-97] > 0)
            {
                map['f'-97]--; 
                map['i'-97]--; 
                map['v'-97]--;
                map['e'-97]--;
                ans += '5';
            }
            else if(map['s'-97] > 0 && map['i'-97] > 0 && map['x'-97] > 0)
            {
                map['s'-97]--; 
                map['i'-97]--; 
                map['x'-97]--;
                ans += '6';
            }
            else if(map['s'-97] > 0 && map['e'-97] > 1 && map['v'-97] > 0 && map['n'-97] > 0)
            {
                map['s'-97]--; 
                map['e'-97] -=2; 
                map['v'-97]--;
                map['n'-97]--;
                ans += '7';
            }
            else if(map['e'-97] > 0 && map['i'-97] >0 && map['g'-97] > 0 && map['h'-97] > 0 && map['t'-97] > 0)
            {
                map['e'-97]--; 
                map['i'-97]--; 
                map['g'-97]--;
                map['h'-97]--;
                map['t'-97]--;
                ans += '8';
            }
            else if(map['n'-97] > 1 && map['i'-97] > 0 && map['e'-97] > 0)
            {
                map['n'-97]-=2; 
                map['i'-97]--;
                map['e'-97] --; 
                ans += '9';
            }
            cout << ans<< "ans & o" << map['o'-97] << endl;
                
        }
        
        return ans;
    }
};

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

bool cmp(int a, int b) 
{
	if (a > b) return true;
	else return false;
}

int main()
{
  string s;
  // int 배열 생성
  vector<int> a; 

  //초기 숫자 입력을 string 형태로  
  cin >> s;

	
  // string 인덱스 마다 -> int 형태로 변환 후
  // int 배열에 추가
  for(int i=0; i<s.size(); i++)
    a.push_back(s[i]-48);
       
  // int 배열 정렬
  sort(a.begin(), a.end(),cmp);
  
  for(int i=0; i<a.size(); i++)
    cout << a[i];

  return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

bool cmp(string a, string b) 
{
	if (a < b) return true;
	else return false;
}


int main()
{
  string s;
  vector<string> ss; 
  
  cin >> s;
	
  // 접미사 추출 및 string 벡터 저장
  for(int i=0; i<s.size(); i++)
  {
    string tmp = s.substr(i,s.size());
    ss.push_back(tmp);           
  }
  
 // sort
 sort(ss.begin(), ss.end(),cmp);
  
 // 출력
 for(int i=0; i<ss.size(); i++)
   cout << ss[i] << endl;

	return 0;
}

다양한 변수를 가지고 있는 객체를 하나의 변수를 기준으로 정렬하는 방법을 유용하게 잘 쓰고 있다.

마치 c++의 pandas를 만난 기분이다.

#include <iostream>
#include <string>
#include <algorithm>

using namespace std;

class number
{
    public: 
        int n;
        string N = "";
 
};

bool cmp(number a, number b) 
{
	if (a.N < b.N) return true;
	else return false;
}

string int2string(int k)
{
  string s;

  if(k == 1)
    s ="one";
  else  if(k == 2)
    s ="two";
  else  if(k == 3)
    s ="three";
  else  if(k == 4)
    s ="four";
  else  if(k == 5)
    s ="five";
  else  if(k == 6)
    s ="six";
  else  if(k == 7)
    s ="seven";
  else  if(k == 8)
    s ="eight";
  else  if(k == 9)
    s ="nine";
  else 
    s = "zero";
  return s;
}


int main()
{
  int enter=0;
  int m,n;
  cin >> m >> n;
  number p[100];

  for(int i=m; i<=n; i++)
  {
    string s;
         
    
    p[i].n = i;

    if(i/10 != 0)
      p[i].N = int2string(i/10);

    p[i].N += int2string(i%10);

    
  }
  
  sort(p+m,p+n+1,cmp);
  
 for(int i=m; i<=n; i++)
 {
   enter++;
   cout << p[i].n << " ";

   if(enter == 10)
   {
     cout << endl;
     enter = 0;
   }
 }
	return 0;
}

이름 벡터 100개를 생성한 후, 나이에 해당하는 벡터에 입력해주는 알고리즘은

시간 초과로 실패했다

이유를 찾아보니, sort를 사용해야 했다.

int main()
{
  int n;
  vector<vector<string>> name;

  cin >> n;

  for(int i=0; i<200; i++)
  {
    vector<string> v;
    name.push_back(v);
  }

  for(int i=0; i<n; i++)
  {
    int old;
    string s;
         
    cin >> old >> s;
    name[old-1].push_back(s);
  }

  for(int i=0; i<200; i++)
      for(int k=0; k<name[i].size(); k++)
        cout << i+1 << " "<< name[i][k] << endl;
  
	return 0;
}

class와 sort를 사용해 풀었는데, 정답대로 잘 나오지만, 왜 틀렸는지는 알 수가 없다...

로직에는 문제가 없는데,,,, 백준 억까 멈춰!

#include <iostream>
#include <string>
#include <algorithm>

using namespace std;

class people
{
    public: 
        int age;
        string name;
 
};

bool cmp(people a, people b) 
{
	if (a.age < b.age) return true;
	else return false;
}



int main()
{
  ios::sync_with_stdio(false);
  int n;
  cin >> n;
  people p[n];

  for(int i=0; i<n; i++)
  {
    int old;
    string s;
         
    cin >> old >> s;
    p[i].age = old;
    p[i].name = s;
  }
  
  sort(p,p+n,cmp);
  
  for(int i=0; i<n; i++)
    cout << p[i].age << " " << p[i].name << endl; 
	return 0;
}

Bubble Sort를 사용해 풀이하였다.

// 글자의 자리 수 합을 구하는 함수 
int s_number(string s) 
{
  int num = 0;

  for(int i=0; i<s.size(); i++)
  {
    if(48 <= s[i] && s[i] <= 57)
      num += s[i] - 48;
  }

  return num;
}

int main()
{
  int n; // 초기 입력 n
  string s;
  vector<vector<string>> store_s ; //문자열들을 저장하는 2차원 벡터
  vector<vector<int>> store_n ; //문자열들의 자리수 합을 저장하는 2차원 벡터

  for(int i=0; i<50;i++) //2차원 벡터 생성
  {
    vector<string> v1;
    vector<int> v2;
    store_s.push_back(v1);
    store_n.push_back(v2);
  }

  cin >> n; 
  for(int i=0; i<n; i++)
  { 
    cin >> s;
    store_s[s.size()-1].push_back(s); // 시리얼번호 저장 
    store_n[s.size()-1].push_back(s_number(s)); 
    // 시리얼 번호에 해당하는 자리수합 저장
  }



  
   for(int i=0; i<50; i++) //글자 길이가 50까지 이므로 50번 반복
    // Bubble Sort로 글자수에 따른 시리얼 번호 정렬
    for(int j=0; j<store_s[i].size(); j++)
    { 
      for(int k=0; k<store_s[i].size()-j-1; k++)
      { 
        string temp;
        int tmp;
        // 조건 2번에 따른 정렬
        if(store_n[i][k] > store_n[i][k+1])
        { 
          // 위치한 시리얼의 위치를 바꾼다
          temp = store_s[i][k]; 
          store_s[i][k] = store_s[i][k+1]; 
          store_s[i][k+1] = temp;
          // 위치한 시리얼의 자리수 합을 바꾼다
          tmp = store_n[i][k]; 
          store_n[i][k] = store_n[i][k+1]; 
          store_n[i][k+1] = tmp;
        }
        // 조건 3번에 따른 정렬
        else if(store_n[i][k] == store_n[i][k+1] && store_s[i][k] > store_s[i][k+1])
        // 위치한 시리얼의 위치를 바꾼다
        // 자리수 합은 같으므로 바꿀 필요는 없다 
        {
          temp = store_s[i][k]; 
          store_s[i][k] = store_s[i][k+1]; 
          store_s[i][k+1] = temp;
        }
        
      } 
    }


 // 출력
  for(int i=0; i<50; i++)
      for(int k=0; k< store_s[i].size(); k++)
        cout << store_s[i][k] << endl;
  

	return 0;
}

O(n³) 인 방법으로 만들 수 있긴한데, <set>을 사용하는 게 아무래도 편할 것 같아서 set을 사용해서 풀었다.

int main(void) 
{
  set<string> a;
  string s;

  cin >> s;

  for(int i=0 ; i<s.size(); i++)
  { // window 크기 별로 입력 ex) 4글자면 1~4글자
    for(int k=0; k<s.size()-i; k++) 
    { // window slice
      a.insert( s.substr(k,i+1));
      // set 삽입
    }
      
  }

  cout << a.size();

  return 0;
}

스택을 사용해 간단하게 풀었다.

class Solution {
public:
    string removeDuplicates(string s) 
    {
        string ans;
        ans += s[0];
        
        for(int i=1; i<s.size(); i++)
        {

            if(ans.back() == s[i])
                ans.erase(ans.size()-1,ans.size());
            
            else
                ans += s[i];
        }
        
        return ans;
    }
};

나름 조건 다 맞춰서 작성했는데, 아무리 봐도 어디가 문제인지 모르겠다...

다시 풀어보자,,,,

#include <stdio.h>
#include <iostream>
#include <string.h>
#include <string>

using namespace std;



int main(void)
{
  string s;
  int score = 0;
  int tmp = 0; // 탐색 중인 점수를 저장
  int bonus = 0;
  int count = 0;
  int trys = 0;
  int s_count = 0;
  cin >> s;

  for(int i =0; i<s.size(); i++) //1번
  {


    if(48 < s[i] && s[i] < 58) //2번
    {
      score += s[i] - 48;
      tmp = s[i] - 48;
      trys++;
    }
    else if( s[i] == '-')
    {
      tmp = 0;
      trys++;
    }
    else if( s[i] == 'P')
    {
      score += 10 - tmp;
      
      trys++;
      tmp = 10 - tmp;
    }
    else if( s[i] == 'S')
    {
      score += 10;
      s_count ++;
      trys += 2;
      tmp = 10;
    }

    if(bonus > 0 && count < 9)
    {
      score += tmp;
      bonus--;
    }
    //cout << s[i] << "  " << count << "\n" ;
    if(trys == 2)
    {
      trys = 0;
      count++;
    }
    if( s[i] == 'P') bonus ++;
    else if( s[i] == 'S') bonus +=2;
    
    
  }
  if(s_count == 12) score = 300;
  cout << score;


  return 0;
}

int main(void)
{
  queue<int> q;
  int n;

  // 카드 수 입력
  cin >> n;
  
  // 입력한만큼 카드 추가
  for(int i=0; i<n; i++)
    q.push(i+1);


  // 마지막에 한장이 남으므로 n-1번 반복
  for(int i=0; i<n-1; i++)
  {
    q.pop(); // 맨 윗장을 지우고
    q.push( q.front() ); // 그리고 오게 된 카드를 맨 뒤에 놓음
    q.pop(); // 뒤로 보냈기에 중복 방지로 지움
  }
 
  // 정답 출력
  cout << q.front();

  return 0;
}

map의 특성을 이용해 풀었다.

중복을 막는 <set> 이란 라이브러리도 있는데 나중에 찾아봐야겠다.

num의 범위를 1~1000으로 생각해 풀어서 계속 헤맸는데,

-1000 ~ 1000이었다. 문제를 잘 읽도록 하자.

int main(void)
{
  int n = 0;
  int num = 0;
  vector<int> map(2001);

  cin >> n;

  for(int i=0; i<n; i++)
  {
    cin >> num;
    map[num+1000] = 1;
  }

  for(int i=0; i<=2001; i++)
  {
    if(map[i] == 1)
    {
      cout << i-1000 << " ";
    }
  }

  return 0;
}

Try 1 

배열로 풀었는데 뭔가 이상함 n = 4 / k =4 인 부분에서 오류 발생 

큐로 다시 풀어보고 배열도 틀린 점 고칠 예정

#include <vector>
#include <iostream>

using namespace std;

int main(void) 
{
  int n;
  int k;
  int count = 0;
  

  cin >> n >> k;


  vector<int> list(n);
  
  int idx = k-1;
  list[idx] = 1;

  cout << '<' << k << ", ";
  
  for(int i=0; i<n-1; i++)
  {
    while(count != k)
    {
      idx++;
      
      if(list[idx] == 0)
        count ++;

      if(idx == n)
        idx = 0;

      
    }
    
    count = 0;
    
    list[idx] = 1;

    if(i<n-2)
      cout << idx+1 << ", ";
    else 
      cout << idx+1 << ">";

  }

  return 0;
}

Try 2

탐색 idx를 다시 초기화 해주는 부분의 순서를 이상하게 했었음...

해결완료 

/* 수정한 부분 */
  
  for(int i=0; i<n-1; i++)
  {
    
    while(count != k)
    {
      idx++;

      if(idx == n)
        idx = 0;      
      
      if(list[idx] == 0)
        count ++;

    }

왜 간선 좌표로 파악해야하는지 이해하기

Try 1 실패 이유

1. 한 방향으로만 흔적을 남김 -> 한 방향으로 이동 시 역 방향으로 돌아왔을 때도 자취를 남겨야함

2. 배열을 생성했을 때, 배열의 각 요소의 초기값은 0이 아니라 dump값 임

#include <string>
#include <vector>
#include <iostream>

using namespace std;

int solution(string dis) 
{
    int answer = 0;

    vector<vector<int>> w;
    for(int i=0; i<11; i++)
    {
        vector<int> v = {0,0,0,0,0,0,0,0,0,0,0};
        w.push_back(v);
    }
    
    int x = 5;
    int y = 5;
    w[y][x] = 1;
    
    for(int i=0; i<dis.size(); i++)
    {
        if(dis[i] == 'U' && y>=1)
            y--;
        else if(dis[i] == 'D' && y<=9)
            y++;
        else if(dis[i] == 'R' && x<=9)
            x++;
        else if(dis[i] == 'L' && x>=1)
            x--;
        else
        {
            w[y][x] = 0;
            answer--;
        }

        
        cout << x << " " << y << endl;
        
        
        answer++;
        if(w[y][x] == 1)
            break;
        w[y][x] = 1;
    }
    return answer;
}

Try 2 성공

#include <string>
#include <iostream>

using namespace std;

int solution(string dis) 
{
    int answer = 0;
    int map[11][11][11][11];
    
        
    int x = 5, y = 5;
    

    for(int i=0; i<dis.size(); i++)
    {   
        
      if(dis[i] == 'U' && y>=1)
      {
          if(map[y][x][y-1][x] !=1)
          {
            map[y-1][x][y][x] = 1;
            map[y][x][y-1][x] = 1;
            answer++;
          }
            y--;
      }
          
      else if(dis[i] == 'D' && y<=9)
      {
          if(map[y][x][y+1][x] != 1)
          {
            map[y][x][y+1][x] = 1;
            map[y+1][x][y][x] = 1;
            answer++;
          }
            y++;
      }
      else if(dis[i] == 'R' && x<=9)
      {
          if(map[y][x][y][x+1] != 1)
          {
            map[y][x][y][x+1] = 1;
            map[y][x+1][y][x] = 1; 
            answer++;
          }
          x++;
      }
      else if(dis[i] == 'L' && x>=1)
      {
         if(map[y][x][y][x-1] != 1)
         {
            map[y][x][y][x-1] = 1;
            map[y][x-1][y][x] = 1;
            answer++; 
         }
         x--;
      }
        
        cout << answer << endl;
        
    }
    
    return answer;
}

제곱 수는 약수의 개수가 홀수 개라는 성질을 이용

int solution(int left, int right) 
{
    int answer = 0;
    
    for(int i=left ;i<=right; i++)
    {
        if(sqrt(i) - int(sqrt(i)) == 0)
            answer -= i;
        else
            answer += i;
    }
    
    return answer;
}

string compare의 결괏값을 자꾸만 헷갈린다. 
같으면 0을 출력한다.

int main(void)
{
    string s;
    int i = 0;
    int sum = 0;
    cin >> s;
    
    while(i < s.size())
    {
        if(s.substr(i,3).compare("dz=") == 0 && i<s.size()-2) 
            {
             i+=3;
            
            }
        else if(is_cro(s.substr(i,2)) && i<s.size()-1)
            {
              i+=2;
              
            }

        else 
        {
          i++;
          
        }
           
        
        sum++;
    }
    cout << sum;
}

bool is_cro(string s)
{
    
    if(s.compare("c=") == 0 || s.compare("c-") == 0||s.compare("d-") == 0||s.compare("lj") == 0||s.compare("nj")== 0 ||s.compare("s=") == 0||s.compare("z=")== 0)
        return true;
    return false;
}

실수 1월 2월은 윤년이어도 하루를 더하면 안됨

class Solution {
public:
    int dayOfYear(string date) 
    {
        int sum = 0;
        int year = stoi(date.substr(0,4));
        int mon = string_to_int(date.substr(5,2));
        int day = string_to_int(date.substr(8,2));
        vector<int> m_d = {31,28,31,30,31,30,31,31,30,31,30,31};
        
        if(mon == 1) return day;
        
        if(mon != 2)
            sum += is_yoon(year);
        
        for(int i=0; i<mon-1; i++)
        {
            sum += m_d[i];
        }
        
        return sum + day;
    }
    
    int is_yoon(int year)
    {
        if(year % 4 == 0)
        {
            if(year % 100 == 0)
            {
                if(year % 400 == 0)
                    return 1;
                return 0;
            }
            return 1;
        }
        return 0;
    }
    
    int string_to_int(string s)
    {
        if(s[0] == '0')
            return s[1] - '0';
        else
            return stoi(s);
    }
};

Try 1

1. K번째까지 탐색하며 가장 큰 수 전까지 제거
2. 확정된 처음 수 이후부터 끝까지 탐색하면서 
   다음 수와 비교했을 때 수가 증가한 경우 해당 수 제거
3. 제거함에도 불구하고, k가 남은 경우 k만큼 끝 자리 수 제거ㅌ

테스트 케이스는 다 맞았지만, 채점 결과 하나만 통과,,,
스택구조로 다시 풀어보겠다.

string solution(string s, int k) 
{
    int f_val = 0;
    int f_inx;
    
    for(int i=0; i<=k; i++) // 1. 과정
    {
        if(f_val < s[i] - '0')
        {
            f_val = s[i] - '0';
            f_inx = i;
        }
        
        
    }
    
    s = s.substr(f_inx, s.size() - f_inx); 
    k = k - f_inx;
    
    while(k > 0) // 2. 과정, 지워야할 숫자가 없다면 종료
    {
        vector<int> idx;
        
        for(int i=0; i<s.size()-1; i++) //다음 수가 커지는 경우 인덱스 저장
        {
            if(s[i] < s[i+1] && idx.size() < k)
                idx.push_back(i);
        }
        
        for(int i=0; i<idx.size(); i++) // 저장된 인덱스의 수 제거
        {
            s = s.erase(idx[i]-i,1);
        }
        
        k = k - idx.size(); //지워야 할 숫자들의 수 갱신
        if(idx.size() == 0) //다음 수가 커지는 경우가 없다면 끝내기
            break;
    }
    
    if(k > 1) // 3. 과정
        s = s.substr(0, s.size() - k);
    return s;
}

Try 2

테스트 케이스를 안 알려줘서 직접 다 쥐어짜내면서 하느라 죽는줄 알았다...

오름차순, 내림차순 섞으면서 해보고 오름차순으로만도 해보고, 내림차순만으로도 해보고

두자리 숫자에 하나만 지워보기도 하고, 테스크 케이스를 최대한 많이 굴려보는게 접근하기 좋다.

특히나 프로그래머스는 불친절한 감이 없지않아 있다...

아이디어는 아래 블로그를 적극적으로 활용했다.

string solution(string s, int k) 
{
    int f_val = 0;
    int f_inx = 0;
    string ans;
    
    for(int i=0; i <= k; i++) //처음 큰 수까지 추출 과정
    {
        if(f_val < s[i] - '0')
        {
            f_val = s[i] - '0';
            f_inx = i;
        }  
    }
    
    
    s = s.substr(f_inx, s.size() - f_inx); //추출한 값까지 제거
    
    ans += s[0];
    k = k - f_inx;
    
    f_inx = 1; //첫 자리는 정했으므로 그 다음 자리부터 시작
    
    while(k>0 && f_inx< s.size()) 
    { //더 이상 지울 수가 없거나 탐색 인덱스가 범위를 초과하면 중단
        f_val = 0; //수 비교 초깃값 0
        int tmp = f_inx; //탐색 시작점 저장
        
        for(int i=0; i<=k && tmp+i < s.size(); i++) 
        { //가장 큰 수의 인덱스를 찾는 과정
            if(f_val < s[tmp+i] - '0')
            {
                f_val = s[tmp+i] - '0';
                f_inx = tmp+i;
            }
        }
        
        ans += s[f_inx]; // 찾은 큰 수를 추가
        k -= (f_inx - tmp); 
        //큰 수의 인덱스와 시작점의 차이는 지운 숫자의 수임
        
        f_inx ++;  //큰 수의 인덱스 다음 인덱스부터 탐색 시작      
    }
    
    if(k>0) //k가 남아있는 경우 끝에서 k만큼 지워 주면 됨
      ans = s.substr(0, s.size()-k);
    else //다 지운 경우 탐색 인덱스 부터 끝부분까지 마저 채워주면 됨
      ans += s.substr(f_inx, s.size() - f_inx);
       
    
    return ans;
}

int main()
{
  
  int T;
  
  vector<double> ans;
  int num_flag = 0;
  
  cin >> T;

  for(int i=0; i<T+1 ;i++) // 왜 T+1 을 해야 작동하는지 모르겠다.
  {
    double n;
    string num;

    getline(cin,num,'\n'); // 스페이스바 포함 입력
    
    for(int k=0; k < num.size(); k++)
    {
      if(num[k] == ' ' && num_flag == 0) //숫자부분 추출 과정
      {
        num_flag = 1;
        n = stof(num.substr(0,k));
      }
      if(num[k] == '@') n *= 3.0;
      else if(num[k] == '%') n+=5.0;
      else if(num[k] == '#') n-=7.0;
    }
    num_flag = 0;
    ans.push_back(n);
  }

  for(int k=1; k< ans.size(); k++) // 출력과정
  {
    cout.setf(ios::showpoint); // 끝의 0을 표시
    cout << fixed; //소수점 끝의 자리수만 고정
    cout.precision(2);

    cout << ans[k]<< endl; 
     
  }


  return 0;
}

1년이 증가할 때마다
e s m을 1 증가하고 입력한 E S M과 동일한지 확인
다르다면, 1년을 다시 증가

중간에 e s m 이 각각의 범위를 초과할 때마다 1로 초기화시켜줌

int main()
{
  int E,S,M;
  int e = 1;
  int s = 1;
  int m = 1;
  int year = 1;
  cin >> E >> S >> M;

  while(1)
  {
    if(E == e && S == s && M == m)
      break;
    e ++;
    s ++;
    m ++;
    if(e == 16) e=1;
    if(s == 29) s=1;
    if(m == 20) m=1;

    year++;
  }
  cout << year;
  return 0;
}

B(가변비용) 가 C(노트북 판매가)보다 크면 -1 리턴

손익 분기는 
C - B (노트북 한대의 순수익)이
A보다 커지는 시점이고

이는 (C - B) * n > A 로 생각 할 수 있다.
좌변과 우변이 같아지는 시점이 순이익이 0이 되는 지점이므로 이때보다 하나 더 팔면 된다.

int main() 
{
  int a,b,c;

  cin >> a >> b >> c;

  if(b >= c)
    cout << -1;
  else 
    cout << a/(c-b) + 1;

  return 0;
}