asdsa112 님의 블로그

백준 [C++] 15686 치킨 배달

asdsa112 — Fri, 5 Jun 2026 00:04:11 +0900

<조건 분석>

1. N은 50. 집의 갯수 최대 2500개 치킨집의 개수는 13개. 13C6(치킨집 고르는 경우의 수) * (100*100)(집에서 치킨집 가는 탐색) * 6개 라고 해도 1억회는 안넘고, 1초까지는 안걸림.

<문제 해결 포인트>

1. 최대 M개를 고르라니까 조합을 써야되겠다 ! 하는 사고방식이 일어나야 함.

2. 그리고는 완전탐색으로 일일히 거리 계산해주면서 최소값 구하면 됨.

#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;

int N, M;
int board[51][51];
int visited[14];
vector<pii> cv;
vector<pii> hv;
vector<int> indexv;
int res = 987654321;

int cal(int y1, int x1, int y2, int x2)
{
    return abs(y1 - y2) + abs(x1 - x2);
}


void combi(int index)
{
    if (index == M)
    {
        int sum = 0;
        for (auto item : hv)
        {
            int temp = 987654321;
            for (auto index : indexv)
            {
                temp = min(temp, cal(cv[index].first, cv[index].second, item.first, item.second));
            }
            sum += temp;
        }

        res = min(sum, res);

        return;
    }


    for (int i = 0; i < cv.size(); i++)
    {
        if (visited[i]) continue;
        visited[i] = 1;
        indexv.push_back(i);
        combi(index + 1);
        indexv.pop_back();
        visited[i] = 0;
    }

    return ;
}

int main()
{
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);

    cin >> N >> M;

    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            cin >> board[i][j];
            if (board[i][j] == 1)
            {
                hv.push_back({i, j});
            }
            else if (board[i][j] == 2)
            {
                cv.push_back({i, j});
            }
        }
    }

    combi(0);



    cout << res;

    return 0;
}

백준 [C++] 1285 동전 뒤집기

asdsa112 — Sun, 31 May 2026 00:13:16 +0900

<조건 분석>

1. N이 최대 20개. 20 X 20의 배열이 가능함.

2. 그러면 한 행, 한 열당 뒤집거나 안뒤집으니 2의 40승임.

3. 기존의 사고방식으로는 정면돌파 불가능함.

<문제 해결 포인트>

1. 행에서 한번 뒤집으면, 열은 이미 최소값이 정해져 있음.

2. 뒤집힌 행에서 열은 어차피 뒤집으면 되기 때문에, 앞이건 뒤건 상관없이 적은 갯수만 세면 된다는거임.

3. 그렇게 되면 행이나 열만 뒤집으면 되니, 2의 20승으로 줄어듦.

4. 그리고 경우의 수 문제니 재귀를 돌면서 뒤집는 경우의 수 혹은 안뒤집는 경우의 수로 해보고, 최소값을 구하면 됨.

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

int N;
vector<int> arr;
int res = 987654321;

void go(int here)
{
    if (here == N)
    {
        int temp = 0;
        for (int i = 0; i < N; i++)
        {
            int front = 0;
            int back = 0;
            for (int j = 0; j < N; j++)
            {
                if (arr[j] & (1 << i)) front++;
                else back++;
            }
            if (front > back) temp += back;
            else temp += front;
        }

        res = min(res, temp);
        return;
    }

    go(here + 1); // 안뒤집
    arr[here] = ~(arr[here]);
    go(here + 1); // 뒤집
}

int main()
{
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);

    cin >> N;

    arr.resize(20);

    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            char temp;
            cin >> temp;

            if (temp == 'H')
            {
                arr[i] |= (1 << j);
            }
        }
    }

    go (0);

    cout << res;

    return 0;
}

백준 [C++] 19942 다이어트

asdsa112 — Thu, 28 May 2026 23:56:20 +0900

<조건 분석>

1. N개의 식재료 중에서 골라서 경우의 수 따지는 문제임.

2. N이 15이하 이므로 비트마스킹으로 접근해볼 수 있겠음.

3. 그러면 최대 시간복잡도가 2^15정도니까 충분함.

<문제 해결 포인트>

1. 비트마스킹 로직은 흔한 비트마스킹 로직이라 괜찮음.

2. 출력이 문제인데, 오름차순 + 같은 비용의 집합이 하나 이상이면 사전 순 출력임.

3. map으로 (최소 비용, idx배열을 담는 vector) 쌍으로 관리해서 집합을 사전 순 정렬하면 됨.

출력이 .. 좀 ... 재미없다 ..

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

struct diet
{
    int p;
    int f;
    int s;
    int v;
    int price;
};

int N;
int mp, mf, ms, mv;
int res = 987654321;
vector<diet> v;
map<int, vector<vector<int>>> resv;


int main()
{
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    
    cin >> N;

    cin >> mp >> mf >> ms >> mv;

    int tp, tf, ts, tv, tprice;
    for (int i = 0; i < N; i++)
    {
        cin >> tp >> tf >> ts >> tv >> tprice;
        v.push_back({tp, tf, ts, tv, tprice});
    }

    vector<int> tempidx;
    for (int i = 0; i < (1 << N); i++)
    {
        int tempp = 0;
        int tempf = 0;
        int temps = 0;
        int tempv = 0;
        int tempprice = 0;
        tempidx.clear();
        for (int j = 0; j < N; j++)
        {
            if (i & (1 << j))
            {
                tempp += v[j].p;
                tempf += v[j].f;
                temps += v[j].s;
                tempv += v[j].v;
                tempprice += v[j].price;
                tempidx.push_back(j);
            }
        }

        if (tempp >= mp && tempf >= mf && temps >= ms && tempv >= mv)
        {
            if (res >= tempprice)
            {
                res = tempprice;
                resv[res].push_back(tempidx);
            }
        }
    }

    ::sort(resv[res].begin(), resv[res].end());

    if (res == 987654321) cout << -1;
    else
    {
        cout << res << "\n";
        for (auto item : resv[res][0])
        {
            cout << item + 1 << " ";
        }
    }

    return 0;
}

[C#] C#에서 winapi 렌더링을 어떻게 하면 될까 ? - 마샬링

asdsa112 — Wed, 20 May 2026 17:48:00 +0900

C++로 만든 Iocp Server 및 winapi 클라이언트를 연동한 C++ 프로젝트를 C#으로 하나의 단일 게임엔진으로 통합하는 과정이었습니다.

근데 C++에서는 winapi의 함수 호출은 #pragma comment('user32.lib') 뭐 이런 걸로 user32라이브러리 파일을 통해서 링크한 후 CreateWindowExW 이런 함수들을 쓰면 그만이었는데, 막상 C#으로 통합하려하니까

C#에서는 어떻게 하지 ? ?? ? ? 라는 문제점에 봉착했습니다.

1. 일단 런타임이든 윈도우 생성이든 네트워크든간에 OS 기능을 빌려와야 함.

- OS는 그 기능을 native dll (x64/x86 기계어 dll 파일)형태로만 노출하기 때문에, 해당 native dll에 접근해서 가져오면 되겠습니다. (dll 파일도 여러가지 파일이 존재함. native dll / managed dll)

2. native dll 파일은 export table이 존재해서 호출할 수 있는 메서드 이름 및 정보가 존재함.

이런식으로

3. C#에서는 attribute를 통해서 dllimport로 어떤 dll에 접근할건지 알려줄 수 있음.

	[DllImport("user32.dll")]
	public static extern bool ShowWindow(nint hWnd, int nCmdShow);

이런식으로

4. 이렇게 함수를 정의해놓으면 C#에서는 ShowWindow 함수를 그냥 C++에서 쓰듯이 쓰면 되는거임.

5. 그럼 이제 ShowWindow함수를 호출한다고 가정해보겠음. 내부에서 어떤일이 일어나길래 가능한건지 알아보겠음.

6. 호출 시 다음과 같은 일이 일어남.

- CoreCLR(java의 JVM같은거) 이 메타데이터에서 dll의 이름과(attribute를 참고해서) 함수 이름을 꺼냄.

- LoadLibrary("user32.dll") 함수를 호출해서 user32.dll의 베이스 주소를 반환함.

- GetProcAddress(user32, "ShowWindow")함수를 호출함. -> 위에서 봤던 user32.dll의 export table을 참고해서 showwindow를 찾음.

- 이 주소를 캐싱 후 IL Stub를 생성

- IL Stub의 내용 구현에는 매개변수 마샬링 + GC 전환 + 호출 + 역마샬링을 IL로 합성한 임시 메서드를 생성함. 그리고 JIT로 IL컴파일

- 다음 CreateWindowEx를 호출 시에 JIT가 컴파일한 stub의 기계어를 호출

7. 많이 복잡하긴 한데, 이 과정을 P/Invoke 라고 부름.

8. 그리고 이 과정에서 사용자의 언어를 컴파일된 바이너리 user32.dll에 맞춰서 메모리 레이아웃, 호출 규약, 데이터 형식을 맞춰주는 것임. 그리고 데이터 형식을 맞춰준 것을 토대로 함수를 호출하는 것임.

9. 그리고 8번에서 진행하는 것이 바로 '마샬링' 이라는 작업임.

- 마샬링이라는게 굉장히 어려운 문장으로 막 ~~한 객체의 메모리에서의 표현방식을 저장 또한 전송에 적합한 다른 데이터 형식으로 변환하는 과정~~ 이런식으로 설명되어 있는데, 결국에는 상대방이 알아먹기 쉽게 내 언어를 다른 형식으로 변환하는 과정을 말하는 거. marShal이라는 단어의 어원도 군대 혹은 외교에서 '행렬을 정돈해서 다른 진영으로 보낸다' 라는 뜻임.

10. 결과적으로 C#에서 winapi 함수를 호출하기 위해서는 이런식으로 한번의 래핑 ? 작업이 필요한 것임.

프로그래머스 [C++] 같은 숫자는 싫어

asdsa112 — Mon, 11 May 2026 17:01:42 +0900

<조건 분석>

1. 시간제한은 모르겠지만, 배열 크기 100만이기 때문에 순회 한번에 끝내볼 것임.

<문제 해결 포인트>

1. answer에 비어 있으면 넣고, 만약 안 비어있으면 맨 위에 요소랑 비교해보고 다르면 삽입함.

#include <bits/stdc++.h>

using namespace std;

vector<int> solution(vector<int> arr) 
{
    vector<int> answer;
    
    for (auto item : arr)
    {
        if (!answer.empty() && answer.back() == item)
        {
            continue;
        }
        else
        {
            answer.push_back(item);
        }
    }

    return answer;
}

백준 [C++] 4811 알약

asdsa112 — Mon, 11 May 2026 16:13:08 +0900

<조건 분석>

1. 알약이 최대 30개인데 반으로 쪼개 먹을 수도 있으니 최대 60번. 그러면 먹냐 안먹냐니까 최대 경우의 수가 2^60까지 될 수 있음.

2. 가능한 문자열의 경우의 수기에 경우의 수 덧셈으로 진행하면 될 것 같음.

<문제 해결 포인트>

1. 2^60은 말도 안되지만, 경우의 수 덧셈이라면 얘기가 다름.

2. 재귀로 경우의 수를 돌면서 메모제이션을 진행하면 충분히 가능할 수 있음.

3. 알약 한 조각을 꺼내면 반 조각 갯수를 올리고, 만약 반 조각을 먹는다면 한 조각 갯수를 안 내리면 됨.

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

int n;
long long dp[40][40];

long long go (int day, int half)
{
    if (day <= 0 && half <= 0) return 1; // 알약 모두 없음

    long long& ret = dp[day][half];
    if (ret) return ret;
    
    if (day > 0)
    {
        if (half <= 0) // 알약 한 조각은 있는데 반 조각은 없음
        {
            ret += go(day - 1, half + 1);
        }
        else // 알약 한 조각도 있고 반 조각도 있음
        {
            ret += go(day - 1, half + 1) + go(day, half - 1);
        }
    }
    else
    {
        if (half > 0) // 알약 한 조각은 없는데 반 조각은 있음
        {
            ret += go(day, half - 1);
        }
    }

    return ret;
}

int main()
{
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);

    while (true)
    {
        cin >> n;
        if (n == 0) break;

        memset(dp, 0, sizeof(dp));

        cout << go(n, 0) << "\n";
    }

    return 0;

}

백준 [C++] 2240 자두나무

asdsa112 — Mon, 11 May 2026 11:18:04 +0900

<조건 분석>

1. 30번 이동 가능. 나무는 1번 나무, 2번 나무 존재. 그러면 경우의수가 최대 2^30임. (1번 나무 혹은 2번 나무를 30번 이동 가능하니까).

2. 그럼 무식한 완전탐색으로는 불가능. 지나왔던 길을 저장하는 방법을 택해서 복잡도를 줄여봐야 함.

<문제 해결 포인트>

1. 현재 위치에서 받을 수 있는 자두 경우의 수, 다음 위치에서 받을 수 있는 자두 경우의 수를 재귀 때 더해주는 것이 포인트임.

2. DP는 재귀 때 경우의 수를 더해주면서, 재귀 탈출 루프에서는 0의 경우의 수를 던지는 게 포인트 인 것 같음.

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

int t, w;
int tree[1004];
int dp[3][31][1004]; // 현재 위치 , 남은 이동 횟수, Time

int go(int cur, int movecnt, int time)
{
    if (time > t) return 0; // 시간을 넘어가면 다 0의 경우의 수

    int plum = (tree[time] == cur) ? 1 : 0;

    int& ret = dp[cur][movecnt][time];
    if (ret != -1) return ret;

    ret = max(ret, go(cur, movecnt, time + 1) + plum);

    if (movecnt > 0) 
    {
        int npos = (cur == 1) ? 2 : 1;
        int nplum = (tree[time] == npos) ? 1 : 0;
        ret = max(ret, go(npos, movecnt - 1, time + 1) + nplum);
    }


    return ret;
}

int main()
{
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);

    cin >> t >> w;

    memset(dp, -1, sizeof(dp));

    for (int i = 1; i <= t; i++)
    {
        cin >> tree[i];
    }

    cout << go(1, w, 1);

    return 0;
}

DP는 감 잡을 듯 하면서도 잡히지 않음...

프로그래머스 [C++] 올바른 괄호

asdsa112 — Sun, 10 May 2026 23:28:31 +0900

<조건 분석>

1. 프로그래머스는 제한 시간 이런게 없어서 조건 생각하기가 어렵다고 생각함.

2. 문자열 갯수가 10만 이하라 그냥 순회만 하면서 체크해도 충~~~분할 것 이라 생각했음.

3. 벡터를 추가해서 push_back() 연산이나 pop_back() 연산을 추가하니 시간초과가 생겼음.

4. 그만큼 빡빡하다는 거였음.

<문제 해결 포인트>

1. 최대한 string을 한번만 순회하되, 새로운 STL 컨테이너를 추가해서 함수 호출 연산을 추가하면 시간초과가 일어남.

2. 여는 괄호를 +1로, 닫는 괄호를 -1로 count 체크를 진행하면 됨.

3. 중간에 음수가 발생하면 닫는 괄호가 많아졌다는 뜻이니 false, 순회가 끝나고 count가 0이 아니면 짝이 안맞는다는 소리니 그것도 false.

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


bool solution(string s)
{
    bool answer = true;
    
    int count = 0;
    for (auto& item : s)
    {
        if (item == '(')
        {
            count++;
        }
        else if (item == ')')
        {
            count--;
        }
        
        if (count < 0)
        {
            answer = false;
            break;
        }
    }
    
    if (count != 0) answer = false;

    return answer;
}

프로그래머스 [C++] 기능개발

asdsa112 — Sat, 9 May 2026 22:49:01 +0900

<조건 분석>

1. 솔직히 조건 분석이라고 하기에는 progresses의 갯수가 너무 적음.

2. 그냥 구현 문제라고 보면 될 듯함.

<문제 해결 포인트>

1. progresses 첫 요소가 100이상이면 그때 다 돌면서 100을 넘는지 체크해보기 정도가 포인트가 될 듯함.

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

vector<int> solution(vector<int> progresses, vector<int> speeds) {
    vector<int> answer;
    
    int index = 0;
    while (index < progresses.size())
    {
        if (progresses[index] >= 100)
        {
            int cnt = 0;
            for (int i = index; i < progresses.size(); i++)
            {
                if (progresses[i] >= 100)
                {
                    cnt++;
                    index++;
                }
                else break;
            }
            answer.push_back(cnt);
        }
        else
        {
            for (int i = index; i < progresses.size(); i++)
            {
                progresses[i] += speeds[i];
            }
        }
    }
    
    return answer;
}

백준 [C++] 1103 게임

asdsa112 — Sat, 9 May 2026 22:46:30 +0900

<조건 분석>

1. 만약 완탐으로 해보겠다. 라고 생각한다면,4방향, 50*50보드면 4^2500 경우의 수임.

2. 그럼 방문처리해서 DFS 식으로 혹은 DP로 간다면 O(M*N)에 상수 4방향 해서 약 10000번 정도.

<문제 해결 포인트>

1. 방문 처리 된 곳을 방문했다면 사이클 이므로 -1을 출력하고 exit 하는 것도 방법.

2. DP는 DFS가 탐색하고 있는 그 경로 자체의 함수 호출스택이 경우의 수를 탐색하고 있는 거라고 생각해보면 됨.

3. 그렇게 생각하면 맵을 벗어났을 때는 게임이 끝난 것 이므로 경우의 수 0을 반환. go 재귀로 들어갈 때는 경우의 수 1개가 추가되는 거임.

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

int n, m;
int dp[50][50];
char board[50][50];
int visited[50][50];
int dx[] = {0, 0, -1, 1};
int dy[] = {-1, 1, 0, 0};

int go(int y, int x)
{
    if (visited[y][x]) // 방문 되어 있으면 사이클
    {
        cout << -1;
        exit(0);
    }

    if ((y < 0 || x < 0 || y >= n || x >= m)  || board[y][x] == 'H')
    {
        return 0; // 게임 끝이니까 해당 좌표에서는 경우의 수가 없으므로 0 반환
    }


    int& ret = dp[y][x];
    if (ret != -1) return ret;

    int delta = board[y][x] - '0';

    visited[y][x] = 1;
    for (int i = 0; i < 4; i++)
    {
        int ny = y + dy[i] * delta;
        int nx = x + dx[i] * delta;

        ret = max(ret, go(ny,nx) + 1); // 경우의 수 한개 추가
    }
    visited[y][x] = 0;

    return ret;
}

int main()
{
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);

    cin >> n >> m;

    memset(dp, -1, sizeof(dp));

    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            cin >> board[i][j];
        }
    }


    cout << go(0, 0);


}