All is well

[오늘의 에러/GitBash] fatal: invalid reference: / error: The following untracked working tree files would be overwritten by merge:

D0YUN — Fri, 21 Mar 2025 10:32:04 +0900

오늘의 에러1

fatal: invalid reference: ProductDataTable_fin

오류 원인

해결 방법 (선택지 2가지)

https://wakestand.tistory.com/808

Git local에 없는 branch switch 하는 방법

Git에 만들어져 있는 branch이긴 한데 local에 다운로드 받지 않았을 경우 git switch branch명으로 branch 변경이 되지 않는데 $ git switch branch명 fatal: invalid reference: branch명 이런 식의 에러가 뜨게 된다 여

wakestand.tistory.com

오늘의 에러2

error: The following untracked working tree files would be overwritten by merge:

오류 원인

Git은 파일을 병합하는 과정에서 로컬에서 수정되지 않은 파일은 덮어쓸 수 있지만, Git이 추적하고 있지 않은(untracked) 파일이 존재하면 덮어쓰기를 방지한다. 그래서 에러가 발생했다.

해결 방법 (선택지 2가지)

방법1) 로컬 경로의 파일 삭제하기 (로컬 변경 사항 무시)
만약 원격 저장소의 파일로 덮어써도 상관없다면, 로컬의 해당 파일을 삭제하면 됩니다.그런 다음 다시 병합을 시도합니다.

rm Content/DYL/Blueprints/BP_SuperGameMode.uasset

이후 병합 시도

git pull

방법2) Git의 원격 저장소 파일 삭제하기 (원격 저장소 변경 사항 무시)
만약 로컬 파일이 더 중요하고 원격 저장소에서 해당 파일을 업데이트하지 않기를 원한다면, 원격 저장소에서 해당 파일을 삭제하거나 .gitignore로 무시하도록 설정할 수 있습니다.

.gitignore에 추가하는 방법 (추적하지 않도록 설정)

echo "Content/DYL/Blueprints/BP_SuperGameMode.uasset" >> .gitignore
git rm --cached Content/DYL/Blueprints/BP_SuperGameMode.uasset
git commit -m "Ignore BP_SuperGameMode.uasset file"
git push

해결 과정

해결 완료

[오늘의에러/UE] fatal error C1083: 포함 파일을 열 수 없습니다. 'Character/CCharacter.h': No such file or directory (헤더 파일과 소스 파일을 한 폴더에 담았을 때 소스 파일이 헤더 파일을 인식하지 못하는 경우)

D0YUN — Sun, 16 Mar 2025 15:04:27 +0900

오늘의 에러

fatal error C1083: 포함 파일을 열 수 없습니다. 'Character/CCharacter.h': No such file or directory

클론 코딩하다가 소스 파일이 헤더 파일을 인식하지 못하는 에러를 만났다

에러 발생

CCharacter.cpp

언리얼에서 Player 역할을 할 `CCharacter` 파일을 생성하였다.

이때 Public, Private 폴더에 각각 헤더 파일과 소스 파일을 추가하는 것 대신 Character라는 폴더에서 한번에 관리하기 위해 Character 폴더 하위에 두 파일이 생성되도록 설정을 하였다.

같은 폴더 안에 있으면 당연하게 인식을 해야 하는데 소스 파일이 헤더 파일을 인식하지 못하여 당황스러웠다.

에러 원인

이 에러는 주로 `#include` 경로 문제에서 발생한다고 한다.

이 케이스는 Unreal Engine의 빌드 시스템이 `Character.h`와 `Character.cpp`가 들어 있는 Character 폴더의 경로를 제대로 인식하지 못해서 발생했다.

Unreal에서는 보통 `Source/프로젝트이름/` 아래 `Public`과 `Private` 폴더를 두고 관리하며, `Public`에 있는 헤더는 `#include "CCharacter.h"`처럼 단순 이름으로 접근하는 것이 일반적이다.

그런데 Character 폴더에 두 파일을 함께 담았을 경우 Unreal Engine의 Public 또는 Private 폴더 구조를 고려하지 않았기 때문에 제대로 인식하지 못하게 된다.

이를 인식시키기 위해서는 `CCharacter.h`가 있는 폴더를 `Build.cs` 파일에서 추가해서 Unreal Build System이 해당 파일을 찾을 수 있도록 해줘야 한다.

해결 방법

Odyssey.Build.cs

이 에러를 해결하려면 프로젝트의 `Build.cs` 파일에서 `PublicIncludePaths`에 올바른 헤더 경로를 추가해야 한다.

방법은 두 가지다

방법1

PublicIncludePaths.Add(ModuleDirectory);

이 방법을 이용하면 `ModuleDirectory`를 추가하여 `Source/Odyssey/` 전체를 포함할 수 있다.

`#include "CCharacter.h"`처럼 간략한 경로로 헤더를 포함할 수 있고
`Character` 폴더를 따로 지정하지 않아도 `ModuleDirectory` 아래에 있는 모든 헤더 파일을 검색할 수 있다.

방법2

PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Character"));

이 방법을 사용하면 `Character` 디렉터리만 포함 경로에 추가할 수 있다.

`Character` 폴더만 포함 경로에 추가되므로, 헤더 검색 범위를 최소화할 수 있고
이를 통해 빌드 속도를 조금 더 최적화할 가능성이 생긴다.

모든 C++ 파일을 Public, Private을 나누지 않고 기능 별로 묶어 한 폴더에서 관리할 예정이라 방법1을 선택하였다.

추가 개념 정리

// PublicIncludePaths

Unreal Build System에서 헤더 파일을 검색하는 경로 목록이다.
여기에 추가된 경로는 다른 모듈에서도 접근할 수 있는 `Public` 헤더 파일들의 포함 경로로 사용된다.

PublicIncludePaths.Add(ModuleDirectory);

위와 같이 설정하면, ModuleDirectory 내부의 모든 폴더가 검색 경로로 추가된다.

이를 통해 `#include "파일명.h" `형식으로 간략하게 불러올 수 있다.

// ModuleDirectory

`ModuleDirectory`는 현재 모듈의 루트 디렉터리 경로를 나타내는 문자열이다.

이 프로젝트의 구조를 빌려 설명하자면

Odyssey/
 ├── Source/
 │   ├── Odyssey/   (ModuleDirectory)
 │   │   ├── Character/
 │   │   │   ├── CCharacter.h
 │   │   │   ├── CCharacter.cpp

`ModuleDirectory` = `"Source/Odyssey"`
`PublicIncludePaths.Add(ModuleDirectory);`를 추가하면 `Source/Odyssey/` 내부의 모든 폴더에서 헤더를 찾을 수 있다.

#include "CCharacter.h"  // 정상적으로 인식 가능

해결완료

[YYBASIC0401/얌얌코딩] std::string 클래스 만들어보기

D0YUN — Fri, 14 Mar 2025 16:45:05 +0900

#include <iostream>

namespace ya
{
    class string
    {
    public:
        // 기본 생성자: mStr을 nullptr로 초기화하여 정의되지 않은 동작을 방지
        // 멤버 이니셜라이저(:)를 사용하여 mStr을 직접 초기화함으로써 불필요한 대입을 방지하고 성능 최적화
        string() : mStr(nullptr)
        {
            std::cout << "nullptr\n";  // 디버깅용: 기본 생성자가 호출되었음을 알림
        }

        // C 스타일 문자열을 사용하여 객체를 초기화하는 생성자
        // 멤버 이니셜라이저(:)를 사용하여 mStr을 nullptr로 초기화한 후, 동적 할당을 통해 문자열을 저장
        string(const char* str) : mStr(nullptr)
        {
            // str이 null이 아님을 가정하고, 입력 문자열의 길이를 계산
            int len = strlen(str);

            // 문자열과 널 종료문자('\0')를 저장할 메모리를 동적으로 할당
            mStr = new char[len + 1];

            // 문자열을 한 글자씩 복사
            for (size_t i = 0; i < len; i++)
            {
                mStr[i] = str[i];
                std::cout << mStr[i] << '\n';  // 디버깅용: 복사되는 문자 출력
            }

            std::cout << "\n";  // 디버깅용: 복사 완료 후 줄바꿈 출력

            // 문자열 끝에 널 종료문자('\0')를 추가하여 올바른 문자열 형식을 유지
            mStr[len] = '\0';
        }

        // 소멸자: 동적으로 할당된 메모리를 해제하여 메모리 누수를 방지
        ~string()
        {
            delete[] mStr;
        }

    private:
        // 문자열을 저장하는 동적 할당된 메모리의 포인터
        char* mStr;
    };
}

int main()
{
    // 표준 라이브러리의 std::string을 선언 및 초기화
    std::string hello = "Hello!";

    // 기본 생성자로 ya::string 객체를 생성 (mStr이 nullptr로 초기화됨)
    ya::string yaHello1;

    // 기본 생성자를 사용한 임시 객체를 생성한 후, 이를 yaHello2에 복사하여 초기화
    // 주의: 
    // 1. C++ 컴파일러는 최적화를 통해 불필요한 복사를 줄이는 RVO(Return Value Optimization)를 수행할 수도 있음
    // 2. 하지만 일부 컴파일러나 특정 상황에서는 RVO가 적용되지 않아 객체가 복사될 가능성이 있음
    // 3. 즉, yaHello2는 ya::string()을 호출하여 생성된 임시 객체에서 복사되지만, 
    //    RVO가 적용되지 않으면 불필요한 복사 생성자가 호출될 수도 있으므로 권장되지 않음
    ya::string yaHello2 = ya::string();

    // C 스타일 문자열을 사용하여 ya::string 객체를 초기화
    ya::string yaHello3 = "Hello!";  // 문자열을 받는 생성자 호출
    ya::string yaHello4("Hello!");   // 동일한 방식의 객체 초기화

    return 0;
}

// 디버깅용 코드 실행 결과

LV12 string 클래스 만들어보기

[백준/C++] 10988(팰린드롬인지 확인하기) (단순 인덱스 비교 / 캐시 최적화 / reverse() / deque / 투 포인터 / 재귀)

D0YUN — Wed, 12 Mar 2025 12:15:34 +0900

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

내가 해냄 : 단순 인덱스 비교 방식

#include<iostream>
using namespace std;

int main()
{
    // 문자열을 입력받는다.
    string s;
    cin >> s;

    // 문자열의 길이를 변수에 저장한다.
    int len = (int)s.size();

    // 문자열이 팰린드롬인지 확인하기 위해 절반만 검사한다.
    for (int i = 0; i < len / 2; i++)
    {
        // i번째 문자와 (len-1-i)번째 문자가 다르면 팰린드롬이 아니다.
        if (s[i] != s[len - 1 - i])
        {
            // 팰린드롬이 아님을 의미하는 0을 출력하고 프로그램을 종료한다.
            cout << 0;
            return 0;
        }
    }

    // 모든 비교를 통과하면 팰린드롬이므로 1을 출력한다.
    cout << 1;
    return 0;
}

사용한 핵심 개념

// 단순 인덱스 비교 방식

문자열의 앞쪽(s[i])과 뒤쪽(s[len - 1 - i])을 직접 인덱스로 접근하여 비교한다.
반복문을 문자열 길이의 절반(len / 2)까지만 실행하여 비교 횟수를 최소화 하였다.
만약 하나라도 다르면(대칭이 깨지면) 즉시 0을 출력하고 종료 (`return 0;`)하여 추가적인 반복을 배제한다.
모든 비교를 통과하면 팰린드롬이므로 1을 출력하고 함수를 종료한다.
투 포인터 방식과 비슷하지만, 두 개의 포인터를 따로 선언하지 않고 인덱스를 직접 계산하여 접근한다.

AI 피드백 : 캐시 효율 증가

#include <iostream>
using namespace std;

int main() {
    // 문자열 입력
    string s;
    cin >> s;

    int len = (int)s.size();
    int half = len / 2; // 미리 계산하여 반복 조건을 줄임

    // 팰린드롬 검사
    for (int i = 0; i < half; i++) {
        char front = s[i], back = s[len - 1 - i]; // 변수에 저장하여 캐시 효율 증가
        if (front != back) {
            cout << 0;
            return 0;
        }
    }

    cout << 1;
    return 0;
}

주요 최적화 내용

// 반복문에서 반복 조건 계산 줄이기

`len`을 반복문 내부에서 계속 참조하는 대신, 미리 `half = len / 2;`를 계산하여 반복 시 불필요한 연산을 줄인다

// for 문 내부에서 변수를 미리 선언하여 캐시 최적화

루프 안에서 `s[i]`와 `s[len - 1 - i]`를 매번 접근하는 대신, 한 번 변수에 저장하여 CPU 캐시 효율을 높일 수 있다

루프 내부 변수 선언을 통한 캐시 최적화란?

// 기존 방식

for (int i = 0; i < len / 2; i++)
{
    if (s[i] != s[len - 1 - i]) // 매번 s[i]와 s[len - 1 - i]에 직접 접근
    {
        cout << 0;
        return 0;
    }
}

`s[i]`와 `s[len - 1 - i]`를 매번 직접 배열 인덱싱하여 비교하는 방식이다.
문자열 s의 메모리 주소를 반복적으로 참조하게 된다.
CPU 캐시에서 데이터를 불러오는 과정이 반복되므로 성능이 미세하게 저하될 수 있다.

// 캐시 최적화를 적용한 방식

for (int i = 0; i < len / 2; i++) {
    char front = s[i], back = s[len - 1 - i]; // 변수에 저장하여 캐시 효율 증가
    if (front != back) {
        cout << 0;
        return 0;
    }
}

`s[i]`와 `s[len - 1 - i]`를 변수(`front`, `back`)에 한 번만 저장한다.
이후 메모리에서 불러오는 대신 변수로 비교하므로 캐시 효율이 증가한다.
CPU가 필요 없는 메모리 접근을 줄이게 되어 성능이 미세하게 향상된다.

// 캐시 최적화의 원리

CPU 캐시(Cache)란?
- CPU는 데이터를 빠르게 읽기 위해 캐시(Cache)라는 작은 고속 메모리를 사용한다.
- 하지만, 캐시에 없는 데이터는 RAM에서 불러와야 하고, 이는 상대적으로 느리다.
배열 접근과 캐시 미스(Cache Miss)
- 배열 인덱스를 여러 번 참조하면, 해당 데이터가 캐시에 없을 가능성이 높아진다(캐시 미스 발생).
- 따라서 반복문 안에서 동일한 값을 여러 번 참조하는 경우, 변수에 저장해두면 캐시 접근을 최소화할 수 있다.
변수를 활용한 최적화 효과
- `s[i]`와 `s[len - 1 - i]` 값을 미리 변수에 저장하면 CPU가 캐시에서 빠르게 값을 읽을 수 있다.
- 메모리 접근 비용을 줄여 성능이 향상된다.

// 성능 차이 분석 (실제 적용 효과)

방식	메모리 접근 횟수	CPU 캐시 최적화 효과
기존 방식	O(N) (반복문마다 s[i]와 s[len-1-i]에 접근)	낮음
변수 저장 방식	O(N) (한 번만 배열 접근 후 변수로 비교)	높음

기존 방식과의 성능 차이가 크지 않지만, CPU 캐시 미스를 줄이려면 변수에 저장하여 비교하는 것이 더 효율적이다.
고성능이 중요한 환경에서는 이런 작은 최적화들이 누적되면서 차이를 만들 수 있다.

또 다른 풀이 1 : `reverse()` 이용

문자열을 뒤집어서 원본 문자열과 비교하는 방식이다.
C++의 reverse() 함수를 사용하여 빠르게 문자열을 뒤집고, 원본과 비교하면 된다.

#include <iostream>
#include <algorithm> // reverse() 함수 포함
using namespace std;

int main() {
    string s;
    cin >> s;

    string rev = s; // 원본 문자열을 복사
    reverse(rev.begin(), rev.end()); // 문자열을 뒤집음

    cout << (s == rev ? 1 : 0); // 원본과 비교하여 출력
    return 0;
}

// 장점

코드가 매우 간결하고 직관적이다.
STL을 활용하여 가독성이 높아진다.

// 단점

문자열을 복사하는 과정에서 O(N)의 추가적인 공간이 필요하다.
`reverse()` 연산도 O(N)이므로 시간 복잡도가 O(N)으로 동일하다.

또 다른 풀이 2 : `deque`(덱)를 이용한 풀이

deque(덱)를 사용하여 문자열을 앞뒤에서 비교하는 방식이다.
덱은 양쪽에서 데이터를 추가 및 제거할 수 있는 자료구조이며, 이를 활용하면 투 포인터 방식처럼 앞과 뒤를 비교하면서 값을 제거하는 방식으로 풀이 가능하다.

#include <iostream>
#include <deque>
using namespace std;

int main() {
    string s;
    cin >> s;
    
    deque<char> dq(s.begin(), s.end()); // 문자열을 덱에 저장

    while (dq.size() > 1) { // 덱의 크기가 1보다 클 때까지 비교
        if (dq.front() != dq.back()) { // 앞과 뒤가 다르면 팰린드롬 아님
            cout << 0;
            return 0;
        }
        dq.pop_front(); // 앞 문자 제거
        dq.pop_back();  // 뒤 문자 제거
    }

    cout << 1; // 팰린드롬이면 1 출력
    return 0;
}

// 장점

덱을 활용하면 큐와 유사한 방식으로 앞뒤를 제거하면서 비교할 수 있다.
직관적으로 앞과 뒤에서 접근하는 방식이 명확하다.

// 단점

덱을 생성하는 과정에서 O(N)의 추가 공간이 필요하다.
`pop_front()`와 `pop_back()`이 실행될 때마다 오버헤드가 발생할 수 있다.

또 다른 풀이 3 : 투 포인터(Two Pointer) 이용

투 포인터(Two Pointers) 방식은 두 개의 포인터(left, right)를 사용하여 비교하는 방식이다.

#include <iostream>
using namespace std;

int main() {
    string s;
    cin >> s;

    int left = 0, right = (int)s.size() - 1; // 두 개의 포인터 설정

    while (left < right) { // 두 포인터가 교차하기 전까지 반복
        if (s[left] != s[right]) { // 대칭이 깨지면 팰린드롬이 아님
            cout << 0;
            return 0;
        }
        left++;  // 왼쪽 포인터 이동
        right--; // 오른쪽 포인터 이동
    }

    cout << 1; // 팰린드롬이면 1 출력
    return 0;
}

투 포인터 방식의 장점

// 가독성

`left`와 `right` 두 개의 포인터를 사용하므로, 코드의 흐름이 명확하다.
기존 코드에서는 `s[len - 1 - i]`처럼 인덱스를 직접 계산해야 했지만, 여기서는 두 개의 포인터가 이동하면서 비교하므로 논리적으로 직관적이다.

// 다양한 문제 해결에 적용 가능

투 포인터 방식은 문자열 비교뿐만 아니라, 정렬된 배열에서 특정 값을 찾는 문제, 두 개의 배열을 합치는 문제 등 다양한 곳에서 활용 가능하다.
- ex) 정렬된 배열에서 특정 합을 가지는 두 수를 찾는 문제(Two Sum)

// 성능 향상 가능성

기존 코드와 시간 복잡도는 동일하지만, 특정한 경우에는 캐시 효율이 증가할 가능성이 있다.
캐시 미스를 줄이기 위해 두 포인터를 사용하면 배열을 순차적으로 탐색하므로 공간 지역성(Spatial Locality)이 더욱 극대화된다.

또 다른 풀이 4 : 재귀(Recursion) 이용

`isPalindrome()` 함수를 재귀적으로 호출하면서 앞과 뒤의 문자를 비교한다.

#include <iostream>
using namespace std;

bool isPalindrome(const string &s, int left, int right) {
    if (left >= right) return true; // 기저 사례: 모든 문자가 일치했을 경우
    if (s[left] != s[right]) return false; // 문자가 다르면 팰린드롬 아님
    return isPalindrome(s, left + 1, right - 1); // 재귀 호출
}

int main() {
    string s;
    cin >> s;
    cout << (isPalindrome(s, 0, s.size() - 1) ? 1 : 0);
    return 0;
}

// 장점

재귀 호출을 활용하여 다른 문제에도 쉽게 응용할 수 있다.

// 단점

재귀 호출이 많아지면 스택 오버플로우(Stack Overflow) 위험이 존재한다.
반복문보다 성능이 떨어지며, 비효율적인 메모리 사용이 발생할 수 있다.

(맨 아래부터) 단순 인덱스 비교 / 캐시 최적화 이용 / reverse() 이용 / deque 이용 / Two pointer 이용 / Recursion 이용

간단한 문제였는데 생각보다 다양한 풀이 방법이 있어서 흥미로웠다.

[백준/C++] 15651(N과 M (2)) (중복 순열 / 백 트래킹 / 재귀 / 완전 탐색 / ostringstream)

D0YUN — Tue, 11 Mar 2025 22:05:01 +0900

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

내가 해냄 : Back tracking 이용

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

int N, M;               // 자연수 N과 M을 저장하는 변수
vector<int> v;          // 1부터 N까지의 숫자를 저장할 벡터
vector<int> result;     // 선택한 숫자를 저장할 벡터

/*
    문제의 핵심:
    - 숫자를 중복해서 선택할 수 있기 때문에 방문 체크를 하지 않는다.
    - 사전 순 증가하는 순서로 출력해야 하므로 1부터 N까지의 숫자를 저장한 후 백트래킹을 수행한다.
*/

// 백트래킹을 활용하여 자기 자신을 포함하여 M개의 원소를 선택한다
void backtrack(int depth)
{
    // M개를 선택했으면 출력한다
    if (depth == M)
    {
        for(int i = 0; i < M; i++)
            cout << result[i] << ( i != M - 1 ? " " : "\n");
        return;
    }

    // 숫자를 선택한다
    for (int i = 0; i < N; i++) {
        result.push_back(v[i]); // 현재 선택한 숫자를 result에 추가한다

        backtrack(depth + 1);   // 다음 숫자를 선택하기 위해 재귀함수를 호출한다

        // Backtracking : 선택한 숫자를 제거하여 이전 상태로 되돌아 간다
        result.pop_back();
    }
}

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

    // N과 M을 입력받는다
    cin >> N >> M;

    // 1부터 N까지 수를 벡터 v에 저장한다
    v.resize(N);
    iota(v.begin(), v.end(), 1);

    // 백트래킹을 시작한다 (depth = 0)
    backtrack(0);

    return 0;
}

사용한 핵심 개념

// 중복을 허용하는 순열 (중복 순열, Multiset Permutation)

문제에서 같은 수를 여러 번 선택할 수 있으므로 일반적인 순열이 아닌 "중복을 허용하는 순열"을 만들어야 한다.
따라서, 방문 체크 (`visited[]`)를 하지 않고 모든 숫자를 선택할 수 있도록 한다.

사용 예시

for (int i = 0; i < N; i++) {
    result.push_back(v[i]); // 현재 숫자 선택
    backtrack(depth + 1);   // 다음 숫자 선택
    result.pop_back();      // 백트래킹
}

방문 체크를 하지 않고 모든 숫자를 다시 선택할 수 있도록 허용했다.
`v[i]`를 여러 번 선택하여 중복된 숫자가 포함된 수열을 생성할 수 있다.

// 백트래킹 (Backtracking)

백트래킹은 모든 가능한 경우를 탐색하는 알고리즘 기법이다.
불필요한 경로를 미리 차단하여 탐색 속도를 최적화할 수 있다.
이번 문제에서는 M개의 숫자를 중복 선택할 수 있는 순열을 생성하는 과정에서 백트래킹을 사용했다.

사용 예시

void backtrack(int depth)
{
    if (depth == M) { // M개의 숫자를 선택한 경우 출력
        for(int i = 0; i < M; i++)
            cout << result[i] << (i != M - 1 ? " " : "\n");
        return;
    }

    for (int i = 0; i < N; i++) {
        result.push_back(v[i]); // 현재 숫자 선택
        backtrack(depth + 1);   // 다음 숫자 선택 (재귀 호출)
        result.pop_back();      // 백트래킹 (이전 상태로 복구)
    }
}

현재 `depth`가 M이면 완성된 수열이므로 출력한다.
1부터 N까지의 숫자를 선택하고, `depth+1` 단계로 넘어간다.
`result.pop_back();`을 수행하여 이전 상태로 되돌린다.

AI 피드백 : 완전 탐색을 활용한 구현

#include <iostream>  // 표준 입출력 사용 (cin, cout)
#include <vector>    // 벡터 자료구조 사용 (vector<int>)
#include <sstream>   // 문자열 스트림 사용 (ostringstream)

using namespace std;

int N, M;           // 입력으로 주어지는 자연수 N과 M
ostringstream out;  // 출력을 버퍼에 저장하여 성능을 최적화하는 스트림 객체

int main() {
    ios_base::sync_with_stdio(0); // 입출력 속도 최적화 (C 스타일 입출력과 동기화 해제)
    cin.tie(0); cout.tie(0);      // 입력과 출력을 분리하여 속도를 더 향상시킴

    // 사용자 입력 받기: N(1~N까지 숫자 사용), M(길이가 M인 수열 생성)
    cin >> N >> M;

    // M자리 수열을 표현할 벡터 (모든 자리 초기값을 1로 설정)
    vector<int> indices(M, 1);

    while (true) {
        // 현재 선택된 숫자들을 출력 스트림(out)에 저장
        for (int i = 0; i < M; i++)
            out << indices[i] << (i != M - 1 ? " " : "\n"); // 마지막 숫자 뒤에는 개행 추가

        // 가장 오른쪽 자리부터 증가시키면서 새로운 조합 생성
        int pos = M - 1;  // 맨 끝자리(index M-1)부터 증가시키기 시작
        while (pos >= 0 && indices[pos] == N) 
            pos--;  // 현재 자리의 숫자가 N이면, 그 앞자리(pos-1)를 변경

        // pos가 -1이면 모든 조합을 생성했으므로 종료
        if (pos < 0) break;

        indices[pos]++; // 현재 자릿수 값 증가

        // 증가한 자리(pos) 뒤쪽의 모든 숫자를 1로 초기화
        for (int i = pos + 1; i < M; i++) 
            indices[i] = 1;
    }

    // 한 번에 모든 출력을 수행하여 속도 향상
    cout << out.str();
    
    return 0;
}

사용한 핵심 개념

// 완전 탐색 (Brute Force)

모든 경우의 수를 전부 탐색하는 방식으로, 가능한 모든 선택지를 하나씩 나열하며 답을 찾는다.
이 문제에서는 `N^M`개의 경우의 수가 존재하며, 모든 경우를 직접 생성하여 출력하는 방식을 사용한다.
백트래킹을 사용하면 불필요한 탐색을 줄일 수 있지만, 이 코드에서는 반복문을 활용하여 단순하게 모든 경우의 수를 직접 생성하는 방식을 선택했다.

예제 (N=3, M=2)

입력값이 `N = 3`, `M = 2`라면, 가능한 모든 조합은:

이 조합을 순서대로 생성하는 것이 완전 탐색의 핵심이다.

코드에서 완전 탐색을 구현한 부분

while (true) {  // 모든 경우를 생성할 때까지 반복
    for (int i = 0; i < M; i++)
        out << indices[i] << (i != M - 1 ? " " : "\n");

    int pos = M - 1;
    while (pos >= 0 && indices[pos] == N) pos--;  // 더 증가할 수 있는 자리 찾기

    if (pos < 0) break;  // 모든 조합을 다 만들었으면 종료

    indices[pos]++;  // 증가할 수 있는 자리 증가
    for (int i = pos + 1; i < M; i++) indices[i] = 1;  // 이후 자리 초기화
}

조건을 만족하는지 확인하는 과정 없이 무조건 모든 경우를 출력하기 때문에 완전 탐색이 이루어지고 있다고 볼 수 있다.

// 사전순 탐색 (Lexicographic Order)

가장 작은 숫자부터 시작해서 사전순으로 증가하는 순서로 탐색하는 방법이다.
문제에서 사전순 증가 형태로 출력해야 하므로, 작은 수부터 증가하면서 새로운 조합을 만든다.
`indices` 배열을 1부터 시작하고, 오른쪽 자리부터 숫자를 증가시키는 방식으로 구현한다.

예제 (N=3, M=2)

`{1,1}` → `{1,2}` → `{1,3}`
`{2,1}` → `{2,2}` → `{2,3}`
`{3,1}` → `{3,2}` → `{3,3}`

모든 조합이 사전순(오름차순)으로 정렬되어 탐색된다.

코드에서 사전순 탐색을 구현한 부분

for (int i = pos + 1; i < M; i++) indices[i] = 1;  // 증가한 자리 뒤를 1로 초기화

출력 순서가 작은 수에서 큰 수로 변한다.
반복문을 활용하여 증가된 자리 이후의 값들은 가장 작은 값(1)으로 다시 초기화되어 별도의 정렬 없이 사전순 정렬을 유지한다

// 자리값 조정 (Position Update)

숫자를 증가시키면서 모든 조합을 만들되, 오른쪽 자리부터 증가시키는 방식을 사용한다.
마지막 숫자가 N에 도달하면, 그 앞자리를 증가시키고 뒷자리는 다시 1로 초기화한다.

자리 증가 과정 (N=3, M=2)

`{1,1}` → `{1,2}` → `{1,3}` : 오른쪽 자리(두 번째 숫자)만 증가한다
`{2,1}` → `{2,2}` → `{2,3}` : 첫 번째 숫자를 증가시키고 두 번째 숫자는 1부터 다시 시작한다
`{3,1}` → `{3,2}` → `{3,3}` : 첫 번째 숫자가 N까지 도달하면 탐색을 종료한다

코드에서 자리값 조정을 구현한 부분

int pos = M - 1;
while (pos >= 0 && indices[pos] == N) pos--;  // 더 증가할 수 있는 자리 찾기

if (pos < 0) break;  // 모든 조합을 다 만들었으면 종료

indices[pos]++;  // 증가할 수 있는 자리 증가
for (int i = pos + 1; i < M; i++) indices[i] = 1;  // 이후 자리 초기화

오른쪽 자리부터 확인하여 N이면 앞자리를 증가시키고 뒤의 숫자를 초기화하여 증가 가능 여부를 판단한다.

// ostringstream를 활용한 입출력 최적화

`cout`을 여러 번 호출하는 것의 문제점

`cout`을 사용하면 데이터가 한 번 출력될 때마다 버퍼를 flush(비우는 작업) 하게 된다.
즉, `cout`을 여러 번 호출하면 매번 버퍼를 비우면서 출력을 수행하므로 실행 속도가 느려진다.

예제 (비효율적인 출력)

for (int i = 0; i < M; i++) {
    cout << indices[i];  
    if (i != M - 1) cout << " ";
    else cout << "\n";
}

위 코드에서는 `cout`이 최소 M번 호출된다.
버퍼를 자주 flush하기 때문에 출력 성능이 저하된다.

`ostringstream`을 사용한 해결 방법

`ostringstream`은 출력을 버퍼(메모리)에 저장해 두었다가, 한 번에 `cout`을 통해 출력할 수 있도록 도와준다.
출력 횟수를 최소화하여 성능을 향상시킨다.

예제 (`ostringstream`을 활용한 출력 최적화)

ostringstream out; // 출력 버퍼 선언

for (int i = 0; i < M; i++) {
    out << indices[i];  
    if (i != M - 1) out << " ";
    else out << "\n"; 
}

// 한 번에 출력 (여기서만 cout을 사용)
cout << out.str();

버퍼에 모든 출력 내용을 저장한 후, `cout`을 단 한 번 호출하여 출력한다.
출력 연산이 많을 때 성능이 크게 향상된다

백트래킹 (Backtracking) vs. 완전 탐색 (Brute Force)

(위) 완전 탐색 이용 / (아래) 백 트래킹 이

실행 결과에서 위는 완전 탐색을 이용한 코드의 결과이고, 아래는 백 트래킹으로 푼 코드의 결과이고, 위는 완전 탐색을 이용한 코드의 결과이다.

두 가지 접근법(백트래킹 vs. 완전 탐색)의 성능 차이가 크지 않은 이유는 입력 크기가 상대적으로 작기 때문이다.

그러나 입력 크기가 커질수록, 두 방식의 차이가 더욱 두드러지게 나타난다고 한다.

실행 결과 분석

// 메모리 사용량

백트래킹 (2020 KB)이 완전 탐색 (29844 KB)보다 훨씬 적은 메모리를 사용함.
완전 탐색은 모든 경우를 직접 메모리에 저장하거나 탐색해야 하므로, 메모리 소비가 더 큼.

// 실행 시간

백트래킹 (296 ms)이 완전 탐색 (240 ms)보다 약간 더 느리지만, 차이가 크지 않음.
백트래킹이 불필요한 탐색을 줄여 최적화할 수 있지만, 이번 경우에는 탐색 공간이 작아 최적화 효과가 크지 않았음.

언제 어떤 방식을 사용해야 할까?

// 백트래킹이 유용한 경우

탐색 공간이 큰 경우 (N이 크고 M이 클 때)
- 예제에서는 N, M이 상대적으로 작아서 완전 탐색도 효율적이었지만, N = 10, M = 5 이상이 되면 완전 탐색은 기하급수적으로 시간이 증가하게 된다.
- 백트래킹은 탐색 중 불필요한 경우를 가지치기(Pruning)하면서 탐색 공간을 줄일 수 있다.
순열(Permutation)이나 조합(Combination)을 구할 때
- 특정 조건을 만족하는 경우만 선택해야 하는 경우 (예: 중복 없이 M개 선택)
  - 완전 탐색은 모든 경우를 탐색하기 때문에 불필요한 탐색이 많아질 수 있다.
DFS(깊이 우선 탐색, Depth-First Search)와 결합할 때
- 그래프 탐색에서 특정 조건을 만족하는 경로를 찾을 때 (예: 미로 탐색)
  - 백트래킹을 사용하면 불필요한 경로를 미리 배제하여 성능을 개선할 수 있다

// 완전 탐색이 유용한 경우

탐색 공간이 작고 단순한 경우 (N, M이 작을 때)
- 작은 경우의 수를 탐색하는 문제에서는 완전 탐색이 더 직관적이고 빠를 수 있다.
  - 이 문제에서는 N과 M이 작아 완전 탐색도 충분히 빠르게 실행될 수 있었다.
모든 경우를 반드시 탐색해야 하는 경우
- 가지치기를 하더라도 모든 경우를 탐색해야 정답을 구할 수 있는 경우
  - 이 문제처럼 M개를 선택하는 모든 가능한 조합을 순서대로 출력해야 하는 문제라면 완전 탐색이 적합하다.
구현이 쉬운 경우
- 백트래킹을 적용할 수 있지만, 완전 탐색으로도 시간 내 해결 가능하다면 구현이 더 쉬운 완전 탐색이 유리하다.
  - 이 문제의 경우 반복문을 통해 해결하는 방식이 복잡하지 않기 때문에 완전 탐색도 실용적이었다.

방식	개념	장점	단점	언제 유용한가
백트래킹	가능한 모든 경우를 탐색하되, 불필요한 탐색을 가지치기(Pruning)하여 최적화	* 메모리 사용이 적다 * 탐색 공간을 줄여 속도가 빠를 가능성이 높다	일부 경우에는 백트래킹을 활용해도 최적화 효과가 크지 않을 수 있다	탐색 공간이 크고, 가지치기가 가능한 경우 (예: 순열, 조합 문제)
완전 탐색	모든 경우의 수를 전부 생성하여 확인	* 구현이 쉽고 직관적이다 * 모든 경우를 고려하므로 실수 가능성이 적다	* 탐색 공간이 크면 비효율적이다 * 메모리 사용량이 많다	탐색 공간이 작거나, 모든 경우를 반드시 탐색해야 하는 문제 (예: 조합 생성)

즉, 문제의 입력 크기와 요구 사항에 따라 적절한 탐색 방법을 선택하여 풀면 된다

[백준/C++] 15649(N과 M (1)) (int를 string으로 / 순열 / next_permutation / 백트래킹)

D0YUN — Mon, 10 Mar 2025 08:03:11 +0900

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

내가 해냄 : `next_permutation()` 사용

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

int main()
{
    // N과 M을 입력받는다.
    int N, M;
    cin >> N >> M;

    // 1부터 N까지의 자연수를 담을 벡터 v를 선언하고 초기화한다.
    vector<int> v;
    for (int i = 0; i < N; i++)
        v.push_back(i + 1);

    // prev: 직전에 출력한 순열 문자열을 저장하는 변수
    // cur: 현재 출력할 순열 문자열을 저장하는 변수
    string prev = "", cur = "";

    // next_permutation()을 이용하여 N개의 수로 만들 수 있는 모든 순열을 생성한다.
    // N Permutation N
    do {
        // 현재 순열에서 앞에서 M개를 선택하여 문자열 cur을 만든다.
        for (int i = 0; i < M; i++)
            cur += to_string(v[i]) + ((i != M - 1) ? " " : ""); // 마지막 원소 뒤에는 공백을 붙이지 않음

        // 현재 생성한 문자열(cur)이 이전에 출력한 문자열(prev)과 다르면
        // 중복되지 않는 순열이므로 출력한다
        if (cur != prev)
        {
            cout << cur << "\n"; 
            prev = cur; // 이전 문자열(prev)을 현재 문자열(cur)로 갱신
        }

        // 다음 반복을 위해 cur를 초기화한다.
        cur = "";
    } while (next_permutation(v.begin(), v.end())); // 다음 순열이 존재하는 동안 반복

    return 0;
}

사용한 핵심 개념

// `next_permutation()`을 이용한 순열 생성

역할

주어진 수열을 사전순(lexicographical order)으로 다음 순열로 변환하는 함수다.
이를 반복적으로 호출하면 모든 순열을 사전순으로 탐색할 수 있다.

특징

vector 또는 배열과 함께 사용되며, 사전순으로 정렬된 상태(= 오름차순 정렬이 된 상태)에서 시작해야 모든 순열을 탐색할 수 있다.
최후의 순열(내림차순 상태)까지 도달하면 `false`를 반환하며 종료된다.
사용 예시

vector<int> v = {1, 2, 3};
do {
    for (int num : v) cout << num << " ";
    cout << "\n";
} while (next_permutation(v.begin(), v.end()));

결과

// 벡터 초기화 및 활용 (`vector<int>` 사용)

역할

1부터 N까지의 자연수를 저장하는 벡터를 선언하고 초기화하는 역할을 한다.
`push_back()`을 사용하여 1부터 N까지의 값을 순차적으로 삽입한다. 이를 통해 저절로 오름차순 정렬이 된 효과를 볼 수 있다.
구현 방식

vector<int> v;
for (int i = 0; i < N; i++) 
    v.push_back(i + 1);

작동 원리
- `for` 루프를 활용하여 `v[0] = 1, v[1] = 2, ..., v[N-1] = N`과 같이 초기화된다.

// `prev`와 `cur`을 이용한 중복 제거

역할:

`next_permutation()`을 사용하면 N개의 전체 순열을 생성하지만,
앞 M개의 원소만 선택할 경우 일부 순열이 중복될 수 있다.
이를 방지하기 위해 직전 출력된 순열(prev)과 현재 순열(cur)을 비교하여 중복을 제거한다.

구현 방식

string prev = "", cur = "";
do {
    cur = "";
    for (int i = 0; i < M; i++)
        cur += to_string(v[i]) + ((i != M - 1) ? " " : "");
    
    if (cur != prev) { 
        cout << cur << "\n"; 
        prev = cur;
    }
} while (next_permutation(v.begin(), v.end()));

작동 원리

`cur` 문자열을 생성하여 현재 M개의 숫자를 저장한다.
`prev`와 `cur`을 비교하여 중복되지 않은 경우에만 출력한다.
`prev`를 `cur`로 갱신하여 다음 순열과 비교할 기준을 설정한다.

시간 복잡도 분석

해당 코드는 `next_permutation()`을 이용하여 N개의 수로 만들 수 있는 모든 순열을 탐색하며,
각 순열에서 M개의 원소만 선택하여 출력하는 구조이다.

`next_permutation()`의 호출 횟수
- `next_permutation(v.begin(), v.end())`은 N개의 원소로 만들 수 있는 모든 순열을 순차적으로 생성한다.
- 따라서 N개의 순열을 생성하는 데 걸리는 시간 복잡도는 O(N!)이다.
출력 문자열 생성 및 비교 연산
- `for` 루프를 통해 M개의 원소를 선택하여 `cur` 문자열을 구성하는 과정의 시간 복잡도는 O(M)이다.
- `cur`과 `prev`를 비교하는 연산도 문자열 길이가 O(M)이므로 O(M)의 시간 복잡도를 갖는다.
- 따라서, 한 번의 순열에 대해 수행하는 전체 연산의 시간 복잡도는 O(M)이다.
총 시간 복잡도
- `next_permutation()`이 O(N!)번 실행되며, 매 실행마다 O(M)의 연산을 수행하므로,
- 전체 시간 복잡도는 O(N! * M)이 된다.

즉, N!이 급격하게 증가하므로 N이 커질수록 실행 시간이 매우 빠르게 증가하는 알고리즘이다.
- `prev`와 `cur`을 이용한 중복 제거를 통해 불필요한 출력을 방지하지만, 최악의 경우 여전히 O(N! * M)이 된다.
- 상당히 비효율적이다.

AI 피드백 : 백트래킹(Backtracking) 활용

#include <iostream>     // 표준 입출력
#include <vector>       // vector 컨테이너
#include <algorithm>    // sort(), next_permutation()
#include <numeric>      // iota() 사용을 위한 헤더

using namespace std;

int N, M;
vector<int> v;          // 1부터 N까지의 수 저장
vector<bool> used;      // 방문 여부 체크
vector<int> result;     // 현재 선택된 수열

// 백트래킹을 이용하여 중복 없이 M개의 원소를 선택한다.
void backtrack(int depth) {
    // M개 선택 완료 시 출력한다.
    if (depth == M) {
        for (int i = 0; i < M; i++)
            cout << result[i] << (i != M - 1 ? " " : "\n");
        return;
    }

    // 사용되지 않은 숫자를 하나씩 선택한다.
    for (int i = 0; i < N; i++) {
        if (!used[i]) {
            used[i] = true;          // 선택한 숫자를 방문 처리한다.
            result.push_back(v[i]);  // 현재 선택된 수열에 추가한다.

            backtrack(depth + 1);    // 다음 숫자를 선택한다.

            // 백트래킹: 이전 상태로 되돌린다.
            used[i] = false;
            result.pop_back();
        }
    }
}

int main() {
    // N과 M을 입력받는다.
    cin >> N >> M;

    // 1부터 N까지의 수를 벡터에 저장한다.
    v.resize(N);
    iota(v.begin(), v.end(), 1);

    // 방문 여부를 체크할 배열을 초기화한다.
    used.resize(N, false);

    // 백트래킹을 시작한다.
    backtrack(0);

    return 0;
}

주요 개선 포인트

// `next_permutation()`을 제거하고, 백트래킹을 이용하여 직접 순열을 생성했다

기존 코드에서는 모든 순열을 탐색한 후, 중복을 제거하는 방식을 사용했다.
개선된 코드에서는 아예 중복이 없는 순열을 처음부터 생성하므로 불필요한 비교 연산이 사라짐.

// 문자열 비교(prev vs cur) 방식 대신, `vector<bool> used`를 활용함

기존 코드에서는 이전 문자열(`prev`)과 현재 문자열(`cur`)을 비교하는 방식을 사용하여 중복을 제거했다.
개선된 코드에서는 이미 방문한 숫자를 `used[i]`로 체크하여 중복이 발생하지 않도록 차단했다

// 출력 최적화 (`cout` 활용)

기존 코드에서는 `cur` 문자열을 매번 생성하여 출력했다.
개선된 코드에서는 `cout`을 직접 활용하여 불필요한 문자열 연산을 줄였다.

// 시간 복잡도 개선

기존 코드: O(N! * M) → 모든 순열을 탐색한 후 필요한 경우만 출력
개선 코드: O(N! / (N-M)!) → 필요한 조합만 직접 탐색

추가로 사용한 개념

// 백트래킹 (Backtracking)

역할

가능한 모든 경우의 수를 탐색하면서 불필요한 탐색을 가지치기(Pruning)하여 최적화하는 기법이다.
방문 여부(`used` 배열)를 이용하여 이미 선택된 원소를 다시 선택하지 않도록 제한한다.

사용 예시

void backtrack(int depth) {
    if (depth == M) {  // M개 선택 완료 → 출력
        for (int i = 0; i < M; i++)
            cout << result[i] << (i != M - 1 ? " " : "\n");
        return;
    }

    for (int i = 0; i < N; i++) {
        if (!used[i]) {  
            used[i] = true;          // 숫자 사용 처리
            result.push_back(v[i]);  // 현재 선택된 수열에 추가

            backtrack(depth + 1);    // 다음 숫자 선택

            used[i] = false;         // 백트래킹 (되돌리기)
            result.pop_back();
        }
    }
}

// vector<bool>을 이용한 방문 체크

역할

이미 선택한 원소인지 여부를 저장하여 중복된 선택을 방지한다.

사용 예시:

vector<bool> used(N, false); // 모든 원소를 처음에는 미사용 상태로 설정

if (!used[i]) {  // 사용되지 않은 원소만 선택
    used[i] = true;   // 사용 처리
    result.push_back(v[i]);

    backtrack(depth + 1);

    used[i] = false;  // 백트래킹: 원래대로 복구
}

기존 코드의 `prev`와 `cur`을 이용한 중복 비교보다 더 효율적인 방식이다.

기존 코드에서는 `cur`과 `prev`를 비교(O(M))해야 했지만, 백트래킹은 `used[]` 배열을 사용하여 선택한 원소인지 O(1) 연산으로 확인이 가능하다.
즉, 문자열 비교를 하지 않고 방문 여부를 빠르게 확인할 수 있어 성능이 향상된다.

// iota()를 이용한 벡터 초기화

역할:

`iota()`를 사용하면 1부터 N까지의 숫자를 한 줄로 채울 수 있다.
기존 for 루프를 사용하는 것보다 더 간결한 코드 작성이 가능하다.

사용 예시:

v.resize(N);
iota(v.begin(), v.end(), 1);  // v = {1, 2, 3, ..., N}

`for` 루프 없이 `iota()` 한 줄로 벡터를 초기화할 수 있어 코드가 더 깔끔해진다.

// `cout`을 이용한 출력 최적화

역할

`cout`을 활용하여 문자열 연산을 줄이고, 더 빠르게 출력할 수 있도록 개선한다.
삼항 연산자를 활용하여 출력 형식을 조정하고 마지막 숫자 뒤에는 공백을 붙이지 않는다.

기존 방식 (`prev`와 `cur`을 이용한 문자열 비교)

cur += to_string(v[i]) + ((i != M - 1) ? " " : "");

개선된 방식 (`cout` 활용)

cout << result[i] << (i != M - 1 ? " " : "\n");

출력 최적화로 불필요한 문자열 연산을 줄이고 실행 속도를 높인다.

(위) AI 피드백 코드 / (아래) 내가 작성한 코드

이론적으로 보면 백트래킹을 활용한 코드(AI 피드백 코드)가 O(N! / (N-M)!)이므로 더 효율적이어야 한다.
반면, `next_permutation()`을 활용한 코드는 O(N! * M)이므로 더 느릴 것이라고 예상할 수 있다.

하지만, 실제 실행 결과는 `next_permutation()`을 활용한 코드가 더 빠르게 실행되었다.
이는 다음과 같은 이유일 것이라 예상된다.

`next_permutation()`의 내부 최적화

C++ 표준 라이브러리에서 제공하는 `next_permutation()`은 매우 효율적으로 구현된 알고리즘이다.

`next_permutation()`은 사전순으로 정렬된 배열에서 다음 순열을 구하는 최적화된 연산을 수행한다.
일반적인 백트래킹 방식보다 빠르게 순열을 생성할 수 있다.
내부적으로 `swap` 연산과 빠른 비교 연산을 사용하여 최적화가 되어 있기 때문에, 백트래킹보다 실행 속도가 빠를 수 있다.

즉, C++ STL의 최적화된 next_permutation()이 백트래킹의 순열 생성보다 실제 실행에서 더 빠르게 동작할 수 있다.

재귀 함수 호출의 오버헤드

백트래킹 방식은 재귀 함수 호출을 반복적으로 수행해야 한다.
재귀 호출 과정에서 함수 호출 스택이 쌓이고 해제되는 과정이 반복되기 때문에 실행 속도에 영향을 미칠 수 있다.

`backtrack(depth + 1)`을 호출할 때마다 스택 프레임이 새로 생성되며, 함수가 종료될 때마다 스택 프레임이 해제된다.
즉, 재귀 호출이 많아질수록 함수 호출 오버헤드가 커지고 실행 속도가 느려질 가능성이 있다.

반면, `next_permutation()`은 재귀 호출 없이 순열을 반복적으로 생성하는 방식이므로, 함수 호출 오버헤드가 적다.

문자열 연산 vs 벡터 연산

AI 피드백 코드에서는 cout을 사용할 때 벡터에서 값을 가져와 직접 출력하는 방식이다.

for (int i = 0; i < M; i++)
    cout << result[i] << (i != M - 1 ? " " : "\n");

이 과정은 벡터에서 값을 가져와 바로 출력하기 때문에 메모리 복사 오버헤드가 적다.

반면, `next_permutation()`을 사용하는 기존 코드에서는 문자열을 생성하고 비교하는 과정이 추가된다.

cur += to_string(v[i]) + ((i != M - 1) ? " " : "");

하지만, STL에서는 문자열 연산도 내부적으로 최적화되어 있으며,
단순히 cur != prev 비교하는 것이 백트래킹에서 벡터 연산을 수행하는 것보다 빠를 수 있다.

➡ STL의 문자열 비교 연산(O(M))이 재귀 호출을 통한 벡터 조작보다 더 빠를 수도 있음.

입출력 최적화 영향

`cout`은 기본적으로 버퍼링을 사용하지만,
재귀 호출이 많아지면 입출력 연산이 더 느려질 가능성이 있다
`next_permutation()`을 활용한 코드는 반복문 기반이므로 입출력 버퍼를 더 효율적으로 활용할 수 있다.
백트래킹 코드에서도 출력을 모아두었다가 한 번에 출력하는 방식을 사용하면 속도가 더 빨라질 가능성이 있다.
- 이 가능성을 염두하여 AI 피드백 코드의 `main()` 함수에 ` ios_base::sync_with_stdio(false);`를 추가하고 실행해보았는데 똑같이 24초가 걸렸다.

[C++] iota()를 이용하여 연속된 값을 빠르게 채우기 (ft. transform(), generate())

D0YUN — Sun, 9 Mar 2025 16:46:49 +0900

iota() 함수란?

C++에서 `iota()` 함수는 특정 범위에 연속된 값을 채우는 함수로, 시작 값을 설정하면 이후 요소들을 1씩 증가하며 채워 넣습니다.

iota() 함수 정의

`iota()` 함수의 정의는 다음과 같습니다.

void iota(ForwardIterator first, ForwardIterator last, T value);

first: 값을 채울 범위의 시작 (begin())
last: 값을 채울 범위의 끝 (end())
value: 채우기 시작할 값

기본적인 iota() 사용법

벡터를 1부터 N까지 자동으로 채우기

#include <iostream>
#include <vector>
#include <numeric>  // iota()를 사용하기 위한 헤더

using namespace std;

int main() {
    vector<int> v(5); // 크기가 5인 벡터 생성

    // 1부터 시작하는 연속된 값을 벡터에 채운다.
    iota(v.begin(), v.end(), 1);

    // 결과 출력
    for (int num : v) cout << num << " ";

    return 0;
}

실행 결과

1 2 3 4 5

동작 과정

v[0] = 1 (초기 값 1 설정)
v[1] = 2 (이전 값에 +1 증가)
v[2] = 3
v[3] = 4
v[4] = 5

실행 결과를 통해 확인할 수 있듯이 각 원소는 앞의 원소보다 1씩 증가하는 값으로 채워집니다.

iota()를 활용한 다양한 예제

ex1) 0부터 시작하는 값 채우기

vector<int> v(10);
iota(v.begin(), v.end(), 0);  // 0부터 9까지 자동 채움
// 결과: 0 1 2 3 4 5 6 7 8 9

ex2) 100부터 시작하는 값 채우기

vector<int> v(5);
iota(v.begin(), v.end(), 100);  // 100부터 104까지 자동 채움
// 결과: 100 101 102 103 104

ex3) 배열을 초기화할 때 사용하기

int arr[6];
iota(arr, arr + 6, 10);  // 10부터 15까지 자동 채움
// 결과: 10 11 12 13 14 15

`iota()`를 변형하여 특정 간격(2, 5 등)으로 값 증가시키기

`iota()`는 기본적으로 1씩 증가하는 값을 채우지만,
`transform()` 또는 `generate()`를 활용하면 1 이외의 숫자만큼 증가하는 값을 저장할 수도 있습니다.

방법 1: `iota()` + `transform()` 활용

#include <iostream>
#include <vector>
#include <numeric>  // iota()
#include <algorithm> // transform()

using namespace std;

int main() {
    vector<int> v(10); // 크기가 10인 벡터 생성

    // 0부터 9까지 연속된 값 채우기
    iota(v.begin(), v.end(), 0);

    // 각 요소를 2씩 증가하도록 변환 (0, 2, 4, 6, 8, ...)
    transform(v.begin(), v.end(), v.begin(), [](int x) { return x * 2; });

    // 결과 출력
    for (int num : v) cout << num << " ";

    return 0;
}

`iota()`와 `transform()`을 활용한 방식의 원리는 다음과 같습니다.

`iota(v.begin(), v.end(), 0);` v를 0부터 9까지 채웁니다.
`transform()`을 사용하여 각 요소를 2배로 변경합니다.
- `[](int x) { return x * 2; }`는 람다 함수로, 기존 값 x를 2배로 변환하는 역할을 합니다.
결과적으로 0, 2, 4, 6, 8, ... 같은 수열이 생성됩니다.

실행 결과

0 2 4 6 8 10 12 14 16 18

방법 2: `generate()` 활용 (`iota()` 없이 특정 간격 설정)

`generate()`를 사용하면 `iota()` 없이 특정 간격으로 값을 채울 수 있다.

#include <iostream>
#include <vector>
#include <algorithm> // generate()

using namespace std;

int main() {
    vector<int> v(10);
    int start = 2;
    int step = 5;

    // 람다 함수로 각 요소를 채운다.
    generate(v.begin(), v.end(), [&]() { 
        int val = start; 
        start += step; 
        return val;
    });

    // 결과 출력
    for (int num : v) cout << num << " ";

    return 0;
}

`generate()`를 사용하는 방식의 원리는 다음과 같습니다.

`start` 변수에 초기값을 설정하고, `step`만큼 증가시키면서
각 요소를 직접 채웁니다.

실행 결과

2 7 12 17 22 27 32 37 42 47

방법 3: for 루프 직접 사용 (기본적인 방법)

가장 기본적인 방법으로, `iota()`보다 코드가 길어지는 단점이 있습니다.

#include <iostream>
#include <vector>

using namespace std;

int main() {
    vector<int> v(10);

    // 2부터 시작해서 5씩 증가하는 수열 생성
    for (int i = 0; i < v.size(); i++) {
        v[i] = 2 + i * 5;
    }

    // 결과 출력
    for (int num : v) cout << num << " ";

    return 0;
}

실행 결과

2 7 12 17 22 27 32 37 42 47

[백준/C++] 7785(회사에 있는 사람) (문자열 비교 / Hash / unordered_map, unordered_set)

D0YUN — Sun, 9 Mar 2025 10:26:33 +0900

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

내가 해냄

#include <bits/stdc++.h>
// #include <unordered_map>    // 원래는 <bits/stdc++.h> 만 include해도 동작하는데 VS에서 동작하지 않아서 추가로 include
using namespace std;

long long n;    // 출입 기록 수
unordered_map <string, string> syslog; // 출입 기록 로그 (이름 - 출입 상태 저장)
vector<string> cur;   // 현재 회사에 있는 사람들 (정렬을 위해 사용)

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

    // 출입 기록 수를 입력받는다
    cin >> n;

    // 출입 기록을 입력받는다
    for (int i = 0; i < n; i++)
    {
        string tmp1, tmp2;
        cin >> tmp1 >> tmp2;

        syslog[tmp1] = tmp2;  // 마지막 출입 상태만 저장됨 (enter / leave)
    }

    // 현재 회사에 있는 사람들을 기록한다
    // unordered_map을 순회하여 "enter" 상태인 사람만 벡터에 추가
    // *** string은 == 연산자 오버로딩이 되어 있어서 두 문자열이 같은지 비교 가능 ***
    for (auto i : syslog)
        if (i.second == "enter")
            cur.push_back(i.first);

    // 현재 회사에 있는 사람들을 역순으로 정렬한다
    // *** greater<string>()을 비교자로 전달하여 사전 역순(내림차순)으로 정렬한다 ***
    sort(cur.begin(), cur.end(), greater<string>());

    // 회사에 있는 사람들을 출력한다
    for (string i : cur)
        cout << i << '\n';

    return 0;
}

사용한 핵심 개념

// `unordered_map<string, string>` (해시 맵)

역할 : 사람의 이름(string)을 키(key)로 하고, 출입 상태("enter" 또는 "leave")를 값(value)으로 저장하는 자료구조다.
특징
- 평균 O(1)의 시간 복잡도로 빠른 검색, 삽입, 삭제가 가능하다.
- 마지막으로 기록된 출입 상태만 저장된다. (즉, 동일한 이름의 키가 등장하면 새로운 값으로 덮어씌워진다.)
사용 예시

unordered_map<string, string> syslog;
syslog["Alice"] = "enter";  // Alice가 회사에 들어옴
syslog["Alice"] = "leave";  // Alice가 퇴근 → 이전 값 "enter"가 덮어씌워짐

// `vector<string>`의 활용

역할 : 현재 회사에 남아 있는 사람들을 저장하고, 정렬 후 출력하는 역할을 한다.
사용 예시

vector<string> cur;

// `std::string`의 `==` 연산자 활용

역할: "enter"인지 "leave"인지 비교하여 현재 회사에 남아 있는 사람을 판별한다.
사용 코드

if (i.second == "enter")
    cur.push_back(i.first);

작동 원리:
- C++의 `std::string` 클래스는 `==` 연산자가 오버로딩되어 있어 두 문자열이 같은지 쉽게 비교할 수 있다.
- C 스타일 문자열(char*)과 다르게 직접 비교가 가능하며, `strcmp()`를 사용할 필요가 없다.
예제

string a = "hello";
string b = "hello";
string c = "world";

if (a == b) cout << "a와 b는 같다.\n";
if (a != c) cout << "a와 c는 다르다.\n";

출력 결과

a와 b는 같다.
a와 c는 다르다.

시간 복잡도: O(N) (두 문자열의 길이가 N일 경우)

cf) `std::string::compare()` 함수

역할: `std::string::compare()`는 문자열 비교 결과를 정수 값으로 반환한다.
사용 예시

string a = "apple";
string b = "banana";

if (a.compare(b) == 0) cout << "같다.\n";
else if (a.compare(b) < 0) cout << "a가 b보다 사전순으로 앞에 있다.\n";
else cout << "a가 b보다 사전순으로 뒤에 있다.\n";

출력 결과

a가 b보다 사전순으로 앞에 있다.

비교 결과 값:
- 0 → 두 문자열이 같다.
- < 0 → 첫 번째 문자열이 사전순으로 앞에 있다.
- > 0 → 첫 번째 문자열이 사전순으로 뒤에 있다.

하지만 단순히 문자열이 같은지 비교할 때는 `==` 연산자를 사용하는 것이 더 직관적이고 간결하다.

// `sort()` + 비교 함수 `greater<string>()` (사전 역순 정렬)

역할: 회사에 남아 있는 사람들의 이름을 사전 역순(내림차순) 정렬하는 역할을 한다.
구현 방식:

sort(cur.begin(), cur.end(), greater<string>());

작동 원리:
- 기본적으로 sort()는 오름차순 정렬을 수행한다.
- `greater<string>()`을 비교 함수로 전달하면 내림차순 정렬을 수행하여 사전 역순으로 정렬된다.

사용 예시

vector<string> names = {"Alice", "Charlie", "Bob"};
sort(names.begin(), names.end(), greater<string>());
// 정렬 후: {"Charlie", "Bob", "Alice"} (사전 역순)

AI 피드백

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

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

    int n;  // 출입 기록 수
    cin >> n;

    unordered_set<string> syslog; // 현재 회사에 있는 사람들 저장

    for (int i = 0; i < n; i++) {
        string name, action;
        cin >> name >> action;

        if(action == "enter") syslog.insert(name);  // 입장 기록
        else syslog.erase(name);    // 퇴장 기록
    }
    
    // 출입 기록을 모두 처리한 후, 회사에 남아 있는 사람들을 벡터에 저장
    vector<string> cur(syslog.begin(), syslog.end());

    // 사전 역순(내림차순) 정렬
    sort(cur.begin(), cur.end(), greater<string>());

    // 결과 출력
    for (const string& name : cur)
        cout << name << '\n';

    return 0;
}

초기 코드 핵심 로직 분석

초기 코드에서는 `unordered_map<string, string>`을 사용하여 이름을 키(key), 출입 상태를 값(value) 으로 저장하는 방식으로 구현하였다. 마지막으로 기록된 출입 상태만 저장되므로, 동일한 이름이 여러 번 등장해도 최종 상태만 유지가 된다.
출입 기록을 받은 후 "enter" 상태인 사람들만 벡터에 추가한 후, 사전 역순(내림차순)으로 정렬하여 출력하였다.

unordered_map<string, string> syslog; // (이름, 출입 상태)

for (int i = 0; i < n; i++) {
    string name, action;
    cin >> name >> action;
    syslog[name] = action;  // 마지막 출입 상태만 저장됨
}

// 현재 회사에 있는 사람들을 벡터에 추가
for (auto i : syslog)
    if (i.second == "enter")
        cur.push_back(i.first);

// 내림차순 정렬 후 출력
sort(cur.begin(), cur.end(), greater<string>());
for (string i : cur)
    cout << i << '\n';

주요 개선점 : `unordered_set<string>`의 사용

초기 코드는 unordered_map<string, string>을 사용하여 {"이름", "enter"} 혹은 {"이름", "leave"} 형태로 저장하고 있지만, 사실 "leave"를 저장할 필요는 없다.
대신 `unordered_set<string>`을 사용하면 더 간결하고 직관적이며, O(1)의 탐색 속도로 더 빠르게 동작할 수 있다.
해당 자료형을 사용함으로써 개선된 내용은 다음과 같다

기존 코드	개선된 코드
"leave" 상태를 따로 저장하여 비교	"leave" 상태를 저장하지 않고, `erase()`로 삭제
"enter" 상태를 벡터에 따로 저장	`unordered_set`에서 `vector`로 변환 후 정렬
벡터를 따로 관리하며 "enter" 상태만 저장	`unordered_set` 자체가 "enter" 상태인 사람만 저장

unordered_set<string> syslog; // 현재 회사에 있는 사람들 저장

for (int i = 0; i < n; i++) {
    string name, action;
    cin >> name >> action;

    if (action == "enter") syslog.insert(name);  // 입장 기록
    else syslog.erase(name);  // 퇴장 기록
}

// 출입 기록을 모두 처리한 후, 벡터로 변환
vector<string> cur(syslog.begin(), syslog.end());

// 내림차순 정렬 후 출력
sort(cur.begin(), cur.end(), greater<string>());
for (const string& name : cur)
    cout << name << '\n';

추가로 사용한 개념

// unordered_map → unordered_set로 변경

기존 코드 문제점:
- `unordered_map`을 사용하여 "enter"와 "leave" 값을 저장했으나, 사실 "leave" 상태는 따로 저장할 필요가 없다.
  - 회사를 떠난 사람은 최종 결과에서 출력하지 않기 때문이다.
개선 코드 장점:
- "enter"일 때는 insert(), "leave"일 때는 `erase()`를 사용하여 바로 추가 및 삭제가 가능하다
- 불필요한 "leave" 값 비교 연산을 제거하여 연산 속도가 평균 O(1)으로 개선된다

unordered_set<string> syslog;

if (action == "enter") syslog.insert(name);
else syslog.erase(name);

// 벡터 변환 후 정렬 (vector<string> cur(syslog.begin(), syslog.end());)

기존 코드 문제점:
- "enter" 상태인 사람을 벡터에 따로 추가하는 과정이 필요했다
개선 코드 장점:
- `unordered_set`을 벡터의 생성자로 변환하여 한 번에 저장할 수 있다.
- `vector<string> cur(syslog.begin(), syslog.end());`를 사용하여 O(N) 시간 내 변환할 수 있다.

이분 탐색이나 투 포인터 방식을 이용하여 구현할 수도 있다고 한다

[백준/C++] 10808(알파벳 개수) (아스키 코드 / 범위 기반 for문 / constexpr / 삼항연산자)

D0YUN — Sat, 8 Mar 2025 15:55:50 +0900

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

내가 해냄

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

string s;   // 입력받을 문자열 선언

// 알파벳 개수가 기억이 안나서 아스키코드 값을 이용하여 배열 크기 지정
// 소문자 개수만큼 배열을 선언하여 각 알파벳의 개수를 저장
int cnt['z' - 'a' + 1] = {0};   

int main()
{
    /*
      배열의 크기 확인 방법:sizeof(배열) / sizeof(배열의 첫 번째 요소)
      - 배열 전체 크기를 각 요소의 크기로 나누어 개수를 구할 수 있음.
    */
    // cout << sizeof(cnt) / sizeof(cnt[0]) << "\n";  // 배열 크기 확인용 코드 (디버깅용)
    
    // 문자열 s를 입력받는다
    cin >> s;

    /*
      입력받은 문자열을 순회하면서 각 알파벳의 등장 횟수를 카운트
      - s[i]는 문자(char)이며, 이를 'a'와의 차이를 이용해 배열의 인덱스로 변환
      - 'a'는 ASCII 값 97이므로, 'a'~'z'를 0~25 범위의 인덱스로 변환 가능
      - 예: 'b' - 'a' → 1, 'z' - 'a' → 25
   */
    for (int i = 0; i < s.size(); i++)
        cnt[s[i] - 'a']++;      

    /*
      배열에 저장된 각 알파벳의 등장 횟수를 출력
      - 범위 기반 for문을 사용하여 cnt 배열의 모든 값을 출력
      - 값들 사이에는 공백을 출력하여 가독성을 높임
    */
    for(int i : cnt) cout << i << " ";

    return 0;
}

사용한 핵심 개념

// 배열을 이용한 카운팅 (Counting Array)

`cnt` 배열을 활용하여 각 알파벳의 등장 횟수를 저장하는 방식이다.
공간 복잡도가 O(1)로 빠른 조회 및 업데이트가 가능하다.
해시 테이블(`unordered_map`) 대신 고정된 크기의 배열을 활용하여 더 빠르게 동작한다.
코드에서 활용

int cnt[26] = {0};   // 26개의 공간을 갖는 배열 선언
for (int i = 0; i < s.size(); i++)
    cnt[s[i] - 'a']++;  // 해당 알파벳 인덱스 증가

// ASCII 코드 값 이용 (s[i] - 'a')

문자 'a'부터 'z'까지의 ASCII 코드 값을 활용하여 배열의 인덱스로 변환하는 기법이다.
'a'의 ASCII 값은 97, 'b'는 98, ..., 'z'는 122이므로 'a'를 기준으로 빼면 0~25 범위의 정수 인덱스를 얻을 수 있다.

char c = 'c';
cout << c - 'a';  // 결과: 2 ('c' - 'a' = 99 - 97)

코드에서 활용

cnt[s[i] - 'a']++;  // 알파벳을 0~25 범위의 인덱스로 변환하여 개수 증가

// 범위 기반 for문 이용 (for(int i : cnt))

C++11 이상에서 추가된 문법으로, `std::vector` 또는 배열을 순회할 때 유용하다.
기존의 for 루프에서 인덱스를 활용하는 방식보다 가독성이 좋고 코드가 간결하다.

// 기존의 인덱스 기반 for문
for (int i = 0; i < 26; i++) {
    cout << cnt[i] << " ";
}

// 범위 기반 for문 (더 간결하다)
for (int i : cnt) {
    cout << i << " ";
}

코드에서 활용

for (int i : cnt) cout << i << " ";

AI 피드백

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

constexpr int ALPHA = 26;   // 알파벳 갯수
/*
constexpr : 컴파일 타임 상수를 정의하는 키워드
- constexpr을 사용하면 반드시 컴파일 시점에 값이 결정됨
- const는 런타임에도 값이 결정될 수 있지만, constexpr은 무조건 컴파일 타임에 결정되어야 한다
*/

int cnt[ALPHA] = {0};   // 각 알파벳 개수를 저장할 배열 (초기값 0)

int main()
{
    string s;

    // 문자열을 입력한다
    cin >> s;
    
    // 문자열의 각 문자를 순회하며 알파벳 개수를 센다
    // - string은 char로 구성되어 있다.
    // - 이를 범위 기반 for문에 활용하여 각 알파벳 소문자의 갯수를 센다
    // - 아스키코드 값을 이용해 cnt 배열의 해당 알파벳 위치에 접근하여 개수를 증가시킨다
    for(char c : s) cnt[c - 'a']++;     

    // 각 알파벳의 개수를 출력한다
    // - 삼항 연산자를 활용하여 마지막 값 뒤에는 개행, 나머지는 공백을 출력한다
    for(int i = 0; i < ALPHA; i++)
        cout << cnt[i] << (i == ALPHA - 1 ? "\n" : " ");

    return 0;
}

사용한 핵심 개념

// `constexpr`을 활용한 컴파일 타임 상수 정의

`constexpr` 키워드를 사용하여 컴파일 타임에 결정되는 상수를 정의하는 방식이다.
`const`는 런타임에도 값이 결정될 수 있지만, `constexpr`은 반드시 컴파일 시점에 값이 확정되어야 한다.
매직 넘버(하드코딩된 숫자)를 없애고 의미를 명확하게 표현할 수 있다.
코드에서 활용

constexpr int ALPHA = 26;   // 알파벳 개수 (a~z는 총 26개다)

기존 코드와의 차이점

// 기존 코드에서는 'z' - 'a' + 1로 배열 크기를 정의했지만, 
// ALPHA라는 상수를 사용하면 더 직관적이고 유지보수가 편리하다.
int cnt[ALPHA] = {0};

// range-based for loop (범위 기반 for문) 활용

`for (char c : s)`와 같은 구문을 사용하여, 문자열의 각 문자를 직접 순회하는 방식이다.
기존의 인덱스 기반 for 루프보다 더 직관적이고 간결하며, 가독성이 뛰어나다.
코드에서 활용

for (char c : s) cnt[c - 'a']++;  // 문자를 직접 순회하며 카운트한다.

기존 코드와의 차이점

// 기존 코드
for (int i = 0; i < s.size(); i++)
    cnt[s[i] - 'a']++;  

// 개선된 코드 (더 간결해졌다.)
for (char c : s) cnt[c - 'a']++;

// 삼항 연산자 활용하여 출력 최적화

마지막 원소 출력 시 불필요한 공백을 방지하기 위해 삼항 연산자(?:)를 사용한 방식이다.
if-else 문을 사용하는 것보다 더 간결하고 깔끔한 코드가 된다.
코드에서 활용

for (int i = 0; i < ALPHA; i++)
    cout << cnt[i] << (i == ALPHA - 1 ? "\n" : " ");

기존 코드와의 차이점

// 기존 코드에서는 모든 출력값 뒤에 공백이 들어갔다.
for (int i : cnt) cout << i << " ";

// 개선된 코드에서는 마지막 값 뒤에 개행(\n)을 넣고, 나머지는 공백을 출력한다.
for (int i = 0; i < ALPHA; i++)
    cout << cnt[i] << (i == ALPHA - 1 ? "\n" : " ");

[YYBASIC0307/얌얌코딩] 연산자 오버로딩(Operator Overloading)

D0YUN — Sat, 8 Mar 2025 14:37:47 +0900

연산자 오버로딩

C++에서 연산자는 기본적으로 정수, 실수와 같은 기본 타입에 대해서만 정의되어 있습니다. 하지만 사용자가 정의한 클래스에도 연산자를 적용할 수 있도록 연산자 오버로딩(Operator Overloading)을 지원합니다.

연산자 오버로딩을 사용하면, 객체끼리 `+`, `-`, `==`, `<<`, `[]` 등의 연산을 수행할 수 있습니다. 예를 들어, 두 개의 Vector 객체를 `+` 연산자로 더할 수 있다면 코드가 훨씬 직관적이고 가독성이 좋아집니다.

연산자 오버로딩 문법

연산자 오버로딩은 `operator` 키워드를 사용하여 구현할 수 있습니다.

class ClassName {
public:
    반환형 operator연산자(매개변수) {
        // 연산 수행
    }
};

멤버 함수 vs. 비멤버 함수

연산자 오버로딩을 할 때, 멤버 함수로 오버로딩할지 비멤버 함수(전역 함수)로 오버로딩할지 선택해야 합니다.

멤버 함수로 연산자 오버로딩

멤버 함수로 연산자 오버로딩을 하면 왼쪽 피연산자(객체) 가 `this` 포인터를 통해 자동으로 접근됩니다. 즉, 연산자 왼쪽에 있는 객체가 멤버 함수의 주체가 됩니다.

// 멤버 함수의 호출 방식

lhs.operator+(rhs);

위 코드는 우리가 흔히 사용하는 `lhs + rhs` 를 내부적으로 해석한 것입니다.

// 멤버 함수 오버로딩의 특징

왼쪽 피연산자(`lhs`)가 `this` 포인터를 통해 자동으로 접근됨
첫 번째 피연산자(`lhs`)가 클래스의 멤버여야 함
오른쪽 피연산자(`rhs`)는 함수의 매개변수로 전달됨

// ex) `+` 연산자 오버로딩 (멤버 함수)

#include <iostream>
class Vector {
public:
    int x, y;

    Vector(int x = 0, int y = 0) : x(x), y(y) {}

    // 멤버 함수로 + 연산자 오버로딩
    Vector operator+(const Vector& other) const {
        return Vector(x + other.x, y + other.y);
    }
};

int main() {
    Vector v1(3, 4);
    Vector v2(1, 2);
    Vector result = v1 + v2;  // v1.operator+(v2)로 해석됨

    std::cout << result.x << ", " << result.y << std::endl;  // 출력: 4, 6
    return 0;
}

비멤버 함수(전역 함수)로 연산자 오버로딩

비멤버 함수로 연산자 오버로딩을 하면 연산자 왼쪽과 오른쪽을 대등한 관계로 다룰 수 있습니다. 즉, `lhs`와 `rhs`가 동일한 방식으로 처리됩니다.

// 비멤버 함수의 호출 방식

operator+(lhs, rhs);

이 방식은 연산자의 좌항과 우항을 대등한 관계로 처리해야 할 때 유용합니다.

// 비멤버 함수 오버로딩의 특징

두 피연산자가 동등한 관계로 처리됨 (`lhs`와 `rhs` 모두 매개변수로 전달됨)
클래스 내부에 없는 연산자도 구현 가능 (`ostream <<` 같은 연산자)
`friend` 키워드를 사용하면 private 멤버에도 접근 가능

ex) `+` 연산자 오버로딩 (비멤버 함수)

#include <iostream>
class Vector {
public:
    int x, y;
    Vector(int x = 0, int y = 0) : x(x), y(y) {}

    // friend 함수로 + 연산자 오버로딩
    friend Vector operator+(const Vector& lhs, const Vector& rhs);
};

// 전역 함수로 + 연산자 오버로딩
Vector operator+(const Vector& lhs, const Vector& rhs) {
    return Vector(lhs.x + rhs.x, lhs.y + rhs.y);
}

int main() {
    Vector v1(3, 4);
    Vector v2(1, 2);
    Vector result = v1 + v2;  // operator+(v1, v2)로 해석됨

    std::cout << result.x << ", " << result.y << std::endl;  // 출력: 4, 6
    return 0;
}

멤버 함수 사용 vs 비멤버 함수 사용

구분	멤버 함수 오버로딩	비멤버 함수(전역 함수) 오버로딩
호출 방식	`lhs.operator+(rhs)`	`operator+(lhs, rhs)`
첫 번째 피연산자	항상 클래스의 객체(`this`)	두 개의 피연산자가 동등
일반적인 사용 예시	`+=`, `-=`, `*=`, `/=` 등	`+`,`-`, `==`, `!=`, `<<`, `>>` 등
클래스 외부 연산 가능 여부	불가 (클래스 내부에서만 동작)	가능 (클래스 외부에서도 가능)
출력 연산자(<<) 오버로딩 가능?	불가	가능

특별한 경우: `<<` 연산자 오버로딩

출력 연산자(`<<`)는 `std::cout`과 객체를 함께 사용하기 때문에 비멤버 함수(전역 함수)로 오버로딩해야 합니다.

// 비멤버 함수로 구현해야 하는 이유

`std::cout`은 `ostream` 클래스의 객체이므로, 이를 `Vector`의 멤버 함수로 만들 수 없습니다.

ex) `<< `연산자 오버로딩 (비멤버 함수)

#include <iostream>
class Vector {
public:
    int x, y;
    Vector(int x = 0, int y = 0) : x(x), y(y) {}

    // friend 함수로 << 연산자 오버로딩
    friend std::ostream& operator<<(std::ostream& os, const Vector& v);
};

// 전역 함수로 << 연산자 오버로딩
std::ostream& operator<<(std::ostream& os, const Vector& v) {
    os << "(" << v.x << ", " << v.y << ")";
    return os;
}

int main() {
    Vector v(3, 4);
    std::cout << v << std::endl;  // (3, 4)
    return 0;
}

연산자 오버로딩에서 주의할 점

// 반환형을 고려할 것

`operator+`와 같은 연산은 새로운 객체를 반환하는 것이 일반적입니다.
`operator+=`와 같은 연산은 자기 자신을 변경하고 `this`를 반환하는 것이 좋습니다.

// 객체의 원본을 변경하지 않도록 const 사용

`operator+`는 매개변수에 `const`를 붙여 원본이 변경되지 않도록 설계합니다.

// 연산자의 의미를 유지할 것

연산자가 직관적인 의미를 가지도록 구현합니다.
- 예를 들어 `==`는 값 비교, `<<`는 출력 용도로 활용합니다.

// 비효율적인 연산 방지

불필요한 복사 연산을 줄이기 위해 참조(&)와 이동 연산자(std::move)를 고려합니다.

연산자 오버로딩을 통한 커스텀 Vector2 자료형의 사칙 연산 구현

아래 예제에서는 `Vector2`라는 구조체를 정의하고, 기본적인 사칙 연산(`+`, `-`, `*`, `/`) 및 비교 연산(`<`)을 오버로딩하여 사용합니다.

이때 매개변수를 값으로 전달하면 불필요한 복사 연산이 발생하여 성능이 저하될 수 있습니다.

이를 방지하기 위해 `const &`(`const` 참조) 키워드를 사용하여 최적화된 코드를 구현했습니다.

// YYBASIC03_07
#include <iostream>  // 입출력을 위한 헤더 파일
using namespace std;

// 2차원 벡터(Vector2) 구조체 정의
struct Vector2
{
    int x;  // x 좌표
    int y;  // y 좌표

    // + 연산자 오버로딩: 두 Vector2 객체를 더하는 기능
    Vector2 operator+(const Vector2& other)
    {
        Vector2 rslt;
        rslt.x = x + other.x;
        rslt.y = y + other.y;

        return rslt;
    }

    // - 연산자 오버로딩: 두 Vector2 객체를 빼는 기능
    Vector2 operator-(const Vector2& other)
    {
        Vector2 rslt;
        rslt.x = x - other.x;
        rslt.y = y - other.y;

        return rslt;
    }

    // * 연산자 오버로딩: 두 Vector2 객체를 곱하는 기능
    Vector2 operator*(const Vector2& other)
    {
        Vector2 rslt;
        rslt.x = x * other.x;
        rslt.y = y * other.y;

        return rslt;
    }

    // / 연산자 오버로딩: 두 Vector2 객체를 나누는 기능 (단, 0으로 나누는 예외 처리가 필요함)
    Vector2 operator/(const Vector2& other)
    {
        Vector2 rslt;
        rslt.x = x / other.x;
        rslt.y = y / other.y;

        return rslt;
    }

    // < 연산자 오버로딩: 두 Vector2 객체를 비교하는 기능
    bool operator<(const Vector2& other)
    {
        return (x < other.x && y < other.y); // 두 좌표가 모두 작을 때 true 반환
    }
};

int main(void)
{
    Vector2 p1;  // 첫 번째 벡터 객체 선언
    p1.x = 1;
    p1.y = 1;

    Vector2 p2;  // 두 번째 벡터 객체 선언
    p2.x = 3;
    p2.y = 2;

    Vector2 p3;  // 결과를 저장할 세 번째 벡터 객체 선언

    // 연산자 오버로딩을 사용하지 않고 p1 + p2 연산 수행
    p3.x = p1.x + p2.x;
    p3.y = p1.y + p2.y;
    cout << "p3 : (" << p3.x << " , " << p3.y << ")\\n";

    cout << "----- Initialize p3 -----\\n";

    // p3 좌표를 초기화
    p3.x = 0;
    p3.y = 0;
    cout << "p3 : (" << p3.x << " , " << p3.y << ")\\n";

    cout << "----- Use Operator Overloading -----\\n";

    // + 연산자 오버로딩 사용: p1 + p2 계산 (p1.operator+(p2)와 동일)
    p3 = p1 + p2;
    cout << "p3 : (" << p3.x << " , " << p3.y << ")\\n";

    cout << "----- Compare p1 & p2 with Operator Overloading -----\\n";

    // < 연산자 오버로딩 사용: p1이 p2보다 작은지 비교
    if (p1 < p2)
        cout << "p1 is smaller than p2\\n";

    // 문자열도 연산자 오버로딩이 구현되어 있어서 += 연산이 가능함
    string test = "test";
    test += " success";  // 문자열 덧붙이기 연산자 += 가 적용됨

    return 0;
}

// 실행 결과

const &를 사용한 최적화의 장점

불필요한 복사 연산 방지 : `const Vector2&`를 사용하면 원본 객체를 직접 참조하므로 복사 비용을 줄일 수 있습니다.
객체의 불변성 유지 : `const`를 추가하여 연산 중 객체가 변경되지 않도록 보호합니다.
성능 향상 : 값 복사 없이 연산을 수행하여 빠른 실행 속도를 유지합니다.

C++ 표준 라이브러리에서의 연산자 오버로딩 활용

C++ 표준 라이브러리에서도 연산자 오버로딩이 적극적으로 활용됩니다. 대표적인 예로 `std::string`이 있으며, 문자열을 쉽게 이어 붙일 수 있도록 `+=` 연산자가 오버로딩되어 있습니다.

#include <iostream>
#include <string>

int main() {
    std::string test = "test";
    test += " success";  // += 연산자 오버로딩이 적용됨
    std::cout << test << std::endl;  // 출력: test success
    return 0;
}

위 코드에서 `test += " success";` 구문이 동작하는 이유는 `std::string` 클래스에 `operator+=`가 오버로딩되어 있기 때문입니다.

디버깅을 통해 확인해 보면 `operator+=`가 `const char*`을 매개변수로 받아 문자열을 결합하는 역할을 수행한다는 것을 알 수 있습니다.

Lv11 연산자 오버로딩(Operator Overloading)

All is well

[오늘의 에러/GitBash] fatal: invalid reference: / error: The following untracked working tree files would be overwritten by merge:

오늘의 에러1

오류 원인

해결 방법 (선택지 2가지)

오늘의 에러2

오류 원인

해결 방법 (선택지 2가지)

방법1) 로컬 경로의 파일 삭제하기 (로컬 변경 사항 무시)만약 원격 저장소의 파일로 덮어써도 상관없다면, 로컬의 해당 파일을 삭제하면 됩니다.그런 다음 다시 병합을 시도합니다.

해결 과정

해결 완료

[오늘의에러/UE] fatal error C1083: 포함 파일을 열 수 없습니다. 'Character/CCharacter.h': No such file or directory (헤더 파일과 소스 파일을 한 폴더에 담았을 때 소스 파일이 헤더 파일을 인식하지 못하는 경우)

오늘의 에러

에러 발생

에러 원인

해결 방법

방법1

방법2

추가 개념 정리

// PublicIncludePaths

// ModuleDirectory

[YYBASIC0401/얌얌코딩] std::string 클래스 만들어보기

// 디버깅용 코드 실행 결과

[백준/C++] 10988(팰린드롬인지 확인하기) (단순 인덱스 비교 / 캐시 최적화 / reverse() / deque / 투 포인터 / 재귀)

내가 해냄 : 단순 인덱스 비교 방식

사용한 핵심 개념

// 단순 인덱스 비교 방식

AI 피드백 : 캐시 효율 증가

주요 최적화 내용

// 반복문에서 반복 조건 계산 줄이기

// for 문 내부에서 변수를 미리 선언하여 캐시 최적화

루프 내부 변수 선언을 통한 캐시 최적화란?

// 기존 방식

// 캐시 최적화를 적용한 방식

// 캐시 최적화의 원리

// 성능 차이 분석 (실제 적용 효과)

또 다른 풀이 1 : `reverse()` 이용

// 장점

// 단점

또 다른 풀이 2 : `deque`(덱)를 이용한 풀이

// 장점

// 단점

또 다른 풀이 3 : 투 포인터(Two Pointer) 이용

투 포인터 방식의 장점

// 가독성

// 다양한 문제 해결에 적용 가능

// 성능 향상 가능성

또 다른 풀이 4 : 재귀(Recursion) 이용

// 장점

// 단점

[백준/C++] 15651(N과 M (2)) (중복 순열 / 백 트래킹 / 재귀 / 완전 탐색 / ostringstream)

내가 해냄 : Back tracking 이용

사용한 핵심 개념

// 중복을 허용하는 순열 (중복 순열, Multiset Permutation)

// 백트래킹 (Backtracking)

AI 피드백 : 완전 탐색을 활용한 구현

사용한 핵심 개념

// 완전 탐색 (Brute Force)

// 사전순 탐색 (Lexicographic Order)

// 자리값 조정 (Position Update)

// ostringstream를 활용한 입출력 최적화

백트래킹 (Backtracking) vs. 완전 탐색 (Brute Force)

실행 결과 분석

// 메모리 사용량

// 실행 시간

언제 어떤 방식을 사용해야 할까?

// 백트래킹이 유용한 경우

// 완전 탐색이 유용한 경우

[백준/C++] 15649(N과 M (1)) (int를 string으로 / 순열 / next_permutation / 백트래킹)

내가 해냄 : `next_permutation()` 사용

사용한 핵심 개념

// `next_permutation()`을 이용한 순열 생성

// 벡터 초기화 및 활용 (`vector<int>` 사용)

// `prev`와 `cur`을 이용한 중복 제거

시간 복잡도 분석

AI 피드백 : 백트래킹(Backtracking) 활용

주요 개선 포인트

// `next_permutation()`을 제거하고, 백트래킹을 이용하여 직접 순열을 생성했다

// 문자열 비교(prev vs cur) 방식 대신, `vector<bool> used`를 활용함

// 출력 최적화 (`cout` 활용)

방법1) 로컬 경로의 파일 삭제하기 (로컬 변경 사항 무시)
만약 원격 저장소의 파일로 덮어써도 상관없다면, 로컬의 해당 파일을 삭제하면 됩니다.그런 다음 다시 병합을 시도합니다.