Game Develop

'값에 의한 전달'보다는 '상수객체 참조자에 의한 전달' 방식을 택하는 편이 대게 낫다.

MaxLevel — Wed, 25 Feb 2026 19:24:32 +0900

참조자로 전달하는게 대개 나은 이유중 대표적인 이유가, 값에 의한 전달을 하면 복사비용이 크기 때문이다.

아마 이정도는 조금이라도 C++을 공부한 분들이시라면 꽤나 잘 알려진 내용이다.

매개변수로 전달되는 객체를 읽기전용으로 쓸거면 안전하게 const까지 붙여서 전달받는게 베스트이다.

그리고 책을 보면 참조자로 전달해야만 하는 케이스가 또 있는데, 사실 많이 발생하는 이슈일 것 같진 않지만 이런쪽으로 생각 해 본적은 없었어서 한번 남겨본다.

대충 Parent와 Parent를 상속받는 Child가 있다고 가정하고...

bool Validate(Parent p);

라는 함수도 있다고 가정하자.

그리고 특정함수에서 아래와 같은 코드를 작성해보자.

Child c;

Validate(c);

자 여기엔 무슨 문제가 있을까?

c는 Child로 만들었는데, Validate에 매개변수로 복사될 때는 Parent로 복사되는 것이다.

즉, Child영역의 변수라던가 기타등등은 전부 잘려서 Validate함수로 복사되는 것이다. 이런것을 복사손실문제(Slicing Problem)이라고 부른다고 한다. (Object Slicing이라고도 부른단다)

뭐 Validate함수내에서 Parent 부분만 사용한다면 당장의 버그는 없을 수 있겠지만.. 사람일이란 게 또 모르는데다가 어차피 그렇게 확신할거면 안전하게 문법적으로 방지할 수 있기 때문에 매개변수를 값으로 넘겨받을 이유가 없다.

그렇기때문에 위와 같은 상황에서도 상수 참조자, 즉 const Parent& 이런식으로 넘겨받는게 이득이다.

데디케이티드서버 쓸거면 처음부터 써라

MaxLevel — Wed, 21 Jan 2026 07:00:11 +0900

본인 프로젝트에 어차피 나중에 서버를 붙일거면은, 그냥 처음부터 깃허브에서 엔진소스 다운받아서 서버 구축한다음, 서버 띄워놓으면서 클라컨텐츠같은거 구현하는 게 낫다.

나는 원래 서버할 생각 없이 그냥 컨텐츠구현같은거 하다가, 최근에 데디케이티드 서버 연결해서 채팅이랑 애니메이션 동기화같은이슈 경험하려고 지금 하고 있는데, 그러다보니 코드를 꽤나 수정하고 있다.

대충이나마 조금이라도 언리얼 데디서버를 공부해본 사람은 알겠지만, 데디서버로 서버-클라 관계를 구현하려한다고 하면, 이제 기본적으로 서버에 액터같은거를 스폰시키고 그걸 클라이언트에 복제하는 방식이다.

그러다보니 일단 서버에서 레벨로딩 및 액터스폰 등등을 먼저 진행하게 되는데, 이 때 서버고려없이 짰던 코드에서는 매우 높은확률로 여기저기 nullptr 역참조했다는 식의 에러가 많이 발생할 것이다.

예를들어 Monster라는 클래스가 있고 엔진의 AIController를 래핑한 AIControllerBase라는 클래스를 만들었다고 가정하자.

이 AIControllerBase를 Monster라는 클래스 여기저기에서 많이 사용한다면 그냥 아예 멤버변수에다가 저장해서 사용할 수도 있을 것이다. 일일이 함수에서 AIController가져와서 AIControllerBase로 캐스팅하면 중복되는 코드도 많아지고 캐스팅비용도 필요하니까. (틱함수같은거 아니면 크게 체감은 안 될 수도 있겠지만... 결국 메모리를 더 쓰느냐 시간을 더 쓰느냐..)

쨌든 그래서 BeginPlay쯔음에서 m_AIControllerBase = Cast<AIControllerBase>(GetController) 형식으로 미리 저장해놓고 사용했다.

근데 이 상태로 서버 연결하고 실행해보니, GetController가 널값이라고 바로 터졌다. 즉 에디터에서 PIE로 했을때는 BeginPlay에서 GetController 했을 때 이미 컨트롤러가 있는상황이라 널값이 아니였지만, 서버에서 실행하는 시점에서는 아직 컨트롤러가 생성된 시점이 아니라 nullptr을 리턴하게되고, 이걸 Cast해서 에러가 발생한 것이다.

이런식으로 미리 멤버변수에 캐싱해서 사용을 했었어서, 현재는 여기저기 고치고 있는 중이다. 뭐 복잡한거까진 아니라 당장은 그냥 노가다수준이라 어려운 건 아니다만, 어쨌든 중간에 이렇게 바꾸려면 이미 구조를 짜놓은걸 또 바꿔야하니 매우 귀찮아지기 때문에 제목처럼 서버 붙일거면 미리 붙이고 계속 테스트하면서 진행하길 추천한다.

[UE5] 많은 몬스터 최적화. (Animation Budget Allocator)

MaxLevel — Fri, 26 Dec 2025 23:40:47 +0900

많은 몬스터를 스폰시키면서 프레임을 지키려면 어떻게 해야할까..?

기본적으로 엔진자체에서 해주는 프러스텀컬링, 오클루젼컬링, 뭐 거리기반으로 하는 컬링.. 그리고 Precomputed Visibility Volumes 이라고, 생소한 최적화도 있다.

번역으로는 사전 계산된 가시성 볼륨... 인데, 특정 구간을 이 볼륨으로 씌우고, 그 공간에 한해서 '이 위치에 플레이어가 있을 때, 어떤 물체들이 보이는지 안 보이는지를 미리 기록' 해 두는 볼륨상자라고 표현 할 수 있다고 한다.

그냥 런타임중에 실시간 계산하면 비용이 많이 드니, 미리 계산했다가 런타임 때 기록되어진 테이블을 조회만 해서 렌더에서 제외하는 방식이다라고 한다.

그러다 보니 동적메쉬보다는 스태틱메쉬위주로 적용되는 컬링방식이라는데, 무조건 스태틱메쉬에만 되는 건 아니라고 한다.

뭔가 좀 생소한 컬링을 접하다 보니 이야기가 길어졌는데, 어쨌든 이런 기본적인 최적화들이 잘 되고 있는지 체크하기 위한 방법 중 하나로는 그냥 몬스터같은거 많이 스폰시키고 카메라로 비췄을 때와 안비췄을 때의 프레임을 보면 된다.

아래는 96마리 몬스터 스폰시켰을 때 프레임.

20 극후반에서 30 초반 왔다갔다 한다.

아래는 같은 상황에서 카메라만 돌렸을 때.

거의 2배차이 난다.

카메라에서 안보이니 굳이 메쉬를 렌더링 할 필요가 없기 때문에 증가하는 것인데, 여기서 중요한 점은 게임스레드에서 동작하는 애님인스턴스의 틱은 여전히 호출한다는 것이다.

C++쪽에서 NativeUpdateAnimation을 오버라이드해서 로그 찍어보면 확인할 수 있는데, 카메라로 몬스터를 안비춰도 여전히 호출한다.

보통 이 틱함수에다가는 블루프린트에서 사용할 값들을 업데이트 해주는 코드를 넣고들 한다. 블렌드스페이스에 사용할 속도값이라던가 기타 등등...

어쨌든 이 틱함수는 여전히 호출하기 때문에, 만약 렌더가 안되는 상황이더라도(위의 경우처럼 카메라 바깥이라던가) 반드시 호출해야하는게 아니라면 이 틱함수도 막아주는게 좋다. (어디서든 최적화의 기본은 불필요한 틱함수 호출을 막는 것이다)

이건 단순히 옵션설정으로 할 수 있는데, Mesh컴포넌트를 가져와서 아래처럼 해주면 된다.

GetMesh()->VisibilityBasedAnimTickOption = EVisibilityBasedAnimTickOption::OnlyTickPoseWhenRendered;

단어 그대로, 렌더 될 때만 틱을 호출한다는 의미이다.

저 옵션을 했을 때랑 안했을 때랑 한번 UE_LOG로 찍어보면 실제로 호출하는지 안 하는지 알 수 있다.

현재 내 프로젝트의 경우, 애님인스턴스 틱에서 뭐 하는건 없어서 저 옵션 켜두면 아주 미세하게 프레임 오른다.

아예 안오르는 줄 알았는데, 몇번 비교해보니까 2,3프레임정도? 오르긴 하는 것 같다.

아마 NativeUpdateAnimation에서 어떤 걸 수행하느냐에 따라서 카메라로 안 비출 때 프레임이 더 오를 것이다.

현재 내 코드에선 스피드값이랑 지면인지 아닌지 체크하는 bool값들 등 정도만 업데이트 해준다.

사실 이제부터가 본론인데, 여기서 좀 더 추가적인 최적화로 ABA (Animation Budget Allocator)가 있다.

언리얼 공식문서에 있으니 일단 한 번 보는 걸 추천한다.

쉽게 말하자면, 동적으로 스켈레탈 메쉬 컴포넌트의 틱 빈도수를 조절하는 것이다.

기준은? 기본적으로는 현재 뷰포트에 해당하는 카메라이다. 이 카메라와 가까우면 가까운 스켈레탈 메쉬 컴포넌트에 좀 더 많은 예산을 할당해서 스켈레탈 메쉬 컴포넌트의 틱 빈도수를 올린다. 즉, 부드럽게 재생한다.

멀면 반대로다.

즉 가까운 스켈레탈 메쉬 컴포넌트는 중요하다고 판단되니 예산을 더 할당해서 틱호출을 많이 하는 것이고, 먼 것은 반대로 하는 것이다.

이 판단의 기준은 개발자가 따로 지정해줄 수 있다. (공식문서 참고)

위 영상을 보면, 캐릭터(카메라) 바로 앞의 몬스터는 부드럽게 재생되는 걸 확인할 수 있다.

그런데 맨 끝, 화면 기준 오른쪽끝에 있는 몬스터를 잘 보면 굉장히 버벅인다. 틱 호출을 줄여서 그런거다.

중간에 캐릭터(카메라)를 끝으로 이동시키면, 마찬가지로 카메라랑 가까운놈은 부드럽고 멀리 있는 놈은 버벅인다.

반드시 멀리있는 몬스터들까지 부드럽게 해야한다는 것만 아니면, 성능을 챙기기에 매우 좋다.

뭐 호출빈도라던가 예산할당 옵션같은 것들은 공식문서에 잘 나와있다. 나도 딱 여기까지만 해보긴 했는데, 이 ABA를 켰을때랑 안켰을때랑 꽤 차이난다. 거의 8~10프레임??

실제로 카트라이더 드리프트에도 적용한 검증된 최적화이니, 적극적으로 사용해보자.

객체복사 할 때는 빠짐없이 복사하자.

MaxLevel — Fri, 14 Nov 2025 22:53:40 +0900

객체를 복사해야 하는 경우(복사생성이나 대입연산), 말 그대로 모든 부분을 빠짐없이 복사해야 한다.

상속관계인 두 클래스가 있을 때, 자식클래스에서 복사생성을 정의할 경우 부모클래스의 복사생성은 호출되지 않는다.

물론 따로 정의 안하면, 기본컴파일러가 부모것까지 얕은복사를 해준다.

자 그러면 여기서 자식클래스에서 복사생성자랑 대입연산자를 정의해보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

#include <iostream>
#include <string>
 
using namespace std;
 
 
 
 
class Parent
{
 
public:
    Parent() {};
 
    /*Parent(const Parent& rhs) : name(rhs.name)
    {
        cout << "Parent CopyConstructor" << endl;
    }
 
    Parent& operator=(const Parent& rhs)
    {
        cout << "Parent AssignmentOperator" << endl;
    }*/
 
 
    string name = "default";
};
 
 
 
class Child : public Parent
{
 
public:
    Child() {};
 
    Child(const Child& rhs) : value(rhs.value)
    {
        cout << "Child CopyConstructor" << endl;
    }
 
    Child& operator=(const Child& rhs)
    {
        cout << "Child AssignmentOperator" << endl;
 
        this->value = rhs.value;
 
        return *this;
    }
 
    int value = 0;
};
 
 
 
int main()
{
    Child c1;
    c1.name = "c1Name";
    c1.value = 1;
 
    Child c2(c1); // 복사생성
    Child c3;
    c3 = c1;
 
    cout << endl << endl;
 
    cout << c2.name << ' ' << c2.value << endl;
    cout << c3.name << ' ' << c3.value << endl;
}
Colored by Color Scripter

cs

보면 자식클래스에만 복사생성자랑 대입연산자가 정의되어 있다.

이상태로 출력을 하면

이런 결과가 나온다.

자식클래스에서만 복사생성자와 대입연산자를 정의했기 때문에 부모클래스의 변수값은 default로 설정한 그대로이다.

위의 코드에는 부모클래스의 복사생성자와 대입연산자가 주석처리 되어있긴 한데, 주석처리가 되어있든 아니든 자식클래스것만 호출한다.

그렇기 때문에 자식클래스에서 호출할 때 부모것의 객체도 복사해주는 기능이 수행되어져야 한다.

복사생성할 때는 자식클래스것만 Default Member Initialize하지 말고, 아래처럼 부모를 같이 호출해 주면 된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

#include <iostream>
#include <string>
 
using namespace std;
 
 
 
 
class Parent
{
 
public:
    Parent() {};
 
    Parent(const Parent& rhs) : name(rhs.name)
    {
        cout << "Parent CopyConstructor" << endl;
    }
 
    Parent& operator=(const Parent& rhs)
    {
        this->name = rhs.name;
        cout << "Parent AssignmentOperator" << endl;
 
        return *this;
    }
 
 
    string name = "default";
};
 
 
 
class Child : public Parent
{
 
public:
    Child() {};
 
    Child(const Child& rhs) : Parent(rhs), value(rhs.value)
    {
        cout << "Child CopyConstructor" << endl;
    }
 
    Child& operator=(const Child& rhs)
    {
        cout << "Child AssignmentOperator" << endl;
 
        Parent::operator=(rhs);
        this->value = rhs.value;
 
        return *this;
    }
 
    int value = 0;
};
 
 
 
int main()
{
    Child c1;
    c1.name = "c1Name";
    c1.value = 1;
 
    Child c2(c1); // 복사생성
    Child c3;
    c3 = c1; // 대입연산
 
    cout << endl << endl;
 
    cout << c2.name << ' ' << c2.value << endl;
    cout << c3.name << ' ' << c3.value << endl;
}
Colored by Color Scripter

cs

 

보면 깔끔하게 객체복사가 된 것을 확인할 수 있다.

[UE5] 포스트프로세스 기본적인 설정.

MaxLevel — Fri, 14 Nov 2025 04:31:00 +0900

내 캐릭터 스킬중에는 스킬 시전 시, 뷰포트를 검은색 + 캐릭터는 파란색 + 몬스터는 하얀색 으로 렌더링 후, 플레이어가 몬스터한테 이동하면서 공격하고, 몬스터는 피격될 때마다 점차 빨갛게 바뀐다.

대충 이렇게...

이때 포스트프로세스용 머터리얼을 셋팅할 때... 아래의 사항을 빼먹으면 안된다.

1. 프로젝트설정에서 Custom Depth - Stencil Pass 항목을 Enabled With Stencil로 바꿀 것.

-> 그래야 각 액터의 스텐실값을 인지한다.

2. 뷰포트 오른쪽의 Outliner에 Post Process Volume을 반드시 추가할 것.

저기 빨갛게 해놓은데서 Post Process Volume 추가하면 된다.

추가하면 Outliner에 있을텐데, Post Process Volume의 디테일패널에서 Infinite Extent(Unbound)라는 항목이 있을건데, 여기에 true 체크도 해줘야 한다.

그리고 아래처럼 Array라 치면

이렇게 뜨는데 본인이 사용할 머터리얼을 여기다가 추가해줘야 한다.

물론 C++ 코드로 제어해줘도 된다. 나는 코드로 제어하는게 더 편해서 코드로 한다.

이렇게 하면 된다.

operator= (대입연산자) 에서 자기대입에 대한 처리가 빠지지 않도록 하자.

MaxLevel — Wed, 12 Nov 2025 23:14:21 +0900

여기서 말하는 자기대입(self assignment)란, 어떤 객체가 자기 자신에 대해 대입연산자를 적용하는 것을 의미한다.

대충 아래처럼?

Widget w;

w = w;

이게 왜 위험한가... 아래의 예시코드를 먼저 보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

 
class Bitmap {};
 
class Widget
{
 
public:
    Widget& operator= (const Widget& rhs)
    {
        delete pb;
        pb = new Bitmap(*rhs.pb);
 
        return *this;
    }
 
private:
    Bitmap* pb;
};
Colored by Color Scripter

cs

위의 예시코드는 안전하지 않은 대입연산자 코드이다.

왜? rhs가 자기자신일 수 있으니까. 맨 처음의 w = w를 생각해면 된다.

그러면 Bitmap 포인터변수가 같은 놈이라는건데, 대입연산자 첫줄에 delete pb를 해버린게 보이는가?

그러면 rhs의 pb도 delete 됐다는 것이다.

그 상태에서 rhs의 pb를 이용해서 메모리할당을 시도하니 문제가 생길 수 밖에 없다.

이런 현상을 막기위한 제일 쉬운 방법은 자신과 rhs를 비교해서, 다를때만 대입연산자를 시도하는 것.

if (this == &rhs) return *this; // 이 코드 한줄만 앞에 추가해주면 된다.

1
2
3
4
5
6
7
8
9
10
11
12

    Widget& operator= (const Widget& rhs)
    {
        if (this == &rhs)
        {
            return *this;
        }
        
        delete pb;
        pb = new Bitmap(*rhs.pb);
 
        return *this;
    }
Colored by Color Scripter

cs

이런식으로.

근데 이 코드도 안전하지 않은 부분이 있다.

new Bitmap부분에서 예외가 발생해버리는 경우다. (뭐 동적할당 메모리가 부족하다던지, *rhs.pb를 이용한 Bitmap의 복사생성 자체에서 예외가 터져버린다던지...)

예외가 발생해버리면 그냥 pb만 delete해버린 꼴이다. 이런 객체가 남겨져 있으면 어떤 예상치 못한 상황이 발생할 지 알 수가 없다.

댕글링 포인터가 된 셈.

그러니 예외가 발생할 경우를 대비해, 무작정 삭제한다음에 새로 할당하려하지 말고 혹시 모르니 기존값을 미리 저장 후, 새로 할당받고 기존값을 삭제하는 흐름으로 진행하면 안전하다.

1
2
3
4
5
6
7
8

Widget& operator= (const Widget& rhs)
{
    Bitmap* pOrig = pb;
    pb = new Bitmap(*rhs.pb);
    delete pOrig;
    
    return *this;
}
Colored by Color Scripter

cs

이런식으로...

보면 기존값을 pOrig라는 새로운 지역변수에 미리 저장한다음 동적메모리할당을 시도한다.

예외가 발생하더라도 pb는 기존값을 유지하고 있기 때문에 이전의 방법보다 더 안전하다.

그리고 if문으로 자기자신인지 검사할 필요도 없다. 원본 pb로 새로 할당받고, 기존꺼는 지역변수에 보관한다음 그걸 delete 하니까.

객체 생성 및 소멸과정중에는 절대로 가상함수를 호출하면 안된다.

MaxLevel — Wed, 12 Nov 2025 22:17:29 +0900

사실 Effective C++이라는 카테고리를 따로 걸어서 뭔가 올리고 있긴 한데, 다른 내 글들과 마찬가지로 사실상 숙지용? 글에 가깝다.

책처럼 보기 좋게 쓰여진다기 보다는, 공부하다 혼잣말 하는 느낌의 글이라 생각한다.

어차피 Effective 시리즈 관련 정리 글은 다른 분들이 잘 정리해서 올려주신게 많기 때문에...

=== === === === === === === === === === === === === === === === === === === === === === === === === ===

부모와 자식클래스가 있고, 부모클래스에서 Test() 라는 가상함수를 선언했다고 가정해보자.

그리고 자식에서는 그 가상함수를 오버라이드해서 뭐 이것저것 작성했고.

그다음 이 가상함수를 부모의 생성자에서 호출하려 하면? 안된다.

아마 개발자가 의도하지 않은 상황이 나올 가능성이 높다.

자 아래와 같이 아주 간단한 코드를 실행해보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#include <iostream>
 
using namespace std;
 
class Parent
{
public:
    Parent()
    {
        TestVirtualFunc();
    };
 
    virtual void TestVirtualFunc()
    {
        cout << "Parent TestVirtualFunc " << endl;
    }
 
    ~Parent() {};
};
 
class Child : public Parent
{
public:
    Child() {};
 
    virtual void TestVirtualFunc() override
    {
        
        cout << "Child TestVirtualFunc " << endl;
    }
 
    ~Child() {};
};
 
 
int main()
{
    Child* child = new Child();
}
Colored by Color Scripter

cs

보면 부모의 생성자에서 가상함수 TestVirtualFunc()을 호출했는데, 아마 개발자의 의도는 결국 오버라이드된 자식클래스의 가상함수일 것이다.

하지만 결과는?

애석하게도 부모께 호출된다.

왜냐하면 아직 부모객체가 정상적으로 생성자 호출이 완료되지 않았기 때문이다.

생성자호출이 끝나기 전에 오버라이드된 자식의 가상함수를 호출해버렸지 않았는가?

감이 좋은 사람들은 이미 이상함을 눈치 챘을수도 있다. 부모의 객체가 초기화되지도않았는데 자식의 함수를 호출하다니?

본디 상속관계의 객체를 만들려고 할 경우, 부모의 생성자 호출 이후에 자식의 생성자가 호출된다.

부모객체가 정상적으로 초기화가 이루어졌다는 것을 기준으로, 자식객체의 초기화를 진행하는것이 정상적인 흐름이라는 것이다.

그렇기 때문에 아예 생성자에서 가상함수를 호출할 경우, 자식쪽으로 안내려가게 언어레벨에서 막아놨다는 것.

좀 더 확실한 이야기를 하자면, 애초에 부모클래스가 생성되는 동안은, 그 객체의 타입은 부모클래스로 고정시켜 놨다는 것이다.

그렇기 때문에 생성자에서 가상함수를 호출해도 자식으로 못내려가는것이다.

이 때 런타임 타입정보 (RTTI)를 사용하는 행위 (dynamic_cast라던가 typeid)를 사용하더라도 부모객체로 취급받는다는 것이다.

그러니 자식의 가상함수를 호출할 리가 없다는 것.

비슷한 느낌으로 소멸자를 처리하는 과정을 봐보자.

부모클래스의 소멸자를 가상소멸자로 해놨다면, 정상적으로 자식소멸자를 먼저 호출한다음 부모껄 호출할 것이다.

이 때, 자식소멸자를 처리하는 과정에서는 객체타입이 자식클래스인데, 자식소멸자 처리 이후 부모소멸자로 넘어가면 객체타입이 부모타입으로 바뀐다는 것이다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#include <iostream>
 
using namespace std;
 
class Parent
{
public:
    Parent()
    {
        //TestVirtualFunc();
    };
 
    virtual void TestVirtualFunc()
    {
        cout << "Parent TestVirtualFunc " << endl;
    }
 
    ~Parent()
    {
        cout << typeid(*this).name() << endl;
    };
};
 
class Child : public Parent
{
public:
    Child() {};
 
    virtual void TestVirtualFunc() override
    {
        
        cout << "Child TestVirtualFunc " << endl;
    }
 
    ~Child()
    {
        cout << typeid(*this).name() << endl;
    };
};
 
 
int main()
{
    Child* child = new Child();
 
    delete child;
}
Colored by Color Scripter

cs

 

보다시피 자식소멸자 호출할 땐 typeid에 Child가 찍히고, 부모소멸자 호출할 땐 Parent가 찍히는 걸 확인 할 수 있다.

[Algorithm]Baekjoon 1938번 :: 통나무 옮기기

MaxLevel — Mon, 10 Nov 2025 21:47:49 +0900

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211

#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <algorithm>
#include <math.h>
#include <queue>
#include <functional>
#include <sstream>
#include <memory.h>
#include <deque>
#include <set>
#include <unordered_set>
#include <thread>
#include <atomic>
 
using namespace std;
 
 
struct Log
{
    int y, x, moveCount;
    bool bIsVertical;
};
 
int arr[52][52] = { 0 };
int n;
int answer = 0x3f3f3f3f;
int dp[52][52][2] = { 0 }; // 해당좌표에 중심점이 위치한 상태에서 수평으로 도착했는가, 수직으로 도착했는가
int dirs[5][3][2] =
{
    {{-1,0},{-1,0},{-1,0}},
    {{1,0},{1,0},{1,0}},
    {{0,-1},{0,-1},{0,-1}},
    {{0,1},{0,1},{0,1}},
    {{1,-1}, {0,0}, {-1,1}}
};
 
Log destLog;
 
bool IsInRange(const Log& log)
{
    if (log.y < 0 || log.y >= n) return false;
    if (log.x < 0 || log.x >= n) return false;
    if (arr[log.y][log.x] == 1) return false; // 나무칸 체크
 
    return true;
}
 
bool CanRotate(const int y, const int x) 
{
    for (int i = y - 1; i <= y + 1; ++i)
    {
        if (i < 0 || i >= n) return false;
 
        for (int j = x - 1; j <= x + 1; ++j)
        {
            if (j < 0 || j >= n) return false;
 
            if (arr[i][j] == 1) return false;
        }
    }
 
    return true;
}
 
bool IsDest(const int y, const int x, const bool bIsVertical)
{
    if (y == destLog.y &&
        x == destLog.x &&
        bIsVertical == destLog.bIsVertical)
    {
        return true;
    }
 
    return false;
}
 
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    cin >> n;
    
    vector<Log> tempStartLog;
    vector<Log> tempDestLog;
 
    for (int i = 0; i < n; ++i)
    {
        string s;
 
        cin >> s;
 
        for (int j = 0; j < n; ++j)
        {
            if (s[j] == 'B')
            {
                arr[i][j] = 0;
                tempStartLog.push_back({ i,j });
                
            }
            else if (s[j] == 'E')
            {
                arr[i][j] = 0;
                tempDestLog.push_back({ i,j });
            }
            else
            {
                arr[i][j] = s[j] - '0';
            }
        }
    }
 
    memset(dp, 0x3f, sizeof(dp));
 
    bool bIsStartVertical = tempStartLog[0].x == tempStartLog[1].x ? true : false;
    bool bIsDestVerticla = tempDestLog[0].x == tempDestLog[1].x ? true : false;
 
    destLog = { tempDestLog[1].y, tempDestLog[1].x, 0, bIsDestVerticla };
 
    tempStartLog[1].bIsVertical = bIsStartVertical;
 
    Log startLog = tempStartLog[1];
    startLog.moveCount = 0;
 
    queue<Log> q;
    q.push(startLog);
 
    while (!q.empty())
    {
        int curY = q.front().y;
        int curX = q.front().x;
        bool curbIsVertical = q.front().bIsVertical;
        int curMoveCount = q.front().moveCount;
 
        q.pop();
 
        if (dp[curY][curX][curbIsVertical] <= curMoveCount)
        {
            continue;
        }
        
        dp[curY][curX][curbIsVertical] = curMoveCount;
 
        if (IsDest(curY, curX, curbIsVertical))
        {
            answer = curMoveCount;
            break;
        }
 
        int fy, fx, ty, tx;
 
        if (curbIsVertical)
        {
            fy = curY - 1;
            fx = curX;
            ty = curY + 1;
            tx = curX;
        }
        else
        {
            fy = curY;
            fx = curX - 1;
            ty = curY;
            tx = curX + 1;
        }
 
        for (int i = 0; i < 5; ++i)
        {
            int offset = 1;
 
            if (i == 4 && !curbIsVertical)
            {
                offset = -1;
            }
 
            Log tempFirst = { fy + offset * dirs[i][0][0], fx + dirs[i][0][1] * offset }; // next좌표
            if (!IsInRange(tempFirst)) continue;
 
            Log tempSecond = { curY + dirs[i][1][0], curX + dirs[i][1][1], curMoveCount+1, curbIsVertical };
            if (!IsInRange(tempSecond)) continue;
 
            Log tempThird = { ty + offset * dirs[i][2][0], tx + dirs[i][2][1] * offset };
            if (!IsInRange(tempThird)) continue;
 
            if (i <= 3)
            {
                q.push(tempSecond);
            }
            else // 회전시키기 시도
            {
                if (CanRotate(curY, curX)) // 현재위치에서 회전가능한지 먼저 검사.
                {
                    tempSecond.bIsVertical = !tempSecond.bIsVertical;
                    q.push(tempSecond);
                }
            }
        }
    }
    
    if (answer == 0x3f3f3f3f)
    {
        cout << 0;
    }
    else
    {
        cout << answer;
    }
}
Colored by Color Scripter

cs

통나무를 최단이동횟수로 목표까지 안착시키는 문제이다.

단순히 점의 형태가 아니라 세로나 가로의 모양을 가지고 있기 때문에 이부분을 고려해야 한다.

단, 통나무의 길이는 3으로 고정이기 때문에 세 점 중 가운데점을 위치값으로 잡고 수직인지 수평인지만 값을 들고있으면 된다.

그렇기 때문에 dp테이블을 3차원으로 해줘야 한다.

특정 좌표에 도착했을 때 수직인지 수평인지도 구분해야하기 때문이다.

이외에는 사실 뭔가 구현에 더 가까운 느낌?

좌표이동간의 가중치는 1이기 때문에 queue를 이용한 BFS탐색이 대체로 높은시간효율을 보여준다.

상하좌우 + 회전 까지 총 5개의 자식노드들을 뿌리면 BFS탐색 특성상 처음 마주치는 목표좌표가 최단거리가 된다.

통나무의 세 부위에 대해 좌표검사를 꼼꼼히 해주고 회전하기 전에는 회전 가능한지 문제의 조건에 맞게 검사해주면 된다.

(회전하려는 위치기준 3*3에 1이 있으면 안됨)

회전시킨 이후의 좌표를 구할 때 수직에서 수평으로 회전할지 수평에서 수직으로 회전해야할지에 따라 통나무의 첫번째랑 세번째 좌표가 달라지기 때문에 offset값을 이용해 좀 더 깔끔하게 구현해줬다.

아래는 DFS로 푼 코드인데, BFS는 0ms가 나왔던거에 비해 380ms대가 나온다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207

#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <algorithm>
#include <math.h>
#include <queue>
#include <functional>
#include <sstream>
#include <memory.h>
#include <deque>
#include <set>
#include <unordered_set>
#include <thread>
#include <atomic>
 
using namespace std;
 
 
struct Log
{
    int y, x;
    bool bIsVertical;
 
    bool operator==(const Log& other) const
    {
        return (this->y == other.y) && (this->x == other.x) && (this->bIsVertical == other.bIsVertical);
    }
 
    void operator*=(const int num)
    {
        this->y *= num;
        this->x *= num;
    }
};
 
int arr[52][52] = { 0 };
int n;
int answer = 0x3f3f3f3f;
int dp[52][52][2] = { 0 }; // 해당좌표에 중심점이 위치한 상태에서 수평으로 도착했는가, 수직으로 도착했는가
int dirs[5][3][2] =
{
    {{-1,0},{-1,0},{-1,0}},
    {{1,0},{1,0},{1,0}},
    {{0,-1},{0,-1},{0,-1}},
    {{0,1},{0,1},{0,1}},
    {{1,-1}, {0,0}, {-1,1}}
};
 
Log destLog;
 
bool IsInRange(const Log& log)
{
    if (log.y < 0 || log.y >= n) return false;
    if (log.x < 0 || log.x >= n) return false;
    if (arr[log.y][log.x] == 1) return false; // 나무칸 체크
 
    return true;
}
 
bool CanRotate(const int y, const int x) // O(n) == 9가 보장되어야 함.
{
    for (int i = y - 1; i <= y + 1; ++i)
    {
        if (i < 0 || i >= n) return false;
 
        for (int j = x - 1; j <= x + 1; ++j)
        {
            if (j < 0 || j >= n) return false;
 
            if (arr[i][j] == 1) return false;
        }
    }
 
    return true;
}
 
void DFS(Log curLog, int moveCount) // 유효한 좌표로 넘어왔다고 보장
{
    int cy = curLog.y;
    int cx = curLog.x;
    bool cbIsVertical = curLog.bIsVertical;
 
    int& result = dp[cy][cx][cbIsVertical];
 
    if (curLog == destLog) // 목적지 도착했으면
    {
        result = min(result, moveCount);
        answer = result;
 
        return;
    }
 
    if (result <= moveCount) // 이미 더 낮은값 기록되어있으면.
    {
        return; // 탐색종료.
    }
 
    result = moveCount;
 
    int fy, fx, ty, tx;
 
    if (cbIsVertical)
    {
        fy = cy - 1;
        fx = cx;
        ty = cy + 1;
        tx = cx;
    }
    else
    {
        fy = cy;
        fx = cx - 1;
        ty = cy;
        tx = cx + 1;
    }
 
    for (int i = 0; i < 5; ++i)
    {
        int offset = 1;
 
        if (i == 4 && !curLog.bIsVertical)
        {
            offset = -1;
        }
 
        Log tempFirst = { fy + offset * dirs[i][0][0], fx + dirs[i][0][1] * offset }; // next좌표
        if (!IsInRange(tempFirst)) continue;
 
        Log tempSecond = { cy + dirs[i][1][0], cx + dirs[i][1][1], cbIsVertical };
        if (!IsInRange(tempSecond)) continue;
 
        Log tempThird = { ty + offset * dirs[i][2][0], tx + dirs[i][2][1] * offset };
        if (!IsInRange(tempThird)) continue;
 
        if (i <= 3)
        {
            DFS(tempSecond, moveCount + 1);
        }
        else // 회전시키기 시도
        {
            if (CanRotate(cy, cx)) // 현재위치에서 회전가능한지 먼저 검사.
            {
                tempSecond.bIsVertical = !tempSecond.bIsVertical;
                DFS(tempSecond, moveCount + 1);
            }
        }
    }
}
 
 
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    cin >> n;
 
    vector<Log> startLog;
    vector<Log> tempDestLog;
 
    for (int i = 0; i < n; ++i)
    {
        string s;
 
        cin >> s;
 
        for (int j = 0; j < n; ++j)
        {
            if (s[j] == 'B')
            {
                arr[i][j] = 0;
                startLog.push_back({ i,j });
 
            }
            else if (s[j] == 'E')
            {
                arr[i][j] = 0;
                tempDestLog.push_back({ i,j });
            }
            else
            {
                arr[i][j] = s[j] - '0';
            }
        }
    }
 
    memset(dp, 0x3f, sizeof(dp));
 
    bool bIsStartVertical = startLog[0].x == startLog[1].x ? true : false;
    bool bIsDestVerticla = tempDestLog[0].x == tempDestLog[1].x ? true : false;
 
    destLog = { tempDestLog[1].y, tempDestLog[1].x, bIsDestVerticla };
 
    startLog[1].bIsVertical = bIsStartVertical;
    DFS(startLog[1], 0);
 
    if (answer == 0x3f3f3f3f)
    {
        cout << 0;
    }
    else
    {
        cout << answer;
    }
}
Colored by Color Scripter

cs

[Algorithm]Baekjoon 2539번 :: 모자이크

MaxLevel — Tue, 4 Nov 2025 21:23:59 +0900

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <algorithm>
#include <math.h>
#include <queue>
#include <functional>
#include <sstream>
#include <memory.h>
#include <deque>
#include <set>
#include <unordered_set>
#include <thread>
#include <atomic>
 
using namespace std;
  
struct Node
{
    int y;
    int x;
};
 
bool cmp(const Node& a, const Node& b)
{
    return a.x < b.x;
}
 
int n, m, paperCount, wrongCount, wy, wx;
int minSize = 0;
vector<Node> wrongNodes;
 
bool check(int paperSize) 
{
    int tempPaperCount = 1;
    int rangeSizeX = wrongNodes[0].x + paperSize - 1;
 
    for (int i = 1; i < wrongNodes.size(); ++i)
    {
        int x = wrongNodes[i].x;
 
        if (x > rangeSizeX) // 이전에 붙였던 색종이를 벗어나면
        {
            // 새로 붙인다.
            ++tempPaperCount;
            rangeSizeX = x + paperSize - 1;
 
            if (rangeSizeX >= m) // 끝까지 했으면
            {
                break;
            }
        }
    }
 
    return tempPaperCount <= paperCount;
}
 
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    cin >> n >> m >> paperCount >> wrongCount;
 
    for (int i = 0; i < wrongCount; ++i)
    {
        cin >> wy >> wx;
 
        wrongNodes.push_back({ wy,wx });
        minSize = max(minSize, wy);
    }
 
    sort(wrongNodes.begin(), wrongNodes.end(), cmp);
 
    int left = minSize;
    int right = 10000001;
    int answer = 0;
 
    while (left <= right)
    {
        int mid = (left + right) / 2;
 
        if (check(mid))
        {
            right = mid - 1;
            answer = mid;
        }
        else
        {
            left = mid + 1;
        }
    }
 
    cout << answer;
}
 
 
Colored by Color Scripter

cs

일정개수 이하의 색종이를 붙여서 잘못 색칠된 곳을 덮으려 할 때, 최소의 색종이 크기를 구하는 문제이다.

이 문제에서 놓치면 안될 중요한 점은 색종이는 반드시 도화지의 밑변에 딱 붙여야 한다는 것이다.

그렇기 때문에 색종이의 최소크기는 잘못 색칠된 칸들 중 y값이 가장 높은 값이다.

밑변에 딱 붙여야하기 때문에, 어쩔 수 없이 가장 큰 y값이 최소값 (left)가 될 수 밖에 없다.

이후 문제에서 요구하는 답인 색종이크기값으로 이분탐색을 진행할 건데, 색종이크기는 정해놨으니 정해진 개수이하로 모든 잘못색칠된 칸을 덮을 수 있는지 검사해야 한다.

처음에 left값을 최대y값으로 미리 했으니, 검사할 때 y값을 체크할 필욘 없다. 어차피 check할 때의 mid값은 반드시 잘못색칠된 칸의 y값보다 크거나 같으니까.

그러니 x값만 체크하면 되는데, rangeSizeX라는 변수를 선언해서 유효한 X범위를 미리 체크해둔다.

잘못색칠된칸들을 순회할 때, 이 칸의 X값이 유효한X범위안이면 이전에 붙인 색종이로 덮여져 있으니 그냥 지나치면 되고, X범위를 넘어서면 새로 붙여야하니 카운팅한다음 rangeSizeX값도 새로 갱신해준다.

[Algorithm]Baekjoon 9024번 :: 두 수의 합

MaxLevel — Tue, 4 Nov 2025 19:05:59 +0900

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <algorithm>
#include <math.h>
#include <queue>
#include <functional>
#include <sstream>
#include <memory.h>
#include <deque>
#include <set>
#include <unordered_set>
#include <thread>
#include <atomic>
 
using namespace std;
 
int t, n, k;
int arr[1000001] = { 0 };
 
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    cin >> t;
 
    while (t--)
    {
        cin >> n >> k;
        
        for (int i = 0; i < n; ++i)
        {
            cin >> arr[i];
        }
 
        sort(arr, arr + n);
 
        int left = 0;
        int right = n - 1;
        int minGap = 0x3f3f3f3f;
        int minGapCount = 0;
 
        while (left < right)
        {
            int num = arr[left] + arr[right];
 
            int gap = abs(k - num);
            
            if (gap == minGap) // 현재까지의 최소갭과 동일하면 카운팅
            {
                ++minGapCount;
            }
            else if (gap < minGap) // 더 작으면 업데이트.
            {
                minGap = gap;
                minGapCount = 1;
            }
 
            if (num <= k)
            {
                ++left;
            }
            else
            {
                --right;
            }
        }
 
        printf("%d\n", minGapCount);
    }
}
 
 
Colored by Color Scripter

cs

약간 투포인터문제의 정석 느낌이 나는 문제다.

타겟값k와 가장 가까운 두 수의 합을 구한다음 그 합의 개수까지 구해야 한다.

배열을 정렬 후, 양끝에 두개의 포인터를 둔다음 탐색을 시작할 건데, 값이 오름차순으로 정렬되어 있기 때문에 두 포인터가 가리키는 숫자의 합이 작을경우 값을 늘려야하니까 왼쪽포인터를 한칸 오른쪽으로 옮긴다.

두 숫자의 합이 크면 값을 줄여야하니까 오른쪽포인터를 한칸 왼쪽으로 옮긴다.

매번 옮길때마다 k와의 gap을 업데이트 해주면 되는데 최종출력은 개수를 출력하는 거라서 매 탐색 시 현재까지의 최소gap값과 일치하면 카운팅 해주면 된다. gap값이 더 작은값을 발견하면 다시 초기화해주면 되고.