Development Tools (개발 도구 모음) ?

Linux에서 소프트웨어를 개발하고 컴파일하는 데 필요한 도구들의 패키지입니다.

예를 들어 “VMware Tools”처럼 C/C++ 소스 코드로 작성된 프로그램을 설치할 때 반드시 필요합니다.

설치 명령

rocky linux

dnf groupinstall "Development Tools" -y

// vm-tool 설치 (Rocky Linux 공식 저장소에서 설치, ISO 방식이 아님)
sudo dnf install open-vm-tools open-vm-tools-desktop -y

설치 시간 및 용량

• 예상 시간: 3-5분
• 설치 크기: ~1GB
• 필요 디스크: ~2GB

설치 결과

20260217 설치 결과는 Rocky Linux 버전 및 시간에 따라 다를 수 있습니다.

--------------

Installed:
  annobin-docs-12.99-1.el10.noarch                 annobin-plugin-gcc-12.99-1.el10.x86_64               asciidoc-10.2.0-12.el10.noarch                   autoconf-2.71-13.el10.noarch                                   
  automake-1.16.5-20.el10.noarch                   bison-3.8.2-9.el10.x86_64                            boost-atomic-1.83.0-5.el10.x86_64                boost-filesystem-1.83.0-5.el10.x86_64                          
  boost-regex-1.83.0-5.el10.x86_64                 boost-system-1.83.0-5.el10.x86_64                    boost-thread-1.83.0-5.el10.x86_64                byacc-2.0.20230521-7.el10.x86_64                               
  cmake-filesystem-3.30.5-3.el10_0.x86_64          cpp-14.3.1-2.1.el10.x86_64                           debugedit-5.1-8.el10.x86_64                      diffstat-1.66-3.el10.x86_64                                    
  docbook-dtds-1.0-92.el10.noarch                  docbook-style-xsl-1.79.2-30.el10.noarch              dwz-0.16-1.el10.x86_64                           dyninst-13.0.0-1.el10.x86_64                                   
  efi-srpm-macros-6-7.el10.noarch                  efivar-libs-39-3.el10.x86_64                         elfutils-0.193-1.el10.rocky.0.1.x86_64           elfutils-debuginfod-client-devel-0.193-1.el10.rocky.0.1.x86_64 
  elfutils-devel-0.193-1.el10.rocky.0.1.x86_64     elfutils-libelf-devel-0.193-1.el10.rocky.0.1.x86_64  flex-2.6.4-19.el10.x86_64                        fonts-srpm-macros-1:2.0.5-18.el10.noarch                       
  forge-srpm-macros-0.4.0-6.el10.noarch            gcc-14.3.1-2.1.el10.x86_64                           gcc-c++-14.3.1-2.1.el10.x86_64                   gcc-plugin-annobin-14.3.1-2.1.el10.x86_64                      
  gdb-16.3-2.el10.x86_64                           gdb-headless-16.3-2.el10.x86_64                      gettext-common-devel-0.22.5-6.el10.noarch        gettext-devel-0.22.5-6.el10.x86_64                             
  git-2.47.3-1.el10.x86_64                         git-core-2.47.3-1.el10.x86_64                        git-core-doc-2.47.3-1.el10.noarch                glibc-devel-2.39-58.el10_1.7.x86_64                            
  go-srpm-macros-3.6.0-4.el10.noarch               graphviz-9.0.0-15.el10.x86_64                        intltool-0.51.0-29.el10.noarch                   javapackages-filesystem-6.4.0-1.el10.noarch                    
  jna-5.14.0-7.el10.x86_64                         kernel-devel-6.12.0-124.35.1.el10_1.x86_64           kernel-headers-6.12.0-124.35.1.el10_1.x86_64     kernel-srpm-macros-1.0-26.el10.noarch                          
  libipt-2.1-5.el10.x86_64                         libstdc++-devel-14.3.1-2.1.el10.x86_64               libtool-2.4.7-13.el10.x86_64                     libxcrypt-devel-4.4.36-10.el10.x86_64                          
  libzstd-devel-1.5.5-9.el10.x86_64                ltrace-0.7.91-52.el10.x86_64                         lua-srpm-macros-1-15.el10.noarch                 m4-1.4.19-11.el10.x86_64                                       
  make-1:4.4.1-9.el10.x86_64                       mokutil-2:0.7.2-1.el10.x86_64                        nss-tools-3.112.0-4.el10_0.x86_64                ocaml-srpm-macros-10-4.el10.noarch                             
  openblas-srpm-macros-2-19.el10.noarch            openssl-devel-1:3.5.1-7.el10_1.x86_64                package-notes-srpm-macros-0.5-13.el10.noarch     patch-2.7.6-26.el10.x86_64                                     
  patchutils-0.4.2-15.el10.x86_64                  perl-Clone-0.46-10.el10.x86_64                       perl-Compress-Raw-Bzip2-2.212-512.el10.x86_64    perl-Compress-Raw-Zlib-2.212-513.el10_1.x86_64                 
  perl-Data-Dump-1.25-13.el10.noarch               perl-Digest-HMAC-1.04-12.el10.noarch                 perl-Digest-SHA-1:6.04-512.el10.x86_64           perl-Encode-Locale-1.05-31.el10.noarch                         
  perl-Error-1:0.17029-18.el10.noarch              perl-Fedora-VSP-0.001-36.el10.noarch                 perl-File-Compare-1.100.800-512.2.el10_0.noarch  perl-File-Copy-2.41-512.2.el10_0.noarch                        
  perl-File-Listing-6.16-5.el10.noarch             perl-Git-2.47.3-1.el10.noarch                        perl-HTML-Parser-3.82-3.el10.x86_64              perl-HTML-Tagset-3.20-59.el10.noarch                           
  perl-HTTP-Cookies-6.11-5.el10.noarch             perl-HTTP-Date-6.06-6.el10.noarch                    perl-HTTP-Message-6.45-5.el10.noarch             perl-HTTP-Negotiate-6.01-40.el10.noarch                        
  perl-I18N-Langinfo-0.24-512.2.el10_0.x86_64      perl-IO-Compress-2.212-512.el10.noarch               perl-IO-HTML-1.004-14.el10.noarch                perl-LWP-MediaTypes-6.04-19.el10.noarch                        
  perl-Module-Load-1:0.36-511.el10.noarch          perl-NTLM-1.09-41.el10.noarch                        perl-Net-HTTP-6.23-6.el10.noarch                 perl-TermReadKey-2.38-24.el10.x86_64                           
  perl-Thread-Queue-3.14-511.el10.noarch           perl-TimeDate-1:2.33-16.el10.noarch                  perl-Try-Tiny-0.31-12.el10.noarch                perl-WWW-RobotRules-6.02-41.el10.noarch                        
  perl-XML-Parser-2.47-6.el10.x86_64               perl-generators-1.16-7.el10.noarch                   perl-lib-0.65-512.2.el10_0.x86_64                perl-libwww-perl-6.76-3.el10.noarch                            
  perl-macros-4:5.40.2-512.2.el10_0.noarch         perl-srpm-macros-1-57.el10.noarch                    perl-subs-1.04-512.2.el10_0.noarch               perl-threads-1:2.40-511.el10.x86_64                            
  perl-threads-shared-1.69-511.el10.x86_64         perl-version-8:0.99.32-4.el10.x86_64                 pesign-116-6.el10.x86_64                         pyproject-srpm-macros-1.16.2-1.el10.noarch                     
  python-srpm-macros-3.12-10.el10.noarch           qt6-srpm-macros-6.9.1-1.el10.noarch                  redhat-rpm-config-293-1.el10.rocky.0.2.noarch    rpm-build-4.19.1.1-20.el10.x86_64                              
  rpm-sign-4.19.1.1-20.el10.x86_64                 rust-toolset-srpm-macros-1.88.0-1.el10.noarch        sgml-common-0.6.3-65.el10.noarch                 source-highlight-3.1.9-25.el10.x86_64                          
  systemd-rpm-macros-257-13.el10.rocky.0.1.noarch  systemtap-5.3-3b.el10.x86_64                         systemtap-client-5.3-3b.el10.x86_64              systemtap-devel-5.3-3b.el10.x86_64                             
  systemtap-runtime-5.3-3b.el10.x86_64             tbb-2021.11.0-7.el10.x86_64                          valgrind-1:3.25.1-3.el10.x86_64                  valgrind-devel-1:3.25.1-3.el10.x86_64                          
  valgrind-docs-1:3.25.1-3.el10.x86_64             valgrind-gdb-1:3.25.1-3.el10.x86_64                  valgrind-scripts-1:3.25.1-3.el10.x86_64          xz-devel-1:5.6.2-4.el10_0.x86_64                               
  zlib-ng-compat-devel-2.2.3-3.el10_1.x86_64       zstd-1.5.5-9.el10.x86_64                            

Complete!

주요 설치 파일 (C/C++ 기준)

컴파일러 (Compiler)

소스 코드(.c, .cpp) → 기계어 실행파일로 변환

gcc-14.3.1           → C 언어 컴파일러
gcc-c++-14.3.1       → C++ 언어 컴파일러

빌드 도구 (Build Tools)

컴파일러 옵션 자동 설정 / 복잡한 빌드 과정 자동화 / 어떤 파일을 먼저 컴파일할지 관리 등…

make-4.4.1           → 자동 빌드 관리
autoconf-2.71        → 자동 설정 생성
automake-1.16.5      → Makefile 자동 생성

커널 개발 패키지 (Kernel Development)

역할: 커널과 상호작용하는 모듈 작성 가능

kernel-devel-6.12.0-124.35.1
kernel-headers-6.12.0-124.35.1
-----------------------------------------------
설치 명령어
sudo dnf install kernel-devel kernel-headers -y 

라이브러리 개발 패키지 (Library Development)

역할: 컴파일된 코드를 실행 가능 파일로 연결 (링킹)

glibc-devel-2.39           → C 표준 라이브러리
libstdc++-devel-14.3.1     → C++ 표준 라이브러리
-----------------------------------------------
모든 C/C++ 프로그램의 기본 함수 제공
printf(), malloc() 등의 함수 구현

추가 개발 도구

Git: 소스 코드 변경 이력 관리, GDB: 프로그램 실행 중 오류 추적, libtool: 공유 라이브러리(.so) 빌드

git-2.47.3           → 소스 코드 버전 관리
gdb-16.3             → 프로그램 디버거
libtool-2.4.7        → 라이브러리 빌드 도구

참고 및 주의사항

groupinstall vs install

#  잘못된 방법 (의존성 부족 가능)
sudo dnf install gcc

#  올바른 방법 (모든 관련 도구 자동 설치)
sudo dnf groupinstall "Development Tools" -y

설치 확인

# 컴파일러 확인
gcc --version

# Make 확인
make --version

# 커널 헤더 확인
ls /usr/src/kernels/

오류 발생 시

네트워크 오류:

sudo dnf clean all
sudo dnf groupinstall "Development Tools" -y

의존성 충돌:

sudo dnf groupinstall "Development Tools" --allowerasing -y

The post Linux Development Tools Install appeared first on 어제와 내일의 나 그 사이의 이야기.

가장 긴 증가하는 부분 수열 5

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

문제

수열 A가 주어졌을 때, 가장 긴 증가하는 부분 수열을 구하는 프로그램을 작성하시오.

예를 들어, 수열 A = {10, 20, 10, 30, 20, 50} 인 경우에 가장 긴 증가하는 부분 수열은 A = {10, 20, 10, 30, 20, 50} 이고, 길이는 4이다.

입력

첫째 줄에 수열 A의 크기 N (1 ≤ N ≤ 1,000,000)이 주어진다.

둘째 줄에는 수열 A를 이루고 있는 A_i가 주어진다. (-1,000,000,000 ≤ A_i ≤ 1,000,000,000)

출력

첫째 줄에 수열 A의 가장 긴 증가하는 부분 수열의 길이를 출력한다.

둘째 줄에는 정답이 될 수 있는 가장 긴 증가하는 부분 수열을 출력한다.

6
10 20 10 30 20 50

4
10 20 30 50

출처

• 문제를 만든 사람: baekjoon
• 데이터를 추가한 사람: harinboy, jh05013, kkw564, ldw0318, minho6428, sohnryang, surung9898, yeo2507
• 빠진 조건을 찾은 사람: Acka

비슷한 문제

• 11053번. 가장 긴 증가하는 부분 수열
• 11054번. 가장 긴 바이토닉 부분 수열
• 11055번. 가장 큰 증가하는 부분 수열
• 11722번. 가장 긴 감소하는 부분 수열
• 12015번. 가장 긴 증가하는 부분 수열 2
• 12738번. 가장 긴 증가하는 부분 수열 3
• 14002번. 가장 긴 증가하는 부분 수열 4

알고리즘 분류

• 이분 탐색
• 역추적
• 가장 긴 증가하는 부분 수열 문제

1차 시도 – 로직 그대로 구현

한 번의 입력(num)에 의해 생성된 새로운 시퀀스들을 임시로 저장

어떤 수열에도 붙을 수 없으면 독립된 시퀀스 시작

나중에 불필요한 시퀀스(같은 길이인데 꼬리가 큰 것)는 제거

#include <iostream>
#include <vector>

using namespace std;

int n; // 수열의 개수
vector<vector<int>> Sequences;

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

    cin >> n;
    if (n <= 0) return 0;

    int num;
    cin >> num;

    // 첫 번째 수로 초기 시퀀스 하나 생성
    vector<int> sequence;
    sequence.push_back(num);
    Sequences.push_back(sequence);

    for (int i = 1; i < n; i++)
    {
        cin >> num;
        int length = Sequences.size();

        bool canExtend = false;
        vector<vector<int>> newSequences;

        // 기존 시퀀스들을 모두 검사
        for (int j = 0; j < length; j++)
        {
            int last = Sequences[j].back();

            // 확장 가능한 경우 : 새로운 시퀀스 생성
            if (last < num)
            {
                canExtend = true;
                vector<int> extendedSeq = Sequences[j];
                extendedSeq.push_back(num);
                newSequences.push_back(extendedSeq);
            }
        }

        // 어떤 시퀀스에도 붙지 못하면 새로운 시퀀스 시작
        if (!canExtend)
        {
            vector<int> newSeq;
            newSeq.push_back(num);
            newSequences.push_back(newSeq);
        }

        // 새로 생긴 시퀀스들을 기존에 합침
        for (auto& seq : newSequences)
            Sequences.push_back(seq);

        // 최적 시퀀스 길이 및 꼬리값 계산
        int maxSeqSize = 0;
        int bestIndex = 0;
        int bestTail = 1000000001;

        for (int j = 0; j < (int)Sequences.size(); j++)
        {
            int sz = Sequences[j].size();
            int tail = Sequences[j].back();
            if (sz > maxSeqSize || (sz == maxSeqSize && tail < bestTail))
            {
                maxSeqSize = sz;
                bestTail = tail;
                bestIndex = j;
            }
        }

        // 가지치기: 같은 길이인데 꼬리값이 큰 시퀀스 제거
        for (int j = 0; j < (int)Sequences.size();)
        {
            int sz = Sequences[j].size();
            int tail = Sequences[j].back();

            if (sz == maxSeqSize && tail > bestTail)
            {
                Sequences.erase(Sequences.begin() + j);
            }
            else
            {
                j++;
            }
        }
    }

	// 결과 중 가장 긴 시퀀스 찾기
    int maxSize = 0;
    int bestIdx = 0;
    for (int i = 0; i < (int)Sequences.size(); i++)
    {
        if (Sequences[i].size() > maxSize)
        {
            maxSize = Sequences[i].size();
            bestIdx = i;
        }
    }

    cout << maxSize << "\n";
    for (int x : Sequences[bestIdx])
        cout << x << " ";

    return 0;
}

브루트포스 방식으로 모든 가능한 증가 수열을 시도하는 방법은 시간 초과 및 메모리 초과로 인하여 통과할 수 없음.

매 반복마다 Sequences의 크기가 기하급수적으로 늘어나는 구조

n개의 원소가 들어오면 2ⁿ에 비례하는 시퀀스로 통과하기 힘들다. (O(2ⁿ))

2차 시도 – 이분 탐색 + 인덱스 추적을 이용한 LIS 복원 / O(N log N)

최장 증가 수열 (LIS, Longest Increasing Subsequence)

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

using namespace std;

// (LIS, Longest Increasing Subsequence)

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

    int N;
    std::cin >> N;

    vector<int> input(N);
    for (int i = 0; i < N; i++)
        std::cin >> input[i];

    vector<int> tail;  // LIS를 구성하는 인덱스들
    vector<int> prev_idx(N, -1);  //각 요소가 LIS에 포함될 때, 그 직전 요소의 인덱스를 저장


    for (int i = 0; i < N; i++)
    {
        // 이분 탐색으로 input[i]가 tail 배열에서 들어가야 할 위치 찾기
        int lo = 0;
        int hi = (int)tail.size() - 1;
        int pos = (int)tail.size(); // 기본값은 맨 뒤

        while (lo <= hi)
        {
            int mid = (lo + hi) / 2;
            // input[i]보다 크거나 같은 첫 번째 tail 원소 위치(pos)를 찾
            if (input[tail[mid]] < input[i])
            {
                lo = mid + 1;
            }
            else
            {
                pos = mid;
                hi = mid - 1;
            }
        }

        // 이전 인덱스 설정
        if (pos > 0)
        {
            prev_idx[i] = tail[pos - 1];
        }
        else
        {
            prev_idx[i] = -1;  // 첫 번째 요소
        }

        // tail 업데이트
        if (pos == (int)tail.size())
        {
            tail.push_back(i);
        }
        else
        {
            tail[pos] = i;
        }
    }

    // 결과: LIS 길이
    int lis_len = (int)tail.size();
    std::cout << lis_len << "\n";

    // 실제 LIS 수열 재구성
    vector<int> lis;
    for (int idx = tail.back(); idx != -1; idx = prev_idx[idx])
    {
        lis.push_back(input[idx]);
    }
    reverse(lis.begin(), lis.end());

    for (int v : lis)
        std::cout << v << " ";
    std::cout << "\n";

    return 0;
}

input[i]가 들어가야 할 위치(pos)를 찾음

즉, tail 배열 내에서 input[i]보다 작지만 가장 큰 값 다음 위치를 찾는다.

prev_idx[i]는 input[i] 바로 앞에 올 LIS 원소의 인덱스입니다.

pos > 0이면 → 현재 원소가 “길이 pos+1″짜리 LIS의 마지막이 되므로 “그 바로 이전 원소”는 tail[pos - 1]

pos == 0이면 → 수열의 첫 번째 원소이므로 이전이 없음

pos == tail.size() → input[i]가 지금 까지의 모든 수보다 크므로 LIS 길이 1 증가

그렇지 않으면 → 기존 LIS 후보 중 “끝값이 더 큰 것”을 input[i]로 치환 (더 작은 끝값 유지)

예시 1

input = [5, 2, 8, 6, 3, 6, 9, 7]

예시 2

이분 탐색을 이용한 LIS 구성 로직

input = [3, 5, 2, 7, 4, 1, 8]

--------------------------------

i=0 (값: 3)
tail: [] (빈 배열)
이분탐색: tail.size() = 0 → while문 스킵
pos = 0 (기본값)

prev_idx[0] = -1 (pos=0이므로)
tail 업데이트: pos == tail.size() → push_back(0)
결과: tail = [0] (값: [3])

--------------------------------

i=1 (값: 5)
tail: [0] (값: [3])
이분탐색:
  lo=0, hi=0, mid=0
  input[tail[0]] = 3 < 5 → lo = mid+1 = 1
  lo=1 > hi=0 → 종료
pos = tail.size() = 1

prev_idx[1] = tail[0] = 0 (5 앞에 3)
tail 업데이트: push_back(1)
결과: tail = [0,1] (값: [3,5])

--------------------------------

i=2 (값: 2)
tail: [0,1] (값: [3,5])
이분탐색:
  lo=0, hi=1, mid=0
  input[tail[0]] = 3 >= 2 → pos=0, hi=-1
  lo=0 > hi=-1 → 종료
pos = 0

prev_idx[2] = -1 (pos=0이므로)
tail 업데이트: tail[0] = 2
결과: tail = [2,1] (값: [2,5])

--------------------------------

i=3 (값: 7)
tail: [2,1] (값: [2,5])
이분탐색:
  lo=0, hi=1, mid=0: input[tail[0]]=2 < 7 → lo=1
  lo=1, hi=1, mid=1: input[tail[1]]=5 < 7 → lo=2
  lo=2 > hi=1 → 종료
pos = tail.size() = 2

prev_idx[3] = tail[1] = 1 (7 앞에 5)
tail 업데이트: push_back(3)
결과: tail = [2,1,3] (값: [2,5,7])

--------------------------------

i=4 (값: 4)
tail: [2,1,3] (값: [2,5,7])
이분탐색:
  lo=0, hi=2, mid=1: input[tail[1]]=5 >= 4 → pos=1, hi=0
  lo=0, hi=0, mid=0: input[tail[0]]=2 < 4 → lo=1
  lo=1 > hi=0 → 종료
pos = 1

prev_idx[4] = tail[0] = 2 (4 앞에 2)
tail 업데이트: tail[1] = 4
결과: tail = [2,4,3] (값: [2,4,7])

--------------------------------

i=5 (값: 1)
tail: [2,4,3] (값: [2,4,7])
이분탐색:
  lo=0, hi=2, mid=1: input[tail[1]]=4 >= 1 → pos=1, hi=0
  lo=0, hi=0, mid=0: input[tail[0]]=2 >= 1 → pos=0, hi=-1
  lo=0 > hi=-1 → 종료
pos = 0

prev_idx[5] = -1
tail 업데이트: tail[0] = 5
결과: tail = [5,4,3] (값: [1,4,7])

--------------------------------

i=6 (값: 8)

tail: [5,4,3] (값: [1,4,7])
이분탐색:
  lo=0, hi=2, mid=1: input[tail[1]]=4 < 8 → lo=2
  lo=2, hi=2, mid=2: input[tail[2]]=7 < 8 → lo=3
  lo=3 > hi=2 → 종료
pos = tail.size() = 3

prev_idx[6] = tail[2] = 3 (8 앞에 7)
tail 업데이트: push_back(6)
결과: tail = [5,4,3,6] (값: [1,4,7,8])

The post 백준 14003번 (가장 긴 증가하는 부분 수열 5, C++) appeared first on 어제와 내일의 나 그 사이의 이야기.

가운데를 말해요

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

문제

백준이는 동생에게 “가운데를 말해요” 게임을 가르쳐주고 있다.

백준이가 정수를 하나씩 외칠때마다 동생은 지금까지 백준이가 말한 수 중에서 중간값을 말해야 한다.

만약, 그동안 백준이가 외친 수의 개수가 짝수개라면 중간에 있는 두 수 중에서 작은 수를 말해야 한다.

예를 들어 백준이가 동생에게 1, 5, 2, 10, -99, 7, 5를 순서대로 외쳤다고 하면, 동생은 1, 1, 2, 2, 2, 2, 5를 차례대로 말해야 한다.

백준이가 외치는 수가 주어졌을 때, 동생이 말해야 하는 수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에는 백준이가 외치는 정수의 개수 N이 주어진다.

N은 1보다 크거나 같고, 100,000보다 작거나 같은 자연수이다.

그 다음 N줄에 걸쳐서 백준이가 외치는 정수가 차례대로 주어진다.

정수는 -10,000보다 크거나 같고, 10,000보다 작거나 같다.

출력

한 줄에 하나씩 N줄에 걸쳐 백준이의 동생이 말해야 하는 수를 순서대로 출력한다.

예제 입력 1

7
1
5
2
10
-99
7
5

예제 출력 1

1
1
2
2
2
2
5

출처

• 문제를 만든 사람: ntopia
• 데이터를 추가한 사람: pichulia
• 문제를 각색한 사람: baekjoon

알고리즘 분류

• 자료 구조
• 우선순위 큐

1차 시도 – 배열 인덱스 (실패 / 시간 초과)

배열을 기반으로, 중간값의 인덱스(currentMedian)를 유지하면서 새로운 값이 들어올 때마다 leftCount, rightCount를 조정하는 방식

#include <iostream>
using namespace std;

int n = 0;
int num[20001] = { 0 };  // 값의 출현 횟수 (index = value + 10000)
int currentMedian = 0;   // 현재 중간값의 인덱스
int leftCount = 0;       // 중간값보다 작은 값들의 개수
int rightCount = 0;      // 중간값보다 큰 값들의 개수

// 실제 값 => 배열 인덱스로 변환
inline int GetIndex(int value) 
{
    return value + 10000;
}

// 배열 인덱스 => 실제 값으로 변환
inline int GetValue(int index) 
{
    return index - 10000;
}

int FindMedianOptimized(int newValue, int total)
{
    int newIdx = GetIndex(newValue);
    num[newIdx]++;

    // 새 값의 위치에 따라 좌우 카운트 조정
    if (newIdx < currentMedian) leftCount++;
    else if (newIdx > currentMedian) rightCount++;
    else rightCount++; // 같은 값일 경우 간단히 오른쪽으로 분류

    // 목표 중간 위치 계산
    int targetPos = (total + 1) / 2;

    // 중간값 인덱스를 왼쪽으로 이동 (왼쪽 원소가 너무 많을 때)
    while (leftCount >= targetPos) {
        currentMedian--;
        leftCount -= num[currentMedian];
        rightCount += num[currentMedian];
    }

    // 중간값 인덱스를 오른쪽으로 이동 (왼쪽 원소가 부족할 때)
    while (leftCount + num[currentMedian] < targetPos) {
        leftCount += num[currentMedian];
        currentMedian++;
        rightCount -= num[currentMedian];
    }

    // 현재 중간값 반환
    return GetValue(currentMedian);
}

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

    cin >> n;
    int value = 0;

    // 첫 번째 입력값으로 초기화
    cin >> value;
    num[GetIndex(value)]++;
    currentMedian = GetIndex(value);
    leftCount = 0;
    rightCount = 0;

    // 첫 번째 값 => 중간값
    cout << value << "\n"; 

    for (int i = 2; i <= n; ++i) 
    {
        cin >> value;
        cout << FindMedianOptimized(value, i) << "\n";
    }

    return 0;
}

시간 초과의 원인

새로운 값이 입력될 때마다 currentMedian을 1씩 이동하며 왼쪽/오른쪽 카운트를 갱신

currentMedian의 이동 거리는 입력된 값의 분포에 따라서 문제가 생길 수 있음.

// 최악의 경우
-10000, -9999, -9998, ... , 9999, 10000

매번 새로운 값이 들어올 때마다 currentMedian이 오른쪽 끝으로 한 칸씩 이동

매번 while 루프가 최대 20,000번 반복되는 불상사가 생길 수 있음

입력 n = 100,000일 때 최악의 복잡도: O(n * 20000) = 2,000,000,000 (20억)

currentMedian 부분을 개선 또는 다른 알고리즘을 사용하는 방법이 더 좋아보임

2차 시도 – Two Heaps 방식 (성공)

maxHeap(왼쪽) + minHeap(오른쪽)으로 균형 유지

maxHeap: 중간값 이하의 값들 저장 (왼쪽 절반)

minHeap: 중간값 이상의 값들 저장 (오른쪽 절반)

균형 조정 시 힙에서 한 번씩 push/pop → O(log n)

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

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

    int n;
    cin >> n;

    priority_queue<int> maxHeap;                            // 왼쪽 절반 (최대 힙)
    priority_queue<int, vector<int>, greater<int>> minHeap;  // 오른쪽 절반 (최소 힙)

    for (int i = 0; i < n; ++i) 
    {
        int value;
        cin >> value;

        // 값 삽입: 왼쪽/오른쪽 균형 유지
        if (maxHeap.empty() || value <= maxHeap.top())
            maxHeap.push(value);
        else
            minHeap.push(value);

        // 두 힙의 크기 균형 조정 (왼쪽 = 오른쪽 또는 +1)
        if (maxHeap.size() > minHeap.size() + 1) {
            minHeap.push(maxHeap.top());
            maxHeap.pop();
        }
        else if (minHeap.size() > maxHeap.size()) {
            maxHeap.push(minHeap.top());
            minHeap.pop();
        }

        // 현재 중간값 출력
        cout << maxHeap.top() << "\n";
    }

    return 0;
}

입력: [1, 5, 2, 10, -5, 8, 3]

단계별 힙 상태:

1. value=1
   maxHeap: [1]      minHeap: []
   중간값: 1

2. value=5
   maxHeap: [1]      minHeap: [5]
   중간값: 1

3. value=2
   maxHeap: [2, 1]   minHeap: [5]
   중간값: 2

4. value=10
   maxHeap: [2, 1]   minHeap: [5, 10]
   중간값: 2

5. value=-5
   maxHeap: [2, 1, -5] minHeap: [5, 10]
   중간값: 2

6. value=8
   maxHeap: [2, 1, -5] minHeap: [5, 8, 10]
   중간값: 2

7. value=3
   maxHeap: [3, 2, -5, 1] minHeap: [5, 8, 10]
   중간값: 3

The post 백준 1655번 (가운데를 말해요, C++) appeared first on 어제와 내일의 나 그 사이의 이야기.

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

문제

강호네 회사에는 직원이 N명이 있고, 해야할 일이 M개가 있다.

직원은 1번부터 N번까지 번호가 매겨져 있고, 일은 1번부터 M번까지 번호가 매겨져 있다.

각 직원은 자신이 할 수 있는 일들 중 한 개의 일만 담당할 수 있고, 각각의 일을 담당하는 사람은 1명이어야 한다.

각각의 직원이 할 수 있는 일의 목록이 주어졌을 때, M개의 일 중에서 최대 몇 개를 할 수 있는지 구하는 프로그램을 작성하시오.

입력

첫째 줄에 직원의 수 N과 일의 개수 M이 주어진다. (1 ≤ N, M ≤ 1,000)

둘째 줄부터 N개의 줄의 i번째 줄에는 i번 직원이 할 수 있는 일의 개수와 할 수 있는 일의 번호가 주어진다.

출력

첫째 줄에 강호네 회사에서 할 수 있는 일의 개수를 출력한다.

예제 입력 1

5 5
2 1 2
1 1
2 2 3
3 3 4 5
1 1

예제 출력 1

4

출처

• 문제를 만든 사람: baekjoon
• 어색한 표현을 찾은 사람: doju
• 데이터를 추가한 사람: rubix, woojw911

알고리즘 분류

• 이분 매칭

통과된 코드

#include <iostream>
#include <vector>
#include <cstring>

using namespace std;

int N, M;
vector<int> employee[1001];
int works[1001];       
bool visited[1001];      

bool DFS(int n) 
{

    for (int work : employee[n]) 
    {
        if (visited[work]) 
            continue;

        visited[work] = true;

        if (works[work] == 0 || DFS(works[work])) 
        {
            works[work] = n;
            return true;
        }
    }

    return false;
}

int main() 
{

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

    cin >> N >> M;

    for (int i = 1; i <= N; i++) 
    {
        int k, work;
        cin >> k;

        for (int j = 0; j < k; j++) 
        {
            cin >> work;
            employee[i].push_back(work);
        }
    }

    int result = 0;

    for (int i = 1; i <= N; i++) 
    {
        memset(visited, false, sizeof(visited));

        if (DFS(i)) 
            result++;
    }

    cout << result << "\n";

    return 0;
}

해당 문제와 코드가 같은 문제

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

The post 백준 11375번 (열혈강호, C++) appeared first on 어제와 내일의 나 그 사이의 이야기.

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

문제

농부 존은 소 축사를 완성하였다. 축사 환경을 쾌적하게 유지하기 위해서, 존은 축사를 M개의 칸으로 구분하고, 한 칸에는 최대 한 마리의 소만 들어가게 계획했다.

첫 주에는 소를 임의 배정해서 축사를 운영했으나, 곧 문제가 발생하게 되었다. 바로 소가 자신이 희망하는 몇 개의 축사 외에는 들어가기를 거부하는 것이다.

농부 존을 도와 최대한 많은 수의 소가 축사에 들어갈 수 있도록 하는 프로그램을 작성하시오.

축사의 번호는 1부터 M까지 매겨져 있다.

입력

첫째 줄에 소의 수 N과 축사의 수 M이 주어진다. (1 ≤ N, M ≤ 200)

둘째 줄부터 N개의 줄에는 각 소가 들어가기 원하는 축사에 대한 정보가 주어진다.

i번째 소가 들어가기 원하는 축사의 수 S_i (0 ≤ S_i ≤ M)이 먼저 주어지고, 이후 S_i개의 축사 번호가 주어진다.

같은 축사 번호가 두 번 이상 주어지는 경우는 없다.

출력

첫째 줄에 축사에 들어갈 수 있는 소의 최댓값을 출력한다.

예제 입력 1

5 5
2 2 5
3 2 3 4
2 1 5
3 1 2 5
1 2

예제 출력 1

4

https://www.acmicpc.net/board/view/137221

예제 입력 A

4 3
1 1
1 2
1 3
1 3

예제 출력 A

3

예제 입력 B

4 3
0
0
0
0

예제 출력 B

0

예제 입력 C

4 3
1 1
1 2
2 1 2
2 1 2

예제 출력 C

2

예제 입력 D

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

예제 출력 D

39

출처

• 데이터를 추가한 사람: djm03178, rubix
• 문제의 오타를 찾은 사람: hun3555

알고리즘 분류

• 이분 매칭

통과된 코드

#include <iostream>
#include <vector>
#include <cstring>

using namespace std;

int N, M;
vector<int> cowInfo[201]; // 각 소가 원하는 축사 리스트
int barnMatch[201];       // barnMatch[b] = 소 번호 (b번 축사에 배정된 소)
bool visited[201];        // DFS 방문 체크

// 축사 매칭 시도
bool DFS(int cow) 
{

    for (int barn : cowInfo[cow]) 
    {
        if (visited[barn]) 
            continue;

        visited[barn] = true;

        // 이 축사가 비었거나, 이미 배정된 소가 다른 축사로 갈 수 있다면
        if (barnMatch[barn] == 0 || DFS(barnMatch[barn])) 
        {
            barnMatch[barn] = cow;
            return true;
        }
    }

    return false;
}

int main() 
{

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

    cin >> N >> M;

    for (int i = 1; i <= N; i++) 
    {
        int k, barn;
        cin >> k;

        for (int j = 0; j < k; j++) 
        {
            cin >> barn;
            cowInfo[i].push_back(barn);
        }
    }

    int result = 0;

    for (int i = 1; i <= N; i++) 
    {
        memset(visited, false, sizeof(visited));

        if (DFS(i)) 
            result++;
    }

    cout << result << "\n";

    return 0;
}

백준에 해당 문제와 코드가 같은 문제

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

The post 백준 2188번 (축사 배정, C++) / 추가 반례 [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

가장 긴 감소하는 부분 수열

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

문제

수열 A가 주어졌을 때, 가장 긴 감소하는 부분 수열을 구하는 프로그램을 작성하시오.

예를 들어, 수열 A = {10, 30, 10, 20, 20, 10} 인 경우에 가장 긴 감소하는 부분 수열은 A = {10, 30, 10, 20, 20, 10}  이고, 길이는 3이다.

입력

첫째 줄에 수열 A의 크기 N (1 ≤ N ≤ 1,000)이 주어진다.

둘째 줄에는 수열 A를 이루고 있는 A_i가 주어진다. (1 ≤ A_i ≤ 1,000)

출력

첫째 줄에 수열 A의 가장 긴 감소하는 부분 수열의 길이를 출력한다.

6
10 30 10 20 20 10

3

5
5 5 5 5 5

1

6
10 9 8 7 6 5

6

8
50 40 30 60 20 10 70 5

5

출처

• 문제를 만든 사람: baekjoon

비슷한 문제

• 11053번. 가장 긴 증가하는 부분 수열
• 11054번. 가장 긴 바이토닉 부분 수열
• 11055번. 가장 큰 증가하는 부분 수열
• 12015번. 가장 긴 증가하는 부분 수열 2
• 12738번. 가장 긴 증가하는 부분 수열 3
• 14002번. 가장 긴 증가하는 부분 수열 4
• 14003번. 가장 긴 증가하는 부분 수열 5

알고리즘 분류

• 다이나믹 프로그래밍

이진 탐색을 활용한 LDS (Longest Decreasing Subsequence, 최장 감소 부분 수열)

O(N log N)

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

using namespace std;

pair<int, vector<int>> FindLDS(const vector<int>& input)
{
    int n = input.size();
    vector<int> tail; // 각 길이별 LDS의 마지막 원소 인덱스
    vector<int> prev_idx(n, -1); // 이전 원소의 인덱스 추적

    for (int i = 0; i < n; i++)
    {
        int lo = 0;
        int hi = (int)tail.size() - 1;
        int pos = (int)tail.size();

        while (lo <= hi)
        {
            int mid = (lo + hi) / 2;
            if (input[tail[mid]] > input[i])
            {
                lo = mid + 1;
            }
            else
            {
                pos = mid;
                hi = mid - 1;
            }
        }

        if (pos > 0)
        {
            prev_idx[i] = tail[pos - 1];
        }
        else
        {
            prev_idx[i] = -1;
        }

        if (pos == (int)tail.size())
        {
            tail.push_back(i);
        }
        else
        {
            tail[pos] = i;
        }
    }

    vector<int> lds;
    for (int idx = tail.back(); idx != -1; idx = prev_idx[idx])
    {
        lds.push_back(input[idx]);
    }
    reverse(lds.begin(), lds.end());

    return { tail.size(), lds };
}

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

    int N;
    std::cin >> N;

    vector<int> input(N);
    for (int i = 0; i < N; i++)
        std::cin >> input[i];

    auto lds = FindLDS(input);

    cout << lds.first;

    return 0;
}

input = [9, 4, 3, 2, 5]

input = [10, 8, 6, 5, 7, 4, 3, 2, 9]

The post 백준 11722번 (가장 긴 감소하는 부분 수열, C++) appeared first on 어제와 내일의 나 그 사이의 이야기.

Npcap

https://npcap.com

Npcap 요약

Windows 운영체제를 위한 네트워크 패킷 캡처 및 분석 아키텍처이며 소프트웨어 라이브러리와 커널 레벨 네트워크 드라이버로 구성

주요 특징 및 기능

• 원시 패킷 접근: 일반적인 소켓 방식과 달리, 운영체제의 프로토콜 처리 과정을 거치지 않고 네트워크상의 ‘원시(raw)’ 데이터 패킷에 직접 접근할 수 있음
• 패킷 캡처: 로컬 머신으로 오가는 패킷뿐만 아니라, (공유 미디어 환경에서) 다른 호스트 간에 교환되는 패킷까지 캡처할 수 있음
• 패킷 필터링: 사용자가 정의한 규칙에 따라 패킷을 필터링하여 필요한 데이터만 애플리케이션에 전달할 수 있음
• 패킷 전송: 원시 패킷을 네트워크로 직접 전송하는 기능을 제공함
• 통계 수집: 네트워크 트래픽에 대한 통계 정보를 수집할 수 있음

사용 분야

Npcap은 네트워크 분석, 문제 해결, 보안, 모니터링 등 다양한 목적으로 활용함.

• 네트워크/프로토콜 분석기
• 네트워크 모니터 및 트래픽 로거
• 트래픽 생성기
• 네트워크 침입 탐지 시스템 (NIDS)
• 네트워크 스캐너 및 보안 도구

제한 사항

Npcap은 호스트의 TCP/IP 프로토콜 스택과 독립적으로 작동하며 동일한 시스템 내의 다른 프로그램이 생성하는 트래픽을 가로채거나, 필터링하거나, 조작할 수는 없음.

Npcap (및 libpcap) 주요 함수

1. pcap_findalldevs

pcap_findalldevs(pcap_if_t **alldevsp, char *errbuf)

• 기능:
  시스템에 존재하는 모든 네트워크 장치(인터페이스)의 목록을 검색

• 반환:
  성공하면 0을 반환하고, alldevsp가 가리키는 포인터에 pcap_if_t 구조체들의 연결 리스트(linked list) 주소를 저장
  실패하면 -1을 반환하고 errbuf에 오류 메시지를 저장

2. pcap_freealldevs

pcap_freealldevs(pcap_if_t *alldevs)

• 기능:
  함수로 할당된 장치 목록 메모리를 해제하는 함수
  사용이 끝난 후 반드시 호출해야 메모리 누수를 막을 수 있음

3. pcap_open_live

pcap_open_live(const char *device, int snaplen, int promisc, int to_ms, char *errbuf)

• 기능:
  지정된 네트워크 장치를 열어 실시간 패킷 캡처를 위한 세션 핸들(pcap_t *)을 얻는 함수
• device: 캡처할 네트워크 장치의 이름 (예: pcap_findalldevs로 얻은 이름)
• snaplen: 캡처할 패킷의 최대 크기 (byte). 패킷 전체를 캡처하려면 충분히 큰 값(예: 65535)을 지정
• promisc: 무차별 모드(promiscuous mode) 설정 여부. 1로 설정하면 자신에게 오지 않는 패킷도 캡처
• to_ms: 읽기 타임아웃 시간 (밀리초)
• errbuf: 오류 발생 시 오류 메시지를 저장할 버퍼

4. pcap_loop

pcap_loop(pcap_t *p, int cnt, pcap_handler callback, u_char *user)

• 기능:
  패킷 캡처 루프를 시작하는 함수. 패킷이 캡처될 때마다 지정된 콜백 함수(callback)를 호출
• p: 세션 핸들.
• cnt: 캡처할 패킷의 수. 음수나 0이면 오류가 발생하거나 중단될 때까지 계속 캡처합니다.
• callback: 패킷이 캡처될 때 호출될 함수 포인터. 이 함수는 (u_char *user, const struct pcap_pkthdr *header, const u_char *packet) 형태의 인자를 받습니다.
• user: 콜백 함수에 전달될 사용자 정의 데이터 포인터.

5. pcap_close

pcap_close(pcap_t *p)

• 기능:
  캡처 세션을 닫고 관련 리소스를 해제하는 함수
  pcap_open_live 등으로 열었던 핸들은 반드시 이 함수로 닫아야 함.

The post Npcap appeared first on 어제와 내일의 나 그 사이의 이야기.

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

문제

도현이는 바구니를 총 N개 가지고 있고, 각각의 바구니에는 1번부터 N번까지 번호가 매겨져 있다.

바구니에는 공이 1개씩 들어있고, 처음에는 바구니에 적혀있는 번호와 같은 번호가 적힌 공이 들어있다.

도현이는 앞으로 M번 공을 바꾸려고 한다. 도현이는 공을 바꿀 바구니 2개를 선택하고, 두 바구니에 들어있는 공을 서로 교환한다.

공을 어떻게 바꿀지가 주어졌을 때, M번 공을 바꾼 이후에 각 바구니에 어떤 공이 들어있는지 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N (1 ≤ N ≤ 100)과 M (1 ≤ M ≤ 100)이 주어진다.

둘째 줄부터 M개의 줄에 걸쳐서 공을 교환할 방법이 주어진다.

각 방법은 두 정수 i j로 이루어져 있으며, i번 바구니와 j번 바구니에 들어있는 공을 교환한다는 뜻이다. (1 ≤ i ≤ j ≤ N)

도현이는 입력으로 주어진 순서대로 공을 교환한다.

출력

1번 바구니부터 N번 바구니에 들어있는 공의 번호를 공백으로 구분해 출력한다.

예제 입력 1

5 4
1 2
3 4
1 4
2 2

예제 출력 1

3 1 4 2 5

출처

• 문제를 만든 사람: baekjoon
• 문제의 오타를 찾은 사람: onjo0127

알고리즘 분류

• 구현
• 시뮬레이션

통과된 코드

단순한 구현 문제

#include <iostream>

using namespace std;

int N, M;
int Arr[101] = { 0 };

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

	cin >> N >> M;

    for (int i = 1; i <= N; i++)
        Arr[i] = i;

	int t1, t2;

    for (int i = 0; i < M; i++) {
        cin >> t1 >> t2;
		swap(Arr[t1], Arr[t2]);
    }

    for (int i = 1; i <= N; i++)
		cout << Arr[i] << " ";

    return 0;
}

The post 백준 10813번 (공 바꾸기, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

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

문제

상근이는 문자열에 폭발 문자열을 심어 놓았다.

폭발 문자열이 폭발하면 그 문자는 문자열에서 사라지며, 남은 문자열은 합쳐지게 된다.

폭발은 다음과 같은 과정으로 진행된다.

• 문자열이 폭발 문자열을 포함하고 있는 경우에, 모든 폭발 문자열이 폭발하게 된다.
  남은 문자열을 순서대로 이어 붙여 새로운 문자열을 만든다.
• 새로 생긴 문자열에 폭발 문자열이 포함되어 있을 수도 있다.
• 폭발은 폭발 문자열이 문자열에 없을 때까지 계속된다.

상근이는 모든 폭발이 끝난 후에 어떤 문자열이 남는지 구해보려고 한다.

남아있는 문자가 없는 경우가 있다. 이때는 “FRULA”를 출력한다.

폭발 문자열은 같은 문자를 두 개 이상 포함하지 않는다.

입력

첫째 줄에 문자열이 주어진다. 문자열의 길이는 1보다 크거나 같고, 1,000,000보다 작거나 같다.

둘째 줄에 폭발 문자열이 주어진다. 길이는 1보다 크거나 같고, 36보다 작거나 같다.

두 문자열은 모두 알파벳 소문자와 대문자, 숫자 0, 1, …, 9로만 이루어져 있다.

출력

첫째 줄에 모든 폭발이 끝난 후 남은 문자열을 출력한다.

예제 입력 1

mirkovC4nizCC44
C4

예제 출력 1

mirkovniz

예제 입력 2

12ab112ab2ab
12ab

예제 출력 2

FRULA

출처

Contest > Croatian Open Competition in Informatics > COCI 2013/2014 > Contest #5 3번

• 문제를 번역한 사람: baekjoon
• 문제의 오타를 찾은 사람: chan4928
• 시간 제한을 수정한 사람: jh05013
• 데이터를 추가한 사람: limequeen, mrseos

알고리즘 분류

• 자료 구조
• 문자열
• 스택

통과된 코드

#include <iostream>
#include <string>

using namespace std;

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

    string S, C;
    cin >> S >> C;

    string Res; 

    for (char ch : S)
    {
        Res.push_back(ch);

        // Res의 마지막 부분이 c와 같은지 확인
        if (Res.size() >= C.size() && Res.substr(Res.size() - C.size()) == C)
        {
            // 문자열에서 폭발 문자열 제거
            Res.erase(Res.size() - C.size()); 
        }
    }

    cout << (Res.empty() ? "FRULA" : Res);

    return 0;
}

예시
ch = 'm': Res = "m"
ch = 'i': Res = "mi"
ch = 'r': Res = "mir"
ch = 'k': Res = "mirk"
ch = 'o': Res = "mirko"
ch = 'v': Res = "mirkov"
ch = 'C': Res = "mirkovC"
ch = '4': Res = "mirkovC4"
ch = 'n': Res = "mirkovn"
ch = 'i': Res = "mirkovni"
ch = 'z': Res = "mirkoviz"
ch = 'C': Res = "mirkovnizC"
ch = 'C': Res = "mirkovnizCC"
ch = '4': Res = "mirkovnizCC4"
ch = '4': Res = "mirkovnizC4"
Res = “mirkovniz”

The post 백준 9935번 (문자열 폭발, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

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

문제

피보나치 수는 0과 1로 시작한다. 0번째 피보나치 수는 0이고, 1번째 피보나치 수는 1이다.

그 다음 2번째 부터는 바로 앞 두 피보나치 수의 합이 된다.

이를 식으로 써보면 F_n = F_n-1 + F_n-2 (n ≥ 2)가 된다.

n=17일때 까지 피보나치 수를 써보면 다음과 같다.

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597

n이 주어졌을 때, n번째 피보나치 수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 n이 주어진다. n은 1,000,000,000,000,000,000보다 작거나 같은 자연수이다.

출력

첫째 줄에 n번째 피보나치 수를 1,000,000,007으로 나눈 나머지를 출력한다.

예제 입력 1

1000

예제 출력 1

517691607

출처

• 문제를 만든 사람: baekjoon

알고리즘 분류

• 수학
• 분할 정복을 이용한 거듭제곱

문제를 그대로 구현한 코드

답은 정확하게 나오지만 N의 크기가 증가하면 증가할 수록 연산량이 증가하여 시간초과 결과가 나오는 것은 당연하다.

#include <iostream>

using namespace std;

long long int N, t1, t2, t3;

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

	cin >> N;
    t1 = 0;
    t2 = 1;
    t3 = 1;

	if (N == 0) cout << t1;
	else if (N == 1) cout << t2;
	else if (N == 2) cout << t3;
    else 
    {
        for (int i = 2; i < N; i++)
        {
            t1 = t2 % 1000000007;
            t2 = t3 % 1000000007;
            t3 = (t1 + t2) % 1000000007;
        }
    }

	cout << t3 << endl;
    return 0;
}

피보나치 수를 더 좋은 방법으로 해결하는 방법은 아래 링크에 자세하게 설명되어 있다.

https://www.acmicpc.net/blog/view/28

위의 게시글의 내용을 살펴보면 2가지로 문제를 해결하고 있다.

통과된 코드

메모이제이션, 홀수/짝수를 이용한 풀이법을 적용한 코드

#include <iostream>
#include <map>

using namespace std;

map<long long, long long> d; // 메모이제이션을 위한 map
const long long mod = 1000000007; 

// 피보나치 수를 재귀적으로 계산하는 함수
long long Fibonacci_recursive(long long n) {
    if (n <= 0) {
        return 0;
    }
    else if (n == 1 || n == 2) {
        return 1;
    }
    else if (d.count(n) > 0) {
        return d[n];
    }
    else {
        // n이 홀수
        if (n % 2 == 1) {
            long long m = (n + 1) / 2;
            long long t1 = Fibonacci_recursive(m);
            long long t2 = Fibonacci_recursive(m - 1);
            d[n] = t1 * t1 + t2 * t2;
            d[n] %= mod;
            return d[n];
        }
        else { // n이 짝수
            long long m = n / 2;
            long long t1 = Fibonacci_recursive(m - 1);
            long long t2 = Fibonacci_recursive(m);
            d[n] = (2LL * t1 + t2) * t2;
            d[n] %= mod;
            return d[n];
        }
    }
}

int main() {
    long long n;
    cin >> n; // 입력값 받기
    cout << Fibonacci_recursive(n) << '\n'; // n번째 피보나치 수 출력
    return 0;
}

개인적으로 이런 수학적인 문제는 어느 정도 고민해보다 검색해보는 것이 공부하는 데 더 도움이 되는 것 같다.

The post 백준 11444번 (피보나치 수 6, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.