신이 나는 프로그래밍

sql lv3) 헤비 유저가 소유한 장소

junl — Sun, 5 Jul 2026 23:01:28 +0900

-- 코드를 입력하세요
# 서브쿼리 복수 리턴은 = 이 아닌 IN 으로 써야함.
# 갯수 조건은 GROUBY HAVING COUNT(TAR) >= 2 처럼 작성
# WHERE에서 COUNT는 안됨
# https://wikidocs.net/300578   서브쿼리 예제
SELECT ID, NAME, HOST_ID FROM PLACES
WHERE HOST_ID IN (SELECT HOST_ID FROM PLACES GROUP BY HOST_ID
HAVING COUNT(HOST_ID)>=2
      )
ORDER BY ID ASC

타인풀이

-- 다른 사람 풀이
# WITH 사용  
# WITH문이란?  이름을 가진 SubQuery를 정의한 후 사용하는 구문.

WITH HU AS (
    SELECT HOST_ID
    FROM PLACES
    GROUP BY host_id
    HAVING COUNT(ID) >= 2
)
-- 헤비 유저가 등록한 공간의 정보 모두 조회
SELECT *
FROM PLACES
WHERE HOST_ID IN (SELECT * FROM HU)
ORDER BY ID ASC

서브쿼리 , Group by , 조건 having count

(lv2) [3차] 파일명 정렬 [todo: 깔끔한 코드로 정리]

junl — Sun, 28 Jun 2026 23:23:20 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/17686

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

구현문제

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

using namespace std;
//대소문자 구분x
//정렬 조건 h: 오름차순 , n: 숫자로만들어서 오름차순정렬

bool comp(string v, string t) {
    int t_size;
    if (v.size() > t.size()) {
        t_size = t.size();
    }
    else {
        t_size = v.size();
    }
    for (int idx = 0; idx < t_size; ++idx) {
        //대소문자 구분하지 않으면서도 기존 벡터 변형 없게 만들려고
        //임시값 ch1, ch2 생성
        char ch1 = v[idx];
        char ch2 = t[idx];
        //header 단계
        //idx별 문자가 동일할 때 먼저 숫자에 접근할 경우 true를 리턴해 낮은 은 값 정렬
        //둘다 숫자 접근 시 다음 단계인 숫자 비교로 넘어감
        if (ch1 >= '0' && ch1 <= '9' && ch2 >= '0' && ch2 <= '9')break;
        if (ch1 >= '0' && ch1 <= '9') {
            return true;
            break;
        }
        if (ch2 >= '0' && ch2 <= '9') {
            return false;
            break;
        }
        if (ch1 >= 'a' && ch1 <= 'z') {
            ch1 = 'A' + ch1 - 'a';
        }
        if (ch2 >= 'a' && ch2 <= 'z') {
            ch2 = 'A' + ch2 - 'a';
        }

        if (ch1 < ch2) return true;
        if (ch1 > ch2) return false;
    }

    // if(v.size() < t.size()) return true;
     //if(v.size() > t.size()) return false;

// 숫자형태의 문자열 변수
    string vs = "";
    string ts = "";
    int flag = 0;
    int cnt = 0;
    //숫자는 5개 제한.
    for (int idx = 0; idx < v.size(); ++idx) {
        if (v[idx] >= '0' && v[idx] <= '9') {
            vs += v[idx];
            cnt++;
            flag = 1;
        }
        else {
            if (flag == 1) {
                break;
            }
        }
        if (cnt >= 5)break;
    }
    flag = 0;
    cnt = 0;
    for (int idx = 0; idx < t.size(); ++idx) {
        if (t[idx] >= '0' && t[idx] <= '9') {
            ts += t[idx];
            cnt++;
            flag = 1;
        }
        else {
            if (flag == 1) {
                break;
            }
        }
        if (cnt >= 5)break;
    }

//숫자 비교해서 오름차순 정렬 진행.
    int vVal = 0;
    int tVal = 0;
    vVal = stoi(vs);
    tVal = stoi(ts);
    if (vVal < tVal)return true;
    if (vVal > tVal)return false;
    return false;
}
vector<string> solution(vector<string> files) {

    stable_sort(files.begin(), files.end(), comp); // sort로 하면 안정적인 정렬이 아니라 함. stable_ 을 넣어야함
    vector<string> answer;
    for (int y = 0; y < files.size(); ++y) {
        for (int x = 0; x < files[y].size(); ++x) {
            cout << files[y][x];
        }
        cout << endl;
    }

    return files;
}

int main(void) {
    solution({ "foo9.txt", "foobar1.txt" });
}

lv3) 정수 삼각형

junl — Thu, 25 Jun 2026 23:26:52 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/43105

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

#1 위->아래

#include <string>
#include <vector>

using namespace std;

int dp[501][501];
int solution(vector<vector<int>> triangle) {
    dp[0][0] = triangle[0][0];
    int n = triangle.size();
    for (int y = 0; y < n - 1; ++y) {
        for (int x = 0; x < triangle[y].size(); ++x) {
            dp[y + 1][x] = max(dp[y + 1][x], dp[y][x] + triangle[y + 1][x]);
            dp[y + 1][x + 1] = max(dp[y + 1][x + 1], dp[y][x] + triangle[y + 1][x + 1]);
        }
    }
    int maxi = -1;
    for (int x = 0; x < 501; ++x) {
        if (maxi < dp[n - 1][x]) {
            maxi = dp[n - 1][x];
        }
    }
    return maxi;
}

int main() {
    solution({ {7},{3,8},{8,1,0},{2,7,4,4} ,{4,5,2,6,5} });
}

#2 아래->위

#include <string>
#include <vector>

using namespace std;

int dp[501][501];
int solution(vector<vector<int>> triangle) {
    dp[0][0] = triangle[0][0];
    int n = triangle.size();
    for (int y = 1; y < n; ++y) {
        for (int x = 0; x < triangle[y].size()-1; ++x) {
            dp[y][x] = max(dp[y][x], dp[y-1][x] + triangle[y][x]);
            dp[y][x + 1] = max(dp[y][x + 1], dp[y-1][x] + triangle[y][x + 1]);
        }
    }
    int maxi = -1;
    for (int x = 0; x < 501; ++x) {
        if (maxi < dp[n - 1][x]) {
            maxi = dp[n - 1][x];
        }
    }
    return maxi;
}

int main() {
    solution({ {7},{3,8},{8,1,0},{2,7,4,4} ,{4,5,2,6,5} });
}

lv2 ) 완전범죄(틀림) 그리디 vs DP

junl — Fri, 19 Jun 2026 00:26:10 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/389480#

그리디로 접근 (실패)

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

//다중조건: 1. 2번째 원소 오름차순  2. 1번째 원소 오름차순 

bool comp1(vector<int> v, vector<int> tar){
    if(v[0] != tar[0])
        return v[0] > tar[0]; // A 내림차순
    return v[1] < tar[1];     // A 같으면 B 오름차순
} // v == tar 인 경우 v <= tar  -> true 반환. 이는 comp(x, x) = true가 되어버림에 따른 sort 알고리즘 내부 규칙에 위반 됨. 그렇기에 v < tar로 하자.
bool comp2(vector<int> v, vector<int> tar){
    if(v[1]!=tar[1]){ // B흔적 내림차순
        return v[1] < tar[1];
    }
    //2. 만약 B의 흔적이 같다면 A의 흔적(idx 0) 오름차순정렬
    return v[0] < tar[0];
}


int solution(vector<vector<int>> info, int n, int m) {
    int suml = 0; // return
    int sumr = 0;
    
    int flag = 1;
    sort(info.begin(), info.end(), comp1); // 정렬
    
    for(int y = 0; y < info.size(); ++y){
            if(flag == 1){
                sumr+=info[y][1];
                if(sumr >= m){
                    sumr-=info[y][1];
                    suml+=info[y][0];
                    if(suml>=n){
                        suml = -1;
                        break;
                    }
                    flag = 0;
                }
            }
            else{
                suml+=info[y][0];
                if(suml>=n){
                    suml = -1;
                    break;
                }
            }
    }
    int suml2 = 0, sumr2 = 0;
    flag = 1;
    sort(info.begin(), info.end(), comp2); // 정렬
    for(int y = 0; y < info.size(); ++y){
        cout<<info[y][0]<<" "<<info[y][1]<<endl;
            if(flag == 1){
                sumr2+=info[y][1];
                if(sumr2 >= m){
                    sumr2-=info[y][1];
                    suml2+=info[y][0];
                    if(suml2>=n)
                    {
                        suml2 = -1;
                        break;
                    }
                    flag = 0;
                }
            }
            else{
                suml2+=info[y][0];
                if(suml2>=n){
                    suml2 = -1;
                    break;
                }
            }
    }
    if(suml == -1)return suml2;
    if(suml2 == -1)return suml;
    if(suml>suml2)return suml2;
    return suml;
}

이 코드의 전략은:

"B에게 계속 몰아주다가 B가 한계에 가까워지면 그때부터 A에게 준다"

근데 어떤 물건을 B에게 줄지가 중요한데, 정렬로는 그 최적 조합을 찾을 수 없다.

정렬 방식

comp1) 1: A 내림차순 2: B오름차순

comp2) 1: B 내림차순 2: A 오름차순

leftl 은 comp1 , leftl2는 comp2 방식 적용

둘다 -1이면 -1리턴, 그렇지 않으면 둘 중 작은 값 리턴

[그리디로는 안된다고 한다. 그런데 반례를 찾지 못했다.]

그리디 풀이는 이번 문제를 통과하지 못한다.

A의 흔적의 개수가 작은 순서대로 정렬을 하고 선택했을 때 A의 최솟값이 나오지 않기 때문이다.

(반례)

[1, 2], [2, 3], [3, 2] [4, 7] n = 7 m = 8 가정

그리디로 풀게 되면 정답은 6이 된다 A의 흔적 개수가 6이 될 때 14 - 7 = 7 B의 흔적 개수가 7이 되어 통과되지만

정답은 A의 흔적 개수가 4일 때 14 - 7 = 7이 되어서 조건을 만족하여 4가 정답이다.

출처: https://20240228.tistory.com/435 [지적 겸손함:티스토리]

내 코드에서 반례 적용 시

comp1 ) [4, 7], [3, 2], [2, 3], [1, 2]

comp2 ) [1, 2], [3, 2], [2, 3], [4, 7]

TC 답이 4나온다.(정답)

해당 블로그에서의 반례가 내 코드에선 틀렸다.

내 코드 반례

info = [[2,2],[3,2],[2,2],[1,1],[3,2]]
n = 9, m = 8
그리디: 3  →  정답: 2

최적 배정: A B B B B

A가 [2,2] 훔침 → A흔적=2
B가 나머지 4개 훔침 → B흔적=2+2+1+2=7 < 8 ✅

근데 그리디는 정렬 후 B흔적이 한계에 가까워질 때까지 B에게 몰아주다가 전환하는 방식이라, 첫 번째 물건을 A에게 줘야 최적이라는 걸 알 수가 없다.

즉 "어떤 특정 물건을 A에게 줄지" 를 정렬만으로 결정할 수 없는 게 본질적인 한계이다.

A에게 넘기는 물건	A흔적	B흔적
[2,2]	2	7 ✅
[3,2]	3	7 ✅
[2,2]	2	7 ✅
[1,1]	1	8 ❌
[3,2]	3	7 ✅

comp1) 1: A 내림차순 2: B오름차순

comp2) 1: B 내림차순 2: A 오름차순

두가지 정렬을 적용해서 둘 중 하나의 A값이 작으면 그 값을 리턴한다. 다만 그 작은 값이 -1이면 둘다 -1이 아니라는 가정 하에 큰 값을 리턴한다.

그러나 위와 같은 반례처럼 해당 조합(comp1, comp2 정렬 후 선택 전략)이라도, 즉 어떤 정렬 순서로도 ("정렬 기준을 2, 3개 ... 10개로 늘려도) "운 좋게 맞는 케이스"가 늘어날 뿐, 항상 최적을 보장하지 않는다.

최적을 항상 보장하려면 DP를 사용해야한다.

그리디 VS DP

그리디 ⊂ DP 관계

많은 경우 그리디로 해결 가능한 문제는 DP로도 해결 가능하다.
반면 DP로 해결 가능한 문제 중에는 그리디로 해결할 수 없는 문제도 많다.
따라서 실전에서는 DP가 그리디보다 더 범용적인 접근으로 여겨진다.

정확히는 다음과 같이 이해하는 것이 좋다.

그리디로 최적해가 보장되는 문제들은 대체로 DP적으로도 표현 가능하다. (그리디는 항상 “왜 최적인가”에 대한 증명이 중요하다.)
하지만 DP가 필요한 문제 중 상당수는 greedy choice property(탐욕 선택 성질)가 성립하지 않아 그리디로 해결할 수 없다.

예를 들면 다음과 같다.

그리디와 DP 모두 가능한 문제:

동전 문제(특정 화폐 체계)
활동 선택 문제
최소 신장 트리
최단 경로(비음수 가중치의 다익스트라)

DP는 가능하지만 그리디는 불가능한 대표 문제:

0/1 배낭 문제
LIS 일반 DP
행렬 곱셈 순서
편집 거리

특히 0/1 배낭 문제는 대표적인 예시다.

“가성비 좋은 물건부터 담자” 같은 단순 그리디는 반례가 존재한다.
하지만 DP는 항상 최적해를 구할 수 있다.

실전에서는 다음처럼 접근하는 경우가 많다.

그리디가 바로 보이지 않으면 DP를 먼저 고려하는 것이 안전한 경우가 많다.
그리디는 반드시 교환 논법(exchange argument), greedy choice property, 반례 검증 등을 통해 정당화해야 한다.
반면 DP는 상태 정의와 점화식만 올바르면 최적성을 구성하기 비교적 쉽다.
대신 시간과 메모리를 더 사용하는 경우가 많다.

또한 “DP는 느리지만 정확성을 보장한다”라는 표현은 약간 수정이 필요하다.

정확성은 알고리즘 자체의 증명 문제이므로:

잘 설계된 그리디는 정확하다.
잘못 설계된 DP는 틀릴 수 있다.

따라서 일반적으로는 다음처럼 정리하는 것이 가장 적절하다.

그리디: 빠르고 구현이 간단하지만 최적성 증명이 필요하다.

해당 문제는 배낭문제와 유사하다.

이 문제는 전형적인 0/1 배낭(Knapsack) 계열 DP와 가장 흡사하다.

특히 느낌은:

물건마다 선택지가 2개 있고
누적 비용(흔적)을 관리해야 하며
제한 조건을 넘지 않도록 하면서
어떤 값을 최소화/최대화

한다는 점에서 거의 배낭 구조다.

구체적으로 대응시키면:

물건 i
→ 배낭의 아이템
A가 훔친다 / B가 훔친다
→ 아이템 선택 방식
A 흔적, B 흔적
→ 무게(weight) 혹은 비용(cost)
경찰에 안 잡혀야 함
→ 용량 제한(capacity)
A 흔적 최소화
→ 최적화 목표

특히 이 문제는 다음 형태와 매우 비슷하다.

“한쪽 비용 제한 안에서 다른 쪽 비용 최소화”

즉:

B 흔적은 m 미만이어야 하고
그 조건을 만족하면서
A 흔적 최소화

이 구조다.

그리디 VS DP 개념 블로그 참고해보기

https://brynn-park.tistory.com/41

Greedy vs. DP(Dynamic Programming)

최적의 솔루션을 도출하는 두 가지 알고리즘-Greedy, DP-에 대해서 차이점을 중심으로 알아본다. 스스로 헷갈려서 차이점을 명확히 구분하고 공부하기 위해 적는 포스팅이다. Greedy AlgorithmGreedy Algo

brynn-park.tistory.com

그리 vs DP 구분법 (실전용)

1. 그리디를 먼저 의심하는 경우

다음 중 하나라도 강하면 그리디 후보다:

현재 선택이 “전체 최적”에 영향을 거의 안 주는 느낌이다
정렬 후 규칙적으로 풀릴 것 같다
“지금 가장 좋은 선택”이 자연스럽게 보인다
선택이 이후 상태를 크게 복잡하게 만들지 않는다
교환해도 결과가 유지될 것 같다 (교환 논법 가능 느낌)

한마디:

“지금 최선 선택 = 전체 최선” 느낌이면 그리디

2. DP를 써야 하는 경우

다음 특징이면 DP다:

현재 선택이 미래 선택에 영향을 크게 준다
“어떤 선택을 하느냐에 따라 상태가 완전히 달라진다”
경우의 수가 너무 많아서 완전탐색 불가능
같은 상태가 여러 경로로 반복된다
“~까지의 최적값 / 경우의 수” 형태가 보인다

한마디:

“선택에 따라 미래가 갈리고, 같은 상태가 반복된다” → DP

3. 가장 중요한 핵심 기준 (시험용 1줄)

그리디: “지금 선택이 곧 답이 된다”가 증명 가능
DP: “모든 선택을 고려해야 최적을 보장할 수 있다”

4. 빠른 판단 체크리스트

그리디 체크

정렬하면 풀릴 것 같다?
반례 찾기 어렵다?
선택 기준이 하나로 정해진다?

→ YES 많으면 그리디 의심

DP 체크

선택이 2개 이상이고 이후 영향이 크다
상태를 저장해야 할 것 같다
“부분 문제 반복” 느낌이 있다

→ YES 많으면 DP

5. 핵심 요약

그리디 = “선택 1개로 끝나는 구조”
DP = “선택을 다 저장해야 하는 구조”
둘 다 아니면 보통 그래프/탐색/비트마스크

해당 문제가 DP 쪽인지 체크

1. 선택이 누적된다 → DP 신호

각 물건마다 선택이 있음:

A가 훔침 → A 흔적 증가
B가 훔침 → B 흔적 증가

이 선택이 계속 누적돼서
현재 선택이 미래 가능 여부를 바꾼다

→ 전형적인 DP 조건

2. “지금 A/B 중 더 작은 것”이 항상 최적이 아님 → 그리디 실패 구조

예를 들어:

지금은 A로 하면 흔적이 적어 보임
하지만 나중에 A 제한(n)에 빨리 도달하면 전체가 터짐

즉:

지역 최적 선택 ≠ 전체 최적

→ 그리디 구조 붕괴

3. 상태가 2개 축이다

A 누적 흔적
B 누적 흔적

이건 사실상:

2차원 자원 관리 문제

→ 전형적인 DP (knapsack 변형)

4. “남은 선택이 미래 가능성을 결정”함

이게 핵심인데:

어떤 물건을 A로 선택하면
→ B 여유가 늘어남
반대로 B로 선택하면
→ A 여유가 늘어남

즉 선택이 독립이 아니라 서로 얽혀 있음

→ 그리디 성립 거의 불가능

그리디 체크는 거의 안 통함

그리디가 맞으려면 보통 이런 게 있어야 함:

정렬 기준 하나
선택 기준 하나
선택이 미래를 망치지 않음

근데 이 문제는:

기준이 2개 (A, B)
선택이 미래 제약을 바꿈
trade-off 구조

→ 그리디 조건 거의 전부 깨짐

결론

이 문제는 그리디 체크보다 DP 체크가 훨씬 강한 전형적인 2차원 DP 문제다.

시간제한선택

이 문제는 info 길이 최대 40이니까:

2^40 = 약 1,099,511,627,776 = 약 1조

10^8 기준으로 1만 배 넘어서 완전히 시간초과다.

기준 정리:

크기	가능한 알고리즘
n ≤ 20	2^n 브루트포스 가능
n ≤ 40	브루트포스 불가, DP/분할정복
n ≤ 100	O(n^3) 이하
n ≤ 1000	O(n^2) 이하
n ≤ 100,000	O(n log n) 이하
n ≤ 1,000,000	O(n) 이하

lv2) 멀리 뛰기

junl — Tue, 16 Jun 2026 23:19:08 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/12914

#include <string>
#include <vector>
#include<iostream>
using namespace std;
long long answer= 0;
void dfs(int sum, int lv, int limit){
    if(lv <= limit){
        if(sum == limit){
            answer++;
            return;
        }
        if(lv == limit)return;
    }
    if(sum == limit){
        answer++;
       return;     }
    if(sum > limit)return;
    for(int i = 1 ; i <=2;++i){
        dfs(sum + i, lv+1, limit);
    }
}
long long solution(int n) {

   // dfs(0, 0, n);   시간초과 
    //dp 점화식: dp[n] = dp[n-1] + dp[n-2];
   vector<long long>dp(n+1);
    if(n == 1)return 1;
    if(n == 2) return 2;
   dp[0] = 0;
    dp[1] = 1;
    dp[2] = 2;
     for(int idx = 3; idx <= n ;++idx){
         dp[idx] = (dp[idx-1] + dp[idx-2]) % 1234567;
    }   
    
    return dp[n];
}

- dfs로 하면 시간 초과

- dp로 진행해야 하며, dp[idx] 저장 때마다 %1234567 진행해야함.

- 조건만 보면 리턴 시에만 %1234567 을 하라했는데, 그게 아니었다. 매 계산 저장 전 modular 연산을 통해 오버플로우 방지를 해야한다. long long 타입이어도 피보나치 수열의 값 범위를 온전히 담을 수 없기 때문이다.

피보나치 수열(이 문제의 점화식)은 n이 커질 수록 숫자가 기하급수적으로 증가한다.

제한 사항을 보면 n은 최대 2,000까지 주어진다.
long long 타입이 아무리 큰 수를 담을 수 있다고 해도, 피보나치 수열의 90번째 항만 넘어가도 표현할 수 있는 범위를 초과해 버린다. 2,000번째 항은 상상할 수 없을 정도로 큰 수가 되어 쓰레기 값이 담기게 된다.

비트마스킹 관련 연습 (7다)

junl — Wed, 3 Jun 2026 18:08:31 +0900

#1 부분 집합 풀기

#include<iostream>

using namespace std;

int main(void) {
	int n = 4;
	for (int mask = 0; mask < (1 << n); mask++) {
		cout << "{ ";
		for (int idx = 0; idx < n; ++idx) {
			if ((mask >> idx) & 1) {
				cout << idx + 1 << " ";
			}
		}	
		cout << "}\n";
	}
}

부분집합

집합에서 고를 수 있는 모든 경우 (아무것도 안 고르는 것 포함)
{1,2,3} 의 부분집합 → {}, {1}, {2}, {3}, {1,2}, {1,3}, {2,3}, {1,2,3} → 총 2^n개

조합

n개 중에서 정확히 k개 고르는 경우
{1,2,3} 에서 2개 고르는 조합 → {1,2}, {1,3}, {2,3} → 총 nCk개

관계로 보면:

부분집합 = k=0인 조합 + k=1인 조합 + k=2인 조합 + ... + k=n인 조합

즉 부분집합이 조합을 전부 포함하는 더 큰 개념입니다.

https://junworld.tistory.com/2097

힌트스테이지 문제에서는 "번들을 살지 말지" 각각 독립적으로 결정하니까 부분집합 탐색이고, 만약 "n-1개 스테이지 중 정확히 3개만 번들을 산다"는 조건이 있었다면 조합 탐색이 됩니다.

두 원소의 합이 10이 나오는 부분 집합 개수 구하기

#include<iostream>
#include<string>

using namespace std;

int solve(int n, int arr[]) {
    int count = 0;
    for (int mask = 0; mask < (1 << n); mask++) {
        int sum = 0;
        int cnt = 0;
        string subset = "{ ";

        for (int idx = 0; idx < n; idx++) {
            if ((mask >> idx) & 1) {
                sum += arr[idx];
                cnt++;
                subset += to_string(arr[idx]) + " ";
            }
        }

        if (cnt == 2 && sum == 7) {
            cout << subset << "}\n";
            count++;
        }
    }
    return count;
}

int main() {
    int n = 8;
    int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
    cout << "개수: " << solve(n, arr) << "\n";
    return 0;
}

비트마스킹 추가 예제

1단계 - 비트 연산 기본

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

int main() {
    int a = 5; // 0101
    int b = 3; // 0011

    cout << (a & b) << "\n";  // AND  → 0001 = 1
    cout << (a | b) << "\n";  // OR   → 0111 = 7
    cout << (a ^ b) << "\n";  // XOR  → 0110 = 6
    cout << (a << 1) << "\n"; // 왼쪽 시프트 → 1010 = 10
    cout << (a >> 1) << "\n"; // 오른쪽 시프트 → 0010 = 2
}

2단계 - 특정 비트 켜기/끄기/확인

#include<iostream>
using namespace std;

void printBit(int mask, int size = 5) {
    // 상위 비트부터 출력 (앞의 0도 포함)
    for (int i = size - 1; i >= 0; i--) {
        cout << ((mask >> i) & 1);
    }
    cout << "\n";
}

bool checkBit(int mask, int idx) {
    if ((mask >> idx) & 1) {
        cout << "true\n";
        return true;
    }
    else {
        cout << "false\n";
        return false;
    }
}

int main(void) {
    int mask = 0;

    // 0번째, 4번째 비트 켜기
    mask |= (1 << 0);
    mask |= (1 << 4);
    printBit(mask);   // 10001

    // 0번째 비트 끄기
    mask &= ~(1 << 0);
    printBit(mask);   // 10000

    // 4번째 비트 확인
    checkBit(mask, 4); // true
}

3단계 - 부분집합 전체 출력

int main() {
    vector<int> arr = {1, 2, 3, 4};
    int n = arr.size();

    for (int mask = 0; mask < (1 << n); mask++) {
        cout << "{ ";
        for (int i = 0; i < n; i++) {
            if ((mask >> i) & 1) {
                cout << arr[i] << " ";
            }
        }
        cout << "}\n";
    }
}

출력:

{ }
{ 1 }
{ 2 }
{ 1 2 }
{ 3 }
...
{ 1 2 3 4 }

4단계 - 부분집합 합이 특정 값인지 찾기

// {1, 2, 3, 4, 5} 중 합이 7인 부분집합 모두 출력
int main() {
    vector<int> arr = {1, 2, 3, 4, 5};
    int n = arr.size();
    int target = 7;

    for (int mask = 0; mask < (1 << n); mask++) {
        int sum = 0;
        for (int i = 0; i < n; i++) {
            if ((mask >> i) & 1) {
                sum += arr[i];
            }
        }
        if (sum == target) {
            cout << "{ ";
            for (int i = 0; i < n; i++) {
                if ((mask >> i) & 1) cout << arr[i] << " ";
            }
            cout << "}\n";
        }
    }
}

5단계 - 방문 체크 (visited 배열 대신 비트 사용)

// 일반적인 방법 (bool 배열)
int main() {
    int n = 4;
    vector<bool> visited(n, false);

    visited[1] = true;  // 1번 방문
    visited[3] = true;  // 3번 방문

    cout << visited[1] << "\n"; // 1
    cout << visited[2] << "\n"; // 0
}

// 비트마스크로 똑같이 표현
int main() {
    int n = 4;
    int visited = 0; // 0000

    visited |= (1 << 1);  // 1번 방문 → 0010
    visited |= (1 << 3);  // 3번 방문 → 1010

    cout << ((visited >> 1) & 1) << "\n"; // 1번 방문 확인 → 1
    cout << ((visited >> 2) & 1) << "\n"; // 2번 방문 확인 → 0
}

6단계 - 방문 체크 활용 (모든 노드 방문했는지 확인)

// 그래프에서 모든 노드를 방문했는지 확인하는 상황
int main() {
    int n = 4;
    int visited = 0;
    int allVisited = (1 << n) - 1; // 1111 = 15 (모두 방문한 상태)

    // 0, 1, 2, 3번 노드 순서대로 방문
    for (int i = 0; i < n; i++) {
        visited |= (1 << i);
        cout << "현재 방문 상태: " << bitset<4>(visited) << "\n";

        if (visited == allVisited) {
            cout << "모든 노드 방문 완료!\n";
        }
    }
}

현재 방문 상태: 0001
현재 방문 상태: 0011
현재 방문 상태: 0111
현재 방문 상태: 1111
모든 노드 방문 완료!

7단계 - 비트마스크 DP (방문한 노드 집합을 상태로 저장)

// 4개 도시를 모두 방문하는 최소 비용 (외판원 순회 간단 버전)
// dist[i][j] = i번 도시에서 j번 도시로 가는 비용
int main() {
    int n = 4;
    vector<vector<int>> dist = {
        {0, 10, 15, 20},
        {10, 0, 35, 25},
        {15, 35, 0, 30},
        {20, 25, 30, 0}
    };

    // dp[visited][현재위치] = visited 상태에서 현재위치에 있을 때 최소 비용
    // visited는 비트마스크로 표현 (어떤 도시를 방문했는지)
    int allVisited = (1 << n) - 1; // 1111
    vector<vector<int>> dp(1 << n, vector<int>(n, INT_MAX));

    dp[1][0] = 0; // 0번 도시에서 시작 (0번 방문 = 0001)

    for (int visited = 1; visited < (1 << n); visited++) {
        for (int cur = 0; cur < n; cur++) {
            if (dp[visited][cur] == INT_MAX) continue;
            // 아직 방문 안 한 도시로 이동
            for (int next = 0; next < n; next++) {
                if ((visited >> next) & 1) continue; // 이미 방문함
                int nextVisited = visited | (1 << next);
                dp[nextVisited][next] = min(dp[nextVisited][next],
                                           dp[visited][cur] + dist[cur][next]);
            }
        }
    }

    // 모든 도시 방문 후 최소 비용
    int ans = INT_MAX;
    for (int cur = 0; cur < n; cur++) {
        ans = min(ans, dp[allVisited][cur]);
    }
    cout << "최소 비용: " << ans << "\n"; // 60
}

흐름을 정리하면:

1단계: & | ^ << >>          기본 연산
2단계: 켜기/끄기/확인        비트 조작
3단계: 부분집합 출력         완전탐색 활용
4단계: 부분집합 합 찾기      이번 문제랑 같은 구조
5단계: visited 비트로 표현   bool 배열 대체
6단계: 모든 노드 방문 확인   allVisited 패턴
7단계: 비트마스크 DP         외판원 순회

7단계까지 직접 돌려보시면 웬만한 비트마스킹 문제는 다 풀 수 있을 거예요.

비트마스킹 핵심 패턴 6가지

cpp

// 1. idx번째 비트 켜기
S |= (1 << idx)
// 예) S=10000, idx=1 → 10010

// 2. idx번째 비트 끄기
S &= ~(1 << idx)
// 예) S=10010, idx=1 → 10000

// 3. idx번째 비트 반전 (0→1, 1→0)
S ^= (1 << idx)
// 예) S=10010, idx=1 → 10000
//     S=10000, idx=1 → 10010

// 4. idx번째 비트 켜져있는지 확인
if (S & (1 << idx))
// 예) S=10010, idx=1 → true
//     S=10010, idx=0 → false

// 5. n개 비트 전부 켜기
(1 << n) - 1
// 예) n=4 → 1111 = 15

// 6. 최하위 켜진 비트 찾기 (2의 보수 활용)
S & -S
// 예) S=10010 → 00010 = 2

연습 예제 (단계별)

예제 6개 + 연습문제 1개로 구성했습니다. 흐름은 이렇습니다:

예제	내용	핵심 패턴
1	비트 켜기/끄기/확인	\|= &= ~ & (1<<idx)
2	부분집합 전체 출력	mask=0 ~ (1<<n)
3	합이 7인 부분집합	부분집합 + 조건 필터
4	방문 체크	visited, allVisited
5	최하위 켜진 비트	S & -S (2의 보수)
6	XOR 비트 반전	^= 토글
연습	원소 2개인 부분집합	__builtin_popcount

printBits 함수로 이진수를 눈으로 보면서 확인할 수 있게 했으니, 각 예제 출력을 보면서 비트가 어떻게 바뀌는지 따라가보시면 빠르게 감이 잡힐 거예요.

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

// 이진수로 출력해주는 헬퍼 함수 (이해하기 쉽게)
void printBits(int n, int size = 5) {
    for (int i = size - 1; i >= 0; i--) {
        cout << ((n >> i) & 1);
    }
    cout << " (" << n << ")";
}

// =============================================
// 예제 1. 비트 켜기 / 끄기 / 확인
// =============================================
void example1() {
    cout << "===== 예제 1. 비트 켜기 / 끄기 / 확인 =====\n";
    int S = 0b10000; // 16

    cout << "초기값 S = "; printBits(S); cout << "\n";

    // 1번째 비트 켜기
    S |= (1 << 1);
    cout << "1번째 비트 켜기 후: "; printBits(S); cout << "\n";

    // 3번째 비트 켜기
    S |= (1 << 3);
    cout << "3번째 비트 켜기 후: "; printBits(S); cout << "\n";

    // 1번째 비트 끄기
    S &= ~(1 << 1);
    cout << "1번째 비트 끄기 후: "; printBits(S); cout << "\n";

    // 3번째 비트 켜져있는지 확인
    if (S & (1 << 3)) cout << "3번째 비트 켜져 있음\n";
    else               cout << "3번째 비트 꺼져 있음\n";

    // 1번째 비트 켜져있는지 확인
    if (S & (1 << 1)) cout << "1번째 비트 켜져 있음\n";
    else               cout << "1번째 비트 꺼져 있음\n";

    cout << "\n";
}

// =============================================
// 예제 2. 부분집합 전체 출력
// =============================================
void example2() {
    cout << "===== 예제 2. 부분집합 전체 출력 =====\n";
    vector<string> items = {"사과", "딸기", "포도", "배"};
    int n = items.size();

    // 0b0000 ~ 0b1111 (0 ~ 15) 순회 = 모든 부분집합
    for (int mask = 0; mask < (1 << n); mask++) {
        cout << "mask="; printBits(mask, 4); cout << " → { ";
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                cout << items[i] << " ";
            }
        }
        cout << "}\n";
    }
    cout << "\n";
}

// =============================================
// 예제 3. 부분집합 합이 target인 경우 찾기
// =============================================
void example3() {
    cout << "===== 예제 3. 합이 7인 부분집합 찾기 =====\n";
    vector<int> arr = {1, 2, 3, 4, 5};
    int n = arr.size();
    int target = 7;

    for (int mask = 0; mask < (1 << n); mask++) {
        int sum = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) sum += arr[i];
        }
        if (sum == target) {
            cout << "{ ";
            for (int i = 0; i < n; i++) {
                if (mask & (1 << i)) cout << arr[i] << " ";
            }
            cout << "} = " << target << "\n";
        }
    }
    cout << "\n";
}

// =============================================
// 예제 4. 비트로 방문 체크 (visited 대신)
// =============================================
void example4() {
    cout << "===== 예제 4. 비트로 방문 체크 =====\n";
    int n = 5;
    int visited = 0;
    int allVisited = (1 << n) - 1; // 11111

    cout << "목표 상태(전부 방문): "; printBits(allVisited); cout << "\n\n";

    // 0, 2, 4번 노드 방문
    vector<int> order = {0, 2, 4};
    for (int node : order) {
        visited |= (1 << node);
        cout << node << "번 노드 방문 후: "; printBits(visited); cout << "\n";
    }

    cout << "\n모든 노드 방문했나? ";
    cout << (visited == allVisited ? "YES" : "NO") << "\n";

    // 나머지도 방문
    visited |= (1 << 1);
    visited |= (1 << 3);
    cout << "나머지 방문 후: "; printBits(visited); cout << "\n";
    cout << "모든 노드 방문했나? ";
    cout << (visited == allVisited ? "YES" : "NO") << "\n\n";
}

// =============================================
// 예제 5. 최하위 켜진 비트 찾기 (2의 보수 활용)
// =============================================
void example5() {
    cout << "===== 예제 5. 최하위 켜진 비트 찾기 =====\n";
    vector<int> tests = {0b10010, 0b10100, 0b11000};

    for (int S : tests) {
        int lowest = S & -S;
        cout << "S = "; printBits(S);
        cout << "  →  최하위 켜진 비트 = "; printBits(lowest);
        cout << "\n";
    }
    cout << "\n";
}

// =============================================
// 예제 6. XOR로 비트 반전
// =============================================
void example6() {
    cout << "===== 예제 6. XOR로 비트 반전 =====\n";
    int S = 0b10000;
    cout << "초기값: "; printBits(S); cout << "\n";

    // 토글처럼 사용 (켜져있으면 끄고, 꺼져있으면 켜고)
    for (int i = 0; i < 3; i++) {
        S ^= (1 << 1); // 1번째 비트 반전
        cout << "1번째 비트 반전: "; printBits(S); cout << "\n";
    }
    cout << "\n";
}

// =============================================
// 연습 문제: 아래 TODO를 직접 채워보세요!
// =============================================
void practice() {
    cout << "===== 연습 문제 =====\n";
    cout << "{1, 2, 3, 4, 5} 중 원소 개수가 정확히 2개인 부분집합을 출력하세요.\n";

    vector<int> arr = {1, 2, 3, 4, 5};
    int n = arr.size();

    for (int mask = 0; mask < (1 << n); mask++) {
        // TODO: mask에서 켜진 비트 수를 세서 2개인 경우만 출력
        int cnt = __builtin_popcount(mask); // 켜진 비트 수 세기
        if (cnt == 2) {
            cout << "{ ";
            for (int i = 0; i < n; i++) {
                if (mask & (1 << i)) cout << arr[i] << " ";
            }
            cout << "}\n";
        }
    }
}

int main() {
    example1();
    example2();
    example3();
    example4();
    example5();
    example6();
    practice();
    return 0;
}

Extra

비트마스킹 핵심 패턴

n개 원소 집합의 모든 부분집합 순회

for (int mask = 0; mask < (1 << n); mask++)
// n=4이면 0000 ~ 1111, 총 16가지

idx번째 원소 확인 (켜져있는지)

if ((mask >> idx) & 1)
// mask=0101, idx=2 → (0101 >> 2) & 1 = 0001 & 1 = 1 → 존재
// mask=0101, idx=1 → (0101 >> 1) & 1 = 0010 & 1 = 0 → 없음

idx번째 원소 추가 (비트 켜기)

mask |= (1 << idx)
// mask=0101, idx=1 → 0101 | 0010 = 0111

idx번째 원소 삭제 (비트 끄기)

mask &= ~(1 << idx)
// mask=0101, idx=2 → 0101 & ~0100 = 0101 & 1011 = 0001

idx번째 원소 반전 (0→1, 1→0)

mask ^= (1 << idx)
// mask=0101, idx=1 → 0101 ^ 0010 = 0111 (켜짐)
// mask=0111, idx=1 → 0111 ^ 0010 = 0101 (꺼짐)

n개 비트 전부 켜기 (모든 원소 포함)

(1 << n) - 1
// n=4 → 10000 - 1 = 01111

최하위 켜진 비트 찾기

mask & -mask
// mask=10010 → 00010 (2의 보수 활용)

결론

추천 시스템에서 다양성(Diversity) 을 측정할 때 추천 목록 내 항목들끼리 코사인 유사도로 유사성을 구한 뒤 Diversity = 1 - 평균유사도 로 계산해요!

3. 참신성 (Novelty)

추천 데이터가 얼마나 비대중적인가
→ 사용자가 모르는 새로운 것을 추천하는 정도

참신성 vs 신뢰성 트레이드오프

참신성 높음 → 낯선 추천 → 사용자 신뢰 낮음
참신성 낮음 → 대중적 추천 → 사용자 신뢰 높음

균형점을 찾는 것이 중요!

4. 롱테일 (Long Tail) 전략

판매량
↑
|█
|██
|████
|████████______________ → 롱테일
+------------------------→ 전체 상품
  인기상품  틈새상품

대부분의 판매 = 소수의 인기 상품
롱테일 = 틈새 수요를 가진 비인기 상품들

추천 시스템의 목표:
인기 상품(신뢰) + 롱테일 상품(참신성) 균형!

5. 사용자 신뢰 (User Trust)

익숙한 추천 → 신뢰 ↑
낯선 추천만  → 신뢰 ↓

이상적인 추천:
익숙한 데이터(신뢰) + 새로운 데이터(참신성) 균형

전체 요약

요소	의미	높으면
제공률	추천 가능 비율	많은 항목 추천 가능
다양성	추천 항목 간 다양함	아무거나 추천 위험
참신성	비대중적 추천 정도	신뢰 낮아질 위험

추천 시스템은 하나의 예술 정확성, 제공률, 다양성, 참신성, 신뢰 모든 요소의 균형을 찾는 것이 핵심!

매트릭	측정 대상	중요도
RMSE	평점 예측 정확도	낮음
ARHR	추천 순위 품질	높음
참신성	추천 항목 인기도	중간
다양성	추천 항목 다양함	중간
A/B 테스트	실제 사용자 반응	최고 ✅

지표	의미	높으면
MAE/RMSE	평점 예측 정확도	오차 큼 ❌
적중률	추천 순위 정확도	좋은 추천 ✅
제공률	추천 가능 비율	많은 항목 추천 가능 ✅
다양성	추천 항목 다양함	아무거나 추천 위험 ❌
참신성	비대중적 추천	신뢰 낮아질 위험 ❌
이탈	추천 목록 변화 빈도	무작위 추천 위험 ❌
민감성	새 행위 반영 속도	시스템 복잡 ❌

방법	주 사용 처
코사인 유사도	아이템 기반 추천 ✅
피어슨 상관계수	사용자 기반 추천 ✅
유클리드 거리	간단한 유사도 측정

신이 나는 프로그래밍

sql lv3) 헤비 유저가 소유한 장소

(lv2) [3차] 파일명 정렬 [todo: 깔끔한 코드로 정리]

lv3) 정수 삼각형

lv2 ) 완전범죄(틀림) 그리디 vs DP

그리디 VS DP

그리 vs DP 구분법 (실전용)

1. 그리디를 먼저 의심하는 경우

2. DP를 써야 하는 경우

3. 가장 중요한 핵심 기준 (시험용 1줄)

4. 빠른 판단 체크리스트

그리디 체크

DP 체크

5. 핵심 요약

해당 문제가 DP 쪽인지 체크

1. 선택이 누적된다 → DP 신호

2. “지금 A/B 중 더 작은 것”이 항상 최적이 아님 → 그리디 실패 구조

3. 상태가 2개 축이다

4. “남은 선택이 미래 가능성을 결정”함

그리디 체크는 거의 안 통함

결론

이 문제는 그리디 체크보다 DP 체크가 훨씬 강한 전형적인 2차원 DP 문제다.

시간제한선택

lv2) 멀리 뛰기

비트마스킹 관련 연습 (7다)

비트마스킹 핵심 패턴 6가지

연습 예제 (단계별)

비트마스킹 핵심 패턴

추천시스템 RecommenderMetrics.py 둘러보기

추천 시스템 핵심 매트릭 총정리

추천 시스템 핵심 매트릭 총정리

1. RMSE (평균 제곱근 오차)

2. ARHR (평균 상호 적중률)

3. 참신성 (Novelty)

4. 다양성 (Diversity)

5. A/B 테스트 (가장 중요!)

최종 정리

결론

추천시스템 이탈 응답성 및 A/B테스트

1. 이탈 (Churn)

2. 민감성 (Responsiveness)

3. 전체 지표 요약

4. 최종 평가: A/B 테스트

5. 대리 문제 (Proxy Problem)

대리 문제 (Proxy Problem)

개념

쉬운 예시

추천 시스템에서

유튜브 사례

결론

6. 사용자 직접 피드백

최종 결론

A/B 테스트

구조

추천 시스템 예시

실생활 예시

오프라인 지표 vs A/B 테스트

결론

A/B 테스트가 느리고 비싼 이유

느린 이유

비싼 이유

결론

추천시스템 품질 측정 요소

추천 시스템 품질 측정 요소

1. 제공률 (Coverage)

2. 다양성 (Diversity)

유사성 측정 방법

1. 코사인 유사도 (Cosine Similarity)

2. 피어슨 상관계수 (Pearson Correlation)

3. 유클리드 거리 (Euclidean Distance)

추천 시스템에서 주로 사용

결론

3. 참신성 (Novelty)

4. 롱테일 (Long Tail) 전략

5. 사용자 신뢰 (User Trust)

전체 요약