GetComponent<('0')>

bottom-up과 top-down 형식의 DP(백준 14238)

Sun, 9 Jun 2024 15:19:26 +0900

백준 14238번을 풀면서 깨달은 점에 대해 정리.

https://www.acmicpc.net/problem/14238

보통 DP를 쓸 때에는 dfs 재귀함수와 조합하는 편이고,

그리고 (나의 경우에만 국한되는지는 모르나) dfs 재귀는 보통 top-down 방식을 단순하게 짜기 위해 사용한다.

아주 대표적인 예로 피보나치 수열을 dfs로 구현할 때의 dp 사용이 여기에 해당하겠다.

그런데 꼭 재귀방식의 dfs가 top-down으로만 사용되지는 않고 bottom-top 방식으로도 충분히 사용 가능하다

백준 14238번 문제의 경우 bottom-top으로 구현할때 dp가 해야하는 역할은 아래와 같다

그냥 개념적으로는 당연히 반대로 적용하면 되는데 코드 적용 시 직관적으로 이해가 가지 않았던 부분이었는데

이게 이제야 이해가 간 기분이어서 정리해봤다

같이 첨부해보는 내 답안 코드

//https://www.acmicpc.net/problem/14238
#include <iostream>
#include <string>
#include <cstring>

using namespace std;

int dp[51][51][51][3][3]; //[a개수][b개수][c개수][전전날일한사람][전날일한사람] 일 경우 차후 조합으로 가능한지 저장,  초기화 -1
string s;
string answer;
int maximum[3]; //abc 한도

bool go(int a, int b, int c, int before2day, int before1day)
{
    int &ans = dp[a][b][c][before2day][before1day];
    if(a+b+c == s.size())//탈출 조건
    {
        return ans = true;
    }
    if(ans != -1)
    {
        return ans;
    }

    //A - 유효성검사 필요 X
    if(a < maximum[0] && go(a+1,b,c,before1day,0))
    {
        answer = 'A' + answer;
        return ans = true;
    }
    //B
    if(b < maximum[1] && before1day != 1 && go(a,b+1,c,before1day,1))
    {
        answer = 'B' + answer;
        return ans = true;
    }
    //C
    if(c < maximum[2] && before1day != 2 && before2day != 2 && go(a,b,c+1,before1day,2))
    {
        answer = 'C' + answer;
        return ans = true;
    }

    return ans = false;
}

int main()
{
    cin >> s;
    for(auto a : s)
    {
        maximum[a-'A']++;
    }
    memset(dp, -1, sizeof(dp));


    if(go(0,0,0,0,0))//어차피 A는 조건에 안걸리므로 일한사람이 없어도 0으로 통일함
    {
        cout << answer;
    }
    else
    {
        cout << -1;
    }

}

SQL 자격검정 실전문제(노랭이) 오답 기록

Sat, 25 May 2024 00:08:07 +0900

I. 데이터 모델링의 이해

1. 데이터 모델링의 이해

3. 데이터 모델링 유의점 헷갈리는 거

비유연성 : 프로세스와 데이터의 정의를 분리
비일관성 : 데이터와 데이터 간 상호 연관 관계 명확히 정의 - 프로세스와 테이블의 연계성을 낮춰야 함

5-6. 데이터베이스 스키마 구조 헷갈리는 거

외부 스키마 : 여러 사용자 관점, View (외뷰..로 외우자)
개념 스키마 : 통합 사용자 관점, 모든 사용자 관점

12. 발생시점 기준의 엔티티 분류 : 기본 > 중심 > 행위 (기중행)

30. 비식별자 관계, 식별자 관계

식별자 관계	비식별자 관계
강한 연결관계	약한 연결관계
자식 주식별자에 포함	자식 일반속성에 포함
실선	점선
반드시 부모 엔터티에 자식이 종속됨 자식 주식별자 구성에 부모 주식별자 포함 필요 상속받은 주식별자 속성을 타 엔터티에 이전 필요 조인 관계 최소화	약한 종속 관계 자식 주식별자 구성은 독립적 자식 주식별자 구성에 부모 주식별자 부분 필요 상속받은 주식별자 속성을 타 엔터티에 차단 필요 부모쪽 관계참여는 선택관계

2. 데이터 모델과 SQL

35. 정규형, 정규화

정규화 : '논리 데이터 모델'의 일관성 확보, 중복 제거

제 1 정규형	제 2 정규형	제 3 정규형
속성 중복 X, 분해되지 않는 상태	일반속성은 주식별자 전체에 종속	일반속성 간 서로 종속 X
원자성 충족	완전 함수적 종속 상태
	부분 함수적 종속 X	이행적 함수 종속 X
한 튜플안에 여러개가 들어가있는경우 (쉼표로 구분되어 여러개가 들어간다던지)	기본키가 아닌 다른 속성에 종속된 상태를 부분 함수적 종속이라고 함	X를 통해 Y를 알고, Y를 통해 Z를 알 수 있어서 X->Z 가 성립할 때 이를 이행적 함수 종속 상태라고 함

49. NULL

NULL + 숫자 = NULL
NULL (비교연산자) 숫자 = Unknown
NVL/ISNULL : NULL을 치환할 때 사용
레코드 간 연산 중 NULL : 무시 / 컬럼간 연산 중 NULL : NULL

II. SQL 기본 및 활용

1. SQL 기본

1. SQL 명령어들 총정리

명령어 종류	명령어
DML(Manipulation 조작)	SELECT INSERT UPDATE DELETE
DCL(Control)	GRANT REVOKE
DDL(Definition)	CREATE ALTER DROP RENMAE
TCL(Transaction Control)	COMMIT ROLLBACK

11. 공백 문자('') 처리 in Oracle : NULL, in SQLServer : ''(그대로)

14,27. GROUP BY에서는

ALIAS(별칭) 사용 불가
NULL도 집계에 포함

20. NULL 관련 함수

함수명	설명
NVL/ISNULL(표현식1, 표현식2)	표현식1 이 NULL이면 표현식2의 값을 출력
NULLIF(표현식1, 표현식2)	표현식1,2가 서로 같으면 NULL, 다르면 표현식1
COALESCE(표현식1, 표현식2, ...)	NULL이 아닌 최초의 표현식, 다 NULL이면 NULL

37. 순수 관계 연산자 : SELECT, PROJECT, JOIN, DIVIDE (셀프조디)

41. A INNER JOIN B INNER JOIN C ON ~~~~~ (X)

A INNER JOIN B ON ~~~~~ INNER JOIN C ON ~~~~~ (O)

43. TABLE 간 JOIN 조건이 없으면 : CROSS JOIN 발생

49. (+) JOIN : 왼쪽에 붙으면 RIGHT OUTER, 오른쪽에 붙으면 LEFT OUTER

2. SQL 활용

54. UNION 에 ORDER BY는 마지막 줄에 한 번만 사용 가능

57. SQL 집계 함수

ROLLUP : 전체 합계까지 누적되는 게 특징
CUBE : 모든 조합
GROUPING SETS : 소그룹에 대한 합계만 (조합하지 않음)
GROUPING : 집계결과에 대해 1을 가지므로, CASE WHEN으로 1일 때 NULL을 변경하는데 사용

70. EXISTS, NOT EXISTS

SELECT 1 ? SELECT가 불필요해서 그냥 넣는 값이라고 함

72. 연관/비연관 서브쿼리

연관	비연관
서브쿼리가 메인쿼리 컬럼을 가지고 있는 형태	서브쿼리가 메인쿼리 컬럼을 가지고 있지 않음
메인쿼리의 조건을 확인 목적	메인쿼리에 값을 제공하기 위한 목적

지옥의 서브쿼리... 모르겠다;;

3. 관리 구문

99. CONSTRAINT

ALTER TABLE [테이블명] ADD CONSTRAINT [제약조건명] [제약조건]
CREATE 내에서 CONSTRAINT [제약조건명] [제약조건]

108. 외래키의 참조 무결성 제약 :외래키 값은 NULL이거나 참조하는 릴레이션의 기본키 값과 동일해야 한다는 제약

113. 참조 동작

DELETE/MODIFY ACTION	설명
CASACADE	MASTER 삭제 시 CHILD 같이 삭제
SET NULL	MASTER 삭제 시 CHILD 해당 필드 NULL
SET DEFAULT	MASTER 삭제 시 CHILD 해당 필드 DEFAULT
RESTRICT	CHILD에 PK가 없는 경우만 MASTER 삭제 허용
NO ACTION	참조무결성을 위반하는 삭제/수정 액션을 취하지 않음

INSERT ACTION	설명
AUTOMATIC	MASTER 테이블에 PK가 없는 경우 MASTER PK 생성 후 CHILD 입력
SET NULL	MASTER 테이블에 PK가 없는 경우 CHILD 외부키를 NULL로
SET DEFAULT	MASTER 테이블에 PK가 없는 경우 CHILD 외부키를 DEFAULT로
DEPENDENT	MASTER 테이블에 PK가 존재할 때만 CHILD 입력 허용
NO ACTION	참조무결성을 위반하는 입력 액션을 취하지 않음

119. DELETE, TRUNCATE, DROP 비교하기

DROP	TRUNCATE	DELETE
DDL	DDL(일부 DML 성격)	DML
AUTO COMMIT(ROLLBACK X)	AUTO COMMIT(ROLLBACK X)	USER COMMIT(ROLLBACK O)
정의까지 다 삭제	뼈대는 남김(초기 상태로)	삭제해도 사용한 공간은 남김(데이터만)

[C++]10942: 팰린드롬?

Tue, 7 May 2024 20:44:22 +0900

요약

재귀 + dp

풀이과정

시간복잡도를 보기위해 최악의 경우를 본다면 숫자 2000, 질문 100만이며 0.5초를 요구한다.

숫자 2000 기준으로 본다면 O(n^2)는 가능한 범위에 들어온다.

즉 2중 반복문으로 모든 숫자에 대해 팰린드롬인지 아닌지를 확인하고 이를 저장한다면

이후 무슨 질문이 나오던지간에 O(1)으로 팰린드롬 여부를 확인할 수 있기 때문에 위배되지 않을 것이다.

모든 숫자의 조합에 접근하는 순간 O(n^2)를 충족하기 때문에

범위에 대한 펠린드롬 파악 방법은 무조건 O(1)이어야 함.

이는 팰린드롬의 특성을 고려하면 쉽게 해결가능하다.

일단 dp[n+1][n+1](1부터 시작하니까..)에 저장한다고 치고

질문에서 요구하는 답의 형식(1:팰린드롬임, 0:팰린드롬아님)으로 보면

숫자가 1개일때 -> 1 -> O(1)

숫자가 2개일때 -> 같으면 1, 다르면 0 -> O(1) 임은 쉽게 알 수 있다.

숫자가 3개이상일때부터는 같은 패턴을 보이는데,

1. 빨간색끼리 같으면 1, 다르면 0 -> O(1)

2. 보라색 범위가 팰린드롬인가?

의 AND 조건이라는 점이다.

2번의 경우, 범위 크기를 1부터 늘리는 방향으로 진행해왔기 때문에 보라색 범위는 이미 전 단계에서 구해서 저장했다. 그 값을 가져오면 되니 O(1)이다.

문제는 모든 조건을 구할 때 범위가 좀 드럽다는 점인데...

대각선 방향 진행으로 우상단 방향 반복문을 진행해야 함

이는 한 대각선의 row, col값의 합이 같다는 점을 이용해 row, col을 관리하면 되지만...

나는 그냥 위의 패턴을 이용해 재귀로 풀었다.

왜냐면 질문에서 다 요구할지 안할지도 모름

표 다 채우려면 범위가 귀찮음

map[n+1][n+1]은 -1로 모두 초기화하였다. -1은 아직 기록되지 않았다는 뜻이다.

bool isF2(int a, int b)
{
    if(map[a][b] != -1)	//이미 저장된 여부가 있다면
        return map[a][b];
    if(a == b)	// 숫자 1개짜리 팰린드롬의 경우
        return map[a][b] = true;
    if(a > b)	// 짝수개일때 서로 크로스 되는 경우 예외처리
        return true;
    if(nums[a] != nums[b])	//본격적 검사 1 - 외곽 값이 서로 같은지
        return map[a][b] = false;
    
    return map[a][b] = isF2(a+1,b-1);	//본격적 검사 2 - 내부가 팰린드롬인지
}

메모이제이션 여부를 먼저 확인하고,

종료조건인 숫자 1개, 크로스 경우(이건 예외처리라 저장하지 않는다) 를 먼저 확인한다음

펠린드롬 여부를 검사한다. 검사 항목은 2가지이고 AND이기때문에 하나씩 조건검사해도 됨

코드

//https://www.acmicpc.net/problem/10942
using namespace std;
#include <iostream>
#include <vector>

vector<vector<int>> map;    //1 : 펠린드롬, 0: 펠린드롬 아님, -1: 아직 기록되지 않음
vector<int> nums;

bool isF2(int a, int b)
{
    if(map[a][b] != -1)
        return map[a][b];
    if(a == b)
        return map[a][b] = true;
    if(a > b)
        return true;
    if(nums[a] != nums[b])
        return map[a][b] = false;
    
    return map[a][b] = isF2(a+1,b-1);
}

int main()
{
    int N; scanf("%d", &N);
    map.resize(N+1,vector<int>(N+1,-1)); 
    nums.resize(N+1);
    for(int i = 1; i <= N; i++)
        scanf("%d", &nums[i]);
    int M;  scanf("%d", &M);
    while(M--)
    {
        int a, b;   scanf("%d %d",&a,&b);
        printf("%d\n",isF2(a,b));
    }
}

기억할 점

다른 사람의 풀이

[C++]15486: 퇴사 2

Tue, 7 May 2024 19:20:24 +0900

요약

bottom-up 방식이면 O(n)으로 가능하고, top-down이면 O(n^2)

풀이과정

일단 시간복잡도를 가늠해보면 n은 150만이다.

O(n^2) 불가능하고, O(nlongn), O(n)정도 가능해 보인다.

수익의 최대는 일단 고려하지 않는다면, 아래와 같이 생각할 수 있다.

내가 오늘 상담을 한다면? : 이 상담이 끝나는 날 : 오늘 수익 + 오늘 상담 수익

내가 오늘 상담을 하지 않는다면? : 아무것도 변하지 않음

i번째 날 수익을 버는 경우의 수는 다양하며, 이 경우의 수 중에서 최대의 수익을 버는 경우를 고려하려면...

최대 수익을 저장하는 행렬(이든 벡터든) dp에 접근할때마다 max값으로 갱신한다.

내가 오늘 상담을 한다면? : dp[상담끝나는날] = max(기존수익, 오늘수익+오늘상담수익)

문제는 내가 오늘 상담을 하지 않는다면? 이다.

이것도 똑같이 생각하면 된다. 오늘 일하지 않는다는 것은, 내일 수익이 오늘 수익과 같다는 것이다.

내가 오늘 상담을 하지 않는다면? : dp[내일] = max(기존수익, 오늘수익)

그러면 1일부터 n일까지 한번씩 해주면 되니까 O(n)만에 문제 해결이 가능해진다.

O(n)이 되는 이유는 이 문제의 특성 상, 1일부터 n일까지 순서대로 채우면 무조건 max값이 보장된다는 점 때문이다

(미래의 값이 과거에 영향을 줄 수 없음 - 시간의 특성이 반영된 문제)

그게 아니면 모든 경우의 수를 고려해야하니 O(n^2)이 걸렸겠지?

그리고 상담을 하는 경우, 벡터 범위를 뛰쳐나갈수 있으니 상담이 끝나는 날이 n+1일 이하인경우만 계산하게끔 해줘야 런타임 에러가 발생하지 않음

코드

//https://www.acmicpc.net/problem/15486
#include <iostream>
#include <vector>

using namespace std;
vector<int> schedule;
vector<int> pay;
vector<int> dp;


int main()
{
    int n;  scanf("%d", &n);
    schedule.resize(n+1,0);
    pay.resize(n+1,0);
    dp.resize(n+2,0);
    for(int i = 1; i <= n; i++)
    {
        scanf("%d %d",&schedule[i], &pay[i]);
    }

    for(int i = 1; i <= n; i++)
    {
        //상담을 한다면
        if(i+schedule[i] <= n+1)
            dp[i+schedule[i]] = max(dp[i+schedule[i]], dp[i]+pay[i]);
        //상담을 하지 않는다면
        dp[i+1] = max(dp[i+1],dp[i]);
    }

    printf("%d",dp[n+1]);
    return 0;
}

기억할 점

다른 사람의 풀이

[C++]3111번: 검열

Sun, 5 May 2024 12:13:05 +0900

요약

처음에 문제 이해가 안갔는데, 앞뒤앞뒤 이렇게 제거한다는 얘기였다

stack 2개를 사용하여 문자열 그대로 / 리버스 문자열 2개를 대상으로 앞 뒤 제거를 진행하였다.

서로 제거 범위가 겹치지 않도록 index를 저장해서 관리해줘야 한다!

풀이과정

첫시도 - 스택 활용(시간초과)

1. 검열 문자열과, 신문 문자열을 뒤집어서도 저장 - right stack을 위해서

2. left stack point + right stack point의 합이 신문 문자열의 크기보다 작은 동안만 stack에 넣으며 검사를 진행

3. 앞뒤로 문자열을 나누었기 때문에, 마지막에 이 문자열을 합치면서 나오는 검열 문자열이 있는지 한 번 검사 - 겸사겸사 문자열을 합치기 위해 right stack에 있는 것들을 left stack에 넣으면서 검사하기

4. left stack에 들어가 있는 문자열을 출력

//https://www.acmicpc.net/problem/3111
using namespace std;

#include <iostream>
#include <stack>
#include <string>

#define     left    0
#define     right   1

stack<char> s[2];
int p[2];
int wsize, psize;
string word[2];
string paper[2];

// 현재 stack 상단에 검열 문자열이 있는지 확인
bool isCensored(stack<char> s, string &word)
{
    //검열 문자열보다 stack 크기가 작음 - false
    if(s.size() < word.size()) return false;
    for(int i = word.size()-1; i >= 0; i--)
    {
        char temp = s.top();    s.pop();
        if(temp != word[i]) return false;   
    }
    return true;
}

// 문자열에서 검열 문자열의 크기만큼 pop
void popWord(stack<char> &s)
{
    for(int i = 0; i < wsize; i++)
        s.pop();
}

// stack의 값을 뒤집어서 string으로 반환
string stackReverse(stack<char> &s)
{
    string result;
    while(!s.empty())
    {
        result = s.top() + result;
        s.pop();
    }
    return result;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
    cin >> word[left] >> paper[left];
    wsize = word[left].size();
    psize = paper[left].size();

    for(int i = wsize-1; i >= 0; i--)
    {
        word[right] += word[left][i];
    }
    for(int i = psize-1; i >= 0; i--)
    {
        paper[right] += paper[left][i];
    }
    while(p[left] + p[right] < psize)
    {
        for(int i = 0; i < 2; i++)  // i(0) : left, i(1) : right
        {
            while(p[left]+p[right] < psize)    
            {
                // if(i == 0) cout << "left " << p[i] << endl; else cout << "right "<< p[i] << endl;
                s[i].push(paper[i][p[i]++]);  //pointer 위치의 paper char 하나를 stack에 push하고 pointer += 1
                // cout << s[i].top() << " ";
                if(isCensored(s[i], word[i]))
                {//검열 문자열 상단에서 발견
                    // cout << word[i] << " detected" << endl;
                    popWord(s[i]);
                    break;
                }
            }
        }
    }
    // right stack 을 left stack으로 몰아넣고 검열 단어가 나오는지 마지막으로 확인
    if(!s[right].empty())
    {
        while(!s[right].empty())
        {
            s[left].push(s[right].top());
            s[right].pop();
            if(isCensored(s[left], word[left]))
            {
                // cout << word[left] << " detected \n";
                popWord(s[left]);
            }
        }
    }

    // left stack의 값 출력
    cout << stackReverse(s[left]) << endl;
}

이전에 비슷하게 푼 문제를 stack으로 풀었는데, stack으로 푸려다가 더 시간이 오래걸리는게 아닌가 생각이 듦
왜냐면, stack 검사도 pop했다가, 검열문자 발견되면 pop하는데 이게 완전히 중복되는 과정이다.
그렇다고 stack을 reference로 참조시키기에는, 검열문자가 발견되지 않을 경우 push하는 불필요한 과정이 들어가고 말음
그래서 stack대신 string으로 바꿨더니 1372ms로 통과(아슬아슬;)

코드

//https://www.acmicpc.net/problem/3111
using namespace std;

#include <iostream>
#include <stack>
#include <string>

#define     left    0
#define     right   1

int p[2];
int wsize, psize;
string word[2];
string paper[2];
string leftright[2];

// 현재 stack 상단에 검열 문자열이 있는지 확인
bool isCensored(string &s, string &word)
{
    int ssize = s.size();
    //검열 문자열보다 크기가 작음 - false
    if(ssize < wsize) return false;
    for(int i = 0; i < wsize; i++)
    {
        if(s[ssize - wsize + i] != word[i]) return false;
    }

    return true;
}

// 문자열에서 검열 문자열의 크기만큼 제거
void popWord(string &s)
{
    s = s.substr(0,s.size()-wsize);
}

// stack의 값을 뒤집어서 string으로 반환
string stackReverse(stack<char> &s)
{
    string result;
    while(!s.empty())
    {
        result = s.top() + result;
        s.pop();
    }
    return result;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
    cin >> word[left] >> paper[left];
    wsize = word[left].size();
    psize = paper[left].size();

    for(int i = wsize-1; i >= 0; i--)
    {
        word[right] += word[left][i];
    }
    for(int i = psize-1; i >= 0; i--)
    {
        paper[right] += paper[left][i];
    }
    while(p[left] + p[right] < psize)
    {
        for(int i = 0; i < 2; i++)  // i(0) : left, i(1) : right
        {
            while(p[left]+p[right] < psize)    
            {
                // if(i == 0) cout << "left " << p[i] << endl; else cout << "right "<< p[i] << endl;
                leftright[i] += paper[i][p[i]++];
                // cout << s[i].top() << " ";
                if(isCensored(leftright[i], word[i]))
                {//검열 문자열 상단에서 발견
                    // cout << word[i] << " detected" << endl;
                    popWord(leftright[i]);
                    break;
                }
            }
        }
    }

    // cout << leftright[left] << endl << leftright[right] << endl;
    // right stack 을 left stack으로 몰아넣고 검열 단어가 나오는지 마지막으로 확인
    for(int i = leftright[right].size()-1; i >= 0; i--)
    {
        leftright[left] += leftright[right][i];
        if(isCensored(leftright[left], word[left]))
        {
            popWord(leftright[left]);
        }
    }
    cout << leftright[left] << endl;
}

기억할 점

다른 사람의 풀이

substr 대신 leftright에 index를 따로 지정해주는 방법이 있다.
즉, leftright 끝에서 검열 문자열이 발견되는 경우, 이 index를 검열문자열의 크기만큼 앞으로 땡겨버리는 것이다.

l	u	k	a	n	e
0	1	2	3	4	5	6
				b	<<	a

lukane에서 ne가 검열문자열인 경우 index가 6인데, 발견되는 순간 ne의 크기인 2만큼 빼버린다.

그리고 차후 입력을 b의 위치에서부터 하면 자연스럽게 해당 부분이 무시된다.

출력할때도 b까지만 출력하게 하면 된다.

다만 이 방법을 사용하려면 index기반 값 입력이므로 string 대신 vector나 array사용이 필요해 보인다.

(string도 index를 통한 접근이 가능하지만 기존에 미리 특정 크기만큼 할당하는게 어려우므로... -string은 크기 지정 초기화 시 빈 채로 지정이 안돼서 메모리낭비로 보임)

자주쓰지만 까먹는 것들

Thu, 23 Nov 2023 08:33:01 +0900

띄어쓰기로 string 분리 저장하기

    std::string sentence = "Hello world! This is a sentence.";
    std::vector<std::string> words;

    // stringstream을 사용하여 string을 띄어쓰기로 분리
    std::stringstream ss(sentence);
    std::string word;
    while (ss >> word) {
        words.push_back(word);
    }

특정 구분자로 string 분리 저장하기

    string str = "apple,banana,orange";
    vector<string> vec;
    stringstream ss(str);
    string token;
    while(getline(ss,token,','))
        vec.push_back(token);
    for(const auto& ele : vec)
        cout << ele << endl;

파일 열어서 쓰기

    char arr[]= "Hello, World!";
    std::ofstream file("output.txt");
    if (file.is_open()) {
        file << arr;
        file.close();
    }

파일 열어서 읽어오기

ifstream file("input.txt");
vector<string> row;
if(file.is_open())
{
    string str;
    while(getline(file,str))
    {
        row.push_back(str));
    }
    file.close();

[C++]입국심사

Wed, 3 May 2023 11:29:47 +0900

풀이과정

1차 시도(실패)

먼저, times를 오름차순 정렬한 뒤, etimes라는 벡터를 만든다.
times의 index에 대응하는 심사관에게 지금 대기할 경우, 대기자의 업무가 끝나는 시간이다.

    for(int index = 0; index < n; index++)
    {
        int min_index = min_element(etimes.begin(),etimes.end())-etimes.begin();
        etimes[min_index] += times[min_index];
    }

들어가는 사람마다 etimes이 최소값인 index를 찾고, etimes를 업데이트해준다(검사시간만큼 더함)
[사람][etimes]
[1][14,10]
[2][14,20]
[3][21,20]
[4][21,30]
[5][28,30]
[6][35,30]
모든 사람에 대한 etimes를 끝낸 후, etimes는 다음 손님의 예상 종료시간이기 때문에 times만큼 값을 빼준다.

    for(int i = 0; i < times.size(); i++)
        etimes[i] -= times[i];
    answer = *max_element(etimes.begin(), etimes.end());

그러면 [35,30]이었던 값이 [28,20]이 되겠지?
여기서 max_element값을 answer로 반환한다.

테스트 1 〉통과 (0.01ms, 4.11MB)
테스트 2 〉통과 (0.10ms, 3.66MB)
테스트 3 〉통과 (2.62ms, 4.18MB)
테스트 4 〉통과 (4968.05ms, 7.66MB)
테스트 5 〉실패 (시간 초과)
테스트 6 〉실패 (시간 초과)
테스트 7 〉실패 (시간 초과)
테스트 8 〉실패 (시간 초과)
테스트 9 〉통과 (4155.45ms, 4.18MB)

당연하게도 시간초과가 났다.

문제 분석

위 코드의 시간복잡도는 O(n)이다. 문제는 이 n이 최대 1,000,000,000이라는 것...
내 방식에서는 시간 초과가 불가피하다.

2차 시도(성공)

이분 탐색 문제 답게, 이분 탐색으로 풀어야 한다.
탐색 기준 : 시간
low : 정렬한 times의 최소값 즉 times[0]
high : 모든 사람 n이 최악의 심사관 즉, times[times.size()-1]에게 갔을 때의 시간
조건 : 주어진 시간동안 모든 검사관이 받을 수 있는 사람과 n을 비교

예제로 예시를 들자면,
low : 7, high : 10*6 = 60
mid : (7+60)/2 = 33부터 시작

1) mid : 33일 때
최대 처리 가능 사람의 수 : 33/7+33/10 = 7
n인 6과 비교했을 시 high > 왼쪽 탐색
high = mid-1 = 32 갱신

2) mid : (32+7)/2 = 19
최대 처리 가능 사람의 수 : 19/7+19/10 = 3
n인 6과 비교했을 시 low > 오른쪽 탐색
low = mid+1 = 20 갱신

3) mid : (20+32)/2 = 26
최대 처리 가능 사람의 수 : 26/7 + 27/10 = 5
n인 6과 비교했을 시 low > 오른쪽 탐색
low = mid+1 = 27 갱신

4) mid : (27+32)/2 = 29
최대 처리 가능 사람의 수 : 29/7 + 29/10 = 6
n인 6과 비교했을 시 같으나, low < high인 상황이라 high = mid-1로 재갱신

5) mid : (27+28)/2 = 27
최대 처리 가능 사람의 수 : 27/7 + 27/10 = 5
n인 6과 비교했을 시 low >오른쪽 탐색
low = mid + 1 = 28 갱신

6) low <= high 조건 불만족으로 while문 탈출

주의점

자료형자료형자료형자료형자료형자료형자료형자료형자료형
범위범위범위범위범위범위범위범위범위범위범위범위범위

코드

#include <bits/stdc++.h>
using namespace std;

long long solution(int n, vector<int> times) {
    long long answer = 0;
    sort(times.begin(),times.end());
    long long low = times[0];
    long long high = (long long)*(times.end()-1) * n;
    while(low <= high)
    {
        long long mid = (low+high)/2;
        long long people(0);
        for(int t : times)
        {
            people += mid/t;
            if(people >= n) break;  //추가 연산 하지 않게
        }
        if(people >= n)  //go to left
        {
            high = mid-1;
            answer = mid;
        }
        else //go to right
            low = mid + 1;


    }
    return answer;
}

기억할 점

다른사람의 풀이

[C++]단속카메라

Fri, 28 Apr 2023 14:13:48 +0900

요약

routes 오름차순 정렬
카메라 범위 설정풀이과정순서대로 routes를 체크하기 위해 sort해준다.
예제[[-20,-15], [-14,-5], [-18,-13], [-5,-3]]의 경우
[[-20,-15], [-18,-13],[-14,-5],[-5,-3]] 으로 정렬한단 얘기
이후 각 자동차마다 camera 설치 가능 범위를 정한다.

맨 처음 자동차를 감시할 수 있는 범위

두번째의 경우 (-18,-15)로 줄어든다.

세 번째의 경우 더이상 하나의 카메라로 감시할 수 없게 됐다.

검사 조건은 camera 범위의 end값과 routes[i][0] 값을 비교하면 된다.

이런 식으로 구현하였다.

코드

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

using namespace std;

int solution(vector<vector<int>> routes) {
    int answer = 1;
    int start = 0;
    int end = 0;
    bool cam = false;
    sort(routes.begin(), routes.end());
    for(int i = 0; i < routes.size(); i++)
    {
        if(routes[i][0] > end)
        {    //현재 범위(start,end)를 벗어나는 차량
            cam = false;
            answer++;
        }

        if(cam == false)    //새로운 카메라 범위 시작
        {
            cam = true;
            start = routes[i][0];
            end = routes[i][1];
        }
        else    //카메라 범위 업데이트
        {
            start = routes[i][0];
            end = min(end, routes[i][1]);
        }
    }
    return answr;
}

기억할 점

다른사람의 풀이

나는 시작점 정렬로 풀었는데, 끝점 정렬로 풀면 범위 start, end에서 start가 필요치 않다. camera의 마지막 부분과 routes[i][0]을 비교하고, 필요에 따라 routes[i][1]로 start를 갱신해주면 된다. bool 변수도 없이 구현이 가능하다.

#include <bits/stdc++.h>

using namespace std;

bool cmp(vector<int> a, vector<int> b) { return a[1] < b[1]; }

int solution(vector<vector<int>> routes) {
    int answer = 0;
    int limit = -30001;
    sort(routes.begin(), routes.end(), cmp);
    for(int i = 0; i < routes.size(); i++){
        if(limit < routes[i][0]){
            answer++;
            limit = routes[i][1];
        }
    }
    return answer;
}

함수 오버로딩(Function Overloading)

Tue, 4 Apr 2023 11:09:29 +0900

함수 오버로딩

같은 이름의 함수를 두 개 이상 정의하여 사용하는 것
함수명은 같으나, parameter list 부분이 달라야 함
함수 type(X), parameter 순서(O), type(O), 개수(O), 구성 etc... parameter list가 달라야 함.
pointer의 const 여부도 다른 type으로 인식함!
parameter type 자동형변환에 의한 호출이 가능함. 단, 대표타입에 한해서

Default Parameter

함수의 매개변수에 기본값을 정의할 수 있다.

int Function(int, int, int = 1, int = 2);

int main()
{
    Function(1,2,3,4);    //default parameter 사용 X
    Function(1,2,3);    //(1,2,3,2)
    Function(1,2);        //(1,2,1,2)
    Function(1);        //error
    Function();            //error
    Function(1,2,,4);    //error -> 이런 구조는 불가능
}

Default Parameter를 지정하면 그 이후의 parameter는 모두 Default Parameter로 지정되어야 함!

void func(int a = 10, int b, int c);    
void func(int a = 10, int b = 20, int c);    
void func(int a, int b = 20, int c);
void func(int(a = 10; int b, int c = 30);

위의 경우는 모두 불가능. default parameter를 부분적으로 사용하고 싶다면 다 뒤로 빼야 한다.

함수 overlading과 default parameter를 같이 사용 시, 형태의 모호함이 발생한다면 컴파일 오류가 난다.

void prn(char *);
void prn(char *, int = 10);    //error!!

실습 with ChatGPT

Low Difficulty

Write a C++ program that defines a function called print that takes a single argument of type int and prints it to the console. Then overload the print function to take a single argument of type double and prints it to the console as well. Use default parameter for the double version of print, so that the user can call the function with just one argument and it will be treated as a double by default.

Code

/*
Write a C++ program that defines a function called print that takes a single argument of type int and prints it to the console. 
Then overload the print function to take a single argument of type double and prints it to the console as well. 
Use default parameter for the double version of print, 
so that the user can call the function with just one argument and it will be treated as a double by default.
*/
#include <iostream>
using namespace std;

void print(int n)
{
    cout << "int print" << endl;
    cout << n << endl;
}

void print(double n = 0.0)
{
    cout << "double print" << endl;
    cout << n << endl;
}

int main()
{
    int num = 3;
    double num2 = 2.5;
    print(3);
    print(num2);
    print();
    print(num);
}

출력 결과

int print
3
double print
2.5
double print
0
int print
3

Medium Difficulty

Write a C++ program that defines a function called sum that takes two arguments of type int and returns their sum.
Then overload the sum function to take three arguments of type int and return their sum.
Use default parameters for the third argument of the sum function,
so that the user can call the function with just two arguments and the third argument will be assumed to be 0 by default.

Code

/*
Write a C++ program that defines a function called sum that takes two arguments of type int and returns their sum. 
Then overload the sum function to take three arguments of type int and return their sum. 
Use default parameters for the third argument of the sum function, 
so that the user can call the function with just two arguments and the third argument will be assumed to be 0 by default.
*/
#include<iostream>
using namespace std;
int sum(int a, int b, int c=0)
{
    return a+b+c;
}

int main()
{
    cout << sum(1,2) << endl;
    cout << sum(2,3,4) << endl;
}

출력 결과

3
9

High Difficulty

Write a C++ program that defines a class called Rectangle with private member variables width and height. The class should have the following public member functions:

A default constructor that sets both width and height to 0.
A constructor that takes two arguments of type int and sets width and height to those values.
A function called area that takes no arguments and returns the area of the rectangle (width times height).
Overload the + operator to allow adding two Rectangle objects together, which should return a new Rectangle object whose width and height are the sums of the width and height of the two operands, respectively.
Overload the << operator to allow outputting a Rectangle object to the console. This should print the values of width and height of the Rectangle object.

Code

/*
Write a C++ program that defines a class called Rectangle with private member variables width and height. 
The class should have the following public member functions:

A default constructor that sets both width and height to 0.
A constructor that takes two arguments of type int and sets width and height to those values.
A function called area that takes no arguments and returns the area of the rectangle (width times height).
Overload the + operator to allow adding two Rectangle objects together, 
which should return a new Rectangle object whose width and height are the sums of the width and height of the two operands, respectively.
Overload the << operator to allow outputting a Rectangle object to the console. 
This should print the values of width and height of the Rectangle object.
*/

#include <iostream>
using namespace std;

class Rectangle {
    int height, width;
    public:
        Rectangle() : height(0), width(0) { }
        Rectangle(int a, int b) : height(a), width(b) { }
        int area()
        {
            return height * width;
        }
        Rectangle operator+(const Rectangle &obj);
        friend ostream& operator<<(ostream& os, const Rectangle &obj);
};

Rectangle Rectangle::operator+(const Rectangle &obj)
{
    Rectangle temp(height + obj.height, width + obj.width);
    return temp;    
}

ostream& operator<<(ostream& os, const Rectangle &obj)
{
    os << "height : " << obj.height << ", width : " << obj.width << endl;
    return os;
}

int main()
{
    Rectangle rect1;
    cout << rect1;
    Rectangle rect2(2, 3);
    Rectangle rect3(1, 1);
    cout << rect2;
    cout << rect2.area() << endl;
    Rectangle rect4 = rect2 + rect3;
    cout << rect4.area() << endl;
}

실행 결과

height : 0, width : 0
height : 2, width : 3
6
12

갑자기 연산자 오버로딩을 시켜서 좀 당황하였다.

[C++]모음사전

Mon, 13 Mar 2023 19:41:53 +0900

요약

경우의 수 파악

풀이과정

솔직히 이렇게 풀라고 낸 의도는 아닐텐데...

수학식을 세워서 풀었다.

자릿수마다 A,E,I,O,U가 가능하니 5를 그만큼 곱한다.

A _ _ _ _ 의 경우의 수는

5자리인 경우 5*5*5*5

4자리인 경우 5*5*5

3자리인 경우 5*5

2자리인 경우 5

1자리인 경우 1(5^0)

인 것이다.

예를 들어,

맨 앞자리가 E이면 A _ _ _ _ 인 경우의 수만큼 앞에 존재하는 것이라 생각해서 식을 세웠다.

AAAAE	A	(1-1)*(5^4+5^3+5^2+5^1) + 1
	A	(1-1)*(5^3+5^2+5^1) + 1
	A	(1-1)*(5^2+5^1) + 1
	A	(1-1)*(5^1) + 1
	E	2

AAAE	A	(1-1)*(5^4+5^3+5^2+5^1) + 1
	A	(1-1)*(5^3+5^2+5^1) + 1
	A	(1-1)*(5^2+5^1) + 1
	E	(2-1)*(5^1) + 1

(3-1)*(5^4+5^3+5^2+5^1) + 3

EIO	E	(2-1)*(5^4+5^3+5^2+5^1) + 2
	I	(3-1)*(5^3+5^2+5^1) +3
	O	(4-1)*(5^2+5^1) + 4

코드

#include<bits/stdc++.h>
using namespace std;

int ctoi(char c)
{
    int num;
    switch(c)
    {
        case 'A':
            num = 1;
            break;
        case 'E':
            num = 2;
            break;
        case 'I':
            num = 3;
            break;
        case 'O':
            num = 4;
            break;
        case 'U':
            num = 5;
            break;
    }
    return num;
}

int solution(string word) {
    int answer = 0;
    for(int i = 0; i < word.length(); i++)
    {
        int powSum = 0;
        for(int j = 4-i; j>0; j--)
            powSum += pow(5,j);
 
        answer += (ctoi(word[i])-1) * powSum + ctoi(word[i]);
    }
    return answer;
}

이렇게 나와서 식겁했는데 그냥 오류였다.

다른 사람의 풀이

첫번째 풀이

같은 풀이 방식이나 더 간결하게 정리한 코드이다.

#include <string>

using namespace std;

int solution(string word) {
    string v = string("AEIOU");
    int a = word.size();

    for(int i = 0, b = 1; i < word.size(); i++, b *= 5)
        a += v.rfind(word[i]) * 781 / b;

    return a;
}

v.rfind(word[i])

"AEIOU"에서 word의 각 자리수와 일치하는 index를 반환한다.

내가 쓴 코드에서 ctoi switch문으로 장황하게 A:1 E:2 I:3 O:4 U:5 한것을 하나로 일축한 방식이다.

781

이 값이다.

예를들어, 위 예제 중 EIO에서 'I'는 (3-1)*(5^3+5^2+5^1) +3 라는 식을 도출했다.

3끼리 식을 묶으면

3(5^3+5^2+5^1+5^0)-(5^3+5^2+5^1)

식을 하나로 통합하려면

3(5^3+5^2+5^1+5^0)-(5^3+5^2+5^1+5^0)+5^0 = 2*(5^3+5^2+5^1+5^0)+1

이게 된다.

EIO	E	(1)*(5^4+5^3+5^2+5^1+5^0) + 1
	I	(2)*(5^3+5^2+5^1+5^0) +1
	O	(3)*(5^2+5^1+5^0) + 1

2에 해당하는 값은 'A':0, 'E':1, 'I':2, 'O':3, 'U':4 를 그대로 가져가면 된다.

매번 781을 b= 5, 5^2, 5^3 ... 이렇게 나눠준 이유는, 소숫점 자리 이하를 버리는 것이 Default이기 때문이다.

5^4+5^3+5^2+5^1+1 을 5로 나누면?

5^3+5^2+5^1+1+0.2 가 된다.

여기서 0.2는 버려진다.

따라서 깔끔하게, 5^3+5^2+5^1+1 이 되는 것.

맨 뒷 항의 +1 은 자릿수마다 생기므로 맨 앞에서 a = word.size(); 를 해준 이유가 된다.

1. rfind를 통해 index로 AEIOU를 01234로 바꿔먹은 것

2. 나머지가 안생기는 점을 이용해 5로 나누는 것

이건 기억해두면 좋을 것 같다.

위 코드를 기반으로 내 코드를 수정해봤다.

#include<bits/stdc++.h>
using namespace std;

int solution(string word) {
    int answer = 0;
    string s = "AEIOU";
    int powSum = 0;
    for(int i = 0; i < 5; i++)
        powSum += pow(5,i);
    for(int i = 0; i < word.length(); i++)
    {
        answer += s.rfind(word[i]) * powSum + 1;
        powSum/=5;
    }
    return answer;
}

781을 상수로 그대로 쓰는건 실제로는 좋지 않다 생각해서

외부에서 powSum으로 계산하는 과정을 추가했다.

첫 풀이는 어찌됐든간에 이중 반복문이라 O(n^2)의 시간복잡도를 지녔지만,

두번째 풀이에서는 O(n)이 되어서 시간이 확실히 줄었다.

두번째 풀이

그냥 거듭제곱의 합 계산에서 DP를 쓰는 방법이다. DP[0] = 1, DP[1] = 5를 주고

DP[2]부터 DP[5] 까지 DP[i] = 5*(DP[i-1]+1)으로 구하는 방법이다. 그 외는 같다.