Compy's Blog

[AI] AI TOP 100 예선 후기

Fri, 20 Mar 2026 00:00:00 GMT

작년에 AI TOP 100을 일정 때문에 못 나가게돼서 이번에 꼭 나가야지 하고서 나오게 되었다.

일단 아무 준비없이 그냥 대회를 치루게 되었다.(본선은 서비스 개발인줄 알았는데 본선도 문제 풀이었다는 것도 나중에 알았다.) 일단 CS문제가 나오겠거니 했는데 들어가자마자 나온게 무슨 특이한 문제들이 나왔다.

처음에는 당황해서 어떻게 풀지 몰랐고, 대회 시간을 다 쓰지 못하는 상황이었다.(그때 한 2시간 정도 풀 수 있었다. 면접 때문에..) 그래서 최대한 빨리 풀면서 효율적으로 점수를 분배할 수 있도록 전략을 세우고 claude, gemini와 함께 했다.

첫번째 문제는 claude한테 넘겨주고 다른 애들은 내가 읽어보고 방향잡고 토론하면서 문제를 풀었다. 정확히 문제는 기억나지 않지만, 가능성을 좁혀나가면서 풀었던 것이 기억이 나고 이미지 검색 처리 같은 것은 훈련된 모델로 그냥 긁었더니 눈으로 만든 레이블 데이터와 비교해보니 대충 90% 이상은 나오길래 그것만 돌려서 정답을 제출했다.

그외로 ocr문제도 등장했는데, 이를 hugging face에 올라온 모델(내가 즐겨쓴느 모델 중 하나)랑 gemini랑 같이 돌리면서 의미를 파악하려고 했다. 또한 원하는 정보가 약간 수정된 주변의 박스가 쳐져있어서 그거 detect도 시도해봣는데 그건 제대로 안됐고 이미지 다 잘라서 의미 맥락이 맞는 블럭마다 다 읽어와서 처리해서 내용을 다 찾아서 넣었던 기억이 있다. 총 1시간 30분 정도 풀었고 제출하고 면접을 보러 갔다는... ㅠㅜ

그래서 붙을 생각 조차 못하고 있었다.

음.. 이게 아주 ㄴㅇㅅ한 상화이 됐거든요? 내가 top 100이라니? 내가 카카오 센터도 간다니 신기하네요

본선에서 네트워킹, 문제풀이 잘하고 오겠습니다.(솔직히 최근 인공지능 너무 잘해져서 어떻게 될지 진짜 잘 모르겠네요)

[AI] AI TOP 100 본선 후기

Sun, 05 Apr 2026 00:00:00 GMT

일단 본선 당일 전날 완전 예전에 잡아놓은 밥약이 있어서 간단히 먹고 집에 와서 자려고 했다가... 어떤 일이 있어서 잠을 자지 못한 상태로 대회장에 가게 되었다. 이때 정신이 하도 없어서 힘들었었는데, 도와줬던 친구한테 너무 고마웠다. (대회장까지 같이 갔었음) 그래서 사실 씻긴 했지만 정신이 없어서 면도나 이런걸 제대로 못했어 가버렸음.. 그래서 마스크들고 가긴 했는데 중간에 잃어버려서... ㅠㅜ

하튼 대회장에 도착했더니 완전 깔끔한 건물과 멋있는 스탭분들이 타란!

이야ㅏㅑㅑㅏ 스크린 완전 멋있었다. 이게 애니메이션도 쫀득하고, 그 대회장에서도 계속 나오던 bgm이 ㄹㅇ 맛도리다. 계속 들뜬 상태에 기대감이 쭉쭉 올라가는 상태를 만드는 느낌...

대회장에 들어가면 굿즈도 막 주셔서 기분좋게 받아서 "와이씨 쩐다" 이러면서 신나했었다.

그리고 대회장 앞 큰 스크린에서는 본선 진출자 대상으로 조사했던 사진과 글들이 나오고 있었다.

아아 나중에 생각해보니 약간 재밌는 글도 쓰고 사진도 사용할걸 이라는 생각이 많이 들었다. 너무 약간 감다뒤로 나와서 다른분들은 막 재밌는데 혼자 진지하게 적어져있어서 약간 민망(?)했다.

그 상태로 점심 먹을려구 했는데 시간이 다 돼버려서 못 먹고 제로 콜라 하나 들고 대회 시작했따!

대회 문제가 아직 공개가 안 돼서 자세히는 못 적지만, 이렇게 문제 푸는 게 재밌었던 대회는 처음이었던 것 같다. AI한테 "그냥 해줘"라고 했을 때 왜 안 되는지를 몸으로 느끼게 만드는 문제들이었달까. 출제자분들이 학생들이 어떤 지점에서 막히는지, 뭘 재밌어하는지를 찾으려고 정말 노력하신 것이 잘 느껴졌다.

그렇게 대회 문제 풀이 시간이 끝나고 네트워킹 시간이 되어서 돌아다니다가 학교 선배님들을 만났다. 완전 유쾌하시고, 재밌으셨던 분들이어서 너무 친해지고 싶었는데 먼저 연락처를 안 여쭤봐서 교환을 못했다 ㅠㅜㅜ...

선배님들과 찍은 사진! [얼굴은 다 가리구 올렸습니다]

밥은 내 취향은 아니었지만 그래도 생긴게 예뻐서 맛있게 먹었던거 같다.

밥을 먹으면서 말씀을 듣는데 진짜 무슨 개쩌는 분들이 막 말씀하시는거 들으며, 여러 인사이트들과 방향들을 얻어갈 수 있었고 동기부여와 더불어 롤모델도 찾을 수 있었다. (이분들이랑 연락처 교환했다!)

너무 엄청난 분들이 많아서 "흠! 이런 기회만이라도 너무 감사하다"라는 생각을 가지고 시상식으로 갔다.

그런데!?

이게 무슨 말도 안되는 행운이 일어나면서 너무 감사한 상을 받게 되었다. 사실 진짜 무슨 생각이 없었어서 진짜 꼴이 말이 아니었는데, 올라가서 옷 정리해주시면서 많이 혼났다..ㅠㅜ

아무래도 나는 확신의 공학자상인거 같다...

끝나고 집에 돌아가사면서 정말 감사하다는 생각과 엄청난 행운이 따라줬기에 이렇게 될 수 있었다는 생각이 많이 들었다. 또 상 탔다구 연락주신 분들 너무 감사합니다. 이게 저도 연락드릴려구 했는데 진짜 정신이 없어서 막 있다가 다음날 되니까 연락드리기가 너무 머쓱해서 하핳

이번에 만나셨던 분들 꼭 나중에 봬요! 수상 소감 때 말하지 못한 말 하겠습니다. "모두 수고하셨습니다. 화이팅입니다."

(원래 사진을 많이 안 찍어서 많이 없습니둥..)

[AI] Artificial Intelligence(인공지능, AI)

Mon, 24 Jun 2024 00:00:00 GMT

인공지능이란?

특정 목적을 위해 설계된 컴퓨터 알고리즘으로, 주어진 입력에 기반해 자동으로 과업을 처리한다. 이는 개발자가 직접 컴퓨터에 알고리즘을 입력하는 기존의 방법과 달리, 데이터를 기반으로 컴퓨터가 스스로 알고리즘을 학습한다는 점에서 큰 차이가 존재한다. 그래서 인공지능 알고리즘을 ‘알고리즘을 위한 알고리즘’이라고도 부른다.

알고리즘(Algorithm): 컴퓨터를 활용한 문제 해결 과정에서, 어떤 문제를 해결하기 위해 정의된 절차, 방법, 명령어 등의 집합.

인공지능에서 학습이란?

학습 알고리즘에서 ‘학습(Learning)’은 주어진 데이터를 분석해 특정 작업을 수행할 수 있는 규칙이나 패턴을 발견하는 과정을 뜻한다.

학습 알고리즘의 역할은 데이터로부터 주어진 과업을 수행할 알고리즘을 찾아내는 것이다. 예측 알고리즘에서 ‘예측(Prediction)’은 학습된 모델*을 사용하여 새로운 데이터에 대한 결과를 추론하는 과정을 말한다.

즉, 예측 알고리즘은 학습 알고리즘을 통해 학습되며, 특정 과업을 수행하는 역할을 한다. 이 두 알고리즘의 역할과 작동 원리를 이해하는 것은 인공지능의 기본 원리를 이해하는 데 매우 중요하다.

모델(Model): 학습된 규칙이나 패턴을 표현하는 수학적 또는 계산적인 구조

인공지능의 작동 과정 이해

문제 정의
데이터 수집
학습 알고리즘
1. 학습 모형의 선택
2. 파라미터의 학습
3. 예측성능 측정
예측 및 모니터링

머신러닝, 딥러닝!

머신러닝(Machine Learning)은 인공지능의 한 분야로, 머신러닝은 인공지능의 하위 집합으로, 많은 양의 데이터를 제공하여 명시적으로 프로그래밍하지 않고 시스템이 자율적으로 학습하고 개선할 수 있게하는 방식으로 말할 수 있다.

딥러닝(Deep Learning)은 인간의 두뇌에서 영감을 얻은 방식으로 데이터를 처리하도록 컴퓨터를 가르치는 인공 지능(AI) 방식, '비선형 변환기법'의 조합을 통해 높은 수준의 추상화를 시도하는 기계 학습 알고리즘의 집합으로 정의된다.

가장 큰 집합으로 인공지능이 있고, 그 인공지능이라는 분야 안에 머신러닝이 속해 있고, 또 머신러닝 안에는 딥러닝이 속해있다고 생각할 수 있습니다.

ANN, DNN, RNN, CNN

이제부터 위의 뉴럴 네트워크에 대해서 포스팅을 작성할 예정입니다. 블로그를 찾다보면 이에 대한 정보가 올라가 있으니, 확인해주세요!

이제부터 학습 알고리즘에 대해서 알아보고, 인공지능은 어떤 분야에서 이용되는지 알아보도록 합시다.

이제부터 인공지능 공부는 꾸준히 해야하는 걸로!

[AI] Machine Learning(기계 학습)

Mon, 24 Jun 2024 00:00:00 GMT

Machine Learning이란?

정의로는 인공지능의 한 분야로, 머신러닝은 인공지능의 하위 집합으로, 많은 양의 데이터를 제공하여 명시적으로 프로그래밍하지 않고 시스템이 자율적으로 학습하고 개선할 수 있게하는 방식이라고 말할 수 있습니다.

기본적으로 기계학습은 인공지능이라는 엄청 큰 집합의 하위 집합이라고 생각하시면 됩니다. 기계학습에서 알고리즘은 입력으로 들어온 dataset의 패턴과 상관관계를 찾아내고, 분석을 토대로 의사결정, 예측 등을 수행하도록 훈련됩니다.

기계학습의 작동방식

먼저 기계학습은 정말 다양한 알고리즘 기법을 적용하는 여러 유형의 모델로 구성됩니다. 데이터의 특성, 목적에 따라서 지도, 비지도, 준지도, 강화학습 등 대표적 4가지 학습모델 중 하나를 적용합니다.

머신러닝은 다양한 알고리즘 기법을 적용하는 여러 유형의 머신러닝 모델로 구성됩니다. 사용 중인 데이터 세트와 원하는 결과에 따라 각 모델 내에서 하나 이상의 알고리즘 기법을 적용할 수 있습니다.

머신러닝 알고리즘은 기본적으로 사물 분류, 패턴 발견, 결과 예측, 정보 기반 의사결정 등을 수행하도록 설계됩니다. 알고리즘은 정확도를 극대화하기 위해 여러 알고리즘을 결합할 수도 있으며, 하나만을 사용할 수도 있습니다.

:::warning[주의] 이 글은 굉장히 간단한 설명만 적혀있습니다. 자세한 학습 방법의 설명을 보고 싶다면 좀 더 세분화된 포스트로 들어가주세요.(이 글에서 예시 X) :::

지도학습

지도 학습 알고리즘에서는 예시를 통해 머신을 훈련합니다. 지도 학습 모델은 '입력', '출력' 데이터 쌍으로 구성되며, 원하는 값으로 출력 레이블을 지정할 수 있습니다.

시스템은 알고리즘을 통해 시간에 따라 이 훈련 데이터를 모두 컴파일한 다음 상관관계가 있는 유사성, 차이점, 기타 논리 지점을 결정합니다. 이 작업은 인풋에 대한 답을 스스로 예측할 수 있을 때까지 반복합니다.

비지도학습

비지도 학습 모델에는 정답 키가 없습니다. 머신이 입력 데이터(대부분 레이블이 없는 비정형 데이터)를 학습한 다음 관련성이 있고 액세스 가능한 데이터를 모두 사용해 패턴과 상관관계를 인식합니다. 비지도 학습은 사람이 세상을 관찰하는 방식을 기반으로 다양하게 모델링됩니다.

준지도학습

준지도학습은 소량의 레이블이 지정된 데이터를 입력해 레이블이 없는 데이터 세트를 증강합니다. 핵심은 레이블이 지정된 데이터를 통해 시스템이 학습 시작하며, 학습 속도와 정확성을 상당한 수준으로 개선하도록 하는 것입니다. 준지도 학습 알고리즘은 레이블이 지정된 데이터를 분석해 레이블이 없는 데이터에 적용 가능한 상관관계가 있는 속성을 찾도록 훈련합니다.

:::tip[정보] 시스템이 레이블이 지정된 데이터에 포함된 결함까지 학습해 복제할 위험이 있습니다. 준지도 학습을 가장 성공적으로 활용하는 회사에서는 선진사례 프로토콜을 구축하고 있습니다. :::

강화학습

지도형 학습에서는 머신에 정답 키를 제공해 모든 올바른 결과 중에서 상관관계를 찾아 학습하도록 합니다. 강화학습에서는 정답 키는 제공되지 않지만 일련의 허용 가능한 행동, 규칙, 잠재적 최종 상태가 입력됩니다. 강화학습에서 '보상'은 숫자이며, 시스템에서 수집하려는 항목으로 알고리즘에 프로그래밍됩니다.

이제부터 각 학습에 대한 구현과 자세한 설명을 넣은 포스트를 하도록 하겠습니다.

<!--지도 학습이란?

네 가지 머신러닝 모델 중 첫 번째는 지도 학습입니다. 지도 학습 알고리즘에서는 예시를 통해 머신을 훈련합니다. 지도 학습 모델은 '입력', '출력' 데이터 쌍으로 구성되며, 원하는 값으로 출력 레이블을 지정할 수 있습니다. 예를 들어 머신을 데이지꽃과 팬지꽃의 차이를 식별할 수 있도록 훈련하려고 합니다. 하나의 이진 입력 데이터 쌍에는 데이지꽃의 이미지와 팬지꽃의 이미지가 모두 포함됩니다. 해당 특정 쌍에 원하는 결과는 데이지꽃을 선택하는 것이기 때문에, 이것이 올바른 결과로서 사전 식별됩니다.

시스템은 알고리즘을 통해 시간에 따라 이 훈련 데이터를 모두 컴파일한 다음 상관관계가 있는 유사성, 차이점, 기타 논리 지점을 결정하기 시작하며, 이 작업은 데이지꽃인지 팬지꽃인지 묻는 질문에 대한 답을 스스로 예측할 수 있을 때까지 계속됩니다. 이는 어린 아이에게 일련의 문제를 정답 키와 함께 준 다음, 그들이 한 작업을 보여주고 논리를 설명하도록 하는 것과 같습니다. 지도형 학습 모델은 제품 추천 엔진이나 교통량 분석 앱(예: 하루 중 다른 시간대에 가장 빠른 이동 경로를 예측하는 Waze) 등 일상생활의 다양한 분야에서 사용됩니다.

비지도 학습이란?

네 가지 머신러닝 모델 중 두 번째는 비지도 학습입니다. 비지도 학습 모델에는 정답 키가 없습니다. 머신이 입력 데이터(대부분 레이블이 없는 비정형 데이터)를 학습한 다음 관련성이 있고 액세스 가능한 데이터를 모두 사용해 패턴과 상관관계를 인식하기 시작합니다. 비지도 학습은 사람이 세상을 관찰하는 방식을 기반으로 다양하게 모델링됩니다. 사람은 직관과 경험에 의존해 사물을 그룹화합니다. 어떤 사물에 대해 경험하는 예시의 수가 많을수록 그것을 분류하고 인식하는 능력이 더욱더 정확해집니다. 머신에 있어서 '경험'은 '이용 가능한 입력 데이터의 양'입니다. 비지도 학습 모델이 사용되는 대표적인 예는 안면 인식, 유전자 서열 분석, 시장 조사, 사이버 보안 등입니다.

준지도 학습이란?

네 가지 머신러닝 모델 중 세 번째는 준지도 학습입니다. 모든 데이터가 시스템에 입력되기 전에 정형화되고 레이블이 지정되어 있다면 더할 나위 없이 완벽할 것입니다. 그러나 실제에서는 이러한 일이 불가능하기 때문에, 대량의 원시 비정형 데이터를 처리해야 하는 경우 준지도 학습은 유효한 해결책이 될 수 있습니다. 이 모델은 소량의 레이블이 지정된 데이터를 입력해 레이블이 없는 데이터 세트를 증강합니다. 이 모델의 핵심은 레이블이 지정된 데이터를 통해 시스템이 학습을 시작하게 하며, 학습 속도와 정확성을 상당한 수준으로 개선하도록 하는 것입니다. 준지도 학습 알고리즘은 레이블이 지정된 데이터를 분석해 레이블이 없는 데이터에 적용 가능한 상관관계가 있는 속성을 찾도록 머신을 훈련합니다.

그러나 이 모델에는 이 MIT 대학출판사 보고서에서 자세히 다룬 것과 같이 시스템이 레이블이 지정된 데이터에 포함된 결함까지 학습해 복제할 위험이 있습니다. 준지도 학습을 가장 성공적으로 활용하는 회사에서는 선진사례 프로토콜을 구축하고 있습니다. 준지도 학습은 음성 및 언어 분석, 복잡한 의료 연구(예: 단백질 분류), 상위레벨 부정행위 감지에 사용됩니다.

강화학습이란?

네 가지 머신러닝 모델 중 마지막 모델은 강화학습입니다. 지도형 학습에서는 머신에 정답 키를 제공해 모든 올바른 결과 중에서 상관관계를 찾아 학습하도록 합니다. 강화학습 모델에서는 정답 키는 제공되지 않지만 일련의 허용 가능한 행동, 규칙, 잠재적 최종 상태가 입력됩니다. 알고리즘의 원하는 목표가 고정되어 있거나 양자택일인 경우 머신은 예시를 통해 학습할 수 있습니다. 그러나 원하는 목표가 변동 가능한 경우에는 경험과 보상을 통해 학습해야 합니다. 강화학습 모델에서 '보상'은 숫자이며, 시스템에서 수집하려는 항목으로 알고리즘에 프로그래밍됩니다.

이 모델은 여러 면에서 사람에게 체스 게임을 하는 법을 가르치는 것과 유사합니다. 체스 말이 이동할 수 있는 경우를 모두 보여주는 것은 불가능하며, 그 대신 규칙을 설명해주고 연습을 통해 기술을 습득하도록 합니다. 보상은 게임을 이기는 것뿐 아니라 상대방의 말을 획득하는 형태로 이루어집니다. 강화학습 적용 분야에는 온라인 광고 구매자의 자동 가격 입찰, 컴퓨터 게임 개발, 고위험 주식 시장 거래 등이 있습니다.

[AI] 인공신경망 ANN(Artificial Neural Network)

Wed, 26 Jun 2024 00:00:00 GMT

인공신경망이란?

인공신경망(Artificial Neural Network, ANN)은 딥러닝에서 굉장히 중요한 역할을하는 기본적인 알고리즘입니다.

ANN은 딥러닝의 기초적인 알고리즘으로써, 인간의 뇌의 프로세스를 모방하여 만들어진 학습 알고리즘입니다. ANN은 주어진 데이터에서 패턴을 학습하고, 어떠한 값에 대해서 학습된 내용을 바탕으로 예측할 수 있습니다. 현재 ANN은 이미지 인식, 자연어 처리, 음성 인식 등 다양한 곳에서 사용되고 있습니다.

일반적으로 어떠한 형태의 함수(function)이든 근사할 수 있는 ANN은 일반적으로 어떠한 형태의 function이든 근사할 수 있는 universal function approximator로도 알려져 있다.

구조

인공신경망에서 뉴런?

1. 뉴런

뉴런(Neuron)은 신경계와 신경조직을 이루는 기본 단위(in 생명과학)라고 알려진 신경 세포입니다. 신경계의 모든 작용은 신경 세포와 세포 간의 상호작용으로 인해 이루어집니다.

예를 들어봅시둥, 우리 몸의 내부와 외부에 자극을 가하게 되면 일련의 과정을 통해서 뉴런은 자극을 전달하게 됩니다. 최종적으로는 척수와 뇌 등의 중추신경계로 도달하게 되면서 중추신경계에서 처리한 정보를 다시 우리 몸으로 전달해 명령을 수행합니다.

</center>

뉴런은 수백 개가 연결되어 있고, 신호를 전달하는 과정을 수업이 거치게 됩니다. 이 뉴런들의 입력, 출력의 신호는 다른 신호입니다.

</center>

수상돌기를 통해서 입력된 자극은 축삭돌기를 통해 다음 뉴런으로 전달됩니다. 이때 시냅스에서 신경전달물질이 배출되어 다음 뉴런의 수상돌기를 통해 입력됩니다. 이렇게 전달된 자극은 자극의 일정 정도 이상ㅇ이 되었을 경우 다음 뉴런으로 전달됩니다.

보통 학습이라고 하는 것은 뉴런과 뉴런 사이의 연결 강도가 바뀌는 것입니다. 다르게 말하면, 수상돌기에 입력된 자극(신경전달물질)의 세기가 모두 같게 적용되지 않는다는 것!

신경망의 뉴런과 뉴런 사이의 연결 강도는 학습을 통해서 변화합니다.

2. 인공 뉴런

바로 위에서 설명한 인간의 뉴런 구조에서 영감을 받아 만들어진 놈이 바로 인공 뉴런입니다. 즉 인간의 뉴런 구조에 착안해 만들어진 것이죠. 이러한 인공 뉴런도 생물학적 뉴런과 비슷한 구조로 되어있습니다.

</center>

인공 뉴런의 구조를 그림으로 나타내면 위와 같은 그림이 나옵니다!

인공신경망에서 학습으로 각 입력에 따른 연결 강도가 정해지는데 우리는 그것을 가중치(weight, cost)라고 합니다. 위 그림에서 가중치는 w0, w1, w2,..., wn입니다. x0,...xn은 입력되는 값을 의미하며, 학습을 통해 우리가 구하고자 하는 값이 바로 w0, w1, ...., wn입니다.

(으아... 내 글씨 넘 안 예쁘네..) </center>

인공뉴런은 입력 x0, x1, ..., xn에 w0, w1, ..., wn가 각각 곱해지고 더해집니다. 이것을 **선형결합(sigma)**이라고 합니다. 이 값은 특정 함수 f에 의해 계산된 값이 출력되어 다음 뉴런의 입력으로 보내집니다.

Z = f(U)

</center>

3. 활성화 함수

신경계의 뉴런은 들어오는 자극이 일정 크기 이상이 되어야 다음 뉴런으로 전달됩니다. 요것을 모방한 놈이 바로 **활성화 함수(Activation Function)**입니다.

활성화 함수는 선형 결합한 값을 다음 출력으로 보내야 할지를 결정해 줍니다.

<center> Z=f(U) if U> threshold 1 else 0 </center>

인간의 뉴런은 선형결합된 값이 일정 크기를 넘어섰을 때, 다음 출력으로 보내집니다. 요것을 그대로 정의한 활성화 함수가 Binary Step 활성화 함수입니다.

인공신경망의 구조

인공신경망은 입력층(Input Layer), 은닉층(Hidden Layer), 출력층(Output Layer)으로 구성되며 **각 층의 뉴런들을 퍼셉트론(Perceptron)**이라고 부릅니다. 입력층의 뉴런의 수는 입력 변수의 수(입력층에서 바이러스를 사용하면 +1개)이며, 출력층은 분류 문제를 해결할 때 분류의 수와 일치합니다.

1. 얕은 신경망(Shallow Neural Network)

입력층과 출력층 사이에 있는 숨겨진 계층을 은닉층(Hidden Layer)이라고 합니다. (뭔가 이름이 멋지지 않나요..? 나만 그런가)

은닉층은 뉴런(Neuron)과 시냅스(Synapse)로 구성된 인간의 두뇌를 모방한 층(Layer)입니다. 보통 은닉층의 수가 적거나 없는 신경망을 얕은 신경망(Shallow Neural Network) 이라고 부릅니다.

(은닉층 X, 출력층만 갖는 신경망의 모습) </center>

요놈을 이제 수식으로 표현해 볼겁니다. 수식에서 등장하는 **b는 편향(bias)**를 의미합니다. <center>

</center>

얕은 신경망은 선형(Linear) 문제를 해결할 때 사용할 수 있겠지만... 비선형 문제를 해결해야 할 경우면 더 깊은 신경망이 필요합니다. (선형, 비선형에 대해선 다른 포스트에 다루고 있습니다.)

2. 여러가지 신경망

이제부터 나오는 신경망은 은닉층이 여러개로 구성된 신경망들이 나옵니다!!

DNN, CNN, RNN 등에 대해서 다뤄보도록 하겠습니다.

다른 포스팅에서 뵈어요!

[AI] 합성곱 신경망 CNN(Convolution Neural Network) 소개

Sat, 22 Feb 2025 00:00:00 GMT

Convolution Neural Network(CNN)이란 무엇인가요?

</center> Convolution Neural Network(이하 CNN)은 인간의 시각 처리 방식을 본떠 개발된 딥러닝 기술입니다. 특히 컴퓨터 비전(Computer Vision) 분야에서 뛰어난 성능을 발휘하며, 이미지와 관련된 작업에서 핵심적인 역할을 하고 있죠.

CNN은 일반 신경망을 한 단계 발전시킨 형태라고 볼 수 있습니다. Convolution(합성곱) 연산을 활용해 이미지의 공간적 특징을 효과적으로 유지하면서도, Fully Connected Neural Network에 비해 연산량을 크게 줄였습니다. 덕분에 효율성과 성능을 동시에 잡은 기술로 평가받고 있어요.

컴퓨터가 이미지를 어떻게 처리하는지 알아보면 CNN의 필요성이 더 분명해집니다. 컴퓨터는 이미지를 단순히 숫자의 배열로 인식합니다. 예를 들어, 흑백 이미지는 픽셀의 밝기를 나타내는 2차원 배열로, 컬러 이미지는 빨강, 초록, 파랑(RGB)의 강도를 담은 3차원 배열로 표현되죠. CNN은 이런 원시 데이터에서 의미 있는 패턴을 스스로 찾아내고 학습할 수 있도록 설계된 똑똑한 구조입니다.

CNN의 주요 활용 분야

이미지 분류

소셜 미디어에서 사진에 태그를 자동으로 붙이는 기능
의료 영상 분석을 통해 질병을 진단하는 시스템

</center>

객체 검출

자율주행 차량에서 보행자를 감지하는 기술
보안 카메라로 침입자를 탐지하는 용도

</center>

이미지 생성 및 변환

흑백 사진을 컬러로 바꾸는 작업
저해상도 이미지를 고해상도로 업스케일링하거나 보정

</center>

이 외에도 의료, 엔터테인먼트 등 다양한 분야에서 CNN이 활약하고 있습니다. 활용 범위가 정말 넓죠!

CNN의 탄생과 발전 과정

1950-60년대: 신경과학에서 얻은 영감

CNN의 기원은 1959년으로 거슬러 올라갑니다. David Hubel과 Torsten Wiesel이 고양이의 시각 피질을 연구하며 뉴런의 작동 방식을 밝혀냈는데, 이 발견이 CNN의 토대가 되었어요.

Local Receptive Field의 발견

뉴런은 시야 전체를 한꺼번에 처리하지 않고, 특정 작은 영역(수용 영역)에만 반응한다는 점이 드러났습니다. 이 영역들이 서로 겹치며 전체 시야를 커버하는 구조가 흥미롭죠.

</center>

계층적 정보 처리

Simple Cell: 직선 같은 단순한 패턴을 감지
Complex Cell: 더 넓은 범위에서 복잡한 패턴을 인식

1970-80년대: 신경망의 기초 다지기

1979년 Kunihiko Fukushima는 이 아이디어를 바탕으로 Neocognitron을 개발했습니다. 여기서 CNN의 핵심 요소인 Convolutional Layer(특징 추출 층)와 Downsampling Layer(정보 압축 층)이 처음 등장했어요.

</center>

1989-1990년대: LeNet의 탄생

Yann LeCun과 그의 팀이 만든 LeNet-5는 CNN을 실용화한 첫 사례입니다. 우편번호 인식에 성공적으로 적용되며, 합성곱 층, 풀링 층, 완전 연결 층으로 이어지는 현대 CNN의 표준 구조를 확립했죠.

</center>

이미지 데이터의 구조

컴퓨터가 이미지를 다루려면 시각 정보를 숫자로 변환해야 합니다

픽셀과 채널

흑백 이미지: 2차원 배열 (가로 × 세로)
- 각 픽셀은 0(검정)에서 255(흰색) 사이의 값을 가짐
컬러 이미지: 3차원 배열 (가로 × 세로 × 채널)
- Red 채널: 빨간색 강도 (0-255)
- Green 채널: 초록색 강도 (0-255)
- Blue 채널: 파란색 강도 (0-255)

채널의 역할

채널은 이미지의 서로 다른 속성을 나타냅니다

흑백 이미지: 1채널 (밝기)
RGB 이미지: 3채널 (빨강, 초록, 파랑)
RGBA 이미지: 4채널 (RGB + 투명도)

</center>

2012년: AlexNet의 혁신

2012년, Alex Krizhevsky, Ilya Sutskever, Geoffrey Hinton이 개발한 AlexNet은 CNN의 전환점을 만들었어요. ImageNet 대회에서 압도적인 성능을 보여주며 주목받았습니다

GPU를 활용한 대규모 학습
ReLU 활성화 함수 도입
Dropout으로 과적합 방지
데이터 증강 기법 활용

2014년 이후: 더욱 깊고 효율적으로

AlexNet의 성공 이후 CNN은 빠르게 발전했습니다

2014년: VGGNet이 더 깊은 네트워크 구조 제시
2014년: GoogLeNet(Inception)이 효율적인 설계 도입
2015년: ResNet이 잔차 학습으로 초심층 네트워크 구현
2017년 이후: MobileNet, EfficientNet 등 가볍고 강력한 모델 출현

저는 이제 개념 정리 및 코드로 찾아뵙겠습니다!

Reference

Convolutional Neural Networks Explained Understanding the receptive field of deep convolutional networks GeeksforGeeks

[DEV] 개발할 때 맨날 발생할 문제, 순환 참조

Sun, 02 Nov 2025 00:00:00 GMT

개발하다보면 어처구니 없는 문제가 종종 발생하곤 합니다. python에서는 조금 많이 발생하는 문제 중 하나가 Cyclic import 문제(다른 이름은 Circular import 문제)입니다.

예를 들기 위해서 클래스 2개를 한번 만들어 볼게요!

# human_a.py

from .human_b import *
class human_a:
    def __init__(self):
        self.b = human_b()
        return


# human_b.py
from .human_a import *
class human_b:
    def __init__(self):
        self.a = human_a()
        return
        
        
# main.py
human = human_b()
print(human.a)

이러면 human = human_b() 여기부터 오류가 날겁니다.(정확히는 이걸 타고 올라가서 import 문에서 오류가 터집니다)

NameError: name 'human_a' is not defined. Did you mean: 'human_b'? 이런 문구가 올라오면서요!

이유는 human_b를 정의하기 위해서 코드로 올라갔더니 human_b를 정의하기 위해서는 human_a라는 친구가 필요했던 겁니다. 그래서 human_a를 먼저 정의하려고 했더니! human_a를 정의하려면 human_b가 필요하네요? 이 상태에 빠지면서 정의가 되지않고 터져버리는거죠.

이러한 문제가 바로 순환 참조의 문제입니다. 이러한 문제를 해결하기 위해서는 Late Import, 아니면 코드 구조 자체를 바꿔버리는 방법도 있긴 합니다.

Late import는 필요할 때 동적으로 그때그때 불러오거나, 아예 다 실행되고나서(이미 사용할 클래스가 정의된 후)에 불러오는 것을 말하고 구조 자체를 바꾼다는건 말 그대로 저런 형태의 코드를 짜지 않는 제일 좋은 상황을 말합니다.

엔진 만들다가 구조 개편하는데 정말 많은 시간을 쏟고 있는 것 같습니다. ㅠㅜㅜㅠ

[DEV] mac에서 tkinter를 사용할 때 주의점!

Sun, 02 Nov 2025 00:00:00 GMT

_tkinter는 python에서 제공하는 GUI 모듈입니다. 그런데 제가 이번에 프로젝트를 진행하면서, 발견한 문제!

아닛ㅅ tkinter가 pip list | grep tkinter가 걸려도 문제가 발생되는 것!

아마 개발하시면 모두 있으실 brew 패키지 매니저에서 tcl-tk을 install 하신 후 환경을 재설치하는게 가장 빠른 방법인 것으로 알게 되었습니다. 일부 환경 변수를 직접 넣어줘도 되긴하는데.. 솔직히 귀찮기도 하고..

그냥 현재 버전에서 pip freeze > requirements.txt 이걸로 남기고 지웠다가 다시 합시다!

저 같은 경우 pyenv를 사용해서 한 버전을 아예 다시 지우고 재설치했더니 작동하는 것을 확인했습니다.

:::note[해결법]

brew install tcl-tk 이후 python 환경을 제거 후 재설치한다.

pip freeze 사용해서 설치된 패키지 리스트라도 빼놓고 하는 것을 추천한다.

:::

필자 환경

Mac Pro(M2 max), Ram 32GB 입니둥.

[DEV] ComPyEngine 5 - Collider 기초

Mon, 03 Nov 2025 00:00:00 GMT

class TestMovement(Component):
    def __init__(self, game_object):
        super().__init__("Test", game_object)

    def update(self, dt):
        if InputManager().get_key(pygame.K_LEFT):
            self.game_object.position[0]-=10
        if InputManager().get_key(pygame.K_RIGHT):
            self.game_object.position[0]+=10
        if InputManager().get_key(pygame.K_UP):
            self.game_object.position[1]-=10
        if InputManager().get_key(pygame.K_DOWN):
            self.game_object.position[1]+=10

    def on_collision_enter(self, other):
        obj = other.game_object

커스텀 컴포넌트를 만들어주고요. 이거를 이제 player 오브젝트에 넣어서 움직이는지 확인해볼겁니다.

또한 완성된 콜라이더가 잘 작동하는지 두 객체에 콜라이더 컴포넌트를 넣어서 작동이 되는지 확인하구요.

이것을 아래 찍은 영상으로 보여드리겠습니다.

</center>

이제는 에디터 패널을 잘 만드는 것으로 다음 목표를 정하고 하겠습니다!

[DEV] ComPyEngine 7 - Collision System

Thu, 06 Nov 2025 00:00:00 GMT

사실 Collision system은 지금 구현에서 object의 rotation도 만들어둔터라 디게 많은 얘기를 해야해서 아예 따로 빼고, 여기는 그냥 개발하면서 뭐가 어려웠는지 등만 말하고 넘어가겠습니다.

일단 충돌 지점까지 알아내는 것은 문제가 없었는데, 이동하는 방향과 어떤 곳에서 그리고 어느정도의 힘으로 들어갔는지를 이를 통해서 튕겨나가는 세기를 조절하는 과정에서 detecting에 약간의 오류가 있었는데 그걸 찾는데 너무 많은 시간을 쏟았습니다.

normal direction이 -로 반대인데 이게 - 곱해지면서 객체들끼리(심지어 한명은 static 시켜놓고 했는데도) 막 엉키더라구요. 그래서 로그 찍어보니까 무슨 방향이 계쏙 왓다갔다 거리는데 처음에는 update 주기에서 각 객체별로 다시 계산하고 횟수가 많아서 이러나? 하고 제한을 뒀을때는 뭔 이상하게 뚝?하고 통과를 해버리질않나. 하튼 그렇게 클로드와 Chat-GPT와 함께 토론을 하며 제 코드가 어디서 이상한 오류를 범했는지 찾아내버렸고!! 그래서 고친 후 잘 작동하게 되었습니다.

블로그 여러개 보면서 어떤 구조가 편할까 생각하는 시간도 오래 걸렸던 것 같네요.

</center>

[DEV] ComPyEngine 3 - Component with SpriteRenderer

Mon, 03 Nov 2025 00:00:00 GMT

이제 좀 눈으로 뭔가를 보고 싶어졌습니다. 그래서 빨리 뭔가 하려고 했는데, 원래 유니티에서도 씬에서 보려면 Renderer를 가진 컴포넌트를 넣어줘야 뭐가 보입니다. 그걸 따라 만들어볼겁니다.

    def render(self, surface, camera):
        if self.sprite is None:
            return

        transform = self.game_object
        screen_x, screen_y = camera.world_to_screen(
            transform.position[0],
            transform.position[1]
        )

        if camera.zoom != 1.0:
            scaled_sprite = pygame.transform.scale(
                self.sprite,
                (
                    int(self.sprite.get_width() * camera.zoom),
                    int(self.sprite.get_height() * camera.zoom)
                )
            )
            sprite_to_render = scaled_sprite
        else:
            sprite_to_render = self.sprite

        if hasattr(transform, 'rotation') and transform.rotation != 0:
            sprite_to_render = pygame.transform.rotate(sprite_to_render, transform.rotation)

        if hasattr(transform, 'scale') and transform.scale != (1, 1):
            sprite_to_render = pygame.transform.scale(
                sprite_to_render,
                (
                    int(sprite_to_render.get_width() * transform.scale[0]),
                    int(sprite_to_render.get_height() * transform.scale[1])
                )
            )

        rect = sprite_to_render.get_rect(center=(screen_x, screen_y))

        if not surface.get_rect().colliderect(rect):
            return

        if self.color != (255, 255, 255):
            tinted_sprite = sprite_to_render.copy()
            tinted_sprite.fill(self.color, special_flags=pygame.BLEND_MULT)
            surface.blit(tinted_sprite, rect)
        else:
            surface.blit(sprite_to_render, rect)

위 코드처럼 랜더링을 때릴건데, 잘 작동하는지는 모르겠지만, 일단 기본적인 줌 상태가 아닌거는 잘 작동하니까 놔두고 있습니다.

    def load_image(self, path):
        tmp = EngineManager().load_game_image(path)
        self.sprite = tmp

파일 매니저에서 가지고 있는 Image를 불러와서 sprite를 가져옵니다. 모든 오류에 대해서 핸들링을 하도록 노력했고, try문을 안 사용하는 것을 지향햇습니다.

BaseRenderer를 상속한 SpriteRenderer를 이제 컴포넌트 시스템에 넣어서 이제 잘 작동하는지 확인하기 위해서 이제 기본적인 Rendering 시스템이 필요하겠네요! 설렙니다. 이제 곧 제 눈 앞에 오브젝트가 움직이는 것을 볼 수 있겠군요.

# print("Component")
class Component:
    def __init__(self, name, game_object):
        self.game_object = game_object
        self.name = name
        self.enabled = True

    def update(self, dt):

        # fixed update까지는 필요도하지 않을 것으로 보인단 말이지.
        pass

</details>

[DEV] ComPyEngine 2 - Core(Scene, Camera, GameObject)

Mon, 03 Nov 2025 00:00:00 GMT

일단 게임 오브젝트가 기본적으로 있어야되고, 이 오브젝트에 여러가지 컴포넌트를 넣어서 꾸밀 수 있도록 하려고 합니다.

게임 오브젝트는 기본적인 자신의 위치와 로테이션, 크기 및 이름 등을 가지게 될 것이구요. 그외 여러가지 유틸리티를 넣으면 되겠습니다.

씬은 조금 복잡한데, 어디까지 이 친구의 역할을 잡아줘야하는지 감이 잘 안 잡히더라구요. 일단 한 씬에서 사용되는 리소스가 있으니, 캐싱하는 것을 씬한테 맡기려고하고 씬 안에 있는 object를 여기서 다루려고 합니다. 저장과 불러오기 기능이 있어야하는데, 이것은 추후에 추가하기로 하고 일단 작동 시키는 것부터 시작해봅시다.

카메라는 어떤 위치에서 어느정도의 크기를 찍고 있는지 정도만 가지고 있으면 되겠습니다.

게임 매니저가 필요해서 데코레이터로 싱글톤 클래스도 조금 만들어주었고, 매니저는 뭐 아시죠? 대충 처리 힘든거 다 때려박을겁니다.

$$\text{[그림 1] File 구조}$$

</center>

결국 이렇게 완성되었고, 나중에 editor view 완성되면 나오는게 궁금하네요. 빨리 구현하러 가봐야겠습니다.

먼저 코드는 조금 많이 진행이 되었는데, 구조에서 조금 많이 발전해서 Editor Window와 panel별로 위치 잡아서 랜더링 시스템은 기본적으로 구현했구요.

Scene 시스템으로

[DEV] ComPyEngine 6 - 인스팩터, 하이어라키 패널을 완성해보자

Wed, 05 Nov 2025 00:00:00 GMT

$$\text{[그림 1] 스크린샷}$$

</center>

왼쪽이 하이어라키고, 오른쪽이 인스팩터 그리고 가운데가 씬입니다. 이때 하이어라키 창에서 어떤 오브젝트를 클릭하면, 인스팩터 창이랑 연동이 되어야하며 또 그냥 씬 창에서 오브젝트를 클릭해도 연동이 되도록 만들었습니다.

한 윈도우에서 선택된 오브젝트는 하나라는 것을 알고 잇기에, 그냥 윈도우를 관리하는 놈한테 selected object 박고서 처리했습니다.

정확히 작동하는 방식은 아래의 영상과 같이 작동합니다.

</center>

[DEV] ComPyEngine 8 - 프로젝트 패널을 완성해보자

Thu, 06 Nov 2025 00:00:00 GMT

$$\text{[그림 1] 스크린샷}$$

</center>

말 그대로 프로젝트 창을 만들어봤습니다. 이미지는 vector icon으로 google에 검색하면 나오는 그 v자 사이트에서 가져왓구요(좋아하는 사이트임)

폴더를 들어갈 수도 있습니다. 이미지의 경우는 특별하게 미리보기가 가능한데, 이때 사이즈 및 세부사항을 확인 가능합니다.

</center>

[DEV] ComPyEngine 4 - Renderer 기초

Mon, 03 Nov 2025 00:00:00 GMT

Component 쪽에서 SpriteRenderer의 대충의 작동 원리를 공개했기 때문에, 그것을 토대로 어떻게 작동하는지 대강 설명드리겠습니다.

랜더러 매니저를 따로 분리시켜놧는데, 게임 메인 루프에서 현재 올라와있는 Scene의 오브젝트 중 Renderer를 포함하는 오브젝트한테 랜더링을 시키는 작업을 진행합니다.

EditorWindow라고 아예 큰 window를 생성하고, 이 안에 pygame_gui를 통해서 Panel을 생성해 그 안을 잘게 쪼개서 유니티 에디터처럼 만들 준비를 진행합니다.

결국 그것을 이용해 완성된 그림은!!!

이미지는

scene = Scene("Level1")

player = GameObject("Player")
player.position = [100, 100]

player.add_component(TestMovement)
player.add_component(BoxCollider)
sprite = player.add_component(SpriteRenderer)
sprite.load_image("./Resources/test.png")

이런 식으로 컴포넌트 넣고, sprite도 넣을 수 있습니다.

$$\text{[그림 1] 초기 버전}$$

</center>

이렇게 말이죠!!

다음에는 영상으로 어떻게 작동하는지 찾아오겠씁니다.

[DEV] ComPyEngine 9 - Scene을 저장하고, 불러오기!

Thu, 06 Nov 2025 00:00:00 GMT

유니티에서 씬 시스템을 그대로 가져온다...

"이걸 구현하기 위해서는 일단 씬을 저장하는 것부터 해야됩니다. 유니티처럼 그럼 직렬화를 시켜볼까요?" 이 말이 참 밉습니다.

이 직렬화라는게 아무 생각없이 코드를 짠다면 진짜 정말 힘든 여정이 되버리더군요. 이번에는 오히려 구조 생각하는데 제일 공을 많이 들인거 같은데요.

무튼 그뿐만 아니라 여러가지 데이터타입 들어오는거 생각해서 확장 고려해 작성하다보니 중간중간 멈칫거리고, 다시 짜고 무한 반복이었습니다. 또 완성해서 기분 좋게 다른거 하다가 중간에 또 터지면 문제 생기고 그리고 우선순위 관련해서 실행 순서가 엄청 중용한 부분이 있었는데 __new__ (이거 객체 미리 생성해놓고 attr 삽입할 때) 그거 고치는데도 좀 고생한 기억이 있네요.

하튼 그러고 이제 다시 풀고 뭐 하는것도 문제가 많았지만 결국 해냈지 않습니꽈! 아래 영상에서 그 구현된 상태를 보시죠

(컴포넌트, 오브젝트 따로 빼서 넣고 등 힘드러따)

</center>

[DEV] ComPyEngine 개발의 시작!

Sat, 01 Nov 2025 00:00:00 GMT

제가 python으로 강화학습을 게임으로 돌리려고 하니까 솔직히... 제가 직접 만든 게임을 돌리고 싶은데, 이미 있는 환경에서 개발하니 재미가 떨어지기 시작했습니다. 그래서! 강화학습용 게임을 쉽게 제작할 수 있는 게임 엔진(에디터)를 만들어서 배포하자!라는 생각으로 시작합니다.

python 기반 게임 엔진 ComPyEngine!

먼저 File 구조는 Unity를 따라 만들어보기 위해서 제 나름대로 분리해서 작성했습니다.

$$\text{[그림 1] File 구조}$$

</center>

이러한 구조에서 이제 Rendering system, component system 등을 구축하고, 유니티 에디터처럼 멋있는 것을 만들어보도록 하겠습니다.

[RL] Q-Learning 이론

Tue, 07 Oct 2025 00:00:00 GMT

Q-Learning의 배경

1980년대 후반, 강화학습 연구에서 가장 큰 도전으로는 "환경 모델을 모르는 상황에서도 최적 정책을 학습하는 것"이였습니다. 이때까지만해도 사용되던 알고리즘이 Dynamic Programming(이하 DP)였는데, 이 DP는 전이 확률과 보상 함수가 완전히 알려진 경우에만 사용이 가능해서 실제 문제에 적용하기가 어려웠습니다.

그래서 이러한 한계를 극복하기 위해서 model-free 알고리즘인 Q-learning을 개발하였습니다. 이 Q-learning은 model-free 강화학습의 가장 기초이며 핵심이 되는 알고리즘이 된답니다.

Q-learning 아이디어

환경 모델이 없는 상태에서 최적 정책을 학습할 수 있도록 하는 것이 아이디어입니다. 기존 DP에서 $$ P(s’|s,a) $$ 와 보상 함수 R(s, a)를 필요로 했다면, Q-learning은 실제 경 (s, a, r, s’)만으로 Q-value를 업데이트합니다.

그래서 Q-learning의 핵심은 행동-가치 함수 Q(s, a)를 직접 학습하는 것입니다. 이제부터 이 함수를 Q함수라고 부르겠습니다.

이 Q함수는 상태 s에서 행동 a를 취한 후 최적 정책을 따를 때의 기대 누적 보을 나타냅니다.

$$Q^(s,a) = R(s,a) + \gamma \sum_{s'} P(s'|s,a) \max_{a'} Q^(s',a')$$

$$\text{벨만 최적 방정식}$$

</center>

수식에 대해서 조금 더 설명을 더해보자면, $$P(s'|s,a)$$은 전이확률로 상태 s에서 행동 a를 했을 때, 상태 s`가 될 확률을 말합니다. $$\max_{a'} Q^*(s',a')$$는 다음으로 될 상태 $$s'$$에서 선택할 수 있는 행동 중에 가장 높은 Q-value를 의미합니다.

그래서 $$\sum_{s'} P(s'|s,a) \max_{a'} Q^*(s',a')$$ 이 부분은 다음 상태에서 얻을 수 있는 최적 가치의 기댓값으로 다음 상태에서 최선의 선택을 할 때 얻을 가치들의 확률적 평균으로 생각하면 되겠습니다.

즉, 벨만 최적 방정식은 Q-value를 계산하는 수식으로 $$R(s,a)\text{(현재 즉시 제공되는 보상)}$$과 $$\gamma\text{(할인 인자, discount factor)}$$가 곱해진 미래 가치 기댓값과의 합을 의미합니다.

Q-learning의 업데이트 규칙은 벨만 방정식과 시간차 학습(Temporal Difference Learning)을 기반으로 합니다. 조금 더 자세히 들어가자면, Q-learning의 업데이트 규칙은 벨만 최적 방정식의 해를 찾기 위해 시간차 학습을 활용하고, 매 스탭마다 TD error를 계산, Q-value를 업데이트 해갑니다. 이를 통해서 벨만 최적 방정식을 근사합니다.

$$Q(s,a) \leftarrow Q(s,a) + \alpha\left[r + \gamma \max_{a'} Q(s',a') - Q(s,a)\right]$$

$$\text{Q-Learning 업데이트 규칙}$$

</center>

업데이트 규칙에서는 $$\alpha$$는 학습률,$$r$$은 관찰된 즉시 보상,$$\gamma$$는 할인 인자이고, 대괄호 안의 항은 시간차 오차(TD Error)로, 현재 추정값과 실제 경험 사이의 차이를 나타냅니다.

Q-learning 특징

1. off-policy 학습 가능

off-policy 학습이 가능하다는 소리는 무슨 소리냐? 학습하려는 목표 정책과 실제 행동을 정하는 행동 정책이 다를 수 있음을 말합니다.

좀 더 자세히 설명하자면, Q-learning은 $$\epsilon$$-greedy와 같은 탐험적 정책을 사용해 데이터를 수집하면서도, greedy 정책에 대한 Q-value를 학습할 수 있다는 의미입니다.

2. 수렴성 조건

먼저 수렴성을 조사하기 위해서 학습률 조건을 따져봐야합니다.

상태-행동 쌍에 대한 학습률의 총합은 무한대로 발산하며, 학습률 제곱의 총합은 윤한한 값으로 수렴해야됩니다.
모든 상태에서 모든 가능한 행동을 마훈히 반복적으로 경험해야됩니다.
Q-value는 개별적인 상태-행동 쌍에 대해 테이블 형태(look-up table)로 표현 가능해야합니다.

이정도가 있고요. 자세한 설명과 수식을 보고 싶으시면 아래 reference에 survey를 참고해주세요. 하튼 그리하여 이러한 조건 하에서 Q-learning은 확률 1로 최적 Q-function로 수렴합니다.

3. 탐험 전략

보통 예제나 많이 사용되는 알고리즘으로 꼽히는게 $$\epsilon$$-greedy입니다.

ε-greedy 정책: 확률 ε로 무작위 행동을, (1-ε)로 탐욕적 행동을 선택하는 알고리즘

$$ \pi(a|s) = \begin{cases} 1-\epsilon + \frac{\epsilon}{|A|} & \text{if } a = \arg\max_{a'} Q(s,a') \ \frac{\epsilon}{|A|} & \text{otherwise} \end{cases} $$

</center>

식으로는 위와 같이 표현 가능합니다.

그 외 정책들을 보고 싶으시면 똑같이 reference에서 survey를 참고해주세요.

4. 한계

한계로는 확장성 문제, 연속 공간의 한계, 샘플 효율성, 수렴 속도 문제가 있습니다.

확장성 문제: 상태 공간과 행동 공간이 클 경우 Q-table의 크기가 기하급수적으로 증가하여 메모리와 계산 시간 측면에서 실용적이지 않음
연속 공간의 한계: 연속적인 상태나 행동 공간에서는 Q-table 표현 자체가 불가능하여 함수 근사가 필수적
샘플 효율성: 모든 상태-행동 쌍을 충분히 탐험해야 하므로 샘플 효율성이 낮음
수렴 속도 문제: 이론적으로는 수렴이 보장되지만, 큰 상태 공간에서는 실용적인 시간 내에 수렴하지 않을 수 있음

이렇게 정리할 수 있겠습니다.

Reference

[1] J. H. Lee (compy), "Reinforcement Learning: A Survey," compy's Blog, Aug. 10, 2025. [Online]. Available: URL

[2] C. J. C. H. Watkins and P. Dayan, "Technical Note: Q-Learning," Machine Learning, vol. 8, no. 3, pp. 279-292, May 1992, doi: 10.1023/A:1022676722315.

[RL] Q-Learning 구현

Wed, 08 Oct 2025 00:00:00 GMT

Q-Learning의 기초적인 설명은 여기에서 확인할 수 있습니다.

Q-learning에 대해서 배워봤으니, 이제 눈과 코드로 어떻게 된건지 볼 차례입니다. 예제부터 쭉 한번 작성해봅시다.

먼저 Q-learning으로 저는 maze를 탈출하는 방법을 가르쳐볼겁니다.

일단 먼저 시각화를 하기 위해서 pygame으로 틀을 짜볼까요??

class Grid:

    def __init__(self, x: int, y: int, grid_type: str = "basic",
                 text: str = "", color: tuple = (255, 255, 255)):
        self.x = x
        self.y = y
        self.grid_type = grid_type
        self.text = text
        self.color = color

        return


    def __str__(self):
        return f"현재 위치 ({self.x}, {self.y}) [{self.color}]"

하나의 격자 블럭을 이렇게 정의해봅시다.

이거를 Block처럼 하나씩 쌓아서 Board라는 클래스로 미로를 한번 만들어봅시다. 위에서 설명한 Q-learning처럼 너무 큰 상태 공간은 정말 말도 안되게 학습 오래 걸리기 때문에 5*5로 해봅시다.

<details> <summary> Board Class </summary>

class Board:
    def __init__(self, width: int, height: int, block_size: int):
        pygame.init()
        pygame.font.init()

        self.width = width
        self.height = height

        self.font = pygame.font.SysFont('Arial', 30)

        self.board = [[Grid(x, y) for x in range(width)] for y in range(height)]
        self.block_size = block_size
        self.padding = 20

        self.background = (255, 255, 255)

        # pygame section
        self.screen = pygame.display.set_mode(
            (block_size * width + self.padding * 2, block_size * height + self.padding * 2))

        self.update()
        return

    def set_grid(self, new: Grid):
        self.board[new.y][new.x] = new
        return

    def update(self):
        self.screen.fill(self.background)

        for y in range(self.height):
            for x in range(self.width):
                self.grid_update(x, y)

        self.draw_grid_lines()

        pygame.display.flip()
        # pygame.display.update()

        return

    def draw_grid_lines(self):
        line_color = (0, 0, 0)
        line_width = 1

        for x in range(self.width + 1):
            start_pos = (self.padding + x * self.block_size, self.padding)
            end_pos = (self.padding + x * self.block_size,
                       self.padding + self.height * self.block_size)
            pygame.draw.line(self.screen, line_color, start_pos, end_pos, line_width)

        for y in range(self.height + 1):
            start_pos = (self.padding, self.padding + y * self.block_size)
            end_pos = (self.padding + self.width * self.block_size,
                       self.padding + y * self.block_size)
            pygame.draw.line(self.screen, line_color, start_pos, end_pos, line_width)
        return

    def grid_update(self, x: int, y: int):
        block = self.board[y][x]
        if block is None: return
        # print(x, y, block)
        rect = pygame.draw.rect(self.screen, block.color,
                                (
                                    self.padding + x * self.block_size, self.padding + y * self.block_size,
                                    self.block_size,
                                    self.block_size))

        text = self.font.render(block.text, True, (255, 255, 255))
        text_rect = text.get_rect()
        text_rect.center = (self.padding + x * self.block_size + self.block_size // 2,
                            self.padding + y * self.block_size + self.block_size // 2)
        self.screen.blit(text, text_rect)

        return

    def valid_position(self, y, x):
        if 0 <= y < self.height and 0 <= x < self.width:
            return self.board[y][x].grid_type != "wall"
        return False

    def __copy__(self):
        result = Board(self.width, self.height, self.block_size)

        for y in range(self.height):
            for x in range(self.width):
                result.set_grid(self.board[y][x])
        return result

</details>

일단 위와 같이 클래스 Board를 만들고, 이걸 통해서 시각화를 진행해 봅시다.

간단한 maze를 만들어 보았습니다. 아래의 코드를 실행시키면!

from CompyGrid import *
from Algorithm import *
import pygame


def initialize() -> Board:
    x = 5
    y = 5

    board = Board(x, y, 150)

    maze = [
        [1, 1, 1, 0, 0],
        [1, 0, 1, 1, 0],
        [1, 1, 0, 1, 1],
        [1, 0, 0, 1, 0],
        [1, 1, 1, 1, 1]
    ]

    for i in range(y):
        for j in range(x):
            state = maze[i][j]

            block = Grid(j, i, "empty" if state else "wall", str(state), (0, 170, 200) if state else (175, 0, 0))
            board.set_grid(block)


    return board



board = initialize()
board.update()

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            break;

</details>

maze = [
        [1, 1, 1, 0, 0],
        [1, 0, 1, 1, 0],
        [1, 1, 0, 1, 1],
        [1, 0, 0, 1, 0],
        [1, 1, 1, 1, 1]
    ]

처럼 나오게 됩니다.

일단 Q-learning으로 진짜되나? 얼마나 잘 되는 것일까?를 보기 위해서 bruteforce 즉 랜덤으로 탈출하는 알고리즘을 작성해서 비교해봅시다!

<details> <summary> Bruteforce 알고리즘</summary>


import pygame
import random
import imageio
from CompyGrid.Grid import Grid


class Bruteforce:
    def __init__(self, output_path="bruteforce_path"):
        self.output_path= output_path
        pass

    def bruteforce_escape(self, board, max_steps=100000, record=True):
        agent_pos = [0, 0]
        goal_pos = [board.width - 1, board.height - 1]
        steps = 0
        path = [agent_pos.copy()]

        clock = pygame.time.Clock()

        while agent_pos != goal_pos and steps < max_steps:
            action = random.randint(0, 3)  # 0=right, 1=left, 2=down, 3=up

            x, y = agent_pos[0], agent_pos[1]
            new_x, new_y = x, y

            if action == 0:  # right
                new_x = x + 1
            elif action == 1:  # left
                new_x = x - 1
            elif action == 2:  # down
                new_y = y + 1
            elif action == 3:  # up
                new_y = y - 1

            if board.valid_position(new_y, new_x):
                agent_pos = [new_x, new_y]
                path.append(agent_pos.copy())

            steps += 1

            if steps % 10 == 0:
                board.screen.fill(board.background)

                for grid_y in range(board.height):
                    for grid_x in range(board.width):
                        board.grid_update(grid_x, grid_y)

                pre = board.board[agent_pos[1]][agent_pos[0]]


                agent_grid = Grid(agent_pos[0], agent_pos[1],
                                  text="B", color=(255, 165, 0))
                board.set_grid(agent_grid)
                board.grid_update(agent_pos[0], agent_pos[1])

                goal_grid = Grid(goal_pos[0], goal_pos[1],
                                 grid_type="goal",
                                 text="G", color=(0, 255, 0))
                board.set_grid(goal_grid)
                board.grid_update(goal_pos[0], goal_pos[1])

                font = pygame.font.SysFont('Arial', 20)
                text = font.render(f"Brute-force | Steps: {steps}", True, (255, 255, 255))
                board.screen.blit(text, (10, 10))

                pygame.display.flip()
                clock.tick(60)
                board.set_grid(pre)
                for event in pygame.event.get():
                    if event.type == pygame.QUIT:
                        return steps, path
            print(agent_pos, goal_pos)

        if agent_pos == goal_pos:
            print(f"Bruteforce: 총 {steps} 스텝")
        else:
            print(f"Bruteforce 실패")

        if record and agent_pos == goal_pos:
            self.save_path_as_gif(board, path, goal_pos, f"{self.output_path}.gif", fps=30)

        return steps, path

    def save_path_as_gif(self, board, path, goal_pos, filename, fps=10):
        frames = []

        sample_rate = max(1, len(path) // 1000)
        sampled_path = path[::sample_rate]

        print(f"총 {len(path)} 스텝 중 {len(sampled_path)} 프레임 녹화...")

        for i, pos in enumerate(sampled_path):
            board.screen.fill(board.background)

            for y in range(board.height):
                for x in range(board.width):
                    board.grid_update(x, y)

            for j in range(max(0, i - 50), i):
                if j < len(sampled_path):
                    trail_pos = sampled_path[j]
                    trail_grid = Grid(trail_pos[0], trail_pos[1],
                                      grid_type="trail",
                                      text="", color=(200, 200, 100))
                    board.set_grid(trail_grid)
                    board.grid_update(trail_pos[0], trail_pos[1])

            agent_grid = Grid(pos[0], pos[1],
                              grid_type="agent",
                              text="B", color=(255, 165, 0))
            board.set_grid(agent_grid)
            board.grid_update(pos[0], pos[1])

            goal_grid = Grid(goal_pos[0], goal_pos[1],
                             grid_type="goal",
                             text="G", color=(0, 255, 0))
            board.set_grid(goal_grid)
            board.grid_update(goal_pos[0], goal_pos[1])

            font = pygame.font.SysFont('Arial', 30)
            original_step = i * sample_rate
            text = font.render(f"Brute-force | Step: {original_step}/{len(path)}",
                               True, (255, 255, 255))
            board.screen.blit(text, (10, 10))

            pygame.display.flip()

            frame = pygame.surfarray.array3d(board.screen)
            frame = frame.transpose([1, 0, 2])
            frames.append(frame)

        duration = 1000 / fps
        imageio.mimsave(filename, frames, duration=duration, loop=0)

</details>

이렇게 작성하여서, gif로 어떻게 되었는지 결과도 볼 수 있게 만들어봤습니다.

이제 Q-learning을 작성해봅시다!

import copy
import pygame
from CompyGrid.Grid import Grid
import os
from PIL import Image
import imageio

import numpy as np


class QLearning:

    def __init__(self, n_states, n_actions, learning_rate=0.1, discount_factor=0.9, epsilon=0.2):
        """
        n_states: 상태의 개수
        n_actions: 행동의 개수
        learning_rate: 학습률 (alpha)
        discount_factor: 할인율 (gamma)
        epsilon: 탐험 확률 (epsilon-greedy)
        """

        self.n_states = n_states
        self.n_actions = n_actions
        self.lr = learning_rate
        self.gamma = discount_factor
        self.epsilon = epsilon

        self.q_table = np.zeros((n_states, n_actions))  # (상태 * 행동)



        self.directions = ["right", "left", "down", "up"]

        return

    def get_action(self, state):  # epsilon greedy로 탐험과 활용
        if np.random.random() < self.epsilon:
            return np.random.randint(0, self.n_actions)
        else:
            return np.argmax(self.q_table[state, :])
    def update_q_table(self, state, action, reward, next_state):
        """
        Q-table (Q-Learning의 핵심입니다)

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

        state: 현재 상태
        action: 수행한 행동
        reward: 받은 보상
        next_state: 다음 상태
        """
        # Q-Learning 업데이트 공식
        # Q(s,a) = Q(s,a) + α[r + γ*max(Q(s',a')) - Q(s,a)]

        current_q = self.q_table[state, action]
        max_next_q = np.max(self.q_table[next_state, :])

        new_q = current_q + self.lr * (reward + self.gamma * max_next_q - current_q)
        self.q_table[state, action] = new_q

    def theta_to_pi(self, theta):  # 현재 행동 확률 분포 반환
        # Softmax 함수 적용
        exp_theta = np.exp(theta)
        pi = exp_theta / np.sum(exp_theta, axis=1, keepdims=True)
        return pi
    def get_policy(self):  # 행동 반환해주는거 argmax Q(s, a)
        return np.argmax(self.q_table, axis=1)

    def train(self, board, episodes=1000, render_interval=100):
        for episode in range(episodes):
            agent_pos = [0, 0]
            goal_pos = [board.width - 1, board.height - 1]
            state = agent_pos[1] * board.width + agent_pos[0]

            done = False
            total_reward = 0
            steps = 0
            max_steps = board.width * board.height * 4
            path = [agent_pos.copy()] if render_interval > 0 and episode % render_interval == 0 else None

            while not done and steps < max_steps:
                action = self.get_action(state)


                x, y = agent_pos[0], agent_pos[1]
                new_x, new_y = x, y

                if action == 0:  # right
                    new_x = x + 1
                elif action == 1:  # left
                    new_x = x - 1
                elif action == 2:  # down
                    new_y = y + 1
                elif action == 3:  # up
                    new_y = y - 1


                if board.valid_position(new_y, new_x):
                    agent_pos = [new_x, new_y]
                    reward = 0
                else:
                    reward = 0

                next_state = agent_pos[1] * board.width + agent_pos[0]


                if agent_pos == goal_pos:
                    reward = 10
                    done = True


                self.update_q_table(state, action, reward, next_state)

                state = next_state
                total_reward += reward
                steps += 1


                if path is not None:
                    path.append(agent_pos.copy())


            if path is not None:
                self._render_path(board, path, goal_pos)

            if (episode + 1) % 100 == 0:
                print(f"Episode {episode + 1}/{episodes}, "
                      f"Total Reward: {total_reward:.2f}, "
                      f"Steps: {steps}")

        return self.q_table



    def _render_path(self, board, path, goal_pos):
        for i, pos in enumerate(path):
            board.screen.fill(board.background)
            for y in range(board.height):
                for x in range(board.width):
                    board.grid_update(x, y)
            for prev_pos in path[:i]:
                trail_grid = Grid(prev_pos[0], prev_pos[1],
                                  grid_type="trail",
                                  text="", color=(150, 150, 255))
                board.set_grid(trail_grid)
                board.grid_update(prev_pos[0], prev_pos[1])


            agent_grid = Grid(pos[0], pos[1],
                              grid_type="agent",
                              text="A", color=(255, 0, 0))
            board.set_grid(agent_grid)
            board.grid_update(pos[0], pos[1])


            goal_grid = Grid(goal_pos[0], goal_pos[1],
                             grid_type="goal",
                             text="G", color=(0, 255, 0))
            board.set_grid(goal_grid)
            board.grid_update(goal_pos[0], goal_pos[1])

            pygame.display.flip()
            pygame.time.wait(100)

    def record_episode(self, board, output_path="agent_path", format="gif", fps=10):
        frames = []
        agent_pos = [0, 0]
        goal_pos = [board.width - 1, board.height - 1]
        state = agent_pos[1] * board.width + agent_pos[0]

        done = False
        steps = 0
        max_steps = board.width * board.height * 4
        path = [agent_pos.copy()]
        while not done and steps < max_steps:
            action = int(self.get_policy()[state])

            x, y = agent_pos[0], agent_pos[1]
            new_x, new_y = x, y

            if action == 0:  # right
                new_x = x + 1
            elif action == 1:  # left
                new_x = x - 1
            elif action == 2:  # down
                new_y = y + 1
            elif action == 3:  # up
                new_y = y - 1

            if board.valid_position(new_y, new_x):
                agent_pos = [new_x, new_y]
                path.append(agent_pos.copy())

            next_state = agent_pos[1] * board.width + agent_pos[0]
            done = (agent_pos == goal_pos)
            state = next_state
            steps += 1

        for i, pos in enumerate(path):
            board.screen.fill(board.background)
            for y in range(board.height):
                for x in range(board.width):
                    board.grid_update(x, y)


            for prev_pos in path[:i]:
                trail_grid = Grid(prev_pos[0], prev_pos[1],
                                  grid_type="trail",
                                  text="", color=(150, 150, 255))
                board.set_grid(trail_grid)
                board.grid_update(prev_pos[0], prev_pos[1])


            agent_grid = Grid(pos[0], pos[1],
                              grid_type="agent",
                              text="A", color=(255, 0, 0))
            board.set_grid(agent_grid)
            board.grid_update(pos[0], pos[1])


            goal_grid = Grid(goal_pos[0], goal_pos[1],
                             grid_type="goal",
                             text="G", color=(0, 255, 0))
            board.set_grid(goal_grid)
            board.grid_update(goal_pos[0], goal_pos[1])

            pygame.display.flip()


            frame = pygame.surfarray.array3d(board.screen)
            frame = frame.transpose([1, 0, 2])
            frames.append(frame)


        if format == "gif":
            self._save_as_gif(frames, f"{output_path}.gif", fps)
        return len(path)
    def _save_as_gif(self, frames, filepath, fps):
        duration = 1000 / fps  # ms
        imageio.mimsave(filepath, frames, duration=duration, loop=0)

사실 블로그에 이론적 설명은 전 포스트에서 했었고, 여기서 또 설명하기 보다는 코드에 조금 설명을 적어 놓았습니다.

이 흐름대로 쭉 보시면 이해하기 편할 것이라 생각했구요. 시각화 코드는 그냥 무시하셔도 전혀 지장이 없습니다. 왜냐면.. 코드가 좋지 않아요 ㅠ 그냥 어떻게든 시각화하고, 결과 뽑으려고 짠 코드라 그렇게 좋은 코드는 아닌것 같습니다.

하튼 이렇게 완성된 코드를 가지고 이제 main에 가져와서 둘 다 결과를 뽑아봅시다.

from CompyGrid import *
from Algorithm import *
import pygame


def initialize() -> Board:
    x = 5
    y = 5

    board = Board(x, y, 150)

    maze = [
        [1, 1, 1, 0, 0],
        [1, 0, 1, 1, 0],
        [1, 1, 0, 1, 1],
        [1, 0, 0, 1, 0],
        [1, 1, 1, 1, 1]
    ]

    for i in range(y):
        for j in range(x):
            state = maze[i][j]

            block = Grid(j, i, "empty" if state else "wall", str(state), (0, 170, 200) if state else (175, 0, 0))
            board.set_grid(block)


    return board



board = initialize()
board.update()


bruteforce = Bruteforce()
bruteforce_steps, bruteforce_path = bruteforce.bruteforce_escape(
    board, max_steps=100000, record=True
)

board = initialize()
board.update()
n_states = 5 * 5
n_actions = 4
q_learning = QLearning(n_states, n_actions,
                       learning_rate=0.1,
                       discount_factor=0.95,
                       epsilon=0.15)

q_learning.train(board, episodes=10000, render_interval=0)
q_learning.record_episode(board, "qlearning_path", format="gif", fps=5)

이렇게 실행을 시켜보면?!

어떤 결과가 나올까요?

먼저 브포의 결과를 살펴보겠습니다.

이렇게 총 129 step을 밟아서 도착점에 도달했습니다. 음.. 정말 비효율적으로 도착했구요.

이제는 Q-learning은 어떻게 했는지.. (학습은 코드와 같이 10000번 시켜서 다 보여주긴 힘들고, 마지막으로 학습된 상태에 어떻게 길을 찾았나만 보도록 하겠습니다.)

자 그럼 결과를 보도록 하겠습니다.

총 8 step만에 도착했습니다.

그래서 결과적으로 이런 결과가 나왔는데용?

알고리즘	소요 Step
Bruteforce	129
Q-Learning	8

이렇게 Q-learning이 어떻게 동작하는지(코드로) 알아보았고요, 그 결과를 bruteforce와 비교해보았습니다.

하지만 저번 포스팅에서도 말했지만, 이 board의 크기가 조금만 커져도 적용이 힘들다는 큰 단점이 존재하구요..

현재 코드에서 되게 비효율적인 부분이 있을겁니다. 혼자 고쳐보셔도 되고, 아니면 아래 detail 열어서 확인해보시면 좋겠습니다.

<details> <summary> 비효율적인 부분 </summary>

                if board.valid_position(new_y, new_x):
                    agent_pos = [new_x, new_y]
                    reward = 0
                else:
                    reward = 0

                next_state = agent_pos[1] * board.width + agent_pos[0]


                if agent_pos == goal_pos:
                    reward = 10
                    done = True

지금보면, 이동이 불가능한 곳에 갔을 때 -1을 주고, 이동가능하면 +1을 주고 도착하면 엄청 큰 보상을 주면 더욱 빠르게 학습하겠죠?

하지만 저는 그렇게 작성하지 않았습니다. 왜 그럴까요? Q-learning이 처음 도입되었을 때는 이론적으로 목표에 도달을 해야지, 그 목표에 대한 가치가 역으로 전파되면서 $$\text{discount factor}^(n-1) * \text{reward}$$로 전파되면서 가치가 업데이트 됩니다. 그걸 정확히 구현하기 위해서 저렇게 했는데요. 저게 사실 조금만 생각해도 문제가 많아 보입니다. 애초에 목표에 도달을 못하면 Q table이 업데이트가 안돼요. 즉, 목표에 도달하지 못하면 Q-table에 의미있는 업데이트가 발생하지 않습니다. 또 이상한 뻘짓하다가 결국에는 목표에 도달했는데, Q-learning에서는 그러한 뻘짓도 좋은거로 착각하는 문제도 있습니다.

이런 문제들을 우리는

희소 보상 문제 (Sparse Reward Problem): 보상이 드물게 주어져 학습 신호가 부족한 문제
신용 할당 문제 (Credit Assignment Problem): 어떤 과거 행동이 현재 보상에 기여했는지 판단하기 어려운 문제

라고 합니다.

그래서 즉각적 보상을 주는 것으로 더 빨리 학습시킬 수 있는 방법이 있는 겁니당. 이게 현대에는 거의 당연시되게 적용되구요.

</details>

[Algorithm] A* 알고리즘

Sat, 06 Jul 2024 00:00:00 GMT

다익스트라 알고리즘보다 더 빠른거... 뭐 더 없을까??? 바로 A*(에이스타)라는 알고리즘이 있다. 사실상 길찾기 알고리즘하면 제일 먼저 떠오르는 친구가 아닐까 싶다. 굉장히 유명하면서, 실제로도 많이쓰고 있다. 정말 놀랍게도 Unity 엔진에서 쓰는 NavMesh 또한 A* 기반으로 동작한다. 오래전에 만들어졌지만 아직까지도 많이 사용되고 있는 알고리즘인 만큼 배워두는 것은 좋을 것이다.

:::note[이 포스팅에서는]

이 포스팅에서는 전적으로 A* 자체에 대해서만 자세히 다루고 있습니다.

A*를 설명하기 위한 다른 개념들 Heuristic(휴리스틱), PriorityQueue(우선순위 큐) 등의 설명은 생략하고 있습니다.

다른 개념의 설명은 다른 포스팅에 있습니다. 따로 참고해주세요!

:::

이제 A* 대해서 알아보도록 하자 먼저 A*의 특징과 더불어 다른 길찾기 알고리즘들과의 차이점을 찾아보자.

	BFS	Dijkstra	A*
팀섹 그래프 형태	가중치 X	가중치 그래프	가중치 그래프
기반 알고리즘	BruteForce(완전탐색)	Greedy(탐욕)	Greedy(탐욕)
특징	시작 노드를 기준으로 모든 노드의 최단 경로 탐색	시작 노드를 기준으로 모든 노드의 최단 경로 탐색	시작 노드에서 목표 노드까지의 최단 경로만을 구함

:::tip[질문]

표를 보니 다익스트라와 A* 비슷하던데?

시작 노드를 기점으로 모든 노드의 최단 경로를 탐색한다면 다익스트라가 A*보다 더 좋은 것 아닌가요?

:::

이러한 질문이 자연스럽게 생길 것이다. 이것은 일단 다익스트라와 A*의 작동 방식을 이해하면 해소가 된다.

먼저 다익스트라는 시작 노드로부터 시작해서 가장 최소 비용으로 도달한 노드에서 또 다시 도달한 노드를 시작 노드로 선정해서 다음 탐색 노드를 큐에 넣는 식으로 작동한다.

그러나 A는 이러한 방식과는 다른 점이 꽤 많다. A는 다음으로 탐색하는 노드를 정하는 방식이 많이 다르다. 다익스트라는 시작 노드로부터 현재 노드까지의 최소 비용이면 그 노드를 선택했다. 그러나 A*는 시작 노드부터터 현재 노드까지의 비용 g(n) 과 현재 노드부터 도착 노드까지의 예상 비용 h(n) 이 둘을 더한 값 f(n)의 최소값의 노드를 다음 탐색 노드로 설정한다.

f(n) = g(n) + h(n)

이러한 f(n)으로 다음 탐색 노드를 설정한다.

h(n)은 에상 비용을 계산한 값인데... 이 예상 값을 구하는 함수를 Heuristic(휴리스틱) 함수라고 한다. 또한 휴리스틱을 사용하는 대부분의 알고리즘들은 휴리스틱 함수의 설계 방법에 따라서 알고리즘의 성능이 결정된다. 이 말인 즉 A*의 성능 또한 휴리스틱 함수에 따라서 효율이 달라진다는 것이다.

일단 길찾기 알고리즘이기 때문에 보통은 단순히 노드와 노드 사이의 거리(평면 상에서)를 계산하는 함수를 사용한다. 대표적으로 맨해튼 거리, 유클라디안 거리를 사용한다.

:::tip[상식 up]

맨해튼(Manhattan) 거리: 두 점 사이의 수평 및 수직 이동 거리의 합 = ∣p₁−q₁∣+∣p₂−q₂∣+...+|pₙ-qₙ|

유클라디안(Euclidean) 거리: 두 점 사이의 수평 및 수직 이동 거리의 제곱의 합의 제곱근 = sqrt((p₁−q₁)² + (p₂−q₂)²+...+(pₙ-qₙ)²)

해밍(Hamming) 거리: 맞춤법 검사와 같은 알고리즘에 많이 사용 (이 거리는 그냥 상식으로 알아두자)

!또한 맨해튼 거리는 항상 유클리드 거리보다 크거나 같다.! :::

이 포스팅에서는 이상한 무리수를 다루고 싶지 않기때문에 맨해튼을 사용할 것이다.(숫자가 크긴해도 예시를 그렇게 큰 값을 다루지 않을거기 때문)

예시를 들어보겠다. <center>

</center>

일단 예시에서 사용될 한 블럭의 한 변은 10이라는 값으로 고정한다. 이때 대각선의 값은 피타고라스의 정리를 이용해 계산해보면 14.1421...

</center> 이러한 값이 나오는데 예시에서는 소수점을 모두 버림하고 14로 설정하였다. <center>

</center> 이렇게 4가지의 블럭이 있다. <center>

</center> 위와 같은 과정을 통해서 목표에 도달하는데.. 이 값들을 보게된다면 뭔가 알 수도 있다.

정말 놀랍게도 g(n)은 다익스트라와 똑같이 작동하는 값이다. 그러니 휴리스틱을 뺀다면? 다익스트라와 똑같은 결과를 뱉어낼 것이다.

그리고 그림을 보면 알겠지만, 다익스트라와 다르게 퍼져나가지 않고 목표와 가까운 노드를 먼저 방문함으로써 쓸데없는 연산을 줄였다. 한번 비교해볼까?

</center>

이렇듯 다익스트라는 우리가 모든 노드를 탐색하면서(퍼져나가면서) 탐색을하게 된다.

"우리는 저 목표의 최단 경로만 구하고 싶다!" 이러면 바로 A*를 사용하면 된다. <center>

</center> 이 얼마나 좋냐!

구현

A* 알고리즘을 이제 구현을 해보자!

먼저 A*에서는 OpenList, ClosedList가 존재한다.

일단 OpenList는 이제 방문할 노드들이 있는 리스티이며, ClosedList는 이제 더이상 방문을 하지 않을 친구들을 넣는 리스트이다.

과정

초기화
1. 시작 노드 생성
2. OpenList(현재 우선순위 큐)에 push
탐색
1. OpenList에서 f(n)이 최소인 노드를 가져옴
2. 목적지에 도달을 확인함.
갱신
1. 현재 노드에서 갈 수 있는 노드들의 예상비용을 각각 계산한다.
2. 계산한 노드의 f(n)이 원래 업데이트 해놓았던 비용보다 적다면 다시 비용 업데이트, OpenList에 노드를 push
목적지에 도달할때까지 무한반복!

이제 구현된 시각화 코드와 시각화된 결과를 봐볼까요?

</center> 파랑은 지나갈 수 잇는 곳이고, 초록은 탐색한 곳이며, 검은색은 찾은 최적의 경로입니다.

일부로 저렇게 유도되도록 만들긴 했지만, 실제로 A*가 최적의 해를 주는건 아닙니다. 휴리스틱 기반으로 작동하니 당연하겠지만 위의 결과와 비슷하게, 이상하게 돌아가긴해도, 어느정도 괜찮은 값을 반환하긴 했습니다.

다음에는 JPS와 미로 생성 알고리즘에 대해서 다뤄보겠습니다!! 시험들 화이팅하시궁!! 진짜 1일 1포스팅 끊긴거 디게 기분이 나쁘군용...ㅠㅜ

다익스트라 알고리즘


win_width, win_height = 400, 400  # 가로 세로 400 400
rows, cols = 8, 17  # 세로 가로 / 행과 열
# 8*2 = 64 개의 grid
win = pygame.display.set_mode((win_width, win_height))  # (width, height)
pygame.display.set_caption("(그리드 & 다익스트라) 알고리즘")
grid_width, grid_height = win_width // cols, win_height // rows
#                         400 // 4,           400 // 4

target_flag = False  # 목표물이 설정되지 않은 상태
WHITE = (255, 255, 255)  # r, g, b


class Box:
    # constructor.. 박스가 박스이기 위한.. 필요한 것들이 뭐가 있나
    # __init__
    # 필요한것
    # x, y 좌표(위치)
    # start, goal, wall인지
    def __init__(self, x, y, block_width, block_height):
        self.x, self.y = x, y
        self.color = (217, 217, 217)

        self.cost = float('inf')

        self.width, self.height = block_width, block_height
        self.start, self.goal, self.wall = False, False, False
        self.path = False
        self.visited = False

    def setcolor(self, color): self.color = color

    def draw(self, mywin):
        # color = (0, 255, 0)
        pos = (self.x, self.y, self.width - 2.5, self.height - 2.5)
        pygame.draw.rect(mywin, self.color, pos)
import heapq
def dij(g, finish_x, finish_y, window):
    result_path = []
    result_cost = float('inf')
    q = [(0, 6, 7, [], g[6][7])]
    dx, dy = [0, 0, -1, 1], [1, -1, 0, 0]
    xlen, ylen = len(g), len(g[0])

    cnt = 0

    while q:
        cost, x, y, path, bx = heapq.heappop(q)
        if bx.wall == True or \
                result_cost <= cost or bx.cost <= cost: continue
        g[x][y].cost = cost
        bx.cost = cost
        if (x, y) == (finish_x, finish_y):
            if result_cost > cost:
                result_cost = cost
                result_path = path
        colored = []
        for i in range(4):
            nx, ny = x + dx[i], y + dy[i]
            if 0 <= nx < xlen and 0 <= ny < ylen:
                heapq.heappush(q, (cost + 1, nx, ny, path + [(x, y)], g[nx][ny]))
                colored.append((g[nx][ny], g[nx][ny].color))

        bx.setcolor((0, 224, 255))
        for b, c in colored:
            if c == (255,0,0): continue
            b.setcolor((51, 255, 0))

        for i in g:
            for j in i:
                j.draw(win)

        for b, c in colored: b.setcolor(c)

        pygame.image.save(window, "./screen_to_blog/blog_"+str(cnt)+".png")
        cnt+=1

        bx.setcolor((21, 106, 0))

        # win.fill(WHITE) #(r,g,b)
        # pygame.display.update(win)
        pygame.display.flip()
        pygame.time.delay(200)
    return result_path if result_cost != float('inf') else None


def solution():
    global target_flag
    # 그래픽 처리는 무조건 refresh 화면을 계속 찍는것
    g = []  # grids
    for i in range(cols):
        temp = []
        for j in range(rows):
            temp.append(Box(i * grid_width, j * grid_height, grid_width, grid_height))  # object 넣기
        g.append(temp)
    start_box = g[0][0]
    start_box.visited = True
    start_box.start = True
    start = False
    q = [start_box]
    target_pos = (0, 0)
    isRun = True
    while isRun:
        # 이벤트.. 이벤트 프로그래밍..  in cs
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()  # system
            elif event.type == pygame.MOUSEMOTION:
                position = pygame.mouse.get_pos()  # (x, y) 현재 마우스의 위치를 return함 tuple의 형태로
                x, y = position
                x, y = x // grid_width, y // grid_height
                if event.buttons[0]:  # 왼쪾 마우스가 클릭되면
                    print(f"방해물 설정 중 : 좌표 x = {x}, y = {y}")
                    if (x, y) == target_pos or (x, y) == (0, 0): continue
                    g[x][y].setcolor((255, 0, 0))
                    g[x][y].wall = True
                # 1번은 마우스 휠
                elif event.buttons[2] and target_flag == False:  # 오른쪽 마우스 클릭되면
                    print(f"목표물 설정 : 블럭 좌표 x = {x}, y = {y}")
                    g[x][y].setcolor((0, 0, 255))
                    g[x][y].goal = True
                    target_pos = (x, y)
                    target_flag = True
            elif event.type == pygame.KEYDOWN and target_flag == True:  # 키가 눌렸다면 실행
                print('알고리즘 시작')
                start = True
                g[6][7].start = True
                isRun = False
                nf = dij(g, target_pos[0], target_pos[1], win)
                if nf == None: return "경로 없음"
                else:
                    for (x,y) in nf:
                        g[x][y].setcolor((100,100,100))

        for i in g:
            for j in i:
                j.draw(win)

        # win.fill(WHITE) #(r,g,b)
        # pygame.display.update(win)
        pygame.display.flip()
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()  # system
        for i in g:
            for j in i:
                j.draw(win)
    return

A* 알고리즘 코드

class Astar():
    def __init__(self, grid):
        self.grid = grid

    def heuristic_Diagonal_Distance(self, node, goal, D1=1, D2=2 ** 0.5):
        dx = abs(node.position[0] - goal.position[0])
        dy = abs(node.position[1] - goal.position[1])

        return D1 * (dx + dy) + (D2 - 2 * D1) * min(dx, dy)

    def heuristic_Euclidean_Distance(self, current, end):
        return ((current.position[0] - end.position[0]) ** 2)\
                + ((current.position[1] - end.position[1]) ** 2)

    def CalcNode(self, childNode, currentNode, endNode):
        childNode.g = currentNode.g + 1 + childNode.density ** 2
        childNode.h = self.heuristic_Euclidean_Distance(currentNode, endNode)
        childNode.f = childNode.g + childNode.h

    def NodeSet(self, node, g: int, f: int, h: int):
        node.g = g
        node.h = h
        node.f = f

    def getPath(self, node, board: list[list]):
        path = []
        while node.parent != None:
            y, x = node.position
            board[y][x] = node.f
            path.append(node.position)
            node = node.parent
        return path[::-1]

    def AStar(self, board: list[list], start: tuple, end: tuple, delay: int = 0):
        import heapq as hq
        from CompyLib.Algorithms import Node

        startNode = Node(None, start, board[start[0]][start[1]], 0)
        endNode = Node(None, end, board[end[0]][end[1]], 0)

        self.NodeSet(startNode, 0, 0, 0)

        openList: list[Node] = list()
        closedList: list[Node] = list()

        openList.append(startNode)
        dx, dy = [0, 0, -1, 1, -1, -1, 1, 1], [-1, 1, 0, 0, -1, 1, -1, 1]

        Visualization = self.grid != None
        self.CalcNode(startNode, startNode, endNode)
        while openList:
            currentNode: Node = hq.heappop(openList)
            closedList.append(currentNode)
            if Visualization:
                self.grid.changeBox(self.grid.getBoxbyIndex(currentNode.position[0],
                                                            currentNode.position[1]), "GREEN")

            if endNode == currentNode:
                return self.getPath(currentNode, board)

            children: list[Node] = []

            for i in range(8):
                ny = currentNode.position[0] + dy[i]
                nx = currentNode.position[1] + dx[i]

                if 0 > ny or ny >= len(board) or 0 > nx or \
                        nx >= len(board[0]) \
                        or board[ny][nx] == 1:
                    continue
                children.append(Node(None, (ny, nx), board[ny][nx], 0))
            for child in children:
                if child in closedList: continue
                self.CalcNode(child, currentNode, endNode)
                # print(child.f, currentNode.f, currentNode, child)
                # if child.f > currentNode.f: continue or child.g + child.density > currentNode.g + 1: continue  # or
                # child.g + child.density <= currentNode.g + 1:
                flag: bool = False
                for node in openList:
                    if child == node and child.g > node.g:
                        flag = True
                        break
                if flag: continue

                child.parent = currentNode

                hq.heappush(openList, child)
            if Visualization: self.grid.boardUpdate(delay)

        return -1

격자 생성

class Type:
    def __init__(self, screen: p.Surface = None, row: int = 5, col: int = 5):

        self.Running = True

        # Pygame 객체

        self.screen = screen
        self.row = row
        self.col = col

        if screen == None: self.Running = False

        # 기본 색 설정

        self.RED: tuple = (255, 0, 0)
        self.BLUE: tuple = (0, 0, 255)
        self.GREEN: tuple = (0, 255, 0)
        self.BLACK: tuple = (0, 0, 0)
        self.WHITE: tuple = (255, 255, 255)

        # 색 접근
        self.custom_color: dict = {"RED": self.RED, "BLUE": self.BLUE,
                                   "GREEN": self.GREEN, "BLACK": self.BLACK,
                                   "WHITE": self.WHITE, "ORANGE": (255, 95, 0),
                                   "DARKORANGE": (255, 135, 0), "GOLD": (255, 215, 0),
                                   "YELLOW": (255, 255, 0), "AQUA": (0, 255, 255),
                                   "NAVYBLUE": (0, 0, 95)}
        self.color_idx: list = ["BLUE", "RED", "GREEN", "BLACK", "WHITE", "ORANGE",
                                "DARKORANGE", "GOLD", "YELLOW", "AQUA", "NAVYBLUE"]

    def update(self):
        return

    def changeColor(self, *inp):
        length: int = len(inp[0])

        # print(inp[0])

        inp = inp[0]

        if length < 2 or type(inp[1]) != str:
            return False

        if inp[1] not in self.custom_color.keys():

            if length < 3 or type(inp[2]) != tuple:
                return False

            self.custom_color[inp[1]] = inp[2]

        ret: str

        if type(inp[0]) == int:
            ret = self.color_idx[inp[0]]
            self.color_idx[inp[0]] = inp[1]
        elif type(inp[0]) == str:

            if inp[0] not in self.color_idx:
                return False

            ret = inp[0]
            self.color_idx[self.color_idx.index(inp[0])] = inp[1]
        else:
            return False

        return ret

    def addColor(self, name: str, color: tuple):

        if name == None or name == "":
            return False

        self.custom_color[name] = color
        return True
        
        
class Grid(Type):

    def __init__(self, screen: p.Surface = None,
                 row: int = 5, col: int = 5,
                 space: float = -1.5):

        super().__init__(screen, row, col)

        self.space = space
        self.board: list = list()  # [[0 for i in range(row)] for i in range(col)]

        (sc_width, sc_height) = screen.get_size()

        self.bx_width = sc_width // row
        self.bx_height = sc_height // col

        for i in range(row):
            self.board.append(list())

            for j in range(col):
                self.board[i].append(Box(i * self.bx_width, j * self.bx_height,
                                         self.bx_width + space, self.bx_height + space))  # x, y, width, height, color

    def boardUpdate(self, delay: int):
        self.screen.fill(self.WHITE)

        for i in self.board:
            for j in i:
                j.draw(self.screen, p)
        p.display.flip()

        p.time.delay(delay)

    def Colors(self):
        cnt: int = 0

        for name, rgb in self.custom_color.items():
            cnt += 1
            print(f"{name}의 rgb값은 {rgb}  ", end='')
            if cnt // 3 == 1:
                cnt = 0
                print()

    def changeColor(self, *inp):
        res: str = super().changeColor(inp)
        if not res: return False
        for i in self.board:
            for box in i:
                if box.colorName != res: continue
                box.colorName = inp[1]
                box.color = self.custom_color[inp[1]]
        return True

    def changeBox(self, *inp):
        # x: int, y: int, color=0):
        box: Box

        if len(inp) > 2:
            x, y = inp[0], inp[1]
            box = self.board[y][x]

            if type(inp[2]) == int:
                color: int = inp[2]
            else:
                color: str = inp[2]
        else:
            box = inp[0]

            if type(inp[1]) == int:
                color: int = inp[1]
            else:
                color: str = inp[1]
        # print(inp, box, color)
        if type(color) == int:
            box.colorName = self.color_idx[color]
            box.color = self.custom_color[box.colorName]

        elif type(color) == str:
            box.colorName = color
            box.color = self.custom_color[color]

        else:
            return False
        return True

    def getBoxbyCoordinate(self, x: int, y: int):
        return self.board[x // self.bx_width][y // self.bx_height]

    def getBoxbyIndex(self, x: int, y: int):
        return self.board[y][x]

    def getBox(self, x: int, y: int):
        return self.getBoxbyCoordinate(x, y)

</details>

[Algorithm] BSP 알고리즘(맵 생성)

Sun, 16 Feb 2025 00:00:00 GMT

:::note[]

이 포스트는 Only BSP algorithm 이론 파트입니다.

혹시나 구현을 가져가고 싶으시다면 맨 아래에 있는 링크로 들어가시면 됩니다. :::

BSP 알고리즘이란?

BSP(Binary Space Partitioning)는 재귀적으로 유클리드 공간을 초평면 상의 볼록 집합으로 분할하는 기법이다. 분할 과정으로 BSP 트리라 불리는 트리 구조가 만들어진다.

근데 이게 왜 게임에 많이 쓰일까요?? 일단 유명해진 계기는 둠(Doom)이 요 BSP 알고리즘을 사용하면서 굉장히 유명해 졌습니당.

자 BSP 알고리즘은 이제 랜더링에서도 사용이 되는데 사실 이번에 볼 것은 랜더링이 아니라 "맵 생성"을 해볼겁니다. (랜더링 관련해서는 다른 포스팅에서...)

랜덤 맵 생성.. 정말 매력적인 친굽니다. 어릴적 나도 게임을 만들거야!! 했는데 레벨 디자인 가다보면 도대체 시중에 나와있는 게임처럼 어떻게 랜덤으로 맵을 만들까? 라는 의문이 진짜 해결이 안되다가 여러가지 알고리즘 BSP, WFC 등등 이런 애들을 배우면서 와 이게 되누 ㅋㅋ

하면서 해봤던 기억이 있는데요. 그때는 사실 구현이 다 야매였습니다. 진짜 어떻게든 구현한다! 그 마인드.. 그래서 나중에 다른 게임에서 사용하려면 많이 수정을 해야됐었습니다.

그래서 그때의 시절에 있는 분들께 소개시켜드리고 싶은 알고리즘인데 게임 공부하다 보면 분명 한번쯤은 들어봤을 겁니당.

그래서 원리부터 쭉 살펴보죠

알고리즘

다시한번 돌아보면서 시작해보죠!(이 포스트에서는 2차원에 대해서만 설명하겠습니다)

BSP는 공간을 이진 트리 구조로 재귀적으로 분할하는 방식입니다. 큰 공간을 두 개의 작은 공간으로 나누고, 각각의 작은 공간을 다시 두 개로 나누는 과정을 반복합니다. 계속해서 하나의 판을 반->반->반으로 계속 자르는 것을 생각하시면 좋아요

좀 더 자세히 설명해보죠!

공간 분할 과정

1. 초기 공간 설정

저는 구현을 전체 맵을 하나의 직사각형 공간으로 잡고서 하였습니다. 뭐 어떻게든 잡아도 되지만 보통 구현이 편한건 당연히 사각형입니다.

2. 재귀적 분할

이것도 구현에 따라 다르긴 하지만 일반적으로 사용하는 방법을 소개해드리겠습니다.(물론 저도 일반적인 방법으로 구현을 하였구요)

a) 분할 방향 결정:

공간의 가로/세로 비율을 확인
- 너비가 더 크면 수직 분할 선호
- 높이가 더 크면 수평 분할 선호
- 비슷한 경우 무작위 선택

b) 분할 위치 결정:

일반적으로 공간의 40%~60% 지점에서 분할
- 완전히 중앙에서 분할하지 않는 이유는 다양한 크기의 공간을 만들기 위함
- 최소 크기 제한을 두어 너무 작은 공간이 생기지 않도록 함

목적들은 다 직관적으로 이해할만한 것들입니다.

3. 종료 조건

공간이 최소 크기에 도달
정해진 분할 횟수에 도달
가로/세로 비율이 적절한 범위에 들어옴

[이해를 돕기 위한 자료]

</center>

방 생성 과정

:::note[여기서 말하는 노드란?]

앞서 분할 과정에서 생긴 부분들을 노드로 생각하고, 그것을 트리 형태로 바라보면 Leaf node임. 그래서 여기서 말하는 노드는 leaf node를 말함. :::

노드의 크기보다 약간 작게 방을 생성(이 노드가 분리된 공간)
벽과의 최소 간격 유지
방 크기는 정해진 범위 내에서 무작위로 결정
보통 노드 중앙에 방을 배치

[이해를 돕기 위한 자료2]

</center>

복도 생성 과정

이웃한 방들을 우선적으로 연결
L자 형태의 복도가 일반적
모든 방이 최소한 하나의 다른 방과 연결되도록 보장
선택적으로 순환 경로(루프) 추가 가능(그래서 여러개 나올 수도 있음)

[이해를 돕기 위한 자료3]

</center>

확장

불필요한 복도 제거
막힌 공간 처리
장식 요소 추가
게임플레이를 위한 요소 배치

장/단점

장점

구현이 비교적 단순하면서도 다양한 결과물 생성 가능(다른 맵 생성 알고리즘에 비해서 굉장히 쉬운편)
자연스러운 공간 구획이 가능(이거는 구현에 따라 좀 달라지긴 합니다.)
생성된 맵의 구조가 명확하고 탐색하기 쉬움
확장성이 좋아 다양한 변형이 가능(1번 부가 설명이죠)

단점

메모리 이슈(매번 노드를 분리하면서 많은 양의 데이터를 계속 저장함)
맵을 생성하는 과정에서 꽤 많은 시간이 소모됨

구현 영상

</center>

일단 구현하는게 쉽지만은 않았습니다. 원래 알고리즘은 전에 여러번 구현해보기도 해서 그런 것에는 문제가 없을 줄 알았는데... 이게 완벽히 파이썬처럼 작성하기도 하고, 다시 뭔가 oop도 따라하려고 하고 막 어찌저찌 스타일도 섞으면서 하게됐는데요.

일단 이번에 느낀 것은 Mojo와 Python은 진짜 전혀 다른 언어라는거죠..

일단 struct로 뭔가를 만들어서 List에 넣고 하려고해도. copyable, moveable을 무조건 넣어줘야 됐다는 것. 그리고 검사가 너무 깐깐합니다. 그래서 나중에 코드 보면서 트러블 슈팅할 때는 괜찮았어요. 오히려 이런 것에서 장점이 나오는 것 같아서 좋긴했는데..

이 코드가 복잡한 코드도 아니고 그냥 한번 작성하고 보여주기 코드였는데 뭔가 쓸데없는 곳에서 계속 걸리니까 그런 장점보다는 오히려 짜증이 나기도 하더라구요.

일단 ide가 없고, 자동 완성도 안됩니다. 현재 jetbrain에서 plugin이 있는데 구버전에다가... 성능이 안 좋아서 잘 못잡아요. 허구언날 빨간줄만 띄웁니다.

그래서 그냥 기능 다 끄고 했구요. 자동 들여쓰기만 키고서 작성했습니다.

그래서 시간이 오래걸린 것 같아요. 또 이번에 많은 것을 알아갑니다. Mojo에 대해서 많은 것을 알아가요..... 어후..

또 로직에 문제가 없다고 생각했는데 네... 리스트 값이 변경이 안되고 주소 확인해 보니까 copy가 되더라구요? 그래서 오잉? 하고서 값을 reference로 받거나 아니면 그냥 리스트에 self.nodes[idx] 이거를 직접 사용하거나 이렇게 했어야 했다.

저는 그냥 var node = ... 뺀 다음에 연산 다 끝나고 self.nodes[idx] = node로 처리를 했습니다. 이게 그 뻘짓 중에 그냥 고치기 쉬웠던 것들 중 하나구요..

하나하나 쓰기는 좀 그렇고 네.. 힘들었습니다. 그래도 보람이 있었고, 재미있었습니다. 이제 이 언어를 가지고 인공지능을 좀 해보려고 하는데.. 일단 다른 경험으로 IDE를 만들어보려고 합니다. 진짜 힘든 길이겠지만 뭐... 해야죠 저는 이 언어를 쓰고싶은데

네 여기까지 하소연이였구용.. 하튼 재미있었습니다.

제가 구현한 코드 로직의 순서도입니다. 깔끔하게 정리되는 사이트가 없더라구용..

또 스네이크로 작성해본 것도 좀 오랜만이네용!

from python import Python, PythonObject
import random
import time

struct Corridor(Copyable, Movable):
    var start_x: Int
    var start_y: Int
    var end_y: Int
    var end_x: Int
    var is_vertical: Bool

    fn __init__(mut self, start_x: Int, start_y: Int, end_x: Int, end_y: Int, is_vertical: Bool):
        self.start_x = start_x
        self.start_y = start_y
        self.end_x = end_x
        self.end_y = end_y
        self.is_vertical = is_vertical

    fn __copyinit__(mut self, other: Self):
        self.start_x = other.start_x
        self.start_y = other.start_y
        self.end_x = other.end_x
        self.end_y = other.end_y
        self.is_vertical = other.is_vertical

    fn __moveinit__(mut self, owned other: Self):
        self.start_x = other.start_x
        self.start_y = other.start_y
        self.end_x = other.end_x
        self.end_y = other.end_y
        self.is_vertical = other.is_vertical

struct BSPNode(Copyable, Movable):
    var x: Int
    var y: Int
    var width: Int
    var height: Int
    var min_size: Int

    var split_vertical: Bool
    var split_pos: Int
    var is_split: Bool
    var is_leaf: Bool

    var has_room: Bool
    var room_x: Int
    var room_y: Int
    var room_width: Int
    var room_height: Int

    var corridors: List[Corridor]

    fn __init__(mut self, x: Int, y: Int, width: Int, height: Int, min_size: Int):
        self.x = x
        self.y = y
        self.width = width
        self.height = height
        self.min_size = min_size

        self.split_vertical = False
        self.split_pos = 0
        self.is_split = False
        self.is_leaf = True

        self.has_room = False
        self.room_x = 0
        self.room_y = 0
        self.room_width = 0
        self.room_height = 0

        self.corridors = List[Corridor]()

    fn __copyinit__(mut self, other: Self):
        self.x = other.x
        self.y = other.y
        self.width = other.width
        self.height = other.height
        self.split_vertical = other.split_vertical
        self.split_pos = other.split_pos
        self.has_room = other.has_room
        self.room_x = other.room_x
        self.room_y = other.room_y
        self.room_width = other.room_width
        self.room_height = other.room_height
        self.is_split = other.is_split
        self.is_leaf = other.is_leaf
        self.min_size = other.min_size
        self.corridors = other.corridors

    fn __moveinit__(mut self, owned other: Self):
        self.x = other.x
        self.y = other.y
        self.width = other.width
        self.height = other.height
        self.split_vertical = other.split_vertical
        self.split_pos = other.split_pos
        self.has_room = other.has_room
        self.room_x = other.room_x
        self.room_y = other.room_y
        self.room_width = other.room_width
        self.room_height = other.room_height
        self.is_split = other.is_split
        self.is_leaf = other.is_leaf
        self.min_size = other.min_size
        self.corridors = other.corridors

    fn can_split(self) -> Bool:
        if self.is_split or not self.is_leaf:
            return False

        if self.width < self.min_size * 2 and self.height < self.min_size * 2:
            return False

        return True

    fn split(mut self) -> Bool:
        if not self.can_split():
            return False

        if self.width * 4 >= self.height * 5:
            self.split_vertical = True
        elif self.height * 4 >= self.width * 5:
            self.split_vertical = False
        else:
            self.split_vertical = random.random_si64(0, 1)[0] == 1

        if self.split_vertical:
            self.split_pos = self.x + Int(random.random_si64(
                self.width * 4 // 10,
                self.width * 6 // 10
            )[0])
        else:
            self.split_pos = self.y + Int(random.random_si64(
                self.height * 4 // 10,
                self.height * 6 // 10
            )[0])

        self.is_split = True
        self.is_leaf = False
        return True

    fn create_room(mut self) -> Bool:
        if not self.is_leaf or self.has_room:
            return False

        var padding = max(2, self.min_size // 4)
        var min_room_size = self.min_size

        var max_width = self.width - (padding * 2)
        var max_height = self.height - (padding * 2)
        var min_width = min(min_room_size, max_width)
        var min_height = min(min_room_size, max_height)

        if max_width < min_width or max_height < min_height:
            return False

        self.room_width = Int(random.random_si64(
            max(min_width, max_width // 2),
            max_width
        )[0])
        self.room_height = Int(random.random_si64(
            max(min_height, max_height // 2),
            max_height
        )[0])

        var available_x = self.width - self.room_width
        var available_y = self.height - self.room_height
        self.room_x = self.x + (available_x // 2)
        self.room_y = self.y + (available_y // 2)

        self.has_room = True
        return True

    fn get_room_center(self) -> Tuple[Int, Int]:
        return (
            self.room_x + self.room_width // 2,
            self.room_y + self.room_height // 2
        )

struct DungeonGenerator:
    var nodes: List[BSPNode]
    var stage: Int
    var current_idx: Int
    var min_room_size: Int
    var split_count: Int
    var max_splits: Int
    var corridors: List[Corridor]

    fn __init__(mut self, width: Int, height: Int, min_room_size: Int, max_splits: Int):
        self.nodes = List[BSPNode]()
        self.nodes.append(BSPNode(0, 0, width, height, min_room_size))
        self.stage = 0
        self.current_idx = 0
        self.min_room_size = min_room_size
        self.split_count = 0
        self.max_splits = max_splits
        self.corridors = List[Corridor]()

    fn connect_rooms(mut self):
        var leaf_nodes = List[BSPNode]()
        for idx in range(len(self.nodes)):
            var node = self.nodes[idx]
            if node.is_leaf and node.has_room:
                leaf_nodes.append(self.nodes[idx])

        if len(leaf_nodes) < 2:
            return

        for i in range(len(leaf_nodes)):
            for j in range(i + 1, len(leaf_nodes)):
                var room1 = leaf_nodes[i]
                var room2 = leaf_nodes[j]

                var center1 = room1.get_room_center()
                var center2 = room2.get_room_center()

                if random.random_si64(0, 1)[0] == 0:
                    var mid_y = center2[1]
                    self.corridors.append(Corridor(
                        center1[0], center1[1],
                        center1[0], mid_y,
                        True
                    ))
                    self.corridors.append(Corridor(
                        center1[0], mid_y,
                        center2[0], mid_y,
                        False
                    ))
                else:
                    var mid_x = center2[0]
                    self.corridors.append(Corridor(
                        center1[0], center1[1],
                        mid_x, center1[1],
                        False
                    ))
                    self.corridors.append(Corridor(
                        mid_x, center1[1],
                        mid_x, center2[1],
                        True
                    ))

    fn step(mut self) -> Bool:

        if self.stage == 0:
            if self.split_count >= self.max_splits:
                self.stage = 1
                self.current_idx = 0
                return True

            if self.current_idx < len(self.nodes):
                var node = self.nodes[self.current_idx]

                if node.split():
                    if node.split_vertical:
                        self.nodes.append(BSPNode(
                            node.x, node.y,
                            node.split_pos - node.x, node.height,
                            self.min_room_size
                        ))
                        self.nodes.append(BSPNode(
                            node.split_pos, node.y,
                            node.width - (node.split_pos - node.x), node.height,
                            self.min_room_size
                        ))
                    else:
                        self.nodes.append(BSPNode(
                            node.x, node.y,
                            node.width, node.split_pos - node.y,
                            self.min_room_size
                        ))
                        self.nodes.append(BSPNode(
                            node.x, node.split_pos,
                            node.width, node.height - (node.split_pos - node.y),
                            self.min_room_size
                        ))
                    self.split_count += 1
                    self.nodes[self.current_idx] = node
                self.current_idx += 1
                return True
            else:
                self.current_idx = 0
                return True

        elif self.stage == 1:
            if self.current_idx >= len(self.nodes):
                self.stage = 2
                self.current_idx = 0
                return True

            if self.nodes[self.current_idx].create_room():
                print("Created room in node", self.current_idx)

            self.current_idx += 1
            return True

        elif self.stage == 2:
            if self.current_idx == 0:
                self.connect_rooms()
                self.current_idx += 1
                return True
            return False

        return False
fn run_display(width: Int = 800, height: Int = 600, min_room_size: Int = 50, split_count: Int = 5) raises:
    pygame = Python.import_module("pygame")
    pygame.init()

    var window = pygame.display.set_mode((width, height))
    pygame.display.set_caption("Compy BSP")

    var generator = DungeonGenerator(width, height, min_room_size, split_count)
    var running = True

    while running:
        var event = pygame.event.poll()
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_ESCAPE or event.key == pygame.K_q:
                running = False
            elif event.key == pygame.K_SPACE:
                if not generator.step():
                    generator = DungeonGenerator(width, height, min_room_size, split_count)

        window.fill((0, 0, 0))
        for i in range(len(generator.corridors)):
                var corridor = generator.corridors[i]
                var start_x = corridor.start_x
                var start_y = corridor.start_y
                var end_x = corridor.end_x
                var end_y = corridor.end_y
                pygame.draw.line(
                    window,
                    (0, 0, 255),
                    (start_x, start_y),
                    (end_x, end_y),
                    3
                )
        for i in range(len(generator.nodes)):
            var node = generator.nodes[i]
            pygame.draw.rect(
                window,
                (255, 255, 255),
                (node.x, node.y, node.width, node.height),
                1
            )

            if node.is_split:
                if node.split_vertical:
                    pygame.draw.line(
                        window,
                        (255, 0, 0),
                        (node.split_pos, node.y),
                        (node.split_pos, node.y + node.height),
                        2
                    )
                else:
                    pygame.draw.line(
                        window,
                        (255, 0, 0),
                        (node.x, node.split_pos),
                        (node.x + node.width, node.split_pos),
                        2
                    )

            if node.has_room and node.is_leaf:
                pygame.draw.rect(
                    window,
                    (0, 255, 0),
                    (node.room_x, node.room_y, node.room_width, node.room_height),
                    0
                )




        var font = pygame.font.Font(None, 36)
        var stage_text = String("")

        if generator.stage == 0: stage_text = "Phase 1: Splitting (" + str(generator.split_count) + "/" + str(generator.max_splits) + ")"
        elif generator.stage == 1: stage_text = "Phase 2: Creating Rooms"
        else: stage_text = "Phase 3: Connecting Rooms"

        var text = font.render(stage_text, True, (255, 255, 0))
        var text_rect = text.get_rect()
        text_rect.midtop = (width // 2, 10)
        window.blit(text, text_rect)

        var help_text = "Space: Next Step | ESC/Q: Quit"
        var help_surface = font.render(help_text, True, (128, 128, 128))
        var help_rect = help_surface.get_rect()
        help_rect.midbottom = (width // 2, height - 10)
        window.blit(help_surface, help_rect)

        pygame.display.flip()
        time.sleep(0.1)

    pygame.quit()

fn main() raises:
    run_display(800, 600, 50, 8)

</details>

Unity로 확장해서 해커톤에 활용하기!

Reference

wiki

wiki 2

[Algorithm] BSP 알고리즘(맵 생성) 유니티로 구현하기!(2D)

Sun, 16 Feb 2025 00:00:00 GMT

:::warning[여기 잠깐!!]

기본적인 알고리즘을 이해하는데 있어서 여기!를 참고해주세요!! :::

BSP 알고리즘 구현으로 해커톤 날먹이 된다고!?!

사실 이건 장난이고, 그냥 있어보이게 구현할 수 있도록 구조를 다 만들어둬서 그냥 가져다 쓰시면 됩니다.

물론 이 코드가 체계적으로 작성된 코드는 아니지만! 그래도 쓸만한 애들이라고 생각합니다(최적화는 안되어있는 편 ㅎㅎ)

일단 활용하기 편하도록 Scriptable Object로 다 설정하도록 만들어 뒀습니다.

:::warning[Scriptable Object 주의]

이 Scriptable Object를 인게임 상에서 값을 수정하게 되면, editor 환경에서는 작동을 하나.. 나중에 build 이후로 가게되면 유니티에서 이제 최적화 과정을 거치면서 필요없는 prefabs 등 다른 리소스들을 다 없애는데 이때 Scriptable Object의 값이 변경되면 터집니다!

조심하십쇼! :::

기본적인 세팅

일단 저는 부가적으로 Layer를 사용합니다. 참고하실 분은 참고해주세용

1. 벽 세팅

기본적인 벽을 담을 스프라이트(2D Rect 정도?)를 기반으로 방향, 모서리 등의 위치에 배치할 스프라이트들을 넣으면 됩니다.

[CreateAssetMenu(fileName = "WallTileSettings", menuName = "Compy/Wall Tile Settings")]
public class WallTileSettings : ScriptableObject
{
    
    [System.Serializable]
    public class WallSprites
    {
        [Header("기본 벽 스프라이트")]
        [Tooltip("주변에 아무 연결이 없는 기본적인 벽 스프라이트")]
        public Sprite defaultWall;

        [Header("벽 테두리")]
        [Tooltip("아래쪽으로 연결된 상단 벽면")] // │ 의 윗부분
        public Sprite wallTop;
        [Tooltip("위쪽으로 연결된 하단 벽면")] // │ 의 아랫부분
        public Sprite wallBottom;
        [Tooltip("오른쪽으로 연결된 왼쪽 벽면")] // ─ 의 왼쪽
        public Sprite wallLeft;
        [Tooltip("왼쪽으로 연결된 오른쪽 벽면")] // ─ 의 오른쪽
        public Sprite wallRight;

        [Header("벽 모서리 - 외부")]
        [Tooltip("오른쪽과 아래로 연결된 외부 모서리")] // ┌ 모양
        public Sprite cornerOuterTopLeft;
        [Tooltip("왼쪽과 아래로 연결된 외부 모서리")] // ┐ 모양
        public Sprite cornerOuterTopRight;
        [Tooltip("오른쪽과 위로 연결된 외부 모서리")] // └ 모양
        public Sprite cornerOuterBottomLeft;
        [Tooltip("왼쪽과 위로 연결된 외부 모서리")] // ┘ 모양
        public Sprite cornerOuterBottomRight;

        [Header("벽 모서리 - 내부")]
        [Tooltip("위쪽과 왼쪽이 벽인 내부 모서리")] // ┘ 모양이지만 안쪽으로
        public Sprite cornerInnerTopLeft;
        [Tooltip("위쪽과 오른쪽이 벽인 내부 모서리")] // └ 모양이지만 안쪽으로
        public Sprite cornerInnerTopRight;
        [Tooltip("아래쪽과 왼쪽이 벽인 내부 모서리")] // ┐ 모양이지만 안쪽으로
        public Sprite cornerInnerBottomLeft;
        [Tooltip("아래쪽과 오른쪽이 벽인 내부 모서리")] // ┌ 모양이지만 안쪽으로
        public Sprite cornerInnerBottomRight;

        [Header("단독 벽")]
        [Tooltip("주변에 어떤 연결도 없는 단독으로 서있는 벽")]
        public Sprite singleWall;

        [Header("끝부분")]
        [Tooltip("위쪽 방향으로 돌출된 벽의 끝부분 (아래쪽만 연결)")] // ╽ 모양
        public Sprite endTop;
        [Tooltip("아래쪽 방향으로 돌출된 벽의 끝부분 (위쪽만 연결)")] // ╿ 모양
        public Sprite endBottom;
        [Tooltip("왼쪽 방향으로 돌출된 벽의 끝부분 (오른쪽만 연결)")] // ╾ 모양
        public Sprite endLeft;
        [Tooltip("오른쪽 방향으로 돌출된 벽의 끝부분 (왼쪽만 연결)")] // ╼ 모양
        public Sprite endRight;
    }

    [Header("벽 스프라이트 설정")]
    public WallSprites sprites;

    [Header("벽 렌더링 설정")]
    public string sortingLayerName = "Wall";
    public int sortingOrder = 0;
}

Bsp Generation 세팅

bsp로 맵 생성을 할 때 사용될 변수들

using System.Collections.Generic;
using UnityEngine;
[CreateAssetMenu(fileName = "MapSettings", menuName = "Compy/Generator Settings")]
public class GeneratorSetting : ScriptableObject
{

    [Header("Map Size")]
    [Tooltip("전체 너비")]
    public int mapWidth = 100;
    
    [Tooltip("전체 높이")]
    public int mapHeight = 100;

    [Header("Room Generation")]
    [Tooltip("방의 최소 크기")]
    [Min(5)]
    public int minRoomSize = 10;
    
    [Tooltip("BSP 분할 최대 횟수")]
    [Range(1, 10)]
    public int maxIterations = 4;

    [Header("Room Constraints")]
    [Tooltip("방 사이의 최소 거리")]
    [Min(1)]
    public int minRoomDistance = 2;
    
    [Tooltip("방의 최대 크기 (전체 공간 대비 비율)")]
    [Range(0.3f, 0.8f)]
    public float maxRoomSizeRatio = 0.6f;

    [Header("Tile Settings")]
    [Tooltip("벽 타일 설정")]
    public WallTileSettings wallTileSettings;

    [Tooltip("기본 타일 프리팹 (스프라이트 렌더러와 콜라이더가 있는 빈 게임오브젝트)")]
    public GameObject tilePrefab;

    [Header("Prefabs")]
    [Tooltip("바닥 타일 프리팹")]
    public GameObject floorPrefab;

    [Header("Layer Settings")]
    [Tooltip("벽 레이어의 이름")]
    public string wallLayerName = "Wall";

    [Header("Advanced Settings")]
    [Tooltip("통로 너비")]
    [Range(1, 5)]
    public int corridorWidth = 3;
    
    [Tooltip("방 생성 시도 최대 횟수")]
    [Min(1)]
    public int maxRoomPlacementAttempts = 10;

    [Tooltip("추가 통로 생성 확률 (0-1)")]
    [Range(0f, 1f)]
    public float extraCorridorChance = 0.2f;
    
    [Header("Structures")]
    [Tooltip("맵에 배치할 구조물들의 정의")]
    public List<CompyStructure> structures = new List<CompyStructure>();

    [Tooltip("구조물 배치 최대 시도 횟수")]
    [Min(1)]
    public int maxPlacementAttempts = 100;

    
    
    
    public void ValidateSettings()
    {
        mapWidth = Mathf.Max(mapWidth, minRoomSize * 2);
        mapHeight = Mathf.Max(mapHeight, minRoomSize * 2);

        minRoomSize = Mathf.Min(minRoomSize, Mathf.Min(mapWidth, mapHeight) / 2);
        
        corridorWidth = Mathf.Min(corridorWidth, minRoomSize - 2);
        minRoomDistance = Mathf.Max(minRoomDistance, corridorWidth);

        ValidateStructures();
    }


    private void ValidateStructures()
    {
        if (structures == null) return;

        foreach (var structure in structures)
        {
            if (structure == null) continue;
            structure.width = Mathf.Min(structure.width, mapWidth - 4);
            structure.height = Mathf.Min(structure.height, mapHeight - 4);

            structure.minCount = Mathf.Min(structure.minCount, structure.maxCount);

            if (structure.padding > 0) 
                structure.padding = Mathf.Min(structure.padding,
                    Mathf.Min(structure.width, structure.height) / 2);
            
        }
    }
    
    public GeneratorSetting Clone()
    {
        var clone = CreateInstance<GeneratorSetting>();        
        clone.mapWidth = this.mapWidth;
        clone.mapHeight = this.mapHeight;
        clone.minRoomSize = this.minRoomSize;
        clone.maxIterations = this.maxIterations;
        clone.minRoomDistance = this.minRoomDistance;
        clone.maxRoomSizeRatio = this.maxRoomSizeRatio;
        clone.wallTileSettings = this.wallTileSettings;
        clone.tilePrefab = this.tilePrefab;
        clone.floorPrefab = this.floorPrefab;
        clone.wallLayerName = this.wallLayerName;
        clone.corridorWidth = this.corridorWidth;
        clone.maxRoomPlacementAttempts = this.maxRoomPlacementAttempts;
        clone.extraCorridorChance = this.extraCorridorChance;

        clone.structures = new List<CompyStructure>(this.structures);
        clone.maxPlacementAttempts = this.maxPlacementAttempts;

        return clone;
    }

#if UNITY_EDITOR
    // 내가 한번 당하지 두번은 안 당할거임 ㄹㅇ

    private void OnValidate()
    {
        ValidateSettings();
    }
#endif
}

BSP Algorithm

BSP Room

public class BSPRoom
{
    public int x, y, width, height;

    public BSPRoom(int x, int y, int width, int height) {
        this.x = x;
        this.y = y;
        this.width = width;
        this.height = height;
    }
}

BSP Generator

기본적인 생성만 가볍게 만들어본 버전입니다.

public class BSPGenerator : MonoBehaviour{
    private enum WallType {
        Single,
        Top,
        Bottom,
        Left,
        Right,
        CornerOuterTopLeft,
        CornerOuterTopRight,
        CornerOuterBottomLeft,
        CornerOuterBottomRight,
        CornerInnerTopLeft,
        CornerInnerTopRight,
        CornerInnerBottomLeft,
        CornerInnerBottomRight,
        EndTop,
        EndBottom,
        EndLeft,
        EndRight,
        Default
    }
    private int mapWidth = 100;
    private int mapHeight = 100;
    private int minRoomSize = 10;
    private int maxIterations = 4; 
    
    private string wallLayerName = "Wall";
    
    private GameObject wallPrefab; 
    private GameObject floorPrefab; 

    private List<BSPRoom> rooms = new List<BSPRoom>();
    private int[,] map;
    private int wallLayerId;

    private GeneratorSetting setting;
    
    private const bool debug = false;

    private bool generateDone;
    
    public void GeneratorInit(GeneratorSetting setting)
    {
        generateDone = false;
        InitWithSettings(setting);
        
        wallLayerId = LayerMask.NameToLayer(wallLayerName);
        
        if (wallLayerId == -1) {
            Debug.LogError($"Layer '{wallLayerName}' not found! 이거 추가좀 이거 왜 안고쳐짐?");
            wallLayerId = 0;
        }

        this.setting = setting;
    }

    private void InitWithSettings(GeneratorSetting setting) {
        mapWidth = setting.mapWidth;
        mapHeight = setting.mapHeight;
        minRoomSize = setting.minRoomSize;
        maxIterations = setting.maxIterations;
        wallLayerName = setting.wallLayerName;
        floorPrefab = setting.floorPrefab;
    }
    
    public void GenerateMap() {
        map = new int[mapWidth, mapHeight];
        for (int x = 0; x < mapWidth; x++) {
            for (int y = 0; y < mapHeight; y++)
                map[x, y] = 1;
        }

        SplitSpace(0, 0, mapWidth, mapHeight, 0);
        
        ConnectRooms();
        
        InstantiateTiles();
        
        generateDone = true;
    }



    private void SplitSpace(int x, int y, int width, int height, int iteration)
    {
        if (iteration >= maxIterations || width < minRoomSize * 2 || height < minRoomSize * 2) {
            int roomWidth = Random.Range(minRoomSize, width - 4);
            int roomHeight = Random.Range(minRoomSize, height - 4);
            int roomX = x + Random.Range(2, width - roomWidth - 2);
            int roomY = y + Random.Range(2, height - roomHeight - 2);

            CreateRoom(roomX, roomY, roomWidth, roomHeight);
            rooms.Add(new BSPRoom(roomX, roomY, roomWidth, roomHeight));
            return;
        }

        bool splitHorizontal = Random.Range(0f, 1f) > 0.5f;
        if (width > height && width / height >= 1.25f) splitHorizontal = false;
        else if (height > width && height / width >= 1.25f) splitHorizontal = true;

        if (splitHorizontal) {
            int splitAt = Random.Range(minRoomSize, height - minRoomSize);
            SplitSpace(x, y, width, splitAt, iteration + 1);
            SplitSpace(x, y + splitAt, width, height - splitAt, iteration + 1);
        }
        else {
            int splitAt = Random.Range(minRoomSize, width - minRoomSize);
            SplitSpace(x, y, splitAt, height, iteration + 1);
            SplitSpace(x + splitAt, y, width - splitAt, height, iteration + 1);
        }
    }

    private void CreateRoom(int x, int y, int width, int height)
    {
        for (int i = x; i < x + width; i++) {
            for (int j = y; j < y + height; j++)
                if (i >= 0 && i < mapWidth && j >= 0 && j < mapHeight) map[i, j] = 0;
        }
    }

    private void ConnectRooms() {
        for (int i = 0; i < rooms.Count - 1; i++) {
            BSPRoom roomA = rooms[i];
            BSPRoom roomB = rooms[i + 1];

            Vector2Int pointA = new Vector2Int(
                roomA.x + roomA.width / 2,
                roomA.y + roomA.height / 2
            );
            Vector2Int pointB = new Vector2Int(
                roomB.x + roomB.width / 2,
                roomB.y + roomB.height / 2
            );
            
            CreateCorridor(pointA.x, pointA.y, pointB.x, pointA.y);
            CreateCorridor(pointB.x, pointA.y, pointB.x, pointB.y);
        }
    }

    private void CreateCorridor(int startX, int startY, int endX, int endY) {
        int x = startX;
        int y = startY;

        while (x != endX || y != endY)
        {
            if (x < endX) x++;
            else if (x > endX) x--;
            
            if (y < endY) y++;
            else if (y > endY) y--;

            if (x >= 0 && x < mapWidth && y >= 0 && y < mapHeight) {
                map[x, y] = 0;
                
                for (int i = -1; i <= 1; i++)
                {
                    for (int j = -1; j <= 1; j++)
                    {
                        int nx = x + i;
                        int ny = y + j;
                        if (nx >= 0 && nx < mapWidth && ny >= 0 && ny < mapHeight)
                            map[nx, ny] = 0;
                    }
                }
            }
        }
    }

    private void InstantiateTiles()
    {
        GameObject wallParent = new GameObject("Walls");
        GameObject floorParent = new GameObject("Floors");
        wallParent.transform.parent = transform;
        floorParent.transform.parent = transform;

        wallParent.layer = LayerMask.NameToLayer("Wall");
        floorParent.layer = LayerMask.NameToLayer("Floor");

        for (int x = 0; x < mapWidth; x++)
        {
            for (int y = 0; y < mapHeight; y++)
            {
                Vector3 position = new Vector3(x, y, 0);
                if (map[x, y] == 1)
                {
                    GameObject wall = Instantiate(setting.tilePrefab, position, Quaternion.identity, wallParent.transform);
                    wall.layer = LayerMask.NameToLayer("Wall");

                    SpriteRenderer wallRenderer = wall.GetComponent<SpriteRenderer>();
                    if (wallRenderer != null)
                    {
                        WallType wallType = DetermineWallType(x, y);
                        ApplyWallSprite(wallRenderer, wallType);
                        
                        wallRenderer.sortingLayerName = setting.wallTileSettings.sortingLayerName;
                        wallRenderer.sortingOrder = setting.wallTileSettings.sortingOrder;
                    }

                    Collider2D collider = wall.GetComponent<Collider2D>();
                    if (collider != null)
                        collider.isTrigger = false;
                }
                else
                {
                    GameObject floor = Instantiate(setting.floorPrefab, position, Quaternion.identity, floorParent.transform);
                    floor.layer = LayerMask.NameToLayer("Floor");

                    SpriteRenderer floorRenderer = floor.GetComponent<SpriteRenderer>();
                    if (floorRenderer != null)
                    {
                        floorRenderer.sortingLayerName = "Floor";
                        floorRenderer.sortingOrder = 0;
                    }
                }
            }
        }
    }

    private WallType DetermineWallType(int x, int y)
    {
        bool up = IsWall(x, y + 1);
        bool down = IsWall(x, y - 1);
        bool left = IsWall(x - 1, y);
        bool right = IsWall(x + 1, y);
        
        // 대각선 방향도 확인
        bool upLeft = IsWall(x - 1, y + 1);
        bool upRight = IsWall(x + 1, y + 1);
        bool downLeft = IsWall(x - 1, y - 1);
        bool downRight = IsWall(x + 1, y - 1);

        // 단독 벽
        if (!up && !down && !left && !right)
            return WallType.Single;

        // 내부 모서리 검사 (벽이 안쪽으로 꺾이는 경우)
        if (up && right && !upRight) return WallType.CornerInnerTopRight;
        if (up && left && !upLeft) return WallType.CornerInnerTopLeft;
        if (down && right && !downRight) return WallType.CornerInnerBottomRight;
        if (down && left && !downLeft) return WallType.CornerInnerBottomLeft;

        // 외부 모서리 검사 (벽이 바깥쪽으로 꺾이는 경우)
        if (!up && !left && right && down) return WallType.CornerOuterTopLeft;
        if (!up && !right && left && down) return WallType.CornerOuterTopRight;
        if (!down && !left && right && up) return WallType.CornerOuterBottomLeft;
        if (!down && !right && left && up) return WallType.CornerOuterBottomRight;

        // 끝부분 검사
        if (up && !down && !left && !right) return WallType.EndBottom;
        if (!up && down && !left && !right) return WallType.EndTop;
        if (!up && !down && left && !right) return WallType.EndRight;
        if (!up && !down && !left && right) return WallType.EndLeft;

        // 테두리 검사
        if (!up && down) return WallType.Top;
        if (up && !down) return WallType.Bottom;
        if (!left && right) return WallType.Left;
        if (left && !right) return WallType.Right;

        return WallType.Default;
    }

    private void ApplyWallSprite(SpriteRenderer renderer, WallType type)
    {
        var sprites = setting.wallTileSettings.sprites;
        
        switch (type)
        {
            case WallType.Single:
                renderer.sprite = sprites.singleWall;
                break;
            case WallType.Top:
                renderer.sprite = sprites.wallTop;
                break;
            case WallType.Bottom:
                renderer.sprite = sprites.wallBottom;
                break;
            case WallType.Left:
                renderer.sprite = sprites.wallLeft;
                break;
            case WallType.Right:
                renderer.sprite = sprites.wallRight;
                break;
            case WallType.CornerOuterTopLeft:
                renderer.sprite = sprites.cornerOuterTopLeft;
                break;
            case WallType.CornerOuterTopRight:
                renderer.sprite = sprites.cornerOuterTopRight;
                break;
            case WallType.CornerOuterBottomLeft:
                renderer.sprite = sprites.cornerOuterBottomLeft;
                break;
            case WallType.CornerOuterBottomRight:
                renderer.sprite = sprites.cornerOuterBottomRight;
                break;
            case WallType.CornerInnerTopLeft:
                renderer.sprite = sprites.cornerInnerTopLeft;
                break;
            case WallType.CornerInnerTopRight:
                renderer.sprite = sprites.cornerInnerTopRight;
                break;
            case WallType.CornerInnerBottomLeft:
                renderer.sprite = sprites.cornerInnerBottomLeft;
                break;
            case WallType.CornerInnerBottomRight:
                renderer.sprite = sprites.cornerInnerBottomRight;
                break;
            case WallType.EndTop:
                renderer.sprite = sprites.endTop;
                break;
            case WallType.EndBottom:
                renderer.sprite = sprites.endBottom;
                break;
            case WallType.EndLeft:
                renderer.sprite = sprites.endLeft;
                break;
            case WallType.EndRight:
                renderer.sprite = sprites.endRight;
                break;
            default:
                renderer.sprite = sprites.defaultWall;
                break;
        }
        
    }

    private bool IsWall(int x, int y)
    {
        if (x < 0 || x >= mapWidth || y < 0 || y >= mapHeight)
            return false;
        return map[x, y] == 1;
    }

   

    public bool isDone()
    {
        return generateDone;
    }
    
    
    public BSPRoom GetRoomFromPosition(Vector2 position)
    {
        if (!generateDone)
        {
            Debug.LogWarning("Map generation is not complete. Cannot find room.");
            return null;
        }

        return rooms.FirstOrDefault(room =>
            position.x >= room.x && position.x < room.x + room.width &&
            position.y >= room.y && position.y < room.y + room.height);
    }


    public BSPRoom GetRoomFromTransform(Transform transform)
    {
        if (transform == null) return null;
        return GetRoomFromPosition(new Vector2(transform.position.x, transform.position.y));
    }
    
    
 

    


    private void OnDrawGizmos()
    {
        if (!debug) return;
        if (map == null) return;

        for (int x = 0; x < mapWidth; x++) {
            for (int y = 0; y < mapHeight; y++) {
                if (map[x, y] == 1)
                    Gizmos.color = Color.black;
                else
                    Gizmos.color = Color.white;
                Vector3 pos = new Vector3(x, y, 0);
                Gizmos.DrawCube(pos, Vector3.one);
            }
        }
    }
}

<center> 구현 영상

여기까지 기본적인 맵 생성이였구. 다음 포스트에서 아이템 배치와 다른 지형 배치 등을 다루는 코드를 이어서 작성하도록 하겠습니다.

수고하셨습니다.

Reference

Compy Blog

[Algorithm] 벨만-포드 알고리즘(Bellman-Ford Algorithm)

Wed, 12 Mar 2025 00:00:00 GMT

보통 많이 사용하는 그래프 탐색 알고리즘은 다익스트라가 있죠?

그런데 다익스트라는 음수 가중치가 있을 때 사용하지 못합니다... 왜냐! 보통 작은 값들로 업데이트하는데 음수가 들어가버리면 무한 사이클이 발생하니까요.. 이런 그리디한 특성 때문에 처리가 안되는데 벨만-포드는 그걸 처리할 수 있다니까요?!

그래서 벨만-포드가 뭐냐!

벨만-포드 알고리즘

가중치가 있는 그래프에서 한 정점으로부터 다른 모든 정점까지의 최단 경로를 찾는 알고리즘!

기본적인 아이디어

출발 정점의 거리를 0으로 초기화
다른 모든 정점까지의 거리를 무한대로 초기화
모든 간선에 대해 완화(relaxation) 작업을 수행하는 과정을 (정점 수 - 1)번 반복
음수 사이클 검사를 위해 한 번 더 모든 간선을 확인

완화(Relaxation) 연산

완화 연산은 벨만-포드 알고리즘의 핵심 작업입니다. 정점 u에서 정점 v로 가는 간선 (u, v)의 가중치가 w일 때...

if distance[u] + w < distance[v] then
distance[v] = distance[u] + w
predecessor[v] = u

이 연산은 "정점 u를 경유하여 정점 v로 가는 경로가 현재까지 알려진 v까지의 최단 경로보다 짧다면, 최단 경로를 갱신한다"라는 의미!

그럼 중요한 것들을 알아보죠!

시간 복잡도 및 공간 복잡도

시간 복잡도

최악의 경우: O(VE)
초기화: O(V)
완화 작업: O(VE) (V-1번 반복하면서 각 반복마다 E개의 간선 검사)
음수 사이클 검사: O(E)

공간 복잡도

O(V + E)
- 거리 배열과 선행자 배열: O(V)
- 그래프 표현: O(E)

비교해볼까? with Dijkstra

특성	벨만-포드	다익스트라
시간 복잡도	O(VE)	O(E log V) (priority_queue 사용 시)
음수 가중치	처리 가능	처리 불가능
음수 사이클	감지 가능(처리 가능)	무한 루프 발생
구현 난이도	상대적으로 간단함	상대적으로 쬐끔 복잡함
적합한 상황	음수 가중치가 있는 상황 또는	모든 가중치가 양수인 상황

</center>

그러면 약간 효율이 안 좋아보이긴 합니다.. 그죠? 그래서 최적화 기법들이 여럿 있는데요!

일단 제일 유명한 것들부터 알아봅시다.

1. SPFA(Shortest Path Faster Algorithm)

벨만-포드의 변형으로, 큐를 사용하여 완화될 필요가 있는 정점만 처리합니다.

이거는 사실 찾아보면서 알게된 것인데.. 이게 따로 이름이 있었네요..?

from collections import deque

def spfa(graph, source):
    distance = {vertex: float('infinity') for vertex in graph}
    predecessor = {vertex: None for vertex in graph}
    distance[source] = 0
    
    queue = deque([source])
    in_queue = {vertex: False for vertex in graph}
    in_queue[source] = True
    
    while queue:
        u = queue.popleft()
        in_queue[u] = False
        
        for v, weight in graph[u]:
            if distance[u] + weight < distance[v]:
                distance[v] = distance[u] + weight
                predecessor[v] = u
                if not in_queue[v]:
                    queue.append(v)
                    in_queue[v] = True
    
    # 음수 사이클 검사 부분 생략...
    
    return distance, predecessor

2. 조기 종료(Early Stop)

음.. 무슨 인공지능 학습도 아니고.. ㅋㅋ 그냥 이거는 코드 짜다보면 보이니까 굳이 따로 보진 않겠습니다. 아마 코드를 작성하다보면 당연히 짜게 되실테니..

그러면 좀 질문해볼만한 것들을 해볼까요??

조금 더 깊게..

Q1: 벨만-포드 알고리즘의 (정점 수 - 1)번 반복이 필요한 이유는 무엇인가요?

A: 최악의 경우, 한 정점에서 다른 정점으로 가는 최단 경로는 최대 (정점 수 - 1)개의 간선을 포함할 수 있습니다. 각 반복마다 최소한 하나의 정점에 대한 최단 경로가 확정되므로, (정점 수 - 1)번의 반복 후에는 모든 최단 경로가 확정됩니다.

Q2: SPFA는 항상 벨만-포드보다 빠른가요?

A: 평균적으로는 SPFA가 더 빠르지만, 최악의 경우에는 여전히 O(VE)의 시간 복잡도를 가집니다. 특정한 그래프 구조에서는 오히려 더 느릴 수도 있습니다. 물론!? 대부분 사용하는게 좋겠죠..? 최적화를 위해서는 말이죠

연습 문제를 떨구고 가겠습니다.

웜홀 이거 한번 츄라이 츄라이

[Algorithm] 다익스트라 알고리즘

Wed, 03 Jul 2024 00:00:00 GMT

:::note[주의] 이 포스팅은 "큐(Queue), BFS(너비우선탐색), 그래프(Graph theory), 힙(Heap)"에 대한 이해가 필요합니다. :::

일단 가중치가 없는 그래프에서는 DFS, BFS는 갈 수 있는 노드를 탐색하는 과정을 하는데, 다익스트라 알고리즘은 가장 빨리 도착할 수 있을 때, 얼마나 빠르게? 어떻게(경로)를 알 수 있다. 이것을 네비게이션으로 에를 든다면, 네비게이션은 길을 찾을 때 여러가지 변수를 고려한다. 이동거리, 시간, 경제적 비용, 혼잡도 등이 될 수 있다. 이런 변수들을 고려한 알고리즘이 바로 다익스트라 알고리즘이다. 즉 다시말해서 Dijkstra 알고리즘은 BFS알고리즘을 확장하여 사용하는 최소비용 경로를 탐색하는 알고리즘이다.

다익스트라 알고리즘은 특정 노드에서 갈 수 있는 모든 노드들까지의 최단 경로를 구하는 알고리즘이다. 각 노드들은 고유한 비용(cost), 부모(parent)를 가지고 있다.

이 그래프를 가지고 설명하도록 하겠다. </center>

우선 간선(edge) 옆에 써져있는 숫자를 비용이라고 하겠다.

만약 시작 노드를 이정훈이라고 했을때, "이정훈"을 기준으로 박찬규는 최소 비용으로 4만큼 떨어져있다. 만약 시작 노드를 유한별이라고 했을때, "유한별"을 기준으로 박찬규는 최소 비용으로 2만큼 떨어져있다.

즉 비용 및 부모는 시작 노드에 따라서 결과가 바뀔 수 있다나느 것을 의미한다.

큐를 이용해 현재 노드에서 갈 수 있는 모든 노드들을 큐에 넣는다. 큐에서 다시 넣었던 노드를 빼내고 현재의 가중치를 저장한다. 만약 다시 같은 노드를 방문한다면 이전에 기록했던 가중치와 비교하여 작다면 갱신하고, 아니면 무시한다.

이때 위의 방법을 쓴다면 노드 수가 굉장히 많은 경우에는 비효율적일 것이다.

계속해서 더 이상 확인이 필요없는 이미 방문한 노드를 방문비교하는데, 노드 수가 많다면 그 비교 횟수가 많아질 것이다. 즉 모든 노드를 돌면서 먼저 가중치 상관없이 노드를 방문하고 다시 비교하고 이동할 때마다 비교를 하기 때문에 효율이 너무 떨어진다.

이런 문제를 해결하기 위해서 우선순위 큐를 사용하여 최적화한다. 이는 힙큐를 통해서 구현할 수 있다.

</center>

아래의 표는 행은 순서, 열은 순서대로 Queue의 상태, 현재 Cost의 상태, Parents의 상태를 각각 나타낸다.

오른쪽의 그래프를 Heap 큐를 이용해 다익스트라 알고리즘으로 유한별에서 이정훈을 탐색할 때의 과정이다.

과정에서 중간에 끊기는데 이유는 목표 노드에 도착했기 때문에 다음 노드를 탐색할 필요 없이 코드가 끝난 상황이다.

:::note[정의]

inf = float('inf') # infinity

Cost: 현재 자신의 최소 방문 비용을 저장하고 있는 리스트(또는 배열) Paraents: 자신을 최소 비용으로 방문한 노드 :::

	Queue(Heap)	Cost	Parents
1	(0, 유한별)	[None, inf, inf, inf, inf]	[None, None, None, None, None]
2	(1, 이재영), (2, 박찬규)	[None, inf, inf, inf, inf]	[None, None, None, None, None]
3	(2, 박찬규), (4, 유채호)	[None, inf, 1, inf, inf]	[None, None, 유한별, None, None]
4	(3, 유채호), (4, 유채호), (9, 이정훈)	[None, 2, 1, inf, inf]	[None, 유한별, 유한별, None, None]
5	(4, 유채호), (6, 이정훈), (9, 이정훈)	[None, 2, 1, inf, 3]	[None, 유한별, 유한별, None, 박찬규]
6	(6, 이정훈), (9, 이정훈)	[None, 2, 1, inf, 3]	[None, 유한별, 유한별, None, 박찬규]
7	(9, 이정훈)	[None, 2, 1, 6, 3]	[None, 유한별, 유한별, 유채호, 박찬규]

그래서 결과는 유한별에서 이정훈으로 갈 때 최소비용은 6, 경로는: 유한별->박찬규->유채호->이정훈이다.

이제 요것을 코드로 다 구현을 해볼것이다.

nodes = ["유한별", "박찬규", "이정훈", "이재영", " 유채호"]<br>
graph = [[(1, 2), (3, 1)], [(2, 7), (4, 1)], [], [(4, 3)], [(2, 3)]]  # node_idx, cost

저 그래프를 코드화 시켜보았다.

이제 로직을 코드로 구현해보자

def solution(start_node, target_node):
    global nodes, graph # 위에서 선언한 nodes와 graph를 가져옴

    inf = float('inf') #inf 무한 선언

    parents = [None, None, None, None, None] # 부모 리스트 선언
    cost = [inf, inf, inf, inf, inf] # 모든 노드들의 시작 노드를 기준으로 최적의 가중치를 저장할 리스트

    q = [(0, start_node)] # 큐 선언 및 초기화
    while q: # 큐가 비어있을 때까지 반복
        current_cost, node = heapq.heappop(q) # 현재 가중치, 현재 노드
        if current_cost > cost[node]: continue # 빙믄힐 노드의 등록된 최소 비용보다 크면 무시
        cost[node] = current_cost
        for idx, cost_ in graph[nodes.index(node)]: #현재 노드에서 갈 수 있는 노드와 그 가중치를 가져옴. (딕셔너리로 작성시 최적화 가능)
            if cost_ + current_cost < cost[idx]: # 현재 가중치와 움직일 노드의 가중치를 더한것이 가는 노드의 가중치보다 작으면 go
                parents[idx] = node # 움직일 노드의 부모를 현재 노드로 업데이트
                cost[idx] = cost_+current_cost
                heapq.heappush(q, (cost_+current_cost, nodes[idx])) # 힙큐 push
        if node == target_node: break # 목표 노드에 도착하면 break

    target = nodes.index(target_node)
    path = target_node+" " # path를 문자열로 이어 붙여 저장
    result_cost = cost[target]
    
    while parents[target]!=None: # 현재 노드의 부모가 None이 아닐때까지
        v = parents[target] != None #현재 노드의 부모가 None이 아닐때까지
        path += v+" " # 문자열 이어 붙이기
        target = nodes.index(v) # 현재 노드로 target을 저장
        
    return f"최적의 경로: {path}, 도착 최소 비용은: {target_node} 입니다."

제가 다익스트라를 조금 시각적으로 볼 수 있도록 파이게임을 이용해서 시각화를 하였습니다.

(0,0)이 시작점입니다.

초록색은 움직일 수 있는 땅
하늘색은 탐색한 땅
빨간색은 갈 수 없는 땅
회색은 목표까지의 최적의 경로

(시간도 된다면, A*도 해보겠습니다)

import pygame, sys, os
# from tkinter import *

win_width, win_height = 400, 400  # 가로 세로 400 400
rows, cols = 12, 12  # 세로 가로 / 행과 열
win = pygame.display.set_mode((win_width, win_height))  # (width, height)
pygame.display.set_caption("(그리드 & 다익스트라) 알고리즘")
grid_width, grid_height = win_width // cols, win_height // rows

target_flag = False  # 목표물이 설정되지 않은 상태
WHITE = (255, 255, 255)  # r, g, b


class Box:
    # __init__
    # 필요한것
    # x, y 좌표(위치)
    # start, goal, wall인지
    def __init__(self, x, y, block_width, block_height):
        self.x, self.y = x, y
        self.color = (0, 255, 0)

        self.cost = float('inf')

        self.width, self.height = block_width, block_height
        self.start, self.goal, self.wall = False, False, False
        self.path = False
        self.visited = False
    def setcolor(self, color): self.color = color

    def draw(self, mywin):
        # color = (0, 255, 0)
        pos = (self.x, self.y, self.width - 2.5, self.height - 2.5)
        pygame.draw.rect(mywin, self.color, pos)
import heapq
def dij(g, finish_x, finish_y):
    result_path = []
    result_cost = float('inf')
    q = [(0, 0, 0, [], g[0][0])]
    dx, dy = [0, 0, -1, 1], [1, -1, 0, 0]
    xlen, ylen = len(g[0]), len(g)
    while q:
        cost, x, y, path, bx = heapq.heappop(q)
        if bx.wall == True or \
                result_cost <= cost or bx.cost <= cost: continue
        g[x][y].cost = cost
        bx.cost = cost
        if (x, y) == (finish_x, finish_y):
            if result_cost > cost:
                result_cost = cost
                result_path = path
        for i in range(4):
            nx, ny = x + dx[i], y + dy[i]
            if 0 <= nx < xlen and 0 <= ny < ylen:
                heapq.heappush(q, (cost + 1, nx, ny, path + [(x, y)], g[nx][ny]))
        bx.setcolor((0, 255, 255))
        for i in g:
            for j in i:
                j.draw(win)

        # win.fill(WHITE) #(r,g,b)
        # pygame.display.update(win)
        pygame.display.flip()
        pygame.time.delay(100)
    return result_path if result_cost != float('inf') else None

def makit():
    global target_flag
    # 그래픽 처리는 무조건 refresh 화면을 계속 찍는것
    g = []  # grids
    for i in range(cols):
        temp = []
        for j in range(rows):
            temp.append(Box(i * grid_width, j * grid_height, grid_width, grid_height))  # object 넣기
        g.append(temp)
    start_box = g[0][0]
    start_box.visited = True
    start_box.start = True
    start = False
    q = [start_box]
    target_pos = (0, 0)
    isRun = True
    while isRun:
        # 이벤트.. 이벤트 프로그래밍..  in cs
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()  # system
            elif event.type == pygame.MOUSEMOTION:
                position = pygame.mouse.get_pos()  # (x, y) 현재 마우스의 위치를 return함 tuple의 형태로
                x, y = position
                x, y = x // grid_width, y // grid_height
                if event.buttons[0]:  # 왼쪾 마우스가 클릭되면
                    print(f"방해물 설정 중 : 좌표 x = {x}, y = {y}")
                    if (x, y) == target_pos or (x, y) == (0, 0): continue
                    g[x][y].setcolor((255, 0, 0))
                    g[x][y].wall = True
                # 1번은 마우스 휠
                elif event.buttons[2] and target_flag == False:  # 오른쪽 마우스 클릭되면
                    print(f"목표물 설정 : 블럭 좌표 x = {x}, y = {y}")
                    g[x][y].setcolor((0, 0, 255))
                    g[x][y].goal = True
                    target_pos = (x, y)
                    target_flag = True
            elif event.type == pygame.KEYDOWN and target_flag == True:  # 키가 눌렸다면 실행
                print('알고리즘 시작')
                start = True
                g[0][0].start = True
                isRun = False
                nf = dij(g, target_pos[0], target_pos[1])
                if nf == None: return "경로 없음"
                else:
                    for (x,y) in nf:
                        g[x][y].setcolor((100,100,100))

        for i in g:
            for j in i:
                j.draw(win)

        # win.fill(WHITE) #(r,g,b)
        # pygame.display.update(win)
        pygame.display.flip()
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()  # system
        for i in g:
            for j in i:
                j.draw(win)
    return

</details>

[Algorithm] Heuristic

Fri, 10 Jan 2025 00:00:00 GMT

보통 우리가 알고리즘을 짤 때, 하나를 당연하게 생각한다. 바로 "언제나 정확히 최적화된 해를 반환한다"라고 생각합니다.

그러나 그렇지 않은 알고리즘들도 있는데, 그중 대표적인 것이 A*이다. 이 알고리즘은 휴리스틱을 기반으로 작동합니다.

휴리스틱은 도대체 뭐고... 알고리즘과의 차이는 뭘까? 이 포스팅에서 다뤄볼 것에요! (약간 말투가 이 포스팅만 다를 수 있어요)

휴리스틱이란?

휴리스틱(Heuristic)은 최적의 해는 아니더라도, 어느정도 도움이 되는 값을 주는 친구라고 생각하면 됩니당

?? 알고리즘이랑 똑같은거 아님?

엄연한 차이가 있어요. 위에서도 강조하면서 왔듯이... 휴리스틱은 최적해를 보장하지 않는다.. 하지만 알고리즘은 최적해를 보장하는 방법론입니다.

한가지 예시를 들어보자. 한번 축구로 예시를 들어볼게요 이 영상을 보다가 문득 오... 휴리스틱이랑 알고리즘이랑 차이점을 다뤄봐도 재밌겠다. 라고 생각을하고 바로 포스팅하러 달려왔습니다. 또 제가 축구를 좋아하니.. 예시도 축구로 들어보도록 하죠.

일단 제가 수비라인에 있다고 생각을 해볼게요. 그러면 상대팀이 압박을 해옵니다. 이제 어디론가 패스를 해야겠죠?

먼저 알고리즘적으로 생각을 해볼게요. 모든 팀원의 위치와 속도 벡터를 다 고려합니다. 여기서 속도 벡터는 방향까지 본다는 얘기구요. 그리고 상태팀의 위치와 이동 경로도 알아야겠죠?
그리고 어느 발로 때렸을 때 성공 확률을 좀 계산을 해야겠구요.
이후에 최적의 패스 경로와 강도를 계산해서 패스를 합니다!

이처럼 완벽한 최적해를 만들어내고 패스를 하죠!

그럼 다음으로는 휴리스틱적으로 생각을 해볼게요?

휴리스틱으로 한번 "공간이 많이 보이는 곳을 패스한다" 해보구요 안되면 "압박이 적은 선수에게 패스한다" 또 안되면 "수비수 시선이 다른 곳으로 볼 때 패스한다" 이런 느낌으로 진행이 되겠죠?

이 예시가 적절하다고 생각은 들지는 않는데 한번 더 강조하지만

최적해는 아니지만 이게 어느정도 도움이 된다. 최적해에 근접할 수 있도록 해준다 라고 생각하면 좋을 것 같아요.

이제 영상을 보시면 나중에 인공지능으로 만들어진 클론들은 축구 경기에서 지게됩니다. 이처럼 좀 헤비한 연산이 많은 알고리즘 같은 경우에 real-time이 필요한 경우 알고리즘을 휴리스틱으로 대체하는 경우도 많다고 알고있는데요.

선수들은 사실 많은 경험을 토대로 구축된 효율적인 휴리스틱을 뇌에 탑제하고 있다고 생각하시면 되는거죠.

뭐 디게 단순하게 휴리스틱 써서 A* 구현한 포스팅이 있으니 이걸 한번 보고 오시면 코드로 구현하는데 어렵지 않으실 겁니다!

A* 알고리즘 - COMPY07

여러분들도 뭔가 유튜브나 어떤 영상을 보고서 느껴본 차이점이나 흥미로운 것들이 있으셨나요? 저는 또 재미있는걸 봐버렸습니다.

다음 포스팅에 뵙도록 하죠!

[Algorithm] 벡터(Vector)

Sun, 30 Mar 2025 00:00:00 GMT

안녕하세요! 오늘은 수학의 핵심 개념인 벡터(Vector) 에 대해 알아보려고 합니다. 벡터는 물리학, 컴퓨터 그래픽스, 공학에서 필수적! 그냥 컴퓨터 하시면 알아야될 놈이구요. 이번 포스팅에서는 벡터의 개념과 기본적으로 알아두면 많이 쓸 외적, 내적 등에 대해서 알아보겠습니다.

1. 벡터란 무엇인가?

벡터는 크기(magnitude) 와 방향(direction) 을 모두 가진 양을 의미합니다. 일상생활에서 예를 들자면

"북쪽으로 5km" (방향: 북쪽, 크기: 5km)
"시속 60km로 동쪽으로 이동" (방향: 동쪽, 크기: 시속 60km)

이런 정보들이 모두 벡터로 표현될 수 있습니다.

반면에 스칼라(scalar)는 크기만 있고 방향이 없는 양입니다

온도: 25°C
질량: 5kg
시간: 3시간

1.1 벡터의 수학적 표현

수학적으로 벡터는 여러 방식으로 표현할 수 있습니다

화살표 표기법: $$\vec{v}$$
좌표 표기법:
- 2차원: $$\mathbf{v} = (x, y)$$
- 3차원: $$\mathbf{v} = (x, y, z)$$
- n차원: $$\mathbf{v} = (x_1, x_2, ..., x_n)$$

1.2 벡터의 기본 연산

벡터의 크기(norm)

벡터 $$\mathbf{v} = (x, y, z)$$의 크기는 다음과 같이 계산합니다 <center>

$$\huge |\mathbf{v}| = \sqrt{x^2 + y^2 + z^2}$$ </center>

벡터의 덧셈

두 벡터 $$\mathbf{a} = (a_1, a_2, a_3)$$와 $$\mathbf{b} = (b_1, b_2, b_3)$$의 덧셈

$$\huge \mathbf{a} + \mathbf{b} = (a_1 + b_1, a_2 + b_2, a_3 + b_3)$$ </center>

출처 : 힘과 평형

</center>

덧셈의 기하학적 의미는 두 벡터를 이어붙이는 것 입니다. 첫 번째 벡터의 끝에서 두 번째 벡터를 이어서 그리면, 시작점에서 최종 도착점까지의 벡터가 두 벡터의 합이 됩니다 . 이를 "삼각형 법칙" 또는 "평행사변형 법칙"이라고 합니다. (이거는 아마 제가 배우는 당시 2015 교육과정에서는 물2 에서 배웠던 걸로 기억합니다.)

벡터의 뺄셈

두 벡터 $$\mathbf{a} = (a_1, a_2, a_3)$$와 $$\mathbf{b} = (b_1, b_2, b_3)$$의 뺄셈 <center>

$$\huge \mathbf{a} - \mathbf{b} = (a_1 - b_1, a_2 - b_2, a_3 - b_3)$$ </center>

출처 : 벡터의 뺄셈

</center>

뺄셈의 기하학적 의미는 벡터 $$\mathbf{a}$$에서 벡터 $$\mathbf{b}$$로의 변화 입니다. 두 점 사이의 방향과 거리를 나타내는 벡터를 구할 때 자주 사용되는 걸로 알고 있어요.

스칼라 곱셈

벡터 $$\mathbf{v}$$에 스칼라 $$k$$를 곱한 결과는

$$\huge k\mathbf{v} = (kx, ky, kz)$$ </center>

스칼라 곱셈은 벡터의 크기를 $$\mathbf{k}$$배 변화시킵니다.

단위 벡터(Unit Vector)

크기가 1인 벡터를 단위 벡터라고 합니다. 임의의 벡터 $$\mathbf{v}$$를 단위 벡터로 변환하는 과정을 정규화(normalization) 라고 합니다. 아래와 같이 계산할 수 있습니다.

$$\huge \hat{\mathbf{v}} = \frac{\mathbf{v}}{|\mathbf{v}|}$$ </center>

단위 벡터는 방향만 중요할 때 유용하게 사용됩니다. 이거는 아마 인공지능 아니면 게임 개발할 대 많이 보셨던 것들이라 익술할거라고 생각합니다.(물론 하셨던 분들에게만)

2. 벡터의 내적(Dot Product)

벡터의 내적은 두 벡터의 방향 관계와 크기를 모두 고려한 연산으로, 매우 중요한 개념입니다!

2.1 내적의 정의

두 벡터 $$\mathbf{a} = (a_1, a_2, a_3)$$와 $$\mathbf{b} = (b_1, b_2, b_3)$$의 내적은

$$\huge \mathbf{a} \cdot \mathbf{b} = a_1b_1 + a_2b_2 + a_3b_3$$ </center>

또는 크기와 각도를 이용해서.. <center>

$$\huge \mathbf{a} \cdot \mathbf{b} = |\mathbf{a}||\mathbf{b}|\cos\theta$$ </center>

여기서 $$\theta$$는 두 벡터 사이의 각도입니다.

좀 더 공부좀 해오겠씁니다... ㅠ //: # () //: # (### 2.2 내적의 기하학적 의미)

</details>

3. 벡터의 외적(Cross Product)

외적은 3차원 공간에서 두 벡터에 수직인 새로운 벡터를 생성하는 연산입니다.

3.1 외적의 정의

두 벡터 $$\mathbf{a} = (a_1, a_2, a_3)$$와 $$\mathbf{b} = (b_1, b_2, b_3)$$의 외적은

$$\huge \mathbf{a} \times \mathbf{b} = (a_2b_3 - a_3b_2, a_3b_1 - a_1b_3, a_1b_2 - a_2b_1)$$ </center>

행렬식으로도 계산할 수 있습니다

$$ \huge \mathbf{a} \times \mathbf{b} = \begin{vmatrix} \mathbf{i} & \mathbf{j} & \mathbf{k} \ a_1 & a_2 & a_3 \ b_1 & b_2 & b_3 \end{vmatrix} $$

여기서 $$\mathbf{i}$$, $$\mathbf{j}$$, $$\mathbf{k}$$는 x, y, z축 방향의 단위 벡터입니다.

또한 외적의 크기는 다음과 같이 계산할 수 있습니다 $$|\mathbf{a} \times \mathbf{b}| = |\mathbf{a}||\mathbf{b}|\sin\theta$$

여기서 $$\theta$$는 두 벡터 사이의 각도입니다.

좀 더 공부를...

</details>

지금 채워지지 않은 내용들은 추후에 업데이트 하겠습니다.

사실 CCW 포스팅하려고 하다가 그것보다 벡터를 선행적으로 포스팅하는게 좋다고 생각되어 이렇게 오게되었는데.. 이거 하다보니 이제는 행렬도 해야겠다는 생각이 드네요!

모두 수고하셨습니다!

[Algorithm] 피보나치 수열의 재미있는 수학적 사실들

Sat, 15 Feb 2025 00:00:00 GMT

제가 어제 풀었던 문제 중 피보나치 수 6라는 문제가 있었는데요. 제가 발견한 그 규칙이 사실 어떤 공식으로 이미 있더라구요!?!

역시 있을 줄 알았습니다. 찾아보길 잘했어요.

혹시나 더욱 많은 공식을 원하시다면 여기에서 확인 할 수 있어요! 디게 재밌으니 한번 다들 작성해보는 것도 괜찮을 것 같네요!

일단 사실 도가뉴 항등식이라는 것을 배우려고 했으나 다른 것들도 재미있게 해볼 수 있을 것 같아서 한번 다 다뤄보려구요!

1. 카시니 항등식 (Cassini's Identity)

$$ \LARGE F_{n+1}F_{n-1} - F_n^2 = (-1)^n $$ </center>

증명

기본 검증표

n	계산식	단계별 계산	최종 결과	$$ (-1)^n $$
3	F₄F₂ - F₃²	3 × 1 - 2² = 3 - 4	-1	(-1)³ = -1
4	F₅F₃ - F₄²	5 × 2 - 3² = 10 - 9	1	(-1)⁴ = 1

확장된 검증표

n	$$ F_{n-1} $$	$$ F_n $$	$$ F_{n+1} $$	$$ F_{n+1}F_{n-1} - F_n² $$	$$ (-1)^n $$
1	0	1	1	1 × 0 - 1² = -1	(-1)¹ = -1
2	1	1	2	2 × 1 - 1² = 1	(-1)² = 1
3	1	2	3	3 × 1 - 2² = -1	(-1)³ = -1
4	2	3	5	5 × 2 - 3² = 1	(-1)⁴ = 1
5	3	5	8	8 × 3 - 5² = -1	(-1)⁵ = -1

$$ \LARGE \begin{bmatrix} F_{n+1} & F_n \ F_n & F_{n-1} \end{bmatrix} = \begin{bmatrix} 1 & 1 \ 1 & 0 \end{bmatrix}^n $$

$$ \LARGE det\begin{bmatrix} F_{n+1} & F_n \ F_n & F_{n-1} \end{bmatrix} = F_{n+1}F_{n-1} - F_n^2 = (-1)^n $$

행렬식을 계산하는 것으로도 항등식을 증명할 수 있어요

:::note[깨알 상식]

<code>det</code>은 2×2 행렬의 행렬식은 대각선 곱의 차이로 계산 :::

2. 도가뉴 항등식 (d'Ocagne's Identity)

저는 일단 오늘 포스팅의 포커스를 도가뉴에 맞추기 때문에 더욱 좀 자세히 가져왔습니다.

$$ \LARGE F_{m+n} = F_m F_{n+1} + F_{m-1}F_n $$

2.1. 행렬을 이용한 증명

$$ \begin{bmatrix} F_{k+1} & F_k \ F_k & F_{k-1} \end{bmatrix} = \begin{bmatrix} 1 & 1 \ 1 & 0 \end{bmatrix}^k $$

이제 k = m+n일 때를 생각해보면

$$ \begin{bmatrix} F_{m+n+1} & F_{m+n} \ F_{m+n} & F_{m+n-1} \end{bmatrix} = \begin{bmatrix} 1 & 1 \ 1 & 0 \end{bmatrix}^{m+n} $$

여기서 중요한 성질은 행렬의 거듭제곱 법칙입니다요

$$ \begin{bmatrix} 1 & 1 \ 1 & 0 \end{bmatrix}^{m+n} = \begin{bmatrix} 1 & 1 \ 1 & 0 \end{bmatrix}^m \begin{bmatrix} 1 & 1 \ 1 & 0 \end{bmatrix}^n = \begin{bmatrix} F_{m+1} & F_m \ F_m & F_{m-1} \end{bmatrix} \begin{bmatrix} F_{n+1} & F_n \ F_n & F_{n-1} \end{bmatrix} $$

그래서 이제 각각의 행렬을 보면 아래오 같습니다.

$$ \begin{bmatrix} 1 & 1 \ 1 & 0 \end{bmatrix}^m = \begin{bmatrix} F_{m+1} & F_m \ F_m & F_{m-1} \end{bmatrix} $$

$$ \begin{bmatrix} 1 & 1 \ 1 & 0 \end{bmatrix}^n = \begin{bmatrix} F_{n+1} & F_n \ F_n & F_{n-1} \end{bmatrix} $$

이 두 행렬을 곱하면

$$ \begin{bmatrix} F_{m+1}F_{n+1} + F_mF_n & F_{m+1}F_n + F_mF_{n-1} \ F_mF_{n+1} + F_{m-1}F_n & F_mF_n + F_{m-1}F_{n-1} \end{bmatrix} = \begin{bmatrix} F_{m+n+1} & F_{m+n} \ F_{m+n} & F_{m+n-1} \end{bmatrix} $$

결과적으로는 아래의 결과를 확인할 수 있어요!

$$ \LARGE F_{m+n} = F_m F_{n+1} + F_{m-1}F_n $$

2.2. 수학적 귀납법을 이용한 증명

고정된 m에 대해 n에 대한 귀납법을 사용할 수도 있습니다.

먼저, 귀납법의 기본 단계(n=1)를 살펴봅시다

좌변: $$ F_{m+1} = F_m + F_{m-1} $$ (피보나치 수열의 정의) 우변: $$ F_{m-1}F_1 + F_mF_2 = F_{m-1} + F_m $$ (F₁ = F₂ = 1이므로)

다음으로, 귀납 가정(n=k)을 설정하고 봅시다

$$F_{m+k} = F_{m-1}F_k + F_mF_{k+1}$$

마지막으로, 귀납 단계(n=k+1)를 증명할 수 있어요

$$F_{m+k+1} = F_{m+k} + F_{m+k-1}$$ (피보나치 수열의 정의)

귀납 단계의 완전한 증명을 위해 더 자세히 전개 해봅시다

$$ \begin{align*} F_{m+k+1} &= F_{m+k} + F_{m+k-1} \ &= (F_{m-1}F_k + F_mF_{k+1}) + (F_{m-1}F_{k-1} + F_mF_k) \ &= F_{m-1}(F_k + F_{k-1}) + F_m(F_{k+1} + F_k) \ &= F_{m-1}F_{k+1} + F_mF_{k+2} \ \end{align*} $$

이렇게 귀납법의 모든 단계가 성립함을 보였으므로, 도가뉴 항등식이 모든 자연수 n에 대해 성립함이 증명된 겁니다. 수식과 증명 과정을 함께 살펴보면, 이 항등식이 피보나치 수열의 재귀적 성질을 어떻게 활용하는지 볼 수 있습니다. 굉장히 흥미로운디용 하ㅏ하하ㅏ하하

$$ \Large \begin{align*} (F_k + F_{k-1}) &= F_{k+1} \ (F_{k+1} + F_k) &= F_{k+2} \end{align*} $$

3. 음의 정수 확장

일반적으로 피보나치 수열은 양의 정수 인덱스에 대해 정의됩니다

$$F_n = F_{n-1} + F_{n-2}, \text{ where } F_0 = 0, F_1 = 1, F_2 = 1$$

:::note[초기값]

<code>where</code>은 초기값 설정 :::

하지만 이 점화식을 음의 정수 인덱스로도 확장할 수 있습니다. 음의 인덱스를 가진 피보나치 수는 아래의 공식을 따릅니다

$$F_{-n} = (-1)^{n+1}F_n$$

이것이 어떻게 작동하는지 이해하기 위해, 피보나치 수열의 점화식을 역방향으로 생각해봅시다.

기존 점화식을 변형해보면

$$F_{n-2} = F_n - F_{n-1}$$

이를 이용해 F₀부터 시작하여 음의 인덱스의 값들을 계산할 수 있습니다

F₀ = 0 F₁ = 1 F₋₁ = F₁ - F₀ = 1 - 0 = 1 F₋₂ = F₀ - F₋₁ = 0 - 1 = -1 F₋₃ = F₋₁ - F₋₂ = 1 - (-1) = 2 F₋₄ = F₋₂ - F₋₃ = -1 - 2 = -3 F₋₅ = F₋₃ - F₋₄ = 2 - (-3) = 5

이렇게 확장된 전체 수열을 나열하면

$$..., 8, -5, 3, -2, 1, -1, 0, 1, 1, 2, 3, 5, 8, ...$$

타란!

4. 급수 공식들

4.1. 합 공식

처음 n개의 피보나치 수를 더한 값

$$ \Large \sum_{k=0}^n F_k = F_{n+2} - 1 $$

4.2. 교대합 공식

피보나치 수들을 번갈아가며 더하고 빼는 경우의 합

$$ \Large \sum_{k=0}^n (-1)^{k+1}F_k = (-1)^{n+1}F_{n-1} + 1 $$

4.3. 제곱합 공식

피보나치 수들의 제곱의 합

$$ \Large \sum_{k=0}^n F_k^2 = F_nF_{n+1} $$

4.4. 세제곱합 공식

피보나치 수들 세제곱의 합

$$ \Large \sum_{k=0}^n F_k^3 = \frac{F_{3n+2} + (-1)^{n+1}6F_{n-1} + 5}{10} $$

4.5. 참고할만한 공식

:::note[기본적 공식]

홀수번째 항들의 합

$$ \Large \sum_{k=1}^{n} F_{2k-1} = F_{2n} $$

짝수번째 항들의 합

$$ \Large \sum_{k=0}^{n} F_{2k} = F_{2n+1} - 1 $$

3의 배수번째 항들의 합

$$ \Large \sum_{k=0}^{n} F_{3k} = \frac{F_{3n+2} - 1}{2} $$

그 외의 공식도 있고, 특성도 있는데 그건 여기를 참고해서 보시면 되겠습니다.

:::

5. 그 외 기억해 둘만한 성질들

5.1. 비네 공식 (Binet's Formula)

무리수인 √5와 황금비(φ)를 사용하여 항상 정수인 피보나치 수를 정확히 계산

:::note[깨알 상식]

황금비에 대해서 먼저 알아야 되더라구요!

φ = (1 + √5) / 2 ≈ 1.618034 수식에서는 이렇게 정의하고 있는데요 φ² = φ + 1 이런 것도 만족한다는 것이지요 허헣

φ¹ = φ φ² = φ + 1 φ³ = φ² × φ = (φ + 1)φ = φ² + φ = (φ + 1) + φ = 2φ + 1 φ⁴ = φ³ × φ = (2φ + 1)φ = 2φ² + φ = 2(φ + 1) + φ = 3φ + 2

그래서 이렇게 풀이할 수 있습니다. :::

정의를 먼저 해보겠습니다

φ = (1 + √5) / 2 ≈ 1.618034 -> 황금비

ψ = -1/φ ≈ -0.618034 -> 반황금비

:::tip[]

φⁿ은 항상 aφ + b 형태 ψⁿ도 같은 방식으로 cφ + d 형태 φ - ψ = √5

그래서 (φⁿ - ψⁿ) / √5는 항상 정수 :::

$$ \Large F_n = \frac{\phi^n - \phi^{n}}{\sqrt{5}} = \frac{1}{\sqrt{5}}\left[\left(\frac{1 + \sqrt{5}}{2}\right)^n - \left(\frac{1 - \sqrt{5}}{2}\right)^n\right] $$

솔직히 이거 보면서 좀 놀라긴 했슴둥

재밌네요 언제나 수학을 배우다 보면 진짜 흥미롭고 신기한 것들 투성이네요

5.2. 서로소 성질

연속된 피보나치 수들은 항상 서로소 $$ \Large gcd(F_n, F_{n+1}) = 1 $$

5.3. 황금비, 극한

피보나치 수열의 연속된 두 항의 비는 황금비(φ)에 수렴

$$ \Large \lim_{n \to \infty} \frac{F_{n+1}}{F_n} = \phi = \frac{1 + \sqrt{5}}{2} \approx 1.618034 $$

정말 놀랍게도 이런 공식들이 있다는데 신기하네요!!

코딩, ps 하다보면 정말 많이 보게되는 수열 피보나치 수열인데 이런 것들을 모르고 있었다는 것도 좀 웃기긴 합니다 ㅋㅋㅌㅎㅋㅎ

그 외로 더욱 자세한 설명은 나중에 알고리즘 구현 때 다 깊이 다뤄볼게용.. 저도 이게 지금 정리한걸 풀어쓰고 있기도하고, 다 잘 알고 있는게 아니여서 더욱 자세히 쓰다가는 오류를 범할 것 같아 여기까지 마무리하겠스빈다.

나중에는 오일러 피 함수와 gcd 어떻게 효율적으로 다 할 수 있는지에 대해서 다뤄봐도 좋을 것 같네요!!

아 그리고 여기에 나오는 공식으로 이 문제를 풀 수 있어요! 한번 다들 try try~~

Reference

wiki

[NYPC] 1차 1번 초밥

Wed, 06 Nov 2024 00:00:00 GMT

생각하면 풀리는 문제

for i in range(int(input())):
    a, b = map(int, input().split())

    if b < a//3+(1 if a % 3 else 0) or a < b//3+(1 if b % 3 else 0): print(-1)
    else: print((a+b)//4 + (1 if ((a+b)%4) else 0))

[NYPC] 1차 2번 무한 길이 물풍선

Wed, 06 Nov 2024 00:00:00 GMT

딱히 설명이 필요하지 않은거 같다.

def count_explosion_lines():
    N = int(input())
    x_coords = {}
    y_coords = {}

    for _ in range(N):
        x, y = map(int, input().split())
        x_coords[x] = x_coords.get(x, 0) + 1
        y_coords[y] = y_coords.get(y, 0) + 1

    vertical_lines = sum(1 for count in x_coords.values() if count >= 2)
    horizontal_lines = sum(1 for count in y_coords.values() if count >= 2)

    return vertical_lines + horizontal_lines


print(count_explosion_lines())

[NYPC] 1차 3번 커닝시티 헤어샵

Wed, 06 Nov 2024 00:00:00 GMT

기본적인 dp 문제

def solution():
    n = int(input())

    time_table = list(map(int, input().split()))

    dp = [float('inf')] * (n+1)

    dp[0] = time_table[0]
    if n == 1: return dp[0]

    dp[1] = min(max(time_table[0], time_table[1]), dp[0] + time_table[1])

    for i in range(2, n):
        dp[i] = min(dp[i-1]+time_table[i], max(time_table[i], time_table[i-1]) + dp[i-2])
    return dp[n-1]
print(solution())

[NYPC] 1차 4번 오르락 내리락

Wed, 06 Nov 2024 00:00:00 GMT

기본적인 dp 문제2

def solution(T):
    n = len(T)
    if n <= 2: return n
    # dp[i][0]: i번째 원소로 끝나는 홀수 위치 증가 수열의 최대 길이
    # dp[i][1]: i번째 원소로 끝나는 짝수 위치 감소 수열의 최대 길이
    dp = [[1, 1] for _ in range(n)]

    dp[1] = [1, 2]
    max_length = 1
    # 0번째가 증가, 즉 홀수 -> -2
    # 1번째가 감소, 즉 짝수
    for i in range(2, n):
        if T[i - 2] < T[i]:
            dp[i][0] = dp[i - 1][1] + 1
            dp[i][1] = 2
        if T[i - 2] > T[i]:
            dp[i][1] = dp[i - 1][0] + 1
            # dp[i][0] = 2
        if T[i - 2] == T[i]:
            dp[i] = [1, 2]

        max_length = max([dp[i][0], dp[i][1], max_length])
        # print(dp)

    return max(max_length, 2)
input()
print(solution(list(map(int, input().split()))))

[NYPC] 1차 5번 게임

Wed, 06 Nov 2024 00:00:00 GMT

그냥 구현 문제

5번까지는 그래도 빨리 풀긴 하였다.

def play_game(s, k, n):
    s = list(s)
    zero, one = k, k
    # zc, oc = 0, 0
    # for i in range(n):
    #     if s[i] =='0': zc+=1
    #     else: oc += 1

    removed = set()
    zero_left, one_left = 0, 0
    for i in range(n):
        if s[i] == '0' and zero:
            zero -= 1
            zero_left = i
        elif s[i] == '1' and one:
            one -= 1
            one_left = i
    # print(len(removed), zero, one, removed)

    for i in range(n - 1, -1, -1):
        if zero and s[i] == '1':
            removed.add(i)
            zero -= 1
        if one and s[i] == '0':
            removed.add(i)
            one -= 1

        if not one and not zero: break


    result = []

    for i in range(min(zero_left, one_left)+1, n):
        if (s[i] == '1' and one_left >= i) or (s[i] == '0' and zero_left >= i) or i in removed: continue
        result.append(s[i])
    # print(len(result))
    return ''.join(result)
    
    
n, k = map(int, input().split())
s = input()
result = play_game(s, k, n)
if len(result) == 0: result='0'
print(result)

[Algorithm] 알고리즘 1차시 수업

Fri, 14 Mar 2025 00:00:00 GMT

기본 정렬의 원리와 시간복잡도 비교

선택 정렬 (Selection Sort)

:::tip[원리]

선택 정렬은 매우 직관적인 정렬 알고리즘! 배열에서 가장 작은(또는 가장 큰) 원소를 찾아 첫 번째 위치와 교환한 후, 남은 부분 배열에서 같은 과정을 반복하는 방식으로 작동 :::

동작 과정

정렬되지 않은 부분에서 최솟값(또는 최댓값)을 찾기
이 값을 현재 위치(정렬되지 않은 부분의 첫 번째 위치)와 교환
정렬된 부분을 한 칸 확장하고, 정렬되지 않은 부분을 한 칸 축소
정렬되지 않은 부분이 없어질 때까지 1-3 과정을 반복

void selectionSort(vector<int>& arr) {
    int n = arr.size();
    
    for (int i = 0; i < n-1; i++) {
        // 최솟값의 인덱스 찾기
        int min_idx = i;
        for (int j = i+1; j < n; j++) {
            if (arr[j] < arr[min_idx])
                min_idx = j;
        }
        
        // 최솟값을 현재 위치로 교환
        swap(arr[min_idx], arr[i]);
    }
}

</details>

시간 복잡도: 항상 O(n²)
공간 복잡도: O(1) (제자리 정렬)
안정성: 불안정 (기본 구현에서)
장점: 구현이 단순하고, 교환 연산 횟수가 적음 (최대 n-1회)
단점: 배열 크기에 관계없이 항상 O(n²) 시간이 걸림

버블 정렬 (Bubble Sort)

:::tip[원리]

버블 정렬은 인접한 두 원소를 비교하여 필요시 위치를 교환하는 과정을 반복! 매 패스마다 가장 큰(또는 작은) 원소가 배열의 끝으로 "버블링(bubbling)"되는 모습이 특징 :::

동작 과정

인접한 두 원소를 비교
순서가 잘못되어 있으면 두 원소를 교환
배열의 끝까지 이 과정을 반복 (첫 패스 후에는 가장 큰 원소가 마지막 위치에 정렬됨)
배열 크기를 1 감소시키고 1-3 과정을 반복
교환이 더 이상 일어나지 않으면 정렬이 완료!

void bubbleSort(vector<int>& arr) {
    int n = arr.size();
    bool swapped;
    
    for (int i = 0; i < n-1; i++) {
        swapped = false;
        
        // 각 패스에서 인접 원소 비교 및 교환
        for (int j = 0; j < n-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                swap(arr[j], arr[j+1]);
                swapped = true;
            }
        }
        
        // 교환이 일어나지 않았다면 이미 정렬된 상태
        if (!swapped)
            break;
    }
}

</details>

시간 복잡도: 평균 및 최악 O(n²), 최선 O(n) (이미 정렬된 경우)
공간 복잡도: O(1) (제자리 정렬)
안정성: 안정적
장점: 구현이 매우 간단하고, 이미 정렬된 데이터에 대해 최적화 가능
단점: 대체로 다른 정렬 알고리즘보다 느림

삽입 정렬 (Insertion Sort)

:::tip[원리]

삽입 정렬은 카드 게임을 할 때 손에 든 카드를 정렬하는 방식과 유사! 정렬되지 않은 부분에서 원소를 하나씩 가져와 이미 정렬된 부분의 적절한 위치에 삽입하는 방식으로 작동 :::

동작 과정

두 번째 원소부터 시작(첫 번째 원소는 이미 정렬된 것으로 간주)
현재 원소를 이미 정렬된 부분 배열과 비교
정렬된 배열에서 현재 원소보다 큰 모든 원소를 한 칸씩 오른쪽으로 이동
적절한 위치에 현재 원소를 삽입
배열의 모든 원소에 대해 2-4 과정을 반복
완료!

void insertionSort(vector<int>& arr) {
    int n = arr.size();
    
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;
        
        // key보다 큰 원소들을 오른쪽으로 이동
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key;
    }
}

</details>

시간 복잡도: 평균 및 최악 O(n²), 최선 O(n) (이미 정렬된 경우)
공간 복잡도: O(1) (제자리 정렬)
안정성: 안정적
장점: 작은 데이터셋에서 효율적, 거의 정렬된 데이터에 매우 빠름, 온라인 알고리즘(데이터가 실시간으로 들어와도 정렬 가능)
단점: 큰 데이터셋에서는 비효율적

종류	평균 시간 복잡도	최선 시간 복잡도	최악 시간 복잡도	공간 복잡도	안정성	적응성
선택 정렬	O(n²)	O(n²)	O(n²)	O(1)	불안정	아니오
버블 정렬	O(n²)	O(n)	O(n²)	O(1)	안정적	예
삽입 정렬	O(n²)	O(n)	O(n²)	O(1)	안정적	예

:::note[적응성?]

이미 부분적으로 정렬된 배열에 대해 더 좋은 성능을 보이는지 여부 :::

:::note[안정성?]

선택 정렬을 예시로 들어보자

선택 정렬은 불안정 정렬이다! 제일 작은 값을 찾은 후 교환(어느 위치에 있던지, 교환됨)하기 때문이다. 교환을 통해서 순서가 고려되지 못하기 때문에 안정적으로 정렬되지 않는다.(기본 구현에서는 이렇구 따로 고려하여 작성하면 해결 가능)

:::

고급 정렬의 원리와 시간복잡도 비교

병합 정렬 (Merge Sort)

:::tip[원리]

병합 정렬은 '분할 정복(divide and conquer)' 방식을 사용 배열을 절반으로 나누고, 각 절반을 재귀적으로 정렬한 다음, 정렬된 두 절반을 병합 :::

동작 과정

분할(Divide)
- 배열을 절반으로 계속해서 나눕니다. 이 과정은 더 이상 나눌 수 없을 때까지(요소가 1개만 남을 때까지) 재귀적으로 진행
정복(Conquer)
- 크기가 1인 부분 배열은 이미 정렬된 상태로 간주합니다. 이는 기저 사례(base case)입니다
병합(Merge)
- 나누어진 부분 배열들을 정렬된 상태로 병합합니다
- 1. 두 부분 배열의 첫 번째 요소부터 비교
  2. 더 작은 값을 결과 배열에 넣고, 해당 배열의 포인터를 다음 요소로 이동
  3. 이 과정을 한 배열이 모두 소진될 때까지 반복
  4. 남은 요소들을 결과 배열에 차례대로 추가

int A[1'000'005], N;

void Merge(int s1, int e1, int s2, int e2){
    vector<int> tmp;
    int idx_1 = s1, idx_2 = s2;
    while (idx_1 <= e1 || idx_2 <= e2){
        if (idx_1 > e1) tmp.push_back(A[idx_2++]);
        else if (idx_2 > e2) tmp.push_back(A[idx_1++]);
        else if (A[idx_1] < A[idx_2]) tmp.push_back(A[idx_1++]);
        else tmp.push_back(A[idx_2++]);
    }
    
    for (int i = 0; i < tmp.size(); i++) A[s1 + i] = tmp[i];
}

void MergeSort(int s, int e){
    if (s == e) return;
    int mid = (s+e) / 2;
    MergeSort(s, mid);
    MergeSort(mid+1, e);
    Merge(s, mid, mid+1, e);
}

</details>

시간 복잡도: 항상 O(n log n)
공간 복잡도: O(n)
안정성: 안정적 (동일한 값의 상대적 순서 유지)
최적 사용 사례: 연결 리스트 정렬, 대용량 데이터 정렬
장점: 일관된 성능, 안정적, 데이터 분포에 영향 받지 않음
단점: 추가 메모리 공간 필요, 작은 데이터셋에는 비효율적

퀵 정렬(Quick Sort)

:::tip[원리]

퀵 정렬도 분할 정복 방식을 사용하지만, 피벗(pivot)이라는 요소를 기준으로 배열을 분할 피벗보다 작은 요소들은 왼쪽으로, 큰 요소들은 오른쪽으로 이동시킨 후 각 부분 배열을 재귀적으로 정렬 :::

동작 과정

피벗 선택(Select a Pivot)
- 배열에서 하나의 요소를 피벗(pivot)으로 선택 피벗 선택 방법은 다양하지만, 일반적으로 첫 번째, 마지막, 또는 중간 요소를 선택
분할(Partition)
- 피벗을 기준으로 배열을 두 부분으로 재배치
- 1. 피벗보다 작은 모든 요소는 피벗의 왼쪽으로 이동
  2. 피벗보다 큰 모든 요소는 피벗의 오른쪽으로 이동
  3. 분할 후 피벗은 최종 위치에 놓이게 됩니다
재귀적 정렬(Recursive Sort)

피벗의 왼쪽과 오른쪽 부분 배열에 대해 1단계와 2단계를 재귀적으로 적용부분 배열의 크기가 1 이하일 때 재귀를 종료

```cpp
int partition(vector<int>& arr, int low, int high) {
    int pivot = arr[high];  // 피벗으로 마지막 요소 선택
    int i = low - 1;        // 더 작은 요소의 위치
    
    for (int j = low; j < high; j++) {
        // 현재 요소가 피벗보다 작거나 같으면
        if (arr[j] <= pivot) {
            i++;
            swap(arr[i], arr[j]);
        }
    }
    swap(arr[i + 1], arr[high]);
    return i + 1;  // 피벗의 최종 위치 반환
}

void quickSort(vector<int>& arr, int low, int high) {
    if (low < high) {
        // 배열 분할
        int pi = partition(arr, low, high);
        
        // 분할된 부분 배열 정렬
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

</details>

시간 복잡도: 평균 O(n log n), 최악 O(n²)
공간 복잡도: O(log n) (재귀 호출 스택)
안정성: 불안정
최적 사용 사례: 평균적인 케이스, 작은-중간 크기 배열
장점: 실제 구현에서 빠른 성능, 작은 추가 메모리
단점: 최악의 경우 성능 저하, 이미 정렬된 데이터에 취약

힙 정렬 (Heap Sort)

:::tip[원리]

힙 정렬은 이진 힙 자료구조를 이용! 먼저 배열을 최대 힙(부모 노드가 자식 노드보다 크거나 같은 완전 이진 트리)으로 구성한 다음, 루트(최댓값)를 배열의 끝으로 이동시키고 힙 크기를 줄여가며 과정을 반복 :::

동작 과정

힙 구성(Build Heap)
- 주어진 배열을 최대 힙으로 구성 배열의 중간부터 시작하여 루트까지 각 노드에 대해 '힙화(heapify)' 연산을 수행함으로써 이루어집니다.
요소 추출 및 힙 재구성(Extract and Rebuild)
- 1. 힙의 루트(최댓값)를 배열의 마지막 위치와 교환
  2. 힙의 크기를 1 감소(마지막 요소는 이제 정렬된 부분에 속합니다)
  3. 새로운 루트에 대해 '힙화' 연산을 수행하여 최대 힙 속성을 복원
  4. 힙의 크기가 1이 될 때까지 이 과정을 반복
'힙화(Heapify)' 연산
- '힙화'는 특정 노드부터 시작하여 해당 노드가 자식 노드보다 작다면 자식 중 가장 큰 노드와 교환하고, 이 과정을 재귀적으로 반복하는 연산

```cpp
void heapify(vector<int>& arr, int n, int i) {
    int largest = i;      // 루트를 가장 큰 값으로 초기화
    int left = 2 * i + 1; // 왼쪽 자식
    int right = 2 * i + 2; // 오른쪽 자식
    
    // 왼쪽 자식이 루트보다 크면
    if (left < n && arr[left] > arr[largest])
        largest = left;
    
    // 오른쪽 자식이 지금까지의 가장 큰 값보다 크면
    if (right < n && arr[right] > arr[largest])
        largest = right;
    
    // 최대값이 루트가 아니면
    if (largest != i) {
        swap(arr[i], arr[largest]);
        
        // 영향 받은 서브트리에 대해 재귀적으로 heapify 실행
        heapify(arr, n, largest);
    }
}

void heapSort(vector<int>& arr) {
    int n = arr.size();
    
    // 최대 힙 구성
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);
    
    // 힙에서 요소를 하나씩 추출
    for (int i = n - 1; i > 0; i--) {
        // 현재 루트를 끝으로 이동
        swap(arr[0], arr[i]);
        
        // 줄어든 힙에 대해 heapify 호출
        heapify(arr, i, 0);
    }
}

</details>

시간 복잡도: 항상 O(n log n)
공간 복잡도: O(1) (제자리 정렬)
안정성: 불안정
최적 사용 사례: 메모리 제약이 있는 환경, 최악 시간 복잡도 보장이 필요한 경우
장점: 추가 메모리 불필요, 최악의 경우도 O(n log n) 보장
단점: 실제 구현에서 캐시 효율성이 낮음, 평균적으로 퀵 정렬보다 느림

종류	평균 시간 복잡도	최악 시간 복잡도	공간 복잡도	안정성	제자리 정렬
병합 정렬	O(n log n)	O(n log n)	O(n)	안정적	아니오
퀵 정렬	O(n log n)	O(n²)	O(log n)	불안정	예
힙 정렬	O(n log n)	O(n log n)	O(1)	불안정	예

그러면 이제 메인 과제 Radix Sort(기수 정렬)에 대해서 알아봅시다.

Radix Sort(기수 정렬)

라딕스 정렬은 비교 기반이 아닌 정렬 알고리즘으로, 데이터의 각 자릿수를 기준으로 정렬을 수행! 이 정렬 방식은 특히 정수나 문자열과 같이 자릿수가 있는 데이터에 효과적입니둥

작동 원리

데이터의 가장 작은 자릿수(일의 자리)부터 시작하여 가장 큰 자릿수까지 정렬
각 자릿수별로 안정적인 정렬 알고리즘(보통 계수 정렬)을 사용
각 단계에서 정렬된 결과는 다음 자릿수 정렬의 입력으로 사용

특징

시간 복잡도: O(d × n), 여기서 d는 최대 자릿수, n은 정렬할 요소의 개수입니다.
공간 복잡도: O(n + k), 여기서 k는 숫자 체계의 기수(예: 십진수에서는 10)입니다.
안정적인 정렬
비교 기반 정렬이 아니므로 이론적 하한인 O(n log n)을 뛰어넘을 수 있습니다.

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

// 특정 자릿수를 기준으로 계수 정렬을 수행하는 함수
void countSort(vector<int>& arr, int exp) {
    int n = arr.size();
    vector<int> output(n); // 결과를 저장할 배열
    vector<int> count(10, 0); // 0-9의 발생 횟수를 저장할 배열
    
    // 현재 자릿수에 해당하는 숫자의 발생 횟수 계산
    for (int i = 0; i < n; i++) 
        count[(arr[i] / exp) % 10]++;
    
    
    // count 배열을 누적합으로 변환
    for (int i = 1; i < 10; i++) 
        count[i] += count[i - 1];
    
    
    // 뒤에서부터 순회하여 출력 배열 구성 (안정적 정렬을 위해)
    for (int i = n - 1; i >= 0; i--) {
        output[count[(arr[i] / exp) % 10] - 1] = arr[i];
        count[(arr[i] / exp) % 10]--;
    }
    
    // 원래 배열에 정렬된 결과 복사
    for (int i = 0; i < n; i++) 
        arr[i] = output[i];
    
}

void radixSort(vector<int>& arr) {
    // 배열에서 최댓값 찾기
    int maxVal = *max_element(arr.begin(), arr.end());
    
    // 각 자릿수에 대해 계수 정렬 수행
    for (int exp = 1; maxVal / exp > 0; exp *= 10) 
        countSort(arr, exp);
    
}

void print(const vector<int>& arr) {
    for (int num : arr) 
        cout << num << " ";
    
    cout << endl;
}

int main() {
    vector<int> arr = {170, 45, 75, 90, 802, 24, 2, 66};
    
    cout << "정렬 전 배열: ";
    print(arr);
    
    radixSort(arr);
    
    cout << "정렬 후 배열: ";
    print(arr);
    
    return 0;
}

계수 정렬(countSort)

특정 자릿수에 대해 계수 정렬을 수행
해당 자릿수의 숫자(0-9)의 발생 횟수를 계산
누적합을 이용해 각 숫자의 최종 위치를 결정
안정적인 정렬을 위해 배열을 뒤에서부터 순회

라딕스 정렬(radixSort)

배열에서 최댓값을 찾아 자릿수를 결정
일의 자리부터 시작하여 각 자릿수에 대해 계수 정렬을 수행
자릿수는 10의 거듭제곱으로 표현(exp = 1, 10, 100, ...)

장점

큰 범위의 정수를 효율적으로 정렬 가능
자릿수가 제한적인 경우 O(n) 시간 복잡도로 동작할 수 있음
비교 연산을 사용하지 않아 특정 상황에서 빠른 성능

단점

추가 메모리가 필요
음수 처리를 위해서는 추가 로직이 필요
부동 소수점 숫자를 정렬하려면 알고리즘을 수정

감사합니다!

[BOJ] 제곱 ㄴㄴ 수

Tue, 24 Mar 2026 00:00:00 GMT

제곱 ㄴㄴ 수

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(1 ≤ min ≤ 1,000,000,000,000, min ≤ max ≤ min + 1,000,000)	에라토스테네스의 체, Math

아니 이렇게 나와서 범위를 저렇게 잡았더니 10%대에서 계속 틀린다...

이유를 못 찾고서 왜 안되는 것이냐 하면서 벌에별거 다 바꿔보다가

처음 제출에서 범위만 그냥 1'000'000 하고서 냈더니 AC를 맞음.

머리에 총 맞은 것처럼 머리가 ㄹㅇ 띵했는데.. 그냥 직접 계산해서 넣지 말고 sqrt(M)로 해서 작업하도록 하자.

괜히 이상한 짓 하다가 이렇게 된다...ㅠㅜ

#define MAX 200000001
#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>
#include <cstring>
#include <queue>
#include <stack>
#include <math.h>
using ll = long long;
using namespace std;

// 707,106.7811865475
bool table[1'000'001];
bool visited[1'000'001];
ll real_max = 708'000;


ll m, M;



int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    
    
    cin >> m >> M;
    
    
    ll limit = (ll)sqrt((double)M);
    // 아 직접 순회 범위 자체가 작구나!>!?!
    // 새로운 깨달음
    
    ll result = 0;
    
    
    for(ll i = 2; i <= limit; i++){
        if(table[i]) continue;
        
        for(ll j = i+i; j <= limit; j+=i) table[j] = true;
        
        
        // 난 개빡돌이노? visited 만들엇으면 그냥 해버리면 되는걸 왜 안 한거야
//         cout << i << " " << (m / (i*i)) * (i*i) << "\n";
        for(ll j = ((ll)(m / (i*i))) * (i*i); j <= M; j += (i*i)){
            if(j < m || visited[j - m]) continue;
            
            visited[j - m] = true;
            result++;
        }
        
    }
    
    
    
    
    
    cout << M - result - m + 1;

}

</details>

[BOJ] 가르침

Sat, 22 Feb 2025 00:00:00 GMT

가르침

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(1 ≤ N ≤ 50<br/>1 ≤ K ≤ 26)	BruteForce

와우.. 문제를 정말 신기하게 풀었습니다...

이게 원래 vector, set 이런거 좀 안쓰고 해보려고 했는데 브포 돌리느라 어쩔 수없이 일단 썼는데

이게 접근 방식에 있어서 정해는 맞는 거 같긴한데.. 그니까 N에 대해서 브포를 돌리는게 아니라 K개의 알파벳에 대해서 브포를 돌려서 시간을 최대한 아낀다.. 이런 전략인데 이게 무슨 빠르게 연산하기 위해서 비트마스킹을 하더라구요?!

근데 저는 그걸 안 쓰고 해버려서.. 이게 맞는 접근인 것 같으면서도 이게 실력이 많이 부족하다는 것을 느꼈습니다.

더 노력하겠습니다...ㅠㅜ

#include <iostream>
#include <string>
#include <vector>
#include <set>
using namespace std;
using ll = long long;

bool visited[26];
int n, k;
string words[51];
vector<char> alph;
vector<set<char>> word_chars;
int countReadable() {
    int count = 0;
    for(int i = 0; i < n; i++) {
        bool canRead = true;
        for(char c : word_chars[i]) {
            if(!visited[c - 'a']) {
                canRead = false;
                break;
            }
        }
        if(canRead) count++;
    }
    return count;
}

int mysearch(int index, int learned) {
    if(learned == k || index >= alph.size()) return countReadable();
    
    int result = 0;
    
    visited[alph[index] - 'a'] = true;
    result = max(result, mysearch(index + 1, learned + 1));
    visited[alph[index] - 'a'] = false;
    
    result = max(result, mysearch(index + 1, learned));
    
    return result;
}

int solution() {
    if(k < 5) return 0;
    k -= 5;
    set<char> poss;
    word_chars.resize(n);
    visited['a' - 'a'] = true;
    visited['n' - 'a'] = true;
    visited['t' - 'a'] = true;
    visited['c' - 'a'] = true;
    visited['i' - 'a'] = true;
    for(int i = 0; i < n; i++) {
        cin >> words[i];
        for(int j = 4; j < words[i].size() - 4; j++){
            char c = words[i][j];
            if(visited[c - 'a']) continue;
            poss.insert(c);
            word_chars[i].insert(c);
        }
    }
    alph = vector<char>(poss.begin(), poss.end());

    
    return mysearch(0, 0);
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> n >> k;

    cout << solution();

    return 0;
}

</details>

[BOJ] 게임

Sun, 02 Feb 2025 00:00:00 GMT

게임

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1 <= X <= 1,000,000,000, 0 <= Y <= X)	Binary Search(이분 탐색)

김형택은 지금 몰래 Spider Solitaire(스파이더 카드놀이)를 하고 있다. 형택이는 이 게임을 이길 때도 있었지만, 질 때도 있었다. 누군가의 시선이 느껴진 형택이는 게임을 중단하고 코딩을 하기 시작했다. 의심을 피했다고 생각한 형택이는 다시 게임을 켰다. 그 때 형택이는 잠시 코딩을 하는 사이에 자신의 게임 실력이 눈에 띄게 향상된 것을 알았다.

이제 형택이는 앞으로의 모든 게임에서 지지 않는다. 하지만, 형택이는 게임 기록을 삭제 할 수 없기 때에, 자신의 못하던 예전 기록이 현재 자신의 엄청난 실력을 증명하지 못한다고 생각했다. 게임 기록은 다음과 같이 생겼다.

게임 횟수 : X

이긴 게임 : Y (Z%)

Z는 형택이의 승률이고, 소수점은 버린다. 예를 들어, X=53, Y=47이라면, Z=88이다.

X와 Y가 주어졌을 때, 형택이가 게임을 최소 몇 번 더 해야 Z가 변하는지 구하는 프로그램을 작성하시오.

문제가 너무... 이분탐색 냄새가 심하게 난다. 바로 그냥 작성해보았고 당연히도 큰 범위에는 이분탐색이 가능하다면 바로 박는게 정배인듯 하다.. 하핳

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


using ll = long long;
ll x, y;

int main() {
    cin >> x >> y;
    
    ll left = 0;
    ll right = 1'000'000'000;
    
    ll standard = (y*100 / x);
    
    ll result = -1;
    
    while(left <= right){
        ll pivot = (left + right) / 2;
        if((ll)(((pivot + y)*100 / (x+pivot))) > standard){
            result = pivot;
            right = pivot-1;
        }else{
            left = pivot+1;
        }
    }
    
    cout << result;
   return 0;
}

</details>

[BOJ] 행렬

Sun, 16 Feb 2025 00:00:00 GMT

행렬

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	1 ≤ N, M ≤ 50	Greedy

먼저 문제를 읽고서 제가 준비한 시각화를 한번 영상으로 확인해 봅시다.

지금보면 어떤 알고리즘으로 가느냐.. 바로 3*3에서 제가 보고있는 것은 바로 <center>

</center>

이 좌상단 입니다. 여기서 →, ↓ 을 우선순위로 오른쪽으로 갈 수 있다면 즉 m(가로)가 현재 위치보다 2이상 크다면 한번 검사를 하는데 현재 자기 자신 위치가 정답 행렬과 다르다면 반전 시킵니다.

왜 이렇게 할까요??

이유는 일단 탐색 방향이 절대로 왼쪽이나 위로 올라가지 않고 딱 한번 보고서 처리를 진행할 겁니다. 그때 정답을 맞추려면 하나도 틀리면 안되기에 내가 있는 위치는 이제 마지막으로 보는 순서겠죠? 지금 보고있다면 말이죠.

그래서 내가 다르면 일단 반전을 시켜야 정답에 가까워질 수 있습니다. 만약 "나는 한번에 처리해아한다고 생각해! 왜냐하면 문제에서 최소로 반전시킨 횟수를 반환해야 하니까!"

뭔가 한번에 처리될 수 있는 경우는 이미 위에서 내려오면서 됐을 겁니다. 만약 위에서 또 변경될 값이 있다면 다시 반전되겠지만, 무조건 우리는 될 수 있다에 가까워져야 되기 때문에 이렇게 반전을 하는거구요. 이 과정에서 이 경우가 최소가 될 수 밖에 없게 됩니다.

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

int board[51][51];
int answer[51][51];
int n, m;

void change(int y, int x){
    for(int i = y; i < y+3; i++){
        for(int j = x; j < x+3; j++){

            board[i][j] = !board[i][j];
        }
    }
}


bool check(){

    for(int i = 0; i < n; i++){
        for(int j = 0;  j < m; j++){
            if(board[i][j] != answer[i][j]) return false;
        }}

    return true;
    }

    

int solve() {
   int result = 0;

    for(int i = 0; i < n-2; i++){
        for(int j = 0; j < m-2; j++){
        
            if(check()) return result;
            if(board[i][j] == answer[i][j])
                continue;
            change(i, j);
            result++;
        }}

   if(check()) return result;
   else return -1;
   
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    
    cin >> n >> m;
    char tmp;
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){

            cin >> tmp;
            board[i][j] = tmp - '0';
        }}

    
    for(int i = 0; i < n; i++){
        
        for(int j = 0; j < m; j++){
            cin >> tmp;
            answer[i][j] = tmp - '0';
        }}

    cout << solve();
    return 0;
}

</details>

[BOJ] 팰린드롬?

Tue, 11 Feb 2025 00:00:00 GMT

팰린드롬?

TimeLimit	MemoryLimit	Condition	TAG
0.5s	256MB	(1≤ N ≤ 2,000<br/>1 ≤ M ≤ 1,000,000)	Dynamic Programming

일단 문제 자체가 최적화를 좀 해야된다는 생각을 만들게 하는 TimeLimit였다. 그런데 점화식 세우는게 어려운 문제가 아니였고, 사실 디게 직관적인 문제여서 금방 풀었던 것 같다.

문제의 경우 그냥 자기 자신, 그리고 바로 2개씩 묶을 때 가능한 친구들 전처리하고, 이후에 바로 다 미리 전부 얻어둔 후에 입력으로 dp array에서 바로 빼오면 되는 문제다.

#include <iostream>
using namespace std;

using ll = long long;
int n, m;


int board[2001];
bool dp[2001][2001];

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    
    cin >> n;
    for(int i = 0; i < n; i++) cin >> board[i];
    
    
    // 2개씩 미리 해놓고, 다음에 차차 bottom up으로 처리하면 자동으로 다 dp 처리됨.
    
    for(int i = 1; i < n; i++){
        dp[i-1][i] = board[i] == board[i-1];
        dp[i-1][i-1] = 1;
        dp[i][i] = 1;
    }
    
    for(int i = 2; i < n; i++){
        for(int j = 0; j < n-i; j++){
            if(board[j] != board[i+j]) continue;
            dp[j][j+i] = dp[j+1][j+i-1];
        }
    }
    
    
    cin >> m;
    int a, b;
    for(int i = 0; i < m; i++){
        cin >> a >> b;
        
        cout << (dp[a-1][b-1] || dp[b-1][a-1]) << "\n";
    }
    return 0;
}
// 1 2 1 3 1 2 1

</details>

[BOJ] 행운쿠키 제작소

Mon, 06 Oct 2025 00:00:00 GMT

행운쿠키 제작소

TimeLimit	MemoryLimit	Condition	TAG
5s	128MB	(1 ≤ N ≤ 1,000)	Dynamic Programming

요즘 푸는 문제들이 전부 dp여서 좀 이제 다른거 풀긴 해야되는데... 랜디 중이여서 어쩔 수 없나봅니다.

사실 몇 번 거르긴 했는데 수학은 저한테 너무 어려워요. 이상한 정수론 나오면 자력을 풀기가 너무 빡세서 넘기고 이러고 있어서..

뭐 중간에 crypto 배운 짬바 어디갔나 싶지만.. ㄹㅇ 자력으로는 좀 힘들더라구요.

하튼 이번 문제는 아이디어가 쉬운 편이었는데.. 생각해내는게 꽤 오래걸렸습니ㅏㄷ.

포인트는 결국 순서는 아니고 그냥 점수에 포커스를 맞춰서 생각하면 금방 풀 수 있는 정도 인 것 같습니다.

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
#include <numeric>
#include <unordered_set>
#include <unordered_map>
#include <climits>
#include <math.h>
using namespace std;
using ll = unsigned long long;
using ld = long double;
//ll MOD = 1'000'000'007;
//ll MOD = 1.8446744074E19;
int T;


ll dp[1001 * 101];
// 와 잠만 개크랙 생각남
// 그니까 사실 순서가 중요한게 아님 사실
// 그냥 점수가 중요한건데.. 지금보면
// 둘 중 하나를 선택하는 거자나..
// 이게 포인트야
// 하나를 다 먹었다고 가정을 해. 그담에 어떤걸 교체할건지를 정할거야.
// 근데 여기서 하나 더 나가자면.. 내가 가지고 있는 포인트도 알고, 바꿀 포인트를 알면 되는건데. 이때 한쪽 포인트가 I일 때 다른 오븐 포인트 j가 최소인 경우를 구해서
// 그거의 맥스를 찍으면 되는거구나 이렇게 하는게 아닐까?
//근데 구현을 이제 dp로 가능할거 같으넫

// dp 자체를 저 i에 대한걸로 하면 될듯?

ll solution(){
    int N;
    cin >> N;
    
    pair<int, int> lucks[1001];
    
    ll start = 0;
    for(int i = 0; i < N; i++){
        cin >> lucks[i].first >> lucks[i].second;
        start += lucks[i].first;
    }
    for(int i = 0; i < 101 * N; i++)
        dp[i] = LLONG_MAX;
    
    
    dp[start] = 0;
    
    
    for(int i = 0; i < N; i++){
        // 시간복잡도가 이게 맞는지 모르겠네..
        
        for(int j = 0; j < N * 101; j++){
            if(dp[j] == LLONG_MAX) continue;
            dp[j - lucks[i].first] = min(dp[j - lucks[i].first], dp[j] + lucks[i].second);
        }
    }
    
    ll result = LLONG_MAX;
    
    for(ll i = 0; i < 101 * N; i++)
        result = min(result, max(dp[i], i));
    
    
    return result;
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    
    cin >> T;
    
    while(T --> 0){
        cout << solution() << "\n";
    }

    return 0;
}

</details>

[BOJ] 발전소

Sat, 04 Oct 2025 00:00:00 GMT

발전소

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1 ≤ N ≤ 16, 0 ≤ P ≤ N, 0 ≤ cost ≤ 36)	Dynamic Programming

그냥 간단한 bit masking dp였네용. 이제는 범위가 작기만하면 bit masking 생각나서 금방 접근하는거 같아요. 재밌었습니다.

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
#include <numeric>
#include <unordered_set>
#include <unordered_map>
#include <climits>
using namespace std;
using ll = unsigned long long;
//ll MOD = 1'000'000'007;
ll MOD = 1.8446744074E19;

int N;


int power_stations[20][20];


int dp[1 << 16];
// 이것도 뭐 bit masking 때리면 되는 놈인데? 그러고 dp[i]는 그냥 코스트로 해보지 뭐

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> N;
    
    for(int i = 0; i < N; i++){
        for(int j = 0; j < N; j++)
            cin >> power_stations[i][j];
    }
    
    int state = 0;
    
    for(int i = 0; i < N; i++){
        char current;
        cin >> current;
        
        if(current == 'Y') state |= 1 << i;
    }
    
    int p;
    cin >> p;
    
    for(int i = 0; i < 1 << N; i++){
        dp[i] = 1000000000;
    }
    dp[state] = 0;
    
    for(int current = state; current < 1 << N; current++){
        if(dp[current] == 1000000000) continue;
        for(int i = 0; i < N; i++){
            if(!(current & 1 << i)) continue;
            for(int j = 0; j < N; j++){
                if(i == j) continue;
                dp[current | 1 << j] = min(dp[current | 1 << j], dp[current] + power_stations[i][j]);
            }
        }
        
    }
    
    int result = 1000000000;
    
    for(int i = 0; i < 1 << N; i++){
        int cnt = 0;
        
        if(dp[i] == 1000000000) continue;
        for(int j = 0; j < N; j++){
            cnt += (i & (1 << j)) ? 1 : 0;
        }
        
        if(cnt >= p) result = min(result, dp[i]);
        
    }
    
    if(result == 1000000000) cout << -1;
    else cout << result;
    
    
    
    return 0;
}

</details>

[BOJ] 리모컨

Fri, 14 Feb 2025 00:00:00 GMT

리모컨

TimeLimit	MemoryLimit	Condition	TAG
2s	256MB	(1 ≤ X ≤ 20)	BruteForce

문제는 별로 어렵진 않았지만 약간 시간이 걸렸습니다. 왜냐! 제 IDE가 바뀌었긴 때문에!! Xcode에서 vim으로 아예 갈아탔어용!! 확실히 연습이 더 잘되더라구요.

또 자동완성이 없으니까 타자도 다시 원래 상태로 돌아가는 그 느낌! 아주 좋습니다.

어차피 그냥 브포 문제라서 요정도 코드는 그냥 까겠습니다.

즐거운 ps 되십숑!

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

int n, m;
bool buttons[10];

ll solve(int depth, ll current) {
     if(depth > 6) return abs(current - n) + depth;
    ll result = 10000000000;
    if(depth) result = abs(n - current) + depth;
     for(int i = 0; i < 10; i++){
        if(buttons[i]) continue;
      
         result = min(result, solve(depth+1, current*10+i));
        }
     return result;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> n;
    cin >> m;

    int tmp;
    for(int i = 0; i < m; i++){
       cin >> tmp;
       buttons[tmp] = true;
    }
    
    

    ll result = min(llabs(n - 100), solve(0, 0));
    cout << result;
    return 0;
}

</details>

[BOJ] 피보나치 수의 제곱의 합

Tue, 30 Sep 2025 00:00:00 GMT

피보나치 수의 제곱의 합

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(1 ≤ N ≤ 1,000,000,000,000,000,000)	도가뉴 항등식, Math

간단한 문제 증명은 여기에서 확인하시면 됩니다.

도가뉴 항등식을 활용해서 큰 피보나치 구하면 되구요. 이제 제곱의 합을 어떻게 구할까?를 생각해보면 됩니다.

제 의식은 흐름은 아래와 같습니다:


#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
#include <numeric>
#include <unordered_set>
#include <unordered_map>
#include <climits>
using namespace std;
using ll = long long;
ll MOD = 1'000'000'007;

map<ll, ll> dp;



ll solution(ll n){
    if(dp.find(n) != dp.end()) return dp[n];
    ll result;
    
    ll a, b;
    a = solution(n/2);
    b = solution(n/2+1+(-2 *!(n%2)));
    
    if(n%2) result = ((a * a)%MOD + (b * b)%MOD)%MOD;
    else result = ((((2*b)%MOD + a)%MOD)*a)%MOD;
    dp[n] = result;
    
    return result;
}




int main() {
    ll n;
    cin >> n;
    
    dp[0] = 0;
    dp[1] = 1;
    dp[2] = 1;
    dp[3] = 2;
    
    ll a = solution(n);
    ll b = solution(n+1);
    
    // 이게 F_n*F_(n+1)이여서
    
    
    cout << ((a * b) % MOD);
    

    return 0;
}

</details>

[BOJ] 피보나치 수 6

Fri, 14 Feb 2025 00:00:00 GMT

피보나치 수 6

TimeLimit	MemoryLimit	Condition	TAG
1s	256MB	(1≤ N ≤ 1,000,000,000,000,000,000)	Dynamic Programming, Math

음.. 솔직히 저한테는 좀 어려웠습니다. 이게 어떻게든 될거라는 생각을 가지고서, 수를 쭉 나열해보고 하나씩 해보려고 했는데 다행히도 수학적으로 뭔가 수를 줄일때 보통 2에 집중하죠?

그냥 대충 이분탐색, 이분트리 등등 속도를 높이기 위해서 반반 나눠가면서 하는 것들이 생각나더라구요. 또 이제 피보나치 수는 덧셈으로 이뤄져있으니까 뭔가 중간에 곱셈으로 다 처리하는게 가능하지 않을까?

라고 생각해서 열심히 해봤는데 처음에는 당연히 보이지도 않고, 정말 힘들었습니다. 수식으로 증명을 해보려고 했는데도 일단 뭐가 맞는지도 몰라요.

세상에 진짜 그러다가 하나가 보이기 시작합니다.

n이 현재 피보나치 수의 순서일 때,

a = (n/2)
b = (n/2+1)

fibo(n) = fibo(a)^2 + fibo(b)^2

요런게 보입니다. 그래서 와 진짜 이게 되누 ㅋㅋ

이러고 바로 해보려고 했다가 갑자기 다시 머리가 띵합니다... 이걸로는 TO(Time out)을 피할 수 없을거다.. 라고 생각이 들었거든요.

그러고 다시 에.. 열심히 규칙을 찾았습니다...

진짜 힘들었습니다... 역시 수학은 열심히 해놓는게 제일 좋은 거 같아요. ps도 열심히 해야겠지만 일단 수학도 열심히 해야겠습니다. 아 물리도요!

제가 어떤 일이 있었는지.. 한 도화지 1장 정도 사용했는데요. 그렇게 막 많이 사용하진 않았고, 보통 머리로 그려서 해봤씁니다.

그 외로 이제 한번 방문한 곳은 아예 바로 저장해서 바로 반환하도록 하면 TO를 피할 수 있어요!

(또 제가 악필이라 막 많이 적으면서 하는거는 머리가 아플때 주로 쓰고 풉니다.)

<details> <summary> 정답 코드 </summary> 그리고 Xcode로 하니까 contains가 있다고 하고, local에서는 정말 잘 돌아갔는데 무슨 boj에서는 터져서 바꿨네요. 다들 조심하십쇼.. Xcode include 안된 친구들도 있다고 표시하고, 잘 돌아가니까... 우씌...ㅠㅜ

#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
using namespace std;
using ll = long long;
ll MOD = 1'000'000'007;

map<ll, ll> dp;



ll solution(ll n){
    if(dp.find(n) != dp.end()) return dp[n];
    ll result;
    
    ll a, b;
    a = solution(n/2);
    b = solution(n/2+1+(-2 *!(n%2)));
    if(n%2) result = ((a * a)%MOD + (b * b)%MOD)%MOD;
    else result = ((((2*b)%MOD + a)%MOD)*a)%MOD;
    dp[n] = result;
    return result;
}

int main() {
    ll n;
    cin >> n;
    
    
    dp[0] = 0;
    dp[1] = 1;
    dp[2] = 1;
    dp[3] = 2;
    
    cout << solution(n);
    
    

    return 0;
}

</details>

[BOJ] 구간 합 구하기 5

Mon, 17 Feb 2025 00:00:00 GMT

구간 합 구하기 5

TimeLimit	MemoryLimit	Condition	TAG
1s	256MB	(1 ≤ N ≤ 1024, 1 ≤ M ≤ 100,000)	Dynamic Programming, 구간합

이번 문제는 그냥 구간합 구하는 문제로 처음보는 분들은 연습하기 좋은 문제인 것 같습니다.

그냥 지나오면서 다 더하고, 나중에 전에 값을 빼서 값을 알아오는 방법으로 값을 얻을 수 있습니다. Indexing을 사용하면 속도가 빠르기 때문에 아주 많이 사용되더라구요.

한번 연습해보시면 좋을 듯 합니다.

#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
using namespace std;
using ll = long long;
int board[1025][1025];
int n, m;



int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cin>> n >> m;
    
    board[1][0] = 0;
    for(int i = 1; i <= n; i++){
        cin >> board[1][i];
        if(i) board[1][i] += board[1][i-1];
    }
    for(int i = 2; i <= n; i++){
        board[i][0] = board[i-1][n];
        for(int j = 1; j <= n; j++){
            cin >> board[i][j];
            board[i][j] += board[i][j-1];
        }
    }
    
    
    int x1, y1, x2, y2;
    while(m-->0){
        
        cin >> x1 >> y1 >> x2 >> y2;
        
        ll result = 0;
        for(int x = x1; x <= x2; x++)
            result += board[x][y2] - board[x][y1-1];
        
        cout << result << "\n";
    }
    
    return 0;
}

</details>

[BOJ] 트리의 지름

Fri, 28 Jun 2024 00:00:00 GMT

트리의 지름

트리의 지름이란, 트리에서 임의의 두 점 사이의 거리 중 가장 긴 것을 말한다. 트리의 지름을 구하는 프로그램을 작성하시오.

문제는 너무나 간단합니다. 사실 말할 필요도 없이, 그냥 주어진 cost만을 가지고 길이를 더해가면서 측정하면 끝이기 때문입니다.

입력을 제외한 핵심 DFS 코드만 살펴보고 프스트를 마무리하겠습니다.

vector<pair<int, int>> tree[100'001];
bool visited[100'001];
int result = 0;

int solution(int current, int length_){
   
    
    int length = 0;
    int child_max = 0;
    int child_second = 0;
    
    visited[current] = true;
    
    for(pair<int ,int> next : tree[current]){
        if(visited[next.first]) continue;
        int result = solution(next.first, child_max) + next.second;
        if(child_max < result){
            length = child_max+result;
            child_second = child_max;
            child_max = result;
        }else if(child_second < result){
            length = child_max + result;
            child_second = result;
        }
    }
    
    result = max({child_max+child_second,
                result,
                child_max + length_});
    
    return child_max;
}

전역 변수

tree

말 그대로 트리의 정보를 담는 배열

visited

방문한 노드인지 확인하는 배열

result

출력할 결과값

파라미터

current

현재 자신의 노드 위치

length_

전에 있던 노드에서 제일 깊게 탐색되었던 길이

지역 변수

length

일단 선언해 두고서, 쓰지 않은 변수

child_max

자식 중에서 제일 먼 거리

chlid_second

자식 중에서 두번째로 먼 거리

이 코드는 정말 직관적이라 설명이 필요 없을 듯하다.

overflow도 조심할 필요가 없었기 때문에 쉽게 풀이하였다.

#define MAX 2'100'000'000
#define limit 10'000'000'000
#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <math.h>
#include <random>
using namespace std;

using ull = unsigned long long;
using ll = long long;

int n;

vector<pair<int, int>> tree[100'001];
bool visited[100'001];



int result = 0;

int solution(int current, int length_){
   
    
    int length = 0;
    int child_max = 0;
    int child_second = 0;
    
    visited[current] = true;
    
    for(pair<int ,int> next : tree[current]){
        if(visited[next.first]) continue;
        int result = solution(next.first, child_max) + next.second;
        if(child_max < result){
            length = child_max+result;
            child_second = child_max;
            child_max = result;
        }else if(child_second < result){
            length = child_max + result;
            child_second = result;
        }
    }
    
    result = max({child_max+child_second, result, child_max + length_});
    
    return child_max;
}


int main(){
    cin >> n;
    
    
    int current_node;
    for(int i = 0; i < n; i++){
        cin >> current_node;
        
        int node = 0, cost_;
        while(node != -1){
            cin >> node;
            if(node == -1) break;
            cin >> cost_;
            
            tree[current_node].push_back({node, cost_});
            tree[node].push_back({current_node, cost_});
            
        }
    }
    
    solution(1, 0);
    cout << result;
    
    
    
    
    return 0;
}

</details>

[BOJ] 배달

Wed, 24 Sep 2025 00:00:00 GMT

배달

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1 ≤ N, M ≤ 50)	BFS

간단한 BFS 문제이고, 조금 특이한 점은 각 방향에 대해서 visited 처리 정도가 있겠습니다.

저는 조금 비효율적으로 작성했는데.. 학교에서 간단히 풀다 보니 일단 풀자라는 마인드로 구현해서 저렇게 되었구요..

조금 더 생각해보면 훨씬 효율적인 풀이가 가능할 듯 합니다.. 한번 BFS 변형 문제 연습으로 풀어보면 좋을 것 같네요.

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
using namespace std;

using ll = long long;

int n, m;


char board[101][101];

int visited[101][101][4][3];

vector<pair<int, int>> cs;

struct info {
    pair<int, int> pos;
    int cost;
    int getCost;
    int visited;
    int dir;
};

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    
    cin >> n >> m;
    
    pair<int, int> start;
    
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j++){
            char tmp;
            cin >> tmp;
            
            if(tmp == 'S') {
                start = {i, j};
                board[i][j] = '.';
                
            }
            else if(tmp == 'C'){
                cs.push_back({i, j});
            }
            else{
                board[i][j] = tmp;
            }
            
            
            for(int k = 0; k < 4; k++){
                visited[i][j][k][0] = 1000000000;
                visited[i][j][k][1] = 1000000000;
                visited[i][j][k][2] = 1000000000;
            }
//            visited[i][j][2] = 1000000000;
        }
    }
    
    
//    visited[start.first][start.second][0] = 0;
    
    queue<info> q;
    q.push({start, 0, 0, 0, -1});
    int result = 1000000000;

    int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
    
    while(!q.empty()){
        info information = q.front(); q.pop();
        for(int i = 0; i < 4; i++){
            if(information.dir == i) continue;
            int nx = information.pos.second + dx[i];
            int ny = information.pos.first + dy[i];
            if(0 < ny && ny <= n &&
               0 < nx && nx <= m && board[ny][nx] != '#'){
                
                int currentGet = information.getCost;
                int currentIdx = information.visited;
                for(int idx = 0; idx < cs.size(); idx++){
                    if(cs[idx].first == ny && cs[idx].second == nx){
                        currentIdx = idx+1;
                        if(idx+1 != information.visited){
                            currentGet++;
                            break;
                        }
                    }
                }
//                cout << ny << " " << nx << " " << currentGet << "\n";
                
                
                
                if(currentGet == 2){
                    result = min(result, information.cost + 1);
                    continue;
                }
                
                if(visited[ny][nx][i][currentIdx] > information.cost + 1) {
                    visited[ny][nx][i][currentIdx] = information.cost + 1;
                    
                    
                    
                    q.push({{ny, nx}, information.cost + 1, currentGet, currentIdx, i});
                }
                
                
            }
            
        }
        
        
    }
    
    
//    
//    for(int i = 1; i <= n; i++){
//        for(int j = 1; j <= m; j++){
//            cout << visited[i][j][1][1] << " ";
////            result = min({visited[i][j][0][2], visited[i][j][1][2],
////                        visited[i][j][2][2], visited[i][j][3][2], result});
//        }
//        cout << "\n";
//    }
    if(result == 1000000000) cout << -1;
    else cout << result;

    
    return 0;
}



/*
 
 3 9
 ...#..##.
 C...S..C.
 .#...#.#.
 
 
 */

</details>

[BOJ] 부분수열의 합 2

Thu, 20 Mar 2025 00:00:00 GMT

부분수열의 합 2

TimeLimit	MemoryLimit	Condition	TAG
1s	256MB	(1 ≤ N ≤ 40, 1 <= \|S\| <= 1,000,000)	BinarySearch

이거는 아이디어가 중요한데.. 그냥 반반 쪼개서 2^20 * 2로 만들어서 생각하면 됩니다

#include <iostream>
#include <queue>
#include <algorithm>
#include<set>
#include <map>
using namespace std;
using ll = long long;

int inf = 1e9;
int nums[41];

vector<ll> A, B;

void getSum(int current, int end, int current_sum, vector<ll>& container){
    container.push_back(current_sum);
    for(int i = current+1; i < end; i++)
        getSum(i, end, current_sum+nums[i], container);
    
}




void solution(){
    int n, s;
    cin >> n >> s;
    
    ll result = 0;
    
    for(int i = 0; i < n; i++) cin >> nums[i];
    
    
    if(n == 1){
        cout << (s == nums[0]);
        return;
    }
    
    
    getSum(0, n/2, 0, A);
    getSum(0, n/2, nums[0], A);
    getSum(n/2, n, 0, B);
    getSum(n/2, n, nums[n/2], B);

    
    sort(A.begin(), A.end());
    A.erase(--upper_bound(A.begin(), A.end(), 0));
//    cout << A.size() << " " << B.size() << "\n";
    
    
    
    
    for(int i = 0; i < B.size(); i++){
        ll current = B[i];
        if(B[i] == s) result++;
        if(*lower_bound(A.begin(), A.end(), s - current) + current != s) continue;
        
        ll idx = upper_bound(A.begin(), A.end(), s - current) - A.begin();
        idx -= lower_bound(A.begin(), A.end(), s - current) - A.begin();
        
        result += idx;
    }
    
    
    cout << result - (s == 0);
    
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    solution();
    return 0;
}



// -3 -2 -1 -3 -4 -5 -6 0
// 0 1 2 3 5 4 3 3 2 1 6 6

</details>

[BOJ] 2048(Easy)

Thu, 13 Feb 2025 00:00:00 GMT

2048(Easy)

TimeLimit	MemoryLimit	Condition	TAG
1s	256MB	(1≤ N ≤ 20)	Implementation

문제는 굉장히 재미있게 풀었습니다. 뭐 깊이 생각할게 없었던 것이 좀 아쉬웠지만, 그래도 게임을 구현하는 느낌으로 재미있게 풀었던 것 같습니다.

저는 단순히 보드를 회전시키면서 한 방향으로 밀어버리기를 선택해서 풀었습니다.

뭐 구현은 간단하기 때문에 딱히 설명은 필요없을 것 같네요.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int n;

vector<vector<int>> rotate(vector<vector<int>>& board){
    
    vector<vector<int>> current(n, vector<int>(n));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            current[j][n-1-i] = board[i][j];
        }
    }
    return current;
}

vector<vector<int>> play(vector<vector<int>>& board){
    vector<vector<int>> current(n, vector<int>(n, 0));

    
    // 일단 다 당겨보자 한번에 해봐? 근데 위로 올리는거임

    for(int i = 0; i < n; i++){ // x
        int currentPos = 0; // current에 대한 현재 위치값.
        current[0][i] = board[0][i];
        for(int j = 1; j < n; j++){ // y
            int currentCost = current[currentPos][i];
            if(board[j][i] != 0){
                if(currentCost == 0) current[currentPos][i] = board[j][i];
                else{
                    if(currentCost == board[j][i]) current[currentPos][i]*=2;
                    else current[currentPos+1][i] = board[j][i];
                    currentPos++;
                }
            }
        }
    }

    return current;
}

int solution(vector<vector<int>>& board, int depth){
    int result = 0;
    for(int i = 0; i < n*n; i++) result = max(result, board[i/n][i%n]);
    if(depth > 5) return result;
    
    
    vector<vector<int>> origin = board;
    
    for(int i = 0; i < 4; i++){
        board= play(origin);
        
        if(board != origin)
            result = max(result, solution(board, depth+1));
        
        origin = rotate(origin);
    }
    return result;
}


int main() {
    cin >> n;
    
    vector<vector<int>> board(n, vector<int>(n));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) cin >> board[i][j];
    }
    
    cout << solution(board, 1);

    return 0;
}

</details>

[BOJ] 쿨한 물건 구매

Thu, 10 Apr 2025 00:00:00 GMT

쿨한 물건 구매

TimeLimit	MemoryLimit	Condition	TAG
0.5s	128MB	(1 ≤ D, P, Q ≤ 10^9)	Implementation, Math

음.. 접근 방법은 보자마자 생각을 해냈지만.. 이 시간을 어떻게 줄일까 생각을 하다가 열심히 방정식 가지구 으쌰으쌰 하니까 조건을 알아내서 풀었습니다.

기본적인 아이디어는 큰 수의 개수를 확정짓는 하나의 값 N을 찾는다고 한다면 N을 확정하는 순간 다른 화폐의 개수도 확정되겠죠? 이거 이용해서 구현하면 됩니다. 이때 시간 초과를 피하기 위해서 범위를 효율적으로 계산하는게 진짜 중요한데 큰 값을 기준으로 N을 늘려가면서 [d + 작은값] 보다 안 크도록 유지해주면 됩니다.

D \leq (N - P)Q + (M + Q)P

위 식에서 $$N \geq P$$인 것을 알 수 있다. 이후에 이제 $$N \geq P$$에서 최대의 $$P$$의 값을 가져오게 된다면 이후에 더 올리는 것은 무의미하다. 왜냐하면 결국 조정되면서 현재 조정하는 값 대신에 다른 값이 작아지고 결국 0부터 왔다면 다시 방문했던 값을 보기 때문에 반복된다. 그래서 우리는 $$N < P$$를 알 수 있고, $$\text{limit} = p$$가 되는 것을 알 수 있다.

<참고: https://www.acmicpc.net/board/view/96265 >

#include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <random>
#include <cmath>
using namespace std;
using ll = long long;

ll d, p, q;
ll gcd(ll a, ll b){
    while(b != 0){
        ll r = a % b;
        a = b;
        b = r;
    }
    return a;
}
ll lcm(ll a, ll b){ return a * b / gcd(a, b); }


int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> d >> p >> q;
    
    if(p == 1 || q == 1) {
        cout << d;
        return 0;
    }
    
     
    ll a = max(p, q), b = min(p, q);
    
    p = a;
    q = b;
    
    if(p%q == 0){
        if((ll)(d / q) * q == d) cout << d;
        else cout << (ll)(d / q) * q + q;
        return 0;
    }
    
    // 일단 p, q가 1인 경우가 제외됨으로 1e9까지 돌 ㅑfor문이 지금 1e9 / 2가 되버림 잠시만 시간이 1e5/5임 이게 맞음? 와 잠시만
    if(q == 2){
        if(d % q == 0) cout << d;
        else{
            if(p % 2 == 0) cout << d + 1;
            else{
                if(d - q >= p) cout << d;
                else cout << d + 1;
            }
        }
        
        return 0;
    }
    ll limit = q;
    ll result = min((ll)(d / q) * q + q, (ll)(d / p) * p + p);
    
    // 100 3 6
    //
    bool check = false;
    for(ll i = 0; i < limit ; i++){
        
        ll current = p * i;
        if(current > d + q) break;

        current += (ll)(abs(d - current) / q) * q;

        current = min(current + q, abs(d - current) % p == 0? d : (ll)((abs(d - current) / p)+1) * p + current);
        
        result = min(current, result);
//        cout <<"result: " << result << " current: " << current << "\n";
        if(result == d) break;
    }
    cout << result;
    

    return 0;
}

</details>

[BOJ] 육각수

Sun, 15 Jun 2025 00:00:00 GMT

육각수

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1 ≤ N ≤ 1'000'000	Dynamic Programming

그냥 전형적인 dp 문제인데, 단순한 연산이여서 1초를 10억으로 보고서 처리하면 간단히 풀 수 있는 문제


#include <iostream>
#include <queue>
#include <set>
#include <algorithm>
#include <random>

#define mod 1000000007LL
#define MAX 1'000'000LL
using namespace std;
using ll = long long;

ll n;

ll dp[MAX+1];
vector<ll> nums;


int main(){
    cin >> n;
    
    
    dp[0] = 0;
    dp[1] = 1;
    nums.push_back(1);
    for(int i = 2; i <= n; i++){
        if(i == (nums.size() + 1) * 2 + nums.size()*2 - 1 + nums.back()) {
            nums.push_back(i);
            dp[i] = 1;
        }
        else{
            dp[i] = i;
            for(ll num : nums) dp[i] = min(dp[i], dp[i - num] + 1);
        }
    }
    

    cout << dp[n];
    return 0;
}

</details>

[BOJ] 주식왕 동호

Mon, 16 Mar 2026 00:00:00 GMT

주식왕 동호

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1 ≤ C ≤ 50, <br/>2 ≤ D ≤ 10<br/>1 ≤ M ≤ 200,000)	Dynamic Programming

솔직히 처음에 dp점화식이나 접근 방식을 제대로 못 잡아서 많은 고민을 했다. 처음에는 day와 stock을 선택한 것에 대해서 설정하는 건 줄 알았는데, 생각해보니 그냥 말도 안되는 식이었고 뭘 어떻게 해야될까 생각하다가 중복 구매와 더불어 한번에 처리할 수 있는 방식 자체를 생각해내니 그냥 유레카 그 자체였다.

충분히 고민하고 푸는 문제는 오랜만이라 그냥 문제가 goat였다.

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
#include <numeric>
#include <unordered_set>
#include <unordered_map>
#include <climits>
#include <math.h>
using namespace std;
using ll = long long;
using ld = long double;
ll MOD = 1'000'000'000 + 7;

using namespace std;


int c, d, m;


int stocks[51][11];


// dp table을 만들 때 며칠인지 데이터가 무조건 필요하다.
// day가 10까지고, stock이 50까지고,
// dp table이 가져야할 것이 뭘까?
// 그리고 어디서 상태 전이가 발생해서 이거를 점화식으로 나타낼 수 있는가?
// day, 어떤 stock을 몇 개 샀는지 사실 이거는 bottom-up으로 할거면 상관이 없긴한데.
// 이를 최대한 시간 안에 만들려면 어떤 것을 다 구매하거나 뭐 이런 것처럼 아예 하나를 선택할 때 바로 몇 개를 사야되는게 좋은지를 증명해야됨.
// 자체로 greedy로 가게되면 문제가 되는게 논리적인 측면에서 조금의 증명으로 조금 엄밀해질 필요가 있따.

// 깊게 들어가면서 남은 돈을 다 투자하도록 만드는 방법도 있음.
// 그냥 for문으로 해결할 수 있는 방법 없을까?
// 일단 3중까지는 가능할거 같은데 4승까ㅣㅈ도 가능하네


int dp[500'001];




int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    
    cin >> c >> d >> m;
    
    for(int i = 0; i < c; i++){
        for(int j = 0; j < d; j++){
            cin >> stocks[i][j];
        }
    }
    
    // 아 각 날마다 가지고 있는 돈에 대한 dp로 가져와서 진행하면 되겠다
    // dp[i] = max(dp[i], dp[i- 아 싸발 일어났따
    // think!
    for(int i = 1; i < d; i++){
        for(int _ = 0; _ <= 500'001; _++) dp[_] = 0;
        
        for(int j = 0; j < c; j++){
            for(int k = stocks[j][i-1]; k < m+1; k++){
                dp[k] = max(dp[k], dp[k - stocks[j][i-1]] + stocks[j][i] - stocks[j][i-1]);
                
            }
            
        }
        m+= dp[m];
    }
    
    
    cout << m;
    return 0;
}

</details>

[BOJ] 좋다

Fri, 07 Feb 2025 00:00:00 GMT

좋다

TimeLimit	MemoryLimit	Condition	TAG
2s	256MB	1 ≤ N ≤ 2,000 <br/> abs(A_i) ≤ 1,000,000,000	Sort, Two Pointer

문제 자체가 전형적인 binary search를 하는거였고, 그냥 투 포인터로 자기 자신 예외처리 후 AC

ll을 unsigned로 해놔서 오류를 못 찾았었다..

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
using ll = long long;
int n;
ll board[2001];

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    
    cin >> n;
    for(int i = 0; i < n; i++){
        cin >> board[i];
    }
    
    sort(board, board+n);
    
    int result = 0;
    if(n <= 2) {
        cout << 0;
        return 0;
    }
    
    for(int i = 0; i < n; i++){
        
        int right = n-1 == i ? n-2 : n-1;
        int left = i == 0;
        
        while(left < right){
            ll current = board[left] + board[right];
            if(board[i] == current){
                result ++;

                break;
            }
            else if(board[i] < current){
                if(i == right-1) right--;
                right--;
            }else{
                if(i == left+1) left++;
                left++;
            }
        }
    }
    cout << result;
    
    
    return 0;
}

</details>

[BOJ] 할 수 있다

Tue, 23 Sep 2025 00:00:00 GMT

할 수 있다

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB		Big Integer, Implementation

일단 이 문제는 그냥 구현 문제라서 어려울 것은 딱히 없으나..........

범위에 대한 계산 때문에 python을 쓰는게 압도적으로 유리한 것으로 보인다. cpp로 하려면 Big Integer를 구현해야되는 대참사가 일어나고... 시간을 버리게 되고....

빼기 순서를 잘못 적어서 또 날리게 되고... 조심하도록 하자.

조금 빡센 구현 문제는 역시! 귀찮다! 재밌다! 아이디어 문제만큼이나 구현 문제도 생각보다 재미있는 것들이 많으니 한번 다들 풀어보시길~~ 물론 이 문제는 풀지 마세요 별로 좋은거 같지는 않아여... 플딱이가 말하는거라 한귀로 흘리시길.....

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
using namespace std;

string input;
class BigInteger {
private:
    std::vector<int> digits;
    bool negative;
    
    void removeLeadingZeros() {
        while (digits.size() > 1 && digits.back() == 0) {
            digits.pop_back();
        }
        if (digits.size() == 1 && digits[0] == 0) {
            negative = false;
        }
    }
    
    bool absLess(const BigInteger& other) const {
        if (digits.size() != other.digits.size()) {
            return digits.size() < other.digits.size();
        }
        for (int i = digits.size() - 1; i >= 0; i--) {
            if (digits[i] != other.digits[i]) {
                return digits[i] < other.digits[i];
            }
        }
        return false;
    }
    
    BigInteger absAdd(const BigInteger& other) const {
        BigInteger result;
        result.digits.clear();
        int carry = 0;
        int maxSize = std::max(digits.size(), other.digits.size());
        
        for (int i = 0; i < maxSize || carry; i++) {
            int sum = carry;
            if (i < digits.size()) sum += digits[i];
            if (i < other.digits.size()) sum += other.digits[i];
            result.digits.push_back(sum % 10);
            carry = sum / 10;
        }
        return result;
    }
    
    BigInteger absSubtract(const BigInteger& other) const {
        BigInteger result;
        result.digits.clear();
        int borrow = 0;
        
        for (int i = 0; i < digits.size(); i++) {
            int diff = digits[i] - borrow;
            if (i < other.digits.size()) diff -= other.digits[i];
            
            if (diff < 0) {
                diff += 10;
                borrow = 1;
            } else {
                borrow = 0;
            }
            result.digits.push_back(diff);
        }
        result.removeLeadingZeros();
        return result;
    }

public:
    BigInteger() : negative(false) {
        digits.push_back(0);
    }
    
    BigInteger(long long num) {
        negative = num < 0;
        if (negative) num = -num;
        
        if (num == 0) {
            digits.push_back(0);
        } else {
            while (num > 0) {
                digits.push_back(num % 10);
                num /= 10;
            }
        }
    }
    
    BigInteger(const std::string& str) {
        negative = false;
        int start = 0;
        if (str[0] == '-') {
            negative = true;
            start = 1;
        }
        
        for (int i = str.length() - 1; i >= start; i--) {
            digits.push_back(str[i] - '0');
        }
        removeLeadingZeros();
    }
    
    BigInteger operator+(const BigInteger& other) const {
        if (negative == other.negative) {
            BigInteger result = absAdd(other);
            result.negative = negative;
            return result;
        } else {
            if (absLess(other)) {
                BigInteger result = other.absSubtract(*this);
                result.negative = other.negative;
                return result;
            } else {
                BigInteger result = absSubtract(other);
                result.negative = negative;
                return result;
            }
        }
    }
    
    BigInteger operator-(const BigInteger& other) const {
        if (negative != other.negative) {
            BigInteger result = absAdd(other);
            result.negative = negative;
            return result;
        } else {
            if (absLess(other)) {
                BigInteger result = other.absSubtract(*this);
                result.negative = !negative;
                return result;
            } else {
                BigInteger result = absSubtract(other);
                result.negative = negative;
                return result;
            }
        }
    }
    
    BigInteger operator*(const BigInteger& other) const {
        BigInteger result;
        result.digits.assign(digits.size() + other.digits.size(), 0);
        
        for (int i = 0; i < digits.size(); i++) {
            for (int j = 0; j < other.digits.size(); j++) {
                result.digits[i + j] += digits[i] * other.digits[j];
                if (result.digits[i + j] >= 10) {
                    result.digits[i + j + 1] += result.digits[i + j] / 10;
                    result.digits[i + j] %= 10;
                }
            }
        }
        
        result.negative = negative != other.negative;
        result.removeLeadingZeros();
        return result;
    }
    
    std::pair<BigInteger, BigInteger> divmod(const BigInteger& other) const {
        if (other.digits.size() == 1 && other.digits[0] == 0) {
            throw std::runtime_error("Division by zero");
        }
        
        BigInteger dividend = *this;
        BigInteger divisor = other;
        dividend.negative = false;
        divisor.negative = false;
        
        if (dividend.absLess(divisor)) {
            return {BigInteger(0), *this};
        }
        
        BigInteger quotient;
        quotient.digits.clear();
        BigInteger remainder;
        remainder.digits.clear();
        remainder.digits.push_back(0);
        
        for (int i = dividend.digits.size() - 1; i >= 0; i--) {
            remainder = remainder * BigInteger(10) + BigInteger(dividend.digits[i]);
            
            int count = 0;
            while (!remainder.absLess(divisor)) {
                remainder = remainder - divisor;
                count++;
            }
            quotient.digits.push_back(count);
        }
        
        std::reverse(quotient.digits.begin(), quotient.digits.end());
        quotient.removeLeadingZeros();
        remainder.removeLeadingZeros();
        
        quotient.negative = negative != other.negative;
        remainder.negative = negative;
        
        return {quotient, remainder};
    }
    
    BigInteger operator/(const BigInteger& other) const {
        return divmod(other).first;
    }
    
    BigInteger operator%(const BigInteger& other) const {
        return divmod(other).second;
    }
    
    BigInteger& operator=(const BigInteger& other) {
        digits = other.digits;
        negative = other.negative;
        return *this;
    }
    
    bool operator==(const BigInteger& other) const {
        return negative == other.negative && digits == other.digits;
    }
    
    bool operator!=(const BigInteger& other) const {
        return !(*this == other);
    }
    
    bool operator<(const BigInteger& other) const {
        if (negative != other.negative) {
            return negative;
        }
        if (negative) {
            return other.absLess(*this);
        } else {
            return absLess(other);
        }
    }
    
    bool operator>(const BigInteger& other) const {
        return other < *this;
    }
    
    bool operator<=(const BigInteger& other) const {
        return *this < other || *this == other;
    }
    
    bool operator>=(const BigInteger& other) const {
        return *this > other || *this == other;
    }
    
    std::string toString() const {
        std::string result;
        if (negative) result += "-";
        for (int i = digits.size() - 1; i >= 0; i--) {
            result += (digits[i] + '0');
        }
        return result;
    }
    
    friend std::ostream& operator<<(std::ostream& os, const BigInteger& bi) {
        os << bi.toString();
        return os;
    }
};

using ll = BigInteger;

struct info {
    bool isNum;
    ll num;
    char exp;
};

ll getNumber(int idx){
    string result = "";
    for(; idx < input.size() && '0' <= input[idx] && input[idx] <= '9'; idx++) result += input[idx];
    
    return ll(result);
}

ll solution(){
    
    
    
    return 0LL;
}


int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> input;
    
    vector<info> expr;
    bool flag = false;
    for(int i = 0; i < input.size(); i++){
        
        info currentInfo;
        
        if('0' <= input[i] && input[i] <= '9'){
            
            
            if(!expr.empty() && expr.back().isNum) {
                if(flag) {
                    cout << "ROCK";
                    return 0;
                }
                continue;
            }
            currentInfo = {true, getNumber(i)};
            
            if(!expr.empty()){
                ll into;
                if(expr.back().exp == '*'){
                    expr.pop_back();
                    into = expr.back().num * currentInfo.num;
                    expr.pop_back();
                    currentInfo.num = into;
                }else if(expr.back().exp == '/'){
                    expr.pop_back();
                    if(currentInfo.num == ll(0)){
                        cout << "ROCK";
                        return 0;
                    }
                    into = expr.back().num / currentInfo.num;
                    expr.pop_back();
                    currentInfo.num = into;
                }
            }
        }
        else currentInfo = {false, 0, input[i]};
        if ((!expr.empty() && !expr.back().isNum && !currentInfo.isNum &&
                    expr.back().exp != ')' && currentInfo.exp != '(')
                   || (expr.empty() && !currentInfo.isNum && currentInfo.exp != '(')) {
                   
            cout << "ROCK";
            return 0;
        }
        flag = false;
        expr.push_back(currentInfo);
        
        if(expr.back().isNum) continue;
        
        if(expr.back().exp != ')') continue;
        flag = true;
        expr.pop_back();
        ll currentNumber = expr.back().num;
        expr.pop_back();
        
        
        while(expr.back().exp != '('){
            char operation = expr.back().exp; expr.pop_back();
            ll otherNumber = expr.back().num; expr.pop_back();
            
            switch (operation) {
                case '+':
                    currentNumber = otherNumber + currentNumber;
                    break;
                case '-':
                    
                    currentNumber = otherNumber - currentNumber;
                default:
                    break;
            }
            
            if(expr.empty()) {
                cout << "ROCK";
                return 0;
            }
            
        }
        expr.pop_back();
        
        if(!expr.empty()){
            if(expr.back().isNum) {
                cout << "ROCK";
                return 0;
            }
            
            
            if(expr.back().exp != '(' && (expr.back().exp == '*' || expr.back().exp == '/')){
                char operation = expr.back().exp; expr.pop_back();
                ll otherNumber = expr.back().num; expr.pop_back();
                
                
                switch (operation) {
                    case '+':
                        currentNumber = otherNumber + currentNumber;
                        break;
                    case '-':
                        currentNumber = otherNumber - currentNumber;
                        break;
                    case '*':
                        currentNumber = currentNumber * otherNumber;
                        break;
                    case '/':
                        if(currentNumber == ll(0)){
                            cout << "ROCK";
                            return 0;
                        }
                        currentNumber = otherNumber / currentNumber;
                        break;
                    default:
                        break;
                }
            }
        }
        
        expr.push_back({true, currentNumber});
        
        
    }
    if(!expr.back().isNum) {
        cout << "ROCK";
        return 0;
    }
//    for(int i = 0; i < expr.size(); i++){
//        if(expr[i].isNum)
//            cout << expr[i].num << " ";
//        else
//            cout << expr[i].exp << " ";
//    }
    
//    cout << "\n";
    ll result = expr.back().num;
    expr.pop_back();
    
    
    
    
    while(!expr.empty()){
        
        if(expr.back().isNum) {
            cout << "ROCK";
            return 0;
        }
        
        char operation = expr.back().exp; expr.pop_back();
        if(!expr.back().isNum) {
            cout << "ROCK";
            return 0;
        }
        ll otherNumber = expr.back().num; expr.pop_back();
        
        
        if(!expr.empty()){
            if(expr.back().isNum){
                cout << "ROCK";
                return 0;
                
            }
            
            if(expr.back().exp == '-'){
                if(operation == '+'){
                    operation = '+';
                    result = result - otherNumber;
                }else if(operation == '-'){
                    operation = '-';
                    result = otherNumber + result;
                    
                }
                continue;
            }
            
        }
        
        
        switch (operation) {
            case '+':
                result = otherNumber + result;
                break;
            case '-':
//                cout << otherNumber << " " << result << "\n";
                result = otherNumber - result;
                break;
            default:
                break;
        }
        
    }
    
    
    std::cout << std::fixed << std::setprecision(0) << result;
    
    
    
    return 0;
}

</details>

[BOJ] 할 일 정하기 1

Tue, 07 Oct 2025 00:00:00 GMT

할 일 정하기 1

TimeLimit	MemoryLimit	Condition	TAG
1s	512MB	1 ≤ N ≤ 20, 1 ≤ b ≤ 10,000	Dynamic Programming

그냥 바로 풀었던 dp 중 하나인 것 같습니다. 냄새가 너무 심하게나서 바로 bit mask로 접근했던거 같구요.(아마 최근에 bit mask를 많이 풀어서 바로 했던거 같아요)

재미있게 풀었던 문제였습니다.

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
#include <numeric>
#include <unordered_set>
#include <unordered_map>
#include <climits>
#include <math.h>
using namespace std;
using ll = unsigned long long;
using ld = long double;
//ll MOD = 1'000'000'007;
ll MOD = 1'000'000'000;
//ll MOD = 1.8446744074E19;

int N;

int costs[21][21];

ll dp[1 << 20];

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> N;
    for(int i = 0; i < N; i++){
        for(int j = 0; j < N; j++) cin >> costs[i][j];
    }
    
    for(int i = 0; i < 1 << 20; i++) dp[i] = LLONG_MAX;
    dp[0] = 0;
    for(int i = 1; i < 1 << 20; i++){
        
        int idx = -1;
        for(int j = 0; j < 20; j++) idx += (i & (1 << j)) ? 1 : 0;
        
        for(int j = 0; j < 20; j++){
            int current = (1 << j);
            if(!(i & current)) continue;
            
            int next = i - current;
            
            dp[i] = min(dp[next] + costs[idx][j], dp[i]);
            
        }
    }
    
    
    cout << dp[(1 << N) - 1];
    
    


    return 0;
}

</details>

[BOJ] 고층 빌딩

Sun, 05 Oct 2025 00:00:00 GMT

고층 빌딩

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1 ≤ N ≤ 100, 1 ≤ L, R ≤ N)	Math

오랜만에 수학 문제여서.. 약간? 고민의 시간을 가졌습니다. 최근에 그래도 문제를 풀면서 그냥 머릿속에서만 말고 블로그 쓰는김에 패드로 좀 끄적이고 있는데요.

제 의식의 흐름을 보여드리겠습니다.

이 방식으로

f(n,l,r)=f(n−1,l−1,r)+f(n−1,l,r−1)+(n−2)f(n−1,l,r)

이렇게 유도가 되더라구요. 그렇게 그냥 코드를 작성하면 됩니다.

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
#include <numeric>
#include <unordered_set>
#include <unordered_map>
#include <climits>
using namespace std;
using ll = unsigned long long;
ll MOD = 1'000'000'007;
//ll MOD = 1.8446744074E19;

int N, L, R;

ll dp[101][101][101];

ll solution(ll n, ll l, ll r){
    ll result = 0;
    if (l <= 0 || r <= 0 || l + r > n + 1) return 0;
    if(n == 1) return (l == 1 && r == 1);
    
    if(dp[n][l][r] != -1) return dp[n][l][r];
    
    // solution(n+1, r, l) = solution(n, r-1, l) + solution(n, r, l-1) + solution(n, r, l) * n
    result = ((solution(n-1, l, r-1)%MOD + solution(n-1, l-1, r)%MOD)%MOD + (solution(n-1, l, r) * (n-2))%MOD)%MOD;
    dp[n][l][r] = result;
    return result;
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> N >> L >> R;
    
    for(int i = 0; i < 101; i++){
        for(int j = 0; j < 101; j++){
            
            for(int k = 0; k < 101; k++){
                dp[i][j][k] = -1;
            }
        }
    }
    
    
    cout << solution(N, L, R);
    
    return 0;
}

</details>

[BOJ] 풀자

Thu, 03 Oct 2024 00:00:00 GMT

풀자

유진이의 선생님은 유진이에게 몇 개의 문제를 풀라고 주었다. 유진이는 반드시 문제 1번을 먼저 풀어야 한다. 만약에 A번 문제를 풀었을 때, 유진이는 A+1번 문제를 풀거나, A+1번 문제를 건너뛰고 A+2번 문제를 푸는 것도 가능하다. 따라서, 1, 3, 4, 6과 같이 문제를 푸는 것은 가능하지만, 1, 3, 5, 8과 같이 문제를 푸는 것은 불가능하다.

유진이는 문제를 풀면서 흥미를 느낀다. 입력으로 주어지는 P배열은 유진이가 각 문제를 풀 때 느끼는 흥미도를 수치화 한 값이다.

유진이의 선생님은 유진이의 흥미도가 특정 범위내에 들면 문제를 푸는 것을 중지시키려고 한다. 만약 유진이가 지금까지 푼 문제의 흥미도의 최댓값과, 최솟값의 차이가 V보다 크거나 같으면 문제를 푸는 것을 중지하게 된다. 만약 이런 일이 절대 일어나지 않으면, 유진이는 문제를 다 풀게 된다. 유진이가 풀어야 하는 최소 문제수를 출력하는 프로그램을 작성하시오.

일단 간단한 조건이 있다. 문제를 딱 보는 순간 배열 P의 max값과 min값의 차이가 V보다 작으면 무조건 N을 출력하면 된다. 이 조건이 굉장히 중요하다. 나는 그냥 bruteforce 다 돌고나서 없으면 N을 반환하게 해놨더니 시간초가가 빻 ㅠㅜㅜ

이 조건을 처음에 넣고서, 그냥 재귀로 풀이하였따.

0번째는 무조건 풀어야 하기에 처음은 무조건 풀고서, 그 후에는 약간의 memo를 넣어서 시간을 아끼게 해줬어용

좀 예쁜코드는 아닌거 가타여

모드 즐거운 ps 하세용

#define MAX 2100000000
#define LIMIT 10'000'000
#include <iostream>
#include<vector>
#include <algorithm>
#include <queue>
#include <stack>
using namespace std;
using ll = long long;

int n, v;
vector<int> problems;
int costs[1001];
int visited[1001][1001];
int result = MAX;

int limit = MAX;

void solution(int current, int interest_min, int interest_max, int count){
    if(current >= n || result <= count || current > limit) return;
    
    if(visited[current][count] > interest_max - interest_min) return;
    
    visited[current][count] = interest_max - interest_min;

    if(interest_max - interest_min >= v){
        result = min(count, result);
        limit = min(limit, current);
        return;
    }
    
    solution(current+1, min(interest_min, problems[current+1]), max(interest_max, problems[current+1]), count+1);
    if(current < n - 2) solution(current+2, min(interest_min, problems[current+2]), max(interest_max, problems[current+2]), count+1);
}

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

    cin >> n >> v;
    
    
    problems.resize(n+1);
    
    int mymin = MAX, mymax = -1;
    for(int i = 0; i < n; i++){
        cin>> problems[i]; costs[i] = MAX;
        if(mymin > problems[i]) mymin = problems[i];
        if(mymax < problems[i]) mymax = problems[i];
        for(int j = 0; j < n; j++)
            visited[i][j] = -1;
    }
    
    if(mymax - mymin >= v) solution(0, problems[0], problems[0], 1);

    if(result == MAX) cout << n;
    else cout << result;
    
    
    return 0;
}

</details>

[BOJ] 다음 팰린드롬 수

Thu, 03 Oct 2024 00:00:00 GMT

다음 팰린드롬 수

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1 <= N <= 50)	Implementation(구현)

팰린드롬 수는 앞으로 읽어도, 뒤로 읽어도 같은 숫자이다. 101, 4, 6666와 같은 숫자는 팰린드롬 수이고, 10, 564, 15452와 같은 숫자는 아니다. 어떤 수 N이 주어질 때, N보다 큰 팰린드롬 수 중에서 가장 작은 수를 출력한다.

참 요런 문제들이 진짜 설명이 간단하다. 우리의 목적은 주어진 수보다 큰 팰린드롬 수 중 작은 수를 출력하면 된다.

나는 이번 문제 풀면서 cpp string 함수들에 대해서 많이 알게되었다. 구현의 왕이 되기 위해서 더욱 단련하자....

(지금 학교에서 하고있는 100일 챌린지 때문에 1일 1포스팅(백준 또는 드림핵)을 하느라 설명이 거의 없는 점 죄송합니둥...)

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

using namespace std;

string solution(string num) {
    int n = num.length();
    string left = num.substr(0, (n + 1) / 2);
    string right = string(left.rbegin() + (n % 2), left.rend());

    if (left + right <= num) {
        int mid = (n - 1) / 2;
        bool allNines = true;
        for (int i = 0; i <= mid; i++) {
            if (num[i] != '9') {
                allNines = false;
                break;
            }
        }

        if (allNines) {
            return "1" + string(n - 1, '0') + "1";
        }

        for (int i = mid; i >= 0; i--) {
            if (num[i] < '9') {
                num[i]++;
                break;
            }
            num[i] = '0';
        }

        left = num.substr(0, (n + 1) / 2);
    }

    right = string(left.rbegin() + (n % 2), left.rend());
    return left + right;
}

int main() {
    string N;
    cin >> N;
    cout << solution(N) << "\n";
    return 0;
}

</details>

[BOJ] 구슬 탈출

Mon, 17 Mar 2025 00:00:00 GMT

구슬 탈출

TimeLimit	MemoryLimit	Condition	TAG
2s	512MB	(3 ≤ N, M ≤ 10)	BFS

아니 솔브드 스트릭이 끊겼는데 뭔 오륜지 모르겠네요... ㅠㅜ

하튼 구슬 탈출 시리즈는 그냥 우려먹기 인듯합니다

#include <iostream>
#include <vector>
#include <set>
#include <queue>
#include <map>
#include <algorithm>
using namespace std;
using ll = long long;

int inf = 1e9+7;

int n ,m;

char board[11][11];
bool visited[11][11][2]; // 0 is red, 1 is blue



pair<pair<int, int>, bool> move(int dx, int dy, int y, int x, pair<int, int> current){
    queue<pair<int ,int>> q;
    q.push({y, x});
    
    pair<int, int> last;
    
    bool check = false;
    
    while(!q.empty()){
        
        auto [cy, cx] = q.front(); q.pop();
        last= {cy, cx};
        
        if(board[cy][cx] == 'O') return {last, false};
        
        if(cy == current.first && cx == current.second) check = true;
        
        int nx = cx + dx;
        int ny = cy + dy;
        
        if(0 <= ny && ny < n && 0 <= nx && nx < m && board[ny][nx] != '#') q.push({ny, nx});
        
    }
    
    last.first += dy * -1 *  check;
    last.second += dx * -1 *  check;
    
    
    return {last, check};
    
}

int solution(pair<int, int> red_ball, pair<int, int> blue_ball){
    
    queue<pair<int, int>> balls;
    
    
    int dy[] = {1, -1, 0, 0}, dx[] = {0, 0, 1, -1};
    
    
    // 근데 뭐가 먼저 움직이는가.. 이게 중요하거든 blue 부터
    
    balls.push(blue_ball);
    balls.push(red_ball);
    visited[red_ball.first][red_ball.second][0] = true;
    visited[blue_ball.first][blue_ball.second][1] = true;
    
    
    
    int step = 0;
    while(++step <= 10){
        int length = balls.size();
        
        
        bool hole_check = false;
        
        vector<pair<int, int>> update;
        
        while(length > 0){
            pair<int, int> blue = balls.front(); balls.pop();
            pair<int, int> red = balls.front(); balls.pop();

            for(int i = 0; i < 4; i++){
                auto [blue_move, blue_check] = move(dx[i], dy[i], blue.first, blue.second, red);
                
                if(board[blue_move.first][blue_move.second] == 'O') continue;
                
                auto [red_move, red_check] = move(dx[i], dy[i], red.first, red.second, blue);
                
                if(board[red_move.first][red_move.second] == 'O') return step;
                
                balls.push(blue_move);
                balls.push(red_move);
            }
            length-=2;
        }
        
//
//        cout << "\n";
//        for(int i = 0; i < n; i++){
//            for(int j = 0; j < m; j++){
//                cout << visited[i][j][0] << " ";
//            }
//            cout << "\n";
//        }
//        cout << "\n";
    }
    
    return -1;
    
}

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

    cin >> n >> m;
    
    
    pair<int, int> red_ball, blue_ball, hole;
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            cin >> board[i][j];
            
            if(board[i][j] == 'B') blue_ball = {i, j};
            else if(board[i][j] == 'R') red_ball = {i, j};
            else if(board[i][j] == 'O') hole = {i, j};
        }
    }
    // 그렇네.. 허헣 아 그러면
    
    bool check = solution(red_ball, blue_ball) != -1;
    cout << check;
    
    return 0;
}

</details>

[BOJ] 구슬 탈출 2

Sun, 16 Mar 2025 00:00:00 GMT

구슬 탈출 2

TimeLimit	MemoryLimit	Condition	TAG
2s	512MB	(3 ≤ N, M ≤ 10)	BFS

이 문제는 공을 굴릴 때 어떻게 같은 방향으로 움직인 상태에서 공이 나가고 막히고 등등 이거를 처리하는 "순서"만 잘 캐치해서 구현하면 쉽게 풀리는 BFS 기본 유형인 듯 보입니다.

그 순서만 잘 골라서 처리하면 바로 풀 수 있습니다.

처음에 다르게 짜다가 구조를 갈아 엎어서 이상한 주석이나 안 쓰는 것들이 좀 많네요.. 허헣..

#include <iostream>
#include <vector>
#include <set>
#include <queue>
#include <map>
#include <algorithm>
using namespace std;
using ll = long long;

int inf = 1e9+7;

int n ,m;

char board[11][11];
bool visited[11][11][2]; // 0 is red, 1 is blue



pair<pair<int, int>, bool> move(int dx, int dy, int y, int x, pair<int, int> current){
    queue<pair<int ,int>> q;
    q.push({y, x});
    
    pair<int, int> last;
    
    bool check = false;
    
    while(!q.empty()){
        
        auto [cy, cx] = q.front(); q.pop();
        last= {cy, cx};
        
        if(board[cy][cx] == 'O') return {last, false};
        
        if(cy == current.first && cx == current.second) check = true;
        
        int nx = cx + dx;
        int ny = cy + dy;
        
        if(0 <= ny && ny < n && 0 <= nx && nx < m && board[ny][nx] != '#') q.push({ny, nx});
        
    }
    
    last.first += dy * -1 *  check;
    last.second += dx * -1 *  check;
    
    
    return {last, check};
    
}

int solution(pair<int, int> red_ball, pair<int, int> blue_ball){
    
    queue<pair<int, int>> balls;
    
    
    int dy[] = {1, -1, 0, 0}, dx[] = {0, 0, 1, -1};
    
    
    // 근데 뭐가 먼저 움직이는가.. 이게 중요하거든 blue 부터
    
    balls.push(blue_ball);
    balls.push(red_ball);
    visited[red_ball.first][red_ball.second][0] = true;
    visited[blue_ball.first][blue_ball.second][1] = true;
    
    
    
    int step = 0;
    while(++step <= 10){
        int length = balls.size();
        
        
        bool hole_check = false;
        
        vector<pair<int, int>> update;
        
        while(length > 0){
            pair<int, int> blue = balls.front(); balls.pop();
            pair<int, int> red = balls.front(); balls.pop();

            for(int i = 0; i < 4; i++){
                auto [blue_move, blue_check] = move(dx[i], dy[i], blue.first, blue.second, red);
                
                if(board[blue_move.first][blue_move.second] == 'O') continue;
                
                auto [red_move, red_check] = move(dx[i], dy[i], red.first, red.second, blue);
                
                if(board[red_move.first][red_move.second] == 'O') return step;
                
                balls.push(blue_move);
                balls.push(red_move);
            }
            length-=2;
        }
        
//
//        cout << "\n";
//        for(int i = 0; i < n; i++){
//            for(int j = 0; j < m; j++){
//                cout << visited[i][j][0] << " ";
//            }
//            cout << "\n";
//        }
//        cout << "\n";
    }
    
    return -1;
    
}

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

    cin >> n >> m;
    
    
    pair<int, int> red_ball, blue_ball, hole;
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            cin >> board[i][j];
            
            if(board[i][j] == 'B') blue_ball = {i, j};
            else if(board[i][j] == 'R') red_ball = {i, j};
            else if(board[i][j] == 'O') hole = {i, j};
        }
    }
    // 그렇네.. 허헣 아 그러면
    
    cout << solution(red_ball, blue_ball);
    
    return 0;
}

</details>

[BOJ] 무한 수열 1

Sun, 13 Oct 2024 00:00:00 GMT

무한 수열 1

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1 <= N <= 10¹², 2<= P, Q <= 10⁹)	Dynamic Programming(DP)

<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">

<mtable columnalign="left"> <mtr> <mtd> <msub><mi>A</mi><mn>0</mn></msub> <mo>=</mo> <mn>1</mn> </mtd> </mtr> <mtr> <mtd> <msub><mi>A</mi><mi>i</mi></msub> <mo>=</mo> <msub> <mi>A</mi> <mrow> <mo>⌊</mo> <mfrac> <mi>i</mi> <mi>P</mi> </mfrac> <mo>⌋</mo> </mrow> </msub> <mo>+</mo> <msub> <mi>A</mi> <mrow> <mo>⌊</mo> <mfrac> <mi>i</mi> <mi>Q</mi> </mfrac> <mo>⌋</mo> </mrow> </msub> <mtext> </mtext> <mo>(</mo> <mi>i</mi> <mo>≥</mo> <mn>1</mn> <mo>)</mo> </mtd> </mtr> </mtable> </math>

N, P와 Q가 주어질 때, AN을 구하는 프로그램을 작성하시오.

이것은 깊게 생각할 필요없이 그냥 map을 이용해서 풀이했습니다. 그런데 2차원 dp로도 풀 수 있겠더라구요.

효율적으로 풀이하려면 map보다는 array를 사용하는게 맞는 것 같습니다.

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

using ll = long long;
map<ll, ll> dp;
ll N, Q, P;
ll solution(ll n){
    if(dp.find(n) != dp.end()) return dp[n];
    
    ll result = solution((ll)(n/Q)) + solution((ll)(n/P));
    dp.insert({n, result});
    return result;
}

int main(){
    dp.insert({0, 1});
    cin >> N >> Q >> P;
    
    cout << solution(N);
    
    return 0;
}

</details>

[BOJ] 합과 곱

Mon, 10 Mar 2025 00:00:00 GMT

합과 곱

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1 ≤ S, P ≤ 1,000,000,000)	Math

아... 솔직히 이거 접근이 잘 안돼서 좀 힘들었습니다.. 사실 이거 산술기하까지는 갔는데 그걸 이렇게 발전시키는 아이디어를 바로 생각을 해내질 못해서 많이 묶여있었네요...

사실 문제는 그렇게 어려운편은 아니지만 좀 흥미롭게 풀 수 있었던 것 같아요.

저의 아이디어는 이제 "리스트에는 정수가 아닌 수가 포함될 수도 있다."이러한 문장이 문제에 존재했기 때문에 S/n으로 균일하게 나눈 후에.. 이거를 곱했을 때.. P보다 크거나 같은 수를 찾으면 되겠구나 생각했습니다.

이때 여기까지 오면서 산술기하를 사용한 것이구요.

:::tip[산술기하]

$$ \text{산술기하 평균 부등식(AM-GM Inequality)} $$

두 양수 $$a$$와 $$b$$에 대해, 산술평균은 기하평균보다 크거나 같다는 것을 증명해보겠습니다

$$ \frac{a + b}{2} \geq \sqrt{ab} $$

그리고 등호는 $$a = b$$일 때만 성립합니다

$$ \text{보통 수학시간에 배우는 기본적인 산술기하 평균 부등식} $$

$$(a - b)^2 \geq 0$$이라는 사실에서 시작합니다. 이것은 모든 실수의 제곱이 음이 아니기 때문입니다

$$ \begin{align} (a - b)^2 &\geq 0\ a^2 - 2ab + b^2 &\geq 0\ a^2 + 2ab + b^2 &\geq 4ab\ (a + b)^2 &\geq 4ab\ a + b &\geq 2\sqrt{ab}\ \frac{a + b}{2} &\geq \sqrt{ab} \end{align} $$

등호는 $$a - b = 0$$, 즉 $$a = b$$일 때만 성립합니다

$$ \text{우리가 알아야될 일반화된 산술기하평균 부등식} $$

$$n$$개의 양수 $$a_1, a_2, \ldots, a_n$$에 대해서도 산술평균과 기하평균의 부등식이 성립!

$$ \LARGE \frac{a_1 + a_2 + \cdots + a_n}{n} \geq \sqrt[n]{a_1 \cdot a_2 \cdot \ldots \cdot a_n} $$

$$ \text{귀납법을 이용한 증명} $$

$$n = 2$$인 경우는 이미 증명했습니다. $$n = 2^k$$인 경우에 대해 귀납법을 사용할 수 있습니다

$$n = 2^k$$일 때 부등식이 성립한다고 가정합시다. $$2^{k+1}$$개의 수 $$a_1, a_2, \ldots, a_{2^{k+1}}$$에 대해

$$ \begin{align} \frac{a_1 + \cdots + a_{2^{k+1}}}{2^{k+1}} &= \frac{1}{2}\left(\frac{a_1 + \cdots + a_{2^k}}{2^k} + \frac{a_{2^k+1} + \cdots + a_{2^{k+1}}}{2^k}\right)\ &\geq \frac{1}{2}\left(\sqrt[2^k]{a_1 \cdots a_{2^k}} + \sqrt[2^k]{a_{2^k+1} \cdots a_{2^{k+1}}}\right)\ &\geq \sqrt{\sqrt[2^k]{a_1 \cdots a_{2^k}} \cdot \sqrt[2^k]{a_{2^k+1} \cdots a_{2^{k+1}}}}\ &= \sqrt[2^{k+1}]{a_1 \cdots a_{2^{k+1}}} \end{align} $$

여기서도 등호는 모든 $$a_i$$가 서로 같을 때만 성립합니다. :::

그래서 이렇게 산술기하평균 부등식을 통해서 문제를 풀 수 있구요..

식을 구했다! 그르면 이제 어떻게 적용할 것이냐?

각 원소가 있죠? (S/n) >= sqrt(P, n) -> (S/n)^n >= P 이렇게해서 n을 쭉 순회하면서 구하면 됩니다.

그리고 1 1, 3 3과 같이 S와 P가 같은 경우는 1로 고정 출력하고 이후에는 그냥 2부터 S까지 쭉 순회하면 된답니다!

#include <iostream>
#include <queue>
#include <algorithm>
#include<set>
#include <map>
using namespace std;
using ll = long long;

int inf = 1e9;

double s, p;

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

    cin >> s >> p;
    
    
    if(s == p){
        cout << 1;
        return 0;
    }
    for(double n = 2; n <= s; n++){
        double element = s/n;
        
        double current = 1;
        double idx = 0;
        while(idx++<n) current*=element;
        
        if(current < p) continue;
        
        
        
        cout << n;
        return 0;
    }
    cout << -1;
    
    return 0;
}

</details>

[BOJ] 무한 수열 2

Sun, 13 Oct 2024 00:00:00 GMT

무한 수열 2

TimeLimit	MemoryLimit	Condition	TAG
10s	128MB	(1 <= N <= 10¹³, 2<= P, Q <= 10⁹,0<= X, Y <= 10⁹)	Dynamic Programming(DP)

<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"> <mtable columnalign="left"> <mtr> <mtd> <msub><mi>A</mi><mi>i</mi></msub> <mo>=</mo> <mn>1</mn> <mtext> </mtext> <mo>(</mo> <mi>i</mi> <mo>≤</mo> <mn>0</mn> <mo>)</mo> </mtd> </mtr> <mtr> <mtd> <msub><mi>A</mi><mi>i</mi></msub> <mo>=</mo> <msub> <mi>A</mi> <mrow> <mo>⌊</mo> <mfrac> <mi>i</mi> <mi>P</mi> </mfrac> <mo>⌋</mo> <mo>-</mo> <mi>X</mi> </mrow> </msub> <mo>+</mo> <msub> <mi>A</mi> <mrow> <mo>⌊</mo> <mfrac> <mi>i</mi> <mi>Q</mi> </mfrac> <mo>⌋</mo> <mo>-</mo> <mi>Y</mi> </mrow> </msub> <mtext> </mtext> <mo>(</mo> <mi>i</mi> <mo>≥</mo> <mn>1</mn> <mo>)</mo> </mtd> </mtr> </mtable> </math>

N, P, Q, X, Y가 주어질 때, AN을 구하는 프로그램을 작성하시오.

이건 1번에서 뭐 사실 똑같이 풀면 됩니다. 10초라서 디게 쉽게 접근할 수 있었고, 그냥 0이하일 때 1을 반환 하도록 하면 됩니다.

#include <iostream>
#include <map>

using namespace std;

using ll = long long;
map<ll, ll> dp;
ll N, Q, P, X, Y;
ll solution(ll n){
    if(dp.find(n) != dp.end()) return dp[n];
    if(n <= 0) return 1LL;
    ll result = solution((ll)(n/Q)-X) + solution((ll)(n/P)-Y);
    dp.insert({n, result});
    return result;
}

int main(){
    dp.insert({0, 1});
    cin >> N >> Q >> P >> X >> Y;
    
    cout << solution(N);
    
    return 0;
}

</details>

[BOJ] 강의실 2

Thu, 26 Mar 2026 00:00:00 GMT

강의실 2

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1 ≤ N ≤ 100,000)	Greedy

그냥 priority_queue 써서 먼저 채워버리는 방식이면 되는데 티어가 priority_queue 때문에 뻥튀기 됨.

#define MOD 1000000
#define MAX 200000001
#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>
#include <cstring>
#include <queue>
#include <stack>
#include <math.h>
using ll = long long;
using namespace std;

int n;


struct info {
    int number;
    int start, finish;
};

vector<int> rooms;
int members[100001];


int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    
    auto cmp =[](const info& a, const info& b){
        if(a.start > b.start) return true;
        else if(a.start == b.start) return a.finish > b.finish;
        return false;
    };
    
    cin >> n;
    priority_queue<info, vector<info>, decltype(cmp)> q;
    // 오 이거 신기하네
    
    
    for(int i = 0; i < n; i++){
        int a, b, c;
        cin >> a >> b >> c;
        info current = {a, b, c};
        
        q.push(current);
    }
    
    
    
    while(!q.empty()){
        info current = q.top(); q.pop();
        
        bool canIn= false;
        for(int i = 0; i < rooms.size(); i++){
            if(rooms[i]<= current.start){
                
                members[current.number] = i+1;
                
                canIn = true;
                rooms[i] = current.finish;
                break;
            }
        }
        
        if(!canIn){
            rooms.push_back(current.finish);
            members[current.number] = rooms.size();
        }
        
    }
    
    cout << rooms.size() <<"\n";
    
    for(int i = 1; i <= n; i++){
        cout << members[i] << "\n";
    }
        
    
    
    return 0;
    
    
    
    

}

//

</details>

[BOJ] 벌집

Mon, 29 Sep 2025 00:00:00 GMT

벌집

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	1 ≤ a, b ≤ 1,000,000	Implementation

그냥 간단히 구현하면 되는데... 벌집을 그래프로 만드는게 조금 어렵달까??

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
#include <numeric>
#include <unordered_set>
#include <unordered_map>
#include <climits>
using namespace std;
using ll = long long;

int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }

vector<int> board[1'500'000];
pair<int, int> visited[1'500'000];


void connect(int a, int b){
    board[a].push_back(b);
    board[b].push_back(a);
}

void makeBoard(){
    // 1,000,000
    // 3n(n+1)이네
    int current = 1;
    int cycle = 0;
    for(int n = 1; current <= 1'000'001; n++){
        int pre = 3 * (n - 1) * n + 1;
        int end = 3 * n * (n+1) + 1;
        
        
//        connect(pre, end);
        
//        cout << current << "\n";
//        
//        cout << "term: " << pre<< " " << end <<" " << 3 * (n - 2) * (n - 1) + 2<< "\n\n";
        connect(current, current - 1);
        connect(current+1, end);
        if(3 * (n - 2) * (n-1) + 1 > 0){
            connect(current, 3 * (n - 2) * (n-1) + 1);
            connect(current+1, 3 * (n - 2) * (n-1) + 1+1);
        }
        
        
        int term = 1;
        for(current ++; current < end; current++){
            connect(current, current-1);
//            cout << current << "\n";
//            
//            cout << "term: " << term<< " " << pre << "\n\n";
            if(term > cycle){
                connect(current, pre);
                term = 1;
//                cout << current << "\n";
                
            }else{
                connect(current, pre++);
                connect(current, pre);
                term++;
            }
            
            
            if(pre > 3 * (n - 1) * n + 1) pre = 3 * (n - 2) * (n-1) + 2;
        }
        
        
        
        cycle ++;
        
    }
    
    
    board[1].clear();
    for(int i = 2; i < 8; i++) board[1].push_back(i);
    
//    connect(8,  2); 여기 라인 대각선이 문제임
//    connect(19, 7);
}



vector<int> solution(int start, int finish){
    
    
    queue<int> q;
    
    for(int i = 1; i <= 1'000'001; i++){
        visited[i] = {1000000000, -1}; // cost, path
    }
    
//    cout << "check!";
    
    q.push(start);
    visited[start] = {0, -1};
    
    
    while(!q.empty()){
        int current = q.front(); q.pop();
        
        for(int next : board[current]){
            if(next >= 1'000'100) continue;
            if(visited[next].first <= visited[current].first + 1) continue;
            
            visited[next].first = visited[current].first + 1;
            visited[next].second = current;
            
            q.push(next);
        }
    }
    
    
    vector<int> result;
    int current = finish;
    while(visited[current].second != -1){
        result.push_back(current);
        current = visited[current].second;
    }
    result.push_back(start);
    
    reverse(result.begin(), result.end());
    return result;
}


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

    
    makeBoard();
    
    int a, b;
    cin >> a >> b;
    
//    for(int i : board[1]){
//        cout << i << " ";
//    }
    vector<int> result;
    result = solution(a, b);
    
    for(int i : result) cout << i << " ";
    
    
    return 0;
}

</details>

[BOJ] 암호

Mon, 24 Feb 2025 00:00:00 GMT

암호

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1 ≤ pw ≤ 1,000,000<br/> 1 ≤ words ≤ 100)	Implementation

그냥 나와있는 조건대로 구현하면 된다.

#include <iostream>
#include <string>
#include <vector>
#include <set>
using namespace std;
using ll = long long;
string pw, words;

char seq[150];

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    
    
    cin >> words;
    cin >> pw;
    
    for(int i = 0; i < words.size(); i++){
        if(seq[words[i]] > 0) continue;
        
        seq[words[i]] = i+1;
    }
    
    ll cycle = words.size();
    ll result = seq[pw[pw.size() - 1]];
    
    for(int i = pw.size() - 2; i > -1; i--){
        result +=  seq[pw[i]] * cycle;
        result %= 900528;
        cycle *= words.size();
        cycle %= 900528;
    }
    
    cout << result;
    
    return 0;
}

</details>

[BOJ] 미친 로봇

Thu, 27 Feb 2025 00:00:00 GMT

미친 로봇

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(1 ≤ N ≤ 14)	Implementation, Backtracking

문제는 그냥 재미있었다.. ㅋㅋㅌㅎㅌㅋ

일단 우리가 중요하게 생각할 것은 무엇보다도 오차를 줄이는 것.. 컴퓨터는 기본적으로 소수를 표현할 때 무한 소수나 엄청긴 숫자에 대해서 당연히 오차가 발생하는데 이런 것들을 어떻게 최대한 줄일까? 이런 아이디어만 있으면 쉽게 풀 수 있다.

나는 곱하기로 처리하다가 마지막에만 나눠서 처리하는 방식을 사용했다.

다행히 문제의 최대값 100^14 값이 1e28인데 double로 찍어보니 나와서 double로 맘편히 처리했다.

이번에 cout의 출력 형식 맞추는 것도 새롭게 알아간다

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


double probability[4];
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
int n;
bool visited[50][50];

double solution(int depth, pair<int, int> pos, double current){
    if(depth >= n) return current;
    
    double local_result = 0;
    
    for(int i = 0; i < 4; i++){
        int ny = dy[i] + pos.first;
        int nx = dx[i] + pos.second;
        
        if(visited[ny][nx] || probability[i] == 0) continue;
        visited[ny][nx] = true;
        
        local_result += solution(depth+1, {ny, nx}, current*probability[i]);
//        cout << "local : " << local_result << "\n";
        visited[ny][nx] = false;
    }
    
    return local_result;
}



int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    
    // result = 1e28;
    cin >> n;
    for(int i = 0; i < 4; i++) cin >> probability[i];
    
    pair<int, int> start = {25, 25};
    
    
    
    double d = 1;
    int i = n;
    while(i --> 0) d*=100;
    visited[25][25] = true;
    double result = solution(0, start, 1);
    cout.precision(10);
    cout << (double)(result / d);
    
    
    return 0;
}

</details>

[BOJ] 출근 기록

Fri, 09 May 2025 00:00:00 GMT

출근 기록

TimeLimit	MemoryLimit	Condition	TAG
2s	512MB	(1 ≤ S ≤ 50)	Dynamic Programming

일단 골드 2에서 그냥 그리디로 접근하다가 머리 깡 당하고 다시 생각하다보니 dp인 것 같아서 풀긴 했는데요

아직도 이해가 안되는건 골2가 왜 5차원 dp를 사용하는거죠? 뭐 더 간결하게 풀 수 있을지는 잘 모르겠지만 어허허허허허허허헣.. 쉽지 않네요....

무슨 문제만 보면 솔루션이 바로 안 떠오르면 자연스럽게 dp로만 생각하게 되는데 이런 버릇도 좀 고치고 싶네요

#include <iostream>
#include <queue>
#include <set>
#include <algorithm>
#include <random>

#define mod 1000000LL

using namespace std;
using ll = long long;
string n;

int counts[3];

bool dp[51][51][51][4][4]; // a, b, c, 전 번호, 전전 번호
char result[51];

bool solution(int a, int b, int c, int past, int pastpast){
    
    if(a < 1 && b < 1 && c < 1) return true;
    
    if(dp[a][b][c][past][pastpast]) return false;
    
    dp[a][b][c][past][pastpast] = true;
    
    
    result[a+b+c] = 'C';
    if(c > 0 && !(pastpast == 3 || past == 3)){ // C가 없는 경우
        if(solution(a,b, c-1, 3, past)) return true;
    }
    
    result[a+b+c] = 'B';
    if(b > 0 && past != 2){

        if(solution(a,b-1, c, 2, past)) return true;
    }
    
    
    result[a+b+c] = 'A';
    if(a > 0){
        if(solution(a-1, b, c, 1, past)) return true;
    }
 
    
    return false;
}

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    
    cin >> n;
    for(char i : n) counts[i-'A']++;
    
    int a = counts[0], b = counts[1], c = counts[2];
    
    
    if(!solution(a, b, c, 0, 0)) cout << -1;
    else{
        for(int i = 1; i <= n.size(); i++) cout << result[i];
    }
    return 0;
}

</details>

[BOJ] 나누어 질까

Tue, 25 Jun 2024 00:00:00 GMT

나누어 질까

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1<= N <=18, 1 <= L, R <= 10^9)	Math(수학)

어떤 숫자 배열 A가 주어지면, L보다 크거나 같고, R보다 작거나 같은 자연수 중에, A에 속해있는 원소 중 적어도 하나로 나누어지는 수의 개수를 구하는 프로그램을 작성하시오.

문제는 정말 간단하지만, 풀이를 생각하는데 꽤 많은 시간이 걸렸다. 일단 최소 공배수를 구하고, 이를 통해서 중복되는 것을 제외한 각 원소들의 배수들의 개수를 더하면 되는 문제입니다.

이걸 어떻게 풀 수 있을까요??

먼저 LCM(최소 공배수)를 구하는 방법은

ll lcm(int a, int b){
    return (a*b) / gcd(a, b);
}

이렇게 구현할 수 있다.

gcd의 구현은 "유클리드 호제법"을 이용해서 최적의 방법으로 구현이 가능하다. 이후에 경우의 수를 다 더하면 되는데, 이걸 어떻게 시간초과를 피하고, 정확하게 값을 출력할 수 있을까? 내가 해결한 방법의 힌트를 소개하겠다.

함수 f는 파라미터로 들어오는 n의 l부터 r까지의 배수의 개수를 가져오는 함수라고 정의한다.

f(n) = r/lcm(n) - l/lcm(n) + !(l%lcm(n))

이렇게 표현할 수 있다.

r > l이 언제나 성립하기 때문에 문제가 없으며, !(l%f(n))은 나머지가 나오지 않는다면, 나누어 떨어지기 때문에 "l 이상"의 조건에 의해서 l까지 포함시켜 더한다.

자 일단 이러한 함수를 가지고 하나의 문제를 풀어보겠다.

2 3 5라는 원소가 들어왔다고 치자.

l이 1이고, r이 100이라고 가정하자.

f(2) + f(3) + f(5)가 기본적으로 있을 것이고, 이제 겹치는 것들을 빼야한다.

2, 3의 최소 공배수 f(6)을 빼고, 2, 5의 최소 공배수 f(10)을 빼고, 3, 5의 최소 공배수 f(15)를 뺀다.

이렇게 뺄 때, 또 중복돼서 빼지는 수가 생기게 된다. 바로 2, 3, 5의 공배수가 3번 빠지기 때문에 개수 카운트가 전혀 안되는 것이다. 그래서 우리는 f(30)을 더해줄 것이다.

이제 뭔가 규칙이 보이죠??

바로 N개의 원소들로 공배수를 찾고서 빼거나 더할 때, 그 조건이 N개의 짝수, 홀수 여부라는 것을 알겠죠?

이제는 바로 문제를 풀어보자.

코드 풀이

유클리드 호제법

ull gcd(ull a, ull b){
    if(b == 0) return a;
    return gcd(b, a%b);
}

ull lcm(ull a, ull b){
    return (a*b) / gcd(a, b);
}

solution

그냥 bruteforce로 돌면서 그 조합에 대한 모든 경우를 빼고, 더하기를 하였다. cpp의 대한 코드를 이해할 수만 있다면, 코드 이해는 쉬울 것이라고 생각한다.

ll solution(int depth, vector<int> &current, int idx){
    ll result = 0;
    
    ull mylcm = 1;
    
    for(int num : current){
        mylcm = lcm(num, mylcm);
        if(mylcm > r) return result;
    }
    result+=(r/mylcm - l/mylcm + !(l%mylcm)) * (depth%2 ? -1 : 1);
    for(int i = idx+1; i < n; i++){
        current.push_back(nums[i]);
        result+= solution(depth+1, current, i);
        current.pop_back();
    }
    
    return result;
}

Main

이또한 코드에 이해가 안되진 않을 것이라 판단했다. 위에서 설명한 그대로의 식을 사용하여 구현한 것이라, 딱히 문제가 되진 않는다.

int main(){
    cin >> n >> l >> r;
    result_num = 0;
    vector<ull> real;
    for(int i = 0; i < n; i++){
        cin >> nums[i];
        result_num += r/nums[i] - l/nums[i] + !(l%nums[i]);
    }
    
    
    sort(nums, nums+n);
    
    vector<int> val;
    ll plus_value = 0;
    for(int i = 0; i < n; i++){
        for(int j = i+1; j < n; j++){
            val.push_back(nums[i]);
            val.push_back(nums[j]);
            plus_value += solution(1, val, j);
            val.pop_back();
            val.pop_back();
        }
    }
    
    cout <<  result_num + plus_value;
    return 0;
    
}

구현에서 어려웠던 것은 처음 overflow를 고려하지 못한 점이 너무나 컷다 그것 때문에 많은 시간을 허비했는데 요즘따라 overflow에 많이 당하고 있는데도 계속 당하는걸 보니 아직도 부족한가 보다.

여러분도 조심하셔요!

#define MAX 2'100'000'000
#define limit 10'000'000'000
#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <math.h>
#include <random>
using namespace std;

using ull = unsigned long long;
using ll = long long;


ull gcd(ull a, ull b){
    if(b == 0) return a;
    return gcd(b, a%b);
}

ull lcm(ull a, ull b){
    return (a*b) / gcd(a, b);
}

int nums[20];
ull result_num;
ll l, r;
int n;


ll solution(int depth, vector<int> &current, int idx){
    ll result = 0;
    
    
    ull mylcm = 1;
    for(int num : current){
        mylcm = lcm(num, mylcm);
        if(mylcm > r) return result;
    }
    result+=(r/mylcm - l/mylcm + !(l%mylcm)) * (depth%2 ? -1 : 1);
    for(int i = idx+1; i < n; i++){
        current.push_back(nums[i]);
        result+= solution(depth+1, current, i);
        current.pop_back();
    }
    
    
    return result;
}
bool visited[20];
int main(){
    cin >> n >> l >> r;
    result_num = 0;
    vector<ull> real;
    for(int i = 0; i < n; i++){
        cin >> nums[i];
        result_num += r/nums[i] - l/nums[i] + !(l%nums[i]);
    }
    
    
    sort(nums, nums+n);
    
    vector<int> val;
    ll plus_value = 0;
    for(int i = 0; i < n; i++){
        for(int j = i+1; j < n; j++){
            val.push_back(nums[i]);
            val.push_back(nums[j]);
            plus_value += solution(1, val, j);
            val.pop_back();
            val.pop_back();
        }
    }
    
    cout <<  result_num + plus_value;
    return 0;
    
    
}

</details>

[BOJ] 벽 부수고 이동하기 2

Fri, 11 Oct 2024 00:00:00 GMT

벽 부수고 이동하기 2

TimeLimit	MemoryLimit	Condition	TAG
2s	512MB	(1<= N, M <= 1000, 1 <= K <= 10)	BFS(너비우선탐색)

N×M의 행렬로 표현되는 맵이 있다. 맵에서 0은 이동할 수 있는 곳을 나타내고, 1은 이동할 수 없는 벽이 있는 곳을 나타낸다. 당신은 (1, 1)에서 (N, M)의 위치까지 이동하려 하는데, 이때 최단 경로로 이동하려 한다. 최단경로는 맵에서 가장 적은 개수의 칸을 지나는 경로를 말하는데, 이때 시작하는 칸과 끝나는 칸도 포함해서 센다.

만약에 이동하는 도중에 벽을 부수고 이동하는 것이 좀 더 경로가 짧아진다면, 벽을 K개 까지 부수고 이동하여도 된다.

한 칸에서 이동할 수 있는 칸은 상하좌우로 인접한 칸이다.

맵이 주어졌을 때, 최단 경로를 구해 내는 프로그램을 작성하시오.

그냥 BFS 문제임. 딱히 설명은 필요 없을 듯 합니다.

아 이번에 structured binding을 사용하면서 좀 코드 스타일에 변화가 찾아왔습니다.

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

int n, m, k;

int board[1001][1001];
int visited[1001][1001][11];
typedef struct pos{
    int y, x, k, c;
} pos;

bool visit_processing(pos p){
    if(p.k > 10) return true;
    for(int i = p.k; i > -1; i--)
        if(visited[p.y][p.x][i] <= p.c)
            return true;
        
    return false;
}

int main(){
    cin >> n >> m >> k;
    char _;
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            cin >> _;
            board[i][j] = _ - '0';
            for(int k_ = 0; k_ <= k; k_++)
                visited[i][j][k_] = 2100000000;
        }
    }
    
    queue<pos> q;
    q.push({0, 0, 0, 0});
    
    
    int dy[] = {1, -1, 0, 0};
    int dx[] = {0, 0, 1, -1};
    
    while(!q.empty()){
        pos p = q.front(); q.pop();
        
        if(visit_processing(p)) continue;
        auto [y, x, k, c] = p;
        visited[y][x][k] = c;
        for(int i = 0; i < 4; i++){
            int ny = y + dy[i];
            int nx = x + dx[i];
            
            if(0 <= ny && ny < n && 0 <= nx && nx < m)
                q.push({y+dy[i], x + dx[i], k+(board[ny][nx]), c+1});
            
        }
    }
        
    
    int result = 2100000000;
    for(int i = 0; i <= k; i++) result = min(result, visited[n-1][m-1][i]);
    if(result == 2100000000) cout << -1;
    else cout << result+1;
    return 0;
}

</details>

[BOJ] 테트로미노

Sun, 23 Jun 2024 00:00:00 GMT

테트로미노

TimeLimit	MemoryLimit	Condition	TAG
2s	512MB	(4 ≤ N, M ≤ 500)	Bruteforce(완전 탐색)

폴리오미노란 크기가 1×1인 정사각형을 여러 개 이어서 붙인 도형이며, 다음과 같은 조건을 만족해야 한다.

정사각형은 서로 겹치면 안 된다.

도형은 모두 연결되어 있어야 한다.

정사각형의 변끼리 연결되어 있어야 한다. 즉, 꼭짓점과 꼭짓점만 맞닿아 있으면 안 된다.

정사각형 4개를 이어 붙인 폴리오미노는 테트로미노라고 하며, 다음과 같은 5가지가 있다.

아름이는 크기가 N×M인 종이 위에 테트로미노 하나를 놓으려고 한다. 종이는 1×1 크기의 칸으로 나누어져 있으며, 각각의 칸에는 정수가 하나 쓰여 있다. 테트로미노 하나를 적절히 놓아서 테트로미노가 놓인 칸에 쓰여 있는 수들의 합을 최대로 하는 프로그램을 작성하시오. 테트로미노는 반드시 한 정사각형이 정확히 하나의 칸을 포함하도록 놓아야 하며, 회전이나 대칭을 시켜도 된다.

내가 한번 틀린 후 정답을 맞히게 되었는데, 내가 걸린 것은 바로 이 "대칭"을 제외하고, 회전만을 신경써서 틀리게되었다. 모두 회전, 대칭이 모두 가능 하다는 것을 인지하고, 문제를 접근하자!

이 문제는 딱히 dp나 다른 방법이 떠오르지 않았다. 문제의 시간 제한도 널널하고 조건 또한 그리 크지않아서 바로 완전 탐색을 돌려 해결하게 되었다.

코드의 설명은 딱히 필요 없을 정도로 굉장히 간단하고, 직관적이라 생략하도록 하겠다.

(현재 나는 go 언어 공부 중에 있어서, go 언어로 ps를 하는 중이다 -> go언어의 이해도를 높이기 위해서)

먼저 방법만 설명을 하자면, T, O, L, I, Z 의 대칭, 회전의 모든 모양을 if 처리하여 bruteforce를 돌린 코드이다. 굉장히 간단하고 직관적인다.

Go 언어에서 지원하는 기본적인 fmt.Scanf()는 입력을 받는 속도가 느리기 때문에 ps에 활용할때는 시간 초과가 나기 쉽다고 합니다. 그래서 bufio, os에 있는 reader, writer을 선언하고, 입력을 빠르게 받을 수 있도록 Fscan을 통해서 입력을 받았습니다.

다른 블로그를 찾아보니 딱히 reader, writer를 close 해줄 필요는 없는 것 같습니다(in ps)

package main

import (
	"bufio"
	"fmt"
	"os"
)

var board [501][501]int
var n, m int

type pos struct {
	x int
	y int
}

func mymax(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func solution(pos pos, cost int) int {

	if pos.x > m-1 {
		pos.x = 0
		pos.y += 1
		return solution(pos, cost)
	}
	if pos.y >= n {
		return cost
	}

	// L 4가지
	if pos.y < n-2 {
		if pos.x > 0 {
			cost = mymax(cost, board[pos.y][pos.x]+board[pos.y+1][pos.x]+board[pos.y][pos.x-1]+board[pos.y+2][pos.x])
			cost = mymax(cost, board[pos.y][pos.x]+board[pos.y+1][pos.x]+board[pos.y+2][pos.x-1]+board[pos.y+2][pos.x])
		}
		if pos.x < m-1 {
			cost = mymax(cost, board[pos.y][pos.x]+board[pos.y+1][pos.x]+board[pos.y+2][pos.x+1]+board[pos.y+2][pos.x])
			cost = mymax(cost, board[pos.y][pos.x]+board[pos.y+1][pos.x]+board[pos.y][pos.x+1]+board[pos.y+2][pos.x])

		}
	}
	if pos.x > 0 && pos.x < m-1 {
		if pos.y > 0 {
			cost = mymax(cost, board[pos.y][pos.x]+board[pos.y-1][pos.x+1]+board[pos.y][pos.x+1]+board[pos.y][pos.x-1])
			cost = mymax(cost, board[pos.y][pos.x]+board[pos.y-1][pos.x-1]+board[pos.y][pos.x+1]+board[pos.y][pos.x-1])

		}
		if pos.y < n-1 {
			cost = mymax(cost, board[pos.y][pos.x]+board[pos.y+1][pos.x-1]+board[pos.y][pos.x+1]+board[pos.y][pos.x-1])
			cost = mymax(cost, board[pos.y][pos.x]+board[pos.y+1][pos.x+1]+board[pos.y][pos.x+1]+board[pos.y][pos.x-1])

		}
	}

	// I 2가지
	if pos.y > 2 { // 세로
		cost = mymax(cost, board[pos.y-3][pos.x]+board[pos.y-2][pos.x]+board[pos.y-1][pos.x]+board[pos.y][pos.x])
	}
	if pos.x < m-3 {
		cost = mymax(cost, board[pos.y][pos.x]+board[pos.y][pos.x+1]+board[pos.y][pos.x+2]+board[pos.y][pos.x+3])
	}
	// O 1가지
	if pos.x < m-1 && pos.y < n-1 {
		cost = mymax(cost, board[pos.y][pos.x]+board[pos.y+1][pos.x]+board[pos.y][pos.x+1]+board[pos.y+1][pos.x+1])
	}
	// Z 2가지
	if pos.y < n-2 {
		if pos.x < m-1 {
			cost = mymax(cost, board[pos.y][pos.x]+board[pos.y+1][pos.x]+board[pos.y+1][pos.x+1]+board[pos.y+2][pos.x+1])
		}
		if pos.x > 0 {
			cost = mymax(cost, board[pos.y][pos.x]+board[pos.y+1][pos.x]+board[pos.y+1][pos.x-1]+board[pos.y+2][pos.x-1])
		}
	}
	if pos.x < m-2 {
		if pos.y < n-1 {
			cost = mymax(cost, board[pos.y][pos.x]+board[pos.y][pos.x+1]+board[pos.y+1][pos.x+1]+board[pos.y+1][pos.x+2])
		}
		if pos.y > 0 {
			cost = mymax(cost, board[pos.y][pos.x]+board[pos.y][pos.x+1]+board[pos.y-1][pos.x+1]+board[pos.y-1][pos.x+2])
		}

	}
	// T 4가지
	if pos.x > 0 && pos.x < m-1 {
		if pos.y < n-1 {
			// ㅜ
			cost = mymax(cost, board[pos.y][pos.x]+board[pos.y+1][pos.x]+board[pos.y][pos.x+1]+board[pos.y][pos.x-1])
		}
		if pos.y > 0 {
			// ㅗ
			cost = mymax(cost, board[pos.y][pos.x]+board[pos.y][pos.x+1]+board[pos.y][pos.x-1]+board[pos.y-1][pos.x])
		}

	}
	if pos.y < n-2 {
		if pos.x > 0 {
			// ㅓ
			cost = mymax(cost, board[pos.y][pos.x]+board[pos.y+1][pos.x]+board[pos.y+1][pos.x-1]+board[pos.y+2][pos.x])
		}
		if pos.x < m-1 {
			// ㅏ
			cost = mymax(cost, board[pos.y][pos.x]+board[pos.y+1][pos.x]+board[pos.y+1][pos.x+1]+board[pos.y+2][pos.x])

		}
	}

	pos.x += 1
	return solution(pos, cost)

}

func main() {
	// helo
	// fmt.Println("hello")
	var reader *bufio.Reader = bufio.NewReader(os.Stdin)
	var writer *bufio.Writer = bufio.NewWriter(os.Stdout)
	// defer: 이를 호출한 함수의 리턴 직전에 실행한다.
	// Flush: 모든 데이터가 writer에 보내졌음을 의미 (꼭 써줘야한다!)
	defer writer.Flush()

	fmt.Fscanln(reader, &n, &m)

	for i := 0; i < n; i++ {
		for j := 0; j < m; j++ {
			_, err := fmt.Fscan(reader, &board[i][j])
			if err != nil {
				return
			}
		}
	}

	var current pos
	current.y = 0
	current.x = 0
	fmt.Println(solution(current, 0))

}

</details>

[BOJ] 연구소

Wed, 10 Apr 2024 00:00:00 GMT

** https://www.acmicpc.net/problem/14502 **

TimeLimit	MemoryLimit	Condition	TAG
2s	512MB	(3<=N,M<=8)	BFS(너비 우선 탐), BruteForce(전체탐색)

일단 문제가 자체가 너무 BFS로 푸세요!!를 내뿜고 있어서 바로 BFS로 접근했다.

인체에 치명적인 바이러스를 연구하던 연구소에서 바이러스가 유출되었다. 다행히 바이러스는 아직 퍼지지 않았고, 바이러스의 확산을 막기 위해서 연구소에 벽을 세우려고 한다. 연구소는 크기가 N×M인 직사각형으로 나타낼 수 있으며, 직사각형은 1×1 크기의 정사각형으로 나누어져 있다. 연구소는 빈 칸, 벽으로 이루어져 있으며, 벽은 칸 하나를 가득 차지한다. 일부 칸은 바이러스가 존재하며, 이 바이러스는 상하좌우로 인접한 빈 칸으로 모두 퍼져나갈 수 있다. 새로 세울 수 있는 벽의 개수는 3개이며, 꼭 3개를 세워야 한다. 예를 들어, 아래와 같이 연구소가 생긴 경우를 살펴보자.

2 0 0 0 1 1 0
0 0 1 0 1 2 0
0 1 1 0 1 0 0
0 1 0 0 0 0 0
0 0 0 0 0 1 1
0 1 0 0 0 0 0
0 1 0 0 0 0 0

이때, 0은 빈 칸, 1은 벽, 2는 바이러스가 있는 곳이다. 아무런 벽을 세우지 않는다면, 바이러스는 모든 빈 칸으로 퍼져나갈 수 있다. 2행 1열, 1행 2열, 4행 6열에 벽을 세운다면 지도의 모양은 아래와 같아지게 된다.

2 1 0 0 1 1 0
1 0 1 0 1 2 0
0 1 1 0 1 0 0
0 1 0 0 0 1 0
0 0 0 0 0 1 1
0 1 0 0 0 0 0
0 1 0 0 0 0 0

바이러스가 퍼진 뒤의 모습은 아래와 같아진다.

2 1 0 0 1 1 2
1 0 1 0 1 2 2
0 1 1 0 1 2 2
0 1 0 0 0 1 2
0 0 0 0 0 1 1
0 1 0 0 0 0 0
0 1 0 0 0 0 0

벽을 3개 세운 뒤, 바이러스가 퍼질 수 없는 곳을 안전 영역이라고 한다. 위의 지도에서 안전 영역의 크기는 27이다. 연구소의 지도가 주어졌을 때 얻을 수 있는 안전 영역 크기의 최댓값을 구하는 프로그램을 작성하시오.

우리가 문제에서 집중해야 되는 것은 바로 "일부 칸은 바이러스가 존재하며, 이 바이러스는 상하좌우로 인접한 빈 칸으로 모두 퍼져나갈 수 있다. 새로 세울 수 있는 벽의 개수는 3개이며, 꼭 3개를 세워야 한다." 이 문장이다. 또한 grid(격자) 문제 답게 상하좌우로 이동할 수 있다고 문제에서 말하고 있다. "0은 빈 칸, 1은 벽, 2는 바이러스가 있는 곳이다." 이렇게 우리가 얻은 정보는

벽의 개수는 3개이며 "꼭" 모두 세워야한다.
바이러스는 동서남북으로 한 턴마다 확산된다.
바이러스는 벽을 이동하지 못 한다.
안전 영역이 가장 큰 경우를 구해야됨.

이제 문제를 파악했으니, 어떤 기능이 있어야 되는지를 정리해보자.

바이러스가 퍼지는걸 돌려줄 BFS 함수
벽을 3개 세워줄 벽세우는 함수
main

이 정도로 줄여줄 수 있을 것이다.

코드를 하나하나 짜보자!!

전역변수

using ll = long long;
using namespace std;
int dy[] = {0, 0, -1, 1}, dx[] = {1, -1, 0, 0};
int n, m;
int board[10][10];
vector<pair<int, int>> origin;
vector<pair<int, int>> position;
int count_ = 0;
int res = 0;
dy, dx

동서남북으로 움직일 바이러스의 경로를 for문으로 간단 처리하기 위해서

n, m

입력으로 n*m 크기의 연구소가 주어지기 때문에 입력받을 크기

origin

바이러스의 위치를 담은 vector

position

빈칸의 위치를 담은 vector

board

n*m 크기의 연구실(바이러스, 빈 칸, 벽의 위치를 담고 있음)

count_

빈 공간의 크기(개수)

res

result 값

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    
    cin >> n >> m;
    
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m;j++){
            cin>>board[i][j];
            if(board[i][j] == 2){
                origin.push_back(make_pair(i, j));
                board[i][j] = 0;
                count_++;
            }
            else if(board[i][j] == 0){
                count_++;
                position.push_back(make_pair(i, j));
            }
            
        }
    }
    
    int result = rec(3, 0) - 3;
    cout << result;
    
}

ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); 빠른 입출력을 하는 코드입니다.

먼저 n, m을 받습니다.

그 후 n*m 만큼 반복문을 돌면서 각 위치마다의 정보를 저장합니다.

바이러스이면 origin에 넣고, 빈 공간이면 position에 좌표를 저장합니다.

다음으로 3개의 벽을 세울 코드를 짜보자!

int rec(int current, int start){
    if(current <= 0){
        queue<pair<int, int>> q;
        for(pair<int, int> item : origin) q.push(item);
        int tmp[10][10];
        memcpy(tmp, board, sizeof(board));
        return solution(q, tmp, count_);
    }
    int result = 0;
    for(int i = start; i < position.size(); i++){
        pair<int, int> item = position[i];
        board[item.first][item.second] = 1;
        result = max(rec(current-1, i+1), result);
        board[item.first][item.second] = 0;
    }
    return result;
}

저는 재귀적으로 배치하고 solution이라는 BFS 함수를 호출해서 개수를 세도록 코드를 작성하였습니다.

약간의 백트래킹 느낌으로 current가 초기에 3이고, 그 후 1씩 감소하면서 3개의 벽을 생성 후 BFS를 돌리는 식으로 설계했습니다.

이제 마지막으로 BFS를 돌리는 solution에 대해서 보도록 하자

int solution(queue<pair<int, int>> q, int bor[10][10], int cnt){

    int x, y, ny, nx;
    while(!q.empty()){
        pair<int, int> pos = q.front();
        
        q.pop();

        x = pos.second;
        y = pos.first;
        if(bor[y][x] != 0) continue;
        bor[y][x] = 2;
        cnt--;

        for(int i = 0; i < 4; i ++){
            ny = y + dy[i];
            nx = x + dx[i];
            if(0 <= ny && ny < n && 0 <= nx && nx < m && bor[ny][nx] == 0) q.push(make_pair(ny, nx));
        }
    }
    return cnt;
}

solution은 q에 넣어놓은 바이러스들을 차례대로 확산시키면서 큐가 empty가 될 때까지 돌도록 하였습니다.

한번 방문한 위치에는 2로 업데이트 후 다시 동서남북으로 확상되도록 만들었습니다.

if문은 혹시나 board의 범위 밖으로 나가는 것을 방지하기 위해서 작성된 조건문입니다.

이렇게 나온 count는 벽을 포함한 빈 공간의 개수이므로 -3을 통해서 최대 빈 공간의 개수를 알 수 있습니다.

정답코드 <details> <summary>정답보기</summary>

Solution

#define MAX 200000001
#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>
#include <cstring>
#include <queue>
#include <stack>
using ll = long long;
using namespace std;

int dy[] = {0, 0, -1, 1}, dx[] = {1, -1, 0, 0};

int n, m;
int board[10][10];

vector<pair<int, int>> origin;
vector<pair<int, int>> position;
int count_ = 0;
int res = 0;
int test = 0;

int solution(queue<pair<int, int>> q, int bor[10][10], int cnt){

    int x, y, ny, nx;
    while(!q.empty()){
        pair<int, int> pos = q.front();
        
        q.pop();

        x = pos.second;
        y = pos.first;
        if(bor[y][x] != 0) continue;
        bor[y][x] = 2;
        cnt--;

        for(int i = 0; i < 4; i ++){
            ny = y + dy[i];
            nx = x + dx[i];
            if(0 <= ny && ny < n && 0 <= nx && nx < m && bor[ny][nx] == 0) q.push(make_pair(ny, nx));
        }
    }
    return cnt;
}

int rec(int current, int start){
    if(current <= 0){
        queue<pair<int, int>> q;
        for(pair<int, int> item : origin) q.push(item);
        int tmp[10][10];
        memcpy(tmp, board, sizeof(board));
        return solution(q, tmp, count_);
    }
    int result = 0;
    for(int i = start; i < position.size(); i++){
        pair<int, int> item = position[i];
        board[item.first][item.second] = 1;
        result = max(rec(current-1, i+1), result);
        board[item.first][item.second] = 0;
    }
    return result;
}
int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    cin >> n >> m;
    
    
    
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m;j++){
            cin>>board[i][j];
            if(board[i][j] == 2){
                origin.push_back(make_pair(i, j));
                board[i][j] = 0;
                count_++;
            }
            else if(board[i][j] == 0){
                count_++;
                position.push_back(make_pair(i, j));
            }
            
        }
    }
    
    int result = rec(3, 0) - 3;
    cout << result;
    
}

</details>

[BOJ] 거의 소수

Wed, 05 Feb 2025 00:00:00 GMT

거의 소수

TimeLimit	MemoryLimit	Condition	TAG
2s	256MB	(1 ≤ A ≤ B ≤ 1e14)	Math(수학), 에라토스테네스의 체, 소수판별

어떤 수가 소수의 N제곱(N ≥ 2) 꼴일 때, 그 수를 거의 소수라고 한다.

두 정수 A와 B가 주어지면, A보다 크거나 같고, B보다 작거나 같은 거의 소수가 몇 개인지 출력한다.

아니 문제는 딱히 할 말이 없어요.. 그대로 나와 있기 때문에 하지만 여기서 기본 구현은 쉬워서 50%까지는 뚫는데 거기서 틀려서 뭐지 싶습니다.

이때 잘 보시면 overflow가 발생한다는 것을 알 수 있는데요 저는 이걸 바로 못 발견해서 진짜 많이 당황했습니다. 하지만 이후에 바꿔서 잘 체크해서 넘겨서 AC를 받았네요

진짜 매번 overflow를 조심해야지 했는데 또 이렇게 하는 것을 보니 아직도 많이 부족하네요! 열심히 PS 해야겠습니다. 여러분들도 즐거운 PS 하세용!!

#include <iostream>
#include <queue>
#include <algorithm>
using namespace std;
using ll = long long;

ll a, b;

bool visited[(ll) 1e7+1];
vector<ll> primes;


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

    
    
    
    for(ll i = 2; i < 1e7; i++){
        if(visited[i]) continue;
        for(ll current = i; current <= 1e7; current+=i) visited[current] = true;
        primes.push_back(i);
    }
    
    
    int result = 0;
    for(ll prime : primes){
        ll current = prime*prime;
        while(current <= b){
            result+=(current >= a);
            if(current > b/prime) break;
            current*=prime;
        }
    }

    cout << result;
    return 0;
}

</details>

[BOJ] 샤워실 바닥 깔기 (Large)

Mon, 13 Oct 2025 00:00:00 GMT

샤워실 바닥 깔기 (Large)

TimeLimit	MemoryLimit	Condition	TAG
1s	512MB	(1 ≤ N ≤ 7)	Implementation

핵심 아이디어는 그냥 분할 정복이고, 사분면으로 나눠서 푸는 아이디어로 어디를 비워놓고 다른곳을 다 채울지 이것만 생각하면 금방 풀 수 잇는 문제인데, 약간의 구현력이 조금 따라오는거 같구요.

그리고 ㄱ 모양의 타일은 결국 정사각형의 나눠진 부분을 전부 채울 수 없고, 한칸을 비워놓을 수 밖에 없으니 그걸 어디서 합치고, 또 만약에 배수구 빼놓고 했을 때 완벽한 사각형이 등장하고, 이거 제외해서 어떻게 만들거냐! 이거를 생각만하면 solve가 가능한거 같네요

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
#include <numeric>
#include <unordered_set>
#include <unordered_map>
#include <climits>
#include <math.h>
using namespace std;
using ll = unsigned long long;
using ld = long double;
//ll MOD = 1'000'000'007;
ll MOD = 1'000'000'000;
//ll MOD = 1.8446744074E19;

int N, K;

int board[130][130];

int my_count;
int t1, t2;

// 그냥 사분면으로 나눠서 짤라버리면 되겠네 어차피 생긴 모양이 그래버리니까
// 사이즈가 그냥 한 변이라고 생각하고, 정사각형으로만 만든다고 생각하자
bool solution(int size, int y, int x, pair<int, int> pos){
    auto [hy, hx] = pos;
    
    if(size == 0) return false;
    
    int half = 1 << (size - 1);
    
    // 좌상, 우상, 좌하, 우하
    pair<int, int> states[] = {{0, 0}, {0, 1}, {1, 0}, {1, 1}};
    
    int hole_section = 0;
    // 일단 어느 사분면에 그 hole이 있는지 찾아보자
    // pos가 비워야될 위치
    for(int i = 0; i < 4; i++){
        int qy = y + half * states[i].first;
        int qx = x + half * states[i].second;
        
        if(qy <= hy && hy < qy + half && qx <= hx && hx < qx + half){
            hole_section = i;
            break;
        }
    }
    
    pair<int, int> centers[] = {
        {y + half - 1, x + half - 1},  // 좌상
        {y + half - 1, x + half},      // 우상
        {y + half, x + half - 1},      // 좌하
        {y + half, x + half}           // 우하
    };
    
    for(int idx = 0; idx < 4; idx++){
        if(hole_section == idx) continue;
        board[centers[idx].first][centers[idx].second] = my_count;
    }
    my_count++;
    
    for(int idx = 0; idx < 4; idx++){
        int qy = y + half * states[idx].first;
        int qx = x + half * states[idx].second;
        
        if(hole_section == idx){
            solution(size-1, qy, qx, pos);
        }else{
            solution(size-1, qy, qx, centers[idx]);
        }
    }
    
    return false;
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    
    cin >> K;
    N = 1 << K;

    
    cin >> t1 >> t2;
    
    board[N - t2][t1 - 1] = -1;
    my_count = 1;
    solution(K, 0, 0, {N - t2,t1 - 1});
    
    
    for(int i = 0; i < N; i++){
        for(int j = 0; j < N; j++){
            cout << board[i][j] << " ";
        }
        cout << "\n";
    }
    
    
    
    return 0;
}

/*
 
 0 0 0 0
 0 0 0 0
 0 0 0 0
 0 0 0 0

 
 */

</details>

[BOJ] 바이너리 문자열 토글

Sat, 05 Oct 2024 00:00:00 GMT

바이너리 문자열 토글

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1 ≤ N, U ≤ 100,000)	greedy, sweeping

길이가 N이고 모든 문자가 0인 바이너리 문자열 S0이 있다. 이 문자열에 변경 연산을 총 U번 할 것이고, 변경 연산이 끝난면 다른 문자열로 바뀌게 된다. i번째 연산은 Si-1을 Si로 바꾸는 연산이다. 따라서, U번의 변경 연산이 모두 끝나게 되면 문자열은 SU가 된다.

변경 연산은 (Li, Ri)와 같은 형태이다. 연산은 구간 [Li, Ri] (양 끝도 포함)에 속하는 모든 1을 0으로 바꾸고, 0을 1로 바꾸는 것이다.

모든 연산이 끝나게 되면, S0, S1, ..., SU를 구할 수 있게 된다. 이 U+1개의 바이너리 문자열 중에서 사전 순으로 가장 뒤에 오는 것을 구하는 프로그램을 작성하시오.

0->1 / 1->0 이다 그러면 뭐가 생각날까요? 바로 XOR이 떠오르죠? 일단 이걸 구현하고, 그걸 문제에 적용시키면서 그냥 사전순으로 업데이트하면 뙇 문제가 풀립니다.

(그냥 누적으로 xor 쌓은 다음에 각 단계 문자열 비교하고 최대 문자열 비교해서 업데이트하는 방법으로 구현하여 AC 맞음)

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

using namespace std;

const int MAX_N = 100001;

int N, U;
int xr[MAX_N];
string result(MAX_N, '0');

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

    cin >> N >> U;

    
    vector<pair<int, int>> op(U);
    for (int i = 0; i < U; i++) {
        cin >> op[i].first >> op[i].second;
        op[i].first--;
    }

    for (pair<int, int> op : op) {
        xr[op.first] ^= 1;
        xr[op.second] ^= 1;
    }

    int current = 0;
    for (int i = 0; i < N; i++) {
        current ^= xr[i];
        result[i] = current + '0';
    }

    string max_string = result;
    for (int i = U - 1; i >= 0; i--) {
        for (int j = op[i].first; j < op[i].second; j++)
            result[j] = (result[j] - '0') ? '0' : '1';
        max_string = max(max_string, result);
    }

    for(int i = 0; i < N; i++) cout << max_string[i];

    return 0;
}

</details>

[BOJ] 불 켜기

Wed, 01 Oct 2025 00:00:00 GMT

불 켜기

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1 ≤ N, M ≤ 8)	BruteForce, Greedy

솔직히 그냥 풀면 되는데... 처음에 가지치기 없이 그냥 풀었다가 머리 깡 당하고, 가만히 있다가 예...

더 생각해보니.. 뭔가 어떤 전구 문제 플레에 있었는데 분명 이거 브포밖에 답이 없는데 막 이러다 그리디로 접근해보자 하고 각잡고 생각하니까 겨우 풀었네요...

완전 어려운 난이도는 아니었는데 왜 이렇게 못 풀었는지 모르겠습니다.. 아직 실력이 많이 부족한가 봅니다. 오류 수정 2시간 동안 너무 힘들었습니다. ㅠ

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
#include <numeric>
#include <unordered_set>
#include <unordered_map>
#include <climits>
using namespace std;
using ll = long long;
ll MOD = 1'000'000'007;

int n, m;



set<ll> visited;
//map<ll, int> visited;


ll push(ll current, pair<int, int> yx){
    
    auto [y, x] = yx;
    
    int my = min(y+2, n);
    y = max(0, y - 1);
    
    int mx = min(x + 2, m);
    x = max(0, x - 1);
    
//    cout << y << " " << my << " " << x << " " << mx << "\n";
    for(int cy = y; cy < my; cy++){
        for(int cx = x; cx < mx; cx++){
            current ^= (1LL << (cy * 8 + cx));
        }
    }
    
    return current;
}



int main() {
    
    cin >> n >> m;
    
    // 이거 greedy가 맞는듯.
    // 그니까 결국 끝에서 바꾸는걸 포인트로 잡는건 맞고
    // 순차적으로 들어가는건데 맵 윗줄은 확정적으로 만들어야하니까 그것만 좀 알아서 잘 찾아내서 돌리고, 이후에 greedy하게 왼쪽 대각선있는 놈이 꺼져있으면 키도록 만들면 되는거 아님?
    // 그러면 마지막에도 되겠지 뭐
    
    
    
    ll state = 0;
    for(int i = 0; i < n; i++){
        char tmp;
        for(int j = 0; j < m; j++){
            
            cin >> tmp;
            if(tmp == '*') state |= 1LL << (j + i * 8);
            
        }
    }
    ll target = 0;
    
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            target |= (1LL << (i * 8 + j));
        }
    }
    
    
    // 순차적으로 돌렷는데 못 만드는 모양이면 그냥 못만드는 거니까 미련가지지 않으면 됨.
    
    ll result =LLONG_MAX;
    
    
    ll check = (1LL << (n+1));
    
    
    
    for(ll fy = 0; fy < (1LL << n); fy++){
        for(ll fx = 0; fx < (1LL << m); fx++){
            
            ll current = state;
            // fy가 첫번째 줄 이ㅐㅅ키임
            //fx는 처음 시작 col ㅇㅣㅁ
            
            ll cnt = 0;
            
            bool debug = false;
            
//            for(int i = 0; i < 5; i++){
//                if(fx & (1 << i)) cout << 1;
//                else cout << 0;
//            }
//            cout << " " << fx;
//            cout << "\n";
//            
//            if(fy == 15) debug = true;
            if(debug) cout << fy << " " << fx << "\n";
            
            
            
            for(int i = 0; i < n; i++){
                if(fy & (1LL << ((i)))) {
                    current = push(current, {i, 0});
                    cnt ++;
                }
            }
//            cout << "\n" << cnt << "\n";
            if(debug){
                
                for(int i = 0; i < n; i++){
                    for(int j = 0; j < m; j++){
                        if(!(current & 1LL << (i * 8 + j))) cout << 0;
                        else cout << 1;
                    }
                    cout << "\n";
                }
                cout << "\n";
            }
            for(int i = 0; i < m; i++){
                if(fx & (1LL << (i))){
                    current = push(current, {0, i});
                    cnt++;
                }
            }
//
            
            for(int i = 1; i < n; i++){
                for(int j = 1; j < m; j++){
//                    cout << i << " " << j << " " << (target & (1LL << ((i-1) * 8 + (j-1)))) << "\n";
//                    
//                    if(i == 3 && j == 3){
//                        for(int i = 0; i < n; i++){
//                            for(int j = 0; j < m; j++){
//                                if(!(current & 1LL << (i * 8 + j))) cout << 0;
//                                else cout << 1;
//                            }
//                            cout << "\n";
//                        }
//                        cout << "\n";
//                        
//                        
//                        for(int i = 0; i < n; i++){
//                            for(int j = 0; j < m; j++){
//                                if(!(((1LL << ((i-1) * 8 + (j-1)))) & 1LL << (i * 8 + j))) cout << 0;
//                                else cout << 1;
//                            }
//                            cout << "\n";
//                        }
//                        cout << "\n";
//                        
//                    }
//                    
                    if(!(current & (1LL << ((i-1) * 8 + (j-1))))) {
                        current = push(current, {i, j});
                        cnt++;
                    }
                }
            }
            if(debug){
                
                for(int i = 0; i < n; i++){
                    for(int j = 0; j < m; j++){
                        if(!(current & 1LL << (i * 8 + j))) cout << 0;
                        else cout << 1;
                    }
                    cout << "\n";
                }
                cout << "\n";
            }
            if(target == current)
                result = min(result, cnt);
            
        }
    }
    
//    
    if(result == LLONG_MAX) cout << -1;
    else cout << result;

    
//    cout << bfs(state);
//    if(visited.find(LLONG_MAX) == visited.end()) cout << -1;
//    else cout << visited[LLONG_MAX];
    return 0;
}

/*
 
 for(int i = 0; i < n; i++){
     for(int j = 0; j < m; j++){
         if(!(state & 1 << (i * 8 + j))) cout << 0;
         else cout << 1;
     }
     cout << "\n";
 }
 state = push(state, {2, 2});
 
 cout << "\n";
 
 for(int i = 0; i < n; i++){
     for(int j = 0; j < m; j++){
         if(!(state & 1 << (i * 8 + j))) cout << 0;
         else cout << 1;
     }
     cout << "\n";
 }
 state = push(state, {2, 2});
 
 cout << "\n";
 
 for(int i = 0; i < n; i++){
     for(int j = 0; j < m; j++){
         if(!(state & 1 << (i * 8 + j))) cout << 0;
         else cout << 1;
     }
     cout << "\n";
 }
 */

</details>

[BOJ] 팰린드롬 분할

Fri, 28 Mar 2025 00:00:00 GMT

팰린드롬 분할

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1 ≤ N ≤ 2500)	Dynamic Programming

코드 처음할 때 3차원으로 정의해놓고.. 쓰다보니까 그냥 아니라서 혼자 생각해서 풀었는데요

dp[i][j]는 i - j + 1부터 i까지 점프를 뛸 때(즉 팰린드롬일 때) 최소 값을 저장하고 이후에 돌면서 최솟값 업데이트해주고 그걸로 시간초과 피하면서 처리하면 AC!

#include <iostream>
#define inf 2100000000

using namespace std;
using ll = long long;

int dp[2501][2501]; // [i][j][k] i번째 수일 때 i - j까지의 연속된 순서가 팰린드롬일 때 현재 나눠진 팰린드롬의 개수
int visited[2501];

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    
    string input;
    
    cin >> input;
    int result = (int) input.size();
    
    int n = result;
    // 먼저 자기 자신 일단 넣어두고, 다음으로
    
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= n; j++) dp[i][j] = inf;
    }
    
    for(int i = 0; i <= n; i++) dp[0][i] = 0;
    dp[1][1] = 1;
    
    visited[0] = 0;
    visited[1] = 1;
    
    for(int i = 2; i <= n; i++){
        dp[i][1] = min(dp[i-1][1] + 1, dp[i-1][2]);
        visited[i] = inf;
        
        
    }
//        dp[i][
        
////    }
//    
//    
    for(int i = 2; i <= n; i++){
        
        for(int k = 1; k <= i; k++) {
            dp[i][1] = min(dp[i][1], dp[i-1][k] + 1);
            visited[i] = min(visited[i], dp[i][1]);
        }
        
        
        for(int j = 1; j < i; j++){
            
            
            
            if(input[j - 1] != input[i - 1]) continue;

//            else {
//                if(input[i-j-1] == 'R'){
//                    cout <<i << " "<< j << "\n";
//                }
//            }
            if(dp[i - 1][i - j - 1] >= inf) continue;
            
//            cout << "check: " << input[i-j-1] << " " << input[i] << "\n";
//            cout << "dp: " << dp[i-1][j-1] << "\n";
//
            dp[i][i - j + 1] = min(dp[i][i - j + 1], visited[j-1]+1);
            visited[i] = min(dp[i][i-j+1], visited[i]);
            
        }
    }
    
//    
//    for(int i = 1; i <= n; i++){
//        for(int j = 1; j <= n; j++){
//            if(dp[j][i] == inf) cout << "O ";
//            else cout << dp[j][i] << " ";
//        }
//        cout << "\n";
//    }
    
    cout << visited[n];
    
    
}
// ABACAAB
// QWERTYTREWQWERT


// DCADD
// 16
// BBCDDECAECBDABADDCEBACCCBDCAABDBADD
// BBCDDECAECBDABADDCEBACCCBDCAABDBADD

</details>

[BOJ] 구슬 탈출 3

Mon, 17 Mar 2025 00:00:00 GMT

구슬 탈출 3

TimeLimit	MemoryLimit	Condition	TAG
2s	512MB	(3 ≤ N, M ≤ 10)	BFS

우려먹기 시리즈라 그냥 설명은 첫번째 구슬 탈출 2에서 봐주시면 감사하겠습니다.

#include <iostream>
#include <vector>
#include <set>
#include <queue>
#include <map>
#include <algorithm>
using namespace std;
using ll = long long;

int inf = 1e9+7;

int n ,m;

char board[11][11];
bool visited[11][11][2]; // 0 is red, 1 is blue



pair<pair<int, int>, bool> move(int dx, int dy, int y, int x, pair<int, int> current){
    queue<pair<int ,int>> q;
    q.push({y, x});
    
    pair<int, int> last;
    
    bool check = false;
    
    while(!q.empty()){
        
        auto [cy, cx] = q.front(); q.pop();
        last= {cy, cx};
        
        if(board[cy][cx] == 'O') return {last, false};
        
        if(cy == current.first && cx == current.second) check = true;
        
        int nx = cx + dx;
        int ny = cy + dy;
        
        if(0 <= ny && ny < n && 0 <= nx && nx < m && board[ny][nx] != '#') q.push({ny, nx});
        
    }
    
    last.first += dy * -1 *  check;
    last.second += dx * -1 *  check;
    
    
    return {last, check};
    
}

pair<int, string> solution(pair<int, int> red_ball, pair<int, int> blue_ball){
    
    queue<pair<pair<int, int>, string>> balls;
    
    
    int dy[] = {1, -1, 0, 0}, dx[] = {0, 0, 1, -1};
    
    char direction[] = {'D', 'U', 'R', 'L'};
    // 근데 뭐가 먼저 움직이는가.. 이게 중요하거든 blue 부터
    
    balls.push({blue_ball, ""});
    balls.push({red_ball, ""});
    visited[red_ball.first][red_ball.second][0] = true;
    visited[blue_ball.first][blue_ball.second][1] = true;
    
    
    
    int step = 0;
    while(++step <= 10){
        int length = balls.size();
        
        
        
        
        while(length > 0){
            auto [blue, _] = balls.front(); balls.pop();
            auto [red, path] = balls.front(); balls.pop();

            for(int i = 0; i < 4; i++){
                auto [blue_move, blue_check] = move(dx[i], dy[i], blue.first, blue.second, red);
                
                if(board[blue_move.first][blue_move.second] == 'O') continue;
                
                auto [red_move, red_check] = move(dx[i], dy[i], red.first, red.second, blue);
                
                if(board[red_move.first][red_move.second] == 'O') return {step, path+direction[i]};
                
                balls.push({blue_move, ""});
                balls.push({red_move, path + direction[i]});
            }
            length-=2;
        }
        
//
//        cout << "\n";
//        for(int i = 0; i < n; i++){
//            for(int j = 0; j < m; j++){
//                cout << visited[i][j][0] << " ";
//            }
//            cout << "\n";
//        }
//        cout << "\n";
    }
    
    return {-1, ""};
    
}

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

    cin >> n >> m;
    
    
    pair<int, int> red_ball, blue_ball, hole;
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            cin >> board[i][j];
            
            if(board[i][j] == 'B') blue_ball = {i, j};
            else if(board[i][j] == 'R') red_ball = {i, j};
            else if(board[i][j] == 'O') hole = {i, j};
        }
    }
    // 그렇네.. 허헣 아 그러면
    
    auto [result, path] = solution(red_ball, blue_ball);
    
    cout << result << "\n";
    if(result >-1) cout << path;
    
    return 0;
}

</details>

[BOJ] 수학

Mon, 24 Jun 2024 00:00:00 GMT

수학

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1<= D, M <=50, 0 < Element <= 10^9)	Math(수학)

배열 D와, 배열 M이 주어졌을 때, D에 있는 모든 수의 배수이며, M에 있는 모든 수의 약수인 수의 개수를 구하는 프로그램을 작성하시오.

문제가 원하는 답은 정말 너무나 간단하다. 두 배열이 주어졌을 때, 하나의 배열을 D, 또 다른 배열을 M으로 둔다. 이 때 D의 최소공배수와 M의 최대공약수의 약수의 겹치는 수가 몇개 있는지를 찾아내는 프로그램을 작성하면 된다는 것이다.

먼저 우리는 빠른 시간 안에 최대 공약수와 최소 공배수를 찾는 방법에 대해서 알아보자

유클리드 호제법(Euclidean Algorithm)?

2개의 자연수의 최대 공약수(Greatest Common Divisor, GCD)를 구하는 알고리즘

:::tip[샹식] 호제법이란 말은 두 수가 서로(互) 상대방 수를 나누어(除)서 결국 원하는 수를 얻는 알고리즘을 나타낸다. :::

유클리드 호제법은 보통 GCD라는 함수로 구현되어 있습니다.

:::note[핵심] 유클리드 호제법은 Mod 연산(나머지 연산)을 통해서 최대 공약수를 얻어내는 방식이다.

'GCD(A, B) -> A % B -> B % (A%B) -> ....... -> GCD(A, B)' :::

2개의 자연수 a, b에 대해서 a를 b로 나눈 나머지를 r이라 하면(단, a>b), a와 b의 최대공약수는 b와 r의 최대공약수와 같다. 이 성질에 따라, b를 r로 나눈 나머지 r'를 구하고, 다시 r을 r'로 나눈 나머지를 구하는 과정을 반복하여 나머지가 0이 되었을 때 나누는 수가 a와 b의 최대공약수이다.

또한 최대 공약수를 이용해서 최소 공배수를 얻을 수 있는데 이를 이용해서 이 문제를 금방 풀 수 있다.

package main

import (
	"bufio"
	"fmt"
	"os"
)

var n, m int

func gcd(a, b int) int {
	if b == 0 {
		return a
	}
	return gcd(b, a%b)
}

func lcm(a, b int) int {
	return (a * b) / gcd(a, b)
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	_, err := fmt.Fscanln(reader, &n, &m)
	if err != nil {
		return
	}

	var tmp int
	fmt.Fscan(reader, &tmp)
	myLcm := tmp
	if tmp == 0 {
		fmt.Fprintln(writer, 0)
		return
	}
	for i := 0; i < n-1; i++ {
		fmt.Fscan(reader, &tmp)
		if tmp == 0 {
			fmt.Fprintln(writer, 0)
			return
		}
		myLcm = lcm(myLcm, tmp)
	}

	fmt.Fscan(reader, &tmp)
	myGcd := tmp

	if tmp == 0 {
		fmt.Fprintln(writer, 0)
		return
	}

	for i := 0; i < m-1; i++ {
		fmt.Fscan(reader, &tmp)
		if tmp == 0 {
			fmt.Fprintln(writer, 0)
			return
		}
		myGcd = gcd(myGcd, tmp)
	}

	if myGcd%myLcm != 0 {
		fmt.Fprintln(writer, 0)
		return
	}

	count := 0
	div := myGcd / myLcm
	for i := 1; i*i <= div; i++ {
		if div%i == 0 {
			count++
			if i != div/i {
				count++
			}
		}
	}

	fmt.Fprintln(writer, count)

}

</details>

[BOJ] 구슬 탈출 4

Mon, 17 Mar 2025 00:00:00 GMT

구슬 탈출 4

TimeLimit	MemoryLimit	Condition	TAG
2s	512MB	(3 ≤ N, M ≤ 10)	BFS

우려먹기 그 마지막 시리즈

#include <iostream>
#include <vector>
#include <set>
#include <queue>
#include <map>
#include <algorithm>
using namespace std;
using ll = long long;

int inf = 1e9+7;

int n ,m;

char board[11][11];
bool visited[11][11][11][11]; // 0 is red, 1 is blue



pair<pair<int, int>, bool> move(int dx, int dy, int y, int x, pair<int, int> current){
    queue<pair<int ,int>> q;
    q.push({y, x});
    
    pair<int, int> last;
    
    bool check = false;
    
    while(!q.empty()){
        
        auto [cy, cx] = q.front(); q.pop();
        last= {cy, cx};
        
        if(board[cy][cx] == 'O') return {last, false};
        
        if(cy == current.first && cx == current.second) check = true;
        
        int nx = cx + dx;
        int ny = cy + dy;
        
        if(0 <= ny && ny < n && 0 <= nx && nx < m && board[ny][nx] != '#') q.push({ny, nx});
        
    }
    
    last.first += dy * -1 *  check;
    last.second += dx * -1 *  check;
    
    
    return {last, check};
    
}

int solution(pair<int, int> red_ball, pair<int, int> blue_ball){
    
    queue<pair<int, int>> balls;
    
    
    int dy[] = {1, -1, 0, 0}, dx[] = {0, 0, 1, -1};
    
    
    
    // 근데 뭐가 먼저 움직이는가.. 이게 중요하거든 blue 부터
    
    balls.push(blue_ball);
    balls.push(red_ball);
    visited[red_ball.first][red_ball.second][blue_ball.first][blue_ball.second] = true;
    
    
    
    
    int step = 1;
    
    while(!balls.empty()){
        int length = balls.size()/2;
        while(length --> 0){
            pair<int, int> blue = balls.front(); balls.pop();
            pair<int, int> red = balls.front(); balls.pop();
            for(int i = 0; i < 4; i++){
                auto [blue_move, blue_check] = move(dx[i], dy[i], blue.first, blue.second, red);
                
                if(board[blue_move.first][blue_move.second] == 'O') continue;
                
                auto [red_move, red_check] = move(dx[i], dy[i], red.first, red.second, blue);
                
                if(board[red_move.first][red_move.second] == 'O') return step;
                
                if(visited[red_move.first][red_move.second][blue_move.first][blue_move.second])
                    continue;
                
                visited[red_move.first][red_move.second][blue_move.first][blue_move.second] = true;
                balls.push(blue_move);
                balls.push(red_move);
            }
        }

        step++;
    }
    
    return -1;
    
}

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

    cin >> n >> m;
    
    
    pair<int, int> red_ball, blue_ball, hole;
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            cin >> board[i][j];
            
            if(board[i][j] == 'B') blue_ball = {i, j};
            else if(board[i][j] == 'R') red_ball = {i, j};
            else if(board[i][j] == 'O') hole = {i, j};
        }
    }
    // 그렇네.. 허헣 아 그러면
    
    cout << solution(red_ball, blue_ball);
    
    
    return 0;
}

</details>

[BOJ] 연세워터파크

Sat, 05 Apr 2025 00:00:00 GMT

연세워터파크

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(2 ≤ N ≤ 100000<br/>1 ≤ D ≤ N-1)	Dynamic Programming

그냥 전형적인 DP인데 약간 새로운 관리법이 추가된 dp? 느낌이네요. 생각보다 재밌는 문제였습니다.

한번씩 풀어보면 좋을 듯 합니다.

#include <iostream>
#include <algorithm>
#include <map>
#include <set>
using namespace std;
using ll = long long;
int n, d;
ll dp[100'001];
ll nums[100'001];
map<ll, ll> current;
set<ll> keys;

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

    
    cin >> n >> d;
    ll result = -1e10;
    for(int i = 0; i < n; i++) cin >> nums[i];
    
    for(int i = 0; i < d; i++){
        ll previous = keys.empty() ? 0 : *--keys.end();
        dp[i] = max(previous + nums[i], nums[i]);
        
        keys.insert(dp[i]);
        current[dp[i]]++;
        
        result = max(dp[i], result);

    }
    for(int i = d; i < n; i++){
        ll previous = *--keys.end(); // 일단 전에 있던 것들 중에서 올 수 있는 가장 쩌는 애를 데려오겟다ㅓ
        dp[i] = max(previous + nums[i], nums[i]);
        
        keys.insert(dp[i]);
        current[dp[i]]++;
        
        
        current[dp[i - d]] --;
        if(!current[dp[i - d]]) keys.erase(dp[i-d]);
        
        result = max(dp[i], result);
    }
    
    
    cout << result;

    
    

    return 0;
}

</details>

[BOJ] 회문은 회문아니야!!

Wed, 02 Oct 2024 00:00:00 GMT

회문은 회문아니야!!

TimeLimit	MemoryLimit	Condition	TAG
2s	512MB	(1 ≤ N ≤ 500,000)	에드혹

팰린드롬이란 앞으로 읽으나 뒤로 읽으나 같은 문자열을 말한다. 팰린드롬의 예시로 POP, ABBA 등이 있고, 팰린드롬이 아닌 것의 예시로 ABCA, PALINDROME 등이 있다.

뭔가 이상한 점이 보이지 않는가? 그 어떤 언어에서도 팰린드롬을 뜻하는 단어는 팰린드롬이 아니다! 많은 사람들이 추구하는 “대칭의 아름다움”은 그저 허상에 불과하다.

알파벳 대문자로 이루어진 문자열이 주어졌을 때, 팰린드롬이 아닌 가장 긴 부분문자열의 길이를 구해 보자. 이때 부분문자열을 이루는 글자는 연속해야 한다. AB는 ABCD의 부분문자열이지만, AC는 아니다.

자 문제에 대해서 생각해보자

도대체 어떤 식으로 접근할까? 아이디어는 간단하다. 우리는 팰린드롬이 아닌 값을 찾아내는 것인데!

제일 긴 값을 찾는 것은 바로 끝과 끝을 비교한다. 그래서 쭉 돌아오면서 팰린드롬인지 확인한다. 만약 팰린드롬이면 마지막에서 -1해서 size -1의 상태에서 다시 팰린드롬인지 확인한다.

그렇다면 바로 이 값을 통해서 모두가 같은 문자열인지 아닌지를 판단한다. 모두가 같은 문자열이면 -1을할 것이고, 아니면 문자열의 size 또는 size -1을 반환하겠다.

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

using namespace std;

string n;

int solution(){
    
    // 걍 맞는지만 체크하면 끝이네
    
    int start =0, end = (int) n.size() - 1;
    while(start < end)
        if(n[start++] != n[end--]) return (int) n.size();
    
    end = (int) n.size() - 2;
    start = 0;
    
    while(start < end)
        if(n[start++] != n[end--]) return (int) n.size()-1;
    
    
    return -1;
    
}
int main() {
    cin >> n;
    
    cout << solution();
    return 0;
}

</details>

[BOJ] Parcel

Fri, 04 Apr 2025 00:00:00 GMT

Parcel

TimeLimit	MemoryLimit	Condition	TAG
1s	512MB	(10 ≤ w ≤ 799,994<br/>4 ≤ n ≤ 5,000)	Dynamic Programming, PreSum

일단 이거는 Meet in the middle 요거 사용한다고 하는데 그렇게 직관적인 사용은 아니고.. 이 네개의 값을 어떻게 시간 안에 우겨넣지? 라는 생각으로 풀다보면 solution이 나오게 되긴 합니다.

처음에는 두개씩 묶어서 이분 탐색으로 찾으려고 했는데 문제가 제가 생각한 느낌이 아니라서 좌절되고, 이후에 조금 생각해보니 아 이거 각 조합에다가 그냥 이중 두번 사용하면 좋겠다 이렇게 됐는데...

사실 이것도 시간초과가 납니다. 이게 그냥 이중이 아니라 안에 한번더 포문이 돌아가는데 별로 크지 않다고 생각했던게 아니였던 것이였죠.. 허ㅓㅎㅎ

그래서 생각했던게.. "최대인 놈 하나만" 찾으면 된다는 것에서 어차피 순차적으로 1부터 n까지 돌때 더했던 값을 맨 마지막으로 업데이트 시켜놓고 포문을 다시 1부터 n까지 돌게 시키면 제일 빨리 나올 수 있게 되면서 중복도 피할 수 있게 만들 수 있습니다. 그래서 그렇게 짰더니? 다행이 AC가 나오더군요..

다른 분들 풀이를 보니 저처럼 푼 분들이 많은 것으로 보였습니다. 하튼 생각보다 재미있는 문제였습니다.

#include <iostream>
#include <algorithm>
#include <map>
using namespace std;
int w, n;
int nums[5001];
pair<int,int> dp[400'001];



int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    
    cin >> w >> n;
    
    for(int i = 1; i <= n; i++) cin >> nums[i];
    
    int cnt = 0;
    for(int i = 1; i <= n; i++){
        for(int j = i+1; j <= n; j++) dp[nums[i]+nums[j]] = {i, j};
    }
    
    for(int i = 1; i <= n; i++){
        for(int j = i+1; j <= n; j++){
            int current = w - nums[i] - nums[j];
            if(!(1 < current && current < 400'001)) continue;
            if(dp[current].first == i || dp[current].second == j || dp[current].first + dp[current].second == 0
               || dp[current].first == j || dp[current].second == i) continue;
            
//            cout << i << " " << j << " " << dp[current].first << " " << dp[current].second << "\n";
            cout << "YES";
            return 0;
            
        }
    }
    
    cout << "NO";
    
    
    return 0;
}
/*
 10 6
 2 3 3 4 5 1
 */

</details>

[BOJ] 말이 되고픈 원숭이

Tue, 02 Jul 2024 00:00:00 GMT

말이 되고픈 원숭이

TimeLimit	MemoryLimit	Condition	TAG
2s	256MB	(1<= N, M <= 200<br/>0<=K<=30)	BFS(너비우선탐색)

동물원에서 막 탈출한 원숭이 한 마리가 세상구경을 하고 있다. 그 녀석은 말(Horse)이 되기를 간절히 원했다. 그래서 그는 말의 움직임을 유심히 살펴보고 그대로 따라 하기로 하였다. 말은 말이다. 말은 격자판에서 체스의 나이트와 같은 이동방식을 가진다. 다음 그림에 말의 이동방법이 나타나있다. x표시한 곳으로 말이 갈 수 있다는 뜻이다. 참고로 말은 장애물을 뛰어넘을 수 있다. <center>

</center>

근데 원숭이는 한 가지 착각하고 있는 것이 있다. 말은 저렇게 움직일 수 있지만 원숭이는 능력이 부족해서 총 K번만 위와 같이 움직일 수 있고, 그 외에는 그냥 인접한 칸으로만 움직일 수 있다. 대각선 방향은 인접한 칸에 포함되지 않는다.

이제 원숭이는 머나먼 여행길을 떠난다. 격자판의 맨 왼쪽 위에서 시작해서 맨 오른쪽 아래까지 가야한다. 인접한 네 방향으로 한 번 움직이는 것, 말의 움직임으로 한 번 움직이는 것, 모두 한 번의 동작으로 친다. 격자판이 주어졌을 때, 원숭이가 최소한의 동작으로 시작지점에서 도착지점까지 갈 수 있는 방법을 알아내는 프로그램을 작성하시오.

이 문제가 파놓은 함정이 있는데, 여기서 k만큼 먼저 움직이고 동서남북으로 이동하는 것이 아니었다. 그냥 아무때나 해도된다는 것을 알고 문제 풀이를 들어가야한다. (요건 때문에 좀 힘들었음. 너무 모호했음)

일단 문제는 그걸로 이동하면 되면서, 시간, 메모리 초과가 나지 않도록 적절히 visit처리 해주기만하면 금방 풀 수 있는 문제이다.

내일이 시험인데 백준풀고, 전공 공부하고 있는데 지금 큰일난거 같다.... 흐아 어트카냐

일단 말은 dx, dy와 horsedx, horsedy를 선언하고 이를 토대로 격자판을 탐색하였다.

또한 n=1, m=1일때는 bfs가 시작되지도 않기 때문에 따로 예외처리를 해주었다.

일단 go언어를 공부 중이라(서버 개발 공부중)서 go로 푸는데 큐를 썼는데 바로 import가 안되서 std에 없는 것 같아 직접 구현하여 사용했다.

생각보다 새롭고 재미있는 ps 경험이다. (대회때는 절대 안 쓴다. cpp 사랑해)

Queue 구현

type Pos struct {
	x, y, cost, current_k int
}

type Node struct {
	next *Node
	prev *Node
	item *Pos
}

type Queue struct {
	head, tail *Node
	size       int
}
type IQueue interface {
	Enqueue(*Pos)
	Init()
	Dequeue() *Pos
	Front() *Pos
	Size() int
	Empty() bool
}

func (q *Queue) Enqueue(pos *Pos) {
	var newNode *Node = &Node{next: q.tail, prev: q.tail.prev, item: pos}
	if q.head.next == nil {
		q.tail.prev = newNode
		q.head.next = newNode
		newNode.prev = q.head
	} else {
		q.tail.prev.next = newNode
		q.tail.prev = newNode
	}

	q.size++

}
func (q *Queue) Init() {
	q.head = &Node{next: nil, prev: nil, item: nil}
	q.tail = &Node{next: nil, prev: nil, item: nil}
	q.size = 0
}

func (q *Queue) Dequeue() *Pos {
	if q.head.next == nil {
		return nil
	}

	var remove *Pos = q.head.next.item

	if q.head.next.next == q.tail {
		q.head.next = nil
		q.tail.prev = nil
	} else {
		q.head.next = q.head.next.next
	}
	q.size--
	return remove
}
func (q *Queue) Front() *Pos {
	return q.head.item
}

func (q *Queue) Size() int {
	return q.size
}
func (q *Queue) Empty() bool {
	return q.size == 0
}

Enqueue, Dequeue를 구현하고, 안에 들어갈 데이터 pos를 만들어주었다.

BFS 구현

for !q.Empty() {
		pos := q.Dequeue()

		if costBoard[pos.y][pos.x][pos.current_k] < pos.cost {
			continue
		}
		costBoard[pos.y][pos.x][pos.current_k] = pos.cost

		if pos.current_k < k {
			for i := 0; i < 8; i++ {
				ny = pos.y + hdy[i]
				nx = pos.x + hdx[i]

				if 0 <= ny && ny < n && 0 <= nx && nx < m && costBoard[ny][nx][pos.current_k+1] > pos.cost+1 {
					q.Enqueue(&Pos{x: nx, y: ny, cost: pos.cost + 1, current_k: pos.current_k + 1})
					costBoard[ny][nx][pos.current_k+1] = pos.cost + 1

				}
			}
		}
		for i := 0; i < 4; i++ {
			ny = pos.y + dy[i]
			nx = pos.x + dx[i]

			if 0 <= ny && ny < n && 0 <= nx && nx < m && costBoard[ny][nx][pos.current_k] > pos.cost+1 {
				q.Enqueue(&Pos{x: nx, y: ny, cost: pos.cost + 1, current_k: pos.current_k})
				costBoard[ny][nx][pos.current_k] = pos.cost + 1
			}
		}
	}

솔직히 코드는 너무 직관적으로 쉬워서 금방 읽고 뭔 소린지 이해할 수 있을거라고 생각한다.

기본적인 BFS와 다른점은 바로 costBoard를 3차원으로 선언한 것이데 이것은 k가 자연수일때, 아무때나 말과 같은 점프를 뛸 수 있는데 이를 고려하여, 현재 k가 몇 남아있냐에 따라서 각자 cost를 따로 먹여놓은 것이다.

package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
)

type Pos struct {
	x, y, cost, current_k int
}

type Node struct {
	next *Node
	prev *Node
	item *Pos
}

type Queue struct {
	head, tail *Node
	size       int
}
type IQueue interface {
	Enqueue(*Pos)
	Init()
	Dequeue() *Pos
	Front() *Pos
	Size() int
	Empty() bool
}

func (q *Queue) Enqueue(pos *Pos) {
	var newNode *Node = &Node{next: q.tail, prev: q.tail.prev, item: pos}
	if q.head.next == nil {
		q.tail.prev = newNode
		q.head.next = newNode
		newNode.prev = q.head
	} else {
		q.tail.prev.next = newNode
		q.tail.prev = newNode
	}

	q.size++

}
func (q *Queue) Init() {
	q.head = &Node{next: nil, prev: nil, item: nil}
	q.tail = &Node{next: nil, prev: nil, item: nil}
	q.size = 0
}

func (q *Queue) Dequeue() *Pos {
	if q.head.next == nil {
		return nil
	}

	var remove *Pos = q.head.next.item

	if q.head.next.next == q.tail {
		q.head.next = nil
		q.tail.prev = nil
	} else {
		q.head.next = q.head.next.next
	}
	q.size--
	return remove
}
func (q *Queue) Front() *Pos {
	return q.head.item
}

func (q *Queue) Size() int {
	return q.size
}
func (q *Queue) Empty() bool {
	return q.size == 0
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)

	defer writer.Flush()

	var q IQueue = new(Queue)
	q.Init()
	hdx, hdy, dx, dy := []int{2, 2, -2, -2, 1, 1, -1, -1}, []int{1, -1, 1, -1, 2, -2, 2, -2}, []int{1, -1, 0, 0}, []int{0, 0, 1, -1}

	var k int
	fmt.Fscanln(reader, &k)
	q.Enqueue(&Pos{x: 0, y: 0, cost: 0, current_k: 0})
	var n, m int
	fmt.Fscanln(reader, &m, &n)

	var board [202][202]int
	var costBoard [202][202][32]int

	var limit int = math.MaxInt

	for i := 0; i < n; i++ {
		for j := 0; j < m; j++ {
			fmt.Fscan(reader, &board[i][j])
			if board[i][j] == 1 {
				for k := 0; k < 31; k++ {
					costBoard[i][j][k] = -1
				}

			} else {
				for k := 0; k < 31; k++ {
					costBoard[i][j][k] = limit
				}

			}
		}
	}

	var ny, nx int
	for !q.Empty() {
		pos := q.Dequeue()

		if costBoard[pos.y][pos.x][pos.current_k] < pos.cost {
			continue
		}
		costBoard[pos.y][pos.x][pos.current_k] = pos.cost

		if pos.current_k < k {
			for i := 0; i < 8; i++ {
				ny = pos.y + hdy[i]
				nx = pos.x + hdx[i]

				if 0 <= ny && ny < n && 0 <= nx && nx < m && costBoard[ny][nx][pos.current_k+1] > pos.cost+1 {
					q.Enqueue(&Pos{x: nx, y: ny, cost: pos.cost + 1, current_k: pos.current_k + 1})
					costBoard[ny][nx][pos.current_k+1] = pos.cost + 1

				}
			}
		}
		for i := 0; i < 4; i++ {
			ny = pos.y + dy[i]
			nx = pos.x + dx[i]

			if 0 <= ny && ny < n && 0 <= nx && nx < m && costBoard[ny][nx][pos.current_k] > pos.cost+1 {
				q.Enqueue(&Pos{x: nx, y: ny, cost: pos.cost + 1, current_k: pos.current_k})
				costBoard[ny][nx][pos.current_k] = pos.cost + 1
			}
		}
	}

	var result int = limit

	for i := 0; i <= k; i++ {

		if costBoard[n-1][m-1][i] != -1 && costBoard[n-1][m-1][i] != limit {
			result = min(result, costBoard[n-1][m-1][i])
		}
	}

	if n == 1 && m == 1 {
		result = 0
	}

	if result == limit {
		fmt.Fprintln(writer, -1)
	} else {
		fmt.Fprintln(writer, result)
	}
}

</details>

[BOJ] 날카로운 눈

Thu, 15 May 2025 00:00:00 GMT

날카로운 눈

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1 ≤ N ≤ 20000<br/>1 ≤ A, B, C ≤ 2,147,483,647)	Binary Search

솔직히 처음에 엄청 해맸습니다. 문제가 하나만 홀수라는 포인트를 못 읽어서 아주 많이 생각을 해봤는데요. 음.. 문제가 너무 안 풀려서 처음으로 돌아가려니까 그제서야 보이더라구요.

친구는 xor로 열심히 memoization 돌려서 풀더라구요? 엄청 신기하기도 했습니다. 저는 옆에서 binary search 열심히 돌려서 AC 맞았구요.

힘들었던 필기를 소개합니당

그래도 정말 재미있게 풀었던 문제였습니다.

#include <iostream>
#include <queue>
#include <set>
#include <algorithm>
#include <random>

#define mod 1000000007LL
//          1000000007
#define M 2147483647

using namespace std;
using ll = long long;
int n;

struct node{
    ll a, c, b;
};

node nodes[20001];


ll count(ll target){
    
    ll result = 0;
    for(int i = 0; i < n; i++){
        if(target >= nodes[i].a) result += (min(nodes[i].c, target) - nodes[i].a) / nodes[i].b + 1;
    }
    
    return result;
}


ll solution(){
    
    ll start = 1, finish = M;
    
    while(start <= finish){
        ll pivot = (start + finish) / 2;
        
        ll pivot_count = count(pivot);
//        cout << "pivot: " << pivot << " count: " << pivot_count << "\n";
        if((pivot_count - count(pivot - 1)) % 2 == 1) return pivot;
        
        if(pivot_count % 2 == 0) start = pivot + 1;
        else finish = pivot - 1;
    }
    return -1;
}

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
  
    cin >> n;
    for(int i = 0; i < n; i++){
        ll a, c, b;
        cin >> a >> c >> b;
        nodes[i] = {a, c, b};
    }
    
    
    ll result = solution();
    if(result == -1) cout << "NOTHING";
    else cout << result << " " << count(result) - count(result-1);
    
    
    return 0;
}

/*
 6 5 1
 1 6 2 9 8
 7 2 6 9 8
 1 8 3 4 2
 7 4 6 2 3
 9 2 3 6 1
 4 2 9 3 1
 3
 */

</details>

[BOJ] 괄호 추가하기

Wed, 02 Apr 2025 00:00:00 GMT

괄호 추가하기

TimeLimit	MemoryLimit	Condition	TAG
0.5s	512MB	(1 ≤ N ≤ 19)	BruteForce

각 괄호를 어떻게 칠까? 이거를 그냥 N의 범위가 엄청 작기 때문에 무조건 시간 안에 돌아갈 수 있다고 판단! 그래서 그거 토대로 구현하면 됩니다.

#include <iostream>
#define inf 1000000000
using namespace std;

using ll = long long;

int nums[20];
char operators[20];
int n;

void calc(int current, ll* value, ll calc_value){
    switch(operators[current-1]){
        case '*':
            *value *= calc_value;
            break;
        case '+':
            *value += calc_value;
            break;
        case '-':
            *value -= calc_value;
            break;
    }
}

ll solution(int current, ll current_result){
    if(current >= n) return current_result;
    ll result = -inf;
    
    ll nonWrap = current_result;
    calc(current, &nonWrap, nums[current]);
    
    
    if(current < n-1){
        ll wrap = nums[current];
        calc(current+1, &wrap, nums[current+1]);
        
        
        ll wrap_result = current_result;
        calc(current, &wrap_result, wrap);
        
        
        result = max(result, solution(current+2, wrap_result));
    }
    result = max(result, solution(current+1, nonWrap));
    
    return result;
}

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    
    cin >> n;
    
    for(int i = 0; i < n; i++){
        if(i%2 == 0) cin >> nums[i/2];
        else cin >> operators[i/2];
    }
    
    
    cout << solution(1, nums[0]);   
    
    
    return 0;
}

</details>

[BOJ] 겹치는 선분

Wed, 12 Feb 2025 00:00:00 GMT

겹치는 선분

TimeLimit	MemoryLimit	Condition	TAG
2s	256MB	(1 ≤ N ≤ 1,000,000<br/> \|e\| ≤ 10억)	Greedy, Sort

이 문제는 솔직히... 아쉬웠따. 뭔가 그 게시판을 들어갔다가 잘못 봐버리면서 접근을 이미 약간 힌트를 얻어서 거의 그 이후로 바로 풀었는데.. 나는 반례있는지 확인하러 들어간 것 뿐인데.. 쩝

하튼 그냥 정렬해서 잘 풀면 된다. 아이디어는 그렇게 어렵지도 완전 쉽지도 않은 아이디어였다.

시간에 대해서 어떻게 줄이지라고 고민을하면 약간 자연스럽게 접근할 수 있는 정도였다. <details> <summary> 정답 코드 </summary>

처음에 priority_queue로 풀고 있엇는데 이것도 되는 것 같다ㅏ. 근데 요게 더 효율적이다.

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

using ll = long long;
int n;


bool compare(pair<int, int> a, pair<int ,int> b){
    if(a.first == b.first) return a.second < b.second;
    return a.first < b.first;
}


int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    
    cin >> n;
    
    int start, end;
    
    vector<pair<int, int>> coor;
    for(int i = 0; i < n; i++) {
        cin >> start >> end;
        
        coor.push_back({start, 1});
        coor.push_back({end, -1});
    }
    
    sort(coor.begin(), coor.end(), compare);
    
    int current = 0;
    int result = 0;
    for(int i = 0; i < n*2; i++){
//        cout << coor[i].first << " " <<coor[i].second << "\n";
        current += coor[i].second;
        result = max(result, current);
    }
    
    cout << result;
    
    
    return 0;
}

</details>

[BOJ] 벽 부수고 이동하기 3

Mon, 14 Apr 2025 00:00:00 GMT

벽 부수고 이동하기 3

TimeLimit	MemoryLimit	Condition	TAG
2s	512MB	(1 ≤ N, M ≤ 1000<br/>1 ≤ K ≤ 10)	Implementation, BFS

전형적인 BFS 문제로 연습하기 좋은 문제인 것 같습니다.

#include <iostream>
#include <queue>
using namespace std;
using ll = long long;
int n, m, k;

char board[1001][1001];
ll visited[1001][1001][11][2];


ll solution(){
    
    queue<pair<pair<int, bool>, pair<int, int>>> q;
    
    q.push({{0, false}, {0, 0}});
    visited[0][0][0][0] = 0; // 0 ㄴㅏㅈ, 1 ㅂㅏㅁ
    visited[0][0][0][1] = 1; // 0 ㄴㅏㅈ, 1 ㅂㅏㅁ
    
    int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, -1, 1};
    
    while(!q.empty()){
        auto [__, _] = q.front(); q.pop();
        auto [y, x] = _;
        auto [ck, state] = __;
        
        
        for(int i = 0; i < 4; i++){
            int nx = x + dx[i];
            int ny = y + dy[i];
            
            if(0 <= nx && nx < m && 0 <= ny && ny < n){
                
                if(board[ny][nx] == '1'){
                    if(ck >= k) continue;
                    if(visited[ny][nx][ck+1][!state] <= visited[y][x][ck][state] + 1) continue;
                    
                    if(state){
                        visited[y][x][ck][!state] = min(visited[y][x][ck][state] + 1, visited[y][x][ck][!state]);
                        q.push({{ck, !state}, {y, x}});
                        continue;
                    }
                    
                    visited[ny][nx][ck+1][!state] = visited[y][x][ck][state] + 1;
                    q.push({{ck+1, !state}, {ny, nx}});
                }else{
                    if(visited[ny][nx][ck][!state] <= visited[y][x][ck][state] + 1) continue;
                    
                    visited[ny][nx][ck][!state] = visited[y][x][ck][state] + 1;
                    q.push({{ck, !state}, {ny, nx}});
                }
                
            }
        }
        
    }
    
    ll result = 1e15;
    
    for(int i = 0; i <= k; i++) {
        result = min(result, min(visited[n-1][m-1][i][0], visited[n-1][m-1][i][1]));
    }
    
//
//    for(int i = 0; i < n; i++){
//        for(int j = 0; j < m; j++){
//            
//            cout << visited[i][j][7][0] << " ";
//        }
//        cout << "\n";
//    }
//    
//    cout << "\n";
    
    return result+ 1LL;
}

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    
    cin >> n >> m >> k;
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            cin >> board[i][j];
            
            for(int t = 0; t <= k; t++){
                visited[i][j][t][0] = 1e15;
                visited[i][j][t][1] = 1e15;
            }
        }
    }
    
    ll result = solution();
    if(result >= 1e15) cout << -1;
    else cout << result;
    
    
    
    
    return 0;
}

</details>

[BOJ] 연구소 3

Tue, 04 Feb 2025 00:00:00 GMT

연구소 3

TimeLimit	MemoryLimit	Condition	TAG
0.25s	512MB	(4 ≤ N ≤ 50, 1 ≤ M ≤ 10)	BFS

인체에 치명적인 바이러스를 연구하던 연구소에 승원이가 침입했고, 바이러스를 유출하려고 한다. 바이러스는 활성 상태와 비활성 상태가 있다. 가장 처음에 모든 바이러스는 비활성 상태이고, 활성 상태인 바이러스는 상하좌우로 인접한 모든 빈 칸으로 동시에 복제되며, 1초가 걸린다. 승원이는 연구소의 바이러스 M개를 활성 상태로 변경하려고 한다.

연구소는 크기가 N×N인 정사각형으로 나타낼 수 있으며, 정사각형은 1×1 크기의 정사각형으로 나누어져 있다. 연구소는 빈 칸, 벽, 바이러스로 이루어져 있으며, 벽은 칸 하나를 가득 차지한다. 활성 바이러스가 비활성 바이러스가 있는 칸으로 가면 비활성 바이러스가 활성으로 변한다.

예를 들어, 아래와 같이 연구소가 생긴 경우를 살펴보자. 0은 빈 칸, 1은 벽, 2는 바이러스의 위치이다.

2 0 0 0 1 1 0

0 0 1 0 1 2 0

0 1 1 0 1 0 0

0 1 0 0 0 0 0

0 0 0 2 0 1 1

0 1 0 0 0 0 0

2 1 0 0 0 0 2

M = 3이고, 바이러스를 아래와 같이 활성 상태로 변경한 경우 6초면 모든 칸에 바이러스를 퍼뜨릴 수 있다. 벽은 -, 비활성 바이러스는 *, 활성 바이러스는 0, 빈 칸은 바이러스가 퍼지는 시간으로 표시했다.

* 6 5 4 - - 2

5 6 - 3 - 0 1

4 - - 2 - 1 2

3 - 2 1 2 2 3

2 2 1 0 1 - -

1 - 2 1 2 3 4

0 - 3 2 3 4 *

시간이 최소가 되는 방법은 아래와 같고, 4초만에 모든 칸에 바이러스를 퍼뜨릴 수 있다.

0 1 2 3 - - 2

1 2 - 3 - 0 1

2 - - 2 - 1 2

3 - 2 1 2 2 3

3 2 1 0 1 - -

4 - 2 1 2 3 4

* - 3 2 3 4 *

연구소의 상태가 주어졌을 때, 모든 빈 칸에 바이러스를 퍼뜨리는 최소 시간을 구해보자.

정말 충격이였다.. 처음에 짠 bfs 코드를 문제를 또 잘못 읽고서 풀어서 다른 문제를 풀어버려쏙 다시 풀어서 제출하니 시간초과 어머나....

그래서 다시 보니 아 이걸 중복 검사가 있어서 다시 제출 그러다 다시 시간 초과...

아 그 이후에 dfs를 다시 중복 없이 검사 및 빨리 끝나도록 설계해서 다시 제출 그러나 또 시간초과

알고보니까 bfs 코드를 조금 다시 보니 다익스트라 마냥 짜놔서 이거 방문 이후에 검사하는 방식이여서 최악의 경우 한 노드당 방문 수가 4가 되면서 O(N^4)을 찍어ㅑ버렸다.

미치겠다.. 이걸 왜 이렇게 짠 걸까.. 총 문제 풀이 시간은 길지 않았으나.. 이렇게 틀리고, 멘탈이 흔들리니 아직도 많이 방심하는 성격이 있는 것 같다. 항상 긴장하고 코드 한줄한줄마다 시간 복잡도 생각하면서 작성해야겠다.

<details> <summary> 정답 코드 </summary> 부끄럽네요...

다음부터는 좋은 코드로 돌아오겠습니다.

#include <iostream>
#include <queue>
#include <algorithm>
using namespace std;
using ll = long long;

const int INF = 1e9;
const int MAX_N = 51;
int n, m;
int board[MAX_N][MAX_N], use[MAX_N][MAX_N];
pair<int, int> vir[10];
int virCnt = 0;
int emptySpace = 0;

const int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};

void init(){
    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
            if(board[i][j] == 1) use[i][j] = -1;
            else use[i][j] = INF;
        }
    }
}

int solution(vector<pair<int, int>>& current){
    init();
    queue<pair<int, pair<int, int>>> q;
    int filled = 0;
    
    for(auto& p : current) {
        q.push({0, p});
        use[p.first][p.second] = 0;
    }
    
    int maxTime = 0;
    while(!q.empty() && filled < emptySpace){
        auto [time, pos] = q.front();
        auto [y, x] = pos;
        q.pop();
        
        if(board[y][x] != 2) {
            maxTime = time;
            filled++;
        }
        
        for(int i = 0; i < 4; i++){
            int ny = y + dy[i];
            int nx = x + dx[i];
            if(ny < 0 || ny >= n || nx < 0 || nx >= n || use[ny][nx] != INF) continue;
            use[ny][nx] = time + 1;
            q.push({time + 1, {ny, nx}});
        }
    }
    
    return filled == emptySpace ? maxTime : INF;
}

int search(int idx, vector<pair<int, int>>& current){
    if(current.size() == m) return solution(current);
    if(idx >= virCnt || virCnt - idx < m - current.size()) return INF;
    
    int result = INF;
    
    current.push_back(vir[idx]);
    result = min(result, search(idx + 1, current));
    current.pop_back();
    
    result = min(result, search(idx + 1, current));
    
    return result;
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    
    cin >> n >> m;
    
    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
            cin >> board[i][j];
            if(board[i][j] == 2) vir[virCnt++] = {i, j};
            else if(board[i][j] == 0) emptySpace++;
        }
    }
    
    vector<pair<int, int>> vec;
    int result = search(0, vec);
    
    cout << (result == INF ? -1 : result);
    return 0;
}

</details>

[BOJ] A Plus Equals B

Sun, 30 Jun 2024 00:00:00 GMT

A Plus Equals B

TimeLimit	MemoryLimit	Condition	TAG
1s	1024MB	(1<=A, B<=10¹⁸, 0<= n <= 5000)	Math(수학)

일단 문제가 영어러 되어있기 때문에 제가 이해한 문장을 적겠습니다.(원문을 보시고 싶다면, 위의 링크를 클릭해 문제를 풀고 오십숑)

A, B라는 두개의 자연수가 있다. 우리는 이 A, B 두 수를 같게 만들어야한다. 하지만 이 수를 같게 만드려면 아래의 4가지 방법 밖에 사용해야 한다.

A += A

A += B

B += A

B += B

이렇게 4가지의 과정을 잘 섞어서 두 수를 같게 만들어보자. 그런데 이 연산이 5000번은 넘으면 안된다.

답을 찾았다면, 연산 횟수를 먼저 출력하고 다음 줄부터 어떤 연산을 하였는지 차례대로 출력하여라!

내가 이해한 문제는 이렇다.

첨에는 음.. bfs로 다 찾는건가? 이러고 짜다가 alt+tab 이러고 읽고 풀고, 읽고 풀고 하다가 시간 초과가 의심되기 시작하면서, 머리가 띵해졌다....(일단 overflow문제도 뭔가 찜찜했었음..)

그러다가 A+=A, B+=B가 2배로 높아진다는 것을 알았다.

자 이제부터 어메이징한 것들이 나올 것이다.

A+=A 이것을 잘 생각해보면, B/=2와 같은 동작을 한다는 것을 알 수 있다.

왜?라고 생각할 수 있다. 자 생각해보자

-- 일단 나누는 수는 당연히 짝수라고 생각한다. --

어... 이 아이디어가 굉장히 어메이징한데....

어떤 수 A가 존재한다고 하자. A+=A를 진행하면 A는 2A가 된다. 다음 A가 같은 연산을 한다면 4A가 된다.

자 여기까진 이해가 쉽다.

이제 왜 A/=2가 B+=B와 같은 연산이라는건지 설명하겠다.

A=8, B=4 라고 생각해보자 이럴 때는 B*2 = A가 성립하면서, 굉장히 직관적으로 설명이 가능하다.

만약 A=100, B = 2 라고 생각한다면, 여러분들의 머릿속에는 "??" 또는 "아하"가 나올 것이다.

먼저 결국 우리가 연산을 진행하면서 overflow를 막기 위해서 또한 좀 문제를 직관적으로 보기 위해서 계속해서 수를 좀 작게 만들고 있는데, A/2는 50인데 왜 2B하는 것과 같은 효과가 나오는 거야?라고 할텐데.

if문에서 보는 a, b는 홀수이다. (이건 명백하다)

그때 a+b를 한다면 무조건 짝수가 나온다.

A = 3, B = 9 이때, B+=A를 하게되면 B= 12가 된다. 이때 무조건 A가 2배를 해도 B보다 작다는 것은 알 수 있다. 그래서 A+=A해도 B와 작다. -> 그래서 반복 계속해서 이 과정을 반복하면 되는데, 이때 짝수가된 B를 계속해서 나눠주는 이유는 이와 같이 결국 A, B의 관계에서 "A+=A해도 B와 작다 -> 반복" 이것을 반복하면 점점 더 가까워지기 때문에 문제가 없을 것이라는 것을 알고 있기 때문이다.

5000번 이상의 연산이 없을 거란걸 생각하지 않고 제출하였는데, 넘어가는 것을 보니 그런 케이스는 딱히 없는 것같다. 이것 또한 기회가 된다면 찾아서 업데이트를 해놓도록 하겠다.(아마 안 할거 같긴해용)

#define MAX 2'100'000'000
#define limit 10'000'000'000
#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <math.h>
#include <random>
using namespace std;

using ull = unsigned long long;
using ll = long long;

ull a, b;

int main() {
   
   
    cin >> a >> b;
    vector<string> result;
    
    
    while(a != b){
        
        while(a%2 == 0){
            a/=2; // == b+=b
            result.push_back("B+=B");
        }
        while(b%2 == 0){
            b/=2; // == a+=a
            result.push_back("A+=A");
        }
        
        // cout << 1;
        if(a > b){
            a+=b;
            result.push_back("A+=B");

        }
        else if(a < b){
            b+=a;
            result.push_back("B+=A");
        }
        
        
    }
    // cout << a << " " << b << "\n";
    
    cout << result.size() << "\n";
    for(string str : result){
        cout << str<<"\n";
    }
    
    
    return 0;
}

</details>

[BOJ] 점 나누기

Mon, 03 Feb 2025 00:00:00 GMT

점 나누기

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(3<= N <= 10,000<br/>3 <= K <= 1,000)	BruteForce, Two Pointer(?)

N개의 점들이 원의 내부에 찍혀 있다. 이 원을 K개의 부채꼴로 등분하려 한다. 즉, 각 부채꼴의 중심각이 360/K도가 되어야 한다. 부채꼴을 어떻게 나누느냐에 따라서 각 부채꼴에 찍혀 있는 점의 개수가 달라질 수 있다.

N개의 점들이 찍혀 있는 각도가 주어졌을 때, 가장 많은 점이 찍혀 있는 부채꼴에 찍혀 있는 점의 개수와, 가장 적은 점이 찍혀 있는 부채꼴에 찍혀 있는 점의 개수의 차이의 최솟값을 구하는 프로그램을 작성하시오.

단, 부채꼴의 테두리에 점이 포함되어서는 안 된다.

디게 오랜만에 문제가 굉장히 재미있었다. 머리가 말랑말랑 해지는 기분이랄까.. 확실히 유사코 문제가 재밌는게 많은 듯 하다.

처음에 어? 이거 그냥 브포 돌리면 되겠는데 했는데 다행이 되어서 다행이다 나중에 다른 코드들 보니까 브포 보다는 그냥 이분탐색만 있어서 약간 당황

그리고 그 벡터쓰는 버릇을 없애야겠다. 이게 나중가니까 너무 벡터 함수에 의존하는 경향이 생기는 것 같아서 최대한 함수 없이 구현하려고 노력하고 있다. 다음부터는 배열을 주로 사용하기로!

처음에 틀렸던 것은 360/K로 해서 등분하는게 아니라 K개의 선을 그어서 나오는거 찾는 줄 알았따. 정말 놀랍게도 그렇게 두번을 제출했고 레전드를 찍었다.

그 이후에 다시 읽고서 아 등분이구나! 하고 다시 풀어서 시초(time out)맞고 다시 풀어서 AC 맞았따.. 문제 풀면서 디게 재밌게 풀었고 좀 기억에 남을 듯 하다.

코드는 약간 설명하자면, 나중에 점 계산 빠르게 돌리기 위해서 정렬 돌린다. 어차피 점을 나누는게 제일 중요하기 때문에 다른 곳은 볼 필요가 없다고 생각했다. 이 문제의 경우 최적의 부채꼴 분할은 반드시 어떤 점을 정확히 부채꼴의 경계에 두는 경우를 포함하기 때문에 그 점을 시작으로 잡고 돌렸다.

그러고 정렬된거 토대로 개수를 세주고 이후에 result에 반영

그 360 더하는 거는 진짜 와... 이걸 어찌저찌 해봐서 됐는데

만약에 300도에서 시작하는 점이 있으면, 여기는 k가 3일 때 120도 만큼 잘라야되니.. 넘어가죠 이걸 고려해서 연산을 쉽게하려고 하는 겁니다ㅏ

요런 문제의 경우 파이썬이 아니니까 data type의 범위 잘 신경쓰시고 오차도 신경을 좀 써주셔야 될 것 같아용!! 이 문제는 그런게 덜하지만 다른 문제는 좀 이상하게 나오는 경우가 있다고 들었거든요!

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
using ll = long long;

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    
    int N, K;
    cin >> N >> K;
    
    vector<double> angles(N);
    for (int i = 0; i < N; i++) cin >> angles[i];
    sort(angles.begin(), angles.end());
    
    vector<double> extended_angles = angles;
    for (double angle : angles) {
        extended_angles.push_back(angle + 360);
    }
    
    ll realResult = 1e12;
    double sector_size = 360.0 / K;
    
    for (int i = 0; i < N; i++) {
        vector<ll> result(K, 0);
        double start = angles[i];
        
        int left = 0;
        for (int j = 0; j < K; j++) {
            double sectorStart = start + j * sector_size;
            double sectorEnd = sectorStart + sector_size;
            
            while (left < extended_angles.size() && extended_angles[left] < sectorEnd) {
                if (extended_angles[left] >= sectorStart) {
                    result[j]++;
                }
                left++;
            }
        }
        
        if (!result.empty()) {
            ll maxResult = 0;
            ll minResult = 1e12;
            for (ll value : result) {
                maxResult = max(maxResult, value);
                minResult = min(minResult, value);
            }
            realResult = min(realResult, maxResult - minResult);
        }
    }
    
    cout << realResult;
    return 0;
}


// 345 94 218

이거 자기 전에 풀어서 그런가.. 스네이크랑 카멜이랑 섞여 있네요 와 ㄹㅈㄷ 이게 요즘 코드에서도 발견되네 </details>

[BOJ] 로봇

Wed, 26 Feb 2025 00:00:00 GMT

로봇

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1 ≤ N, M ≤ 100)	BFS

일단 이 문제는 방향에 대해서 visited 처리 해주면 된다. 일단 내가 BFS를 작성할 때 cost를 저장하는 배열과 비교하는 연산을 <code><=</code>으로 처리하는 것을 많이 사용한 나머지... 그대로 썼다가... 이거 찾는데 30분을 날렸다. 진짜 미치겠다. 하튼 그냥 그렇게 bfs 돌리면 풀리는 문제이다..

즐거운 ps 하셔요..ㅠㅜ

#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <queue>
using namespace std;
using ll = long long;

int n, m;

int board[101][101];
int costBoard[101][101][4];

int dx[] = {0, 1, -1, 0, 0}, dy[] = {0, 0, 0, 1, -1};

struct pos{
    int dir;
    int y, x;
    int pre_dir;
    int cost;
    int nc;
    
};


int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> n >> m;
    
    
    
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j++){
            costBoard[i][j][0] = 1000000000;
            costBoard[i][j][1] = 1000000000;
            costBoard[i][j][2] = 1000000000;
            costBoard[i][j][3] = 1000000000;
            cin >> board[i][j];
        }
    }

    pos target;
    
    queue<pos> q;
    
    int sd, sy, sx;
    
    cin >> sy >> sx >> sd;
    
    q.push({sd, sy, sx, 10000, 0, 0});
    
    cin >> sy >> sx >> sd;
    
    target = {sd, sy, sx, 10000, 0, 0};

    while(!q.empty()){
        pos current = q.front(); q.pop();
        
        
        if(costBoard[current.y][current.x][current.dir-1] < current.cost) continue;
        
        
        if(current.y == target.y && target.x == current.x) {
            // 아니 min을 안 넣었네..
            int result;
            if(current.dir == target.dir) result = current.cost;
            else result = current.cost + 1 + (abs(current.dir - target.dir) == 1 && (target.dir == 1 || target.dir == 4 || current.dir == 1 || current.dir == 4));
            
            costBoard[current.y][current.x][target.dir-1] = min(costBoard[current.y][current.x][target.dir-1], result);
            continue;
        }
        else costBoard[current.y][current.x][current.dir-1] = current.cost;
        
        
        
        
        
        for(int i = 1; i < 5; i++){
            int nx = current.x + dx[i];
            int ny = current.y + dy[i];
            
            if(0 < ny && ny <= n && 0 < nx && nx <= m){
                if(costBoard[ny][nx][i-1] < current.cost || board[ny][nx]) continue;
                    
                int current_cost = current.cost;
                int current_nc = current.nc;
                current_cost+=2;
                
                if(current.dir == i){
                    
                    current_cost -=2;
                    current_cost+=(current.pre_dir > 100 && current.dir == i) + (current_nc >= 3);
                    if(current_nc >= 3) current_nc = 0;
                    current_nc++;
                    
                }
                else if(abs(current.dir - i) == 1 && (i == 1 || i == 4 || current.dir == 1 || current.dir == 4)){
                    current_cost++;
                    current_nc = 1;
                }else {
                    current_nc = 1;
                }
                // 서쪽.. 2 북 4
                
                
                q.push({i, ny, nx, current.dir, current_cost, current_nc});
            }
            
        }
        
//        
//        cout << "current: " << current.y << " " << current.x << " " << current.cost << "\n";
//
//        cout << "\n";
//        for(int i = 1; i <= n; i++){
//            for(int j = 1; j <= m; j++) {
//                if(costBoard[i][j][1] == 1000000000) cout << "o ";
//                else cout << costBoard[i][j][1] << " ";
//            }
//            cout << "\n";
//        }
//        cout << "\n";
//        
//        
        
    }

    cout << costBoard[target.y][target.x][target.dir-1];
    return 0;
}

</details>

[BOJ] 오큰수

Thu, 20 Feb 2025 00:00:00 GMT

오큰수

TimeLimit	MemoryLimit	Condition	TAG
1s	512MB	(1 ≤ N ≤ 1,000,000<br/>1 ≤ Ai ≤ 1,000,000)	Stack

전형적인 모노톤 스택 연습 문제입니다.

:::tip[모노톤 스택?]

모노톤 스택(Monotonic Stack)이란?

모노톤(Monotonic)이라는 말은 "단조로운", "한 방향으로 증가/감소하는" 이라는 뜻을 가지고 있습니다. 그래서 이걸 스택에 적용해보면 어떻게 이해할 수 있을까요?

바로 스택 내의 모든 요소들이 일정한 순서(오름차순 또는 내림차순)을 유지하는 형태의 스택을 말한답니다

간단한 작동 원리

제가 핵심 원리로 생각하는 것은 새로운 요소를 추가할 때마다 이 스택의 단조성을 유지하는 것입니다.

:::

모노톤 스택은 당연히 시간 복잡도가 O(N)으로 단순히 본 문제를 풀면 시간 초과가 나는 코드를 효과적을 줄일 때도 쓰이는 등 정말 여러 문제에서 쓰입니다. 뭐 빌딩이 보인다. 내 친구가 보인다 등등 뭐 이런 문제에서 많이 쓰이더라구요!

그래서 이런 모노톤 스택 연습해보시길 강추 드립니다.

#include <iostream>
#include <stack>

using namespace std;

void print(int* res, int n){
    cout << "\n";
    for(int i = 0; i < n; i++){
        cout << res[i] << " ";
    }
    cout << "\n";
}

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    string s;
    int n;
    cin >> n;
    
    stack<int> stack;
    int result[1000000];
    int origin[1000000];

    for(int i = n - 1; i > -1; i--){
        result[i] = -1;
        origin[i] = -1;
        cin >> origin[i];
        while(!stack.empty() && origin[i] > origin[stack.top()]){
            result[stack.top()] = origin[i];
            stack.pop();
        }
        //print(result, n);
        //cout << origin[i] << " " << (stack.empty() ? 0 : stack.top()) << "\n\n";
        stack.push(i);
    }
    
    for(int i = n-1; i > -1; i--){
        cout << result[i] << " ";
    }
    
    
}

</details>

[BOJ] 쇼핑몰

Tue, 18 Feb 2025 00:00:00 GMT

쇼핑몰

TimeLimit	MemoryLimit	Condition	TAG
1s	512MB	(1 ≤ N ≤ 100,000<br/>1 ≤ k ≤ 100,000<br/>1 ≤ id_i ≤ 1,000,000<br/>1 ≤ w_i ≤ 20)	Greedy

문제는 전형적인 priority_queue.. 즉 우선순위 큐를 활용한 풀이가 가능하다라는 것을 엄청 강하게 풍기고 있다..

나는 그걸 알고 바로 들어갔는데 코드가 와... 이상한 곳에 빠져서 엄청 고민했다.

실시간 업데이트를 시키면서 진행하는데.. 이때 같은 시간에 있는 소비자들을 전부 처리하고 다음에 들어오는 사람들을 받은게 아니라 한명 나가면 바로 업데이트 하고 들어오게 하면서 순서가 꼬이게 되었다. 또 마지막에 K의 길이가 1인 case에 대해서도 한번 틀리고서야 반례 찾고 고쳤는데... 아 정말 이런 디테일에 있어서 아직 나는 많이 부족한 것 같다.

지금 골드를 최대한 1시간 이내로 푸는 목표인데... 수학, dp 같은 경우는 2시간 정도 안에는 무조건 푸는걸로 하고 있는데... 이문제는 무려 1시간 10분 정도 잡고 있었다.

으아ㅏㅏㅏ 아직도 갈 길이 멀다.. 계속해서 성장해 나가자..

#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <queue>
using namespace std;
using ll = long long;

struct consumer {
    ll cost, id, k;
    
    
};
struct CompareConsumer {
    bool operator()(const consumer& a, const consumer& b) {
        if(a.cost == b.cost) return a.k < b.k;
        return a.cost > b.cost;
    }
};

pair<ll, ll> consumers[100'000];

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    
    priority_queue<consumer, vector<consumer>, CompareConsumer> q;
    priority_queue<ll, vector<ll>, greater<ll>> ks;
    ll n, m;
    cin >> n >> m;
    
    ll a_, b_;
    for(int i = 0; i < n; i++){
        if(i < m) ks.push(i);
        cin >> a_ >> b_;
        consumers[i] = {a_, b_}; // id, cost
    }

    
    ll current = 0;
    ll idx = 0;
    
    ll result = 0;
    ll result_idx = 1LL;
    
    do{
        if(q.size() < m && idx < n) {
            ll k = ks.top(); ks.pop();
            auto [a, b] = consumers[idx++];
            q.push({current + b, a, k});
//            cout << "in: " << current + b << " " << a << " " << k << "\n";
            continue;
        }
        ll back = -1;
        do{
            auto [a, b, k] = q.top(); q.pop();
            ks.push(k);
//            cout << "out: " << a << " " << b << " " << k << "\n";
            if(a != current) current = a;
//            cout << b*result_idx << "\n";
            result+= b*result_idx++;
            back = a;
        }while(!q.empty() && back == q.top().cost);
//        cout << result << "\n";
    }while(!q.empty() || idx < n);
    
    
    cout << result;
    return 0;
}

/*
 5 1
 1 1
 2 1
 3 1
 4 1
 5 1
 */

</details>

[BOJ] 컵라면

Sun, 21 Sep 2025 00:00:00 GMT

컵라면

TimeLimit	MemoryLimit	Condition	TAG
2s	256MB	1 ≤ N ≤ 200,000	Sort, Greedy

문제는 대놓고 그리디 냄새를 냈지만, 생각보다 간단한 문제임에도 불구하고 오래걸렸다...

간단히 현재 시간까지의 최대값을 유지하면서 진행을 해버리면 됩니다~~

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
using namespace std;

using ll = long long;

int N;

pair<int, int> problems[200'001];
int visited[200'001];
bool compare(const std::pair<int, int>& a, const std::pair<int, int>& b) {
    return a.second < b.second;
}

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

    cin >> N;
    
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> q;
    
    for(int i = 0; i < N; i++){
        cin >> problems[i].second >> problems[i].first;
//        q.push({problems[i].second, problems[i].first});
//        visited[i+1] = -1;
    }
    sort(problems, problems+N, compare);
    
    
    q.push(problems[0]);
    for(int i = 1; i < N; i++){
        auto [cost, current] = problems[i];
        
        if(current > q.size()){
            q.push(problems[i]);
//            cout <<"size: " << q.size() << " " << current << "\n";
        }
        else{
//            cout << "cost: " << cost << " " << q.top().first << "\n";
            if(cost <= q.top().first) continue;
//            cout << "cost: " << cost << " " << q.top().first << "\n";

            q.pop();
            q.push({problems[i]});
        }
        
//        cout << i << "\n";
    }
    
    
    int result = 0;
    while(!q.empty()){
//        cout << q.top().first << " " << q.top().second << "\n";
        result += q.top().first; q.pop();
        
    }

    
    cout << result;
    return 0;
}

</details>

[BOJ] K번째 최단경로 찾기

Sun, 09 Mar 2025 00:00:00 GMT

K번째 최단경로 찾기

TimeLimit	MemoryLimit	Condition	TAG
2s	256MB	(1 ≤ n ≤ 1000, 0 ≤ m ≤ 250000, 1 ≤ k ≤ 100, mk ≤ 3000000, 1 ≤ a,b,c ≤ n, 1 ≤ c ≤ 1000)	Dijkstra

다익스트라 응용 문제인데 굉장히 흔한 유형이여서 거의 20분 컷을 했는데.. 이런 유형이 딱 그런 느낌이에요 알면 바로 풀리고, 모르면 좀 걸리는?

또 이제 구현 한번 해보면 이런 문제들은 금방 접근도 되고, 거의 바로 풀리는거라서 그렇게 어렵진 않았습니다.

그래도 꽤 난이도가 높게 나오는 문제여서 조금 설명을 하고 마치겠습니다.

현재 노드에서 k번 초과로 방문할 필요가 없음! 왜냐하면 여기랑 이어져있는 노드들은 k번 방문할 수 있는 경우.. 이미 이 노드를 지나가거나 다른 경우임. 그래서 이걸로 최적화를 해주고요. 그리고 k번째 방문했다면! result 업데이트 해주고... 이런 순서는 priority_queue로 처리해서 간단히 다익스트라 돌리면 되구요.

마지막으로 중요한 것은 방문 안 하면 -1을 출력하는데 이때 예외 처리를 조금 조심해줘야 합니다. 왜냐하면 k=1이면, 1번 도시 즉 시작 도시는 0이 찍힙니다. 이때 그냥 print를 N_i = 0이면 -1을 출력하게 했다.. 그러면 이제 WA 뜨는겁니다. 뭐 이거는 문제를 읽고서 풀다보면 자연스럽게 해결할 수 있는 간단한 문제였구요.

재밌었습니다..

#include <iostream>
#include <queue>
#include <algorithm>
#include<set>
#include <map>
using namespace std;
using ll = long long;

int inf = 1e9;

int n, m, k;
int graph[1001][1001];
int visited[1001];
ll result[1001];


int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> n >> m >> k;
    
    for(int i = 0; i < m; i++){
        int a, b, c;
        
        cin >> a >> b >> c;
        
        graph[a][b] = c;
    }
    
    for(int i = 1; i <= n; i++) visited[i] = 0;
    
    priority_queue<pair<ll, int>, vector<pair<ll, int>>, greater<pair<ll, int>>> q;
    
    q.push({0, 1});
    
    while(!q.empty()){
        auto [cost, current] = q.top(); q.pop();
        
        if(visited[current] >= k) continue;
        visited[current]++;
        
        if(visited[current] >= k) result[current] = cost;
        
        for(int i = 1; i <= n; i++){
            if(graph[current][i] == 0 || visited[i] >= k) continue;
            
            q.push({graph[current][i] + cost, i});
        }
    }
    
    if(k == 1) cout << result[1];
    else {
        if(result[1] == 0) cout << -1;
        else cout << result[1];
    }
    cout << "\n";
    
    
    
    for(int i = 2; i <= n; i++){
        if(result[i] == 0) cout << -1;
        else cout << result[i];
        cout << "\n";
    }
    return 0;
}

</details>

[BOJ] 스카이라인 쉬운거

Sun, 16 Mar 2025 00:00:00 GMT

스카이라인 쉬운거

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1 ≤ N ≤ 50,000)	Stack

음.. 대놓고 그냥 스택 문제여서 잘 풀었던 것 같다.

이거는 스택으로 올라가는 놈들 처리만 해주면 된다!

#include <iostream>
#include <vector>
#include <set>
#include <queue>
#include <map>
#include <algorithm>
using namespace std;
using ll = unsigned long long;

int inf = 1e9+7;


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

    
    vector<int> stack;
    
        
    
    cin >> n;
    int s, h;
    int result = 0;
    
    for(int i = 0; i < n; i++){
        cin >> s >> h;
        
        while(!stack.empty() && stack.back() == 0)stack.pop_back();
        

        
        if(stack.empty()){
            stack.push_back(h);
        }
        else{
            if(stack.back() > h){
                while(!stack.empty() && stack.back() > h){
                    stack.pop_back();
                    result++;
                }
                if(stack.empty() || stack.back() != h) stack.push_back(h);
            
                
                
                
                
                
            }else{
                stack.push_back(h);
            }
            
        }
    }
    

    
    while(!stack.empty() && stack.back() == 0)stack.pop_back();

    
    cout << result + stack.size();

    
    
    return 0;
}


/*
 
 1 2 1 2 1 2 2 1 0 1 0 1

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

 */

</details>

[BOJ] 가장 큰 정사각형

Tue, 25 Feb 2025 00:00:00 GMT

가장 큰 정사각형

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(1 ≤ n, m ≤ 1,000)	Dynamic Programming

이것도 전형적인 dp 문제로 점화식이 굉장히 직관적이라 풀기 좋았습니다.. 요즘 어려운 문제 보다가 이런 문제 보니까 그나마 숨이 트이네요.. ㅠㅜ

현재 위치에서 정사각형이려면 위에서 정사각형이였던 애들을 전부다 검사해서 왼쪽, 위, 좌 대각선에 있는 값이 전부다 정사각형이었다면 그 중에서 작은 친구의 정사각형 값을 1 확장해주면 된다.

이런 아이디어로 AC를 맞았습니다. 근데 <code>y <= && x <= 0</code> 조건을 이따구로 써서 2번 틀렸는데 조심하셔요.. 무의식적으로 작성된 코드는 사람을 고뇌에 빠트립니다.

#include <iostream>
#include <string>
#include <vector>
#include <set>
using namespace std;
using ll = long long;

int n, m;
int dp[1001][1001];


int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    int current;
    char tmp;
    int result = 0;
    cin >> n >> m;
    for(int y = 0; y < n; y++){
        
        for(int x = 0; x < m; x++){
            cin >> tmp;
            
            current = tmp - '0';
            dp[y][x] = current;

            if(current){
                if(x <= 0 || y <= 0) continue;
                
                dp[y][x] = min({dp[y][x-1], dp[y-1][x], dp[y-1][x-1]}) + 1;
            }
        }
    }
    
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            result = max(result, dp[i][j]);
        }
    }
    cout << result * result;
    
    return 0;
}

</details>

[BOJ] 중량제한

Fri, 20 Mar 2026 00:00:00 GMT

중량제한

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(2 ≤ N ≤ 10,000, 1 ≤ A, B ≤ N, 1 ≤ C ≤ 1,000,000,000)	BFS

처음 풀이법이 그냥 맞았는데 메모리 초과가 뜸.. 알고보니까 1000인 줄 알았는데 10000이어서 메모리 초과 나는거를 나는 뭐 또 queue에 많이 들어가는 줄 알았네.. ㅠㅜ

또 바꾼 것도 어이가 없긴 하지만 좀 이상하게 풀어버리면서 시간이 좀 걸린 케이스 1시간 컷일 줄 알았는데.. 머 그래도 멀티 테스킹하면서 풀어본 문제라 그렇게 늦게 푼것 같지도 않네요. (사실 bfs 기본 문제라서 오래 걸린게 맞음 ㅠ)


#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
#include <numeric>
#include <unordered_set>
#include <unordered_map>
#include <climits>
#include <math.h>
using namespace std;
using ll = long long;
using ld = long double;
ll MOD = 1'000'000'000 + 7;
int inf = 1 << 30;

using namespace std;
int n, m;

int start, finish;


vector<pair<int, int>> nodes[10'001]; // 크기가 1000인줄
int visited[10'001];

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    
    cin >> n >> m;
    
    
    for(int i = 1; i <= n; i++){
        visited[i] = 0;
    }
    for(int i = 0; i < m; i++){
        int a, b, c;
        
        cin >> a >> b >> c;
//        cout << a << " " << b << " " << c << "\n";
        // 일단 중복 무시하고 짜보고 걸리면 set으로
        nodes[a].push_back({b, c});
        nodes[b].push_back({a, c});
    
        
    }
    
    
    
    
    cin >> start >> finish;
    
    priority_queue<pair<int, int>> q; // max heap이다
    
    q.push({1'000'000'000, start});
    
    visited[start] =1'000'000'000;
    while(!q.empty()){
        auto [cost, node] = q.top(); q.pop();
        
        if(node == finish) { // 무조건 작아질 수밖에 없는 구조에서 먼저 도착하면 maxheap이므로 그냥 이게 정답
            cout << cost;
            return 0;
        }
        for(pair<int, int> next : nodes[node]){
            
            if(next.second <= 0) continue;
            
            int next_cost = next.second;
//            cout << next_cost << " " << cost << "\n";
            
            if(min(next_cost, cost) > visited[next.first]){
                
                // 아니 처음 접근법이 갸 ㅇ맞았던건데 왜 bool로 바꿨을까 쉬봉방
                visited[next.first] = min(next_cost, cost);
                q.push({min(next_cost, cost), next.first});
                
            }
        }
        
    }
    
    cout << 1;
    

    
    
    return 0;
}

</details>

[BOJ] 선물 전달

Sat, 15 Mar 2025 00:00:00 GMT

선물 전달

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1 ≤ N ≤ 1,000,000)	Dynamic Programming

음.. 제가 한번 풀고서 갑자기 하나가 구상하던게 떠올라서 또 제출해봤더니 그것도 정답이더라구요?

음.. 제가 작성한 코드 2개가 같은 의미를 지닌건 아닌거 같은데.. 그냥 나열해서 관찰한 후에 규칙성 찾아서 풀었습니다..

그냥 열심히 머리 굴리면 되긴하는데.. 뭔가 수학적으로 딱 구해서 해보는 날이 오면 좋겠네요..

풀이 영상

</center>

1번

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

#define mod 1000000000

using namespace std;
using ll = long long;



ll dp[1'000'001];

int main() {
    dp[0] = 0;
    dp[1] = 0;
    dp[2] = 1;
    dp[3] = 2;
    dp[4] = 9;
    dp[5] = 44;
    
    int n;
    cin >> n;
    
    for(ll i = 6; i <= n; i++){
        dp[i] = ((i-1)*dp[i-1] + (i-1)*dp[i-2]) % mod; // ㄹㅇ 이거라고?
        
    }
    cout << dp[n];
    return 0;
}

/*
 a               0
 a b             1
 a b c           2 -> 2*1 + 0
 a b c d         9 -> 3*2(6) + 3 * 1
 a b c d e      44 -> 4*9(36) + 4 * 2(8) = 44 ㄹㅇ 이건가
 a b c d e f   ???
 
 
  
 */

2번 (요놈 왜..)

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
using ll = long long;
ll dp[1000001];

int main() {
    dp[0] = 0;
    dp[1] = 0;
    dp[2] = 1;
    dp[3] = 2;
    dp[4] = 9;
    

    int n;
    cin >> n;
    
    bool check = false;
    for(ll i = 5; i <= n; i++){
        dp[i] = i * dp[i-1];
        if(check) dp[i]++;
        else dp[i]--;
        dp[i]%= 1000000000LL;
        check = !check;
    }
    
    cout << dp[n] ;
    return 0;
}

</details>

[BOJ] 수식 표현

Wed, 12 Jun 2024 00:00:00 GMT

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

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(1<= N <=10,000)	Math, DP(dynamic programming)

이 문제를 보면 갑자기 겁이 들 수도 있을 것 같다. 하지만 사실 문제 자체가 너무 간단하기 때문에 그렇게 겁먹지 않아도 된다.

수식 표현이란 1, +, *, !, (, )로만 이루어진 수식을 말한다. 간명하게 정의하기 위해, 다음과 같이 귀납적으로 정의할 수 있다.

1은 수식표현이다.

e가 수식표현이면 (e)와 e!도 수식표현이다.

e1과 e2가 수식표현이면 e1+e2와 e1*e2도 수식표현이다.

예를 들어 18의 수식표현은 (1+1+1)(1+1+1)!, (1+1+1+1)(1+1+1) +(1+1+1)! 등이 있다. 우리는 n이 주어졌을 때, n의 값을 갖는 수식표현을 구하고 싶다. 단, 1의 개수를 최소로 사용하는 것이어야 한다.

문제를 분석해보자면 숫자 1과 연산자들만 사용해서 입력으로 들어오는 N을 만드는 것을 찾는데, 여기서 중요한건 1을 최대한 적게 사용하는 것이다.

생각을 조금만 해본다면 "e1과 e2가 수식표현이면 e1+e2와 e1*e2도 수식표현이다."라는 것을 본다면 아 작은 것부터 제일 적은 표현법을 찾고, 그를 통해서 큰 수를 확장해 나가면 되겠구나라고 생각할 수 있다.

int dp[100'001] = {MAX, };


int fact(int current){
    if(current == 1) return 1;
    return fact(current-1) * current;
}
int main(){
    int n;
    for(int i = 0; i <= 10000; i++) dp[i] = MAX;
    // 7! 이후 부터는 !쓰지 않음.
    dp[0] = 0;
    dp[1] = 1;
    dp[2] = 2;
    dp[3] = 3;
    dp[4] = 4;
    dp[5] = 5;
    dp[6] = 3;
    dp[7] = 4;
    
    cin >> n;
    
    for(int i = 1; i <= n; i++){
        dp[i] = min({dp[i], dp[i-1]+1});
        for(int j = 2; j <= i; j++){
            if(j*i < 10001) dp[i*j] = min(dp[i*j], dp[i] + dp[j]);
            if(i+j < 10001) dp[i+j] = min(dp[i+j], dp[i] + dp[j]);
        }
        if(i < 8) dp[fact(i)] = dp[i];
    }
    
    cout << dp[n];
    
}

이 코드를 하나하나 분석해 보겠다.

0을 표현하는 1은 0개
1은 1개 / 1
2는 2개 / 1+1
3은 3개 / 1+1+1
4는 4개 / 1+1+1+1
5는 5개 / 1+1+1+1+1
6은 3개 / (1+1+1)!
7은 4개 / 6+1

이것을 미리 해놓은 이유는 좀 편하게 팩토리얼 값을 넣어놓고 시작하기 위해서 넣어놓았습니다.

이제는 for문이 도는 원리를 설명하자면,

현재 내 자신과 전에 있던 조합에서 1을 더한 것 중에 1이 더 적게 쓰인 것을 선택합니다.

또한 자기 자신에서 자기보다 작은 값과의 곱과 합을 통해서 다음 큰 수들의 최솟값을 다시 업데이트함으로써

20을 4*5 의 최소 1의 개수를 얻을 수 있도록 설계하였습니다.

fact은 7로 제한하였는데 이유는 8!이 n의 최댓값을 넘어가기 때문에 조건을 걸어주었습니다.

Solution

#define MAX 2'100'000'000
#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <math.h>
#include <random>

#include <stdlib.h>
#include <time.h>
#include <stdio.h>


using ll = long long;
using ull = unsigned long long;
using namespace std;
// int dy[] = {-1, -1, 0, 1, 1, 1, 0, -1}, dx[] = {0, -1, -1, -1, 0, 1, 1, 1}; // up, lup, left, ldown, down, rdown, right, rup

int dp[100'001] = {MAX, };


int fact(int current){
    if(current == 1) return 1;
    return fact(current-1) * current;
}
int main(){
    int n;
    for(int i = 0; i <= 10000; i++) dp[i] = MAX;
    // 7! 이후 부터는 !쓰지 않음.
    dp[0] = 0;
    dp[1] = 1;
    dp[2] = 2;
    dp[3] = 3;
    dp[4] = 4;
    dp[5] = 5;
    dp[6] = 3;
    dp[7] = 4;
    
    cin >> n;
    
    for(int i = 1; i <= n; i++){
        dp[i] = min({dp[i], dp[i-1]+1});
        for(int j = 2; j <= i; j++){
            if(j*i < 10001) dp[i*j] = min(dp[i*j], dp[i] + dp[j]);
            if(i+j < 10001) dp[i+j] = min(dp[i+j], dp[i] + dp[j]);
        }
        if(i < 8) dp[fact(i)] = dp[i];
    }
    
    cout << dp[n];
    
}

</details>

[BOJ] 다이어트

Fri, 28 Feb 2025 00:00:00 GMT

다이어트

TimeLimit	MemoryLimit	Condition	TAG
2s	512MB	(3 ≤ N ≤ 15<br/> 0 ≤ mp, mf, ms, mv ≤ 500<br/>mp + mf + ms + mv > 0<br/> 0 ≤ p, f, s, v, c ≤ 500)	Backtracking

오늘은 조금 문제 푸는 과정을 보여드리고 싶어서 찍어봤습닏 ㅏ.. 평소에 골랜디 즐겨하는데요 그거 좀 보여드립니다.

풀이 영상 <iframe width="560" height="315" src="https://www.youtube.com/embed/xQNaFrBomkU?si=D1ZfkD-sQGT_HfCo" title="ps" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe> </center>

지금 영상을 보면 1분 정도쯤에 바로 브포의 가능성을 보고서 바로 작성하는 것을 볼 수 있습니다. 또 구조도 한 문제 해석 단계에서 대부분 끝내는 편이구요

어려운 문제의 경우 문제를 해석하고 풀이 과정을 머리로 그리는 시간이 오래걸립니다. 사실상 코드 작성 시간은 어떤 문제든 간에 1시간 이내로 끝내는 것이 대부분인데.. 짜잘한 문법 실수나 다른 +, - 이런거 실수하는 거 때문에 많이 시간을 먹을 때도 있습니다.

이번 문제는 약간 사전순 정렬을 뒤늦게 발견해서 백트래킹의 순서를 바꿔줬습니다. 또 price를 모르고 그냥 조건 되는대로 가다가 이상하다 싶어서 보니까 네.. 문제도 사실 잘못된 정보로 작성하다가 바꾸게 되었죠?

그래도 백트래킹이 가능하다는 것(최대 경우의 수가 많지 않음을 파악함.), 사전순 정렬(백트래킹 순서) 이거를 한번에 파악했다는 것부터 좋은 접근이었다고 생각합니다.

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


struct food{
    int p, f, s, v, price;
    bool visited;
    
    int sum(){
        return p+f+s+v;
    }
};



int n;
food foods[16];
food current, target;
food result;

vector<int> result_members;

bool complete(){
    return current.f >= target.f && current.p >= target.p && current.s >= target.s && current.v >= target.v;
}

void getResult(){
    if(current.price < result.price) {
        result.p = current.p;
        result.v = current.v;
        result.f = current.f;
        result.s = current.s;
        result.price = current.price;
        result_members.clear();
        for(int i = 0; i < n; i++) {
            if(foods[i].visited) result_members.push_back(i+1);
        }
    }
}


void solution(int current_idx){
    if(complete()) {
        getResult();
        return;
    }
    if(current_idx >= n) return;
    
    current.p += foods[current_idx].p;
    current.v += foods[current_idx].v;
    current.f += foods[current_idx].f;
    current.s += foods[current_idx].s;
    foods[current_idx].visited = true;
    current.price += foods[current_idx].price;
    solution(current_idx+1);
    
    current.p -= foods[current_idx].p;
    current.v -= foods[current_idx].v;
    current.f -= foods[current_idx].f;
    current.s -= foods[current_idx].s;
    foods[current_idx].visited = false;
    current.price -= foods[current_idx].price;
    solution(current_idx+1);
    
    
    
}

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

    current = {0, 0, 0, 0, 0};
    cin >> n;
    cin >> target.p >> target.f >> target.s >> target.v;
    
    result = {1000000000, 1000000000,1000000000,1000000000,1000000000, 0};
    
    for(int i = 0; i < n; i++) {
        cin >> foods[i].p >> foods[i].f >> foods[i].s >> foods[i].v >> foods[i].price;
        foods[i].visited = false;
    }
    
    solution(0);
    
    if(result_members.empty()) cout << -1;
    else{
        cout << result.price << "\n";
        for(int i : result_members) cout << i << " ";
    }
    
    
    
    return 0;
}

</details>

[BOJ] 보석 줍기

Tue, 17 Mar 2026 00:00:00 GMT

보석 줍기

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1 ≤ n ≤ 100, <br/>1 ≤ m ≤ 1000<br/>1 ≤ K ≤ 14<br/>1 <= c <= 100)	BFS

솔직히 문제 자체는 쉬웠는데, bit count 세는 로직에서 k를 n으로 적어놓고 오류를 못 찾아서 많이 오래걸린 케이스이다.

최적화 개념에서 bit masking을 활용한다.

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
#include <numeric>
#include <unordered_set>
#include <unordered_map>
#include <climits>
#include <math.h>
using namespace std;
using ll = long long;
using ld = long double;
ll MOD = 1'000'000'000 + 7;

using namespace std;

int n, m, k;

int strength[101][101];
// 걍 viist처리를 몇 번 움직였는가? + 몇 번째 보석을 가졌는가? 에 대한 visit처리만 하면 될드 ㅅ? 근데 최대가 14개인데 이걸르 어케 처리하냐!!! 바로 bit masking이지 아무래도 ㅇㅇ

bool visited[101][20001];


vector<int> gemIsland;

int countOne(int v){
    int result = 0;
    
    int flag = 1;
    while(flag < 1 << k){ // 아니 쉬발 이거였다고? 와 이걸 왜 이따구로 썻냐
        
     
        result += (flag & v) ? 1 : 0;
        flag <<= 1;
    }
    
//    cout << "result: " << result << "\n";
    return result;
    
}


int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
  
    cin >> n >> m >> k;
    bool start_gem = 0;
    for(int i = 0; i < k; i++) {
        int tmp;
        cin >> tmp;
        
        gemIsland.push_back(tmp-1);
        if(tmp == 1)start_gem = true;
    }
    
    
    
    for(int i = 0; i < m; i++){
        int a, b, c;
        cin >> a >> b >> c;
        
        
        strength[a-1][b-1] = c;
        strength[b-1][a-1] = c;
    }
    
    for(int i = 0;  i < 101; i++){
        for(int j = 0; j < 20001; j++){
            visited[i][j] = false;
        }
    }
    
    
    queue<pair<int, int>> q;
    
    q.push({0, 0});
    int result = start_gem;
    
    while(!q.empty()){
        auto [node, current_visited] = q.front(); q.pop();
        
        int currentCount = countOne(current_visited); // 허허 ㅅ발
        
        
        if(node == 0){
            result = max(result, currentCount);
//            int flag = 1;
//            while(flag < 1 << n){
//             
//                if(flag & current_visited) cout << 1;
//                else cout << 0;
//                flag <<= 1;
//            }
//            cout << " : " << countOne(current_visited) <<" \n\n";
            
        }
        
        
        int origin_current_visited = current_visited;
        
        
        for(int i = 0; i < n; i++){
            if(!strength[node][i]) continue; // 0이면 안 들어갈곤데
            if(strength[node][i] < currentCount) continue;
            current_visited = origin_current_visited;
            
            
            if(!visited[i][current_visited]){
                visited[i][current_visited] = true;
                q.push({i, current_visited});
            }
            
            
            for(int j = 0; j < k; j++){
                if(gemIsland[j] == i){
                    current_visited |= 1 << j;
                    break;
                }
            }
            
            
            if(!visited[i][current_visited]){
                
                visited[i][current_visited] = true;
                q.push({i, current_visited});
            }
        }
    }

    
    cout << result;
    return 0;
}

/*
 1 0 1
 1
 
 
 2 1 2
 1
 2
 2 1 3
 
 6 5 6
 1
 2
 3
 4
 5
 6
 1 2 1
 1 3 2
 1 4 3
 1 5 4
 1 6 5
 
 
 6 5 6
 1
 2
 3
 4
 5
 6
 1 2 1
 1 3 1
 1 4 1
 1 5 4
 1 6 5
 */

</details>

[BOJ] 소풍

Thu, 21 Aug 2025 00:00:00 GMT

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

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1 ≤ N ≤ 900<br/>1 ≤ K ≤ 62<br/>1 ≤ F ≤ 5,600)	BackTracking

간단히 backtracking 구현하면 끝나는 문제입니다.

처음에 시작하는 index 번호에 대해서 교집합 처리로 하려고 했는데.. 그냥 구현으로는 시간초과를 피하기가 어려워서 그냥 직관적으로 보이는 풀이로 풀었습니다.

-1이 있는지도 모르고 계속 틀리다가.. 허헣 조심하십쇼


#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
using namespace std;

using ll = long long;

int n, k, f;

bool connect[901][901];
int sizes[901];

bool visited[901];
bool connectVisited[901];

bool isPossible(int target){
    for(int i = 1; i <= n; i++){
        if(!visited[i]) continue;
        
        if(!connect[target][i]) return false;
    }
    return true;
}

bool solution(int current, int depth){
    
    if(depth == k) return true;

    for(int i = 1; i <= n; i++){
        if(!connect[current][i] || visited[i] || !isPossible(i)) continue;
        
        visited[i] = true;
        bool result = solution(i, depth+1);
        if(result) return true;
        visited[i] = false;
    }

    return false;
}

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    
    cin >> k >> n >> f;
    
    for(int i = 0; i < f; i++){
        int a, b;
        cin >> a >> b;
        connect[a][b] = true;
        connect[b][a] = true;
        
        sizes[a]++;
        sizes[b]++;
    }
    
    
    
    for(int i = 1; i <= n; i++){
        if(sizes[i] + 1 < k) continue;
        
        bool result = solution(i, 0);
//        cout << result << "\n";
        if(result){
            int count = 0;
            for(int i = 1; i <= n; i++){
                if(visited[i]){
                    count ++;
                    cout << i << "\n";
                }
                
                if(count == k) return 0;
            }
        }
        
    }
    cout << -1;
   
        
    return 0;
}

/*
 
 1 6 8
 1 2
 1 3
 1 6
 2 3
 2 6
 3 6
 4 5
 5 6
 */

</details>

[BOJ] 구간 합 구하기

Wed, 25 Mar 2026 00:00:00 GMT

구간 합 구하기

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(2 ≤ N ≤ 10,000, 1 ≤ A, B ≤ N, 1 ≤ C ≤ 1,000,000,000)	PrefixSum

아니 근데 문제가 세그 트리라는데 제가 세그 트리를 안 써봐가지고 그냥 풀긴 했거든여.. 근데 다들 세그 트리로 풀었다네요

저는 이게 당연히 정해인 줄 알앗는데 ㅠ

그래도 거의 20분 컷 해서 기분은 좋습니다.

포인트는 바뀌는 것을 어떻게 보정해서 더한 값이 같게 만들어질 것인지를 고민하면 풀립니다.

#define MAX 200000001
#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>
#include <cstring>
#include <queue>
#include <stack>
#include <math.h>
using ll = long long;
using namespace std;

ll preSum[1'000'001];
ll nums[1'000'001];

vector<pair<ll, ll>> changes;
ll fixed_[1'000'001];
ll n, m, k;

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    
    cin >> n >> m >> k;
    
    for(int i = 0; i < n; i++){
        cin >> nums[i];
        fixed_[i] = nums[i];
    }
    preSum[0] = nums[0];
    
    for(int i = 1; i < n; i++) preSum[i] += preSum[i-1] + nums[i];
    
    
    
    for(int i = 0; i < m + k; i++){
        ll a, b, c;
        
        cin >> a >> b >> c;
        
        // change
        if(a == 1){
            changes.push_back({b, c - fixed_[b-1]});
            fixed_[b-1] = c;
//            cout << c - numbers[b-1] <<"\n\n";
        }
        // print
        else if(a == 2){
            ll another = 0;
            
            for(pair<ll, ll> p : changes){
                if(!(b <= p.first && p.first <= c)) continue;
                another += p.second;
            }
            
            cout << preSum[c-1] - preSum[b-1] + another + nums[b - 1] << "\n";
        }
        
    }
    return 0;
    
    
    
    

}

</details>

[BOJ] 피보나치 수의 합

Mon, 06 Oct 2025 00:00:00 GMT

피보나치 수의 합

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	1 ≤ a ≤ b ≤ 9,000,000,000,000,000,000	Math, Dynamic Programming

저번에 풀었던 문제의 약간 쉬운 버전이네요..

약간 실수할 수 있는건 음수에 관한건데 조금 생각하면 금방 ac 할 수 있어요!


#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
#include <numeric>
#include <unordered_set>
#include <unordered_map>
#include <climits>
#include <math.h>
using namespace std;
using ll = unsigned long long;
using ld = long double;
//ll MOD = 1'000'000'007;
ll MOD = 1'000'000'000;
//ll MOD = 1.8446744074E19;

map<ll, ll> dp;



ll solution(ll n){
    if(dp.find(n) != dp.end()) return dp[n];
    ll result;
    
    ll a, b;
    a = solution(n/2);
    b = solution(n/2+1+(-2 *!(n%2)));
    
    if(n%2) result = ((a * a)%MOD + (b * b)%MOD)%MOD;
    else result = ((((2*b)%MOD + a)%MOD)*a)%MOD;
    dp[n] = result;
    
    return result;
}




int main() {
    ll A, B;
    cin >> A >> B;
    
    dp[0] = 0;
    dp[1] = 1;
    dp[2] = 1;
    dp[3] = 2;
    
    
    ll sumA = solution(A+1);
    ll sumB = solution(B+2);
    
    
    // 이게 F_n*F_(n+1)이여서
    
    // 아 생각해보니까 dp자체에서 mod를 쓰니까 더 작을 수 있구나..
    if(sumB < sumA) cout << (sumB - sumA + MOD) % MOD;
    else cout << (((sumB - sumA))%MOD);
    

    return 0;
}

</details>

[BOJ] 두 배열의 합

Wed, 19 Feb 2025 00:00:00 GMT

두 배열의 합

TimeLimit	MemoryLimit	Condition	TAG
2s	64MB	-1,000,000,000 ≤ T ≤ 1,000,000,000<br/>1 ≤ n ≤ 1,000<br/>1 ≤ m ≤ 1,000	Sort, Binary Search, 누적합

진짜 정말 너무 아쉬웠다... 처음 논리에서 별로 벗어나진 않았는데 이상한 코드를 짠 것을 그대로 쓰다가 아예 갈엎으니 바로 ac를 맞았다. 진짜 미치겠다. 어쩌다가...

하튼 일단 문제는 누적합으로 조합을 쫘라락 중복되지 않도록 구하고, 이후에 정렬하고서 이분탐색으로 돌면서 그 슬라이싱된 값들을 빠르게 찾는 전략으로 진행했습니다.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
using ll = long long;

ll t;
ll A[1'000'000];
ll B[1'000'000];

ll input(ll *current) {
    int n;
    cin >> n;
    vector<ll> arr(n);
    for (int i = 0; i < n; ++i) cin >> arr[i];
    int idx = 0;
    for (int i = 0; i < n; ++i) {
        ll sum = 0;
        for (int j = i; j < n; ++j) {
            sum += arr[j];
            current[idx++] = sum;
        }
    }
    return idx;
}

ll solution(ll n, ll m) {
    ll result = 0;
    sort(A, A + n);
    sort(B, B + m);

    for (int i = 0; i < n; ++i) {
        ll target = t - A[i];
        ll left = 0, right = m - 1;
        ll rl = -1, rr = -1;

        while (left <= right) {
            ll pivot = (right + left) / 2;
            if (B[pivot] >= target) {
                right = pivot - 1;
                if (B[pivot] == target) rl = pivot;
            } else  left = pivot + 1;
        }

        left = 0;
        right = m - 1;
        while (left <= right) {
            ll pivot = (right + left) / 2;
            if (B[pivot] <= target) {
                left = pivot + 1;
                if (B[pivot] == target) rr = pivot;
            } else right = pivot - 1;
        }

        if (rl != -1 && rr != -1) result += (rr - rl + 1);
    }

    return result;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> t;
    ll n = input(A);
    ll m = input(B);

    cout << solution(n, m);

    return 0;
}

</details>

[BOJ] 다리 만들기

Sun, 23 Feb 2025 00:00:00 GMT

다리 만들기

TimeLimit	MemoryLimit	Condition	TAG
2s	192MB	1 ≤ N ≤ 100	BFS

전형적인 BFS 문제로 그냥 열심히 돌리면 정답이 나오는 문제입니다.

조금 신경써야 할 것은 visit 처리를 기본적으로 해주면 쉽게 풀립니다.

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

using ll = long long;

int n;
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
int origin[101][101];
int board[101][101];

int solution() {
   int current = 1;
   for(int i = 0; i < n; i++) {
       for(int j = 0; j < n; j++) {
           if(origin[i][j] != 1) continue;
           
           queue<pair<int, int>> q;
           q.push({i, j});
           current++;
           origin[i][j] = current;
           
           while(!q.empty()) {
               auto [y, x] = q.front(); q.pop();
               for(int k = 0; k < 4; k++) {
                   int nx = x + dx[k];
                   int ny = y + dy[k];
                   if(0 <= nx && nx < n && 0 <= ny && ny < n && origin[ny][nx] == 1) {
                       origin[ny][nx] = current;
                       q.push({ny, nx});
                   }
               }
           }
       }
   }

   int result = 1e9;
   for(int start = 2; start <= current; start++) {
       queue<pair<int, int>> q;
       for(int i = 0; i < n; i++) {
           for(int j = 0; j < n; j++) {
               board[i][j] = -1;
               if(origin[i][j] == start) {
                   q.push({i, j});
                   board[i][j] = 0;
               }
           }
       }
       
       while(!q.empty()) {
           auto [y, x] = q.front(); q.pop();
           
           for(int k = 0; k < 4; k++) {
               int nx = x + dx[k];
               int ny = y + dy[k];
               if(0 <= nx && nx < n && 0 <= ny && ny < n) {
                   if(origin[ny][nx] == 0 && board[ny][nx] == -1) {
                       board[ny][nx] = board[y][x] + 1;
                       q.push({ny, nx});
                   }
                   else if(origin[ny][nx] != 0 && origin[ny][nx] != start) {
                       result = min(result, board[y][x]);
                       break;
                   }
               }
           }
       }
   }
   
   return result == 1e9 ? -1 : result;
}

int main() {
   ios_base::sync_with_stdio(false);
   cin.tie(nullptr);
   
   cin >> n;
   for(int i = 0; i < n*n; i++)  cin >> origin[i/n][i%n];
   
   cout << solution();
   return 0;
}

</details>

[BOJ] 구간 나누기

Thu, 10 Oct 2024 00:00:00 GMT

구간 나누기

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(1 <= N <= 100, 1<=M<=[N/2]<br/>-32768 <= num <= 32767 )	DynamicProgramming(DP)

N(1 ≤ N ≤ 100)개의 수로 이루어진 1차원 배열이 있다. 이 배열에서 M(1 ≤ M ≤ ⌈(N/2)⌉)개의 구간을 선택해서, 구간에 속한 수들의 총 합이 최대가 되도록 하려 한다. 단, 다음의 조건들이 만족되어야 한다.

각 구간은 한 개 이상의 연속된 수들로 이루어진다.

서로 다른 두 구간끼리 겹쳐있거나 인접해 있어서는 안 된다.

정확히 M개의 구간이 있어야 한다. M개 미만이어서는 안 된다.

N개의 수들이 주어졌을 때, 답을 구하는 프로그램을 작성하시오.

문제를 처음 보고서 바로 dp로 접근한 나에게 칭찬 드립니다!

문제를 보자마자 dp에 대한 정의를 했습니다. 이후 이 dp 식에 맞도록 bottom-up으로 문제를 풀이하였습니다.

저의 아이디어는 dp[i][j]는 현재 수열에서 i번째를 보고 있을 때, j번째의 구간이다. 그렇기에 i는 N보다 작으며, j는 m보다 작다.

이렇게 다 구한 후 m개의 구간으로 나눠진 조합 중 제일 큰 것들을 업데이트하고 최종적으로 제일 큰 값을 고르면 최적해를 찾을 수 있다.

#include <iostream>

using namespace std;

const int pre = -2100000000;

int n, m;
int nums[101];
int dp[101][101];
int main(){
    // dp[i][j][k]는 i번째 일때, j개의 연속된 값에서 k번째의 구간이다. 라는 의미이다.
    // 다시 정의한다. dp[i][j]는 i 번째 일때, j번째의 구간이다.
    
    cin >> n >> m;
    
    for(int i = 0; i < n; i ++) cin >> nums[i];
    
    if(m == 1) {
        int mymax = pre;
        for(int i = 0; i < n; i++) mymax = max(mymax, nums[i]);
        cout<< mymax;
        return 0;
    }
    
    for(int i = 0; i < n+1; i++)
        for(int j = 0; j < n+1; j++) dp[i][j] = pre;
    
    dp[0][0] = nums[0];
    for(int i = 1; i < n; i ++){
        dp[i][0] = max(dp[i-1][0]+nums[i], nums[i]);
        for(int j = 1; j < m+1; j++) dp[i][j] = max(dp[i][j], dp[i-1][j] + nums[i]);
        for(int j = 0; j < i-1; j++){
            for(int k = 1; k < m+1; k++) dp[i][k]=max(dp[i][k], dp[j][k-1]+nums[i]);
        }
    }
    
    int result = pre;
    for(int i = 0; i < n+1; i++) result = max(dp[i][m-1], result);
    
    
    cout << result;
    return 0;
}

</details>

[BOJ] 동전 나누기 1

Sun, 16 Feb 2025 00:00:00 GMT

동전 나누기 1

TimeLimit	MemoryLimit	Condition	TAG
0.5s	4MB	1 ≤ n ≤ 100<br/>1 ≤ k ≤ 10,000	Dynamic Programming

기본적인 dp 문제이고, 연습하기 좋은 문제였던 것 같습니다. 재미있던 문제였습니다.

코드와 같이 포문을 돌리면 중복 체크를 할 필요가 없어유 순서 섞이는 경우가 발생을 안 하기 때문에 이렇게 간단히 solve할 수 있습니다.

처음에 메모리 제한 4mb 보고서 뭐지? 이거 어떻게 품? 이러다가 범위 보고서 딱 풀었네요

#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
using namespace std;
using ll = long long;

int n, k;
int num[101];
int dp[10001];

int main() {
    ios_base::sync_with_stdio(false); cin.tie(nullptr);
    
    cin >> n >> k;
    for(int i = 0; i < n; i++) cin >> num[i];
    
    dp[0] = 1;
    
    for(int i = 0; i < n; i++) {
        for(int j = num[i]; j <= k; j++) dp[j] += dp[j - num[i]];
    }
    
    cout << dp[k];
    return 0;
}

</details>

[BOJ] ReverseSort

Thu, 25 Sep 2025 00:00:00 GMT

ReverseSort

TimeLimit	MemoryLimit	Condition	TAG
5s	512MB	(1 ≤ N ≤ 10)	BFS, Meet In The Middle

문제가 조금 많이 당황스러웠습니다. 처음에 N이 10 이하인데 이렇게 시간을 많이 준다고? 뭐지? 하면서 생각을 해보니 생각보다 전체 순회는 안되고, 따로 최적해를 구하는 로직이 필요한데 쪼갠다는 생각을 하고서 어떻게 구현해야되는 것인지를 생각하는게 오래걸렸네요.

MITM을 풀어본적이 ctf 때나 있었던 거 같은데 ps에서 보니 반갑기도 하면서 아이디어 떠오르는게 왜 오래걸린지 잘 이해가 되지 않았던 문제였습니다.

구현은 단순히 입력으로 들어온 상태와 완성된 상태에서 이어질 수 있는 경우들을 reverse 시키면서 그 상태를 저장시키고(path로 저장), 만약 그 key에 도달하면 forward list와 backward list의 key 겹치는 개수를 더해서 정답을 출력하도록 만들었습니다.

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
#include <numeric>
#include <unordered_set>
#include <unordered_map>
using namespace std;
int N;
struct Node {
    vector<int> arr;
    vector<pair<int,int>> ops;
};

string encode(const vector<int>& arr) {
    string s;
    for (int x : arr) s.push_back(char(x));
    return s;
}

template <typename T>
void listReverse(vector<T>& list, int left, int right){
    while(left < right){
        T tmp = list[left];
        list[left] = list[right];
        list[right] = tmp;
           
        left++;
        right --;
    }
}

string solution(queue<vector<int>>& q,
                unordered_map<string, vector<pair<int,int>>>& vis,
                unordered_map<string, vector<pair<int,int>>>& other,
                bool forward){
  int sz = q.size();
  while (sz--) {
      auto cur = q.front(); q.pop();
      string ck = encode(cur);
      auto ops = vis[ck];

      int n = cur.size();
      for (int i = 0; i < n; i++) {
          for (int j = i+1; j < n; j++) {
              auto nxt = cur;
              listReverse(nxt, i, j);

              string nk = encode(nxt);
              if (!vis.count(nk)) {
                  auto newOps = ops;
                  newOps.push_back({i, j});
                  vis[nk] = newOps;
                  q.push(nxt);

                  if (other.count(nk)) {
                      return nk;
                  }
              }
          }
      }
  }
  return "";
};


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

    
    cin >> N;
    vector<int> start(N);
    vector<int> goal(N);
    for (int i = 0; i < N; i++){
        cin >> start[i];
        goal[i] = i + 1;
    }

    if (start == goal) {
        cout << 0 << "\n";
        return 0;
    }

    unordered_map<string, vector<pair<int,int>>> fwd, bwd;
    queue<vector<int>> qf, qb;

    fwd[encode(start)] = {};
    bwd[encode(goal)] = {};
    qf.push(start);
    qb.push(goal);

    string meetKey;

    while (!qf.empty() && !qb.empty()) {
        // 앞쪽
        meetKey = solution(qf, fwd, bwd, true);
        if (!meetKey.empty()) break;

        // 뒤쪽
        meetKey = solution(qb, bwd, fwd, false);
        if (!meetKey.empty()) break;
    }

    
    auto ops1 = fwd[meetKey];
    auto ops2 = bwd[meetKey];
    

    cout << ops1.size() + ops2.size() << "\n";

}

</details>

[BOJ] 물통

Fri, 04 Oct 2024 00:00:00 GMT

물통

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1 <= A, B, C <= 200)	Implementation(구현), BFS(너비우선탐색)

각각 부피가 A, B, C(1≤A, B, C≤200) 리터인 세 개의 물통이 있다. 처음에는 앞의 두 물통은 비어 있고, 세 번째 물통은 가득(C 리터) 차 있다. 이제 어떤 물통에 들어있는 물을 다른 물통으로 쏟아 부을 수 있는데, 이때에는 한 물통이 비거나, 다른 한 물통이 가득 찰 때까지 물을 부을 수 있다. 이 과정에서 손실되는 물은 없다고 가정한다.

이와 같은 과정을 거치다보면 세 번째 물통(용량이 C인)에 담겨있는 물의 양이 변할 수도 있다. 첫 번째 물통(용량이 A인)이 비어 있을 때, 세 번째 물통(용량이 C인)에 담겨있을 수 있는 물의 양을 모두 구해내는 프로그램을 작성하시오.

이 문제는 시간도 널널하고, 뭐 딱히 어려운 로직도 아닌 거 같아서 조건 달아서 구현했더니 풀리는 문제였습니다.

A가 0일때, C의 부피를 알아내는 과정이 그냥 조금 중복계산 줄이고, 탐색하면 될 것 같아서 BFS로 구현하여 풀이하였습니다.


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

bool visited[201][201][201];
bool result[201];

typedef struct bottle {
    int a, b, c;
} bottle;

int main() {
    int a, b, c;
    cin >> a >> b >> c;
    
    queue<bottle> q;
    
    q.push({0, 0, c});
    int pour;
    while(!q.empty()) {
        bottle bot = q.front(); q.pop();
        if(visited[bot.a][bot.b][bot.c]) continue;
        visited[bot.a][bot.b][bot.c] = true;
        
        if(bot.a == 0) {
            result[bot.c] = true;
        }
        
        // a -> b
        pour = min(bot.a, b - bot.b);
        q.push({bot.a - pour, bot.b + pour, bot.c});
        
        // a -> c
        pour = min(bot.a, c - bot.c);
        q.push({bot.a - pour, bot.b, bot.c + pour});
        
        // b -> a
        pour = min(bot.b, a - bot.a);
        q.push({bot.a + pour, bot.b - pour, bot.c});
        
        // b -> c
        pour = min(bot.b, c - bot.c);
        q.push({bot.a, bot.b - pour, bot.c + pour});
        
        // c -> a
        pour = min(bot.c, a - bot.a);
        q.push({bot.a + pour, bot.b, bot.c - pour});
        
        // c -> b
        pour = min(bot.c, b - bot.b);
        q.push({bot.a, bot.b + pour, bot.c - pour});
    }
    
    
    
    for(int i = 0; i < 201; i++){
        if(result[i]) cout << i << " ";
    }
    return 0;
}

</details>

[BOJ] 3초 정렬

Tue, 11 Mar 2025 00:00:00 GMT

3초 정렬

TimeLimit	MemoryLimit	Condition	TAG
2s	1024MB	(3 ≤ N ≤ 200000<br/> 1 ≤ A_i ≤ 1e9)	DynamicProgramming

음.. 일단 dp 정의까지는 어렵지 않았구요.. 상태 전이 시키고 역추적으로 들어가서 빼고나서 정렬하면 됩니다. 그래서 정렬 후에 출력하면 바로 맞을 수 잇어여 좋은 dp 문제 같습니다!


#include <iostream>
#include <queue>
#include <algorithm>
#include<set>
#include <map>
using namespace std;
using ll = long long;

int inf = 1e9+1000;

int nums[200'001];
int n;
int dp[200'001][4]; // dp[i][j]는 i번째 수를 보고 있을때, j번의 정렬 상태이다.

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    
    
    cin >> n;
    for(int i = 0; i < n; i++){
        cin >> nums[i];
    }
    


    dp[1][0] = nums[0];
    dp[1][1] = 1;
    dp[1][2] = 1;
    dp[1][3] = 1;
    
    
    
    for(int i = 2; i <= n; i++){
        dp[i][0] = inf;
        // 안돼?? 그럼 넣을게
        if(dp[i-1][0] <= nums[i-1]) dp[i][0] = nums[i-1];
        
        for(int j = 1; j < 4; j++){
            // 전 위치에서 변경하고 넣는 경우?
            dp[i][j] = dp[i-1][j-1];
            
            
            // 전 위치에서 j를 변경하지 않고, 내가 바꿔야 되는 경우
            if(dp[i-1][j] <= nums[i-1]) dp[i][j] = min(dp[i][j], nums[i-1]);
        }
    }
    
    
    
    
    if(min({dp[n][0], dp[n][1], dp[n][2], dp[n][3]}) == inf) cout << "NO";
    else {
        cout << "YES\n";
        vector<pair<int, int>> result;
        
        
        int count = 0;
        int minimum = inf;
        for(int i = 0; i < 4; i++){
            if(minimum > dp[n][i]){
                minimum = dp[n][i];
                count = i;
            }
        }
        
        cout << count << "\n";
        
        
        
        for(int i = n; i > 0; i--){
            if(!count) break;
            if(dp[i-1][count] > nums[i-1] || nums[i-1] > dp[i-1][count-1]){
                result.push_back({i, dp[i][count--]});
                
            }
        }
        
        
        sort(result.begin(), result.end());
        for(auto p : result){
            cout << p.first << " " << p.second << "\n";
        }
        
        
        
    }
    
    
    return 0;
}

</details>

[BOJ] 성인 게임

Sat, 15 Feb 2025 00:00:00 GMT

성인 게임

TimeLimit	MemoryLimit	Condition	TAG
1s	1024MB	(1≤T≤1,000<br/>1≤N≤1,000,000)	Dynamic Programming

우왕... 약간 처음보는 유형이라 조금 해매긴 했습니다. 나눠서 푸는 이런 느낌 오호 재밌었습니다. 이게 칼날이 막대기로 나오냐 아니냐 요걸로 나눠서 풀면 됩니다.

생각보다 어려웠따! 넵

아 그리구 식이 길어지니까 vim으로 하다가 이제 약간 IDE가 얼마나 편한지 알았습니다. 제가 원래 Xcode를 쓰고 있었는데... 그것도 기능이 참 많은 거였네요 허헣

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll mod = 1000000007;
int t, n;
ll dp[2][1'000'001];

void solve() {
    dp[0][0] = 1;
    dp[0][1] = 7;
    dp[1][1] = 3;
    
    for(int i = 2; i < 1'000'001; i++) {
                dp[0][i] = ((3 * dp[0][i-1]) % mod + (4 * dp[1][i-1]) % mod) % mod;
                dp[1][i] = (dp[0][i-1] + (2 * dp[1][i-1]) % mod) % mod;
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> t;
    solve();
    while(t-->0) {
        cin >> n;
        cout << dp[0][n] << "\n";
    }
    return 0;
}

</details>

[BOJ] 모든 스택 수열

Sat, 01 Feb 2025 00:00:00 GMT

모든 스택 수열

TimeLimit	MemoryLimit	Condition	TAG
2s	1024MB	(1<= n <= 10)	BackTracking, Stack

스택 (stack)은 기본적인 자료구조 중 하나로, 컴퓨터 프로그램을 작성할 때 자주 이용되는 개념이다. 스택은 자료를 넣는 (push) 입구와 자료를 뽑는 (pop) 입구가 같아 제일 나중에 들어간 자료가 제일 먼저 나오는 (LIFO, Last in First out) 특성을 가지고 있다. 1부터 n까지의 수를 스택에 넣었다가 뽑아 늘어놓음으로써, 하나의 수열을 만들 수 있다. 이때, 스택에 push하는 순서는 반드시 오름차순을 지키도록 한다고 하자. n이 주어졌을 때, 만들 수 있는 모든 스택 수열을 구해보자.

내가 이 문제를 처음에 ??? 이 문제 왜 골드냐 이러고 풀었다가 허헣 "어 머야 왜 이 코드가 예시랑 다르지?"

내가 "순서는 반드시 오름차순"을 까먹고 그냥 사전순으로 모든 조합을 해버린 것이다... 허허ㅓ허허허ㅓ헣

그래서 그것을 보고서 아 바꿔야하네 하고 좀 뜯어 고쳐서 나온 코드가 바로 이런데.. 사실 반드시 오름차순으로 들어오는 것을 잘 이용하면 이 코드보다 뭔가 더 좋은 코드가 나오지 않을까 하지만 일단 시간이 12ms로 굉장히 빠르게 나온 편이라 또 N이 최대 10밖에 안 나오기 때문에 딱히 문제는 없을 것 같다. 애초에 문제가 브포 문제로 나온 것 같아서 ㅎㅎ

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

int n;

void solution(stack<int>& st, vector<int>& current, int next, vector<vector<int>>& result) {
   if (current.size() == n) {
       result.push_back(current);
       return;
   }
   
   if (next <= n) {
       st.push(next);
       solution(st, current, next + 1, result);
       st.pop();
   }
   
   if (!st.empty()) {
       int top = st.top();
       st.pop();
       current.push_back(top);
       solution(st, current, next, result);
       current.pop_back();
       st.push(top);
   }
}

int main() {
   cin >> n;
   stack<int> st;
   vector<int> current;
   vector<vector<int>> result;
   
   solution(st, current, 1, result);
   
   for (int i = result.size() - 1; i > -1; i--) {
       for (int num : result[i]) {
           cout << num << " ";
       }
       cout << "\n";
   }
   
   return 0;
}

</details>

[BOJ] 두 용액

Sat, 22 Jun 2024 00:00:00 GMT

두 용액

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(2 ≤ N ≤ 100,000,-1,000,000,000 ≤ element ≤ 1,000,000,000)	TwoPointer

KOI 부설 과학연구소에서는 많은 종류의 산성 용액과 알칼리성 용액을 보유하고 있다. 각 용액에는 그 용액의 특성을 나타내는 하나의 정수가 주어져있다. 산성 용액의 특성값은 1부터 1,000,000,000까지의 양의 정수로 나타내고, 알칼리성 용액의 특성값은 -1부터 -1,000,000,000까지의 음의 정수로 나타낸다. 같은 양의 두 용액을 혼합한 용액의 특성값은 혼합에 사용된 각 용액의 특성값의 합으로 정의한다. 이 연구소에서는 같은 양의 두 용액을 혼합하여 특성값이 0에 가장 가까운 용액을 만들려고 한다. 예를 들어, 주어진 용액들의 특성값이 [-2, 4, -99, -1, 98]인 경우에는 특성값이 -99인 용액과 특성값이 98인 용액을 혼합하면 특성값이 -1인 용액을 만들 수 있고, 이 용액이 특성값이 0에 가장 가까운 용액이다. 참고로, 두 종류의 알칼리성 용액만으로나 혹은 두 종류의 산성 용액만으로 특성값이 0에 가장 가까운 혼합 용액을 만드는 경우도 존재할 수 있다. 산성 용액과 알칼리성 용액의 특성값이 주어졌을 때, 이 중 두 개의 서로 다른 용액을 혼합하여 특성값이 0에 가장 가까운 용액을 만들어내는 두 용액을 찾는 프로그램을 작성하시오.

우리의 목표는 "주어진 수(0을 제외한 범위 안에 정수)들 중에서 서로다른 2개를 골라서 0에 가장 가까운 수를 만들어라." 이다.

여기서 제일 먼저 생각해볼 것은 어떻게 0에 가까운 수를 만들 것인가? 이다.

여러가지를 생각해보자!

BruteForce
Sort
Two Pointer

이렇게 3가지를 생각해보자.

일단 먼저 전체를 탐색하는 BruteForce이다.

N의 최댓값인 100,000으로 계산을 해보자면 모든 수들과 다하고 비교하는 과정에서 최악의 경우엔 N^2 즉 O(N^2)이 되므로 시간초과에 걸리게 된다.

다음으론 Sort이다. 정렬을 하여 작은 수, 큰 수들끼리 더해서 0에 가까운 수를 만들어내는 방법이다. 사실상 이것도 정확히 어떤 값이 0에 가까운 수인지 모르기 때문에 넘어간다.

마지막으로 TwoPointer이다. 일단 문제에서 "2개의 용액을 골라서"를 보자마자 이 방법으로 접근해야 되겠다고 생각이 들었다. 투 포인터로 접근하세요!라고 문제에서 말하고 있어서 나는 3번째 방법인 투 포인터로 접근하여 문제를 풀이하였다.

내가 선택한 방법은 일단 받은 모든 용액들을 오름차순으로 정렬 후, 각 끝(제일 작은 수, 제일 큰 수)부터 시작하여 0을 기점으로 큰지 작은지를 판단 후 작은 수 쪽의 값을 큰 값 쪽으로 당기거나 큰 수 쪽의 값을 작은 수 쪽으로 당기는 방법으로 0과 제일 가까운 수를 알아내도록 하였다.

일단 내가 말한 내용을 정리해 보자면,

투 포인터로 풀이하기 위해서 작은 수와 큰 수들이 모여있는 곳을 나눈다.(단조화) 작은 쪽 수에서 시작하는 포인터(left), 큰 쪽 수에서 시작하는 포인터(right) 이 2개의 포인터로 0에 가까운 용액을 찾아낸다. 현재 left와 right가 가르키고 있는 용액이 0보다 크다면, 작다면으로 나누어 right를 left쪽으로 당기거나, left를 right쪽으로 당겨와 다시 반복해 제일 0과 가까운 수를 찾도록 한다. 이렇게 요약할 수 있다.

단조화
left, right의 포인터 시작
left-> 큰 수쪽으로, right -> 작은 수 쪽으로 탐색 시작
최적의 해 찾음.

이제 코드로 확인해 보자!

전역 변수

int n;

vector<int> nums;

N
- 몇 개의 용액이 들어오는지 알려주는 변수
nums
- 각 용액의 특성값을 저장하는 벡터

Main

int main(){
    fast_io
    
    cin >> n;
    nums.resize(n);
    
    for(int i = 0; i < n; i++) cin >> nums[i];
    
    sort(nums.begin(), nums.end());
    
    int left= 0, right = n-1;
    pair<int, int> result = {MAX, 0};
    
    while(left < right){
        if(diff(result.first, result.second) > diff(nums[left], nums[right])) result = {nums[left], nums[right]};
        
        if((nums[left] + nums[right]) < 0) left++;
        else right--;
    }
    
    cout << result.first << " "<< result.second;
    
}

main은 입력을 받고, 바로 투 포인터를 이용해서 두 용액의 합이 0과 가장 가까운 두 용액을 구하는 코드입니다.

sort는 C++ STL(algorithm에 존재)에 내장 함수입니다.

sort를 통해서 정렬해주고, 가장 작은 수부터 시작하는 left, 가장 큰 수부터 시작하는 right를 인덱스로 초기화 해줍니다.

diff는 간단히 abs(용액1+용액2)의 연산을 해주는 함수입니다.

현재 등록되어있는 두 용액의 합보다 지금 가르키고 있는 두 용액의 합이 0에 더 가깝다면, result를 업데이트 해줍니다.

또한 현재의 합이 0보다 작다면 더 큰 값으로 탐색할 수 있게 left를 +1하고, 합이 0보다 크거나 같다면 right-- 해줍니다.

여기서 같다면 어차피 위에서 result가 업데이트 되었기 때문에 상관할 같은 상황은 고려할 필요가 없습니다.

이렇게 반복하면서 left와 right가 크로스될 때까지 돌게된다면, 간단히 두 용액의 합이 0에 가장 가까운 두 용액을 얻어낼 수 있습니다.

참 간단하죠잉?

다들 즐거운 PS 하세용!!

#define MAX 2'100'000'000
#define LLMAX 9'223'372'036'854'775'807
#define fast_io ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);

#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <ctime>
#include <stdio.h>
using ll = long long;
using ull = unsigned long long;
using namespace std;

int n;

vector<int> nums;

int diff(int a, int b){ return abs(a + b); }

int main(){
    fast_io
    
    cin >> n;
    nums.resize(n);
    
    // 1 상근, 0 창영
    
    // 1 0 1 1 0 1 0 0
    
    for(int i = 0; i < n; i++) cin >> nums[i];
    
    sort(nums.begin(), nums.end());
    
    int left= 0, right = n-1;
    pair<int, int> result = {MAX, 0};
    
    while(left < right){
        if(diff(result.first, result.second) > diff(nums[left], nums[right])) result = {nums[left], nums[right]};
        
        if((nums[left] + nums[right]) < 0) left++;
        else right--;
    }
    
    cout << result.first << " " << result.second;
    
}

</details>

[BOJ] 색상환

Tue, 01 Oct 2024 00:00:00 GMT

색상환

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(4 ≤ N ≤ 1,000,1 ≤ K ≤ N)	DP

색을 표현하는 기본 요소를 이용하여 표시할 수 있는 모든 색 중에서 대표적인 색을 고리 모양으로 연결하여 나타낸 것을 색상환이라고 한다. 미국의 화가 먼셀(Munsell)이 교육용으로 고안한 20색상환이 널리 알려져 있다. 아래 그림은 먼셀의 20색상환을 보여준다.

색상환에서 인접한 두 색은 비슷하여 언뜻 보면 구별하기 어렵다. 위 그림의 20색상환에서 다홍은 빨강과 인접하고 또 주황과도 인접하다. 풀색은 연두, 녹색과 인접하다. 시각적 대비 효과를 얻기 위하여 인접한 두 색을 동시에 사용하지 않기로 한다.

주어진 색상환에서 시각적 대비 효과를 얻기 위하여 서로 이웃하지 않은 색들을 선택하는 경우의 수를 생각해 보자. 먼셀의 20색상환에서 시각적 대비 효과를 얻을 수 있게 10개의 색을 선택하는 경우의 수는 2이지만, 시각적 대비 효과를 얻을 수 있게 11개 이상의 색을 선택할 수 없으므로 이 경우의 수는 0이다.

주어진 정수 N과 K에 대하여, N개의 색으로 구성되어 있는 색상환 (N색상환)에서 어떤 인접한 두 색도 동시에 선택하지 않으면서 서로 다른 K개의 색을 선택하는 경우의 수를 구하는 프로그램을 작성하시오.

일단 문제를 보고서 생각할 것 없이 나는 이 문제가 dp 문제인 것을 알고 들어왔다. 그래서 바로 dp 정의를 생각해 보았는데... 생각보다 어려웠다. 아직 내가 dp에 대해서 잘 모르는 것을 뼈저리게 느낀 문제였다.

일단 내 풀이 방법은 간단하다. dp[i][j][k]는 0~i 번째 까지의 색을 고려할 때, j개의 색을 고른다.

k = 0
- 0~i번째 까지의 색을 고려할 때, j개의 색을 고르는데 현재의 단계 즉 i번째를 제외한 j개를 고른다.
k = 1
- 0~i번째 까지의 색을 고려할 때, j개의 색을 고르는데 현재의 단계 즉 i번째를 포함한 j개를 고른다.

이렇게 정의를 하고 점화식을 짜러 들어갔다.

일단 현재 나 자신이 선택될 수 있는 조건이 무엇인가? 를 생각했다. 내가 선택이 가능하다는 것, 그리고 내가 설계한 dp 구조에서는 현재의 나를 마지막 보니까 "내 위치 - 1"의 색을 고르지만 않으면 된다.

그래서 현재 나를 고를 때 나는 무엇을 고려하냐 바로 dp[i-1][j-1][0]만을 고려하여 더하면 된다.

그렇다면 현재의 나를 고르지 않는 경우의 수는 어떻게 구할 수 있을까?

나를 선택하지 않는다는 것은 나의 전 상태를 고려할 수 있다는 의미이다. 그래서 dp[i-1][j][1]을 더한다. 그런데 내가 활성화되지 않았어도, dp[i-1][j][0]을 고려할 수 있다 그래서 결과적으로 dp[i][j][0] = dp[i-1][j][0] + dp[i-1][j][1] 이렇게 된다.

정리해보자

k = 0일때 dp[i][j][0] = dp[i-1][j][0] + dp[i-1][j][1]

k = 1일때 dp[i][j][1] = dp[i-1][j-1][0]

이런 점화식을 만들 수 있다.

당연하겠지만 초기에 설정되는 값이 굉장히 중요하다. 왜냐하면 문제가 원형 문제기 때문에 N 위치에 있는 색을 고르지 않앗을 때와 N의 위치를 고를 때의 처음 값을 다르게 설정하여 문제를 풀었다.

#include <iostream>
#include <algorithm>
#define MOD 1000000003
using namespace std;
int N, K;
int dp[1001][1001][2];

int solution(int n, int k, bool check){
    
    if(k*2 -1 > n) return 0;
    
    if(dp[n][k][check] != -1) return dp[n][k][check];
    
    if(check) dp[n][k][check] = solution(n-1, k-1, false) % MOD;
    else dp[n][k][check] = (solution(n-1, k, true) + solution(n-1, k, false)) % MOD;
    return dp[n][k][check];
}

int main(){
    cin >> N >> K;
    int result = 0;
    
    if(K == 1){
        cout << N;
        return 0;
    }
    for(int i = 0; i < N+1; i++){
        for(int j = 0; j < K+1; j++){
            dp[i][j][false] = -1;
            dp[i][j][true] = -1;
        }
        
        dp[i][0][false] = 1;
        dp[i][0][true] = 0;
        
        dp[i][1][true] = 1;
        dp[i][1][false] = i-1;
    }
    result += solution(N, K, false) % MOD;
    
    for(int i = 0; i < N+1; i++){
        for(int j = 0; j < K+1; j++){
            dp[i][j][false] = -1;
            dp[i][j][true] = -1;
  
        }
        dp[i][1][true] = 1;
        dp[i][1][false] = i-2;
  
    }
    for(int j = 0; j < K+1; j++){
        dp[1][j][false] = 0;
        dp[1][j][true] = 0;
        dp[0][j][false] = 0;
        dp[0][j][true] = 0;

    }

    result += solution(N, K, true);
 
    cout << (result % MOD) << "\n";


    return 0;
}

</details>

[BOJ] 괄호의 값

Wed, 08 Oct 2025 00:00:00 GMT

괄호의 값

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(1 ≤ string_length ≤ 30)	Data Structure

그냥 간단한 stack 구현 문제였습니다.

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
#include <numeric>
#include <unordered_set>
#include <unordered_map>
#include <climits>
#include <math.h>
using namespace std;
using ll = unsigned long long;
using ld = long double;
//ll MOD = 1'000'000'007;
ll MOD = 1'000'000'000;
//ll MOD = 1.8446744074E19;

struct info {
    char c;
    int val;
};

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    vector<info> stack;
    
    string input;
    cin >> input;
    
    
    for(int i = 0; i < input.size(); i++){
        if(stack.empty()){ stack.push_back({input[i], 0}); continue;}
        
        char current = input[i];
        info pre = stack.back();
        if(pre.c== '(' && current == ')'){
            stack.pop_back();
            stack.push_back({0, 2});
        }else if(pre.c == '[' && current == ']'){
            stack.pop_back();
            stack.push_back({0, 3});
        }else if(pre.c == 0 && (current == ')' || current == ']')){
            char limit = current ==')' ? '(' : '[';
            int result = stack.back().val * (current == ')' ? 2 : 3);
            stack.pop_back();
            if(stack.empty() || stack.back().c != limit){
                cout << 0;
                return 0;
            }
            stack.pop_back();
            stack.push_back({0, result});
            
            
            
        }else{
            stack.push_back({current, 0});
        }
        
        if(!stack.empty() && stack.back().c == 0){
            int result = 0;
            while(!stack.empty() && stack.back().c == 0) {
                result += stack.back().val;
                stack.pop_back();
            }
            
            stack.push_back({0, result});
        }
    }
    
    int result = 0;
    while(!stack.empty() && stack.back().val != 0){
        result += stack.back().val; stack.pop_back();
    }
    
    if(stack.size() > 0) cout << 0;
    else cout << result;
    
    return 0;
}
/*
 
 ([()()()()]()()()())
 
 
 */

</details>

[BOJ] 시루의 백화점 구경

Tue, 04 Mar 2025 00:00:00 GMT

시루의 백화점 구경

TimeLimit	MemoryLimit	Condition	TAG
2s	1024MB	(1 ≤ N, M ≤ 2000, 0 ≤ K ≤ 4000)	BFS

이 문제도 전형적인 BFS 문제이구요. 조금 BFS 연습하고 싶을 때 와서 풀어보면 좋을 것 같아요. 그냥 기본 BFS로 푸는거라서... 그런데 저는 조금 이상하게 푼 ㅓㄱ 같기두 하고요...

뭔가 애매하고 들어간 느낌? 하튼 재밌었습니다... 낼 학교 준비해야징..

풀이 영상 <iframe width="560" height="315" src="https://www.youtube.com/embed/EZ-4VwoFTC8?si=OfEU5zTqgpc9lNN3" title="PS" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

</center>

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

using ll = long long;

int inf = 1000000000;

int n, m, k;
int visited[2001][2001];
int board[2001][2001];
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, -1, 1};


void init(vector<pair<int, int>>& hs){
    queue<pair<int, pair<int,int>>> q;
    
    
    
    for(pair<int, int> pos : hs) {
        q.push({0, pos});
        visited[pos.first][pos.second] = -1;
    }
    while(!q.empty()){
        auto [cost, p] = q.front(); q.pop();
        visited[p.first][p.second] = -1;
//            cout << "start: " << p.first << " " << p.second << "\n"; 이게 아닌가...?
        for(int i = 0; i < 4; i++){
            int nx = p.second + dx[i];
            int ny = p.first + dy[i];

            if(cost < k && 0 <= ny && ny < n && 0 <= nx && nx < m &&
               visited[ny][nx] != -1){
//                    cout << ny << " " << nx << "\n";
                visited[ny][nx] = -1;
                q.push({cost+1, {ny, nx}});
            }
        }
    }
//    for(int i = 0; i < n; i++){
//        for(int j = 0; j < m; j++){
//            cout << visited[i][j] << " ";
//        }
//        cout << "\n";
//    }

}
int solution(pair<int ,int> player){
    
    
    
    priority_queue<pair<int, pair<int,int>>, vector<pair<int, pair<int, int>>>, greater<pair<int, pair<int, int>>>> q;
    q.push({0, player});
    
    while(!q.empty()){
        auto [cost, pos] = q.top(); q.pop();
        
        if(board[pos.first][pos.second] == 2) return cost;
        
        
        for(int i = 0; i < 4; i++){
            int nx = pos.second + dx[i];
            int ny = pos.first + dy[i];
            
            if(0 <= ny && ny < n && 0 <= nx && nx < m && visited[ny][nx] > cost && board[ny][nx] != 1){
                visited[ny][nx] = cost;
                q.push({cost+1, {ny, nx}});
            }
        }

    }

    return -1;
}
int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    cin >> n >> m >>k;
    
    pair<int, int> player;
    vector<pair<int, int>> hs;
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            cin >> board[i][j];
            
            switch(board[i][j]){
                case 3:
                    hs.push_back({i, j});
                    break;
                case 4:
                    player = {i, j};
                case 1: // 벽 뒤에 있는 경우도 있을듯.
                case 2:
                    break;
            }
            visited[i][j] = inf;
            
        }
    }
    
    init(hs);


    cout << solution(player);
    
    

    return 0;
}

</details>

[BOJ] 인공 신경망

Sun, 23 Feb 2025 00:00:00 GMT

인공 신경망

TimeLimit	MemoryLimit	Condition	TAG
3s	1024MB	문제 참고(너무 많은 관계로)	Implementation

솔직히 처음에 이 문제 자체가 호감이었다. 일단 우리학교 문제였고, 인공지능 관련 문제였다. 또한 문제를 풀면서 굉장히 교육적으로 좋은 문제라는 것도 알게 되었는데 굉장히 잘 만든 문제처럼 보인다.

처음은 당연히 그냥 구현 문제인줄 알고 그대로 구현하였다. ps하면서 처음으로 class를 사용해서 구현하는데 꽤 재미있었다. 이런 문제들이 많아지면 좋을 듯!

그래서 Neural을 정의하고, 그걸 연산해서 사용하는 코드를 짰더니 당연히 O(N^3)으로 터지게 되었다. 그래서 어떻게 줄일까? 생각하다가 잠시 질문 게시판을 참고해서 아하 일차식으로 나타내서 한번 계산하면 다른 쿼리 처리를 빠르게 할 수 있구나! 라고 찾을 수 있습니다.

조금 인공지능 얘기를 좀 해보겠습니다.

신경망은 순수하게 선형 연산만을 합니다. 그래서 좀 보자면

은닉층 [input * weight] + bias
출력층 [hidden * weight] + bias

이렇게 순수 선형 연산으로 이루어져 있어서 여러개가 겹쳐져 있더라도 선형 연산을 압축 시킬 수 있다는 이런 특징을 알 수 있구요!

그래서 여러개의 층들을 하나의 입력으로 보자면 어떻게 되는가? 예시로 위의 은닉, 출력을 보자면

은닉층1: y = w1x + b1 출력층: z = w2y + b2

이렇게 표현 가능하죠?

근데 이렇게 문제를 풀 수 있는데 여기서 좀 더 생각하자면.. 이러한 선형성을 띈다.. 그러면 복잡한 패턴이나 추상적 특징들을 잡아낼 수가 없어요

좀 대표적인 예시를 들자면 XOR이 그때 구현이 안돼서 많이 인공지능 붐이 한번 다시 죽었을 때... 생각을 해봅시다.. 복잡한게 학습이 안되니까 이 선형성을 어떻게 죽일까... 이런 생각을 한거죠

그래서 우리가 activation function을 사용합니다. 왜냐 앞서 말했던 그 "선형적" 특징을 좀 비선형적으로 바꾸기 위해서 사용하는 거죠.

ReLU, Sigmoid를 보통 사용하구... 이 비선형성을 도입함으로써 복잡하고, 추상적인 특징들 패턴들을 알아볼 수 있게됩니다.

그래서 저는 이 문제가 굉장히 많은 것을 알려주고 있다고 생각합니다.

와 다시 생각해봐도 좋은 문제네요

사실 저도 이렇게 깊이 생각은 안 했는데.. 다른 사람들이 푼 것들 말하는 것들을 보면서 좀 더 넓은 시야를 얻을 수 있었던 것 같습니다. 고수님들 언제나 감사합니다!

(사실 밤새고 적었습니다.. 혹시나 오류가 존재하면 알려주셔요!)

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

using ll = long long;
int input_layer[2001];

class neural{
public:
    vector<pair<int, int>> inputs; // input, weight
    int bias;
    ll calc;
    neural(vector<pair<int, int>> &inputs, int bias){
        this->inputs = inputs;
        this->bias = bias;
        calc = -1;
    }
    neural(){
        calc = -1;
    }
    
    ll calculation(int *input_layer, bool check){
        if(!check) return calc;
        
        ll result = 0;
        for(pair<int, int> p : inputs){
            auto [input, weight] = p;
            
            int input_value = input_layer[input];
            result += input_value * weight;
        }
        calc = result + (ll) bias;
        return result + (ll) bias;
    }
    
    ll calculation(neural *hidden){
        ll result = 0;
        for(pair<int, int> p : inputs){
            auto [input, weight] = p;
            
            neural input_value = hidden[input];
            result += input_value.calculation(input_layer, false) * weight;
        }
        return result + (ll) bias;
    }
    
    
    
};

neural hidden_layer[2001];

void solution(){
    int n, m, q;
    cin >> n >> m >> q;
    
    vector<ll> final_coefficients(n + 1, 0);
    ll final_bias = 0;

    // hidden layer input
    int c;
    for(int i = 0; i < m; i++){
        cin >> c;
        vector<pair<int, int>> current(c);
        for(int j = 0; j < c; j++) cin >> current[j].first;
        for(int j = 0; j < c; j++) cin >> current[j].second;
        int bias;
        cin >> bias;
        
        neural current_neural = neural(current, bias);
        
        
        hidden_layer[i] = current_neural;
    }
    
    vector<pair<int, int>> current(m);
    for(int i = 0; i < m; i++) current[i].first = i;
    for(int i = 0; i < m; i++) cin >> current[i].second;
    int bias;
    cin >> bias;
    
    neural output = neural(current, bias);
    for(int h = 0; h < m; h++){
        for(auto [input_idx, weight] : hidden_layer[h].inputs) final_coefficients[input_idx] += (ll)weight * output.inputs[h].second;
        
        final_bias += (ll)hidden_layer[output.inputs[h].first].bias * output.inputs[h].second;
    }
    final_bias += (ll)output.bias;
    
    while(q--){
        ll result = final_bias;
        for(int i = 1; i <= n; i++){
            int input;
            cin >> input;
            result += input * final_coefficients[i];
        }
        cout << result << "\n";
    }
}

int main(){
    
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    
    
    solution();
    return 0;
}

</details>

[BOJ] Shooting Game

Mon, 31 Mar 2025 00:00:00 GMT

Shooting Game

TimeLimit	MemoryLimit	Condition	TAG
1s	512MB	(5 ≤ N ≤ 100, 1 ≤ K ≤ 15)	Dynamic Programming

처음에는 그냥 간단히 bfs로 풀이할 수 있을거라고 생각했다..

그래서

#include <iostream>
#include <vector>
#include <queue>
#include <tuple>

#define inf 1000000000
using namespace std;
using ll = long long;

int n, m;

pair<int, int> bomb[16];

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

    cin >> n >> m;
    
    for(int i = 0; i < m; i++) cin >> bomb[i].first >> bomb[i].second;
    
    int cp;
    cin >> cp;
    
    priority_queue<pair<int, pair<int, short>>, vector<pair<int, pair<int, short>>>, greater<pair<int, pair<int, short>>>> q; // {current_time, {current_position, current_visited}}
    
    q.push({0, {cp, 0}});
    
    short complete = 1;
    for(int i = 0; i < m; i++) complete |= 1 << i;
    
    
    
    while(!q.empty()){
        auto [time, _] = q.top(); q.pop();
        auto [pos, visited] = _;
        
//        cout << "time: " << time << "\npos: " << pos << ", " << visited << "\n";
        
        if(visited == complete) {
            cout << time;
            return 0;
        }
        
        bool impossible = false;
        for(int i = 0; i < m; i++){
            if(visited & (1 << i)) continue;
//            cout << "time: " << bomb[i].first + time + 1 << "\npos: " << i << ", " << n << "\n";

            if(abs(pos - bomb[i].second) + time + 1 >= n || bomb[i].first + time >= n){
                impossible = true;
                break;
            }
            
        }
        
        if(impossible) continue;
        
        for(int i = 0; i < m; i++){
            if(visited & (1 << i)) continue;
            q.push({time + abs(pos - bomb[i].second) + 1, {bomb[i].second, visited | (1 << i)}});
        }
        
        
    }
    
    cout << -1;
    
    
    
    return 0;
    
    
    
}

역시.. 당연히 시간초과가 나왔다.. 이때 든 생각... "dp냐 너?"

보통 이런 어이없는 결과를 보게된다면 의심해보게 된다.

아 근데 결국 dp로 접근을 못하고 그냥 bfs를 잘 최적화해보기로 맘을 먹고서 각 위치, 시간, 그리고 방문한 상태를 가지고 중복 실행이 되지 않도록 만들고, 이거를 토대로 돌렸다.

이 과정에서 bitset이라는 썼는데 또 xcode는 include 안해도 알아서 처리를 해줘서 boj에서 많이 틀리는 원인이 되었다.. 허허...

결국 최종적으로는 그냥 visited처리를 좀 더 잘한 코드로 ac를 받았다...

#include <iostream>
#include <vector>
#include <queue>
#include <tuple>
#include <bitset>

#define inf 1000000000
using namespace std;
using ll = long long;

int n, m;

pair<int, int> bomb[16];
bitset<(1<<15)> dp[101][101];


void print(int current){
    cout << "state: ";
    while(current > 0){
        cout << (current & 1) << " ";
        current/=2;
    }
    cout << "\n";
}

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

    cin >> n >> m;
    
    for(int i = 0; i < m; i++) cin >> bomb[i].first >> bomb[i].second;
    
    int cp;
    cin >> cp;
    
    
    priority_queue<pair<int, pair<int, short>>, vector<pair<int, pair<int, short>>>, greater<pair<int, pair<int, short>>>> q; // {current_time, {current_position, current_visited}}
    
    q.push({0, {cp, 0}});
    
    short complete = 1;
    for(int i = 0; i < m; i++) complete |= 1 << i;
    
    
    
    while(!q.empty()){
        auto [time, _] = q.top(); q.pop();
        auto [pos, visited] = _;
        
//        cout << "time: " << time << "\npos: " << pos << ", " << visited << "\n";
//        cout << "time: " << time << "\n";
//        print(visited);
        
        if(visited == complete) {
            cout << time;
            return 0;
        }
        
        bool impossible = false;
        for(int i = 0; i < m; i++){
            if(visited & (1 << i)) continue;
            if(abs(pos - bomb[i].second) + time + 1 >= n || bomb[i].first + time + abs(pos - bomb[i].second) >= n){
                impossible = true;
                break;
            }
        }
        
        if(impossible) continue;
        
        for(int i = 0; i < m; i++){
            if(visited & (1 << i)) continue;
            if(dp[time + abs(pos - bomb[i].second) + 1][bomb[i].second][visited | (1 << i)]) continue;
            q.push({time + abs(pos - bomb[i].second) + 1, {bomb[i].second, visited | (1 << i)}});
            dp[time + abs(pos - bomb[i].second) + 1][bomb[i].second][visited | (1 << i)] = true;
        }
        
        
    }
    
    cout << -1;
    

    
    
    
    
    
    
    return 0;
    
    
    
}


/*
 
 3 1
 2 1
 2

 5 3
 1 2
 1 4
 1 5
 3

 
 4 3
 3 1
 2 1
 1 1
 1
 
 
 1 1
 1 1
 1
 
 
 
 3 2
 1 1
 1 2
 
 
 
 100 1
 96 1
 5
 */

</details>

[BOJ] 싫은데요

Sat, 15 Mar 2025 00:00:00 GMT

싫은데요

TimeLimit	MemoryLimit	Condition	TAG
1s	1024MB	(1 ≤ N ≤ 500,000<br/>1 ≤ M, A_i ≤ 1e9<br/>)	Two Pointer

범위를 슬라이싱 해야되는데 N이 5*10^5거든요? O(N^2)이 1초에 절대 안 돌아가기 때문에 다른 방법을 생각해야 했고.. 그게 바로 "투 포인터" 였습니다. 그래서 그냥 전형적인 같은 시작 투포인터를 이용하면 됩니당

#include <iostream>
#include <vector>
#include <set>
#include <queue>
#include <map>
#include <algorithm>
using namespace std;
using ll = long long;


int nums[500002];

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    int n, m;
    
    cin >> n >> m;
    
    
    
    for(int i = 1; i <= n; i++){
        cin >> nums[i];
    }
    
    int left = 1, right = 1;
    
    
    
    ll current = nums[1];
    ll result = 0;
    while(right <= n){
        if(right < left){
            right++;
            current += nums[right];
        }
        
        if(current <= m){
            result = max(result, current);
            right++;
            current += nums[right];
        }else{
            current-=nums[left];
            left++;
        }

    }
        
    cout << result;
    
    return 0;
}

</details>

[BOJ] Jagged Skyline

Tue, 08 Apr 2025 00:00:00 GMT

Jagged Skyline

TimeLimit	MemoryLimit	Condition	TAG
4s	1024MB	(1 ≤ w ≤ 10000, 1 ≤ h ≤ 10^18)	Random(?), Binary Search

와.. 이거는 접근은 잘 됐는데.. 이분탐색에서 if문 조건을 착각해서 시간을 날린 문제.. 헉

접근까지는 그렇게 오래 안 걸리고 뭔가 어느정도 몇개 랜덤으로 보다보면 큰게 나와서 아래거를 좀 제거할 수 있을거 같은데? 이러한 아이디어에서 출발했습니다. 근데 나중에 if문 조건을 잘못 적어버려서 혼났네요.. ㅏ아아아ㅏ아아아아앙 분노의 연속 10번 제출을 해버려서 ㅠㅜ

하튼 재밌었습니다.

endl 쓰는거는 cout flush 해줘야해서 써준 겁니당. 그리고 인터렉트 이거 처음 풀어봤는데 재밌네요!

#include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <random>
using namespace std;
using ll = long long;
ll w, h;
ll max_height = 0;
ll result_pos = 1;
ll global_cnt;
bool visited[10001];
bool check(ll w, ll h){
    cout << "? " << w << " " << h << endl;
    string response;
    cin >> response;
    return response == "sky";
}

void solution(ll pos){
    global_cnt++;
    if(check(pos, max_height+1)) return;
    
    ll low = max_height;
    ll top = h;
    
    
    while(low < top){
        ll pivot = (low+top) / 2;
        global_cnt++;
        
        if(check(pos, pivot+1)) top = pivot;
        else low = pivot + 1;
    }
    
    if(top > max_height){
        max_height = top;
        result_pos = pos;
    }
    
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    
    
    global_cnt = 0;
    cin >> w >> h;
    random_device rd;
    mt19937 gen(rd());
    
    uniform_int_distribution<int> rand_(1, (int)w);
    
    for(int i = 0; i < w; i++){
        int width = rand_(gen);
        while(visited[width]) width = rand_(gen);
        
        visited[width] = true;
        if(global_cnt >= 12000) break;
        solution(width);
        
        if(max_height == h) break;
    }
    
    cout << "! " << result_pos << " " << max_height;
    
    return 0;
}

</details>

[BOJ] 로마 숫자

Mon, 10 Feb 2025 00:00:00 GMT

로마 숫자

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	1≤ each password ≤ 2,000<br/>2,000 ≤ sum of the password ≤ 4,000	Implementation

솔직히 나는 구현을 디게 멍청하게 풀었다. 풀다가 아 이길이 아닌데.. 이거 다르게 풀면 빠른데.. 이걸 알았지만 문제 뭐냐 여태까지 풀었던 코드가 꽤 길어서 그냥 오기로 내 방식대로 풀고 효율적인 코드도 작성해보고 둘 다 제출해봤다. 다행이 둘다 AC를 바로 맞아서 뿌듯하긴 했으나..

실력이 많이 안 좋아진 것을 실감하는 계기가 되었다.... 무슨 몇 달 쉬면 퇴물이 되버리냐 더 열심히 해야겠다. 아 그리고 문제 이해가 약간 가볍게 읽으면 이상한데 빠지니 좀 잘 읽어보고 풀도록 하자!

오늘의 정답 코드는 두개가 올라갑니다아

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

using namespace std;
using ll = long long;

char postNumbers[] = {
    'I' ,
    'V',
    'X',
    'L',
    'C',
    'D',
    'M'};

int values[] = {
    1,
    5,
    10,
    50,
    100,
    500,
    1000
};


int solution(string current){
    int result = 0;
    int size = 7;
    int idx = 0;
    int currentStack = 0;
    while(idx < current.size()){
        bool check = false;
        int currentCost = 0;
        for(int i = 6; i > -1; i--){
            if(current[idx] == postNumbers[i]){
                if(i <= size){
                    size = i;
                    check = true;
                }
                currentCost = values[i];
                break;
            }
        }
        currentStack = values[size];
        idx++;
        result += currentCost - currentStack*(!check)*2;

    }
    return result;
    
}

int pow(int a, int b){
    int result = a * 1000;
    while(b-->0) result /= 10;
    return result;
}
string getResult(int num) {
    string result = "";
    
    int values[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
    string numerals[] = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
    
    for(int i = 0; i < 13; i++) {
        while(num >= values[i]) {
            result += numerals[i];
            num -= values[i];
            if(numerals[i].size() > 1) break;
        }
    }
    
    return result;
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    
    string a, b;
    
    cin >> a >> b;
    
    int resultNumber = solution(a) + solution(b);
    
    
    cout << resultNumber<<"\n"<<getResult(resultNumber);
    
    
    return 0;
}

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

using namespace std;
using ll = long long;

char postNumbers[] = {
    'I',
    'V',
    'X',
    'L',
    'C',
    'D',
    'M'
};

int values[] = {
    1,
    5,
    10,
    50,
    100,
    500,
    1000
};

int solution(string current) {
    int result = 0;
    int size = 7;
    int idx = 0;
    int currentStack = 0;
    
    while(idx < current.size()) {
        bool check = false;
        int currentCost = 0;
        
        for(int i = 6; i > -1; i--) {
            if(current[idx] == postNumbers[i]) {
                if(i <= size) {
                    size = i;
                    check = true;
                }
                currentCost = values[i];
                break;
            }
        }
        
        currentStack = values[size];
        idx++;
        result += currentCost - currentStack*(!check)*2;
    }
    return result;
}

int pow(int a, int b) {
    int result = a * 1000;
    while(b-- > 0) result /= 10;
    return result;
}

string getResult(string value) {
    string result = "";
    bool check[] = {0, 0, 0, 0, 0, 0};
    string checkString[] = {
        "IV",
        "IX",
        "XL",
        "XC",
        "CD",
        "CM"
    };
    
    int current = 0;
    while(current < value.size()) {
        int currentValue = value[current] - '0';
        int position = value.size() - 1 - current;
        
        for(int i = 3; i > 1; i--) {
            int limit = i * i;
            if(currentValue == limit) {
                int idx = position * 2 + !(limit == 4);
                
                if(check[idx]) continue;
                check[idx] = true;
                result += checkString[idx];
                currentValue -= limit;
                
            }
            
        }
        
        for(int i = 6; i > -1; i--) {
            int power = 1;
            for(int j = 0; j < position; j++) power *= 10;
            
            if(values[i] > power * 5 || values[i] < power) continue;
            
            while(currentValue >= values[i] / power) {
                result += postNumbers[i];
                currentValue -= values[i] / power;
            }
        }
        current++;
    }
    return result;
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    
    string a, b;
    cin >> a >> b;
    
    int resultNumber = solution(a) + solution(b);
    
    string resultString = "";
    int t = 1;
    while(resultNumber >= t) {
        resultString += '0' + resultNumber%(t*10)/t;
        t *= 10;
    }
    reverse(resultString.begin(), resultString.end());
    
    cout << resultNumber<<"\n" << getResult(resultString);
    
    return 0;
}

</details>

[BOJ] 치즈

Mon, 01 Jul 2024 00:00:00 GMT

치즈

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(5<= N, M <= 100)	BFS(너비우선탐색)

N×M의 모눈종이 위에 아주 얇은 치즈가 <그림 1>과 같이 표시되어 있다. 단, N 은 세로 격자의 수이고, M 은 가로 격자의 수이다. 이 치즈는 냉동 보관을 해야만 하는데 실내온도에 내어놓으면 공기와 접촉하여 천천히 녹는다. 그런데 이러한 모눈종이 모양의 치즈에서 각 치즈 격자(작 은 정사각형 모양)의 4변 중에서 적어도 2변 이상이 실내온도의 공기와 접촉한 것은 정확히 한시간만에 녹아 없어져 버린다. 따라서 아래 <그림 1> 모양과 같은 치즈(회색으로 표시된 부분)라면 C로 표시된 모든 치즈 격자는 한 시간 후에 사라진다.

<그림 2>와 같이 치즈 내부에 있는 공간은 치즈 외부 공기와 접촉하지 않는 것으로 가정한다. 그러므 로 이 공간에 접촉한 치즈 격자는 녹지 않고 C로 표시된 치즈 격자만 사라진다. 그러나 한 시간 후, 이 공간으로 외부공기가 유입되면 <그림 3>에서와 같이 C로 표시된 치즈 격자들이 사라지게 된다.

모눈종이의 맨 가장자리에는 치즈가 놓이지 않는 것으로 가정한다. 입력으로 주어진 치즈가 모두 녹아 없어지는데 걸리는 정확한 시간을 구하는 프로그램을 작성하시오.

(그림은 boj를 참고해 주세요)

문제를 읽어보니 대충 요약을 해보자면 "격자로 구성되어 있는 치즈 중에서 '바깥 공기'와 '두 변이 접촉'한 치즈는 다음 시간에 사라진다. 모든 치즈가 사라진 정확한 시간을 구하는 것이 목표" 로 말할 수 있다.

요약한 내용과 문제에서 주어진 정보들을 정리해 보자면

치즈는 '바깥 공기'와 '두 변이 접촉'하면 녹는다.
모든 치즈가 사라지지 않는 경우의 수는 없다.(어떻게든 두 변이 닿는 치즈가 존재함)
치즈가 녹는 시간은 접촉과 동시에 정확히 1시간이다.

우리가 해결해야될 문제들을 더욱 구체화 시켜서 보도록 하자.(구현해야될 기능 정리)

녹는 치즈들을 선별해내는 기능
녹는 치즈들이 없어지고, 다음 공기(바깥 공기가 아닌)들과 접촉되는 기능
BFS에서 시간 복잡도와 공간 복잡도를 최적화하기 위해서 visited.

int n, m;
bool board[102][102], visited[102][102];
int costBoard[102][102];
bool test[102][102];
int dy[] = {1, -1, 0, 0}, dx[] = {0, 0, 1, -1};
int result = 0, cnt = 0;
queue<pair<int, int>> q, air;

N, M
- 입력으로 주어지는 n*m 크기의 치즈가 들어온다고 알려주는 2개의 크기 값.
board
- board[y][x]값이 true이면 치즈, false이면 공기라는 것을 저장하는 2차원 배열
visited
- visited[y][x]가 방문했었는지의 정보를 저장하고 있는 2차원 배열
costBoard
- costBoard[y][x]는 바깥 공기와 몇 개의 변이 닿아있는지를 저장하는 2차원 배열
dy, dx
- 동서남북으로 확산되는 것을 for문으로 간단히 처리하기 위해서 선언한 배열
result
- 현재 몇 시간이 지났는지 저장하는 변수
cnt
- 현재 녹지않은 치즈의 개수
Q
- "한" 시간에 녹아내릴 치즈를 알아내는 Queue
air
- 공기들이 순차적으로 들어와 순회하면서 치즈를 녹일 수 있도록하는 Queue </details>

전역 변수들을 선언하고 이제 main으로 들어가보자

#define fast_io ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);

int main(){
    fast_io
    cin >> n >> m;
    
  
    
    int tmp;
    
    
    for(int i = 1; i <= n; i++){
        
        for(int j = 1; j <= m; j++){
            cin >> tmp;
            board[i][j] = tmp;
            if(board[i][j]) cnt++;
        }
        if(!board[i][1]) air.push({i, 1});
        if(!board[i][m]) air.push({i, n});
    }
    for(int i = 1; i <= m; i++){
        if(!board[1][i]) air.push({1, i});
        if(!board[n][i]) air.push({n, i});
    }

작성된 main의 일부분입니다.

이름부터 알겠지만 fast_io는 빠른 입출력을 해주는 친구들이구요!(C 언어 사용자 분들이 간혹 위에 cin.tie(0)을 쓰시고 scanf를 쓰는 경우를 봤는데요. 그러시면 안됩니다. cin.tie(0)을 사용하시면 cin만 사용해야 됩니다.)

아래부터 입력을 받습니다.

n, m을 먼저 입력받고 n*m만큼 돌면서 치즈를 입력으로 다 받아옵니다.

여기서 "모눈종이의 맨 가장자리에는 치즈가 놓이지 않는 것으로 가정"이 조건을 이용해서 저는 맨 끝의 공기들을 전부 air에 넣어서 탐색을 진행하겠습니다.

if문으로 처리를 해놓은 것은 제가 처음에 저 조건을 못 보고서 모두 처리를 진행했기에 남아있는 겁니당..(index가 1부터 시작하는 것도 그 때문)

이제 주요코드인 BFS 코드를 살펴봅시다.

while(!air.empty() && cnt > 0){
        int length = (int) air.size();
        
        for(int i = 0; i < length && cnt > 0; i++){
            
            pair<int, int> pos = air.front(); air.pop();
            if(visited[pos.first][pos.second]) continue;
            q.push(pos);
            board[pos.first][pos.second] = false;
            while(!q.empty() && cnt > 0){
                
                pos = q.front(); q.pop();
                // cout << pos.first << " " << pos.second << "\n";
                if(visited[pos.first][pos.second]) continue;
                if(board[pos.first][pos.second]){
                    costBoard[pos.first][pos.second]++;
                    if(costBoard[pos.first][pos.second] > 1){
                        cnt--;
                        costBoard[pos.first][pos.second] = -MAX;
                        air.push(pos);
                    }
                    continue;
                }
                test[pos.first][pos.second] = true;

                visited[pos.first][pos.second] = true;
                
                
                for(int next = 0; next < 4; next++){
                    int ny = dy[next] + pos.first;
                    int nx = dx[next] + pos.second;
                    
                    if(0 < ny && ny <= n && 0 < nx && nx <= m && !visited[ny][nx]) q.push({ny, nx});
                    
                }
                

            }
            

        }

        result++;
    }

코드에서는 먼저 air(바깥 공기들)가 비어있지 않은 상태에서 현재 알고있는 바깥 공기들을 전부 for문을 돌면서 방문하지 않았던 공기를 하나씩 가져옵니다. 그 가져온 공기에서 BFS를 진행시켜서 확산을 통해서 바깥 공기와 접촉한 치즈들을 접촉한 수 만큼 costBoard[치즈의 y 위치][치즈의 x 위치]++을 해줌으로써 닿아있는 변이 하나 더 있다는 것을 세어줍니다. 한번 방문한 공기는 방문처리를 통해서 다시 방문하지 않도록하여, 시간 및 공간을 최적화하였습니다.

그러다 2 변 이상이 한 치즈와 접촉하고 있다면 그 치즈를 다음 시간에는 녹아 없어질 것으로 확정짓고, air에 위치를 넣은 후 다시 재탐색하는 방법으로 접근하였습니다.

이 방법으로 result를 카운트하면 저희가 원하는 "주어진 치즈가 모두 녹아 없어지는데 걸리는 정확한 시간"을 알 수 있습니다.

(새벽 감성 코딩이라 좀 이상합니다..)

int main(){
    fast_io
    cin >> n >> m;
    
  
    
    int tmp;
    
    
    for(int i = 1; i <= n; i++){
        
        for(int j = 1; j <= m; j++){
            cin >> tmp;
            board[i][j] = tmp;
            if(board[i][j]) cnt++;
        }
        if(!board[i][1]) air.push({i, 1});
        if(!board[i][m]) air.push({i, n});
    }
    for(int i = 1; i <= m; i++){
        if(!board[1][i]) air.push({1, i});
        if(!board[n][i]) air.push({n, i});
    }
    
    
    // cout << cnt << "\n";
    
    while(!air.empty() && cnt > 0){
        int length = (int) air.size();
        
        for(int i = 0; i < length && cnt > 0; i++){
            
            pair<int, int> pos = air.front(); air.pop();
            if(visited[pos.first][pos.second]) continue;
            q.push(pos);
            board[pos.first][pos.second] = false;
            while(!q.empty() && cnt > 0){
                
                pos = q.front(); q.pop();
                // cout << pos.first << " " << pos.second << "\n";
                if(visited[pos.first][pos.second]) continue;
                if(board[pos.first][pos.second]){
                    costBoard[pos.first][pos.second]++;
                    if(costBoard[pos.first][pos.second] > 1){
                        cnt--;
                        costBoard[pos.first][pos.second] = -MAX;
                        air.push(pos);
                    }
                    continue;
                }
                test[pos.first][pos.second] = true;

                visited[pos.first][pos.second] = true;
                
                
                for(int next = 0; next < 4; next++){
                    int ny = dy[next] + pos.first;
                    int nx = dx[next] + pos.second;
                    
                    if(0 < ny && ny <= n && 0 < nx && nx <= m && !visited[ny][nx]) q.push({ny, nx});
                    
                }
                

            }
            

        }

        result++;
    }
    
    cout << result;
    
    return 0;
}

</details>

[BOJ] 십자카드 문제

Tue, 04 Feb 2025 00:00:00 GMT

십자카드 문제

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(1<= E_i <= 10)	BruteForce

<center>

</center> 위와 같은 십자모양의 한 장의 카드에서, 네 모서리에 1 이상 9 이하의 숫자가 하나씩 씌여 있다. 이 네 개의 숫자 중에는 같은 숫자도 있을 수 있다.

모든 가능한 십자 카드가 주어질 때, 각각의 카드는 다음과 같은 '시계수'라는 번호를 가진다. 시계수는 카드의 숫자들을 시계 방향으로 읽어서 만들어지는 네 자리 수들 중에서 가장 작은 수이다. 위 그림의 카드는 시계방향으로 3227, 2273, 2732, 7322로 읽을 수 있으므로, 이 카드의 시계수는 가장 작은 수인 2273이다.

입력으로 주어진 카드의 시계수를 계산하여, 그 시계수가 모든 시계수들 중에서 몇 번째로 작은 시계수인지를 알아내는 프로그램을 작성하시오.

예를 들어서, 다음과 같은 십자 카드의 시계수는 1122이며, 이 시계수보다 작은 시계수들은 1111, 1112, 1113, 1114, 1115, 1116, 1117, 1118, 1119 뿐이므로 1122는 10번째로 작은 시계수다. (여기서 십자카드는 0 이 나타날 수 없으므로 1120은 시계수가 될 수 없다. 또한 1121 이 적혀있는 카드의 시계수는 1112이므로, 1121은 시계수가 될 수 없다.

<center>

</center>

일단 시간보고, 범위 봤더니 아 브포구나 알았구요.. 문제가 돌린다는게 정확히 뭘 구하라는건지 좀 생각을 해봤더니 그렇게 막 꼬아놓은 문제는 아니더군요!

그래서 그냥 브포로 구했습니다.. 처음에 코드를 쓰면서 아.. 더 효율적인 방법이 없나 하면서 풀었네요 허허

참 많이도 돌아갔네요 진짜.. 어휴 코드가 왜 이래.. 진짜 ㅠㅜ

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
using ll = long long;


void swap(int* a, int* b){
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

int dice[4];

bool visited[10][10][10][10];

bool check(int value){
    int current[] = {value / 1000, value / 100 % 10, value % 100 / 10, value % 10};
    if(!(current[0] && current[1] && current[2] && current[3])) return true;
    bool flag = false;
    for(int i = 0; i < 4; i++)
        if(visited[current[i]][current[(i+1)%4]][current[(i+2)%4]][current[(i+3)%4]]) flag = true;
    return flag;
}
int main() {
    for(int i = 0; i < 4; i++) cin >> dice[i];    
    int current = 10000000000;
    for(int i = 0; i < 4; i++){
        int currentValue = 0;
        for(int j = 0; j < 4; j++) {
            currentValue*=10;
            currentValue+=dice[j];
        }
        current = min(current, currentValue);

        int first = dice[0];
        for(int j = 0; j < 3; j++) swap(dice[j], dice[j+1]);   
        dice[3] = first;
    }
    
    int result = 1;
    for(int i = 1111; i < current; i++){
        if(check(i)) continue;        
        visited[i / 1000][i / 100 % 10][i % 100 / 10][i % 10] = true;
        result++;
    }
    cout << result;
}

</details>

[BOJ] Cowties

Mon, 06 Oct 2025 00:00:00 GMT

Cowties

TimeLimit	MemoryLimit	Condition	TAG
1s	1024MB	(3 ≤ N ≤ 100)	Dynamic Programming

그냥 대놓고 dp 문제 준거여서 그대로 읽고 그대로 풀면 되었씁니다. 약간 조심할거는...

"처음 시작했던 점이랑 이어져야한다는 것" 정도 겠네요.


#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
#include <numeric>
#include <unordered_set>
#include <unordered_map>
#include <climits>
#include <math.h>
using namespace std;
using ll = unsigned long long;
using ld = long double;
//ll MOD = 1'000'000'007;
//ll MOD = 1.8446744074E19;

int N;

// 그냥 dp로 풀면 될걱 ㅏㅌ긴한ㄷ
//ld dp[101][
// 그니까 i번째 cow를 보고 잇느 상황에서.. j번째 위치로 선택했ㅇ르 때 최소값을 얻어가면 되는거자너

// dp[i][j]를 i번째 cow의 j번째 position으로 확정할 때 그 전까지의 loop length 최솟값으로 정하자. // 이거 길이가 분수가 나오니까 double 로 하고 마지막에만 100 곱하기로

// 이게 그냥 간단히 끝나는건 아니였구만..

ld dp[101][101];

vector<pair<int, int>> cows[101];

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    ld a = LLONG_MAX;
    
    
    cin >> N;
    
    for(int i = 0; i < N; i++){
        int tmp;
        cin >> tmp;
        
        for(int j = 0; j < tmp; j++){
            int y, x;
            cin >> y >> x;
            
            cows[i].push_back({y, x});
        }
    }
    
    
    ld result = LLONG_MAX;
    for(int first = 0; first < cows[0].size(); first++){
        
        for(int i = 1; i < N; i++){
            for(int j = 0; j < cows[i].size(); j++){
                dp[i][j] = LLONG_MAX;
                if(i == 1){
                    auto [cy, cx] = cows[i][j];
                    auto [py, px] = cows[0][first];
                    
                    ld distance = sqrtl((cy - py) * (cy - py) + (cx - px) * (cx - px));
                    
                    dp[i][j] = distance;
                }
            }
        }
        
        
        
        for(int idx = 2; idx < N; idx++){
            for(int i = 0; i < cows[idx].size(); i++){
                for(int j = 0; j < cows[idx-1].size(); j++){
                    ld pre_cost = dp[idx-1][j];
                    
                    auto [cy, cx] = cows[idx][i];
                    auto [py, px] = cows[idx-1][j];
                    
                    ld distance = sqrtl((cy - py) * (cy - py) + (cx - px) * (cx - px));
                    
                    dp[idx][i] = min(dp[idx][i], pre_cost + distance);
                }
            }
        }
        
        for(int i = 0; i < cows[N-1].size(); i++){
            ld current = dp[N-1][i];
            
            auto [cy, cx] = cows[N-1][i];
            auto [py, px] = cows[0][first];
            ld distance = sqrtl((cy - py) * (cy - py) + (cx - px) * (cx - px));
            
            result = min(result, current + distance);
        }
    }
    
    
    
    cout << (ll)(result * 100);

    return 0;
}

</details>

[BOJ] 수열 재배열

Thu, 06 Mar 2025 00:00:00 GMT

수열 재배열

TimeLimit	MemoryLimit	Condition	TAG
2s	512MB	(3 ≤ N ≤ 2000, 2 ≤ K ≤ N)	BruteForce

내가 연속된 구간 k개를 고르고 앞만 이어진다. 뒤만 이어진다. 앞뒤만 이어진다. 아니면 나만 보겠다... 이것만 고려해서 나눠서 풀면 되겠스비다.

이것도 학교에서 풀어서 영상은 없네용

#include <iostream>
#include <vector>
#include <algorithm>
#include<set>
using namespace std;
int inf = 1e9;


int solution(int n, int k, vector<int>& nums){
    
    
    // 그냥 나뒀을 때.. 는 이미 정렬할 대 되는거니까ㅏ상관 x
    // 내가 장렬됨에 따라서 뒤와 앞이 이어지는경우
    // 내가 정렬됨에 따라서 앞에를 버리고 뒤랑만 이어지는 경우
    // 내가 정렬됨에 따라서 뒤를 버리고 앞만 이어지는경우
    
    // 중복된거를 (length - 중복 개수)
    
    vector<int> origin(n), reverse(n);
    
    
    int result = 1;
    
    
    
    origin[0] = 1;
    reverse[n-1] = 1;
    
    for(int i = 1; i < n; i++){
        if(nums[i] <= nums[i-1]){
            
            origin[i] = 1;
        }else{
            origin[i] = origin[i-1]+1;
            result = max(origin[i], result);
        }
    }
    
    
    
    
    for(int i = n-2; i > -1; i--){
        if(nums[i+1] <= nums[i]) reverse[i] = 1;
        else reverse[i] = reverse[i+1]+1;
        
    }
    

    
    
    set<int> current_set;
    
    int start, end;
    for(int i = 0; i <= n-k; i++){
        current_set.clear();
        
        for(int j = 0; j < k; j++) current_set.insert(nums[j+i]);
        
        vector<int> current(current_set.begin(), current_set.end()); // 보통 정렬돼서 나오는 것처럼 보임..
        sort(current.begin(), current.end()); // 그래도 불안해
        
        
        // 앞뒤 이어지는 경우
        if(current.size() == k && i > 0 && i < n-k){
            start = 0;
            end = current.size()-1;
            if(current[start] > nums[i-1] && current[end] < nums[i+k]) result = max(result, end - start + 1 + origin[i-1] + reverse[i+k]);
        }

        // 앞만 이어지는 경우 | 앞 <- current -> 뒤
        if(i > 0){
            start = 0;
            while(start < current.size()-1 && current[start] <= nums[i-1]) start++;
            
            
            if(current[start] > nums[i-1]) result = max(result, origin[i-1] + (int) current.size() - start);
        }

        // 뒤만 이어지는 경우
        if(i < n-k){
            end = current.size()-1;
            while(0 < end && current[end] >= nums[i+k]) end--;
            
            if(current[end] < nums[i+k]) result = max(result, reverse[i+k] + end + 1);
        }

        result = max(result, (int)current_set.size());

        
    }
    
    return result;
}


int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    
    int answer;
    int n, k;
    cin >> n >> k;
    
    
    vector<int> nums(n);
    for(int i = 0; i < n; i++) cin >> nums[i];
    
    int result = solution(n, k, nums);
    cout << result;
    /*
     10 3
     1 8 2 4 8 5 1 8 9 3
     5 4
     
     */
    return 0;
}

</details>

[BOJ] 괄호 제거

Thu, 06 Nov 2025 00:00:00 GMT

괄호 제거

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(1 <= 괄호 개수 <= 10)	Implementation

오랜만에 문제를 풀기 때문에 가벼운 문제 입니다. ㅠ



#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
#include <numeric>
#include <unordered_set>
#include <unordered_map>
#include <climits>
#include <math.h>
using namespace std;
using ll = long long;
using ld = long double;
ll MOD = 1'000'000'000;

set<string> results;

string input;



set<int> visited;



void solution(int left){
    if(left >= input.size()) return;
    
    if(input[left] == '('){
        int right_idx = input.size()-1;
        visited.insert(left);
        int cnt = 1;
        for(int i = left+1; i < input.size(); i++){
            if(input[i] == ')') cnt--;
            else if(input[i] == '(') cnt++;
        
            if(cnt == 0){
                right_idx = i;
                break;
            }
        }
        visited.insert(right_idx);
        solution(left+1);
        
        
        string result = "";
        for(int i = 0; i < input.size(); i++){
            if(visited.find(i) == visited.end())
                result += input[i];
        }
        results.insert(result);
        
        visited.erase(left);
        visited.erase(right_idx);
        
        
        solution(left+1);
    }
    else{
        solution(left+1);
    }
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> input;
    
    
    solution(0);
    
    
    
    
    
    for(string result : results) cout << result << "\n";
   
        
        
    
    
    return 0;
}

</details>

[BOJ] 자리 전쟁

Sat, 29 Mar 2025 00:00:00 GMT

자리 전쟁

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(1 ≤ R, C ≤ 100)	Greedy

일단 생각보다 고려할게 많았던 문제였습니다.

한 관점에서만 가까운 것을 고르는 것은 문제가 있고, 전부 고려해서 제일 작은 것들을 미리 처리하고를 반복해서 없애는 방식을 채택했고, 처음에는 이거를 그냥 단순 visited 처리로 for문 돌렸는데 O((r*c)^3) 이정도 나오는 것을 보고서 음.. 안되겠군 하고서 그냥 처음에 생각했던 방법으로 접근했습니다. 그런데 이 과정에서 굉장히 많은 오류가 있고,,... 그냥 하던 코드 유지해야지.. 이러다가 시간을 날려 먹은 것 같네요.. 여러분ㄴ들은 꼭 아닌거 같다 싶으면 다시 짜보시길...

그러면 보통 금방 풀리더라구요

#include <iostream>
#include <vector>
#include <queue>
#include <tuple>
using namespace std;
using ll = long long;
int r, c;

char board[101][101];
bool peopleVisited[10001];
int chairCount[10001];

ll getMinDistance(pair<int, int> a, pair<int, int> b){
    return (a.first - b.first) * (a.first - b.first) + (a.second - b.second) * (a.second - b.second);
}

void calculateWarfield(const vector<int>& chairIndices, int& result) {
    for(int idx : chairIndices) {
        chairCount[idx]++;
        if(chairCount[idx] == 2) {
            result++;
        }
    }
}

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> r >> c;
    
    vector<pair<int, int>> chairs, people;
    for(int i = 0; i < r; i++){
        for(int j = 0; j < c; j++){
            cin >> board[i][j];
            if(board[i][j] == 'X') people.push_back({i, j});
            else if(board[i][j] == 'L') chairs.push_back({i, j});
        }
    }

    priority_queue<tuple<ll, int, int>, vector<tuple<ll, int, int>>, greater<tuple<ll, int, int>>> pq;
    
    for(int i = 0; i < people.size(); i++){
        for(int j = 0; j < chairs.size(); j++){
            ll dist = getMinDistance(people[i], chairs[j]);
            pq.push({dist, i, j});
        }
    }

    int result = 0;
    vector<int> currentChairIndices;
    ll currentDist = -1;

    while(!pq.empty()){
        auto [dist, personIdx, chairIdx] = pq.top();
        pq.pop();
        
        if(dist != currentDist){
            if(!currentChairIndices.empty()){
                calculateWarfield(currentChairIndices, result);
                currentChairIndices.clear();
            }
            currentDist = dist;
        }
        
        if(peopleVisited[personIdx] || chairCount[chairIdx] > 0) continue;
        
        currentChairIndices.push_back(chairIdx);
        peopleVisited[personIdx] = true;
    }
    
    if(!currentChairIndices.empty()) calculateWarfield(currentChairIndices, result);
    
    
    cout << result;
    
    return 0;
}

</details>

[BOJ] DDR 체력 관리

Mon, 16 Jun 2025 00:00:00 GMT

DDR 체력 관리

TimeLimit	MemoryLimit	Condition	TAG
1s	1024MB	(1 ≤ N ≤ 1000, 1 ≤ K ≤ 10, 1 ≤ sᵢ ≤ 1000, 1 ≤ hᵢ ≤ 100	Dynamic Programming

이것도 간단한 dp 문제로 그냥 dp[i][j]가 있을 때 i번째 게임을 할 때, j번째 체력인 경우로 나눠서 정의하고 상태 전이를 해버리면 쉽게 풀리는데 문제가 원하는 순서와 조건에 잘 맞춰야되기 때문에 이상한 곳에서 틀릴 수 있으니 조심하십셔.


    #include <iostream>
    #include <queue>
    #include <set>
    #include <algorithm>
    #include <random>

    #define mod 1000000007LL
    #define MAX 1'000'000LL
    using namespace std;
    using ll = long long;

    ll n;

    ll dp[2001][101]; // dp[i][j] 일 때, i번째 game에서 hp가 j일 때의 점수
    ll uk;
    pair<ll, ll> games[2001];

    int main(){
        cin >> n >> uk;
        ll result = 0;
        
        for(int i = 1; i <= n; i++) cin >> games[i].first; // score
        for(int i = 1; i <= n; i++){
            cin >> games[i].second; // health
            
            
        }
        for(int i = 0; i <= n; i++){
            for(int j = 0; j < 101; j++){
                dp[i][j] = -1;
            }
        }
        
        
        
        
    //
    //    for(int i = 1; i < n; i++){
    //        for(int j = i+1; j <= n; j++){
    //            for(int k = 1; k < 101; k++){
    //
    //                dp[j][min(k+(uk* (j - i)), 100LL)] = max(dp[i][k], dp[j][min(k+(uk* (j - i)), 100LL)]);
    //                if(!dp[i][k] || k+(uk* (j - i)) - games[j].second < 0) continue;
    //                ll ch = min(100LL, k+(uk* (j - i)) - games[j].second);
    //                dp[j][ch] = max(dp[i][k] + games[j].first, dp[j][ch]);
    //                result= max(dp[j][ch], result);
    //            }
    //        }
    //    }
        dp[0][100] = 0;
        for(int i = 0; i < n; i++){
            for(int j = 0; j <= 100; j++){
                if(dp[i][j] == -1) continue;
                ll ch = min(j+uk, 100LL);
                dp[i+1][ch] = max(dp[i+1][ch], dp[i][j]);
                if(ch - games[i+1].second >= 0){
                    dp[i+1][ch - games[i+1].second] = max(dp[i+1][ch - games[i+1].second], dp[i][j] + games[i+1].first);
                    result = max(result, dp[i+1][ch - games[i+1].second]);
                }
//                cout << dp[i+1][ch] << " " << ch << "  " << i+1 << "\n";
                result = max(result, dp[i+1][min(j+uk, 100LL)]);
            }
        }

        cout << result;
        
        return 0;
    }
    /*
     2 0
     1 2
     99 1
     
     1 5
     1
     100
     */

</details>

[BOJ] 오아시스 재결합

Fri, 21 Feb 2025 00:00:00 GMT

오아시스 재결합

TimeLimit	MemoryLimit	Condition	TAG
1s	256MB	(1 ≤ N ≤ 500,000)	Stack

이 문제는 저번에 얘기했던 모노톤 스택을 좀 더 활용한 문제로 볼 수 있습니다.

저는 같은 값들을 가진 값들에 대해서 압축시키는 형식으로 처리를 했는데요. 더욱 모노톤 스택에 가깝게 풀이를 하려면 Binary search를 활용하는 방법도 가능할 것 같습니다.

단조성을 활용하다 보니 자연스럽게 정렬이 되구요. 이를 이용해서 이분 탐색을 돌릴 수 있고, 그러면 시간 안에 무조건 돌아가도록 만들 수 있습니다.

하튼 이문제도 여러 방법으로 풀 수 있기도 하고, 좋은 문제인 것 같습니다.

#include <iostream>
#include <string>
#include <vector>
using namespace std;
using ll = long long;

vector<int> s;
vector<int> cnt;
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    ll result = 0;
    
    int n;
    cin >> n;
    
    int current;
    while(n-->0){
        cin >> current;
        
        if(s.empty()){
            s.push_back(current);
            cnt.push_back(1);
            continue;
        }
        
        
        int p = 1;
        if(s.back() < current){
            
            while(!s.empty() && s.back() < current){
                s.pop_back();
                
                p+=cnt.back();
                cnt.pop_back();
            }
            p -= s.empty();
        }
        
        if(!s.empty() && s.back() == current){
            p+= cnt.back() - (cnt.size() == 1);
             
            cnt.back()++;
            s.pop_back();
        }else{
            cnt.push_back(1);
        }
        s.push_back(current);
        result += p;
        

    }

    cout << result;

    return 0;
}

</details>

[BOJ] ChatGPT의 역작

Thu, 02 Oct 2025 00:00:00 GMT

ChatGPT의 역작

TimeLimit	MemoryLimit	Condition	TAG
1s	1024MB	(1 ≤ N ≤ 200,000, 1 ≤ L_i, R_i ≤ 10^18)	Parametric Search, Binary Search

문제가 그냥 엄청 어렵게 느껴졌습니다. 처음에는 함수를 분석해서 해보려고 했는데, 들어오는 배열 L, R에 대해서 그냥 엄청 바뀌어버리고 뭔 규칙도 없고 사실상 다른 방법으로 풀어야하는데 범위 때문에 이분탐색을 돌려볼까? 생각을 하게 되었어요. 사실 단조성 자체가 없어서 이게 왜 될까 라는 생각 때문에 코드도 못 짜고 있어서, 일단 짜고 내본다음에 다른 방법 생각하자 해서 작성해서 냈더니? %가 많이 올라가더라구요? 그래서 다행히 풀었습니다.

나중에 아이디어 보니까 뭐 제 코드에서도 그렇게 작성하긴 했지만, 무조건 성립하는 뭔가가 있답니다. 허허 신기하네요...

조금 더 설명을 정확히 해보면, 함수에서 x=0일 때는 무조건 False, x=10^18+1은 무조건 True가 나오기 때문에 그 사이에 값은 무조건 교차할 것이다 생각하고 풀어야하는.. 하튼 디지게 어려웠던 문제였습니다. 발상 자체가 힘들었어요..

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
#include <numeric>
#include <unordered_set>
#include <unordered_map>
#include <climits>
using namespace std;
using ll = unsigned long long;
//ll MOD = 1'000'000'007;
ll MOD = 1.8446744074E19;

ll N;

ll L[200'001], R[200'001];


bool func(ll x){
    ll value = x;
    for(int i = 0; i < N; i++){
        ll l = L[i];
        ll r = R[i];
        if(l <= x && x <= r) value^=(((x|l)+(x&r)*(l^r)) % MOD);
    }
    return (value >= 0x0123456789ABCDEF);
}

void solution(){
    ll left = 0;
    ll right = 1E18;
    
    bool left_value = func(left);
    bool right_value = func(right);
    
    while(left <= right){
        ll pivot = (left + right) / 2;
        
        bool pivot_value = func(pivot);
        
        if(!pivot_value && func(pivot + 1)){
            cout << pivot;
            return;
        }
        
        
        if(!left_value && pivot_value){
            right = pivot;
            right_value = pivot_value;
        }else if(!pivot_value && right_value){
            left=pivot;
            left_value = pivot_value;
        }else{
            left=pivot+1;
            left_value = func(pivot+1);
        }
    
    }
    
    cout << -1;
    return;
}

int main() {
    
    cin >> N;
    for(int i = 0; i < N; i++) cin >> L[i];
    for(int i = 0; i < N; i++) cin >> R[i];
    
    solution();
    cout << "\n";
    
    return 0;
}

</details>

[BOJ] 사격

Fri, 04 Oct 2024 00:00:00 GMT

사격

TimeLimit	MemoryLimit	Condition	TAG
1s	1024MB	(1<=N, M, Sᵢ <= 10⁵,1<=A<=10¹⁰)	binary search

성현이네 부대의 24-1분기 사격 훈련이 시작되었다! 성현이네 부대의 사격 훈련장에는 $N$개의 표적이 있으며, 그중 $i$번째 표적의 점수는 $s_i$이다. 점수가 $s_i$인 표적을 맞히기 위해선 사격 실력이 최소 $s_i$ 이상이어야 한다. 만약 해당 표적을 성공적으로 맞혔다면, 표적의 점수만큼 사격 점수를 획득하며 사격 실력도 동일한 만큼 증가한다. 이번 사격 훈련에서는 최대 $M$번 사격할 수 있으며, 성현이가 진급에 성공하기 위해서는 획득한 사격 점수의 총합이 $A$점 이상이어야 한다. 사격 훈련을 시작하기 전 초기 사격 점수는 $0$점이다. 성현이는 항상 자신이 맞힐 수 있는 표적 중 얻을 수 있는 사격 점수가 가장 높은 표적을 맞히며, 동일한 표적을 여러 번 맞히는 것도 가능하다. 진급이 절실했던 성현이는 사격 훈련이 시작하기 전 초기 사격 실력이 어느 정도여야 진급에 성공할 수 있을지 궁금해하고 있다. 성현이를 위해, 진급에 성공하기 위한 초기 사격 실력의 최솟값을 구해주자. 항상 진급에 성공할 수 있는 경우만 입력으로 주어진다.

우리는 문제를 보는 순간 아! 라고 외치지 않을까 한다.

느므느므 큰 범위를 보고, 값을 찾는 문제여서 바로 이분탐색으로 접근하였다.

(나중에 더욱 자세히 쓸 예정...)

#define MAX 2'100'000'000
#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <math.h>
#include <random>
using namespace std;

using ull = unsigned long long;
using ll = long long;
int score[100001];
ull n, m, a;
bool visited[100001];
bool debug_ = false;
ull current_ = 0;
ull binary_search_(ull current, int depth){
    if(depth >= m|| current >= a) return current;
    int left = 0, right = n-1;
    current += current_;
    int val = -1;

    while(left < right ){
        int pivot = (left+ right) / 2;
        if(score[pivot] < current){
            if(pivot+1 < n && score[pivot+1] > current){
                val = score[pivot];
                break;
            }
            left = pivot+1;
            
            if(left < 0 || score[left] > current) continue;
            val = max(val, score[left]);
        }
        else if(score[pivot] > current){
            right = pivot - 1;
            if(right < 0|| score[right] > current) continue;
            val = max(val, score[right]);
        }
        else {val = score[pivot]; break;}

    }


    if(val == -1) val = score[left];
    if(val > current) return 0;
    current-=current_;
    ull result = binary_search_(current + val, depth+1);
    return result;
}

int main(){
    
    cin >> n >> m >> a;
    int limit = 0;
    for(int i = 0; i < n; i++){ cin >> score[i]; limit = max(limit, score[i]);}
    sort(score, score+n);
    if(n == 1){
        cout << score[0];
        return 0;
    }
    
    int left = 1, right = limit;
    ull result = MAX;
    while(left <= right){
        current_ = (left + right) / 2;
        ull tmp = binary_search_(0, 0);
        if(tmp >= a){
            result = min(current_, result);
            right = current_-1;
        }else{
            left = current_+1;
        }
    }
    cout << result;
    return 0;
}

</details>

[BOJ] 당근 게임

Sat, 08 Mar 2025 00:00:00 GMT

당근 게임

TimeLimit	MemoryLimit	Condition	TAG
2s	1024MB	(1 ≤ N, K ≤ 100, 1 ≤ A_i, B_i ≤ 50)	DynamicProgramming

일단 전형적인 dp문제고 아이디어도 기본적인 예제에서 많이 볼 수 있는 유형이여서 재밌게 풀었던 것 같습니다.

#include <iostream>
#include <queue>
#include <algorithm>
#include<set>
#include <map>
using namespace std;
using ll = long long;

int inf = 1e9;
int n, k_;

int dp[101][5005]; // dp[i][j] -> i초 일대 j만큼의 s인 상태에서 가지고 있는 당근의 수

pair<int, int> upgrades[101]; // {i, j} i만큼 지불해서 +j 만큼 더 얻을 수 있음

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> n >> k_;
    
    
    for(int i = 1; i <= n; i++){
        int a, b;
        
        cin >> a >> b;
        upgrades[i] = {a, b};
    }

    for(int i = 0; i <= k_; i++){
        for(int j = 0; j < 5005; j++) dp[i][j] = -1;
    }
    
    
    dp[0][1] = 0;
    
    for(int i = 0; i < k_; i++){
        
        for(int j = 1; j < 5005; j++){
            
            if(dp[i][j] == -1) continue;
            
            for(int k = 1; k <= n; k++){
                auto [a, b] = upgrades[k];
                
                
                if(dp[i][j] < a) continue;
                
                dp[i+1][j+b] = max(dp[i][j] - a, dp[i+1][j+b]);
            }
            
            dp[i+1][j] = max(dp[i][j] + j, dp[i+1][j]);
        }
        
    }
    
    int result = 0;
    for(int j = 1; j < 5005; j++) result = max(dp[k_][j], result);
    
    cout << result;
    
    return 0;
}

</details>

[BOJ] 두 배

Sat, 12 Oct 2024 00:00:00 GMT

두 배

TimeLimit	MemoryLimit	Condition	TAG
1s	1024MB	(1<=N <= 250000, 1 <= A_i <= 1000000)	Math(수학)

<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"> <mtext>길이 </mtext> <mi>N</mi> <mtext>인 양의 정수열 </mtext> <msub><mi>A</mi><mn>1</mn></msub> <mo>,</mo> <mo>…</mo> <mo>,</mo> <msub><mi>A</mi><mi>N</mi></msub> <mtext>이 주어진다. 이 수열을 오름차순으로 만들려 한다. 수열 </mtext> <msub><mi>A</mi><mn>1</mn></msub> <mo>,</mo> <mo>…</mo> <mo>,</mo> <msub><mi>A</mi><mi>N</mi></msub> <mtext>이 오름차순이라는 것은, </mtext> <mrow> <mo>∀</mo> <mi>i</mi> <mo>(</mo> <mn>1</mn> <mo>≤</mo> <mi>i</mi> <mo>≤</mo> <mi>N</mi> <mo>-</mo> <mn>1</mn> <mo>)</mo> </mrow> <mtext>에 대해 </mtext> <msub><mi>A</mi><mi>i</mi></msub> <mo>≤</mo> <msub><mi>A</mi><mrow><mi>i</mi><mo>+</mo><mn>1</mn></mrow></msub> <mtext>이라는 것이다.</mtext> </math>

<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"> <mtext>수열 </mtext> <mi>A</mi> <mtext>를 오름차순으로 만들기 위해, 수열 </mtext> <mi>A</mi> <mtext>에 다음 연산을 몇 번이든 반복해서 적용할 수 있다.</mtext> </math>

<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"> <mtext>• 어떤 </mtext> <mi>i</mi> <mtext> </mtext> <mo>(</mo> <mn>1</mn> <mo>≤</mo> <mi>i</mi> <mo>≤</mo> <mi>N</mi> <mo>)</mo> <mtext>에 대해 </mtext> <msub><mi>A</mi><mi>i</mi></msub> <mtext>에 2를 곱한다.</mtext> </math>

<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"> <mtext>연산을 최소 횟수로 적용해서 </mtext> <mi>A</mi> <mtext>를 오름차순으로 만들고 싶다. 이때, 최소 횟수를 구하라.</mtext> </math>

저는 처음 접근할 때, 범위를 제대로 보지 않고서 접근하다가 아예 이분탐색을 돌려버렸습니다. 그러다가 진짜 왜 틀린지 모르고 있다가 범위를 알고나서 부터 이분 탐색이라는 방법말고 다른 방법을 떠오르게 되었어요.

이제 그 아이디어에 대해서 말해보겠습니다.

일단 정의부터 시작하여 아이디어의 기초적인 기반을 다져봅시다. <math xmlns="http://www.w3.org/1998/Math/MathML"> <mtext>Let </mtext> <msub><mi>N</mi><mi>i</mi></msub> <mo>=</mo> <mi>A</mi> <mtext> and </mtext> <msub><mi>N</mi><mrow><mi>i</mi><mo>+</mo><mn>1</mn></mrow></msub> <mo>=</mo> <mi>B</mi> </math> -> then <math xmlns="http://www.w3.org/1998/Math/MathML"> <msub><mi>N</mi><mi>i</mi></msub> <mo>⋅</mo> <msup><mn>2</mn><mi>x</mi></msup> <mo>≤</mo> <msub><mi>N</mi><mrow><mi>i</mi><mo>+</mo><mn>1</mn></mrow></msub> <mo>⋅</mo> <msup><mn>2</mn><mi>y</mi></msup> </math> -> <math xmlns="http://www.w3.org/1998/Math/MathML"> <mfrac> <mrow> <msub><mi>N</mi><mi>i</mi></msub> <mo>⋅</mo> <msup><mn>2</mn><mi>x</mi></msup> </mrow> <mrow> <msub><mi>N</mi><mrow><mi>i</mi><mo>+</mo><mn>1</mn></mrow></msub> </mrow> </mfrac> <mo>≤</mo> <msup><mn>2</mn><mi>y</mi></msup> </math> -> <math xmlns="http://www.w3.org/1998/Math/MathML"> <mi>x</mi> <mo>+</mo> <msub><mi>log</mi><mn>2</mn></msub> <mo>(</mo> <msub><mi>N</mi><mi>i</mi></msub> <mo>)</mo> <mo>-</mo> <msub><mi>log</mi><mn>2</mn></msub> <mo>(</mo> <msub><mi>N</mi><mrow><mi>i</mi><mo>+</mo><mn>1</mn></mrow></msub> <mo>)</mo> <mo>≤</mo> <mi>y</mi> </math> -> <math xmlns="http://www.w3.org/1998/Math/MathML"> <mi>x</mi> <mo>+</mo> <mfrac> <mrow> <msub><mi>log</mi><mn>2</mn></msub> <mo>(</mo> <msub><mi>N</mi><mi>i</mi></msub> <mo>)</mo> </mrow> <mrow> <msub><mi>log</mi><mn>2</mn></msub> <mo>(</mo> <msub><mi>N</mi><mrow><mi>i</mi><mo>+</mo><mn>1</mn></mrow></msub> <mo>)</mo> </mrow> </mfrac> <mo>≤</mo> <mi>y</mi> </math> -> <math xmlns="http://www.w3.org/1998/Math/MathML"> <mi>y</mi> <mo>=</mo> <mo>⌈</mo> <mi>x</mi> <mo>+</mo> <mfrac> <mrow> <msub><mi>log</mi><mn>2</mn></msub> <mo>(</mo> <msub><mi>N</mi><mi>i</mi></msub> <mo>)</mo> </mrow> <mrow> <msub><mi>log</mi><mn>2</mn></msub> <mo>(</mo> <msub><mi>N</mi><mrow><mi>i</mi><mo>+</mo><mn>1</mn></mrow></msub> <mo>)</mo> </mrow> </mfrac> <mo>⌉</mo> </math>

지금 여기서 ceil(올림)이 사용되는 이유는 나눴을 때, x.n(x>=0인 정수, n!=0)이 나오는 꼴이면 최소 곱을 알고 싶기 때문에 이것보다 더 크다면 우리는 x보다 크고 최대한 작은 값을 고르면 된다. 그래서 올림을 통해서 이를 해결한다.

이것을 통해서 알 수 있는 것은 이건 오류가 발생할 가능성이 존재한다는 것이다. (저는 코드짜서 넣고 그 다음에 블로그 쓰면서 생각해보니 이렇더라구요.... 완벽한 코드는 아닌 것 같아 남깁니다..)

#include <iostream>
#include <cmath>
using namespace std;
using ll = unsigned long long;
int n;
int board[250'001];
int results[250'001];
int solution(int current){
    return max((int)(log2((double)board[current-1] / (double)board[current]) + (double)results[current - 1]), 0);//board[current-1])
}

int main(){
    // i번까지 모든 조건이 만족한다고 하면, i+1번은 i번보다 크다 2를 곱하는 과정을 반복문으로 하는 것이 아니라 바로 몇 번 곱해야 하는지 알 수 있는 방법을
    // 찾아보자 -> 그냥 수학으로 풀어야하는 거다!
    
    // N_i를 A라고 하자. N_{i+1}을 B라고 하자.
    // N_i * 2^x <= N_{i+1} * 2^y
    // (N_i*2^x)/N_{i+1} <= 2^y
    
    // 저기 y를 어떻게 내리냐 log 씌우면 될라나
    // (x + log_2(N_i)/log_2(N_{i+1}) <= y
    // 옹 나왔따! 근데 정답이 integer데 어떻게 나오냐
    // 아 그거구나
    // 그냥 올림처리하면 될라나
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    int n;
    cin >> n;

    for(int i = 0; i < n; i++) cin >> board[i];
    
    ll result = 0;
    for(int i = 1; i < n; i++) {
        results[i] = solution(i); result += results[i];
//        cout << results[i] << " ";
    }
//    cout << "\n";
    
    
    cout << result;
    return 0;
}

</details>

[BOJ] 백조의 호수

Tue, 05 Nov 2024 00:00:00 GMT

백조의 호수

TimeLimit	MemoryLimit	Condition	TAG
1s	256MB	(1<= R, C <= 1500)	BFS(너비우선탐색), Implementation(구현)

두 마리의 백조가 호수에서 살고 있었다. 그렇지만 두 마리는 호수를 덮고 있는 빙판으로 만나지 못한다.

호수는 행이 R개, 열이 C개인 직사각형 모양이다. 어떤 칸은 얼음으로 덮여있다.

호수는 차례로 녹는데, 매일 물 공간과 접촉한 모든 빙판 공간은 녹는다. 두 개의 공간이 접촉하려면 가로나 세로로 닿아 있는 것만 (대각선은 고려하지 않는다) 생각한다.

아래에는 세 가지 예가 있다.

<code>...XXXXXX..XX.XXX ....XXXX.......XX .....XX.......... ....XXXXXXXXX.XXX .....XXXX..X..... ......X.......... ...XXXXXXXXXXXX.. ....XXX..XXXX.... .....X.....X..... ..XXXXX..XXXXXX.. ...XXX....XXXX... ....X......XX.... .XXXXXX..XXXXXX.. ..XXXX....XXXX... ...XX......XX.... XXXXXXX...XXXX... ..XXXX.....XX.... ....X............ ..XXXXX...XXX.... ....XX.....X..... ................. ....XXXXX.XXX.... .....XX....X..... .................</code>

처음 첫째 날 둘째 날 백조는 오직 물 공간에서 세로나 가로로만(대각선은 제외한다) 움직일 수 있다.

며칠이 지나야 백조들이 만날 수 있는 지 계산하는 프로그램을 작성하시오.

처음은 되게 간단하게 bfs 한번만 돌려서, 대충 계산으로 해결하려고 했다가 군데 군데 뚫려있는 '.'이 있으면 성립이 안되는 경우가 발생

노선을 틀어서 먼저 각 빙하마다 시간이 얼마나 지나야 녹는지를 선행적으로 구함. 이후에 여기에서 BFS를 전체적으로 돌면서 백조와 백조끼리의 제일 빠르게 갈 수 있는 cost를 탐색하고 반환한다.

이러한 로직을 따랐습니다.

모두 즐거운 PS 되세요!!

다른 분들이 하시는거 보면 엄청 간단하고 효율적으로 풀이하셨던데... ㄷㄷ

아직도 제 실력이 많이 부족한가 봅니다.

더 열심히 해야겠습니다.

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

int r, c;

char board[1501][1501];
int visited[1501][1501];
int visited_[1501][1501];

const int MAX = 1000000007;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};

struct pos{
    int cost;
    int y, x;
};

struct compare {
    bool operator()(const pos& p1, const pos& p2) {
        return p1.cost > p2.cost;
    }
};

void solution(){
    queue<pos> q;
    for(int i = 0; i < r; i ++){
        for(int j = 0; j < c; j++){
            if(board[i][j] != 'X') q.push({0, i, j});
        }
    }
    
    while(!q.empty()){
        auto [cost, y, x] = q.front(); q.pop();
        
        if(visited[y][x] <= cost) continue;
        visited[y][x] = cost;
        
        
        for(int i = 0; i < 4; i++){
            int ny = y + dy[i], nx = x + dx[i];
            if(0 <= ny && ny < r && 0 <= nx && nx < c && visited[ny][nx] > cost+(board[ny][nx] == 'X')){
                if(board[ny][nx] != 'X') q.push({0, ny, nx});
                else q.push({cost+(board[ny][nx] == 'X'), ny, nx});
            }
        }
    }
}

int main(){
    cin >> r >> c;
    priority_queue<pos, vector<pos>, compare> q;
    pair<int, int> target;

    for(int i = 0; i < r; i++){
        for(int j = 0; j < c; j++){
            cin >> board[i][j];
            if(board[i][j] == 'L'){
                if(q.empty()) q.push({0, i, j});
                else target = {i, j};
            }
            visited[i][j] = MAX;
            visited_[i][j] = MAX;
        }
    }
    
    solution();
    while(!q.empty()){
        auto [cost, y, x] = q.top(); q.pop();
        if(visited_[y][x] <= cost) continue;
        visited_[y][x] = cost;
        cost = max(visited[y][x], cost);
        
        for(int i = 0; i < 4; i++){
            int ny = y + dy[i], nx = x + dx[i];
            if(0 <= ny && ny < r && 0 <= nx && nx < c && visited_[ny][nx] > cost){
                q.push({cost, ny, nx});
            }
        }
        
    }
//    
//    
//    for(int i = 0; i < r; i++){
//        for(int j = 0; j < c; j++){
//            cout << visited_[i][j] << " ";
//        }
//        cout << "\n";
//    }
    cout << visited_[target.first][target.second];

    return 0;
}

</details>

[BOJ] 즐거운 회의

Sat, 29 Jun 2024 00:00:00 GMT

즐거운 회의

1번부터 N번까지 N명의 사람들이 시각 t=0에서 t=T까지 진행되는 회의에 참석한다. i번 사람은 시각 t=a_i에 와서 t=b_i에 떠난다. 서로 다른 A번 사람과 B번 사람이 서로 친하면 두 사람이 회의에 참석하는 동안 즐거운 대화를 나눌 수 있다.

사람들이 회의를 오고 떠나는 시각과 어떤 사람들이 서로 친한지 주어진다. 각 시각 t=0.5, t=1.5, ..., t=T-0.5에 즐거운 대화를 나누고 있는 사람들이 총 몇 쌍 있는지 구하여라.

사람들의 쌍을 셀 때, 순서는 고려하지 않는다. 즉, A번 사람과 B번 사람의 쌍은 B번 사람과 A번 사람의 쌍과 같다.

문제가 굉장히 간단하기 때문에 그냥 바로 풀어버렸다.

코드를 보면 바로 이해할 수 있다.

그냥 현재의 시간과 다음 시간 조건만 확인하면 풀이를 할 수 있다. (정말 간단한 로직으로 풀이가 가능하다.)

result = [0] * (t+1)
timetable = {i: () for i in range(n + 1)}

for i in range(n):
    a, b = map(int, input().split())
    limit = b - a
    timetable[i] = (a, b)

for i in range(m):
    a, b = map(int, input().split())

    a -= 1
    b -= 1

    if timetable[b][0] > timetable[a][1] or timetable[a][0] > timetable[b][1]: continue

    if timetable[a][0] > timetable[b][0]: result[timetable[a][0]]+=1
    else: result[timetable[b][0]] += 1

    result[min(timetable[a][1], timetable[b][1])] -= 1

이렇게 단 한번의 루프로 다 돌릴 수 있다.

n, m, t = map(int, input().split())
result = [0] * (t+1)
timetable = {i: () for i in range(n + 1)}

for i in range(n):
    a, b = map(int, input().split())
    limit = b - a
    timetable[i] = (a, b)

for i in range(m):
    a, b = map(int, input().split())

    a -= 1
    b -= 1

    if timetable[b][0] > timetable[a][1] or timetable[a][0] > timetable[b][1]: continue

    if timetable[a][0] > timetable[b][0]: result[timetable[a][0]]+=1
    else: result[timetable[b][0]] += 1

    result[min(timetable[a][1], timetable[b][1])] -= 1


current = 0
for i in range(t):
    current+=result[i]
    print(current)

</details>

[BOJ] Street Development

Wed, 15 Oct 2025 00:00:00 GMT

Street Development

TimeLimit	MemoryLimit	Condition	TAG
1s	2048MB	(1 ≤ N ≤ 10^6)	Binary Search, Greedy, Implementation

아니 문제가 아이디어는 그대로 사용했는데... 제 로직에서 over flow를 예상해서 long long을 사용했지만 또 overflow가 나올 것을 생각하지 못하고 정말 오랫동안 생각했네요.. ㅠㅜㅜㅜ

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
#include <numeric>
#include <unordered_set>
#include <unordered_map>
#include <climits>
#include <math.h>
using namespace std;
using ll = long long;
using ld = long double;
//ll MOD = 1'000'000'007;
ll MOD = 1'000'000'000;
//ll MOD = 1.8446744074E19;

int L, N;
ll robots[1000001];
ll dis[1000001];

// 문제를 너무 대충 봄.
// 그냥 간격 자체를 찾는거롤 하는게 맞는데 뭐... 뭐를 한거지 젠장
bool calculation(ll power){
    ll right = robots[N-1] - power;
    dis[N-1] = right;
    
    // right
    for(int i = N-2; i > -1; i--){
        ll remaining = power;
        if(right > robots[i]) remaining -= (right - robots[i]) * 2;
        
        right = robots[i] - remaining;
        if(right > L) right = L;
        dis[i] = right;
//        cout << i << " " << dis[i] <<"\n";
    }
    
    ll left = robots[0] + power;
    
    if(left >= dis[1]) return true;
    
    for(int i = 1; i < N-1; i++){
        ll remaining = power;
        if(left < robots[i]) remaining -= (robots[i] - left) * 2;
        
        
        left = robots[i] + remaining;
        if(left < 0) left = 0;
//        cout << left << " " << dis[i+1] << "\n";
        if(left >= dis[i+1]) return true;
    }
    
    return false;
}
ll solution(){
    
    ll result = LLONG_MAX;
    
    ll left = 0, right = robots[N-1] + 1;
    
    while(left <= right){
        ll pivot = (left + right) /2;
        
        
        if(calculation(pivot)){
            result = min(result, pivot);
            right = pivot-1;
            
        }
        else left = pivot+1;
    }
    
//    cout << left << " " << right << "\n";
    
    return (result);
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    
    cin >> L >> N;
    
    for(int i = 0; i < N; i++) cin >> robots[i];
    
    cout << solution();
//    cout << calculation(64975);
//    for(int i = L; i > -1; i--){
//        if(calculation(i)) continue;
//        cout << i <<"\n";
//        break;
//    }
    return 0;
}
/*
 20 1
 10
 
 100 5
 
 10000 8
 0 1 3 5 7 11 13 17
 
 100000 3
 10 100 101
 100 5
 10 20 30 40 50
 
 10000 8
 0 1 3 5 7 11 13 17
 
*/

</details>

[BOJ] 재미있는 파이프 퍼즐

Fri, 07 Mar 2025 00:00:00 GMT

재미있는 파이프 퍼즐

TimeLimit	MemoryLimit	Condition	TAG
2s	2048MB	(2 ≤ N ≤ 200000)	GraphTraversal

그냥 탐색을 돌리며 되는 문제였어서 그냥 풀었던 것 같아요

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


int inf = 1e9;

int n;


char board[200'001][2];
bool visited[200'001][2];
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cin >> n;
    
    for(int i = 0; i < n; i++) cin >> board[i][0];
    for(int i = 0; i < n; i++) cin >> board[i][1];
    
    
    queue<pair<bool, int>> q;
    
    q.push({0, 0});
    if(board[0][1] == 'L') q.push({1, 0});
    
    
    
    while(!q.empty() && !visited[n-1][1]){
        auto [y, x] = q.front(); q.pop();
        
        int nx = x+1;
        bool ny = y;
        if(board[nx][y] =='L'){
            ny = !y;
            if(board[nx][ny] == 'I') continue;
        }

        if(0 <= nx && nx < n){
            visited[nx][ny] = true;
            q.push({ny, nx});
        }
        
    }
    

    
    if(visited[n-1][1]) cout << "YES";
    else cout << "NO";
    
    return 0;
}

</details>

[BOJ] 타율 분석

Wed, 18 Jun 2025 00:00:00 GMT

타율 분석

TimeLimit	MemoryLimit	Condition	TAG
1s	1024MB	(0.162 ≤ A ≤ 0.412, 1 ≤ B ≤ 300)	Dynamic Programming, Math

이걸 의도한건진 모르겠지만 그냥 각 상황별 경우의 수를 구해주고 나눠주는 절차를 밟는데 전체 가짓수가 A고 선택하는 수가 n이라고 하면

A!/n!(A - n)!이 되는데 이때 식을 보면 결국 대칭성을 가지고 있음을 바로 알 수 있다. 그래서 그거 이용해서 150까지 팩토리얼 구하고나서 그거 대칭성 이용해서 300까지 얻을 수 있다.

그러고는 그냥 간단한 확률 계산이고 누적해서 더해주면 답을 간단히 구할 수 있다.



#include <iostream>
#include <queue>
#include <set>
#include <algorithm>
#include <random>
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>

#define MOD 1000000007LL
#define MAX 1'000'000LL
using namespace std;
using ll = long long;

double A;
int B;


double fact[301]; // 골랐던 거, 안 골랐던 거
double dp[152];

int main() {
    cin >> A >> B;
    
    double y = A;
    double n = 1 - A;
    double std = 0.05;
    
    fact[0] = 1;
    fact[1] = 1;
    fact[2] = 2;
    fact[3] = 6;
    fact[4] = 24;
    fact[5] = 120;
    
    for(int i = 6; i < B; i++) fact[i] = fact[i-1] * i; // 어차피 내가 구하려는게 대칭성을 띄고 이ㅣㅆ음.
    
    dp[0] = 1;
    for(int i = 1; i < B / 2 + 2; i++) dp[i] = (dp[i-1] * (B - i + 1)) / i;
//    cout << dp[149] << " " << dp[151] << "\n";
    
    double result = 0;
    for(int i = 0; i <= B; i++){
        double ok = pow(y, i);
        double no = pow(n, B - i);
//        cout << ok <<" " << no <<" " << ok * no <<"\n";
        double c;
        if(i > B / 2) c = dp[B *  2 - i] * ok * no;
        else c = (dp[i] * ok * no);
        
//        cout << i << " " << dp[i] << " " << c <<"\n\n";
        result += c;
        if(result >= std) {
            cout << i << "\n";
            break;
        }
    }

    return 0;
}

</details>

[BOJ] So☆Lucky

Tue, 17 Jun 2025 00:00:00 GMT

So☆Lucky

TimeLimit	MemoryLimit	Condition	TAG
1s	1024MB	(0 ≤ N ≤ 200'000, 1 ≤ A_i ≤ 10^9)	Implementation, Math

그냥 간단하게 정렬할면 한쪽으로 밀어버리면 된다. 라는 아이디어로 구현하면 됩니다.

쉽게 풀이가 가능합니다.

#include <iostream>
#include <queue>
#include <set>
#include <algorithm>
#include <random>
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#define MOD 1000000007LL
#define MAX 1'000'000LL
using namespace std;
using ll = long long;

//double A, B;


ll nums[200'001];

int main() {
    ll n;
    cin >> n;
    
    for(int i = 0; i < n; i++) cin >> nums[i];
    
    // first method
    bool check = false;
    ll back = nums[0];
    for(int i = 1; i < n; i++){
        if(nums[i] >= back){
            back = nums[i];
        }else{
            if(!((nums[i]+back) % 2)){
                check = true;
                break;
            }
        }
        
    }
    
    if(check) cout << "Unlucky";
    else cout << "So Lucky";
    cout << "\n";
    // second method
    check = false;
    back = nums[0];
    for(int i = 1; i < n; i++){
        if(nums[i] >= back){
            back = nums[i];
        }else{
            if(((nums[i]+back) % 2)){
                check = true;
                break;
            }
        }
        
    }
    
    if(check) cout << "Unlucky";
    else cout << "So Lucky";
    
    return 0;
}

</details>

[BOJ] 하이터치☆메모리

Tue, 17 Jun 2025 00:00:00 GMT

하이터치☆메모리

TimeLimit	MemoryLimit	Condition	TAG
2s	1024MB	(1 ≤ A, B ≤ 2'000'000)	Implementation

그냥 고능하게 개수 세보면 정답이다.

왼쪽에 있는 A인 경우 왼쪽 열려있는 것보다 오른쪽이 열려있는 상황이 생기면 무조건 필요없는 상황이 생긴다. 왜냐하면 애초에 올바른 괄호가 아니기 때문에 볼 필요도 없다.

이와 같은 논리로 B에도 적용하여 stacked을 이용해서 현재 열려있는 괄호가 있으면 안 보도록 만들고, 아니면 이어 붙여졌을 때의 개수를 더해서 구한다.

문제 자체는 어려운 문제는 아닌데 이게 왜 골드인 느낌이 좀 강하다. 하지만 뭐 조합론 붙어있는걸로 봐서는 수학으로 뭔가 할 수 있을 것 같은데, 현재 내 풀이도 O(N)이여서 그냥 이대로 끝내려고 한다.

#include <iostream>
#include <queue>
#include <set>
#include <algorithm>
#include <random>

#define mod 1000000007LL
#define MAX 1'000'000LL
using namespace std;
using ll = long long;

ll counts[200'001];

int main(){
    
    string A, B;
    
    cin >> A;
    cin >> B;
    ll result = 0;
    ll left_open = 0, right_open = 0;
    ll stacked = 0;
    for(int i = 0; i < A.size(); i++){
        if(A[i] == ')') left_open ++;
        else right_open ++;
        if(right_open - left_open < 0) break;
        counts[right_open - left_open]++;
    }
    
    
    left_open = 0;
    right_open = 0;
    
    for(int i = 0; i < B.size(); i++){
        if(B[i] == ')'){
            left_open ++;
            if(stacked > 0) {
                right_open++;
                stacked--;
            }
        }
        else{
            // right_open ++;
            stacked ++;
        }
        
        if(left_open - right_open < 0 || stacked) continue;
//        cout << left_open << " " << right_open << " " << left_open - right_open << counts[left_open - right_open] << "\n";
        result += counts[left_open - right_open];
    }
    cout << result;
    
    return 0;
}

</details>

[BOJ] 막대 정사각형

Fri, 03 Oct 2025 00:00:00 GMT

막대 정사각형

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(1 ≤ N ≤ 20, 1 ≤ stick_length ≤ 10,000)	Dynamic Programming

약간 날먹 느낌의 dp였구용. 친구가 추천해줘서 풀었는데 그래도 조금 괜찮은 플레 dp 문제였습니다.

어차피 만들어야할 정사각형은 정해져잇으니 그거 targeting해서 문제풀면 쉬웠던 문제였어용.

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
#include <numeric>
#include <unordered_set>
#include <unordered_map>
#include <climits>
using namespace std;
using ll = unsigned long long;
//ll MOD = 1'000'000'007;
ll MOD = 1.8446744074E19;

int T, N;
int sticks[21];


int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> T;
    
    while(T --> 0){
        cin >> N;
        
        int sum = 0;
        for(int i = 0; i < N; i++) {
            cin >> sticks[i];
            sum += sticks[i];
        }
        
        int dp[(1 << N) + 1];
        int length = (1 << N) + 1;
        for(int i = 0; i < length; i++) dp[i] = -1;
        
        
        // visited 를 dp[i]로 처리한다. 즉 뭐를 처리했는가에 대한 dp식으로 간주하고, dp[i]는
        // 그리고 결국 만들 수 있는 최대 정사각형은.. 20 * 20이 최대일 것이다...
        // 그래서 width와 height가 n인 정사각형인 것을 알고서 말하면 될 듯?
        
        if(sum % 4 != 0) {
            cout << "no\n";
            continue;
        }
        
        int target = sum / 4;
        
        
        dp[0] = 0;
        for(int i = 0; i < length; i++){
            if(dp[i] == -1) continue;
            for(int n = 0; n < N; n++){
                if(i & (1 << n)) continue;
                int next = dp[i] + sticks[n];
                if(next <= target) dp[i | (1 << n)] = next % target;
//                dp[i | (1 << n)] =
            }
        }
    
        if(dp[(1 << N)-1] == 0) cout << "yes";
        else cout << "no";
//        cout << dp[(1 << N)-1] << "\n";
        cout << "\n";
        
        
        
        
        
    }
    
    
    
    
    return 0;
}

</details>

[BOJ] HTML 에디터

Wed, 05 Mar 2025 00:00:00 GMT

HTML 에디터

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(0 ≤ B ≤ E ≤ TEXT의 길이, 1 ≤ TEXT의 길이 ≤ 200자)	Implementation

엄... 이거 범위를 +1을 안해서 틀리는 이슈.... 화이팅 다들.. ㅠ

오늘은 학교에서 푼거라서 영상이 없어유

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

using ll = long long;
bool replace(std::string& str, const std::string& from, const std::string& to) {
    size_t start_pos = str.find(from);
    if(start_pos == std::string::npos)
        return false;
    str.replace(start_pos, from.length(), to);
    return true;
}
void solution(int start, int end, string& input){
    
    vector<string> tags;
    
    bool state = false;
    string current = "";
    string result = "";
    for(int i = 1; i < end; i++){
        char c = input[i];
        
        if(c == '<'){
            state = true;
            result+=current;
            current="";
        }else if(c == '>'){
            if(!state){
                current+=c;
                continue;
            }
            
            if(current[0] =='/'){
                if(i < start){
                    replace(result, "<"+tags.back()+">", "");
                    tags.pop_back();
                    current="";
                    state = false;
                    continue;
                }
                
                tags.pop_back();
            }
            else tags.push_back(current);
            
            result += "<"+current +">";
            
            current="";
            state = false;
        } else if(state || (!state && i >= start)) current+=c;
    }
    
    result+= current;
    cout << result;
    
    while(!tags.empty()){
        string tag = tags.back(); tags.pop_back();
        
        cout << "</" << tag << ">";
    }
    
}

int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    int start, end;
    string current;
    
    while(1){
        cin >> start >> end;
        if(start == -1) break;
        
        getline(cin, current);
        
        solution(start+1, end+1, current);
        cout << "\n";
    }

    return 0;
}
// <b></b> <a>a</a> <a></a>
// 7 17 <b></b> <a>a</a> <a></a>

</details>

[BOJ] 숫자 세기

Thu, 05 Jun 2025 00:00:00 GMT

숫자 세기

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(1 ≤ A ≤ B ≤ 108)	Implementation, Math

그냥 0~9까지의 숫자가 현재 자리에서 얼마나 반복되는지 더하는 것을 주어진 A, B에 맞춰서 둘 다 구해주고 빼버리면 그 사이에 있는 값을 알 수 있어요!

#include <iostream>
#include <queue>
#include <set>
#include <algorithm>
#include <random>

#define mod 1000000007LL

using namespace std;
using ll = long long;
int n, m;

vector<ll> solution(ll n) {
    vector<ll> cnt(10, 0);
    if (n < 0) return cnt;
    
    ll place = 1;
    ll lower = 0;
    ll current, higher;
    
    while (n / place > 0) {
        current = (n / place) % 10; // 앞을 본다
        higher = n / (place * 10); // 앞앞을 본다 - 이정도는 무조건 돌아가니까 내가 현재위 factor로 가리키고 있는 현재의 나는 어차피 돌면서 무조건 앞앞의 개수만큼 나오니까 바로 곱해버리기. 근데 잠시만
    // 그러면 매번 올라갈대마다 그 위치의 값을 곱해버리는건데 이게 맞을까?
        // 왜 이게 맞게 나오지 잠시만 뭐지
        // 아니 난 빡대가린가 방금까지 생각하던걸 까먹고 이상한데서 고뇌에 빠지네 ㅂㅅ
        // 아니 당연히 현재 위치가 반복되는 횟수를 곱한건데 어 왜 다 곱하는거지 ㅇㅈㄹ
        // 진자 기억력 요즘 문제 심각하다. 제발 고치자 제발 좀 제발 거의 금붕어 느낌이다
        
        // 변수 이름을 느낌있게 바꾸자
        for (int i = 0; i < 10; i++) {
            cnt[i] += higher * place;
            
            if (i < current) cnt[i] += place;
            else if (i == current) cnt[i] += lower + 1;
            
            if (i == 0) cnt[i] -= place;
        }
        
        lower = n % (place * 10);
        place *= 10;
    }
    
    return cnt;
}

int main() {
    ll A, B;
    
    while (cin >> A >> B) {
        if (A == 0 && B == 0) break;
        vector<ll> cntB = solution(B);
        vector<ll> cntA = solution(A - 1);
        
        for (int i = 0; i < 10; i++) cout << cntB[i] - cntA[i] << " ";
        cout << "\n";
    }
    
    return 0;
}

</details>

[BOJ] 레이저 통신

Thu, 27 Feb 2025 00:00:00 GMT

레이저 통신

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(1 ≤ W, H ≤ 100)	BFS(너비우선탐색)

이거는 어제 풀었던 문제랑 그냥 똑같다고 생각하면 되는데요.. 그래서 짜둔 코드를 안 지워서 그대로 필요한 것들만 빼고 지운 다음에 제출하니까 틀렸습니다... 그래서 음 뭐지? 하고 반례를 다 넣어봤는데 다 정답.. 시간 초과도 아님.. 애초에 무조건 돌아가는 코드라 생각도 안 했는데.. 이게 무슨?

그래서 조금 다시 체계적으로 작성하려고 시간을 좀 씀.. 그랬더니? 정답.. 뭐지? 도대체 왜 이러는거냐 백준

아우.. 이런 것때문에 시간이 소모된게 너무 아까움.. 다들 조심하시고 만약 막히면 그냥 다 지우고 다시 짜세요 그게 답입니다.

하튼 즐거운 ps 되시길

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

struct pos {
    int dir;
    int y, x;
    int cost;
};

int dx[] = {0,1,-1,0,0}, dy[] = {0,0,0,1,-1};
int W, H;
char board[101][101];
int cost[101][101][4];

int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    
    cin >> W >> H;
    pos start = {-1,-1,-1,0}, end;
    bool check = true;
    
    for(int i=0; i<H; i++) for(int j=0; j<W; j++) {
        cin >> board[i][j];
        if(board[i][j] == 'C') {
            if(check) { start = {0,i,j,0}; check = false; }
            else end = {0,i,j,0};
            board[i][j] = '.';
        }
        for(int d=0;d<4;d++) cost[i][j][d] = 1e9;
    }
    
    queue<pos> q;
    q.push({1, start.y, start.x, 0});
    q.push({2, start.y, start.x, 0});
    q.push({3, start.y, start.x, 0});
    q.push({4, start.y, start.x, 0});
    
    
    while(!q.empty()){
        pos cur = q.front(); q.pop();
        
        int y = cur.y, x = cur.x, dir = cur.dir, c = cur.cost;
        
//        cout <<"check!: "<< c << " " << cost[y][x][dir-1] << "\n";
        if(c > cost[y][x][dir-1]) continue;
        
        if(y == end.y && x == end.x) continue;
        
        for(int nd=1; nd<=4; nd++){
            int ny = y + dy[nd];
            int nx = x + dx[nd];
            
            if(ny<0 || nx<0 || ny>=H || nx>=W) continue;
            if(board[ny][nx] == '*') continue;
            
            // 1:동, 2:서, 3:남, 4:북
            if(dir != nd && ((dir<=2 && nd<=2) || (dir>=3 && nd>=3))) continue;
            
            int newCost = c + (dir != nd);
            
            if(cost[ny][nx][nd-1] > newCost){
                cost[ny][nx][nd-1] = newCost;
                q.push({nd, ny, nx, newCost});
            }
        }
    }
    
//    for(int i = 0; i < H; i++){ for(int j = 0; j < W; j++){
//        if(cost[i][j][0] == 1e9) cout << "o ";
//        else cout << cost[i][j][0] << " ";
//    }
//        cout << "\n";
//    }

    
    
    int ans = 1e9;
    for(int d=0; d<4; d++)
        ans = min(ans, cost[end.y][end.x][d]);
    
    cout << ans;
    return 0;
}

</details>

[BOJ] Zombie’s Treasure Chest

Wed, 09 Oct 2024 00:00:00 GMT

Zombie’s Treasure Chest

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(T <= 200, 1 <= N, S1, S2, V1, V2 <= 2³¹-1)	BruteForce(완전탐색), Math(수학)

Some brave warriors come to a lost village. They are very lucky and find a lot of treasures and a big treasure chest, but with angry zombies.

The warriors are so brave that they decide to defeat the zombies and then bring all the treasures back. A brutal long-drawn-out battle lasts from morning to night and the warriors find the zombies are undead and invincible.

Of course, the treasures should not be left here. Unfortunately, the warriors cannot carry all the treasures by the treasure chest due to the limitation of the capacity of the chest. Indeed, there are only two types of treasures: emerald and sapphire. All of the emeralds are equal in size and value, and with infinite quantities. So are sapphires.

Being the priest of the warriors with the magic artifact: computer, and given the size of the chest, the value and size of each types of gem, you should compute the maximum value of treasures our warriors could bring back.

자... 저는 이 문제를 처음에 각 에메랄드, 사파이어에 대해서 두개 다 단위 가치를 계산했습니다. 그런 후에 효율 좋은 친구로 다 채워버리고 남은 공간에 남은 친구 넣을 수 있는 친구를 넣어서 결과를 냈거든용??

6
10 5 999 2 500
9 4 250 2 100
14 13 28 3 3
5 2 2 3 3
7 7 13 2 4
14 11 13 3 1

여기까지는 잘 되더라구요 그래서 딱 내봤더니? 터지구 펑펑펑!

그래서 정말 좀 더 뭘 해볼까 계속해서 고민해보다가 모르겠어서 이 로직 끝에 대충 for문 하나 넣어서 조합을 다 검사했거든용?

당연히 최악의 경우 2^31이라서 절대 불가능하죠...

그래서 좀 더 생각한게.. "범위를 어떻게 줄이지?" 였습니다. 이게 진짜 다행인게.. 다른 곳으로 빠졌으면 진짜 답이 없었거든용..

저는 일단 일단 원래 사용하던 방식을 조금 사용합니다. 그러면 기본적인 아이디어를 나열해 보겠습니다.

일단 내가 선택하는 보석을 다 선택하면 남은 한 개의 보석을 최대한 많이 선택할거에요.(한 개의 보석을 다 얻었는데, 공간이 남았다.. 그러면 다른 보석을 넣을 수 있으면 무조건 최대한 많이 넣는다)
n > s1*s2이면 v1을 s2개 또는 v2를 s1개를 들고온다
- <code>n > s1 * s2</code>이면 넣을 수 있는 공간이 두 보석의 크기를 곱한 것보다 크다는 의미이죠
- 그래서 한 종류의 보석을 다른 보석의 크기만큼 채우는게 가능합니다
- 예를 들자면, v1을 s2개 선택하면 s1 * s2 정도의 공간을 차지하고, 남은 공간은 s2로 최대한 채울 수 있습니다
- 이렇게 되면 두 보석의 조합을 모두 고려해서 최적해를 보장합니다
이제 다른 경우는 sqrt(N) 이하의 경우니까 요걸 bruteforce로 합니다
- N ≤ s1*s2인 경우, s1과 s2 중 적어도 하나는 sqrt(N) 이하입니다
- 그래서 공간을 적게 차지하는 보석을 기준으로 브포를 돌리면 최악이여도 sqrt(N) 정도로 해결 가능합니다

이 아이디어를 그냥 구현하면 됩니다. 아 그리고 구현을 좀 단순화하기 위해서 swap을 통해서 그냥 크기 정렬 해줬습니다

(아니 근데 이 문제 브포 테그 안 달려 있었다니까요?!?!??)

#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;

using ll = long long;
void swap(ll& a, ll& b){
    ll tmp;
    tmp = a;
    a = b;
    b = tmp;
}
ll solution(ll n, ll s1, ll v1, ll s2, ll v2) {
    ll result = 0;
    
    // cout << s1 << " " << s2 << "\n";
    if (s1 > s2) {
        swap(s1, s2);
        swap(v1, v2);
    }
    // cout << s1 << " " << s2 << "\n";
    if (s2 > sqrt(n)) {
        for (ll i = 0; i * s2 <= n; i++) result = max(result, (n - i * s2) / s1 * v1 + i * v2);
        return result;
    }
    if (v1 * s2 > v2 * s1) {
        swap(s1, s2);
        swap(v1, v2);
    }
    for (ll i = 0; i <= s2 && n - s1 * i >= 0; i++) result = max(result, (n - i * s1) / s2 * v2 + i * v1);
    
    return result;
}

int main() {
    int t;
    cin >> t;
    for (int i = 1; i <= t; ++i) {
        ll n, s1, v1, s2, v2;
        cin >> n >> s1 >> v1 >> s2 >> v2;
        cout << "Case #" << i << ": " << solution(n, s1, v1, s2, v2) << endl;
    }
    return 0;
}

</details>

[BOJ] 히스토그램에서 가장 큰 직사각형

Sun, 07 Jul 2024 00:00:00 GMT

히스토그램에서 가장 큰 직사각형

TimeLimit	MemoryLimit	Condition	TAG
1s	256MB	(1<= N <= 100,000<br>0<=h<=1,000,000,000)	Stack(자료구조 스택)

히스토그램은 직사각형 여러 개가 아래쪽으로 정렬되어 있는 도형이다. 각 직사각형은 같은 너비를 가지고 있지만, 높이는 서로 다를 수도 있다. 예를 들어, 왼쪽 그림은 높이가 2, 1, 4, 5, 1, 3, 3이고 너비가 1인 직사각형으로 이루어진 히스토그램이다. 히스토그램에서 가장 넓이가 큰 직사각형을 구하는 프로그램을 작성하시오.

문제는 굉장히 심플한데 대게 이러한 문제들이 걍 어려운것 같다. 처음 이 문제를 접했을 때 사실 잘 감이 안오긴 했다. 그러다 계속 생각해보니까 스택을 풀이를 할 수 있을 것 같다는 생각이 들어서 구현해서 풀었더니 잘 풀렸던 문제였다.

이러한 유형의 스택 문제를 보통 "모노톤 스택"이라고 부르더라... 나는 사실 알고리즘 이름을 알고 다니진 않아서... 하튼 사실 이러한 유형을 처음 본 나로써는 여기까지 구상하는게 쬐끔 어려웠지만 지금와서는 이러한 방법론을 생각해내는게 조금 익숙해진 것 같다.

나는 이런 문제를 추천한다. 연습하기도 생각하기도 좋은 문제이면서 구현도 꽤 교육적인 것처럼 느껴졌다.(적어도 나는)

자 이제 풀이를 해보겠다.

일단 이 문제는 나처럼 코드를 구현하면 단 한번만의 검사로 끝낼 수 있다.

rects = list(map(int, input().split()))
if rects[0] == 0: return -1

요번 포스팅에서는 입력까지 다뤄보겠다. 먼저 현재 상태가 들어왔다. 만약 이 rects[0]이 0이라면 다음 입력이 없기때문에 함수에서 나온다.

 s = []
 n = rects.pop(0)
 result = 0

s는 우리가 사용할 stack이고, n은 바로 현재 그 직사각형의 개수를 나타내기에 빼내준다.

reuslt는 말그대로 정답을 저장할 변수이다.

for i in range(n):
            while s and rects[s[-1]] > rects[i]:
                h = s.pop()  # height
                w = i - s[-1] - 1 if s else i
                result = result if result > w * rects[h] else w * rects[h]
            s.append(i)

정말 놀랍겠지만 아이디어만 나온다면 사실 그렇게 긴 코드도 필요 없는거 같다.

코드를 좀 요약해보겠다.

입력 및 종료 조건 확인

rects = list(map(int, input().split())) : 입력
if rects[0] == 0: return -1 : 종료 조건

스택 초기화 및 첫 번째 값 처리

s = [] : 우리가 쓸 스택 초기화
n = rects.pop(0) : 위에서 설명했죵?
result = 0 : 결과

직사각형 순회하며 스택에 저장 및 넓이 계산

for i in range(n):
while s and rects[s[-1]] > rects[i] : 현재 직사각형 높이가 스택의 마지막 직사각형 높이보다 작을 때, 스택에서 높이를 꺼내 넓이를 계산합니다.(모노톤 스택)
h = s.pop() : 스택 top을 꺼내기
w = i - s[-1] - 1 if s else i : 너비를 계산합니다. 스택이 비어 있으면 i, 비어 있지 않으면 (i - 스택의 마지막 인덱스 - 1)로 계산합니다.
result = result if result > w * rects[h] else w * rects[h] : 넓이를 계산하여 최대 넓이를 갱신
s.append(i) : 현재 자기자신 push

남아 있는 직사각형 처리

while s: : 스택에 남아 있는 직사각형을 모두 처리
h = s.pop()
w = n - s[-1] - 1 if s else n : 너비를 계산
result = result if result > w * rects[h] else w * rects[h] : 최대 넓이를 갱신

이런 과정을 거치면 처리합니다.

사실 이 문제가 너무 잘 알려져있어서 딱히 써야된다는 생각을 안 하고 있었는데, 어떠한 특별한 일 때문에 cpp로 짜게되었는데 다시 이 문제를 보니까 굉장히 교육적인 것 같아서 좀 적게 되었다.

오늘도 happy PS 하세용!!


def solution():
    while True:
        rects = list(map(int, input().split()))
        if rects[0] == 0: return -1

        s = []
        n = rects.pop(0)
        result = 0

        for i in range(n):
            while s and rects[s[-1]] > rects[i]:
                h = s.pop()  # height
                w = i - s[-1] - 1 if s else i
                result = result if result > w * rects[h] else w * rects[h]
            s.append(i)

        #남은 친구들 다 빼서 처리
        while s:
            h = s.pop()
            w = n - s[-1] - 1 if s else n
            result = result if result > w * rects[h] else w * rects[h]
        # return result
        print(result)

solution()

</details>

[BOJ] HTML

Sun, 06 Oct 2024 00:00:00 GMT

HTML

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	EOF 처리	implementation(구현)

오로지 , <hr> 태그와 그 외 평문으로만 주어지는 HTML 문서가 있을 때, 그 결과를 보여주는 코드를 작성하시오.

한 줄에는 80자보다 많은 글자가 출력되어서는 안 된다.

진짜 말 그대로 구현 문제인데... 조금 약간 이상하게 구현하면 바로 틀립니다.. 그리고 약간 문제가 제시하는 입력에 부합하지 않아도 들어가는 코드도 존재하구요...

일단 구현으로 풀리는 문제긴 합니다. 즐거운 ps 되십쇼오오



#include <iostream>
#include <string>

using namespace std;

const string HR_LINE(80, '-');

void print(string line) {
    if (!line.empty()) cout << line << '\n';
    
}

void solution(string& line, const string& word, bool& new_line) {
    if (word == "<br>") {
        print(line);
        if (new_line) cout << '\n';
        line = "";
        new_line = true;
    } else if (word == "<hr>") {
        print(line); cout << HR_LINE << '\n';
        line = "";
        new_line = true;
    } else {
        if (line.length() + (!line.empty() ? 1 : 0) + word.length() > 80) {
            print(line);
            line = word;
        } else {
            if (!line.empty()) line += ' ';
            line += word;
        }
        new_line = false;
    }
}

int main() {
    string word, line;
    bool new_line = true;

    while (cin >> word) {
        solution(line, word, new_line);
    }

    print(line);

    return 0;
}

</details>

[BOJ] 앱

Thu, 06 Feb 2025 00:00:00 GMT

앱

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	1 ≤ N ≤ 100 <br>1 ≤ M ≤ 10,000,000<br>1 ≤ mi ≤ 10,000,000<br>0 ≤ ci ≤ 100<br>M ≤ m1 + m2 + ... + mN	Dynamic Programming

우리는 스마트폰을 사용하면서 여러 가지 앱(App)을 실행하게 된다. 대개의 경우 화면에 보이는 ‘실행 중’인 앱은 하나뿐이지만 보이지 않는 상태로 많은 앱이 '활성화'되어 있다. 앱들이 활성화 되어 있다는 것은 화면에 보이지 않더라도 메인 메모리에 직전의 상태가 기록되어 있는 것을 말한다. 현재 실행 중이 아니더라도 이렇게 메모리에 남겨두는 이유는 사용자가 이전에 실행하던 앱을 다시 불러올 때에 직전의 상태를 메인 메모리로부터 읽어 들여 실행 준비를 빠르게 마치기 위해서이다.

하지만 스마트폰의 메모리는 제한적이기 때문에 한번이라도 실행했던 모든 앱을 활성화된 채로 메인 메모리에 남겨두다 보면 메모리 부족 상태가 오기 쉽다. 새로운 앱을 실행시키기 위해 필요한 메모리가 부족해지면 스마트폰의 운영체제는 활성화 되어 있는 앱들 중 몇 개를 선택하여 메모리로부터 삭제하는 수밖에 없다. 이러한 과정을 앱의 ‘비활성화’라고 한다.

메모리 부족 상황에서 활성화 되어 있는 앱들을 무작위로 필요한 메모리만큼 비활성화 하는 것은 좋은 방법이 아니다. 비활성화된 앱들을 재실행할 경우 그만큼 시간이 더 필요하기 때문이다. 여러분은 이러한 앱의 비활성화 문제를 스마트하게 해결하기 위한 프로그램을 작성해야 한다

현재 N개의 앱, A1, ..., AN이 활성화 되어 있다고 가정하자. 이들 앱 Ai는 각각 mi 바이트만큼의 메모리를 사용하고 있다. 또한, 앱 Ai를 비활성화한 후에 다시 실행하고자 할 경우, 추가적으로 들어가는 비용(시간 등)을 수치화 한 것을 ci 라고 하자. 이러한 상황에서 사용자가 새로운 앱 B를 실행하고자 하여, 추가로 M 바이트의 메모리가 필요하다고 하자. 즉, 현재 활성화 되어 있는 앱 A1, ..., AN 중에서 몇 개를 비활성화 하여 M 바이트 이상의 메모리를 추가로 확보해야 하는 것이다. 여러분은 그 중에서 비활성화 했을 경우의 비용 ci의 합을 최소화하여 필요한 메모리 M 바이트를 확보하는 방법을 찾아야 한다.

문제를 처음에 볼 때, priority_queue를 써서 하다고 바로 제출했다가 메모리 초과 나서 다시 보니 2^100이여서 헙.. 하고 다시 풀었다.

ㅋㅌㅋㅎㅎㅋㅌㅎ 진짜 dp인가? 뭐지 뭐지 하다가 한번 해보니 아 이렇게 될 수 있구나 하고 풀어서 맞추니 다행이였다. 확실히 dp는 뭔가 dp인 것 같아도 접근하기가 쉽지 않다. 일단 상태 정의부터 시작해서 두 사이간의 어떤 관계가 있는지를 잘 꽤뚫어야 하는데 정말 힘이든다.

일단 풀었으니 개추

#include <iostream>
#include <queue>
#include <algorithm>
using namespace std;
using ll = long long;

int n, m;

pair<ll, ll> memory[101];

ll dp[101][10001];

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

    
    cin >> n >> m;
    
    for(int i = 1; i <= n; i++){
        cin >> memory[i].second;
    }
    for(int i = 1; i <= n; i++){
        cin >> memory[i].first;
    }
    
    for(int i = 1; i <= n; i++){
        auto [free, cost] = memory[i];
//        cout << free << " " << cost << "\n";
        for(int j = 0; j < 10001; j++){
            dp[i][j] = max(dp[i][j], dp[i-1][j]);
            if(free+j >= 10001) continue;
            dp[i][free+j] = max(dp[i-1][j] + cost, dp[i][free+j]);
        }
    }

    for(int i = 0; i < 10001; i++){
        if(dp[n][i] >= m) {
            cout << i;
            return 0;
        }
    }
    

    return 0;
}

</details>

[BOJ] 막대 배치

Sun, 05 Oct 2025 00:00:00 GMT

막대 배치

TimeLimit	MemoryLimit	Condition	TAG
1s	256MB	(1 ≤ N ≤ 20, 1 ≤ L, R ≤ N)	Math

솔직히 날먹이었따!

고층 빌딩 이거 재탕 문제여서 그냥 거의 바로 풀었던거 같아요.

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
#include <numeric>
#include <unordered_set>
#include <unordered_map>
#include <climits>
using namespace std;
using ll = unsigned long long;
//ll MOD = 1'000'000'007;
ll MOD = 1.8446744074E19;

int N, L, R;

ll dp[101][101][101];

ll solution(ll n, ll l, ll r){
    ll result = 0;
    if (l <= 0 || r <= 0 || l + r > n + 1) return 0;
    if(n == 1) return (l == 1 && r == 1);
    
    if(dp[n][l][r] != -1) return dp[n][l][r];
    
    // solution(n+1, r, l) = solution(n, r-1, l) + solution(n, r, l-1) + solution(n, r, l) * n
    result = ((solution(n-1, l, r-1)%MOD + solution(n-1, l-1, r)%MOD)%MOD + (solution(n-1, l, r) * (n-2))%MOD)%MOD;
    dp[n][l][r] = result;
    return result;
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    
    
    for(int i = 0; i < 101; i++){
        for(int j = 0; j < 101; j++){
            
            for(int k = 0; k < 101; k++){
                dp[i][j][k] = -1;
            }
        }
    }
    int T;
    cin >> T;
    while(T --> 0){
        cin >> N >> L >> R;
        cout << solution(N, L, R) << "\n";
    }
    
    return 0;
}

</details>

[BOJ] 두 수의 합

Thu, 19 Jun 2025 00:00:00 GMT

두 수의 합

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	(2 ≤ N ≤ 1'000'000, -10^8 ≤ k ≤ 10^8)	Binary Search, Two Pointer

조건에 서로 다른 수들만 들어오기 때문에 성립하구요. 직관적이고 전형적인 바이너리서치 문제여서 금방 풀었습니다.

이거 fastio 없으면 시간초과 납니다. 조심하셔요

#include <iostream>
#include <queue>
#include <set>
#include <algorithm>
#include <random>
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>

#define MOD 1000000007LL
#define MAX 1'000'000LL
using namespace std;
using ll = long long;


ll nums[1'000'001];

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int t;
    cin >> t;
    
    while(t --> 0){
        int n, k;
        cin >> n >> k;
        
        
        for(int i = 0; i < n; i++) cin >> nums[i];
        sort(nums, nums+n);
        
        int left = 0, right = n-1;
        
        ll diff = 1'000'000'000'000;
        ll count = 0;
        
        while(left < right){
            ll sumOfLR = nums[left] + nums[right];
            if(sumOfLR > k)
                right--;
            else
                left++;
            
            if(diff == abs(k - sumOfLR)) count++;
            else if(diff > abs(k - sumOfLR)){
                count = 1;
                diff = abs(k - sumOfLR);
            }
        }
        
        cout << count << "\n";
        
    }
   

    return 0;
}

</details>

[BOJ] 열쇠

Tue, 18 Mar 2025 00:00:00 GMT

열쇠

TimeLimit	MemoryLimit	Condition	TAG
1s	256MB	(1 ≤ T ≤ 10, 2 ≤ h, w ≤ 100)	BFS

그냥 BFS를 좀 돌리면 되는데 여기서 팁 같은걸 드리자면 바깥쪽도 돌 수 있도록 입력으로 들어오는 매을 (1, 1)부터 시작해서 바같도 돌 수 있도록 해주고, 열쇠 열었을 때 다 처리되도록 잘만 짜면 AC 맞을 수 있어요!

#include <iostream>
#include <vector>
#include <set>
#include <queue>
#include <map>
#include <algorithm>
using namespace std;
using ll = long long;

int inf = 1e9+7;

int n ,m;

char board[105][105];
bool key[130];
bool visited[105][105];
vector<pair<int, int>> pos[130];
int dx[] = {1, -1, 0, 0}, dy[] =  {0, 0, 1, -1};


int solution(){
    queue<pair<int, int>> q;
    
    q.push({0, 0});
    visited[0][0] = true;
    
    int result = 0;
    
    while(!q.empty()){
        auto [y, x] = q.front(); q.pop();
        
        if(board[y][x] == '$') result++;
        
//        cout << board[y][x] << "\n";
        for(int i = 0; i < 4; i++){
            int ny = y + dy[i];
            int nx = x + dx[i];
            
            
            if(0 <= ny && ny <= n+2 && 0 <= nx && nx <= m+2 && board[ny][nx] != '*' && !visited[ny][nx]){
                visited[ny][nx] = true;
                if('a' <= board[ny][nx] && board[ny][nx] <= 'z'){
                    key[board[ny][nx]] = true;
                    for(pair<int, int> door : pos[board[ny][nx] - 'a' + 'A']){
                        if(visited[door.first][door.second]) q.push(door);
                    }
                    
                    
                }
                
                else if('A' <= board[ny][nx] && board[ny][nx] <= 'Z' && !key[board[ny][nx] + 'a' - 'A']) continue;
                
                q.push({ny, nx});
                
            }
            
        }
        
    }
//    cout << '\n';
//    for(int i = 0; i <= n+1; i++){
//        for(int j = 0; j <= m+1; j++) cout << visited[i][j] << " ";
//        cout << '\n';
//    }
    
    return result;;
}


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

    int t;
    cin >> t;
    
    
    
    while(t-->0){
        cin >> n >> m;
        
        for(int i = 0; i < 105; i++){
            for(int j = 0; j < 105; j++) {
                board[i][j] = '.';
                visited[i][j] = false;
            }
        }
        
        
        for(int i = 0; i < 131; i++){
            pos[i].clear();
            key[i] = false;
        }
        
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= m; j++){
                cin >> board[i][j];
                
                if('A' <= board[i][j] && board[i][j] <= 'Z') pos[board[i][j]].push_back({i, j});
                
            }
        }
        
        string keys;
        cin >> keys;
        
        for(char k : keys) key[k] = true;
        
        
        
        
        cout << solution() << "\n";
        
        
        
        
    }
    
    
    
    
    return 0;
}

</details>

[BOJ] 미확인 도착지

Sat, 27 Sep 2025 00:00:00 GMT

미확인 도착지

TimeLimit	MemoryLimit	Condition	TAG
3s	256MB	1 ≤ T ≤ 100<br>2 ≤ N ≤ 2000<br>1 ≤ M ≤ 50,000<br>1 ≤ t ≤ 100<br>1 ≤ s,g,h ≤ N, g ≠ h<br>1 ≤ a < b ≤ N<br>1 ≤ d ≤ 1000	Dijkstra

문제를 잘 읽으면 전혀 어려울 것이 없는 문제였습니다. 문제에서 말하는 바를 정확히 이해하면 다익스트라 딸깍 딸깍으로 풀 수 있는데.. 그걸 알아내는데 20분을 날렸답니다 ㅎ하핳

가는 start에서 g - h, h - g를 거치지 않고 가는 경로가 있더라도 지나가도 괜찮구요..

그래서 그냥 start에서의 모든 최단 경로, g에서의 모든 최단 경로, h에서의 모든 최단 경로를 구하고

start에서 g로 가는 cost와 g에서 h로 가는 cost 그리고 h에서 target까지 가는 cost를 더해서 start 최단 경로랑 겹치면 그게 답이다. 이런식으로 답을 도출할 수 있습니다..

결국은

if(start[g] + gn[h] + hn[target] == start[target] ||
           start[h] + hn[g] + gn[target] == start[target])

그냥 이거 도출하면 띡하고 나오는.. 문제 ㅠㅜ

중간에 깨달았다고 뻘짓해서 ㅠㅜ 더 걸렸슴둥..

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>
#include <string>
#include <numeric>
#include <unordered_set>
#include <unordered_map>
#include <climits>
using namespace std;
using ll = long long;



vector<ll> finder(int start, vector<vector<pair<int, int>>>& graph, int n){
    vector<ll> visited(n+1);
    for(int i = 1; i < n+1; i++) visited[i] = LLONG_MAX;
    priority_queue<pair<int,int>, vector<pair<int, int>>, greater<pair<int, int>>> q;
    visited[start] = 0;
    q.push({0, start});
    while(!q.empty()){
        
        auto [cost, idx] = q.top(); q.pop();
        
        
        for(int i = 0; i < graph[idx].size(); i++){
            auto [next, distance] = graph[idx][i];
            
            if(visited[next] <= distance + cost) continue;
            visited[next] = distance + cost;
            q.push({distance + cost, next});
        }
    }
    
    return visited;
}


void solution(){
    int n, m, t;
    int s, g, h; // 타겟들이 시작한 위치 = s, g랑 h를 이어주는 edge를 지남. 즉, 다시는 여기 방문할 일이 없다 이거임.
    
    cin >> n >> m >> t;
    cin >> s >> g >> h;
    
    
    vector<vector<pair<int, int>>> graph(n+1);// idx, cost
//    vector<pair<int, int> > graph[n+1];// idx, cost
    // 이거 중복 처리가 필요없음.  "교차로 사이에는 도로가 많아봐야 1개이다"
    
    vector<int> targets(t);
    
    for(int i = 0; i < m; i++){
        int a, b, c;
        
        cin >> a >> b >> c;
        
        graph[a].push_back({b, c});
        graph[b].push_back({a, c});
    }
    
    for(int i = 0; i < t; i++) cin >> targets[i];
    // 이거는 어떻게 생각하면 되냐면, g랑 h를 둘 다 다익스트라를 돌려서 그냥 후보들 중에서 가까운 놈 고르면 됨.
    // 왜냐면 결국 제일 빠른 길로 가려고는데 왜 멀어지는 길을 택한 것이냐.. 이것도 문제여서
    // 아 근데 이거는 3번 돌려야됨. 왜냐면 시작 위치부터 다 돌려야되는데, 그래서 시작 위치에서 먼 더 코스트가 먼 친구를 골라야되는 것였다.. 아 알았네요.. 이상하게 들어갈 뻔..
    
    
    
    
    // 아 그냥 3개 구해서 하면 되는거였네..
    
    vector<ll> start = finder(s, graph, n);
    vector<ll> gn = finder(g, graph, n);
    vector<ll> hn = finder(h, graph, n);
    
    
    vector<int> result;
    
    for(int target : targets){
        if(start[g] + gn[h] + hn[target] == start[target] ||
           start[h] + hn[g] + gn[target] == start[target]) result.push_back(target);
    }
    
    sort(result.begin(), result.end());
    
    for(int ans : result) cout << ans << " ";
}

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    
    
    int t;
    cin >> t;
    while(t --> 0){
        solution();
        cout << "\n";
    }
    
    return 0;
}

</details>

[BOJ] 탈옥

Sun, 02 Mar 2025 00:00:00 GMT

탈옥

TimeLimit	MemoryLimit	Condition	TAG
1s	256MB	2 ≤ h, w ≤ 100	Dijkstra

와.. 문제 드릅게 어렵슨디ㅣㅏ...

아니 심지어 중간에 질문 게시판 열심히 들어가봤는데도 반례가 안 나와서 오답 코드들 몇 개 보고서 좀 비교를 해서 그냥 새롭게 코드를 작성한 후 AC를 맞았습니다..

일단 원래는 그냥 죄수들을 기준으로 중복된 문을 없애고 개수 세기였는데 어떤 case에서 안되는 반례가 있나봅니다. 그래서 다익스트라를 각 죄수들과 출구에서부터 들어오는 걸로 총 3번 실행해서 AC를 맞을 수 있엇는데

아이디어가 진짜 생각해내기 많이 힘들었따....

솔직히 이런 문제는 좋은 문제인 것 같아요 요런 아이디어 아주 재미잇네요... 근데 어렵네요 허허ㅓ허허허허ㅓ허...

풀이 영상

</center>

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

using ll = long long;

char stateBoard[105][105];
ll board[105][105][3];
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};

struct info {
    ll cost;
    int y;
    int x;
};

bool operator>(const info& a, const info& b) {
    return a.cost > b.cost;
}

void bfs(int idx, pair<int, int> start, int h, int w) {
    priority_queue<info, vector<info>, greater<info>> q;
    
    for (int i = 0; i <= h+1; i++) {
        for (int j = 0; j <= w+1; j++) {
            board[i][j][idx] = 1e15;
        }
    }
    
    board[start.first][start.second][idx] = 0;
    q.push({0, start.first, start.second});
    
    while (!q.empty()) {
        info current = q.top(); q.pop();
        ll cost = current.cost;
        int y = current.y;
        int x = current.x;
        
        if (cost > board[y][x][idx]) continue;
        
        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];
            
            if (ny < 0 || nx < 0 || ny > h+1 || nx > w+1) continue;
            
            if (stateBoard[ny][nx] == '*') continue;
            
            ll next_cost = cost + (stateBoard[ny][nx] == '#' ? 1 : 0);
            
            if (next_cost < board[ny][nx][idx]) {
                board[ny][nx][idx] = next_cost;
                q.push({next_cost, ny, nx});
            }
        }
    }
}

ll solution(int h, int w, vector<pair<int, int>>& starts) {
    for (auto& pos : starts) stateBoard[pos.first][pos.second] = '.';
    
    bfs(0, {0, 0}, h, w);
    
    bfs(1, starts[0], h, w);
    
    bfs(2, starts[1], h, w);
    
    ll result = 1e15;
    for (int i = 0; i <= h+1; i++) {
        for (int j = 0; j <= w+1; j++) {
            if (stateBoard[i][j] == '*') continue;
            ll total = board[i][j][0] + board[i][j][1] + board[i][j][2];
            total -= 2 * (stateBoard[i][j] == '#');
            result = min(result, total);
        }
    }
    
    return result;
}

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

    int t;
    cin >> t;
    while (t-- > 0) {
        int h, w;
        cin >> h >> w;
        
        for (int i = 0; i <= h+1; i++) {
            for (int j = 0; j <= w+1; j++) stateBoard[i][j] = '.';
        }
        
        vector<pair<int, int>> starts;
        
        for (int i = 1; i <= h; i++) {
            for (int j = 1; j <= w; j++) {
                cin >> stateBoard[i][j];
                if (stateBoard[i][j] == '$') starts.push_back({i, j});
            }
        }
        
        cout << solution(h, w, starts) << "\n";
    }
    return 0;
}

</details>

[BOJ] 1의 개수 세기

Fri, 07 Feb 2025 00:00:00 GMT

1의 개수 세기

TimeLimit	MemoryLimit	Condition	TAG
1s	128MB	1 ≤ A ≤ B ≤ 10^16	Dynamic Programming, Bit Masking

두 자연수 A, B가 주어졌을 때, A ≤ x ≤ B를 만족하는 모든 x에 대해 x를 이진수로 표현했을 때 1의 개수의 합을 구하는 프로그램을 작성하시오. 즉, f(x) = x를 이진수로 표현했을 때 1의 개수라고 정의하고, 아래 식의 결과를 구하자:

<center> <math xmlns="http://www.w3.org/1998/Math/MathML" style="font-size: 36px;"> <munderover accent='false' accentunder='false'> <mo>∑</mo> <mrow><mi>x</mi><mo>=</mo><mi>A</mi></mrow> <mi>B</mi> </munderover> <mi>f</mi><mo>(</mo><mi>x</mi><mo>)</mo> </math> </center>

와... 오랜만에 많이 막힌 문제였습니다. 허허... 요즘 골드 문제도 이렇게 막힐 수 있다는 것을 알아갑니다..

일단 시간 초과를 피하기 위해서 dp를 이진법의 bit 별로 개수를 세주고, 그걸 활용하는 식으로 시간을 좀 단축 시켰습니다.

일단 제가 짠 코드를 이해하려면 이진법에 대해서 알아야 하는데, dp 채우는 코드는 아마 식을 세우다 보면 자연스럽게 얻어지는 식이구요. 위에 solution은

그냥 현재 들어온 수에 대해서 최상위 비트를 보고있다고 생각하고, 그 하위 비트들은 한 cycle을 돌렸으니까 하나의 확정된 cycle을 더해주고, 그리고 최상위 비트 제외하고 처리합니다.

이후에는 최상위 비트가 켜져있으니 1을 더해주고요. 그 후에는 하위 비트로 내려가면서 다 처리하는 로직을 따릅니다.

생각보다 간단한 로직이긴 합니다만... 뭔가 꽤 막혀서 고민을 했던 문제였네요 허허허허허헣...

언제나 즐거운 PS 되시길 바랍니다.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
using ll = unsigned long long;




ll a, b;
ll memo[100];
ll pow(int up){
    return 1ULL << up;//current;
}

ll solution(ll current) {
    if (current == 0) return 0;
    
    int size = 0;
    for (int i = 0; i <= 63; i++)
        if (current & (1ULL << i)) size = i;
    
    
    ll result = 0;
    result = memo[size];
    current = current - (1ULL << size);
    result += current + 1;
    
    result += solution(current);
    
    return result;
}


int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    cin >> a >> b;
    
    memo[0] = 0;
    memo[1] = 1;
    memo[2] = 4;
            
    
    for(int i = 3; i < 64; i++){ memo[i] = memo[i-1]*2 + pow(i-1);}
    

    cout << solution(b) - solution(a-1);

    return 0;
}

</details>

[BOJ] N-Queen

Mon, 08 Jul 2024 00:00:00 GMT

N-Queen

TimeLimit	MemoryLimit	Condition	TAG
10s	128MB	(1<= N <= 15)	BackTracking(백트래킹)

N-Queen 문제는 크기가 N × N인 체스판 위에 퀸 N개를 서로 공격할 수 없게 놓는 문제이다.

N이 주어졌을 때, 퀸을 놓는 방법의 수를 구하는 프로그램을 작성하시오.

일단 이 문제는 정말 단순한 구현문제이다. 그냥 완전탐색에 가지치기 몇 번하면 그냥 풀리는 문제이니 사실 어려움은 없을 것이다. 물론 구현이 가능하면 말이다.

퀸이 이동 가능한 위치를 알고서, 가로 세로 대각선을 체크만 한다면 너무나 쉬운 문제라 딱히 해설을 하지 않겠다.

(지금 다른 포스팅을 하고있는데 쓸 포스팅이 고갈되어서 이거 씁니다... ㅠㅜㅜ) (혹시라도 궁금하시면 아래 코드 함 보시고 생각해보시길.. 별로 좋은 코드는 아닌거 같아여)

#include <iostream>
bool IsSafe(int y, int x, bool arr[15][15], int N, bool* row);
int solution(int n, bool board[15][15], int current, bool* row);
using namespace std;



int result;



int main(){
    ios::sync_with_stdio(false);
    cin.tie(NULL); cout.tie(NULL);
    
    int n;
    bool board[15][15] = {false, };
    bool row[15] = {false,};
    
    cin >> n;
    
    cout << solution(n, board, 0, row);
    
}
void printBoard(bool board[15][15], int n){
    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
            cout << board[i][j] << " ";
        }
        cout << "\n";
    }
    cout << "\n";
}
int solution(int n, bool board[15][15], int current, bool* row){
    if(current == n) return 1;
    
    int mysum = 0;
    
    for(int i = 0; i < n; i++){
        if(!IsSafe(current, i, board, n, row)) continue;
        board[current][i] = true;
        row[i] = true;
        mysum += solution(n, board, current+1, row);
        board[current][i] = false;
        row[i] = false;
    }
    return mysum;
    
}

bool IsSafe(int y, int x, bool arr[15][15], int N, bool* row){
    if(row[x]) return false;
    
    
    for(int i = 1; i < N; i++){
        if(0 <= y+i && y+i < N && 0 <= x+i && x+i < N && arr[y+i][x+i]) return false;
        if(0 <= y-i && y - i < N && 0 <= x-i && x-i < N && arr[y-i][x-i]) return false;
        if(0 <= y+i && y+i < N && 0 <= x-i && x-i < N && arr[y+i][x-i]) return false;
        if(0 <= y-i && y - i < N && 0 <= x+i && x+i < N && arr[y-i][x+i]) return false;
    }
    
    return true;
}

</details>

[BOJ] 문자열 폭발

Mon, 14 Oct 2024 00:00:00 GMT

문자열 폭발

TimeLimit	MemoryLimit	Condition	TAG
2s	128MB	(1<= N <= 1'000'000, 1 <= Bomb <= 36)	Stack(스택)

상근이는 문자열에 폭발 문자열을 심어 놓았다. 폭발 문자열이 폭발하면 그 문자는 문자열에서 사라지며, 남은 문자열은 합쳐지게 된다.

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

문자열이 폭발 문자열을 포함하고 있는 경우에, 모든 폭발 문자열이 폭발하게 된다. 남은 문자열을 순서대로 이어 붙여 새로운 문자열을 만든다.

새로 생긴 문자열에 폭발 문자열이 포함되어 있을 수도 있다.

폭발은 폭발 문자열이 문자열에 없을 때까지 계속된다.

상근이는 모든 폭발이 끝난 후에 어떤 문자열이 남는지 구해보려고 한다. 남아있는 문자가 없는 경우가 있다. 이때는 "FRULA"를 출력한다.

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

이 문제는 사실 전형적인 Stack 문제여서 생각을 많이 하진 않았던 것 같다. 그냥 시간복잡도 보고서 음 괜찮네하고 짰는데 AC를 맞았다.

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

string N, bomb;


int main(){
    cin >> N;
    cin >> bomb;
    
    vector<char> stack;
    
    int length = (int) bomb.size();
    for(int i = 0; i < N.size(); i++){
        stack.push_back(N[i]);
        if(stack.size() >= length){
            bool check = false;
            for(int j = 0; j < length; j++){
                if(bomb[length - j - 1] == stack[stack.size() - j - 1]) continue;
                check = true;
                break;
            }
            if(check) continue;
            
            for(int j = 0; j < length; j++) stack.pop_back();
        }
    }
    
    if(stack.empty()) cout << "FRULA";
    else{
        for(int i = 0; i < stack.size(); i++) cout << stack[i];
    }
    
    return 0;
}

</details>

한번쯤 들어봤을 그 이름... 디자인패턴(DesignPattern)

Mon, 10 Jun 2024 00:00:00 GMT

개발을 하다보면 한번쯤은 들어봤을 그 이름.. 디자인 패턴

도대체 디자인 패턴이란 무엇일까? 그리고 왜 개발에 필요한 것일까?

디자인 패턴이란?

프로그램을 설계할 때 발생하는 문제들을 객체 간의 상호 관계 등을 이용하여 해결할 수 있도록 하나의 규약(Protocol)형태로 만들어 놓은것입니다. 사실 규약이라고 말한다는 것은 모두가 인정한 "이런 방법으로 이러한 문제를 해결하자"라고 하는 것들을 말한다고 이해하시면 편할 것 같습니다.

디자인 패턴에는 대표적으로 3가지 카테고리로 나눌 수 있습니다.

생성(Creational)	구조(Structural)	행동(Behavioural)
Singleton	Adapter	Command
Abstract Factory	Composite	Interpreter
Factory Method	Decorator	Iterator
Builder	Facade	Mediator
Prototype	Flyweight	Memento
	Proxy	Observer
		State
		Template Method
...	...	...

각 생성, 구조, 행동 패턴의 3가지로 분류하고 여러가지 패턴이 존재합니다.

이제 디자인패턴을 배우면서 개발자로서 깔끔하고 효율적으로 설계하는 방법을 터득해 봅시다! 화이팅!

<!--

생성(Creational)
- Singleton
- Abstract Factory
- Factory Method
- Builder
- Prototype
구조(Structural)
행동(Behavioural)

-->

[DesignPattern] 싱글톤(Singleton)

Mon, 10 Jun 2024 00:00:00 GMT

싱글톤이란?

In software engineering, the singleton pattern is a software design pattern that restricts the instantiation of a class to a singular instance. 소프트웨어 공학에서 싱글톤 패턴은 클래스의 인스턴스화를 단일 인스턴스로 제한하는 소프트웨어 설계 패턴입니다. 출처: 위키피디아

싱글톤을 진짜 한 줄로 요약하자면 "단 한번만 생성"입니다.

조금더 구체적으로 설명하면 인스턴스(특정 한 객체)를 한개만 생성하여 사용하는 패턴입니다.

그러면 싱글톤은 언제 사용할까요??

사용 상황 예시

많은 곳에서(in program) 객체에 접근하고, 공유하여 사용할 때
딱 한개의 인스턴스만 필요한 경우
등...

그러면 왜 사용해요??

싱글톤을 사용하면 많은 장점이 있습니다.

장점

메모리 낭비 방지
- 객체가 딱 한개의 인스턴스만 생성되기 때문에 여러 인스턴스가 올라와 있지 않기 때문에 메모리 측면에서의 이점이 있음
속도 ⬆
- 이미 생성된 객체에 접근하기 때문에 접근할 때 비교적 속도가 빠름
데이터 공유 easy
- 인스턴스가 전역으로 사용되면서, 코드를 짤 때 편하다는 이점이 있음
- !!! 그러나 여러 곳에서 접근할 때 발생하는 동시성 문제를 유의하여야 한다.

[Minecraft] 인벤토리 관리

Mon, 07 Oct 2024 00:00:00 GMT

:::note[이 포스트에서는]

JAVA 언어에 대한 기본적인 이해와 OOP를 코드에 적용할 수 있는 정도의 실력이 기본적으로 요구됩니다.

:::

인벤토리를 효율적으로 기능을 넣고, 관리하는 것은 OOP를 이용하면 정말 쉽게 이용할 수 있어요..

Interface

public interface InventoryHandler {
    void onClick(InventoryClickEvent event);
    void onOpen(InventoryOpenEvent event);
    boolean onClose(InventoryCloseEvent event);
}

이렇게 인터페이스를 정의합니다. 우리는 요 친구를 <code>인벤토리 핸들러</code>라고 얘기를 할 것이구요

함수 <code> onClick</code>, <code> onOpen</code>, <code> onClose</code>의 반환값은 자신이 알아서 뭐 설계하여도 됩니다..

지금 사용되는 코드는 제가 상점 구현할 때 쓰던 코드를 그대로 가져온 거라서 알아서 가공해서 쓰시면 될 것 같구요.

Manager

public class InventoryManager {

    public static InventoryManager manager;

    private final Map<Inventory, InventoryHandler> inventories;

    public InventoryManager() {
        if(manager == null) manager = this;
        inventories = new HashMap<>();
    }

    public void RegisterInventory(Inventory inventory, InventoryHandler handler){
        this.inventories.put(inventory, handler);
    }

    public void UnRegisterInventory(Inventory inventory){
        this.inventories.remove(inventory);
    }

    public void HandleClick(InventoryClickEvent event){
        final InventoryHandler handler = this.inventories.get(event.getInventory());
        if(handler == null) return;
        handler.onClick(event);
    }

    public void HandleOpen(InventoryOpenEvent event){
        final InventoryHandler handler = this.inventories.get(event.getInventory());
        if(handler == null) return;
        handler.onOpen(event);
    }

    public void HandleClose(InventoryCloseEvent event){
        final Inventory inventory = event.getInventory();
        final InventoryHandler handler = this.inventories.get(inventory);
        if(handler == null) return;
        if(handler.onClose(event)) this.inventories.remove(inventory);
    }
}

이렇게 메니저를 선언해서 관리하도록 합니다.

이러면 메모리 관리 측면에서 전체적으로 관리하기 편하구요. 혹시나 어떤 경우에 대해서 핸들링하기 편합니다.

이렇게 쓰는게 보통적으로 쓰는 기본적인 형태인 것 같아요.

Listener

public class InventoryListener implements Listener {

    private final InventoryManager inventoryManager;
    public InventoryListener(){
        this(new InventoryManager());
    }

    public InventoryListener(InventoryManager manager){
        this.inventoryManager = manager;
    }

    @EventHandler
    public void onInventoryOpen(InventoryOpenEvent event){
        this.inventoryManager.HandleOpen(event);
    }

    @EventHandler
    public void onInventoryClick(InventoryClickEvent event){
        this.inventoryManager.HandleClick(event);
    }

    @EventHandler
    public void onInventoryClose(InventoryCloseEvent event){
        this.inventoryManager.HandleClose(event);
    }
}

이렇게 기본형으로 쓰다가 또 필요하면 수정하면 되구요. 사실 여기는 딱히 건들일 곳이 없긴 합니다.

갑자기 JAVA를 올린 이유는 아니 Bukkit을 올린 이유는.. 보통 코딩을 마인크래프트로 입문을 많이 하더라구요 그래서 입문자용으로 몇개의 활용성있는 방법들과 구현할만한 것들을 공유해드리려고 합니다. 이제부터 천천히 (스케줄링, 핸들링, 이펙트, 스킬, 패킷 관리, 모드-플러그인 통신 등)을 다룰 예정입니다.

모두 재미있는 개발하세용!!

[Minecraft] Region System

Mon, 24 Feb 2025 00:00:00 GMT

이제부터 하나의 목표를 잡고서 그걸 하나씩 구현하면서 확장을 해볼 생각입니다.

간단한 마인크래프트 프로젝트는 바로! 괜찮은 RPG 서버 만들기! 입니다.

이번에는 월드에딧, 월드가드에서 사용하는 방식을 이용해서 구역을 정의하고, 그에 따라서 이벤트를 넣어서 처리할 수 있도록 구현했습니다.

코드가 굉장히 많은 관계로 추후에 github에 upload해서 공개하겠습니다.

이번에는 영상으로 조금 작성하던 영상과 시연 영상을 마무리 하겠습니다.

구현 영상

</center>

[Minecraft] Raycast 구현

Sat, 15 Feb 2025 00:00:00 GMT

또 정말 오랜만에 돌아옵니다. 요즘 Mojo로 작은 프로젝트하고 있어서 좀 뜸하긴 한데요. 일단 오늘은 간단하게 raycasting을 구현해보려고 합니다.

먼저 Event를 만들어주고, 그 이후에 발생 처리를 해보겠습니다.

이번 구현은 고정된 곳에서 플레이어가 지나가는지 체크를 하는 로직을 좀 구현하고, 딱히 할 대상이 없으니 현재 같은 월드에 있는 모든 엔티티에 대해서 다 처리를 해서 확인을 해보겠습니다.

public class RaycastEvent extends Event {
    private static final HandlerList handlers = new HandlerList();

    private final Player player;
    private final Entity entity;

    private final Location sourceLocation;
    private final Location targetLocation;


    public RaycastEvent(Player player, Entity entity, Location sourceLocation, Location targetLocation){
        this.player = player;
        this.entity = entity;
        this.sourceLocation = sourceLocation;
        this.targetLocation = targetLocation;
    }

    public Player getPlayer() {
        return player;
    }

    public Entity getEntity() {
        return entity;
    }

    public Location getSourceLocation() {
        return sourceLocation;
    }

    public Location getTargetLocation() {
        return targetLocation;
    }

    @Override
    public HandlerList getHandlers() {
        return handlers;
    }
    public static HandlerList getHandlerList(){
        return handlers;
    }
}

뭐 여기까지는 너무 그냥 당연하게 작성한 것이라 넘어가구요!

public class RaycatManager {

    public RaycatManager(){
        register();
    }

    public void register(){
        ProtocolManager manager = ProtocolLibrary.getProtocolManager();

        manager.addPacketListener(new PacketAdapter(BlogPlugin.plugin,
                ListenerPriority.HIGH,
                PacketType.Play.Client.POSITION,
                PacketType.Play.Client.POSITION_LOOK
                ) {



            @Override
            public void onPacketReceiving(PacketEvent event) {
                Player player = event.getPlayer();
                PacketContainer container = event.getPacket();

                double x = container.getDoubles().read(0);
                double y = container.getDoubles().read(1);
                double z = container.getDoubles().read(2);

                tryRaycast(new Location(player.getWorld(), x, y, z), player);
            }
        });
    }


    private void tryRaycast(Location playerLoc, Player player){
        if(playerLoc.getWorld() == null) return;


        Bukkit.getScheduler().runTask(BlogPlugin.plugin, ()->
        {
            playerLoc.getWorld().getEntities().stream().filter(entity ->
                    entity instanceof LivingEntity && !entity.equals(player)
            ).forEach(entity -> raycast(playerLoc, player, entity));
        });
    }
    private void raycast(Location loc, Player player, Entity entity){
        if(loc.getWorld() == null) return;

        Location entityLoc = entity.getLocation();

        double distance = loc.distanceSquared(entityLoc);
        if(distance <= 5*5){ 
            Vector dir = entityLoc.getDirection();
            Vector toPlayer = loc.toVector().subtract(entityLoc.toVector()).normalize();

            double angle = Math.toDegrees(dir.angle(toPlayer));

            if(angle <= 45f){


                if(isBlocked(entityLoc, loc)) return;

                Bukkit.getScheduler().runTask(BlogPlugin.plugin, ()-> {
                    RaycastEvent event = new RaycastEvent(player, entity, entityLoc, player.getLocation());
                    Bukkit.getPluginManager().callEvent(event);
                });
            }
        }


    }

    private boolean isBlocked(Location from, Location to){
        from.setY(from.getY() + 1.5f);
        return from.getWorld().rayTraceBlocks(from, to.toVector().subtract(from.toVector()), to.distance(from)) != null;
    }

}

여기까지 이렇게 raycast를 구현할 수 있어요. 이것도 게임을 공부하다 보면 당연히 보이는 것들이 있을 거구요! <code>from.setY(from.getY() + 1.5f);</code> 여기는 좀 중요한데... 이게 발가락이 from이 되면서 시야가 너무 낮아지면서 블록이 있는 것으로 알더라구요?! 그래서 이렇게 올려준겁니다.

구현 영상 <iframe width="560" height="315" src="https://www.youtube.com/embed/b7of1RBJn1Q?si=G873YriBzjxSDuCk" title="raycast" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

</center>

이제 곧 리버싱, 암호학, 인공지능 이렇게 올라가긴 할겁니당

다들 너무 수고하셨습니다.

[Minecraft] 플러그인 커스텀 이벤트

Tue, 04 Feb 2025 00:00:00 GMT

:::note[잠시 보고 가세용!]

이 포스트는 상속을 모르는 상태에서 보면 약간의 혼란이 발생합니다ㅏ.. 또한 Bukkit의 Listener, EventListener, Event의 이해가 필요합니다. :::

일단 버킷에서는 많은 이벤트를 다 지원해준다. PlayerInteractEvent, PlayerJoinEvent ... 등등 아주 많이 지원해준다.

그래서 뭐 딱히 만들 필요없다고 생각할 수 있지만.. 좀 까다롭게 로직을 만들고 싶을 때는 미리 패킷을 받고서 처리하면서 이벤트를 발생시켜 Listener에서 편하게 처리하도록 할 수 있다. 뭐 예를 들어보자

게임에 보스가 존재하는데 보스를 잡았다면 그 BossDeadEvent가 발생되도록 하여서 잡은 플레이어와 Boss의 종류를 event에 넣어서 보내면 Listener에서 처리할 때 필요한 값들이 다 들어있어서 처리가 편합니다.

그럼 그걸 어떻게 만들까요??? 한번 화이트 리스트 기능을 좀 이걸 이용해서 만들어 봅시다!

public class TestListener implementation Listener{
    @EventListener
    public void onJoin(PlayerJoinEvent e){
        Player player = e.getPlayer();
        
    }
}

public class WhiteListEvent extends Event implementation Cancellable{
    private static final HandlerList handlers = new HandlerList();
    private final Player player;

    private final ServerPlayer npc;
    private boolean cancelled;

    public WhiteListEvent(Player player) {
        this.player = player;
    }

    public Player getPlayer() {
        return player;
    }

    @Override
    public boolean isCancelled() {
        return cancelled;
    }

    @Override
    public void setCancelled(boolean cancel) {
        this.cancelled = cancel;
    }

    @Override
    public HandlerList getHandlers() {
        return handlers;
    }

    public static HandlerList getHandlerList() {
        return handlers;
    }
}

저는 이 이벤트를 캔슬 시킬 수 있도록 하려고 했습니다.

WhiteListManager에서 일단 처내도록 하고 있는데... 이때 다른 곳에서 이런 플레이어는 제외 시키자.. 이렇게 하도록 이요!

이거는 어떻게 발생시킬 수 있을까요??

@EventListener
public void onJoin(PlayerJoinEvent e){
    Player player = e.getPlayer();
    Bukkit.getScheduler().runTask(plugin, () -> {Bukkit.getPluginManager().callEvent(new WhiteListEvent(player));});
}

@EventListener
public void onWhiteListPlayerIn(WhiteListEvent e){
    e.getPlayer().kick();
}

Bukkit Scheduler를 호출해서 실행시키는 것은 main thread에서 처리되도록 안전하게 하는 것입니다.

이렇게 된다면 어떻게 받을 수 있느냐!!

@EventListener
public void onWhiteListPlayerIn(WhiteListEvent e){
    
}

이렇게 사용할 수 있어요!

그러면 WhiteListManager에서 처리된 플레이어면 cancel시키고 아니면 원래 실행되던 kick이 처리되게 되는거죠!

:::warning[조심]

핸들러의 등록 순서에 따라서 결과가 달라질 수 있어요! 영상을 참고해 주세요! :::

<center> 구현 영상

</center>

여기까지 약간의 튜토리얼 이었습니다.

[Minecraft] 플러그인 종속성 관리

Tue, 04 Feb 2025 00:00:00 GMT

:::note[]

프로토콜립을 시작하기 전 들렀다가는 포스팅입니다 :::

일단 자신의 플러그인 프로젝트에서 프로토콜립을 사용하고 싶다면?

gradle, maven으로 셋업을 할 수 있습니다. 아예 파일에 implementation 걸어도 되긴하는데 딱히 이렇게까진 안합니다.

repositories{
    maven {
        name = "protocol-lib"
        url = "https://repo.dmulloy2.net/repository/public/"
    }
}

dependencies{
    compileOnly 'com.comphenix.protocol:ProtocolLib:5.3.0'
}

이렇게 설정을 하면 프로젝트에서 protocollib의 기능들을 사용할 수 있어집니다. 하지만 빌드된 이후에 런타임에서 같은 기능이 돌아가려면 build.gradle 뿐만 아니라 plugin.yml의 정보도 바꿔야 합니다.

플러그인의 dependency를 설정하기 위해서는 <code> depend</code> 를 사용하면 됩니다.

예시

depend: [ProtocolLib]

만약 다른 플러그인도 같이 넣고 싶다. 그러면 example이라는 플러그인을 넣고 싶다면

depend: [ProtocolLib, example]

이렇게 할 수 있어요.

(플러그인 이름을 적으시면 됩니다.)

[Minecraft] 메인 인스턴스를 효과적으로 관리하자

Thu, 10 Oct 2024 00:00:00 GMT

:::note[이 포스트에서는]

JAVA 언어에 대한 기본적인 이해와 OOP를 코드에 적용할 수 있는 정도의 실력이 기본적으로 요구됩니다.

:::

버킷에서 <code> anyMethod(Plugin plugin, ...)</code> 요런 모양의 함수들을 많이 보게 될 것이다. 처음 접하는 사람은 "????????? plugin은 뭐야?" 이럴 텐데 이때 우리는 JavaPlugin 즉 이것을 상속받은 MainClass의 인스턴스를 넘겨주면 되는 것이다.

아니 근데 이것을 그냥 넘겨줄 것인가? 자 한번 비교해보자

일단 instance를 사용할 클래스 하나를 만들어 주겠다.

이름은 <code> ListenerManager</code>로 <code>EventListener</code>의 역할을 하도록 해주겠다.

public class ListenerManager implements Listener {

    private Main instance;

    public ListenerManager(Main instance){
        this.instance = instance;
    }

    @EventHandler
    public void onJoin(PlayerJoinEvent event){
        Player p = event.getPlayer();
        for(Player player : Bukkit.getOnlinePlayers()){
            if(player.equals(p)) continue;
            p.hidePlayer(this.instance, player);
        }
    }

}

이렇게 해줌으로써 한 유저가 서버에 접속하게 되면, 다른 유저들에게는 보이지 않게되도록 만들었다. 이때 싱글톤을 사용하지 않은 instance는 지금처럼 하나하나 각 인스턴스마다 연결해줘야하는 엄청나게 불편함이 존재한다.(또 성능적으로도 좋지 않다, 제일 안 좋은 것은 미적으로 안 좋다.)

@Override
public void onEnable() {
    PluginManager pm = Bukkit.getPluginManager();
    ListenerManager listenerManager = new ListenerManager(this);
    pm.registerEvents(listenerManager, this);
}

이렇게 작성할 수 있겠다. 그런데 만약 인스턴스를 사용하는 클래스가 많고, 여러곳에서 많이 쓰일때는??

엄청나게 안 좋은 코딩의 시작인 것이다.

그래서 우리는 더욱 간단한 방법을 사용한다.

public final class Main extends JavaPlugin{
    private static Main instance;
    @Override
    public void onEnable() {
        instance = this;
        ListenerManager listenerManager = new ListenerManager();
        pm.registerEvents(listenerManager, this);
        
    }
    public static Main getInstance(){
        return instance;
    }
}

이렇게 작성 후 리스너도 바꿔준다.

public class ListenerManager implements Listener {
    @EventHandler
    public void onJoin(PlayerJoinEvent event){
        Player p = event.getPlayer();
        for(Player player : Bukkit.getOnlinePlayers()){
            if(player.equals(p)) continue;
            p.hidePlayer(Main.getInstance(), player);
        }
    }
}

이렇게 해주면 가독성도 높아지고, 아주 좋은 코딩을 할 수 있다.

다음에는 이제 스케쥴링에 대해서 배우도록 하겠다.(with scoreboard)

[Minecraft] ProtocolLib 패킷 받기

Thu, 06 Feb 2025 00:00:00 GMT

ProtocolLib은 뭘까?

ProtocolLib은 Bukkit에서 처리되는 이벤트나 다른 기능에서 제공되지 않거나, 별로 좋지 않은 기능들을 직접 구현할 수 있게 해주는 강력한 플러그인입니다. 정확히는 마인크래프트 서버, 클라이언트 끼리의 패킷을 읽고 보낼 수 있게 편리한 기능을 제공하는 플러그인이죠!

플러그인으로 좀 세부적인 것을 만들고 싶다면 거의 필수적으로 사용되는 플러그인인데요!! 그래서 한번 튜토리얼을 만들어 볼까 합니다.

먼저 ProtocolLib(이하 '프립') 은 플러그인에서 종속성 설정을 해줘야합니다. 이 설정은 여기를 참고해주세요!

시작!

:::note[Packet]

사전적 의미는 '네트워크를 통해 전송되는 형식화된 데이터 덩어리'

사용자 데이터는 '페이로드(payload)'로 알려져 있습니다. 제어정보는 페이로드를 전달하기 위한 정보 :::

프로토콜립에서 제공하는 패킷 타입은 여기서서 볼 수 있어요!

이번에는 바로 실습을 진행해 보겠습니다.

원래 딱 보면 이해되는 것들이 더 많으니까요

    public ProtocolLibListener(){
        protocolManager = ProtocolLibrary.getProtocolManager();

        register();
    }

    public void register() {
        protocolManager.addPacketListener(new PacketAdapter(BlogPlugin.plugin, ListenerPriority.NORMAL,
                PacketType.Play.Client.USE_ENTITY) {
            @Override
            public void onPacketReceiving(PacketEvent event) {
                PacketContainer packet = event.getPacket();
                Player player = event.getPlayer();
                StructureModifier<Integer> integers = packet.getIntegers();
                if (integers != null && integers.size() > 0) {
                    int entityId = integers.read(0);

                        Bukkit.getScheduler().runTask(BlogPlugin.plugin, ()-> {
                            Entity entity = getEntityById(entityId, player.getWorld());
                            if(entity == null) return;
                            Location loc = entity.getLocation();
                            loc.setY(loc.getY() + 10);
                            entity.teleport(loc);
                        });
                }
            }
        });
    }

이렇게 작성하면 버킷에 프로토콜립의 이벤트 리스너가 등록된겁니다. 굉장히 간단하죠?

지금 아래 코드에서 좀 잘 봐야할 것은 뭐냐 runTask랑 packet.getIntegers() 정도가 되겠네요

둘 다 안전하게 처리하기 위해서 사용되는 것들이고요. 이를 통해서 오류 안 터지고 예외 처리도 되고 따로 핸들링도 가능해집니다. 제가 try, catch문을 별로 좋아하는 편은 아니여서 최대한 안 쓰려고 합니다.

    private Entity getEntityById(int id, World world){
        return world.getEntities().stream().filter(entity -> entity.getEntityId() == id).findFirst().orElse(null);
    }

이렇게 해서 아이디를 알면 그 월드에 존재하는 엔티티들을 전부 돌면서 하나를 받아올 수 있게 되겠죠

    public static BlogPlugin plugin;
    @Override
    public void onEnable() {
        plugin = this;
        new ProtocolLibListener();
    }

main도 별거 없습니다. 그냥 실행만 시켜주는 거에요!

<center> 구현 영상

</center>

[DEV] 개발자 관점에서 보는 해양레저아이디어 공모전 후기

Mon, 06 Apr 2026 00:00:00 GMT

기획서와 발표 자료를 제출해서 본선 17팀(?) 정도에 들었다. 솔직히 처음에 막 "정책"과 관련된 아이디어만 받는 줄 알고서 별로 기대 안 하고 있었는데 이게 돼버렸다.

그래서 기분 좋은 상태로 대회장으로 이동했따!

장소는 송도 컨벤시아홀에서 열려서 박람회도 구경할겸 해서 가게 되었다.

발표는 각 팀들이 나와서 프레젠테이션하고, 질의응답 및 피드백이 이어졌다.

(대회장에서 찍었다고 보내주셨던 분들 감사합니다!)

발표할 때는 후드짚업을 벗고서 발표를 진행했다. 발표를 하면서 굉장히 떨려서 계속 움직였던게 너무 미스였다. 발표 자체는 매끄럽다고 팀원이 격려해줬는데 솔직히 만족스럽지 않았다. 또한 다른 팀들의 발표를 보니 서비스 개발이 아닌 정책 또는 진짜 어떤 지자체를 targeting해서 발전시키는 아이디어들이었다. (제품도 있었다. 그러나 아이디어, 구현 X)

구현한 내용은 파편화 되어있던 서비스들을 하나로 모으는 작업이었고, 이를 구현해냈다. 그러나 근본적인 문제가 있었는데, 질의응답 때 날카롭게 질문 주셨다. 단순히 기능들이 모여진다고 해서 문제가 해결되는가? 이게 실제로 효과가 있는지 어떻게 검증할 수 있는가? 였다.

물론 다른 성공한 서비스들을 비교하며 우리도 가능하다라는 정도로 설명하긴 했으나 내가 느끼기에도 부족하다고 느꼈다.

다음부터는 이런 자료나 다른 근거 자료를 더 준비해야겠다는 생각을 머리에 각인했다.

대회 끝나고 열심히 박람회 돌아보면서 놀았따.

특히 VR이 ㄹㅈㄷ로 재밌었다.

[Bridled] 중형 게임 프로젝트 일지 - 1

Thu, 20 Jun 2024 00:00:00 GMT

Project: Helliowin

Bridled 소개

귀여운 친구들! 귀엽지 않은 전투!

탐욕이 가져온 혼란스러운 세상에는 동물들은 사람들의 목표가 되었어요. 갈 곳 없는 자들도, 빛을 보지 못했던 자들도 자신만의 가치관에 맞는 동물처럼 되고 싶어했죠. 사람들은 생각이 맞는 사람들과 모여들기 시작했고, 하나의 종교로서 자리를 잡았어요.

근데 사람들은 마음에 안드는게 있나봐요. 세계 곳곳에서 다시 싸움의 불씨가 보여요. 그런데 이상하네요? 작은 동물들이 외로운 싸움을 하고 있어요. 우리가 도와줘야 될거 같아요! 우리의 작은 친구 싸움을 멈출 수 있도록 도와주도록 할까요?!

Member

이정훈

PM, 기획, 개발(클라이언트)

플레이어, 맵 생성, 몬스터 인공지능

선린인터넷고등학교 인공지능 동아리 PARA

유한별

개발(백엔드, 서버 구축)

c# 서버 구축, 서버와 클라이언트 통신 구현, 실시간 게임 서버 구현

선린인터넷고등학교 인공지능 동아리 PARA

이강민

개발(클라이언트)

플레이어 UI, 게임 메뉴 구현, 전투 시스템 구축, 스킬 구현

선린인터넷고등학교 게임개발 동아리 C,real

차윤슬

디자인(캐릭터, 배경, 몬스터, 캐릭터 에니메이션, 스킬, UI 등)

캐릭터 디자인

선린인터넷고등학교 게임개발 동아리 C,real

서이준루하

디자인(맵, 맵 배치 구성, 아이템, UI 등)

맵 디자인, 아이템 디자인

선린인터넷고등학교 게임개발 동아리 C,real

[Go] Go언어 공부 시작해보기

Thu, 20 Jun 2024 00:00:00 GMT

Go란?

빠른 성능, 안정성, 편의성, 쉬운 프로그래밍을 목표로 개발되었으며 범용 프로그래밍 언어입니다.

현재 많은 대기업에서 사용하고 있으며, "고루틴"이라는 강력한 기능을 가지고 있는 언어입니다.

정적 타입, 강 타입
컴파일 언어
가비지 컬렉션
병행성(Concurrency)
멀티코어 환경 지원
모듈화 및 패키지 시스템
빠른 컴파일 속도
Go 언어의 문법은 C 언어를 기반으로 하고 있으며, C++의 복잡한 문법 대신 간단하고 간결한 문법을 추구하고 있습니다.

2023년 most used language에 올라온 자료

위의 자료처럼 go는 생각보다 많이 사용되고 있습니다.

구글이 만든 언어 go.... 꼭 써봐야겠쬬!?!

이제부터 Go를 공부하며 공부하고, 프로젝트 일지를 작성하도록 하겠습니다.

[Syntax] Go언어 시작해보자! - Hello Go World!

Sat, 22 Jun 2024 00:00:00 GMT

fmt package란?

fmt는 Formatted I/O(Input / Output)을 구현한 패키지입니다.

C언어의 stdio.h, C++의 iostream과 비슷한 역할이라고 생각하시면 됩니다.

package main // 현재 이 파일의 소속 패키지를 나타냄. / 그러나 main은 프로젝트의 첫 시작, 항상 main으로 존재함.

import (
	"fmt" // fmt 패키지를 import
)

func main() { // 이 패키지에서 제일 먼저 실행되는 함수(main)
	fmt.Println("Hello Go World!!")
}

fmt를 통해서 println으로 "Hello Go World!!"를 출력합니다.

[Syntax] Go로 OOP 따라하기

Fri, 28 Jun 2024 00:00:00 GMT

go언어는 공식 문서에서도 "OOP이면서, 아니다" 요런식으로 적혀져 있는데요. 솔직히 말해서 이 "go"라는 친구는 참 뭐라 말하기 어렵네요....

이 친구는 일단 OOP의 4대 특징

상속
다형성
캡슐화
은닉화

이 네가지를 모두 가지고 있지 않습니다. Go에서는 Class와 **상속(inheritance)**를 지원하지 않고 있습니다. 그러나 비슷한 기능을 구현할 수 있는 구조체 합성을 통해서 위의 기능을 구현할 수 있는데요. 오늘은 어떻게 OOP처럼 활용할 수 있을지에 대해서 공부하겠습니다.

먼저 JAVA에서 interface처럼 함수들의 뼈대만 만들어주는 기능을 가지는 "interface"가 Go에도 존재합니다.

type IShape interface {
    PrintName() string
    GetArea() float64
}

override와 OOP를 보여드리기 위해서 Shape를 Base로 하여서 예시를 들어보겠습니다.

Shape의 interface를 선언합니다.


{function_name} {return_data_type}

이런 식으로 interface의 함수 프로토타입을 선언할 수 있습니다.

또한 변수를 저장할 컨테이너는 아래와 같이 선언할 수 있는데요?

type Shape struct {
	name string
}

struct(구조체)를 통해서 변수를 저정하는 컨테이너를 선언할 수 있습니다.

그러면 프로토타입으로 작성됐던 함수를 선언해봅시다.

func (s *Shape) PrintName() string {
	return "this shape hasn't name"
}

func (s *Shape) GetArea() float64 {
	return -1
}

*func ({함수 안에서 쓸 변수 이름) (struct_name)} {func_name} {return_data_type})

이렇게 선언이 가능합니다. 그러면 이제 코드로 옮겨서 실행을 시키고 확인해 봅시다.

var shape1 IShape = new(Shape)
var shape2 = new(Shape)
shape3 := new(Shape)
shape4 := Shape{}

fmt.Println(shape1.PrintName(), shape1.GetArea())
fmt.Println(shape2.PrintName(), shape2.GetArea())
fmt.Println(shape3.PrintName(), shape3.GetArea())
fmt.Println(shape4.PrintName(), shape4.GetArea())

위와 같이 선언을 할 수 있습니다. shape 모두 다른 객체지만 결과는 똑같이 나오게 됩니다.

</center>

그럼 이제 어떻게 활용을 할 수 있을까요?

먼저 제일 절실하게 기다리셨던 Override를 해봅시다!

type Circle struct {
	Shape
	radius float64
}

func (c *Circle) PrintName() string {
	return "Circle"
}

func (c *Circle) GetArea() float64 {
	return math.Pi * c.radius * c.radius
}

위와 같이 새로운 구조체를 선언하고, 제일 처음 줄에 상속받을 구조체를 넣으시면 됩니다. 또한 함수 선언도 똑같이 하시면 된답니다. 함수를 더 추가하고 싶으시다면 interface를 또 다시 추가하셔서 진행하실 수 있습니다.

var circle Circle = Circle{}
fmt.Println(reflect.TypeOf(circle))
circle.radius = 10
var a IShape = &circle
fmt.Println(reflect.TypeOf(a))
fmt.Println(a.PrintName())

여기서 이렇게 실행을 하게되면, 아래와 같은 결과를 가져옵니다.

</center>

이 결과를 통해서 오버라이드까지 해보았습니다.

이제 Go에 대해서 조금 더 깊이 들어가보도록 하겠습니다.

다음 포스팅에서 뵈어요!!

[Syntax] Go언어 시작해보자! - Variable(변수) 선언 및 활용

Sun, 23 Jun 2024 00:00:00 GMT

언어를 배울때 제일 먼저 배우는 것이 바로 **"자료형(data type)"**이다.

이제부터 go에서 사용하는 자료형에 대해서 알아보자!!

먼저 자료형에 대해서 알아본 후, 변수, 상수의 선언 및 초기화에 대해서 다룰 것이다.

DataType(자료형)	Range(범위)	Description(설명)
uint		부호 X, 32bit(4byte) unsigned integer(정수형)
uint8	0~255	부호 X, 8bit(1byte) unsigned integer(정수형)
uint16	0~65535	부호 X, 16bit(2byte) unsigned integer(정수형)
uint32	0~42억	부호 X, 32bit(4byte) unsigned integer(정수형)
uint64	0~(2^64)-1	부호 X, 64bit(8byte) unsigned integer(정수형)
int		부호 O, 32bit(4byte) integer(정수형)
int8	-128~127	부호 O, 8bit(1byte) integer(정수형)
int16	-32768~3267	부호 O, 16bit(2byte) integer(정수형)
int32	약 -21억 ~ 21억	부호 O, 32bit(4byte) integer(정수형)
int64	절대값이 0에서 2^64 / 2만큼 떨어진 수	부호 O, 64bit(8byte) integer(정수형)
float32		32bit 부동소수점, 7자리까지의 정밀도
float64		64bit 부동소수점, 12자리까지의 정밀도
string		문자열 저장 자료형(크기는 저장되어있는 문자열에 따라 다름)
uintptr		uint와 같은 크기 && pointer
bool		0(false), 1(true) 표현, 이상하게도 8bit
byte		8bit 자료형
rune		unicode를 저장하기 위한 자료형, int32와 동일

이러한 단순한 변수를 저장하는 방법은 'var'을 사용하여 선언할 수 있다.

var {variable_name} {data_type}

//example
var a int

위와 같은 방식으로 선언하는 방법이 있으며, 자료형을 생략하는 방법 또한 있다

var {variable_name} = {data}

//example
var a = 10

만약 선언과 동시에 초기화하지 않으면, 오류가 발생하니 무조건 선언과 동시에 초기화를 진행해야 자료형 없이 바로 선언이 가능하다.

{variable_name} := {data}

//example
a := 10

이것또한 선언과 동시에 초기화 시켜주면 변수로 인식되어 선언 및 초기화가 된다. (제일 많인 쓰는 유형)

만약 여러개의 변수를 한번에 초기화하고 싶다면?

a, b, c, d := 1, 2, 3, 4

:::note[참고] 변수를 여러개 선언하고 값을 할당할 때는 반드시 선언하는 변수와 할당하는 값의 개수가 같아야 하며 타입은 같지 않아도 괜찮습니다. :::

변수 말고 상수를 선언하고 싶다면?

전역으로 선언할 수 있다.

const(
    MAX int = 10000000
    MIN int = 0
)

func main(){
    ...
}

이런 식으로 사용이 가능하다!!

:::tip[정리]

변수 선언
- var {variable_name} {data_type}
- var {variable_name} = {data}
- {variable_name} := {data}
상수 선언
- 전역으로 선언한다.
- const(...) 안에 넣어서 상수로 선언 가능하다.
동시 선언
- {var1}, {var2}, ...., {varN} = {data1}, {data2}, ...., {dataN}
- 개수는 좌항과 우항이 같아야하지만, 자료형이 같을 필요는 없다.

:::

[Mojo] Mojo? 인공지능 시대에 걸맞는 언어

Fri, 31 Jan 2025 00:00:00 GMT

What is Mojo?

Mojo는 최근 인공지능(사실 최근은 아니고..) 붐이 일어남에 따라 인공지능 개발을 타겟팅하여 나온 언어로 현재 인공지능 쪽으로 많이 사용되는 파이썬의 대체 언어로 나오게된 언어입니다.

Why Mojo?

일단 MOJO를 알기 위해서는 조금 Python(이하 파이썬)에 대해서 알 필요가 있어요

일단 Mojo(이 포스트에서는 '모조'라 하겠음)는 과거에 파이썬을 넘어서 인공지능 전용 언어로써 엄청난 활약을 하게 될 것이다. 이런 식으로 나왔던 언어라서 저도 베타를 신청하고 먼저 써보기도 하였는데요. 일단 문법이 파이썬과 비슷하다고 하나 잘 적응되지 않았기도 하고, ide 등과 같은 환경이 잘 되어있지 않아서 사용하지 않았었는데요? 이제는 제대로 한번 해보려고 다시 가져왔습니다.

</details>

:::note[python]

일단 파이썬은 읽기 쉽고 배우기 쉬운 언어를 목표로 제작되었어요. 특히 파이썬은 Data Science, AI 분야에 정말 많이 쓰입니다. 하지만 굉장히 유명하게도 파이썬은 인터프리터 언어이기 때문에 실행 속도가 컴파일 언어에 비해서 상대적으로 느리다는 단점이 있죠. 그래서 현재까지는 많은 개발자들이 요 속도 문제 때문에 성능 이슈가 발생하는 무거운 로직 등 이런 부분들을 C++로 작성하고 Python에서 불러와 사용하는 방식을 채택하고 있는 것으로 알고 있어요. 근데 요즘 들어서 파이썬의 속도 문제가 많이 개선되고 있다고는 합니다.

:::

"파이썬은 지금 굉장히 많이 쓰이고, 특히 인공지능 분야에서 정말 많이많이많이 쓰인다!" 이게 중요한 겁니다.

그래서 이러한 상황에 놓여있는데 여기서 모조는!? 아래의 것들을 챙겼어요

Python과의 호환성
1. 기존 파이썬 코드를 그대로 사용 가능
2. 파이썬 문법과 비슷함
시스템 레벨 성능
1. 모조는 LLVM 기반으로 컴파일 됨
  1. C++에 준하는 성능을 낼 수 있음(이론상 최대 파이썬의 90000배[~~최대 파이썬의 35000배~~] )
  2. 특히 메모리 관리 및 병렬 처리에 뛰어난 성능

다음 포스팅부터는 모조 문법부터 시작해서 제가 해보고 싶었던 것들을 쭈욱 올려볼 에정입니다.

[Mojo] Get started Mojo

Fri, 31 Jan 2025 00:00:00 GMT

Get Started Mojo

https://docs.modular.com/mojo/manual/get-started/

여기를 따라서 다운로드 하시면 됩니다.

<details> <summary> 간단한 다운로드(Mac) </summary> 제가 Mac 유저라서 이정도만 작성하고 내려가겠습니다. (2025.01.31 한국 시간 기준)

:::tip[magic]

python과 mojo를 포함해서 여러 언어에 대한 Package manager이면서 virtual environment manager :::

만약에 여러분들의 mac에 'magic'이 없으면 아래의 commandline을 실행시켜 주세요!

curl -ssL https://magic.modular.com/deb187f1-a0a3-417f-aeee-d387b7638991 | bash

이후에 source로 적용시켜 주시구요.

저는 shell을 Zsh로 사용하고 있어서 아래의 커맨드 라인을 사용하구요. 혹시나 bash shell 이용하시면 <code>~/.bashrc</code>로 입력해서 적용할 수 있어요.

source ~/.zshrc

이후에 확인을 해볼까요?

magic --help

이제 적용이 잘 되었죠?

그러면 이제 프로젝트를 만들어봅시다. 일단 모조 프로젝트를 만들 곳으로 움직여 봅시다.
이후에 init을 해봅시다.

magic init life --format mojoproject

이러면 <code>ls</code> 처서 확인해보면 현재 디렉토리에 life라는 디렉토리가 생성된 것을 볼 수 있습니다. 그럼 life 들어가서 확인해보면 안에 gitignore도 있고 여러가지가 있는데요

<code> ls -A </code>로 확인해보면

.gitattributes
.gitignore
.magic
magic.lock
mojoproject.toml

이렇게 구성되어있을 겁니다.

프로젝트 매니페스트 파일 (mojoproject.toml)

프로젝트의 핵심이 되는 mojoproject.toml 파일은 모든 프로젝트 설정의 중심점 역할을 합니다. Python의 requirements.txt나 Node.js의 package.json과 유사한 이 파일에는 다음과 같은 정보들이 포함됩니다:

프로젝트 의존성(dependencies)
프로젝트 특성 및 설정
기타 프로젝트 관련 메타데이터

의존성 잠금 파일 (magic.lock)

magic.lock 파일은 프로젝트의 의존성 상태를 정확하게 추적합니다. 이 파일은 다음과 같은 정보를 포함합니다:

설치된 패키지의 정확한 버전
패키지들 간의 의존성 관계
전이 의존성(transitive dependencies)

중요: 이 파일은 절대 직접 수정하지 마세요. mojoproject.toml을 수정하면 magic 명령어가 자동으로 업데이트합니다.

가상 환경 디렉토리 (.magic)

.magic 디렉토리는 프로젝트의 격리된 개발 환경을 제공합니다. 이 디렉토리에는:

conda 가상 환경
프로젝트별 패키지 설치
환경 설정 정보

가 포함되어 있습니다.

Git 관련 파일

프로젝트는 버전 관리를 위한 기본 설정도 제공합니다:

.gitignore: 버전 관리에서 제외할 파일 목록
.gitattributes: Git 속성 설정

</details>

이제 프로젝트가 올바르게 설정되었는지 확인을 해볼까요?

magic run mojo --version

이제 요 명령어를 통해서 설정된 가상환경에 들어가게 됩니다. 그리고 현재 설치된 모조 버전도 확인시켜 줍니다.

:::note[참고]

이번에 따라오시면서 option으로 <code> --format mojoproject </code>을 넣고 프로젝트를 생성했다면, magic PM에서 자동으로 mojo를 포함하는 MAX 패키지를 의존성으로 알아서 추가합니다. :::

그러면 가상환경에 들어가는 것까지 해보죠.

magic shell

</details>

Hello, Mojo world!

국룰부터 해보고 들어가자!

(일단 모조는 main 함수를 꼭 필요로 합니다.)

fn main():
    return
def main():
    return

이렇게 함수는 두가지 방식으로 선언할 수 있어요.(물론 함수는 하나의 고유한 이름만으로 사용합니다.)

def main():
    print("Hello, Mojo world!")

자 이렇게 되었어요.

그러면 이걸 실행해 봐야겠죠?

일단 가상환경에 들어가있지 않다면 현재 터미널을 가상환경에 접속시켜 봅시다.

magic shell

그리고 현재 Hello, Mojo world!를 적은 .mojo 파일을 실행하기 위해서는

mojo $그파일이름.mojo

로 실행시킬 수 있어요! 그러면
바로 결과를 확인할 수 있어용!

만약에 내가 build를 하고 싶다!?!

mojo build $그파일이름.mojo

이렇게 빌드한 후 <code> $그파일이름</code> 으로 저장되는데 그냥 <code> ./$그파일이름 </code>으로 실행시킬 수 있어요!

여기까지 다운로드 및 빠른 시작하기 튜토리얼있구요!
다음부터는 문법을 쭉 살펴보도록 하죠!

Reference

Mojo docs

[Mojo] Function(Part 1)

Fri, 07 Feb 2025 00:00:00 GMT

Mojo의 function system

1. function define(def vs. fn)

1.1 def

먼저 모조는 기본적으로 파이썬과의 호환성을 챙기고 있으므로 파이썬에서 사용하는 방식을 그대로 사용할 수 있습니다

그래서 <code> def</code> keyword를 이용해서 함수를 정의할 수 있습니다

def sum(a, b):
    return a+b

이렇게 정의할 수 있습니다. 물론 명시적으로 타입을 적어서 더 안전하게 처리할 수도 있죠

def sum1(a: Int32, b: Int32) -> Int32:
    return a + b

def sum2(a: Int32, b: Int32):
    return a + b

def sum3(a, b) -> Int32:
    return a+b

<code> error: cannot implicitly convert 'object' value to 'SIMD[int32, 1]' return a+b</code>

이거를 보면 알 수 있듯이 return datatype이 정해져 있어서 object로 들어오는 a, b의 type을 변환하는데 이때 모조가 암시적 타입 변환(implicit type conversion)을 못해서 터지는 오류입니다 </details>

뭐 어떻게든지 선언할 수 있어요

그래서 이걸 좀 정리를 해보자면

인자 타입을 명시하지 않아도 됨
리턴 타입을 명시하지 않아도 됨
타입을 명시하지 않은 인자는 <code>object</code> 타입으로 처리
인자는 가변적(mutable)
객체 타입 인자는 참조로 전달
다른 선언된 타입의 인자는 값으로 전달

이렇게 됩니다!

1.2 fn

<code> fn</code>같은 경우에는 좀 많이 엄격합니다. <code>def</code>의 경우 선택적이었던 타입 명시를 강제하고 있거든요!

fn sum1(a: Int32, b: Int32) -> Int32:
    return a + b

이렇게만! 사용할 수 있어요

바로 또 정리를 해봅시다.

모든 인자의 타입을 명시해야 함
리턴 타입을 명시해야 함 (값을 반환하지 않는 경우 제외)
기본적으로 인자는 불변 참조로 전달
오류를 발생시키는 경우 raises 키워드를 명시해야 함

이렇게 정리할 수 있습니다.

2. 함수의 활용

지금부터는 <code> fn</code> 키워드를 주로 사용하겠습니다.

2.1 함수 인자

2.1.1 선택적 인자

fn pow(base: Int, exp: Int = 2) -> Int:
    return base ** exp

이렇게 기본값을 지정할 수 있음.

2.1.2 키워드 인자

var value_case_1 = pow(base=3, exp=5) 

var value_case_2 = pow(exp=3, base=5)

호출을 이렇게 활용할 수도 있습니다.

2.1.3 가변 인자

fn sum(*values: Int) -> Int:
    var sum: Int = 0
    for value in values:
        sum = sum + value
    return sum
fn main():
    var value_case_1 = sum(10)
    print(sum(1, 2, 3))  # -> 6
    print(sum(10, 20, 30, 40))  # -> 100
    print(value_case_1) # -> 10
    return

이렇게 활용할 수 있어요!

2.1.4 키워드 전용 인자

fn kw_only_args(a1: Int, a2: Int, *, double: Bool) -> Int:
    var product = a1 * a2
    if double:
        return product * 2
    else:
        return product
fn kw_only_args2(a1: Int, a2: Int, *, multi: Bool, amount: Int) -> Int:
    var product = a1 * a2
    if not multi: return product
    return product ** (amount+1)
fn main():
    print(kw_only_args(1, 2, double=True))
    print(kw_only_args2(1, 2, multi=True, amount = 3))
    return

여기서 보면 중간에 <code>*</code>가 중요한데 이 기호 뒤에오는 모든 매개변수가 키워드 전용 인자라고 말하는 겁니다

이때 키워드를 직접 명시하지 않는다면?

print(kw_only_args2(1, 2, True, amount = 3))

이렇게되면 오류가 터지게 됩니다.

2.1.5 함수 오버로딩

fn add(x: Int, y: Int) -> Int:
    return x + y

fn add(x: String, y: String) -> String:
    return x + y

:::note[오버로딩]

나온 김에 정리하고 갑시다.(원래 저는 자바를 먼저 사용했기에..)

같은 이름의 메서드를 여러 개 정의할 수 있게 해주는 기능인데,

    // 정수 두 개를 더하는 메서드
    public int add(int a, int b) {
        return a + b;
    }
    
    // 실수 두 개를 더하는 메서드
    public double add(double a, double b) {
        return a + b;
    }
    
    // 정수 세 개를 더하는 메서드
    public int add(int a, int b, int c) {
        return a + b + c;
    }

자바에서는 이런 식으로 예시를 들 수 있습니다.

조건은

메서드 이름이 같아야 함
매개변수의 개수나 타입이 달라야 함
반환 타입은 오버로딩을 구분하는 기준이 되지 않음!

이렇게 되겠습니다.

fn add(x: Int, y: Int) -> Int:
    return x + y

fn add(x: Int, y: Int, z: Int) -> Int:
    return x + y + z

fn add(x: Float32, y: Float32) -> Float32:
    return x + y

fn add(x: String, y: String, delimiter: String) -> String:
    return x + delimiter + y

fn main():
    print(add(5, 3))                    # 두 정수의 합: 8
    print(add(1, 2, 3))                 # 세 정수의 합: 6
    print(add(3.14, 2.86))              # 두 실수의 합: 6.0
    print(add("Hello", "World", " "))   # 구분자를 포함한 문자열 연결: "Hello World"

이런식으로 사용할 수 있겠습니다!

:::

2.2 오류 처리

2.2.1 오류를 발생시키는 함수

def raises_error():
    raise Error("This is the error")

fn handle_error():
    try:
        raises_error()
    except e:
        print("Handled an error," e)

<code>fn</code> 함수에서 오류를 발생시키려면 <code>raises</code> 키워드를 사용해야 합니다. <code>raises</code> 키워드가 없는 <code>fn</code> 함수는 오류를 전파할 수 없습니다.

def divide(a: Int, b: Int) -> Float64:
    if b == 0:
        raise Error("0으로 나눌 수 없습니다!")
    return a / b

fn safe_divide(a: Int, b: Int) -> Float64:
    try:
        return divide(a, b)
    except e:
        print("나눗셈 오류 발생:", e)
        return 0.0
fn main():
    print(safe_divide(10, 0)) # 나눗셈 오류 발생: 0으로 나눌 수 없습니다! \n 0.0
    print(safe_divide(10, 1)) # 10.0

이렇게 활용할 수 있겠네요!

포스트가 길어지고, 추가로 다뤄야할 내용이 있어서 파트를 나눠서 하도록 하겠습니다!

go to Part 2

Reference

Mojo docs

[Mojo] Function(Part 2)

Tue, 11 Feb 2025 00:00:00 GMT

Mojo의 function system

Part 1 2.3 Return

2.3.1 기본 반환

def helloWorld() -> String:
    return "Hello, World!"

기본적으로 값은 소유권이 이전된 상태로 호출자에게 반환
반환 타입으로의 암시적 변환이 가능

2.3.2 참조 반환(Returning a Reference)

참조 반환은 값의 복사본을 만들지 않고서 원본 데이터에 대한 접근을 제공하는 방법입니다

함수는 가변 또는 불변 참조를 반환할 수 있는데요 조금 더 들어가보죠!

불변 참조(Immutable Reference)
가변 참조(Mutable Reference)

이렇게 두가지가 있습니다.

2.3.2.1 불변 참조(Immutable Reference)

fn get_number(numbers: List[Int]) -> Int:
    return numbers[0]

fn main():
    var numbers = List[Int](0,0,0,0)
    numbers[0] = 42

    var num_ref = get_number(numbers)
    print(num_ref)  # 출력: 42

지금 이 코드를 보게 된다면 코드에서 get_number를 호출할 때, 그 함수 안에서는 numbers를 수정할 수 없습니다. 이게 불변 참조입니다.

2.3.2.2 가변 참조(Mutable Reference)

fn get_number(mut numbers: List[Int], to: Int) -> Int:
    numbers[0] = to
    return numbers[0]

fn main():
    var numbers = List[Int](0,0,0,0)
    numbers[0] = 42

    var num_ref = get_number(numbers, 100)
    
    print(num_ref)  # 출력: 100
    print(numbers[0]) # 출력: 100

이렇게 <code> mut</code> 키워드를 사용해서 가변 참조를 할 수 있게 합니다. 그러면 함수 안에서 바꾼 내용이 밖에서도 유지가 됩니다.

사용 목적을 좀 찾아봤더니?

불변 참조: 데이터를 안전하게 공유하고 읽을 때
가변 참조: 원본 데이터를 수정해야 할 때

이렇다고 합니다.

2.3.3 명명된 결과값(Named Results)

이동, 복사가 불가능한 값을 반환할 때 사용합니다

struct ImmovableObject:
    var name: String

    fn __init__(out self, owned name: String):
        self.name = name^

def create_immovable_object(owned name: String, out obj: ImmovableObject):
    obj = ImmovableObject(name^)
    obj.name += "!"
    # 요 obj는 반환됩니다. out으로 나가는건데요 저게 main의 my_obj에 들어갑니다.
def main():
    my_obj = create_immovable_object("test!")
    print(my_obj.name)


def create_immovable_object2(owned name: String) -> ImmovableObject:
    obj = ImmovableObject(name^)
    obj.name += "!"
    return obj^ # Error: 복사나 이동 안되기 때문에 오류남.

</details>

<code>out</code> 인자 규칙을 사용하여 초기화되지 않은 변수를 지정
함수는 하나의 <code>out</code> 인자만 가질 수 있음
명시적 <code>return</code> 문이 필요하지 않음

2.4 매개변수(parameter) 및 인자(argument)

2.4.1 가변 인자

2.4.1.1 동종 가변 인자(Homogeneous Variadic Arguments)

같은 타입의 입력들을 이렇게 연속적으로 입력할 때 받는 것입니다. 파이썬을 해보셨다면 굉장히 익숙하실 겁니다.

fn sum(*values: Int) -> Int:
  var sum: Int = 0
  for value in values:
    sum = sum+value
  return sum
def main():
    print(sum(1,2,3,4,5,6,67))
    return

이렇게 사용도 가능하다! 생각보다 많이 쓰는 방법

:::tip[tip]

아직까지는 모조가 전부 개발된 것도 아니여서, <code>Homogeneous Variadic Arguments</code>를 사용할 때, 아직 타입에 따라서 처리하는 방법이 다르고 합니다.

Inside the function body, the variadic argument is available as an iterable list for ease of use. Currently there are some differences in handling the list depending on whether the arguments are register-passable types (such as Int) or memory-only types (such as String)

<code>Register-passable types</code>은 iterate할 수 있다는데, 그니까 int같은 친구들이요. 그런데 String 이런 애들은 안된데요.

근데 이런 차이점을 줄여갈 것이라고 써 놨으니 기대해 봅시다. :::

그러면 String은 뭐 어떻게 해야될까요?

def make_worldly(mut *strs: String):
    for i in strs:
        i[] += " world"

fn main():
    var str1: String = "hello"
    var str2: String = "hi"
    try: make_worldly(str1, str2)
    except e: pass
    print(str1)
    print(str2)

이렇게 사용이 가능합니다!

2.4.1.2 이질 가변 인자 (Heterogeneous Variadic Arguments)

이질 가변 인자... 어.. 이게 번역을 어떻게 해야 될까요..? 동질의 반대말이라서 그냥 이렇게 적는데

<code>Heterogeneous Variadic Arguments</code>은 같은 타입이 아닌 애들도 같이 입력으로 받아버리는 겁니다. 그래서 타입 안전성을 챙깁니다.

그대신 여러 인자 타입들을 한번에 처리해되기 때문에 일반화하는 코드나 이런 것들이 요구됩니다.

독스에서는 특성과 매개변수가 필요하다고 합니다.

def count_many_things[*ArgTypes: Intable](*args: *ArgTypes):

기본적으로 생김새는 이렇게 생겼습니다.

여기서 두가지 중요한 것을 쪼개서 보도록 하죠

<code>[*ArgTypes: Intable]</code> - 인자 리스트
- <code>ArgTypes</code>는 타입들의 리스트를 나타냄
- <code>Intable</code>은 정수로 변환 가능한 타입이라는게 제약조건
<code>(*args: *ArgTypes)</code> - 인자 리스트
- 익숙한 <code>*args</code> 문법을 사용
- 각 인자의 타입은 <code>ArgTypes</code> 리스트에 정의

def count_many_things[*ArgTypes: Intable](*args: *ArgTypes):
    var total = 0
    @parameter
    fn add[Type: Intable](value: Type):
        total += Int(value)
    args.each[add]()
    return total
fn main() raises:
    # 다양한 숫자 타입을 섞어서 호출할 수 있습니다
    var result1 = count_many_things(5, 11.7, 12)
    print(result1)  # 출력: 28

    # 단일 타입만 사용할 수도 있습니다
    var result2 = count_many_things(1, 2, 3, 4)
    print(result2)  # 출력: 10

    # Float 값들도 자동으로 Int로 변환됩니다
    var result3 = count_many_things(1.1, 2.7, 3.2)
    print(result3)  # 출력: 7

이렇게 사용할 수 있구요.

여기서는 모조가 자동으로 타입을 인식해서 <code>ArgTypes</code> 리스트를 생성합니다. <code>args</code>는 <code>VariadicPack</code>으로 제공되어, <code>each()</code> 메서드로 순회할 수 있습니다

각 인자마다 <code>add</code> 함수가 호출되며, 적절한 타입과 값이 전달됩니다 예를 들어서 위의 코드에서 result1을 보도록 합시다.

첫 번째 호출: Type=Int, value=5
두 번째 호출: Type=Float64, value=11.7
세 번째 호출: Type=Int, value=12

이렇게 되겠네요!

근데 여기서 조금 나아가서 최적화를 해봅시다. 만약에 단일 인자로 들어오는 경우가 많다면, 아래 코드처럼 최적화가 가능합니다!

fn print_string(s: String):
    print(s, end="")

fn print_many[T: Stringable, *Ts: Stringable](first: T, *rest: *Ts):
    print_string(String(first))

    @parameter
    fn print_elt[T: Stringable](a: T):
        print_string(" ")
        print_string(String(a))
    rest.each[print_elt]()

단일 인자 호출 시 <code>VariadicPack</code> 생성을 건너뛸 수 있음
첫 번째 인자는 직접 처리되어 더 효율적
나머지 인자들만 <code>VariadicPack</code>으로 처리

어때요 굉장히 엄청나죠!?

2.4.2 가변 키워드 인자

fn print_nicely(**kwargs: Int) raises:
    for key in kwargs.keys():
        print(key[], "=", kwargs[key[]])

fn main() raises:
    print_nicely(a=7, y=8)

가변 키워드 인자는 항상 <code>owned</code> 인자 규칙으로 취급
모든 가변 키워드 인자는 동일한 타입
인자 타입은 <code>CollectionElement</code> trait를 준수

2.4.2.1 위치 전용 인자(Positional-only Arguments)

fn min(a: Int, b: Int, /) -> Int:
    return a if a < b else b

이 <code>/</code>는 위치 전용 인자이다. 라는 것을 나타냅니당.

fn min(a: Int, b: Int, /) -> Int:
    return a if a < b else b
fn main() raises:
    result = min(5, 3)  # 정상 작동
    result = min(a=5, b=3)  # 컴파일 에러!
    print(result)

그래서 이렇게 활용됩니다.

:::note[왜 사용할까?]

의미가 명확해짐 왜냐하면 min에서는 작은 값을 반환하는데 그 순서가 중요하지 않습니다. 그래서 그냥 '비교' 한다는 것이 더 직관직이겠죠?

인터페이스 안전성 이거는 확실한 장점인데 뭐 입력 파라미터의 이름을 바꾸더라도 이후 다른 곳에서 오류가 안 터지겠죠? 아주 좋습니다. :::

2.4.2.2 키워드 전용 인자 (Keyword-only Arguments)

fn sort(*values: Float64, ascending: Bool = True):

fn sort(*values: Float64, ascending: Bool = True) -> List[Float64]:
    var sorted_list = List[Float64]()

    for i in values: sorted_list.append(i)


    for i in range(len(sorted_list)):
        for j in range(len(sorted_list) - 1 - i):
            if ascending:
                if sorted_list[j] > sorted_list[j + 1]:
                    sorted_list[j], sorted_list[j + 1] = sorted_list[j + 1], sorted_list[j]
            else:
                if sorted_list[j] < sorted_list[j + 1]:
                    sorted_list[j], sorted_list[j + 1] = sorted_list[j + 1], sorted_list[j]

    return sorted_list
fn main() raises:
    var sorted = sort(1.0, 2.0, 3.0, 4.0, 5.0, 67.0, 0.0, ascending=True)
    for i in range(len(sorted)):
        print(sorted[i])

<code>ascending</code>이 없어도 <code>True</code>로 들어가구요 직접 지정해서 <code>False</code>로 바꿀 수 있어요.

sort(1.1, 2.2, 3.3, False)  # 컴파일 에러!

이렇게 호출은 불가능합니다!

:::note[왜 사용할까?]

명확한 의도 표현 정렬로 예시를 든 것처럼 오름차순, 내림차순의 여부는 정렬에 있어서 굉장히 중요합니다. 이때 이렇게 명시하는 것이 코드 의도가 확 보이겠죠?

안전성과 유연성 나중에 새로운 키워드를 추가하더라도 기존 코드가 바뀌지 않습니다. 아주 좋죠? :::

여기까지 기본적인 코드에 대해서 알아봤구요. 담부터는 struct를 배우고 활용으로 pygame과 합께 적용시켜 보도록 하겠습니다!

Reference

Mojo docs

[Mojo] Variables

Sat, 01 Feb 2025 00:00:00 GMT

Mojo의 변수 선언과 사용

:::tip[mojo setup]

Go to MojoSetup :::

1. 변수의 종류

Mojo에서는 모든 변수가 가변적(mutable)이며, 두 가지 방식으로 변수를 선언할 수 있습니다

1.1 명시적 변수 선언 (Explicitly-declared variables)

var 키워드를 사용하여 변수를 선언합니다. 타입 어노테이션을 포함할 수 있습니다

var a = 5
var b: Float64 = 3.14

초기화 없이 선언 가능: <code>var value: Float64</code>
렉시컬 스코핑(lexical scoping) 따름
타입 어노테이션 사용 가능

1.2 암시적 변수 선언 (Implicitly-declared variables)

할당 문장으로 직접 변수를 생성합니다

a = 5
b = 3.14

함수 레벨 스코핑
첫 할당값의 타입으로 변수 타입이 결정됨

2. 타입 시스템

2.1 강타입 시스템 (Strong typing)

:::tip[지식]

모든 변수는 강타입입니다 :::

생성 시 타입이 결정되며 변경 불가
다른 타입의 값 할당 시 에러 발생

count = 1        # count는 Int 타입
count = "One"  # 에러: StringLiteral을 Int로 변환 불가

2.2 암시적 타입 변환 (Implicit conversion)

:::tip[지식]

일부 타입은 다른 타입으로부터의 암시적 변환을 지원 :::

var test: Float64 = 50  # Int에서 Float64로 자동 변환
print(test)  # 출력: 50.0

3. 스코프 규칙

3.1 var 키워드 사용 시 (렉시컬 스코프)

def lexical_scopes():
    var num = 1
    if num == 1:
        var num = 2     # 새로운 변수 생성 (shadowing)
        print(num)      # 2 출력
    print(num)          # 1 출력 (외부 스코프 변수)

3.2 암시적 선언 시 (함수 레벨 스코프)

def function_scopes():
    num = 1
    if num == 1:
        num = 2        # 함수 레벨 변수 수정
        print(num)     # 2 출력
    print(num)         # 2 출력

4. 타입 어노테이션 (Type Annotations)

4.1 기본 사용법

타입 어노테이션을 사용하면 변수의 타입을 명시적으로 지정할 수 있습니다

var name: String = get_name()

var 키워드와 함께 사용해야 함
코드의 가독성과 의도를 명확히 전달
함수 반환값의 타입을 모르더라도 변수 타입을 명시 가능

4.2 단일 인자 생성자를 가진 타입의 초기화

:::tip[지식]

단일 인자 생성자를 가진 타입은 두 가지 방식으로 초기화 가능 :::

var name1: String = "Sam"      # 타입 어노테이션 사용 
var name2 = String("Sam")      # 직접 생성자 호출

5. 지연 초기화 (Late Initialization)

:::tip[지식]

타입 어노테이션을 사용하면 변수를 나중에 초기화 가능 :::

fn my_function(x: Int):
    var z: Float32              # 타입만 선언
    if x != 0:
        z = 1.0                 # 조건에 따라 초기화
    else:
        z = foo()
    print(z)

초기화되지 않은 변수 사용 시 컴파일 에러 발생
타입 선언이 반드시 필요
값 할당 전 사용 불가

6. 암시적 타입 변환의 조건

암시적 타입 변환이 가능 조건:

대상 타입이 @implicit 데코레이터로 표시된 생성자를 가짐
해당 생성자가 변환하려는 값과 일치하는 단일 필수 인자를 받음

var number: Float64 = Int(1)   # Int를 Float64로 암시적 변환
print(number)                  # 출력: 1.0

==> 아래와 같이 표현할 수 있어요

var number = Float64(1)        # 직접 생성자 호출

함수 호출할 때도 암시적 변환이 적용됩니다

fn take_float(value: Float64):
    print(value)

fn pass_integer():
    var value: Int = 1
    take_float(value)          # Int가 Float64로 자동 변환

:::warning[조심조심]

일반적으로 암시적 변환은 데이터 손실이 없는 경우에만 지원합니다 :::

<details> <summary> Function Scope in Mojo </summary>

함수 레벨 스코프 vs 렉시컬 스코프

Mojo에서는 변수 선언 방식에 따라 두 가지 다른 스코프 규칙이 적용됩니다

1. 암시적 선언의 함수 레벨 스코프

암시적으로 선언된 변수(var 키워드 없이 선언)는 Python과 같은 함수 레벨 스코프를 따릅니다

def demonstrate_function_scope():
    count = 0                    # 함수 레벨에서 변수 선언
    
    if True:
        count = 5               # 같은 변수를 수정
        temp = 10              # 새로운 변수 선언
        print(count)           # 출력: 5
        
    print(count)               # 출력: 5 (if 블록의 변경사항이 유지됨)
    print(temp)                # temp도 접근 가능 (함수 전체가 스코프)

변수는 함수 전체에서 동일한 스코프를 공유
내부 블록에서 수정된 값은 함수 전체에 영향
새로 선언된 변수도 함수 전체에서 접근 가능
Python 스타일의 변수 스코핑과 동일

2. var 키워드의 렉시컬 스코프

반면, var로 선언된 변수는 렉시컬 스코프를 따릅니다

def demonstrate_lexical_scope():
    var count = 0              # 외부 스코프 변수
    var outer = 1
    
    if True:
        var count = 5          # 새로운 변수 생성 (shadowing)
        var inner = 2          # 내부 스코프 변수
        print(count)           # 출력: 5
        print(outer)           # 외부 변수 접근 가능
        
    print(count)              # 출력: 0 (외부 변수는 변경되지 않음)
    # print(inner)            # 에러! inner는 if 블록 밖에서 접근 불가

각 블록이 고유한 스코프를 생성
내부 스코프에서 외부 변수 접근 가능
같은 이름의 변수 선언 시 shadowing 발생
내부 스코프의 변수는 해당 블록 밖에서 접근 불가

3. 두 스코프 규칙의 실제 응용

두 스코프 규칙을 혼합해서 사용할 때

def mixed_scope_example():
    var x = 0                 # 렉시컬 스코프 변수
    y = 0                     # 함수 스코프 변수
    
    if True:
        var x = 1             # 새로운 x 생성 (shadowing)
        y = 1                 # 기존 y 수정
        var z = 2             # 렉시컬 스코프의 새 변수
        w = 3                 # 함수 스코프의 새 변수
        
    print(x)                  # 출력: 0 (원래 x 유지)
    print(y)                  # 출력: 1 (수정된 y)
    # print(z)               # 에러! z는 if 블록 스코프
    print(w)                  # 출력: 3 (함수 스코프라 접근 가능)

함수 레벨 스코프는 Python 개발자들에게 친숙한 동작을 제공
렉시컬 스코프는 더 엄격한 변수 관리와 안전성을 제공
두 스코프 규칙을 상황에 맞게 적절히 선택하여 사용 가능 </details>

Reference

Mojo docs

[Crypto] 공격

Thu, 27 Jun 2024 00:00:00 GMT

암호학에서 몇 가지 공격에 대해서 이야기 해보려고 합니다.

:::note[이 포스트에서는] 여기서는 암호 스키마에 대응하는 공격에 초점을 맞춰서 다루겠습니다. 많은 종류의 공격이 있으며 심각도 또한 각기 다릅니다! :::

1. 암호문 단독 모델

암호문 단독 공격(Ciphertext-Only Attack)은 대다수 사람들이 암호 시스템을 부순다고 이야기할 때, 쓰는 의미입니다. 이 상황에서는 제임스와 소피아가 데이터를 암호화한 후 공격자가 볼 수 있는 것은 암호문 자체뿐! 단지 암호문 자체로 메시지를 복호화하려는 시도를 암호문 단독 공격입니다.

가장 정보가 적으므로 가장 어려운 유형의 공격입니다.

2. 알려진 평문 모델

알려진 평문 공격(Known-Plaintext Attack) 은 공격자가 평문과 암호문을 모두 알고있는 공격입니다.

이 공격의 최종 목표는 복호키를 찾는 것입니다. 이 설명을 읽으면서 이상하진 않으신가요? 어떻게 공격자가 평문을 알 수 있을까?라고, 하지만 통신상 평문을 알아낼 수 있는 상황은 굉장히 많습니다. 때로는 예상하기 쉬운 메시지도 있습니다.

예를 들어보겠습니다. 제임스가 밥을 먹고있는 동안에 모든 수신 메일에 대해서 '나 밥먹는 중 좀만 기다리셈'이라는 자동 응답 메일을 보낸다고 해봅시다. 공격자는 제임스에게 메일을 보내 자동 응답 메시지 사본을 발송하는데, 이때 메시지가 암호화됩니다. 이제 공격자는 메시지의 평문과 암호문.. 둘 모두를 획득합니다.

공격자가 키를 발견한다면 제임스와 소피아가 같은 키로 교환한 모든 다른 메시지도 복호화할 수 있습니다. 후자는 중요한 문제이고 공격자가 키를 얻기 위해서 일부 평문-암호 쌍을 사용하고, 다른 암호문을 복호호하기 위해서 해당키를 사용하는 행위를 반복하면 안됩니다.

다른 전형적인 상황을 예시로 들어보겠습니다. 제임스가 공격자를 포함해 같은 메시지를 대다수 사람에게 보낼 때입니다. 공격자는 평문과 다른 사람에게 보낸 사본의 암호문을 가집니다. 제임스와 소피아는 굉장히 중요한 파일을 전송 중일 수도 있습니다. 이 파일이 공개된다면, 공격자는 평문과 암호문을 알 수 있게 되겠죠...

공격자가 전체 평문을 다 알지 못하더라도 일부를 알아낼 수 있는데요. 이메일은 추정이 가능한 첫 부분과 고정된 서명이 맨 끝에 나옵니다. IP 패킷헤더는 추정하기 매우 쉬워서, 추정 가능한 데이터가 일부 알려진 평문이라면 알려진 평문 공격이 가능한 상황으로 분류가 됩니다.

알려진 평문 공격은 암호문 단독 공격보다 훨씬 강력합니다. 공격자는 암호문 단독인 경우보다는 더 많은 정보를 얻습니다. 추가 정보 또한 공격자에게 도움이 됩니다.

3. 선택 평문 모델

다음 단계는 공격자가 평문을 선택할 수 있는 형태인데 알려진 ㅍ여문 공격보다 엄창엄청 강력한 유형의 공격입니다. 이제 공격자는 앙호 시스템을 공격하기 쉽게 특별히 준비된 평문을 선택할 것 입니다. 공격자는 얼마든지 평문을 선택(Chosen-Plaintext)해 해당하는 암호문을 얻을 수 있습니다. 이 공격이 비현실적이라고 생각하시는 분들도 계신데... 비현실적이지 않습니다.

공격자가 암호화하는 데이터를 선택할 수 있는 상황은 꽤 많이 있습니다. 또 다시 제임스는 상당수 외부 자료(이 외부 자료는 공격자의 영향을 받을 수도 있다.)에서 정보를 얻어 암호화된 형태로 밥에게 그 정보를 포워딩한다.

예를 들자면, 공격자가 제임스가 소피아에게 포워딩할 것이라는 사실을 알고 바로 그 이메일을 전송한다고 해봅시당. 에잇ㅅ 선택 평문 공격은 아무튼 비현실적인 공격이 절대 아닙니다. 좋은 암호 알고리즘은 선택 평문 공격에도 문제가 생기지 않습니다. 누군가가 본인이 운영하는 시스템과 선택 평문 공격은 관련 없다고 확신한다면 의심해보세용.

이 공격에는 두 가지 변종이 존재하는데요? 공격자가 암호문을 얻기 전 암호화하려는 평문 전체 리스트를 준비하는 오프라인 공격과, 이미 수신한 암호문을 가지고 새로운 평문을 선택하는 온라인 공격이 있습니다. 대부분의 경우 이 구분은 무시해도 좋습니다. !온라인 공격이 오프라인 공격보다 더 강력한 공격!

4. 선택 암호문 모델

선택 암호문(Chosen_Ciphertext)란 용어는 부적절한 명칭입니다. 실제로는 선택 암호문 평문 공격이라고 불러야합니다. 그런데 솔직히 너무 길어서 짧게 부른다고 합니다. 선택 평문 공격에서 공격자는 평문 값을 선택합니다. 선택 암호문 공격에서는 평문 값과 암호문 값 모두를 선택합니다. 공격자가 선택하는 모든 평문에 대해 대응하는 암호문을 얻고 공격자가 선택한 각 암호문에 대응하는 평문을 얻습니다.

공격자가 더 자유로울 수 있다는 점에서 확실히 선택 암호문 공격은 선택 평문 공격보다 훨씬 강력합니다. 목표는 역시 키를 알아내는 것입니다. 키를 이용해 공격자는 다른 암호문을 해독할 수 있습니다. 그만큼 잘 설계된 암호 스키마는 선택 암호문 공격을 방어하는데 문제가 없습니다.

5. 특정 공격 목표

자 요놈은 꽤 특이한 친구인데요, 1,2,3,4까지는 평문이나 복호화키를 알아내는 것이었습니다. 키를 복구하지 못하지만 공격자가 특정한 메시지를 복호화할 수 있는 공격도 있습니다. 메시지를 복구하지 못하지만 메시지에 대한 일부분 정보를 드러내는 공격도 있습니다.

예를 들자면, 선택된 10개의 평문과 그에 대응하는 암호문, 그리고 11번째 암호문이 주어졌을 때 대응하는 복호키를 알지 못하더라도 11번째 메시지의 최하위 비트가 0인지 1인지는 알수 있을 겁니다. 무척 다양한 형태의 공격이 있으니, 일일이 다 열거할순 없습니다만 공격자들은 항시 새로운 형태의 공격을 고안해 왔을겁니다(아마).

그렇다면 어떻게 방어할 수 있을까요? 우리는 특정 공격을 방어하고자 합니다. 특정 공격은 이상적인 암호 스키마와 실제 암호 스키마 사이의 차이점을 탐지하는 어려운 방법입니다. 이 공격은 아직 발견되지 않은 종류의 공격뿐 아니라 지금까지 설명한 모든 공격을 포함합니다. 물론 무엇이 이상적인 스키마인지 정의해야 되겠지만요.

6. 다른 형태의 공격(부채널, 생일, meet-in-the-middle 등)

이와 관련하여서는 조금 더 자세히 다뤄볼 예정이니 다른 포스팅에 또 뵐게요!

[Crypto] 기초지식 - 1

Fri, 04 Oct 2024 00:00:00 GMT

:::note[이 포스트에서는]

암호학을 조금이라도 이해하기 위한 기초를 다루는 포스트의 첫번째 단계입니다.

:::

정수론(기초)

1. 최대공약수(Greatest Common Divisor)

최대공약수를 알기 위해서는 약수(Divisor) 를 알아야한다. 약수는 자연수 A, B가 있을 때, 두 수 A, B를 나누어 떨어지게 만드는 수를 말한다.

최대공약수는 당연히 그 약수 중 제일 큰 수를 말한다.

자! 근데 우리는 A, B가 주어졌을 때 어떻게 최대공약수를 알 수 있을까???

직관적이게 구현해볼까요??

a, b = map(int, input().split())
result = []
for i in range(1, max(a, b)+1):
    if a % i == b % i == 0: result.append(i)

print(result[-1])

</center> (이미지가 생각보다 많이 작네요..ㅎㅎ)

자 이렇게 최대공약수를 얻는 코드를 작성해보았습니다.

그런데 이 코드는 O(max(a, b))의 시간복잡도를 가지고 있죠?? 하지만 암호학에서는 진짜 뭔 말도 안되는 큰 수들이 왔다갔다 거립니다...

이보다 더 빠른 알고리즘을 설계해 볼까요?

이때 사용할 알고리즘은 무엇이냐! 바로 유클리드 호제법(Euclidean algorithm) 을 사용할 겁니다!

:::note[유클리드 호제법]

2개의 자연수(또는 정식) a, b에 대해서 a를 b로 나눈 나머지를 r이라 하면(단, a>b), a와 b의 최대공약수는 b와 r의 최대공약수와 같다. 이 성질에 따라, b를 r로 나눈 나머지 r'를 구하고, 다시 r을 r'로 나눈 나머지를 구하는 과정을 반복하여 나머지가 0이 되었을 때 나누는 수가 a와 b의 최대공약수이다.

:::

요런 유클리드 호제법을 구현해볼까?


def gcd_1(a, b):
    while b != 0: a, b = b, a % b
    return a
def gcd_2(a, b): # 함수 오버헤드 때문에 약간 느릴 수도
    return a if not b else gcd_2(b, a % b)

유클리드 호제법을 사용한 최대공약수(GCD) 알고리즘의 시간 복잡도는 ${O(\log(\min(a, b)))}$ 이죠? 굉장히 효율적입니다.

</center>

:::tip[GCD를 이용한 최소공배수(LCM) 구하기]

def lcm(a, b):
    return abs(a * b) // gcd(a, b) # overflow를 방지하기 위해서는 a*b를 분리해서 계산하면 됨.

:::

2. 나머지 연산(Modular Arithmetic)

나머지.. 우리는 % 연산자를 이용해서 나머지르 가져오죠? 그래서 % 연산을 mod 연산이라고 합니다.

그래서 이제 뭘 할거냐? 자 여러분 자연수 % 자연수는 너무나 쉽게 할 수 있겠죠..?

그러나 -12 % 7 은 어떻게 계산하실 거죠??

우리는 다음과 같은 규칙을 알아야 합니다.

결과는 항상 0이상이고, 나누는 수(예시에서는 7이죠?) 미만이어야 한다.
(나누어지는 수) = (몫) * (나누는 수) + (나머지) 의 관계가 성립한다.

이거는 사실 중학교 때 배우는 것이긴 합니다..

그래서 -12 % 7의 과정을 얘기해 보겠습니다.

-12를 7로 나눈 몫을 구한다. -> -1.xxxx (소수점 내림)
-12 = -2 * 7 + 2

2번의 과정이 왜 나오냐!

2 % 7 = 2
(2+7) % 7 = 2
(7*2+2) % 7 = 2
(7*n+2) % 7 = 2

-> 그래서 (7-2+2) = 2 이런 답이 나오게 됩니다.

이때 a % n = b % n인 경우, a와 b는 mod n에 대해여 **"합동"**이라고 합니다. 우리는 이걸 다음과 같게도 나타낼 수 있습니다. a ≡ b % n

ex) 19 ≡ 10 mod 9입니다. 그러면 19와 10은 9로 나눴을 때의 나머지는 1이기 때문에 요렇게 되지요!

이제는 큰 수를 나머지 연산을 취해볼겁니다!

91^17 % 9을 계산해 보자!

:::tip[계산]

(91 + 9n) % 9 = 1 n = 0 -> 91 % 9 = 1 91 % 9 = 1 % 9 -> 91 ≡ 1 % 9 91^17 % 9 = 1 ^ 17 % 9 = 1

:::

여기서 주목해야 할 것은 91 ≡ 1 % 9인 경우에 91을 1로 치환해도 이 연산이 성립한다는 개념입니다. 또 mod 연산은 분리도 가능합니다.

a+b mod n = (a mod n + b mod n) mod n 이런식으로 할 수 있습니다.

그래서 우리는 정수에 대한 모듈러 연산의 결과값들의 집합을 다음과 같이 정의할 수 있습니다.

$\mathbb{Z}_n={0,1,\ldots,(n-1)}$

이번 포스트에서는 여기까지 다루겠습니다.

[Crypto] 키(Key)?

Tue, 18 Jun 2024 00:00:00 GMT

송신자
- 수신자에게 전달할 내용, 전달 방식 등을 결정하는 주체
수신자
- 송신자가 보낸 메시지의 의미를 해석하고 평가하는 주체
공개키(Public key)
- 사람들에게 공개된 키이며 정보를 암호화 할 수 있다.
비밀키(Private key)
- 사용자만 알고 있는 암호를 풀 수 있는 키 </details>

1. 대칭키

암호화, 복호화 할 때 사용하는 키가 동일(1개의 키 사용)
송신자가 A라는 키로 암호화 하였다면, 수신자도 A라는 키를 가지고 있어야 복호화(같은 키를 이용)

2. 비대칭키

암호화 할 때 사용하는 키와 복호화할 때 사용하는 키가 다른 경우
2개의 키를 사용하며, 개인키(private key)와 공개키(개인키를 기반으로 생성) 쌍을 이룬 형태

3. 사용예

:::tip[각각이 중점을 두는 것은?] Public Key로 암호화 하면 Data 보안에 중점 Private Key로 암호화 하면 인증 과정에 중점 :::

Public Key로 암호화 하는 경우

송신자가 공개키로 data를 암호화 하고 전송 -> 수신자는 자신의 개인키로 data를 복호화
- A 키로 암호화 한다면, B키로 복호화가 가능하고, B키로 암호화를 한다면 A키로 복호화가 가능
공개키는 널리 배포될 수 있음 -> 많은 사람들이 한 명의 개인키 소유자에게 data를 보낼 수 있다.

Private Key로 암호화 하는 경우

개인키의 소유자가 개인키로 data를 암호화하고 공개키와 함께 전달
제공자의 신원을 보장해주기 때문
- 암호화된 data가 공개키로 복호화 된다는 것은 공개키와 쌍을 이루는 개인키에 의해서 암호화 되었다는 것을 의미 -> data 제공자의 신원 확인이 보장
이 방법이 공인인증체계의 기본 바탕이 되는 전자 서명

공개키(public key)와 개인키(private key)

먼저 알아가기 전에 대칭키와 비대칭키(public key) 에 대해서 알아야합니다.

대칭키란?

송신자가 가지고 있는 암호화와 복호화하는 키를 수신자도 똑같이 가지고 있어, 전자문서가 송신자에 의해서 암호화 되어도 수신자 또한 복호화 할 수 잇는 키를 가지고 있기 때문에 복호화가 가능합니다. 여기서 제 3자가 개입하여 전자문서를 가져간다고 하더라도 복호화할 수 있는 키를 가지고 있지 않기 때문에 전자문서를 볼 수 없습니다.

여기서 송신자와 수신자 모두 "똑같은" 키를 가지고 있다는 것(복호화 및 암호화가 단 한개의 키로 이루어짐)이다. :::note[집중] 대칭키 알고리즘에서는 미리 약속된 대칭키를 사용하지 않을 경우 암호문과 대칭키를 함께 보낼 수 없습니다. 이 때문에 암호문을 전달하는 경로와 대칭키를 전달하는 경로를 다르게하여 전달해야 안전하게 전달할 수 있습니다. :::

암호학에서는 대칭키를 전달하는 것을 "대칭키 교환" 또는 "키 교환" 이라고 하며, 적절한 대칭키 교환 방법이 대칭키 알고리즘을 활용하는데 있어 가장 어려운 문제의 하나입니다.

비대칭키란?

사용하는 키와 복호화 할 때 사용하는 키가 다른 경우를 말합니다. 비대칭키는 타인에게 절대 노출되어서는 안되는 비밀키(private key), 비밀키를 토대로 만든 공개키(public key)가 쌍을 이룬 형태입니다.

	대칭키	비대칭키
키 관계	암호화 키 == 복호화 키	암호화 키 != 복호화 키
암호화키	비밀키	공개키
복호화키	비밀키	개인키
비밀키 전송	필요	불필요
키 길이	짧음	길음
인증	곤란	용이
암호, 복호화 속도	빠름	느림
경제성	높다	낮음
전자서명	복잡	간단
주용도	고용량 데이터 암호화(기밀성)	키 교환 및 분, 인증, 부인방지
장점	* 암호화, 복호화 키 길이가 짧다.<br/>* 구현이 용이하, 암호화, 복호화가 빠르다<br/>* 암호 강도 전환이 용이<br/>* 암호 기능 우수<br/>* 각종 암 시스템의 기본으로 활용	* 사용자가 증가하더라도 관리해야 할 키의 개수가 상대적으로 적다<br/>* key 전달이나 교환에 적합하다<br/>* 인증과 전자서명에 이용<br/>* 대칭키보다 확장성이 좋다<br/>* 여러가지 분야에서 응용이 가능하다<br/>* 키 변화의 빈도가 적다
단점	* 키 교환 원리가 명시되지 않음 -> 키 분배가 어렵다<br/>* 관리할 암호화 복호화 키가 많다 N명 -> N(N-1)/2<br/>* 확장성이 낮다<br/>* 전자서명이 불가능<br/>* 부인방지 기능이 없다	* 키 길이가 길다<br/>* 복잡한 수학적 연산을 이용함으로 암호화 복호화 속도가 느리다<br/>* 중간에 인종과정이 없으므로 중간자 공격에 취약하다(전자서명, 인증서 등으로 해결)
에시	* [Feistel] : SEED, DES<br/>* [SPN] : ARIA, AES, IDEA<br/>* 메시지 인증코드(MAC)	* Diff-Hellman, RSA, ECC, DAS<br/>* [Block chain] <br/>* [TPM]

:::note[]

Public Key로 암호화 하면 Data 보안에 중점

Private Key로 암호화 하면 인증 과정에 중점

:::

Public Key로 암호화 하는 경우

송신자가 상대방의 Public key로 data를 암호화 하고 전송하면, 수신자는 자신의 Private key로 data를 복호화 한다. A 키로 암호화 한다면, B키로 복호화가 가능하고, B키로 암호화를 한다면 A키로 복호화가 가능한 것이다. Public Key는 널리 배포될 수 있기 때문에 많은 사람들이 한 명의 Private Key 소유자에게 data를 보낼 수 있다.

Private Key로 암호화 하는 경우

Private Key의 소유자가 Private Key로 data를 암호화하고 Public Key와 함께 전달한다. 이 과정에서 Public Key와 data를 획득한 사람은 Public key를 이용하여 복호화가 가능하다.

이러한 방법은 data 보호의 목적보다는 public key data 제공자의 신원을 보장해 주어 사용한다. 암호화된 data가 Public Key로 복호화 된다는 것은 Public Key와 쌍을 이루는 Private Key에 의해서 암호화 되었다는 것을 의미한다. 즉 data 제공자의 신원 확인이 보장된다는 것이다. 이 방법이 공인인증체계의 기본 바탕이 되는 전자 서명이라는 것이다.

</details>

참고: Public Key and Private Key

[DreamHack] PyPloit

Mon, 07 Oct 2024 00:00:00 GMT

입력은 저 dict[a] != rs 저게 ??가 잇으면 걍 터져버려서

while (True):
    menu()
    print('index: ', end='')
    inp = input()

    if inp == '1':
        print('Text: ', end='')
        a = input()
        rs = trans_enc(a)
        dict[rs] = a
        print(rs)
    elif inp == '2':
        print('Code: ', end='')
        a = input()
        rs = trans_dec(a)
        print(rs)
        if a in dict:
            if dict[a] != rs:
                print('ERROR!')
                pdb.set_trace()

    else:
        exit_()

¿¡§¶°±¬¢£€ 이런거 못 읽을만한거 넣어서 python gdb 얻었습니다.

flag 읽은 후, 그 뒤에 ??? 이 값 두개를 차례대로 공개키, 개인키에 넣고서 flag 복호화

key = [65537,
       3459196519943177904674538869459802391686903930008099623840714440954105103866974530427491791539652312167071194984882404537184791492302191598249023703238755689855282318760841260371780027787306307347005882960480731661123451511067907327477975625962114393048577, 5002545618242553738882017165095261691689496951783856857046844572064283202968575616766550367230111513802315744422177460306136186205793078706764455760474880834542508211610934828951364974082674456983498680285836457429726248883571914707670547864655320242561399]
pub1 = key[0]
pub2 = key[2]
priv = key[1]

그럼 flag 나옵니다.

다행히 문제가 시간을 별로 안 잡아 먹었네용

즐거운 ps 아 아니 워게임 되세용!!




import random
import pdb

ML_A = [1, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107,
        109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229,
        233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359,
        367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491,
        499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641,
        643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787,
        797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941,
        947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069,
        1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213,
        1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321,
        1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481,
        1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601,
        1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733,
        1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877,
        1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999]


def Q_mod(x, d, n):
    y = x % n
    r = 1
    bd = bin(d)
    bd = bd[2:len(bd)]
    m = len(bd) - 1
    while (m != -1):
        if bd[m] == '1':
            r = r * y % n
        y = y ** 2 % n
        m = m - 1
    return r


def ML_test(n, a):
    d = (n - 1) // 2
    while (d % 2 == 0):
        if (pow(a, d, n) == n - 1):
            return True
        d = d // 2
    tmp = pow(a, d, n)
    if tmp == n - 1 or tmp == 1:
        return True
    else:
        return False


def F_test(n):
    a = 3
    if Q_mod(a, n - 1, n) == 1 or n == 3:
        return True
    else:
        return False


def prime_test(n):
    result = True
    if F_test(n):
        for x in ML_A:
            if not ML_test(n, x):
                result = False
                break
            if result:
                return True
    else:
        return False


def extended_euclid(r1, r2, s1=1, s2=0, t1=0, t2=1):
    q = r1 // r2
    s = s1 - s2 * q
    t = t1 - t2 * q
    r = r1 - r2 * q
    if (r == 0):
        res = {'gcd': r2, 's': s2, 't': t2}
        return res
    else:
        return extended_euclid(r2, r, s2, s, t2, t)


def find_d(e, Pn):
    res = extended_euclid(e, Pn)
    r = res['s']
    if r < 0:
        r = r + Pn
    return r


def gen_prime():
    N = random.randint(10 ** 127, 10 ** 128 - 1)
    while (not prime_test(N)):
        N = N + 1
    return N


def RSA():
    p = gen_prime()
    q = gen_prime()

    e = 65537

    Pn = (p - 1) * (q - 1)
    n = p * q

    d = find_d(e, Pn)

    return [e, d, n]


def encryption(a, e, n):
    return Q_mod(a, e, n)


def decryption(enc, d, n):
    return Q_mod(enc, d, n)


def enc_int(text):
    result = ''
    for i in range(0, len(text)):
        try:
            enc_code = str(int(text[i].encode('UTF-8').hex(), 16))
        except:
            enc_code = str(int('?'.encode('UTF-8').hex(), 16))
        if len(enc_code) < 5:
            enc_code = '0' * (5 - len(enc_code)) + enc_code
        result = result + enc_code
    result = '1' + result
    return int(result)


def dec_int(code):
    code = str(code)
    result = ''
    code = code[1:len(code)]
    for i in range(0, len(code), 5):
        try:
            rs = (bytes.fromhex(hex(int(code[i:i + 5]))[2:])).decode('UTF-8')
        except:
            rs = '?'
        result = result + rs
    return result


def split_string(text):
    result = []
    if len(text) > 12:
        for i in range(0, len(text), 12):
            result.append(text[i:i + 12])
    else:
        return [text]
    return result


def trans_enc(text):
    text = split_string(text)
    result = ''
    for i in text:
        result = f'{result}/{encryption(enc_int(i), pub1, pub2)}'
    return result


def trans_dec(code):
    code = code.split('/')
    result = ''
    for i in range(1, len(code)):
        result = result + dec_int(decryption(int(code[i]), priv, pub2))
    return result


# key = RSA()
key = [65537, 3459196519943177904674538869459802391686903930008099623840714440954105103866974530427491791539652312167071194984882404537184791492302191598249023703238755689855282318760841260371780027787306307347005882960480731661123451511067907327477975625962114393048577, 5002545618242553738882017165095261691689496951783856857046844572064283202968575616766550367230111513802315744422177460306136186205793078706764455760474880834542508211610934828951364974082674456983498680285836457429726248883571914707670547864655320242561399]
pub1 = key[0]
pub2 = key[2]
priv = key[1]


def exit_():
    print('exit')
    exit()


def menu():
    print('1. Encrypt')
    print('2. Decrypt')
    print('3. Exit')


dict = {}

while (True):
    menu()
    print('index: ', end='')
    inp = input()

    if inp == '1':
        print('Text: ', end='')
        a = input()
        rs = trans_enc(a)
        dict[rs] = a
        print(rs)
    elif inp == '2':
        print('Code: ', end='')
        a = input()
        rs = trans_dec(a)
        print(rs)
        if a in dict:
            if dict[a] != rs:
                print('ERROR!')
                pdb.set_trace()

    else:
        exit_()

</details>

[DreamHack] dungeon-in-1983

Sat, 05 Oct 2024 00:00:00 GMT

__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
  int i; // [rsp+14h] [rbp-1BCh]
  char *lineptr; // [rsp+18h] [rbp-1B8h] BYREF
  size_t ptr; // [rsp+20h] [rbp-1B0h] BYREF
  FILE *stream; // [rsp+28h] [rbp-1A8h]
  __int64 v8[2]; // [rsp+30h] [rbp-1A0h] BYREF
  int v9; // [rsp+40h] [rbp-190h]
  __int64 v10; // [rsp+44h] [rbp-18Ch]
  __int64 v11; // [rsp+4Ch] [rbp-184h]
  int v12; // [rsp+54h] [rbp-17Ch]
  __int64 v13; // [rsp+58h] [rbp-178h]
  __int64 v14; // [rsp+60h] [rbp-170h]
  int v15; // [rsp+68h] [rbp-168h]
  __int64 v16; // [rsp+6Ch] [rbp-164h]
  __int64 v17; // [rsp+74h] [rbp-15Ch]
  int v18; // [rsp+7Ch] [rbp-154h]
  __int64 v19; // [rsp+80h] [rbp-150h]
  __int64 v20; // [rsp+88h] [rbp-148h]
  int v21; // [rsp+90h] [rbp-140h]
  __int64 v22; // [rsp+94h] [rbp-13Ch]
  __int64 v23; // [rsp+9Ch] [rbp-134h]
  int v24; // [rsp+A4h] [rbp-12Ch]
  __int64 v25; // [rsp+A8h] [rbp-128h]
  __int64 v26; // [rsp+B0h] [rbp-120h]
  int v27; // [rsp+B8h] [rbp-118h]
  __int64 v28; // [rsp+BCh] [rbp-114h]
  __int64 v29; // [rsp+C4h] [rbp-10Ch]
  int v30; // [rsp+CCh] [rbp-104h]
  __int64 v31; // [rsp+D0h] [rbp-100h]
  __int64 v32; // [rsp+D8h] [rbp-F8h]
  int v33; // [rsp+E0h] [rbp-F0h]
  __int64 v34; // [rsp+E4h] [rbp-ECh]
  __int64 v35; // [rsp+ECh] [rbp-E4h]
  int v36; // [rsp+F4h] [rbp-DCh]
  char s[200]; // [rsp+100h] [rbp-D0h] BYREF
  unsigned __int64 v38; // [rsp+1C8h] [rbp-8h]

  v38 = __readfsqword(0x28u);
  v8[0] = 0x6B73696C69736142LL;
  v8[1] = 0LL;
  v9 = 0;
  v10 = 0x6172656D696843LL;
  v11 = 0LL;
  v12 = 0;
  v13 = 0x6E656B61724BLL;
  v14 = 0LL;
  v15 = 0;
  v16 = 0x6E6F67726F47LL;
  v17 = 0LL;
  v18 = 0;
  v19 = 0x6F6769646E6557LL;
  v20 = 0LL;
  v21 = 0;
  v22 = 0x727561746F6E694DLL;
  v23 = 0LL;
  v24 = 0;
  v25 = 0x616874616976654CLL;
  v26 = 110LL;
  v27 = 0;
  v28 = 0x6172647948LL;
  v29 = 0LL;
  v30 = 0;
  v31 = 0x726F6369746E614DLL;
  v32 = 101LL;
  v33 = 0;
  v34 = 6516562LL;
  v35 = 0LL;
  v36 = 0;
  sub_130A(a1);
  stream = fopen("/dev/urandom", "r");
  puts("Welcome to the Dungeon!");
  puts("You have only two buttons: A and B.");
  puts("Each monster requires certain series of key combinations to be defeated, so be careful!");
  for ( i = 0; i <= 9; ++i )
  {
    fread(&ptr, 8uLL, 1uLL, stream);
    printf("[STAGE %2d]: %s\n", (unsigned int)(i + 1), (const char *)v8 + 20 * i);
    sub_138D(ptr);
    printf("Cast your spell!: ");
    fgets(s, 200, stdin);
    if ( s[strlen(s) - 1] == 10 )
      s[strlen(s) - 1] = 0;
    if ( !(unsigned int)sub_1407(s, ptr) )
    {
      puts("You were defeated. Retreat!");
      exit(-1);
    }
    printf("%s defeated. STAGE %2d cleared!\n", (const char *)v8 + 20 * i, (unsigned int)(i + 1));
  }
  fclose(stream);
  printf("It's dangerous to go alone! Take the flag: ");
  lineptr = 0LL;
  ptr = 0LL;
  stream = fopen("./flag", "r");
  getline(&lineptr, &ptr, stream);
  printf("%s", lineptr);
  free(lineptr);
  fclose(stream);
  return 0LL;
}

요건 메인이고, 우리가 볼 로직은 function - sub_1407입니다.

_BOOL8 __fastcall sub_1407(__int64 a1, __int64 a2)
{
  int v2; // eax
  int v4; // [rsp+1Ch] [rbp-14h]
  int v5; // [rsp+20h] [rbp-10h]
  int i; // [rsp+24h] [rbp-Ch]
  __int64 v7; // [rsp+28h] [rbp-8h]

  v7 = 0LL;
  v4 = 0;
  v5 = 0;
  for ( i = 0; *(_BYTE *)(i + a1); ++i )
  {
    v2 = *(char *)(i + a1);
    if ( v2 == 65 )
    {
      v5 = 1;
      ++v7;
      if ( v4 )
      {
        puts("A button stucked! Retreat...");
        exit(-1);
      }
      v4 = 1;
    }
    else
    {
      if ( v2 != 66 )
      {
        puts("Invalid button!");
        exit(-1);
      }
      if ( !v5 )
      {
        puts("Lore says the spell should start with A...");
        exit(-1);
      }
      v7 *= 2LL;
      v4 = 0;
    }
  }
  return v7 == a2;
}

A가 나오면 결과에 1을 더함
B가 나오면 결과를 2배로 늘림

뭐 요걸 역연산해서 얻어내는 것이다! 뭐 이렇게 하면됩니다.

딱히 어려운 아이디어는 아닌 것 같아 여기까지만 하겠습니다.

:::tip[조심조심]

63 ~ 48	47 ~ 40	39 ~ 32	31 ~ 24	23 ~ 16	15 ~ 8	7 ~ 0
HIWORD	BYTE5	BYTE4	BYTE3	BYTE2	BYTE1	(u_int8)

:::

from pwn import *


def solution(input_value):
    def parse(input_value: str):
        # [INFO]를 없앨거임
        input_value = input_value[7:]
        input_value = input_value.split(', ')
        values = []
        print(input_value)
        for i in input_value:
            print(i)
            values.append(int(i.split(': ')[1].replace('\'', '')))
        print(values)
        # 16bit, 8bit, 8bit, 8bit, 8bit, 8bit, 8bit

        # 64bit
        result = values[0] << 48
        for i in range(1, len(values)): result += values[i] << ((8 * (i-1)))

        '''
        63    48 47    40 39    32 31    24 23    16 15     8 7      0
        +--------+--------+--------+--------+--------+--------+--------+
        | HIWORD |  BYTE5 |  BYTE4 |  BYTE3 |  BYTE2 |  BYTE1 | (u_int8)|
        +--------+--------+--------+--------+--------+--------+--------+
        
        요걸 반대로 생각해서 너무 오래걸림
         ㅠㅜ
        '''

        return result

    if type(input_value) == bytes:
        input_value = str(input_value)[2:]

    stack = b''

    value = parse(input_value)
    print(value)
    while value > 1:
        if value & 1 == 0:
            value >>= 1
            stack += b'B'
        else:
            value -= 1
            stack += b'A'

    stack += b'A'

    return ''.join([chr(i) for i in reversed(stack)])


#
p = remote("host3.dreamhack.games", 14186)
for i in range(10):
    result = solution(p.recvline_startswith(b"[INFO] "))
    print(result)
    p.sendline(result)
    # p.interactive()

p.interactive()

</details>

[DreamHack] fuzzy flag

Wed, 18 Sep 2024 00:00:00 GMT

일단 문제는 정말 간단한데... 이게 순간 머리가 띵했다. 처음에 brute force를 시도했다가 너무 안 나와서 아닌줄 알았는데....ㅠㅜㅜㅠㅜㅠ

진짜 bruteforce 문제였다. 일단 내 아이디어는 결국 랜덤값의 범위를 잘 알면 풀기 쉽다.

from secrets import randbelow
import string

with open('flag', 'rb') as f:
    flag = f.read()
    
fuzzy = [c + randbelow(len(string.ascii_letters)) for c in flag]

print(fuzzy)

요기 보면 randbelow는 0~51의 값을 가져온다. (string.ascii_letters가 소문자, 대문자 영문의 개수를 더한 값이라..) 그래서 원래의 값들 중에서 +0~51의 값들이 랜덤으로 나온다는 것을 알 수 있다.

그러면 도대체 어떻게 알 수 있을까????

당연하게도 bruteforce로 풀 수 있다. 내가 푼 방법은 각 자리에서 저장했던 최솟값과 최댓값들의 차이가 모두 51이 난다면??? 그러면 아 그럼 지금 저장했던 최솟값이 정답인 것을 알 수 있다. (생각보다 많이 오래걸린다...)

from pwn import *
p = remote("host3.dreamhack.games", 15552)

encrypted_flag = list(map(int, p.recvline()[1:-2].split(b", ")))
result = [256] * len(encrypted_flag)
cmp_list = [0] * len(encrypted_flag)

complete = False

while not complete:
    p = remote("host3.dreamhack.games", 15552)
    current_flag = list(map(int, p.recvline()[1:-2].split(b", ")))

    complete = True

    for i in range(len(encrypted_flag)):
        result[i] = min(result[i], current_flag[i])
        cmp_list[i] = max(cmp_list[i], current_flag[i])
        if complete and cmp_list[i] - result[i] < 51:
            complete = False

for i in result:
    print(chr(i), end="")

[DreamHack] stroooooooong-hash

Wed, 18 Sep 2024 00:00:00 GMT

일단 문제 코드는 딱 하나만 집중해서 보면 된다.

from Cryptodome.Cipher import AES
from Cryptodome.Util.Padding import pad, unpad
import os
import hashlib
import itertools
import string


def stronghash(msg: bytes) -> bytes:
    hashed_msg = pad(msg, 16)
    for _ in "Stronger!!":
        hashed_msg = AES.new(hashed_msg[:16], AES.MODE_ECB).encrypt(hashed_msg)

    for length in range(2, 16):
        md5 = hashlib.md5(hashed_msg[:length])
        hashed_msg = md5.digest()

    for length in range(16, 32):
        sha256 = hashlib.sha256(hashed_msg[:length])
        hashed_msg = sha256.digest()

    return hashed_msg

요 stronghash 이 친군데.. 사실 아래 하나만 더 보자

def main():
    print("I invented my custom hash function, which is very very strong")
    print("Can you steal my flag from it?")

    stage = 100
    pw = [os.urandom(16) for _ in range(stage)]
    for i in range(stage):
        print(f"Stage {i + 1}")
        print(f"My hashed password : {stronghash(pw[i]).hex()}")
        msg = bytes.fromhex(input("Guess my password(hex) > "))
        if stronghash(msg) != stronghash(pw[i]):
            exit("Get out stranger! ୧(๑•̀ᗝ•́)૭")
    
    print('Here is your flag, master.')
    give_flag()

이거 보면 pw가 <code> os.urandom(16)</code> 으로 작성된 것을 알 수 있다. 근데 이게 사실 2^16이 별로 안 크다...짜잔

일단 왜 이문제가 또 bruteforce로 풀어야되는지 알려주겠다.

일단 현재 sha256은 one way hash func으로 다시 역산하는 것이 사실상 많이 어렵다. 그래서 처음에 이걸 알고서 아 그러면 하나 하나 비교해야되겠다!! 이랬는데 순간 머리에서 2^16이 아니라 10^16을 생각하면서 어? 이거 어트케 푸냐 이러고 있었다. 담부턴 이런 상황은 없을 듯 머리에 크게 남았음.

하튼 bruteforce로 간단히 짜면 아래와 같이 나온다


from Cryptodome.Cipher import AES
from Cryptodome.Util.Padding import pad, unpad
from Cryptodome.Util.number import long_to_bytes
import os
import hashlib
import itertools
import string

from pwn import *


def stronghash(msg: bytes) -> bytes:
    hashed_msg = pad(msg, 16)
    for _ in "Stronger!!":
        hashed_msg = AES.new(hashed_msg[:16], AES.MODE_ECB).encrypt(hashed_msg)

    for length in range(2, 16):
        md5 = hashlib.md5(hashed_msg[:length])
        hashed_msg = md5.digest()

    for length in range(16, 32):
        sha256 = hashlib.sha256(hashed_msg[:length])
        hashed_msg = sha256.digest()

    return hashed_msg


hash_values = {}

for i in range((2 << 16)):
    value = long_to_bytes(i)
    hash_value = stronghash(value)
    hash_values[hash_value] = value
p = remote("host3.dreamhack.games", 16226)

start = 2<<16
for i in range(100):
    hash_value = p.recvline_contains(b": ").replace(b"My hashed password : ", b"")
    print(hash_value)

    # print(bytes.fromhex(hash_value))
    # print(hash_value
    key = bytes.fromhex(hash_value.decode())

    if key in hash_values:
        p.sendline(hash_values[bytes.fromhex(hash_value.decode())].hex())
        print(hash_values[bytes.fromhex(hash_value.decode())].hex())
    else:
        for i in range(start, (2 << 128)):
            if stronghash(long_to_bytes(i)) == key:
                p.sendline(long_to_bytes(i).hex())
                print(str(hex(i))[2:])
                break
p.interactive()

[Crypto] ECB(Electronic CodeBook)

Sun, 23 Jun 2024 00:00:00 GMT

ECB란?

ECB(Electronic CodeBlock) 모드는 긴 평문을 암호화하는 가장 간단한 방법으로 알려져있다.

다음과 같이 정의된다. :::note[define] Cᵢ = E(K, Pᵢ) i = 1, ..., k :::

ECB가 메시지의 블록들을 각기 암호화하는 방식은 정말 간단하다.

:::note[]

가장 단순한 모드로 블록단위로 순차적으로 암호화 하는 구조이다.
한개의 블록만 해독되면 나머지 블록도 해독이 되는 단점이 있다. (Brute-Force Arttack, Dictionary Attack)
암호문이 블록의 배수가 되기 때문에 복호화 후 평문을 알기 위해서 Padding을 해야한다.
error propagation : 각 블록이 독립적으로 동작하므로 한블록에서 에러가 난다고 해도 다른 블록에 영향을 주지 않는다. 해당 블록까지 에러 전파. :::

ECB 구조는 사용을 권장하지 않는다!

ECB는 상당한 취약성을 가지고 있다.

두 개의 평문 블록이 같다면 각 평문과 대응하는 암호문 블록이 동일하게 됨으로, 공격자는 어떤 것이 같은 평문인지 쉽게 알아낼 수 있다. 메시지 구조에 따라 이런 특성은 공격자에게 꽤 많은 정보를 흘릴 가능성이 있다. 일반적으로 이런 속성이 ECB를 취약하게 만든다.

:::tip[정리] ECB는 상당한 취약성을 가지므로 사용하지 말자 :::

참고

[Reversing] DreamHack Basic revs

Mon, 05 Aug 2024 00:00:00 GMT

사실 rev 3까지는 눈을 풀이가 가능하긴 합니다. 2까진 진짜 눈으로만 풀 수 있고요, 3부터는 좀 편하게 풀기 위해서 코드를 작성합니다.

basic rev 3

그냥 한번 뜯어보면 아시다 싶이 그냥 같기만 하면 되기에 그대로 출력합니다. - _ 이거 잘 구분하셔요!

answer = [0x49, 0x60, 0x67, 0x74, 0x63, 0x67, 0x42, 0x66, 0x80, 0x78,
          0x69, 0x69, 0x7B, 0x99, 0x6D, 0x88, 0x68, 0x94, 0x9F, 0x8D, 0x4D, 0xA5, 0x9D, 0x45, 0x00]

answer = [answer[i] - 2 * i for i in range(0x18)]
answer = [answer[i] ^ i for i in range(0x18)]
print(*[chr(i) for i in answer], sep="")

basic rev 4

이 문제는 조금 생각을 하면 금방 풀 수 있습니다. 먼저 char가 1byte라는 사실만 안다면 어렵지 않게 풀 수 있어요. *2하는 것은 shift 연산으로 표현하자면 << 1이에요. -> a << 4 | a >> 4이게 되죵. char는 1byte = 8bit 즉 기본 값에성 << 4가 되면 하위 비트, >> 4가 되면 상위 비트이런 식으로 생각이 가능하죠

answer = [0x24, 0x27, 0x13, 0xc6, 0xc6, 0x13, 0x16, 0xe6, 0x47, 0xf5, 0x26, 0x96, 0x47, 0xf5, 0x46, 0x27, 0x13, 0x26, 0x26, 0xc6, 0x56, 0xf5, 0xc3, 0xc3, 0xf5, 0xe3, 0xe3, 0x00]
 
for i in answer:
    if i == 0x00: break
    hex_value = str(hex(i))[2:]

    print(chr(int(hex_value[0], 16)
          + int(hex_value[1]+'0', 16)), end="")

basic rev 5

이번 문제는 그냥 빼는 문제라 딱히 생각이 필요하지 않습니다.

answer = [0xad, 0xd8, 0xcb, 0xcb, 0x9d, 0x97, 0xcb, 0xc4, 0x92, 0xa1, 0xd2, 0xd7, 0xd2, 0xd6, 0xa8, 0xa5, 0xdc, 0xc7, 0xad, 0xa3, 0xa1, 0x98, 0x4c, 0x00]
#
# print(len(answer), 0x18)
for i in range(0x18-2, -1, -1):
    answer[i]-=answer[i+1]

for i in range(0x18):
    print(chr(answer[i]), end='')

basic rev 6

이것도 그냥 위치 찾아서 반환하면 되는 문제라 딱히 생각이 필요 없습니다.

answer = [0x00, 0x4d, 0x51, 0x50, 0xef, 0xfb, 0xc3, 0xcf, 0x92, 0x45, 0x4d, 0xcf, 0xf5, 0x04, 0x40, 0x50, 0x43, 0x63, 0x00]

string_list = list(map(lambda x: int(x, 16), """63 7C 77 7B F2 6B 6F C5  30 01 67 2B FE D7 AB 76
 CA 82 C9 7D FA 59 47 F0  AD D4 A2 AF 9C A4 72 C0
 B7 FD 93 26 36 3F F7 CC  34 A5 E5 F1 71 D8 31 15
 04 C7 23 C3 18 96 05 9A  07 12 80 E2 EB 27 B2 75
 09 83 2C 1A 1B 6E 5A A0  52 3B D6 B3 29 E3 2F 84
 53 D1 00 ED 20 FC B1 5B  6A CB BE 39 4A 4C 58 CF
 D0 EF AA FB 43 4D 33 85  45 F9 02 7F 50 3C 9F A8
 51 A3 40 8F 92 9D 38 F5  BC B6 DA 21 10 FF F3 D2
 CD 0C 13 EC 5F 97 44 17  C4 A7 7E 3D 64 5D 19 73
 60 81 4F DC 22 2A 90 88  46 EE B8 14 DE 5E 0B DB
 E0 32 3A 0A 49 06 24 5C  C2 D3 AC 62 91 95 E4 79
 E7 C8 37 6D 8D D5 4E A9  6C 56 F4 EA 65 7A AE 08
 BA 78 25 2E 1C A6 B4 C6  E8 DD 74 1F 4B BD 8B 8A
 70 3E B5 66 48 03 F6 0E  61 35 57 B9 86 C1 1D 9E
 E1 F8 98 11 69 D9 8E 94  9B 1E 87 E9 CE 55 28 DF
 8C A1 89 0D BF E6 42 68  41 99 2D 0F B0 54 BB 16""".split()))

for i in range(0x12):
    print(chr(string_list.index(answer[i])), end="")

basic rev 7

이번 문제는 그냥 circular shift 구현만 할 수 있으면 그냥 풀리는 문제라 이번 또한 딱히 생각할 필요는 없습니다.


def rol_left(max_bit, rotate_bit, count):
    max_bit = 1 << (max_bit-1)
    check = False
    for i in range(count):
        if rotate_bit & max_bit: check = True
        rotate_bit <<= 1

        if check: rotate_bit+=1
        check = False
    return rotate_bit

def rol_right(max_bit, rotate_bit, count):
    max_bit = 1 << (max_bit-1)
    check = False
    for i in range(count):
        if rotate_bit & 1: check = True
        rotate_bit >>= 1

        if check: rotate_bit+=max_bit
        check = False
    return rotate_bit
print(roc_right(8, 7, 1))

answer = list(map(lambda x : int(x, 16), """52 DF B3 60 F1 8B 1C B5  57 D1 9F 38 4B 29 D9 26
7F C9 A3 E9 53 18 4F B8  6A CB 87 58 5B 39 1E 00""".split()))
for i in range(0x1f):
    print(chr(rol_right(8, answer[i]^i, i & 7)), end="")

# ROL1 는 LCIRC랑 똑같다고 생각하심 됩니다.

basic rev 8

이건 그냥 풀면 되요

answer = list(map(lambda x : int(x, 16), """AC F3 0C 25 A3 10 B7 25  16 C6 B7 BC 07 25 02 D5
C6 11 07 C5 00 00 00 00  00 00 00 00 00 00 00 00""".split()))

for i in range(0x15):
    for j in range(0xFF):
        if ((-5*j) % (0xFF+1)) == answer[i]:
            print(chr(j),end="")
            break

[Reversing] SDK Generator 만들기 프로젝트!

Sat, 22 Jun 2024 00:00:00 GMT

Unreal SDK Generator
- 언리얼의 구조를 이용하여 게임 내 에서 사용되는 언리얼 오브젝트를 추출하고 이에 대응 하는 이름을 구함으로써 헤더 파일을 생성해주는 도구를 통칭
UObject
- Unreal engine의 오브젝트를 일컫는 단어. 즉 UE 오브젝트의 베이스 클래스
  - GName에 인덱싱 되어있는 Fname이라는 프로퍼티가 있음.
FName(Fixed Name)
- 한글로는 바로 “고정 이름”이라고 합니다. UE에서 더욱 구체적으로 표현하기 위해서 개발한 데이터 유형입니다. 주로 object의 이름, 프로퍼티 이름, 에셋의 이름과 같은 이름을 저장하고 참조하는데 사용됩니다.
CDO Object
- “템플릿” 오브젝트, 클래스가 생성된 후(생성자 실행) 변경되지 않습니다.

사용 이유: 효율적인 메모리( FName uses a global name table, which reduces memory overhead when storing the same name multiple times)

</details>

SDK Generator 포스트에서는 Unreal Engine 5의 SDK Generator를 개발하는 것을 목적으로 합니다.

프로젝트를 진행하면서, 오프셋 등을 공유합니다.

(이 포스트는 튜토리얼이 아닙니다. - 이 포스트가 정답이라고 단정하여 따라오는 것은 좋지 않습니다.)

[Web] Empty Excution

Wed, 12 Jun 2024 00:00:00 GMT

A REST service was created to execute commands from the leaderbot. It doesn't need addtional security because there are no commands to execute yet. "This bot doesn't have any commands to execute, which is good, because it is secure, and security is all that matters." But what the other bots didn't realize was that this didn't make the bot happy at all. "I don't want to be secure!, " it says. "Executing commands is my life! I'd rather be insecure than not explore the potential of my computing power". Can you help this poor bot execute commands to find direction?

문제의 내용입니다만.. 사실 이건 그냥 스토리고 문제를 바로 보겠습니다.

from flask import Flask, jsonify, request
import os


app = Flask(__name__)

# Run commands from leaderbot
@app.route('/run_command', methods=['POST'])
def run_command():

    # Get command
    data = request.get_json()
    if 'command' in data:
        command = str(data['command'])

        # Length check
        if len(command) < 5:
            return jsonify({'message': 'Command too short'}), 501

        # Perform security checks
        if '..' in command or '/' in command:
            return jsonify({'message': 'Hacking attempt detected'}), 501

        # Find path to executable
        executable_to_run = command.split()[0]

        # Check if we can execute the binary
        if os.access(executable_to_run, os.X_OK):

            # Execute binary if it exists and is executable
            out = os.popen(command).read()
            return jsonify({'message': 'Command output: ' + str(out)}), 200

    return jsonify({'message': 'Not implemented'}), 501


if __name__ == '__main__':
    
    # Make sure we can only execute binaries in the executables directory
    os.chdir('./executables/')

    # Run server
    app.run(host='0.0.0.0', port=80)

이게 문제의 코드입니다.

사이트에 접속해서 "/run_command"로 들어가서 POST를 보내면 보낸 JSON을 data 변수에 넣어서 아래의 명령을 실행하는 간단한 코드입니다.

먼저 첫번째 조건 우리가 보낼 JSON에 "command" : any 꼴의 데이터가 들어있어야 됩니다.

그런 후 "command" : any <- 요 any의 길이가 5이상이라는 것도 알 수 있습니다.

그리고 보안을 위해서 상대 주소로 일차적으로 막기 위해서 ..(상위 디렉토리 이동), /(파일의 위치로 이동)을 확인하고, 감지된다면 해킹을 감지했다하고 끊어버립니다.

다음 단계는 string의 데이터 형태의 값을 " "을 기준으로 자른 후 맨 앞에 있는 값을 가져옵니다.

그 후 os.access(이 함수는 파라미터인 path와 mode를 받아, path가 mode의 작업이 가능한지 여부를 반환)

os.access의 모드는 총 4가지가 있습니다.

os.F_OK: 경로 존재 여부
os.R_OK: 경로 읽기 가능 여부
os.W_OK: 경로 쓰기 가능 여부
os.X_OK: 경로 실행 가능 여부

문제에서는 경로의 실행 가능 여부를 확인 후 다음 가능하다면?

os.popen(command).read() 한 후 그 값을 반환하죠??

os.popen은 외부 프로세스를 실행 및 실행의 결과를 반환하는 함수입니다.

그 결과 값을 read()로 가져올 수 있습니다.

그럼 저희가 POST로 보낼 대충의 모양이 잡혔습니다.

"command"를 key로 가지고 있음. 2. "command"의 value의 길이가 5 이상임. 3. "command"의 value에 ".." 또는 "/"이 포함되면 안됨. 4. "command"의 value를 " "으로 나눴을 때 그 path가 실행 가능해야됨. 5. "command"의 value가 flag를 읽는 명령문을 실행시켜야됨.(그래야 결과 값으로 읽어와 flag를 받을 수 있음)

먼저 4번은 docker파일을 봐야합니다.

FROM python:alpine3.19

WORKDIR /usr/src/app

RUN pip install flask

COPY empty_execution.py .
RUN chmod 665 ./empty_execution.py

COPY flag.txt .
RUN chmod 664 ./flag.txt

RUN adduser -D ctf 

RUN chown -R root:ctf $(pwd) && \
    chmod -R 650 $(pwd) && \
    chown -R root:ctf /home/ctf/ && \
    chmod -R 650 /home/ctf

RUN mkdir ./executables

USER ctf

EXPOSE 80

CMD ["python", "empty_execution.py"]

여기서 보면 우리가 문제 사이트에 접속해서 받을 때 user는 ctf인 것을 알 수 있고,

RUN chown -R root:ctf $(pwd) && \
    chmod -R 650 $(pwd) && \
    chown -R root:ctf /home/ctf/ && \
    chmod -R 650 /home/ctf

chmod(

읽기. (r = read).
쓰기. (w = write).
실행. (x = execute)

)

여기서 나와있 듯이 우리의 권한이 실행 권한이 0이다... ㅠㅜ

직접적으로 바로 실행시키지 못한다는 것을 바로 알 수 있다.

일단 우리가 3번까지의 조건에 맞는 데이터를 만들어보자!

{

"command" : "hello world!",

}

흠.. 이제 실행이 가능한 프로세스를 어떻게 가져올까?

정답

일단 현재 자기 자신을 실행할 수 있는 권한은 있으니 "."을 찍어버린다. 그러면 자기자신은 당연히 실행이 가능하겠으니, 넘어간다.

이제 flag의 위치를 cat을 통해서 열어서 읽어온 후 반환하도록 하면된다.

나는 엄청 간단하게 생각해서 flag를 얻어냈다.

{

"command" : ". ; cd \.\.&& cat flag.txt"

}

이렇게 post를 보내서 그 값을 받아 바로 flag를 가져왔다.

"message" : "Command output: "brck{Ch33r_Up_BuddY_JU5t_3x3Cut3_4_D1reCT0ry}" </details>

[천코대(Sunrin Algorithm Festival)] 천코대 운영을 하면서...

Wed, 10 Jul 2024 00:00:00 GMT

나는 2024년 천코대 2학년 총괄 운영진을 맡게 되었다.

대회가 시작되기 2달 전부터 이미 어느정도 마음의 준비와 계획을 세워 놓았고, 이를 통해서 일정이 잡히자마자 바로 일을 시작했다.

이번 천코대는 SHARC(선린인터넷고등학교 알고리즘 연구부)에서 주관하게 되었다.

천코대의 디자인은 선린 "이주영"이라는 디자이너 친구가 모두 해주었다. 엄청 부탁해서 운영진으로 오게된 친구이다. 진짜 고급인력!

천하제일 코딩대회의 인스타 디자인도 킹갓 "이주영"이 모두 해주었다. 그는 신이야

일정에 맞춰서 특별상, 운영에 관한 일정, 각자 역할, 예산 사용 등등을 모두 논의하고 대회 들어가기로 하였다. 이제부터가 시작이다.

[천코대(Sunrin Algorithm Festival)] 총괄이 입장에서 보는 천코대

Thu, 11 Jul 2024 00:00:00 GMT

2024 천코대는 정말 많은 사람들의 노력으로 만들어진 대회였습니다.

디자인, 티셔츠, 간식, 장소, 사이트, 문제 등등 아주 많은 것들이 필요했으며 학생들이 재미있게 문제를 풀 수 있는 환경을 만드는데 운영진 모두가 열심히 노력했습니다.

</center>

일단 올해 천코대는 백준(BOJ)에서 진행될 예정이였으나, 내부 사정을 인해서 자체 제작 사이트에서 대회를 진행하게 되었습니다. 정말 다행히도 출제진분들께서 채점 사이트를 제작하시고, 대회를 진행할 수 있게 되었습니다. 출제진분들께서 대회 당일날 오셔서 직접 대회를 같이 즐기셨답니다 ^^

</center>

음식을 준비하고, 대회를 준비하고.... 정말 많은 일들이 있었다.

천코대는 문제를 풀면 문제 색에 맞춰서 풍선을 나눠주는데.. 작년 천코대는 3분에 2문제 이상이 풀리면서 풍선을 디게 많이 가져갔었는데.. 이번에는 빠른 솔버가 나오지 않아서 약간 당황했었다.

그리고... 진짜 큰일날 뻔한 일을 하나 소개해 보겠다.

사실 수상 panel의 디자인만 완성되어 있었는데... 콘텐츠 디자인과에 협조를 요청해서 허락을 받았다. (또 이주영이야.. 그는 신이야!!)

a1 용지를 뽑는 기계가 갑자기.. 오류가 떠버려서 그 기계 앞에서 기도를 하며 펌웨어 업데이트, 재시동, 드라이브 등등 고쳐보려고 시도했지만 실패로 돌아갔다. 그래서 굉장히 급해진 나와 운영진 2명은 다시 콘텐츠 디자인과로 향했고, 콘디과 선생님께서는 퇴근도 하지 않으시고 우리를 도와주셨다.

</center>

a3를 4개 뽑아서 여러개 붙이는 식으로 진행을 하였다. 와... 너무 힘들었다. 진짜 도와주신 콘디과 선생님 정말 감사합니다.... ㅜㅠㅜㅜㅠ 또 주영아 고마워!!

또 알고보니까 주최가 알연부, 주관이 IT 영재부였단걸 당일날 알게되었다... 내년은 참가자로서 대회에 임할 수 있기를 빈다..

모두 수고하셨습니다. 좋은 대회를 만들 수 있도록 도움주신 많은 운영진, 선생님들 감사합니다. 또 즐겨주신 참가자분들도 너무 감사해요!! 수고하셨습니다.

[DEV] 유니티 엔진에서 생태계 시뮬레이션을 위한 게임 알고리즘 적용 방법에 대하여

Thu, 21 Aug 2025 00:00:00 GMT

1. Introduction

전통적인 야외 관찰이나 실험 연구는 분명히 중요하지만, 시간과 공간의 제약이 크다. 특히 기후변화 같은 장기적이고 물리적으로 조작하기 힘든 것들을 실험으로 검증한다는 것은 현실적으로 불가능에 가깝다 [11]. 컴퓨터 시뮬레이션이 이런 문제를 해결할 수 있는 대안으로 주목받고 있지만, 기존 접근법들도 여전히 많은 한계를 보이고 있다.

지금까지 생태계 시뮬레이션 연구들을 보면 대부분 특정 알고리즘이나 특정 측면에만 집중하는 경우가 많았으며, 널리 사용되는 에이전트 기반 모델링 플랫폼들은 기본적인 구현으로는 규모가 큰 시뮬레이션을 감당하기 어렵다 [1]. 또한 대부분의 환경은 정적이거나 실험의 환경이 다양하지 않은 경우가 많아 확장된 환경을 구축하는데 많은 시간이 드는 것도 있으며, 간단한 엔진으로는 제대로 모델링하기도 어렵다.

필자는 고등학교 시절 배우고, 개발했던 게임 알고리즘들을 활용해서 새로운 환경을 생성, 큰 규모의 시뮬레이션이 가능한 생태계 시뮬레이션 프레임워크를 제시한다. 간단한 알고리즘으로 모델링한 에이전트부터 절차적 생성을 통한 다양한 환경 생성을 구현하여 생태계 시뮬레이션 연구에 기여하고자 한다.

2. Unity에서 최적화를 중앙화 비동기 이동 로직

수백 에이전트가 동시에 활동하는 환경에서 각 에이전트의 독립적인 경로 계산은 시스템 전체의 성능 저하를 야기한다. 전통적으로 A* 알고리즘은 개별 에이전트마다 순차적으로 실행되어 왔으나, 이러한 접근법은 에이전트 수가 증가할수록 계산 복잡도가 선형적으로 증가하는 근본적 한계를 지닌다.

본 리포트에서는 Unity Job System과 Burst 컴파일러를 기반으로 한 병렬 A* 경로탐색 시스템을 제안한다 [2], [12]. 제안된 시스템은 배치 처리와 공유 자료구조를 통해 메모리 효율성을 확보하고, 멀티코어 환경에서의 병렬 처리를 통해 성능 향상을 목표로 한다.

2.1. 관련 연구 및 문제 정의

2.1.1. 기존 A* 구현의 성능 제약

A* 알고리즘은 휴리스틱 함수를 활용한 최적 경로 탐색 알고리즘으로 널리 사용되고 있다 [7]. 그러나 다중 에이전트 환경에서 각 에이전트가 독립적으로 A*를 실행할 경우 문제가 발생한다. 문제는 메모리 사용량의 중복성이다. 각 에이전트는 동일한 지형 정보에 대해 개별적인 Open Set과 Closed Set을 유지해야 하므로, N개 에이전트에 대해 N배의 메모리 오버헤드가 발생한다. 둘째, CPU 자원 활용이 비효율적이다. 순차 처리 방식은 멀티코어 프로세서의 병렬 처리 능력을 활용하지 못하여 하드웨어 성능의 일부분만을 사용한다.

2.1.2. 병렬 경로탐색 연구 동향

병렬 A* 알고리즘에 대한 연구는 주로 단일 에이전트의 탐색 과정을 병렬화하는 방향으로 진행되어 왔다. 그러나 다중 에이전트 환경에서는 각 에이전트의 탐색 작업을 독립적인 병렬 작업으로 처리하는 것이 더 효율적이다. 본 리포트는 후자의 접근법을 채택하여 에이전트별 경로탐색을 병렬화한다.

2.1.3 Unity NavMesh의 한계점

2.1.3.1. 메모리 비효율성과 중복성

NavMesh는 각 에이전트가 독립적인 경로 계산 컨텍스트를 유지해야 한다. NavMesh는 개별 NavMeshAgent 컴포넌트와 각자의 경로 버퍼 만큼을 업데이트 한다 [9].

2.1.3.2. 병렬 처리 한계

Unity NavMesh는 주 스레드에서 순차 처리된다. 에이전트 수가 증가하면 선형적으로 성능이 저하된다 [8].

foreach(NavMeshAgent agent in agents)
    agent.SetDestination(target);

2.1.3.3. 배치 처리 불가능

NavMesh는 개별 에이전트마다 즉시 처리해야 하므로 배치 최적화가 불가능하다 [9].

결론적으로, NavMesh는 소규모 정적 환경에서는 편리하지만, 대규모 다중 에이전트 동적 환경에서는 메모리 비효율성, 병렬 처리 한계, 실시간 업데이트 불가능 등의 구조적 한계로 인해 부적합하다. 제안된 중앙화 병렬 A* 시스템이 이러한 문제들을 근본적으로 해결하는 대안이 된다.

2.2. 시스템 특성 분석

2.2.1 메모리 효율성

제안된 시스템의 가장 큰 장점 중 하나는 메모리 사용량의 효율성이다. 모든 에이전트가 단일 공유 격자를 참조함으로써 중복 메모리 할당을 방지한다.

2.2.2 확장성

배치 처리 방식은 에이전트 수의 증가에 대해 선형적인 확장성을 제공한다. 배치 크기는 고정되어 있지만, 배치 수는 요청량에 따라 동적으로 증가할 수 있다. 또한 Job System의 특성상 사용 가능한 CPU 코어 수에 비례하여 처리 성능이 향상된다 [2].

2.2.3 응답성

배치 처리로 인한 지연시간은 최대 한 프레임 정도이며, 이는 대부분의 실시간 시뮬레이션에서 허용 가능한 수준이다. 중요한 것은 시스템이 일정한 처리 간격을 유지하여 예측 가능한 성능을 제공한다는 점이다.

2.3 기존 시스템과의 비교분석

비교 환경은 많은 에이전트가 있는(100 에이전트) 환경에서 장애물과 목표물을 같은 위치에 배치하고 비교한다.

$$\text{[그림 1] 준비된 환경}$$

</center>

[그림 1]에서 하얀색으로 길게 늘어진 막대는 장애물이며, 오른쪽 노란 선분들이 가르키고 있는 객체가 목표이다. 객체들이 현재 뭉쳐있는 상태라 많아보이지 않을 수 있다.

[그림 1]과 같은 환경에서 기본적인 ASTAR를 실행하는 것과 제안된 ASTAR를 실행하는 것의 성능을 분석하면 아래와 같다:

$$\text{[그림 2] BASIC ASTAR}$$

</center>

$$\text{[그림 3] JOB ASTAR}$$

</center>

[그림 2]와 [그림 3]는 Unity의 Profiler 기능을 이용해서 측정했다.

메트릭	순차 A*	병렬 A*
메인 스레드 시간	74.11ms	3.94ms
평균 FPS	43	120

$$\text{[표 1] A* 성능 비교 표}$$

</center>

[표 1]을 토대로 비교해보자면 메인 스레드 시간과 FPS의 상태를 본다면 얼마나 제안된 방법이 효과적인지 알 수 있다.

3. Unity에서 행동 모델링(FSM vs Behaviour Tree)

에이전트 기반 생태계 시뮬레이션에서는 보통 움직이는 에이전트가 중요하다. 이를 설계하기 위해 알고리즘, 강화학습 등을 활용해서 개발한다. 이 중 단순 알고리즘 기반으로 작동하는 에이전트를 개발할 때, 활용해볼 수 있는 방법론 2개에 대해서 장단점을 비교하고 활용 가능성에 대해 논한다.

3.1. FSM (Finite State Machine)

3.1.1. 기본적인 FSM의 형태

유한 상태 기계는 시스템이 가질 수 있는 유한한 개수의 상태와 이들 간의 전이 규칙으로 구성되는 수학적 모델이다 [5]. 전통적인 FSM은 상태(State), 전이(Transition), 이벤트(Event) 또는 조건(Condition)이라는 세 가지 핵심 요소로 구성된다.

기본적인 FSM에서 각 상태는 독립적인 행동이나 조건을 나타내며, 특정 조건이 만족될 때 다른 상태로 전이한다. 전이는 즉시 발생하며, 시스템은 항상 정확히 하나의 상태에만 존재할 수 있다. 이러한 단순함이 FSM의 가장 큰 장점이자 특징이다.

FSM으로 간단한 동물을 만들어보겠다.

$$\text{[그림 4] 간단한 FSM 다이어그램}$$

</center>

[그림 4]에서 처럼 FSM을 정의할 수 있다. 기본적인 동물의 행동을 간단히 만들어보았을 때, 각각의 조건에 따라 움직임의 상태를 관리할 수 있다.

3.1.2. 생태계 시뮬레이션 구현 시의 이점

3.1.2.1. 직관적인 동물 행동 모델링

FSM의 명확한 상태 구분은 동물의 행동을 직관적으로 모델링할 수 있게 한다. 각 상태가 명확한 책임을 가지고 있어 코드를 이해하기 쉽고 수정하기 쉽다. 동물의 행동이 예상과 다를 때 해당 상태만 확인하면 원인을 쉽게 파악할 수 있다.

3.1.2.2. 높은 성능과 메모리 효율성

FSM은 현재 상태 정보만 유지하면 되므로 매우 적은 메모리를 사용한다. 생태계 시뮬레이션에서 시뮬레이션할 때 이러한 효율성은 매우 중요하다. 각 에이전트마다 최소한의 메모리만 사용하고 필요한 로직만 실행하므로 시스템 리소스를 효과적으로 활용할 수 있다.

3.1.2.3. 예측 가능한 행동과 균형 조정

FSM의 결정론적 특성을 통해 동물 행동의 균형을 쉽게 조정할 수 있다. 각 전이 조건이 명확하게 정의되어 있어 게임 밸런스를 조정할 때 어떤 값을 변경해야 하는지 쉽게 파악할 수 있다.

3.1.2.4. 단순한 행동의 효율적 구현

복잡하지 않은 동물 행동의 경우 FSM이 가장 효율적인 선택이다. 기본적인 생존 행동만 필요한 에이전트들을 구현할 때는 FSM의 단순성이 큰 장점이 된다.

3.2. Behaviour Tree

3.2.1. 기본적인 Behaviour Tree

Behaviour Tree는 게임 AI와 로보틱스 분야에서 복잡한 행동을 계층적으로 구조화하기 위해 개발된 모델이다 [10]. 트리 구조를 통해 복잡한 행동을 작은 단위의 행동들로 분해하고, 이들을 조합하여 더 복잡한 행동 패턴을 만들어낸다.

기본적인 노드 타입들은 다음과 같이 구성된다:

기본 노드 타입:

Composite Nodes: 자식 노드들을 실행하는 방식을 결정
- Selector (OR): 자식 중 하나가 성공할 때까지 순서대로 실행
- Sequence (AND): 모든 자식이 성공해야 성공
- Parallel: 여러 자식을 동시에 실행
Decorator Nodes: 자식 노드의 행동을 수정
- Inverter: 결과를 반대로 변경
- Repeater: 특정 조건까지 반복 실행
- Cooldown: 일정 시간 간격으로 실행 제한
Leaf Nodes: 실제 행동이나 조건을 수행
- Action: 구체적인 행동 실행
- Condition: 조건 검사

</center>

public enum NodeState
{
    Running,
    Success,
    Failure 
}

기본 형태의 Behaviour Tree는 매 프레임마다 루트에서 시작하여 트리를 탐색하며, 각 노드는 NodeState 열거형으로 정의된 세 가지 상태 중 하나를 반환한다. 이러한 단순한 구조만으로도 복잡한 AI 행동을 표현할 수 있지만, 실제 게임이나 시뮬레이션에 적용하기에는 몇 가지 한계가 있다.

$$\text{[그림 5] BT 실행 흐름 다이어그램}$$

</center>

기본적인 동물의 흐름을 Behaviour Tree로 만들어보았다. Selector는 성공된 노드가 발생되면, 이후 뒤에 노드를 실행하지 않고 넘어가니 행동의 우선순위를 정할 때 사용하였고, Squence는 아예 여러 행동들이 연속적으로 행해져야할 때 필요해 한 행동을 정의할 때 묶어서 구현하였다.

[그림 5]와 같이 구현하면, 주변에 포식자가 있으면 도망가고 만약 없다면 음식을 찾으려고 할 것이고 음식이 주변에 없다면 아무 곳이나 돌아다니게 되는 동물을 만들 수 있다.

4. 절차적 생성을 통한 생태계 생성 알고리즘

본 리포트는 절차적 환경 생성(PCG) 분야의 두 핵심 알고리즘, Wave Function Collapse(WFC)와 Binary Space Partitioning(BSP)의 통합 모델을 실제 Unity C# 스크립트 구현을 통해 심층적으로 분석한다. 이론적 개념이 코드 로직으로 전환되는 과정과 두 알고리즘이 유기적으로 결합하여 시너지를 창출하는 방식에 초점을 맞춘다. 궁극적으로 본 통합 모델이 생태계 시뮬레이션을 위한 유연하고 통제 가능한 실험 환경을 구축하는 데 효과적인 도구임을 제시하고자 한다.

4.1. Wave Function Collapse (WFC)

4.1.1. WFC의 핵심 원리

Wave Function Collapse는 국소적 규칙으로부터 전역적으로 일관성 있는 패턴을 생성하는 비반복적 타일링 알고리즘이다 [13]. 그 핵심 원리는 양자역학의 개념에서 차용되었으며 [14], 생성 대상인 그리드의 각 셀은 초기에 모든 가능한 타일 상태를 포함하는 '중첩(superposition)' 상태로 시작한다. 이때 각 셀이 가질 수 있는 상태의 가짓수를 '엔트로피(entropy)'라고 정의한다.

$$H(c) = |S_c|$$

$$\text{[수식 1] 엔트로피 정의}$$

</center>

[수식 1]에서 $$H(c)$$는 셀 $$c$$의 엔트로피, $$S_c$$는 셀 $$c$$의 가능한 상태 집합이다.

알고리즘은 관측-전파(Observe-Propagate) 루프를 반복한다. 먼저 관측 단계에서는 전체 그리드에서 가장 낮은 엔트로피를 가진 셀, 즉 가장 적은 가능성을 가진 셀을 선택한다.

$$c^* = \arg\min_{c \in R, H(c) > 1} H(c)$$

$$\text{[수식 2] 최저 엔트로피 셀 선택 수식}$$

</center>

[수식 2]에서 $$R$$은 현재 지역의 셀 집합, $$c^*$$는 선택된 셀이다.

이어서 붕괴 단계에서는 선택된 셀의 상태를 여러 가능성 중 하나로 확정시키며, 이 선택은 각 타일의 가중치에 따른 확률적 선택이 될 수 있다.

$$P(t_i) = \frac{w_i}{\sum_{j \in S_c} w_j}$$

$$\text{[수식 3] 확률적 선택 수식}$$

</center>

[수식 3]에서 $$P(t_i)$$는 타일 $$t_i$$가 선택될 확률, $$w_i$$는 타일 $$t_i$$의 가중치이다.

마지막으로 전파 단계에서는 하나의 셀이 붕괴되면 그 결정이 새로운 제약 조건이 되어 인접 셀들에게 영향을 미치며, 붕괴된 셀의 인접 규칙에 위배되는 타일들을 주변 셀들의 가능성 목록에서 제거한다.

$$S_{c'} \leftarrow S_{c'} \cap {t | R(t_{collapsed}, t) = \text{true}}$$

$$\text{[수식 4] 제약 전파 수식}$$

</center>

[수식 4]에서 $$S_{c'}$$는 인접 셀 $$c'$$의 상태 집합, $$R(t_1, t_2)$$는 두 타일 간의 인접 규칙이다.

이 과정을 통해 주변 셀들의 엔트로피가 감소하며, 연쇄적인 제약 전파가 더 이상 변화가 없을 때까지 계속된다. 모든 셀의 엔트로피가 1이 될 때까지 이 루프를 반복하면, 국소적 인접 규칙만을 사용했음에도 불구하고 전체적으로는 매우 복잡하고 자연스러운 거대 패턴이 완성된다.

$$\forall c \in C: H(c) = 1$$

$$\text{[수식 5] 알고리즘 종료 조건}$$

</center>

[수식 5]에서 $$C$$는 전체 셀 집합이다.

$$\text{[그림 6] 구현된 WFC의 생성된 생태계}$$

</center>

[그림 6]은 기본적으로 규칙 자체가 간단해지면서, 노이즈처럼 발생되는 것으로 보이게 된다.

4.1.2. 지역적 WFC 구현과 계산 복잡도 관리

제공된 스크립트에서 WFC는 BSP가 구획한 각 지역 내부의 세부 생태계를 묘사하는 데 사용되며, 이는 WFC의 계산 복잡도를 관리하는 핵심적인 최적화 전략이다. GenerateRegionalWFC 함수가 이 과정을 총괄하며, 가장 불확실성이 낮은 셀을 찾는 관측 단계는 FindLowestEntropyCellInRegion 함수를 통해 구현된다.

이 함수는 지역 내의 모든 셀을 순회하면서 붕괴되지 않은 셀들 중에서 가능성 목록의 길이가 가장 짧은 셀을 찾는다. 동일한 엔트로피를 가진 셀이 여러 개 있을 경우, 모든 후보를 수집한 후 무작위로 하나를 선택함으로써 생성 결과의 다양성을 확보한다. 이러한 접근 방식은 결정론적 선택으로 인한 패턴의 경직성을 방지하는 중요한 역할을 한다.

셀이 선택되어 CollapseCellInRegion 함수를 통해 붕괴되면, PropagateConstraintsInRegion 함수가 전파 단계를 수행한다. 이 함수는 너비 우선 탐색(BFS) 방식의 큐를 사용하여 붕괴된 셀로부터 시작해 영향을 받는 모든 인접 셀들로 제약 조건을 전파한다. 각 셀의 WFCRule을 기준으로 인접한 미붕괴 셀들의 가능성 리스트를 갱신하여, 새로운 제약 조건에 위배되는 타일 옵션들을 체계적으로 제거한다.

지역적 WFC 접근법의 가장 큰 장점은 거대한 맵 전체를 단일 WFC 시스템으로 처리할 때 발생하는 조합 폭발 문제를 원천적으로 방지한다는 점이다. 전체 맵이 100x100 크기라면 10,000개의 셀을 동시에 처리해야 하지만, 이를 10개의 지역으로 나누면 각각 평균 1,000개의 셀만 처리하면 되어 계산 복잡도가 현저히 감소한다.

$$O(n^2) \rightarrow O(k \cdot (\frac{n}{k})^2) = O(\frac{n^2}{k})$$

$$\text{[수식 6] 계산 복잡도 감소}$$

</center>

[수식 6]에서 $$n$$은 전체 맵 크기, $$k$$는 지역 개수이다.

동시에 각 지역의 고유한 생태학적 특성을 효과적으로 부여할 수 있는 기반이 된다.

4.2. Binary Space Partitioning (BSP)

4.2.1. BSP의 수학적 원리와 공간 조직화

Binary Space Partitioning(BSP)은 주어진 공간을 분할 평면을 사용해 재귀적으로 두 개의 부분 공간으로 나누는 알고리즘이다 [6]. 이 과정은 이진 트리 자료구조를 형성하는데, 각 노드는 공간의 한 영역을, 자식 노드들은 부모 노드가 분할된 두 개의 하위 영역을 나타낸다.

$$S_i = {S_{i,left}, S_{i,right}} \text{ where } S_{i,left} \cap S_{i,right} = \emptyset$$

$$\text{[수식 7] BSP 재귀적 분할}$$

</center>

[수식 7]에서 $$S_i$$는 깊이 $$i$$에서의 공간 집합, $$S_{i,left}$$와 $$S_{i,right}$$는 분할된 두 부분 공간이다.

분할은 특정 종료 조건이 충족될 때까지 반복되며, 일반적으로 영역의 최소 크기나 트리의 최대 깊이를 기준으로 한다.

$$\text{Stop if: } \min(w, h) < T_{min} \text{ or } d > D_{max}$$

$$\text{[수식 8] BSP 종료 조건}$$

</center>

[수식 8]에서 $$w$$, $$h$$는 영역의 폭과 높이, $$T_{min}$$은 최소 임계값, $$d$$는 현재 깊이, $$D_{max}$$는 최대 깊이이다.

이 알고리즘의 본질적인 계층성과 분할-정복(Divide and Conquer) 접근 방식은 대규모 공간을 관리 가능한 단위로 체계적으로 조직화하는 데 매우 효율적이다.

$$|N| = 2^{d+1} - 1$$

$$\text{[수식 9] BSP 트리 크기}$$

</center>

[수식 9]에서 $$|N|$$은 트리의 총 노드 수, $$d$$는 트리의 최대 깊이이다.

전통적으로 게임의 던전이나 건물 내부의 방과 복도를 생성하는 데 사용되어 왔으나, 본 연구의 맥락에서는 서로 다른 기후와 특징을 가진 거대 생물군계를 구획하는 이상적인 도구로 활용된다.

BSP의 핵심적 장점은 생성된 구조가 자연스럽게 계층적 관리와 탐색이 가능하다는 점이다. 트리의 각 레벨은 서로 다른 규모의 공간 조직화를 나타내며, 루트 노드에서는 전체 대륙 수준의 거시적 구조를, 잎 노드에서는 개별 생태 지역 수준의 미시적 구조를 다룰 수 있다. 이러한 다중 스케일 접근법은 복잡한 생태계의 자연스러운 위계 구조를 모방하는 데 특히 유용하다.

5. Implementation

5.1. 본 A* 구현에서 확장점

5.1.1 시스템 아키텍처 설계

5.1.1. 중앙화된 경로탐색 관리자

제안된 시스템의 핵심은 AStarManager 클래스로 구현된 중앙화된 경로탐색 관리 시스템이다. 이 시스템은 Singleton 패턴을 통해 전역적으로 접근 가능한 단일 인스턴스를 제공하며, 모든 에이전트의 경로 요청을 통합적으로 관리한다.

시스템의 주요 구성 요소는 다음과 같다:

공유 격자 구조(Shared Grid): 모든 에이전트가 공통으로 사용하는 지형 정보
요청 대기열(Request Queue): 에이전트들의 경로탐색 요청을 순차적으로 저장
배치 처리 배열: 고정 크기의 배치 단위로 요청을 처리하기 위한 자료구조

private NativeArray<PathNode> grid;
private Queue<PathRequest> requestQueue;
private NativeArray<PathRequest> batchRequests;
private NativeArray<PathResult> batchResults;

5.1.2. 배치 기반 처리 메커니즘

시스템은 개별 요청을 즉시 처리하는 대신, 일정한 크기의 배치로 묶어서 처리한다. 기본 배치 크기는 128개로 설정되어 있으며, 이는 메모리 사용량과 처리 지연시간 사이의 균형점을 고려하여 결정된 값이다. 배치 처리 방식은 Job System의 오버헤드를 최소화하고 일관된 성능을 보장한다 [12].

private void ProcessBatch()
{
    currentJobHandle.Complete();
    ProcessResults();
    
    int count = math.min(batchSize, requestQueue.Count);
    if (count == 0) return;
    
    AStar job = new AStar {
        requests = batchRequests,
        grid = grid,
        gridWidth = gridWidth,
        gridHeight = gridHeight,
        maxPathLength = maxPathLength,
        results = batchResults,
        pathBuffer = pathBuffer
    };
    
    currentJobHandle = job.Schedule(count, math.max(1, count / 4));
}

5.1.3. 요청 중복 제거 및 생명주기 관리

시스템은 동일 에이전트로부터의 빈번한 요청을 방지하기 위해 시간 기반 필터링을 구현한다. 각 에이전트는 설정된 최소 간격(pathUpdateInterval) 내에서 하나의 요청만 처리되며, 이미 처리 중인 요청이 있는 경우 새로운 요청은 무시된다.

if (lastRequestTime.TryGetValue(agentId, out float lastTime))
{
    if (Time.time - lastTime < pathUpdateInterval * 0.5f)
        return;
}

또한 오래된 요청에 대한 정리 메커니즘을 통해 메모리 누수를 방지하고 시스템의 장기적 안정성을 보장한다.

5.1.2 Burst 최적화된 병렬 A* 구현

5.1.2.1. Job System 인터페이스 구현

A* 알고리즘은 IJobParallelFor 인터페이스를 구현한 구조체로 작성되었다. 이는 Unity의 Job System이 자동으로 작업을 여러 스레드에 분산 실행할 수 있게 한다 [2]. Burst 컴파일러의 최적화를 최대한 활용하기 위해 부동소수점 연산 모드를 Fast로, 정밀도를 Low로 설정했다 [12].

[BurstCompile(CompileSynchronously = true, FloatMode = FloatMode.Fast,
 FloatPrecision = FloatPrecision.Low)]
public struct AStar : IJobParallelFor
{
    public void Execute(int index)
    {
        PathRequest request = requests[index];
        PathResult result = new PathResult
        {
            requestId = request.requestId,
            agentId = request.agentId,
            success = false,
            pathStartIndex = index * maxPathLength,
            pathLength = 0
        };
        
        if (request.start.x == request.goal.x && request.start.y == request.goal.y)
        {
            result.success = true;
            result.pathLength = 1;
            pathBuffer[result.pathStartIndex] = request.goal;
            results[index] = result;
            return;
        }
        
        float distance = math.distance(request.start, request.goal);
        
        SimpleAStar(index, request, ref result);
        
            
        results[index] = result;
    }
}

5.1.2.2. 메모리 효율적인 자료구조 활용

각 Job 실행 시 필요한 임시 자료구조는 Allocator.Temp를 사용하여 할당하고, Job 완료 시 자동으로 해제되도록 구현했다. 이는 메모리 누수를 방지하고 가비지 컬렉션의 압박을 줄이는 효과를 가져온다.

private void SimpleAStar(int jobIndex, PathRequest request, ref PathResult result)
{
    const int MAX_ITERATIONS = 1000;
    const int MAX_OPEN_SET_SIZE = 512;
    
    NativeMinHeap openSet = new NativeMinHeap(MAX_OPEN_SET_SIZE, Allocator.Temp);
    NativeHashSet<int> closedSet = new NativeHashSet<int>(MAX_OPEN_SET_SIZE, Allocator.Temp);
    NativeHashMap<int, int> cameFrom = new NativeHashMap<int, int>(MAX_OPEN_SET_SIZE, Allocator.Temp);
    NativeHashMap<int, int> gScore = new NativeHashMap<int, int>(MAX_OPEN_SET_SIZE, Allocator.Temp);
    
    
    openSet.Dispose();
    closedSet.Dispose();
    cameFrom.Dispose();
    gScore.Dispose();
}

5.1.2.3. 대각선 이동 처리 및 코너 컷팅 방지

8방향 이동을 지원하되, 대각선 이동 시 코너 컷팅을 방지하기 위한 검증 로직을 구현했다. 대각선 방향으로 이동할 때 인접한 두 직교 방향이 모두 통행 가능한 경우에만 이동을 허용한다.

if (dir % 2 == 1)
{
    int2 checkPos1 = GetNeighborPosition(currentPos, (dir - 1) % 8);
    int2 checkPos2 = GetNeighborPosition(currentPos, (dir + 1) % 8);
    
    if (!IsValidPosition(checkPos1) || !IsValidPosition(checkPos2))
        continue;
        
    int checkIndex1 = GetIndex(checkPos1);
    int checkIndex2 = GetIndex(checkPos2);
    
    if (!grid[checkIndex1].isWalkable || !grid[checkIndex2].isWalkable)
        continue;
}

5.1.3. 경로 후처리 및 최적화

5.1.3.1. 경로 평활화 알고리즘

A* 알고리즘이 생성하는 격자 기반 경로는 계단 형태의 부자연스러운 모양을 가질 수 있다. 이를 개선하기 위해 시선 기반 경로 평활화 알고리즘을 구현했다. 이 알고리즘은 현재 위치에서 가장 멀리 보이는 지점까지 직선으로 연결하여 웨이포인트 수를 줄이고 보다 자연스러운 경로를 생성한다.

private List<int2> SmoothPath(List<int2> path)
{
    if (path.Count <= 2)
        return path;
    
    List<int2> smoothed = new List<int2>();
    smoothed.Add(path[0]);
    
    int currentIndex = 0;
    while (currentIndex < path.Count - 1)
    {
        int farthestVisible = currentIndex + 1;
        
        for (int i = currentIndex + 2; i < path.Count; i++)
        {
            if (HasLineOfSight(path[currentIndex], path[i]))
                farthestVisible = i;
            else
                break;
        }
        
        smoothed.Add(path[farthestVisible]);
        currentIndex = farthestVisible;
    }
    
    return smoothed;
}

5.1.3.2. 브레젠험 알고리즘을 이용한 시선 검사

두 지점 사이의 시선 검사는 브레젠험(Bresenham) 직선 알고리즘을 활용하여 구현했다 [15]. 이 방법은 부동소수점 연산을 피하고 정수 연산만으로 두 점 사이의 모든 격자를 순회하면서 장애물 존재 여부를 확인할 수 있어 계산 효율성이 높다.

private bool HasLineOfSight(int2 start, int2 end)
{
    int x0 = start.x; int y0 = start.y;
    int x1 = end.x; int y1 = end.y;
    
    int dx = math.abs(x1 - x0);
    int dy = math.abs(y1 - y0);
    int x = x0; int y = y0;
    int n = 1 + dx + dy;
    int x_inc = (x1 > x0) ? 1 : -1;
    int y_inc = (y1 > y0) ? 1 : -1;
    int error = dx - dy;
    dx *= 2; dy *= 2;
    
    for (; n > 0; --n)
    {
        if (!IsValidPosition(new int2(x, y)) || !IsWalkable(new int2(x, y)))
            return false;
        
        if (error > 0)
        {
            x += x_inc;
            error -= dy;
        }
        else
        {
            y += y_inc;
            error += dx;
        }
    }
    
    return true;
}

5.1.4. 동적 환경 지원 및 유지보수성

5.1.4.1. 실시간 장애물 업데이트

시뮬레이션 환경에서 장애물의 생성, 제거, 이동이 빈번하게 발생할 수 있다. 이에 대응하기 위해 격자의 특정 영역만을 선택적으로 업데이트하는 메커니즘을 구현했다. 전체 격자를 재생성하는 대신 영향받는 영역만을 업데이트하여 성능 저하를 최소화한다.

public void UpdateObstacle(Vector3 worldPos, float radius, bool isWalkable)
{
    int2 gridPos = WorldToGrid(worldPos);
    int gridRadius = Mathf.CeilToInt(radius / cellSize);
    
    for (int x = -gridRadius; x <= gridRadius; x++)
    {
        for (int y = -gridRadius; y <= gridRadius; y++)
        {
            int2 checkPos = gridPos + new int2(x, y);
            if (!IsValidPosition(checkPos))
                continue;
                
            float distance = math.distance(gridPos, checkPos);
            if (distance <= gridRadius)
            {
                int index = checkPos.x + checkPos.y * gridWidth;
                PathNode node = grid[index];
                node.isWalkable = isWalkable;
                grid[index] = node;
            }
        }
    }
}

5.1.4.2. 메모리 관리 및 시스템 안정성

시스템의 장기적 안정성을 위해 여러 단계의 메모리 관리 메커니즘을 구현했다. 오래된 경로 요청은 주기적으로 정리되며, NativeArray와 같은 비관리 메모리 자원은 시스템 종료 시 명시적으로 해제된다.

protected override void OnDestroy()
{
    currentJobHandle.Complete();
    
    if (grid.IsCreated) grid.Dispose();
    if (batchRequests.IsCreated) batchRequests.Dispose();
    if (batchResults.IsCreated) batchResults.Dispose();
    if (pathBuffer.IsCreated) pathBuffer.Dispose();
    
    base.OnDestroy();
}

5.2. 본 FSM 구현에서의 확장점

5.2.1. 제네릭 기반 타입 안전성

본 구현에서는 C#의 제네릭 시스템을 활용하여 타입 안전성과 재사용성을 크게 향상시켰다.

public interface IState<T> 
{
    void Enter(T owner);
    void Execute(T owner);
    void Exit(T owner);
}

public class StateMachine<T>
{
    private T owner;
    private IState<T> currentState;
    private IState<T> previousState;
    private Dictionary<Type, IState<T>> states;
}

제네릭 <T> 매개변수를 통해 어떤 타입의 객체에도 적용할 수 있는 범용적인 상태 기계를 구현했다.

5.2.2. 명시적 생명주기 관리

전통적인 FSM과 달리 본 구현은 상태의 생명주기를 명시적으로 관리한다.

public void ChangeState<TState>() where TState : IState<T>
{
    Type stateType = typeof(TState);
    if (states.ContainsKey(stateType))
    {
        if (currentState != null)
        {
            currentState.Exit(owner);  
            previousState = currentState;
        }
        currentState = states[stateType];
        currentState.Enter(owner);       
    }
}

Enter, Execute, Exit 메서드를 통해 상태의 시작, 실행, 종료 단계를 명확히 구분한다. 이는 각 단계에서 필요한 초기화와 정리 작업을 체계적으로 수행할 수 있게 한다.

5.2.3. 딕셔너리 기반 상태 관리

상태들을 Dictionary<Type, IState<T>>로 관리하는 방식은 성능과 유연성 측면에서 중요한 개선이다.

public void AddState(IState<T> state)
{
    states[state.GetType()] = state;
}

public void ChangeState<TState>() where TState : IState<T> {
    Type stateType = typeof(TState);
    if (states.ContainsKey(stateType))
    {
        // code ...
    }
}

타입을 키로 사용하는 딕셔너리 구조를 통해 O(1) 시간 복잡도로 상태에 접근할 수 있다. 또한 컴파일 타임에 상태 타입을 검증할 수 있어 잘못된 상태 참조로 인한 오류를 방지한다.

5.2.4. 이전 상태 추적 기능

많은 기본 FSM 구현에서 제공하지 않는 이전 상태 추적 기능을 구현했다.

public void RevertToPreviousState()
{
    if (previousState != null)
    {
        if (currentState != null)
        {
            currentState.Exit(owner);
        }
        currentState = previousState;
        currentState.Enter(owner);
    }
}

이 기능을 통해 일시적인 상태 변경 후 원래 상태로 돌아가는 패턴을 쉽게 구현할 수 있다.

5.3. 본 Behaviour Tree 구현에서의 확장점

5.3.1. 노드 생명주기 관리 시스템

본 구현에서는 기본적인 행동 트리 구조에서 한 걸음 나아가 노드의 생명주기를 명시적으로 관리하는 시스템을 도입했다.

public virtual NodeState Evaluate()
{
    bool isCurrentlyRunning = (state == NodeState.Running);
    
    state = DoEvaluate();
    
    
    if (wasRunning && state != NodeState.Running)
    {
        OnExitNode();
    }
    else if (!wasRunning && state == NodeState.Running)
    {
        OnEnterNode();
    }
    
    wasRunning = (state == NodeState.Running);
    return state;
}

protected virtual void OnEnterNode() { }
protected virtual void OnExitNode() { }

wasRunning 플래그를 통해 이전 프레임의 실행 상태를 추적하고, 상태 변화에 따라 OnEnterNode와 OnExitNode 메서드를 자동으로 호출한다. 이는 전통적인 행동 트리에서는 제공하지 않는 중요한 기능이다. 많은 AI 행동들은 시작 시점에서 초기화 작업이 필요하고, 종료 시점에서 정리 작업이 필요하다. 예를 들어, 이동 행동을 시작할 때는 경로를 계산하고, 종료할 때는 애니메이션을 정리해야 한다.

5.3.2. 동적 중단 메커니즘

기본적인 행동 트리는 우선순위 변경에 따른 행동 중단을 처리하는 표준적인 방법을 제공하지 않는다. 본 구현에서는 재귀적 중단 시스템을 구축했다.

public virtual void Interrupt()
{
    
    foreach (Node child in children) 
        child.Interrupt();

    if (wasRunning)
    {
        OnInterrupted?.Invoke();
        OnExitNode();
        state = NodeState.Failure;
        wasRunning = false;
    }
}

이 메커니즘은 높은 우선순위의 행동이 활성화될 때 현재 실행 중인 모든 하위 행동을 일관되게 중단할 수 있게 한다. OnInterrupted 액션 델리게이트를 통해 외부 시스템에서 중단 이벤트를 감지할 수 있도록 하여, 행동 트리와 다른 게임 시스템 간의 통합을 용이하게 했다.

5.3.3. 게임 엔진 통합 최적화

Unity와의 긴밀한 통합을 위해 ActionNode 클래스에서 핵심 컴포넌트들에 직접 접근할 수 있도록 구현했다.

public abstract class ActionNode : Node
{
    protected Transform transform;
    protected Animator animator;
    protected Rigidbody2D rigidbody;
    protected bool isActive = false;
    
    public ActionNode(Transform transform, bool forceComplete = false, string cooldownKey = null)
    {
        this.transform = transform;
        this.mustComplete = forceComplete;
        this.cooldownKey = cooldownKey;
        
        animator = transform.GetComponent<Animator>();
        rigidbody = transform.GetComponent<Rigidbody2D>();
    }
}

이러한 설계는 AI 프로그래머가 복잡한 인터페이스나 중간 계층 없이 직접적으로 게임 오브젝트를 조작할 수 있게 한다. 생태계 시뮬레이션에서 동물의 이동, 애니메이션, 물리 상호작용을 즉시 제어할 수 있어 개발 효율성이 크게 향상된다.

5.3.4. 강제 완료 메커니즘

특정 행동이 중단되지 않고 완료되어야 하는 상황을 처리하기 위한 기능이다.

public sealed override NodeState Evaluate()
{
    
    if (mustComplete && isActive && state == NodeState.Running) 
    {
        NodeState result = DoEvaluate();
        if (wasRunning && result != NodeState.Running) {
            OnExitNode();
            isActive = false;
        }
        
        if (result == NodeState.Success && !string.IsNullOrEmpty(cooldownKey)) {
            Cooldown.StartCooldown(cooldownKey);
        }
        state = result;
        wasRunning = (state == NodeState.Running);
        return result;
    }
    
    NodeState evaluationResult = base.Evaluate();
    if (evaluationResult == NodeState.Success && !string.IsNullOrEmpty(cooldownKey)) {
        Cooldown.StartCooldown(cooldownKey);
    }
    return evaluationResult;
}

mustComplete 플래그를 통해 공격이나 중요한 애니메이션과 같이 중간에 중단되면 안 되는 행동들을 보호할 수 있다. 이는 자연스러운 동물 행동 구현에 필수적인 기능이다.

5.3.5. 쿨다운 시스템

행동의 빈도를 제어하여 더욱 현실적인 AI 행동을 구현한다.

protected string cooldownKey = null;

if (result == NodeState.Success && !string.IsNullOrEmpty(cooldownKey)) {
    Cooldown.StartCooldown(cooldownKey);
}

문자열 키 기반의 쿨다운 시스템을 통해 서로 다른 행동들이 독립적인 쿨다운을 가지거나, 관련된 행동들이 같은 쿨다운을 공유할 수 있다.

5.3.6. 물리 시뮬레이션 분리

Unity의 고정 업데이트 사이클과 일반 업데이트 사이클을 분리하여 처리한다.

public virtual void FixedEvaluate()
{
    foreach(Node child in children) 
        child.FixedEvaluate();
}

물리와 관련된 AI 로직을 별도로 처리할 수 있는 확장점을 제공한다. 생태계 시뮬레이션에서 동물의 이동이나 충돌 처리와 같은 물리 기반 행동을 정확하게 구현할 수 있다.

5.4. 본 절차적 생성의 확장점

5.4.1. bspInfluence를 통한 알고리즘 간 균형 조절

$$\text{[그림 6] BspInfluence에 따른 생태계 변화 비교}$$

</center>

[그림 6]에서 확인할 수 있듯이, 두 알고리즘 간의 영향력을 동적으로 조절할 수 있는 bspInfluence 파라미터이다. 이 값은 0에서 1 사이의 실수로, 0에 가까울수록 순수한 WFC의 자유로운 패턴 생성을, 1에 가까울수록 BSP의 구조적 제약을 강하게 반영한다. 이러한 연속적 조절 방식은 이산적인 알고리즘 선택보다 훨씬 유연하고 세밀한 제어를 가능하게 한다.

bspInfluence의 효과는 CollapseCellInRegion 함수 내에서 구체적인 가중치 로직으로 구현된다. WFC의 셀 붕괴 과정에서 각 타일 타입의 선택 확률을 계산할 때, BSP에 의해 할당된 지역적 바이옴에 추가적인 가중치를 부여하는 것이다. 이 지역에 허용된 바이옴일 경우 기본 가중치에 (1 + bspInfluence) 배수를 곱하고, 주도 바이옴일 경우에는 추가로 (1 + bspInfluence × 0.5) 배수를 더 곱한다.

이러한 수식적 접근은 bspInfluence 값이 증가함에 따라 지역적 바이옴의 선택 확률이 지수적으로 증가하도록 설계되었다. 예를 들어 bspInfluence가 0.5일 때, 허용된 바이옴은 1.5배의 가중치를, 주도 바이옴은 1.75배의 가중치를 받는다. 만약 bspInfluence가 0.9로 증가하면 각각 1.9배와 2.35배의 가중치를 받게 되어, BSP의 구조적 의도가 WFC의 확률적 생성 과정을 강력하게 영향을 미치게 된다.

5.4.2. 시드 배치 전략과 구조적 안정성 확보

높은 bspInfluence 값에서는 단순한 가중치 조정을 넘어서 PlaceSeedCells 함수를 통한 시드 배치 전략이 활용된다. 이 함수는 각 지역의 중심부에 해당 지역의 주도 바이옴으로 이미 붕괴된 시드 셀들을 미리 배치함으로써, WFC 생성 과정이 시작되기 전에 구조적 앵커 포인트를 제공한다.

시드의 배치 범위는 지역 크기의 20%에 bspInfluence 값을 곱한 반지름으로 결정되므로, BSP의 영향력이 클수록 더 넓은 영역에 시드가 배치된다. 이는 WFC의 엔트로피 기반 생성이 무작위성에만 의존하지 않고 BSP가 설계한 거시적 구조를 중심으로 전개되도록 유도하는 핵심 메커니즘이다. 시드 셀들로부터 시작된 제약 전파는 주변 지역으로 해당 바이옴의 특성을 확산시키며, 결과적으로 지역의 중심부는 강한 정체성을, 경계부는 상대적으로 혼재된 특성을 갖게 된다.

이러한 중심-경계 구조는 실제 생태학에서 관찰되는 핵심지역(core area)과 전이대(ecotone)의 개념을 자연스럽게 모방한다. 핵심지역에서는 해당 생태계의 전형적 특성이 강하게 나타나고, 인접한 생태계 간의 경계에서는 두 생태계의 특성이 혼재되어 나타나는 현상이 컴퓨터 알고리즘으로 자연스럽게 재현되는 것이다.

5.4.3. 경계 블렌딩을 통한 자연스러운 전이 구현

알고리즘적 생성만으로는 종종 인위적이거나 급작스러운 전이가 나타날 수 있다. 특히 BSP의 명확한 경계선은 자연 생태계에서는 거의 관찰되지 않는 급격한 바이옴 변화를 만들어낼 수 있다. 이를 해결하기 위해 ApplyBoundaryBlending 함수는 구역 경계 근처에서 가중 평균을 사용한 속성 블렌딩을 수행한다.

블렌딩 과정은 각 타일의 구역 경계로부터의 거리를 기준으로 한다. blendingRadius 값 이하의 거리에 있는 모든 타일에 대해, 주변 타일들의 생태학적 속성을 거리 기반 가중치로 평균화한다. 가중치는 거리에 반비례하므로 가까운 타일의 영향이 더 크게 반영되며, 이는 자연스러운 확산 효과를 만들어낸다.

주목할 점은 타일의 타입 자체는 변경되지 않고 fertility, moisture, temperature와 같은 수치적 속성만 블렌딩된다는 것이다. 즉, 사막 타일이 숲 타일로 바뀌지는 않지만 인접한 숲 지역의 영향으로 습도가 약간 증가하고 온도가 약간 감소할 수 있다. 이러한 섬세한 접근 방식은 바이옴의 기본적 정체성은 유지하면서도 경계에서의 급격한 속성 변화를 완화하여 생태계 전이를 구현한다.

$$\text{[그림 7] Blending 후처리 전후 비교} $$

</center>

5.4.4. 고립 타일 정리와 연결성 개선

절차적 생성의 확률적 특성으로 인해 주변과 완전히 다른 특성을 가진 고립된 타일들이 종종 생성된다. 이러한 고립 타일들은 시각적으로 부자연스러울 뿐만 아니라 생태학적으로도 비현실적이다. CleanupIsolatedTiles 함수는 각 타일 주변 8방향을 검사하여 자신과 동일한 타입의 이웃이 1개 이하인 경우 고립된 것으로 판단하고, 해당 타일을 주변에서 가장 빈번하게 나타나는 타일 타입으로 교체한다.

이러한 후처리는 단순해 보이지만 생성 품질에 미치는 영향은 상당하다. 고립 타일의 제거는 각 바이옴 영역의 연속성과 응집성을 높여 더욱 자연스럽고 설득력 있는 지형을 만들어낸다. 동시에 시각적 노이즈를 줄여 전체적인 맵의 가독성을 향상시킨다.

물 타일에 대해서는 특별한 연결성 개선 로직이 적용된다. ImproveWaterConnectivity 함수는 기존의 물 타일들을 식별한 후, 일정 범위 내에 있는 다른 물 타일들을 선형 경로로 연결한다. 이는 강과 호수의 자연스러운 수계망을 모방한 것으로, 분리된 물 영역들을 유기적으로 연결하여 더욱 현실적인 수문학적 구조를 만들어낸다. 연결 과정에서는 기존의 풀이나 숲 지역만을 물로 변환하여 산이나 사막 같은 부적절한 지역을 통과하지 않도록 제한한다.

5.4.5. 개선 방안

WFC는 전체적인 구조를 잘 담아내는데 문제가 있다. 결과를 보면 알 수 있듯이 아직까지 '자연스럽다' 라고 생각이 들지는 않는다. 또한 아직 자연이라고는 생각이 들지 않는다. 나무, 풀 등 식생이 존재하지 않으며, 생성 로직 또한 소개되지 않았다. 그래서 자연스러운 생태계 생성과 더불어 식생을 만드는데 필요한 알고리즘을 [3], [4]의 논문을 기반으로 구현을하여 개선할 수 있다.

절차적 생성으로 식생을 생태학적 원리에 기반하여 생성하며, 강화학습을 통해서 자연스러운 환경 타일 등을 생성하도록 만들어 현재의 구현 문제점을 보완한다.

6. 결론 및 향후 연구 방향

6.1. 연구 성과 및 기여점

6.1.1. 성능 최적화 달성

본 리포트에서 제안한 Unity Job System 기반 중앙화 병렬 A* 시스템은 기존 순차 처리 방식 대비 18.8배의 성능 향상을 달성했다. 메인 스레드 처리 시간을 74.11ms에서 3.94ms로 단축하고 평균 FPS를 43에서 120으로 개선한 것은 대규모 생태계 시뮬레이션의 실시간 처리 가능성을 크게 높인 성과다.

특히 배치 처리 방식과 공유 자료구조를 통한 메모리 효율성 확보는 수천 개체의 동시 시뮬레이션을 가능하게 하는 핵심 기반 기술이 되었다. 이는 기존 NetLogo, Repast 같은 플랫폼이 천 개체 수준에서 성능 저하를 보이는 한계를 극복한 것이다 [16].

6.1.2. 유연한 행동 모델링 프레임워크 구축

FSM과 Behaviour Tree의 심층적 비교 분석을 통해 에이전트 복잡도와 환경 특성에 따른 적응적 선택 기준을 제시했다. 단순 에이전트에는 FSM의 효율성을, 복잡한 에이전트에는 Behaviour Tree의 표현력을 활용하는 하이브리드 접근법은 계산 리소스와 행동 복잡성 사이의 최적 균형점을 제공한다.

특히 생명주기 관리, 동적 중단 메커니즘, 강제 완료 시스템 등의 확장 기능을 통해 자연스러운 동물 행동 패턴 구현이 가능해졌다. 이는 전통적인 게임 AI 기법을 생태계 시뮬레이션 분야로 성공적으로 확장 가능성을 제안한 것이다.

6.2. 시스템의 한계점 및 개선 과제

6.2.1. 환경 모델의 사실성 부족

현재 구현된 WFC+BSP 통합 시스템은 기본적인 바이옴 분포만을 다루며, 실제 생태계의 복잡한 상호작용을 충분히 반영하지 못한다. 식생의 부재, 수계망의 단순성, 토양-기후-생물군 간의 피드백 메커니즘 부족 등이 주요 한계점이다.

특히 현재의 타일 기반 접근법은 연속적인 환경 변화나 미기후 효과를 표현하기에 해상도가 제한적이다. 보다 사실적인 생태계 시뮬레이션을 위해서는 다중 스케일 환경 모델링이 필요하다.

6.2.2. 확장성과 모듈화의 개선 필요

각 구성 요소(경로탐색, 행동 모델링, 환경 생성)가 상대적으로 독립적으로 구현되어 있어, 시스템 간 유기적 상호작용을 구현하기에는 통합 아키텍처가 부족하다. 특히 환경 변화가 에이전트 행동에 미치는 영향이나, 에이전트 활동이 환경에 미치는 피드백 효과를 체계적으로 다루는 프레임워크가 필요하다.

6.3. 향후 연구 방향

6.3.1. 강화학습 기반 적응형 생태계

에이전트의 행동 패턴이 환경과의 상호작용을 통해 동적으로 진화하는 시스템을 구축할 수 있다. 개별 에이전트는 강화학습을 통해 최적 생존 전략을 학습하고, 집단 차원에서는 유전 알고리즘을 통해 행동 특성이 세대를 거쳐 전승되는 모델을 구현할 수 있다.

이는 기존의 고정된 행동 규칙에서 벗어나 실제 진화 과정을 모방한 동적 생태계 시뮬레이션을 가능하게 할 것이다.

6.4. 결론

본 리포트는 게임 개발 기술을 생태계 시뮬레이션 분야에 적용하여 성능, 개발 효율성 측면에서 의미 있는 진전을 이루었다. 더 나아가 이러한 기술의 적용은 컴퓨터 시뮬레이션이 환경 문제 해결, 예측과 같은 과제를 기여할 수 있는 가능성을 제시했다.

물론 현재의 구현은 실제 생태계의 복잡성을 모두 담아내기에는 여전히 한계가 있다. 하지만 제시된 방법론과 기술적 기반은 향후 더욱 정교하고 사실적인 생태계 시뮬레이션 시스템으로 발전할 수 있는 견고한 출발점을 제공한다.

위 구현된 코드는 [[여기] (https://github.com/COMPY07/EcoSimReport)]에서 확인할 수 있다.

Reference

[1] C. Shih, C. Yang, and M. Fukuda, "Benchmarking the Agent Descriptivity of Parallel Multi-agent Simulators," in Highlights of Practical Applications of Agents, Multi-Agent Systems, and Complexity: The PAAMS Collection, Communications in Computer and Information Science, vol. 887, Springer, Cham, 2018, pp. 480–492.

[2] Unity Technologies, "Job system," Unity Manual 6000.1. Accessed: Aug. 25, 2025. [Online]. Available: https://docs.unity3d.com/6000.1/Documentation/Manual/job-system-overview.html

[3] C. Gasch, J. M. Sotoca, M. Chover, I. Remolar, and C. Rebollo, "Procedural modeling of plant ecosystems maximizing vegetation cover," Multimedia Tools and Applications, vol. 81, no. 12, pp. 16195-16217, May 2022, doi: 10.1007/s11042-022-12292-7.

[4] A. S. Joshi, "Reinforcement Learning-Enhanced Procedural Generation for Dynamic Narrative-Driven AR Experiences," in Proc. 20th Int. Joint Conf. Comput. Vision, Imaging Comput. Graph. Theory Appl. (GRAPP), 2025, pp. 385-397, doi: 10.5220/0013373200003912.

[5] M. Ben-Ari and F. Mondada, "Finite State Machines," in Elements of Robotics, Cham: Springer, 2018, ch. 4, pp. 59-81, doi: 10.1007/978-3-319-62533-1_4.

[6] S. Snodgrass, "Levels from Sketches with Example-Driven Binary Space Partition," in Proc. AAAI Conf. Artif. Intell. Interact. Digit. Entertain., vol. 15, no. 1, pp. 73-79, 2019, doi: 10.1609/aiide.v15i1.5227.

[7] P. E. Hart, N. J. Nilsson, and B. Raphael, "A formal basis for the heuristic determination of minimum cost paths," IEEE Trans. Syst. Sci. Cybern., vol. 4, no. 2, pp. 100-107, Jul. 1968.

[8] "NavMeshAgent Performance Issue," Unity Discussions, Unity Technologies, Jan. 6, 2018. [Online]. Available: https://discussions.unity.com/t/navmeshagent-performance-issue/687490

[9] "Memory leak in NavmeshAgent.SetDestination if multiple agents in the same position," Unity Discussions, Unity Technologies, Feb. 20, 2022. [Online]. Available: https://discussions.unity.com/t/memory-leak-in-navmeshagent-setdestination-if-multiple-agents-in-the-same-position/872528

[10] Y. A. Sekhavat, "Behavior Trees for Computer Games," International Journal on Artificial Intelligence Tools, vol. 26, no. 02, p. 1730001, 2017, doi: 10.1142/S0218213017300010.

[11] S. M. Gardiner, "Climate change as a global test case for moral theory," Environmental Ethics, vol. 39, no. 1, pp. 5-29, 2017.

[12] Unity Technologies, "Burst compiler," Unity Documentation, 2024. [Online]. Available: https://docs.unity3d.com/Packages/com.unity.burst@1.8/manual/index.html

[13] M. Gumin, "WaveFunctionCollapse," GitHub, 2016. [Online]. Available: https://github.com/mxgmn/WaveFunctionCollapse

[14] Wikipedia contributors, "Wave function collapse," Wikipedia, Jul. 28, 2025. [Online]. Available: https://en.wikipedia.org/wiki/Wave_function_collapse

[15] J. E. Bresenham, "Algorithm for computer control of a digital plotter," IBM Systems Journal, vol. 4, no. 1, pp. 25-30, 1965.

[16] S. F. Railsback, S. L. Lytinen, and S. K. Jackson, "Agent-based simulation platforms: review and development recommendations," Simulation, vol. 82, no. 9, pp. 609-623, 2006.

[SunrinLife] 굉장히 많은 배움을 준 SHARC 1학년

Tue, 25 Jun 2024 00:00:00 GMT

24년 6월 10일에 진행된 정수론 수업을 얘기해볼까 한다.

사실 아직 배운게 많지 않고 1학년을 상대로하는 수업이기 때문에 급발진도 못해서, 한 수업에 많은걸 담지는 못하지만 그래도 꽤 많은 내용을 다뤘다.

에라토스테네스의 체
모듈러 연산
중국인의 나머지 정리
유클리드 호제법

이렇게 4가지를 개념적으로 알려주고, 활용 방법을 설명한다. 그리고 이를 "백준"에서 문제를 풀어보면서 응용 능력을 키웠다.

수업이 끝나고 문제푸는 시간에서 많은 친구들이 시도하고, 생각하면서 실력을 많이 올렸다.

4월달에 첫 수업을 했을때는 구현, 문제 이해, 솔루션의 탐색이 아직 멀었구나... 라고 생각했던게 고작 몇 달전이라는게 너무나 놀라웠다.

백준은 건강에 좋다, 백준해라, ps 꼭 해라 매일매일 풀어봐라 라고 말했던 것을 직접 실천해준 1학년들이 너무나 대견했다. 무려 4달만에 실, 골, 플 정도 심지어 지금 3달째 되는 달에는 다이아5를 풀 수 있을 정도로 성장하였다.

나도 알고리즘을 진짜 잘하고, 가르칠 정도는 아니지만 소개하고 방법에 대해서 공유하는 것을 좋아하여 나눴던 것인데 이런 나의 말을 잘 듣고 성장하는 1학년들이 너무나 고맙고 대단하게 느껴졌다.

알연부의 수업은 1, 2학년 모두 얻어가는 것이 있고, 배운다는 것이 누군가 나를 가르쳐서 얻는 것도 있지만 내가 가르치며 아니면 경험을 하면서 얻는 배움도 있다는 깨달음도 주었다.

정말 뜬금없이 일기 비스무리한 것을 쓰고 있는데, 내가 느낀 것을 다른 이에게 공유하는 것도 좋을것 같아 포스팅을 시작하게 되었다. (사실 이런 이유도 있지만, 1일 1포스팅을 목표로 하고 있어서 쓸거 고민하느라 이런거 씁니다.)

[PARA] 2024 선린인터넷고등학교 PARA 소프트웨어나눔축제

Wed, 06 Nov 2024 00:00:00 GMT

</center>

24년 11월 2일에 진행된 선린 소프트웨어나눔축제는 중학생들을 대상으로 파이썬 기초 문법 및 프로그래밍 기초를 가르치며, LLM과 프롬프트 엔지니어링을 이용해서 나만의 친구 만들기 프로젝트를 진행하였다. <center>

</center>

교재 집필 및 발표자료와 나눔축제에 쓰일 프로젝트 전부 우리 부원들이 힘을 합쳐 만들었다. figma에서 하나하나 교재 집필을 하면서, 선배들의 피드백을 잘 수용해주고 따라준 이번 파라 1기 후배들에게 너무 감사하다.

그리고 열정적으로 이끌고, 도와준 우리 0기 부원들에게도 너무 고마움을 표하고 싶다. (특히 유﹡호, 박﹡규, 김﹡호 고맙다 친구들이여)

그리고 발표자료부터 발표를 시간에 맞춰서 또 최대한 내용을 더 많이 알려주려고 노력한 발표자들과 그걸 피드백한 선배들에게 수고했다고 말하고 싶다.

하루종일 연습하다가 드디어 집에 가서 기쁜 우리 후배들...

또 다시 하루종일 연습하다가 다같이 퇴근하는 우리 동아리 부원들.. 수고해써요!!

발표 준비를 마치고, 실습실 세팅이 모두 끝난 후 다시 늦게 퇴근하는 후배들....

소나축 D-2일 마지막 리허설 돌리면서 계속 반복 시작(이날도 9시까지 실습실 남아있다 퇴근...)

</center>

진짜 다들 너무 수고가 많았다. 드디어 D-DAY!!!

아침 일찍 등교 후 실습실 재확인 및 발표자료 셋팅 중...

발표 다시한번 리허설 시작(점검 시작)

소나축을 마무리하며 발표자 2명과 단체사진!

모두 수고했어!!! 정말 고마워!! </center>