우주의WouldYou

#include <string>
#include <vector>

using namespace std;

long long solution(int N) {
    long long answer = 0;
    vector <int> arr;
    
    arr.push_back(1); arr.push_back(1);
    int i = 2;
    while (i  < N+1){
        arr.push_back(arr[i-1] + arr[i-2]);
        i++;
    }
    answer = 2 * (arr[N-1] + (arr[N-1] + arr[N-2]));
    
    return answer;
}

정확성은 100점, 효율성은 0점

모두 저장하고 하니까 당연히 그렇겠지만,, 어떻게 해야하지!?

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

string solution(vector<string> participant, vector<string> completion) {
    string answer = "";
    string name = "";
    int num = 0;
    int flag = 0;
    sort(participant.begin(), participant.end());
    sort(completion.begin(), completion.end());
    for(int i = 0;i < completion.size(); i++){
        name = participant[i];
        if(participant[i] != completion[i]){
            answer = participant[i];
            flag = 1;
            break;
        }
        
    }
    if (flag ==0)
        answer = participant[participant.size()-1];
    return answer;
}

이거 전에 풀 때는 진짜 큐?인가 그런거 써서 풀려다가 포기했었다. 너무 어렵게 생각하지 말자!

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

int solution(int N, vector<vector<int> > road, int K) {
    int answer = 0;
    int i, j ,k, m, num, num2, city;
    sort(road.begin(), road.end());
    vector <int> uniq;
    uniq.push_back(1);
   int tmp, tmp2;
    for(i=0; i < road.size(); i++){
        tmp = 0;
        for(j = 0; j < 2; j++){
            if(road[i][j] == 1){
                num = abs(j-1);
                city = road[i][num];
                tmp += road[i][2];
                if( tmp > K)
                    break;
                uniq.push_back(city);
                for(k = i + 1; k < road.size(); k++){
                    cout << "k: " << k << " ";
                    for(m =0; m < 2; m++ ){
                        if(road[k][m] == city){
                            tmp += road[k][2];
                            if(tmp > K){
                                tmp -= road[k][2];
                                continue;
                            }
                            num2 = abs(m-1);
                            uniq.push_back(road[k][num2]);
                            tmp -= road[k][2];
                                
                        }
                    }
                }
                
            }
        }
    }
    for(i =0; i < uniq.size(); i++)
        cout << uniq[i] << " ";
    cout << endl;
    sort(uniq.begin(), uniq.end());
    uniq.erase(unique(uniq.begin(), uniq.end()), uniq.end());
    for(i =0 ;i < uniq.size(); i++)
        cout << uniq[i] << " ";
    answer = uniq.size();
    return answer;
}

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

vector<int> sorting (vector<int> arr){
    int tmp = 0;
    for(int i=0; i < arr.size()-1; i++){
        for(int j = i +1; j < arr.size(); j++){
            if(arr[i] > arr[j]){
                tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
            }
        }
    }
    return arr;
}
int solution(vector<int> A, vector<int> B) {
    int answer = 0;
    //vector<int> b_arr = sorting( B);
    sort(B.begin(), B.end());
    sort(A.begin(), A.end());
    //vector<int> a_arr = sorting(A);
    int tmp = 0;
    for(int i=0 ; i < A.size(); i++){
        int now = A[i];
        for(; tmp <B.size(); tmp++){
            if (now < B[tmp]){
                
                tmp++;
                answer++;
                break;
            }
        }
    }
    return answer;
}

진짜 바보같이... 난 지금까지 내가 직접 정렬 코드를 함수로 만들어서 문제 풀이를 하였다.

이번에도 항상 그래왔듯이 정렬함수를 만들어서 사용하는데 정확성은 통과하지만 효율성에서 자꾸 시간초과가 나서 고민을 하였다.

퀵정렬, 병합정렬 등 시간복잡도가 낮은 정렬방식으로 할까 하다가 생각해보니 벡터 내장함수에 정렬이 있다는 걸 떠올리고 그걸로 풀이하였더니 바로 통과하였다.......진작 이렇게 할걸ㅜㅜ