복습 정리 노트

[광고][노트북 추천] MSI 2025 스텔스 18 코어Ultra9 지포스 RTX 5070 Ti

restudy — Thu, 20 Nov 2025 16:57:04 +0900

* 이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다.

오랜만에 노트북을 교체할 목적으로 여러 제품을 살펴보던 중, 해당 모델을 확인하게 되어 주요 사양을 정리합니다.

"MSI 2025 스텔스 18 코어Ultra9 지포스 RTX 5070 Ti"

https://link.coupang.com/a/c599QY

MSI 2025 스텔스 18 코어Ultra9 지포스 RTX 5070 Ti - 노트북 | 쿠팡

쿠팡에서 MSI 2025 스텔스 18 코어Ultra9 지포스 RTX 5070 Ti 구매하고 더 많은 혜택을 받으세요! 지금 할인중인 다른 노트북 제품도 바로 쿠팡에서 확인할 수 있습니다.

www.coupang.com

(이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다.)

이 제품은 Intel Core Ultra 9 275HX 프로세서와 NVIDIA GeForce RTX 5070 Ti Laptop GPU(140W 다이나믹 부스트)를 탑재하고 있고, 일반적인 사무 작업, 개발, 영상 편집 등 다양한 용도의 고성능 작업 환경을 구성하는 데 적합한 사양이라고 생각됩니다.

디스플레이는 18형 QHD 플러스 해상도(2560×1600), 16대10 비율, 240Hz 주사율, DCI-P3 100퍼센트 색역, 500니트 밝기로 구성되어 있으며, 대형 화면 기반의 작업 환경을 필요로 하는 경우에 활용성이 높다고 생각됩니다.

메모리는 DDR5 32GB(2슬롯, 최대 96GB 확장 가능), 저장장치는 1TB NVMe M.2 SSD로 구성되어 있어 일반적인 개발 작업이나 대용량 데이터 처리 용도로 사용하는 데 무리가 없어보입니다.

네트워크는 Wi-Fi 7, Bluetooth 5.4를 지원합니다. 입출력 구성은 Thunderbolt 4, USB Type-A, USB Type-C, HDMI 2.1, SD 카드 리더, RJ45 유선 LAN 등 여러 단자가 포함되어 있네요.

배터리 용량은 99.9Wh이며, 무게는 당연히 꽤 많이 나가지만, 대형 고성능 노트북 기준에서는 이동성을 어느 정도 확보한 편 같습니다.

전체적으로 고성능 CPU와 GPU 구성, 화면 사양, 확장성, 포트 구성 등 핵심 요소를 기준으로 판단했을 때 균형 잡힌 사양의 제품인 것 같네요!

머신러닝이 약학에 어떻게 적용될 수 있을까?

restudy — Wed, 17 Jul 2024 21:24:56 +0900

머신러닝이 약학에 어떻게 적용될 수 있을지 간단히 정리해 보았다.

약동학 = pharmacokinetic

- 약물이 체내에서 어떻게 ADME(흡수, 분포, 대사, 배설) 되는지 연구

- 약물의 체내 행동을 시간에 따라 분석하고, 약물의 농도-시간 곡선을 평가하여 약물의 효과를 예측

ECMO (체외막산소요법, Extracorporeal Membrane Oxygenation)

- (회복 가능성이 있는 심부전 환자에 대해) 정맥혈을 뽑아내어 혈액에 산소를 공급하고 환자의 순환 및 호흡 기능을 보조하는 장치

- 사용 시 병용되는 약물: 항응고제, 항생제, 진정제 및 진통제, 이뇨제, 심혈관계 약물 등

머신러닝(ML)과 딥러닝(DL)의 활용

환자의 연령, 체중, 신장 기능, 간 기능, 병력 등 약물 투여에 중요한 변수에 따른 최적의 약물 투여량을 ML/DL로 결정할 수 있다.

다만, 여기에 어떤 머신러닝 모델을 선택할지는 문제의 특성과 데이터의 특성에 따라 달라진다.

머신러닝(ML) 모델의 종류

- 선형 회귀: 비선형 관계를 잘 처리하지 못함 (당연히 최적의 약물 농도 구할 때에는 쓸 수 없음)

- 랜덤 포레스트: 여러 개의 트리가 각각의 추론을 수행하고, 여러 트리들의 추론 결과를 종합하여 최종 결정

- 큰 데이터셋에서 훈련 시간 오래 걸린다고 함

Scikit-learn과 Tensorflow

Scikit-learn: 머신러닝에 자주 사용되는 라이브러리

Tensorflow: 딥러닝에 자주 사용되는 라이브러리

다음은 훈련 데이터로 선형 회귀를 학습시키고, 랜덤으로 생성한 테스트 데이터를 가지고 MSE를 측정해서 얼마나 학습이 잘 되었는지 확인하는 예제 코드이다.

- Scikit-learn 라이브러리의 머신러닝을 이용한 예제

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

X = np.array([[1], [2], [3], [4], [5]])
y = np.array([1, 3, 3, 2, 5])

# 훈련 데이터와 테스트 데이터로 분리
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 모델 초기화 및 훈련
model = LinearRegression()
model.fit(X_train, y_train)

# 예측 및 성능 평가
y_pred = model.predict(X_test)
mse = mean_squared_error(y_test, y_pred)

print("Mean Squared Error:", mse)
print("Predictions:", y_pred)

Mean Squared Error: 1.6530612244897955
Predictions: [1.71428571]

- Tensorflow 라이브러리의 딥러닝을 이용한 예제

import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam
from sklearn.model_selection import train_test_split

X = np.array([[1], [2], [3], [4], [5]])
y = np.array([1, 3, 3, 2, 5])

# 훈련 데이터와 테스트 데이터로 분리
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 모델 정의
model = Sequential()
model.add(Dense(10, input_dim=1, activation='relu'))
model.add(Dense(1))

# 모델 컴파일
model.compile(optimizer=Adam(learning_rate=0.01), loss='mean_squared_error')

# 모델 훈련
model.fit(X_train, y_train, epochs=100, verbose=0)

# 예측 및 성능 평가
y_pred = model.predict(X_test)
mse = np.mean((y_test - y_pred.flatten())**2)

print("Mean Squared Error:", mse)
print("Predictions:", y_pred.flatten())

Mean Squared Error: 1.2140690288737375
Predictions: [1.898152]

최적의 약물 투여량을 ML/DL로 구하는 방법

- 먼저 다음과 같은 데이터를 수집합니다.

- 환자 데이터: 나이, 성별, 체중, 키, 병력 등 환자의 기본 정보
- 약물 데이터: 약물 종류, 투여량, 투여 빈도 등
- 생체 지표: 혈압, 혈당 수치, 심박수 등 약물 투여 후 측정된 생체 지표
- 치료 결과: 치료의 효과와 부작용 여부 등

- 딥러닝 모델(ANN, LSTM)을 이용하여 약물 투여와 결과 사이의 관계를 학습시켜 모델링합니다.

(- 간단한 경우, 위에서 소개한 간단한 머신러닝 모델(선형 회귀, 랜덤 포레스트 등)을 활용할 수도 있음)

(- 약물 투여량에 따른 생체 지표는 당연히 비선형으로 나오는 것이 상식적)

- 딥러닝은 머신러닝에 비해 큰 규모의 학습 데이터가 필요합니다.

- 하이퍼파라미터 튜닝 과정을 통해 최적의 성능을 내기 위한 하이퍼파라미터를 찾습니다.

다층 퍼셉트론(MLP)을 가진 인공 신경망(ANN)을 사용해 최적의 약물 투여량을 찾는 예제 코드

- X: 환자의 다양한 특징을 나타내는 수치형 데이터 (여기서는 각각이 10개의 특징을 가진 데이터셋, 이것이 실제로는 환자의 나이, 성별, 체중, 키 등의 변수일 수 있음)
- Y: 각 환자에 대한 최적의 약물 투여량
- 결과적으로 얻어지는 것: '비선형'의 회귀 모델. 이 비선형의 회귀 모델을 통해 임의의 입력 데이터(= 환자 데이터)에 대해 최적의 약물 투여량을 예측할 수 있음

import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from sklearn.model_selection import train_test_split

# 가상의 예제 데이터 생성
# 실제로는 환자 데이터, 약물 데이터, 생체 지표 등으로 이루어진 데이터셋 사용
X = np.random.rand(1000, 10)  # 1000명의 환자, 10개의 특징
y = np.random.rand(1000)  # 1000명의 환자에 대한 약물 투여량

# 데이터를 훈련 데이터와 테스트 데이터로 분리
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 신경망 모델 정의
model = Sequential()
model.add(Dense(64, input_dim=X_train.shape[1], activation='relu'))
model.add(Dense(32, activation='relu'))
model.add(Dense(1))  # 약물 투여량을 예측하는 하나의 출력 뉴런

model.compile(optimizer='adam', loss='mean_squared_error')

# 모델 훈련 과정
model.fit(X_train, y_train, epochs=100, batch_size=32, verbose=1, validation_split=0.2)

# 모델을 평가
mse = model.evaluate(X_test, y_test)
print("Mean Squared Error:", mse)

# 새로운 데이터 예측
new_data = np.random.rand(1, 10)  # 가상의 새로운 환자 데이터
predicted_dosage = model.predict(new_data)
print("Predicted Dosage:", predicted_dosage)

Epoch 1/100
20/20 [==============================] - 1s 9ms/step - loss: 0.2945 - val_loss: 0.1110
Epoch 2/100
20/20 [==============================] - 0s 3ms/step - loss: 0.1119 - val_loss: 0.1002
Epoch 3/100
20/20 [==============================] - 0s 3ms/step - loss: 0.0952 - val_loss: 0.0989

...

Epoch 98/100
20/20 [==============================] - 0s 3ms/step - loss: 0.0414 - val_loss: 0.1202
Epoch 100/100
20/20 [==============================] - 0s 3ms/step - loss: 0.0411 - val_loss: 0.1229
7/7 [==============================] - 0s 1ms/step - loss: 0.1183
Mean Squared Error: 0.1182592362165451
Predicted Dosage: [[0.3699172]]

코드 원문 링크

GitHub - yeohj0710/ml-dl-simple-sample

Contribute to yeohj0710/ml-dl-simple-sample development by creating an account on GitHub.

github.com

NextJS 당근마켓 클론코딩: #5.0 ~ #12.7 필기 내용 정리

restudy — Mon, 29 Apr 2024 16:35:20 +0900

이 포스트에서는 당근마켓 클론코딩의 #5.0 ~ #12.7 단원에서 학습한 내용들을 정리한다.

# 5.0 Route Handlers

로그인 form을 입력하면 백엔드에서 값을 어떻게 가져가서 확인하고, 로그인을 시켜주는가

<기존 방식>
API route를 만들고, API URL을 이용해서 데이터를 전송

→ 이때 route handler를 만들기 위해서는 파일명을 반드시 route.ts로 해야한다.

→ 그래야 NextJS에서 route handler임을 인식한다.

프론트엔드에서 fetch(주소, { method: "POST", body: JSON.stringify({ value: 값 }))로 전송하면, 백엔드에서 request: NextRequest에 대해 await request.json()과 같이 값을 받을 수 있었다.

# 5.1 Server Actions

<새로운 방식>
NextJS의 Server Actions를 이용하면 프론트엔드에서 전달한 값을 백엔드에서 받는 과정을 훨씬 간단하게 구현할 수 있다.
함수 내에 "use server";를 작성하면, 이 함수는 서버에서만 실행되도록 해 준다.

(이때 함수는 비동기 함수이므로 async 함수로 선언해 주어야 한다.)

함수를 선언하고 "use server";를 입력해 준 다음, 이 함수 이름을 form의 props에서 action={함수명}과 같이 작성해 주면 끝이다.
이제 프론트엔드에서 form을 입력하고 제출하면, 해당 함수가 백엔드에서 실행된다.

(이때 Server Action을 이용해 데이터가 전송된다.)

함수에서 데이터를 받기 위해서는, 매개변수를 'FormData' 타입으로 선언한 다음,

'변수명.get("form의 name")'과 적어주면 된다.

# 5.2 useFormStatus

useFormStatus hook을 사용하면, 컴포넌트가 로딩 중인 상황도 쉽게 컨트롤할 수 있다.
const { pending } = useFormStatus();와 같이 선언한 다음, <button disabled={pending} />과 같이 사용할 수 있다.

(Component 코드 최상단에 "use client";를 선언해 주어야 한다.)

# 5.3 useFormState

const [state, action] = useFormState(함수, 초깃값(null));와 같이 실행한다.
state는 action의 return 값이고, action은 함수를 실행한다.
이때 action은 (action의) 이전 state와 함께 호출된다.

action을 useFormState를 이용해서 넘겨주면, action의 결과를 반환한다.
→ useFormState가 action을 호출하면, action은 formData와 함께 이전에 반환한 state(없으면 초깃값)와 함께 실행된다.

# 6.5 Recap

Zod: 데이터에 대한 schema를 정의하여 올바르지 않은 데이터가 백엔드로 전달되는 것을 방지해 준다.
하지만 Zod를 사용하더라도, form 자체에서 validation을 이중으로 처리해 줄 필요는 있다.

formSchema의 safeParse() 메서드: 데이터를 파싱할 때 에러가 발생하더라도 에러를 throw 하지 않고, 데이터와 에러를 반환한다.
result.error.flatten() 메서드: 여러 에러를 하나의 배열에 담아서 반환해 준다. 이를 통해 에러를 더 쉽게 처리할 수 있다.

# 6.7 Coerce

Zod에서 z.coerce.number()와 같이 coerce 속성을 이용하면 유저의 입력을 자동으로 number 타입으로 변환해 준다.

# 7.0 Setup

Prisma: 사용자와 DB 사이의 통역사 역할
DB 내 데이터 구조를 prisma의 언어로 알려주면, prisma가 우리가 연결해 준 DB를 관리해 준다.

# 8.3 Iron Session

iron-session: NodeJS에서 session을 처리하기 위한 middleware
getIronSession(): session을 관리할 수 있는 함수로, session 데이터에 접근/조작 가능

session.id = user!.id와 같이 session 값을 설정한 이후에는,

반드시 await session.save()와 같이 session을 저장해 주어야 한다.

로그아웃과 같은 기능을 구현할 때는 const session = await getSession()으로 session을 얻어준 다음,

await session.destroy()와 같이 session을 제거한다.

//@ts-ignore: TypeScript가 다음 줄의 에러를 무시할 수 있게 해 준다.

# 8.9 Middleware

/app 폴더가 위치한 경로와 동일한 경로에 middleware.ts를 생성하면, NextJS가 자동으로 이를 middleware로 인식한다. (파일 내 함수 이름 역시 middleware()이어야 한다.)
middleware는 페이지에 접속하기 이전에 페이지 접속 권한 검사 등 다양한 처리들을 수행할 수 있다.

middleware가 특정 페이지에서만 작동하도록 하려면, config라는 객체 내에 작성해주면 된다. (역시 변수명 config로 고정 필수, 정규표현식을 사용할 수도 있고, ! 기호를 붙이면 특정 페이지에서만 middleware가 실행되지 않도록 할 수도 있음)

# 8.11 Edge Runtime

NextJS의 middleware는 빠르게 동작할 수 있는 Edge runtime에서 작동하기 때문에 특정 기능은 사용하지 못한다.

(따라서 session이나 cookie 확인, 그리고 redirect 정도만 사용하는 것이 적절)

# 9.1 Github Authentication

OAuth: 사용자 인증 방식 (네이버, 카카오 등 다양한 플랫폼 모두 동일한 방식 사용)
github의 경우 다음의 링크에서 새 OAuth를 등록할 수 있다.

https://github.com/settings/applications/new

# 9.7 Twilio SMS

Twilio를 이용해 SMS 인증 기능을 구현한다.

# 10.1 Tab Bar

소괄호 이름 폴더로 라우트 디렉토리들을 묶을 경우 묶인 디렉토리들에는 서로 다른 layout을 적용할 수 있다.

(단순히 라우트에 영향을 받지 않도록 라우트 디렉토리들을 묶는 것만이 장점이 아님)

# 10.6 Image Hostnames

NextJS의 Image는 이미지를 자동으로 최적화를 해 주어 성능을 향상시키고 빠른 로딩이 되도록 해 준다.
하지만 외부 호스트의 이미지(다른 사이트의 이미지 링크 등)를 불러올 때는 보안 때문에 이 기능이 허용되지 않는다.

따라서 next.config.mjs에서 hostname들을 등록해 주어야 한다.
(nextConfig > images > remotePatterns > hostname)

# 10.9 Infinite Scrolling

infinite scrolling의 구현: IntersectionObserver를 이용해 페이지의 하단에 도달했는지를 감지할 수 있다.

# 11.0 Introduction

Zod + React Hook Form + Server Actions를 함께 활용해 Server upload하는 방법을 배운다.
NextJS cache: DB response를 server memory에 저장하여 재사용할 수 있게 해 준다. 이를 통해 DB에 매번 접속 및 로딩하지 않고 데이터를 즉시 볼 수 있다.

# 11.3 Images Setup

Cloudflare images: 이미지 저장 및 로드, 최적화에 특화된 서비스
user가 server에 요청을 보내면, user → server → cloudflare 순서로 파일이 전송되는 것이 아닌,

user → cloudflare 순서로 효율적으로 이미지 업로드가 진행된다.
cloudflare는 저장된 image의 URL을 반환하며, 이 URL만 DB에 저장하면 된다.

# 11.8 RHF Refactor

react-hook-form을 이용하여 코드를 refactoring 하는 과정
흐름은 유지하면서 코드만 고치는 부분이 많으므로 복습 필요

# 12.1 Intercepting Routes

폴더명을 "(..)라우트명"과 같이 작성하여 다른 라우트로의 request를 intercept 해 올 수 있다.
이렇게 될 경우 상대 경로로 폴더명을 지정한 폴더의 코드가 먼저 실행되고, 새로고침을 하고 나서는 절대 경로로 해당 위치에 있는 폴더의 코드가 실행된다.
이를 활용하여 modal 창을 구현할 수 있다.

그렇다면 현재 경로에 있는 a라는 라우트를 intercept 하려면?
→ (.)a 폴더를 하나 더 작성해서 page.tsx를 작성해주면 된다.

(...)은 root directory까지 밖으로 이동하는 것을 뜻한다.

# 12.3 Parallel Routes

두 route의 page가 동시에 렌더링될 수 있도록 해 준다.
slot: parallel route로 지정하려면 route의 폴더명의 맨 앞에 @ 기호를 붙이면 된다. 이를 slot이라고 한다.

구현된 parallel route page는 해당 폴더들을 포함하는 폴더의 layout.tsx에서 인자로 받아서 렌더링해 줄 수 있다.

주의할 점은, route가 redirect 되는 것도 고려해 주어야 한다.
예를 들어 로그인하지 않은 사용자는 "/"로 이동하고 로그인한 사용자는 "/home"으로 이동한다면 이 둘을 모두 고려하여 parallel route page를 둘 다 작성해 주어야 layout.tsx에서 인자를 받을 때 404 에러가 발생하지 않는다.

# 12.4 Default Routes

위의 내용처럼 parallel route가 match 되는 route가 없을 경우, 404 에러가 발생하게 된다.
이를 피하기 위해서는 위의 내용처럼 각각의 parallel route page들을 만들어주는 방법도 있겠지만,

default routes를 사용하면 사전에 지정하지 않은 모든 route에 대해 렌더링할 component를 지정해 줄 수 있다.

parallel route 폴더 안에 "default.tsx"라는 이름의 컴포넌트 파일을 생성하면, route가 match 되지 않는 경우 해당 컴포넌트를 렌더링해 준다.

+ Code Challenge

Button 컴포넌트 분리하여 use client 사용하지 않아도 되도록 만들 것
modal에 이미지와 product에 대한 정보 DB에서 받아와서 렌더링하기

Flutter로 웹툰 앱 만들기: 스터디 필기 내용 정리

restudy — Mon, 29 Apr 2024 16:21:16 +0900

widget: UI를 구성하는 블록
ex) Center: child를 가운데로 오게 하는 widget

widget을 만들기 위해서는 flutter에 있는 3개의 core widget 중 하나를 extend 받아서 사용할 수 있다.
StatelessWidget: 정적 UI / StatefulWidget: 동적 UI (상태가 변경되는 UI)

모든 widget은 build 메서드를 포함해야 한다.
build 메서드: widget의 상태가 변경될 때마다 호출되어 UI를 렌더링

root widget에는 2개의 옵션이 있다.
material 앱(from google) > cupertino 앱(from apple)

scaffold: 화면을 구성하는 구조
모든 화면은 scaffold를 가져야 한다.

stateful widget: 상태에 따라 데이터를 변경되면, 변화를 UI에 실시간으로 반영할 수 있는 widget

변경된 데이터를 UI에 업데이트하기 위해서는 setState() 함수를 사용해야 한다. setState() 함수를 호출하면 build() 메서드를 다시 실행된다.
ex ) void onClicked() { setState(() { counter++; }); }

또는 다음과 같이 작성해도 UI가 업데이트 된다.
ex ) void onClicked() { counter++; setState(() {}); }

of() 메서드: Theme.of(context)는 BuildContext인 context에서 조상 중 가장 가까운 Theme widget을 찾아 데이터에 접근한다.

initState() 메서드: widget이 최초로 생성되었을 때 한 번만 호출되는 메서드
잘 안 쓰이지만, super.initState()와 같이 부모 클래스까지 같이 초기화를 해 줄 수 있다.

dispose() 메서드: widget이 스크린에서 제거될 때 호출되는 메서드

Flutter나 Dart의 공식 패키지 저장소는 pub.dev이다.
패키지는 flutter pub add "패키지명" 명령어를 사용하여 설치한다.

Future: flutter에서 비동기 작업을 수행하고 결과를 반환하는 객체
Future 객체를 반환받으려면 await을 사용해 주어야 한다.

Future 객체를 이용해 data를 fetch 할 때는 setState()를 사용할 필요가 없다.
FutureBuilder라는 widget을 이용하면, StatelessWidget으로도 반환된 Future 객체의 데이터를 전달해줄 수 있다.
(future: Future 객체 이름, builder: (context, snapshot) { 함수 })

ListView: 여러 개의 항목들을 나열해서 볼 수 있는 widget
ListView.builder: infiniteScroll 등의 기능을 구현할 수 있는 최적화된 ListView
ListView.separator: ListView.builder에 separatorBuilder라는 추가로 인자를 가진다.

Container widget에서, clipBehavior 속성을 통해 자식의 부모 영역 침범을 제어할 수 있다. (ex: clipBehavior: Clip.hardEdge)

Flutter에서 Screen을 이동하는 법: Navigator
Navigator는 context와 route를 필요로 한다. (Navigator.push(context, route))
route는 widget을 스크린처럼 보이도록 한다.
route 자리에는 MaterialPageRoute와 같은 클래스들이 들어간다.
fullscreenDialog: card → full screen (옆으로 넘겨서 닫는 것이 아닌, 밑에서 화면이 팝업됨)

Hero widget: 두 개의 widget 화면을 애니메이션으로 전환하게 해주는 widget
hero widget을 두 widget에 사용하고, 같은 tag 값을 주면 된다.

Future 객체는 constructor로 초기화할 수는 없으므로, 이를 초기화할 때는 late modifier가 유용하다.

Flutter에서 앱 내에서 브라우저를 열도록 하는 방법: url_launcher 패키지를 설치하여 이용하면 된다.

앱 내에서 모바일 기기에 데이터를 저장하는 방법: shared_preference 패키지를 사용하면 된다.

빌드하기 전에, 인터넷 권한 문제 해결을 해야 한다.
Poject 뷰 > android > app > src > main > AndroidManifest.xml에서,
<application> 태그 바로 윗 줄에 다음의 코드를 입력하여 권한을 추가한다.
<uses-permission android:name="android.permission.INTERNET" />

apk 빌드 : 터미널에 flutter build apk --release --target-platform=android-arm64
빌드 경로: [Project Forder]/build/app/outputs/apk/release/app-release.apk

NextJS 개념 정리 + 영화 정보 사이트 만들고 vercel로 배포하기 (모든 과정 요약 정리)

restudy — Sat, 23 Mar 2024 03:05:49 +0900

이번 포스트에서는 NextJS가 무엇인지에 대해 알아보고, NextJS를 이용하여 간단한 영화 정보 사이트를 만들고 실제 웹사이트를 배포하는 과정까지 수행해 보겠습니다.

완성 결과 미리보기

먼저 완성된 웹사이트의 형태를 같이 보겠습니다.

API를 제공하는, 데이터가 저장된 사이트로부터 데이터를 잘 fetch 해 와서 정보를 잘 나타내어주는 것을 확인할 수 있습니다.

주의깊게 살펴볼 부분은 렌더링이 진행되는 과정에서, 먼저 로딩이 끝난 컴포넌트부터 렌더링이 부분적으로 완료될 수 있다는 것입니다.

(물론 이 부분은 NextJS만의 기능이 아닌 React의 기능을 이용한 것이지만, 이러한 컴포넌트별 렌더링 기능을 포함하여 페이지의 빠른 로딩을 위한 다양한 기능이 사용되므로, 더 좋은 사용자 경험을 제공할 수 있습니다.)

NextJS와 Server Side Rendering

NextJS는 React의 application을 구축하는 것을 도와주는 프레임워크로, Server Side Rendering(SSR, Server Side Rendering)이라는 페이지 로딩 시간을 줄여주는 기능을 가지고 있습니다.

NextJS는 application을 render 하는 방법으로, 'Server Side Rendering'이라는 방법을 사용합니다.

SSR이 일어나는 과정은 다음과 같습니다.

① NextJS가 서버(백엔드)에서 Javascript → HTML로 렌더링을 한 다음, 이 HTML 코드를 브라우저에 전달해 줍니다.

이때 주목할 점은, 코드는 HTML의 형식으로 전달되기 때문에 페이지에 Javascript가 적용되지 않은 상태여도 렌더링이 정상적으로 작동한다는 것입니다.

② 그 다음 프레임워크가 페이지에 React application을 추가합니다.

이 기능은 각 Component에 해당하는 파일의 맨 위에 "use client"; 라는 코드를 작성하여 선택적으로 추가할 수 있습니다.

여기서 use client란, 이 Component는 클라이언트에서 interactive 해야 함을 의미합니다.

그렇게 되면, 기존에 로드된 HTML 페이지는 그대로 있는 상태로, 여기에 이벤트 리스너 등이 추가되는 것입니다.

→ 이를 (사용자가 최초 HTML을 본 후) 'Hydration이 일어난다'라고 합니다.

NextJS로 영화 정보 사이트 제작하기

먼저 저는 NextJS 프로젝트를 작성하여 아래와 같은 Repository에 push 해 두었습니다.

전체적인 프로젝트 코드는 노마드코더의 'NextJS 시작하기' 코스를 통해 학습하면서 작성하였습니다!

GitHub - yeohj0710/NextJS-movie-app: movie application built using NextJS

movie application built using NextJS. Contribute to yeohj0710/NextJS-movie-app development by creating an account on GitHub.

github.com

소스 코드는 위의 Repository에서 참고하시면 됩니다.

(NextJS의 프로젝트 구성에 대한 설명과 코드에 대한 설명은 이후에 추가할 예정입니다.)

이 포스트에서는 '배포'에 대한 부분을 조금 더 중점적으로 다룹니다.

NextJS 프로젝트 배포하기

작성이 완료된 프로젝트는 Vercel에서 무료로 배포할 수 있습니다.

여기서 Vercel은 NextJS를 개발한 기업입니다.

웹사이트 배포를 위해, 'vercel.com'으로 이동해 주시면 됩니다.

vercel의 메인 페이지로 들어가서, 중앙에 보이는 'Start Deploying'을 눌러줍니다.

'Continue with Github'를 선택합니다.

Github에 프로젝트를 업로드 한 후, 해당 Repository를 vercel에 연결하면 vercel에서 자동으로 배포를 진행하고 도메인을 제공해 주는 방식으로 배포가 진행될 것입니다.

Github 계정 인증을 진행한 이후에, NextJS 프로젝트가 push 되어 있는 Repository를 선택해 줍니다.

주의할 점은 이 부분 정도인데, vercel에서 NextJS 프로젝트를 배포할 때 미리 default 값으로 지정해 둔 명령어에 맞게 package.json의 scripts들을 맞춰서 작성해 두어야 합니다.

또는 Vercel 페이지에서 직접 명령어를 수정하면 됩니다.

배포가 완료되면 위의 이미지와 같이 초록색 원이 뜨면서 'Ready'가 나타납니다.

'Project' 탭에서 deployment 결과를 확인할 수 있습니다.

빨간 네모 박스를 친 부분을 클릭하면, 특정 형식을 벗어나지 않는 선에서 도메인을 직접 지정할 수도 있습니다.

생성된 도메인으로 이동해 보면, build와 배포가 정상적으로 완료되어 인터넷으로 정상 접속 및 이용이 가능한 것을 확인할 수 있습니다.

이렇게 해서 NextJS가 무엇인지 알아보고, NextJS를 이용해 영화 정보 웹사이트를 제작 및 배포까지의 과정을 간단하게 다루어보았습니다.

Firebase 나만의 소셜 미디어 사이트 만들고 배포하기 (모든 과정 설명)

restudy — Fri, 22 Mar 2024 14:32:52 +0900

이번 포스트에서는 Firebase를 이용해 나만의 소셜 미디어 서비스를 구현하여 실제 웹사이트로 배포하는 과정까지를 다루어보겠습니다.

완성 결과 미리보기

먼저 완성한 결과부터 gif 파일로 확인해 봅시다.

실제 도메인이 등록되어 있는, 어디서나 접속 가능한 웹 페이지입니다.

메인 페이지 살펴보기, 피드 읽고 사진 확대하기

회원가입하기 (계정 생성하기)

새로운 글 작성하고 이미지 첨부하기, 작성한 글 삭제하기

프로필 사진 수정하기, 닉네임 수정하기, 수정 후 새로운 글 작성하기

Firebase

Firebase는 구글에서 제공하는 데이터베이스 서비스입니다.

DB에 접근하고 데이터를 관리하기 위한 다양한 함수들을 간편하게 제공하기 때문에 코드를 쉽게 구현할 수 있다는 장점이 있습니다.

또한, 일정 데이터 사용량과 DB 용량까지는 무료로 사용할 수 있다는 것과 실제 웹사이트 주소로 간편하게 배포할 수 있다는 것도 매우 큰 장점이라고 생각합니다.

Firebase 프로젝트 생성 및 설정

가장 먼저 Firebase 사이트로 접속해줍니다.

https://console.firebase.google.com/?hl=ko

'프로젝트 만들기'를 눌러줍니다.

프로젝트 이름을 정해 주세요.

프로젝트 이름은 나중에 호스팅 서비스를 이용해서 웹사이트 링크가 생성될 때 이름이 그대로 사용되니, 신중하게 결정해줍니다.

저는 가능한 짧고 이해하기 쉬운 프로젝트 이름을 추천합니다.

저는 yeohj0710x로 하겠습니다.

다음으로 Firebase Google 애널리틱스를 사용할 거냐고 묻는데, 저는 사용하지 않겠습니다.

그럼 이렇게 Firebase 프로젝트가 생성됩니다.

생성하는 데 시간이 걸리니 잠시 기다려주세요.

프로젝트가 생성되면 메인 화면으로 이동되는데, 우리는 웹사이트를 만들 것이니 웹을 클릭해 줍니다.

앱 닉네임을 설정하고, Firebase 호스팅을 체크해 줍니다. 웹사이트의 실제 배포를 위해 필요합니다.

이제 '앱 등록'을 눌러줍니다.

다음으로 'npm install firebase'를 이용해 프로젝트에 firebase를 설치해 줍니다.

프로젝트를 생성하지 않았으면 새로 생성하고, 터미널에서 위 명령어를 입력해 주세요.

이제 이런 절차를 거치라는 내용이 나올 건데, firebase.ts라는 파일을 만들어 다음과 같이 작성합니다.

// firebase.ts

import { initializeApp } from "firebase/app";
import { getAuth } from "firebase/auth";
import { getFirestore } from "firebase/firestore";
import { getStorage } from "firebase/storage";

const firebaseConfig = {
  apiKey: "AIzaSyA9CrbgL6FmJIUYy4CL7Ps3NIEelnMASjE",
  authDomain: "yeohj0710x.firebaseapp.com",
  projectId: "yeohj0710x",
  storageBucket: "yeohj0710x.appspot.com",
  messagingSenderId: "1070119465029",
  appId: "1:1070119465029:web:c21ac2cbe88da79c5e732c",
};

const app = initializeApp(firebaseConfig);

export const auth = getAuth(app);

export const storage = getStorage(app);

export const db = getFirestore(app);

위의 firebaseConfig 자리에, Google Firebase에서 제공되는 코드를 붙여넣으면 됩니다.

이제 다음의 명령어를 이용해 Firebase CLI를 설치합니다.

npm install -g firebase-tools

먼저 firebase login을 수행해 줍니다.

로그인 창이 뜨면 현재 구글 Firebase에 로그인 중인 계정으로 로그인해 주세요.

'firebase init'과 'firebase deploy'는 프로젝트의 코드를 완성한 이후에 수행할 것입니다.

이제 다시 Firebase 웹 페이지로 돌아와서, Authentication을 눌러줍니다.

'시작하기'를 눌러주세요.

이제 로그인 방법을 추가하면 되는데, '이메일/비밀번호'가 가장 간편합니다.

저의 경우에는 Github도 추가하였습니다.

이번에는 탭 왼쪽에서, 빌드 > 'Firestore Database'를 선택해 주세요.

Firestore는 데이터베이스 테이블들이 저장될 공간입니다.

마찬가지로 '데이터베이스 만들기'를 눌러줘야 시작할 수 있습니다.

이제 다음의 절차를 따라주세요.

1. 데이터베이스 ID는 (default)로 자동 설정되니 넘어가면 되고, DB 위치는 가장 가까운 'asia-noretheast3 (Seoul)'로 해 줍시다.

2. 다음으로 보안 규칙은 일단 '테스트 모드'로 설정해 줍니다. 나중에 바꿀 수 있습니다.

3. '만들기'를 누르고 기다려주세요.

생성이 완료되었으면 Cloud Firestore의 '규칙' 탭으로 이동합니다.

이제 다음과 같이 작성해 주세요. 이 코드는 나중에 알맞게 수정하면 됩니다.

rules_version = '2';

service cloud.firestore {
  match /databases/{database}/documents {
    match /tweets/{doc} {
      allow read: if true
      allow create: if request.auth != null
      allow delete, update: if request.auth.uid == resource.data.userId
    }
  }
}

이번에는 '색인'으로 이동합니다.

'색인 추가'를 누르고, 다음과 같이 작성해 주세요.

이건 저의 프로젝트에만 적용되는 내용인데, 임시적으로 생성하고 나중에 바꾸면 됩니다.

아래로 내려서 쿼리 범위는 '컬렉션'을 선택하고 '색인 만들기'를 클릭합니다.

색인이 생성되는 데에는 시간이 조금 걸립니다. 기다려 주세요.

이번에는 좌측 탭에서 'Storage'로 이동해 주세요.

Storage는 이미지와 같은 용량이 큰 데이터들이 저장될 공간입니다.

마찬가지로 '시작하기'를 누르고, '테스트 모드에서 시작' 버튼을 눌러주세요.

지역은 자동으로 설정될 겁니다.

'완료'를 누르고 버킷이 생성될 때까지 기다려줍니다.

생성이 완료되었으면, 폴더를 추가하는 버튼을 눌러서 'avatars'와 'tweets' 2개의 폴더를 만들어주세요.

이 역시 저의 프로젝트에만 해당되는 내용이지만, 나중에 알맞게 수정하면 됩니다.

이제 마찬가지로 '규칙' 탭으로 이동해서 다음과 같이 코드를 작성합니다.

rules_version = '2';

service firebase.storage {
  match /b/{bucket}/o {
    match /{allPaths=**} {
      allow read: if true // request.auth != null
      allow write: if request.auth != null && request.resource.size < 10 * 1024 * 1024
    }
  }
}

'게시'를 누르고 기다려줍니다.

이제 마지막으로 좌측 탭의 '빌드'를 누르고 'Hosting'으로 들어갑니다.

우리는 아까 firebase tools를 설치했기 때문에, '다음'과 '콘솔로 이동'을 눌러서 일단 이동해줍니다.

프로젝트 코드 작성

이제 프로젝트 코드를 작성해 주면 됩니다.

Firebase 공식 문서를 참조하면, Firebase의 다양한 함수들과 사용 방법이 제시되어 있으니 이를 활용할 수 있습니다.

제가 작성한 프로젝트의 코드는 다음과 같습니다.

전체적인 프로젝트 코드는 노마드코더의 '트위터 클론코딩' 코스를 통해 학습하면서 작성했고, 그 이후로 필요한 기능들은 스스로 코딩하여 추가하였습니다!

GitHub - yeohj0710/Firebase-social-media-app: YHJ - Social media platform implemented using Firebase

YHJ - Social media platform implemented using Firebase - yeohj0710/Firebase-social-media-app

github.com

프로젝트의 전체적인 구조는 위와 같습니다.

스크립트 역시 위와 같이 작성하여 배포 명령어까지 완성하였으면, 이제 실제 웹사이트로의 배포 준비가 끝났습니다.

실제 웹사이트로 배포하기

이제 코드를 작성한 프로젝트를 실제 웹사이트로 배포해 봅시다.

아까 firebase login까지만 진행하고, init과 deploy는 진행하지 않았었는데요, 그 과정을 지금 수행할 겁니다.

가장 먼저 다음의 명령어를 통해 firebase 프로젝트 설정을 콘솔에서 진행하겠습니다.

firebase init

그럼 firebase에서 콘솔을 통해 몇 가지 질문을 할 텐데, 프로젝트에 알맞은 설정을 해주면 됩니다.
첫 번째 질문에는 'Yes'로 답해 줍니다.
다음으로 프로젝트 설정에서는, 'Hosting: Configure files for Firebase Hosting and (optionally) set up GitHub Action deploys'을 선택해 줍니다.

만약 여기서 에러가 발생하는 경우, 다른 계정으로 firebase login이 수행된 상태거나, 또는 다른 프로젝트로 접근이 설정되어 있을 수 있습니다.

다른 계정으로 로그인 되어있는 경우 firebase logout을 입력해 로그아웃을 해 준 이후, 다시 firebase login을 통해 로그인을 해 주면 됩니다.

다른 프로젝트로 접근이 설정되어있는 경우에는 'firebase use (프로젝트명)'으로 접근할 프로젝트를 변경해 줄 수 있으니 에러가 발생할 경우 시도해 보면 됩니다.

'What do you want to use as your public directory?'라는 질문에는 'dist'라고 입력해 줍니다.

왜냐하면, build 명령어를 수행했을 때 dist/ 디렉토리에 파일들이 빌드되기 때문입니다.

'single-page app?' 관련 질문에는 'y'로 답해 줍니다.

'automatic builds & deploys with Github?' 관련 질문에는 'N'으로 답해 줍니다.

이제 모든 설정이 끝났고, 진짜로 배포만 남았습니다!

다음의 명령어를 입력하여 배포를 시작해 줍니다.

npm run deploy

잠시 기다린 후 위와 같이 호스팅 주소가 나타나면 배포에 성공한 것입니다.

그럼 링크로 접속해 봅시다.
참고로 firebase에서 같은 프로젝트에 제공하는 도메인은 2가지입니다.

1. (도메인 이름).web.app

2. (도메인 이름).firebaseapp.com

여기서 팁~

첫 번째 주소는 도메인이 짧다는 장점이 있지만, 가끔 새로 deploy 했을 때 바로 반영이 안되는 현상이 있습니다.

따라서 내가 배포 후 업데이트된 사항이 반영되었는지 바로 체크하고 싶으면 ~.firebaseapp.com 도메인을 사용하는 것도 좋습니다.

생성된 도메인으로 접속해 보면, 웹사이트가 성공적으로 잘 배포된 것을 확인할 수 있습니다.

보너스: 웹사이트 메타 태그(meta 정보) 등록하기

여기까지 읽거나 따라오신 분을 위해 웹사이트의 메타 태그를 등록하는 과정을 알려드리겠습니다.

메타 태그를 등록하면, 카카오톡으로 링크를 공유했을 때 나타나는 미리보기를 원하는 대로 설정할 수 있습니다.

따라서 왼쪽과 같이 공유되는 링크에 오른쪽과 같이 내가 원하는 설명과 이미지 미리보기를 붙일 수 있다는 것입니다.

메타 태그를 설정하는 방법은, index.html을 다음과 같이 작성하는 것입니다.

미리보기에 제공할 정보를 위한 og:url, og:title, og:type, og:image와 같은 다양한 메타 태그를 추가할 수 있습니다.

참고를 위해 제가 작성한 메타 태그 코드를 다음과 같이 첨부합니다.

미리보기 이미지는 제가 만든 사이트에 업로드한 뒤, 해당 이미지의 주소를 붙여넣었습니다.

<!-- index.html -->
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <meta property="og:url" content="https://yeohj0710x.web.app/" />
    <meta property="og:title" content="YHJ  " />
    <meta property="og:type" content="website" />
    <meta
      property="og:image"
      content="https://firebasestorage.googleapis.com/v0/b/yeohj0710x.appspot.com/o/tweets%2F1kf9VCWF32SqtUw8SC0XUvnmfeG2-tester123%2FIOsMYA5yaQ5NsWNeazd0?alt=media&token=1ee035c7-2bd1-44b6-aec3-6201c9db9e94"
    />
    <meta property="og:description" content="YHJ  에서 일상을 공유하세요." />
    <title>YHJ  </title>
  </head>
  <body>
    <div id="root"></div>
    <script type="module" src="/src/main.tsx"></script>
  </body>
</html>

이제 이를 적용시키기 위해서, 'npm run deploy' 명령어를 통해 다시 배포를 해 줍니다.

그리고 카카오톡을 통해 링크 이미지 미리보기나 사이트 이름 등 메타 태그가 제대로 적용이 되는지 확인해 봅니다.

적용이 잘 되는 것을 확인할 수 있습니다.

만약 바로 적용이 되지 않는 경우, 카카오톡의 '공유 디버거' 사이트에서 링크를 업로드하고 강제로 캐시를 초기화하여 업데이트할 수 있습니다.

https://developers.kakao.com/tool/debugger/sharing

위의 링크로 들어가서, 업데이트 된 페이지 링크를 붙여넣고 캐시 초기화 및 디버그를 수행해 주면 업데이트가 적용됩니다.

이렇게 해서 Firebase를 이용해 나만의 소셜 미디어 사이트 만들고 배포하는 모든 과정을 다루어보았습니다.

SocketIO 실시간 채팅 사이트 만들고 실제 웹사이트 배포하기

restudy — Sun, 10 Mar 2024 21:21:58 +0900

이번 포스트에서는 SocketIO를 이용해 실시간 채팅 사이트를 만들고, 실제 웹사이트 배포까지 하는 과정을 다루어보겠습니다.

먼저 완성된 웹사이트의 작동 화면은 다음과 같습니다.

완성된 웹 페이지의 작동 화면

HTTP vs WebSocket

모두들 HTTP에 대해서는 많이 들어보셨을 것입니다.

우리가 인터넷 주소 맨 앞에 작성하는 'http'는 클라이언트(우리)가 웹 서버에 요청을 보내고, 서버가 응답을 보내는 하나의 정해진 통신 규칙입니다.

우리가 한글을 사용하는 것과 같이 http라는 프로토콜에 따라 서버에 요청을 보내고 웹 페이지를 받아와서 우리가 화면을 볼 수 있는 것입니다.

WebSocket은 HTTP와 비교되는 개념입니다.

HTTP에서 페이지가 업데이트 되려면 클릭을 하거나 페이지를 이동하는 등 새로운 '요청'을 보내야 합니다.

하지만 WebSocket은 지속적으로 연결을 유지하는 규칙을 가지고 있기 때문에, 실시간으로 데이터를 주고받을 수 있습니다.

예를 들어 채팅을 구현했다고 가정해 봅시다.

HTTP 통신으로 새로운 채팅이 왔는지 확인을 하기 위해서는, 페이지를 새로고침해야 합니다.

하지만 WebSocket으로 구현된 채팅의 경우에는 페이지를 띄워놓기만 해도 채팅이 업데이트 될 수 있습니다.

SocketIO란?

SockeIO는 WebSocket 기능을 쉽게 구현할 수 있게 해주는 JavaScript 라이브러리입니다.

WebSocket 통신에 필요한 기능들이 많이 구현되어 있어서 쉽게 가져다 쓸 수 있습니다.

또한 백엔드와 프론트엔드 사이에서 호출할 이벤트의 이름들을 직접 정의하고 사용할 수 있다는 점, 함수를 포함한 다양한 객체들을 쉽게 주고받을 수 있다는 점이 매우 큰 장점입니다.

코드 작성하기

작성된 전체 코드는 아래의 Github 프로젝트 레포지토리에 있습니다.

전체적인 코드는 노마드코더의 '줌 클론코딩' 코스를 통해 학습하면서 작성했고, 그 이후로 필요한 기능들은 스스로 코딩하여 추가하였습니다!

아직 코드를 정리하지 않아서 코드 순서를 한눈에 보기 쉽지 않지만, 코드의 양이 크게 많지는 않습니다.

GitHub - yeohj0710/SocketIO-practice: A project for practicing SocketIO

A project for practicing SocketIO. Contribute to yeohj0710/SocketIO-practice development by creating an account on GitHub.

github.com

실제로 코드를 작성한 파일은 server.js, app.js, home.pug 3개뿐이고 그마저도 다 합쳐서 300줄 이내이므로, SocketIO가 얼마나 간편한 라이브러리인지 알 수 있습니다.

핵심 기능은 io().on(이벤트명, 객체) 함수라고 생각합니다.

이 함수를 이용하면 위에서 언급한대로 이벤트의 이름을 정의하고, 프론트엔드와 백엔드 사이에서 이벤트를 발생시키고 다양한 객체를 실시간으로 전송할 수 있습니다.

로컬에서 프로젝트 빌드하기

코드 작성이 끝났으면 이제 프로젝트를 빌드해 주어야 합니다.

빌드 명령어 'build'와 app 시작 명령어 'start'를 다음과 같이 정의해 줍니다.

그 다음 두 명령어를 각각 실행해서 build와 start가 잘 작동하는지 확인해 줍니다.

build 명령어 실행 후에는 최적화된 자바스크립트 코드가 build 폴더에 들어가 있어야 하고,

start 명령어를 실행하면 build 명령어를 통해 빌드된 프로젝트가 정상적으로 실행이 되어야합니다.

실제 웹사이트로 배포하기 (Koyeb 이용)

코드가 로컬에서 제대로 작동하는 것을 확인했으면 이제 실제 웹사이트 링크로 배포가 가능합니다.

원래는 배포에 Heroku를 사용했는데, 유료로 전환된 관계로 대체할만한 플랫폼을 찾은 끝에 Koyeb을 사용합니다.

Koyeb의 장점은 당연히 무료이고, 신용카드 등록을 하지 않을 뿐더러(즉 사이트가 공격을 받더라도 자동결제 될 일이 없다는 것이죠), 배포가 어렵지 않습니다.

Koyeb에 회원가입을 하고, Github에 프로젝트를 업로드한 뒤 github 계정 권한을 받아 해당 프로젝트를 Koyeb과 연결해 줍니다.

Settings 탭에서 위와 같이 npm 명령어를 똑같이 맞춰줍니다.

그래야 Koyeb 서버에서 빌드 후 app을 시작할 수 있습니다.

Build 완료 후 프로젝트 실행이 정상적으로 완료되면 위와 같이 Active 표시가 뜹니다.

그러면 Public URL을 통해 실제로 외부에서 사이트에 접속이 가능한지 확인할 수 있습니다.

사이트 배포가 성공적으로 완료되어 정상적으로 작동하는 것을 확인할 수 있습니다.

Node.js 여러 버전을 설치하고 원하는 버전으로 변경하기 (NVM)

restudy — Sun, 25 Feb 2024 11:11:51 +0900

이 포스트에서는 Node.js의 여러 가지 버전을 설치하고, 또 원하는 버전으로 언제든 변경하는 방법을 다룹니다.

NVM(Node Version Manager)이란?

다양한 모듈이나 라이브러리를 설치하면 위와 같이 Node.js 버전이 맞지 않아 서로 호환이 되지 않는 상황이 발생할 수 있습니다.

그렇다고 해서 이 모듈과의 호환성 하나만을 위해 기존의 node 버전을 삭제하고 다시 다른 버전을 설치하는 과정을 반복하는 것은 매우 번거롭습니다.

이런 경우 NVM(Node Version Manager)를 이용하면 다양한 버전의 NodeJS를 설치하고 원할 때마다 프로젝트의 버전을 바꾸어 사용할 수 있습니다.

필요한 node.js 버전 확인하고 새로운 버전 설치하기

먼저 다음의 링크로 들어가서 원하는 NodeJS의 버전들이 어떤 것들이 있는지 살펴봅니다.

https://nodejs.org/en/about/previous-releases

필요한 버전을 확인한 후 다음과 같이 필요한 NodeJS 버전을 추가 설치합니다.

nvm install {원하는 버전}

그럼 위와 같이 새로운 버전이 추가됩니다.

NVM으로 존재하는 node.js 버전 확인하고 변경하기

다음과 같은 명령어로 설치되어 존재하는 node.js 버전들의 목록을 확인할 수 있습니다.

nvm list

위와 같이 설치된 node.js 버전들이 나타나는 것을 확인할 수 있습니다.

별표 표시된 버전이 현재 프로젝트에서 사용 중인 버전에 해당합니다.

다음과 같은 명령어로 이 프로젝트에서 사용할 node.js의 버전을 변경할 수 있습니다.

nvm use {사용할 node.js 버전}

이제 원하는 버전으로 node.js의 버전이 변경된 것을 확인할 수 있습니다.

GraphQL 간단한 Query와 Mutation을 구현하고 테스트 해 보기

restudy — Sat, 24 Feb 2024 09:59:11 +0900

이번 포스트에서는 GraphQL에서 데이터에 접근하는 Query와, 데이터를 추가하고 삭제하는 간단한 Mutation을 구현해 보고 테스트를 해 보도록 하겠습니다.

개요: 구현할 기능

먼저 구현할 기능은 다음과 같습니다.

Person이라는 객체 타입을 정의하고, 각 Person은 고유한 id, 이름, 나이를 값으로 가지도록 작성할 것입니다.

모든 Person들은 group이라는 배열에 저장됩니다. (실제 프로젝트에서는 group이라는 이름을 가지는 데이터베이스에 저장이 되겠죠?)

Query는 group을 반환받아 전체 Person들을 받아오는 group 쿼리와, 특정 이름을 가진 Person이 있는지 체크하는 person 쿼리가 있습니다.

마지막으로 Mutation에는 2가지를 작성할 것입니다.

group에 새로운 Person을 정의하여 추가하는 createPerson과 특정 이름을 가진 Person을 group에서 제거하는 deletePerson을 구현할 것입니다.

전체 코드 살펴보기

이제 다음으로 코드를 살펴보겠습니다.

간략한 설명을 위해 한눈에 볼 수 있게끔 모든 typeDefs들과 resolvers들을 한 JavaScript 파일에 작성하였습니다.

// server.js

import { ApolloServer, gql } from "apollo-server";

const typeDefs = gql`
  type Person {
    id: ID!
    name: String!
    age: Int!
  }
  type Query {
    group: [Person]
    person(name: String!): Person
  }
  type Mutation {
    createPerson(name: String!, age: Int!): Boolean
    deletePerson(name: String!): Boolean
  }
`;

const group = [
  { id: 1, name: "asdf", age: 25 },
  { id: 2, name: "qwer", age: 30 },
];

const resolvers = {
  Query: {
    group: () => {
      return group;
    },
    person: (_, { name }) => {
      return group.find((person) => {
        return person.name === name;
      });
    },
  },
  Mutation: {
    createPerson: (_, { name, age }) => {
      const newPerson = {
        id: group.length + 1,
        name,
        age,
      };
      group.push(newPerson);
      return true;
    },
    deletePerson: (_, { name }) => {
      const index = group.findIndex((person) => person.name == name);
      if (index === -1) return false;
      group.splice(index, 1);
      return true;
    },
  },
};

const server = new ApolloServer({
  typeDefs,
  resolvers,
});

server
  .listen()
  .then(() => console.log("Server is running on http://localhost:4000/"));

typeDefs 살펴보기

먼저 typeDefs를 살펴볼까요?

구현할 기능에서 말한 대로, Person 타입을 선언하고 id, name, age 값을 정의해 줍니다.

그 다음 Query와 Mutation에도 각각 위에서 언급한 내용들을 적어줍니다.

매개변수가 필요한 Query와 Mutation은 소괄호를 쳐주고 필요한 매개변수들과 타입을 적어주어야 합니다.

반환값의 타입을 적어주는 것도 주의해야 합니다.

그 다음 group 배열을 미리 만들어줍니다.

실제 프로젝트에서는 DB가 필요하겠지만, 여기서는 임시로 배열을 선언하여 여기에 데이터를 추가하고 제거하도록 하겠습니다.

resolvers 살펴보기

다음으로 resolvers를 살펴봅시다.

resolvers에는 실제로 데이터에 접근하거나 수정하는 과정을 수행하는 함수를 구현해야 합니다.

Query 부분을 살펴봅시다.

group의 경우에는 전체 배열을 반환해 주면 됩니다.

person은 같은 이름을 가진 Person을 반환해야 하므로, name 인자를 받아 find 함수를 이용해 동일한 이름을 가진 Person을 반환받아 해당 Person을 반환해 줍니다.

다음은 Mutation 부분입니다.

createPerson에는 새로 지정할 Person의 name, age 값이 필요합니다.

이제 새로운 Person 객체를 정의하고, 그 객체를 group에 push 해 주면 됩니다.

성공적으로 처리가 되었음을 알리기 위해 true 값을 마지막에 반환해 주도록 합시다.

deletePerson에서는 먼저 해당 name을 가진 Person이 있는지 검색해야 합니다.

만약 index가 -1이라면 해당 이름을 가진 Person이 없다는 뜻이므로, 아무런 변화도 주지 않고 false를 반환하면 됩니다.

만약 찾았다면 해당 Person을 splice 함수를 이용해 group 배열로부터 제거해 주고, true를 반환합니다.

Query, Mutation 실행해 보기

npm run 명령어를 터미널에 입력하여 코드를 실행하면 이렇게 localhost:4000에 서버가 열렸다는 메시지를 출력됩니다.

localhost:4000으로 이동하면 이렇게 Operation을 작성하고 보낼 수 있는 창이 제공됩니다.

그럼 아까 작성한 쿼리를 실행해 봅시다.

먼저 group 쿼리입니다.

존재하는 모든 Person들의 id, name, age를 받아오도록 하니 제대로 출력되는 것을 확인할 수 있습니다.

person 쿼리입니다.

person 쿼리부터는 인자가 필요하므로, name 값에 찾는 사람의 이름을 적어주면 위와 같이 해당 Person만 반환하는 것을 확인할 수 있습니다.

이제 mutation들을 실행해 보겠습니다.

mutation을 실행할 때에는 위와 같이 가장 바깥쪽의 중괄호 앞에 'mutation'이라고 명시해 주어야 합니다.

먼저 createPerson입니다.

name과 age를 적어 create 해 주도록 하였습니다.

반환값을 요청하지 않아도 자동으로 true를 반환하는 것을 확인할 수 있습니다.

간단히 Person들의 name만 요청해서 확인해 볼까요?

"zxcv"라는 이름을 가진 Person이 group에 잘 추가된 것을 확인할 수 있습니다.

이번에는 deletePerson입니다.

"asdf"라는 이름을 가진 Person을 group에서 제거해 보겠습니다.

true 값이 정상적으로 반환되는 것을 확인할 수 있습니다.

group 쿼리로 확인해 보면, "asdf"라는 이름을 가진 Person이 성공적으로 제거된 것을 확인할 수 있습니다.

What's next...

이렇게 해서 간단한 쿼리와 뮤테이션들을 작성하고 실행해 보았습니다.

하지만 이 코드의 경우에는 실제 DB가 아닌 코드의 배열에서 데이터를 다루고 있기 때문에 서버를 재시작하면 모든 변경 사항이 초기화되고 다시 "asdf"와 "qwer" 이름을 가진 Person들이 들어있는 group으로 시작할 것입니다.

따라서 우리는 별도로 상태를 저장할 데이터베이스가 필요합니다.

다음 시간에는 Prisma Studio를 이용해 별도의 Database를 관리하는 방법에 대해 알아보겠습니다.

GraphQL typeDefs를 정의하고 Mutation resolvers로 조작하기

restudy — Fri, 23 Feb 2024 21:38:42 +0900

GraphQL

GraphQL에는 typeDefs와 resolvers가 있습니다.

typeDefs에는 우리가 사용할 데이터들의 자료형을 정의합니다.

resolvers에는 데이터를 변경하는 등 백엔드에 어떤 조치를 취할 때 작동할 함수를 정의합니다.

물론 실제 서비스를 개발할 때는 분량이 매우 많아지므로, 각각의 typeDefs들과 resolvers들을 개별적인 파일들로 분할하여 정리해 두는 것이 좋습니다.

typeDefs들은 다음과 같은 형식으로 작성합니다.

import { gql } from "apollo-server";

const typeDefs = gql`
    type User {
    	id: ID!
        username: String!
    }
    type Message {
    	id: ID!
        author: User!
        text: String!
    }
    type Query {
    	allMessages: [Messages!]!
        message(id: ID!): Message
    }
    type Mutation {
    	postMessage(text: String!, userId: ID!): Message!
    }
`;

GraphQL의 typeDefs에서 사용할 수 있는 데이터 타입으로는 ID, Int, String, Boolean, Float가 있습니다.

여기서 주목할 점은 'ID'라는 타입의 데이터가 있다는 것입니다.

ID는 고유한 식별자로, 한 테이블에서 각 레코드가 유일한 ID 값을 가질 수 있습니다.

여기에서 type에 느낌표( ! )를 붙이는 것은 값이 반드시 필요한 필드라는 뜻으로, non-nullable type이라고 합니다.

따라서 non-nullable type 자료형에 값을 null로 두면 에러가 발생합니다.

resolver 작성을 위한 기초 JavaScript 문법 복습

JavaScript에서 배열의 길이는 다음과 같이 구합니다.

변수명.length

배열에 새로운 값을 추가할 때는 다음과 같이 작성합니다.

변수명.push(객체명)

주어진 조건을 만족하는 배열의 첫 번째 요소를 구하기 위해서는 다음과 같이 작성합니다.

변수명.find((element) => { Boolean을 반환하는 함수 내용 })

Mutation resolvers 작성 시 주의점

resolvers를 구현할 때 함수에서 받는 인자들은 parent, args, context, info 순서입니다.

이중에서 args는 넘겨받은 인자들에 접근할 때 사용됩니다.

예를 들어서 message를 추가하는 mutation을 다음과 같이 작성할 수 있습니다.

context는 데이터베이스 연결이나 사용자 정보에 접근할 때 사용됩니다.

info는 현재 쿼리에 대한 정보에 접근할 때 사용합니다.

** 단, type resolvers에서는 첫 번째 인자가 object의 data입니다.

const resolvers = {
    Mutation: {
    	postMessage(_, { text, userId }) {
        	const newMessage = {
            	id: messages.length + 1,
                text,
            };
            messages.push(newMessage);
            return newMessage;
        }
    },
    User: {  // type resolvers
    	firstName({ firstName }) {  // type resolvers에서는 첫 번째 인자가 object data
        	return firstName;
        },
        fullName({ firstName, lastName }) {
        	return `${firstName} $lastName});
        },
    }
}

Mutation resolver를 작성할 때에는 mutation이 제대로 처리되었는지 알 수 있도록 값을 반환해 줍니다.

위의 예시 코드에서는 newMessage에 해당합니다.

GraphQL에서 Operation 작성하는 방법

Operation(작업)은 클라이언트가 서버에 보내는 요청을 말합니다.

Query, Mutation, Subscription 3가지의 종류가 있습니다.

(이중에서 Subscription은 실시간 데이터 업데이트를 위한 작업입니다. 예를 들어서 실시간으로 메시지를 주고받는 채팅 등에서 활용될 수 있습니다.)

예를 들어, Mutation은 다음과 같이 작성할 수 있습니다.

mutation UpdateUser($userId: ID!, $name: String!) {
    updateUser(id: $userID, name: $name) {
    	id
        name
    }
}

여기에다가 실제로 보내는 mutation과 같이 실제 변수를 넣으면 다음과 작성할 수 있습니다.

mutation UpdateUser($userId: ID!, $name: String!) {
    updateUser(id: "1", name: "codingterrace") {
    	id
        name
    }
}

또는 mutation은 그대로 두고, variables만 다음과 같이 따로 정의해서 mutation을 보낼 수도 있습니다.

{
    "id": 1,
    "name": codingterrace
}

작성한 Query와 Mutation 실행해 보기

'http://localhost:4000/'로 이동하면 GraphQL Query와 Mutation들을 직접 전송하고 응답을 확인해 볼 수 있습니다.

물론 이것은 로컬로 서버를 열었을 때의 상황이고, 외부에서 접속이 가능한 서버에서 열었을 때에는 알맞은 주소로 변경해주면 됩니다.

React(리액트) create-react-app으로 프로젝트 생성하기

restudy — Mon, 19 Feb 2024 22:08:26 +0900

이번 포스트에서는 create-react-app을 이용하여 리액트에서 프로젝트를 생성하고, 필요한 파일만 남기는 방법에 대해 다루어보겠습니다.

create-react-app

create-react-app은 리액트에서 제공하는 React 어플리케이션을 생성하기 위한 툴입니다.

npx 명령어를 통해 create-react-app을 실행할 수 있는데, 이를 위해서는 NodeJS가 설치되어 있어야 합니다.

따라서 NodeJS가 설치되어 있지 않다면 공식 사이트로 가서 안정적인 버전의 NodeJS를 설치해주면 됩니다.

NodeJS를 설치하였다면 이제 터미널 등에서 프로젝트를 생성할 폴더로 이동하고, 다음의 명령어를 실행하면 됩니다.

npx create-react-app (프로젝트 이름)

그럼 (프로젝트 이름)이라는 이름으로 구성된 프로젝트 폴더가 생성됩니다.

프로젝트 기본 구조 살펴보기

폴더 안의 프로젝트 구조는 다음과 같은 형태를 가지고 있을 것입니다.

여기서 간단한 프로젝트를 만드는 데 대부분의 파일은 필요 없습니다.

기본적인 것부터 살펴보기 위해서, 다음과 같이 필수적인 파일만 남겨둘 수 있습니다.

node_modules는 프로젝트에 필요한 모듈들을 저장하는 폴더이므로 삭제하면 안됩니다.

우리는 프로젝트를 업로드할 때 node_modules에 있는 모듈들을 모두 업로드하지 않고, package.json이라는 파일에 '이 프로젝트에 어떤 모듈들이 필요한지'에 대한 정보만을 저장하여 업로드할 수 있습니다.

따라서 package.json 파일도 삭제하면 안됩니다.

.gitignore 파일은 프로젝트를 업로드할 때 보안과 관련되거나 중요한 정보를 온라인 저장소에 노출시키지 않는 등 업로드하지 않아야 하는 파일의 목록을 관리하는 파일입니다.

필수적인 코드만 남기기

다음으로 index.html은 다음과 같이 반드시 필요한 코드만 남깁니다.

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <title>React App</title>
  </head>
  <body>
    <div id="root"></div>
  </body>
</html>

이 코드에서 주의할 점은 body의 id="root"인 div 하나를 남겨야 한다는 것입니다.

element가 하나라도 있어야 프로젝트에서 렌더링이 잘 작동하는지 확인할 수 있습니다.

다음으로 index.js는 다음과 같이 매우 중요한 코드만 남깁니다.

import React from "react";
import ReactDOM from "react-dom/client";
import App from "./App";

const root = ReactDOM.createRoot(document.getElementById("root"));
root.render(
  <React.StrictMode>
    <App />
  </React.StrictMode>
);

여기서 <React.StrictMode>는 React의 개발 모드에서 검사를 엄격히하여 발생할 수 있는 문제들을 잡아내고 알려주는 역할을 합니다.

따라서 반드시 필요한 것은 아니지만 여기서는 그냥 두도록 합시다.

마지막으로 App.js는 다음과 같이 작성합니다.

function App() {
  return <div>Hello</div>;
}

export default App;

아까 html 태그로 남겨둔 <div id="root>에 Hello라는 텍스트를 작성해 봅시다.

이제 웹에서 어떻게 작동하는지 웹 화면을 확인해볼까요?

프로젝트 실행해 보기

프로젝트의 실행을 위해서는 터미널에 npm start를 입력해주면 됩니다.

물론 이와 관련된 명령어를 package.json 파일에서 설정할 수 있습니다.

npm start는 다음과 같이 프로젝트 생성 처음부터 기본으로 작성되어 있는 명령어입니다.

이제 npm start를 터미널에 쳐서 프로젝트가 제대로 작동하는지 확인해봅시다.

실행 결과는 다음과 같습니다.

'http://localhost:3000/'의 주소에 접속되며 프로젝트가 잘 작동하는 것을 확인할 수 있습니다.

여기서 3000은 React 프로젝트가 작동하는 포트의 번호로, 임의로 빈 포트인 3000을 설정한 것입니다.

이렇게 해서 create-react-app을 이용해 React의 프로젝트를 생성해 보고, 간단한 코드만 남겨 프로젝트가 제대로 작동하는지 확인해 볼 수 있었습니다.

React(리액트) props(속성) 활용과 예시 (+ propTypes)

restudy — Sun, 18 Feb 2024 00:39:03 +0900

이번 포스트에서는 React(리액트)의 props라는 기능에 대해 알아보고, 예시를 통해 props가 어떻게 활용되는지 설명해보도록 하겠습니다.

Props(속성)

React(리액트)에서 props는 properties, 즉 속성이라는 뜻으로 컴포넌트에 전달할 수 있는 데이터라는 뜻을 가지고 있습니다.

우리는 변수와 같이 컴포넌트에 유동적으로 변형을 주어야 할 때, props를 통해 값을 전달하여 컴포넌트가 원하는 값을 나타낼 수 있도록 설정해 줄 수 있습니다.

이렇듯 props를 활용하면 동일한 코드를 가지고도 여러 컴포넌트들의 서로 다른 부분들만을 필요에 따라 다른 props 값을 전달하여 구현할 수 있으므로, 코드의 재사용성이 높아진다는 장점이 있습니다.

예를 들어 5개의 디자인이 비슷한 서로 다른 버튼을 만들 때 5개의 컴포넌트 반환 함수를 구현할 필요없이, 1개의 컴포넌트 반환 함수만을 만들어 서로 다른 props 값을 받아 적용시키면 훨씬 코드가 간단해질 것입니다.

이렇게만 설명하면 이해하기 어려울 수 있으니 예시 코드를 통해 살펴봅시다.

실행 결과와 전체 코드

두 개의 버튼이 있고, 두 버튼의 폰트 사이즈가 다른 것을 확인할 수 있습니다.

↓ 전체 코드는 다음과 같습니다.

<!-- index.html -->
<!DOCTYPE html>
<html>
  <body>
    <div id="root"></div>
  </body>
  <script src="https://unpkg.com/react@17.0.2/umd/react.production.min.js"></script>
  <script src="https://unpkg.com/react-dom@17.0.2/umd/react-dom.production.min.js"></script>
  <script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>
  <script type="text/babel">
    function Btn(props) {
      return (
        <button
          style={{
            backgroundColor: "#4CAF50",
            color: "white",
            padding: "10px 20px",
            border: 0,
            borderRadius: 10,
            cursor: "pointer",
            marginRight: 10,
            fontSize: props.big ? 18 : 14,
          }}
        >
          {props.text}
        </button>
      );
    }
    function App() {
      return (
        <div>
          <Btn text="왼쪽 버튼" big={true} />
          <Btn text="오른쪽 버튼" big={false} />
        </div>
      );
    }
    ReactDOM.render(<App />, root);
  </script>
</html>

코드 부분별로 살펴보기

이제 코드에서 중요한 부분을 살펴봅시다.

먼저 Btn 컴포넌트를 생성하는 부분부터 자세히 살펴볼까요?

<Btn text="왼쪽 버튼" big={true} />
<Btn text="오른쪽 버튼" big={false} />

2개의 Btn 컴포넌트를 생성하는데, text라는 값과 big이라는 값을 설정해 주고 있습니다.

여기서 'text'와 'big'이 리액트의 Props에 해당합니다.

2개의 값을 함수를 호출할 때 인자를 전달하는 것처럼 값을 전달해 줄 수 있습니다.

그렇다면 Btn 함수에서 어떤 컴포넌트를 반환하는지 살펴볼까요?

function Btn(props) {
  return (
    <button
      style={{
        fontSize: props.big ? 18 : 14,
      }}
    >
      {props.text}
    </button>
  );
}

CSS와 관련된 코드 중 필요없는 부분들은 거의 다 삭제하고, 필요한 부분만 남겨두었습니다.

보면 함수의 매개변수로 prop를 사용하며, props.big 값과 props.text 값을 자유롭게 사용할 수 있습니다.

fontSize와 같이 CSS 요소에도 사용할 수 있으며, 버튼에 들어갈 텍스트 부분에도 props의 값을 사용할 수 있습니다.

하지만 props.~와 같이 props의 하위 요소들로 접근하도록 코드를 매번 작성하면 불편할 수 있습니다.

그래서 우리는 다음과 같이 속성 값을 바로 받아서 사용할 수 있습니다.

비구조화 할당(Destructuring)을 이용해 props 받아오기

function Btn({ text, big }) {
  return (
    <button
      style={{
        fontSize: big ? 18 : 14,
      }}
    >
      {text}
    </button>
  );
}

이렇게 중괄호를 이용하여 인자들을 받아주면 매번 'props.'라는 코드를 작성하지 않아도 되며, 정확히 어떤 값들이 함수의 인자로 전달되었는지 쉽게 확인할 수 있습니다.

알 필요는 없지만, 이러한 방식을 '비구조화 할당(destructuring)을 이용해 props를 받아온다'라고 합니다.

CSS 스타일 직접 지정하기

<Btn text="왼쪽 버튼" fontSize={18} />
<Btn text="오른쪽 버튼" fontSize={14} />

여기서 끝이 아니라, props로 style의 속성값과 완전히 동일한 이름으로 인자를 전달하면, 다음과 같이 그 이름을 그대로 사용할 수 있습니다.

즉, props를 이용하여 CSS 스타일을 직접 지정해 줄 수 있습니다.

  return (
    <button
      style={{
        fontSize,
      }}
    >
      {text}
    </button>
  );

fontSize 부분이 보이시나요?

위와 같이 'fontSize: props의 변수명'과 같이 값을 대입해주지 않고 바로 'fontSize'로 값을 사용할 수 있습니다.

이렇게 해서 지금까지 props의 개념과 간단한 활용 방법에 대해 알아보았습니다.

+ propTypes에 대해 알아보기

props에 대해 조금만 더 알아봅시다.

이번에는 propTypes라는 기능에 대해 알아보도록 하겠습니다.

React의 propTypes란 컴포넌트에 전달되는 props가 유효한지를 검사할 수 있는 기능입니다.

단어의 뜻을 살펴보면 '속성의 타입'이라는 뜻을 가지고 있습니다.

즉, 컴포넌트 생성 함수에 제대로 된 타입의 데이터를 전달하고 있는지 체크할 수 있습니다.

propTypes를 사용하기 위해서는 다음과 같이 script로 기능을 웹 링크에서 불러와주어야 합니다.

<script src="https://unpkg.com/prop-types@15.7.2/prop-types.js"></script>

이제 코드를 통해 propTypes를 어떻게 지정할 수 있는지 살펴봅시다.

    function Btn({ text, fontSize }) {
      return (
        <button
          style={{
            fontSize,
          }}
        >
          {text}    
        </button>
      );
    }
    Btn.propTypes = {
      text: PropTypes.string,
      fontSize: PropTypes.number,
    };

위에서 보았던 코드를 그대로 가져와서 propTypes를 작성하겠습니다.

'컴포넌트 이름.propTypes = { }'와 같이 작성해주고, 중괄호 안에는 Object 형식으로 prop 속성명과 'PropTypes.데이터 타입'을 작성해주면 됩니다.

여기서 주의할 점은, 객체명.propTypes의 맨 앞의 P는 소문자로, 내부의 속성은 대문자 P로 작성해 주어야 한다는 것입니다.

반드시 필요한 값임을 명시하기 + 기본값 인자

만약 어떤 prop 데이터가 반드시 필요한 값이라는 것을 명시해 줄 때에는 다음과 같이 작성해줄 수 있습니다.

    Btn.propTypes = {
      text: PropTypes.string.isRequired,
      fontSize: PropTypes.number.isRequired,
    };

위와 같이 'isRequired' 속성을 추가해주면 해당 속성을 반드시 전달해 주어야 한다는 뜻이 됩니다.

이럼에도 불구하고 JSX 요소 생성 시 값을 전달하지 않을 경우를 대비하여, 기본값 인자를 활용할 수 있습니다.

기본값 인자란 어떤 매개변수의 기본값을 지정함으로써 해당 매개변수의 인자 값이 전달되지 않아도 자동으로 인자의 값을 설정하도록 하는 값을 말합니다.

위의 'fontSize = 14'와 같이 어떤 매개변수의 값을 지정해주면 해당 매개변수에 대응되는 인자 값이 전달되지 않아도 자동으로 fontSize = 14로 설정해주게 됩니다.

이렇게 해서 리액트의 prop의 개념과 활용법, 그리고 더 나아가 propTypes라는 개념과 활용법에 대해서도 다뤄보았습니다.

React(리액트) 컴포넌트 분할/조각화를 통해 코드 가독성 높이기

restudy — Sat, 17 Feb 2024 10:10:26 +0900

이번 시간에는 React(리액트) 코드를 여러 개의 JSX 요소들로 나누어 코드의 가독성을 높이는 방식으로 코드를 최적화해 보도록 하겠습니다.

실행 결과와 전체 코드

먼저 실행 결과입니다.

select 태그를 사용하여 모드를 선택할 수 있고, 원하는 단위를 다른 단위로 변환할 수 있습니다.

↓ 전체 코드는 다음과 같습니다.

<!-- index.html -->
<!DOCTYPE html>
<html>
  <body>
    <div id="root"></div>
  </body>
  <script src="https://unpkg.com/react@17.0.2/umd/react.production.min.js"></script>
  <script src="https://unpkg.com/react-dom@17.0.2/umd/react-dom.production.min.js"></script>
  <script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>
  <script type="text/babel">
    const MinutesToHours = () => {
      const [amount, setAmount] = React.useState(0);
      const [inverted, setInverted] = React.useState(false);
      const onChange = (event) => {
        setAmount(event.target.value);
      };
      const reset = () => setAmount(0);
      const onFlip = () => {
        reset();
        setInverted((current) => !current);
      };
      return (
        <>
          <div>
            <input
              value={inverted ? Math.round(amount * 60 * 100) / 100 : amount}
              id="minutes"
              placeholder="분"
              type="number"
              onChange={onChange}
              disabled={inverted}
              style={{ textAlign: "right" }}
            />
            <label htmlFor="minutes"> 분</label>
          </div>
          <div>
            <input
              value={inverted ? amount : Math.round((amount / 60) * 100) / 100}
              id="hours"
              placeholder="시간"
              type="number"
              disabled={!inverted}
              onChange={onChange}
              style={{ textAlign: "right" }}
            />
            <label htmlFor="hours"> 시간</label>
          </div>
          <button onClick={reset}>초기화</button>
          <button onClick={onFlip}>뒤집기</button>
        </>
      );
    };
    const KilometersToMiles = () => {
      const [amount, setAmount] = React.useState(0);
      const [inverted, setInverted] = React.useState(false);
      const onChange = (event) => {
        setAmount(event.target.value);
      };
      const reset = () => setAmount(0);
      const onFlip = () => {
        reset();
        setInverted((current) => !current);
      };
      return (
        <>
          <div>
            <input
              value={inverted ? Math.round(amount * 1.609 * 100) / 100 : amount}
              id="kilometers"
              placeholder="킬로미터"
              type="number"
              onChange={onChange}
              disabled={inverted}
              style={{ textAlign: "right" }}
            />
            <label htmlFor="minutes"> 킬로미터</label>
          </div>
          <div>
            <input
              value={
                inverted ? amount : Math.round((amount / 1.609) * 100) / 100
              }
              id="miles"
              placeholder="마일"
              type="number"
              disabled={!inverted}
              onChange={onChange}
              style={{ textAlign: "right" }}
            />
            <label htmlFor="hours"> 마일</label>
          </div>
          <button onClick={reset}>초기화</button>
          <button onClick={onFlip}>뒤집기</button>
        </>
      );
    };
    function App() {
      const [index, setIndex] = React.useState("x");
      const onSelect = (event) => {
        setIndex(event.target.value);
      };
      return (
        <div>
          <h1>단위 변환기</h1>
          <select value={index} onChange={onSelect}>
            <option value="x">단위를 선택해주세요.</option>
            <option value="0">시간 ↔ 분</option>
            <option value="1">킬로미터 ↔ 마일</option>
          </select>
          <hr />
          {index === "x" ? "단위를 선택해주세요." : null}
          {index === "0" ? <MinutesToHours /> : null}
          {index === "1" ? <KilometersToMiles /> : null}
        </div>
      );
    }
    const root = document.getElementById("root");
    ReactDOM.render(<App />, root);
  </script>
</html>

코드 부분별로 살펴보기

그럼 이제 코드를 여러 개의 작은 JSX 요소로 나누는 것이 어떤 장점이 있는지 살펴봅시다.

<div>
  <h1>단위 변환기</h1>
  <select value={index} onChange={onSelect}>
    <option value="x">단위를 선택해주세요.</option>
    <option value="0">시간 ↔ 분</option>
    <option value="1">킬로미터 ↔ 마일</option>
  </select>
  <hr />
  {index === "x" ? "단위를 선택해주세요." : null}
  {index === "0" ? <MinutesToHours /> : null}
  {index === "1" ? <KilometersToMiles /> : null}
</div>

주목할 코드는 이 부분입니다.

select 태그를 이용하면 정해진 목록들 중 하나를 선택할 수 있게 됩니다.

여기서 만약 option을 변경한다면, onChange라는 이벤트를 발생시킬 수 있습니다.

React에서 자동으로 onChange 이벤트가 감지되면, 우리는 그때 실행할 함수를 지정해줄 수 있습니다.

const [index, setIndex] = React.useState("x");
const onSelect = (event) => {
  setIndex(event.target.value);
};

이 코드를 살펴볼까요?

우리는 위에서 사용자가 option을 변경했을 때 onSelect라는 함수를 실행하도록 지정해두었습니다.

그렇다면 onSelect 함수에서는 우리가 이전에 배운 State 개념을 활용하여 변수의 값을 실시간으로 바꿔줄 수 있습니다.

따라서 setIndex 함수를 호출하여 event에서 선택한 value 값으로 index 값을 변경해 줄 수 있겠네요.

{index === "x" ? "단위를 선택해주세요." : null}
{index === "0" ? <MinutesToHours /> : null}
{index === "1" ? <KilometersToMiles /> : null}

방금 살펴보았던 코드입니다.

index 값이 setIndex 함수에 의해 변경됨에 따라, 위와 같은 삼항 연산자를 활용하여 각 코드 블록이 실행되거나 실행되지 않도록 할 수 있습니다.

여기에서 JSX 요소가 굉장히 유용하게 쓰입니다.

코드의 위에서는 'const MinutesToHours = () => {}'와 같이 MinutesToHours가 호출되었을 때 실행할 코드가 작성되어 있습니다.

우리는 긴 코드를 삼항연산자에 길게 작성할 필요 없이, 위에서 작성한 JSX 요소의 이름만을 태그로 달아 해당 코드가 실행될 수 있도록 하는 것입니다.

이렇게 코드를 조각화하여 활용해 주면 코드의 가독성을 높이고 이해하기 쉬운 코드를 작성할 수 있습니다.

이렇게 해서 간단한 단위 변환기에 여러 가지 모드를 추가하고, 삼항 연산자와 JSX 요소들을 이용하여 코드를 분할 및 조각화를 하고 코드의 가독성을 높이는 방법을 살펴보았습니다.

React(리액트) State를 이용해 단위 변환기 구현하기

restudy — Fri, 16 Feb 2024 23:37:40 +0900

이번 시간에는 React(리액트)의 State를 이용해 단위 변환기를 구현해보도록 하겠습니다.

리액트에서 State는 이름 그대로 '컴포넌트의 상태', 또는 '컴포넌트 안에서 관리되는 데이터'를 의미합니다.

State를 이용해 어떤 컴포넌트의 상태를 변경하면, React는 자동으로 이 컴포넌트만을 다시 렌더링하여 변경된 상태를 페이지에 반영해줍니다.

React의 State를 사용하는 것이 좋은 이유는, 리액트는 앞서 말한대로 필요한 부분만 다시 렌더링하므로, 값이 바뀐다고 페이지 전체를 다시 렌더링할 필요가 없기 때문입니다.

따라서 매우 효율적으로, 화면에 변화가 필요한 부분만을 다시 로딩할 수 있습니다.

물론 Vanilla Javascript에서도 수동적으로 DOM을 조작할 수 있지만, 매우 긴 코드가 필요하고 따라서 번거롭습니다.

하지만 리액트의 State를 사용한다면 리액트가 자동으로 변경 사항을 감지하고 UI를 업데이트해 줄 수 있습니다.

index.html 실행 결과

앞서 언급한대로 이 포스트에서는 위와 같은 '시간 ↔ 분 변환기'를 구현해볼 것입니다.

index.html의 코드는 다음과 같습니다.

<!-- index.html -->
<!DOCTYPE html>
<html>
  <body>
    <div id="root"></div>
  </body>
  <script src="https://unpkg.com/react@17.0.2/umd/react.production.min.js"></script>
  <script src="https://unpkg.com/react-dom@17.0.2/umd/react-dom.production.min.js"></script>
  <script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>
  <script type="text/babel">
    function App() {
      const [amount, setAmount] = React.useState(0);
      const [inverted, setInverted] = React.useState(false);
      const onChange = (event) => {
        setAmount(event.target.value);
      };
      const reset = () => setAmount(0);
      const onFlip = () => {
        reset();
        setInverted((current) => !current);
      };
      return (
        <div>
          <h1>시간 ↔ 분 변환기</h1>
          <div>
            <input
              value={inverted ? Math.round(amount * 60 * 100) / 100 : amount}
              id="minutes"
              placeholder="분"
              type="number"
              onChange={onChange}
              disabled={inverted}
              style={{ textAlign: "right" }}
            />
            <label htmlFor="minutes"> 분</label>
          </div>
          <div>
            <input
              value={inverted ? amount : Math.round((amount / 60) * 100) / 100}
              id="hours"
              placeholder="시간"
              type="number"
              disabled={!inverted}
              onChange={onChange}
              style={{ textAlign: "right" }}
            />
            <label htmlFor="hours"> 시간</label>
          </div>
          <button onClick={reset}>초기화</button>
          <button onClick={onFlip}>뒤집기</button>
        </div>
      );
    }
    const root = document.getElementById("root");
    ReactDOM.render(<App />, root);
  </script>
</html>

주목해서 볼만한 부분을 자세히 살펴보겠습니다.

const [amount, setAmount] = React.useState(0);
const [inverted, setInverted] = React.useState(false);

먼저 여기서는 amount와 inverted라는 state를 사용합니다.

amount는 input 태그에 입력된 값을 나타내고, inverted는 false면 위 칸이 활성화, true면 아래 칸이 활성화되도록 할 것입니다.

useState는 리액트에 내장되어있는 훅(Hook)의 한 종류입니다. (여기서 훅은 컴포넌트의 상태나 생명주기 등을 관리할 수 있도록 도와주는 기능을 뜻합니다.)

useState() 함수는 두 개의 값을 반환하는데, 첫 번째 값은 상태, 두 번째 값은 해당 상태를 업데이트할 수 있는 함수입니다.

따라서 우리는 [value, setValue]와 같이 상태와 업데이트 함수를 각각 받아올 수 있습니다.

useState 함수의 인자로는 상태의 초깃값을 지정해주면 됩니다.

<input
  value={inverted ? Math.round(amount * 60 * 100) / 100 : amount}
  id="minutes"
  type="number"
  onChange={onChange}
  disabled={inverted}
/>

첫 번째 input 태그만 살펴봅시다.

우선 inverted가 true인 경우 아래 칸의 입력에 따라 현재 칸의 값을 설정할 것입니다.

위 칸은 단위가 시간이고, 아래 칸은 단위가 분이므로, amount(시간)을 (분)으로 변환하기 위해 60을 곱해주면 됩니다.

만약 inverted가 false인 경우는 현재 칸이 활성화된 것이므로 입력한 값 그대로 value로 설정해주면 됩니다.

이제 onChange 이벤트를 살펴봅시다.

이 이벤트는 사용자가 입력 필드의 값을 바꿀 때마다 발생합니다.

따라서 이 경우 실행할 함수를 정의해두고 적어주면, 값이 바뀔 때마다 호출이 될 것입니다.

여기서는 onChange() 함수를 사용할 것입니다.

그렇다면 onChange() 함수를 살펴볼까요?

const onChange = (event) => {
  setAmount(event.target.value);
};

onChange() 함수의 구현은 이 포스트에 한해서는 별 내용이 없습니다.

왜냐하면 그냥 변화된 값을 그대로 input 내용으로 반영해주기만 하면 되기 때문입니다.

발생한 이벤트 객체를 event라고 했을 때, event.target.value와 같이 접근하면 입력 필드에 입력된 값에 접근할 수 있습니다.

이 값을 setAmount를 이용해 업데이트해주면, 리액트가 실시간으로 해당 컴포넌트를 업데이트 해줍니다.

이렇게 두 번째 input 태그도 비슷한 원리로 작성해주면, 단위 변환기를 성공적으로 구현할 수 있습니다.

뒤집기를 눌러 invert 시킨 후 값을 입력한 결과

위와 같이 뒤집기 버튼을 누른 후 시간 값을 입력해도 분 단위로 잘 변화가 일어나는 것을 확인할 수 있습니다.

React(리액트) 컴포넌트와 이벤트 간단하게 만들고 렌더링하기

restudy — Mon, 12 Feb 2024 23:50:02 +0900

React(리액트)를 이용해 간단한 컴포넌트와 이벤트를 간단하게 구현해봅시다.

컴포넌트와 이벤트 구현

<!-- index.html -->
<!DOCTYPE html>
<html>
  <body>
    <div id="root"></div>
  </body>
  <script src="https://unpkg.com/react@17.0.2/umd/react.production.min.js"></script>
  <script src="https://unpkg.com/react-dom@17.0.2/umd/react-dom.production.min.js"></script>
  <script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>
  <script type="text/babel">
    const root = document.getElementById("root");
    const Title = (
      <h3 id="title" onMouseEnter={() => console.log("마우스가 들어왔습니다.")}>
        h3 텍스트
      </h3>
    );
    const Button = (
      <button
        style={{ backgroundColor: "gray" }}
        onClick={() => console.log("클릭되었습니다.")}
      >
        클릭해보세요!
      </button>
    );
    const container = React.createElement("div", null, [Title, Button]);
    ReactDOM.render(container, root);
  </script>
</html>

index.html 실행 결과

h3 텍스트에 마우스가 진입하면 '마우스가 들어왔습니다.'라는 텍스트가 콘솔에 출력되고, 버튼을 클릭하면 '클릭되었습니다.'라는 문구가 콘솔에 출력됩니다.

코드가 어떻게 작동하는지 한 줄씩 확인해봅시다.

<script src="https://unpkg.com/react@17.0.2/umd/react.production.min.js"></script>

이 코드는 사용자 인터페이스를 만들기 위한 JavaScript 라이브러리 중 하나인 React를 로드하는 코드입니다.

<script src="https://unpkg.com/react-dom@17.0.2/umd/react-dom.production.min.js"></script>

이 코드는 React에서 작성한 객체 모델인 DOM을 실제 페이지에 표시하는 역할을 수행하는, ReactDOM을 로드하는 코드입니다.

<script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>

이 코드는 최신 버전의 JavaScript 코드를 옛날 버전의 JavaScript 코드로 변환해주는 역할을 수행하는, Babel을 로드하는 코드입니다.

필요한 기능들을 모두 로드했으니 이제 React에서 컴포넌트를 생성하는 방법에 대해 알아봅시다.

const Title = (
  <h3 id="title" onMouseEnter={() => console.log("마우스가 들어왔습니다.")}>
    h3 텍스트
  </h3>
);

JavaScript의 확장 문법인 JSX 문법을 사용하면 컴포넌트를 이렇게 HTML 문법에 가깝게 작성하여 생성하고, 해당 컴포넌트에 이벤트를 추가할 수 있습니다.

물론 이 문법을 옛날 JavaScript 코드처럼 인식시키기 위해서, 위에서 로드한 Babel이 필요합니다.

기존 Vanilla JavaScript 문법과 비교했을 때 훨씬 간단하게 컴포넌트를 생성하고 이벤트를 추가할 수 있습니다.

const root = document.getElementById("root");
const container = React.createElement("div", null, [Title, Button]);
ReactDOM.render(container, root);

이제 root 요소를 찾아주고, 컨테이너를 구성한 뒤 root에 container를 렌더해주면 첫 이미지로 첨부한 화면과 같이 컴포넌트와 이벤트가 제대로 렌더되는 것을 확인할 수 있습니다.

코드 개선

코드를 확인해보면 Container는 Title 컴포넌트와 Button 컴포넌트를 포함하고 있습니다.

리액트(React)에서는 이 컴포넌트들을 html 형식의 문법으로 작성해 줄 수 있습니다.

<!-- index.html -->
<!DOCTYPE html>
<html>
  <body>
    <div id="root"></div>
  </body>
  <script src="https://unpkg.com/react@17.0.2/umd/react.production.min.js"></script>
  <script src="https://unpkg.com/react-dom@17.0.2/umd/react-dom.production.min.js"></script>
  <script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>
  <script type="text/babel">
    const root = document.getElementById("root");
    const Title = () => (
      <h3 id="title" onMouseEnter={() => console.log("마우스가 들어왔습니다.")}>
        h3 텍스트
      </h3>
    );
    const Button = () => (
      <button
        style={{ backgroundColor: "gray" }}
        onClick={() => console.log("클릭되었습니다.")}
      >
        클릭해보세요!
      </button>
    );
    const Container = (
      <div>
        <Title />
        <Button />
      </div>
    );
    ReactDOM.render(Container, root);
  </script>
</html>

단순히 h3 컴포넌트로 구현해준 Title을, h3 컴포넌트를 반환하는 함수로 바꿔줍니다.

그러면 우리는 <Title />과 같이 호출하여 작성한 위치에서 우리가 선언한 컴포넌트를 반환받을 수 있습니다.

이때 주의할 점은, 함수 이름의 첫 글자를 반드시 대문자로 작성해주어야 한다는 것입니다.

함수 이름의 첫 글자를 소문자로 작성한다면, 해당 코드 조각을 호출할 때 태그 이름을 html 태그로 인식하게 되기 때문입니다. (이를 구분하기 위해 대문자로 작성하도록 설정되어 있습니다.)

Button에 대해서도 동일한 처리를 해줍니다.

이렇게 코드를 작성하면, html 형식과 거의 비슷하게 작성하면서도 코드 조각들을 한눈에 알아보기 쉽게 배치할 수 있게 됩니다.

Codeforces 퍼플 달성 / 2022 BOJ solved 1위 / 블로그 접습니다 (+ 수정 : 다시 시작합니다!)

restudy — Sat, 31 Dec 2022 18:35:27 +0900

Codeforces 퍼플 달성

코드포스의 Goodbye 2022 대회에서 적당한 레이팅을 띄웠고 덕분에 2022년이 끝나기 전에 퍼플을 달성할 수 있었다.

나처럼 어려운 문제 푸는거 싫어하고 업솔빙이 재미없다면 그냥 컨테스트만 꾸준히 쳐도 경험이 쌓이니 이를 추천한다.

9개월 정도 걸렸는데 재능 있는 사람들이 훨씬 빨리 올라가는거 보면 부럽긴 하다.

BOJ 2022 solved 수 1위

백준에서 1년동안 문제를 제일 많이 푼 등수인데 보니까 올해는 내가 1등을 기록했다.

심심할 때마다 풀었는데 어려운 거 고민하기는 싫어서 브론즈 실버 난이도 문제들을 거의 다 풀다시피 풀었더니 이렇게 된 것 같다.

아무튼 푼 문제 수는 실력이랑은 큰 관계 없다는 거

추후 계획

그리고 이 글을 누가 볼지는 모르겠지만 블로그는 접으려고 한다.

앞으로 크게 바빠져서 알고리즘을 공부할 시간이 없을 것 같기도 하고, 공부할 내용을 여기에 정리할만큼 시간이 많지도 않을 것 같다.

다만 필요하다면 가끔씩 공부 관련 글들이 몇 개 더 올라올 수는 있다.

광고는 모두 내렸고, 필요없는 글들도 정리했다.

다만 혹시나 검색 유입으로 정보를 얻어가시는 분들이 계실까봐 공부 관련 글들은 남겨두었다.

결국은 혼자 보려고 정리하기 시작한 내용들이지만 누군가에게 도움이 되기를 바란다.

다시 시작! (2024 ~)

개발 공부와 관련한 내용들을 정리하기 위해 포스트 작성을 다시 시작합니다.

이번에도 역시 공부한 내용들을 혼자 정리하고 나중에 잊어버렸을 때 스스로 빠르게 참고하고 다시 활용하기 위해 포스트를 작성하지만, 혹시라도 보시는 분들이 계시다면 도움이 되셨으면 좋겠습니다!

12월 알고리즘 공부 : 퍼시스턴트 세그먼트 트리, 머지 소트 트리, 오일러 회로 등

restudy — Wed, 14 Dec 2022 22:03:41 +0900

백준 BOJ 11012번 : Egg

문제 난이도 : Platinum II

알고리즘 분류 : 퍼시스턴트 세그먼트 트리

2차원 좌표계에서 점들의 좌표가 주어질 때, 직사각형 영역이 쿼리로 주어지면 해당 영역에 점이 몇 개가 있는지를 구하는 문제이다. (0 ≤ x, y ≤ 10^5, Q ≤ 50,000)

1차원 좌표계였다면 일반적인 세그먼트 트리로 해결이 가능한 것은 물론이고 값의 갱신이 없으므로 누적 합으로도 쉽게 계산이 가능하다.

2차원 좌표계 + 작은 범위였다면 2차원 배열의 누적 합으로 쉽게 계산이 가능하다.

이 문제에서는 세그먼트 트리 또는 2차원 배열을 선언하면 메모리 초과가 발생하게 되는데 이를 어떻게 해결할 수 있을까?

이러한 문제는 퍼시스턴트 세그먼트 트리(Persistent Segment Tree, PST)로 풀이할 수 있다.

퍼시스턴트 세그먼트 트리는 노드의 갱신 기록을 저장하고 있는 트리이다.

예를 들어 0번 트리에서 어떤 노드가 갱신되면, 1번 트리를 만들고 갱신되는 노드들만 1번 트리에 노드를 만들고 0번 트리와 연결시킨다.

이런 식으로 해나가면 하나의 새로운 트리에 log N개 정도의 노드만 새로 갱신하면 되므로, M개의 갱신에 대해서도 M log N개의 노드만 저장하면 되므로 메모리를 효율적으로 아낄 수 있다.

대신 구현이 조금 더 복잡한데, 아래의 코드를 참고하자.

이 문제에서는 x값에 하나의 트리가 대응되게 하였으며, 각 x값에 해당하는 y값들을 x번 트리의 y번 노드에 대응되도록 하여 데이터를 저장하게 구현하였다.

이후는 누적 합을 계산하는 것과 같은 원리로 구할 수 있다.

주의할 점은 좌표가 0 "이상" 10^5 "이하"로 들어올 수 있으므로 이 처리를 잘해주어야 한다. (하나의 트리에서 값을 10^5 + 1개 이상 담당하도록 해야함)

참고로 퍼시스턴트 세그먼트 트리는 인덱스를 이용하여 구현하는 방법이 있고 포인터를 이용하여 구현하는 방법이 있다.

백준 BOJ 11012 Egg 문제의 풀이를 구글링해보면 대부분 인덱스 기반으로 구현되어있을 것인데, 아래는 포인터를 이용하여 구현하는 방법이다.

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

const int MAX = 1e5 + 1;

struct node {
    node *l, *r; int x;
    node() { l = r = NULL, x = 0; }
};

node *add(node *cur, int b, int e, int idx, int val) {
    if(cur == NULL) cur = new node();

    if(idx < b || e < idx) return cur;

    if(b == e) {
        node *ret = new node();

        ret->x = cur->x + 1;

        return ret;
    }

    node *ret = new node();

    node *ln = add(cur->l, b, (b+e)/2, idx, val);
    node *rn = add(cur->r, (b+e)/2 + 1, e, idx, val);

    ret->l = ln, ret->r = rn, ret->x = ln->x + rn->x;

    return ret;
}

int sum(node *cur, int b, int e, int l, int r) {
    if(cur == NULL) return 0;

    if(r < b || e < l) return 0;
    if(l <= b && e <= r) return cur->x;

    return sum(cur->l, b, (b+e)/2, l, r) + sum(cur->r, (b+e)/2 + 1, e, l, r);
}

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

    int T; cin >> T;

    while(T--) {
        int N, M; cin >> N >> M;

        vector<vector<int>> v(MAX+1);

        for(int i=0; i<N; i++) {
            int x, y; cin >> x >> y;

            v[x+1].push_back(y+1);
        }

        node *u[MAX+1];
        u[0] = new node();

        for(int i=1; i<=MAX; i++) {
            u[i] = new node();

            u[i]->l = u[i-1]->l, u[i]->r = u[i-1]->r, u[i]->x = u[i-1]->x;

            for(int j=0; j<v[i].size(); j++)
                u[i] = add(u[i], 1, MAX, v[i][j], 1);
        }

        int ans = 0;

        while(M--) {
            int a, b, c, d; cin >> a >> b >> c >> d;

            ans += sum(u[b+1], 1, MAX, c+1, d+1)
                   - sum(u[a], 1, MAX, c+1, d+1);
        }

        cout << ans << "\n";
    }
}

백준 BOJ 13537번 : 수열과 쿼리 1

문제 난이도 : Platinum III

알고리즘 분류 : 머지 소트 트리

길이 10만 이하의 수열이 주어지고, 10만 개 이하의 쿼리에 대해 구간 [i, j]가 주어지면 해당 구간에서 k보다 큰 원소의 개수를 구하는 문제이다.

세그먼트 트리와 동일하게 각 구간을 담당하는 노드가 있고, 각 노드에 담당 구간 원소들이 정렬된 벡터를 가지고 있다면 log 시간에 해결이 가능할 것이다.

그리고 이렇게 구현을 하는 경우 트리의 높이는 log N 정도이고, 하나의 층에 총 N개의 원소가 있으므로 공간복잡도 역시 O(N log N)으로 메모리 초과를 발생시키지 않는다.

이것이 머지 소트 트리(Merge Sort Tree)이다.

구현이 문제인데, 이것은 merge 함수를 이용하여 생각보다 간단하게 구현이 가능하다.

자세한 구현은 아래의 코드를 참고하면 도움이 될 것이다.

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

struct mergeSortTree {
    vector<vector<int>> v;

    void init(int n, int b, int e, vector<int> &u) {
        if(b == e) {
            v[n].push_back(u[b-1]);
            return;
        }

        init(n*2, b, (b+e)/2, u);
        init(n*2+1, (b+e)/2+1, e, u);

        v[n].resize(v[n*2].size() + v[n*2+1].size());
        merge(v[n*2].begin(), v[n*2].end(), v[n*2+1].begin(), v[n*2+1].end(), v[n].begin());
    }

    int gt(int n, int b, int e, int l, int r, int x) {
        if(r < b || e < l) return 0;

        if(l <= b && e <= r)
            return v[n].end() - upper_bound(v[n].begin(), v[n].end(), x);

        return gt(n*2, b, (b+e)/2, l, r, x) + gt(n*2+1, (b+e)/2+1, e, l, r, x);
    }
};

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

    mergeSortTree f;
    f.v.resize(1<<18);

    int N; cin >> N;

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

    f.init(1, 1, N, v);

    int M; cin >> M;

    while(M--) {
        int a, b, c; cin >> a >> b >> c;

        int ans = f.gt(1, 1, N, a, b, c);

        cout << ans << "\n";
    }
}

백준 BOJ 13544번 : 수열과 쿼리 3

문제 난이도 : Platinum III

알고리즘 분류 : 머지 소트 트리

위의 문제와 거의 동일하다.

코드 역시 거의 비슷하다. 아래에 첨부해두었다.

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

struct mergeSortTree {
    vector<vector<int>> v;

    void init(int n, int b, int e, vector<int> &u) {
        if(b == e) {
            v[n].push_back(u[b-1]);
            return;
        }

        init(n*2, b, (b+e)/2, u);
        init(n*2+1, (b+e)/2+1, e, u);

        v[n].resize(v[n*2].size() + v[n*2+1].size());
        merge(v[n*2].begin(), v[n*2].end(), v[n*2+1].begin(), v[n*2+1].end(), v[n].begin());
    }

    int gt(int n, int b, int e, int l, int r, int x) {
        if(r < b || e < l) return 0;

        if(l <= b && e <= r)
            return v[n].end() - upper_bound(v[n].begin(), v[n].end(), x);

        return gt(n*2, b, (b+e)/2, l, r, x) + gt(n*2+1, (b+e)/2+1, e, l, r, x);
    }
};

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

    mergeSortTree f;
    f.v.resize(1<<18);

    int N; cin >> N;

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

    f.init(1, 1, N, v);

    int M; cin >> M;

    int ans = 0;

    while(M--) {
        int a, b, c; cin >> a >> b >> c;

        a ^= ans, b ^= ans, c ^= ans;

        ans = f.gt(1, 1, N, a, b, c);

        cout << ans << "\n";
    }
}

백준 BOJ 7469번 : K번째 수

문제 난이도 : Platinum II

알고리즘 분류 : 머지 소트 트리

역시 쿼리 문제인데, 주어진 구간의 원소들을 정렬했을 때 K번째로 작은 수를 구하는 쿼리를 처리하는 문제이다.

머지 소트 트리로 해결이 가능하다.

방법은 이분 탐색을 활용하는 것이다.

적당한 x를 잡아서 x 이하인 수의 개수를 구하고, 이 x 이하인 수가 k개인 가장 작은 x를 이분 탐색으로 구해주면 된다.

구현은 아래에 있으며, ord 함수를 중점적으로 보면 될 것이다.

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

struct mergeSortTree {
    vector<vector<int>> v;

    void init(int n, int b, int e, vector<int> &u) {
        if(b == e) {
            v[n].push_back(u[b-1]);
            return;
        }

        init(n*2, b, (b+e)/2, u);
        init(n*2+1, (b+e)/2+1, e, u);

        v[n].resize(v[n*2].size() + v[n*2+1].size());
        merge(v[n*2].begin(), v[n*2].end(), v[n*2+1].begin(), v[n*2+1].end(), v[n].begin());
    }

    int ord(int n, int b, int e, int l, int r, int x) {
        if(r < b || e < l) return 0;

        if(l <= b && e <= r)
            return upper_bound(v[n].begin(), v[n].end(), x) - v[n].begin();

        return ord(n*2, b, (b+e)/2, l, r, x) + ord(n*2+1, (b+e)/2+1, e, l, r, x);
    }
};

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

    mergeSortTree f;
    f.v.resize(1<<18);

    int N, M; cin >> N >> M;

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

    f.init(1, 1, N, v);

    while(M--) {
        int a, b, c; cin >> a >> b >> c;

        int l = -1e9, r = 1e9, ans = 1e9;

        while(l <= r) {
            int m = (l + r) / 2;

            int x = f.ord(1, 1, N, a, b, m);

            if(x >= c) {
                ans = min(ans, m);
                r = m - 1;
            }
            else l = m + 1;
        }

        cout << ans << "\n";
    }
}

백준 BOJ 13310번 : 먼 별

문제 난이도 : Diamond V

알고리즘 분류 : 회전하는 캘리퍼스, 삼분 탐색

3만 개 이하의 2차원 좌표 상의 점과 하루 이동하는 거리가 주어지고, 10^7 이하의 일 수가 주어질 때, 주어진 기간 내에서 가장 먼 두 별의 거리가 가장 가까운 날짜를 구하고, 그 때의 거리를 구하는 문제이다.

우리는 우선 특정 날짜에서 별의 분포에 대해 가장 먼 두 별의 거리를 구하는 방법을 생각해보아야 한다.

이것은 볼록 껍질 (Convex Hull) + 회전하는 캘리퍼스 (Rotating Calipers) 알고리즘으로 구현할 수 있다.

이제 날짜에 따른 별들의 거리 분포에 대해 생각해보자.

여기선 엄밀한 증명은 하지 않겠지만, 직관적으로 보았을 때 별들의 최대 거리가 시간이 지남에 따라 증가하거나, 감소하거나, 또는 감소하다가 증가하는 세 가지 경우가 전부이다.

이렇게 최대 1개의 극값을 갖는 경우 삼분 탐색으로 답을 찾을 수 있다.

이 블로그에 컨벡스 헐, 회전하는 캘리퍼스, 삼분 탐색 알고리즘을 이전에 모두 정리해두었으므로 여기에서는 풀이 코드만 첨부한다.

두 삼분점에서의 가장 먼 두 별의 거리를 가지고 범위를 적절히 좁혀나간 뒤, 좁혀진 범위 내에서의 최소 거리를 구해주면 된다.

참고로 삼분 탐색 문제를 많이 안 풀어봤으면 부등호 범위가 애매할 수 있다. (나도 오랜만에 풀어서 잠시 헷갈렸다.)

양단 좌표가 l, r이고 삼분점이 각각 m1, m2라고 할 때 이 문제에서는 f(m1) == f(m2)인 경우 r = m2로 범위를 좁혀야 되는데, 그 이유는 가장 먼 두 별의 거리가 최소인 날짜가 여러 개일 경우 가장 빠른 촬영일을 출력하면 된다고 하였으므로 오른쪽 끝을 왼쪽으로 붙여주면 된다.

만약 이 처리를 하지 않는다면 삼분 탐색이 끝나도 f(x) 값이 동일한 날이 매우 많아 l ~ r 범위가 커진다면 시간 초과가 발생한다.

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

struct P { int x, y; };

P operator-(P a, P b) {
    P c;
    c.x = a.x - b.x;
    c.y = a.y - b.y;
    return c;
}

int N, M;
vector<P> v, u, w;

int ccw(P a, P b, P c) {
    return a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y);
}

bool cmp(P &a, P &b) {
    int x = ccw(v[0], a, b);

    if(x != 0) return x > 0;
    else if(a.y != b.y) return a.y < b.y;
    else return a.x < b.x;
}

int f(int m) {
    v.clear(); v.resize(N);

    for(int i=0; i<N; i++) {
        v[i].x = u[i].x + w[i].x * m;
        v[i].y = u[i].y + w[i].y * m;
    }

    for(int i=1; i<N; i++)
            if(v[i].y < v[0].y || (v[i].y == v[0].y && v[i].x < v[0].x)) swap(v[i], v[0]);

    sort(v.begin()+1, v.end(), cmp);

    stack<P> s;

    s.push(v[0]);
    s.push(v[1]);

    for(int i=2; i<N; i++) {
        while(s.size() >= 2) {
            P a = s.top(); s.pop();
            P b = s.top();

            if(ccw(b, a, v[i]) > 0) {
                s.push(a);
                break;
            }
        }
        s.push(v[i]);
    }

    vector<P> u(s.size());
    while(!s.empty()) {
        u[s.size()-1] = s.top();
        s.pop();
    }

    int l = 0, r = 0;
    for(int i=0; i<u.size(); i++) {
        if(u[i].x < u[l].x) l = i;
        if(u[i].x > u[r].x) r = i;
    }

    int ret = pow(u[l].x - u[r].x, 2) + pow(u[l].y - u[r].y, 2);
    P o = {0, 0};

    for(int i=0; i<u.size(); i++) {
        int nl = (l+1) % u.size();
        int nr = (r+1) % u.size();

        if(ccw(o, u[nl] - u[l], u[r] - u[nr]) > 0) l = nl;
        else r = nr;

        ret = max(ret, (u[l].x - u[r].x) * (u[l].x - u[r].x)
                        + (u[l].y - u[r].y) * (u[l].y - u[r].y));
    }

    return ret;
}

signed main() {
    ios_base::sync_with_stdio(0), cin.tie(0);

    cin >> N >> M;

    u.resize(N), w.resize(N);

    for(int i=0; i<N; i++)
        cin >> u[i].x >> u[i].y >> w[i].x >> w[i].y;

    int l = 0, r = M;

    while(l+3 <= r) {
        int m1 = (l*2 + r) / 3;
        int m2 = (l + r*2) / 3;

        if(f(m1) > f(m2)) l = m1;
        else r = m2;
    }

    int dis = LLONG_MAX, day;

    for(int i=l; i<=r; i++) {
        int val = f(i);

        if(val < dis) {
            dis = val;
            day = i;
        }
    }

    cout << day << "\n";
    cout << dis << "\n";
}

백준 BOJ 1199번 : 오일러 회로

문제 난이도 : Platinum IV

알고리즘 분류 : 오일러 경로

그래프에서의 N x N 크기의 인접 행렬이 주어질 때, 오일러 회로대로 방문하는 정점들을 순서대로 출력하는 문제이다.

오일러 회로란 그래프에서 모든 간선을 지나고 다시 출발점으로 돌아오는 "회로"를 말한다.

오일러 회로 자체를 구현하는 것은 다음과 같은 아이디어로 구현한다.

회로를 따라 이동하면 다시 원래 자리로 돌아오므로 여러 개의 회로를 쪼개어 찾은 뒤 이 경로들을 합쳐주면 된다.

이것은 DFS를 재귀적으로 구현하면 된다.

문제는 이 문제에 한해서는 이렇게 구현된 Hierholzer 알고리즘은 O(VE)의 시간복잡도를 가지는데, 여기에서는 O(E log V) 이하로 줄여야 통과가 가능하다.

따라서 나의 경우 세그먼트 트리를 활용하여 꼭짓점들을 log 시간에 인접 리스트에서 탐색하여 추가하거나 제거할 수 있도록 구현해주었다.

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

struct segmentTree {
    vector<int> v;

    void upd(int n, int b, int e, int idx, int val) {
        if(b == e) {
            v[n] += val;
            return;
        }

        if(idx <= (b+e)/2) upd(n*2, b, (b+e)/2, idx, val);
        else upd(n*2 + 1, (b+e)/2 + 1, e, idx, val);

        v[n] = v[n*2] + v[n*2 + 1];
    }

    int sum(int n, int b, int e, int l, int r) {
        if(r < b || e < l) return 0;
        if(l <= b && e <= r) return v[n];

        return sum(n*2, b, (b+e)/2, l, r)
                + sum(n*2 + 1, (b+e)/2 + 1, e, l, r);
    }

    int kth(int n, int b, int e, int ran) {
        if(b == e) return b;

        if(ran <= v[n*2]) return kth(n*2, b, (b+e)/2, ran);
        else return kth(n*2+1, (b+e)/2+1, e, ran-v[n*2]);
    }
};

struct EulerianPath {
    segmentTree adj[1001];

    int N, start = 0;
    stack<int> s;

    void init() {
        cin >> N;

        for(int i=1; i<=N; i++) {
            adj[i].v.resize(N*4);

            for(int j=1; j<=N; j++) {
                int x; cin >> x;

                adj[i].upd(1, 1, N, j, x);
            }
        }
    }

    bool exist() {
        for(int i=1; i<=N; i++) {
            int cnt = adj[i].sum(1, 1, N, 1, N);

            if(cnt % 2 == 1) return false;

            if(start == 0 && cnt > 0) start = i;
        }

        return true;
    }

    void dfs(int x) {
        while(adj[x].sum(1, 1, N, 1, N) > 0) {
            int y = adj[x].kth(1, 1, N, 1);

            adj[x].upd(1, 1, N, y, -1);
            adj[y].upd(1, 1, N, x, -1);

            dfs(y);
        }

        s.push(x);
    }
};

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

    EulerianPath f; f.init();

    if(!f.exist()) {
        cout << -1 << "\n";
        return 0;
    }

    f.dfs(f.start);

    while(!f.s.empty()) {
        cout << f.s.top() << " ";
        f.s.pop();
    }
    cout << "\n";
}

백준 BOJ 9463번 : 순열 그래프

문제 난이도 : Platinum V

알고리즘 분류 : 세그먼트 트리

이 문제는 기본적인 세그먼트 트리 문제인데 워낙 웰노운이라 여기에 간단히만 정리한다.

위와 같이 2개의 순열이 주어지고, 위 아래에서 같은 수끼리 연결했을 때 교차점의 수를 구하는 문제이다.

핵심은 넘버링 부분인데, 웰노운이긴 하지만 깔끔하기도 하고 기억해둘만 해서 아래에 정리한다.

먼저 윗줄에서 i번째로 입력받은 x에 대해 v[x] = i로 저장해준다.

그 다음 아랫줄에서 i번째로 입력받은 x에 대해 u[i] = v[x]로 저장해준다.

그러면 u[i]는 아랫줄의 i번째 수가 있는 윗줄의 인덱스가 되므로, 이제 세그먼트 트리로 매우 쉽게 처리해줄 수 있다.

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

struct segmentTree {
    vector<int> v;

    void upd(int n, int b, int e, int idx, int val) {
        if(b == e) {
            v[n] += val;
            return;
        }

        if(idx <= (b+e)/2) upd(n*2, b, (b+e)/2, idx, val);
        else upd(n*2 + 1, (b+e)/2 + 1, e, idx, val);

        v[n] = v[n*2] + v[n*2 + 1];
    }

    int sum(int n, int b, int e, int l, int r) {
        if(r < b || e < l) return 0;
        if(l <= b && e <= r) return v[n];

        return sum(n*2, b, (b+e)/2, l, r)
                + sum(n*2 + 1, (b+e)/2 + 1, e, l, r);
    }
};

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

    int T; cin >> T;

    while(T--) {
        int N; cin >> N;

        segmentTree f; f.v.resize(N*4);

        vector<int> v(N+1), u(N+1);

        for(int i=1; i<=N; i++) {
            int x; cin >> x;

            v[x] = i;
        }

        for(int i=1; i<=N; i++) {
            int x; cin >> x;

            u[i] = v[x];
        }

        int ans = 0;

        for(int i=1; i<=N; i++) {
            ans += (u[i] - 1) - f.sum(1, 1, N, 1, u[i]);

            f.upd(1, 1, N, u[i], 1);
        }

        cout << ans << "\n";
    }
}

백준 BOJ 2-SAT 알고리즘 심화 문제 풀이

restudy — Sun, 27 Nov 2022 23:13:05 +0900

백준 BOJ 1739번 : 도로 정비하기

문제 난이도 : Platinum I

알고리즘 분류 : 2-SAT

어떤 가로 도로에 대해서 왼쪽 일방 통행의 경우 T, 오른쪽이면 F로 임의로 두자.

마찬가지로 세로 도로에 대해서도 위 방향은 T, 아래 방향을 F로 두자.

방향은 푸는 사람이 정의하면 된다. 명제 연결할 때만 제대로 연결하면 관계없다.

이제 어떤 점에서 다른 점으로의 이동에 대해, 두 가지 경로가 있으므로, 두 경로에 대해 (A and B) or (C and D)꼴이 나온다.

이것을 식을 풀어서 (나는 분배 법칙으로 풀었다.) (E or F) and (G or H) 꼴로 바꾼 뒤 2-SAT를 적용해주면 된다.

이 문제는 2-SAT에 다른 알고리즘이 접목된 문제도 아닌데 난이도가 Platinum I이다.

왜냐하면 나눠야 할 조건 분기가 너무 많고, 동시에 각각 연결해야 할 명제의 개수도 매우 많다.

아래에 모든 경우의 수를 정리해두었으니 그림을 참고하면 좋을 것이다.

↓ 풀이 코드는 여기에 있다.

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

vector<vector<int>> adj, scc;
vector<int> nnum, cnum;
int ncnt = 0, ccnt = 0;

stack<int> s;
vector<bool> ch;

int y(int x) {
    if(x < 0) return (-x)*2 - 2;
    else return x*2 - 1;
}

int n(int x) {
    x = y(x);

    if(x % 2 == 0) return x + 1;
    else return x - 1;
}

int dfs(int x) {
    nnum[x] = ++ncnt;
    s.push(x);

    int tmp = nnum[x];

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(nnum[y] == 0) tmp = min(tmp, dfs(y));
        else if(!ch[y]) tmp = min(tmp, nnum[y]);
    }

    if(tmp == nnum[x]) {
        vector<int> v;
        ccnt++;

        while(true) {
            int y = s.top();
            s.pop();

            v.push_back(y);

            ch[y] = true;
            cnum[y] = ccnt;

            if(y == x) break;
        }

        sort(v.begin(), v.end());

        scc.push_back(v);
    }

    return tmp;
}

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

    int T; cin >> T;

    while(T--) {
        int R, C, K; cin >> R >> C >> K;

        int N = R + C;

        adj.clear(); adj.resize(N*2);

        while(K--) {
            int bx, by, ex, ey; cin >> bx >> by >> ex >> ey;

            if(bx == ex && by < ey) adj[y(bx)].push_back(n(bx));
            else if(bx == ex && by > ey) adj[n(bx)].push_back(y(bx));
            else if(bx > ex && by == ey) adj[n(R+by)].push_back(y(R+by));
            else if(bx < ex && by == ey) adj[y(R+by)].push_back(n(R+by));
            else if(bx < ex && by < ey) {
                adj[y(bx)].push_back(n(ex));
                adj[y(ex)].push_back(n(bx));
                adj[y(bx)].push_back(n(R+by));
                adj[y(R+by)].push_back(n(bx));
                adj[y(ex)].push_back(n(R+ey));
                adj[y(R+ey)].push_back(n(ex));
                adj[y(R+ey)].push_back(n(R+by));
                adj[y(R+by)].push_back(n(R+ey));
            }
            else if(bx < ex && by > ey) {
                adj[n(bx)].push_back(y(ex));
                adj[n(ex)].push_back(y(bx));
                adj[n(bx)].push_back(n(R+by));
                adj[y(R+by)].push_back(y(bx));
                adj[n(ex)].push_back(n(R+ey));
                adj[y(R+ey)].push_back(y(ex));
                adj[y(R+ey)].push_back(n(R+by));
                adj[y(R+by)].push_back(n(R+ey));
            }
            else if(bx > ex && by < ey) {
                adj[y(bx)].push_back(n(ex));
                adj[y(ex)].push_back(n(bx));
                adj[y(bx)].push_back(y(R+by));
                adj[n(R+by)].push_back(n(bx));
                adj[y(ex)].push_back(y(R+ey));
                adj[n(R+ey)].push_back(n(ex));
                adj[n(R+ey)].push_back(y(R+by));
                adj[n(R+by)].push_back(y(R+ey));
            }
            else if(bx > ex && by > ey) {
                adj[n(bx)].push_back(y(ex));
                adj[n(ex)].push_back(y(bx));
                adj[n(bx)].push_back(y(R+by));
                adj[n(R+by)].push_back(y(bx));
                adj[n(ex)].push_back(y(R+ey));
                adj[n(R+ey)].push_back(y(ex));
                adj[n(R+ey)].push_back(y(R+by));
                adj[n(R+by)].push_back(y(R+ey));
            }
        }

        nnum.clear(); nnum.resize(N*2);
        cnum.clear(); cnum.resize(N*2);
        ch.clear();   ch.resize(N*2);

        scc.clear();
        ncnt = ccnt = 0;

        for(int i=0; i<N*2; i++)
            if(nnum[i] == 0) dfs(i);

        bool check = true;

        for(int i=0; i<N; i++) {
            if(cnum[i*2] == cnum[i*2 + 1]) {
                check = false;
                break;
            }
        }

        if(check) cout << "Yes\n";
        else cout << "No\n";
    }
}

백준 BOJ 5009번 : 유치원

문제 난이도 : Platinum I

알고리즘 분류 : 2-SAT, 이분 탐색

2-SAT에 이분 탐색을 결합한 문제이다.

큰 틀에서는 적절한 T를 찾기 위해 0 ~ N-1 사이에서 이분 탐색을 하며 T를 찾아주면 된다.

2-SAT 문제로 치환하기 위해, 특정 번호 i가 0반에 속하는지의 여부, 1반에 속하는지의 여부, 2반에 속하는지의 여부를 각각 bool 변수로 생각해서 3N개의 변수를 만들어주고, 명제 관계만 잘 연결해주면 된다.

예를 들어 T를 기준으로 등수가 더 낮은 번호와는 같은 반이 되면 안 되므로, "i가 x반이면 → j는 x반이 아니다", 동시에 "j가 x반이면 → i는 x반이 아니다" 이런 식으로 명제들을 연결해줄 수 있다.

모든 명제 조건을 다 설명하기엔 길기 때문에 풀이 코드를 참고하면 도움이 될 것이다.

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

vector<vector<int>> adj, scc;
vector<int> nnum, cnum;
int ncnt = 0, ccnt = 0;

stack<int> s;
vector<bool> ch;

int y(int x) {
    if(x < 0) return (-x)*2 - 2;
    else return x*2 - 1;
}

int n(int x) {
    x = y(x);

    if(x % 2 == 0) return x + 1;
    else return x - 1;
}

int dfs(int x) {
    nnum[x] = ++ncnt;
    s.push(x);

    int tmp = nnum[x];

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(nnum[y] == 0) tmp = min(tmp, dfs(y));
        else if(!ch[y]) tmp = min(tmp, nnum[y]);
    }

    if(tmp == nnum[x]) {
        vector<int> v;
        ccnt++;

        while(true) {
            int y = s.top();
            s.pop();

            v.push_back(y);

            ch[y] = true;
            cnum[y] = ccnt;

            if(y == x) break;
        }

        sort(v.begin(), v.end());

        scc.push_back(v);
    }

    return tmp;
}

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

    int N; cin >> N;

    vector<int> v(N+1);
    vector<vector<int>> u(N+1, vector<int>(N));

    for(int i=1; i<=N; i++) {
        cin >> v[i];

        for(int j=1; j<=N-1; j++) cin >> u[i][j];
    }

    int l = 0, r = N-1, ans = N-1;
    int M = N * 3;

    while(l <= r) {
        int m = (l + r) / 2;

        adj.clear(); adj.resize(M*2);

        for(int i=1; i<=N; i++) {
            adj[y(v[i]*N + i)].push_back(n(v[i]*N + i));

            int a = ((v[i] + 1) % 3)*N + i;
            int b = ((v[i] + 2) % 3)*N + i;

            adj[n(a)].push_back(y(b));
            adj[n(b)].push_back(y(a));

            for(int j=m+1; j<=N-1; j++)
                for(int k=0; k<3; k++) {
                    if(k == v[i]) continue;

                    adj[y(k*N + i)].push_back(n(k*N + u[i][j]));
                    adj[y(k*N + u[i][j])].push_back(n(k*N + i));
                }
        }

        nnum.clear(); nnum.resize(M*2);
        cnum.clear(); cnum.resize(M*2);
        ch.clear();   ch.resize(M*2);

        scc.clear();
        ncnt = ccnt = 0;

        for(int i=0; i<M*2; i++)
            if(nnum[i] == 0) dfs(i);

        bool check = true;

        for(int i=0; i<M; i++) {
            if(cnum[i*2] == cnum[i*2 + 1]) {
                check = false;
                break;
            }
        }

        if(check) {
            ans = min(ans, m);
            r = m - 1;
        }
        else l = m + 1;
    }

    cout << ans << "\n";
}

백준 BOJ 2519번 : 막대기

문제 난이도 : Diamond V

알고리즘 분류 : 2-SAT, 선분 교차 판정

2-SAT 문제에 선분 교차 판정이 접목된 문제이다.

구현이 쉽지 않은 두 알고리즘이 모두 사용되기 때문에 다른 2-SAT 문제에 비해 구현량이 매우 많다.

다만 두 가지를 구현할 줄만 알면 간단한 명제 식 몇 개만 풀면 문제가 쉽게 풀리므로, 곧 투표에 의해 Platinum으로 난이도가 하향될 것 같기도 하다.

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

struct s { int x, y; };

bool operator== (s a, s b) {
    if(a.x == b.x && a.y == b.y) return true;
    else return false;
}
bool operator>= (s a, s b) {
    if(a.x > b.x || (a.x == b.x && a.y >= b.y)) return true;
    else return false;
}
bool operator<= (s a, s b) {
    if(a.x < b.x || (a.x == b.x && a.y <= b.y)) return true;
    else return false;
}
bool operator> (s a, s b) {
    if(a.x > b.x || (a.x == b.x && a.y > b.y)) return true;
    else return false;
}
bool operator< (s a, s b) {
    if(a.x < b.x || (a.x == b.x && a.y < b.y)) return true;
    else return false;
}

int ccw(s a, s b, s c) {
    int val = a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y);

    if(val == 0) return 0;
    else if(val > 0) return 1;
    else if(val < 0) return -1;
}

bool cross, overlap;
double cx, cy;

void coor(s a, s b, s c, s d) {
    double X = (a.x * b.y - a.y * b.x) * (c.x - d.x) - (a.x - b.x) * (c.x * d.y - c.y * d.x);
    double Y = (a.x * b.y - a.y * b.x) * (c.y - d.y) - (a.y - b.y) * (c.x * d.y - c.y * d.x);
    double div = (a.x - b.x) * (c.y - d.y) - (a.y - b.y) * (c.x - d.x);

    if(div == 0) {
        if(b == c && a <= c) cx = b.x, cy = b.y, overlap = false;
        else if(a == d && c <= a) cx = a.x, cy = a.y, overlap = false;
        else overlap = true;
    }
    else cx = X / div, cy = Y / div, overlap = false;
}

void inter(s a, s b, s c, s d) {
    int val1 = ccw(a, b, c) * ccw(a, b, d);
    int val2 = ccw(c, d, a) * ccw(c, d, b);

    if(val1 == 0 && val2 == 0) {
        if(a > b) swap(a, b);
        if(c > d) swap(c, d);

        if(a <= d && b >= c) {
            cross = true;
            coor(a, b, c, d);
        }
        else cross = false;
    }
    else {
        if(val1 <= 0 && val2 <= 0) {
            cross = true;
            coor(a, b, c, d);
        }
        else cross = false;
    }
}

vector<vector<int>> adj, scc;
vector<int> nnum, cnum;
int ncnt = 0, ccnt = 0;

stack<int> st;
vector<bool> ch;

int dfs(int x) {
    nnum[x] = ++ncnt;
    st.push(x);

    int tmp = nnum[x];

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(nnum[y] == 0) tmp = min(tmp, dfs(y));
        else if(!ch[y]) tmp = min(tmp, nnum[y]);
    }

    if(tmp == nnum[x]) {
        vector<int> v;
        ccnt++;

        while(true) {
            int y = st.top();
            st.pop();

            v.push_back(y);

            ch[y] = true;
            cnum[y] = ccnt;

            if(y == x) break;
        }

        sort(v.begin(), v.end());

        scc.push_back(v);
    }

    return tmp;
}

int cvt(int x) {
    if(x < 0) return (-x)*2 - 2;
    else return x*2 - 1;
}

int cvtn(int x) {
    x = cvt(x);

    if(x % 2 == 0) return x + 1;
    else return x - 1;
}

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

    int N; cin >> N;

    N *= 3;

    vector<vector<s>> v(N+1, vector<s>(2));

    for(int i=1; i<=N; i++)
        cin >> v[i][0].x >> v[i][0].y >> v[i][1].x >> v[i][1].y;

    adj.resize(N*2);

    for(int i=1; i<=N; i+=3) {
        adj[cvt(i)].push_back(cvtn(i+1));
        adj[cvt(i)].push_back(cvtn(i+2));

        adj[cvt(i+1)].push_back(cvtn(i));
        adj[cvt(i+1)].push_back(cvtn(i+2));

        adj[cvt(i+2)].push_back(cvtn(i));
        adj[cvt(i+2)].push_back(cvtn(i+1));
    }

    for(int i=1; i<=N; i++)
        for(int j=i+1; j<=N; j++) {
            inter(v[i][0], v[i][1], v[j][0], v[j][1]);

            if(cross) {
                adj[cvtn(i)].push_back(cvt(j));
                adj[cvtn(j)].push_back(cvt(i));
            }
        }

    nnum.resize(N*2);
    cnum.resize(N*2);
    ch.resize(N*2);

    for(int i=0; i<N*2; i++)
        if(nnum[i] == 0) dfs(i);

    bool check = true;

    for(int i=0; i<N; i++) {
        if(cnum[i*2] == cnum[i*2 + 1]) {
            check = false;
            break;
        }
    }

    if(!check) {
        cout << -1 << "\n";
        return 0;
    }

    vector<pair<int, int>> p(N*2);
    for(int i=0; i<N*2; i++) p[i] = {cnum[i], i};

    sort(p.begin(), p.end(), greater<pair<int, int>>());

    vector<int> tf(N*2, -1);

    for(int i=0; i<N*2; i++) {
        int x = p[i].second;

        if(tf[x/2] == -1) {
            if(x % 2 == 1) tf[x/2] = 0;
            else tf[x/2] = 1;
        }
    }

    vector<int> u;

    for(int i=0; i<N; i++)
        if(tf[i]) u.push_back(i+1);

    cout << u.size() << "\n";

    for(int i=0; i<u.size(); i++) cout << u[i] << " ";
    cout << "\n";
}

백준 BOJ 25456번 : 궁금한 시프트

문제 난이도 : Platinum I

알고리즘 분류 : FFT

이 문제는 2-SAT 문제가 아니고 FFT 문제인데 적을 곳이 없기도 하고 설명할 내용도 거의 없어서 여기에 끼워넣는다.

백준 BOJ 1067번 : 이동 문제와 거의 구조가 비슷하고, 풀이 코드 또한 거의 유사하다.

따라서 원리만 그대로 가져다가 풀어주면 된다.

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

const double PI = acos(-1);
typedef complex<double> cpx;

void FFT(vector<cpx> &v, bool inv) {
    int S = v.size();

    for(int i=1, j=0; i<S; i++) {
        int bit = S/2;

        while(j >= bit) {
            j -= bit;
            bit /= 2;
        }
        j += bit;

        if(i < j) swap(v[i], v[j]);
    }

    for(int k=1; k<S; k*=2) {
        double angle = (inv ? PI/k : -PI/k);
        cpx w(cos(angle), sin(angle));

        for(int i=0; i<S; i+=k*2) {
            cpx z(1, 0);

            for(int j=0; j<k; j++) {
                cpx even = v[i+j];
                cpx odd = v[i+j+k];

                v[i+j] = even + z*odd;
                v[i+j+k] = even - z*odd;

                z *= w;
            }
        }
    }

    if(inv)
        for(int i=0; i<S; i++) v[i] /= S;
}

vector<int> mul(vector<int> &v, vector<int> &u) {
    vector<cpx> vc(v.begin(), v.end());
    vector<cpx> uc(u.begin(), u.end());

    int S = 2;
    while(S < v.size() + u.size()) S *= 2;

    vc.resize(S); FFT(vc, false);
    uc.resize(S); FFT(uc, false);

    for(int i=0; i<S; i++) vc[i] *= uc[i];
    FFT(vc, true);

    vector<int> w(S);
    for(int i=0; i<S; i++) w[i] = round(vc[i].real());

    return w;
}

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

    string a, b; cin >> a >> b;

    int N = a.length();

    vector<int> v(N*2), u(N);
    
    for(int i=0; i<N; i++) v[i] = v[i+N] = a[i] - '0';
    for(int i=0; i<N; i++) u[N-1-i] = b[i] - '0';

    vector<int> w = mul(v, u);

    int ans = 0;
    for(int i=0; i<w.size(); i++) ans = max(ans, w[i]);

    cout << ans << "\n";
}

빠른 MCMF 최소 비용 최대 유량 알고리즘 등 (+ 응용 문제 풀이)

restudy — Sun, 27 Nov 2022 22:56:14 +0900

11월 말 백준에서 풀이한 문제들 중, 플래티넘 이상 난이도 문제들에서 다른 사람들이 잘 다루지 않는 내용들을 선별하여 정리해보려고 한다.

이번 기간에 다룬 알고리즘은 MCMF(최소 비용 최대 유량)이다.

낮은 난이도나 다른 사람들이 많이 푼 문제들은 이미 다 풀어서 플래티넘 난이도 중에서도 어려운 것만 남았고, 그에 대한 풀이를 다룬 사람들이 별로 없어서 간략하게나마 적어본다.

어디까지나 스스로 공부, 잊어버렸을 때 나중에 다시 참고하기 위한 목적이지만 혹시나 검색 유입으로 보는 사람이 있다면 도움이 될 수 있으면 좋겠다.

백준 BOJ 14424번 : 두부장수 장홍준 3

문제 난이도 : Diamond V

알고리즘 분류 : MCMF (최소 비용 최대 유량)

사실 이 문제는 이전에 백준 BOJ 11111번 : 두부장수 장홍준 2 문제에 대한 풀이를 다룬 적이 있다.

다만 이 문제에서는 N, M의 제한이 50에서 200으로 늘어났고, 11111번 문제의 풀이 코드를 제출하면 일반적으로는 시간 초과에 걸리게 된다.

이 문제를 풀기 위해서는 기존 MCMF 알고리즘에 대해 최적화가 조금 더 이루어진 코드가 필요하다.

Dinic 알고리즘과 같이 유량을 갱신함과 동시에 새로운 DAG를 O(V+E) 시간에 갱신하는 최적화된 MCMF에 대한 구현을 찾을 수 있어 이를 참고하여 풀이하였다. (jhnah917님의 블로그에서 참고하였다. 처음부터 다시 작성했고 구조가 많이 다르긴 하지만 사실 본질은 거의 똑같이 구현되긴 했다.)

정형화시킨 코드는 팀노트(?)라고 부르기는 애매하지만 아무튼 오른쪽 카테고리의 "알고리즘 구현 코드 모음"의 MCMF 파트에 정리되어 있다.

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

struct sm {
	// referred to the jhnah917's implementation (purpose of study)

    struct se { int num, cap, sco, ord; };
    vector<vector<se>> adj;

    void edge(int a, int b, int c, int d) {
        adj[a].push_back({b, c, d, adj[b].size()});
        adj[b].push_back({a, 0, -d, adj[a].size()-1});
    }

    int sour, sink;
    vector<int> tco, idx;
    vector<bool> chk;

    int dfs(int x, int flo) {
        chk[x] = true;

        if(x == sink) return flo;

        for(; idx[x] < adj[x].size(); idx[x]++) {
            se &ad = adj[x][idx[x]];

            if(chk[ad.num] || tco[x] + ad.sco != tco[ad.num] || ad.cap == 0) continue;

            int ret = dfs(ad.num, min(flo, ad.cap));

            if(ret == 0) continue;

            ad.cap -= ret;
            adj[ad.num][ad.ord].cap += ret;

            return ret;
        }

        return 0;
    }

    pair<int, int> mcmf(int sour_, int sink_) {
        sour = sour_, sink = sink_;

        int minc = 0, maxf = 0;

        tco.resize(adj.size(), INT_MAX);
        tco[sour] = 0;

        queue<int> q;
        q.push(sour);

        vector<bool> inq(adj.size());
        inq[sour] = true;

        while(!q.empty()) {
            int x = q.front();
            q.pop(); inq[x] = false;

            for(int i=0; i<adj[x].size(); i++) {
                int y = adj[x][i].num;
                int cap = adj[x][i].cap;
                int sco = adj[x][i].sco;

                if(cap <= 0 || tco[x] + sco >= tco[y]) continue;

                tco[y] = tco[x] + sco;

                if(inq[y]) continue;

                q.push(y);
                inq[y] = true;
            }
        }

        while(true) {
            chk.clear(); chk.resize(adj.size());
            idx.clear(); idx.resize(adj.size());

            while(true) {
                int cur = dfs(sour, INT_MAX);
                if(cur == 0) break;

                minc += tco[sink] * cur;
                maxf += cur;

                chk.clear(); chk.resize(adj.size());
            }

            int Min = INT_MAX;

            for(int i=0; i<adj.size(); i++) {
                if(!chk[i]) continue;

                for(int j=0; j<adj[i].size(); j++) {
                    int x = adj[i][j].num;
                    int cap = adj[i][j].cap;
                    int sco = adj[i][j].sco;

                    if(cap > 0 && !chk[x]) Min = min(Min, tco[i] + sco - tco[x]);
                }
            }

            if(Min == INT_MAX) break;

            for(int i=0; i<adj.size(); i++)
                if(!chk[i]) tco[i] += Min;
        }

        return {minc, maxf};
    }
};

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

    int N, M; cin >> N >> M;

    vector<vector<char>> v(N+1, vector<char>(M+1));

    for(int i=1; i<=N; i++)
        for(int j=1; j<=M; j++) cin >> v[i][j];

    sm f;

    f.adj.resize(N*M + 3);

    int sour = N*M + 1, sink = N*M + 2;

    int cvt[6][6] = {{10, 8, 7, 5, 0, 1},
                      {8, 6, 4, 3, 0, 1},
                      {7, 4, 3, 2, 0, 1},
                      {5, 3, 2, 2, 0, 1},
                      {0, 0, 0, 0, 0, 0},
                      {1, 1, 1, 1, 0, 0}};

    for(int i=1; i<=N; i++)
        for(int j=1; j<=M; j++) {
            if((i + j) % 2 == 0) {
                f.edge(sour, (i-1)*M + j, 1, 0);
                f.edge((i-1)*M + j, sink, 1, 0);

                int di[4] = {1, -1, 0, 0};
                int dj[4] = {0, 0, 1, -1};

                for(int k=0; k<4; k++) {
                    int ni = i + di[k];
                    int nj = j + dj[k];

                    if(ni < 1 || nj < 1 || ni > N || nj > M) continue;

                    f.edge((i-1)*M + j, (ni-1)*M + nj, 1, -cvt[v[i][j]-'A'][v[ni][nj]-'A']);
                }
            }
            else f.edge((i-1)*M + j, sink, 1, 0);
        }


    pair<int, int> mcmf = f.mcmf(sour, sink);

    int minc = mcmf.first;
    int maxf = mcmf.second;

    cout << -minc << "\n";
}

백준 BOJ 5892번 : Landscaping

문제 난이도 : Platinum V

알고리즘 분류 : MCMF (최소 비용 최대 유량)

이 문제는 애초에 내가 질문 글을 올렸으니 그 이미지를 첨부한다.

이런 문제인데 아무튼 정석 풀이는 DP이고, 그래서 난이도가 Platinum V이다.

질문 글을 올리고 다음 날 답변이 달렸는데 이 문제를 유일하게 MCMF로 푸신 djs100201님이 풀이를 거의 떠먹여주시다시피 알려주셔서 구현해볼 수 있었다.

MCMF로 푸는 방법은 다음과 같다.

X와 Y를 처리할 노드를 하나 만들어서 마음껏 처리할 수 있도록 해준다.

그 다음 A_i값들의 합 asum과 B_i값들의 합 bsum을 구해 만약 asum이 더 크다면, (asum - bsum) x Y만큼 답에 더해준다.

반대의 경우에는 (bsum - asum) x X만큼 답에 더해준다.

대충 생각했을 때는 X, Y 값이 Z보다 매우 작을 경우 예외가 발생할 것 같기도 한데, 따로 연결한 노드 하나에서 그러한 예외가 모두 처리되기 때문에, 우선 최대한 싸게 이동을 시킨 뒤 마지막에 추가 또는 제거를 해도 답에 영향을 주지 않는다.

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

struct se {
    int num, ord, cap, sco;

    se(int num, int ord, int cap, int sco) : num(num), ord(ord), cap(cap), sco(sco) {}
};

vector<vector<se>> adj;
int maxf, minc;

void edge(int a, int b, int c, int d) {
    adj[a].emplace_back(b, adj[b].size(), c, d);
    adj[b].emplace_back(a, adj[a].size()-1, 0, -d);
}

void mcmf(int sour, int sink) {
    while(true) {
        vector<int> pre(adj.size(), -1), idx(adj.size(), -1);

        vector<int> tco(adj.size(), INT_MAX);
        tco[sour] = 0;

        queue<int> q;
        q.push(sour);

        vector<bool> inq(adj.size());
        inq[sour] = true;

        while(!q.empty()) {
            int x = q.front();
            q.pop();
            inq[x] = false;

            for(int i=0; i<adj[x].size(); i++) {
                int y = adj[x][i].num;
                int cap = adj[x][i].cap;
                int sco = adj[x][i].sco;

                if(cap <= 0 || tco[x] + sco >= tco[y]) continue;

                tco[y] = tco[x] + sco;
                pre[y] = x;
                idx[y] = i;

                if(inq[y]) continue;

                q.push(y);
                inq[y] = true;
            }
        }
        if(pre[sink] == -1) break;

        int sfl = INT_MAX;

        for(int i=sink; i!=sour; i=pre[i]) {
            int a = pre[i], b = idx[i];

            sfl = min(sfl, adj[a][b].cap);
        }

        for(int i=sink; i!=sour; i=pre[i]) {
            int a = pre[i], b = idx[i];

            adj[a][b].cap -= sfl;
            adj[i][adj[a][b].ord].cap += sfl;

            minc += sfl * adj[a][b].sco;
        }

        maxf += sfl;
    }
}

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

    int N, X, Y, Z; cin >> N >> X >> Y >> Z;

    vector<int> v(N+1), u(N+1);
    int vsum = 0, usum = 0;

    for(int i=1; i<=N; i++) {
        cin >> v[i] >> u[i];

        vsum += v[i];
        usum += u[i];
    }

    adj.clear();
    adj.resize(N+4);

    int ext = N+1, sour = N+2, sink = N+3;

    for(int i=1; i<=N; i++) {
        edge(sour, i, v[i], 0);
        edge(i, sink, u[i], 0);

        edge(i, ext, INT_MAX, Y);
        edge(ext, i, INT_MAX, X);

        for(int j=1; j<=N; j++)
            if(i != j) edge(i, j, INT_MAX, abs(i-j)*Z);
    }

    int ans = 0;

    if(vsum > usum) ans += (vsum - usum) * Y;
    else if(vsum < usum) ans += (usum - vsum) * X;

    maxf = 0, minc = 0;

    mcmf(sour, sink);

    ans += minc;

    cout << ans << "\n";
}

백준 BOJ 17506번 : 주때의 자소서 쓰기

문제 난이도 : Platinum II

알고리즘 분류 : MCMF (최소 비용 최대 유량)

처음에는 이렇게 접근했다.

그런데 A, B, C 각각에 최소 하나 이상의 소재는 배정을 받아야 한다는 조건이 있다.

이를 처리해주기 위해서는 아주 낮은 비용으로 유량을 1씩 흘려줘서 무조건 흘러주게 하는 방법이 있는데, 그렇게 하기 위해서는 그래프를 좌우로 뒤집어주어야 한다. (A, B, C가 왼쪽으로 오도록)

그러면 이렇게 되고, -1e7 정도의 값으로 pri 노드에 유량을 흘려주면, 최소 비용으로 유량이 흐르므로 pri 노드의 3의 유량은 무조건 A, B, C 각각에 1씩 흐르게 된다.

이들이 우선적으로 배정이 되고, 그 다음 나머지 유량들이 흐르므로 원하는 결과를 얻을 수 있게 된다.

마지막에는 3e7을 더해준 뒤 마이너스 붙여서 답을 구해주면 된다.

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

struct MCMF {
	// referred to the jhnah917's implementation (purpose of study)

    struct se { int num, cap, sco, ord; };
    vector<vector<se>> adj;

    void edge(int a, int b, int c, int d) {
        adj[a].push_back({b, c, d, adj[b].size()});
        adj[b].push_back({a, 0, -d, adj[a].size()-1});
    }

    int sour, sink;
    vector<int> tco, idx;
    vector<bool> chk;

    int dfs(int x, int flo) {
        chk[x] = true;

        if(x == sink) return flo;

        for(; idx[x] < adj[x].size(); idx[x]++) {
            se &ad = adj[x][idx[x]];

            if(chk[ad.num] || tco[x] + ad.sco != tco[ad.num] || ad.cap == 0) continue;

            int ret = dfs(ad.num, min(flo, ad.cap));

            if(ret == 0) continue;

            ad.cap -= ret;
            adj[ad.num][ad.ord].cap += ret;

            return ret;
        }

        return 0;
    }

    pair<int, int> mcmf(int sour_, int sink_) {
        sour = sour_, sink = sink_;

        int minc = 0, maxf = 0;

        tco.resize(adj.size(), INT_MAX);
        tco[sour] = 0;

        queue<int> q;
        q.push(sour);

        vector<bool> inq(adj.size());
        inq[sour] = true;

        while(!q.empty()) {
            int x = q.front();
            q.pop(); inq[x] = false;

            for(int i=0; i<adj[x].size(); i++) {
                int y = adj[x][i].num;
                int cap = adj[x][i].cap;
                int sco = adj[x][i].sco;

                if(cap <= 0 || tco[x] + sco >= tco[y]) continue;

                tco[y] = tco[x] + sco;

                if(inq[y]) continue;

                q.push(y);
                inq[y] = true;
            }
        }

        while(true) {
            chk.clear(); chk.resize(adj.size());
            idx.clear(); idx.resize(adj.size());

            while(true) {
                int cur = dfs(sour, INT_MAX);
                if(cur == 0) break;

                minc += tco[sink] * cur;
                maxf += cur;

                chk.clear(); chk.resize(adj.size());
            }

            int Min = INT_MAX;

            for(int i=0; i<adj.size(); i++) {
                if(!chk[i]) continue;

                for(int j=0; j<adj[i].size(); j++) {
                    int x = adj[i][j].num;
                    int cap = adj[i][j].cap;
                    int sco = adj[i][j].sco;

                    if(cap > 0 && !chk[x]) Min = min(Min, tco[i] + sco - tco[x]);
                }
            }

            if(Min == INT_MAX) break;

            for(int i=0; i<adj.size(); i++)
                if(!chk[i]) tco[i] += Min;
        }

        return {minc, maxf};
    }
};

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

    int N; cin >> N;

    MCMF f;

    int S = N+8;
    f.adj.resize(S);

    int sour = S-1, sink = S-2, pri = S-3, ext = S-4;

    f.edge(sour, pri, 3, -1e7);
    f.edge(sour, ext, INT_MAX, 0);

    for(int i=1; i<=3; i++) {
        int x; cin >> x;

        f.edge(sour, N+i, x-1, 0);
        f.edge(pri, N+i, 1, 0);
    }

    for(int i=1; i<=N; i++) {
        for(int j=1; j<=3; j++) {
            int x; cin >> x;

            f.edge(N+j, i, 1, -x);
        }

        f.edge(ext, i, 1, 0);
        f.edge(i, sink, 1, 0);
    }

    pair<int, int> mcmf = f.mcmf(sour, sink);

    int minc = mcmf.first;
    int maxf = mcmf.second;

    int ans = -(minc + 1e7 * 3);

    cout << ans << "\n";
}

백준 BOJ 7154번 : Job Postings

문제 난이도 : Platinum III

알고리즘 분류 : MCMF (최소 비용 최대 유량)

이 문제는 어렵지는 않은데 누가 질문글을 올렸고 구글링해봐도 풀이가 없길래 간단하게 그래프와 풀이 코드만 첨부한다.

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

struct se {
    int num, cap, sco, ord;

    se(int num, int cap, int sco, int ord) : num(num), cap(cap), sco(sco), ord(ord) {}
};

vector<vector<se>> adj;
int maxf, minc;

void edge(int a, int b, int c, int d) {
    adj[a].emplace_back(b, c, d, adj[b].size());
    adj[b].emplace_back(a, 0, -d, adj[a].size()-1);
}

void mcmf(int sour, int sink) {
    while(true) {
        vector<int> pre(adj.size(), -1), idx(adj.size(), -1);

        vector<int> tco(adj.size(), INT_MAX);
        tco[sour] = 0;

        queue<int> q;
        q.push(sour);

        vector<bool> inq(adj.size());
        inq[sour] = true;

        while(!q.empty()) {
            int x = q.front();
            q.pop();
            inq[x] = false;

            for(int i=0; i<adj[x].size(); i++) {
                int y = adj[x][i].num;
                int cap = adj[x][i].cap;
                int sco = adj[x][i].sco;

                if(cap <= 0 || tco[x] + sco >= tco[y]) continue;

                tco[y] = tco[x] + sco;
                pre[y] = x;
                idx[y] = i;

                if(inq[y]) continue;

                q.push(y);
                inq[y] = true;
            }
        }
        if(pre[sink] == -1) break;

        int sfl = INT_MAX;

        for(int i=sink; i!=sour; i=pre[i]) {
            int a = pre[i], b = idx[i];

            sfl = min(sfl, adj[a][b].cap);
        }

        for(int i=sink; i!=sour; i=pre[i]) {
            int a = pre[i], b = idx[i];

            adj[a][b].cap -= sfl;
            adj[i][adj[a][b].ord].cap += sfl;

            minc += sfl * adj[a][b].sco;
        }

        maxf += sfl;
    }
}

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

    while(true) {
        int N, M; cin >> M >> N;
        if(N == 0 && M == 0) break;

        adj.clear();
        adj.resize(N+M+3);

        int sour = N+M+1, sink = N+M+2;

        for(int i=1; i<=M; i++) {
            int x; cin >> x;

            edge(N+i, sink, x, 0);
        }

        for(int i=1; i<=N; i++) {
            edge(sour, i, 1, 0);

            int a; cin >> a;

            for(int j=0; j<4; j++) {
                int b; cin >> b;

                edge(i, N+b+1, 1, -(a*4-j));
            }
        }

        maxf = minc = 0;

        mcmf(sour, sink);

        cout << -minc << "\n";
    }
}

백준 BOJ 1650번 : 지민이의 테러 Season II

문제 난이도 : Platinum III

알고리즘 분류 : MCMF (최소 비용 최대 유량)

같은 길을 두 번 지나가지 않되 1번 노드에서 N번 노드 사이를 왕복하는 최소 비용을 구하는 문제이다.

간선의 방향이 양방향인 경우 반대로 갈 때 마이너스 비용 처리를 하기 애매하므로 노드를 분할하여 in, out을 따로 처리해주면 된다.

그리고 이 문제에서는 왕복 비용을 구하라고 하였으므로 유량을 2만큼 흘려주면 된다.

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

struct se {
    int num, cap, sco, ord;

    se(int num, int cap, int sco, int ord) : num(num), cap(cap), sco(sco), ord(ord) {}
};

vector<vector<se>> adj;
int maxf, minc;

void edge(int a, int b, int c, int d) {
    adj[a].emplace_back(b, c, d, adj[b].size());
    adj[b].emplace_back(a, 0, -d, adj[a].size()-1);
}

void mcmf(int sour, int sink) {
    while(true) {
        vector<int> pre(adj.size(), -1), idx(adj.size(), -1);

        vector<int> tco(adj.size(), INT_MAX);
        tco[sour] = 0;

        queue<int> q;
        q.push(sour);

        vector<bool> inq(adj.size());
        inq[sour] = true;

        while(!q.empty()) {
            int x = q.front();
            q.pop();
            inq[x] = false;

            for(int i=0; i<adj[x].size(); i++) {
                int y = adj[x][i].num;
                int cap = adj[x][i].cap;
                int sco = adj[x][i].sco;

                if(cap <= 0 || tco[x] + sco >= tco[y]) continue;

                tco[y] = tco[x] + sco;
                pre[y] = x;
                idx[y] = i;

                if(inq[y]) continue;

                q.push(y);
                inq[y] = true;
            }
        }
        if(pre[sink] == -1) break;

        int sfl = INT_MAX;

        for(int i=sink; i!=sour; i=pre[i]) {
            int a = pre[i], b = idx[i];

            sfl = min(sfl, adj[a][b].cap);
        }

        for(int i=sink; i!=sour; i=pre[i]) {
            int a = pre[i], b = idx[i];

            adj[a][b].cap -= sfl;
            adj[i][adj[a][b].ord].cap += sfl;

            minc += sfl * adj[a][b].sco;
        }

        maxf += sfl;
    }
}

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

    int N, M; cin >> N >> M;

    adj.clear();
    adj.resize(N*2 + 3);

    int sour = N*2 + 1, sink = N*2 + 2;

    edge(sour, 1, 2, 0);
    edge(N+N, sink, 2, 0);

    for(int i=1; i<=N; i++) edge(i, N+i, INT_MAX, 0);

    while(M--) {
        int a, b, c; cin >> a >> b >> c;

        edge(N+a, b, 1, c);
        edge(N+b, a, 1 ,c);
    }

    maxf = 0, minc = 0;

    mcmf(sour, sink);

    cout << minc << "\n";
}

11월 알고리즘 공부 : 최소 외접원/구, 가장 가까운 두 점, 번사이드 보조정리 등

restudy — Tue, 22 Nov 2022 21:34:59 +0900

최근 글 작성 빈도가 현저히 낮아졌는데, 바쁘다거나 그런 이유보다는 2022년 막바지로 갈수록 의욕이 떨어져간다는 표현이 맞는 것 같다.

그래도 아직 백준에서 2022년 푼 문제 수 랭킹 1위를 유지하고 있기 때문에 최소한 유종의 미라도 거두기 위해 연말까지는 열심히 풀어보려고 한다.

아무튼 11월 중순동안 공부한 내용들을 나중에 스스로 참고할 수 있도록 정리해보려고 한다.

백준 BOJ 2626번 : 헬기착륙장

문제 난이도 : Diamond V

알고리즘 분류 : 최소 외접원

2차원 좌표 평면 상의 N개의 점이 주어질 때 이들을 모두 포함하는 가장 작은 원의 중심과 반지름을 구하는 문제이다.

세 점을 지나는 원이 반드시 존재함을 이용하여 풀이하는 문제이다. (여담으로, 타원의 경우 최대 다섯 개의 점을 지나는 타원이 반드시 존재한다. 어떤 점을 잡아도 무조건 지나는 원이 있으려면 3개의 점이 최대이고, 구의 경우에는 4개이다.)

아래와 같이 3중 for문을 이용하여 가장 바깥쪽의 세 점을 지나는 원을 구해주면 된다.

세 점을 지나는 원의 중심 좌표에 대한 식은 문제에서 알려준다.

3중 for문이므로 시간 복잡도가 O(N^3)처럼 보이지만, 실제로는 어떤 점이 현재 구한 원을 벗어나야만 for문 내부의 코드가 작동하므로 실질적인 작동 시간은 O(N)에 가깝다고 한다.

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

struct p { double x, y; };

double dis(p a, p b) {
    return sqrt(pow(a.x - b.x, 2) + pow(a.y - b.y, 2));
}

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

    cout << fixed;
    cout.precision(3);

    int N; cin >> N;

    vector<p> v(N);
    for(int i=0; i<N; i++) cin >> v[i].x >> v[i].y;

    p cen = {0, 0};
    double r = 0;

    for(int i=0; i<N; i++) {
        if(dis(cen, v[i]) <= r) continue;

        cen = v[i], r = 0;

        for(int j=0; j<i; j++) {
            if(dis(cen, v[j]) <= r) continue;

            cen = {(v[i].x + v[j].x) / 2, (v[i].y + v[j].y) / 2};
            r = dis(cen, v[i]);

            for(int k=0; k<j; k++) {
                if(dis(cen, v[k]) <= r) continue;

                cen.x = ((pow(v[j].x, 2) - pow(v[k].x, 2) + pow(v[j].y, 2) - pow(v[k].y, 2)) * (v[i].y - v[j].y)
                         - (pow(v[j].x, 2) - pow(v[i].x, 2) + pow(v[j].y, 2) - pow(v[i].y, 2)) * (v[k].y - v[j].y))
                         / ((v[i].x - v[j].x) * (v[k].y - v[j].y) * 2 - (v[k].x - v[j].x) * (v[i].y - v[j].y) * 2);
                cen.y = ((pow(v[j].y, 2) - pow(v[k].y, 2) + pow(v[j].x, 2) - pow(v[k].x, 2)) * (v[i].x - v[j].x)
                         - (pow(v[j].y, 2) - pow(v[i].y, 2) + pow(v[j].x, 2) - pow(v[i].x, 2)) * (v[k].x - v[j].x))
                         / ((v[i]. y- v[j].y) * (v[k].x - v[j].x) * 2 - (v[k].y - v[j].y) * (v[i].x - v[j].x) * 2);
                r = dis(cen, v[i]);
            }
        }
    }

    if(abs(cen.x) < 1e-4) cen.x = 0;
    if(abs(cen.y) < 1e-4) cen.y = 0;

    cout << cen.x << " " << cen.y << "\n";
    cout << r << "\n";
}

이 문제를 풀이하면 거의 비슷한 코드로 다음의 문제들을 풀 수 있다.

백준 BOJ 2389번 : 세상의 중심에서... (Platinum I)

백준 BOJ 13708번 : 모든 점을 포함하는 원 (Platinum I)

백준 BOJ 21182번 : Weird Flecks, But OK (Platinum I)

백준 BOJ 10517번 : Radar Coverage (Gold III)

풀이 코드는 거의 비슷하므로 생략한다.

백준 BOJ 11930번 : Smallest Enclosing Sphere

문제 난이도 : Diamond V

알고리즘 분류 : 최소 외접원, 3차원 기하학

3차원 좌표 상의 N개의 점이 주어질 때, 이 점들을 모두 포함하는 가장 작은 구의 반지름을 구하는 문제이다.

위 문제의 풀이를 확장시키면 풀이할 수 있지만, 식의 구현이 매우 복잡하다.

실제로 나와 같은 방식으로 휴리스틱 없이 풀이한 사람은 1명인 것으로 확인된다. (실행 시간이 0ms에 가까워야 함)

식으로 이 문제를 풀기 위해서는 다음의 2가지 식이 필요하다.

(1) 3차원 좌표 상에서 3개의 점을 지나는 원의 중심을 구하는 공식

(2) 3차원 좌표 상에서 4개의 점을 지나는 구의 중심을 구하는 공식

이들은 모두 행렬 식을 이용하여 풀이할 수 있는데, 역행렬을 구하는 과정이나 행렬 곱을 구하는 과정이 매우 복잡해서 자세한 설명은 아래의 코드로 대체한다.

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

struct p { double x, y, z; };

double dis(p a, p b) {
    return sqrt(pow(a.x - b.x, 2) + pow(a.y - b.y, 2) + pow(a.z - b.z, 2));
}

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

    cout << fixed;
    cout.precision(2);

    int N; cin >> N;

    vector<p> v(N);
    for(int i=0; i<N; i++) cin >> v[i].x >> v[i].y >> v[i].z;

    p cen = {0, 0, 0};
    double r = 0;

    for(int i=0; i<N; i++) {
        if(dis(cen, v[i]) <= r) continue;

        cen = v[i], r = 0;

        for(int j=0; j<i; j++) {
            if(dis(cen, v[j]) <= r) continue;

            cen = {(v[i].x + v[j].x) / 2, (v[i].y + v[j].y) / 2, (v[i].z + v[j].z) / 2};
            r = dis(cen, v[i]);

            for(int k=0; k<j; k++) {
                if(dis(cen, v[k]) <= r) continue;

                double ax = v[i].x, ay = v[i].y, az = v[i].z;
                double bx = v[j].x, by = v[j].y, bz = v[j].z;
                double cx = v[k].x, cy = v[k].y, cz = v[k].z;

                double Cx = bx - ax, Cy = by - ay, Cz = bz - az;
                double Bx = cx - ax, By = cy - ay, Bz = cz - az;

                double B2 = ax*ax - cx*cx + ay*ay - cy*cy + az*az - cz*cz;
                double C2 = ax*ax - bx*bx + ay*ay - by*by + az*az - bz*bz;

                double CByz = Cy*Bz - Cz*By;
                double CBxz = Cx*Bz - Cz*Bx;
                double CBxy = Cx*By - Cy*Bx;

                double zz1 = - (Bz - Cz*Bx/Cx) / (By - Cy*Bx/Cx);
                double z01 = - (B2 - Bx/Cx*C2) / ((By - Cy*Bx/Cx) * 2);
                double zz2 = - (zz1*Cy + Cz) / Cx;
                double z02 = - (z01*Cy*2 + C2) / (Cx * 2);

                cen.z = - ((z02 - ax) * CByz - (z01 - ay) * CBxz - az * CBxy) / (zz2 * CByz - zz1 * CBxz + CBxy);
                cen.x = zz2 * cen.z + z02;
                cen.y = zz1 * cen.z + z01;

                r = dis(cen, v[i]);

                for(int l=0; l<k; l++) {
                    if(dis(cen, v[l]) <= r) continue;

                    double x1 = v[i].x, x2 = v[j].x, x3 = v[k].x, x4 = v[l].x;
                    double y1 = v[i].y, y2 = v[j].y, y3 = v[k].y, y4 = v[l].y;
                    double z1 = v[i].z, z2 = v[j].z, z3 = v[k].z, z4 = v[l].z;

                    double a11 = x2 - x1, a12 = y2 - y1, a13 = z2 - z1;
                    double a21 = x3 - x2, a22 = y3 - y2, a23 = z3 - z2;
                    double a31 = x4 - x1, a32 = y4 - y1, a33 = z4 - z1;

                    double det = a11 * (a22*a33 - a23*a32) - a12 * (a21*a33 - a23*a31) + a13 * (a21*a32 - a22*a31);

                    double c11 = a22*a33 - a32*a23, c12 = - (a12*a33 - a32*a13), c13 = a12*a23 - a22*a13;
                    double c21 = - (a21*a33 - a31*a23), c22 = a11*a33 - a31*a13, c23 = - (a11*a23 - a21*a13);
                    double c31 = a21*a32 - a31*a22, c32 = - (a11*a32 - a31*a12), c33 = a11*a22 - a21*a12;

                    double xx = x2*x2 - x1*x1 + y2*y2 - y1*y1 + z2*z2 - z1*z1;
                    double yy = x3*x3 - x2*x2 + y3*y3 - y2*y2 + z3*z3 - z2*z2;
                    double zz = x4*x4 - x1*x1 + y4*y4 - y1*y1 + z4*z4 - z1*z1;

                    cen.x = (c11*xx + c12*yy + c13*zz) / (det * 2);
                    cen.y = (c21*xx + c22*yy + c23*zz) / (det * 2);
                    cen.z = (c31*xx + c32*yy + c33*zz) / (det * 2);

                    r = dis(cen, v[i]);
                }
            }
        }
    }

    if(abs(cen.x) < 1e-4) cen.x = 0;
    if(abs(cen.y) < 1e-4) cen.y = 0;
    if(abs(cen.z) < 1e-4) cen.z = 0;

    // cout << cen.x << " " << cen.y << " " << cen.z << "\n";
    cout << r << "\n";
}

백준 BOJ 6567번 : Let it Bead

문제 난이도 : Platinum V

알고리즘 분류 : 조합론, 번사이드 보조정리

N개의 원형으로 배치된 구슬을 M개의 색을 이용하여 칠하고, 이들을 회전시키거나 뒤집었을 때 같은 색 배치인 것은 동일한 것으로 판단할 때 가능한 조합이 몇 개인지 구하는 문제이다.

번사이드 보조정리에 대해서 배울 수 있는 연습 문제이다.

원리는 다음과 같다.

어떤 원형의 구슬의 조합으로 가능한 것을 하나 만들었다고 할 때, 예를 들어 이것이 RBRB로 2칸 회전시켰을 때마다 동일한 형태가 나온다면 중복을 제거하지 않고 2번 count 되도록 해준 뒤, 마지막에 N = 4로 나누어 한 번만 count 되도록 하는 것이다. (RBRB에서 2번, BRBR에서 2번 count 되고 이것을 4로 나누면 RBRB 1개만 count가 되므로 옳게 세어졌다는 것을 알 수 있다.)

다만 이 문제는 여기서 끝이 아니라 뒤집었을 때 같은 것도 동일한 것으로 판단하므로, 뒤집은 형태까지 모두 고려해주되 2N번씩 count 되도록 해주어야 한다.

따라서 뒤집었을 때 동일한 것 = 대칭이어야 하므로 대칭 형태인 것들의 개수를 세어주어서 총 count에 이것들까지 중복이 되도록 더해준 뒤 2N으로 나누어 답을 구해야 한다.

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

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

    while(true) {
        int N, M; cin >> M >> N;
        if(N == 0 && M == 0) break;

        int ans = 0;

        for(int i=1; i<=N; i++) ans += pow(M, __gcd(N, i));

        if(N % 2 == 0) ans += (N / 2) * (pow(M, N/2) + pow(M, N/2 + 1));
        else ans += N * pow(M, (N + 1)/2);

        ans /= (N * 2);

        cout << ans << "\n";
    }
}

백준 BOJ 2261번 : 가장 가까운 두 점

문제 난이도 : Platinum II

알고리즘 분류 : 기하학, 분할 정복

2차원 좌표 평면 위에 N개의 점이 주어질 때, 가장 가까운 두 점 사이의 거리의 제곱을 구하는 문제이다.

가장 먼 두 점은 컨벡스 헐 + 회전하는 캘리퍼스로 구현이 가능하지만 가장 가까운 두 점은 어떻게 구할까?

방법은 바로 분할 정복을 이용하는 것이다.

점들을 x 좌표를 기준으로 오름차순 정렬을 해준 뒤, 가운데 점을 기준으로 분할 정복을 통해 최소 거리의 점을 찾는다.

분할 정복을 통해 구하는 과정에서 왼쪽 그룹의 점과 오른쪽 그룹의 점을 각각 선택하여 얻어지는 거리는 확인하지 않았으므로, 현재까지 구한 최소 거리보다 중점으로부터 가까운 점들을 모두 벡터에 넣고 가능한 조합들을 모두 검사해본다.

이 때 시간 초과를 방지하기 위해 벡터에 저장된 점들을 y 좌표를 기준으로 정렬한 뒤 이중 for문을 돌리는 과정에서 두 점의 y 좌표의 차이가 Min 값 이상이 되면 즉시 break문을 사용하여 불필요한 값의 비교가 최소화되도록 해주어야한다.

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

struct s { int x, y; };

bool cmpx(s a, s b) {
    if(a.x != b.x) return a.x < b.x;
    else return a.y < b.y;
}

bool cmpy(s a, s b) {
    if(a.y != b.y) return a.y < b.y;
    else return a.x < b.x;
}

int dis(s a, s b) {
    return pow(a.x - b.x, 2) + pow(a.y - b.y, 2);
}

vector<s> v;

int f(int l, int r) {
    if(l == r) return LLONG_MAX;
    if(l+1 == r) return dis(v[l], v[r]);

    int m = (l + r) / 2;
    int Min = min({dis(v[l], v[r]), f(l, m), f(m+1, r)});

    vector<s> u;
    int cen = v[m].x;

    for(int i=l; i<=r; i++)
        if(pow(v[i].x - cen, 2) < Min) u.push_back(v[i]);

    sort(u.begin(), u.end(), cmpy);

    for(int i=0; i<u.size(); i++)
        for(int j=i+1; j<u.size(); j++) {
            if(pow(u[i].y - u[j].y, 2) >= Min) break;

            if(pow(u[i].x - u[j].x, 2) < Min) Min = min(Min, dis(u[i], u[j]));
        }

    return Min;
}

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

    int N; cin >> N;

    v.resize(N);
    for(int i=0; i<N; i++) cin >> v[i].x >> v[i].y;

    sort(v.begin(), v.end(), cmpx);

    int ans = f(0, N-1);

    cout << ans << "\n";
}

백준 BOJ 26003번 : Lowest Latency

문제 난이도 : 난이도 정보 없음

알고리즘 분류 : 정보 없음

0 ≤ x, y, z < 10^9인 점이 무작위로 10^5개가 주어질 때, 가장 가까운 두 점 사이의 거리를 구하는 문제이다.

이러한 상황에서는 어떻게 구해야할까?

위의 가장 가까운 두 점 문제와 같은 방법으로 분할 정복을 이용한 구현이 가능하겠지만, 3차원 상의 점들이기 때문에 구현이 훨씬 복잡할 것이다.

이 문제에서는 점의 위치가 무작위로 주어진다는 점에 주목해야 한다.

가장 간단한 해결책은 점의 위치가 무작위라는 것은 이들이 상당히 균일한 분포를 가지고 있고, 따라서 대략적으로 계산했을 때 넉넉잡아 답이 최소한 10^6은 넘어간다는 것이다.

따라서 점들을 x 좌표를 기준으로 정렬했을 때 v[i]와 v[i+1] ~ v[i+100] 정도만 비교해줘도 확률적으로 그 안에는 무조건 답이 있음을 유추할 수 있다는 것이다.

따라서 O(N log N) 시간에 정렬을 수행하고, O(100 N) 시간에 탐색을 수행할 수 있으므로 충분히 짧은 시간에 답을 구할 수 있다.

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

struct s { int x, y, z; };

bool cmp(s a, s b) {
    return a.x < b.x;
}

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

    cout << fixed;
    cout.precision(6);

    int N; cin >> N;

    vector<s> v(N);
    for(int i=0; i<N; i++) cin >> v[i].x >> v[i].y >> v[i].z;

    sort(v.begin(), v.end(), cmp);

    double ans = DBL_MAX;

    for(int i=0; i<N; i++)
        for(int j=i+1; j<i+100 && j<N; j++) {
            double dis = sqrt(pow(v[i].x - v[j].x, 2) + pow(v[i].y - v[j].y, 2) + pow(v[i].z - v[j].z, 2));

            ans = min(ans, dis);
        }

    cout << ans << "\n";
}

백준 BOJ 22940번 : 선형 연립 방정식

문제 난이도 : Gold I

알고리즘 분류 : 가우스 소거법

가우스 소거법을 이용하여 N차 선형 연립 방정식의 해를 구하는 문제이다.

비교적 최근 문제로 출제되었고 전에 가우스 소거법을 구현할 줄 몰라서 풀지 못했던 문제가 기억나서 생각난 김에 구현해보았다.

다음과 같이 구현하면 거의 최소한의 코드로 가우스 소거법을 구현할 수 있다.

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

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

    int N; cin >> N;

    int M = N + 1;

    vector<vector<double>> v(N, vector<double>(M));

    for(int i=0; i<N; i++)
        for(int j=0; j<M; j++) cin >> v[i][j];

    for(int i=0; i<N; i++) {
        for(int j=0; j<N; j++) {
            double d = v[i][i], c = v[j][i] / v[i][i];

            for(int k=0; k<M; k++) {
                if(j == i) v[j][k] /= d;
                else v[j][k] -= c * v[i][k];
            }
        }
    }

    for(int i=0; i<N; i++) cout << v[i].back() << " ";
    cout << "\n";
}

참고로 아직 주어진 행렬에 대해 RREF와 같은 꼴을 만들도록 하는 코드는 구현하지 못했는데, 가까운 시일 내에 구현해볼 수 있도록 노력해보겠다.

백준 BOJ 26017번 : Guessing Game

문제 난이도 : Platinum II

알고리즘 분류 : 2-SAT

7일동안 각각 d_i개의 대회가 열리고, N명의 사람들이 매일 각 대회들 중 하나를 골라 승패 여부를 예상할 때, 마지막 2일동안의 승패 예상만 가지고 N명의 사람들을 모두 이길 수 있는지 여부를 구하는 문제이다.

다른 사람들은 1개 이하로 맞추고, 마지막 줄에 주어진 2개의 예측이 모두 맞으면 조건을 만족한다.

2-SAT를 이용해 문제를 풀이하기 위해 N명 각각에 대해 7C2개의 조합을 가지고 하나가 맞으면 다른 하나가 틀리게 되도록 N x 7C2개의 조건식을 만들 수 있다.

동시에 마지막 줄에 주어진 2개의 예측이 a, b라고 할 때 이들 또한 2-SAT 식의 절에 들어가야 하므로 ~a → a와 ~b → b 식을 추가해준 뒤 2-SAT를 돌려주면 된다.

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

vector<vector<int>> adj, scc;
vector<int> nnum, cnum;
int ncnt = 0, ccnt = 0;

stack<int> s;
vector<bool> ch;

int dfs(int x) {
    nnum[x] = ++ncnt;
    s.push(x);

    int tmp = nnum[x];

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(nnum[y] == 0) tmp = min(tmp, dfs(y));
        else if(!ch[y]) tmp = min(tmp, nnum[y]);
    }

    if(tmp == nnum[x]) {
        vector<int> v;
        ccnt++;

        while(true) {
            int y = s.top();
            s.pop();

            v.push_back(y);

            ch[y] = true;
            cnum[y] = ccnt;

            if(y == x) break;
        }

        sort(v.begin(), v.end());

        scc.push_back(v);
    }

    return tmp;
}

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

    int N; cin >> N;

    vector<int> add(8);
    for(int i=1; i<=7; i++) {
        cin >> add[i];

        add[i] += add[i-1];
    }

    int M = add[7];

    adj.resize(M*2);

    for(int i=0; i<N; i++) {
        vector<int> v(7);
        for(int j=0; j<7; j++) {
            cin >> v[j];

            if(v[j] > 0) v[j] += add[j];
            else v[j] -= add[j];
        }

        for(int j=0; j<7; j++)
            for(int k=j+1; k<7; k++) {
                int a = -v[j], b = -v[k];

                if(a < 0) a = (-a)*2 - 2;
                else a = a*2 - 1;

                if(b < 0) b = (-b)*2 - 2;
                else b = b*2 - 1;

                int na, nb;

                if(a % 2 == 0) na = a + 1;
                else na = a - 1;

                if(b % 2 == 0) nb = b + 1;
                else nb = b - 1;

                adj[na].push_back(b);
                adj[nb].push_back(a);
            }
    }

    for(int i=0; i<2; i++) {
        int x; cin >> x;

        if(x > 0) x += add[5+i];
        else x -= add[5+i];

        if(x < 0) x = (-x)*2 - 2;
        else x = x*2 - 1;

        int nx;

        if(x % 2 == 0) nx = x + 1;
        else nx = x - 1;

        adj[nx].push_back(x);
    }

    nnum.resize(M*2);
    cnum.resize(M*2);
    ch.resize(M*2);

    for(int i=0; i<M*2; i++)
        if(nnum[i] == 0) dfs(i);

    bool check = true;

    for(int i=0; i<M; i++) {
        if(cnum[i*2] == cnum[i*2 + 1]) {
            check = false;
            break;
        }
    }

    if(check) cout << "possible\n";
    else cout << "impossible\n";
}

백준 BOJ 26012번 : Breeding Bugs

문제 난이도 : Platinum III

알고리즘 분류 : 이분 매칭, 에라토스테네스의 체

N개의 수가 주어질 때 어떤 두 수를 골라도 그 합이 소수가 되지 않도록 하는 집합의 최대 크기를 구하는 문제이다.

2를 제외한 모든 소수는 홀수이므로, 수들을 짝수와 홀수로 나누어 최대 독립 집합의 크기를 구해주면 된다.

최대 독립 집합의 크기 = N - 최대 매칭이라는 공식이 있으므로, 이분 매칭으로 문제를 풀어주면 된다.

예외 처리로 2가 나오지 않으려면 1이 1개 이하로 집합에 포함되면 된다.

소수 판별을 빨리 하기 위해 에라토스테네스의 체를 이용해주면 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int Max = 2e7;

    vector<bool> p(Max, true);
    p[1] = false;

    for(int i=2; i*i<Max; i++)
        for(int j=2; i*j<Max; j++) p[i*j] = false;


    int N; cin >> N;

    vector<int> v, u;
    bool one = false;

    while(N--) {
        int x; cin >> x;

        if(x == 1) {
            if(!one) {
                v.push_back(x);
                one = true;
            }

            continue;
        }

        if(x % 2 == 1) v.push_back(x);
        else u.push_back(x);
    }

    adj.resize(v.size());

    for(int i=0; i<v.size(); i++)
        for(int j=0; j<u.size(); j++)
            if(p[v[i] + u[j]]) adj[i].push_back(j);

    l.resize(v.size(), -1);
    r.resize(u.size(), -1);

    int match = 0;

    for(int i=0; i<v.size(); i++) {
        vis.clear();
        vis.resize(v.size());

        if(f(i)) match++;
    }

    int ans = v.size() + u.size() - match;

    cout << ans << "\n";
}

백준 BOJ 26050번 : 수열의 합 2

문제 난이도 : Gold I

알고리즘 분류 : 정수론

주어진 N에 대해 N의 모든 약수 d1, ... , dk가 있을 때 a_n = (-1)^d1 + (-1)^d2 + ... + (-1)^dk라고 한다면 주어지는 s, t에 대해 a_s + ... + a_t의 값을 구하는 문제이다. 이 때 s, t ≤ 10^14이다.

s, t 범위가 크므로 O(sqrt(N)) 풀이를 찾아야 하는 문제이다.

먼저 a_1 + ... + a_N을 구하는 함수 f(N)를 구현하고 답은 f(t) - f(s-1)로 구해주면 된다.

약수 dk가 나타나는 횟수는 N / dk를 내림한 값이므로, (-1)^dk × (N / dk)의 시그마 값을 구해주면 된다.

원래 이렇게 풀면 O(N) 시간에 풀이가 가능한데, 시간을 더 줄여야한다.

발견할 수 있는 성질은 N의 약수는 O(sqrt(N)) 시간에 구할 수 있을 정도로 적으므로, N / dk 값들의 종류도 O(sqrt(N)) 시간에 구할 수 있다.

따라서 각 N / dk 값이 변화하는 구간을 찾고, 이 구간의 길이만큼의 값을 한번에 구해줄 수 있다.

자세한 내용은 아래의 풀이 코드를 참고하면 쉬울 것이다.

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

int f(int N) {
    vector<int> v, u;

    for(int i=1; i*i<=N; i++) {
        if(v.empty() || N/i != v.back()) {
            v.push_back(i);

            if(i != N/i) u.push_back(N/i);
        }
    }

    for(int i=u.size()-1; i>=0; i--) v.push_back(u[i]);

    int sum = (-1) * N;

    for(int i=1; i<v.size(); i++) {
        if((v[i] - v[i-1]) % 2 == 0) continue;

        sum += (v[i] % 2 == 0 ? 1 : -1) * (N / v[i]);
    }

    return sum;
}

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

    int a, b; cin >> a >> b;

    int ans = f(b) - f(a-1);

    cout << ans << "\n";
}

백준 BOJ 13738번 : Ghostbusters 2

문제 난이도 : Platinum II

알고리즘 분류 : 2-SAT, 이분 탐색

N개의 지점이 주어지고, 각 지점에서 상하 또는 좌우로 길이 x인 선분을 발사하여 같은 축에 있는 선분이 서로 겹치지 않게 하기 위한 x의 최댓값을 구하는 문제이다.

x를 임의로 정하고 서로 겹치는 것이 발생할 수 있는지를 검사하는 것은 가능하므로, 이분 탐색으로 접근하면 된다.

각 x에 대해서는 선분을 가로로 발사하면 true, 세로로 발사하면 false라고 생각하면 2-SAT 문제가 된다.

예를 들어 같은 가로축에 위치한 두 지점에 대해, 두 지점의 거리가 2x 이하이면 지점 a에서의 선분을 좌우로 선택했을 때 지점 b에서의 선분은 반드시 상하로 선택해야 하므로 a → not b가 되고, 마찬가지로 not b → a가 된다.

이런 식으로 여러 개의 절을 세워서 2-SAT 문제로 풀어주어 만약 가능한 상태가 존재한다면 l = m+1로, 그렇지 않다면 r = m-1로 설정하며 가능한 최댓값을 구해주면 된다.

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

vector<vector<int>> adj, scc;
vector<int> nnum, cnum;
int ncnt = 0, ccnt = 0;

stack<int> s;
vector<bool> ch;

int dfs(int x) {
    nnum[x] = ++ncnt;
    s.push(x);

    int tmp = nnum[x];

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(nnum[y] == 0) tmp = min(tmp, dfs(y));
        else if(!ch[y]) tmp = min(tmp, nnum[y]);
    }

    if(tmp == nnum[x]) {
        vector<int> v;
        ccnt++;

        while(true) {
            int y = s.top();
            s.pop();

            v.push_back(y);

            ch[y] = true;
            cnum[y] = ccnt;

            if(y == x) break;
        }

        sort(v.begin(), v.end());

        scc.push_back(v);
    }

    return tmp;
}

struct st { int x, y; };

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

    int N; cin >> N;

    vector<st> v(N+1);
    for(int i=1; i<=N; i++) cin >> v[i].x >> v[i].y;

    int l = 0, r = INT_MAX, ans = 0;

    while(l <= r) {
        int m = (l + r) / 2;

        adj.clear(); adj.resize(N*2);

        for(int i=1; i<=N; i++)
            for(int j=i+1; j<=N; j++) {
                int a = i, b = j;

                if(a < 0) a = (-a)*2 - 2;
                else a = a*2 - 1;

                if(b < 0) b = (-b)*2 - 2;
                else b = b*2 - 1;

                int na, nb;

                if(a % 2 == 0) na = a + 1;
                else na = a - 1;

                if(b % 2 == 0) nb = b + 1;
                else nb = b - 1;

                if(v[i].x == v[j].x && abs(v[i].y - v[j].y) <= m*2) {
                    adj[a].push_back(nb);
                    adj[b].push_back(na);
                }
                if(v[i].y == v[j].y && abs(v[i].x - v[j].x) <= m*2) {
                    adj[na].push_back(b);
                    adj[nb].push_back(a);
                }
            }

        nnum.clear(); nnum.resize(N*2);
        cnum.clear(); cnum.resize(N*2);
        ch.clear();   ch.resize(N*2);

        scc.clear();
        ncnt = ccnt = 0;

        for(int i=0; i<N*2; i++)
            if(nnum[i] == 0) dfs(i);

        bool check = true;

        for(int i=0; i<N; i++) {
            if(cnum[i*2] == cnum[i*2 + 1]) {
                check = false;
                break;
            }
        }

        if(check) {
            ans = max(ans, m);
            l = m + 1;
        }
        else r = m - 1;
    }

    if(ans < INT_MAX) cout << ans << "\n";
    else cout << "UNLIMITED\n";
}

백준 BOJ 17030번 : Cow Dating 풀이 (Diamond V, 투 포인터)

restudy — Sat, 12 Nov 2022 16:58:17 +0900

백준 BOJ 17030번 : Cow Dating

문제 난이도 : Diamond V

알고리즘 분류 : 투 포인터, 누적 합

N개의 선택받을 확률 p_i가 주어질 때 (실제 입력은 p_i의 10^6배를 한 값들로 주어진다.) 연속한 구간 p_l ~ p_r을 선택하여 그들 중 하나에게만 선택이 될 확률의 최댓값을 구하는 문제이다.

구간을 잡고 관계식을 찾는 것이 핵심이다.

구간 [l, r]에서의 확률이 이미 있을 때, 어떤 조건에서 구간을 늘렸을 때 확률이 늘어나는지 계산해보자.

구간 [l, r]에서 하나에게만 선택받을 확률 f(l, r)은 위의 식처럼 나타낼 수 있고, 거기에 항을 하나 추가하여 f(l, r+1)을 관계식으로 구할 수 있다.

그러면 f(l, r+1) > f(l, r)일 조건을 찾아주면 된다.

식을 풀어보면 p_i / (1 - p_i)의 구간 합이 1보다 작을 때와 동치이므로, [1, 1]에서 시작하여 해당 조건을 만족할 때 오른쪽 구간을 늘리고 그렇지 않으면 왼쪽 구간을 줄이는 식으로 투 포인터 알고리즘을 통해 O(N)에 풀이할 수 있다.

이 문제에서는 O(N^2) 풀이를 허용하지 않으므로 (N ≤ 60,000) 누적 합을 이용하여 O(1) 시간에 위의 시그마 식을 구해줄 수 있도록 해야한다.

또한 구간 곱을 사용하면 구간이 넓어질 때 값이 0에 수렴하여 오차가 발생하므로 앞에 곱해지는 곱은 매 반복문마다 갱신해서 구해주는 방식을 사용해주면 된다.

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

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

    int N; cin >> N;

    vector<double> v(N+1);

    for(int i=1; i<=N; i++) {
        cin >> v[i];

        v[i] *= 1e-6;
    }

    vector<double> u(N+1);

    for(int i=1; i<=N; i++)
        u[i] = u[i-1] + v[i] / (1 - v[i]);

    int i = 1, j = 1;
    double p = 1 - v[1], ans = 0;

    while(j <= N) {
        ans = max(ans, p * (u[j] - u[i-1]));

        if(u[j] - u[i-1] < 1) {
            j++;
            p *= (1 - v[j]);
        }
        else {
            i++;
            p /= (1 - v[i-1]);
        }
    }

    ans = (int)(ans * 1e6);

    cout << ans << "\n";
}

백준 BOJ 24486번 : Counting Haybales 풀이 (Diamond II, DP)

restudy — Thu, 10 Nov 2022 17:07:02 +0900

백준 BOJ 24486번 : Counting Haybales

문제 난이도 : Diamond II

알고리즘 분류 : DP

N개의 자연수가 주어지고, 크기 차이가 1인 인접한 두 수를 서로 swap할 수 있다고 할 때, 만들 수 있는 서로 다른 수열의 개수를 구하는 문제이다.

문제의 풀이는 USACO 사이트를 참고하였다.

먼저 관찰을 통해 알 수 있는 사실은 홀짝성이 같은 수들끼리는 순서가 바뀔 수 없다는 것이다.

(이것은 오직 크기 차이가 1인 인접한 두 수만 교환이 가능하므로, 홀짝성이 같은 = 크기가 2 이상 차이나는 수는 서로 위치가 바뀔 수 없기 때문이다.)

원래 정석적인 풀이는 이 사실을 이용하여 그래프의 단방향 간선들을 만들 수 있으므로, 위상 정렬로 푸는 풀이로 보인다.

아무튼 홀짝성을 활용하여 문제를 풀이하기 위해, dp[i][j]를 수열의 앞 부분 i+j개의 수들 중 i개의 짝수와 j개의 홀수가 나타나는 길이 i+j인 서로 다른 수열의 개수라고 하자.

이제 점화식을 만들기 위해 다음의 값들을 구해보자.

olp[j'] : inversion 불가능한 i'번째 홀수와 j'번째 짝수(홀수가 왼쪽)가 있을 때, j'번째 짝수에 대해 가능한 odd's leftmost position

elp[j'] : inversion 불가능한 i'번째 짝수와 j'번째 홀수(짝수가 왼쪽)가 있을 때, j'번째 홀수에 대해 가능한 even's leftmost position

(inversion 불가능하다는 것은 두 수의 차가 1보다 큰 경우를 의미한다.)

N이 5,000 이하로 충분히 작으므로 O(N^2) 시간에 이중 for문으로 모든 쌍들에 대해 검사하여 olp와 elp 값들을 구할 수 있다.

olp[j'] : j'번째(= num[j]) 짝수 왼쪽에 있을 수 있는 홀수의 가장 왼쪽 번호 (max로 갱신하면서 왼쪽 임계값을 오른쪽으로 좁혀나감)

elp[j'] : j'번째(= num[j]) 홀수 왼쪽에 있을 수 있는 짝수의 가장 왼쪽 번호 (max로 갱신하면서 왼쪽 임계값을 오른쪽으로 좁혀나감)

이제 모든 이제 모든 i번째 짝수와 j번째 홀수에 대해 O(even x odd) 시간에 dp값을 계산해주면 된다. (even : 짝수 개수, odd : 홀수 개수)

j번째 홀수가 olp[i] = i번째 짝수 왼쪽에 있을 수 있는 홀수의 가장 왼쪽 번호와 같거나 오른쪽에 있는 경우, dp[i][j] += dp[i-1][j]가 성립한다.

반대로 i번째 짝수가 elp[j] = j번째 홀수 왼쪽에 있을 수 있는 짝수의 가장 왼쪽 번호와 같거나 오른쪽에 있는 경우에도, dp[i][j] += dp[i][j-1]이 성립한다.

최종적으로는 dp[even][odd]가 답이 된다. (even : 짝수 개수, odd : 홀수 개수)

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

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

    int T; cin >> T;

    while(T--) {
        int N; cin >> N;

        vector<int> v(N), num(N);
        int e = 0, o = 0;

        for(int i=0; i<N; i++) {
            cin >> v[i];

            if(v[i] % 2 == 0) num[i] = ++e;
            else if(v[i] % 2 == 1) num[i] = ++o;
        }

        vector<int> olp(e+1), elp(o+1);

        for(int i=0; i<N; i++)
            for(int j=i+1; j<N; j++)
                if(v[i] % 2 != v[j] % 2 && abs(v[i] - v[j]) > 1) {
                    if(v[j] % 2 == 0) olp[num[j]] = max(olp[num[j]], num[i]);
                    if(v[j] % 2 == 1) elp[num[j]] = max(elp[num[j]], num[i]);
                }

        vector<vector<int>> dp(e+1, vector<int>(o+1));
        dp[0][0] = 1;

        int mod = 1e9 + 7;

        for(int i=0; i<=e; i++)
            for(int j=0; j<=o; j++) {
                if(i > 0 && j >= olp[i]) dp[i][j] = (dp[i][j] + dp[i-1][j]) % mod;
                if(j > 0 && i >= elp[j]) dp[i][j] = (dp[i][j] + dp[i][j-1]) % mod;
            }

        int ans = dp[e][o];

        cout << ans << "\n";
    }
}

여담으로 FFT를 활용하면 이 문제를 O(N log N) 시간에도 풀이가 가능하다고 한다.

백준 BOJ 10058번 : 센서 네트워크 풀이 (Ruby V, 이분 매칭)

restudy — Sat, 29 Oct 2022 10:16:46 +0900

백준에서 3600문제 넘게 풀면서 루비 난이도 문제를 처음으로 푼 기념으로 이 문제만 별개의 포스트로 정리해본다.

무려 월드 파이널 문제이며 그 해 문제 중에서도 solved.ac 기준으로 난이도가 가장 높은 문제이다.

백준 BOJ 10058번 : 센서 네트워크

문제 난이도 : Ruby V

알고리즘 분류 : 기하학, 이분 매칭

2차원 좌표 평면 상에 N개의 점이 주어질 때, 어떤 두 점의 거리도 M 이하가 되게 하는 점들의 집합의 최대 크기와 그 때의 점들의 번호 목록을 구하는 문제이다.

가장 naive하게 생각할 수 있는 풀이는 각 점을 집합에 포함시키거나 시키지 않은 뒤 해당 집합에서 가장 먼 두 점 사이의 거리가 M 이하라면 집합의 최대 크기를 비교하여 갱신해주는 방식이 있다.

이 때의 시간 복잡도는 최소 O(2^N) 이상이 되고, 당연히 시간 초과이다.

N ≤ 100으로 N의 제한이 매우 크지 않음에 주목하자.

임의의 두 점이 집합에서 가장 먼 두 점이라고 먼저 가정한 뒤, 이 집합에 포함될 수 있는 점들을 탐색한다면, 이중 for문 내에서 별개의 이중 for문을 더 돌려서 O(N^4)가 되어도 충분히 돌아간다.

따라서 두 점을 잡고 이 두 점 사이의 거리가 집합에서 가장 먼 두 점이 되도록 집합을 완성하여 답을 구해보자.

결정한 두 점이 A, B이고, 두 점 사이의 거리가 r ≤ M이라고 할 때, 점 A에서 반지름 r인 원과 점 B에서 반지름 r인 원을 그려서 그 교집합에 포함되는 점들이 집합에 포함될 수 있는 점들의 후보가 된다.

하지만 두 원의 교점 사이의 거리가 r보다 크므로 반례가 존재하게 된다. (예를 들면 위의 그림에서 선분 xy가 반례가 된다.)

여기서 핵심 아이디어가 필요하다.

교집합에 포함되는 점들을 선분 AB를 기준으로 위에 위치하는 점들과 아래에 위치하는 점들로 나눠보자.

실제로는 두 점 A, B가 x축에 평행하게 위치하지 않으므로, ccw를 사용하여 ccw 값을 0을 기준으로 두 부분으로 나누어 선분 AB를 기준으로 양쪽에 위치하는 점들로 나누면 된다.

그러면 같은 그룹에 속한 점들 사이의 거리는 반드시 r 이하이다.

따라서 점들을 위 그룹과 아래 그룹으로 나누어 거리가 r보다 큰 위의 점과 아래의 점 사이를 간선으로 연결하여 이분 그래프를 만들어주고, 여기서 이분 매칭을 수행하여 최대 매칭 수만큼 점들에서 빼주면 그것이 최종적인 집합의 크기가 된다. 즉, 이제 이 집합에는 어떤 두 점 사이의 거리도 r 이하가 된다.

문제는 집합의 크기는 위 그룹 + 아래 그룹 - 최대 매칭 수임을 알 수 있는데 일부 점을 뺄 때 어떤 점을 빼야하냐는 것이다. (최종적으로 점들의 번호를 구해야하므로)

여기서 최소 정점 커버에 대한 다음의 정리를 사용해야한다.

이분 그래프에서 왼쪽 정점 그룹을 L, 오른쪽 정점 그룹을 R이라고 하자.

이분 매칭이 수행된 이분 그래프에서 alternating path란 최대 매칭에 포함되는 간선과 포함되지 않는 간선을 번갈아가며 선택하면서 이동하는 경로를 말한다.

L의 최대 매칭에 포함되지 않는 점들에서 시작하여 alternating path로 도달할 수 있는 모든 정점들의 집합을 X라고 하자.

그러면 최소 정점 커버 = (L - X) ∪ (R ∩ X)이다.

이제 풀이가 끝났다. 풀이를 요약하면 다음과 같다.

1. 가능한 모든 두 점의 조합들 중 거리가 M 이하인 두 점에 대해 다음을 반복한다.

2. 두 점을 기준으로 반지름이 두 점 사이의 거리인 원을 그려 교집합에 들어오는 점들을, 두 점을 잇는 선분을 기준으로 ccw값의 부호에 따라 두 그룹으로 나눈다.

3. 거리가 r 이상인 점들 사이에 간선을 연결해주고 이분 매칭을 수행하여 최소로 지워야 하는 점의 수를 구하고, 집합의 크기를 구한다.

4. 집합의 원소를 구하기 위해 최소 정점 커버에 대한 정리를 사용하여 구해준다.

5. 이렇게 구한 집합들 중에서 크기가 가장 큰 것을 답으로 출력해주면 된다.

이것을 코드로 구현하면 다음과 같다.

아래는 정답 처리를 받은 풀이 코드이다.

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

struct s { double x, y; int n; };

double dis(s a, s b) {
    return sqrt(pow(a.x - b.x, 2) + pow(a.y - b.y, 2));
}

double ccw(s a, s b, s c) {
    return a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y);
}

vector<vector<int>> adj;
vector<int> ll, rr;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(rr[y] == -1 || (!vis[rr[y]] && f(rr[y]))) {
            ll[x] = y, rr[y] = x;

            return true;
        }
    }

    return false;
}

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

    int N; cin >> N;
    double M; cin >> M;

    vector<s> v(N);
    for(int i=0; i<N; i++) {
        cin >> v[i].x >> v[i].y;

        v[i].n = i+1;
    }

    vector<int> ans;
    ans.push_back(1);

    for(int i=0; i<N; i++)
        for(int j=i+1; j<N; j++) {
            double r = dis(v[i], v[j]);

            if(r > M) continue;

            vector<s> u, w;

            for(int k=0; k<N; k++) {
                if(dis(v[i], v[k]) > r || dis(v[j], v[k]) > r) continue;

                if(ccw(v[i], v[j], v[k]) >= 0) u.push_back(v[k]);
                else w.push_back(v[k]);
            }

            adj.clear();
            adj.resize(u.size());

            for(int k=0; k<u.size(); k++)
                for(int l=0; l<w.size(); l++)
                    if(dis(u[k], w[l]) > r) adj[k].push_back(l);

            ll.clear(); ll.resize(u.size(), -1);
            rr.clear(); rr.resize(w.size(), -1);

            int match = 0;

            for(int k=0; k<u.size(); k++) {
                vis.clear();
                vis.resize(u.size());

                if(f(k)) match++;
            }

            if(u.size() + w.size() - match <= ans.size()) continue;

            vector<bool> lvis(u.size()), rvis(w.size());

            for(int k=0; k<u.size(); k++) {
                if(ll[k] != -1 || lvis[k]) continue;

                lvis[k] = true;

                queue<pair<bool, int>> q;
                q.push({true, k});

                while(!q.empty()) {
                    bool isLeft = q.front().first;
                    int x = q.front().second;
                    q.pop();

                    if(isLeft) {
                        for(int l=0; l<adj[x].size(); l++) {
                            int y = adj[x][l];

                            if(ll[x] != y && !rvis[y]) {
                                rvis[y] = true;
                                q.push({false, y});
                            }
                        }
                    }
                    else {
                        for(int l=0; l<u.size(); l++) {
                            int y = l;

                            if(lvis[y]) continue;
                            if(count(adj[y].begin(), adj[y].end(), x) == 0) continue;

                            for(int m=0; m<adj[y].size(); m++) {
                                if(adj[y][m] != x) continue;

                                if(rr[x] == y) {
                                    lvis[y] = true;
                                    q.push({true, y});
                                }
                            }
                        }
                    }
                }
            }

            ans.clear();

            for(int k=0; k<u.size(); k++)
                if(lvis[k]) ans.push_back(u[k].n);

            for(int k=0; k<w.size(); k++)
                if(!rvis[k]) ans.push_back(w[k].n);
        }

    cout << ans.size() << "\n";

    for(int i=0; i<ans.size(); i++) cout << ans[i] << " ";
    cout << "\n";
}

이분 매칭 알고리즘 어려운 문제들 풀이 (Platinum II ~ Diamond)

restudy — Sun, 23 Oct 2022 12:31:15 +0900

백준 BOJ 3419번 : Racing Car Trail

문제 난이도 : Diamond III

알고리즘 분류 : 이분 매칭

N x M 크기의 배열이 주어지고, X가 없는 칸에서만 이동이 가능하다고 할 때, Alice와 Bob이 번갈아가면서 지나온 칸은 다시 이동하지 않도록 칸을 이동시키면서 상대가 더 이상 이동하지 못하도록 최선의 전략으로 이동시킨다고 할 때, 각 칸에서 시작할 때 누가 이기는지를 구하는 문제이다.

격자 그래프는 이분 그래프이므로 이분 매칭 알고리즘으로 최대 매칭을 구한 뒤, 시작점 v를 포함하지 않는 최대 매칭이 존재한다면 Bob이 항상 이길 수 있다.

왜냐하면 그러한 매칭이 존재하는 경우 Alice는 어떻게 이동해도 최대 매칭에 포함되는 정점으로 이동하게 되고, Bob은 그 격자점과 매칭되어있는 점을 따라서만 이동시키면 되기 때문이다.

만약 그러한 매칭이 존재하지 않는 경우 이번에는 Alice가 격자점과 매칭되어있는 점을 따라서 이동시키면 승리하게 된다.

N x M 모든 격자에 대해 그래프 연결을 다시 수행한 뒤 이분 매칭을 각각 돌리면 시간 초과가 발생하므로, 삭제한 뒤 새로 매칭을 찾는 격자점 한 칸에 대해서만 이분 매칭을 수행해주면 시간 초과를 피해 AC를 받을 수 있다.

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

vector<vector<int>> adj1, adj2;
vector<int> l1, r1, l2, r2;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj1[x].size(); i++) {
        int y = adj1[x][i];

        if(r1[y] == -1 || (!vis[r1[y]] && f(r1[y]))) {
            l1[x] = y, r1[y] = x;

            return true;
        }
    }

    return false;
}

bool g(int x) {
    vis[x] = true;

    for(int i=0; i<adj2[x].size(); i++) {
        int y = adj2[x][i];

        if(r2[y] == -1 || (!vis[r2[y]] && g(r2[y]))) {
            l2[x] = y, r2[y] = x;

            return true;
        }
    }

    return false;
}

vector<vector<int>> tadj;
vector<int> ll, rr;

bool h(int x) {
    vis[x] = true;

    for(int i=0; i<tadj[x].size(); i++) {
        int y = tadj[x][i];

        if(rr[y] == -1 || (!vis[rr[y]] && h(rr[y]))) {
            ll[x] = y, rr[y] = x;

            return true;
        }
    }

    return false;
}

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

    while(true) {
        int N, M; cin >> N >> M;
        if(N == 0 && M == 0) break;

        vector<vector<char>> v(N+1, vector<char>(M+1));

        for(int i=1; i<=N; i++)
            for(int j=1; j<=M; j++) cin >> v[i][j];

        int s = (N*M + 1) / 2;

        int di[4] = {1, -1, 0, 0};
        int dj[4] = {0, 0, 1, -1};

        adj1.clear();
        adj1.resize(s+1);

        for(int i=1; i<=N; i++)
            for(int j=!(i%2)+1; j<=M; j+=2) {
                if(v[i][j] != '.') continue;

                for(int k=0; k<4; k++) {
                    int ni = i + di[k];
                    int nj = j + dj[k];

                    if(ni < 1 || nj < 1 || ni > N || nj > M) continue;
                    if(v[ni][nj] != '.') continue;

                    adj1[((i-1)*M+j+1)/2].push_back(((ni-1)*M+nj+1)/2);
                }
            }

        l1.clear();
        l1.resize(s+1, -1);

        r1.clear();
        r1.resize(s+1, -1);

        for(int i=1; i<=s; i++) {
            vis.clear();
            vis.resize(s+1);

            f(i);
        }

        adj2.clear();
        adj2.resize(s+1);

        for(int i=1; i<=N; i++)
            for(int j=(i%2)+1; j<=M; j+=2) {
                if(v[i][j] != '.') continue;

                for(int k=0; k<4; k++) {
                    int ni = i + di[k];
                    int nj = j + dj[k];

                    if(ni < 1 || nj < 1 || ni > N || nj > M) continue;
                    if(v[ni][nj] != '.') continue;

                    adj2[((i-1)*M+j+1)/2].push_back(((ni-1)*M+nj+1)/2);
                }
            }

        l2.clear();
        l2.resize(s+1, -1);

        r2.clear();
        r2.resize(s+1, -1);

        for(int i=1; i<=s; i++) {
            vis.clear();
            vis.resize(s+1);

            g(i);
        }

        vector<vector<char>> w(v);

        for(int ii=1; ii<=N; ii++)
            for(int jj=1; jj<=M; jj++) {
                if(v[ii][jj] != '.') continue;

                int x = ((ii-1)*M+jj+1)/2;

                bool check = false;

                if((ii + jj) % 2 == 1 && r1[x] == -1) check = true;
                if((ii + jj) % 2 == 0 && r2[x] == -1) check = true;

                if(check) {
                    w[ii][jj] = 'B';
                    continue;
                }

                if((ii + jj) % 2 == 1) {
                    tadj.clear(); tadj = adj1;

                    for(int k=0; k<4; k++) {
                        int ni = ii + di[k];
                        int nj = jj + dj[k];

                        if(ni < 1 || nj < 1 || ni > N || nj > M) continue;
                        if(v[ni][nj] != '.') continue;

                        int y = ((ni-1)*M+nj+1)/2;

                        if(count(tadj[y].begin(), tadj[y].end(), x) > 0)
                            tadj[y].erase(remove(tadj[y].begin(), tadj[y].end(), x), tadj[y].end());
                    }

                    ll.clear(); ll = l1;
                    rr.clear(); rr = r1;

                    int z = rr[x];

                    ll[rr[x]] = -1;
                    rr[x] = -1;

                    vis.clear(); vis.resize(s+1);

                    if(h(z)) w[ii][jj] = 'B';
                    else w[ii][jj] = 'A';
                }
                if((ii + jj) % 2 == 0) {
                    tadj.clear(); tadj = adj2;

                    for(int k=0; k<4; k++) {
                        int ni = ii + di[k];
                        int nj = jj + dj[k];

                        if(ni < 1 || nj < 1 || ni > N || nj > M) continue;
                        if(v[ni][nj] != '.') continue;

                        int y = ((ni-1)*M+nj+1)/2;

                        if(count(tadj[y].begin(), tadj[y].end(), x) > 0)
                            tadj[y].erase(remove(tadj[y].begin(), tadj[y].end(), x), tadj[y].end());
                    }

                    ll.clear(); ll = l2;
                    rr.clear(); rr = r2;

                    vis.clear(); vis.resize(s+1);

                    int z = rr[x];

                    ll[rr[x]] = -1;
                    rr[x] = -1;

                    if(h(z)) w[ii][jj] = 'B';
                    else w[ii][jj] = 'A';
                }
            }

        for(int i=1; i<=N; i++) {
            for(int j=1; j<=M; j++) cout << w[i][j];
            cout << "\n";
        }
        cout << "\n";
    }
}

백준 BOJ 2051번 : 최소 버텍스 커버

문제 난이도 : Platinum II

알고리즘 분류 : 이분 매칭

이분 그래프가 주어질 때 최소 정점 커버에 해당하는 정점들의 목록을 구하는 문제이다.

중요한 문제이므로 위에다가 배치한다.

백준 BOJ 10058번 : 센서 네트워크 풀이 (난이도 Ruby V / 루비 5)

백준에서 3600문제 넘게 풀면서 루비 난이도 문제를 처음으로 푼 기념으로 이 문제만 별개의 포스트로 정리해본다. 무려 월드 파이널 문제이며 그 해 문제 중에서도 solved.ac 기준으로 난이도가 가

restudycafe.tistory.com

위 포스트의 중간에 정리된 정리를 사용하면 된다. (최소 정점 커버 = (L - X) ∪ (R ∩ X))

최소 정점 커버에 대한 엄밀한 증명은 kks227님의 블로그에 정리되어있다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int N, M; cin >> N >> M;

    adj.resize(N+1);

    for(int i=1; i<=N; i++) {
        int K; cin >> K;

        while(K--) {
            int x; cin >> x;

            adj[i].push_back(x);
        }
    }

    l.resize(N+1, -1);
    r.resize(M+1, -1);

    int match = 0;

    for(int i=1; i<=N; i++) {
        vis.clear();
        vis.resize(N+1);

        f(i);
    }

    vector<bool> lvis(N+1), rvis(M+1);

    for(int i=1; i<=N; i++) {
        if(l[i] != -1 || lvis[i]) continue;

        lvis[i] = true;

        queue<pair<bool, int>> q;
        q.push({true, i});

        while(!q.empty()) {
            bool isLeft = q.front().first;
            int x = q.front().second;
            q.pop();

            if(isLeft) {
                for(int j=0; j<adj[x].size(); j++) {
                    int y = adj[x][j];

                    if(l[x] != y && !rvis[y]) {
                        rvis[y] = true;
                        q.push({false, y});
                    }
                }
            }
            else {
                for(int j=1; j<=N; j++) {
                    int y = j;

                    if(lvis[y]) continue;
                    if(count(adj[y].begin(), adj[y].end(), x) == 0) continue;

                    for(int k=0; k<adj[y].size(); k++) {
                        if(adj[y][k] != x) continue;

                        if(r[x] == y) {
                            lvis[y] = true;
                            q.push({true, y});
                        }
                    }
                }
            }
        }
    }

    vector<int> v, u;

    for(int i=1; i<=N; i++)
        if(!lvis[i]) v.push_back(i);

    for(int i=1; i<=M; i++)
        if(rvis[i]) u.push_back(i);

    cout << v.size() + u.size() << "\n";

    cout << v.size() << " ";

    for(int i=0; i<v.size(); i++) cout << v[i] << " ";
    cout << "\n";

    cout << u.size() << " ";

    for(int i=0; i<u.size(); i++) cout << u[i] << " ";
    cout << "\n";
}

백준 BOJ 13980번 : Maximum Islands

문제 난이도 : Platinum II

알고리즘 분류 : 이분 매칭

N x M 크기의 배열이 주어지고, L은 땅, W은 물, C는 구름으로 가려져서 어떤 것인지 보이지 않는다고 했을 때, 상하좌우가 물로 분리된 땅 덩어리를 섬이라고 한다면 가능한 섬의 최댓값을 구하는 문제이다.

최대 정점 커버를 활용하여 이분 매칭으로 풀이할 수 있다.

L은 이미 땅이니 인접한 부분 중 C가 모두 물이라고 생각해도 가능한 최대 섬의 수에 영향을 주지 않는다.

따라서 인접한 부분에 L이 없는 C들을 가지고 이분 매칭을 수행하여 최대 매칭 수를 그러한 C들의 수에서 빼주면, 추가로 형성할 수 있는 최대 섬의 수가 된다. (최대 정점 커버 = 정점 수 - 최대 매칭 수라는 정리를 사용한 것이다.)

따라서 기존의 L은 DFS 등으로 탐색하여 섬의 수를 세어주고, 나머지는 이분 매칭으로 풀이해주면 된다.

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

int N, M;
vector<vector<char>> v;
vector<vector<bool>> lvis;

void g(int x, int y) {
    lvis[x][y] = true;

    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, 1, -1};

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

        if(nx < 1 || ny < 1 || nx > N || ny > M) continue;
        if(v[nx][ny] != 'L' || lvis[nx][ny]) continue;

        g(nx, ny);
    }
}

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    cin >> N >> M;

    v.resize(N+1, vector<char>(M+1));

    for(int i=1; i<=N; i++)
        for(int j=1; j<=M; j++) cin >> v[i][j];

    lvis.resize(N+1, vector<bool>(M+1));
    int lnd = 0;

    for(int i=1; i<=N; i++)
        for(int j=1; j<=M; j++)
            if(v[i][j] == 'L' && !lvis[i][j]) {
                g(i, j);
                lnd++;
            }

    vector<vector<bool>> u(N+1, vector<bool>(M+1));
    int cnt = 0;

    for(int i=1; i<=N; i++)
        for(int j=1; j<=M; j++) {
            if(v[i][j] != 'C') continue;

            int di[4] = {1, -1, 0, 0};
            int dj[4] = {0, 0, 1, -1};

            bool check = true;

            for(int k=0; k<4; k++) {
                int ni = i + di[k];
                int nj = j + dj[k];

                if(ni < 1 || nj < 1 || ni > N || nj > M) continue;
                if(v[ni][nj] == 'L') check = false;
            }

            if(check) {
                u[i][j] = true;
                cnt++;
            }
        }

    int s = (N*M + 1) / 2;

    adj.resize(s+1);

    for(int i=1; i<=N; i++)
        for(int j=!(i%2)+1; j<=M; j+=2) {
            if(!u[i][j]) continue;

            int di[4] = {1, -1, 0, 0};
            int dj[4] = {0, 0, 1, -1};

            for(int k=0; k<4; k++) {
                int ni = i + di[k];
                int nj = j + dj[k];

                if(ni < 1 || nj < 1 || ni > N || nj > M) continue;
                if(v[ni][nj] != 'C' || !u[ni][nj]) continue;

                adj[((i-1)*M+j+1)/2].push_back(((ni-1)*M+nj+1)/2);
            }
        }

    l.resize(s+1, -1);
    r.resize(s+1, -1);

    int match = 0;

    for(int i=1; i<=s; i++) {
        vis.clear();
        vis.resize(s+1);

        if(f(i)) match++;
    }

    int ans = lnd + cnt - match;

    cout << ans << "\n";
}

백준 BOJ 12428번 : 박테리아 (Large)

문제 난이도 : Platinum II

알고리즘 분류 : 이분 매칭

** 이 문제의 풀이 코드로 백준 BOJ 12427번 : 박테리아 (Small) 문제를 정답 처리 받을 수 있다.

N x M x K 크기의 배열이 주어질 때, K개의 각 층에서 상하좌우로 인접한 .은 하나의 방이고, 상하 모두 방인 칸끼리는 박테리아를 보관할 수 없다고 할 때, 최대 몇 개의 방에 박테리아를 보관할 수 있는지 구하는 문제이다.

먼저 DFS 또는 BFS로 각 층에 있는 방들에 번호를 매기고, 각 층에 대해 각 방 칸의 위 아래 칸에 방이 인접해있는지를 검사하여 해당 방의 번호들끼리 간선을 연결한다.

이 때 이분 그래프가 형성되어야 이분 매칭을 수행할 수 있으므로, 홀수번째 층과 짝수번째 층을 나누어 매칭해준다. (2층 이상 떨어진 칸은 절대로 인접할 수 없으므로 이분 그래프가 만들어진다.)

그 다음 이분 매칭을 수행해준 뒤 방의 수에서 매칭의 수를 빼주면 답이 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int T; cin >> T;

    for(int t=1; t<=T; t++) {
        int N, M, K; cin >> N >> M >> K;

        vector<vector<vector<int>>> v(K+1, vector<vector<int>>(N+1, vector<int>(M+1, -1)));

        for(int i=1; i<=K; i++)
            for(int j=1; j<=N; j++)
                for(int k=1; k<=M; k++) {
                    char ch; cin >> ch;

                    if(ch == '.') v[i][j][k] = 0;
                }

        int cnt = 0;

        for(int i=1; i<=K; i++)
            for(int j=1; j<=N; j++)
                for(int k=1; k<=M; k++) {
                    if(v[i][j][k] != 0) continue;

                    cnt++;
                    v[i][j][k] = cnt;

                    queue<pair<int, int>> q;
                    q.push({j, k});

                    vector<vector<bool>> vis(N+1, vector<bool>(M+1));
                    vis[j][k] = true;

                    while(!q.empty()) {
                        int x = q.front().first;
                        int y = q.front().second;
                        q.pop();

                        int dx[4] = {1, -1, 0, 0};
                        int dy[4] = {0, 0, 1, -1};

                        for(int l=0; l<4; l++) {
                            int nx = x + dx[l];
                            int ny = y + dy[l];

                            if(nx < 1 || ny < 1 || nx > N || ny > M) continue;
                            if(v[i][nx][ny] != 0) continue;

                            v[i][nx][ny] = cnt;
                            q.push({nx, ny});
                        }
                    }
                }

        adj.clear();
        adj.resize(cnt+1);

        for(int i=1; i<=K; i+=2)
            for(int j=1; j<=N; j++)
                for(int k=1; k<=M; k++) {
                    if(v[i][j][k] == -1) continue;

                    int dz[2] = {1, -1};

                    for(int l=0; l<2; l++) {
                        int nz = i + dz[l];

                        if(nz < 1 || nz > K) continue;
                        if(v[nz][j][k] == -1) continue;

                        adj[v[i][j][k]].push_back(v[nz][j][k]);
                    }
                }

        l.clear(); l.resize(cnt+1, -1);
        r.clear(); r.resize(cnt+1, -1);

        int match = 0;

        for(int i=1; i<=cnt; i++) {
            vis.clear();
            vis.resize(cnt+1);

            if(f(i)) match++;
        }

        int ans = cnt - match;

        cout << "Case #" << t << ": " << ans << "\n";
    }
}

백준 BOJ 12634번 : Stock Charts (Large)

문제 난이도 : Platinum II

알고리즘 분류 : 이분 매칭

** 이 문제의 풀이 코드로 백준 BOJ 12988번 : 주식 차트, 백준 BOJ 12633번 : Stock Charts (Small) 문제를 정답 처리 받을 수 있다.

(12988번은 테스트케이스 부분을 조금만 수정해주면 된다.)

N개의 주식 차트가 주어지는데, 서로 차트가 겹치는 것은 같은 차트에 넣을 수 없다고 한다면 차트가 최소 몇 개 필요한지 구하는 문제이다.

역시 최대 매칭을 구한 뒤 매칭 수만큼 빼주면 되는 것으로 보이는 문제이다.

당연히 일반 그래프에서의 최대 매칭은 구현하기 매우 어려우므로, 주어진 상황을 이분 그래프로 만드는 것이 핵심이다.

해결책은 그래프의 상하 관계대로만 간선을 연결하는 것이다.

예를 들어 2번 그래프가 3번 그래프보다 위에 있다면, 2번 노드에서 3번 노드로 간선을 연결하는 것이다. (3번 노드에서 2번 노드로 연결하는 것이 아니라)

이러한 방식으로 간선들을 연결해준다면, 최대 매칭을 구했을 때 얻어지는 매칭 수만큼 차트의 개수를 줄일 수 있고 반례가 존재하지 않게 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int T; cin >> T;

    for(int t=1; t<=T; t++) {
        int N, M; cin >> N >> M;

        vector<vector<int>> v(N, vector<int>(M));

        for(int i=0; i<N; i++)
            for(int j=0; j<M; j++) cin >> v[i][j];

        adj.clear();
        adj.resize(N);

        for(int i=0; i<N; i++)
            for(int j=0; j<N; j++) {
                if(i == j) continue;

                bool check = true;

                for(int k=0; k<M; k++)
                    if(v[i][k] >= v[j][k]) check = false;

                if(check) adj[i].push_back(j);
            }

        l.clear(); l.resize(N, -1);
        r.clear(); r.resize(N, -1);

        int match = 0;

        for(int i=0; i<N; i++) {
            vis.clear();
            vis.resize(N);

            if(f(i)) match++;
        }

        int ans = N - match;

        cout << "Case #" << t << ": " << ans << "\n";
    }
}

백준 BOJ 15007번 : Easter Eggs

문제 난이도 : Platinum II

알고리즘 분류 : 이분 매칭

2차원 좌표 평면 상에 N개의 파란 점과 M개의 빨간 점이 주어지고, 이들 중 K개의 점을 선택하여 빨간 점과 파란 점의 최소 거리가 최대가 되도록 했을 때 그 거리를 구하는 문제이다.

거리 임계 값에 대해 이분 탐색을 수행하면서, 현재 임계 거리 값 이하가 되는 것들에 대해 간선을 연결하여 (파란 점 → 빨간 점 방향으로 연결한다.) 이분 매칭을 수행해준 뒤 최대 정점 독립 집합이 K 이상이면 답의 최댓값을 갱신해주는 방식으로 답을 구해주면 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(x == y) continue;

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int T; cin >> T;

    for(int t=1; t<=T; t++) {
        int N; cin >> N;

        adj.clear();
        adj.resize(N+1);

        map<string, int> m1, m2;

        int x = 0, y = 0;

        for(int i=1; i<=N; i++) {
            string a, b; cin >> a >> b;

            if(m1[a] == 0) m1[a] = ++x;
            if(m2[b] == 0) m2[b] = ++y;
            
            
        }

        l.clear(); l.resize(N+1, -1);
        r.clear(); r.resize(N+1, -1);

        int ans = 0;

        for(int i=1; i<=N; i++) {
            vis.clear();
            vis.resize(N+1);

            if(f(i)) ans++;
        }

        cout << ans << "\n";
    }
}

백준 BOJ 17994번 : Swap Free

문제 난이도 : Platinum II

알고리즘 분류 : 이분 매칭

N개의 애너그램 관계인 단어들이 주어질 때, 이들 중 몇 개를 선택하여 만든 집합들 중 어떤 두 단어를 골라도 두 철자를 한 번만 swap하여 만들 수 있는 단어 관계가 없도록 하는 최대 집합 크기를 구하는 문제이다.

단어 A에서 B를 만들 때 최소 x번 swap하여야 하고, B에서 C를 만들 때 최소 y번 swap해야 하고, A에서 C를 만들 때 z번 swap해야 한다면 x + y와 z의 홀짝성이 동일하다.

따라서 첫 번째 단어에서 홀수 횟수만큼 swap해야 만들 수 있는 단어들은 오른쪽에, 짝수 횟수만큼 swap해야 만들 수 있는 단어들은 왼쪽에 (첫 번째 단어 포함, 0번이니까) 위치시킨 뒤 이분 매칭을 통해 최대 정점 독립 집합의 크기를 구해주면 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(x == y) continue;

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int T; cin >> T;

    for(int t=1; t<=T; t++) {
        int N; cin >> N;

        adj.clear();
        adj.resize(N+1);

        map<string, int> m1, m2;

        int x = 0, y = 0;

        for(int i=1; i<=N; i++) {
            string a, b; cin >> a >> b;

            if(m1[a] == 0) m1[a] = ++x;
            if(m2[b] == 0) m2[b] = ++y;
            
            
        }

        l.clear(); l.resize(N+1, -1);
        r.clear(); r.resize(N+1, -1);

        int ans = 0;

        for(int i=1; i<=N; i++) {
            vis.clear();
            vis.resize(N+1);

            if(f(i)) ans++;
        }

        cout << ans << "\n";
    }
}

백준 BOJ 7064번 : Air Raid

문제 난이도 : Platinum II

알고리즘 분류 : 이분 매칭

루프 없는 단방향 그래프가 주어질 때, 서로 경로가 겹치지 않고 모든 노드를 방문할 수 있는 최소 사람 수를 구하는 문제이다.

양쪽에 각각 N개의 노드를 두고 간선 방향대로 간선을 연결한 뒤, 최대 매칭을 찾아주면 매칭 수만큼 필요한 사람 수가 줄어들게 되므로 N - (최대 매칭 수)가 답이 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int T; cin >> T;

    while(T--) {
        int N, M; cin >> N >> M;

        adj.clear();
        adj.resize(N+1);

        while(M--) {
            int x, y; cin >> x >> y;

            adj[x].push_back(y);
        }

        l.clear(); l.resize(N+1, -1);
        r.clear(); r.resize(N+1, -1);

        int match = 0;

        for(int i=1; i<=N; i++) {
            vis.clear();
            vis.resize(N+1);

            if(f(i)) match++;
        }

        int ans = N - match;

        cout << ans << "\n";
    }
}

백준 BOJ 19647번 : Unique Solution

문제 난이도 : Platinum II

알고리즘 분류 : 이분 매칭

이분 그래프에서 N개 모두 매칭이 가능한 경우가 유일한지를 검사하는 문제이다.

이분 매칭 함수를 두 개 구현하여 하나는 앞에서부터 탐색하고 하나는 뒤에서부터 탐색하여 두 해가 동일한지 확인해주면 된다.

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

vector<vector<int>> adj;
vector<int> l1, r1, l2, r2;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r1[y] == -1 || (!vis[r1[y]] && f(r1[y]))) {
            l1[x] = y, r1[y] = x;

            return true;
        }
    }

    return false;
}

bool g(int x) {
    vis[x] = true;

    for(int i=adj[x].size()-1; i>=0; i--) {
        int y = adj[x][i];

        if(r2[y] == -1 || (!vis[r2[y]] && g(r2[y]))) {
            l2[x] = y, r2[y] = x;

            return true;
        }
    }

    return false;
}

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

    int N; cin >> N;

    adj.resize(N+1);

    for(int i=1; i<=N; i++) {
        int M; cin >> M;

        while(M--) {
            int x; cin >> x;

            adj[i].push_back(x);
        }
    }

    l1.resize(N+1, -1);
    r1.resize(N+1, -1);

    for(int i=1; i<=N; i++) {
        vis.clear();
        vis.resize(N+1);

        f(i);
    }

    l2.resize(N+1, -1);
    r2.resize(N+1, -1);

    for(int i=1; i<=N; i++) {
        vis.clear();
        vis.resize(N+1);

        g(i);
    }

    if(l1 != l2) {
        cout << -1 << "\n";
        return 0;
    }

    cout << 1 << "\n";

    for(int i=1; i<=N; i++) cout << l1[i] << " ";
    cout << "\n";
}

이분 매칭 최대 독립 집합 (Maximum Independent Set) 외 문제 풀이

restudy — Thu, 20 Oct 2022 20:08:51 +0900

이 포스트에서는 이분 매칭의 응용 중 하나인 최대 독립 집합(Maximum Independent Set)에 대해서 다룬다.

어떤 노드들의 집합에서 어떤 두 노드도 서로 간선으로 연결되어 있지 않을 때, 이 집합을 독립 집합이라고 한다.

그래프에서 최대 크기의 독립 집합을 최대 독립 집합이라고 한다.

이분 매칭 문제에서 최대 독립 집합은 전체 노드에서 최소 정점 커버(= 최소 꼭짓점 덮개)를 뺀 나머지가 된다.

그리고 최소 정점 커버는 쾨니그의 정리에 의해서 최대 매칭 수와 동일하다.

즉, 최대 독립 집합의 크기 I = V - M이다. (V = vertex의 수, M = 최대 매칭 수)

백준 BOJ 14986번 : Punching Power

문제 난이도 : Platinum III (난이도 기여로 난이도 상향시킴)

알고리즘 분류 : 이분 매칭

기계를 설치할 수 있는 좌표들의 후보가 N개 주어지고, 거리가 1.3 이하인 두 지점에 모두 기계를 설치하는 것은 불가능하다고 할 때, 최대로 설치할 수 있는 기계의 수를 구하는 문제이다.

거리가 1.3 이하라면 결국은 인접한 칸 사이에만 설치되지 않도록 기계들을 배치하면 된다.

인접한 노드들을 간선으로 연결한 뒤 여기에서 최대 독립 집합을 구해주면 된다.

다만 이를 위해서는 위에서 사용한 I = V - M의 식을 사용하기 위해 최대 매칭을 구해야 하므로 이분 그래프로 바꾸어줄 필요가 있다.

따라서 (x + y) % 2 = 0인 칸과 (x + y) % 2 = 1인 칸 두 가지로 나눈다. (체스판의 검은 칸, 흰 칸과 같다.)

간선들로 연결해서 최대 매칭을 구해주고, N에서 이를 빼주면 답이 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int N;

    while(cin >> N) {
        vector<pair<int, int>> v, u;
        map<pair<int, int>, int> vm, um;
        int vcnt = 0, ucnt = 0;

        for(int i=0; i<N; i++) {
            int x, y; cin >> x >> y;

            if((x + y) % 2 == 0) {
                v.push_back({x, y});
                vm[{x, y}] = ++vcnt;
            }
            else {
                u.push_back({x, y});
                um[{x, y}] = ++ucnt;
            }
        }

        adj.clear();
        adj.resize(vcnt+1);

        for(int i=0; i<v.size(); i++) {
            int x = v[i].first;
            int y = v[i].second;

            int dx[4] = {1, -1, 0, 0};
            int dy[4] = {0, 0, 1, -1};

            for(int j=0; j<4; j++) {
                int nx = x + dx[j];
                int ny = y + dy[j];

                if(um[{nx, ny}] != 0) adj[vm[{x, y}]].push_back(um[{nx, ny}]);
            }
        }

        l.clear();
        l.resize(vcnt+1, -1);

        r.clear();
        r.resize(ucnt+1, -1);

        int match = 0;

        for(int i=1; i<=vcnt; i++) {
            vis.clear();
            vis.resize(vcnt+1);

            if(f(i)) match++;
        }

        int ans = N - match;

        cout << ans << "\n";
    }
}

백준 BOJ 16726번 : 영과일 학회방

문제 난이도 : Platinum III

알고리즘 분류 : 이분 매칭

N x M 크기의 배열이 주어질 때, 1 x 1 또는 1 x 2 블럭으로 맵의 빈칸을 채운다고 한다면 최소로 필요한 블럭의 수를 구하는 문제이다.

이분 매칭 개수의 여집합을 이용하는 대표적인 문제이다.

맵을 체스판처럼 생각하여, 검은색 칸에 해당하는 노드와 흰색 칸에 해당하는 노드들로 나누어 서로 붙어있는 빈칸 사이인 노드들을 간선으로 연결해준 뒤 이분 매칭을 수행한다.

최대 매칭 값은 최대로 놓을 수 있는 1 x 2 블럭의 수와 동일하므로, 전체 빈칸 수 - 1 x 2 블럭 수 = 총 블럭 수임을 이용하여 답을 구해주면 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int N, M; cin >> N >> M;

    vector<vector<char>> v(N+1, vector<char>(M+1));
    int cnt = 0;

    for(int i=1; i<=N; i++)
        for(int j=1; j<=M; j++) {
            cin >> v[i][j];

            if(v[i][j] == '.') cnt++;
        }

    adj.resize(N*M + 1);

    for(int i=1; i<=N; i++)
        for(int j=!(i%2)+1; j<=M; j+=2) {
            if(v[i][j] != '.') continue;

            int di[4] = {1, -1, 0, 0};
            int dj[4] = {0, 0, 1, -1};

            for(int k=0; k<4; k++) {
                int ni = i + di[k];
                int nj = j + dj[k];

                if(ni < 1 || nj < 1 || ni > N || nj > M) continue;
                if(v[ni][nj] != '.') continue;

                adj[((i-1)*M+j+1)/2].push_back(((ni-1)*M+nj+1)/2);
            }
        }

    int s = (N*M + 1) / 2;

    l.resize(s+1, -1);
    r.resize(s+1, -1);

    int match = 0;

    for(int i=1; i<=s; i++) {
        vis.clear();
        vis.resize(s+1);

        if(f(i)) match++;
    }

    int ans = cnt - match;

    cout << ans << "\n";
}

백준 BOJ 7058번 : Royal guards

문제 난이도 : Platinum III

알고리즘 분류 : 이분 매칭

N x M 배열이 주어지고, 0으로 된 칸은 경비병을 배치할 수 있는 칸, 1은 빈 칸이나 경비병을 배치할 수 없는 칸, 2는 벽이라고 할 때, 벽으로 막혀있지 않고 같은 행이나 열인 병사끼리는 서로 공격한다고 할 때, 서로 공격하지 않도록 경비병을 배치하는 최대 수를 구하는 문제이다.

각 0으로 된 빈칸에 행과 열 번호를 부여하고, 행 번호와 열 번호 사이의 이분 그래프를 만들어준 뒤 최대 매칭을 찾아주면 된다.

이 문제를 상단에 배치한 이유는 바로 매칭을 구해야하기 때문인데, 이것은 각 {i, l[i]} 값들에 해당하는 행 번호와 열 번호를 가지고 있는 칸을 반복문으로 찾아주면 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int N, M; cin >> N >> M;

    vector<vector<int>> v(N+1, vector<int>(M+1));

    for(int i=1; i<=N; i++)
        for(int j=1; j<=M; j++) cin >> v[i][j];

    vector<vector<int>> u(N+1, vector<int>(M+1));
    int rcnt = 1;

    for(int i=1; i<=N; i++)
        for(int j=1; j<=M; j++) {
            if(v[i][j] == 0) u[i][j] = rcnt;
            if(v[i][j] != 2 && (j == M || v[i][j+1] == 2)) rcnt++;
        }

    rcnt--;

    vector<vector<int>> w(N+1, vector<int>(M+1));
    int ccnt = 1;

    for(int i=1; i<=M; i++)
        for(int j=1; j<=N; j++) {
            if(v[j][i] == 0) w[j][i] = ccnt;
            if(v[j][i] != 2 && (j == N || v[j+1][i] == 2)) ccnt++;
        }

    ccnt--;

    adj.resize(rcnt+1);

    for(int i=1; i<=N; i++)
        for(int j=1; j<=M; j++)
            if(v[i][j] == 0) adj[u[i][j]].push_back(w[i][j]);


    l.resize(rcnt+1, -1);
    r.resize(ccnt+1, -1);

    int ans = 0;

    for(int i=1; i<=rcnt; i++) {
        vis.clear();
        vis.resize(rcnt+1);

        if(f(i)) ans++;
    }

    cout << ans << "\n";

    vector<pair<int, int>> vv;

    for(int i=1; i<=rcnt; i++)
                if(i == r[l[i]]) vv.push_back({i, l[i]});

    for(int i=0; i<vv.size(); i++)
        for(int j=1; j<=N; j++)
            for(int k=1; k<=M; k++)
                if(u[j][k] == vv[i].first && w[j][k] == vv[i].second) cout << j << " " << k << "\n";
}

백준 BOJ 2787번 : 흔한 수열 문제

문제 난이도 : Platinum III

알고리즘 분류 : 이분 매칭

N 이하의 자연수로 이루어진 길이 N인 순열이 있고, M개의 힌트가 주어질 때 순열을 맞추는 문제이다.

이 때 힌트란 2가지로 분류되는데, 1 a b c의 경우 a번째부터 b번째 수 중 최댓값이 c라는 것이고, 2 a b c의 경우 최솟값이 c라는 것이다.

다음의 두 가지 조건을 사용하면 된다. 1번 쿼리를 예시로 들겠다.

1. 각 인덱스에 해당하는 최솟값을 1, 최댓값을 N으로 두고 구간을 좁힐 수 있다. 1 a b c이면 a번 원소부터 b번 원소들 중 최댓값을 기존의 최댓값과 c 중 더 작은 값으로 갱신할 수 있다.

2. 각 숫자가 나타나는 인덱스 범위의 최솟값을 1, 최댓값을 N으로 두고 구간을 좁힐 수 있다. a b c 쿼리에 대해, c라는 숫자는 기존의 최솟값과 a 중 더 큰 인덱스로 갱신이 가능하며, 반대로 인덱스의 최댓값과 b 중 더 작은 인덱스로 갱신이 가능하다.

이제 1, 2를 모두 만족하는 조합들만 뽑아 인덱스 → 가능한 숫자로 연결시켜준 뒤 이분 매칭을 수행해주면 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int N, M; cin >> N >> M;

    vector<int> minv(N+1, 1), maxv(N+1, N);
    vector<int> minr(N+1, 1), maxr(N+1, N);

    while(M--) {
        int Q, a, b, c; cin >> Q >> a >> b >> c;

        if(Q == 1) {
            for(int i=a; i<=b; i++) maxv[i] = min(maxv[i], c);
        }
        else if(Q == 2) {
            for(int i=a; i<=b; i++) minv[i] = max(minv[i], c);
        }

        minr[c] = max(minr[c], a);
        maxr[c] = min(maxr[c], b);
    }

    adj.resize(N+1);

    for(int i=1; i<=N; i++)
        for(int j=minv[i]; j<=maxv[i]; j++)
            if(minr[j] <= i && i <= maxr[j]) adj[i].push_back(j);

    l.resize(N+1, -1);
    r.resize(N+1, -1);

    int match = 0;

    for(int i=1; i<=N; i++) {
        vis.clear();
        vis.resize(N+1);

        if(f(i)) match++;
    }

    if(match < N) {
        cout << -1 << "\n";
        return 0;
    }

    for(int i=1; i<=N; i++) cout << l[i] << " ";
    cout << "\n";
}

백준 BOJ 22620번 : Defend the Bases

문제 난이도 : Platinum IV

알고리즘 분류 : 이분 매칭, 이분 탐색

N개의 군대의 좌표와 이동 속도, M개의 기지의 좌표가 주어질 때 모든 기지에 하나 이상의 군대를 배치하기 위해 필요한 최소 시간을 구하는 문제이다.

만약 제한 시간이 주어지고 최대로 하나 이상의 군대를 배치할 수 있는 기지의 수를 구하는 문제라면 이분 매칭으로 쉽게 구할 수 있다.

따라서 이 상황을 확장시켜 이분 탐색으로 미리 제한 시간을 가정하고, 그에 따른 match 값이 M인 경우 제한 시간을 줄여나가는 식으로 풀이할 수 있다.

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

struct s { double x, y, v; };

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    cout << fixed;
    cout.precision(8);

    while(true) {
        int N, M; cin >> N >> M;
        if(N == 0 && M == 0) break;

        vector<s> v(N), u(M);

        for(int i=0; i<N; i++) cin >> v[i].x >> v[i].y >> v[i].v;
        for(int i=0; i<M; i++) cin >> u[i].x >> u[i].y;

        double ll = 0, rr = INT_MAX, ans = INT_MAX, tr = 1e2;

        while(tr--) {
            double m = (ll + rr) / 2;

            adj.clear();
            adj.resize(M);

            for(int i=0; i<N; i++)
                for(int j=0; j<M; j++)
                    if(sqrt(pow(v[i].x - u[j].x, 2) + pow(v[i].y - u[j].y, 2)) / v[i].v <= m) adj[j].push_back(i);

            l.clear();
            l.resize(M, -1);

            r.clear();
            r.resize(N, -1);

            int match = 0;

            for(int i=0; i<M; i++) {
                vis.clear();
                vis.resize(M);

                if(f(i)) match++;
            }

            if(match == M) {
                ans = min(ans, m);
                rr = m;
            }
            else ll = m;
        }

        cout << ll << "\n";
    }
}

백준 BOJ 13470번 : Programming Tutors

문제 난이도 : Platinum III

알고리즘 분류 : 이분 매칭, 이분 탐색

N명의 학생의 좌표와 N명의 교사의 좌표가 2차원 상에서 주어질 때, 하나의 교사가 서로 다른 하나의 학생으로 이동할 때 가장 맨해튼 거리가 먼 거리가 최소가 되도록 매치했을 때 그 최솟값을 구하는 문제이다.

위의 문제와 비슷한 방법으로, 이분 매칭을 하되 제한 값을 미리 정해두고 그 거리 이하인 노드들 내에서만 간선을 연결한 뒤 수행해준 뒤 매치된 쌍의 수가 N개이면 제한 거리를 줄여보고, 그렇지 않으면 제한 거리를 늘리는 식으로 조절해가면서 최소 제한 거리를 구해주면 된다.

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

struct s { int x, y; };

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int N; cin >> N;

    vector<s> v(N), u(N);

    for(int i=0; i<N; i++) cin >> v[i].x >> v[i].y;
    for(int i=0; i<N; i++) cin >> u[i].x >> u[i].y;

    int ll = 0, rr = INT_MAX, ans = INT_MAX;

    while(ll <= rr) {
        int m = (ll + rr) / 2;

        adj.clear();
        adj.resize(N);

        for(int i=0; i<N; i++)
            for(int j=0; j<N; j++)
                if(abs(v[i].x - u[j].x) + abs(v[i].y - u[j].y) <= m) adj[i].push_back(j);

        l.clear();
        l.resize(N, -1);

        r.clear();
        r.resize(N, -1);

        int match = 0;

        for(int i=0; i<N; i++) {
            vis.clear();
            vis.resize(N);

            if(f(i)) match++;
        }

        if(match == N) {
            ans = min(ans, m);
            rr = m - 1;
        }
        else ll = m + 1;
    }

    cout << ans << "\n";
}

백준 BOJ 9577번 : 토렌트

문제 난이도 : Platinum IV

알고리즘 분류 : 이분 매칭

N개의 토렌트 조각이 있고 M명의 회원들이 접속한 시각에 해당 회원이 가지고 있는 조각 하나를 1초에 받을 수 있다고 할 때, 모든 조각을 모으기 위한 최소 시간을 구하는 문제이다.

이분 매칭으로 푸는 것을 알았다면, 어떤 그룹과 어떤 그룹 사이의 매칭을 수행할지 고민해보면 된다.

각 시간 (초 단위) → 토렌트 조각 관계로 연결을 해준 뒤 이분 매칭 알고리즘을 돌려주면 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int T; cin >> T;

    while(T--) {
        int N, M; cin >> N >> M;

        adj.clear();
        adj.resize(101);

        while(M--) {
            int a, b, K; cin >> a >> b >> K;

            while(K--) {
                int x; cin >> x;

                for(int i=a; i<b; i++) adj[i].push_back(x);
            }
        }

        l.clear();
        l.resize(101, -1);

        r.clear();
        r.resize(N+1, -1);

        int match = 0;
        bool check = false;

        for(int i=0; i<=100; i++) {
            vis.clear();
            vis.resize(101);

            if(f(i)) match++;

            if(match == N) {
                cout << i+1 << "\n";

                check = true;
                break;
            }
        }

        if(!check) cout << -1 << "\n";
    }
}

백준 BOJ 25846번 : Make the Team

문제 난이도 : Platinum IV

알고리즘 분류 : 이분 매칭

N개의 비디오가 있고 각각 시청 가능한 시간이 주어질 때, 모든 비디오를 시청 완료하는 가장 짧은 시간을 구하는 문제이다.

두 비디오가 동일한 시간에 재생된다면 하나만 볼 수 있기 때문에, 각 시간에 볼 수 있는 비디오를 매칭하는 이분 매칭을 생각해볼 수 있다.

풀이 코드는 위의 문제와 거의 비슷하며, 변수의 범위만 다르다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int N; cin >> N;

    adj.resize(1001);

    for(int i=0; i<N; i++) {
        int M; cin >> M;

        while(M--) {
            int x; cin >> x;

            adj[x].push_back(i);
        }
    }

    l.clear();
    l.resize(1001, -1);

    r.clear();
    r.resize(N, -1);

    int match = 0;

    for(int i=1; i<=1000; i++) {
        vis.clear();
        vis.resize(1001);

        if(f(i)) match++;

        if(match == N) {
            cout << i+1 << "\n";
            break;
        }
    }
}

백준 BOJ 3736번 : System Engineer

문제 난이도 : Platinum III

알고리즘 분류 : 이분 매칭

N개의 작업이 있고, 각 작업을 수행 가능한 서버들의 목록이 주어지며 하나의 서버에서는 하나의 작업만 수행이 가능하다면 동시에 수행할 수 있는 최대 작업의 수를 구하는 문제이다.

문자열 처리만 조금 해주면 일반적인 이분 매칭으로 간단하게 풀이 가능하다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int N;

    while(cin >> N) {
        adj.clear();
        adj.resize(N);

        for(int i=0; i<N; i++) {
            int a, M; char ch;
            cin >> a >> ch >> ch >> M >> ch;

            while(M--) {
                int b; cin >> b;

                adj[a].push_back(b - N);
            }
        }

        l.clear();
        l.resize(N, -1);

        r.clear();
        r.resize(N, -1);

        int ans = 0;

        for(int i=0; i<N; i++) {
            vis.clear();
            vis.resize(N);

            if(f(i)) ans++;
        }

        cout << ans << "\n";
    }
}

백준 BOJ 5780번 : Uncle Tom's Inherited Land

문제 난이도 : Platinum III

알고리즘 분류 : 이분 매칭

N x M 크기의 배열이 있고 그들 중 연못에 해당하는 칸들의 목록이 주어질 때, 연못이 아닌 땅은 1 x 2 크기로 하나씩 판매할 수 있다고 할 때, 판매 가능한 땅의 최대 개수를 구하는 문제이다.

위에서 풀이한 백준 BOJ 16726번 : 영과일 학회방 문제의 풀이와 비슷하게 풀이하면 된다.

체스판의 검은칸, 흰칸을 나누어 이분 매칭시켜준 뒤 두 칸이 모두 육지인 칸 사이를 간선으로 연결하고, 이분 매칭을 시켜 최대 매칭 수를 구해주면 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    while(true) {
        int N, M; cin >> N >> M;
        if(N == 0 && M == 0) break;

        vector<vector<bool>> v(N+1, vector<bool>(M+1, true));

        int K; cin >> K;

        while(K--) {
            int x, y; cin >> x >> y;

            v[x][y] = false;
        }

        adj.clear();
        adj.resize(N*M + 1);

        for(int i=1; i<=N; i++)
            for(int j=!(i%2)+1; j<=M; j+=2) {
                if(!v[i][j]) continue;

                int di[4] = {1, -1, 0, 0};
                int dj[4] = {0, 0, 1, -1};

                for(int k=0; k<4; k++) {
                    int ni = i + di[k];
                    int nj = j + dj[k];

                    if(ni < 1 || nj < 1 || ni > N || nj > M) continue;
                    if(!v[ni][nj]) continue;

                    adj[((i-1)*M+j+1)/2].push_back(((ni-1)*M+nj+1)/2);
                }
            }

        int s = (N*M + 1) / 2;

        l.clear();
        l.resize(s+1, -1);

        r.clear();
        r.resize(s+1, -1);

        int ans = 0;

        for(int i=1; i<=s; i++) {
            vis.clear();
            vis.resize(s+1);

            if(f(i)) ans++;
        }

        cout << ans << "\n";
    }
}

백준 BOJ 5924번 : Cow Steeplechase

문제 난이도 : Platinum III

알고리즘 분류 : 이분 매칭

N개의 선분이 가로선 또는 세로선으로 주어질 때, 이들 중 서로 겹치지 않는 것들을 최대한 뽑았을 때 그 개수를 구하는 문제이다.

단, 평행한 두 선분이 겹치는 경우는 존재하지 않는다고 가정한다.

가로 선분과 세로 선분을 서로 각각의 그룹으로 분류한 뒤 서로 교차하는 것끼리 간선으로 연결해주면 이분 그래프가 만들어지며, 여기에 이분 매칭을 사용하여 최대 매칭 수를 N에서 빼주면 답이 된다.

아래의 가정 때문에 문제를 훨씬 간단하게 풀이할 수 있다.

만약 평행한 선분이 겹치지 않는다는 조건이 없었다면, 선분 교차 판정 알고리즘까지 가지고 와서 사용해야한다.

(그랬다면 난이도가 Platinum I 이상으로 올라갔을 것 같다.)

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

struct s { int x1, y1, x2, y2; };

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int N; cin >> N;

    vector<s> v, u;

    for(int i=0; i<N; i++) {
        int x1, y1, x2, y2; cin >> x1 >> y1 >> x2 >> y2;

        if(y1 == y2) {
            if(x1 > x2) swap(x1, x2);
            v.push_back({x1, y1, x2, y2});
        }
        else {
            if(y1 > y2) swap(y1, y2);
            u.push_back({x1, y1, x2, y2});
        }
    }

    adj.resize(v.size());

    for(int i=0; i<v.size(); i++)
        for(int j=0; j<u.size(); j++)
            if(v[i].x1 <= u[j].x1 && u[j].x1 <= v[i].x2
               && u[j].y1 <= v[i].y1 && v[i].y1 <= u[j].y2) adj[i].push_back(j);

    l.resize(v.size(), -1);
    r.resize(u.size(), -1);

    int match = 0;

    for(int i=0; i<v.size(); i++) {
        vis.clear();
        vis.resize(v.size());

        if(f(i)) match++;
    }

    int ans = N - match;

    cout << ans << "\n";
}

백준 BOJ 10371번 : Irrigation Lines

문제 난이도 : Platinum III

알고리즘 분류 : 이분 매칭

N x M 배열에 0 또는 1의 값이 주어질 때, 행 또는 열 몇 개를 선택하여 1이 전부 선택되도록 하는 최소 선택 수를 구하는 문제이다.

1의 값을 가지는 위치의 행과 열을 간선으로 이어 이분 그래프를 만들면, 쾨니그의 정리에 의해 최소 꼭짓점 덮개 수 = 최대 매칭 수이므로 이분 매칭으로 풀이할 수 있다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int T; cin >> T;

    for(int t=1; t<=T; t++) {
        int N, M; cin >> N >> M;

        adj.clear();
        adj.resize(N+1);

        for(int i=1; i<=N; i++)
            for(int j=1; j<=M; j++) {
                char c; cin >> c;

                if(c == '1') adj[i].push_back(j);
            }

        l.clear();
        l.resize(N+1, -1);

        r.clear();
        r.resize(M+1, -1);

        int ans = 0;

        for(int i=1; i<=N; i++) {
            vis.clear();
            vis.resize(N+1);

            if(f(i)) ans++;
        }

        cout << "Case #" << t << ": " << ans << "\n";
    }
}

백준 BOJ 10532번 : Book Club

문제 난이도 : Platinum III

알고리즘 분류 : 이분 매칭

N명의 사람들이 있고 M개의 순서쌍 (a, b)에 대해 a번 사람이 b번 사람의 책을 좋아한다고 하자.

모든 사람이 책을 하나씩 전달받고 전달하여 순환이 가능한지 여부를 구하는 문제이다.

왼쪽에 N개의 노드, 오른쪽에 N개의 노드를 설정한 뒤 문제에서 제시한대로 M개의 간선을 연결하여 이분 그래프를 만들고 이분 매칭을 수행하여 최대 매치 수가 N인지의 여부를 파악해주면 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

        int N, M; cin >> N >> M;

        adj.resize(N);

        while(M--) {
            int a, b; cin >> a >> b;

            adj[a].push_back(b);
        }

        l.resize(N, -1);
        r.resize(N, -1);

        int match = 0;

        for(int i=0; i<N; i++) {
            vis.clear();
            vis.resize(N);

            if(f(i)) match++;
        }

        if(match == N) cout << "YES\n";
        else cout << "NO\n";
}

백준 BOJ 10850번 : Bounty Hunter

문제 난이도 : Platinum III

알고리즘 분류 : 이분 매칭

노드가 N개인 단방향 그래프가 주어질 때, 한 사람이 하나의 경로로 지나간 노드들을 체크하되 한 사람이 지나간 노드는 다른 사람이 지나갈 수 없다고 할 때, 모든 노드들을 체크하기 위해 필요한 최소 인원 수를 구하는 문제이다.

위 문제와 똑같이 왼쪽에 N개 노드, 오른쪽에도 N개 노드를 구성한 뒤 a → b간선의 방향대로 왼쪽 a번 노드를 오른쪽 b번 노드로 연결한다.

이렇게 만들어진 이분 그래프에 대해 이분 매칭을 수행하여 최대 매칭을 찾는다.

이분 매칭을 통해 선택된 하나의 간선은 한 사람의 한 번의 이동으로 고려할 수 있고, 간선이 두 개 이상의 노드를 공유하지 않으므로 이들은 경로가 겹치지 않는 최대 이동에 해당한다.

따라서 N - 최대 매치 수를 답으로 얻어주면 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

        int N; cin >> N;

        adj.resize(N);

        for(int i=0; i<N; i++) {
            int M; cin >> M;

            while(M--) {
                int x; cin >> x;

                adj[i].push_back(x);
            }
        }

        l.resize(N, -1);
        r.resize(N, -1);

        int match = 0;

        for(int i=0; i<N; i++) {
            vis.clear();
            vis.resize(N);

            if(f(i)) match++;
        }

        int ans = N - match;

        cout << ans << "\n";
}

백준 BOJ 17238번 : Delicious Pineapple Pizza

문제 난이도 : Platinum III

알고리즘 분류 : 이분 매칭, 이분 탐색

길이 N인 수열 A와 B가 주어질 때, N개의 쌍을 만들어 a ^ b 값의 최솟값이 최대가 되도록 매칭하고, 그 때의 최솟값을 구하는 문제이다.

이분 매칭으로 값들을 매칭시켜야 하는 것은 쉽게 생각할 수 있다.

이분 탐색을 이용하여 특정 임계값 이상의 연산 값을 가지는 경우만 간선으로 연결하여 이분 매칭을 수행하고, 최대 매칭 값이 N이면 임계값을 증가시키는 방식으로 최솟값의 최댓값을 구해주면 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int N; cin >> N;

    vector<int> v(N), u(N);
    for(int i=0; i<N; i++) cin >> v[i];
    for(int i=0; i<N; i++) cin >> u[i];

    int ll = 0, rr = INT_MAX, ans = 0;

    while(ll <= rr) {
        int m = (ll + rr) / 2;

        adj.clear();
        adj.resize(N);

        for(int i=0; i<N; i++)
            for(int j=0; j<N; j++)
                if((v[i] ^ u[j]) >= m) adj[i].push_back(j);

        l.clear();
        l.resize(N, -1);

        r.clear();
        r.resize(N, -1);

        int match = 0;

        for(int i=0; i<N; i++) {
            vis.clear();
            vis.resize(N);

            if(f(i)) match++;
        }

        if(match == N) {
            ans = max(ans, m);
            ll = m + 1;
        }
        else rr = m - 1;
    }

    cout << ans << "\n";
}

백준 BOJ 13503번 : 최소 체인 커버

문제 난이도 : Platinum II

알고리즘 분류 : 이분 매칭

단방향 그래프가 주어질 때, 서로 겹치지 않는 몇 개의 경로로 모든 정점을 지나가려고 할 때 필요한 최소 경로의 수를 구하는 문제이다.

이분 매칭으로 최대 매칭 수를 구한 뒤, 정점의 수에서 매칭 수를 빼주면 곧 경로의 수가 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int N, M; cin >> N >> M;

    adj.resize(N+1);

    while(M--) {
        int x, y; cin >> x >> y;

        adj[x].push_back(y);
    }

    l.resize(N+1, -1);
    r.resize(N+1, -1);

    int match = 0;

    for(int i=1; i<=N; i++) {
        vis.clear();
        vis.resize(N+1);

        if(f(i)) match++;
    }

    int ans = N - match;

    cout << ans << "\n";
}

이분 매칭 (Bipartite Matching) 문제 풀이 모음 221019

restudy — Wed, 19 Oct 2022 04:00:19 +0900

이분 매칭 알고리즘에 대해서는 이전에 다룬 적도 있고 문제 풀이도 한 적 있지만 잊어버린 내용이 많아서 공부를 위해 다시 정리해본다.

이분 매칭 알고리즘

1. 이분 그래프란 그래프의 정점을 같은 그룹의 노드 사이에 간선으로 연결된 노드 쌍이 존재하지 않도록 두 그룹으로 나눌 수 있는 그래프를 의미한다.

2. 이분 매칭 알고리즘은 이러한 이분 그래프에서 하나의 노드가 두 개 이상의 간선에 포함되지 않도록 선택할 수 있는 최대 간선의 수를 말한다. (즉, 최대한으로 매칭시킬 수 있는 노드 쌍의 수를 찾는 것이다.)

3. 쾨니그의 정리는 최대 매칭 수 = 최소 꼭짓점 덮개 수라는 정리이다.

여기서 최소 꼭짓점 덮개란 몇 개의 노드를 선택하여 이들과 이 꼭짓점들을 포함하는 간선들을 체크할 때, 모든 간선들이 체크되도록 하는 최소 꼭짓점들의 개수를 말한다.

쾨니그의 정리는 이분 매칭 알고리즘 문제의 일부 상황에 적용이 가능한데, 예를 들어 이분 그래프 상황에서 최소 선택을 통해 모든 간선들이 선택되도록 해야할 때 이 최소 선택 수 = 최대 매칭 수임을 이용하여 그냥 이분 매칭 알고리즘을 돌려서 답을 얻으면 된다.

백준 BOJ 1867번 : 돌멩이 제거

문제 난이도 : Platinum III

알고리즘 분류 : 이분 매칭

N x N 격자에 M개의 돌이 있을 때, 한 번의 연산에서 행 또는 열을 선택하여 그 행이나 열에 있는 돌멩이를 모두 제거할 때, 격자의 모든 돌멩이를 제거하는 최소 연산 수를 구하는 문제이다.

각 행의 번호를 left 노드, 열의 번호를 right 노드라고 할 때, 하나의 돌멩이는 하나의 행과 열을 연결하는 간선으로 나타낼 수 있다.

그러면 하나의 간선은 하나의 행과 열을 이으므로 (행과 행 사이 간선, 열과 열 사이 간선은 당연히 존재하지 않으므로) 이분 그래프가 되고, 최소 노드를 선택하여 모든 간선이 선택되도록 하는 문제로 바뀐다.

여기서 위의 쾨니그의 정리를 사용하여 최대 매칭을 구해주면 그것이 곧 최소 연산 수임을 알 수 있다.

따라서 이분 매칭 알고리즘을 통해 최대 매칭 수를 구해주면 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int N, M; cin >> N >> M;

    vector<vector<char>> v(N+1, vector<char>(M+1));

    for(int i=1; i<=N; i++)
        for(int j=1; j<=M; j++) cin >> v[i][j];

    adj.resize(N+1);

    while(M--) {
        int x, y; cin >> x >> y;

        adj[x].push_back(y);
    }

    l.resize(N+1, -1);
    r.resize(N+1, -1);

    int ans = 0;

    for(int i=1; i<=N; i++) {
        vis.clear();
        vis.resize(N+1);

        if(f(i)) ans++;
    }

    cout << ans << "\n";
}

백준 BOJ 2414번 : 게시판 구멍 막기

문제 난이도 : Platinum III

알고리즘 분류 : 이분 매칭

N x M 크기의 격자에 . 또는 * 문자들이 주어지고, 행 또는 열 내에서 같은 방향으로 연속한 * 문자들을 선택할 수 있다고 할 때, 모든 *들이 선택되는 최소 선택 수를 구하는 문제이다.

가로 방향으로 연속한 *들에 번호를 매기고, 세로 방향으로 연속한 *들에 다시 번호를 매긴다.

그럼 하나의 * 문자는 가로 번호와 세로 번호 하나씩을 가진다.

하나의 가로 번호 또는 세로 번호를 선택한다는 것은 그 번호에 소속된 모든 *들을 선택한다고 볼 수 있다.

최소 가로 또는 세로 노드의 선택을 통해 모든 *들을 선택하면 문제가 해결된다.

이것은 쾨니그의 정리에 의해 최대 매칭 수와 같으므로 위에서 가로 번호와 세로 번호를 하나의 *이 간선으로 연결된다고 할 때 최대 매칭 수를 구해주면 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int N, M; cin >> N >> M;

    vector<vector<char>> v(N+1, vector<char>(M+1));

    for(int i=1; i<=N; i++)
        for(int j=1; j<=M; j++) cin >> v[i][j];

    vector<vector<int>> u(N+1, vector<int>(M+1));
    int rnum = 1;

    for(int i=1; i<=N; i++)
        for(int j=1; j<=M; j++)
            if(v[i][j] == '*') {
                u[i][j] = rnum;

                if(j == M || v[i][j+1] == '.') rnum++;
            }

    rnum--;

    vector<vector<int>> w(N+1, vector<int>(M+1));
    int cnum = 1;

    for(int i=1; i<=M; i++)
        for(int j=1; j<=N; j++)
            if(v[j][i] == '*') {
                w[j][i] = cnum;

                if(j == N || v[j+1][i] == '.') cnum++;
            }

    cnum--;

    adj.resize(rnum+1);

    for(int i=1; i<=N; i++)
        for(int j=1; j<=M; j++)
            if(v[i][j] == '*') adj[u[i][j]].push_back(w[i][j]);

    l.resize(rnum+1, -1);
    r.resize(cnum+1, -1);

    int ans = 0;

    for(int i=1; i<=rnum; i++) {
        vis.clear();
        vis.resize(rnum+1);

        if(f(i)) ans++;
    }

    cout << ans << "\n";
}

백준 BOJ 2188번 : 축사 배정

문제 난이도 : Platinum IV

알고리즘 분류 : 이분 매칭

N마리의 소가 M개의 축사 중 각각 들어가고 싶어하는 축사들의 번호가 다르다고 할 때, 하나의 축사에 한 마리의 소만 들어갈 수 있다면 최대 몇 마리의 소를 축사로 배정할 수 있는지 구하는 문제이다.

이분 매칭을 사용하는 가장 대표적인 상황의 기본 문제이다.

N마리의 소가 원하는 축사들의 번호로 간선을 만들어주고, 이분 매칭을 수행해주면 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int N, M; cin >> N >> M;

    adj.resize(N+1);

    for(int i=1; i<=N; i++) {
        int K; cin >> K;

        while(K--) {
            int x; cin >> x;

            adj[i].push_back(x);
        }
    }

    l.resize(N+1, -1);
    r.resize(M+1, -1);

    int ans = 0;

    for(int i=1; i<=N; i++) {
        vis.clear();
        vis.resize(N+1);

        if(f(i)) ans++;
    }

    cout << ans << "\n";
}

위의 풀이 코드와 동일한 코드로 백준 BOJ 11375번 : 열혈강호 문제를 통과할 수 있다.

백준 BOJ 9576번 : 책 나눠주기

문제 난이도 : Gold II

알고리즘 분류 : 이분 매칭

N권의 책을 M명의 학생들에게 한 명당 최대 1권씩 나눠준다고 하고, 각 학생은 a ~ b번 사이의 책을 원한다고 할 때, 최대로 나눠줄 수 있는 책의 수를 구하는 문제이다.

i번째 학생에 대한 입력이 (a_i, b_i)일 때 a_i ~ b_i번 책에 해당하는 노드를 i번째 학생으로 연결시켜주는 과정을 모든 학생에 대해 반복하고, 이분 매칭을 수행해주면 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int T; cin >> T;

    while(T--) {
        int N, M; cin >> N >> M;

        adj.clear();
        adj.resize(N+1);

        for(int i=1; i<=M; i++) {
            int a, b; cin >> a >> b;

            for(int j=a; j<=b; j++) {
                adj[j].push_back(i);
            }
        }

        l.clear();
        l.resize(N+1, -1);

        r.clear();
        r.resize(M+1, -1);

        int ans = 0;

        for(int i=1; i<=N; i++) {
            vis.clear();
            vis.resize(N+1);

            if(f(i)) ans++;
        }

        cout << ans << "\n";
    }
}

백준 BOJ 1017번 : 소수 쌍

문제 난이도 : Platinum III

알고리즘 분류 : 이분 매칭

N개의 자연수들이 주어졌을 때, 이들을 2개씩 묶어서 합한 값이 모두 소수가 되도록 묶는 방법들 각각에서 첫 번째 수와 매칭되는 수들을 오름차순으로 출력하는 문제이다.

N개의 수에 대응되는 노드들을 만들고, N x (N - 1) / 2개의 쌍 중에서 합이 소수인 것들을 간선으로 연결한다.

그 다음 첫 번째 노드 수에 해당하는 노드를 간선들 중 하나를 선택하여 연결한 뒤, 이 상태에서 이분 매칭을 수행하는 과정을 여러 번 거쳐 가능한 모든 경우를 구하면 된다.

여기서 주의할 점은 동일한 노드가 left, right 모두에 있으므로 모두 매칭되었을 때 매칭의 수가 N/2가 아니라 N이 되어야 한다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    vector<bool> p(2001, true);
    p[1] = false;

    for(int i=2; i*i<=2000; i++)
        for(int j=2; i*j<=2000; j++) p[i*j] = false;

    int N; cin >> N;

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

    adj.resize(N);

    for(int i=0; i<N; i++)
        for(int j=i+1; j<N; j++)
            if(p[v[i] + v[j]]) {
                adj[i].push_back(j);
                adj[j].push_back(i);
            }

    vector<int> u;

    for(int i=0; i<adj[0].size(); i++) {
        l.clear();
        l.resize(N, -1);

        r.clear();
        r.resize(N, -1);

        int x = adj[0][i];

        l[0] = x, r[x] = 0;

        int cnt = 1;

        for(int j=1; j<N; j++) {
            vis.clear();
            vis.resize(N);

            vis[0] = vis[x] = true;

            if(f(j)) cnt++;
        }

        if(cnt == N) u.push_back(v[x]);
    }

    if(u.size() == 0) {
        cout << -1 << "\n";
        return 0;
    }

    sort(u.begin(), u.end());

    for(int i=0; i<u.size(); i++) cout << u[i] << " ";
    cout << "\n";
}

백준 BOJ 2191번 : 들쥐의 탈출

문제 난이도 : Platinum IV

알고리즘 분류 : 이분 매칭

N마리의 들쥐와 M개의 굴의 위치가 2차원 좌표로 주어지고, 각 쥐는 S x V 이하의 거리에 있는 굴로만 들어갈 수 있을 때 굴로 들어가지 못하는 최소 들쥐의 수를 구하는 문제이다.

위의 조건식에 대해 O(NM) 시간에 거리를 체크하여 그래프를 구성해주고, 이분 매칭으로 최대 매칭을 찾아 N에서 빼주면 답이 된다.

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

struct s { double x, y; };

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int N, M; cin >> N >> M;

    double S, V; cin >> S >> V;

    vector<s> v(N), u(M);

    for(int i=0; i<N; i++) cin >> v[i].x >> v[i].y;
    for(int i=0; i<M; i++) cin >> u[i].x >> u[i].y;

    adj.resize(N);

    for(int i=0; i<N; i++)
        for(int j=0; j<M; j++) {
            double x = sqrt(pow(v[i].x - u[j].x, 2) + pow(v[i].y - u[j].y, 2));

            if(x <= S * V) adj[i].push_back(j);
        }

    l.resize(N, -1);
    r.resize(M, -1);

    int ans = 0;

    for(int i=0; i<N; i++) {
        vis.clear();
        vis.resize(N);

        if(f(i)) ans++;
    }

    ans = N - ans;

    cout << ans << "\n";
}

백준 BOJ 4966번 : Cards

문제 난이도 : Platinum IV

알고리즘 분류 : 이분 매칭

N개의 카드와 M개의 카드가 주어질 때, 두 카드 더미에서 공약수가 1보다 큰 카드 쌍을 제거해나간다고 할 때, 제거할 수 있는 최대 카드 쌍의 수를 구하는 문제이다.

N과 M이 크지 않으므로, 가능한 모든 쌍에 대해 공약수를 조사하여 간선으로 연결해주고, 그렇게 만들어진 그래프에 이분 매칭을 수행해주면 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    while(true) {
        int N, M; cin >> N >> M;
        if(N == 0 && M == 0) break;

        vector<int> v(N), u(M);

        for(int i=0; i<N; i++) cin >> v[i];
        for(int i=0; i<M; i++) cin >> u[i];

        adj.clear();
        adj.resize(N);

        for(int i=0; i<N; i++)
            for(int j=0; j<M; j++)
                if(__gcd(v[i], u[j]) > 1) adj[i].push_back(j);

        l.clear();
        l.resize(N, -1);

        r.clear();
        r.resize(M, -1);

        int ans = 0;

        for(int i=0; i<N; i++) {
            vis.clear();
            vis.resize(N);

            if(f(i)) ans++;
        }

        cout << ans << "\n";
    }
}

백준 BOJ 18138번 : 리유나는 세일러복을 좋아해

문제 난이도 : Platinum IV

알고리즘 분류 : 이분 매칭

N개의 티셔츠와 M개의 세일러카라가 있을 때 카라의 폭이 티셔츠의 폭 w에 대해 w/2 ~ 3w/4 또는 w ~ 5w/4인 경우에만 하나의 세일러복을 만들 수 있다고 할 때, 만들 수 있는 최대 세일러복의 수를 구하는 문제이다.

N개의 노드, M개의 노드를 이분하여 생각한 뒤 O(NM) 시간에 대해 탐색을 수행하여 세일러복을 만들 수 있는 조건에 해당하는 두 노드 사이만 간선으로 연결해주어 이분 매칭을 수행해주면 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int N, M; cin >> N >> M;

    vector<double> v(N), u(M);

    for(int i=0; i<N; i++) cin >> v[i];
    for(int i=0; i<M; i++) cin >> u[i];

    adj.resize(N);

    for(int i=0; i<N; i++)
        for(int j=0; j<M; j++)
            if((v[i]/2 <= u[j] && u[j] <= v[i]*3/4) || (v[i] <= u[j] && u[j] <= v[i]*5/4)) adj[i].push_back(j);

    l.resize(N, -1);
    r.resize(M, -1);

    int ans = 0;

    for(int i=0; i<N; i++) {
        vis.clear();
        vis.resize(N+1);

        if(f(i)) ans++;
    }

    cout << ans << "\n";
}

백준 BOJ 10276번 : Jewelry Exhibition

문제 난이도 : Platinum IV

알고리즘 분류 : 이분 매칭

N x M 격자 내에 실수형 좌표 K개가 주어지고, 하나의 레이저는 행 또는 열 중 [정수, 정수+1] 구간의 모든 좌표를 스캔 가능하다고 할 때, K개의 좌표가 모두 스캔되기 위한 최소 레이저 수를 구하는 문제이다.

정수 x에 대해 [x, x+1) 구간의 모든 점들을 정수 x로 내림하여 기록하면 백준 BOJ 1867번 : 돌멩이 제거 문제의 상황과 동일해지므로 같은 방식으로 풀이하면 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int T; cin >> T;

    while(T--) {
        int N, M, K; cin >> N >> M >> K;

        adj.clear();
        adj.resize(N);

        while(K--) {
            double x, y; cin >> x >> y;

            adj[(int)x].push_back((int)y);
        }

        l.clear();
        l.resize(N, -1);

        r.clear();
        r.resize(M, -1);

        int ans = 0;

        for(int i=0; i<N; i++) {
            vis.clear();
            vis.resize(N+1);

            if(f(i)) ans++;
        }

        cout << ans << "\n";
    }
}

백준 BOJ 11180번 : Paintball

문제 난이도 : Platinum IV

알고리즘 분류 : 이분 매칭

N명의 사람이 있고, M개의 쌍 (a, b)가 주어질 때, a번 사람과 b번 사람이 서로를 paintball로 쏠 수 있다고 하자.

모든 사람이 정확히 하나의 paintball을 맞는 것이 가능한지 판별하고, 가능하다면 i번째 사람이 몇 번 사람을 쏘면 되는지 그 예시를 출력하는 문제이다.

이분 매칭으로 풀이하되 a번 노드를 b번 노드로 연결해주고, b번 노드 또한 a번 노드로 연결해준다. (둘 중 누구라도 서로를 쏠 수 있으므로)

이제 이분 매칭을 해준 뒤 최대 매칭 값이 N인 경우만 답으로 가능하고, 그렇지 않으면 Impossible을 출력해주면 된다.

매칭 값이 N인 경우는 l[i] 값들을 출력해주면 된다. (l[i] : i번째 left 노드에서 연결되어있는 right 노드의 번호)

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int N, M; cin >> N >> M;

    adj.resize(N+1);

    while(M--) {
        int x, y; cin >> x >> y;

        adj[x].push_back(y);
        adj[y].push_back(x);
    }

    l.resize(N+1, -1);
    r.resize(N+1, -1);

    int ans = 0;

    for(int i=1; i<=N; i++) {
        vis.clear();
        vis.resize(N+1);

        if(f(i)) ans++;
    }

    if(ans != N) {
        cout << "Impossible\n";
        return 0;
    }

    for(int i=1; i<=N; i++) cout << l[i] << "\n";
}

백준 BOJ 11432번 : Candy Bombers

문제 난이도 : Platinum IV

알고리즘 분류 : 이분 매칭

N명의 파일럿이 각각 M개의 비행기 중에서 운전 가능한 것이 다르다고 할 때, 최대로 운전할 수 있는 비행기의 수를 구하는 문제이다.

파일럿과 비행기 그룹 간의 그래프를 형성하여 이분 매칭을 돌리면 된다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int T; cin >> T;

    for(int t=1; t<=T; t++) {
        int M, N; cin >> M >> N;

        adj.clear();
        adj.resize(N+1);

        for(int i=1; i<=N; i++) {
            int K; cin >> K;

            while(K--) {
                int x; cin >> x;

                adj[i].push_back(x);
            }
        }

        l.clear();
        l.resize(N+1, -1);

        r.clear();
        r.resize(M+1, -1);

        int ans = 0;

        for(int i=1; i<=N; i++) {
            vis.clear();
            vis.resize(N+1);

            if(f(i)) ans++;
        }

        cout << "Data Set " << t << ":\n";
        cout << ans << "\n";
        cout << "\n";
    }
}

백준 BOJ 11670번 : 초등 수학

문제 난이도 : Platinum IV

알고리즘 분류 : 이분 매칭

N개의 정수 쌍이 주어지고, 두 정수를 +, -, * 연산 중 하나로 연산하여 모든 연산 값들이 다르게 만드는 것이 가능한지를 구하고, 가능하다면 각 연산식을 모두 구하는 문제이다.

해시맵을 사용하여 각 연산 값들이 중복되지 않게 노드를 형성하여 연결해주고, 이분 매칭을 수행해주면 된다.

문제는 매칭이 모두 가능한 경우 연산 식을 복원해야 하는데, 이를 위해 map을 하나 더 선언해서 각 right 노드가 원래는 어떤 값을 가지고 있었는지를 연결시켜주어 마지막에 출력해주는 방식을 사용하면 구현이 가능하다.

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

vector<vector<int>> adj;
vector<int> l, r;
vector<bool> vis;

bool f(int x) {
    vis[x] = true;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(r[y] == -1 || (!vis[r[y]] && f(r[y]))) {
            l[x] = y, r[y] = x;

            return true;
        }
    }

    return false;
}

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

    int N; cin >> N;

    adj.resize(N);

    vector<pair<int, int>> v(N);
    map<int, int> m, rm;
    int cnt = 0;

    for(int i=0; i<N; i++) {
        int a, b; cin >> a >> b;

        v[i].first = a, v[i].second = b;

        if(m[a+b] == 0) m[a+b] = ++cnt;
        rm[m[a+b]] = a + b;
        adj[i].push_back(m[a+b]);

        if(m[a-b] == 0) m[a-b] = ++cnt;
        rm[m[a-b]] = a - b;
        adj[i].push_back(m[a-b]);

        if(m[a*b] == 0) m[a*b] = ++cnt;
        rm[m[a*b]] = a * b;
        adj[i].push_back(m[a*b]);
    }

    l.resize(N, -1);
    r.resize(cnt+1, -1);

    int match = 0;

    for(int i=0; i<N; i++) {
        vis.clear();
        vis.resize(N);

        if(f(i)) match++;
    }

    if(match != N) {
        cout << "impossible\n";
        return 0;
    }

    for(int i=0; i<N; i++) {
        int a = v[i].first, b = v[i].second;

        char ch;

        if(rm[l[i]] == a + b) ch = '+';
        else if(rm[l[i]] == a - b) ch = '-';
        else if(rm[l[i]] == a * b) ch = '*';

        cout << a << " " << ch << " " << b << " = " << rm[l[i]] << "\n";
    }
}

백준 BOJ 풀이 (IGRUS Newbie Programming Contest 일부 포함)

restudy — Mon, 3 Oct 2022 03:18:23 +0900

백준 BOJ 25711번 : 인경산

문제 난이도 : Gold V

알고리즘 분류 : 누적 합

2차원 좌표 상의 N개의 점이 주어지고, 어떤 인접한 구간의 두 점 사이를 이동할 때 필요한 에너지는 내리막길일 경우 거리에 해당, 평지일 경우 거리의 2배, 오르막길일 경우 거리의 3배라고 할 때 M개의 쿼리에 대해 두 지점 사이의 필요한 에너지들을 구하는 문제이다.

쿼리 문제이므로 O(1)이나 O(log N)과 같이 짧은 시간에 쿼리를 처리할 수 있어야 한다.

이 문제에서는 누적 합을 이용하여, 맨 왼쪽 지점에서부터 특정 지점까지 이동하는데 필요한 에너지들의 목록을 구해둔다.

반대로, 맨 오른쪽 지점에서부터 특정 지점까지 이동하는데 필요한 에너지들의 목록도 구해둔다.

각각의 값들은 위에서 정의한 식대로 구해주면 된다.

이제 왼쪽 i번 지점에서 오른쪽 j번 지점으로 이동하는데 필요한 에너지는 (i < j) u[j] - u[i]와 같이 O(1)에 구할 수 있고, 오른쪽 i번 지점에서 왼쪽 j번 지점으로 이동하는데 필요한 에너지 (i > j) 역시 w[j] - w[i]와 같이 구할 수 있다.

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

struct s { double x, y; };

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

    int N, M; cin >> N >> M;

    vector<s> v(N);

    for(int i=0; i<N; i++) cin >> v[i].x;
    for(int i=0; i<N; i++) cin >> v[i].y;

    vector<double> u(N), w(N);

    for(int i=1; i<N; i++) {
        if(v[i].y < v[i-1].y)
            u[i] = u[i-1] + sqrt(pow(v[i].x - v[i-1].x, 2) + pow(v[i].y - v[i-1].y, 2));
        else if(v[i].y == v[i-1].y)
            u[i] = u[i-1] + sqrt(pow(v[i].x - v[i-1].x, 2) + pow(v[i].y - v[i-1].y, 2)) * 2;
        else if(v[i].y > v[i-1].y)
            u[i] = u[i-1] + sqrt(pow(v[i].x - v[i-1].x, 2) + pow(v[i].y - v[i-1].y, 2)) * 3;
    }

    for(int i=N-2; i>=0; i--) {
        if(v[i].y < v[i+1].y)
            w[i] = w[i+1] + sqrt(pow(v[i].x - v[i+1].x, 2) + pow(v[i].y - v[i+1].y, 2));
        else if(v[i].y == v[i+1].y)
            w[i] = w[i+1] + sqrt(pow(v[i].x - v[i+1].x, 2) + pow(v[i].y - v[i+1].y, 2)) * 2;
        else if(v[i].y > v[i+1].y)
            w[i] = w[i+1] + sqrt(pow(v[i].x - v[i+1].x, 2) + pow(v[i].y - v[i+1].y, 2)) * 3;
    }

    cout << fixed;
    cout.precision(4);

    while(M--) {
        int a, b; cin >> a >> b;

        if(a < b) cout << u[b-1] - u[a-1] << "\n";
        else cout << w[b-1] - w[a-1] << "\n";
    }
}

백준 BOJ 25708번 : 만남의 광장

문제 난이도 : Silver II

알고리즘 분류 : 누적 합

N x M 크기의 정수 배열이 주어지고, 이들 중에서 가로와 세로로 2줄씩을 제거하여 도로를 만들 때, 도로 위에 써 있는 숫자들의 합에 네 도로가 감싸는 잔디의 개수를 더한 값의 최댓값을 구하는 문제이다.

네 도로를 결정할 때 가능한 모든 경우를 해보면 O(N^2 M^2)가 되는데, N과 M이 작아 이 정도까지는 돌아간다.

문제는 도로 위에 써 있는 숫자들을 빨리 더하는 방법인데 이것은 N개의 도로와 M개의 도로에 대해 각각의 합을 미리 구해두면 된다.

시간 복잡도는 위에서 언급한대로 O(N^2 M^2)이다.

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

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

    int N, M; cin >> N >> M;

    vector<vector<int>> v(N, vector<int>(M));

    for(int i=0; i<N; i++)
        for(int j=0; j<M; j++) cin >> v[i][j];

    vector<int> u(N), w(M);

    for(int i=0; i<N; i++)
        for(int j=0; j<M; j++) u[i] += v[i][j];

    for(int i=0; i<M; i++)
        for(int j=0; j<N; j++) w[i] += v[j][i];

    int ans = INT_MIN;

    for(int i=0; i<N; i++)
        for(int j=0; j<M; j++)
            for(int k=i+1; k<N; k++)
                for(int l=j+1; l<M; l++) {
                    int sum = u[i] + w[j] + u[k] + w[l]
                              - v[i][j] - v[k][l] - v[i][l] - v[k][j]
                              + (k-i-1) * (l-j-1);

                    ans = max(ans, sum);
                }

    cout << ans << "\n";
}

백준 BOJ 25710번 : 점수 계산

문제 난이도 : Silver II

알고리즘 분류 : 브루트포스 알고리즘

1 ~ 999 사이의 수 10만개가 주어질 때, 두 정수를 곱하여 얻어진 수의 각 자릿수를 더해 얻을 수 있는 최댓값을 구하는 문제이다.

N이 10만 이하로 O(N^2)에 돌리면 시간 초과가 발생하지만, 1 ~ 999 사이의 수만 입력되므로 이들 중에서 존재하는 수들에 대해서만 검사해보면 된다.

이렇게 할 경우 시간 복잡도는 O(1000^2)로 매우 작다.

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

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

    int N; cin >> N;

    vector<int> v(1000);
    for(int i=0; i<N; i++) {
        int x; cin >> x;
        v[x]++;
    }

    vector<int> u;
    for(int i=1; i<=999; i++) {
        if(v[i] == 1) u.push_back(i);
        else if(v[i] >= 2) {
            u.push_back(i);
            u.push_back(i);
        }
    }

    int ans = 0;

    for(int i=0; i<u.size(); i++)
        for(int j=i+1; j<u.size(); j++) {
            int tmp = u[i] * u[j];

            int sum = 0;

            while(tmp > 0) {
                sum += tmp % 10;
                tmp /= 10;
            }

            ans = max(ans, sum);
        }

    cout << ans << "\n";
}

백준 BOJ 25709번 : 1 빼기

문제 난이도 : Silver IV

알고리즘 분류 : 그리디

주어진 수에 대해, 가지고 있는 수에서 1을 빼거나 또는 어떤 자리가 1의 값을 가질 때 해당 자리를 지우는 연산을 거쳐 0으로 만들기 위해 필요한 최소 연산 횟수를 구하는 문제이다.

우선적으로 높은 자릿수에 있는 1을 먼저 지우고, 만약 1이 없다면 1을 감소시키는 연산을 반복하면 된다.

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

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

    int N; cin >> N;

    int ans = 0;

    while(true) {
        if(N == 0) break;

        string tmp = to_string(N);
        int idx = -1;

        for(int i=0; i<tmp.length(); i++)
            if(tmp[i] == '1') {
                idx = i;
                break;
            }

        if(idx != -1) {
            tmp = tmp.substr(0, idx) + tmp.substr(idx+1, tmp.length()-(idx+1));

            N = 0;

            for(int i=0; i<tmp.length(); i++) N = N * 10 + tmp[i] - '0';
        }
        else N--;

        ans++;
    }

    cout << ans << "\n";
}

백준 BOJ 25706번 : 자전거 묘기

문제 난이도 : Silver V

알고리즘 분류 : DP

각 위치에서의 점프대의 높이에 해당하는 N개의 수가 주어졌을 때, 각 위치에서 시작했을 때 밟게 되는 칸의 수를 구하는 문제이다.

역순으로 dp에 값들을 저장하면서 뒤의 dp 값들을 참조하여 답을 구해주면 된다.

( i ) 만약 시작 칸의 점프대 높이가 0이라면 dp[i] = dp[i+1] + 1이다.

( ii ) 시작 칸에서 점프대를 밟고 이동한 위치가 끝 또는 그 이상일 경우 dp[i] = 1이다.

( iii ) 위의 두 경우가 아니라면 dp 값은 점프대를 밟고 이동한 위치에서의 dp 값 + 1이 된다.

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

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

    int N; cin >> N;

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

    vector<int> u(N);
    u[N-1] = 1;

    for(int i=N-2; i>=0; i--) {
        if(v[i] == 0) u[i] = u[i+1] + 1;
        else if(i + v[i] + 1 >= N) u[i] = 1;
        else u[i] = u[i + v[i] + 1] + 1;
    }

    for(int i=0; i<N; i++) cout << u[i] << " ";
    cout << "\n";
}

백준 BOJ 16980번 : Bitaro the Brave

문제 난이도 : Silver III

알고리즘 분류 : 누적 합

N x M 문자 배열이 주어졌을 때, 왼쪽 위에는 'J', 오른쪽 위에는 'O', 왼쪽 아래에는 'I'인 직사각형의 개수를 구하는 문제이다.

오른쪽 아래에서부터 왼쪽 위로 검사하면서 J가 나올 때마다 지금까지 오른쪽에 나타난 O의 개수와 아래에 나타난 I의 개수의 곱만큼을 답에 더해주는 과정을 반복하면 된다.

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

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

    int N, M; cin >> N >> M;

    vector<vector<char>> v(N, vector<char>(M));
    for(int i=0; i<N; i++)
        for(int j=0; j<M; j++) cin >> v[i][j];

    vector<int> u(M);
    int ans = 0;

    for(int i=N-1; i>=0; i--) {
        int x = 0;

        for(int j=M-1; j>=0; j--) {
            if(v[i][j] == 'J') ans += x * u[j];
            else if(v[i][j] == 'O') x++;
            else if(v[i][j] == 'I') u[j]++;
        }
    }

    cout << ans << "\n";
}

백준 BOJ 2208번 : 보석 줍기

문제 난이도 : Gold II

알고리즘 분류 : DP

길이 N인 수열에서, 길이가 M 이상인 구간에 대해 최대 구간 합을 구하는 문제이다.

먼저 구간 합 배열을 만들어준다.

이제 i = M, 최소 구간합은 0부터 검사하면서 0 ~ i까지의 구간 합에서 0 ~ i-M 구간의 최소 구간합을 빼주는 과정을 i에 대해 반복해주면 된다.

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

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

    int N, M; cin >> N >> M;

    vector<int> v(N+1);
    for(int i=1; i<=N; i++) {
        int x; cin >> x;

        v[i] = v[i-1] + x;
    }

    int ans = 0, Min = 0;

    for(int i=M; i<=N; i++) {
        Min = min(Min, v[i-M]);
        ans = max(ans, v[i] - Min);
    }

    cout << ans << "\n";
}

알고리즘 분할정복 거듭제곱, 투포인터 등 알고리즘 문제 풀이 221001

restudy — Sat, 1 Oct 2022 18:24:46 +0900

풀이한 문제들 중에서 인상적인 문제만 몇 개 뽑아서 정리한다.

문제 알고리즘은 무작위로 선정하였다.

백준 BOJ 25569번 : My뷰 꾸미기

문제 난이도 : Platinum IV

알고리즘 분류 : 조합론, 분할 정복을 이용한 거듭제곱

N개의 (a, b)쌍에 대해 min(a, b) = c라고 할 때, (a C 1 x b C 1) + (a C 2 x b C 2) + ... + (a C c x b C c)의 합을 구하는 문제이다.

N과 a, b는 30만 이하이다.

각 항을 팩토리얼과 분모는 페르마의 소정리 + 분할 정복을 이용한 거듭제곱으로 계산이 가능하나, 항이 매우 많아 시간 초과에 걸리게 된다.

이 경우 항을 줄여주어야 하는데, (a C 1 x b C 1) + (a C 2 x b C 2) + ... + (a C c x b C c) = (a C 1 x b C b - 1) + (a C 2 x b C b - 2) + ... + (a C c x b C b - c) = ((a + b) C b) - 1이므로 (a+b개 중에 1 ~ b개를 고르는 경우의 합이니까) 하나의 컴비네이션 값만 계산해주면 된다.

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

int mod = 1e9 + 7;
vector<int> fac(6e5 + 1);

int fp(int ba, int ex) {
    int ret = 1;

    while(ex > 0) {
        if(ex % 2 == 1) ret = (ret * ba) % mod;

        ba = (ba * ba) % mod;
        ex /= 2;
    }

    return ret;
}

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

    fac[0] = 1;

    for(int i=1; i<=6e5; i++) fac[i] = (fac[i-1] * i) % mod;

    int N; cin >> N;

    int ans = 1;

    while(N--) {
        int a, b; cin >> a >> b;

        int c = min(a, b);

        int tmp = (fac[a+b] * fp(fac[c], mod - 2)) % mod;

        tmp = (tmp * fp(fac[a+b-c], mod - 2)) % mod;

        tmp = (tmp - 1 + mod) % mod;

        ans = (ans * tmp) % mod;
    }

    cout << ans << "\n";
}

백준 BOJ 20366번 : 같이 눈사람 만들래?

문제 난이도 : Gold III

알고리즘 분류 : 투 포인터

N개의 정수 중에 4개를 선택하여 두 개, 두 개씩 짝지은 합의 차의 최소를 구하는 문제이다.

먼저 떠올릴 수 있는 방법은 N C 2개를 고른 배열을 만들어 두 배열에서 이분 탐색을 하는 것인데, 이 경우 각 합에서 중복되는 원소가 포함되어 있는지를 알 방법이 없다.

따라서 N이 600 이하이므로, 이중 for문을 돌려주고 이 때 각 i와 j 사이에서 l, r에 대한 투 포인터 알고리즘을 사용하여 v[i] + v[j]와 v[l] + v[r]을 가지고 비교하여 답을 구해주면 된다.

최종 시간 복잡도는 O(N^3)이 된다.

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

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

    int N; cin >> N;

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

    sort(v.begin(), v.end());

    int ans = LLONG_MAX;

    for(int i=0; i<N; i++)
        for(int j=i+3; j<N; j++) {
            int l = i+1, r = j-1;

            while(l < r) {
                int dif = abs((v[i] + v[j]) - (v[l] + v[r]));

                ans = min(ans, dif);

                if((v[l] + v[r]) < (v[i] + v[j])) l++;
                else r--;
            }
        }

    cout << ans << "\n";
}

백준 BOJ 3090번 : 차이를 최소로

알고리즘 분류 : 이분 탐색, 그리디

문제 난이도 : Platinum III

길이 N인 수열에서 하나의 수를 골라 1만큼 감소시키는 비용이 1이라고 할 때, 비용을 M 이하로 하여 수열의 인접한 숫자간의 차이값을 최소로 했을 때의 배열을 구하는 문제이다.

인접한 수의 차이를 m 이하로 잡고 비용을 M 이하로 사용할 수 있는지 체크하면서 이분 탐색으로 풀이하면 된다.

m을 설정했으면 값들을 그리디하게 바꾸어주는 것이 최선이다.

따라서 0에서부터 N-1까지 이동하면서 오른쪽 수가 m보다 많이 크다면 비용에 v[i+1] - (v[i] + m)을 더해주고 v[i+1] = v[i] + m으로 바꿔준다.

반대 방향 인접 값들도 마찬가지로 N-1에서 0까지 이동하면서 왼쪽 수가 m보다 많이 크다면 비용에 v[i-1] - (v[i] + m)을 더해주고 v[i-1] = v[i] + m으로 바꿔준다.

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

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

    int N, M; cin >> N >> M;

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

    int l = 0, r = 1e9;
    vector<int> ans;

    while(l <= r) {
        int m = (l + r) / 2;

        vector<int> u(v);
        int sum = 0;

        for(int i=0; i<N-1; i++) {
            if(u[i] + m < u[i+1]) {
                sum += u[i+1] - (u[i] + m);
                u[i+1] = u[i] + m;
            }
        }

        for(int i=N-1; i>0; i--) {
            if(u[i] + m < u[i-1]) {
                sum += u[i-1] - (u[i] + m);
                u[i-1] = u[i] + m;
            }
        }

        if(sum <= M) {
            ans = u;
            r = m - 1;
        }
        else l = m + 1;
    }

    for(int i=0; i<ans.size(); i++) cout << ans[i] << " ";
    cout << "\n";
}

백준 BOJ 2812번 : 크게 만들기

문제 난이도 : Gold III

알고리즘 분류 : 그리디, 스택

N자리 수에서 M개의 수를 지워 만들 수 있는 가장 큰 수를 구하는 문제이다.

뭔가 코드포스에서 많이 나올 것 같은 유형의 문제라서 풀어보았다.

빈 문자열에 N자리 수를 앞에서부터 하나씩 추가하다가 추가할 수가 문자열의 맨 뒷 문자보다 크다면 맨 뒷 문자를 지우고 추가해주는 과정을 반복하고, M을 1 줄여준다.

만약 이 과정이 끝나도 M이 0보다 크다면, 뒤의 M자리는 지워졌다고 생각하고 앞의 s.length() - M자리만 출력해주면 된다.

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

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

    int N, M; cin >> N >> M;

    string str; cin >> str;

    string ans = "";

    for(int i=0; i<str.length(); i++) {
        while(ans.length() > 0 && str[i] > ans.back() && M > 0) {
            ans.pop_back();
            M--;
        }

        ans += str[i];
    }

    ans = ans.substr(0, ans.length()-M);

    cout << ans << "\n";
}

백준 BOJ 5447번 : Stock Market

문제 난이도 : Silver II

알고리즘 분류 : DP

구간 합이 최대인 부분의 양 끝 주소를 구하는 문제이다.

단, 그러한 구간이 여러 개 있을 경우 시작 주소가 작은 것을 구해야 한다.

DP를 이용한 구간 합 최대를 구하는 알고리즘 문제이다.

이에 대해서는 이 블로그 카테고리의 알고리즘 구현 코드 모음에 정리되어 있으니 참고 바란다.

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

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

    int T; cin >> T;

    while(T--) {
        int N; cin >> N;

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

        vector<int> dp(N), le(N);
        dp[0] = v[0];

        for(int i=1; i<N; i++) {
            if(dp[i-1] >= 0) {
                dp[i] = dp[i-1] + v[i];
                le[i] = le[i-1];
            }
            else {
                dp[i] = v[i];
                le[i] = i;
            }
        }

        int Max = INT_MIN, l, r;
        for(int i=0; i<N; i++)
            if(dp[i] > Max) {
                Max = dp[i];
                l = le[i] + 1;
                r = i + 1;
            }

        cout << l << " " << r << "\n";
    }
}

백준 BOJ 10892번 : Divide into triangle

문제 난이도 : Silver IV

알고리즘 분류 : 기하학, 구성적

2차원 좌표 평면 상의 3N개의 점이 주어지고, 이들 중 일직선 상에 있는 세 점이 없다고 할 때, 3개씩 N개의 쌍을 만들어 각 쌍의 점들의 삼각형이 서로 겹치지 않게 하는 조합을 구하면 된다.

y 좌표, x 좌표 순으로 정렬하여 (반대로 정렬해도 상관없음) 순서대로 3개씩 뽑아주면 절대로 겹치지 않음을 알 수 있다.

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

struct s { int x, y, n; };

bool cmp(s a, s b) {
    if(a.y != b.y) return a.y > b.y;
    else if(a.x != b.x) return a.x < b.x;
}

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

    int N; cin >> N;

    vector<s> v(N*3);
    for(int i=0; i<N*3; i++) {
        cin >> v[i].x >> v[i].y;

        v[i].n = i+1;
    }

    sort(v.begin(), v.end(), cmp);

    for(int i=0; i<N*3; i+=3)
        cout << v[i].n << " " << v[i+1].n << " " << v[i+2].n << "\n";
}

백준 BOJ 25694번 : Ramen

문제 난이도 : Silver IV

알고리즘 분류 : 그리디

길이 N인 라면의 맛에 해당하는 배열이 주어지고, 2l ≤ n인 l에 대해 a_1 ~ a_l이 모두 0보다 크다면 이 구간을 오른쪽으로 접어서 값을 합칠 수 있다고 할 때, 하나의 면을 길이가 1인 면으로 접을 수 있는지 구하는 문제이다.

길이 l만큼 접는 경우 그 구간은 모두 양수여야 하므로, 이는 결국 길이 1씩 접으면서 그 숫자들이 양수인지 체크하는 것과 같다.

따라서 길이 1씩 체크해주면 된다.

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

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

    int N; cin >> N;

    int cur = 0;
    bool check = true;

    while(N--) {
        int x; cin >> x;

        cur += x;

        if(cur <= 0 && N > 0) check = false;
    }

    if(check) cout << "YES\n";
    else cout << "NO\n";
}

삼분 탐색 알고리즘 문제 풀이 모음 220926

restudy — Tue, 27 Sep 2022 04:48:06 +0900

삼분 탐색 알고리즘(Ternary Search Algorithm)이란 말 그대로 구간에서 1/3 지점과 2/3 지점의 함수값의 크기 비교를 기반으로 탐색을 해나가는 알고리즘이다.

이분 탐색 알고리즘은 그래프가 단조 증가 또는 단조 감소한다는 조건 하에서만 사용이 가능하지만, 삼분 탐색은 극값이 최대 1개 이하로 있는 모든 그래프에 대하여 사용 가능하다. (즉, 단순히 극값을 갖는 그래프 뿐만이 아닌 단조 증가, 감소 그래프에서도 사용이 가능하다.)

1개의 최솟값을 갖는 y = x^2 꼴의 그래프를 [l, r]의 구간에서 삼분 탐색하는 상황에 대해 생각해보자. (물론 극값을 구간에 포함하고 있다고 가정한다.)

1/3 지점을 x = m1, 2/3 지점을 x = m2라고 하며, 우리는 극값의 x 좌표 x_min을 찾고자 한다. (그러면 f_min = f(x_min)으로 구할 수 있다.)

( i ) f(m1) > f(m2)일 경우, 최소한 [l, m1] 구간에는 극값을 포함하지 않는다. 따라서 l = m1으로 옮겨준다.

( ii ) f(m1) < f(m2)일 경우, 최소한 [m2, r] 구간에는 극값을 포함하지 않는다. 따라서 r = m2으로 옮겨준다.

위의 과정을 반복하면 구간이 수렴하고, 적절한 횟수만큼 반복을 시켜준 뒤 답을 도출해주면 된다.

이제 예제들을 풀어보면서 연습해보자.

백준 BOJ 11662번 : 민호와 강호

문제 난이도 : Gold IV

알고리즘 분류 : 삼분 탐색

민호가 (v0.x, v0.y)에서 (v1.x, v1.y)로 일정한 속도로 걸어가고, 강호도 (v2.x, v2.y)에서 (v3.x, v3.y)로 일정한 속도로 걸어가며 두 사람은 각자의 시작점에서 동시에 출발하여 각자의 도착점에 동시에 도착한다고 할 때, 두 사람의 거리가 최소일 때의 그 거리를 구하는 문제이다.

두 사람 사이의 거리 그래프가 극값을 1개 이하로 가지므로 삼분 탐색을 사용할 수 있다.

두 사람 사이의 거리를 매개 변수에 대해 나타낸 뒤, 거리의 최솟값을 찾아주면 된다.

예를 들어 t = 0 ~ 1 범위에서 민호의 위치를 나타내자면, (tx2 + (1-t)x1, ty2 + (1-t)y1)으로 나타낼 수 있다.

이건 선분에 대한 방정식을 매개변수로 표현하는 건데 고등학교 1학년 과정에 있는 것으로 기억한다.

이제 t = 0 ~ 1 범위에서 삼분 탐색을 해주면 된다.

다른 사람들의 풀이를 보니 바로 거리를 구해주는 방식으로 했던데 나는 이 방법이 편했다.

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

struct s { double x, y; };

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

    cout << fixed;
    cout.precision(8);

    vector<s> v(4);
    for(int i=0; i<4; i++) cin >> v[i].x >> v[i].y;

    double l = 0, r = 1;

    for(int tr=1; tr<=1e5; tr++) {
        double m1 = (l*2 + r) / 3;
        double m2 = (l + r*2) / 3;

        double a = sqrt(pow((m1*v[1].x + (1-m1)*v[0].x) - (m1*v[3].x + (1-m1)*v[2].x), 2)
                        + pow((m1*v[1].y + (1-m1)*v[0].y) - (m1*v[3].y + (1-m1)*v[2].y), 2));
        double b = sqrt(pow((m2*v[1].x + (1-m2)*v[0].x) - (m2*v[3].x + (1-m2)*v[2].x), 2)
                        + pow((m2*v[1].y + (1-m2)*v[0].y) - (m2*v[3].y + (1-m2)*v[2].y), 2));

        if(tr == 1e5) {
            cout << a << "\n";
            break;
        }
        else if(a < b) r = m2;
        else if(a > b) l = m1;
    }
}

백준 BOJ 8986번 : 전봇대

문제 난이도 : Platinum V

알고리즘 분류 : 삼분 탐색

1차원 선상에 위치한 N개의 전봇대 좌표가 주어질 때, 각각을 정수 좌표로 이동시켜 일정한 간격으로 만들기 위해 필요한 최소 이동 거리 합을 구하는 문제이다.

예를 들어 N = 4이고 좌표가 0, 4, 6, 9라면 두 번째 전봇대를 1만큼 이동시켜 0, 3, 6, 9로 만들 수 있고, 이 때 답은 1이다.

전봇대 사이의 거리를 x라고 할 때, 전봇대의 총 이동 거리를 f(x)라고 하자.

그러면 y = f(x) 그래프는 아래로 볼록한 그래프를 구성한다. (상식적으로 중간에 최솟값이 있으니까 당연하다.)

따라서 삼분 탐색을 사용할 수 있다.

이 문제가 위의 문제와 다른 점은 x가 정수 좌표에서만 정의가 된다는 것인데, 그래프의 개형 자체는 똑같으므로 비슷한 방식으로 풀어줄 수 있다.

대신 여기서는 x가 정수에서만 정의됨을 활용하여 탐색 종료 조건을 r - l < 3과 같이 설정해줄 수 있다.

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

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

    int N; cin >> N;

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

    int l = 0, r = v[N-1];
    int tr = 1e4;

    while(r - l >= 3) {
        int m1 = (l*2 + r) / 3;
        int m2 = (l + r*2) / 3;

        int s1 = 0;
        for(int i=0; i<N; i++) s1 += abs(m1*i - v[i]);

        int s2 = 0;
        for(int i=0; i<N; i++) s2 += abs(m2*i - v[i]);

        if(s1 < s2) r = m2;
        else if(s1 > s2) l = m1;
    }

    int ans = LLONG_MAX;

    for(int i=l; i<=r; i++) {
        int sum = 0;
        for(int j=0; j<N; j++) sum += abs(i*j - v[j]);

        ans = min(ans, sum);
    }

    cout << ans << "\n";
}

백준 BOJ 11664번 : 선분과 점

문제 난이도 : Silver I

알고리즘 분류 : 삼분 탐색

3차원 좌표평면 상에서 선분과 점 사이의 최소 거리를 구하는 문제이다.

벡터를 사용해서 풀어도 되고, 삼분 탐색을 이용해서 풀어도 된다.

여기서는 삼분 탐색을 연습하고 있으니 삼분 탐색으로 풀어보자.

위의 BOJ 11662와 마찬가지로, 매개변수를 이용하여 t = 0 ~ 1으로 선분의 내분점을 잡을 수 있다.

이러한 선분 위의 내분점과 점 사이의 거리를 이용하여 삼분 탐색을 해주면 풀이 가능하다.

참고로 f(m1) = f(m2)인 경우가 나올 수 있으므로 해당 경우에도 l = m1으로 옮기던가 r = m2로 옮기던가 둘 중 하나를 처리 해주어야 반례가 발생하지 않는다.

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

struct s { double x, y, z; };

double f(s a, s b) {
    return sqrt(pow(a.x - b.x, 2) + pow(a.y - b.y, 2) + pow(a.z - b.z, 2));
}

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

    cout << fixed;
    cout.precision(6);

    vector<s> v(3);
    for(int i=0; i<3; i++)
        cin >> v[i].x >> v[i].y >> v[i].z;

    double l = 0, r = 1, tr = 1e3;

    while(tr--) {
        double m1 = (l*2 + r) / 3;
        double m2 = (l + r*2) / 3;

        double a = f({m1*v[1].x + (1-m1)*v[0].x, m1*v[1].y + (1-m1)*v[0].y, m1*v[1].z + (1-m1)*v[0].z}, v[2]);
        double b = f({m2*v[1].x + (1-m2)*v[0].x, m2*v[1].y + (1-m2)*v[0].y, m2*v[1].z + (1-m2)*v[0].z}, v[2]);

        if(tr == 0) cout << a << "\n";
        else if(a > b) l = m1;
        else r = m2;
    }
}

백준 BOJ 13011번 : 사탕의 밀도

문제 난이도 : Silver I

알고리즘 분류 : 삼분 탐색

N명의 학생이 있고 각 바구니의 용량은 v[i], 원하는 사탕의 무게는 u[i]일 때 모든 학생들에게 동일한 밀도의 사탕을 줄 때 밀도를 얼마로 해야 각 참가자가 원하는 무게와 실제 무게의 차이가 최소가 되는지를 구하는 문제이다.

밀도를 먼저 가정하고 차이를 구한 뒤, 그 차이값에 따라 탐색 범위를 조정하는 삼분 탐색으로 풀이 가능하다.

무게 차이에 대한 연산을 여러 번 해야하기 때문에, 함수로 따로 빼서 구현하는 편이 나은 것 같다.

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

double f(vector<double> v, vector<double> u, double m) {
    double sum = 0;

    for(int i=0; i<v.size(); i++)
        sum += abs(v[i] * m - u[i]);

    return sum;
}

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

    cout << fixed;
    cout.precision(9);

    int N; cin >> N;

    vector<double> v(N), u(N);
    for(int i=0; i<N; i++) cin >> v[i];
    for(int i=0; i<N; i++) cin >> u[i];

    double l = 0, r = 1e6;
    double Min = INT_MAX, tr = 1e3;

    while(tr--) {
        double m1 = (l*2 + r) / 3;
        double m2 = (l + r*2) / 3;

        double a = f(v, u, m1);
        double b = f(v, u, m2);

        if(tr == 0) cout << a << "\n";
        else if(a > b) l = m1;
        else r = m2;
    }
}

백준 BOJ 3855번 : Trick or Treat

문제 난이도 : Gold IV

알고리즘 분류 : 삼분 탐색

우연인지 모르겠지만 이 문제도 사탕과 관련된 문제이다.

N개 지점의 (x,y) 좌표가 주어지고, y = 0 직선 위의 하나의 x 좌표를 잡아서 가장 먼 지점의 거리가 최소가 되게 할 때, 그 x 좌표를 구하는 문제이다.

가장 먼 거리가 최소가 되는 지점이 있으므로, 그래프는 아래로 볼록하므로 삼분 탐색을 이용해서 풀이 가능함을 알 수 있다.

x 좌표의 범위를 설정하고 그 범위 내에서 삼분 탐색을 수행해주면 된다.

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

struct s { double x, y; };

double f(vector<s> v, double m) {
    double Max = 0;

    for(int i=0; i<v.size(); i++)
        Max = max(Max, sqrt(pow(v[i].x - m, 2) + pow(v[i].y, 2)));

    return Max;
}

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

    cout << fixed;
    cout.precision(5);

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

        vector<s> v(N);
        for(int i=0; i<N; i++) cin >> v[i].x >> v[i].y;

        double l = -2e5, r = 2e5, tr = 1e2;

        while(tr--) {
            double m1 = (l*2 + r) / 3;
            double m2 = (l + r*2) / 3;

            double a = f(v, m1);
            double b = f(v, m2);

            if(tr == 0) cout << l << " " << a << "\n";
            else if(a > b) l = m1;
            else r = m2;
        }
    }
}

백준 BOJ 21618번 : Lunch Concert

문제 난이도 : Gold IV

알고리즘 분류 : 삼분 탐색

N명의 사람이 1차원 좌표 상에 있고, 각 사람의 위치와 단위 거리 1만큼을 이동하는데 걸리는 시간, 소리를 들을 수 있는 반경이 주어질 때 어떤 좌표에서 공연을 해야 모든 사람들이 공연을 듣는데 필요한 이동 시간의 합이 최소가 되는지를 구하는 문제이다.

일단 이동 시간의 합을 구하는 것은 어렵지 않고, 이를 함수로 만들어 둔다.

이동 시간의 합이 최소가 되는 위치를 기준으로 양방향으로 멀어질수록, 이동 시간의 합이 커짐을 알 수 있고 따라서 그래프는 아래로 볼록한 개형을 가지며 삼분 탐색을 사용하여 풀이할 수 있다.

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

struct s { int x, t, r; };

int f(vector<s> v, int m) {
    int sum = 0;

    for(int i=0; i<v.size(); i++) {
        if(v[i].x - v[i].r <= m && m <= v[i].x + v[i].r) continue;
        else if(m < v[i].x - v[i].r) sum += ((v[i].x - v[i].r) - m) * v[i].t;
        else if(m > v[i].x + v[i].r) sum += (m - (v[i].x + v[i].r)) * v[i].t;
    }

    return sum;
}

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

    int N; cin >> N;

    vector<s> v(N);
    for(int i=0; i<N; i++) cin >> v[i].x >> v[i].t >> v[i].r;

    int l = 0, r = 1e9, tr = 1e2;

    while(tr--) {
        int m1 = (l*2 + r) / 3;
        int m2 = (l + r*2) / 3;

        int a = f(v, m1);
        int b = f(v, m2);

        if(a > b) l = m1;
        else r = m2;
    }

    int m = (l + r) / 2;
    int ans = f(v, m);

    cout << ans << "\n";
}

백준 BOJ 12742번, 12743번 : 혼합물 (Small), (Large)

문제 난이도 : Platinum IV

알고리즘 분류 : 삼분 탐색

A를 단위 질량만큼 만들기 위해 A_1 ~ A_N이 각각 v[i]만큼 필요하거나, 또는 B를 단위 질량만큼 만들기 위해 B_1 ~ B_N이 각각 u[i]만큼 필요하다고 할 때 A의 단위 질량 당 가격은 M이고 B의 단위 질량당 가격은 K일 때 최대로 만들 수 있는 물질의 비용과, 그 때 각 물질을 얼만큼씩 만들어야 하는지를 구하는 문제이다.

먼저 A를 만들 수 있는 최대 양 r을 찾고, l = 0일 때 [l, r] 범위 내에서 A를 만들고 나머지로 B를 최대한 만든다.

이제 만들어진 물질의 비용을 구할 수 있으며, 이 비용에 따라 삼분 탐색을 수행해주면 된다.

small, large 두 버전 모두 동일한 알고리즘으로 풀린다.

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

int N;
double M, K;
vector<double> v, u, w;
struct s { double a, b, c; };

s f(double m) {
    double Min = LLONG_MAX;

    for(int i=0; i<N; i++)
        Min = min(Min, (w[i] - m * v[i]) / u[i]);

    return {m * M + Min * K, m, Min};
}

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

    cout << fixed;
    cout.precision(2);

    cin >> N >> M >> K;

    v.resize(N);
    u.resize(N);
    w.resize(N);

    for(int i=0; i<N; i++) cin >> v[i];
    for(int i=0; i<N; i++) cin >> u[i];
    for(int i=0; i<N; i++) cin >> w[i];

    double l = 0, r = LLONG_MAX, tr = 1e2;

    for(int i=0; i<N; i++) r = min(r, w[i] / v[i]);

    while(tr--) {
        double m1 = (l*2 + r) / 3;
        double m2 = (l + r*2) / 3;

        if(f(m1).a < f(m2).a) l = m1;
        else r = m2;
    }

    double m = (l + r) / 2;

    cout << f(m).a << "\n";
    cout << f(m).b << " " << f(m).c << "\n";
}

백준 BOJ 8983번 : 사냥꾼

문제 난이도 : Gold IV

알고리즘 분류 : 삼분 탐색

x축 위에 N개의 사대가 있고, M개의 동물들의 좌표 (a, b)가 주어진다.

사대와 동물 (a, b) 사이의 거리를 |x - a| + b라고 할 때, 거리가 K 이내인 모든 동물을 사냥할 수 있다고 한다면 한 개 이상의 사대에 대해 사정 거리 이내에 있는 동물들의 개수를 구하는 문제이다.

하나의 동물에 대해 사정 거리 이내에 있는지를, 가장 거리가 가까운 사대를 찾기 위해 삼분 탐색을 사용하여 풀 수 있다.

가장 가까운 사대를 찾았으면 그 사대와의 맨해튼 거리가 K 이내인지 체크하여 counting 해주면 된다.

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

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

    int N, M, K; cin >> N >> M >> K;

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

    sort(v.begin(), v.end());

    int ans = 0;

    while(M--) {
        int x, y; cin >> x >> y;

        int l = 0, r = N-1, tr = 1e2;

        while(tr--) {
            int m1 = (l*2 + r) / 3;
            int m2 = (l + r*2) / 3;

            int d1 = abs(x - v[m1]) + y;
            int d2 = abs(x - v[m2]) + y;

            if(d1 > d2) l = m1;
            else r = m2;
        }

        bool check = false;

        for(int i=l; i<=r; i++)
            if(abs(x - v[i]) + y <= K) check = true;

        if(check) ans++;
    }

    cout << ans << "\n";
}

백준 BOJ 1087번 : 쥐 잡기

문제 난이도 : Platinum IV

알고리즘 분류 : 삼분 탐색

N개의 점의 좌표와 이동 속도가 주어질 때, 어떤 시점에서도 N개의 점이 하나의 정사각형의 내부에 동시에 포함되지 않도록 하는 가장 큰 정사각형의 한 변의 길이를 구하는 문제이다.

문제를 바꿔 말하면 N개의 점을 (정사각형의 변 위의 점까지 포함하여) 포함하는 최소 정사각형의 한 변의 길이를 구하는 문제이다.

따라서 시간 t일 때 점들의 x 좌표의 최대 최소 차이, y 좌표의 최대 최소 차이 중 큰 것을 삼분 탐색으로 구하면서 범위를 좁혀주면 된다.

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

struct s { double x, y, vx, vy; };
vector<s> v;

double f(double m) {
    double xmin = INT_MAX, ymin = INT_MAX, xmax = INT_MIN, ymax = INT_MIN;

    for(int i=0; i<v.size(); i++) {
        xmin = min(xmin, v[i].x + v[i].vx * m);
        ymin = min(ymin, v[i].y + v[i].vy * m);
        xmax = max(xmax, v[i].x + v[i].vx * m);
        ymax = max(ymax, v[i].y + v[i].vy * m);
    }

    return max(xmax - xmin, ymax - ymin);
}

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

    cout << fixed;
    cout.precision(9);

    int N; cin >> N;

    v.resize(N);
    for(int i=0; i<N; i++)
        cin >> v[i].x >> v[i].y >> v[i].vx >> v[i].vy;

    double l = 0, r = 2e3, tr = 1e2;

    while(tr--) {
        double m1 = (l*2 + r) / 3;
        double m2 = (l + r*2) / 3;

        if(f(m1) > f(m2)) l = m1;
        else r = m2;
    }

    double m = (l + r) / 2;

    cout << f(m) << "\n";
}

백준 BOJ 17574번 : Jackpot

문제 난이도 : Gold IV

알고리즘 분류 : 삼분 탐색

N개의 문 중 하나의 뒤에 상금이 있고, 상금은 문을 열 때마다 줄어들며, 초기 상금이 m이고 주어진 상수 값이 f일 때 d개의 문을 연 상태에서 남은 상금의 값 pr = m - (d * f)^2이라고 하자.

예상 수익이 당첨 확률에 남은 상금을 곱한 값이라고 할 때 예상 수익을 극대화시키기 위해서는 문을 몇 개 연 상태에서 고르는 것이 최선인지를 구하는 문제이다.

문제에서 하라는 대로 식을 구해주기만 하면 된다.

d개의 문을 열었을 때 당첨 확률은 1/(N - d)이므로, 예상 수익은 1/(N-d) x (m - (d x f)^2)이다.

이것은 위로 볼록한 그래프 개형을 가지므로 (그려서 확인하지 않더라도 문제에서 준 "최댓값"을 구하라는 표현을 보면 극대값이 존재함을 예상할 수 있다.) 삼분 탐색으로 이를 찾아주기만 하면 된다.

다만 주의할 점은 문을 모두 연 상태는 제외해야 하므로 (왜냐하면 문을 "일부" 열고 나서 최종 선택을 하는 것이므로) r = N-1로 두어야 한다.

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

double N, M, K;

double f(double m) {
    return (1.0 / (N - m)) * (M - pow(m * K, 2));
}

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

    cout << fixed;
    cout.precision(6);

    cin >> N >> M >> K;

    double l = 0, r = N-1, tr = 1e2;

    while(tr--) {
        double m1 = (l*2 + r) / 3;
        double m2 = (l + r*2) / 3;

        if(f(m1) < f(m2)) l = m1;
        else r = m2;
    }

    double m = (l + r) / 2;

    cout << f(m) << "\n";
}

세그먼트 트리 문제 풀이 모음 220924

restudy — Sat, 24 Sep 2022 22:40:08 +0900

백만년만에 문제 풀이 정리를 한다.

물론 시간 날 때마다 문제는 꾸준히 풀어오고 있다.

그동안 정리 안 한 것은 브론즈 문제들을 굳이 풀이를 정리하기에는 불필요하다고 느껴서였고, 가끔 약간의 메모가 필요한 문제들이 있으면 정리해보려고 한다.

백준 BOJ 8120번 : Coding of Permutations

문제 난이도 : Gold I

알고리즘 분류 : 세그먼트 트리

길이 N인 수열로 a_i = i번째 위치의 왼쪽에 있는 더 큰 수의 개수가 주어질 때, N에 대한 순열을 찾는 문제이다.

예를 들어 (0, 0, 1, 0, 2, 0, 4)가 주어진다면 (1, 5, 2, 6, 4, 7, 3)이 답인데 왜냐하면 1의 왼쪽에 더 큰 수가 0개, 5의 왼쪽에 더 큰 수가 0개, 2의 왼쪽에 더 큰 수가 1개, 6의 왼쪽에 더 큰 수가 0개, ...로 규칙을 만족하기 때문이다.

이 문제의 경우에는 역순으로 체크해보면서 답을 구하면 된다.

예를 들어 4가 나왔다면, 1 ~ 7 중에서 4개의 더 큰 수를 갖는 3이 맨 오른쪽에 위치함을 알 수 있다.

이제 1 ~ 7의 목록에서 3을 지운다. (즉, {1, 2, 4, 5, 6, 7})

이제 오른쪽에서 두 번째에 있는 수가 0이므로, 남은 수 중에서 0개의 더 큰 수를 갖는 7이 오른쪽에서 두 번째에 옴을 알 수 있다.

이런 식으로 풀어주면 되는데, 목록에서 수를 제거해야 하기 때문에 세그먼트 트리를 사용한다.

먼저 트리에 1 ~ N의 위치에 수를 1씩 넣어주고, 순열 (0, 0, 1, 0, 2, 0, 4)를 벡터 u에 저장했다고 가정하자.

세그먼트 트리는 벡터 v에 구현되었다고 가정하자.

그러면 v[1](= 루트 노드, 즉 트리의 현재 사이즈) - u[i]번째로 작은 원소를 출력하고 그것을 지워주면 된다.

만약 u[i] ≥ v[1]인 순간이 한 번이라도 있으면 그러한 순열은 존재하지 않는다.

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

int N, Max = 3e4 + 1;
vector<int> v(Max * 4);

void f(int n, int b, int e, int idx) {
    if(idx < b || e < idx) return;

    v[n]++;

    if(b == e) return;

    f(n*2, b, (b+e)/2, idx);
    f(n*2 + 1, (b+e)/2 + 1, e, idx);
}

int g(int n, int b, int e, int cnt) {
    v[n]--;

    if(b == e) return b;

    if(cnt <= v[n*2]) return g(n*2, b, (b+e)/2, cnt);
    else return g(n*2 + 1, (b+e)/2 + 1, e, cnt - v[n*2]);
}

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

    cin >> N;

    for(int i=1; i<=N; i++) f(1, 1, Max, i);

    vector<int> u(N+1);
    for(int i=1; i<=N; i++) cin >> u[i];

    vector<int> ans(N+1);
    for(int i=N; i>=1; i--) {
        if(u[i] >= v[1]) {
            cout << "NIE\n";
            return 0;
        }

        ans[i] = g(1, 1, Max, v[1] - u[i]);
    }

    for(int i=1; i<=N; i++) cout << ans[i] << "\n";
}

백준 BOJ 15459번 : Haybale Feast

문제 난이도 : Gold I

알고리즘 분류 : 세그먼트 트리, 두 포인터

길이 N인 수열 A, B에 대해 연속한 부분 수열을 골라 a_l ~ a_r 값이 M 이상인 것들 중 b_l ~ b_r 중 최댓값이 최소가 되도록하는 값을 구하는 문제이다.

수열 B에 대해 구간의 최솟값을 다루는 세그먼트 트리를 만들고, 수열 A에 대해 투 포인터 알고리즘을 써주면 된다.

항상 느끼지만 USACO에 정석적이고 좋은 문제가 많은 것 같다.

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

vector<int> v, w;

int init(int n, int b, int e) {
    if(b == e) return v[n] = w[b];

    int lv = init(n*2, b, (b+e)/2);
    int rv = init(n*2 + 1, (b+e)/2 + 1, e);

    return v[n] = max(lv, rv);
}

int f(int n, int b, int e, int l, int r) {
    if(r < b || e < l) return INT_MIN;
    if(l <= b && e <= r) return v[n];

    int lv = f(n*2, b, (b+e)/2, l, r);
    int rv = f(n*2 + 1, (b+e)/2 + 1, e, l, r);

    return max(lv, rv);
}

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

    int N, M; cin >> N >> M;

    vector<int> u(N+1);
    w.resize(N+1);

    for(int i=1; i<=N; i++) {
        int x; cin >> x >> w[i];

        u[i] = u[i-1] + x;
    }

    v.resize(N*4);
    init(1, 1, N);

    int i = 1, j = 1, ans = INT_MAX;

    while(j <= N) {
        int sum = u[j] - u[i-1];

        if(sum < M) j++;
        else {
            ans = min(ans, f(1, 1, N, i, j));

            i++;
            if(i > j) j = i;
        }
    }

    cout << ans << "\n";
}

백준 BOJ 12803번 : Peter and the Textbook

문제 난이도 : Silver II

알고리즘 분류 : 세그먼트 트리

1 ~ N 페이지로 구성된 책이 있고 x번째 페이지를 제거한다면 같이 제본된 N-x+1번째 페이지도 같이 제거된다고 할 때, 두 가지의 쿼리를 처리하는 문제이다.

1. - x : x번째 페이지와 N-x+1번째 페이지를 제거한다.

2. ? x : 현재 남은 페이지 중에 앞에서부터 x번째 페이지의 번호를 출력한다.

N이 매우 작으므로 세그먼트 트리를 쓸 필요는 없지만, 세그먼트 트리의 연습을 위해 세그트리로 문제를 풀어보자.

먼저 1 ~ N번째 리프 노드에 대해 모두 1로 채워주고, 그 다음 - 쿼리에 대해서는 루트 노드에서부터 1씩 감소시켜가면서 리프 노드까지 값을 처리해주면 된다.

그리고 ? 쿼리에 대해서는 왼쪽 자식의 값이 cnt 값보다 큰지 작은지를 판단하여 내려가는 방향을 달리해주어 탐색해주면 된다.

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

int Max = 1e2 + 1;
vector<int> v;

void f(int n, int b, int e, int idx) {
    if(idx < b || e < idx) return;

    v[n]++;

    if(b == e) return;

    f(n*2, b, (b+e)/2, idx);
    f(n*2 + 1, (b+e)/2 + 1, e, idx);
}

void g(int n, int b, int e, int idx) {
    if(idx < b || e < idx) return;

    v[n]--;

    if(b == e) return;

    g(n*2, b, (b+e)/2, idx);
    g(n*2 + 1, (b+e)/2 + 1, e, idx);
}

int h(int n, int b, int e, int cnt) {
    if(b == e) return b;

    if(cnt <= v[n*2]) return h(n*2, b, (b+e)/2, cnt);
    else return h(n*2 + 1, (b+e)/2 + 1, e, cnt - v[n*2]);
}

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

    int T; cin >> T;

    while(T--) {
        v.clear();
        v.resize(Max*4);

        int N, M; cin >> N >> M;

        for(int i=1; i<=N; i++) f(1, 1, Max, i);

        while(M--) {
            char Q; cin >> Q;
            int x; cin >> x;

            if(Q == '-') {
                g(1, 1, Max, x);
                g(1, 1, Max, N-x+1);
            }
            else if(Q == '?') cout << h(1, 1, Max, x) << "\n";
        }
    }
}

백준 BOJ 2104번 : 부분배열 고르기

문제 난이도 : Platinum V

알고리즘 분류 : 세그먼트 트리

길이 N인 수열이 주어질 때 연속하는 부분 수열을 골라 그 점수가 (v[l] + v[l+1] + ... + v[r]) * min(v[l] ~ v[r])이라고 할 때 점수의 최댓값을 구하는 문제이다.

백준 BOJ 6549번 : 히스토그램에서 가장 큰 직사각형 문제를 떠올려보면 같은 방법으로 풀이가 가능하다는 것을 알 수 있다.

다만 여기서는 직사각형의 넓이가 아닌 다른 점수를 사용하므로, v[l] + ... + v[r] 값을 누적 합 배열을 사용하여 w[r] - w[l-1]로 O(1)에 구할 수 있고, 이를 활용하여 점수 값을 비교하여 최댓값을 구해주면 된다.

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

int N;
vector<int> v, u, w;

int init(int n, int b, int e) {
    if(b == e) return u[n] = b;

    int lv = init(n*2, b, (b+e)/2);
    int rv = init(n*2 + 1, (b+e)/2 + 1, e);

    if(v[lv] < v[rv]) return u[n] = lv;
    else return u[n] = rv;
}

int g(int n, int b, int e, int l, int r) {
    if(r < b || e < l) return -1;
    if(l <= b && e <= r) return u[n];

    int lv = g(n*2, b, (b+e)/2, l, r);
    int rv = g(n*2 + 1, (b+e)/2 + 1, e, l, r);

    if(lv < 0) return rv;
    if(rv < 0) return lv;

    if(v[lv] < v[rv]) return lv;
    else return rv;
}

int f(int l, int r) {
    int idx = g(1, 1, N, l, r);
    int ret = (w[r] - w[l-1]) * v[idx];

    if(idx+1 <= r) ret = max(ret, f(idx+1, r));
    if(idx-1 >= l) ret = max(ret, f(l, idx-1));

    return ret;
}

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

    cin >> N;

    v.resize(N+1);
    w.resize(N+1);

    for(int i=1; i<=N; i++) {
        cin >> v[i];

        w[i] = w[i-1] + v[i];
    }

    u.resize(N*4);
    init(1, 1, N);

    cout << f(1, N) << "\n";
}

백준 BOJ 1989번 : 부분배열 고르기 2

문제 난이도 : Platinum V

알고리즘 분류 : 세그먼트 트리

위의 문제와 동일하나 이번에는 구간의 주소까지 구해주어야 하는 문제이다.

시간 복잡도를 줄여야 하거나 다른 전략을 사용해야 하는 것은 아니고, left 값과 right 값을 인자로 같이 전달해주기만 하면 된다.

구조체를 사용하여 3개의 값을 한꺼번에 전달할 수 있도록 구현하였다.

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

int N;
vector<int> v, u, w;

int init(int n, int b, int e) {
    if(b == e) return u[n] = b;

    int lv = init(n*2, b, (b+e)/2);
    int rv = init(n*2 + 1, (b+e)/2 + 1, e);

    if(v[lv] < v[rv]) return u[n] = lv;
    else return u[n] = rv;
}

int g(int n, int b, int e, int l, int r) {
    if(r < b || e < l) return -1;
    if(l <= b && e <= r) return u[n];

    int lv = g(n*2, b, (b+e)/2, l, r);
    int rv = g(n*2 + 1, (b+e)/2 + 1, e, l, r);

    if(lv < 0) return rv;
    if(rv < 0) return lv;

    if(v[lv] < v[rv]) return lv;
    else return rv;
}

struct s { int l, r, a; };

s f(int l, int r) {
    int idx = g(1, 1, N, l, r);
    int area = (w[r] - w[l-1]) * v[idx];

    s ret = {l, r, area};

    if(idx+1 <= r) {
        s tmp = f(idx+1, r);

        if(tmp.a > ret.a) ret = tmp;
    }
    if(idx-1 >= l) {
        s tmp = f(l, idx-1);

        if(tmp.a > ret.a) ret = tmp;
    }

    return ret;
}

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

    cin >> N;

    v.resize(N+1);
    w.resize(N+1);

    for(int i=1; i<=N; i++) {
        cin >> v[i];

        w[i] = w[i-1] + v[i];
    }

    u.resize(N*4);
    init(1, 1, N);

    s ans = f(1, N);

    cout << ans.a << "\n";
    cout << ans.l << " " << ans.r << "\n";
}

백준 BOJ 11143번 : Beads

문제 난이도 : Gold I

알고리즘 분류 : 세그먼트 트리

N개의 상자가 있고, 쿼리 P에 대해서는 a번 상자에 구슬 b개를 추가하고, 쿼리 Q에 대해서는 a번 상자부터 b번 상자까지 모든 구슬의 개수의 합을 구하는 처리를 하는 문제이다.

구간 합 구하기 문제를 활용하여 거의 비슷하게 풀이할 수 있다.

일단 초기 상자들에는 구슬이 모두 0개 들어있으므로 init 함수와 같은 것을 구현할 필요가 없다.

값을 갱신할 때는 특정 인덱스의 값을 바꾸는 것이 아닌 더하는 것이므로, diff = b로 설정해주고 v[a] += b와 같이 해주면 갱신이 가능하다.

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

vector<int> v, u;

void upd(int n, int b, int e, int idx, int diff) {
    if(idx < b || e < idx) return;

    u[n] += diff;

    if(b < e) {
        upd(n*2, b, (b+e)/2, idx, diff);
        upd(n*2 + 1, (b+e)/2 + 1, e, idx, diff);
    }
}

int f(int n, int b, int e, int l, int r) {
    if(r < b || e < l) return 0;
    if(l <= b && e <= r) return u[n];

    return f(n*2, b, (b+e)/2, l, r) + f(n*2 + 1, (b+e)/2 + 1, e, l, r);
}

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

    int T; cin >> T;

    while(T--) {
        int N, M, K; cin >> N >> M >> K;

        v.clear();
        v.resize(N+1);

        u.clear();
        u.resize(N*4);

        M += K;

        while(M--) {
            char Q; int a, b; cin >> Q >> a >> b;

            if(Q == 'P') {
                int diff = b;
                v[a] += b;
                upd(1, 1, N, a, diff);
            }
            else if(Q == 'Q') cout << f(1, 1, N, a, b) << "\n";
        }
    }
}

백준 BOJ 새로 나온 문제들 풀어보기 220904

restudy — Sun, 4 Sep 2022 15:31:33 +0900

백준 BOJ 25513번 : 빠른 오름차순 숫자 탐색

문제 난이도 : Gold V

알고리즘 분류 : BFS

주어진 5 x 5 크기의 배열에서, 특정 위치에서 시작하여 1, 2, 3, 4, 5, 6을 순서대로 방문하는 최소 경로의 길이를 구하는 문제이다. (이 때, -1은 지나갈 수 없는 칸이며 만약 순서대로 방문하는 것이 불가능하다면 -1을 출력해야 한다.)

BFS를 반복문으로 여러 번 사용하는 문제이다.

초기 위치에서 cur(1 ~ 6으로 반복문을 돌려준다.)를 방문하는 BFS를 구현하고, 방문이 되었다면 초기 위치를 해당 칸의 위치로 바꿔주고 다음 루프를 돌면 된다.

만약 방문이 불가능하다면 -1을 출력해주고 즉시 종료해주면 된다.

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

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

    vector<vector<int>> v(5, vector<int>(5));

    for(int i=0; i<5; i++)
        for(int j=0; j<5; j++) cin >> v[i][j];

    int si, sj; cin >> si >> sj;

    int ans = 0;

    for(int cur=1; cur<=6; cur++) {
        queue<pair<int, int>> q;
        q.push({si, sj});

        vector<vector<int>> dis(5, vector<int>(5, -1));
        dis[si][sj] = 0;

        bool check = false;

        while(!q.empty()) {
            int x = q.front().first;
            int y = q.front().second;
            q.pop();

            if(v[x][y] == cur) {
                ans += dis[x][y];
                si = x, sj = y;

                check = true;
                break;
            }

            int dx[4] = {1, -1, 0, 0};
            int dy[4] = {0, 0, 1, -1};

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

                if(nx < 0 || ny < 0 || nx >= 5 || ny >= 5) continue;
                if(dis[nx][ny] != -1 || v[nx][ny] == -1) continue;

                dis[nx][ny] = dis[x][y] + 1;
                q.push({nx, ny});
            }
        }

        if(!check) {
            cout << -1 << "\n";
            return 0;
        }
    }

    cout << ans << "\n";
}

백준 BOJ 25512번 : 트리를 간단하게 색칠하는 최소 비용

문제 난이도 : Silver I

알고리즘 분류 : 트리, 그래프 탐색

주어진 트리에 대해 각 노드를 검은색 또는 흰색으로 칠하는 비용이 주어지고, 인접한 노드는 다른 색으로 칠하려고 할 때 모든 노드를 칠하는 최소 비용을 구하는 문제이다.

트리이기 때문에 사이클이 없고, 따라서 하나의 노드의 색을 결정하면 모든 나머지 노드들의 색이 결정된다.

따라서 루트 노드를 검은색으로 칠하는 경우와, 흰색으로 칠하는 경우 두 가지를 구한 뒤 비교해서 최솟값을 출력해주면 된다.

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

int N;
vector<vector<int>> adj;
vector<int> v, u;
int a = 0, b = 0;

void f(int x, int pre) {
    if(pre == 0) a += v[x];
    else a += u[x];

    for(int i=0; i<adj[x].size(); i++) {
        if(pre == 0) f(adj[x][i], 1);
        else f(adj[x][i], 0);
    }
}

void g(int x, int pre) {
    if(pre == 0) b += v[x];
    else b += u[x];

    for(int i=0; i<adj[x].size(); i++) {
        if(pre == 0) g(adj[x][i], 1);
        else g(adj[x][i], 0);
    }
}

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

    cin >> N;

    adj.resize(N);

    for(int i=0; i<N-1; i++) {
        int a, b; cin >> a >> b;

        adj[a].push_back(b);
    }

    v.resize(N);
    u.resize(N);

    for(int i=0; i<N; i++) cin >> v[i] >> u[i];

    f(0, 0);

    g(0, 1);

    cout << min(a, b) << "\n";
}

백준 BOJ 25516번 : 거리가 k이하인 트리 노드에서 사과 수확하기

문제 난이도 : Silver II

알고리즘 분류 : 트리, 그래프 탐색

트리가 주어지고, 루트 노드에서 거리가 k 이하인 노드들에서만 사과를 수확할 때 그 개수를 구하는 문제이다. (각 노드의 사과 개수가 주어진다.)

깊이가 k 이하인 노드를 모두 방문하여 노드의 사과 개수를 답에 더해준 뒤, 답을 출력해주면 된다.

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

int N, M, ans = 0;
vector<vector<int>> adj;
vector<int> v;

void f(int x, int dep) {
    ans += v[x];

    if(dep == M) return;

    for(int i=0; i<adj[x].size(); i++) f(adj[x][i], dep+1);
}

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

    cin >> N >> M;

    adj.resize(N);

    for(int i=0; i<N-1; i++) {
        int a, b; cin >> a >> b;

        adj[a].push_back(b);
    }

    v.resize(N);
    for(int i=0; i<N; i++) cin >> v[i];

    f(0, 0);

    cout << ans << "\n";
}

백준 BOJ 25511번 : 값이 k인 트리 노드의 깊이

문제 난이도 : Silver II

알고리즘 분류 : 트리, 그래프 탐색

트리에서 각 노드가 가지는 값이 따로 주어질 때, 값 k를 가지는 노드의 깊이를 구하는 문제이다.

루트 노드에서부터 재귀적으로 탐색하다가 노드 값이 k인 노드를 방문했을 때의 깊이를 답으로 저장해준다.

탐색이 끝나고 나서 답을 출력해주면 된다.

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

int N, M;
vector<vector<int>> adj;
vector<int> v;
int ans;

void f(int x, int dep) {
    if(v[x] == M) ans = dep;

    for(int i=0; i<adj[x].size(); i++) f(adj[x][i], dep+1);
}

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

    cin >> N >> M;

    adj.resize(N);

    for(int i=0; i<N-1; i++) {
        int a, b; cin >> a >> b;

        adj[a].push_back(b);
    }

    v.resize(N);
    for(int i=0; i<N; i++) cin >> v[i];

    f(0, 0);

    cout << ans << "\n";
}

백준 BOJ 25527번 : Counting Peaks of Infection

문제 난이도 : Bronze III

알고리즘 분류 : 구현

문제 제목 그대로 그래프의 피크의 개수를 구하는 문제이다.

v[i] > v[i-1]이면서 동시에 v[i] < v[i+1]인 i의 개수를 세어주면 된다.

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

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

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

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

        int ans = 0;

        for(int i=1; i<N-1; i++)
            if(v[i] > v[i-1] && v[i] > v[i+1]) ans++;

        cout << ans << "\n";
    }
}

무작위화 알고리즘 문제 풀이 모음 220903

restudy — Sun, 4 Sep 2022 02:55:43 +0900

백준 BOJ 12041번 : Password Security (Small 2)

문제 난이도 : Gold III

알고리즘 분류 : 무작위화, 구성적

모든 대문자 알파벳을 하나씩 사용하여 26자리 비밀번호를 만들 때, 해당 비밀번호가 N개의 주어진 문자열을 포함하지 않도록 만드는 문제이다.

1 ~ 26으로 이루어진 순열을 무작위로 만든 뒤, 이 순열에 해당하는 문자열이 N개의 문자열을 포함하지 않을 때까지 돌리면 된다.

문제는 아예 불가능한 경우가 있는데, 이를 해결하기 위해 1만번까지는 돌려보고, 그래도 해당하는 정답이 없으면 impossible로 간주해주면 모든 테스트케이스를 통과할 수 있다.

(참고로 1천번은 넉넉하지 않아 WA를 받을 확률이 높다.)

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

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

    mt19937 mt((unsigned int)time(NULL));
    uniform_int_distribution<int> uid(0, INT_MAX);
    auto rd = bind(uid, mt);

    int T; cin >> T;

    for(int t=1; t<=T; t++) {
        int N; cin >> N;

        vector<string> v(N);
        for(int i=0; i<N; i++) cin >> v[i];

        bool found = false;

        for(int r=0; r<1e4; r++) {
            vector<int> u;
            vector<bool> w(26);

            while(u.size() < 26) {
                int x = rd() % 26;

                if(!w[x]) {
                    u.push_back(x);
                    w[x] = true;
                }
            }

            string str = "";

            for(int i=0; i<u.size(); i++) str += char('A' + u[i]);

            bool check = true;

            for(int i=0; i<N; i++)
                if(str.find(v[i]) >= 0 && str.find(v[i]) < str.length()) check = false;

            if(check) {
                cout << "Case #" << t << ": " << str << "\n";

                found = true;
                break;
            }
        }

        if(!found) cout << "Case #" << t << ": IMPOSSIBLE\n";
    }
}

같은 코드로 백준 BOJ 12040번 : Password Security (Small 1)을 풀 수 있다.

백준 BOJ 18205번 : Farming Mars

문제 난이도 : Gold IV

알고리즘 분류 : 무작위화, 값/좌표 압축

N개 토양의 산성도가 주어지고, 사용할 수 있는 땅이란 그 구간에서 절반보다 많은 값들이 동일한 산성도를 가지는 땅이라고 할 때, M개 쿼리에 대해 [l, r] 구간을 사용할 수 있는지 구하는 문제이다.

백준 BOJ 2912번 : 백설공주와 난쟁이에서 풀었던 방식과 똑같이 구현했다.

다만 여기서는 소수점 아래 6자리까지 비교해야하므로, 1e6을 곱해준 뒤 좌표 압축을 해주었다.

브루트포스로 돌아간다고 한다. (범위만 조금 더 컸어도 비슷한 문제가 있어 나름 꿀문제인데..)

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

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

    mt19937 mt((unsigned int)time(NULL));
    uniform_int_distribution<int> uid(0, INT_MAX);
    auto rd = bind(uid, mt);

    int N, M; cin >> N >> M;

    vector<int> v(N), u(N);
    for(int i=0; i<N; i++) {
        double x; cin >> x;

        int y = x * 1e6;

        v[i] = u[i] = y;
    }

    sort(u.begin(), u.end());
    u.erase(unique(u.begin(), u.end()), u.end());

    vector<int> w(N);
    for(int i=0; i<v.size(); i++)
        w[i] = lower_bound(u.begin(), u.end(), v[i]) - u.begin();

    vector<vector<int>> vv(1e4 + 1);

    for(int i=0; i<N; i++) vv[w[i]].push_back(i);

    while(M--) {
        int l, r; cin >> l >> r;

        l--, r--;

        bool check = false;

        for(int i=0; i<100; i++) {
            int x = w[l + (rd() % (r-l+1))];

            int cnt = upper_bound(vv[x].begin(), vv[x].end(), r) - lower_bound(vv[x].begin(), vv[x].end(), l);

            if(cnt > (r-l+1)/2) {
                cout << "usable\n";

                check = true;
                break;
            }
        }

        if(!check) cout << "unusable\n";
    }
}

백준 BOJ 23271번 : Grzaed Grains

문제 난이도 : Gold IV

알고리즘 분류 : 무작위화

(x, y)를 중심으로 반지름 r인 원이 10개 이하로 존재할 때 이 원들의 합집합의 넓이를 구하는 문제이다. (x, y, r 모두 -10 ~ 10 사이의 정수이며, 답은 오차 범위 10% 이내이기만 하면 된다.)

범위가 매우 작고, 오차 범위는 매우 크다.

이 문제에 한해서만 특이한 방법으로 풀 수가 있는데, 바로 점들을 무작위로 찍어서 포함되는 비율을 이용하여 구하는 것이다.

나의 경우에는 -20 ~ 20 사이의 x, y 좌표에 해당하는 실수를 만들어서 1e6번 찍어보고, 그 중 포함되는 것의 비율을 이용하여 전체 넓이에 대한 비율로 답을 구하였다.

자세한 구현은 아래의 코드를 참고하자.

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

struct s { int x, y, r; };

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

    mt19937 mt((unsigned int)time(NULL));
    uniform_int_distribution<int> uid(0, INT_MAX);
    auto rd = bind(uid, mt);

    int N; cin >> N;

    vector<s> v(N);
    for(int i=0; i<N; i++)
        cin >> v[i].x >> v[i].y >> v[i].r;

    int cnt = 0;

    for(int att=1; att<=1e6; att++) {
        bool check = false;

        double x = ((rd() % (int)1e5) / 1e5) * 40 - 20;
        double y = ((rd() % (int)1e5) / 1e5) * 40 - 20;

        for(int i=0; i<N; i++)
            if(pow(x - v[i].x, 2) + pow(y - v[i].y, 2) <= pow(v[i].r, 2)) check = true;

        if(check) cnt++;
    }

    double ans = pow(40, 2) * (cnt / 1e6);

    cout << ans << "\n";
}

백준 BOJ 21960번 : Consul

문제 난이도 : Gold V

알고리즘 분류 : 무작위화, 애드 혹 (+ 함수 구현)

N명의 선거인단이 10억명 이하의 후보 중 하나를 뽑았다고 할 때, 쿼리를 50회 이하로 사용하여 N/3보다 큰 인원에게 선발된 후보가 있는지 찾는 문제이다. (있으면 번호를 구하고, 없으면 -1을 제출)

사용할 수 있는 쿼리로는 다음의 것이 있다.

kth(int i) : i번째 후보가 뽑은 후보의 번호를 리턴

cnt(int x) : x번 후보가 뽑힌 횟수

say_answer(int a) : 답을 a로 제출

만약 N/3회 이상 뽑힌 사람이 있다면, 랜덤으로 아무 유권자나 뽑아서 그 사람이 뽑은 번호가 N/3회 이상 나왔는지 확인해보면 되고, 한 번 검사마다 1/3의 확률로 답이 나온다. (이 때 쿼리는 cnt(kth(x))로 하면 되고, 이 때 쿼리는 2회 사용된다.)

따라서 이러한 수행을 최대한으로, 예를 들어 10번 해준다고 치면 답이 얻어질 확률은 1 - (2/3)^10으로 거의 무조건 답을 얻을 수 있다.

이제 최대 쿼리 개수만 찾아주면 되는데, 1번 서브테스크에서 Q ≤ 50 이하여야 만점이라고 하였으므로, 대략 24회 정도 cnt(kth(x))을 사용해주면 된다.

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

int kth(int k);
void say_answer(int k);
int cnt(int k);

void solve(int n)
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL), cout.tie(NULL);

    mt19937 mt((unsigned int)time(NULL));
    uniform_int_distribution<int> uid(0, 1e5);
    auto rd = bind(uid, mt);
    
    bool check = false;

    for(int i=0; i<24; i++) {
        int x = rd() % n + 1;
        
        if(cnt(kth(x)) > n/3) {
            say_answer(kth(x));
            
            check = true;
            break;
        }
    }
    
    if(!check) say_answer(-1);
}

백준 BOJ 15860번 : Ninety-nine

문제 난이도 : Silver III

알고리즘 분류 : 게임 이론, 인터랙티브 (+ 무작위화)

0에서부터 시작하여 프로그램과 번갈아가며 1 또는 2를 더해서 99를 먼저 완성하는 인터랙티브 문제이다.

원래라면 3의 배수만 불러주면 되는데, 내가 먼저 시작하는 입장이기 때문에 최소한 한 번은 뒤집어야 한다.

그렇기 때문에 일단은 무작위로 1 또는 2를 더해서 출력하다가, 3의 배수를 취할 수 있으면 바로 취해주는 방식을 택한다.

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

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

    mt19937 mt((unsigned int)time(NULL));
    uniform_int_distribution<int> uid(0, INT_MAX);
    auto rd = bind(uid, mt);

    int x = 0;

    while(true) {
        if(x % 3 == 0) x += (rd() % 2 + 1);
        else if(x % 3 == 1) x += 2;
        else if(x % 3 == 2) x += 1;

        cout << x << endl;

        if(x >= 99) break;

        cin >> x;

        if(x >= 99) break;
    }
}

백준 BOJ 16972번 : 814 - 1

문제 난이도 : Bronze I

알고리즘 분류 : 무작위화

2차원 좌표 평면 상의 814개의 점들을 두 점의 거리가 같은 쌍이 존재하지 않도록 출력하는 문제이다.

이 때 모든 점들의 좌표는 -8140 ~ 8140 사이의 정수여야 한다.

mt19937을 이용하여 랜덤으로 814개의 점들을 출력해주면 대부분 맞는다.

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

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

    mt19937 mt((unsigned int)time(NULL));
    uniform_int_distribution<int> uid(0, INT_MAX);
    auto rd = bind(uid, mt);

    for(int i=0; i<814; i++)
        cout << (rd() % 16280) - 8140 << " " << (rd() % 16280) - 8140 << "\n";
}

백준 BOJ 20067번 : Nowruz 1

문제 난이도 : Gold V

알고리즘 분류 : 무작위화, 구성적

이 문제는 무작위화를 이용해서 풀려다가 실패해서 아래에 배치한다.

N x M 크기의 배열이 주어지고, 점이 있는 위치에 X들을 적절히 배치해서 모든 점들 사이의 경로가 유일하며, 막다른 길(점 주위의 3칸이 # 또는 X로 둘러싸임)이 K개 만들어지도록 하는 문제이다.

1 ~ 10까지 문제가 있는데 1번 문제의 경우에는 범위가 작아서 노가다로 풀 수 있다.

X.X.#.X.X.X#.X#X
..#.............
X...X.X.X.X#.X.X
..XX.X##.XX.X..#
X##..........X..
....XX.XX.#.X..X
X.X##...X..X..#X
...X.X.XXX..X...
X.X.....X..X.X.X
...X.#.X.X...X..
X.X.XX....#X.X.X
....X..X.XX..X.X
#.X.XX.X#XXX.X..
...XX.X.X.X.XX.X
X#..............
XX.X.X.X.X.X.XXX

Mo's 알고리즘 (모스 알고리즘) 구현해보기 220902

restudy — Thu, 1 Sep 2022 23:30:05 +0900

Mo's 알고리즘이란 오프라인 쿼리(= 원소의 업데이트가 없어야 함)를 특정한 순서로 배치하여 효율적으로 처리하는 알고리즘이다.

보통 제곱근 분할법(= 루트 N개의 버킷으로 나누어, 원소들을 버킷 단위로 다루다가 필요할 때 원소 단위로 들어가 값을 다룸)을 활용하여 하나의 쿼리를 O(√N) 시간에 처리할 수 있다는 점에서 특이한 시간 복잡도를 갖는다.

** kks227님의 블로그를 통해 공부하였다. 문제도 거기서 소개한 문제들을 공부했다.

백준 BOJ 11659번 : 구간 합 구하기 (연습용)

문제 난이도 : Silver III

알고리즘 분류 : 누적 합 (..이지만? Mo's 알고리즘으로 풀어보았다.)

굳이 Mo's 알고리즘까지 필요하지는 않지만, 쿼리들을 재배치하여 풀어볼 수 있는 문제라는 점에서 한 번쯤 이런 방식으로 풀어보는 것도 나쁘지 않은 것 같다.

쿼리들의 구간 left, right 값에 따라 sqrt(N) 크기로 쪼개어 정렬하였으므로, 최악의 경우에도 각 쿼리마다 왼쪽 끝을 조정하는데에는 √N번을 넘어가지 않는다.

그리고 오른쪽 끝은 모든 쿼리를 통틀어 N번 이상 이동이 발생하지 않으므로, 둘을 종합해보면 O(M√N + N)이다.

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

int S;
struct query { int l, r, n; };

bool cmp(query a, query b) {
    if(a.l / S != b.l / S) return a.l / S < b.l / S;
    else return a.r < b.r;
}

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

    int N, M; cin >> N >> M;

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

    S = sqrt(N);

    vector<query> Q(M);

    for(int i=0; i<M; i++) {
        int a, b; cin >> a >> b;

        Q[i].l = a - 1, Q[i].r = b - 1, Q[i].n = i;
    }

    sort(Q.begin(), Q.end(), cmp);

    vector<int> ans(M);
    int tmp = 0, l = Q[0].l, r = Q[0].r;

    for(int i=l; i<=r; i++) tmp += v[i];
    ans[Q[0].n] = tmp;

    for(int i=1; i<M; i++) {
        while(Q[i].l < l) tmp += v[--l];
        while(Q[i].r > r) tmp += v[++r];

        while(Q[i].l > l) tmp -= v[l++];
        while(Q[i].r < r) tmp -= v[r--];

        ans[Q[i].n] = tmp;
    }

    for(int i=0; i<M; i++) cout << ans[i] << "\n";
}

백준 BOJ 13547번 : 수열과 쿼리 5

문제 난이도 : Platinum II

알고리즘 분류 : 오프라인 쿼리, Mo's

쿼리 a b에 대해 a ~ b 구간 사이의 서로 다른 수의 개수를 구하는 문제이다.

역시 마찬가지로 쿼리를 left / S 값의 오름차순, 그리고 left / S가 동률일 경우 right 값을 오름차순으로 정렬해준다.

첫 쿼리에 대해서는 개수를 일일이 세어서 구해준다.

그 다음 각 쿼리들에 대해서 정렬된 순서대로 구간을 변경하며 각 수들을 count 해주면서 답을 구해주면 된다.

수를 증가시켰는데 원래 0이었으면 수의 종류가 하나 늘어난 것이고, 수를 감소시켰는데 0이 된다면 수의 종류가 하나 감소한 것이다.

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

int S;
struct query { int l, r, n; };

bool cmp(query a, query b) {
    if(a.l / S != b.l / S) return a.l / S < b.l / S;
    else return a.r < b.r;
}

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

    int N; cin >> N;

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

    S = sqrt(N);

    int M; cin >> M;

    vector<query> Q(M);

    for(int i=0; i<M; i++) {
        int a, b; cin >> a >> b;

        Q[i].l = a - 1, Q[i].r = b - 1, Q[i].n = i;
    }

    sort(Q.begin(), Q.end(), cmp);

    vector<int> ans(M), cnt(1e6 + 1);
    int val = 0, l = Q[0].l, r = Q[0].r;

    for(int i=l; i<=r; i++) {
        if(cnt[v[i]] == 0) val++;
        cnt[v[i]]++;
    }

    ans[Q[0].n] = val;

    for(int i=1; i<M; i++) {
        while(Q[i].l < l)
            if(cnt[v[--l]]++ == 0) val++;

        while(Q[i].r > r)
            if(cnt[v[++r]]++ == 0) val++;

        while(Q[i].l > l)
            if(--cnt[v[l++]] == 0) val--;

        while(Q[i].r < r)
            if(--cnt[v[r--]] == 0) val--;

        ans[Q[i].n] = val;
    }

    for(int i=0; i<M; i++) cout << ans[i] << "\n";
}

백준 BOJ 2912번 : 백설공주와 난쟁이

문제 난이도 : Platinum II

알고리즘 분류 : 무작위화, 오프라인 쿼리, Mo's

N개의 (10,000 이하의) 수가 주어지고, K개의 쿼리 a b에 대해 a ~ b 구간에서 절반보다 많이 나타나는 수가 있는지 확인하고 그러한 수가 있다면 그것을 구하는 문제이다.

원래 Mo's로 먼저 접근해보려 했는데 구간에 따라 과반수 이상인 수가 바뀌면 갱신을 어떻게 해야할지 모르겠어서 일단 다른 방법으로 푸는 방식을 참고했다.

방법은 이러한데, 먼저 주어진 구간에서 하나의 수를 랜덤으로 고른다.

그 다음 그 수가 구간에서 절반 이상 나왔는지 체크하여 그렇다면 바로 출력해준다.

최악의 경우 어떤 수가 절반에 아주 가까운 과반수라고 하더라도 랜덤으로 뽑았을 때 그 수가 나타날 확률은 1/2보다 많다.

따라서 과반수 이상 존재하는 수가 있음에도 100번 뽑아서 그 수가 나타나지 않을 확률은 (1/2)^100보다 작다.

문제는 어떤 수가 구간에서 절반 이상 나왔는지 빠르게 체크하는 방법인데, 이것은 처음에 배열을 입력받을 때 2차원 벡터에서 해당 수의 주소에 그 수의 주소를 push_back 해준다.

그러면 나중에 어떤 수 x가 l ~ r 구간에서 몇 번 나왔는지 체크할 때, upper_bound(u[x].begin(), u[x].end(), r) - lower_bound(u[x].begin(), u[x].end(), l); 의 방식으로 O(log M) 시간에 확인할 수 있다.

난수 생성은 mt19937, 메르센 트위스터라는 난수 생성기를 이용하여 구현해보았다. (처음 써본다.)

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

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

    mt19937 mt((unsigned int)time(NULL));
    uniform_int_distribution<int> uid(0, INT_MAX);
    auto rd = bind(uid, mt);

    int N, M; cin >> N >> M;

    vector<int> v(N+1);
    vector<vector<int>> u(M+1);

    for(int i=1; i<=N; i++) {
        cin >> v[i];

        u[v[i]].push_back(i);
    }

    int K; cin >> K;

    while(K--) {
        int l, r; cin >> l >> r;

        bool check = false;

        for(int i=0; i<100; i++) {
            int x = v[l + (rd() % (r-l+1))];

            int cnt = upper_bound(u[x].begin(), u[x].end(), r) - lower_bound(u[x].begin(), u[x].end(), l);

            if(cnt > (r-l+1)/2) {
                cout << "yes " << x << "\n";

                check = true;
                break;
            }
        }

        if(!check) cout << "no\n";
    }
}

백준 BOJ 문제 풀이 기록 220831

restudy — Wed, 31 Aug 2022 12:46:50 +0900

백준 BOJ 18017번 : 총알의 속도

문제 난이도 : 난이도를 매길 수 없음

알고리즘 분류 : 물리학

A m/s로 달리며 B m/s로 총알을 발사했을 때 총알의 속력을 구하는 문제이다.

이 때 A, B는 10^8 이하이며, 10^(-9) 이내의 오차로 답을 구해야 한다.

상대성 이론을 사용하는 문제이다.

왜냐하면 속력이 10^8 수준까지 매우 커지면 빛의 속력을 고려할 필요가 있기 때문이다.

따라서 다음의 공식을 사용한다.

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

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

    double a, b; cin >> a >> b;

    double c = 299792458;

    double ans = (a + b) / (1 + (a * b) / (c * c));

    cout << fixed;
    cout.precision(9);

    cout << ans << "\n";
}

백준 BOJ 3154번 : 알람시계

문제 난이도 : Bronze I

알고리즘 분류 : 브루트포스

시간을 맞출 때 시는 24로 나눈 나머지로, 분은 60으로 나눈 나머지로 자동으로 맞춰진다고 할 때 번호키 사이의 맨해튼 거리의 합이 가장 작도록 시간을 입력하려면 어떻게 입력해야 하는지 구하는 문제이다.

번호키가 수식 하나로 거리를 나타내기 어려우므로, 일단은 번호와 번호 사이의 거리를 모두 구해주고 00:00부터 99:99까지 중에 조건에 해당하면서 가장 거리의 합이 작은 것을 구해주면 된다.

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

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

    int a, b; scanf("%02d:%02d", &a, &b);

    int v[10][10] = {{0, 4, 3, 4, 3, 2, 3, 2, 1, 2},
                     {4, 0, 1, 2, 1, 2, 3, 2, 3, 4},
                     {3, 1, 0, 1, 2, 1, 2, 3, 2, 3},
                     {4, 2, 1, 0, 3, 2, 1, 4, 3, 2},
                     {3, 1, 2, 3, 0, 1, 2, 1, 2, 3},
                     {2, 2, 1, 2, 1, 0, 1, 2, 1, 2},
                     {3, 3, 2, 1, 2, 1, 0, 3, 2, 1},
                     {2, 2, 3, 4, 1, 2, 3, 0, 1, 2},
                     {1, 3, 2, 3, 2, 1, 2, 1, 0, 1},
                     {2, 4, 3, 2, 3, 2, 1, 2, 1, 0}};

    int Min = INT_MAX, x, y;

    for(int i=0; i<100; i++)
        for(int j=0; j<100; j++) {
            if(i % 24 != a || j % 60 != b) continue;

            int sum = v[i/10][i%10] + v[i%10][j/10] + v[j/10][j%10];

            if(sum < Min) {
                Min = sum;
                x = i, y = j;
            }
        }

    printf("%02d:%02d\n", x, y);
}

백준 BOJ 5371번 : Annoying Mosquitos

문제 난이도 : Bronze I

알고리즘 분류 : 브루트포스

N개의 모기의 좌표가 주어지고, M개의 파리채의 중심 좌표가 주어질 때, 파리채는 중심 좌표를 기준으로 가로 세로 ±50만큼의 범위에 있는 모기를 잡을 수 있다고 한다면 잡을 수 있는 모기의 수를 구하는 문제이다.

브루트포스로 각 파리채의 위치에 대해 잡히는 모기들을 bool 변수로 check 해주면 된다.

모든 파리채 검사 이후 최종적으로 check 되어있는 모기들의 수를 구하면 된다.

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

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

    int T; cin >> T;

    while(T--) {
        int N; cin >> N;

        vector<pair<int, int>> v(N);
        for(int i=0; i<N; i++)
            cin >> v[i].first >> v[i].second;

        vector<bool> u(N);

        int M; cin >> M;

        while(M--) {
            int x, y; cin >> x >> y;

            for(int i=0; i<N; i++) {
                if(v[i].first <= x + 50 && v[i].first >= x - 50
                   && v[i].second <= y + 50 && v[i].second >= y - 50) u[i] = true;
            }
        }

        int ans = 0;

        for(int i=0; i<N; i++)
            if(u[i]) ans++;

        cout << ans << "\n";
    }
}

백준 BOJ 5768번 : Divide and Conquer

문제 난이도 : Bronze I

알고리즘 분류 : 브루트포스

주어진 a ~ b 사이의 수 중에서 약수의 개수가 가장 많은 것, 그리고 그러한 수가 여러 개라면 가장 큰 수를 구하고, 그 약수의 개수를 구하는 문제이다.

직접 a ~ b 사이의 모든 수들에 대해 약수의 개수를 구해보면서 그들 중 가장 큰 수를 구해주면 된다.

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

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

    while(true) {
        int a, b; cin >> a >> b;
        if(a == 0 && b == 0) break;

        int Max = 0, ans;

        for(int i=a; i<=b; i++) {
            int cnt = 0;

            for(int j=1; j<=i; j++) {
                if(i % j == 0) cnt++;
            }

            if(cnt >= Max) {
                Max = cnt;
                ans = i;
            }
        }

        cout << ans << " " << Max << "\n";
    }
}

백준 BOJ 6367번 : Color Me Less

문제 난이도 : Bronze I

알고리즘 분류 : 브루트포스

16개의 값들 중 RGB 거리가 가장 가까운 것을 매칭시켜주는 문제이다.

매 테스트케이스마다 16개의 값들에 대한 거리를 직접 구한 뒤 그들 중 가장 작은 것을 직접 찾아주면 된다.

특별히 다른 처리를 하지 않았는데 맞는 것을 보면 RGB 거리가 같은 두 점이 존재하지는 않는 것 같다.

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

struct s { int a, b, c; };

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

    vector<s> v(16);
    for(int i=0; i<16; i++)
        cin >> v[i].a >> v[i].b >> v[i].c;

    while(true) {
        int a, b, c; cin >> a >> b >> c;
        if(a == -1 && b == -1 && c == -1) break;

        int Min = INT_MAX, x, y, z;

        for(int i=0; i<16; i++) {
            int val = pow(a - v[i].a, 2) + pow(b - v[i].b, 2) + pow(c - v[i].c, 2);

            if(val < Min) {
                Min = val;
                x = v[i].a, y = v[i].b, z = v[i].c;
            }
        }

        cout << "(" << a << "," << b << "," << c << ") maps to ("
              << x << "," << y << "," << z << ")\n";
    }
}

백준 BOJ 11321번 : Addition Affliction

문제 난이도 : Bronze I

알고리즘 분류 : 브루트포스

두 수를 더한 일의 자리가 0이 되는 조합을 먼저 계산하도록 수식의 앞에 배치해주는 문제이다.

앞에서부터 2중 for문을 돌리며 두 수의 합이 10으로 나누어떨어지는 것들을 체크해서 벡터에 push back 해주면 된다.

이미 체크가 된 것은 건너뛰어주어야 한다.

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

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

    while(true) {
        string str; cin >> str;
        if(str == "0") break;

        vector<int> v;
        string tmp = "";

        for(int i=0; i<str.length(); i++) {
            if(str[i] != '+') tmp += str[i];
            else {
                v.push_back(stoi(tmp));
                tmp = "";
            }
        }
        v.push_back(stoi(tmp));
        tmp = "";

        vector<bool> u(v.size());
        bool fir = true;

        for(int i=0; i<v.size(); i++) {
            if(u[i]) continue;

            int idx = -1;

            for(int j=i+1; j<v.size(); j++) {
                if((v[i] + v[j]) % 10 == 0 && !u[j]) idx = j;
            }

            if(idx != -1) {
                if(fir) fir = false;
                else cout << "+";

                cout << v[i] << "+" << v[idx];
                u[i] = u[idx] = true;
            }
        }

        for(int i=0; i<u.size(); i++)
            if(!u[i]) {
                if(fir) fir = false;
                else cout << "+";

                cout << v[i];
            }

        cout << "\n";
    }
}

백준 BOJ 11504번 : 돌려 돌려 돌림판

문제 난이도 : Bronze I

알고리즘 분류 : 브루트포스

돌림판의 한 칸에 숫자가 한 개씩 적혀있고, 그 중 한 칸을 골라 시계방향으로 선택한 수들을 이어붙인 수가 두 수 사이의 값이 되는 경우를 모두 구하는 문제이다.

문제에서 말한 경우를 모두 세어주기만 하면 된다.

어떻게 보면 구현 문제에 가깝다.

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

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

    int T; cin >> T;

    while(T--) {
        int N, M; cin >> N >> M;

        string a = "", b = "";

        for(int i=0; i<M; i++) {
            char c; cin >> c;

            a += c;
        }

        for(int i=0; i<M; i++) {
            char c; cin >> c;

            b += c;
        }

        vector<char> v(N);
        for(int i=0; i<N; i++) cin >> v[i];

        int ans = 0;

        for(int i=0; i<N; i++) {
            string tmp = "";

            for(int j=0; j<M; j++) tmp += v[(i+j) % N];

            if(tmp >= a && tmp <= b) ans++;
        }

        cout << ans << "\n";
    }
}

백준 BOJ 11453번 : Rummikub

문제 난이도 : Bronze I

알고리즘 분류 : 브루트포스

루미큐브 조각들이 주어질 때, 색이 같고 연속한 3개의 숫자가 있거나, 숫자가 같고 색이 모두 다른 3개의 타일이 존재하는지 찾아주는 문제이다.

2차원 배열을 만들어서 주어진 조각들을 모두 체크해주고, 숫자와 색들을 체크해보면서 조건을 만족하는 세트가 있는지 찾아주어야 한다.

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

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

    int T; cin >> T;

    while(T--) {
        int N; cin >> N;

        bool v[101][4] = {};

        while(N--) {
            string str; cin >> str;

            int x = stoi(str.substr(0, str.length()-1));
            char y = str.back();

            if(y == 'b') v[x][0] = true;
            else if(y == 'g') v[x][1] = true;
            else if(y == 'r') v[x][2] = true;
            else if(y == 'y') v[x][3] = true;
        }

        bool check = false;

        for(int i=0; i<4; i++)
            for(int j=3; j<=100; j++)
                if(v[j-2][i] && v[j-1][i] && v[j][i]) check = true;

        for(int i=1; i<=100; i++) {
            int cnt = 0;

            for(int j=0; j<4; j++)
                if(v[i][j]) cnt++;

            if(cnt >= 3) check = true;
        }

        if(check) cout << "YES\n";
        else cout << "NO\n";
    }
}

백준 BOJ 13450번 : László Babai

문제 난이도 : Bronze I

알고리즘 분류 : 브루트포스

3개의 노드로 이루어진 2개의 그래프가 주어질 때, 이 두 개의 그래프가 isomorphism (동형) 관계인지를 파악하는 문제이다.

노드가 3개밖에 없으므로, 간선의 수가 같으면 동일한 그래프가 될 수 밖에 없다.

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

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

    int T; cin >> T;

    int a, b;

    while(T--) {
        int N; cin >> N;

        for(int i=0; i<N; i++) cin >> a >> b;

        int M; cin >> M;

        for(int i=0; i<M; i++) cin >> a >> b;

        if(N == M) cout << "yes\n";
        else cout << "no\n";
    }
}

백준 BOJ 13641번 : Grid de Largada

문제 난이도 : Bronze I

알고리즘 분류 : 브루트포스

문제를 정확히는 이해 못했는데 주어진 두 개의 순열에 대해 한 순열을 최소 swap수로 swap하여 두 번째 순열을 만들기 위한 최소 횟수를 구하는 문제 같다.

첫 번째 순열을 1 2 3 .. N으로 만들어주고 번호를 매칭하여 두 번째 순열도 바꿔준다.

그 다음 버블 정렬을 하면서 swap 횟수를 count 해주면 된다.

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

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

    int N;

    while(cin >> N) {
        vector<int> v(N+1);

        for(int i=1; i<=N; i++) {
            int x; cin >> x;

            v[x] = i;
        }

        vector<int> u(N+1);

        for(int i=1; i<=N; i++) {
            int x; cin >> x;

            u[i] = v[x];
        }

        int ans = 0;

        for(int i=1; i<N; i++)
            for(int j=N; j>i; j--)
                if(u[j-1] > u[j]) {
                    swap(u[j-1], u[j]);

                    ans++;
                }

        cout << ans << "\n";
    }
}

백준 BOJ 18067번 : Accurate Movement

문제 난이도 : Bronze I

알고리즘 분류 : 브루트포스

주어진 규칙에 따라 두 블럭을 이동시켜서, 왼쪽 끝에 붙어있는 두 블럭을 모두 오른쪽 끝으로 붙이는데 필요한 최소 이동 수를 구하면 된다.

그리디하게 접근하여 각 블럭을 이동할 수 있는 최대한 이동시키고, 오른쪽 끝 범위 이상으로 이동되면 그 때의 횟수를 구해주면 된다.

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

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

    int a, b, N; cin >> a >> b >> N;

    int x = a, y = b, ans = 0;

    while(true) {
        x = y;
        ans++;

        if(x >= N) break;

        y += b - a;
        ans++;
    }

    cout << ans << "\n";
}

백준 18512번 : 점프 점프

문제 난이도 : Bronze I

알고리즘 분류 : 브루트포스

한 명은 지점 a에서 출발하여 한 번에 x미터씩 이동하고, 나머지 한 명은 지점 b에서 출발하여 한 번에 y미터씩 이동할 때, 두 명이 같은 지점을 지나는 가장 작은 위치를 구하는 문제이다.

범위가 작아 브루트포스로 일일이 돌려보면서 확인이 가능하다.

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

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

    int a, b, x, y; cin >> a >> b >> x >> y;

    for(int i=0; i<1e5; i++) {
        if(x == y) {
            cout << x << "\n";
            return 0;
        }

        if(x < y) x += a;
        else if(x > y) y += b;
    }

    cout << -1 << "\n";
}

백준 20240번 : Integer Square

문제 난이도 : Bronze I

알고리즘 분류 : 브루트포스

한 변의 길이의 제곱이 x인 정사각형의 네 정수 좌표를 아무거나 구하면 되는 문제이다.

원점을 기준으로 다른 지점까지의 거리의 제곱이 x인 지점을 찾아서, 90도씩 돌려서 나머지 점들을 찍어주면 된다.

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

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

    int N; cin >> N;

    int a = -1, b = -1;
    bool check = false;

    for(int i=0; i<=1000; i++) {
        for(int j=0; j<=1000; j++)
            if(i*i + j*j == N) {
                a = i, b = j;
                check = true;
                break;
            }
        if(check) break;
    }

    if(a == -1 && b == -1) {
        cout << "Impossible\n";
        return 0;
    }

    cout << 0 << " " << 0 << "\n";
    cout << a << " " << b << "\n";
    cout << -b << " " << a << "\n";
    cout << -b + a << " " << a + b << "\n";
}

백준 BOJ 브론즈 브루트포스 문제들 밀기 220830

restudy — Tue, 30 Aug 2022 11:55:23 +0900

오늘은 백준 브론즈 브루트포스 알고리즘 문제들을 밀어볼 것이다.

참고로 3,000문제를 넘게 풀면 나머지 브론즈 문제들은 솔직히 문제를 풀기보다 번역기에 돌린 문제의 지문을 "해석"하는 과정이 더 어렵다. (말 그대로 문장 구조의 앞뒤가 안 맞아서 대충 그동안 푼 문제들의 경험으로 문제의 지시를 끼워맞춰야 한다.)

백준 BOJ 9703번 : Anti-Arithmetic Permutation

문제 난이도 : Bronze II

알고리즘 분류 : 브루트포스

N개의 수가 주어졌을 때, 순서를 뒤집지 않고 어떤 3개의 수를 선택해도 그 세 수가 등차수열을 이루지 않도록 하는 수열을 Anti-Arithmetic Permutation이라고 할 때, 주어진 수열이 Anti-Arithmetic Permutation인지를 판별하는 문제이다.

브루트포스로 O(N^3) 시간에 3개의 수를 모두 확인해서 등차수열을 이루는 것이 하나라도 있는지 체크해보면 된다.

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

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

    int T; cin >> T;

    for(int t=1; t<=T; t++) {
        int N; cin >> N;

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

        bool check = true;

        for(int i=0; i<N; i++)
            for(int j=i+1; j<N; j++)
                for(int k=j+1; k<N; k++)
                    if(v[i] + v[k] == v[j] * 2) check = false;

        cout << "Case #" << t << ": ";

        if(check) cout << "YES\n";
        else cout << "NO\n";
    }
}

백준 BOJ 9850번 : Cipher

문제 난이도 : Bronze II

알고리즘 분류 : 브루트포스, 문자열

문자열이 주어질 때, 이것을 shift 시킨 문자열 중 CHIPMUNKS와 LIVE가 둘 다 나오는 것을 출력하는 문제이다.

26개의 shift를 모두 적용해보고 그들 중 CHIPMUNKS와 LIVE가 모두 나오는지 체크해보면 된다.

다만 단어 뒤에 .이나 !와 같은 기호가 나올 수 있기 때문에 알파벳이 아닌 경우 단어를 끊어서 검사해주면 된다.

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

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

    string str; getline(cin, str);

    for(int i=0; i<26; i++) {
        string tmp = "";

        for(int j=0; j<str.length(); j++) {
            if(str[j] >= 'A' && str[j] <= 'Z')
                tmp += 'A' + (str[j] - 'A' + i) % 26;
            else tmp += str[j];
        }

        string word = "";
        bool b1 = false, b2 = false;

        for(int j=0; j<tmp.length(); j++) {
            if(!(tmp[j] >= 'A' && tmp[j] <= 'Z')) {
                if(word == "CHIPMUNKS") b1 = true;
                else if(word == "LIVE") b2 = true;

                word = "";
            }
            else word += tmp[j];
        }
        if(word == "CHIPMUNKS") b1 = true;
        else if(word == "LIVE") b2 = true;

        if(b1 && b2) {
            cout << tmp << "\n";
            break;
        }
    }
}

백준 BOJ 9891번 : Rect

문제 난이도 : Bronze II

알고리즘 분류 : 브루트포스

N개의 직사각형이 주어질 때, 두 직사각형 중 어떤 것도 서로 포함되지 않는 쌍의 개수를 구하는 문제이다.

먼저 가로 또는 세로 길이를 구하고, 두 길이를 길이순으로 정렬한다.

예를 들어 (가로, 세로) 값이 각각 (a, b), (c, d)인 두 직사각형이 있다고 하자.

이제 a < c이고 b > d이거나, a > c이고 b < d이면 두 직사각형은 서로 포함될 수 없게 된다.

이러한 비교를 O(N^2) 시간에 브루트포스로 해주면 된다.

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

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

    int N; cin >> N;

    vector<pair<int, int>> v(N);

    for(int i=0; i<N; i++) {
        int a, b, c, d; cin >> a >> b >> c >> d;

        v[i] = {abs(a - c), abs(b - d)};

        if(v[i].first > v[i].second) swap(v[i].first, v[i].second);
    }

    int ans = 0;

    for(int i=0; i<N; i++)
        for(int j=i+1; j<N; j++)
            if((v[i].first < v[j].first && v[i].second > v[j].second)
               || (v[i].first > v[j].first && v[i].second < v[j].second)) ans++;

    cout << ans << "\n";
}

백준 BOJ 14290번 : Diwali lightings (Small)

문제 난이도 : Bronze II

알고리즘 분류 : 브루트포스

무한 반복되는 문자열 패턴이 주어지고 두 수 a와 b가 주어질 때 a번째부터 b번째 문자 중에 'B'가 몇 개 등장하는지 구하는 문제이다.

문자열을 직접 반복해서 붙이면서 (길이가 b 이상이 될 때까지) 주어진 범위에 대해 직접 세어보면 된다. (범위가 작아서 가능하다.)

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

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

    int T; cin >> T;

    for(int t=1; t<=T; t++) {
        string str; cin >> str;

        string tmp = "";

        int a, b; cin >> a >> b;

        while(tmp.length() < b) tmp += str;

        int ans = 0;

        for(int i=a-1; i<b; i++)
            if(tmp[i] == 'B') ans++;

        cout << "Case #" << t << ": " << ans << "\n";
    }
}

백준 BOJ 15121번 : Star Arrangements

문제 난이도 : Bronze II

알고리즘 분류 : 브루트포스

N이 주어질 때, 두 수의 차이가 1 이내이면서 두 수를 반복해서 더하다가 N이 되도록 하는 두 수의 조합을 모두 구하는 문제이다. (이 때 첫 번째 수는 두 번째 수보다 작으면 안된다.)

이중 for문을 돌리면서 모두 체크해보면 된다.

i는 2 ~ N에서 돌려주고 j는 1 ~ N에서 돌리되, i + j가 N 이하이면서 i와 j가 1 이내의 차이를 가지면 된다.

이제 sum 값에 i와 j를 번갈아가면서 더하다가 정확히 N이 되면 i와 j는 하나의 답이 된다.

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

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

    int N; cin >> N;

    cout << N << ":\n";

    for(int i=2; i<=N; i++)
        for(int j=1; j<=i && i+j<=N; j++) {
            if(abs(i - j) > 1) continue;

            int sum = 0;

            while(true) {
                if(sum + i <= N) sum += i;
                else break;

                if(sum + j <= N) sum += j;
                else break;
            }

            if(sum == N) cout << i << "," << j << "\n";
        }
}

백준 BOJ 15494번 : Davor

문제 난이도 : Bronze II

알고리즘 분류 : 브루트포스

월요일에는 x원, 화요일에는 x + y원, ... , 일요일에는 x + 6y원을 저축하여 52주동안 저축 후 정확히 N원을 모았을 때, x와 y를 구하는 문제이다.

52주동안 모인 돈은 7*52x + 21*52y이므로, for문으로 이것이 N이 되는 (x, y)를 구해주면 된다.

나의 경우에는 x를 고정하고 y가 존재하는지 확인하는 방식으로 풀었다.

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

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

    int N; cin >> N;

    for(int i=100; i>=0; i--) {
        if(N - i*7*52 > 0 && (N - i*7*52) % (21*52) == 0) {
            cout << i << "\n";
            cout << (N - i*7*52) / (21*52) << "\n";
            break;
        }
    }
}

백준 BOJ 15593번 : Lifeguards (Bronze)

문제 난이도 : Bronze II

알고리즘 분류 : 브루트포스

N마리의 소 각각이 a ~ b초 사이에 구조 활동을 할 수 있을 때, 1마리를 빼고 나머지가 가능한 최대 구조 활동의 시간을 구하는 문제이다.

3중 for문을 이용하여 한 마리씩 제거해보면서 각 소의 a ~ b 부분을 check 해주고, 마지막에 check 된 값들을 count 하면서 그 count 값의 최댓값을 구해주면 된다.

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

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

    int N; cin >> N;

    vector<pair<int, int>> v(N);

    for(int i=0; i<N; i++)
        cin >> v[i].first >> v[i].second;

    int ans = 0;

    for(int i=0; i<N; i++) {
        vector<bool> u(1001);

        for(int j=0; j<N; j++) {
            if(j == i) continue;

            for(int k=v[j].first; k<v[j].second; k++) u[k] = true;
        }

        int cnt = 0;

        for(int j=0; j<=1000; j++)
            if(u[j]) cnt++;

        ans = max(ans, cnt);
    }

    cout << ans << "\n";
}

백준 BOJ 16306번 : Cardboard Container

문제 난이도 : Bronze II

알고리즘 분류 : 브루트포스

가로, 세로, 높이가 정수이고 부피가 N인 직육면체 중 표면적이 가장 작은 것의 표면적을 구하는 문제이다.

3중 for문을 쓰되 모든 수를 조사하면 쓰면 시간 초과에 걸리므로, 수가 N으로 나누어 떨어지는 경우만 더 탐색하도록 구현해주면 빠른 시간에 풀이할 수 있다.

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

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

    int N; cin >> N;

    int ans = INT_MAX;

    for(int i=1; i<=N; i++) {
        if(N % i != 0) continue;

        int jk = N / i;

        for(int j=1; j<=jk; j++) {
            if(jk % j != 0) continue;

            int k = jk / j;

            ans = min(ans, (i*j + j*k + k*i)*2);
        }
    }

    cout << ans << "\n";
}

백준 BOJ 16412번 : Heir's Dilemma

문제 난이도 : Bronze II

알고리즘 분류 : 브루트포스

6자리 숫자 중에서 주어진 a 이상, b 이하이면서 6자리가 모두 다르고, 0을 포함하지 않으며, 각 자릿수의 숫자로 나누었을 때 나누어떨어지는 수의 개수를 구하는 문제이다.

문제에서 구해야 하는 수의 조건 자체를 모두 주었으므로, 주어진 조건을 조건문으로 구현하기만 하면 되는 문제이다.

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

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

    int a, b; cin >> a >> b;

    int ans = 0;

    for(int i=a; i<=b; i++) {
        int tmp = i;

        vector<int> cnt(10);

        while(tmp > 0) {
            cnt[tmp % 10]++;

            tmp /= 10;
        }

        bool check = true;

        for(int j=0; j<10; j++)
            if(cnt[j] >= 2) check = false;

        if(cnt[0] >= 1) check = false;

        if(!check) continue;

        for(int j=1; j<10; j++) {
            if(cnt[j] == 0) continue;

            if(i % j != 0) check = false;
        }

        if(check) ans++;
    }

    cout << ans << "\n";
}

백준 BOJ 16847번 : Teenage Mutant

문제 난이도 : Bronze II

알고리즘 분류 : 브루트포스

1개의 문자열이 주어지고, N개의 조상 문자열이 주어질 때, 모든 조상 문자열과 다른 문자 위치의 개수를 구하는 문제이다. 모든 문자열의 길이는 M이다.

2중 for문으로 검사해주면 된다.

자리에 대해 먼저 for문을 0 ~ M-1으로 돌려주고, 각 자리에 대해 모든 조상과 같은 위치의 일치하는 문자가 하나라도 있는지 체크해주면 된다.

조건에 의해 약분을 할 필요가 없으므로 유클리드 호제법을 사용할 필요가 없다.

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

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

    int T; cin >> T;

    for(int t=1; t<=T; t++) {
        int N, M; cin >> N >> M;

        string str; cin >> str;

        vector<string> v(N);
        for(int i=0; i<N; i++) cin >> v[i];

        int cnt = 0;

        for(int i=0; i<M; i++) {
            bool check = false;

            for(int j=0; j<N; j++)
                if(str[i] == v[j][i]) check = true;

            if(!check) cnt++;
        }

        cout << "Data Set " << t << ":\n";
        cout << cnt << "/" << M << "\n\n";
    }
}

백준 BOJ 17889번 : Mars Window

문제 난이도 : Bronze II

알고리즘 분류 : 브루트포스

2018년 4월을 기준으로 26개월마다 적절한 발사 시기라고 할 때, 주어진 년에 적절한 발사 시기가 존재하는지 체크하는 문제이다.

2018년 1월의 cnt 값을 1로 잡고, cnt 값을 매 월마다 1씩 추가하다가 cnt % 26 = 4이면 적절한 발사 시기에 해당한다.

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

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

    int N; cin >> N;

    int cnt = 0;

    for(int i=2018; i<=10000; i++) {
        bool check = false;

        for(int j=1; j<=12; j++) {
            cnt++;

            if(cnt % 26 == 4) check = true;
        }

        if(i == N) {
            if(check) cout << "yes\n";
            else cout << "no\n";

            break;
        }
    }
}

백준 BOJ 17924번 : Cooking Water

문제 난이도 : Bronze II

알고리즘 분류 : 브루트포스

문제를 요약하여 설명하자면 주어진 N개의 구간에 대해, 모든 구간에 포함하는 숫자가 존재하는지 확인하는 문제이다.

모든 수의 범위가 10,000 이하로 주어지기 때문에, 구간들을 벡터로 입력받고, 0 ~ 10,000 중에 모든 구간에 포함되는 숫자가 있는지 체크해주면 된다.

시간 복잡도는 O(1e4 N)이 되고, 이는 통과하기에 넉넉하다.

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

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

    int N; cin >> N;

    vector<pair<int, int>> v(N);

    for(int i=0; i<N; i++)
        cin >> v[i].first >> v[i].second;

    for(int i=0; i<=1000; i++) {
        bool check = true;

        for(int j=0; j<N; j++)
            if(i < v[j].first || i > v[j].second) check = false;

        if(check) {
            cout << "gunilla has a point\n";
            return 0;
        }
    }

    cout << "edward is right\n";
}

백준 BOJ 23389번 : 一般化うるう年

문제 난이도 : Bronze II

알고리즘 분류 : 브루트포스

이 문제는 우리가 400년, 100년, 4년을 가지고 규칙에 따라 윤년을 정하는 것처럼 주어진 N개의 수를 가지고 l ~ r년 사이에 윤년이 몇 개인지 세는 문제인데, 번역이 제대로 안 돌아가서 이해가 잘 안된다.

아무튼 문제에서 하라는대로 (년 수) % v[i] = 0이면서 i % 2 == 0이면 윤년이고, 또한 나누어떨어지는 v[i]가 없는 경우 N이 짝수면 윤년을 추가해주면 된다. (문제에서 하라는대로 구현하면 된다.)

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

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

    while(true) {
        int N, l, r; cin >> N >> l >> r;
        if(N == 0 && l == 0 && r == 0) break;

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

        int ans = 0;

        for(int i=l; i<=r; i++) {
            bool check = false;

            for(int j=0; j<N; j++) {
                if(i % v[j] == 0) {
                    if(j % 2 == 0) ans++;

                    check = true;

                    break;
                }
            }

            if(!check && N % 2 == 0) ans++;
        }

        cout << ans << "\n";
    }
}

백준 BOJ 22825번 : Fermat's Last Theorem

문제 난이도 : Bronze II

알고리즘 분류 : 브루트포스

주어진 자연수 z에 대해, z^3 - (x^3 + y^3)의 0보다 큰 최솟값을 구하는 문제이다.

2중 반복문을 돌려서 풀 수 있다.

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

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

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

        int ans = N*N*N;

        for(int i=1; i*i*i<=N*N*N; i++)
            for(int j=1; i*i*i+j*j*j<=N*N*N; j++)
                ans = min(ans, N*N*N - (i*i*i + j*j*j));

        cout << ans << "\n";
    }
}

백준 BOJ 2508번 : 사탕 박사 고창영

문제 난이도 : Bronze I

알고리즘 분류 : 브루트포스

주어진 N x M 문자 배열에서 다음의 두 가지 도형의 개수를 찾는 문제이다.

>o<

v
o
^

이중 for문을 2번 사용하여 먼저 가로로 스캔을 해주고, 그 다음 세로로 다시 스캔해주면서 세면 된다.

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

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

    int T; cin >> T;

    while(T--) {
        int N, M; cin >> N >> M;

        vector<vector<char>> v(N, vector<char>(M));

        for(int i=0; i<N; i++)
            for(int j=0; j<M; j++) cin >> v[i][j];

        int ans = 0;

        for(int i=0; i<N; i++)
            for(int j=0; j<M-2; j++)
                if(v[i][j] == '>' && v[i][j+1] == 'o' && v[i][j+2] == '<') ans++;

        for(int i=0; i<N-2; i++)
            for(int j=0; j<M; j++)
                if(v[i][j] == 'v' && v[i+1][j] == 'o' && v[i+2][j] == '^') ans++;

        cout << ans << "\n";
    }
}

백준 BOJ 알고리즘 공부 일기 (오프라인 쿼리 포함) 220829

restudy — Mon, 29 Aug 2022 12:53:06 +0900

백준 BOJ 13306번 : 트리

문제 난이도 : Platinum IV

알고리즘 분류 : 오프라인 쿼리, 분리 집합

트리와 쿼리가 주어질 때, 각 쿼리에 대해 특정 간선을 지우거나 두 정점이 연결 상태인지를 구하는 문제이다.

오프라인 쿼리 문제인데, 오프라인 쿼리 문제는 주어진 쿼리 순서대로 처리를 하는 것이 아니라 문제를 효율적으로 풀 수 있게끔 쿼리의 순서를 재배치하여 풀이하는 방식의 문제를 말한다.

예를 들어 이 문제에서는 쿼리를 역순으로 배치한 뒤 분리 집합으로 노드들을 연결해가면서 풀어주면 아주 쉽게 풀 수 있다.

역순 배치가 아닌 다른 순서대로 푸는 문제도 있는 것 같던데 조만간 공부할 것이다. (예를 들면 mo's 알고리즘. 지금 제곱근 분할법 문제 몇 개는 풀어봤는데 mo's를 공부 안해서 못 풀고 있는 문제들이 많다.)

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

struct s { int Q, a, b; };

vector<int> v;

int f(int x) {
    if(v[x] == x) return x;
    else return v[x] = f(v[x]);
}

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

    int N, M; cin >> N >> M;

    vector<int> p(N+1);
    for(int i=2; i<=N; i++) cin >> p[i];

    M += N-1;

    vector<s> q(M);

    for(int i=0; i<M; i++) {
        cin >> q[i].Q;

        if(q[i].Q == 0) cin >> q[i].a;
        else if(q[i].Q == 1) cin >> q[i].a >> q[i].b;
    }

    v.resize(N+1);
    for(int i=1; i<=N; i++) v[i] = i;

    stack<bool> ans;

    for(int i=M-1; i>=0; i--) {
        if(q[i].Q == 0) {
            if(f(q[i].a) != f(p[q[i].a])) v[f(q[i].a)] = f(p[q[i].a]);
        }
        else if(q[i].Q == 1) {
            if(f(q[i].a) == f(q[i].b)) ans.push(true);
            else ans.push(false);
        }
    }

    while(!ans.empty()) {
        if(ans.top()) cout << "YES\n";
        else cout << "NO\n";

        ans.pop();
    }
}

백준 BOJ 10775번 : 공항

문제 난이도 : Gold II

알고리즘 분류 : 분리 집합

N개의 게이트가 있고, M개의 비행기가 각각 u_i번 이하의 게이트에 도킹할 수 있다고 할 때, 주어진 입력 순서대로 비행기가 도킹한다면 최대로 도킹할 수 있는 비행기의 수를 구하는 문제이다.

그리디하게 접근하여 u_i 이하의 도킹이 가능한 가장 큰 번호의 게이트에 도킹을 해준다.

그 다음, 같은 번호의 게이트에 비행기가 들어올 경우 그 이하의 최대 번호로 연결을 효율적으로 해주어야 하는데 여기서 분리 집합을 사용하면 수월하다.

f(u_i)번 게이트에 도킹 후 f(u_i)값을 f(u_i) - 1로 해주면 된다.

한 번 parent로 이동했을 때 그 게이트가 이미 차 있다고 하더라도 해당 게이트의 parent 역시 다른 게이트로 연결되어 있을 것이기 때문에 빈 게이트를 효율적으로 찾아줄 수가 있다.

도킹을 계속 하다가 만약 f(u_i) = 0일 경우 도킹이 더 이상 불가능한 것이므로 지금까지 연결한 비행기의 개수로 답을 얻어주면 된다.

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

vector<int> v;

int f(int x) {
    if(v[x] == x) return x;
    else return v[x] = f(v[x]);
}

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

    int N, M; cin >> N >> M;

    v.resize(N+1);
    for(int i=1; i<=N; i++) v[i] = i;

    int ans = 0;

    vector<int> u(M);
    for(int i=0; i<M; i++) cin >> u[i];

    for(int i=0; i<M; i++) {
        int x = u[i];

        if(f(x) == 0) break;

        v[f(x)] = f(x) - 1;
        ans++;
    }

    cout << ans << "\n";
}

백준 BOJ 1440번 : 타임머신

문제 난이도 : Bronze II

알고리즘 분류 : 브루트포스

시, 분, 초가 주어질 때 시, 분, 초의 순서를 바꾸어 (그대로인 것 포함) 읽어도 시, 분, 초의 범위에 해당하는 것의 개수를 구하는 문제이다.

next_permutation으로 3!가지 경우를 모두 확인해보면 된다.

다만 이 문제의 경우 두 값이 같은 경우도 있는데 next_permutation 함수는 이 경우를 건너뛰므로 모두 다른 값을 가지는 벡터 하나를 추가로 이용해주는 방법 등을 사용해야한다.

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

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

    vector<int> v(3);

    char c;

    cin >> v[0] >> c >> v[1] >> c >> v[2];

    vector<int> u(3);
    u[0] = 0, u[1] = 1, u[2] = 2;

    int ans = 0;

    while(true) {
        if(v[u[0]] >= 1 && v[u[0]] <= 12 && v[u[1]] >= 0 && v[u[1]] <= 59 && v[u[2]] >= 0 && v[u[2]] <= 59) ans++;

        if(!next_permutation(u.begin(), u.end())) break;
   }

    cout << ans << "\n";
}

백준 BOJ 7637번 : AAAAHH! Overbooked!

문제 난이도 : Bronze II

알고리즘 분류 : 브루트포스

24시간짜리 시간으로 주어진 N개의 시간 범위에 대해, 겹치는 것이 있는지 확인하는 문제이다.

24 x 60짜리 크기의 bool 변수를 이용하여 체크를 일일이 해주면서 새로 체크할 값에 이미 체크가 하나라도 되어있다면 conflict를, 그렇지 않다면 no conflict를 출력해주면 된다.

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

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

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

        vector<bool> v(24*60);
        bool check = true;

        while(N--) {
            string str; cin >> str;

            int a = stoi(str.substr(0, 2));
            int b = stoi(str.substr(3, 2));
            int c = stoi(str.substr(6, 2));
            int d = stoi(str.substr(9, 2));

            for(int i=a*60+b; i<c*60+d; i++) {
                if(v[i]) check = false;

                v[i] = true;
            }
        }

        if(check) cout << "no conflict\n";
        else cout << "conflict\n";
    }
}

백준 BOJ 8676번 : Figury

문제 난이도 : Bronze II

알고리즘 분류 : 브루트포스

주어진 N개의 수에 대해 3개 연속으로 다른 수가 나오는 경우가 있는지 체크하는 문제이다.

단순히 3개씩 묶어서 일일이 확인해보면 된다.

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

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

    int N; cin >> N;

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

    bool check = false;

    for(int i=2; i<N; i++)
        if(v[i] != v[i-1] && v[i-1] != v[i-2] && v[i-2] != v[i]) check = true;

    if(check) cout << "TAK\n";
    else cout << "NIE\n";
}

백준 BOJ 9151번 : Starship Hakodate-maru

문제 난이도 : Bronze II

알고리즘 분류 : 브루트포스

N 이하이면서 가장 큰 a^3 + b x (b+1) x (b+2) / 6의 값을 구하는 문제이다.

2중 for문으로 N 이하의 범위에서 가능한 모든 조합을 다 확인해보면 된다.

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

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

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

        int ans = 0;

        for(int i=0; i*i*i<=N; i++)
            for(int j=0; i*i*i+j*(j+1)*(j+2)/6<=N; j++) ans = max(ans, i*i*i + j*(j+1)*(j+2)/6);

        cout << ans << "\n";
    }
}

백준 BOJ 9182번 : Biorhythms

문제 난이도 : Bronze II

알고리즘 분류 : 브루트포스

특성 a는 23일마다, 특성 b는 28일마다, 특성 c는 33일마다 발현되며 하나의 테스트케이스에 각 특성이 발현된 날짜, 그리고 현재 날짜가 주어질 때 다음 날부터 세 특성이 모두 발현되는 날 중 가장 가까운 날까지의 기간을 구하는 문제이다.

입력이 a b c d로 들어온다고 해보자.

그러면 x > d인 x에 대해 x % 23 = a % 23이고, x % 28 = b % 28이고, x % 33 = c % 23이라면 x는 d일 이후 세 특성이 모두 발현되는 날이다.

따라서 이러한 x 중 가장 작은 것을 답으로 얻어주면 된다.

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

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

    for(int t=1; ; t++) {
        int a, b, c, d; cin >> a >> b >> c >> d;
        if(a == -1 && b == -1 && c == -1 && d == -1) break;

        for(int i=d+1; i<=21252; i++) {
            if(i % 23 == a % 23 && i % 28 == b % 28 && i % 33 == c % 33) {
                cout << "Case " << t << ": the next triple peak occurs in " << i - d << " days.\n";
                break;
            }
        }
    }
}

백준 BOJ 9377번 : String LD

문제 난이도 : Bronze II

알고리즘 분류 : 브루트포스

N개의 문자열에 대해, 각 문자열의 맨 왼쪽 문자를 지우는 연산을 다음이 되기 전까지 반복한다.

1. 문자열의 길이가 1인 것이 발생

2. 두 문자열이 같은 것이 발생

이 때, 연산을 최대 몇 번 수행할 수 있는지 구하는 문제이다.

예를 들어 1번 연산을 수행하여 같은 문자열이 발생한다면 답은 0이다. (발생 이전까지만 반복해야하므로)

조건 그대로 체크만 해주면 된다.

같은 문자열이 있는 것은 sort 해준 뒤 v[i-1]과 v[i]를 비교해주면 된다.

다만 두 문자열이 같은 것이 발생했을 경우는 이미 연산을 수행한 이후이므로 연산 수행 횟수를 잘 계산해서 구해주어야 한다. (0번이면 상관 없지만, 1번 이상인 경우는 1 빼고 구해주어야 함)

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

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

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

        vector<string> v(N);
        for(int i=0; i<N; i++) cin >> v[i];

        for(int i=0; ; i++) {
            sort(v.begin(), v.end());

            bool check = false;

            for(int j=0; j<N; j++)
                if(v[j].length() == 1) check = true;

            for(int j=1; j<N; j++)
                if(v[j] == v[j-1]) check = true;

            if(check) {
                cout << i << "\n";
                break;
            }

            for(int j=0; j<N; j++)
                v[j] = v[j].substr(1, v[j].length()-1);

            sort(v.begin(), v.end());

            check = false;

            for(int j=1; j<N; j++)
                if(v[j] == v[j-1]) check = true;

            if(check) {
                cout << i << "\n";
                break;
            }
        }
    }
}

백준 BOJ 9161번 : Sir Bedavere’s Bogus Division Solutions

문제 난이도 : Bronze III

알고리즘 분류 : 브루트포스

한 숫자의 맨 뒷자리와 다른 숫자의 맨 앞자리가 같은3자리 숫자 abc와 cde가 있을 때, 공통되는 숫자를 지워 ab, de를 만들었을 때 abc / cde = ab / de인 수의 순서쌍을 모두 구하는 문제이다.

abc를 100 ~ 999, cde도 100 ~ 999 사이의 모든 경우를 확인해보면 된다.

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

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

    for(int i=100; i<=999; i++)
        for(int j=100; j<=999; j++) {
            if(i % 10 != j / 100) continue;
            if(i % 111 == 0) continue;

            int a = i, b = j, c = i / 10, d = j % 100;

            if(a * d == b * c)
                cout << a << " / " << b << " = " << c << " / " << d << "\n";
        }
}

백준 BOJ 9664번 : NASLJEDSTVO

문제 난이도 : Bronze III

알고리즘 분류 : 브루트포스

몇 개의 물건 중에서 1/N만큼을 (내림) 가져가고 남은 것이 M개일 때, 원래 있었던 것으로 가능한 최소/최대 물건의 수를 구하는 문제이다.

내림 처리를 하고 가져갔기 때문에 역으로 연산하기가 쉽지 않다.

따라서 범위를 넉넉하게 잡아서 x - x/N = M이면 x에 대해 최대, 최소를 갱신해주면 된다.

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

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

    int N, M; cin >> N >> M;

    int Min = INT_MAX, Max = INT_MIN;

    for(int i=1; i<=1e3; i++) {
        if(i - i/N == M) {
            Min = min(Min, i);
            Max = max(Max, i);
        }
    }

    cout << Min << " " << Max << "\n";
}

백준 BOJ 19751번 : Fractification

문제 난이도 : Bronze III

알고리즘 분류 : 브루트포스

네 정수 a, b, c, d가 주어질 때 a/b + c/d가 최소가 되도록 값들을 적절히 swap하는 문제이다.

next_permutation 함수를 이용하여 4! 가지의 경우를 모두 비교해보면 된다.

실수 연산에서 오차가 발생하지 않을까 했는데 다행히 극악의 테스트케이스는 없는 것 같다.

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

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

    vector<double> v(4);

    for(int i=0; i<4; i++) cin >> v[i];

    sort(v.begin(), v.end());

    vector<double> u;
    double Min = INT_MAX;

    while(true) {
        if(v[0] / v[1] + v[2] / v[3] < Min) {
            Min = v[0] / v[1] + v[2] / v[3];

            u = v;
        }

        if(!next_permutation(v.begin(), v.end())) break;
    }

    for(int i=0; i<4; i++) cout << (int)u[i] << " ";
    cout << "\n";
}

백준 BOJ 24348번 : ИЗРАЗ

문제 난이도 : Bronze III

알고리즘 분류 : 브루트포스

3개의 수가 주어질 때, +, -, * 를 최대 한 번만 사용하여 만들 수 있는 최댓값을 구하는 문제이다. (세 수의 순서를 바꿔도 된다.)

next_permutation을 이용하여 세 수의 순서를 바꾸고, 주어지는 수가 0 이상이므로 +와 *만을 가지고 모든 조합을 비교해보면 된다.

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

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

    vector<int> v(3);
    for(int i=0; i<3; i++) cin >> v[i];

    sort(v.begin(), v.end());

    int ans = 0;

    while(true) {
        ans = max(ans, v[0] + v[1] * v[2]);
        ans = max(ans, v[0] * v[1] + v[2]);

        if(!next_permutation(v.begin(), v.end())) break;
    }

    cout << ans << "\n";
}

선분 교차 판정 알고리즘 문제 풀이 정리 220828

restudy — Sun, 28 Aug 2022 01:55:45 +0900

백준 BOJ 20149번 : 선분 교차 3

문제 난이도 : Platinum IV

알고리즘 분류 : 기하학, 선분 교차 판정

두 선분의 끝 점의 좌표가 주어질 때, 두 선분의 교차 여부를 구하고, 만약 한 점에서만 교차한다면 그 좌표를 오차 범위 1e-9 이내로 구하는 문제이다.

CCW 값들을 가지고 잘 푸는 것인지는 당연히 아는데, 케이스를 어떻게 나눠야 깔끔하게 정리되는지 도저히 구상이 안 되어서 다른 블로그를 보고 공부했다.

개인적으로는 이 링크에 설명이 가장 잘 되어있다고 생각하고 또 여기서 대부분의 코드를 참고했다. (20220829 수정 : 링크가 잘못 걸려 있었다;;)

일단 교차 판정을 먼저 해보자. 점은 a, b, c, d의 네 점이 주어지고 a, b를 잇는 선분과 c, d를 잇는 선분이 있다고 하자.

ccw 값을 이용하면 세 점의 방향 배치를 알 수 있다. (ccw > 0이면 세 점이 시계 반대 방향, ccw < 0이면 시계 방향, ccw = 0이면 세 점은 일직선 상에 있다.)

ccw(a, b, c) x ccw(a, b, d) 값과 ccw(c, d, a) x ccw(c, d, b) 값이 둘 다 0이라면 두 선분은 평행이거나 끝 점이 일치하는 경우이다.

a와 b, 그리고 c와 d를 좌표가 증가하게 정렬을 일단 해준 다음에 생각해보자.

(1) a ≤ d인데 b ≥ c라면 ab의 오른쪽 끝과 cd의 왼쪽 끝이 겹친다는 뜻이다.

(2) 그게 아니라면 두 점은 교차하지 않는다.

ccw(a, b, c) x ccw(a, b, d) 값과 ccw(c, d, a) x ccw(c, d, b) 값 중 하나라도 0이 아니라면 다음과 같이 나눌 수 있다.

(1) 두 값이 모두 0 이하라면 두 선분은 가운데가 교차하거나, 또는 한 선분의 끝점이 다른 선분의 가운데에 위치하는 경우이다.

(2) 그게 아니라면 두 선분은 교차하지 않는다.

이제 두 선분이 교차하는 경우에 한해 좌표를 구해주어야 하는데, 수학 문제를 손으로 푸는게 아닌 수식을 코드로 작성할 것이기 때문에 다음의 공식을 사용하는 것이 가장 편하다. (식이 길더라도 변수를 많이 안 쓰고 처리하는 편이 수월하다는 이야기)

(교점의 좌표) = (((x1y2 - y1x2)(x3 - x4) - (x1 - x2)(x3y4 - y3x4)) / ((x1 - x2)(y3 - y4) - (y1 - y2)(x3 - x4)), ((x1y2 - y1x2)(y3 - y4) - (y1 - y2)(x3y4 - y3x4)) / ((x1 - x2)(y3 - y4) - (y1 - y2)(x3 - x4)))

문제는 분모가 0인 경우인데, 이 경우에는 다음의 두 경우로 나뉜다.

(1) b = c이고 a ≤ c이면 : 점 b = c에서 교차하는 것이므로 b의 좌표나 c의 좌표 둘 중 하나를 출력해주면 된다.

(2) a = d이고 c ≥ a이면 : 점 a = d에서 교차하는 것이므로 a의 좌표나 d의 좌표 둘 중 하나를 출력해주면 된다.

이제 모든 경우가 해결이 되었다.

코드는 아래의 접은 글에 정리되어있다.

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

struct s { int x, y; };

bool operator== (s a, s b) {
    if(a.x == b.x && a.y == b.y) return true;
    else return false;
}
bool operator>= (s a, s b) {
    if(a.x > b.x || (a.x == b.x && a.y >= b.y)) return true;
    else return false;
}
bool operator<= (s a, s b) {
    if(a.x < b.x || (a.x == b.x && a.y <= b.y)) return true;
    else return false;
}
bool operator> (s a, s b) {
    if(a.x > b.x || (a.x == b.x && a.y > b.y)) return true;
    else return false;
}
bool operator< (s a, s b) {
    if(a.x < b.x || (a.x == b.x && a.y < b.y)) return true;
    else return false;
}

int ccw(s a, s b, s c) {
    int val = a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y);

    if(val == 0) return 0;
    else if(val > 0) return 1;
    else if(val < 0) return -1;
}

void coor(s a, s b, s c, s d) {
    double X = (a.x * b.y - a.y * b.x) * (c.x - d.x) - (a.x - b.x) * (c.x * d.y - c.y * d.x);
    double Y = (a.x * b.y - a.y * b.x) * (c.y - d.y) - (a.y - b.y) * (c.x * d.y - c.y * d.x);
    double div = (a.x - b.x) * (c.y - d.y) - (a.y - b.y) * (c.x - d.x);

    if(div == 0) {
        if(b == c && a <= c) cout << b.x << " " << b.y << "\n";
        else if(a == d && c <= a) cout << a.x << " " << a.y << "\n";
    }
    else cout << X / div << " " << Y / div << "\n";
}

void inter(s a, s b, s c, s d) {
    int val1 = ccw(a, b, c) * ccw(a, b, d);
    int val2 = ccw(c, d, a) * ccw(c, d, b);

    if(val1 == 0 && val2 == 0) {
        if(a > b) swap(a, b);
        if(c > d) swap(c, d);

        if(a <= d && b >= c) {
            cout << 1 << "\n";
            coor(a, b, c, d);
        }
        else cout << 0 << "\n";
    }
    else {
        if(val1 <= 0 && val2 <= 0) {
            cout << 1 << "\n";
            coor(a, b, c, d);
        }
        else cout << 0 << "\n";
    }
}

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

    vector<s> p(4);
    for(int i=0; i<4; i++) cin >> p[i].x >> p[i].y;

    cout << fixed;
    cout.precision(9);

    inter(p[0], p[1], p[2], p[3]);
}

백준 BOJ 10255번 : 교차점

문제 난이도 : Platinum IV

알고리즘 분류 : 기하학, 선분 교차 판정

직사각형의 왼쪽 아래 좌표와 오른쪽 위 좌표, 그리고 선분이 주어졌을 때 선분과 직사각형의 교점의 개수를 구하는 문제이다. (만약 무수히 많은 점이 겹친다면 4를 출력한다.)

직사각형의 4개의 변 각각에 대해 선분과의 교차 여부를 확인해주면 된다.

만약 하나라도 선분이 겹치는 경우가 있으면 4를 출력해주면 된다.

문제는 직사각형의 꼭짓점과 선분이 만나는 경우인데 이 경우에는 만난 꼭짓점의 개수만큼 다시 빼주어야 한다.

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

struct s { int x, y; };

bool operator== (s a, s b) {
    if(a.x == b.x && a.y == b.y) return true;
    else return false;
}
bool operator>= (s a, s b) {
    if(a.x > b.x || (a.x == b.x && a.y >= b.y)) return true;
    else return false;
}
bool operator<= (s a, s b) {
    if(a.x < b.x || (a.x == b.x && a.y <= b.y)) return true;
    else return false;
}
bool operator> (s a, s b) {
    if(a.x > b.x || (a.x == b.x && a.y > b.y)) return true;
    else return false;
}
bool operator< (s a, s b) {
    if(a.x < b.x || (a.x == b.x && a.y < b.y)) return true;
    else return false;
}

int ccw(s a, s b, s c) {
    int val = a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y);

    if(val == 0) return 0;
    else if(val > 0) return 1;
    else if(val < 0) return -1;
}

bool cross, overlap;
double cx, cy;

void coor(s a, s b, s c, s d) {
    double X = (a.x * b.y - a.y * b.x) * (c.x - d.x) - (a.x - b.x) * (c.x * d.y - c.y * d.x);
    double Y = (a.x * b.y - a.y * b.x) * (c.y - d.y) - (a.y - b.y) * (c.x * d.y - c.y * d.x);
    double div = (a.x - b.x) * (c.y - d.y) - (a.y - b.y) * (c.x - d.x);

    if(div == 0) {
        if(b == c && a <= c) cx = b.x, cy = b.y, overlap = false;
        else if(a == d && c <= a) cx = a.x, cy = a.y, overlap = false;
        else overlap = true;
    }
    else cx = X / div, cy = Y / div, overlap = false;
}

void inter(s a, s b, s c, s d) {
    int val1 = ccw(a, b, c) * ccw(a, b, d);
    int val2 = ccw(c, d, a) * ccw(c, d, b);

    if(val1 == 0 && val2 == 0) {
        if(a > b) swap(a, b);
        if(c > d) swap(c, d);

        if(a <= d && b >= c) {
            cross = true;
            coor(a, b, c, d);
        }
        else cross = false;
    }
    else {
        if(val1 <= 0 && val2 <= 0) {
            cross = true;
            coor(a, b, c, d);
        }
        else cross = false;
    }
}

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

    cout << fixed;
    cout.precision(9);

    int T; cin >> T;

    while(T--) {
        vector<s> v(6);

        cin >> v[0].x >> v[0].y >> v[2].x >> v[2].y;
        cin >> v[4].x >> v[4].y >> v[5].x >> v[5].y;

        v[1].x = v[2].x, v[1].y = v[0].y;
        v[3].x = v[0].x, v[3].y = v[2].y;

        int cnt = 0, ver = 0;
        bool inf = false;

        for(int i=0; i<4; i++) {
            inter(v[i], v[(i+1)%4], v[4], v[5]);

            if(cross && overlap) inf = true;
            else if(cross) {
                bool check = false;

                for(int i=0; i<4; i++)
                    if(cx == v[i].x && cy == v[i].y) check = true;

                if(check) ver++;

                cnt++;
            }
        }

        if(inf) cout << 4 << "\n";
        else {
            cnt -= ver/2;

            cout << cnt << "\n";
        }
    }
}

백준 BOJ 16491번 : 대피소 찾기

문제 난이도 : Platinum V

알고리즘 분류 : 기하학, 선분 교차 판정, 브루트포스

N개의 로봇이 N개의 대피소로 한 로봇 당 하나의 대피소에 이동할 때, 직선으로 이동하는 로봇들이 서로 동선이 겹치지 않게 하기 위해 각각 이동해야하는 대피소 번호를 구하는 문제이다.

일단 브루트포스 방식으로 로봇들을 각 대피소에 가능한 모든 매치를 해주고, 각 매치에 대해서 두 지점을 연결한 선분 N개가 서로 교차하는지 체크해주면 된다.

나의 경우에는 매치하는 과정을 next_permutation을 이용해서 풀었다.

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

struct s { int x, y; };

bool operator== (s a, s b) {
    if(a.x == b.x && a.y == b.y) return true;
    else return false;
}
bool operator>= (s a, s b) {
    if(a.x > b.x || (a.x == b.x && a.y >= b.y)) return true;
    else return false;
}
bool operator<= (s a, s b) {
    if(a.x < b.x || (a.x == b.x && a.y <= b.y)) return true;
    else return false;
}
bool operator> (s a, s b) {
    if(a.x > b.x || (a.x == b.x && a.y > b.y)) return true;
    else return false;
}
bool operator< (s a, s b) {
    if(a.x < b.x || (a.x == b.x && a.y < b.y)) return true;
    else return false;
}

int ccw(s a, s b, s c) {
    int val = a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y);

    if(val == 0) return 0;
    else if(val > 0) return 1;
    else if(val < 0) return -1;
}

bool cross, overlap;
double cx, cy;

void coor(s a, s b, s c, s d) {
    double X = (a.x * b.y - a.y * b.x) * (c.x - d.x) - (a.x - b.x) * (c.x * d.y - c.y * d.x);
    double Y = (a.x * b.y - a.y * b.x) * (c.y - d.y) - (a.y - b.y) * (c.x * d.y - c.y * d.x);
    double div = (a.x - b.x) * (c.y - d.y) - (a.y - b.y) * (c.x - d.x);

    if(div == 0) {
        if(b == c && a <= c) cx = b.x, cy = b.y, overlap = false;
        else if(a == d && c <= a) cx = a.x, cy = a.y, overlap = false;
        else overlap = true;
    }
    else cx = X / div, cy = Y / div, overlap = false;
}

void inter(s a, s b, s c, s d) {
    int val1 = ccw(a, b, c) * ccw(a, b, d);
    int val2 = ccw(c, d, a) * ccw(c, d, b);

    if(val1 == 0 && val2 == 0) {
        if(a > b) swap(a, b);
        if(c > d) swap(c, d);

        if(a <= d && b >= c) {
            cross = true;
            coor(a, b, c, d);
        }
        else cross = false;
    }
    else {
        if(val1 <= 0 && val2 <= 0) {
            cross = true;
            coor(a, b, c, d);
        }
        else cross = false;
    }
}

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

    int N; cin >> N;

    vector<s> v(N), u(N);
    for(int i=0; i<N; i++) cin >> v[i].x >> v[i].y;
    for(int i=0; i<N; i++) cin >> u[i].x >> u[i].y;

    vector<int> w(N);
    for(int i=0; i<N; i++) w[i] = i;

    while(true) {
        bool check = true;

        for(int i=0; i<N; i++)
            for(int j=i+1; j<N; j++) {
                inter(v[i], u[w[i]], v[j], u[w[j]]);

                if(cross) check = false;
            }

        if(check) {
            for(int i=0; i<N; i++) cout << w[i] + 1 << "\n";

            break;
        }

        if(!next_permutation(w.begin(), w.end())) break;
    }
}

백준 BOJ 2162번 : 선분 그룹

문제 난이도 : Gold I

알고리즘 분류 : 기하학, 선분 교차 판정, 분리 집합

N개의 선분이 주어지고 한 점 이상에서 교차하는 것은 같은 그룹이라고 할 때, 몇 개의 그룹이 존재하는지와 가장 큰 그룹의 크기를 구하는 문제이다.

교차하는 선분들에 대해서, 분리 집합으로 같은 그룹으로 묶어주면 된다.

이제 교차 여부만 판별하면 되는데 이것은 위에서 구현한 방식으로 해주면 된다.

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

struct s { int x, y; };

bool operator== (s a, s b) {
    if(a.x == b.x && a.y == b.y) return true;
    else return false;
}
bool operator>= (s a, s b) {
    if(a.x > b.x || (a.x == b.x && a.y >= b.y)) return true;
    else return false;
}
bool operator<= (s a, s b) {
    if(a.x < b.x || (a.x == b.x && a.y <= b.y)) return true;
    else return false;
}
bool operator> (s a, s b) {
    if(a.x > b.x || (a.x == b.x && a.y > b.y)) return true;
    else return false;
}
bool operator< (s a, s b) {
    if(a.x < b.x || (a.x == b.x && a.y < b.y)) return true;
    else return false;
}

int ccw(s a, s b, s c) {
    int val = a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y);

    if(val == 0) return 0;
    else if(val > 0) return 1;
    else if(val < 0) return -1;
}

bool cross, overlap;
double cx, cy;

void coor(s a, s b, s c, s d) {
    double X = (a.x * b.y - a.y * b.x) * (c.x - d.x) - (a.x - b.x) * (c.x * d.y - c.y * d.x);
    double Y = (a.x * b.y - a.y * b.x) * (c.y - d.y) - (a.y - b.y) * (c.x * d.y - c.y * d.x);
    double div = (a.x - b.x) * (c.y - d.y) - (a.y - b.y) * (c.x - d.x);

    if(div == 0) {
        if(b == c && a <= c) cx = b.x, cy = b.y, overlap = false;
        else if(a == d && c <= a) cx = a.x, cy = a.y, overlap = false;
        else overlap = true;
    }
    else cx = X / div, cy = Y / div, overlap = false;
}

void inter(s a, s b, s c, s d) {
    int val1 = ccw(a, b, c) * ccw(a, b, d);
    int val2 = ccw(c, d, a) * ccw(c, d, b);

    if(val1 == 0 && val2 == 0) {
        if(a > b) swap(a, b);
        if(c > d) swap(c, d);

        if(a <= d && b >= c) {
            cross = true;
            coor(a, b, c, d);
        }
        else cross = false;
    }
    else {
        if(val1 <= 0 && val2 <= 0) {
            cross = true;
            coor(a, b, c, d);
        }
        else cross = false;
    }
}

vector<int> u;

int f(int x) {
    if(u[x] == x) return x;
    else return x = f(u[x]);
}

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

    cout << fixed;
    cout.precision(9);

    int N; cin >> N;

    vector<s> v(N*2);
    for(int i=0; i<N*2; i++) cin >> v[i].x >> v[i].y;

    u.resize(N);
    for(int i=0; i<N; i++) u[i] = i;

    for(int i=0; i<N; i++)
        for(int j=i+1; j<N; j++) {
            inter(v[i*2], v[i*2 + 1], v[j*2], v[j*2 + 1]);

            if(cross && f(i) != f(j)) u[f(i)] = f(j);
        }

    vector<int> w;

    for(int i=0; i<N; i++) w.push_back(f(i));

    sort(w.begin(), w.end());
    w.erase(unique(w.begin(), w.end()), w.end());

    cout << w.size() << "\n";

    w.clear();
    w.resize(N);

    for(int i=0; i<N; i++) w[f(i)]++;

    int Max = 0;
    for(int i=0; i<N; i++) Max = max(Max, w[i]);

    cout << Max << "\n";
}

백준 BOJ 17387번 : 선분 교차 2

문제 난이도 : Gold II

알고리즘 분류 : 기하학, 선분 교차 판정

두 선분의 끝 점의 좌표가 주어질 때, 두 선분의 교차 여부를 구하는 문제이다.

위의 문제와 달리 교차점의 좌표를 구하지 않아도 되므로, 위 문제의 하위 버전임을 알 수 있다.

위 문제의 풀이 코드에서 coor 함수 부분만 지워주면 된다.

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

struct s { int x, y; };

bool operator== (s a, s b) {
    if(a.x == b.x && a.y == b.y) return true;
    else return false;
}
bool operator>= (s a, s b) {
    if(a.x > b.x || (a.x == b.x && a.y >= b.y)) return true;
    else return false;
}
bool operator<= (s a, s b) {
    if(a.x < b.x || (a.x == b.x && a.y <= b.y)) return true;
    else return false;
}
bool operator> (s a, s b) {
    if(a.x > b.x || (a.x == b.x && a.y > b.y)) return true;
    else return false;
}
bool operator< (s a, s b) {
    if(a.x < b.x || (a.x == b.x && a.y < b.y)) return true;
    else return false;
}

int ccw(s a, s b, s c) {
    int val = a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y);

    if(val == 0) return 0;
    else if(val > 0) return 1;
    else if(val < 0) return -1;
}

void inter(s a, s b, s c, s d) {
    int val1 = ccw(a, b, c) * ccw(a, b, d);
    int val2 = ccw(c, d, a) * ccw(c, d, b);

    if(val1 == 0 && val2 == 0) {
        if(a > b) swap(a, b);
        if(c > d) swap(c, d);

        if(a <= d && b >= c) cout << 1 << "\n";
        else cout << 0 << "\n";
    }
    else {
        if(val1 <= 0 && val2 <= 0) cout << 1 << "\n";
        else cout << 0 << "\n";
    }
}

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

    vector<s> p(4);
    for(int i=0; i<4; i++) cin >> p[i].x >> p[i].y;

    cout << fixed;
    cout.precision(9);

    inter(p[0], p[1], p[2], p[3]);
}

백준 BOJ 1558번 : 그림의 개수

문제 난이도 : Gold II

알고리즘 분류 : 기하학, 선분 교차 판정, 분리 집합

연속된 선분으로 이루어졌고 각 선분의 시작점이 이전 점인 선분의 집합을 폴리라인이라고 할 때, N개의 폴리라인이 주어졌을 때 하나의 점이라도 공유하면 같은 그림이라고 한다면 몇 개의 그림이 존재하는지 구하는 문제이다.

4중 for문으로 모든 폴리라인 쌍의 모든 선분 쌍에 대해 하나라도 교차가 있으면 분리 집합을 이용하여 같은 그룹으로 처리해준 뒤 마지막에 그룹의 개수를 세어주면 된다.

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

struct s { int x, y; };

bool operator== (s a, s b) {
    if(a.x == b.x && a.y == b.y) return true;
    else return false;
}
bool operator>= (s a, s b) {
    if(a.x > b.x || (a.x == b.x && a.y >= b.y)) return true;
    else return false;
}
bool operator<= (s a, s b) {
    if(a.x < b.x || (a.x == b.x && a.y <= b.y)) return true;
    else return false;
}
bool operator> (s a, s b) {
    if(a.x > b.x || (a.x == b.x && a.y > b.y)) return true;
    else return false;
}
bool operator< (s a, s b) {
    if(a.x < b.x || (a.x == b.x && a.y < b.y)) return true;
    else return false;
}

int ccw(s a, s b, s c) {
    int val = a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y);

    if(val == 0) return 0;
    else if(val > 0) return 1;
    else if(val < 0) return -1;
}

bool cross, overlap;
double cx, cy;

void coor(s a, s b, s c, s d) {
    double X = (a.x * b.y - a.y * b.x) * (c.x - d.x) - (a.x - b.x) * (c.x * d.y - c.y * d.x);
    double Y = (a.x * b.y - a.y * b.x) * (c.y - d.y) - (a.y - b.y) * (c.x * d.y - c.y * d.x);
    double div = (a.x - b.x) * (c.y - d.y) - (a.y - b.y) * (c.x - d.x);

    if(div == 0) {
        if(b == c && a <= c) cx = b.x, cy = b.y, overlap = false;
        else if(a == d && c <= a) cx = a.x, cy = a.y, overlap = false;
        else overlap = true;
    }
    else cx = X / div, cy = Y / div, overlap = false;
}

void inter(s a, s b, s c, s d) {
    int val1 = ccw(a, b, c) * ccw(a, b, d);
    int val2 = ccw(c, d, a) * ccw(c, d, b);

    if(val1 == 0 && val2 == 0) {
        if(a > b) swap(a, b);
        if(c > d) swap(c, d);

        if(a <= d && b >= c) {
            cross = true;
            coor(a, b, c, d);
        }
        else cross = false;
    }
    else {
        if(val1 <= 0 && val2 <= 0) {
            cross = true;
            coor(a, b, c, d);
        }
        else cross = false;
    }
}

vector<int> u;

int f(int x) {
    if(x == u[x]) return x;
    else return x = f(u[x]);
}

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

    int N; cin >> N;

    vector<vector<s>> v(N);
    for(int i=0; i<N; i++) {
        int M; cin >> M;

        while(M--) {
            s tmp; cin >> tmp.x >> tmp.y;

            v[i].push_back(tmp);
        }

        if(v[i].size() == 1) v[i].push_back(v[i].back());
    }

    u.resize(N);
    for(int i=0; i<N; i++) u[i] = i;

    for(int i=0; i<N; i++)
        for(int j=i+1; j<N; j++) {
            bool check = false;

            for(int k=1; k<v[i].size(); k++)
                for(int l=1; l<v[j].size(); l++) {
                    inter(v[i][k-1], v[i][k], v[j][l-1], v[j][l]);

                    if(cross) check = true;
                }

            if(check && f(i) != f(j)) u[f(i)] = f(j);
        }

    vector<int> w;
    for(int i=0; i<N; i++) w.push_back(f(i));

    sort(w.begin(), w.end());
    w.erase(unique(w.begin(), w.end()), w.end());

    cout << w.size() << "\n";
}

2-SAT 알고리즘 응용 문제 풀어보기 220827

restudy — Sat, 27 Aug 2022 20:38:36 +0900

백준 BOJ 11281번 : 2-SAT - 4

문제 난이도 : Platinum III

알고리즘 분류 : SCC, 2-SAT

2-SAT에 맞는 식이 주어질 때 x1 ~ xN에 참 또는 거짓을 넣어 식 전체가 참이 되도록 만들 수 있는지 판별하고, 만약 가능하다면 식을 참으로 만드는 각 변수 x1 ~ xN의 값으로 가능한 것을 하나 구하는 문제이다.

식을 참으로 만들 수 있는지 여부의 판별은 2-SAT - 3의 풀이와 동일하다.

이제 식을 만족시키는 각 변수의 참/거짓 값을 찾아야하는데, 그리디하게 접근해보자.

x → y라는 식이 거짓이 되는 경우는 x = true, y = false인 경우뿐이다.

x = false이면 y는 true든 false든 관계없다.

식을 최대한 참으로 만들기 위한 최선의 전략은 노드들을 연결했을 때 앞인 것에서부터 값들을 false로 만들어주면 된다는 것이다.

이 때 x = false라면, ~x = true이므로 반대에 해당하는 번호의 노드는 true로 체크해주면 된다.

그러면 이제 다음 문제는 연결 관계가 앞인 것부터 어떻게 접근하냐는 것인데, 이것은 SCC 알고리즘에 원리에 의해 쉽게 구현이 가능하다.

왜냐하면 dfs를 수행할 때 깊이가 깊은 것부터 scc 번호가 매겨졌으므로, scc 그룹의 번호가 큰 것이 위상적으로 앞에 위치하기 때문이다.

따라서 scc 번호를 기준으로 내림차순 정렬을 한 뒤, 앞에서부터 false를 매겨주면 된다.

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

vector<vector<int>> adj, scc;
vector<int> nnum, cnum;
int ncnt = 0, ccnt = 0;

stack<int> s;
vector<bool> ch;

int dfs(int x) {
    nnum[x] = ++ncnt;
    s.push(x);

    int tmp = nnum[x];

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(nnum[y] == 0) tmp = min(tmp, dfs(y));
        else if(!ch[y]) tmp = min(tmp, nnum[y]);
    }

    if(tmp == nnum[x]) {
        vector<int> v;
        ccnt++;

        while(true) {
            int y = s.top();
            s.pop();

            v.push_back(y);

            ch[y] = true;
            cnum[y] = ccnt;

            if(y == x) break;
        }

        sort(v.begin(), v.end());

        scc.push_back(v);
    }

    return tmp;
}

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

    int N, M; cin >> N >> M;

    adj.resize(N*2);

    while(M--) {
        int a, b; cin >> a >> b;

        if(a < 0) a = (-a)*2 - 2;
        else a = a*2 - 1;

        if(b < 0) b = (-b)*2 - 2;
        else b = b*2 - 1;

        int na, nb;

        if(a % 2 == 0) na = a + 1;
        else na = a - 1;

        if(b % 2 == 0) nb = b + 1;
        else nb = b - 1;

        adj[na].push_back(b);
        adj[nb].push_back(a);
    }

    nnum.resize(N*2);
    cnum.resize(N*2);
    ch.resize(N*2);

    for(int i=0; i<N*2; i++)
        if(nnum[i] == 0) dfs(i);

    bool check = true;

    for(int i=0; i<N; i++) {
        if(cnum[i*2] == cnum[i*2 + 1]) {
            check = false;
            break;
        }
    }

    if(check) cout << 1 << "\n";
    else {
        cout << 0 << "\n";
        return 0;
    }

    vector<pair<int, int>> p(N*2);
    for(int i=0; i<N*2; i++) p[i] = {cnum[i], i};

    sort(p.begin(), p.end(), greater<pair<int, int>>());

    vector<int> tf(N*2, -1);

    for(int i=0; i<N*2; i++) {
        int x = p[i].second;

        if(tf[x/2] == -1) {
            if(x % 2 == 1) tf[x/2] = 0;
            else tf[x/2] = 1;
        }
    }

    for(int i=0; i<N; i++) cout << tf[i] << " ";
    cout << "\n";
}

참고로 이 문제와 동일한 풀이 코드로 백준 BOJ 11278번 : 2-SAT - 2 문제를 풀이할 수 있다. (범위만 더 작음)

백준 BOJ 3648번 : 아이돌

문제 난이도 : Platinum III

알고리즘 분류 : SCC, 2-SAT

N명의 참가자에 대해 M명의 심사위원이 각각 두 명의 참가자에 대해 찬성, 반대를 하는데, 1번 참가자는 반드시 선발하면서 각 심사위원의 평가 중 최소 하나는 반영되도록 선발 멤버를 뽑을 수 있는지의 여부를 구하는 문제이다.

나머지는 기본적인 2-SAT 문제와 동일한데, 1번 참가자를 반드시 합격시키는 조건이 포함된다.

이것은 기존의 식에 (x1 ∨ x1) 절을 포함시켜서 해결이 가능하다. (그러면 x1이 반드시 참이 되어야하므로)

그러면 그래프를 연결해주어야 하는데, 양쪽 항이 동일하므로 ~x1 → x1 하나만 이어주면 된다. (아래의 풀이 코드에서는 adj[0].push_back(1);에 해당)

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

vector<vector<int>> adj, scc;
vector<int> nnum, cnum;
int ncnt = 0, ccnt = 0;

stack<int> s;
vector<bool> ch;

int dfs(int x) {
    nnum[x] = ++ncnt;
    s.push(x);

    int tmp = nnum[x];

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(nnum[y] == 0) tmp = min(tmp, dfs(y));
        else if(!ch[y]) tmp = min(tmp, nnum[y]);
    }

    if(tmp == nnum[x]) {
        vector<int> v;
        ccnt++;

        while(true) {
            int y = s.top();
            s.pop();

            v.push_back(y);

            ch[y] = true;
            cnum[y] = ccnt;

            if(y == x) break;
        }

        sort(v.begin(), v.end());

        scc.push_back(v);
    }

    return tmp;
}

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

    int N, M;

    while(cin >> N >> M) {
        adj.clear(); adj.resize(N*2);

        while(M--) {
            int a, b; cin >> a >> b;

            if(a < 0) a = (-a)*2 - 2;
            else a = a*2 - 1;

            if(b < 0) b = (-b)*2 - 2;
            else b = b*2 - 1;

            int na, nb;

            if(a % 2 == 0) na = a + 1;
            else na = a - 1;

            if(b % 2 == 0) nb = b + 1;
            else nb = b - 1;

            adj[na].push_back(b);
            adj[nb].push_back(a);
        }

        adj[0].push_back(1);

        nnum.clear(); nnum.resize(N*2);
        cnum.clear(); cnum.resize(N*2);
        ch.clear();   ch.resize(N*2);

        for(int i=0; i<N*2; i++)
            if(nnum[i] == 0) dfs(i);

        bool check = true;

        for(int i=0; i<N; i++) {
            if(cnum[i*2] == cnum[i*2 + 1]) {
                check = false;
                break;
            }
        }

        if(check) cout << "yes\n";
        else cout << "no\n";
    }
}

백준 BOJ 16915번 : 호텔 관리

문제 난이도 : Platinum III

알고리즘 분류 : SCC, 2-SAT

N개의 방이 각 2개의 스위치에 연결되어 있으며, M개의 스위치에 대해 연결되어 있는 방의 정보가 주어질 때, 스위치를 누르면 연결되어있는 방들의 문이 toggle (열려 있으면 닫히고, 닫혀 있으면 열림) 된다고 한다면 방의 초기 문의 상태가 주어졌을 때 주어진 스위치들만으로 방의 문을 열 수 있는지 묻는 문제이다.

각 방이 무조건 2개의 스위치에만 연결되어있다는 것이 포인트이다.

그러면 연결된 상태를 이용하여 2-SAT 문제로 치환시켜 생각할 수 있다.

예를 들어 어떤 방이 a번 스위치와 b번 스위치에 연결되어 있다고 할 때, 문이 열려있다면 두 스위치 모두 누르거나 누르지 않아야 하며 (a → b, ~a → ~b) 문이 닫혀있다면 둘 중 하나의 스위치만 눌러야 한다. (a → ~b, ~a → b)

이제 그래프 연결을 해주고 SCC를 돌린 뒤 기본적인 2-SAT 알고리즘 풀이대로 풀어주면 된다.

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

vector<vector<int>> adj, scc;
vector<int> nnum, cnum;
int ncnt = 0, ccnt = 0;

stack<int> s;
vector<bool> ch;

int dfs(int x) {
    nnum[x] = ++ncnt;
    s.push(x);

    int tmp = nnum[x];

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(nnum[y] == 0) tmp = min(tmp, dfs(y));
        else if(!ch[y]) tmp = min(tmp, nnum[y]);
    }

    if(tmp == nnum[x]) {
        vector<int> v;
        ccnt++;

        while(true) {
            int y = s.top();
            s.pop();

            v.push_back(y);

            ch[y] = true;
            cnum[y] = ccnt;

            if(y == x) break;
        }

        sort(v.begin(), v.end());

        scc.push_back(v);
    }

    return tmp;
}

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

    int N, M; cin >> N >> M;

    vector<int> v(N+1);
    for(int i=1; i<=N; i++) cin >> v[i];

    vector<vector<int>> u(N+1);

    for(int i=1; i<=M; i++) {
        int K; cin >> K;

        while(K--) {
            int x; cin >> x;

            u[x].push_back(i);
        }
    }

    adj.resize(M*2);

    for(int i=1; i<=N; i++) {
        int a = u[i][0]*2 - 1, b = u[i][1]*2 - 1;

        int na = a - 1, nb = b - 1;

        if(v[i] == 0) {
            adj[a].push_back(nb);
            adj[b].push_back(na);
            adj[na].push_back(b);
            adj[nb].push_back(a);
        }
        else {
            adj[a].push_back(b);
            adj[b].push_back(a);
            adj[na].push_back(nb);
            adj[nb].push_back(na);
        }
    }

    nnum.resize(M*2);
    cnum.resize(M*2);
    ch.resize(M*2);

    for(int i=0; i<M*2; i++)
        if(nnum[i] == 0) dfs(i);

    bool check = true;

    for(int i=0; i<M; i++) {
        if(cnum[i*2] == cnum[i*2 + 1]) {
            check = false;
            break;
        }
    }

    if(check) cout << 1 << "\n";
    else cout << 0 << "\n";
}

백준 BOJ 7535번 : A Bug's Life

문제 난이도 : Gold II

알고리즘 분류 : 그래프 탐색 (SCC, 2-SAT)

N마리의 벌레가 있고, M개의 상호작용 쌍이 주어질 때, 서로 다른 성별의 벌레들끼리만 상호작용을 한다면 주어진 벌레들 중에서 규칙을 어기는 벌레가 있었는지 검사하는 문제이다.

N마리의 성별을 bool 변수로 잡고 true면 수컷, false면 암컷이라고 하면 2-SAT 문제가 된다.

a b가 상호작용을 했다면 a가 수컷이라면 b는 암컷이고, a가 암컷이라면 b는 수컷이다.

따라서 a → ~b, b → ~a, ~a → b, ~b → a라는 4개의 명제가 얻어진다.

이제 SCC와 2-SAT 알고리즘으로 풀이해주면 된다.

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

vector<vector<int>> adj, scc;
vector<int> nnum, cnum;
int ncnt = 0, ccnt = 0;

stack<int> s;
vector<bool> ch;

int dfs(int x) {
    nnum[x] = ++ncnt;
    s.push(x);

    int tmp = nnum[x];

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(nnum[y] == 0) tmp = min(tmp, dfs(y));
        else if(!ch[y]) tmp = min(tmp, nnum[y]);
    }

    if(tmp == nnum[x]) {
        vector<int> v;
        ccnt++;

        while(true) {
            int y = s.top();
            s.pop();

            v.push_back(y);

            ch[y] = true;
            cnum[y] = ccnt;

            if(y == x) break;
        }

        sort(v.begin(), v.end());

        scc.push_back(v);
    }

    return tmp;
}

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

    int T; cin >> T;

    for(int t=1; t<=T; t++) {
        int N, M; cin >> N >> M;

        adj.clear(); adj.resize(N*2);

        while(M--) {
            int a, b; cin >> a >> b;

            if(a < 0) a = (-a)*2 - 2;
            else a = a*2 - 1;

            if(b < 0) b = (-b)*2 - 2;
            else b = b*2 - 1;

            int na, nb;

            if(a % 2 == 0) na = a + 1;
            else na = a - 1;

            if(b % 2 == 0) nb = b + 1;
            else nb = b - 1;

            adj[a].push_back(nb);
            adj[b].push_back(na);

            adj[na].push_back(b);
            adj[nb].push_back(a);
        }

        nnum.clear(); nnum.resize(N*2);
        cnum.clear(); cnum.resize(N*2);
        ch.clear();   ch.resize(N*2);

        for(int i=0; i<N*2; i++)
            if(nnum[i] == 0) dfs(i);

        bool check = true;

        for(int i=0; i<N; i++) {
            if(cnum[i*2] == cnum[i*2 + 1]) {
                check = false;
                break;
            }
        }

        cout << "Scenario #" << t << ":\n";

        if(check) cout << "No suspicious bugs found!\n\n";
        else cout << "Suspicious bugs found!\n\n";
    }
}

백준 BOJ 2-SAT 알고리즘, 우선순위 큐 등 풀이 220826

restudy — Fri, 26 Aug 2022 14:06:09 +0900

백준 BOJ 11280번 : 2-SAT - 3

문제 난이도 : Platinum IV

알고리즘 분류 : SCC, 2-SAT

bool 변수 x1, ... , xn에 대해서 F = (xi ∨ xj) ∧ (xk ∨ xl) ∧ ... 와 같은 꼴의 식이 주어질 때, 변수들의 참 거짓을 적절히 설정하여 F의 값이 참이 되게 할 수 있는지 판별하는 문제이다.

(a ∨ b)와 같은 식이 있을 때 a가 거짓이면 b가 참, b가 거짓이면 a가 참이라는 두 개의 식을 얻을 수 있고 이렇게 2M개의 식을 얻은 뒤 x와 ~x가 모두 참인 식이 하나라도 나오면 불가능, 나머지 경우는 가능이다.

이것은 SCC로 풀이 가능한데, 2N개의 노드에 대해 2M개의 간선을 모두 연결한 그래프를 만든 후 a와 ~a가 같은 scc에 속해있는 경우 불가능임을 판별하면 되기 때문이다.

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

vector<vector<int>> adj, scc;
vector<int> nnum, cnum;
int ncnt = 0, ccnt = 0;

stack<int> s;
vector<bool> ch;

int dfs(int x) {
    nnum[x] = ++ncnt;
    s.push(x);

    int tmp = nnum[x];

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(nnum[y] == 0) tmp = min(tmp, dfs(y));
        else if(!ch[y]) tmp = min(tmp, nnum[y]);
    }

    if(tmp == nnum[x]) {
        vector<int> v;
        ccnt++;

        while(true) {
            int y = s.top();
            s.pop();

            v.push_back(y);

            ch[y] = true;
            cnum[y] = ccnt;

            if(y == x) break;
        }

        sort(v.begin(), v.end());

        scc.push_back(v);
    }

    return tmp;
}

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

    int N, M; cin >> N >> M;

    adj.resize(N*2);

    while(M--) {
        int a, b; cin >> a >> b;

        if(a < 0) a = (-a)*2 - 2;
        else a = a*2 - 1;

        if(b < 0) b = (-b)*2 - 2;
        else b = b*2 - 1;

        int na, nb;

        if(a % 2 == 0) na = a + 1;
        else na = a - 1;

        if(b % 2 == 0) nb = b + 1;
        else nb = b - 1;

        adj[na].push_back(b);
        adj[nb].push_back(a);
    }

    nnum.resize(N*2);
    cnum.resize(N*2);
    ch.resize(N*2);

    for(int i=0; i<N*2; i++)
        if(nnum[i] == 0) dfs(i);

    for(int i=0; i<N; i++) {
        if(cnum[i*2] == cnum[i*2 + 1]) {
            cout << 0 << "\n";
            return 0;
        }
    }

    cout << 1 << "\n";
}

백준 BOJ 1217번 : 하우스 M.D., 백준 BOJ 2207번 : 가위바위보, 백준 BOJ 3747번 : 완벽한 선거! 모두 이 문제와 동일한 문제이다.

백준 BOJ 11277번 : 2-SAT - 1 문제는 이 문제보다 범위가 작은 하위 문제로, 동일한 풀이 코드로 풀이할 수 있다.

백준 BOJ 18149번 : Length of Bundle Rope

문제 난이도 : Gold V

알고리즘 분류 : 우선순위 큐

N개의 줄의 길이가 주어지고, 길이가 a인 줄과 길이가 b인 줄을 연결하는데 a+b의 비용이 든다면, 모든 줄을 연결하는데 필요한 최소 비용을 구하는 문제이다.

a, b, c 3개의 줄을 연결한다고 생각해보자.

a와 b를 연결하면 a+b의 비용이 들고, 그 다음 연결된 a, b에 c를 연결하면 a+b+c의 비용이 들어 총 2a+2b+c의 비용이 든다.

이것으로 알 수 있는 사실은 먼저 연결한 줄의 비용이 더 든다는 것이다.

따라서 우선순위 큐로 짧은 줄의 길이가 top으로 오게 한 뒤 2개씩 top에서 꺼내어 합치고 비용을 더해주는 방식으로 문제를 풀이할 수 있다.

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

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

    int T; cin >> T;

    while(T--) {
        int N; cin >> N;

        priority_queue<int, vector<int>, greater<int>> pq;

        while(N--) {
            int x; cin >> x;

            pq.push(x);
        }

        int ans = 0;

        while(true) {
            int x = pq.top();
            pq.pop();

            if(pq.empty()) break;

            int y = pq.top();
            pq.pop();

            ans += x + y;
            pq.push(x + y);
        }

        cout << ans << "\n";
    }
}

백준 BOJ 6195번 : Fence Repair

문제 난이도 : Gold IV

알고리즘 분류 : 우선순위 큐

길이가 N개 부분 길이의 총합인 fence를 N개의 부분으로 나눌 때, 길이 a+b인 fence를 a, b로 나누는 비용이 a+b라고 한다면 fence를 N개의 조각으로 나누는 최소 비용을 구하는 문제이다.

조각을 나누는 것이 아니라 역으로 합쳐가면서 최소 비용을 구한다고 생각해보자.

그러면 a, b 두 조각을 합치는 비용이 a+b로 위의 문제 상황과 같은 상황이 된다.

따라서 동일한 코드로 풀이해줄 수 있다.

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

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

    int N; cin >> N;

    priority_queue<int, vector<int>, greater<int>> pq;

    while(N--) {
        int x; cin >> x;

        pq.push(x);
    }

    int ans = 0;

    while(true) {
        int x = pq.top();
        pq.pop();

        if(pq.empty()) break;

        int y = pq.top();
        pq.pop();

        ans += x + y;
        pq.push(x + y);
    }

    cout << ans << "\n";
}

백준 BOJ 11679번 : Canvas Painting

문제 난이도 : Gold IV

알고리즘 분류 : 우선순위 큐

N개의 구획으로 나누어진 캔버스를 칠하는 비용에 대한 규칙이 주어지고, 모든 구획을 다른 색으로 칠하기 위해 필요한 최소 비용을 구하는 문제이다.

규칙이 다른 문제에 비해서 복잡하게 되어있으나, 결국은 위의 상황들과 똑같이 치환시켜서 생각할 수 있다.

백준 BOJ 18149 문제와 동일한 풀이 코드로 정답 처리를 받을 수 있다.

백준 BOJ 13975번 : 파일 합치기 3

문제 난이도 : Gold IV

알고리즘 분류 : 우선순위 큐

N개의 파일이 있는데, 두 파일을 합칠 때 두 파일의 크기만큼 비용이 든다고 할 때, 모든 파일을 합치기 위해 필요한 최소 비용을 구하는 문제이다.

역시 위의 문제들과 동일한 상황이며, 똑같은 코드로 풀이 가능하다.

백준 BOJ 2696번 : 중앙값 구하기

문제 난이도 : Gold II

알고리즘 분류 : 우선순위 큐

값이 입력이 하나씩 들어오고, 홀수 번째 수가 입력될 때마다 그 때의 중앙값을 구하는 문제이다.

우선순위 큐 두 개를 이용하여, 양쪽의 수가 똑같아지도록 유지하면서 큐 두 개에 입력을 받으면 중앙값을 즉시 구할 수 있게 된다.

top에 최댓값이 오도록 하는 pq는 작은 수 절반을 저장하도록 하고, top에 최솟값이 오도록 하는 pq에는 큰 수 절반을 저장하도록 한다.

만약 top의 값의 크기 관계가 반대가 되었다면 가장 최근에 들어온 값 1개가 문제가 되는 것이므로 top에 있는 값의 위치만 바꾸어주면 우선순위 큐에 들어가서는 알아서 log 시간에 정렬이 된다.

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

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

    int T; cin >> T;

    while(T--) {
        int N; cin >> N;

        priority_queue<int> qx;
        priority_queue<int, vector<int>, greater<int>> qn;

        vector<int> v;

        for(int i=0; i<N; i++) {
            int x; cin >> x;

            if(qx.size() == qn.size()) qx.push(x);
            else qn.push(x);

            if(!qx.empty() && !qn.empty() && qx.top() > qn.top()) {
                int x = qx.top();
                int y = qn.top();

                qx.pop();
                qn.pop();

                qx.push(y);
                qn.push(x);
            }

            if(i % 2 == 0) v.push_back(qx.top());
        }

        cout << v.size() << "\n";

        for(int i=0; i<v.size(); i++) {
            cout << v[i] << " ";

            if(i % 10 == 9) cout << "\n";
        }

        cout << "\n";
    }
}

백준 BOJ 10166번 : 관중석

문제 난이도 : Silver II

알고리즘 분류 : 유클리드 호제법

위와 같이 반지름이 D인 원 위에 관중석이 일정한 간격으로 D개 있는 원이 D1 ~ D2에 분포되어 있을 때, 앞에 가려지지 않고 중심으로 도달할 수 있는 점들의 개수를 구하는 문제이다.

각도가 같으면 두 점 중 하나는 가려지게 되므로, 각도에 비례하는 값인 x/D (x = 1 ~ D) 값이 이전에 나온적 있는지를 체크하여 중복을 확인할 수 있다.

따라서 i = D1 ~ D2 범위에서, j = 1 ~ i 범위에서 모든 분수를 적어보고 기약분수로 만들어 이전에 나온적 있었는지 체크해보면 된다.

기약분수를 만드는 과정에서 시간 복잡도를 감소시키기 위해 유클리드 호제법이 사용된다.

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

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

    int N, M; cin >> N >> M;

    vector<vector<bool>> v(2001, vector<bool>(2001));
    int ans = 0;

    for(int i=N; i<=M; i++)
        for(int j=1; j<=i; j++) {
            int a = i / __gcd(i, j);
            int b = j / __gcd(i, j);

            if(!v[a][b]) ans++;

            v[a][b] = true;
        }

    cout << ans << "\n";
}

백준 BOJ 11501번 : 주식

문제 난이도 : Silver II

알고리즘 분류 : 그리디

N개의 일이 주어지고 각 날짜의 주식의 가격이 주어질 때, 각 날마다 주식을 1개 사거나 또는 1개 이상 매도할 수 있다고 할 때, N일 후에 취할 수 있는 이득의 최댓값을 구하는 문제이다.

뒤에서 앞으로 오면서 지금까지 나온 최댓값에서 현재 가격을 뺀 가격만큼 매일 이득을 볼 수 있다.

따라서 최댓값을 기록하면서 현재 가격을 뺀 값들을 합쳐주면 된다.

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

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

    int T; cin >> T;

    while(T--) {
        int N; cin >> N;

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

        int Max = 0, ans = 0;

        for(int i=N-1; i>=0; i--) {
            Max = max(Max, v[i]);

            ans += Max - v[i];
        }

        cout << ans << "\n";
    }
}

백준 BOJ 9253번 : 스페셜 저지

문제 난이도 : Bronze II

알고리즘 분류 : 문자열

문자열 a, b, c가 주어질 때 a, b의 최대 일치 부분 수열이 c인지 검사하는 문제이다.

a.find(c)는 a에서 c가 나타나는 첫 주소를 반환하고 이를 활용하여 풀이를 구현할 수 있다.

a에 c가 포함되지 않는 경우 a.find(c) 값은 매우 큰 양수를 가지므로, 이것이 a.length()보다 크거나 같은지 검사하여 c가 문자열에 포함되지 않음을 확인할 수 있다.

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

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

    string a, b, c; cin >> a >> b >> c;

    if(a.find(c) >= a.length() || b.find(c) >= b.length()) {
        cout << "NO\n";
        return 0;
    }

    bool check = true;

    if(a.find(c) > 0 && b.find(c) > 0 && a[a.find(c)-1] == b[b.find(c)-1]) check = false;
    if(a.find(c) + c.length() < a.length() && b.find(c) + c.length() < b.length()
       && a[a.find(c) + c.length()] == b[b.find(c) + c.length()]) check = false;

    if(check) cout << "YES\n";
    else cout << "NO\n";
}

백준 BOJ 24957번 : Loop of Chocolate

문제 난이도 : Bronze II

알고리즘 분류 : 기하학, 구현

3차원 공간 상에서 N개의 구의 좌표가 주어질 때, 구의 총 부피를 구하는 문제이다.

문제는 구가 겹치는 경우가 발생한다는 것인데, 반지름이 r인 두 구 사이의 거리가 d(< 2r)일 때 겹치는 공간의 부피는 다음과 같다. (문제에서 알려준다.)

따라서 N개의 구의 부피를 더하고, 거기에서 2중 for문으로 일일이 쌍을 대조해보면서 겹치는 부피들을 빼주면 된다.

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

struct s { double x, y, z; };

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

    double N, r; cin >> N >> r;

    vector<s> v(N);
    for(int i=0; i<N; i++)
        cin >> v[i].x >> v[i].y >> v[i].z;

    double ans = N * 4.0 / 3.0 * M_PI * r * r * r;

    for(int i=0; i<N; i++)
        for(int j=i+1; j<N; j++) {
            double d = sqrt(pow(v[i].x - v[j].x, 2) + pow(v[i].y - v[j].y, 2) + pow(v[i].z - v[j].z, 2));

            if(d >= r*2) continue;

            double vol = 2.0 / 3.0 * M_PI * pow(r - d/2, 2) * (2*r + d/2);

            ans -= vol;
        }

    cout << fixed;
    cout.precision(7);

    cout << ans << "\n";
}

백준 BOJ 우선순위 큐(Priority Queue) 문제 풀이 220825

restudy — Thu, 25 Aug 2022 13:05:42 +0900

백준 BOJ 13904번 : 과제

문제 난이도 : Gold III

알고리즘 분류 : 그리디, 우선순위 큐

N개의 과제들의 남은 날짜 수와 그 과제의 점수가 주어질 때, 하루에 하나씩 과제를 하여 얻을 수 있는 점수의 최댓값을 구하는 문제이다.

먼저 문제들을 남을 일 수를 기준으로 오름차순 정렬해준 뒤, 우선순위 큐에 할 과제들만 남겨보자.

우선순위 큐에 과제를 하나씩 넣고 만약 우선순위 큐의 size가 방금 넣은 날짜 수보다 많다면 같아질 때까지 빼주면 된다.

i번째 과제를 넣는 과정을 통해 i일까지 할 과제들을 우선순위 큐에 남긴다고 생각하면, 하루에 한 개씩 과제를 할 수 있으므로 i보다 많은 수의 과제가 들어있으면 안되기 때문이다.

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

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

    int N; cin >> N;

    vector<pair<int, int>> v(N);

    for(int i=0; i<N; i++)
        cin >> v[i].first >> v[i].second;

    sort(v.begin(), v.end());

    priority_queue<int, vector<int>, greater<int>> pq;

    for(int i=0; i<N; i++) {
        pq.push(v[i].second);

        while(v[i].first < pq.size()) pq.pop();
    }

    int ans = 0;

    while(!pq.empty()) {
        ans += pq.top();
        pq.pop();
    }

    cout << ans << "\n";
}

백준 BOJ 2109번 : 순회강연

문제 난이도 : Gold III

알고리즘 분류 : 그리디, 우선순위 큐

N개의 강연 목록이 있고, 각 강연은 d일 안에 가서 하면 p의 보상을 받을 수 있다.

하루에 한 개씩 강연을 할 때 최대로 얻을 수 있는 보상의 합을 구하는 문제이다.

위의 문제와 동일하다.

입력부만 v[i].second, v[i].first 순으로 받아주면 동일한 코드로 풀린다.

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

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

    int N; cin >> N;

    vector<pair<int, int>> v(N);

    for(int i=0; i<N; i++)
        cin >> v[i].second >> v[i].first;

    sort(v.begin(), v.end());

    priority_queue<int, vector<int>, greater<int>> pq;

    for(int i=0; i<N; i++) {
        pq.push(v[i].second);

        while(v[i].first < pq.size()) pq.pop();
    }

    int ans = 0;

    while(!pq.empty()) {
        ans += pq.top();
        pq.pop();
    }

    cout << ans << "\n";
}

백준 BOJ 9869번 : Milk Scheduling

문제 난이도 : Gold III

알고리즘 분류 : 그리디, 우선순위 큐

농부가 소들의 젖을 짜는데 그 후보가 N마리이고, 각각 얻을 수 있는 우유의 양과 특정 순서 내에서만 짤 수 있는 번호가 주어질 때, 농부가 얻을 수 있는 우유의 최대 양을 구하는 문제이다.

위의 문제들과 동일한 문제이며, BOJ 2109 풀이와 동일한 소스 코드로 풀린다.

백준 BOJ 1781번 : 컵라면

문제 난이도 : Gold III

알고리즘 분류 : 그리디, 우선순위 큐

N개의 문제들의 데드라인과 그 문제를 풀었을 때 받을 수 있는 컵라면이 주어지고, 단위 시간 당 1개의 문제만 풀이할 수 있을 때 받을 수 있는 컵라면의 최댓값을 구하는 문제이다.

위의 문제들과 동일한 문제이며, BOJ 13904 풀이와 동일한 코드로 풀린다.

백준 BOJ 1374번 : 강의실

문제 난이도 : Gold V

알고리즘 분류 : 우선순위 큐

N개 강의의 시작 시간과 끝나는 시간이 주어질 때, 한 강의는 한 강의실에서만 하고 모든 강의를 진행하기 위해서는 최소 몇 개의 강의실이 필요한지 구하는 문제이다.

시작 시간이 증가하는 순으로 오름차순 정렬을 해주고, 우선순위 큐에 강의가 끝나는 시간을 push 해주고 다음 강의와 비교할 때 시작 시간보다 먼저 끝나는 강의들은 pop을 해주는 과정을 반복한다.

이 때 pq의 size가 최대가 될 때의 크기가 답이 된다.

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

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

    int N; cin >> N;

    vector<pair<int, int>> v(N);

    for(int i=0; i<N; i++) {
        int x;

        cin >> x >> v[i].first >> v[i].second;
    }

    sort(v.begin(), v.end());

    priority_queue<int, vector<int>, greater<int>> pq;
    int ans = 0;

    for(int i=0; i<N; i++) {
        while(!pq.empty() && pq.top() <= v[i].first) pq.pop();

        pq.push(v[i].second);

        ans = max(ans, (int)pq.size());
    }

    cout << ans << "\n";
}

백준 BOJ 19598번 : 최소 회의실 개수

문제 난이도 : Gold V

알고리즘 분류 : 우선순위 큐

N개의 회의의 시작 시간과 종료 시간이 주어질 때, 필요한 최소 회의실의 개수를 구하는 문제이다.

위의 문제와 동일하다.

회의 번호가 없다는 것만 빼고는 나머지는 동일한 코드로 풀이할 수 있다.

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

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

    int N; cin >> N;

    vector<pair<int, int>> v(N);

    for(int i=0; i<N; i++) cin >> v[i].first >> v[i].second;

    sort(v.begin(), v.end());

    priority_queue<int, vector<int>, greater<int>> pq;
    int ans = 0;

    for(int i=0; i<N; i++) {
        while(!pq.empty() && pq.top() <= v[i].first) pq.pop();

        pq.push(v[i].second);

        ans = max(ans, (int)pq.size());
    }

    cout << ans << "\n";
}

백준 BOJ 5619번 : 세 번째

문제 난이도 : Silver II

알고리즘 분류 : 그리디

N개의 수가 주어질 때, 두 수를 이어붙여 만든 수들 중 세 번째로 작은 수를 구하는 문제이다.

수를 오름차순으로 정렬하여 i번째로 작은 수를 ai라고 하자.

그럼 a1a4가 a2a1, a3a1 a2a3 등보다 작을 수가 있다.

따라서 a4까지는 조합을 해본 뒤 정렬을 해서 답을 구해주어야 한다.

즉, 4C2 x 2 = 12가지 수들을 벡터에 넣고 정렬한 뒤 3번째로 작은 값을 답으로 구해주면 된다.

원래는 우선순위 큐로도 풀 수 있는 문제라고 하지만, 이 풀이가 더 간단해 보여서 이렇게 풀었다.

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

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

    int N; cin >> N;

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

    sort(v.begin(), v.end());

    vector<int> u;

    string a = to_string(v[0]);
    string b = to_string(v[1]);
    string c = to_string(v[2]);

    u.push_back(stoll(a + b));
    u.push_back(stoll(b + a));
    u.push_back(stoll(b + c));
    u.push_back(stoll(c + b));
    u.push_back(stoll(c + a));
    u.push_back(stoll(a + c));

    if(N >= 4) {
        string d = to_string(v[3]);

        u.push_back(stoll(a + d));
        u.push_back(stoll(b + d));
        u.push_back(stoll(c + d));
        u.push_back(stoll(d + a));
        u.push_back(stoll(d + b));
        u.push_back(stoll(d + c));
    }

    sort(u.begin(), u.end());

    cout << u[2] << "\n";
}

백준 BOJ 13984번 : Contest Score

문제 난이도 : Silver II

알고리즘 분류 : 우선순위 큐

N개의 각 문제의 푸는 시간이 주어질 때, 앞에서 M개의 문제를 보고 시간이 가장 적게 드는 것을 풀고 그 다음 2 ~ M+1번째 문제들에 대해 같은 과정을 반복하고, ... 하여 모든 문제를 푸는데 걸리는 시간 페널티의 합을 구하는 문제이다.

우선순위 큐를 이용하여 M개의 값을 담고, 그 중 가장 시간이 적은 것을 sum 값에 더하고, 이 sum 값을 ans에 더하는 과정을 반복해주면 된다.

마지막 N-M개 자료에 대해서는 더 이상 입력을 받지 않고 큐에서 pop 하는 과정만 반복해주면 된다.

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

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

    int N, M; cin >> N >> M;

    priority_queue<int, vector<int>, greater<int>> pq;

    for(int i=0; i<M; i++) {
        int x; cin >> x;

        pq.push(x);
    }

    int ans = 0, sum = 0;

    for(int i=0; i<N-M; i++) {
        sum += pq.top();
        ans += sum;

        pq.pop();

        int x; cin >> x;
        pq.push(x);
    }

    while(!pq.empty()) {
        sum += pq.top();
        ans += sum;

        pq.pop();
    }

    cout << ans << "\n";
}

백준 BOJ 23757번 : 아이들과 선물 상자

문제 난이도 : Silver II

알고리즘 분류 : 우선순위 큐

1번부터 N번까지 상자에 들어있는 선물들의 개수가 주어지고, 1번부터 M번 사람까지 원하는 수의 선물이 있을 때, 1번 사람부터 순서대로 나와 남아있는 선물들 중 가장 개수가 많은 것에서 원하는 개수를 가져가고 남은 선물들은 그대로 둘 때, 모든 사람이 선물을 가져갈 수 있는지의 여부를 구하는 문제이다.

우선순위 큐를 활용하여, 먼저 N개의 수를 넣어 놓고 1번부터 M번 사람까지 순서대로 우선순위 큐의 top에 있는 값과 비교를 하여 원하는 값이 top보다 큰 경우가 있으면 0을 출력해주면 된다.

이 문제를 푸는데 우선순위 큐를 사용하는 것이 수월한 이유는 남은 값을 빼서 구해준 다음 다시 pq에 넣어주기만 하면 되기 때문이다.

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

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

    int N, M; cin >> N >> M;

    priority_queue<int, vector<int>> pq;

    while(N--) {
        int x; cin >> x;

        pq.push(x);
    }

    bool b = true;

    while(M--) {
        int x; cin >> x;

        if(x > pq.top()) {
            b = false;
            break;
        }

        int tmp = pq.top() - x;

        pq.pop();

        if(tmp > 0) pq.push(tmp);
    }

    if(b) cout << 1 << "\n";
    else cout << 0 << "\n";
}

백준 BOJ 25101번 : Robin Hood

문제 난이도 : Silver II

알고리즘 분류 : 우선순위 큐

N명의 사람의 재산이 있을 때, 도둑이 현재 남은 돈이 가장 많으면서 앞 번호에 있는 사람의 돈을 100원씩 가져간다고 할 때, M번 가져간 후에 남은 사람들의 재산을 구하는 문제이다.

먼저 우선순위 큐로 풀이하는 방법을 생각할 수 있다.

문제는 M번의 연산 이후 남은 돈을 순서 그대로 출력해야 한다는 것인데, 이것은 pq 값에 주소까지 넣어서 처리할 수 있다.

같은 돈을 가진 사람이 여러 명이면 앞에 있는 사람의 돈을 가져가므로, 돈은 내림차순으로하되 주소는 오름차순으로 넣어주어야 한다. (나의 경우에는 주소 값에 그냥 마이너스 부호를 붙여서 주소가 클수록 더 큰 음수가 되어 먼저 나오게 하였다.)

이제 pq에서 하나씩 값을 뽑으면서 100을 빼는 연산을 하되, 더 이상 뺄 수 없는 경우는 bool 변수에 기록을 해주면 된다.

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

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

    int N, M; cin >> N >> M;

    priority_queue<pair<int, int>, vector<pair<int, int>>> pq;
    vector<int> v(N);

    for(int i=0; i<N; i++) {
        cin >> v[i];

        pq.push({v[i], -i});
    }

    bool b = true;

    while(M--) {
        if(pq.top().first <= 100) {
            b = false;
            break;
        }

        int x = pq.top().first;
        int y = -pq.top().second;

        pq.pop();

        v[y] -= 100;

        pq.push({x - 100, -y});
    }

    if(b) {
        for(int i=0; i<N; i++) cout << v[i] << " ";
        cout << "\n";
    }
    else cout << "impossible\n";
}

백준 BOJ 안 푼 문제들 중에서 쉬운 문제들 아무거나 220824

restudy — Wed, 24 Aug 2022 04:31:37 +0900

백준 BOJ 1477번 : 휴게소 세우기

문제 난이도 : Gold IV

알고리즘 분류 : 이분 탐색

길이가 K인 도로 위에 N개의 휴게소가 있고, 여기에 M개의 휴게소를 더 지어 휴게소 간 거리의 최댓값이 최소가 되도록 할 때, 그 최솟값을 구하는 문제이다.

이분 탐색을 이용하여 풀이할 수 있다.

답을 m으로 두고 l ~ r 범위 내에서 이분 탐색을 하면서 휴게소 간의 거리를 m으로 두고 휴게소를 설치했을 때 휴게소가 M개 이하로 설치되었는지 확인하면서 값을 갱신해주면 된다.

주의할 점은 두 휴게소 사이의 거리가 x라면, 휴게소는 max(x-1, 0) / m개 설치된다.

왜냐하면, 예를 들어서 생각해보면 휴게소 사이의 거리가 100인데 거리 50으로 휴게소를 설치한다고 하여 휴게소가 2개 설치되지는 않기 때문이다. (0, 50, 100에 위치에 휴게소가 있으면 되므로 1개만 설치하면 된다.)

비슷한 방식으로 거리 101의 도로에 휴게소를 50 간격으로 설치할 때는 2개가 설치되므로, 식을 (x-1) / m으로 두어야 함을 알 수 있다.

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

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

    int N, M, K; cin >> N >> M >> K;

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

    v.push_back(0);
    v.push_back(K);

    sort(v.begin(), v.end());

    vector<int> u;
    for(int i=1; i<v.size(); i++) u.push_back(max(v[i]-v[i-1]-1, (int)0));

    int ans = INT_MAX, l = 1, r = K;

    while(l <= r) {
        int m = (l + r) / 2;

        int sum = 0;
        for(int i=0; i<u.size(); i++) sum += u[i] / m;

        if(sum <= M) {
            ans = min(ans, m);

            r = m - 1;
        }
        else l = m + 1;
    }

    cout << ans << "\n";
}

백준 BOJ 4232번 : Conformity

문제 난이도 : Silver IV

알고리즘 분류 : 구현, 해시를 사용한 집합과 맵

N개의 5개 숫자의 조합이 주어질 때, 이 조합들 중 가장 빈도가 높은 것의 개수를 구하는 문제이다.

map<vector<int>, int>을 이용하여 각 조합의 수를 map에 기록하고 (물론 정렬 후 추가해주어야 한다.) 다시 모든 조합에 대해 map의 값을 확인해보면서 최대인 것의 개수를 count 해주면 된다.

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

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

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

        map<vector<int>, int> m;
        vector<vector<int>> v(N, vector<int>(5));

        for(int i=0; i<N; i++) {
            for(int j=0; j<5; j++) cin >> v[i][j];

            sort(v[i].begin(), v[i].end());

            m[v[i]]++;
        }

        int Max = 0;

        for(int i=0; i<N; i++)
            Max = max(Max, m[v[i]]);

        int ans = 0;

        for(int i=0; i<N; i++)
            if(m[v[i]] == Max) ans++;

        cout << ans << "\n";
    }
}

백준 BOJ 10489번 : Even Up Solitaire

문제 난이도 : Silver IV

알고리즘 분류 : 스택

N개의 수열이 주어질 때, 인접한 두 수의 합이 짝수면 제거할 수 있다고 할 때 남길 수 있는 수의 최소 개수를 구하는 문제이다.

stack을 이용하여 수를 하나씩 입력받으면서, 현재 stack의 top에 있는 수와 새로 들어온 수의 합이 짝수면 두 수를 제거해주고, 아니면 그대로 push 해주면 된다.

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

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

    int N; cin >> N;

    stack<int> s;

    while(N--) {
        int x; cin >> x;

        if(!s.empty() && (s.top() + x) % 2 == 0) s.pop();
        else s.push(x);
    }

    cout << s.size() << "\n";
}

백준 BOJ 14402번 : 야근

문제 난이도 : Silver IV

알고리즘 분류 : 해시를 사용한 집합과 맵

하루동안의 출퇴근 기록이 주어지고, 출근은 +, 퇴근은 -일 때 출근 없이 퇴근만 찍히거나 퇴근 없이 출근만 찍혀있는 경우를 야근이라고 할 때, 야근하는 사람의 수를 구하는 문제이다.

먼저 입력이 "이름 기호" 순으로 주어지므로, string을 기록할 map이 필요하다.

이제 이 map에 대응되는 int 값을 증감시키면 되는데, 값이 0인데 -가 찍히는 경우와 입력이 끝났는데 남아있는 + 값은 전부 야근에 해당되므로 답에 합해주면 된다.

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

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

    int N; cin >> N;

    unordered_map<string, int> m;
    set<string> s;
    int ans = 0;

    while(N--) {
        string str; cin >> str;
        char c; cin >> c;

        if(c == '+') m[str]++;
        else {
            if(m[str] == 0) ans++;
            else m[str]--;
        }

        if(s.count(str) == 0) s.insert(str);
    }

    for(auto i : s) ans += m[i];

    cout << ans << "\n";
}

백준 BOJ 10657번 : Cow Jog

문제 난이도 : Silver V

알고리즘 분류 : 구현

1차원 좌표 상에서 좌표의 오름차순으로 소의 위치와 오른쪽으로 이동하는 속도가 주어질 때, 두 소가 만나면 추월하지 못하고 같이 이동해야 한다면 최종적으로 소는 몇 그룹으로 묶일지 구하는 문제이다.

더 오른쪽에 있는 소가 더 느릴 경우 두 소는 같은 그룹이 되므로, 맨 오른쪽에서 시작하여 최솟값을 가지는 소가 나올 때마다 그 소가 하나의 그룹을 만든다고 생각하면 된다.

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

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

    int N; cin >> N;

    vector<int> v(N);
    for(int i=0; i<N; i++) {
        int x; cin >> x >> v[i];
    }

    int Min = INT_MAX, ans = 0;

    for(int i=N-1; i>=0; i--) {
        if(v[i] <= Min) {
            Min = v[i];
            ans++;
        }
    }

    cout << ans << "\n";
}

백준 BOJ 6296번 : Crazy Search

문제 난이도 : Silver V

알고리즘 분류 : 해시를 사용한 집합과 맵

사용된 문자의 종류가 M인 문자열이 주어질 때, 모든 길이가 N인 부분 수열의 종류를 구하는 문제이다.

unordered_map을 사용하여 쉽게 해결이 가능하다.

substr 함수는 꽤 느리게 동작하지만, 이 문제에서는 시간 초과 없이 해결이 가능하다.

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

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

    int N, M; cin >> N >> M;

    string str; cin >> str;

    unordered_map<string, bool> m;
    int ans = 0;

    for(int i=0; i<str.length()-N+1; i++) {
        string tmp = str.substr(i, N);

        if(!m[tmp]) ans++;

        m[tmp] = true;
    }

    cout << ans << "\n";
}

백준 BOJ 19817번 : Company Merging

문제 난이도 : Silver V

알고리즘 분류 : 우선순위 큐

두 회사를 합병할 때, 두 회사의 최고 임금의 격차만큼 최고 임금이 적은 기업의 모든 직원에게 추가 급여를 준다고 할 때, N개의 회사를 합병하는 데 필요한 최소 비용을 구하는 문제이다.

합병을 처음에 하나 나중에 하나 결국 최대 비용을 가진 사람을 기준으로 비용이 증가하므로, 합병 순서는 관계 없다.

N개 회사 중 최대 급여를 받는 사람의 급여에서 어떤 기업의 최대 급여를 받는 사람의 급여의 격차에 그 회사의 사람 수를 곱한 값들의 합이 답이 된다.

따라서 우선순위 큐를 N개 선언하고, 이들의 최댓값들을 미리 정렬해둔 뒤 답을 쉽게 구할 수 있다.

자세한 구현은 코드를 참고하자.

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

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

    int N; cin >> N;

    vector<priority_queue<int>> pq(N);
    int Max = 0;

    for(int i=0; i<N; i++) {
        int M; cin >> M;

        while(M--) {
            int x; cin >> x;

            pq[i].push(x);

            Max = max(Max, x);
        }
    }

    int ans = 0;

    for(int i=0; i<N; i++)
        ans += (Max - pq[i].top()) * pq[i].size();

    cout << ans << "\n";
}

백준 BOJ 10689번 : Hamza

문제 난이도 : Silver V

알고리즘 분류 : 해시를 사용한 집합과 맵

N개의 수가 주어질 때, 각 번호는 문제의 유형을 나타내고, 문제는 무조건 앞에서부터 푼다고 할 때 모든 유형의 문제를 풀기 위해서는 몇 문제를 풀어야 하는지 구하는 문제이다.

문제의 목록에는 모든 문제의 유형이 포함되어있다는 보장이 있으므로, 새로운 유형이 마지막으로 나온 지점까지가 답이 된다.

따라서 map을 이용하여 번호가 이전에 나온적 있는지의 여부를 기록해주고, 나온 적 없는 번호가 있다면 답을 현재 위치로 갱신해주면 된다.

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

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

    int T; cin >> T;

    for(int t=1; t<=T; t++) {
        int N; cin >> N;

        unordered_map<int, bool> m;
        int ans = 0;

        for(int i=0; i<N; i++) {
            int x; cin >> x;

            if(!m[x]) ans = i+1;

            m[x] = true;
        }

        cout << "Case " << t << ": " << ans << "\n";
    }
}

백준 BOJ 1331번 : 나이트 투어

문제 난이도 : Silver V

알고리즘 분류 : 구현

주어진 36개의 칸의 목록이 6x6 나이트투어, 즉 체스 나이트가 모든 칸을 경유한 뒤 다시 원래대로 돌아올 수 있는 경로인지를 검사하는 문제이다.

검사해야 하는 것은 다음의 세 가지이다.

1. 주어진 칸들 중에서 중복이 없는가 (= 모든 칸을 방문했는가)

2. 인접한 칸들 사이의 격차가 x는 2만큼, y는 1만큼 또는 x는 1만큼, y는 2만큼 나는가

3. 마지막 칸에서 첫 번째 칸으로 이동이 가능한가

위의 세 가지를 구현해주면 된다.

자세한 구현은 코드를 참고하자.

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

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

    vector<string> str(36);

    for(int i=0; i<36; i++) cin >> str[i];

    bool check = true;

    for(int i=0; i<36; i++) {
        int x = str[i][0] - str[(i+1) % 36][0];
        int y = str[i][1] - str[(i+1) % 36][1];

        if(!((abs(x) == 1 && abs(y) == 2) || (abs(x) == 2 && abs(y) == 1))) check = false;
    }

    for(int i=0; i<36; i++)
        for(int j=i+1; j<36; j++)
            if(str[i] == str[j]) check = false;

    if(check) cout << "Valid\n";
    else cout << "Invalid\n";
}

백준 BOJ 1417번 : 국회의원 선거

문제 난이도 : Silver V

알고리즘 분류 : 우선순위 큐

N명의 후보들의 득표 수가 주어질 때, 1번 후보가 단독 1위를 하기 위해서 다른 후보들의 표에서 매수해와야 하는 사람의 최소 수를 구하는 문제이다.

우선 순위 큐를 이용하여 2~N번 후보의 득표 수를 저장하고, 가장 많은 득표를 한 사람의 표를 1개씩 매수해오면서 1등이 언제 되는지 구해주면 된다.

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

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

    int N; cin >> N;

    int cur; cin >> cur;

    priority_queue<int> pq;

    for(int i=0; i<N-1; i++) {
        int x; cin >> x;

        pq.push(x);
    }

    if(N == 1) {
        cout << 0 << "\n";
        return 0;
    }

    int ans = 0;

    while(true) {
        if(cur > pq.top()) break;

        int x = pq.top();
        pq.pop();
        pq.push(x-1);

        cur++;
        ans++;
    }

    cout << ans << "\n";
}

백준 BOJ 4649번 : Tanning Salon

문제 난이도 : Silver V

알고리즘 분류 : 구현

N개의 침대가 있는 salon에 문자열로 각 손님의 방문과 떠나는 순서가 주어졌을 때, tanning을 하지 못하고 떠난 손님의 수를 구하는 문제이다.

문제에서 tanning을 하지 못한 손님은 반드시 tanning 중인 다른 손님보다 먼저 떠난다고 하였으므로, 매 방문마다 bool 변수가 check 된 것의 개수를 count 해주어 그것이 N보다 큰지 작은지를 파악해주면 된다.

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

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

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

        string str; cin >> str;

        vector<bool> v(26);
        int ans = 0;

        for(int i=0; i<str.length(); i++) {
            int cnt = 0;

            for(int i=0; i<26; i++)
                if(v[i]) cnt++;

            int x = str[i] - 'A';

            if(!v[x]) {
                if(cnt >= N) ans++;

                v[x] = true;
            }
            else v[x] = false;
        }

        if(ans == 0) cout << "All customers tanned successfully.\n";
        else cout << ans << " customer(s) walked away.\n";
    }
}

백준 BOJ 4675번 : Word Amalgamation

문제 난이도 : Bronze I

알고리즘 분류 : 해시를 사용한 집합과 맵, 트리를 사용한 집합과 맵

사전에 있는 단어들의 목록이 주어지고, 그 다음 철자 순서가 섞인 단어들이 주어질 때, 섞인 단어들의 철자를 바꾸어 만들 수 있는 사전의 단어들의 목록을 사전 순으로 출력하는 문제이다.

먼저 사전에 있는 단어들을 문자 각각을 정렬을 한 상태로 (ex : apple → aelpp) 해당 문자열과 연결된 set에 원래 단어를 저장한다.

그 다음 순서가 섞인 단어가 입력되면, 이 역시 정렬한 뒤 map에 저장되어 있는지 체크하고, 저장되어 있다면 해당 map과 연결된 set에서 값들을 찾아와 출력해주면 된다.

set은 단어들이 정렬된 상태로 저장되므로, set의 모든 원소들을 출력해주기만 하면 된다.

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

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

    map<string, set<string>> m;

    while(true) {
        string str; cin >> str;
        if(str == "XXXXXX") break;

        string tmp = str;

        sort(tmp.begin(), tmp.end());

        m[tmp].insert(str);
    }

    while(true) {
        string str; cin >> str;
        if(str == "XXXXXX") break;

        sort(str.begin(), str.end());

        if(m[str].empty()) cout << "NOT A VALID WORD\n";
        else {
            for(auto i : m[str]) cout << i << "\n";
        }

        cout << "******\n";
    }
}

백준 BOJ 16466번 : 콘서트

문제 난이도 : Bronze I

알고리즘 분류 : 해시를 사용한 집합과 맵

N개의 수가 주어질 때, 주어진 수들 중 나타나지 않는 가장 작은 자연수를 구하는 문제이다.

map을 이용하여 map에 나온 숫자들을 모두 기록하고, 1부터 확인하면서 map에 없는 최초의 값을 답으로 얻어주면 된다.

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

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

    int N; cin >> N;

    unordered_map<int, bool> m;

    while(N--) {
        int x; cin >> x;

        m[x] = true;
    }

    for(int i=1; ; i++) {
        if(!m[i]) {
            cout << i << "\n";
            break;
        }
    }
}

강한 결합 요소(SCC) 알고리즘 solution들 정리 220823

restudy — Tue, 23 Aug 2022 11:27:02 +0900

백준 BOJ 2150번 : Strongly Connected Component

문제 난이도 : Platinum V

알고리즘 분류 : 강한 결합 요소 (SCC)

방향 그래프가 주어질 때, 이들을 SCC로 나누어 출력하는 문제이다.

여기서 말하는 SCC(Strongly Connected Component)란, 한 Component 내의 어떤 두 점 사이에도 이동이 가능한 요소를 말한다. (SCC를 나눌 때는 당연히 한 Component의 크기가 최대가 되도록 나누어야 한다.)

그래프를 입력받고 adj 벡터에 간선들을 저장해주는 부분은 기본적이므로 설명을 생략한다.

이제 DFS 방식으로 노드들을 탐색하며, 노드 번호를 방문하는 순서대로 오름차순으로 매긴다. (nnum 벡터에 저장)

즉, 번호를 먼저 매기는 것이긴 하지만 아무튼 번호가 작은 것부터 번호가 큰 순서대로 노드들을 방문하게 된다.

재귀적으로 노드들을 탐색하는데, 1. 아직 방문하지 않은 노드, 2. 방문은 했으나 아직 scc로 선택되지 않은 (!ch[y]) 노드들 중 번호가 가장 작은 것이 자기 자신일 경우, 이 노드들은 순환을 통해 현재 노드로는 되돌아올 수 있으나 자기 자신보다 더 작은 번호의 노드로는 더 이상 거슬러 올라가지 못한다는 뜻이므로 SCC임을 알 수 있다.

그러면 이 노드들을 모두 선택(ch[y] = true) 해주고 임시 벡터에 저장하여 2차원 벡터인 scc 벡터에 push_back 해준다.

이제 scc 벡터를 정렬하여 답을 출력해주면 된다.

(여담으로 아래 코드에서 cnum(component number), ccnt(component count) 값은 이 문제에서는 필요 없으나, 다른 SCC 문제를 풀 때 유용하다.)

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

vector<vector<int>> adj, scc;
vector<int> nnum, cnum;
int ncnt = 0, ccnt = 0;

stack<int> s;
vector<bool> ch;

int dfs(int x) {
    nnum[x] = ++ncnt;
    s.push(x);

    int tmp = nnum[x];

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(nnum[y] == 0) tmp = min(tmp, dfs(y));
        else if(!ch[y]) tmp = min(tmp, nnum[y]);
    }

    if(tmp == nnum[x]) {
        vector<int> v;
        ccnt++;

        while(true) {
            int y = s.top();
            s.pop();

            v.push_back(y);

            ch[y] = true;
            cnum[y] = ccnt;

            if(y == x) break;
        }

        sort(v.begin(), v.end());

        scc.push_back(v);
    }

    return tmp;
}

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

    int N, M; cin >> N >> M;

    adj.resize(N+1);

    while(M--) {
        int a, b; cin >> a >> b;

        adj[a].push_back(b);
    }

    nnum.resize(N+1);
    cnum.resize(N+1);
    ch.resize(N+1);

    for(int i=1; i<=N; i++)
        if(nnum[i] == 0) dfs(i);

    sort(scc.begin(), scc.end());

    cout << scc.size() << "\n";

    for(int i=0; i<scc.size(); i++) {
        for(int j=0; j<scc[i].size(); j++) cout << scc[i][j] << " ";
        cout << -1 << "\n";
    }
}

백준 BOJ 4196번 : 도미노

문제 난이도 : Platinum IV

알고리즘 분류 : 강한 결합 요소 (SCC)

N개의 도미노가 M개의 연결 관계에 의해 연결되어 있을 때, 모든 도미노를 넘어뜨리기 위해 쓰러뜨려야 하는 최소 도미노의 개수를 구하는 문제이다.

같은 scc인 도미노는 어떤 것을 넘어뜨려도 scc 내의 도미노들은 모두 넘어지게 된다.

따라서, scc 내의 관계는 신경 쓸 필요 없고 scc와 scc 사이의 연결 관계에 대해 생각해보자.

다른 scc에서 현재 scc로 들어오는 간선이 있는 경우 다른 scc를 먼저 선택하면 현재 scc로의 이동이 가능하므로 모두 넘어뜨릴 수 있다.

따라서 scc들 중에서 들어오는 간선이 없는 scc의 개수를 세어주면 된다.

이를 구현하기 위해서는, 모든 간선들을 다시 체크해보면서 간선이 서로 다른 두 scc에 속한 노드 사이를 연결할 때, 해당 간선이 가리키는 scc 번호의 ind 값을 1 추가해주고 최종 ind 값이 0인 scc들의 개수를 세어주면 된다.

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

vector<vector<int>> adj, scc;
vector<int> nnum, cnum;
int ncnt = 0, ccnt = 0;

stack<int> s;
vector<bool> ch;

int dfs(int x) {
    nnum[x] = ++ncnt;
    s.push(x);

    int tmp = nnum[x];

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(nnum[y] == 0) tmp = min(tmp, dfs(y));
        else if(!ch[y]) tmp = min(tmp, nnum[y]);
    }

    if(tmp == nnum[x]) {
        vector<int> v;
        ccnt++;

        while(true) {
            int y = s.top();
            s.pop();

            v.push_back(y);

            ch[y] = true;
            cnum[y] = ccnt;

            if(y == x) break;
        }

        sort(v.begin(), v.end());

        scc.push_back(v);
    }

    return tmp;
}

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

    int T; cin >> T;

    while(T--) {
        int N, M; cin >> N >> M;

        adj.clear();
        adj.resize(N+1);

        while(M--) {
            int a, b; cin >> a >> b;

            adj[a].push_back(b);
        }

        nnum.clear();   nnum.resize(N+1);
        cnum.clear();   cnum.resize(N+1);
        ch.clear();     ch.resize(N+1);

        scc.clear();
        ncnt = ccnt = 0;

        for(int i=1; i<=N; i++)
            if(nnum[i] == 0) dfs(i);

        sort(scc.begin(), scc.end());

        vector<int> ind(N+1);

        for(int i=1; i<=N; i++)
            for(int j=0; j<adj[i].size(); j++) {
                int x = adj[i][j];

                if(cnum[i] != cnum[x]) ind[cnum[x]]++;
            }

        int ans = 0;
        for(int i=1; i<=ccnt; i++)
            if(ind[i] == 0) ans++;

        cout << ans << "\n";
    }
}

백준 BOJ 24131번 : 宣伝 (Advertisement)

문제 난이도 : Platinum V

알고리즘 분류 : 강한 결합 요소 (SCC)

N명의 사람이 있고, M개의 쌍에 대해 a번 사람이 b번 사람의 연락처를 알고 있다고 할 때, 정보를 처음 전달했을 때 연락처들을 통해 모든 사람에게 정보가 전달될 수 있게 하기 위해 처음에 정보를 전달해야 하는 최소 사람 수를 구하는 문제이다.

위의 도미노 문제와 같은 논리가 적용될 수 있음을 알 수 있다.

따라서 테스트케이스 부분의 구현만 제외하면 나머지는 동일한 풀이로 풀 수 있다.

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

vector<vector<int>> adj, scc;
vector<int> nnum, cnum;
int ncnt = 0, ccnt = 0;

stack<int> s;
vector<bool> ch;

int dfs(int x) {
    nnum[x] = ++ncnt;
    s.push(x);

    int tmp = nnum[x];

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(nnum[y] == 0) tmp = min(tmp, dfs(y));
        else if(!ch[y]) tmp = min(tmp, nnum[y]);
    }

    if(tmp == nnum[x]) {
        vector<int> v;
        ccnt++;

        while(true) {
            int y = s.top();
            s.pop();

            v.push_back(y);

            ch[y] = true;
            cnum[y] = ccnt;

            if(y == x) break;
        }

        sort(v.begin(), v.end());

        scc.push_back(v);
    }

    return tmp;
}

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

    int N, M; cin >> N >> M;

    adj.resize(N+1);

    while(M--) {
        int a, b; cin >> a >> b;

        adj[a].push_back(b);
    }

    nnum.resize(N+1);
    cnum.resize(N+1);
    ch.resize(N+1);

    for(int i=1; i<=N; i++)
        if(nnum[i] == 0) dfs(i);

    sort(scc.begin(), scc.end());

    vector<int> ind(N+1);

    for(int i=1; i<=N; i++)
        for(int j=0; j<adj[i].size(); j++) {
            int x = adj[i][j];

            if(cnum[i] != cnum[x]) ind[cnum[x]]++;
        }

    int ans = 0;
    for(int i=1; i<=ccnt; i++)
        if(ind[i] == 0) ans++;

    cout << ans << "\n";
}

백준 BOJ 13232번 : Domain clusters

문제 난이도 : Gold I

알고리즘 분류 : 강한 결합 요소 (SCC)

N개의 도메인들의 연결 관계가 주어질 때, 서로 이동이 가능한 가장 큰 도메인 집합의 크기를 구하는 문제이다.

가장 큰 scc의 크기를 구하라는 것과 동치이므로, scc들을 구해주고 그들 중 가장 scc[i].size()가 큰 것을 답으로 구해주면 된다.

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

vector<vector<int>> adj, scc;
vector<int> nnum, cnum;
int ncnt = 0, ccnt = 0;

stack<int> s;
vector<bool> ch;

int dfs(int x) {
    nnum[x] = ++ncnt;
    s.push(x);

    int tmp = nnum[x];

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(nnum[y] == 0) tmp = min(tmp, dfs(y));
        else if(!ch[y]) tmp = min(tmp, nnum[y]);
    }

    if(tmp == nnum[x]) {
        vector<int> v;
        ccnt++;

        while(true) {
            int y = s.top();
            s.pop();

            v.push_back(y);

            ch[y] = true;
            cnum[y] = ccnt;

            if(y == x) break;
        }

        sort(v.begin(), v.end());

        scc.push_back(v);
    }

    return tmp;
}

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

    int N, M; cin >> N >> M;

    adj.resize(N+1);

    while(M--) {
        int a, b; cin >> a >> b;

        adj[a].push_back(b);
    }

    nnum.resize(N+1);
    cnum.resize(N+1);
    ch.resize(N+1);

    for(int i=1; i<=N; i++)
        if(nnum[i] == 0) dfs(i);

    sort(scc.begin(), scc.end());

    int ans = 0;

    for(int i=0; i<scc.size(); i++)
        ans = max(ans, (int)scc[i].size());

    cout << ans << "\n";
}

백준 BOJ 1506번 : 경찰서

문제 난이도 : Platinum V

알고리즘 분류 : 강한 결합 요소 (SCC)

각 도시에 경찰서를 세우는 비용이 주어지고, 도시 사이의 단방향 도로들이 주어질 때, 서로 연결된 도시(순환이 가능해야함)들 사이에서는 한 개 이상의 경찰서가 있어야한다고 할 때 이러한 조건을 만족하기 위한 최소 경찰서 설치 비용을 구하는 문제이다.

같은 SCC 내에서는 하나의 경찰서만 있으면 된다.

따라서 SCC 알고리즘을 돌려준 이후 각 SCC들에 대해 비용이 가장 작은 노드의 비용을 합해서 답으로 구해주면 된다.

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

vector<vector<int>> adj, scc;
vector<int> nnum, cnum;
int ncnt = 0, ccnt = 0;

stack<int> s;
vector<bool> ch;

int dfs(int x) {
    nnum[x] = ++ncnt;
    s.push(x);

    int tmp = nnum[x];

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(nnum[y] == 0) tmp = min(tmp, dfs(y));
        else if(!ch[y]) tmp = min(tmp, nnum[y]);
    }

    if(tmp == nnum[x]) {
        vector<int> v;
        ccnt++;

        while(true) {
            int y = s.top();
            s.pop();

            v.push_back(y);

            ch[y] = true;
            cnum[y] = ccnt;

            if(y == x) break;
        }

        sort(v.begin(), v.end());

        scc.push_back(v);
    }

    return tmp;
}

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

    int N; cin >> N;

    vector<int> v(N+1);
    for(int i=1; i<=N; i++) cin >> v[i];

    adj.resize(N+1);

    for(int i=1; i<=N; i++)
        for(int j=1; j<=N; j++) {
            char c; cin >> c;

            if(c == '1') adj[i].push_back(j);
        }

    nnum.resize(N+1);
    cnum.resize(N+1);
    ch.resize(N+1);

    for(int i=1; i<=N; i++)
        if(nnum[i] == 0) dfs(i);

    sort(scc.begin(), scc.end());

    int ans = 0;

    for(int i=0; i<scc.size(); i++) {
        int Min = INT_MAX;

        for(int j=0; j<scc[i].size(); j++)
            Min = min(Min, v[scc[i][j]]);

        ans += Min;
    }

    cout << ans << "\n";
}

백준 BOJ 3977번 : 축구 전술

문제 난이도 : Platinum IV

알고리즘 분류 : 강한 결합 요소 (SCC)

N개의 노드와 M개의 단방향 간선이 주어질 때, 하나의 노드를 선택하여 모든 노드에 도달할 수 있게 할 때, 가능한 노드의 번호가 있으면 오름차순으로 모두 출력하고, 그렇지 않은 경우 Confused를 출력하는 문제이다.

위의 도미노 문제 아이디어의 연장으로 풀이할 수 있다.

indegree가 0인 scc는 다른 scc에서 올 수 없으므로 시작점으로 반드시 선택해주어야 한다.

따라서 만약 indegree가 0인 scc가 2개 이상이면 한 노드에서 모든 노드에 도달하는 것이 불가능하다.

그러므로 이 경우에는 Confused를 출력해준다.

만약 indegree가 0인 scc가 1개인 경우 해당 scc의 어떤 원소에서 시작하여도 모든 노드에 도달할 수 있다.

따라서 해당 노드들을 오름차순으로 모두 출력해주면 된다.

여담으로 indegree가 0인 scc가 없는 경우는 존재하지 않는다.

귀류법으로 만약 그러한 indegree가 존재한다고 가정할 경우, 이는 사이클이므로 scc 알고리즘에 의해 이미 더 큰 scc에 소속되어있어야 한다.

따라서 indegree가 0인 scc가 1개이거나 그보다 많은 경우로만 나누어 생각해주면 된다.

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

vector<vector<int>> adj, scc;
vector<int> nnum, cnum;
int ncnt = 0, ccnt = 0;

stack<int> s;
vector<bool> ch;

int dfs(int x) {
    nnum[x] = ++ncnt;
    s.push(x);

    int tmp = nnum[x];

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(nnum[y] == 0) tmp = min(tmp, dfs(y));
        else if(!ch[y]) tmp = min(tmp, nnum[y]);
    }

    if(tmp == nnum[x]) {
        vector<int> v;
        ccnt++;

        while(true) {
            int y = s.top();
            s.pop();

            v.push_back(y);

            ch[y] = true;
            cnum[y] = ccnt;

            if(y == x) break;
        }

        sort(v.begin(), v.end());

        scc.push_back(v);
    }

    return tmp;
}

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

    int T; cin >> T;

    while(T--) {
        int N, M; cin >> N >> M;

        adj.clear();
        adj.resize(N+1);

        while(M--) {
            int a, b; cin >> a >> b;

            adj[a+1].push_back(b+1);
        }

        nnum.clear();   nnum.resize(N+1);
        cnum.clear();   cnum.resize(N+1);
        ch.clear();     ch.resize(N+1);

        scc.clear();
        ncnt = ccnt = 0;

        for(int i=1; i<=N; i++)
            if(nnum[i] == 0) dfs(i);

        sort(scc.begin(), scc.end());

        vector<int> ind(N+1);

        for(int i=1; i<=N; i++)
            for(int j=0; j<adj[i].size(); j++) {
                int x = adj[i][j];

                if(cnum[i] != cnum[x]) ind[cnum[x]]++;
            }

        int cnt = 0, idx;
        for(int i=1; i<=ccnt; i++)
            if(ind[i] == 0) {
                cnt++;
                idx = i;
            }

        if(cnt == 1) {
            for(int i=1; i<=N; i++)
                if(cnum[i] == idx) cout << i-1 << "\n";
        }
        else cout << "Confused\n";

        cout << "\n";
    }
}

백준 BOJ 6543번 : 그래프의 싱크

문제 난이도 : Platinum IV

알고리즘 분류 : 강한 결합 요소 (SCC)

그래프의 모든 노드에서 어떤 노드로 도달하는 경로가 존재한다면, 이 노드를 그래프의 싱크라고 정의할 때, 주어진 그래프의 싱크 노드들을 모두 출력하는 문제이다.

간선이 단방향 간선이므로, outdegree(외부로 나가는 간선의 수)가 0인 scc의 모든 원소들을 구해주면 된다.

outdegree 값은 위의 도미노 문제에서 풀이한 것과 비슷한 방식으로, 모든 간선에 대해 검사할 때 서로 다른 scc 사이의 간선인 경우 해당 간선의 출발 노드에 outdegree를 1 더해주면 된다.

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

vector<vector<int>> adj, scc;
vector<int> nnum, cnum;
int ncnt = 0, ccnt = 0;

stack<int> s;
vector<bool> ch;

int dfs(int x) {
    nnum[x] = ++ncnt;
    s.push(x);

    int tmp = nnum[x];

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(nnum[y] == 0) tmp = min(tmp, dfs(y));
        else if(!ch[y]) tmp = min(tmp, nnum[y]);
    }

    if(tmp == nnum[x]) {
        vector<int> v;
        ccnt++;

        while(true) {
            int y = s.top();
            s.pop();

            v.push_back(y);

            ch[y] = true;
            cnum[y] = ccnt;

            if(y == x) break;
        }

        sort(v.begin(), v.end());

        scc.push_back(v);
    }

    return tmp;
}

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

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

        int M; cin >> M;

        adj.clear();
        adj.resize(N+1);

        while(M--) {
            int a, b; cin >> a >> b;

            adj[a].push_back(b);
        }

        nnum.clear();   nnum.resize(N+1);
        cnum.clear();   cnum.resize(N+1);
        ch.clear();     ch.resize(N+1);

        scc.clear();
        ncnt = ccnt = 0;

        for(int i=1; i<=N; i++)
            if(nnum[i] == 0) dfs(i);

        sort(scc.begin(), scc.end());

        vector<int> oud(N+1);

        for(int i=1; i<=N; i++)
            for(int j=0; j<adj[i].size(); j++) {
                int x = adj[i][j];

                if(cnum[i] != cnum[x]) oud[cnum[i]]++;
            }

        for(int i=1; i<=N; i++)
            if(oud[cnum[i]] == 0) cout << i << " ";

        cout << "\n";
    }
}

백준 BOJ 4305번 : 성격 진단 테스트

문제 난이도 : Platinum IV

알고리즘 분류 : 강한 결합 요소 (SCC)

N개의 5지선다 문제가 주어지고, 5개 중 가장 선호하는 항목을 고른다고 할 때, N개의 선호 관계를 활용하여 각 그룹의 원소들을 출력하여 같은 그룹의 어떤 두 원소를 뽑아도 모순 관계가 발생하게 그룹화시키는 문제이다.

(예를 들어 a, b 중에서 a를 뽑고, b, c 중에서 b를 뽑고, c, a 중에서 c를 뽑는다면 a > b > c > a로 모순이 발생하고, 출력으로 a b c를 출력해주면 된다.)

잘 생각해보면 SCC를 이루는 원소들끼리는 오갈 수 있는 사이클이 존재하므로, 단순히 SCC 그룹별로 원소들을 출력해주면 된다.

대문자 알파벳 하나씩만 입력으로 주어진다고 하였으므로, N은 최대 26이다.

나의 경우에는 무시하고 N = 26이라고 가정하고 scc를 돌린 다음에, scc[i][0] 값이 입력에 없었던 값이면 해당 줄은 skip하는 방식으로 구현하였다.

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

vector<vector<int>> adj, scc;
vector<int> nnum, cnum;
int ncnt = 0, ccnt = 0;

stack<int> s;
vector<bool> ch;

int dfs(int x) {
    nnum[x] = ++ncnt;
    s.push(x);

    int tmp = nnum[x];

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(nnum[y] == 0) tmp = min(tmp, dfs(y));
        else if(!ch[y]) tmp = min(tmp, nnum[y]);
    }

    if(tmp == nnum[x]) {
        vector<int> v;
        ccnt++;

        while(true) {
            int y = s.top();
            s.pop();

            v.push_back(y);

            ch[y] = true;
            cnum[y] = ccnt;

            if(y == x) break;
        }

        sort(v.begin(), v.end());

        scc.push_back(v);
    }

    return tmp;
}

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

    while(true) {
        int N = 26;

        int M; cin >> M;
        if(M == 0) break;

        adj.clear();
        adj.resize(N+1);

        vector<bool> u(N+1);

        while(M--) {
            vector<char> v(6);
            for(int i=0; i<6; i++) {
                cin >> v[i];

                u[v[i]-'A'+1] = true;
            }

            for(int i=0; i<6; i++) {
                if(v[i] == v[5]) continue;

                adj[v[i]-'A'+1].push_back(v[5]-'A'+1);
            }
        }

        nnum.clear();   nnum.resize(N+1);
        cnum.clear();   cnum.resize(N+1);
        ch.clear();     ch.resize(N+1);

        scc.clear();
        ncnt = ccnt = 0;

        for(int i=1; i<=N; i++)
            if(nnum[i] == 0) dfs(i);

        sort(scc.begin(), scc.end());

        for(int i=0; i<scc.size(); i++) {
            if(!u[scc[i][0]]) continue;

            for(int j=0; j<scc[i].size(); j++) cout << char('A' + scc[i][j] - 1) << " ";
            cout << "\n";
        }

        cout << "\n";
    }
}

백준 BOJ 25488번 : 토큰

문제 난이도 : Platinum IV

알고리즘 분류 : 강한 결합 요소 (SCC)

단방향 간선을 가진 그래프가 주어질 때, N개의 점의 목록 A와 B가 주어질 때, 처음에 A의 위치에 있던 N개의 토큰들을 그래프 간선만 따라서 이동시켜서 B의 위치들로 옮긴 뒤, 다시 A로 돌아올 수 있는지를 구하는 문제이다.

SCC를 돌린 후, A의 점들과 B의 점들이 각 SCC 그룹에 속하는 개수가 일치하면 Yes이고, 그 외에는 No이다.

여담으로 어제 대회 때 이 문제를 풀기 위해서 대회 시간에 SCC를 처음 공부해서 풀었다. (짤 줄은 몰랐지만 개념은 알고 있었기에 SCC로 풀리는 것이 너무 자명해보여서..)

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

vector<vector<int>> adj, scc;
int ncnt = 0, ccnt = 0;
stack<int> s;
vector<int> nnum, cnum;
vector<bool> ch;

int dfs(int x) {
    nnum[x] = ++ncnt;
    s.push(x);

    int tmp = nnum[x];

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(nnum[y] == 0) tmp = min(tmp, dfs(y));
        else if(!ch[y]) tmp = min(tmp, nnum[y]);
    }

    if(tmp == nnum[x]) {
        vector<int> v;
        ccnt++;

        while(true) {
            int y = s.top();
            s.pop();

            v.push_back(y);

            ch[y] = true;
            cnum[y] = ccnt;

            if(y == x) break;
        }

        sort(v.begin(), v.end());

        scc.push_back(v);
    }

    return tmp;
}

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

    int N, M; cin >> N >> M;

    adj.resize(N+1);

    while(M--) {
        int a, b; cin >> a >> b;

        adj[a].push_back(b);
    }

    nnum.resize(N+1);
    cnum.resize(N+1);
    ch.resize(N+1);

    for(int i=1; i<=N; i++)
        if(nnum[i] == 0) dfs(i);

    sort(scc.begin(), scc.end());

    int K; cin >> K;

    vector<int> v(ccnt+1), u(ccnt+1);

    for(int i=0; i<K; i++) {
        int x; cin >> x;

        v[cnum[x]]++;
    }

    for(int i=0; i<K; i++) {
        int x; cin >> x;

        u[cnum[x]]++;
    }

    if(v == u) cout << "YES\n";
    else cout << "NO\n";
}

백준 BOJ 7042번 : Cow Ski Area

문제 난이도 : Platinum IV

알고리즘 분류 : 강한 결합 요소 (SCC)

R x C 크기의 스키장의 높낮이가 주어질 때, 상하좌우로 이동하되 높은 곳에서 낮은 곳 또는 높이가 같은 곳으로만 이동이 가능하며, 특정 두 칸을 연결하는 리프트를 몇 개 설치하여 모든 칸 사이의 이동이 가능하도록 할 때 설치해야하는 최소 리프트의 수를 구하는 문제이다.

SCC를 돌려준 뒤 indegree가 0인 component의 수와 outdegree가 0인 component의 수 중 큰 것이 답이 된다.

여기까지는 그래프 몇 개를 그려보고 빨리 파악을 했는데, 간단한 예외를 못 찾아서 30분은 헤맸다.

만약 component가 단 1개뿐이라면, 위의 풀이대로라면 답이 1이 나와야 하는데 이 경우는 답이 0이 되어야 한다.

이와 같은 반례 처리에 주의하자.

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

vector<vector<int>> adj, scc;
vector<int> nnum, cnum;
int ncnt = 0, ccnt = 0;

stack<int> s;
vector<bool> ch;

int dfs(int x) {
    nnum[x] = ++ncnt;
    s.push(x);

    int tmp = nnum[x];

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(nnum[y] == 0) tmp = min(tmp, dfs(y));
        else if(!ch[y]) tmp = min(tmp, nnum[y]);
    }

    if(tmp == nnum[x]) {
        vector<int> v;
        ccnt++;

        while(true) {
            int y = s.top();
            s.pop();

            v.push_back(y);

            ch[y] = true;
            cnum[y] = ccnt;

            if(y == x) break;
        }

        sort(v.begin(), v.end());

        scc.push_back(v);
    }

    return tmp;
}

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

    int C, R; cin >> C >> R;

    vector<vector<int>> v(R+1, vector<int>(C+1));

    for(int i=1; i<=R; i++)
        for(int j=1; j<=C; j++) cin >> v[i][j];

    int N = R * C;

    adj.resize(N+1);

    int di[4] = {1, -1, 0, 0};
    int dj[4] = {0, 0, 1, -1};

    for(int i=1; i<=R; i++)
        for(int j=1; j<=C; j++)
            for(int k=0; k<4; k++) {
                int ni = i + di[k];
                int nj = j + dj[k];

                if(ni <= 0 || nj <= 0 || ni > R || nj > C) continue;

                if(v[i][j] >= v[ni][nj]) adj[(i-1)*C + j].push_back((ni-1)*C + nj);
            }

    nnum.resize(N+1);
    cnum.resize(N+1);
    ch.resize(N+1);

    for(int i=1; i<=N; i++)
        if(nnum[i] == 0) dfs(i);

    sort(scc.begin(), scc.end());

    if(ccnt == 1) {
        cout << 0 << "\n";
        return 0;
    }

    vector<int> ind(N+1), oud(N+1);

    for(int i=1; i<=N; i++)
        for(int j=0; j<adj[i].size(); j++) {
            int x = adj[i][j];

            if(cnum[i] != cnum[x]) {
                ind[cnum[x]]++;
                oud[cnum[i]]++;
            }
        }

    int incnt = 0, oucnt = 0;
    for(int i=1; i<=ccnt; i++) {
        if(ind[i] == 0) incnt++;
        if(oud[i] == 0) oucnt++;
    }

    int ans = max(incnt, oucnt);

    cout << ans << "\n";
}

백준 BOJ 다양한 해시맵(map) 활용 문제들 solution 220822

restudy — Mon, 22 Aug 2022 10:07:10 +0900

백준 BOJ 24411번 : Stamp Combinations

문제 난이도 : Silver I

알고리즘 분류 : 누적 합, 해시를 사용한 집합과 맵

길이 N인 수열에 대해, 앞의 부분합과 뒤의 부분합의 합으로 쿼리로 입력된 값을 만들 수 있는지 구하는 문제이다.

이 때 N x Q(쿼리의 수) ≤ 10^7이다.

누적 합을 사용하는 것은 확실해보이나, 누적 합을 사용하더라도 O(N^2)에 돌아간다.

따라서 시간 복잡도를 조금 더 개선할 방법을 찾아보아야 한다.

v_i를 1 ~ i번째 원소의 합이라고 하자.

그러면 뒤쪽 부분의 합은 v_N - v_i이고, 앞쪽 부분은 쿼리 값이 x라고 했을 때 x - (v_N - v_i)이다.

map을 활용하여 v_0 ~ v_N 값들을 모두 저장해두고 m[x - (v_N - v_i)]가 체크되어있는지만 확인하면 O(1) 시간에 확인이 가능하다.

반례로 가능한 것은 아래쪽의 그림과 같이 두 부분이 겹쳐버리는 것인데, 이런 경우는 continue로 넘기든 범위를 안 겹치게 설정해주어야 한다.

급하게 푸느라 그림이 조금 더러운데, 빗금(수열 전체의 앞 부분, 뒷 부분) 부분만 보면 대충 이해할 수 있을 것이다.

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

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

    int N, M; cin >> N >> M;

    vector<int> v(N+1);
    for(int i=1; i<=N; i++) {
        int x; cin >> x;

        v[i] = v[i-1] + x;
    }

    unordered_map<int, bool> m;
    for(int i=0; i<=N; i++) m[v[i]] = true;

    while(M--) {
        int x; cin >> x;

        bool check = false;

        for(int i=0; i<=N; i++) {
            if(x - (v[N] - v[i]) > v[i]) continue;

            if(m[x - (v[N] - v[i])]) {
                check = true;
                break;
            }
        }

        if(check) cout << "Yes\n";
        else cout << "No\n";
    }
}

백준 BOJ 3557번 : Homo or Hetero?

문제 난이도 : Silver I

알고리즘 분류 : 트리를 사용한 집합과 맵

집합에 insert 또는 delete로 원소를 추가/제거할 때, 매 쿼리마다 집합이 어디에 속하는지를 구하는 문제이다.

문제에서 정의한 집합의 종류는 다음과 같다.

hetero : 원소가 두 개 이상이고 다른 원소가 존재하는 집합

homo : 원소가 두 개 이상이고 같은 원소가 존재하는 집합

both: hetero이면서 동시에 homo인 집합

neither : hetero도 아니고 homo도 아닌 집합

multiset을 이용하여 구현이 가능하다.

원소를 하나 erase할 때 주의할 점은 s.erase(x)와 같이 수행해주면 여러 개의 x를 가진 경우에도 모두 삭제가 된다.

따라서 s.erase(s.find(x))와 같이 작성해주어야 원소 x가 하나씩 삭제가 된다.

자세한 구현은 아래의 코드를 참조하는 편이 더 나을 것이다.

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

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

    int N; cin >> N;

    multiset<int> s;
    int cnt = 0;

    while(N--) {
        string str; cin >> str;
        int x; cin >> x;

        if(str == "insert") {
            if(s.count(x) == 0) cnt++;
            s.insert(x);
        }
        else if(str == "delete") {
            if(s.count(x) > 0) {
                s.erase(s.find(x));
                if(s.count(x) == 0) cnt--;
            }
        }

        if(s.size() >= 2 && s.size() > cnt && cnt >= 2) cout << "both\n";
        else if(s.size() >= 2 && s.size() == cnt) cout << "hetero\n";
        else if(s.size() >= 2 && cnt == 1) cout << "homo\n";
        else if(s.size() <= 1) cout << "neither\n";
    }
}

백준 BOJ 11313번 : Best Buddies

문제 난이도 : Silver II

알고리즘 분류 : 정렬, 해시를 사용한 집합과 맵

N명의 사람의 성과 이름이 주어지고, 이름을 last name의 사전순, last name이 같으면 first name의 사전 순으로 정렬한 뒤 앞에서부터 3명씩 같은 팀이 된다고 할 때, M개의 쿼리에 대해 한 사람의 이름이 주어지면 위에서 말한 정렬 순으로 다른 팀원 두 명의 이름을 구하는 문제이다.

먼저 정렬은 기준이 주어졌으므로 sort의 cmp 함수를 직접 정의하여 정렬해줄 수 있다.

이제 하나의 팀원의 이름에 대해 나머지 두 팀원의 이름을 구해주어야 하는데, N이 10만 이하이므로 O(N^2)과 같은 방법으로는 불가능하다.

따라서 map 2개를 선언하여, m[str] 값이 팀원 이름이 되도록 저장해주자.

그러면 O(1) 시간에 답을 찾을 수 있으므로 O(M)에 모든 쿼리를 처리해줄 수 있다.

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

bool cmp(pair<string, string> a, pair<string, string> b) {
    if(a.second != b.second) return a.second < b.second;
    else return a.first < b.first;
}

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

    int N; cin >> N;

    vector<pair<string, string>> v(N);

    for(int i=0; i<N; i++)
        cin >> v[i].first >> v[i].second;

    sort(v.begin(), v.end(), cmp);

    unordered_map<string, string> m1, m2;

    for(int i=0; i<N; i+=3) {
        string a = v[i].first + ' ' + v[i].second;
        string b = v[i+1].first + ' ' + v[i+1].second;
        string c = v[i+2].first + ' ' + v[i+2].second;

        m1[a] = b;
        m2[a] = c;

        m1[b] = a;
        m2[b] = c;

        m1[c] = a;
        m2[c] = b;
    }

    int M; cin >> M;
    cin.ignore();

    while(M--) {
        string str; getline(cin, str);

        cout << m1[str] << "\n" << m2[str] << "\n";
    }
}

백준 BOJ 16524번 : Database of Clients

문제 난이도 : Silver II

알고리즘 분류 : 해시를 사용한 집합과 맵

여러 이메일들이 주어질 때, 실제 사용자 수가 몇인지를 구하는 문제이다.

(이메일에서 @ 앞의 +가 나오면 + ~ @ 사이의 문자들은 모두 무시되며, @ 앞에 나오는 . 역시 무시된다.)

tmp라는 문자열에 무시되는 문자들을 제외하고 추가하여, map으로 중복 체크를 해주는 방식을 이용하자.

두 개의 bool 변수 a와 p를 이용하여 @와 +가 언제 나왔는지를 체크한다.

+가 나왔다면 @가 나오기 전까지는 모두 무시해주면 된다.

@가 나왔으면 그 뒤의 모든 문자를 추가해야한다.

@가 나오기 전의 .은 무시해주어야 한다.

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

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

    int N; cin >> N;

    map<string, bool> m;
    int ans = 0;

    while(N--) {
        string str; cin >> str;

        string tmp = "";
        bool a = false, p = false;

        for(int i=0; i<str.length(); i++) {
            if(str[i] == '@') {
                a = true;
                p = false;
            }
            else if(str[i] == '+') p = true;
            else if(p) continue;
            else if(str[i] == '.') {
                if(a) tmp += str[i];
                else continue;
            }
            else tmp += str[i];
        }

        if(!m[tmp]) ans++;

        m[tmp] = true;
    }

    cout << ans << "\n";
}

백준 BOJ 21396번 : 이진수 더하기

문제 난이도 : Silver II

알고리즘 분류 : 해시를 사용한 집합과 맵

주어진 N개의 수 중에서 두 수를 골라 받아올림이 없는 이진수 덧셈을 하여 M이 되는 조합의 수를 구하는 문제이다.

map을 사용하면 쉽게 풀 수 있다.

먼저 받아올림이 없는 이진수 덧셈은 xor 연산을 한 것과 같다.

이제 N개의 수를 앞에서부터 검사하며 m[x] 값을 더하고, 더한 이후에 m[M ^ x]에 1씩 더해주면 다음에 M ^ x가 N개의 수 중 하나로 들어올 경우 count가 된다.

이러한 방식으로 풀면 O(N) 시간에 모든 조합의 수를 찾을 수 있다.

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

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

    int T; cin >> T;

    while(T--) {
        int N, M; cin >> N >> M;

        unordered_map<int, int> m;
        int ans = 0;

        while(N--) {
            int x; cin >> x;

            ans += m[x];

            m[x ^ M]++;
        }

        cout << ans << "\n";
    }
}

백준 BOJ 21980번 : 비슷한 번호판

문제 난이도 : Silver II

알고리즘 분류 : 해시를 사용한 집합과 맵

알파벳으로만 이루어진 번호판에 대해 구성 문자와 길이가 같고, 대문자의 개수가 같으면 비슷한 번호판이라고 한다면 주어진 N개의 번호판 중 비슷한 번호판은 몇 쌍인지 구하는 문제이다.

먼저 번호판을 알파벳 순으로 정렬하는 것은 답에 영향을 주지 않는다.

또한, 대문자의 수만 count 해둔다면 모든 알파벳을 소문자로 바꾸어도 상관이 없다.

이를 이용하여 모든 번호판을 소문자로 바꾸고 정렬한 뒤, map을 <소문자 정렬 문자열, 대문자 개수> → 번호판 개수와 같이 설정한다.

이제 N개의 번호판을 순차적으로 검사하며 해당 번호판과 같은 문자열과 대문자 개수에 해당되는 map의 값만큼 답에 더해주면서 답을 구해주면 된다.

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

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

    int T; cin >> T;

    while(T--) {
        int N, M; cin >> N >> M;

        map<pair<string, int>, int> m;
        int ans = 0;

        while(N--) {
            string str; cin >> str;

            int cnt = 0;

            for(int i=0; i<M; i++) {
                if(str[i] >= 'A' && str[i] <= 'Z') {
                    str[i] += 'a' - 'A';
                    cnt++;
                }
            }

            sort(str.begin(), str.end());

            ans += m[{str, cnt}];

            m[{str, cnt}]++;
        }

        cout << ans << "\n";
    }
}

백준 BOJ 4358번 : 생태학

문제 난이도 : Silver II

알고리즘 분류 : 해시를 사용한 집합과 맵

식물들의 목록이 주어질 때, 각 식물을 사전 순으로 출력하며 각 식물이 개수만큼 차지하는 비중을 백분위로 소수점 아래 4자리까지 구하는 문제이다.

map을 사용하여 어렵지 않게 해결할 수 있다.

이름이 나올 때마다 map[str] 값을 1씩 늘려주고, 마지막에 전체 나온 항목의 개수로 나눈 값 x 100을 하여 퍼센트 값을 구할 수 있다.

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

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

    string str;

    vector<string> v;
    map<string, int> m;
    int tot = 0;

    while(getline(cin, str)) {
        if(m[str] == 0) v.push_back(str);

        m[str]++;
        tot++;
    }

    sort(v.begin(), v.end());

    cout << fixed;
    cout.precision(4);

    for(int i=0; i<v.size(); i++)
        cout << v[i] << " " << (double)m[v[i]] * 100 / tot << "\n";
}

백준 BOJ 21208번 : Gratitude

문제 난이도 : Silver III

알고리즘 분류 : 정렬, 해시를 사용한 집합과 맵

3N개의 목록이 주어지고, 이들 중 가장 빈도가 높은 것이 먼저, 빈도가 같다면 마지막에 나온 것이 뒤 순서일 경우 먼저 나오도록 정렬하였을 때 앞의 M개의 목록을 구하는 문제이다.

map 2개를 사용하여 각각 나온 횟수, 그리고 마지막으로 나온 위치를 저장하여 정렬해주면 된다.

문제는 나온 목록의 종류가 M보다 작은 경우가 있으므로, min(v.size(), M)까지만 출력해주어야 한다.

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

unordered_map<string, int> m, idx;

bool cmp(string a, string b) {
    if(m[a] != m[b]) return m[a] > m[b];
    else return idx[a] > idx[b];
}

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

    int N, M; cin >> N >> M;
    cin.ignore();

    vector<string> v;

    for(int i=0; i<N*3; i++) {
        string str; getline(cin, str);

        if(m[str] == 0) v.push_back(str);

        m[str]++;
        idx[str] = i;
    }

    sort(v.begin(), v.end(), cmp);

    for(int i=0; i<min((int)v.size(), M); i++) cout << v[i] << "\n";
}

백준 BOJ 24653번 : Announcements

문제 난이도 : Silver III

알고리즘 분류 : 해시를 사용한 집합과 맵

N개의 광고가 v_i번째 날짜에 게재되고, M일마다 광고가 모두 수거될 때, 모든 광고를 보기 위해서 학교에 가야하는 날의 최소 수를 구하는 문제이다.

M일에 광고가 수거된다면 1 ~ M-1번째 날에 광고를 보러가면 된다.

즉, N개의 값들을 M으로 나눈 몫이 몇 가지 종류인지를 물어보는 문제임을 알 수 있다.

따라서 map을 이용하여 v_i / M이 나왔던 값인지를 체크하고 만약 나오지 않았다면 답에 1을 더해주는 방식을 반복하면 된다.

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

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

    int N; cin >> N;

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

    int M; cin >> M;

    unordered_map<int, bool> m;
    int ans = 0;

    for(int i=0; i<N; i++) {
        int x = v[i] / M;

        if(!m[x]) ans++;

        m[x] = true;
    }

    cout << ans << "\n";
}

백준 BOJ 18295번 : Ants

문제 난이도 : Silver III

알고리즘 분류 : 해시를 사용한 집합과 맵

주어진 수들 중에서 나타나지 않은 가장 작은 0 이상의 정수를 찾는 문제이다.

이 때 매우 큰 정수가 입력으로 들어올 수 있다.

map을 이용하여 정수들의 입력 여부를 체크할 것인데, 매우 큰 정수가 입력될 경우 오류를 발생시킬 수 있으므로 일단은 문자열로 입력받은 뒤 특정 자리수 이상의 길이를 가질 경우 continue 처리를 해준다.

그 외의 경우에는 map에 기록을 해주고, 그 다음 0부터 검사하면서 map 값이 false인 최초의 정수에 대해 출력을 해주면 된다.

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

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

    int N; cin >> N;

    unordered_map<int, bool> m;

    while(N--) {
        string x; cin >> x;

        if(x.length() > 7) continue;

        m[stoi(x)] = true;
    }

    for(int i=0; ; i++) {
        if(!m[i]) {
            cout << i << "\n";
            break;
        }
    }
}

백준 BOJ 5588번 : 별자리 찾기

문제 난이도 : Gold IV

알고리즘 분류 : 브루트포스

N개의 별의 좌표가 주어지고, 이들이 같은 거리만큼 평행이동을 했으며 N개보다 많은 M개의 별이 주어질 때 N개의 별이 얼마만큼 평행이동을 했는지를 구하는 문제이다.

N이 500 이하라서 브루트포스 알고리즘으로 풀린다.

map에 0번째 별을 기준으로 다른 별들의 간격을 저장하고, M개의 별들 중에 이러한 간격을 모두 가지는 것이 있다면 그 별이 0번째 별인 것이므로, 아까의 0번째 별의 좌표에서 얼마나 이동했는지 계산해주면 된다.

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

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

    int N; cin >> N;

    vector<pair<int, int>> v(N);

    for(int i=0; i<N; i++)
        cin >> v[i].first >> v[i].second;

    map<pair<int, int>, bool> m;

    for(int i=0; i<N; i++)
        m[{v[i].first - v[0].first, v[i].second - v[0].second}] = true;

    int M; cin >> M;

    vector<pair<int, int>> u(M);

    for(int i=0; i<M; i++)
        cin >> u[i].first >> u[i].second;

    for(int i=0; i<M; i++) {
        int cnt = 0;

        for(int j=0; j<M; j++) {
            if(m[{u[j].first - u[i].first, u[j].second - u[i].second}]) cnt++;
        }

        if(cnt >= N) {
            cout << u[i].first - v[0].first << " " << u[i].second - v[0].second << "\n";

            break;
        }
    }
}

중간에서 만나기 : 밋 인더 미들 알고리즘 풀이 모음 220821

restudy — Sun, 21 Aug 2022 15:57:39 +0900

백준 BOJ 16287번 : Parcel

문제 난이도 : Platinum V

알고리즘 분류 : 중간에서 만나기 (밋 인더 미들), DP

N개의 물품 중 "서로 다른" 물품 4개를 골라 그 무게의 합이 M이 되도록 하는 경우가 있는지 확인하는 문제이다.

우선 N이 5,000이므로, O(N^4) 같은 방법은 안 된다.

각 원소는 최대 20만이므로, 두 원소의 합을 배열에 저장하고, 나머지 두 원소의 합을 배열의 기록을 이용하여 비교해보는 방식을 사용해볼 수 있다.

O(N^2) 시간에 두 원소의 합을 구성하는 원소의 주소를 u, w에 저장한다.

다음으로 O(N^2) 시간에 나머지 두 원소의 합이 기록된 것들 중에서 주소가 둘 다 겹치지 않는 것이 있으면, YES를 정답으로 출력해주면 되고 그러한 조합이 하나도 없을 경우 NO를 출력해주면 된다.

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

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

    int M, N; cin >> M >> N;

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

    vector<int> u(5e5, -1), w(5e5, -1);

    for(int i=0; i<N; i++)
        for(int j=i+1; j<N; j++) {
            int sum = v[i] + v[j];

            if(u[sum] != -1 || w[sum] != -1) continue;

            u[sum] = i;
            w[sum] = j;
        }

    for(int i=0; i<N; i++)
        for(int j=i+1; j<N; j++) {
            int sum = M - (v[i] + v[j]);

            if(sum <= 0 || sum >= 400000) continue;
            if(u[sum] == -1 || w[sum] == -1) continue;
            if(u[sum] == i || w[sum] == j || u[sum] == j || w[sum] == i) continue;

            cout << "YES\n";

            return 0;
        }

    cout << "NO\n";
}

백준 BOJ 10767번 : Palindromic Paths

문제 난이도 : Gold IV

알고리즘 분류 : 중간에서 만나기 (밋 인더 미들)

N x N 배열이 주어질 때, 맨 왼쪽 위에서 맨 오른쪽 아래로 이동하면서 거친 알파벳들을 순서대로 합쳐 만들어진 문자열이 회문인 것의 종류의 수를 구하는 문제이다.

N이 최대 18이므로, 지나쳐야하는 경로의 길이는 최대 18 x 2 - 1 = 37이다.

O(2^37)은 시간 초과를 발생시키므로, 시간을 줄일 필요가 있다.

내가 생각한 풀이는 (i, N-1-i) 지점이 경로의 중간이 되므로, 모든 i에 대해 (i, N-1-i)에서 왼쪽 위로 가면서 만들어지는 문자열과 오른쪽 아래로 가면서 만들어지는 문자열이 같은지 검사하면 된다는 것이다.

이렇게 할 경우 O(2 x 2^17)로 시간을 단축시킬 수 있다.

이후 중복을 없애주기 위해서 벡터에 모두 넣은 뒤 정렬 및 중복 제거를 하여 마지막에 벡터에 남은 원소들의 수로 답을 찾아주었다.

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

int N;
vector<vector<char>> v;
vector<string> u, w;

void f(int x, int y, string s) {
    if(x == 0 && y == 0) {
        u.push_back(s);

        return;
    }

    int dx[2] = {-1, 0};
    int dy[2] = {0, -1};

    for(int i=0; i<2; i++) {
        int nx = x + dx[i];
        int ny = y + dy[i];

        if(nx < 0 || ny < 0) continue;

        f(nx, ny, s + v[nx][ny]);
    }
}

void g(int x, int y, string s) {
    if(x == N-1 && y == N-1) {
        w.push_back(s);

        return;
    }

    int dx[2] = {1, 0};
    int dy[2] = {0, 1};

    for(int i=0; i<2; i++) {
        int nx = x + dx[i];
        int ny = y + dy[i];

        if(nx >= N || ny >= N) continue;

        g(nx, ny, s + v[nx][ny]);
    }
}

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

    cin >> N;

    v.resize(N, vector<char>(N));

    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++) cin >> v[i][j];

    vector<string> vv;

    for(int i=0; i<N; i++) {
        u.clear();
        w.clear();

        f(i, N-1-i, "");
        g(i, N-1-i, "");

        sort(u.begin(), u.end());
        sort(w.begin(), w.end());

        for(int j=0; j<u.size(); j++) {
            if(upper_bound(w.begin(), w.end(), u[j]) - lower_bound(w.begin(), w.end(), u[j]) > 0) {
                string s = u[j];

                reverse(s.begin(), s.end());

                vv.push_back(s + v[i][N-1-i] + u[j]);
            }
        }
    }

    sort(vv.begin(), vv.end());
    vv.erase(unique(vv.begin(), vv.end()), vv.end());

    cout << vv.size() << "\n";
}

백준 BOJ 9007번 : 카누 선수

문제 난이도 : Gold III

알고리즘 분류 : 중간에서 만나기 (밋 인더 미들)

한 반에 N명씩으로 구성된 학생들의 몸무게가 주어질 때, 각 반에서 1명씩 뽑아 총 4명의 학생들의 몸무게의 합이 M과 가장 가깝게 하는 합을 구하는 문제이다. (이 때 M - x = y - M이라면 x를 선택한다.)

N이 1,000 이하이므로, 두 반씩 골라서 모든 가능한 몸무게의 조합을 두 개의 벡터에 저장한다.

그 다음 각 u[i]에 대해 M - u[i]에 가장 가까운 값을 w에서 이분 탐색으로 찾으면 O(N^2 log (N^2))에 풀 수 있다.

핵심은 "가장 가까운 합"을 어떻게 찾느냐는 것인데, 이것은 lower_bound로 찾은 주소와 그 주소 - 1 둘을 모두 체크해보아서 확인할 수 있다.

lower_bound가 x 이상인 최솟값이라면, lower_bound - 1의 값은 x 미만인 최댓값일 것이기 때문이다. (이터레이터라 주소와 개념이 다르긴 하지만 대충 이해하시면 됩니다..)

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

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

    int T; cin >> T;

    while(T--) {
        int M, N; cin >> M >> N;

        vector<vector<int>> v(4, vector<int>(N));

        for(int i=0; i<4; i++)
            for(int j=0; j<N; j++) cin >> v[i][j];

        vector<int> u, w;

        for(int i=0; i<N; i++)
            for(int j=0; j<N; j++) u.push_back(v[0][i] + v[1][j]);

        for(int i=0; i<N; i++)
            for(int j=0; j<N; j++) w.push_back(v[2][i] + v[3][j]);

        sort(u.begin(), u.end());
        sort(w.begin(), w.end());

        int ans = INT_MAX;

        for(int i=0; i<u.size(); i++) {
            int x = lower_bound(w.begin(), w.end(), M - u[i]) - w.begin();

            if(x < w.size()) {
                if(abs(u[i] + w[x] - M) < abs(ans - M)) ans = u[i] + w[x];
                else if(abs(u[i] + w[x] - M) == abs(ans - M)) ans = min(ans, u[i] + w[x]);
            }

            if(x > 0) {
                if(abs(u[i] + w[x-1] - M) < abs(ans - M)) ans = u[i] + w[x-1];
                else if(abs(u[i] + w[x-1] - M) == abs(ans - M)) ans = min(ans, u[i] + w[x-1]);
            }
        }

        cout << ans << "\n";
    }
}

백준 BOJ 12045번 : Robot Rock Band (Large)

문제 난이도 : Gold III

알고리즘 분류 : 중간에서 만나기 (밋 인더 미들)

4개의 그룹이 각각 N개의 값을 가졌을 때, 4개에서 각각 1개의 값들을 골라 xor한 값이 M인 조합의 수를 구하는 문제이다.

위의 카누 선수 문제와 동일하기 풀이하면 된다.

xor 연산의 경우 교환 법칙이 성립하므로 벡터 w에서 M ^ u[i] 값을 가지는 것의 개수를 이분 탐색으로 찾아주면 된다.

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

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

    int T; cin >> T;

    for(int t=1; t<=T; t++) {
        int N, M; cin >> N >> M;

        vector<vector<int>> v(4, vector<int>(N));

        for(int i=0; i<4; i++)
            for(int j=0; j<N; j++) cin >> v[i][j];

        vector<int> u, w;

        for(int i=0; i<N; i++)
            for(int j=0; j<N; j++) u.push_back(v[0][i] ^ v[1][j]);

        for(int i=0; i<N; i++)
            for(int j=0; j<N; j++) w.push_back(v[2][i] ^ v[3][j]);

        sort(u.begin(), u.end());
        sort(w.begin(), w.end());

        int ans = 0;

        for(int i=0; i<u.size(); i++)
            ans += upper_bound(w.begin(), w.end(), M ^ u[i]) - lower_bound(w.begin(), w.end(), M ^ u[i]);

        cout << "Case #" << t << ": " << ans << "\n";

    }
}

여담으로 이 문제를 풀면 백준 BOJ 12044번 : Robot Rock Band (Small)을 풀이할 수 있다.

백준 BOJ 23538번 : Easy Equation

문제 난이도 : Gold III

알고리즘 분류 : 중간에서 만나기 (밋 인더 미들)

x^5 + y^4 + z^3 + w^2 + t = N을 만족하는 양의 정수 (x, y, z, w, t)의 순서쌍의 개수를 구하는 문제이다.

우선 x^5 + y^4 + z^3 + w^2 < N을 만족하기만 하면 t는 자동으로 결정된다.

그렇기 때문에 위 4개의 변수의 순서쌍을 구하는데에 초점을 맞추면 된다.

x^5 < N을 만족하는 x들과 w^2 < N을 만족하는 w들을 구해 x + w의 조합을 벡터 u에 저장한다.

y^4 < N을 만족하는 y들과 z^3 < N을 만족하는 z들을 구해 y + z의 조합을 벡터 w에 저장한다.

이렇게 나누는 이유는 u와 w의 size를 최대한 비슷하게 맞추기 위해서이다.

이제 밋 인더 미들로 조합의 수를 구할 수 있다.

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

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

    int N; cin >> N;

    vector<vector<int>> v(4);

    for(int i=1; i*i*i*i*i<N; i++) v[0].push_back(i*i*i*i*i);
    for(int i=1; i*i*i*i<N; i++) v[1].push_back(i*i*i*i);
    for(int i=1; i*i*i<N; i++) v[2].push_back(i*i*i);
    for(int i=1; i*i<N; i++) v[3].push_back(i*i);

    vector<int> u, w;

    for(int i=0; i<v[1].size(); i++)
        for(int j=0; j<v[2].size(); j++)
                u.push_back(v[1][i] + v[2][j]);

    for(int i=0; i<v[0].size(); i++)
        for(int j=0; j<v[3].size(); j++)
                w.push_back(v[0][i] + v[3][j]);

    sort(u.begin(), u.end());
    sort(w.begin(), w.end());

    int ans = 0;

    for(int i=0; i<u.size(); i++) {
        ans += lower_bound(w.begin(), w.end(), N - u[i]) - w.begin();
    }

    cout << ans << "\n";
}

백준 BOJ 5526번 : ダーツ (Darts)

문제 난이도 : Gold II

알고리즘 분류 : 중간에서 만나기 (밋 인더 미들)

4개 이하의 다트를 던져 N개의 점수 중 하나를 받고 그 합을 M점 이하의 최대한 가까운 점수로 만들려고 할 때, 그 점수를 구하는 문제이다.

위와 같이 밋 인더 미들로 풀이하면 되지만, 이 문제에서는 다트의 일부를 던지지 않아도 되므로, 벡터에 0을 추가해준다.

벡터에서 0이 선택된다면 그 다트는 던지지 않는 것으로 생각할 수 있기 때문이다.

이제 이분 탐색에서 x를 초과하는 최소 주소 - 1의 값을 검사해서 최댓값을 갱신해주면 된다.

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

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

    int N, M; cin >> N >> M;

    vector<int> v;
    v.push_back(0);

    for(int i=0; i<N; i++) {
        int x; cin >> x;

        v.push_back(x);
    }

    vector<int> u;

    for(int i=0; i<v.size(); i++)
        for(int j=0; j<v.size(); j++) u.push_back(v[i] + v[j]);

    vector<int> w(u);

    sort(u.begin(), u.end());
    sort(w.begin(), w.end());

    int ans = 0;

    for(int i=0; i<u.size(); i++) {
        int x = upper_bound(w.begin(), w.end(), M - u[i]) - w.begin();

        if(x == 0) continue;

        ans = max(ans, u[i] + w[x-1]);
    }

    cout << ans << "\n";
}

백준 BOJ 10958번 : Ice Hockey World Championship

문제 난이도 : Gold I

알고리즘 분류 : 중간에서 만나기 (밋 인더 미들)

N = 40 이하일 때, N개의 티켓의 가격의 합이 M원 이하가 되도록 하는 조합의 수를 구하는 문제이다.

한 개의 티켓도 사지 않는 경우도 경우에 포함된다.

N을 둘로 나누어 밋 인더 미들을 써주면 된다.

밋 인더 미들의 정석적인 문제라서 크게 설명할 부분은 없고 똑같이 풀이해주면 된다.

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

int N, M;
vector<int> v, u, w;

void f(int idx, int sum) {
    if(idx == N/2) {
        u.push_back(sum);
        return;
    }

    f(idx + 1, sum);
    f(idx + 1, sum + v[idx]);
}

void g(int idx, int sum) {
    if(idx == N) {
        w.push_back(sum);
        return;
    }

    g(idx + 1, sum);
    g(idx + 1, sum + v[idx]);
}

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

    cin >> N >> M;

    v.resize(N);
    for(int i=0; i<N; i++) cin >> v[i];

    f(0, 0);
    g(N/2, 0);

    sort(u.begin(), u.end());
    sort(w.begin(), w.end());

    int ans = 0;

    for(int i=0; i<u.size(); i++)
        ans += upper_bound(w.begin(), w.end(), M - u[i]) - w.begin();

    cout << ans << "\n";
}

백준 BOJ 6099번 : Exams

문제 난이도 : Gold IV

알고리즘 분류 : 중간에서 만나기 (밋 인더 미들)

N개의 각 시험에서 얻을 수 있는 점수가 주어질 때, 일부 시험을 선택하여 M점 이상의 점수를 만드는 경우의 수를 구하는 문제이다.

N이 36 이하이므로 밋 인더 미들을 사용하여 풀이할 수 있다.

0 ~ N/2까지 2^18 이하의 합으로 가능한 조합들을 모두 저장해주고, N/2 ~ N까지도 마찬가지로 해준다.

이제 벡터 값을 정렬 해주고 (한 쪽만 해주면 된다.) 각 2^18 조합에 대해 나머지 2^18 조합들은 이분 탐색으로 몇 개의 값이 조건을 충족하는지 구해서 더해주면 된다.

총 시간 복잡도는 O(2^(N/2) x (N/2))이다.

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

int N, M;
vector<int> v, u, w;

void f(int idx, int sum) {
    if(idx == N/2) {
        u.push_back(sum);
        return;
    }

    f(idx + 1, sum);
    f(idx + 1, sum + v[idx]);
}

void g(int idx, int sum) {
    if(idx == N) {
        w.push_back(sum);
        return;
    }

    g(idx + 1, sum);
    g(idx + 1, sum + v[idx]);
}

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

    cin >> N >> M;

    v.resize(N);
    for(int i=0; i<N; i++) cin >> v[i];

    f(0, 0);
    g(N/2, 0);

    sort(u.begin(), u.end());
    sort(w.begin(), w.end());

    int ans = 0;

    for(int i=0; i<u.size(); i++)
        ans += w.end() - lower_bound(w.begin(), w.end(), M - u[i]);

    cout << ans << "\n";
}

백준 BOJ 17637번 : Count Sqaures

문제 난이도 : Silver IV

알고리즘 분류 : 해시를 사용한 집합과 맵

N개의 수직선과 M개의 수평선이 그어졌을 때, 이들 중 4개를 선택하여 만들 수 있는 정사각형의 수를 구하는 문제이다.

즉, a_i - a_j = b_i - b_j의 쌍을 구하는 문제이다. (좌변의 i, j와 우변의 i, j는 다름)

map으로 a_i - a_j의 모든 쌍을 구해놓고, b_i - b_j들의 모든 쌍들에 대해 map에 몇 개의 값이 저장되어 있는지 확인하여 답에 더해주면 된다.

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

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

    int N, M; cin >> N >> M;

    vector<int> v(N), u(M);

    for(int i=0; i<N; i++) cin >> v[i];
    for(int i=0; i<M; i++) cin >> u[i];

    sort(v.begin(), v.end());
    sort(u.begin(), u.end());

    unordered_map<int, int> m;

    for(int i=0; i<N; i++)
        for(int j=0; j<i; j++) m[v[i] - v[j]]++;

    int ans = 0;

    for(int i=0; i<M; i++)
        for(int j=0; j<i; j++) ans += m[u[i] - u[j]];

    cout << ans << "\n";
}

트리를 사용한 집합과 맵 알고리즘 풀이들 정리 220820

restudy — Sat, 20 Aug 2022 12:36:58 +0900

백준 BOJ 6325번 : Definite Values

문제 난이도 : Silver V

알고리즘 분류 : 트리를 사용한 집합과 맵

N개의 (변수) = (변수) 꼴의 수식이 주어지고, 처음에는 a만 값이 제대로 지정되었다고 할 때, 모든 등식이 적용된 이후 값이 제대로 지정된 변수의 목록을 구하는 문제이다.

set을 사용한다.

a = b라는 등식에서, a가 값이 지정되지 않고 b가 지정되었다면 a는 제대로 된 값이 지정된다. (set에 insert 해준다.)

반대로 a가 값이 지정되고 b가 지정되지 않았다면 a의 값은 쓰레기 값으로 덮어진다. (set에서 erase 해준다.)

이 과정을 N번 반복한 다음 set의 모든 원소들을 출력해주면 된다.

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

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

    for(int t=1; ; t++) {
        int N; cin >> N;
        if(N == 0) break;

        set<string> s;
        s.insert("a");

        while(N--) {
            string a, op, b; cin >> a >> op >> b;

            if(s.count(a) == 0 && s.count(b) > 0) s.insert(a);
            else if(s.count(a) > 0 && s.count(b) == 0) s.erase(a);
        }

        cout << "Program #" << t << "\n";

        if(s.size() > 0) {
            for(auto i : s) cout << i << " ";
        }
        else cout << "none";

        cout << "\n\n";
    }
}

백준 BOJ 8975번 : PJESMA

문제 난이도 : Silver V

알고리즘 분류 : 트리를 사용한 집합과 맵

N개의 단어가 주어지고, M개의 단어가 주어질 때 이 M개의 단어들을 순서대로 보면서 N개의 단어 중에 있으면 체크한다면 N개의 단어 중 절반 이상이 체크될 때 M개의 단어들 중 몇 번째 단어까지 체크해야 하는지 구하는 문제이다.

먼저 N개의 단어는 set에 저장해주고, M개의 단어들을 순서대로 확인하면서 count 해주면 된다.

다만 M개의 단어들 중에서 중복이 있기 때문에 map을 이용하여 중복이 발생하지 않도록 해주자.

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

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

    int N; cin >> N;

    set<string> s;

    for(int i=0; i<N; i++) {
        string str; cin >> str;

        s.insert(str);
    }

    int M; cin >> M;

    vector<string> v(M);

    for(int i=0; i<M; i++) cin >> v[i];

    unordered_map<string, bool> m;
    int cnt = 0;

    for(int i=0; i<M; i++) {
        if(m[v[i]]) continue;

        m[v[i]] = true;

        if(s.count(v[i]) > 0) cnt++;

        if(cnt >= (N+1)/2) {
            cout << i+1 << "\n";
            break;
        }
    }
}

백준 BOJ 4775번 : Spelling Be

문제 난이도 : Silver V

알고리즘 분류 : 트리를 사용한 집합과 맵

사전에 있는 단어들이 주어지고, 각 이메일에 대해 사전에 없는 단어들이 있으면 그 단어들을 출력하는 문제이다.

Set을 사용하여 쉽게 풀이할 수 있다.

사전에 있는 단어들을 Set에 넣어주고, 각 이메일들에 대해 Set에 단어가 있는지 체크하여 없으면 벡터에 저장해준 뒤 마지막에 모두 출력해주면 된다.

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

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

    int N; cin >> N;

    multiset<string> s;

    while(N--) {
        string str; cin >> str;

        s.insert(str);
    }

    int T; cin >> T;

    for(int t=1; t<=T; t++) {
        vector<string> v;

        while(true) {
            string str; cin >> str;
            if(str == "-1") break;

            if(s.count(str) == 0) v.push_back(str);
        }

        if(v.size() == 0) {
            cout << "Email " << t << " is spelled correctly.\n";
        }
        else {
            cout << "Email " << t << " is not spelled correctly.\n";

            for(int i=0; i<v.size(); i++) cout << v[i] << "\n";
        }
    }

    cout << "End of Output\n";
}

백준 BOJ 5390번 : Gene Shuffle

문제 난이도 : Silver V

알고리즘 분류 : 트리를 사용한 집합과 맵

N 이하의 자연수로 이루어진 두 개의 순열에 대해, 부분 원소가 같은 부분 집합을 최대한 많이 쪼개지도록 찾는 문제이다.

set을 사용하여 원소를 순서대로 2개의 set에 넣어주다가 두 set이 같아질 때 그 구간을 출력해주면 된다.

여담으로 unordered_set을 사용해봤는데 시간 초과가 발생했다.

set의 경우 탐색 시간이 O(log N)인 것에 비해 unordered_set은 O(1)일 때도 있고 최악의 경우 O(N)이라고 한다.

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

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

    int T; cin >> T;

    while(T--) {
        int N; cin >> N;

        vector<int> v(N), u(N);

        for(int i=0; i<N; i++) cin >> v[i];
        for(int i=0; i<N; i++) cin >> u[i];

        int cur = 0;

        while(cur < N) {
            set<int> sv, su;

            for(int i=cur; i<N; i++) {
                sv.insert(v[i]);
                su.insert(u[i]);

                if(sv == su) {
                    cout << cur+1 << "-" << i+1 << " ";

                    cur = i+1;

                    break;
                }
            }
        }

        cout << "\n";
    }
}

백준 BOJ 15081번 : Is Everbody Appy?

문제 난이도 : Silver V

알고리즘 분류 : 트리를 사용한 집합과 맵

N명의 사람들이 원하는 앱의 이름들이 주어지고 (먼저 나오는 이름이 우선순위가 높은 앱), 각 사람은 한 개의 앱만을 받을 수 있으며, 먼저 나오는 사람이 우선 순위일 때 각 사람이 받아야 하는 앱의 이름을 구하는 문제이다.

맨 윗 사람부터 그리디하게 앞의 앱부터 set을 체크해보면서 set에 없는 이름일 경우 그 앱을 출력해주고 set에 추가해주면 된다.

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

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

    int N; cin >> N;

    set<string> s;

    while(N--) {
        int M; cin >> M;

        vector<string> v(M);

        for(int i=0; i<M; i++) cin >> v[i];

        for(int i=0; i<M; i++) {
            if(s.count(v[i]) == 0) {
                cout << v[i] << " ";

                s.insert(v[i]);

                break;
            }
        }
    }
    cout << "\n";
}

백준 BOJ 17048번 : Jarvis

문제 난이도 : Silver V

알고리즘 분류 : 트리를 사용한 집합과 맵

배열 A와 B가 주어질 때, A의 전체에 x를 더하여 B와 일치하는 원소 수가 최대가 되게 하려고 할 때, 최대로 일치하는 원소 수를 구하는 문제이다.

map을 사용하여 격차(b[i] - a[i])들을 모두 저장해주고, 그들 중 빈도가 가장 높은 격차의 횟수를 답으로 얻어주면 된다.

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

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

    int N; cin >> N;

    vector<int> v(N), u(N);

    for(int i=0; i<N; i++) cin >> v[i];
    for(int i=0; i<N; i++) cin >> u[i];

    map<int, int> m;
    vector<int> w;

    for(int i=0; i<N; i++) {
        if(m[u[i] - v[i]] == 0)
            w.push_back(u[i] - v[i]);

        m[u[i] - v[i]]++;
    }

    int ans = 0;

    for(int i=0; i<w.size(); i++) ans = max(ans, m[w[i]]);

    cout << ans << "\n";
}

백준 BOJ 18703번 : Duplicate Files

문제 난이도 : Silver V

알고리즘 분류: 트리를 사용한 집합과 맵

여러 파일들의 이름과 번호가 주어질 때, 동일한 이름의 파일은 번호가 더 낮은 것만을 남긴다고 한다면 마지막으로 남는 파일들의 번호들을 구하는 문제이다.

map을 사용하여 번호를 저장하고, 만약 번호가 없을 경우 추가해주고 번호가 있는데 새로 입력된 파일의 번호가 더 작을 경우 갱신해주면 된다.

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

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

    int T; cin >> T;

    while(T--) {
        int N; cin >> N;

        unordered_map<string, int> m;
        vector<string> v;

        while(N--) {
            string str; cin >> str;
            int x; cin >> x;

            if(m[str] == 0) {
                m[str] = x;

                v.push_back(str);
            }
            else m[str] = min(m[str], x);
        }

        vector<int> u;

        for(int i=0; i<v.size(); i++) u.push_back(m[v[i]]);

        sort(u.begin(), u.end());

        for(int i=0; i<u.size(); i++) cout << u[i] << " ";
        cout << "\n";
    }
}

백준 BOJ 18706번 : Coffee

문제 난이도 : Silver V

알고리즘 분류 : 트리를 사용한 집합과 맵

N개의 커피의 종류와 가격(small, medium, large의 가격), M명의 이름과 원하는 커피가 주어지며, 배송료 100달러를 M명이 나눠서 지불할 때 최종적으로 각 사람이 내야 하는 가격을 구하는 문제이다.

(이 때 5의 배수 ±1인 경우는 가까운 5의 배수로 반올림해야 한다.)

map을 사용하여 문제에서 주어진 조건대로 구현하면 되는 구현 문제이다.

배송료는 100 / M을 더해서 구해줄 수 있으며, 최종적으로 이 가격에 5로 나눈 나머지가 1 또는 4일 때만 추가적인 처리를 해주면 된다.

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

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

    int T; cin >> T;

    while(T--) {
        int N, M; cin >> N >> M;

        map<string, int> ms, mm, ml;

        for(int i=0; i<N; i++) {
            string str; cin >> str;

            int a, b, c; cin >> a >> b >> c;

            ms[str] = a;
            mm[str] = b;
            ml[str] = c;
        }

        for(int i=0; i<M; i++) {
            string a, b, c; cin >> a >> b >> c;

            int ans = 0;

            if(b == "small") ans += ms[c];
            else if(b == "medium") ans += mm[c];
            else if(b == "large") ans += ml[c];

            ans += 100 / M;

            if(ans % 5 == 1) ans--;
            else if(ans % 5 == 4) ans++;

            cout << a << " " << ans << "\n";
        }
    }
}

백준 BOJ 7847번 : Sales Report

문제 난이도 : Silver IV

알고리즘 분류 : 트리를 사용한 집합과 맵

각 물건에 대해 2개의 고유한 id가 주어지고, 이들의 판매 수량이 주어질 때 2차원 표를 만들어 각 id에 해당하는 물건의 수의 합을 구하는 문제이다.

map을 pair<int, int> → int로 선언하여, 각 id 쌍에 대한 map의 값을 갱신해준 뒤, 문제에서 만들라고 하는 대로 표를 출력해주면 된다.

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

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

    int N; cin >> N;

    vector<int> v, u;
    map<pair<int, int>, int> m;

    while(N--) {
        int a, b, c; cin >> a >> b >> c;

        v.push_back(a);
        u.push_back(b);

        m[{a, b}] += c;
    }

    sort(v.begin(), v.end());
    sort(u.begin(), u.end());

    v.erase(unique(v.begin(), v.end()), v.end());
    u.erase(unique(u.begin(), u.end()), u.end());

    cout << -1 << " ";

    for(int i=0; i<v.size(); i++) cout << v[i] << " ";
    cout << "\n";

    for(int i=0; i<u.size(); i++) {
        cout << u[i] << " ";

        for(int j=0; j<v.size(); j++) cout << m[{v[j], u[i]}] << " ";
        cout <<"\n";
    }
}

백준 BOJ 24771번 : Un-bear-albe Zoo

문제 난이도 : Silver IV

알고리즘 분류 : 트리를 사용한 집합과 맵

N개의 동물의 이름이 주어지는데 여러 단어로 이루어진 입력이고, 마지막 단어만이 동물의 종을 나타내며 이들은 대소문자가 섞여서 나올 수 있다고 할 때, 최종적으로 나온 동물들과 이들의 수를 구하는 문제이다.

map을 사용하여 각 이름들에 대한 개수를 저장해주면 된다.

문제는 동물의 이름 중간에도 대문자가 섞여 나올 수 있으므로 각 이름의 모든 문자에 대해 대문자 여부를 검사해주어 바꿔주어야 한다.

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

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

    for(int t=1; ; t++) {
        int N; cin >> N;
        if(N == 0) break;

        cin.ignore();

        map<string, int> m;
        vector<string> v;

        while(N--) {
            string str; getline(cin, str);

            string name = "";

            for(int i=str.length()-1; i>=0; i--) {
                if(str[i] == ' ') break;

                name = str[i] + name;
            }

            for(int j=0; j<name.length(); j++)
                if(name[j] >= 'A' && name[j] <= 'Z') name[j] += 'a' - 'A';

            m[name]++;
            v.push_back(name);
        }

        sort(v.begin(), v.end());
        v.erase(unique(v.begin(), v.end()), v.end());

        cout << "List " << t << ":\n";

        for(int i=0; i<v.size(); i++)
            cout << v[i] << " | " << m[v[i]] << "\n";
    }
}

백준 BOJ 6851번 : Snowflakes

문제 난이도 : Silver III

알고리즘 분류 : 트리를 사용한 집합과 맵

N개의 6자리 숫자로 이루어진 배열이 주어지고, 각 배열은 뒤집거나 1칸씩 shift할 수 있다고 할 때, 이러한 이동을 거쳐 서로 같은 6자리 배열 쌍이 존재하는지를 구하는 문제이다.

6자리 shift와 뒤집기를 합치면 총 12개의 배열이 나타날 수 있는데, 이들을 모두 해본 뒤 사전순으로 가장 앞서는 것으로 설정한 뒤 같은 배열이 존재하는지 체크해보면 된다.

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

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

    int N; cin >> N;

    map<vector<int>, bool> m;
    bool check = false;

    while(N--) {
        vector<int> v(6);
        for(int i=0; i<6; i++) cin >> v[i];

        vector<int> w(v);

        for(int i=0; i<6; i++) {
            vector<int> u;

            for(int j=i; j<6; j++) u.push_back(w[j]);
            for(int j=0; j<i; j++) u.push_back(w[j]);

            v = min(v, u);
        }

        reverse(w.begin(), w.end());

        for(int i=0; i<6; i++) {
            vector<int> u;

            for(int j=i; j<6; j++) u.push_back(w[j]);
            for(int j=0; j<i; j++) u.push_back(w[j]);

            v = min(v, u);
        }

        if(m[v]) {
            check = true;
            break;
        }

        m[v] = true;
    }

    if(check) cout << "Twin snowflakes found.\n";
    else cout << "No two snowflakes are alike.\n";
}

백준 BOJ 15237번 : Cipher

문제 난이도 : Silver III

알고리즘 분류 : 해시를 사용한 집합과 맵, 정렬

N개의 수가 주어질 때, 빈도가 높은 수가 먼저 나오고, 같은 빈도인 경우 먼저 나온 수가 앞에 나오도록 정렬할 때 정렬한 배열을 구하는 문제이다.

sort의 cmp 함수를 직접 구현하여 구현해줄 수 있고, cmp 함수에서는 map을 활용하여 return 값을 지정해줄 수 있다.

map으로 각 수의 빈도를 세어주고, 먼저 나오는 것의 여부도 map으로 최초로 나온 idx를 저장해서 확인해줄 수 있다.

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

map<int, int> m, idx;

bool cmp(int a, int b) {
    if(m[a] != m[b]) return m[a] > m[b];
    else return idx[a] < idx[b];
}

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

    int N, M; cin >> N >> M;

    vector<int> v;

    for(int i=0; i<N; i++) {
        int x; cin >> x;

        if(m[x] == 0) {
            v.push_back(x);

            idx[x] = i;
        }

        m[x]++;
    }

    sort(v.begin(), v.end(), cmp);

    for(int i=0; i<v.size(); i++)
        for(int j=0; j<m[v[i]]; j++) cout << v[i] << " ";

    cout << "\n";
}

백준 BOJ 22133번 : Олимпиада

문제 난이도 : Silver I

알고리즘 분류 : 포함 배제의 원리

세 직사각형의 가로 세로가 주어질 때 합집합 넓이의 최소를 구하는 문제이다.

포함 배제의 원리로 풀어줄 수 있다.

먼저 세 직사각형의 넓이를 우선 다 더하고, 그 다음 두 직사각형의 겹치는 넓이를 빼주고 (3C2 3쌍), 마지막으로 세 직사각형이 모두 겹치는 넓이를 더해주면 된다.

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

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

    while(true) {
        int a, b, c, d, e, f; cin >> a >> b >> c >> d >> e >> f;
        if(a*a + b*b + c*c + d*d + e*e + f*f == 0) break;

        if(a < b) swap(a, b);
        if(c < d) swap(c, d);
        if(e < f) swap(e, f);

        int ans = a*b + c*d + e*f;

        ans -= min(a, c) * min(b, d);
        ans -= min(c, e) * min(d, f);
        ans -= min(e, a) * min(f, b);

        ans += min({a, c, e}) * min({b, d, f});

        cout << ans << "\n";
    }
}

백준 BOJ 7121번 : Pencil Factory

문제 난이도 : Silver IV

알고리즘 분류 : 포함 배제의 원리

Painting은 N개의 o 이후에 x가 1개씩 나오고, Varnishing은 M개의 o 이후에 x가 1개씩 나온다고 할 때, 1 ~ K 중에서 다음의 4가지를 구하는 문제이다.

1. Painting과 Varnishing이 모두 o인 것의 개수

2. 둘 다 x인 것의 개수

3. Painting만 o인 것의 개수

4. Varnishing만 o인 것의 개수

먼저 N과 M의 최소공배수를 구한 뒤, 포함과 배제의 원리를 이용하여 풀이할 수 있다.

코드를 참고하자.

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

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

    int N, M, K; cin >> N >> M >> K;

    N++, M++;

    int lcm = N * M / __gcd(N, M);

    cout << K - K/N - K/M + K/lcm << " ";
    cout << K/lcm << " ";
    cout << K/M - K/lcm << " ";
    cout << K/N - K/lcm << "\n";
}

백준 BOJ 스위핑, 값/좌표 압축 알고리즘 문제 풀이 모음 220819

restudy — Fri, 19 Aug 2022 00:11:20 +0900

백준 BOJ 18869번 : 멀티버스 II

문제 난이도 : Gold V

알고리즘 분류 : 값/좌표 압축

두 집합에 대해, a_i, a_j와 b_i, b_j의 대소 관계가 모두 같다면 두 집합은 동일하다고 할 때, N개의 집합에 대해 몇 개의 집합 쌍이 동일한지를 구하는 문제이다.

각 집합에 대해 좌표 압축을 수행해주면, 원소들의 대소 관계가 같은 집합은 동일한 원소들을 가지게 된다.

이를 활용하여 좌표 압축을 N번 반복해준 뒤 브루트포스로 답을 구해주면 된다.

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

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

    int M, N; cin >> M >> N;

    vector<vector<int>> v(M, vector<int>(N)), u(v), w(v);

    for(int i=0; i<M; i++) {
        for(int j=0; j<N; j++) {
            cin >> v[i][j];
            u[i][j] = v[i][j];
            }

        sort(u[i].begin(), u[i].end());
        u[i].erase(unique(u[i].begin(), u[i].end()), u[i].end());

        for(int j=0; j<v[i].size(); j++)
            w[i][j] = lower_bound(u[i].begin(), u[i].end(), v[i][j]) - u[i].begin();
    }

    int ans = 0;

    for(int i=0; i<M; i++)
        for(int j=i+1; j<M; j++)
            if(w[i] == w[j]) ans++;

    cout << ans << "\n";
}

백준 BOJ 1911번 : 흙길 보수하기

문제 난이도 : Silver I

알고리즘 분류 : 그리디, 스위핑

1차원 좌표 상의 N개의 물 웅덩이의 양 끝 좌표가 주어질 때, 길이가 M인 널빤지로 이들을 모두 커버하기 위해서 최소 몇 개의 널빤지가 필요한지 구하는 문제이다.

먼저 N개의 웅덩이를 좌표 순으로 정렬한 뒤, 왼쪽 웅덩이부터 최소한의 판자로 메꾸고 나서 현재 좌표를 판자의 오른쪽 끝으로 갱신해준다.

그 다음 웅덩이에 대해서는, 웅덩이의 오른쪽 끝보다 현재 좌표가 크면 그냥 넘어가고, 그렇지 않으면 오른쪽 끝까지 다시 판자로 덮는 과정을 반복한다. (스위핑)

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

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

    int N, M; cin >> N >> M;

    vector<pair<int, int>> v(N);
    for(int i=0; i<N; i++)
        cin >> v[i].first >> v[i].second;

    sort(v.begin(), v.end());

    int x = INT_MIN, ans = 0;

    for(int i=0; i<N; i++) {
        if(x >= v[i].second) continue;

        x = max(x, v[i].first);

        int cnt = ((v[i].second - x) - 1) / M + 1;

        ans += cnt;
        x += M * cnt;
    }

    cout << ans << "\n";
}

백준 BOJ 21600번 : 계단

문제 난이도 : Silver I

알고리즘 분류 : 그리디, 스위핑

N개의 막대로 이루어진 히스토그램이 주어졌을 때, 가장 큰 연속된 계단의 크기를 구하는 문제이다. (자세한 설명은 문제 원문을 참고하는 것을 추천한다.)

cur를 현재 위치를 마지막으로 이루는 계단의 높이라고 하고, ans를 지금까지 cur 중에 최대 cur 값이라고 하면, 맨 왼쪽 값부터 입력을 받으면서 cur와 ans를 갱신해나가며 답을 구할 수 있다.

예를 들어 특정 위치에서의 높이가 cur보다 높다면, cur를 1 증가시켜줄 수 있다. (1칸 더 높은 계단을 연결할 수 있으므로)

만약 그렇지 않다면, 현재 높이가 현재 위치를 마지막으로 하는 계단의 높이가 된다.

ans 값은 조건문에 관계없이 항상 갱신시켜주면 된다.

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

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

    int N; cin >> N;

    int ans = 0, cur = 0;

    for(int i=0; i<N; i++) {
        int x; cin >> x;

        if(x > cur) cur++;
        else cur = x;

        ans = max(ans, cur);
    }

    cout << ans << "\n";
}

백준 BOJ 12867번 : N차원 여행

문제 난이도 : Silver II

알고리즘 분류 : 값/좌표 압축

N차원 좌표 상에서, 원점에서 시작하여 N번의 이동을 할 때 중복 방문한 지점이 있었는지를 구하는 문제이다.

이 때, N은 10억 이하이고 이동 횟수는 50 이하이다.

N이 아주 크므로 좌표 압축을 통해 0인 부분을 제거하면 벡터의 크기를 50 이하로 줄일 수 있다.

좌표 압축을 사용해준 뒤 vector<int>에서 bool로 가는 map을 활용하여 중복 여부를 체크해줄 수 있다.

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

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

    int M, N; cin >> M >> N;

    vector<int> v(N), u(N);
    for(int i=0; i<N; i++) {
        cin >> v[i];
        u[i] = v[i];
    }

    vector<char> vv(N);
    for(int i=0; i<N; i++) cin >> vv[i];

    sort(u.begin(), u.end());
    u.erase(unique(u.begin(), u.end()), u.end());

    vector<int> w(N);
    for(int i=0; i<v.size(); i++)
        w[i] = lower_bound(u.begin(), u.end(), v[i]) - u.begin();

    map<vector<int>, bool> m;
    vector<int> uu(N);
    m[uu] = true;

    bool check = true;

    for(int i=0; i<N; i++) {
        if(vv[i] == '+') uu[w[i]]++;
        else if(vv[i] == '-') uu[w[i]]--;

        if(m[uu]) check = false;

        m[uu] = true;
    }

    if(check) cout << 1 << "\n";
    else cout << 0 << "\n";
}

백준 BOJ 15889번 : 호 안에 수류탄이야!!

문제 난이도 : Silver III

알고리즘 분류 : 그리디, 스위핑

N명의 사람의 수직선 상의 좌표가 주어지고, 그 중 왼쪽 N-1명이 수류탄을 던질 수 있는 범위가 주어질 때, 맨 왼쪽 사람에서 전달을 시작하여 맨 오른쪽 사람이 받을 수 있는지의 여부를 구하는 문제이다.

맨 왼쪽 사람부터 시작하여 각 사람이 도달 가능한 최대 거리를 구하고, 다음 사람이 이 최대 거리 내에 있어야 전달이 가능하다.

만약 한 사람이라도 해당하지 않는 경우가 발생한다면 맨 오른쪽까지 도달하는 것은 불가능하다.

원래는 이 문제에서는 정렬을 해줄 필요가 없다고 나오지는 않았으나, 맥락 상 좌표 순서대로 주어진다고 유추가 가능하기 때문에 정렬을 해주지 않아도 된다.

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

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

    int N; cin >> N;

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

    vector<int> u(N-1);
    for(int i=0; i<N-1; i++) cin >> u[i];

    int sum = 0;

    for(int i=0; i<N-1; i++) {
        sum = max(sum, v[i] + u[i]);

        if(sum < v[i+1]) {
            cout << "엄마 나 전역 늦어질 것 같아\n";
            return 0;
        }
    }

    cout << "권병장님, 중대장님이 찾으십니다\n";
}

백준 BOJ 24035번 : Impartial Offerings

문제 난이도 : Silver IV

알고리즘 분류 : 값/좌표 압축

N마리의 강아지들에게 간식을 주는데, 모든 강아지들에게 간식을 1 이상 주되 무게가 더 무거운 강아지한테는 더 많은 간식을 준다고 할 때 주어야 할 모든 간식의 양의 최솟값을 구하는 문제이다.

강아지들의 무게에 대한 값들을 압축해주면, 그 합들이 답이 된다.

예를 들어 N = 4이고 30 20 5 5라면, 이를 값 압축을 해주면 3 2 1 1이 되고, 간식을 이렇게 주면 된다.

따라서 이 경우 답은 3+2+1+1 = 7이 된다.

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

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

    int T; cin >> T;

    for(int t=1; t<=T; t++) {
        int N; cin >> N;

        vector<int> v(N), u(N);
        for(int i=0; i<N; i++) {
            cin >> v[i];
            u[i] = v[i];
        }

        sort(u.begin(), u.end());
        u.erase(unique(u.begin(), u.end()), u.end());

        vector<int> w(N);
        for(int i=0; i<v.size(); i++)
            w[i] = lower_bound(u.begin(), u.end(), v[i]) - u.begin() + 1;

        int ans = 0;

        for(int i=0; i<N; i++) ans += w[i];

        cout << "Case #" << t << ": " << ans << "\n";
    }
}

백준 BOJ 8641번 : Sklep

문제 난이도 : Silver IV

알고리즘 분류 : 해시를 사용한 집합과 맵

N개의 목록에 걸쳐 상품의 번호와 개수가 주어질 때, 상품의 번호가 한 번씩 나타나도록 하여 각 상품의 개수를 구하는 문제이다.

이 때 출력 순서는 해당 상품 번호가 먼저 나타난 순으로 출력해야 한다.

해시를 사용한 집합과 맵을 사용하여 풀이해줄 수 있다.

이전에 나온 적 없는 상품이면 벡터에 넣어주고, 마지막에 이 벡터에 나온 순서대로 맵의 값을 출력해주면 된다.

unordered_map을 사용하면 일반 map보다 2배 빠른 속도로 통과할 수 있다.

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

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

    int N; cin >> N;

    vector<int> v;
    unordered_map<int, int> m;

    while(N--) {
        int a, b; cin >> a >> b;

        if(m[a] == 0) v.push_back(a);

        m[a] += b;
    }

    cout << v.size() << "\n";

    for(int i=0; i<v.size(); i++)
        cout << v[i] << " " << m[v[i]] << "\n";
}

백준 BOJ 18881번 : Social Distancing II

문제 난이도 : Silver V

알고리즘 분류 : 정렬, 스위핑

N마리의 소가 있고, 각각 위치와 병에 걸린 여부(1 or 0)가 주어질 때 병 걸린 소는 특정 거리 (입력으로 주어지지 않음) 내에 있는 소들을 감염시킨다고 할 때, 최초에 감염되었을 수 있는 소의 최소 마리 수를 구하는 문제이다.

먼저 소들을 정렬해주고, 인접한 두 소들 중 한 마리만 병에 걸린 경우 감염 반경은 그 두 소의 거리 미만임을 알 수 있다.

따라서 모든 인접한 소들에 대해 이러한 검사를 해주어 r의 범위를 찾는다.

이제 병에 걸린 소들만 벡터에 저장한 뒤 인접한 소들 사이의 거리가 r보다 큰 경우 이들은 서로 다른 근원지에서 병이 걸렸음을 알 수 있으므로, 인접한 병 걸린 소들을 탐색하며 답에 1씩 추가해주면 된다.

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

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

    int N; cin >> N;

    vector<pair<int, int>> v(N);

    for(int i=0; i<N; i++)
        cin >> v[i].first >> v[i].second;

    sort(v.begin(), v.end());

    int r = INT_MAX;

    for(int i=1; i<N; i++)
        if(v[i-1].second != v[i].second)
            r = min(r, v[i].first - v[i-1].first - 1);

    vector<int> u;

    for(int i=0; i<N; i++)
        if(v[i].second == 1) u.push_back(v[i].first);

    int ans = 1;

    for(int i=1; i<u.size(); i++)
        if(u[i] - u[i-1] > r) ans++;

    cout << ans << "\n";
}

백준 BOJ 14567번 : 선수과목 (Prerequisite)

문제 난이도 : Gold V

알고리즘 분류 : 위상 정렬

M개의 순서쌍 (a, b)에 대해 a를 반드시 b보다 이전 학기에 들어야할 때, N개의 과목을 최소 학기에 모두 듣기 위해서는 각 과목들을 몇 학기에 들어야 하는지 구하는 문제이다.

위상 정렬 문제로, 기존 위상 정렬 코드에서 queue 부분에 학기만 기록할 수 있도록 해주면 된다.

최초로 queue에 넣은 과목들은 1학기에 듣고, 그 다음 push 되는 것들은 1학기 증가시켜서 저장하고, ... 이 과정을 반복하면 된다.

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

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

    int N, M; cin >> N >> M;

    vector<vector<int>> adj(N+1);
    vector<int> deg(N+1);

    while(M--) {
        int a, b; cin >> a >> b;

        adj[a].push_back(b);

        deg[b]++;
    }

    queue<int> q;
    vector<int> ans(N+1);

    for(int i=1; i<=N; i++)
        if(deg[i] == 0) {
            q.push(i);

            ans[i] = 1;
        }

    while(!q.empty()) {
        int x = q.front();
        q.pop();

        for(int i=0; i<adj[x].size(); i++) {
            int y = adj[x][i];

            deg[y]--;

            if(deg[y] == 0) {
                ans[y] = ans[x] + 1;
                q.push(y);
            }
        }
    }

    for(int i=1; i<=N; i++) cout << ans[i] << " ";
    cout << "\n";
}

백준 BOJ 2171번 : 직사각형의 개수

문제 난이도 : Gold IV

알고리즘 분류 : 자료 구조

2차원 좌표 평면 상에 주어진 N개의 점에 대해, 그들 중 4개를 선택하여 만들 수 있는 직사각형의 개수를 구하는 문제이다.

원래는 좌표 압축을 사용하여 풀이하려고 했는데, 더 좋은 풀이 겸 배울 게 많은 방법이 있어서 해당 방법으로 풀이해보았다.

set을 사용하면 log 시간에 데이터를 삽입, 삭제, 탐색할 수 있기 때문에 이런 문제를 짧은 코드로도 풀이할 수 있다.

아무튼 핵심 풀이는 set에 모든 좌표들을 넣고, 2중 for문으로 잡은 두 점을 직사각형의 대각선에 위치한 점이라고 보고 set에 나머지 두 점이 존재하는지를 찾는 것이다.

다만 이 경우 반대 대각선으로도 직사각형의 count가 한 번 더 일어나므로, count 된 값을 2로 나누어 정답을 얻어주면 된다.

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

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

    int N; cin >> N;

    vector<pair<int, int>> v;
    set<pair<int, int>> s;

    for(int i=0; i<N; i++) {
        int x, y; cin >> x >> y;

        v.push_back({x, y});
        s.insert({x, y});
    }

    int ans = 0;

    for(int i=0; i<N; i++)
        for(int j=i+1; j<N; j++) {
            if(v[i].first == v[j].first || v[i].second == v[j].second) continue;

            if(s.count({v[i].first, v[j].second}) > 0 && s.count({v[j].first, v[i].second})) ans++;
        }

    ans /= 2;

    cout << ans << "\n";
}

백준 BOJ 11830번 : Star triangles

문제 난이도 : Silver I

알고리즘 분류 : 해시를 사용한 집합과 맵

N개의 점의 좌표가 주어졌을 때, 그 중 3개를 선택하여 두 변이 x축, y축과 평행한 직각삼각형의 수를 구하는 문제이다.

어떤 점의 좌표에 대해서, x 좌표가 같은 점 1개와 y 좌표가 같은 점 1개를 선택해서 직각삼각형을 만들 수 있다.

따라서 map 2개를 선언하여 각 점들의 x 좌표와 y 좌표의 수를 저장하고, 각 점에 대해 위에서 말한대로 점 한 개씩을 선택해서 곱해주면 경우의 수가 된다. (물론 자기 자신에 해당하는 점 1개는 빼야한다.)

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

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

    int N; cin >> N;

    vector<pair<int, int>> v;
    unordered_map<int, int> mx, my;

    for(int i=0; i<N; i++) {
        int x, y; cin >> x >> y;

        v.push_back({x, y});

        mx[x]++;
        my[y]++;
    }

    int ans = 0;

    for(int i=0; i<N; i++) {
        ans += (mx[v[i].first] - 1) * (my[v[i].second] - 1);
    }

    cout << ans << "\n";
}

백준 BOJ 5971번 : Meeting Place

문제 난이도 : Gold V

알고리즘 분류 : LCA

N개의 노드를 가진 트리가 주어지고 M개의 쿼리에 대해 두 노드의 최소 공통 조상(LCA)을 구하는 문제이다.

N이 1,000 이하이므로 하나의 쿼리를 O(H) 시간에 처리하는 풀이로 풀어도 되지만, log(H) 시간 LCA 알고리즘을 다시 작성해보는 겸 로그 시간 풀이로 풀이하였다.

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

vector<vector<int>> adj, par, dis;
vector<int> dep;

void fp(int p, int x, int d) {
    if(adj[x].size() == 0) return;

    par[x][0] = p;
    dep[x] = d;

    for(int i=0; i<adj[x].size(); i++) {
        int y = adj[x][i];

        if(y != p) fp(x, y, d+1);
    }
}

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

    int N, M; cin >> N >> M;

    adj.resize(N+1);

    for(int i=2; i<=N; i++) {
        int x; cin >> x;

        adj[i].push_back(x);
        adj[x].push_back(i);
    }

    par.resize(N+1, vector<int>(30));
    dep.resize(N+1);

    fp(0, 1, 0);

    int H = (int)floor(log2(N+1));

    dis.resize(N+1, vector<int>(30));

    for(int i=1; i<=H; i++)
        for(int j=2; j<=N; j++)
            if(par[j][i-1] != 0) {
                par[j][i] = par[par[j][i-1]][i-1];
                dis[j][i] = dis[j][i-1] + dis[par[j][i-1]][i-1];
            }

    while(M--) {
        int a, b; cin >> a >> b;

        if(dep[a] != dep[b]) {
            if(dep[a] < dep[b]) swap(a, b);

            int diff = dep[a] - dep[b];

            for(int i=0; diff>0; i++) {
                if(diff % 2 == 1) a = par[a][i];

                diff /= 2;
            }
        }

        if(a != b) {
            for(int i=H; i>=0; i--)
                if(par[a][i] != 0 && par[a][i] != par[b][i]) {
                    a = par[a][i];
                    b = par[b][i];
                }

            a = par[a][0];
        }

        cout << a << "\n";
    }
}

백준 BOJ 문제 풀이 모음 : 그래프와 인접 행렬의 활용 220818

restudy — Thu, 18 Aug 2022 12:10:49 +0900

백준 BOJ 17272번 : 리그 오브 레전설 (Large)

문제 난이도 : Gold I

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

N초를 길이가 1초인 스킬과 길이가 M초인 스킬로 구성하는 방법의 수를 구하는 문제이다.

dp[N] = dp[N-1] + dp[N-M]이라는 점화식을 세울 수 있다.

그러나 Large 문제에서는 N이 10^18 이하이므로 dp로는 풀이가 불가능하다.

따라서 점화식을 행렬로 구성하여 행렬의 거듭제곱으로 답을 구해주어야 한다.

위와 같이 점화식을 만들 수 있다.

참고로 M이 100 이하이므로, 행렬의 크기는 아무리 커도 100 x 100을 넘어가지 않는다.

위의 A 행렬을 N 제곱 해주면, 곱해지는 행렬은 a_0, a_-1, ...으로 구성되는데, 정의에 의해 a_0 = 1이고 그 외에는 0이다. (상식적으로 생각해보면 된다.)

따라서 a_N은 A^N의 0행 0열 원소가 된다.

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

typedef vector<vector<int>> mat;
int N, ex, mod = 1e9 + 7;

mat f(mat& v, mat& u) {
    mat w(N, vector<int>(N));

    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
            for(int k=0; k<N; k++)
                w[i][j] = (w[i][j] + v[i][k] * u[k][j]) % mod;

    return w;
}

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

    cin >> ex >> N;

    mat ba(N, vector<int>(N));

    ba[0][0] = ba[0][N-1] = 1;

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

    mat v(N, vector<int>(N));
    for(int i=0; i<N; i++) v[i][i] = 1;

    while(ex > 0) {
        if(ex % 2 == 1) v = f(v, ba);

        ba = f(ba, ba);
        ex /= 2;
    }

    cout << v[0][0] << "\n";
}

참고로 이 문제의 풀이와 같은 풀이로 백준 BOJ 17271번 : 리그 오브 레전설 (Small)을 풀이할 수 있다.

백준 BOJ 19587번 : 객실 배치

문제 난이도 : Gold I

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

한 층에 2호까지 있는 N층의 객실들에 대해, 위 아래 또는 1, 2호 모두에 손님이 있지 않도록 배치하는 경우의 수를 구하는 문제이다.

한 층의 객실 배치를 0, 1, 2의 세 가지로 나누어 점화식을 세워보면 위와 같이 되고, 이는 행렬로 나타낼 수 있으며 N-1 제곱을 하여 모든 원소의 합을 통해 경우의 수를 구할 수 있다.

행렬의 log 시간 거듭 제곱을 구현하여 답을 구해주면 된다.

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

typedef vector<vector<int>> mat;
int N = 3, ex, mod = 1e9 + 7;

mat f(mat& v, mat& u) {
    mat w(N, vector<int>(N));

    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
            for(int k=0; k<N; k++)
                w[i][j] = (w[i][j] + v[i][k] * u[k][j]) % mod;

    return w;
}

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

    cin >> ex;

    mat ba(N, vector<int>(N));

    ba = {{1, 1, 1},
          {1, 0, 1},
          {1, 1, 0}};

    mat v(N, vector<int>(N));
    for(int i=0; i<N; i++) v[i][i] = 1;

    ex--;

    while(ex > 0) {
        if(ex % 2 == 1) v = f(v, ba);

        ba = f(ba, ba);
        ex /= 2;
    }

    int ans = 0;

    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++) ans = (ans + v[i][j]) % mod;

    cout << ans << "\n";
}

백준 BOJ 16467번 : 병아리의 변신은 무죄

문제 난이도 : Gold I

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

모든 병아리는 매일 알을 하나씩 낳고, 각 알은 K일 후에 병아리가 된다고 할 때, N일 후 병아리의 수를 구하는 문제이다.

점화식을 세워보면 dp[i] = dp[i-1] + dp[i-1-K]이다. (dp[0] = 1, dp[i] (i < 0) = 0)

이제 나머지는 위의 백준 BOJ 17272번 문제와 똑같이 풀어주면 된다.

주의할 점은 mod 값이 1e9 + 7이 아닌 1e8 + 7이다.

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

typedef vector<vector<int>> mat;
int N, ex, mod = 1e8 + 7;

mat f(mat& v, mat& u) {
    mat w(N, vector<int>(N));

    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
            for(int k=0; k<N; k++)
                w[i][j] = (w[i][j] + v[i][k] * u[k][j]) % mod;

    return w;
}

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

    int T; cin >> T;

    while(T--) {
        cin >> N >> ex;

        N++;

        mat ba(N, vector<int>(N));

        ba[0][0]++;
        ba[0][N-1]++;

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

        mat v(N, vector<int>(N));
        for(int i=0; i<N; i++) v[i][i] = 1;

        while(ex > 0) {
            if(ex % 2 == 1) v = f(v, ba);

            ba = f(ba, ba);
            ex /= 2;
        }

        cout << v[0][0] << "\n";
    }
}

백준 BOJ 23819번 : 묻고 더블로 마셔

문제 난이도 : Gold I

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

1~k번째 사람이 각자 마실 양이 주어지고, k+1번째부터 N번째 사람까지는 i-1, i-2, ..., i-k번째 사람이 마신 양을 합친 것을 P로 나눈 값을 마신다고 할 때 N번째 사람이 마시는 양을 구하는 문제이다.

맨 위에서 풀이한 문제와 비슷한 방식으로 풀이할 수 있다.

이 문제는 심지어 a_1 ~ a_k 값을 모두 주기 때문에 예외 처리가 어렵지 않다.

백준 BOJ 2099번 : The game of death

문제 난이도 : Gold I

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

N명이 각자 2명의 사람을 지목하고, a번째 사람에서 시작해서 가리키는 사람을 K번 따라갔을 때 b번째 사람으로 도달하는 경우가 있는지를 판별하는 쿼리를 M개 처리하는 문제이다.

인접 행렬을 이용하여 풀이할 수 있다.

예를 들어 a번 사람이 b번 사람을 가리킨다면, ba[a][b] = 1로 설정한다.

그 다음 이 행렬을 K번 거듭제곱 해주면 된다.

이 때 수가 매우 커질 수 있으므로 값을 더해주지는 말고 0보다 큰 경우는 1로 처리해준다.

K번 거듭제곱 이후 ba[a][b] = 1이면 a에서 K번 이동하여 b로 이동이 가능한 것이다.

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

typedef vector<vector<int>> mat;
int N, M, K, ex;

mat f(mat& v, mat& u) {
    mat w(N, vector<int>(N));

    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
            for(int k=0; k<N; k++)
                if(v[i][k] == 1 && u[k][j] == 1) w[i][j] = 1;

    return w;
}

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

    cin >> N >> K >> M;

    mat ba(N, vector<int>(N));

    for(int i=0; i<N; i++) {
        int a, b; cin >> a >> b;

        ba[i][a-1] = ba[i][b-1] = 1;
    }

    mat v(N, vector<int>(N));
    for(int i=0; i<N; i++) v[i][i] = 1;

    ex = K;

    while(ex > 0) {
        if(ex % 2 == 1) v = f(v, ba);

        ba = f(ba, ba);
        ex /= 2;
    }

    while(M--) {
        int a, b; cin >> a >> b;

        if(v[a-1][b-1] > 0) cout << "death\n";
        else cout << "life\n";
    }
}

백준 BOJ 11767번 : Squawk Virus

문제 난이도 : Gold I

알고리즘 분류 : 그래프 이론, 분할 정복을 이용한 거듭제곱

그래프가 주어지고, 바이러스가 처음에 K번 노드에 1개 생성되며 바이러스 1개는 1초마다 인접한 칸들로 모두 복사된다고 할 때, t초 후 총 바이러스의 개수를 구하는 문제이다.

K번 노드에서 t번 이동을 거쳐 도달할 수 있는 모든 경로의 수를 구해주면 된다.

위의 문제와 비슷하게 인접 행렬 세팅을 하여 t번 거듭제곱 해준 뒤, v[K][i]들의 합을 구해주면 된다.

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

typedef vector<vector<int>> mat;
int N, M, K, ex;

mat f(mat& v, mat& u) {
    mat w(N, vector<int>(N));

    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
            for(int k=0; k<N; k++) w[i][j] += v[i][k] * u[k][j];

    return w;
}

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

    cin >> N >> M >> K >> ex;

    mat ba(N, vector<int>(N));

    while(M--) {
        int a, b; cin >> a >> b;

        ba[a][b] = ba[b][a] = 1;
    }

    mat v(N, vector<int>(N));
    for(int i=0; i<N; i++) v[i][i] = 1;

    while(ex > 0) {
        if(ex % 2 == 1) v = f(v, ba);

        ba = f(ba, ba);
        ex /= 2;
    }

    int ans = 0;

    for(int i=0; i<N; i++) ans += v[K][i];

    cout << ans << "\n";
}

백준 BOJ 12916번 : K-Path

문제 난이도 : Gold I

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

N x N 크기의 인접 행렬이 주어질 때, 길이가 M인 경로의 개수를 구하는 문제이다.

인접 행렬을 M번 거듭제곱하여 나타나는 모든 원소의 합을 구해주면 된다.

원리는 위의 문제들과 동일하다.

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

typedef vector<vector<int>> mat;
int N, ex, mod = 1e9 + 7;

mat f(mat& v, mat& u) {
    mat w(N, vector<int>(N));

    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
            for(int k=0; k<N; k++)
                w[i][j] = (w[i][j] + v[i][k] * u[k][j]) % mod;

    return w;
}

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

    cin >> N >> ex;

    mat ba(N, vector<int>(N));

    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++) cin >> ba[i][j];

    mat v(N, vector<int>(N));
    for(int i=0; i<N; i++) v[i][i] = 1;

    while(ex > 0) {
        if(ex % 2 == 1) v = f(v, ba);

        ba = f(ba, ba);
        ex /= 2;
    }

    int ans = 0;

    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++) ans = (ans + v[i][j]) % mod;

    cout << ans << "\n";
}

백준 BOJ 24731번 : XOR-ABC

문제 난이도 : Gold I

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

N자리 이진수 a, b, c에 대해 1 ≤ a < b < c ≤ 2^N - 1이고 A ^ B = C인 (A, B, C) 순서쌍의 개수를 구하는 문제이다.

내키는 방법은 아니지만 정 풀이가 어려우면 완전 탐색으로 작은 N 이하에 대해 수열을 구해보고, 규칙을 찾는 방법이 있다.

코드를 돌려보면 0, 1, 7, 35, 155, ...의 수열이 얻어진다.

규칙을 직접 찾아도 되고 OEIS를 이용해도 되는데, 아무튼 f(N) = (2^n - 1) x (2^(n-1) - 1) / 3이다.

이를 분할 정복을 이용한 거듭제곱과 페르마의 소정리를 이용해서 풀어주면 된다.

정석적인 풀이는 잘 모르겠는데, 다시 풀게 되면 정리하겠다.

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

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

    int N; cin >> N;

    int a = 1, ba = 2, ex = N, mod = 1e6 + 3;

    while(ex > 0) {
        if(ex % 2 == 1) a = (a * ba) % mod;

        ba = (ba * ba) % mod;
        ex /= 2;
    }

    int b = 1; ba = 2, ex = N-1;

    while(ex > 0) {
        if(ex % 2 == 1) b = (b * ba) % mod;

        ba = (ba * ba) % mod;
        ex /= 2;
    }

    int ans = ((a - 1) * (b - 1)) % mod;

    ba = 3, ex = mod - 2;

    while(ex > 0) {
        if(ex % 2 == 1) ans = (ans * ba) % mod;

        ba = (ba * ba) % mod;
        ex /= 2;
    }

    cout << ans << "\n";
}

백준 BOJ 11440번 : 피보나치 수의 제곱의 합

문제 난이도 : Platinum V

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

주어진 N에 대해 0번째 피보나치 수부터 N번째 피보나치 수의 합을 구하는 문제이다.

이 때 N은 10^18 이하이다.

10^18 이하인 N에 대해 N번째 피보나치 수는 O(log N) 시간에 구할 수 있지만, 피보나치 수의 제곱의 합을 구하기 위해 각 항을 일일이 구하게 되면 N log N 시간이 걸려 당연히 시간 초과이다.

따라서 수열을 가지고 규칙성을 찾아보자.

아래의 코드를 돌려 N = 10 이하에서의 수열을 확인해보자. (정답 코드 아님)

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

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

    int N; cin >> N;

    vector<int> v(N+1);
    v[1] = 1;

    for(int i=2; i<=N; i++) v[i] = v[i-1] + v[i-2];

    int sum = 0;

    for(int i=1; i<=N; i++) {
        sum += v[i] * v[i];

        cout << i << " : " << sum << "\n";
    }
}

실행시켜보면 결과는 다음과 같다.

규칙을 찾아보면, i번째 피보나치 수를 g(i)라고 했을 때 f(N) = g(N) x g(N+1)임을 확인할 수 있다.

따라서 두 피보나치 수를 분할 정복을 이용한 거듭제곱으로 구해서 곱해주면 된다.

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

typedef vector<vector<int>> mat;
int mod = 1e9 + 7;

mat f(mat& v, mat& u) {
    int N = 2;
    mat w(N, vector<int>(N));

    for(int i=0; i<v.size(); i++)
        for(int j=0; j<u[0].size(); j++)
            for(int k=0; k<v[0].size(); k++)
                w[i][j] = (w[i][j] + v[i][k] * u[k][j]) % mod;

    return w;
}

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

    int M; cin >> M;

    vector<int> v(2);

    for(int t=0; t<2; t++) {
        int N = M + t;

        mat mul(2, vector<int>(2));
        for(int i=0; i<2; i++) mul[i][i] = 1;

        mat ba(2, vector<int>(2));
        ba = {{1, 1}, {1, 0}};

        while(N > 0) {
            if(N % 2 == 1) mul = f(mul, ba);

            ba = f(ba, ba);
            N /= 2;
        }

        v[t] = mul[0][1];
    }

    int ans = (v[0] * v[1]) % mod;

    cout << ans << "\n";
}

백준 BOJ 빠른 거듭제곱 알고리즘 (인접 행렬 활용 등) 문제 풀이 모음

restudy — Wed, 17 Aug 2022 12:04:07 +0900

백준 BOJ 12987번 : Matrix Again

문제 난이도 : Gold II

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

주어진 행렬 A에 대해, S = A + A^2 + ... + A^K를 구하는 문제이다.

단일 행렬에 대한 거듭제곱은 N^2 log K 시간에 구할 수 있으나, 식 S의 경우에는 그러한 방식을 쓰더라도 결국 각 항을 따로 구하면 시간 복잡도가 늘어난다.

따라서 이 문제에서는 점화식을 사용하여 분할 정복으로 문제를 풀어주어야 되는데, 점화식은 다음과 같다.

위와 같이 점화식을 세우면 K를 계속해서 2로 나눠가면서 log 시간 복잡도로 식의 값을 구할 수 있다.

이 때 ( i ) 케이스의 A^(K/2)는 분할 정복을 이용한 거듭제곱 알고리즘을 사용하여 log(K) 시간에 구해준다.

구현해야 하는 함수가 많아서 복잡할 수 있지만, 어떤 부분을 나눠야 하는지 잘 생각하면서 하면 구현할 수 있을 것이다.

참고로 시간 초과가 발생할 수 있는데, 아래 코드의 mul 함수에서 mod 처리를 하는 과정이 요인이 될 수 있다.

예를 들어 w[i][j] = (w[i][j] + v[i][k] * u[k][j]) % mod와 같이 식을 세울 경우, 단일 덧셈마다 mod 처리를 하여 N^3번의 나눗셈이 발생하는데, 이를 줄이기 위해 k에 대한 루프가 끝난 이후에 한 번만 나누도록 해주면 시간을 많이 단축시킬 수 있다.

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

typedef vector<vector<int>> mat;

int N, K, mod;

mat mul(mat v, mat u) {
    mat w(N, vector<int>(N));

    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++) {
            for(int k=0; k<N; k++) w[i][j] += v[i][k] * u[k][j];

            w[i][j] %= mod;
        }

    return w;
}

mat fpow(mat ba, int K) {
    mat v(N, vector<int>(N));

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

    while(K > 0) {
        if(K % 2 == 1) v = mul(v, ba);

        ba = mul(ba, ba);
        K /= 2;
    }

    return v;
}

mat f(mat ba, int K) {
    if(K == 1) return ba;

    if(K % 2 == 0) {
        mat v = f(ba, K/2);
        mat u = fpow(ba, K/2);

        for(int i=0; i<N; i++) u[i][i] = (u[i][i] + 1) % mod;

        mat w = mul(v, u);

        return w;
    }

    if(K % 2 == 1) {
        mat v = f(ba, K-1);
        mat u = fpow(ba, K);

        for(int i=0; i<N; i++)
            for(int j=0; j<N; j++)
                v[i][j] = (v[i][j] + u[i][j]) % mod;

        return v;
    }
}

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

    cin >> N >> K >> mod;

    mat v(N, vector<int>(N));

    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++) {
            cin >> v[i][j];

            v[i][j] = ((v[i][j] % mod) + mod) % mod;
        }

    mat ans = f(v, K);

    for(int i=0; i<N; i++) {
        for(int j=0; j<N; j++) cout << ans[i][j] << " ";

        cout << "\n";
    }
}

백준 BOJ 13246번 : 행렬 제곱의 합

문제 난이도 : Gold II

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

위의 문제와 동일한 문제이다.

풀이도 같으나, mod 부분만 변수가 아닌 고정값 1,000으로 수정해서 풀이해주면 된다.

중복되는 부분이 많아 풀이 코드는 아래의 접은 글에 정리해두었다.

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

typedef vector<vector<int>> mat;

int N, K, mod = 1e3;

mat mul(mat v, mat u) {
    mat w(N, vector<int>(N));

    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++) {
            for(int k=0; k<N; k++) w[i][j] += v[i][k] * u[k][j];

            w[i][j] %= mod;
        }

    return w;
}

mat fpow(mat ba, int K) {
    mat v(N, vector<int>(N));

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

    while(K > 0) {
        if(K % 2 == 1) v = mul(v, ba);

        ba = mul(ba, ba);
        K /= 2;
    }

    return v;
}

mat f(mat ba, int K) {
    if(K == 1) return ba;

    if(K % 2 == 0) {
        mat v = f(ba, K/2);
        mat u = fpow(ba, K/2);

        for(int i=0; i<N; i++) u[i][i] = (u[i][i] + 1) % mod;

        mat w = mul(v, u);

        return w;
    }

    if(K % 2 == 1) {
        mat v = f(ba, K-1);
        mat u = fpow(ba, K);

        for(int i=0; i<N; i++)
            for(int j=0; j<N; j++)
                v[i][j] = (v[i][j] + u[i][j]) % mod;

        return v;
    }
}

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

    cin >> N >> K;

    mat v(N, vector<int>(N));

    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++) {
            cin >> v[i][j];

            v[i][j] = ((v[i][j] % mod) + mod) % mod;
        }

    mat ans = f(v, K);

    for(int i=0; i<N; i++) {
        for(int j=0; j<N; j++) cout << ans[i][j] << " ";

        cout << "\n";
    }
}

백준 BOJ 15712번 : 등비수열

문제 난이도 : Gold II

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

첫 항이 a, 공비가 r, 항의 수가 N인 등비수열의 합을 mod로 나눈 나머지를 구하는 문제이다.

만약 mod 값이 소수였다면, 등비수열의 합 공식을 사용한 뒤 페르마의 소정리를 사용하여 아주 간단하게 풀이할 수 있다.

그러나 여기서는 그러한 조건이 없으므로, 직접 항들을 계산하는 방식을 생각해보아야 한다.

위에서 사용한 분할 정복의 방식을 사용하면, 항의 개수의 log 값에 비례한 수행 시간으로 답을 얻을 수 있다.

구현 자체도 거의 비슷하고, 행렬 대신 정수에 대한 연산이므로 비교적 간단하게 풀이할 수 있다.

참고로 위에서 풀이한 방식대로 하면 N = 1인 경우 무한 루프를 돌게 된다.

따라서 N = 1인 경우 a % mod를 답으로 출력하여 예외 처리를 해주도록 한다.

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

int a, r, N, mod;

int fpow(int ba, int ex) {
    int val = 1;

    while(ex > 0) {
        if(ex % 2 == 1) val = (val * ba) % mod;

        ba = (ba * ba) % mod;
        ex /= 2;
    }

    return val;
}

int f(int ba, int ex) {
    if(ex == 1) return ba;

    if(ex % 2 == 0) {
        int a = f(ba, ex/2);
        int b = fpow(ba, ex/2);

        return (a * (b + 1)) % mod;
    }

    if(ex % 2 == 1) {
        int a = f(ba, ex-1);
        int b = fpow(ba, ex);

        return (a + b) % mod;
    }
}

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

    cin >> a >> r >> N >> mod;

    if(N == 1) {
        cout << a % mod << "\n";

        return 0;
    }

    int ans = f(r % mod, N-1);

    ans = ((ans + 1) * a) % mod;

    cout << ans << "\n";
}

백준 BOJ 12850번 : 본대 산책2

문제 난이도 : Gold I

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

위와 같은 그래프가 주어질 때, 정보과학관에서 출발하여 N번 이동 후 다시 정보과학관으로 돌아오는 경우의 수를 구하는 문제이다.

8 x 8 크기의 인접 그래프를 만들어 준 뒤, 이를 N 제곱했을 때 얻어지는 행렬의 원소 a_ij는 i번 노드에서 인접한 노드로 N번 이동하여 j번 노드에 도달하는 경우의 수가 된다.

왜냐하면 예를 들어 행렬을 2번 곱, 즉 제곱했다면 a_ij는 모든 k에 대한 a_ik * a_kj이므로, i에서 k로 이동하는 경우의 수에 k에서 j로 이동하는 경우의 수의 합인 것이다.

이러한 방식을 귀납적으로 생각해보면 인접 행렬을 N 제곱해주면 결국 a_ij는 i번 노드에서 인접한 노드로 N번 이동하여 j번 노드에 도달하는 경우의 수가 된다.

따라서 주어진 그래프의 번호만 편한대로 적절히 매겨서 빠른 거듭 제곱을 해준 뒤, 정보과학관에서 정보과학관으로 이동하는 것이므로 해당하는 원소를 답으로 얻어주면 된다.

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

typedef vector<vector<int>> mat;
int N = 8, ex, mod = 1e9 + 7;

mat f(mat& v, mat& u) {
    mat w(N, vector<int>(N));

    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
            for(int k=0; k<N; k++)
                w[i][j] = (w[i][j] + v[i][k] * u[k][j]) % mod;

    return w;
}

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

    cin >> ex;

    mat v(N, vector<int>(N));
    for(int i=0; i<N; i++) v[i][i] = 1;

    mat ba(N, vector<int>(N));

    ba = {{0, 1, 1, 0, 0, 0, 0, 0},
          {1, 0, 1, 1, 0, 0, 0, 0},
          {1, 1, 0, 1, 1, 0, 0, 0},
          {0, 1, 1, 0, 1, 1, 0, 0},
          {0, 0, 1, 1, 0, 1, 0, 1},
          {0, 0, 0, 1, 1, 0, 1, 0},
          {0, 0, 0, 0, 0, 1, 0, 1},
          {0, 0, 0, 0, 1, 0, 1, 0}};

    while(ex > 0) {
        if(ex % 2 == 1) v = f(v, ba);

        ba = f(ba, ba);
        ex /= 2;
    }

    cout << v[0][0] << "\n";
}

백준 BOJ 14289번 : 본대 산책3

문제 난이도 : Gold I

알고리즘 분류 : 그래프 이론, 분할 정복을 이용한 거듭제곱

위의 문제와 동일하나, 노드의 수와 그래프의 간선들, 그리고 시간을 변수로 주는 문제이다.

이번에는 인접 행렬을 변수로 받아주면 된다.

N x N 크기의 인접 행렬을 만들고, a번 노드와 b번 사이에 직접적인 간선이 존재한다면 v[a][b] = v[b][a] = 1로 설정해주면 된다.

원래라면 ++ 연산을 해주어야겠지만 이 문제에서는 같은 간선이 두 개 이상 나오지 않는다고 보장해주었으므로 위와 같이 작성해도 된다.

나머지 구현은 본대 산책2 문제와 동일하다.

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

typedef vector<vector<int>> mat;
int N, M, ex, mod = 1e9 + 7;

mat f(mat& v, mat& u) {
    mat w(N, vector<int>(N));

    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
            for(int k=0; k<N; k++)
                w[i][j] = (w[i][j] + v[i][k] * u[k][j]) % mod;

    return w;
}

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

    cin >> N >> M;

    mat v(N, vector<int>(N));
    for(int i=0; i<N; i++) v[i][i] = 1;

    mat ba(N, vector<int>(N));

    while(M--) {
        int a, b; cin >> a >> b;

        ba[a-1][b-1] = ba[b-1][a-1] = 1;
    }

    cin >> ex;

    while(ex > 0) {
        if(ex % 2 == 1) v = f(v, ba);

        ba = f(ba, ba);
        ex /= 2;
    }

    cout << v[0][0] << "\n";
}

백준 BOJ 15824번 : 너 봄에는 캡사이신이 맛있단다

문제 난이도 : Gold II

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

N개의 수 중에서 부분 수열을 골랐을 때, 그 부분 수열의 최댓값에서 최솟값을 뺀 값이 주헌고통지수라고 할 때, 가능한 모든 조합의 주헌고통지수의 합을 구하는 문제이다.

문제에서 정의된 주헌고통지수는 오직 부분 수열의 최대/최소에만 영향이 있으므로, 수열을 정렬한 뒤 생각해도 답에는 영향이 없다. 따라서 우선 수열을 정렬하고 생각해보자.

그 다음 최솟값이 l번째이고, 최댓값이 r번째인 부분 수열을 생각해보면 [v_l , ... , v_r]인 수열의 종류는 l+1, ... , r-1번째 수를 각각 선택 또는 선택하지 않을 수 있으므로 2^(r - l - 1)가지이고 주헌고통지수의 합은 2^(r - l - 1) x (v_r - v_l)이다.

이제 r - l이 같은 값들에 대해 모든 조합들을 생각해보자.

예를 들어 r - l = 1인 조합들에 대해서 생각해보면, 이들의 합은 2^(1 - 1) x (v_2 - v_1 + v_3 - v_2 + ... + v_N - v_(N-1)) = v_N - v_1이다.

r - l = 2인 조합들에 대해 생각해보면, 이들의 합은 2^(2 - 1) x (v_3 - v_1 + v_4 - v_2 + ... + v_N - v_(N-2)) = 2 x (v_N + v_(N-1) - v_2 - v_1)이다.

규칙을 보면 2^(r - l - 1) x (v_N + ... + v_(N - (r - l + 1)) - (v_1 + v_2 + ... + v_(r - l))이 된다.

이제 이 식을 r - l 으로 나올 수 있는 값인 1 ~ N-1에 대해 모두 더해주면 된다.

식을 잘 정리하면 풀이 코드를 아래와 같이 정리할 수 있는데, 이는 아래의 내 풀이를 직접 참고하는 것을 추천한다. (누적 합을 사용하면 조금 간단하게 풀이할 수 있다.)

참고로 모듈로 연산을 잘못 할 경우 음수가 나오거나 하여 WA를 받을 수 있다.

모듈로는 정렬이 끝나고, 각 연산에 대해 v_r - v_l을 구한 뒤부터 해주도록 하자.

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

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

    int N; cin >> N;

    int mod = 1e9 + 7;

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

    sort(v.begin(), v.end());

    vector<int> u(N); u[0] = v[0];
    for(int i=1; i<N; i++) u[i] = u[i-1] + v[i];

    vector<int> w(N); w[N-1] = v[N-1];
    for(int i=N-2; i>=0; i--) w[i] = w[i+1] + v[i];

    int ans = 0;

    for(int i=0; i<N; i++) {
        int val = (w[N-1-i] - u[i]) % mod, ba = 2, ex = i;

        while(ex > 0) {
            if(ex % 2 == 1) val = (val * ba) % mod;

            ba = (ba * ba) % mod;
            ex /= 2;
        }

        ans = (ans + val) % mod;
    }

    cout << ans << "\n";
}

백준 BOJ 13075번 : Fibonacci Sequence

문제 난이도 : Gold II

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

피보나치 수열의 N번째 항을 구하는 문제이다. (mod 1e9)

단순히 행렬의 거듭제곱을 이용하여 답을 구해주면 된다.

이전에 많이 다루었던 문제들이므로 설명은 생략하며, 역시 접은 글에 풀이 코드를 첨부한다.

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

typedef vector<vector<int>> mat;
int mod = 1e9;

mat f(mat& v, mat& u) {
    int N = 2;
    mat w(N, vector<int>(N));

    for(int i=0; i<v.size(); i++)
        for(int j=0; j<u[0].size(); j++)
            for(int k=0; k<v[0].size(); k++)
                w[i][j] = (w[i][j] + v[i][k] * u[k][j]) % mod;

    return w;
}

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

    int T; cin >> T;

    while(T--) {
        int N; cin >> N;

        mat mul(2, vector<int>(2));
        for(int i=0; i<2; i++) mul[i][i] = 1;

        mat ba(2, vector<int>(2));
        ba = {{1, 1}, {1, 0}};

        while(N > 0) {
            if(N % 2 == 1) mul = f(mul, ba);

            ba = f(ba, ba);
            N /= 2;
        }

        cout << mul[0][1] << "\n";
    }
}

백준 BOJ 2086번 : 피보나치 수의 합

문제 난이도 : Gold I

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

피보나치 수열의 1항을 1, 2항을 1이라고 할 때, a, b에 대해 a번째부터 b번째 피보나치 수의 합을 구하는 문제이다.

먼저 다음 코드로 피보나치 수열과 1 ~ i번째 항의 합을 두 줄에 걸쳐 나타내어보면 다음과 같다.

코드는 접은 글에 있다. (정답 코드 아님)

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

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

    int N; cin >> N;

    vector<int> v(N+1);
    v[1] = 1;

    for(int i=2; i<=N; i++) v[i] = v[i-1] + v[i-2];

    for(int i=1; i<=N; i++) printf("%5d", v[i]);
    printf("\n");

    for(int i=1; i<=N; i++) {
        v[i] += v[i-1];

        printf("%5d", v[i]);
    }
}

규칙성을 찾아보면, 1 ~ N번째 피보나치 수열의 합은 N+2번째 피보나치 수 - 1임을 알 수 있다.

따라서 분할 정복을 이용한 거듭제곱을 이용하여 (b+2번째 피보나치 수 - 1) - (a+2-1번째 피보나치 수 - 1) = (b+2번째 피보나치 수 ) - (a+1번째 피보나치 수)를 답으로 구해주면 된다.

이 때 모듈로에 의해 뒤의 수가 더 클 수도 있으므로, 모듈로를 한 번 더한 뒤 모듈로 처리를 해주면 된다.

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

typedef vector<vector<int>> mat;
int mod = 1e9;

mat f(mat& v, mat& u) {
    int N = 2;
    mat w(N, vector<int>(N));

    for(int i=0; i<v.size(); i++)
        for(int j=0; j<u[0].size(); j++)
            for(int k=0; k<v[0].size(); k++)
                w[i][j] = (w[i][j] + v[i][k] * u[k][j]) % mod;

    return w;
}

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

    vector<int> v(2);
    for(int i=0; i<2; i++) cin >> v[i];

    v[0] += 2 - 1;
    v[1] += 2;

    vector<int> u(2);

    for(int t=0; t<2; t++) {
        int N = v[t];

        mat mul(2, vector<int>(2));
        for(int i=0; i<2; i++) mul[i][i] = 1;

        mat ba(2, vector<int>(2));
        ba = {{1, 1}, {1, 0}};

        while(N > 0) {
            if(N % 2 == 1) mul = f(mul, ba);

            ba = f(ba, ba);
            N /= 2;
        }

        u[t] = mul[0][1];
    }

    int ans = (u[1] - u[0] + mod) % mod;

    cout << ans << "\n";
}

백준 BOJ 11238번 : Fibo

문제 난이도 : Gold I

알고리즘 분류 : 정수론, 분할 정복을 이용한 거듭제곱

10억 이하의 a 또는 b에 대해 a번째 피보나치 수와 b번째 피보나치 수의 최대공약수를 구하는 문제이다.

우리는 분할 정복을 이용한 거듭제곱으로 a 또는 b번째 피보나치 수를 구할 수는 있으나, 모듈로 연산을 해버리면 gcd 값이 달라지므로 다른 방법을 생각해야 한다.

피보나치 수의 성질 중 하나로 a번째 피보나치 수와 b번째 피보나치 수의 최대공약수는 (a와 b의 최대공약수)번째 피보나치수임을 만족한다.

증명 과정을 읽어봤는데 a와 b에 대해 유클리드 호제법을 사용함과 동시에 몇 가지 Lemma들을 사용하여 증명한다.

이러한 성질은 분명 중요하지만, 이런 증명 과정 자체가 PS에서 자주 사용되지는 않는다고 생각하기에 여기서는 증명 과정 없이 이러한 성질을 활용하여 풀이한 코드만 첨부한다.

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

typedef vector<vector<int>> mat;
int mod = 1e9 + 7;

mat f(mat& v, mat& u) {
    int N = 2;
    mat w(N, vector<int>(N));

    for(int i=0; i<v.size(); i++)
        for(int j=0; j<u[0].size(); j++)
            for(int k=0; k<v[0].size(); k++)
                w[i][j] = (w[i][j] + v[i][k] * u[k][j]) % mod;

    return w;
}

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

    int T; cin >> T;

    while(T--) {
        int a, b; cin >> a >> b;

        int N = __gcd(a, b);

        mat mul(2, vector<int>(2));
        for(int i=0; i<2; i++) mul[i][i] = 1;

        mat ba(2, vector<int>(2));
        ba = {{1, 1}, {1, 0}};

        while(N > 0) {
            if(N % 2 == 1) mul = f(mul, ba);

            ba = f(ba, ba);
            N /= 2;
        }

        cout << mul[0][1] << "\n";
    }
}

백준 BOJ 11778번 : 피보나치 수와 최대공약수

문제 난이도 : Gold I

알고리즘 분류 : 정수론, 분할 정복을 이용한 거듭제곱

위의 문제와 동일한 문제이다. (문제 언어만 다르다.)

같은 방식으로 풀이해주되, 테스트케이스 처리부만 제거해주면 된다.

중복 문제이므로 접은 글에 풀이 코드를 첨부한다.

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

typedef vector<vector<int>> mat;
int mod = 1e9 + 7;

mat f(mat& v, mat& u) {
    int N = 2;
    mat w(N, vector<int>(N));

    for(int i=0; i<v.size(); i++)
        for(int j=0; j<u[0].size(); j++)
            for(int k=0; k<v[0].size(); k++)
                w[i][j] = (w[i][j] + v[i][k] * u[k][j]) % mod;

    return w;
}

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

    int a, b; cin >> a >> b;

    int N = __gcd(a, b);

    mat mul(2, vector<int>(2));
    for(int i=0; i<2; i++) mul[i][i] = 1;

    mat ba(2, vector<int>(2));
    ba = {{1, 1}, {1, 0}};

    while(N > 0) {
        if(N % 2 == 1) mul = f(mul, ba);

        ba = f(ba, ba);
        N /= 2;
    }

    cout << mul[0][1] << "\n";
}

백준 BOJ 16134번 : 조합 (Combination)

문제 난이도 : Gold I

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

N C M mod 1e9 + 7을 구하는 문제이다. 이 때 0 ≤ M ≤ N ≤ 1,000,000이다.

단순히 페르마의 소정리를 활용하여 mod 값을 구해주면 된다.

N! mod 1e9 + 7은 O(N)에 구할 수 있고, 분모의 경우에는 하나의 분모당 log(1e9 + 7) 시간에 수행할 수 있으므로, O(M log mod) 시간에 풀이 가능하다.

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

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

    int N, M; cin >> N >> M;

    M = min(M, N - M);

    int ans = 1, mod = 1e9 + 7;

    for(int i=N; i>=N-M+1; i--) ans = (ans * i) % mod;

    for(int i=1; i<=M; i++) {
        int ba = i, ex = mod - 2;

        while(ex > 0) {
            if(ex % 2 == 1) ans = (ans * ba) % mod;

            ba = (ba * ba) % mod;
            ex /= 2;
        }
    }

    cout << ans << "\n";
}

백준 BOJ 분할 정복을 이용한 거듭제곱 문제 풀이 모음 220816

restudy — Tue, 16 Aug 2022 10:39:33 +0900

백준 BOJ 12878번 : Blocks

문제 난이도 : Gold III

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

N개의 블럭을 각각 빨강, 주황, 노랑, 초록색 중 하나로 칠하는데 그들 중 빨간색으로 칠해진 블럭과 노란색으로 칠해진 블럭이 각각 짝수개인 경우의 수를 구하는 문제이다.

가장 간단한 해결책은 N = 5 정도까지 완전 탐색으로 모든 경우를 count 해본 뒤, 규칙을 찾아 일반항을 찾는 방법이 있다.

직접 계산하는 방법은 위와 같다.

빨간색 또는 노란색으로 칠할 블럭을 선택하고, 그들 중 빨간색으로 칠할 블럭을 고른다.

나머지 블럭 중에서는 초록색 또는 주황색 중 어떤 색으로 칠할지를 고른다.

이 문제의 식 유도에서 핵심은 NC0 + NC2 + NC4 + ... = 2^(N-1)임을 알고 있어야 한다는 것이다.

홀수인 경우에도 똑같이 2^(N-1)이니 까먹지 않도록 하자.

N이 최대 10^9이므로 O(N) 시간도 부족하다.

따라서 분할 정복을 이용한 거듭제곱을 이용하여 log 시간에 거듭제곱을 수행할 수 있도록 한다.

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

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

    int N; cin >> N;

    int mod = 1e4 + 7;

    int a = 1, ba = 2, ex = N-1;

    while(ex > 0) {
        if(ex % 2 == 1) a = (a * ba) % mod;

        ba = (ba * ba) % mod;
        ex /= 2;
    }

    int b = 1; ba = 2, ex = 2*(N-1);

    while(ex > 0) {
        if(ex % 2 == 1) b = (b * ba) % mod;

        ba = (ba * ba) % mod;
        ex /= 2;
    }

    int ans = (a + b) % mod;

    cout << ans << "\n";
}

백준 BOJ 11693번 : n^m의 약수의 합

문제 난이도 : Gold II

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

n^m의 모든 약수의 합 mod (1e9 + 7)의 값을 구하는 문제이다.

간단히 식 개형만 정리해보면 위와 같이 약수의 합을 (1 + p + p^2 + ... + p^kM) x (1 + q + q^2 + ... ) x ... 이런 식으로 나타낼 수 있다.

이 때 p^k는 N을 소인수분해 했을 때 나타나는 p의 최고 지수이다.

이 문제에서는 N을 M 제곱했기 때문에 최고 차항은 kM이 된다.

위의 항들을 일일이 더하면 결국 O(kM) 이상의 시간이 걸리므로 시간 초과가 발생한다.

따라서 이를 빨리 구해주기 위해 위에서 정리한 등비수열의 합 공식을 사용해준다.

분모의 경우에는 모듈로 역원 공식을 사용해서 풀어주면 된다. (a^(-1) ≡ a^(p - 2) (mod p))

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

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

    int N, M; cin >> N >> M;

    vector<int> v;

    int tmp = N;

    for(int i=2; i*i<=tmp; i++) {
        while(tmp % i == 0) {
            v.push_back(i);
            tmp /= i;
        }
    }

    if(tmp > 1) v.push_back(tmp);

    int cnt = 1, ans = 1, mod = 1e9 + 7;

    for(int i=1; i<v.size(); i++) {
        if(v[i] == v[i-1]) cnt++;
        else {
            int mul = 1, ba = v[i-1], ex = cnt*M + 1;

            while(ex > 0) {
                if(ex % 2 == 1) mul = (mul * ba) % mod;

                ba = (ba * ba) % mod;
                ex /= 2;
            }

            mul--;

            ba = v[i-1] - 1, ex = mod - 2;

            while(ex > 0) {
                if(ex % 2 == 1) mul = (mul * ba) % mod;

                ba = (ba * ba) % mod;
                ex /= 2;
            }

            ans = (ans * mul) % mod;

            cnt = 1;
        }
    }

    if(v.size() > 0) {
        int mul = 1, ba = v[v.size()-1], ex = cnt*M + 1;

        while(ex > 0) {
            if(ex % 2 == 1) mul = (mul * ba) % mod;

            ba = (ba * ba) % mod;
            ex /= 2;
        }

        mul--;

        ba = v[v.size()-1] - 1, ex = mod - 2;

        while(ex > 0) {
            if(ex % 2 == 1) mul = (mul * ba) % mod;

            ba = (ba * ba) % mod;
            ex /= 2;
        }

        ans = (ans * mul) % mod;
    }

    cout << ans << "\n";
}

백준 BOJ 7677번 : Fibonacci

문제 난이도 : Gold II

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

피보나치 수에 대한 일반화 된 행렬 식을 주고, F_n을 구하게 하는 문제이다.

문제에서 행렬과 일반항에 대한 식을 모두 주었기 때문에 단순히 행렬을 N 제곱하여 F_N에 해당하는 원소의 값을 출력해주면 된다.

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

typedef vector<vector<int>> mat;
int mod = 1e4;

mat f(mat& v, mat& u) {
    int N = 2;
    mat w(N, vector<int>(N));

    for(int i=0; i<v.size(); i++)
        for(int j=0; j<u[0].size(); j++)
            for(int k=0; k<v[0].size(); k++)
                w[i][j] = (w[i][j] + v[i][k] * u[k][j]) % mod;

    return w;
}

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

    while(true) {
        int N; cin >> N;
        if(N == -1) break;

        mat mul(2, vector<int>(2));
        for(int i=0; i<2; i++) mul[i][i] = 1;

        mat ba(2, vector<int>(2));
        ba = {{1, 1}, {1, 0}};

        while(N > 0) {
            if(N % 2 == 1) mul = f(mul, ba);

            ba = f(ba, ba);
            N /= 2;
        }

        cout << mul[0][1] << "\n";
    }
}

백준 BOJ 11442번 : 홀수번째 피보나치 수의 합

문제 난이도 : Gold II

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

문제 이름 그대로 홀수번째 피보나치 수의 합을 구하는 문제이다.

이 때 F_0 = 0, F_1 = 1이며, 합을 1e9 + 7로 나눈 수를 답으로 제출해야 한다.

엄밀하게는 점화식이나 일반항을 찾아도 좋지만, 굳이 엄밀하게 풀 것이 아니라면 규칙성을 찾아서 풀어도 된다.

5줄까지만 적어보면 위와 같이 f(2k + 1) = f(2k) = F_2k임을 알 수 있다. (F_2k는 2k번째 피보나치 수)

따라서 2k번째 피보나치 수만 행렬과 빠른 거듭제곱을 활용하여 구해주면 된다.

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

typedef vector<vector<int>> mat;
int mod = 1e9 + 7;

mat f(mat& v, mat& u) {
    int N = 2;
    mat w(N, vector<int>(N));

    for(int i=0; i<v.size(); i++)
        for(int j=0; j<u[0].size(); j++)
            for(int k=0; k<v[0].size(); k++)
                w[i][j] = (w[i][j] + v[i][k] * u[k][j]) % mod;

    return w;
}

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

    int N; cin >> N;

    if(N % 2 == 1) N++;

    mat mul(2, vector<int>(2));
    for(int i=0; i<2; i++) mul[i][i] = 1;

    mat ba(2, vector<int>(2));
    ba = {{1, 1}, {1, 0}};

    while(N > 0) {
        if(N % 2 == 1) mul = f(mul, ba);

        ba = f(ba, ba);
        N /= 2;
    }

    cout << mul[0][1] << "\n";
}

백준 BOJ 11443번 : 짝수번째 피보나치 수의 합

문제 난이도 : Gold II

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

이 문제 역시 위의 문제와 세트 문제로, 짝수번째 피보나치 수의 합을 구해 그것을 1e9 + 7로 나눈 나머지를 구하는 문제이다.

위와 같이 앞의 몇 항을 적어보면, N이 짝수일 때는 1 더해준 뒤 F_N - 1을 답으로 얻어주면 됨을 알 수 있다.

피보나치 수의 일반항을 구하는 과정은 위의 문제와 동일하다.

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

typedef vector<vector<int>> mat;
int mod = 1e9 + 7;

mat f(mat& v, mat& u) {
    int N = 2;
    mat w(N, vector<int>(N));

    for(int i=0; i<v.size(); i++)
        for(int j=0; j<u[0].size(); j++)
            for(int k=0; k<v[0].size(); k++)
                w[i][j] = (w[i][j] + v[i][k] * u[k][j]) % mod;

    return w;
}

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

    int N; cin >> N;

    if(N % 2 == 0) N++;

    mat mul(2, vector<int>(2));
    for(int i=0; i<2; i++) mul[i][i] = 1;

    mat ba(2, vector<int>(2));
    ba = {{1, 1}, {1, 0}};

    while(N > 0) {
        if(N % 2 == 1) mul = f(mul, ba);

        ba = f(ba, ba);
        N /= 2;
    }

    cout << mul[0][1] - 1 << "\n";
}

백준 BOJ 15999번 : 뒤집기

문제 난이도 : Gold III

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

B 또는 W로 이루어진 N x M의 배열에서 일부 칸을 뒤집어 인접한 같은 칸들이 모두 뒤집힌다고 할 때, 원래 배열로 가능했을 것의 경우의 수를 구하는 문제이다.

뒤집고 나서 옆에 다른 칸이 존재하는 것은 불가능하다.

따라서 상하좌우에 다른 칸이 존재하지 않는 칸은 선택했을 수도, 선택되지 않을 수도 있으므로 2^(상하좌우에 다른 칸이 존재하지 않는 칸)이 답이 된다.

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

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

    int N, M; cin >> N >> M;

    vector<vector<char>> v(N, vector<char>(M));

    for(int i=0; i<N; i++)
        for(int j=0; j<M; j++) cin >> v[i][j];

    int cnt = 0;

    for(int i=0; i<N; i++)
        for(int j=0; j<M; j++) {
            bool check = true;

            int di[4] = {1, -1, 0, 0};
            int dj[4] = {0, 0, 1, -1};

            for(int k=0; k<4; k++) {
                int ni = i + di[k];
                int nj = j + dj[k];

                if(ni < 0 || nj < 0 || ni >= N || nj >= M) continue;

                if(v[ni][nj] != v[i][j]) check = false;
            }

            if(check) cnt++;
        }

    int ans = 1, ba = 2, ex = cnt, mod = 1e9 + 7;

    while(ex > 0) {
        if(ex % 2 == 1) ans = (ans * ba) % mod;

        ba = (ba * ba) % mod;
        ex /= 2;
    }

    cout << ans << "\n";
}

백준 BOJ 13172번 : Σ

문제 난이도 : Gold IV

알고리즘 분류 : 페르마의 소정리, 분할 정복을 이용한 거듭제곱

N쌍의 주어진 a/b들에 대해서, a x b^(-1) mod (1e9 + 7)들의 합을 구하는 문제이다.

페르마의 소정리를 활용하여 기약 분수를 모듈로에 대해 연산하는 방법을 알려주는 가장 기초적인 문제이다.

문제에서 하라는대로 구현해주면 된다.

페르마의 소정리에 의하면 소수 p에 대해 a^(-1) mod p는 a^(p-2) mod p와 같다.

따라서, a/b mod p는 a x b^(p-2) mod p를 구하라는 것과 같고, b^(p-2)는 빠른 거듭제곱을 구현하여 풀이해줄 수 있다.

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

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

    int N; cin >> N;

    int ans = 0, mod = 1e9 + 7;

    while(N--) {
        int a, b; cin >> b >> a;

        int mul = a, ba = b, ex = mod - 2;

        while(ex > 0) {
            if(ex % 2 == 1) mul = (mul * ba) % mod;

            ba = (ba * ba) % mod;
            ex /= 2;
        }

        ans = (ans + mul) % mod;
    }

    cout << ans << "\n";
}

백준 BOJ 14440번 : 정수 수열

문제 난이도 : Gold IV

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

수열의 a0와 a1이 주어지고, a_i = x a_(i-1) + y a_(i-2)일 때 a_N을 구하는 문제이다.

행렬을 위와 같이 잡아 행렬 [ [x y] [1 0] ]을 (N-1)제곱하여 일반항을 구해줄 수 있다.

주의할 점은 A_N의 뒤의 "두 자리"를 구하라고 하였으므로, 답이 한 자리거나 0인 경우 앞에 0 하나를 더 붙여서 출력해주어야 한다는 것이다.

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

typedef vector<vector<int>> mat;
int mod = 100;

mat f(mat& v, mat& u) {
    mat w(2, vector<int>(2));

    for(int i=0; i<v.size(); i++)
        for(int j=0; j<u[0].size(); j++)
            for(int k=0; k<v[0].size(); k++)
                w[i][j] = (w[i][j] + v[i][k] * u[k][j]) % mod;

    return w;
}

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

    int x, y, a0, a1, N; cin >> x >> y >> a0 >> a1 >> N;

    if(N == 0) {
        printf("%02d\n", x);
        return 0;
    }
    else if(N == 1) {
        printf("%02d\n", y);
        return 0;
    }

    mat mul(2, vector<int>(2));
    for(int i=0; i<2; i++) mul[i][i] = 1;

    mat ba(2, vector<int>(2));
    ba[0][0] = x, ba[0][1] = y, ba[1][0] = 1, ba[1][1] = 0;

    N--;

    while(N > 0) {
        if(N % 2 == 1) mul = f(mul, ba);

        ba = f(ba, ba);
        N /= 2;
    }

    int ans = (mul[0][0] * a1 + mul[0][1] * a0) % mod;

    printf("%02d\n", ans);
}

백준 BOJ 4233번 : 가짜소수

문제 난이도 : Gold IV

알고리즘 분류 : 에라토스테네스의 체, 분할 정복을 이용한 거듭제곱

어떤 수 p가 소수가 아니면서 a^p ≡ a (mod p)라면 p를 가짜소수라고 할 때, a와 p가 주어졌을 때 p가 가짜소수인지를 판별하는 문제이다.

다시 적어보자면 p가 가짜소수이려면, 1. 소수가 아니어야 하고 2. a^p ≡ a (mod p)이어야 한다.

1번 조건은 에라토스테네스의 체를 이용하여 sqrt(p) 까지의 소수에 대해서만 나누어지는지 확인해보면 된다.

2번은 분할 정복을 이용한 거듭제곱을 수행하여 O(log p) 시간에 제곱값을 구하고, 이것이 mod p에 대해 a인지 확인해보면 된다.

주의할 점은 가짜소수는 합성수라는 것이다. 조건을 잘 읽어보아야 한다.

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

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

    int Max = 1e5;

    vector<bool> p(Max, true);
    p[1] = false;

    for(int i=2; i*i<Max; i++)
        for(int j=2; i*j<Max; j++) p[i*j] = false;

    vector<int> v;
    for(int i=2; i<Max; i++)
        if(p[i]) v.push_back(i);

    while(true) {
        int N, a; cin >> N >> a;
        if(N == 0 && a == 0) break;

        bool check = true;

        for(int i=0; i<v.size() && v[i]*v[i] <= N; i++) {
            if(N % v[i] == 0) check = false;
        }

        if(check) {
            cout << "no\n";
            continue;
        }

        int mul = 1, bas = a, exp = N;

        while(exp > 0) {
            if(exp % 2 == 1) mul = (mul * bas) % N;

            bas = (bas * bas) % N;
            exp /= 2;
        }

        if(mul == a) cout << "yes\n";
        else cout << "no\n";
    }
}

백준 BOJ 5095번 : Matrix Powers

문제 난이도 : Gold IV

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

N x N 행렬을 M 제곱한 행렬을 구하는 문제이다.

단순히 분할 정복을 이용한 거듭제곱 알고리즘을 이용하여 그대로 풀이 가능하다.

다만 행렬의 곱을 구현하는 부분에서 헷갈릴 수 있는데, A 행렬과 B 행렬의 곱의 경우 A 행렬의 행의 수만큼 행이 생기고, B행렬의 열의 수만큼 열이 생기며, 각 원소는 A 행렬의 열의 수 = B 행렬의 행의 수만큼의 원소들을 곱해서 더해야 한다.

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

typedef vector<vector<int>> mat;
int N, mod, M;

mat f(mat& v, mat& u) {
    mat w(N, vector<int>(N));

    for(int i=0; i<v.size(); i++)
        for(int j=0; j<u[0].size(); j++)
            for(int k=0; k<v[0].size(); k++)
                w[i][j] = (w[i][j] + v[i][k] * u[k][j]) % mod;

    return w;
}

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

    while(true) {
        cin >> N >> mod >> M;
        if(N == 0 && mod == 0 && M == 0) break;

        mat mul(N, vector<int>(N));
        for(int i=0; i<N; i++) mul[i][i] = 1;

        mat bas(N, vector<int>(N));

        for(int i=0; i<N; i++)
            for(int j=0; j<N; j++) cin >> bas[i][j];

        while(M > 0) {
            if(M % 2 == 1) mul = f(mul, bas);

            bas = f(bas, bas);
            M /= 2;
        }

        for(int i=0; i<mul.size(); i++) {
            for(int j=0; j<mul[0].size(); j++) cout << mul[i][j] << " ";

            cout << "\n";
        }
        cout << "\n";
    }
}

백준 BOJ 15710번 : xor 게임

문제 난이도 : Gold V

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

a에서 시작하여 0 ~ 2^31 - 1의 수를 하나 골라 xor하는 과정을 N번 거쳐 b를 만드는 경우의 수를 구하는 문제이다.

중간에 나올 수 있는 수는 0 ~ 2^31 - 1 중 어떤 것이든 가능하다.

즉, 중간에 거치는 수 하나 당 2^31가지의 경우의 수가 발생한다.

연산을 N번 거쳐 b가 되었다는 것은 중간 수가 N-1가지라는 의미이므로, 답은 (2^31)^(N-1)이 된다.

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

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

    int a, b, N; cin >> a >> b >> N;

    int ans = 1, mod = 1e9 + 7;

    int x = 1;

    for(int i=1; i<=31; i++) x = (x * 2) % mod;

    N--;

    while(N > 0) {
        if(N % 2 == 1) ans = (ans * x) % mod;

        x = (x * x) % mod;
        N /= 2;
    }

    cout << ans << "\n";
}

백준 BOJ 15717번 : 떡파이어

문제 난이도 : Gold V

알고리즘 분류 : 분할 제곱을 이용한 거듭제곱

자연수 N을 자연수들로 분할하는 경우의 수를 묻는 문제이다.

예를 들어 N = 4인 경우 3 = 2 + 1 = 1 + 2 = 1 + 1 + 1로 4가지이다.

N개의 공이 있고 그 사이에 막대로 분리하는 경우를 생각해보자.

N-1개의 사이 공간에 막대를 각각 놓을지 안 놓을지 2가지의 선택지가 있으므로 답은 2^(N-1)이다.

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

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

    int N; cin >> N;

    N--;

    int ans = 1, x = 2, mod = 1e9 + 7;

    while(N > 0) {
        if(N % 2 == 1) ans = (ans * x) % mod;

        x = (x * x) % mod;
        N /= 2;
    }

    cout << ans << "\n";
}

백준 BOJ 18291번 : 비요뜨의 징검다리 건너기

문제 난이도 : Gold V

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

1번 다리에서 N번 다리로 건너는데, 1번과 N번 사이에 있는 다리는 건너도 되고 안 건너도 될 때, 다리를 건너는 방법의 수를 구하는 문제이다.

선택이 가능한 다리는 N-2개이고 각각 건널지 말지를 선택할 수 있으므로, 답은 2^(N-2)이다.

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

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

    int T; cin >> T;

    while(T--) {
        int N; cin >> N;

        if(N < 2) {
            cout << 1 << "\n";
            continue;
        }

        N -= 2;

        int ans = 1, x = 2, mod = 1e9 + 7;

        while(N > 0) {
            if(N % 2 == 1) ans = (ans * x) % mod;

            x = (x * x) % mod;
            N /= 2;
        }

        cout << ans << "\n";
    }
}

백준 BOJ 24930번 : Ordinary Ordinals

문제 난이도 : Silver I

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

N 이하의 원소를 규칙에 따라 집합으로 표현했을 때, 문자열의 길이를 구하는 문제이다.

수열의 규칙성 문제의 경우 점화식만 찾아주면 된다.

N+1일 때, N까지의 원소들을 모두 한 번 출력하되 기존의 괄호(2개의 문자열)가 사라진다.

그 다음 콤마가 하나 붙고, N+1에 해당하는 원소가 같은 길이로 나오는데 이번에는 괄호가 붙어있다.

그리고 전체를 감싸는 괄호가 2개 나와야 한다.

그러면 f(N+1) = 2 x f(N) + 1임을 알 수 있다.

f(0)에서 f(1)로 갈 때는 쉼표가 없으므로 예외 처리를 해준다.

위의 점화식에서 일반항의 규칙을 잘 찾아보면 f(N) = 2^(N-2) x 10 - 1임을 알 수 있고, 2^(N-2)는 로그 시간 제곱으로 구해줄 수 있다.

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

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

    int N, mod; cin >> N >> mod;

    if(N == 0) {
        cout << 2 % mod << "\n";
        return 0;
    }
    else if(N == 1) {
        cout << 4 % mod << "\n";
        return 0;
    }

    int ans = 1, a = 2;

    N -= 2;

    while(N > 0) {
        if(N % 2 == 1) ans = (ans * a) % mod;

        a = (a * a) % mod;
        N /= 2;
    }

    ans = (ans * 10 - 1) % mod;

    cout << ans << "\n";
}

백준 BOJ 24159번 : フェルマー方程式 (Fermat)

문제 난이도 : Silver I

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

N과 M이 주어질 때, 0 ~ M-1 사이의 x, y, z에 대해 x^N + y^N ≡ z^N (mod M)인 (x, y, z)의 개수를 구하는 문제이다.

0 ~ M-1인 a에 대해 a^N의 값들을 모두 구해놓고, mod M 값이 i인 것들을 u[i]에 저장한다.

여기서 u[i]는 z^N, 즉 우변에 해당하는 값들이 될 것이다.

이제 좌변의 mod 값들에 따른 개수들을 계산하자.

이중 for문을 이용하여 v[i] + v[j] 값들을 고려해주되, 그냥 계산하면 시간 초과가 나기 때문에 반으로 나눠서 i < j인 경우에 대해서만 count 해주고 나머지는 2배해주면 된다. (물론 i = j인 경우는 따로 count 해주어야 한다.)

이제 좌변과 우변이 같은 경우의 수들을 모두 세어주면 되는데, 이것은 O(M) 시간에 수행 가능하다.

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

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

    int M, N; cin >> M >> N;

    vector<int> v(M, 1), u(M);

    for(int i=0; i<M; i++) {
        int a = i, b = N;

        while(b > 0) {
            if(b % 2 == 1) v[i] = (v[i] * a) % M;

            a = (a * a) % M;
            b /= 2;
        }

        u[v[i]]++;
    }

    vector<int> w(M);

    for(int i=0; i<M; i++)
        for(int j=i+1; j<M; j++) w[(v[i] + v[j]) % M] += 2;

    for(int i=0; i<M; i++) w[(v[i] + v[i]) % M]++;

    int ans = 0;

    for(int i=0; i<M; i++) ans += u[i] * w[i];

    cout << ans << "\n";
}

백준 BOJ 14731번 : 謎紛芥索紀 (Large)

문제 난이도 : Silver II

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

다항식이 주어질 때 f'(2)의 값을 구하는 문제이다.

k x^b를 미분하면 kb x^(b-1)이 되므로, 나머지는 계산해주고 x^(b-1)을 분할 정복을 이용한 거듭제곱으로 log 시간에 계산해주면 된다.

이 때 x = 2이므로, 2를 거듭제곱 해준다.

의문인 점은 mul = k * b를 했을 때 모듈로 처리를 안하면 틀린다는 것인데, 어차피 ans = (ans + mul) % mod에서 모듈로 연산이 될텐데 어디에서 오버플로우가 났는지 잘 모르겠다.

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

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

    int N; cin >> N;

    int ans = 0, mod = 1e9 + 7;

    while(N--) {
        int k, a = 2, b; cin >> k >> b;

        int mul = (k * b) % mod;
        b--;

        while(b > 0) {
            if(b % 2 == 1) mul = (mul * a) % mod;

            a = (a * a) % mod;
            b /= 2;
        }

        ans = (ans + mul) % mod;
    }

    cout << ans << "\n";
}

백준 BOJ 21854번 : Monsters

문제 난이도 : Silver III

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

N개의 수에 대해, 2^(a_i)의 합을 구하는 문제이다.

각 수에 대해 2의 거듭 제곱의 값을 분할 정복을 이용한 거듭제곱으로 log 시간에 구해주면 된다.

총 시간 복잡도는 O(N log K)가 된다.

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

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

    int N; cin >> N;

    int ans = 0, mod = 1e9 + 7;

    while(N--) {
        int b; cin >> b;

        int mul = 1, a = 2;

        while(b > 0) {
            if(b % 2 == 1) mul = (mul * a) % mod;

            a = (a * a) % mod;
            b /= 2;
        }

        ans = (ans + mul) % mod;
    }

    cout << ans << "\n";
}

백준 BOJ 11366번 : Tons of Orcs, no Fibbin'

문제 난이도 : Silver III

알고리즘 분류 : 수학

등차수열의 첫 두 항 a와 b가 주어질 때, c+2번째 항의 값을 구하는 문제이다.

수가 기하급수적으로 늘어나므로 굳이 DP를 사용할 필요도 없이 단순 반복으로 계산이 가능하다.

다만 a = 0, b = 0일 경우 N을 아주 크게 주어도 답이 0으로 나오므로, 시간 초과가 발생할 수 있다.

따라서 이 경우는 예외 처리를 해주어야 한다.

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

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

    while(true) {
        int a, b, N; cin >> a >> b >> N;
        if(a == 0 && b == 0 && N == 0) break;

        if(a == 0 && b == 0) {
            cout << 0 << "\n";
            continue;
        }

        int ans = a + b;
        N--;

        while(N--) {
            a = b;
            b = ans;
            ans = a + b;
        }

        cout << ans << "\n";
    }
}

백준 BOJ 13171번 : A

문제 난이도 : Silver IV

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

a^b의 값을 구하는 문제이다.

분할 정복을 사용한 거듭제곱으로 풀이해줄 수 있다.

이 때 a는 처음부터 mod 값인 1e9 + 7을 넘어가서 주어질 수 있으므로, a는 거듭제곱 전에 mod 처리를 한 번 해주고 시작해야한다.

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

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

    int a, b; cin >> a >> b;

    int ans = 1, mod = 1e9 + 7;

    a %= mod;

    while(b > 0) {
        if(b % 2 == 1) ans = (ans * a) % mod;

        a = (a * a) % mod;
        b /= 2;
    }

    cout << ans << "\n";
}

백준 BOJ 11288번 : Ethel's Encryption

문제 난이도 : Bronze I

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

어떤 암호문이 알파벳을 a^b만큼 shift하여 만들어졌다고 할 때, 원문을 구하는 문제이다.

알파벳은 총 26개이므로, a^b % 26만큼 shift 해주면 된다.

a^b는 분할 정복을 이용한 거듭제곱으로 구해줄 수 있다.

거듭제곱 연산마다 mod 26 처리를 해주어야 한다.

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

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

    int N, a, b; cin >> N >> a >> b;
    cin.ignore();

    string str; getline(cin, str);

    int mul = 1;

    while(b > 0) {
        if(b % 2 == 1) mul = (mul * a) % 26;

        a = (a * a) % 26;
        b /= 2;
    }

    for(int i=0; i<str.length(); i++) {
        if(str[i] == ' ') {
            cout << " ";
            continue;
        }

        str[i] = char('A' + (str[i] - 'A' - mul + 26) % 26);

        cout << str[i];
    }
    cout << "\n";
}

백준 BOJ 11524번 : Immortal Propoises

문제 난이도 : Gold II

알고리즘 분류 : 분할 정복을 이용한 거듭제곱

1,000개 이하의 테스트케이스에 대해 N번째 피보나치 수를 구하는 문제이다. (이 때 N ≤ 2^48)

같은 풀이를 위에서 여러 번 다루었으므로 설명은 생략한다.

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

typedef vector<vector<int>> mat;
int mod = 1e9;

mat f(mat& v, mat& u) {
    int N = 2;
    mat w(N, vector<int>(N));

    for(int i=0; i<v.size(); i++)
        for(int j=0; j<u[0].size(); j++)
            for(int k=0; k<v[0].size(); k++)
                w[i][j] = (w[i][j] + v[i][k] * u[k][j]) % mod;

    return w;
}

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

    int T; cin >> T;

    while(T--) {
        int t; cin >> t;

        int N; cin >> N;

        mat mul(2, vector<int>(2));
        for(int i=0; i<2; i++) mul[i][i] = 1;

        mat ba(2, vector<int>(2));
        ba = {{1, 1}, {1, 0}};

        while(N > 0) {
            if(N % 2 == 1) mul = f(mul, ba);

            ba = f(ba, ba);
            N /= 2;
        }

        cout << t << " " << mul[0][1] << "\n";
    }
}

최소 스패닝 트리, 크루스칼 알고리즘 풀이 모음 220814

restudy — Sun, 14 Aug 2022 22:49:37 +0900

백준 BOJ 1185번 : 유럽여행

문제 난이도 : Platinum IV

알고리즘 분류 : 최소 스패닝 트리 (MST)

트리 형태의 그래프가 주어지고, 한 지점에서 시작하여 어떤 노드와 간선을 지나갈 때의 비용이 모두 주어질 때, 최소 비용으로 모든 노드를 순회할 때 드는 최소 비용을 구하는 문제이다.

경로를 생각해보면, 시작점을 제외하고 어떤 경로든 지나갔다가 다시 돌아와야 하므로, 간선의 시작점 → 간선 → 간선의 끝 점 → 간선 순서로 반드시 지나가게 된다.

따라서 간선의 비용 자체를 (간선의 시작점의 비용 + 간선의 끝 점의 비용 + 간선의 비용 x 2)로 설정해주고, 여기에 시작점으로 설정할 최소 비용인 노드의 비용을 더해주면 된다.

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

struct s { int a, b, c; };

bool cmp(s x, s y) { return x.c < y.c; }

vector<int> v;

int f(int x) {
    if(v[x] == x) return x;
    else return v[x] = f(v[x]);
}

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

    int N, M; cin >> N >> M;

    vector<int> u(N+1);
    int Min = INT_MAX;
    for(int i=1; i<=N; i++) {
        cin >> u[i];

        Min = min(Min, u[i]);
    }

    vector<s> adj(M);

    for(int i=0; i<M; i++) {
        int a, b, c; cin >> a >> b >> c;

        adj[i] = {a, b, c*2 + u[a] + u[b]};
    }

    sort(adj.begin(), adj.end(), cmp);

    v.resize(N+1);
    for(int i=1; i<=N; i++) v[i] = i;

    int ans = 0, cnt = 0;

    for(int i=0; i<adj.size(); i++) {
        int a = adj[i].a, b = adj[i].b, c = adj[i].c;

        if(f(a) == f(b)) continue;

        v[f(a)] = f(b);

        ans += c;
        cnt++;

        if(cnt == N-1) break;
    }

    ans += Min;

    cout << ans << "\n";
}

백준 BOJ 2887번 : 행성 터널

문제 난이도 : Platinum V

알고리즘 분류 : 최소 스패닝 트리 (MST)

최소 스패닝 트리 문제임을 바로 알 수 있지만, N이 최대 10만이므로 가능한 모든 비용을 설정하는 것은 불가능하다.

따라서 x, y, z 값들을 각각 정렬해주고, 인접하지 않은 두 값은 어차피 최소가 될 수 없으므로 인접한 N-1쌍들을 adj 벡터에 넣어준다.

즉, adj 벡터에는 (N-1) x 3개의 값들이 들어가는 것이다.

이제 adj 벡터를 정렬해준 뒤 크루스칼 알고리즘을 수행해주면 O(N) 시간에 MST를 찾을 수 있다.

물론 종합적인 시간 복잡도는 정렬을 수행했으므로 O(N log N)이다.

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

struct s { int a, b, c; };

bool cmp(s x, s y) { return x.c < y.c; }

vector<int> v;

int f(int x) {
    if(v[x] == x) return x;
    else return v[x] = f(v[x]);
}

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

    int N; cin >> N;

    vector<pair<int, int>> vx(N+1), vy(N+1), vz(N+1);

    for(int i=1; i<=N; i++) {
        cin >> vx[i].first >> vy[i].first >> vz[i].first;

        vx[i].second = vy[i].second = vz[i].second = i;
    }

    sort(vx.begin()+1, vx.end());
    sort(vy.begin()+1, vy.end());
    sort(vz.begin()+1, vz.end());

    vector<s> adj;

    for(int i=2; i<=N; i++) adj.push_back({vx[i-1].second, vx[i].second, vx[i].first - vx[i-1].first});
    for(int i=2; i<=N; i++) adj.push_back({vy[i-1].second, vy[i].second, vy[i].first - vy[i-1].first});
    for(int i=2; i<=N; i++) adj.push_back({vz[i-1].second, vz[i].second, vz[i].first - vz[i-1].first});

    sort(adj.begin(), adj.end(), cmp);

    v.resize(N+1);
    for(int i=1; i<=N; i++) v[i] = i;

    int ans = 0, cnt = 0;

    for(int i=0; i<adj.size(); i++) {
        int a = adj[i].a, b = adj[i].b, c = adj[i].c;

        if(f(a) == f(b)) continue;

        v[f(a)] = f(b);

        ans += c;
        cnt++;

        if(cnt == N-1) break;
    }

    cout << ans << "\n";
}

백준 BOJ 6091번 : 핑크 플로이드

문제 난이도 : Gold I

알고리즘 분류 : 최소 스패닝 트리 (MST)

트리에서 플로이드-와셜 알고리즘으로 구한 노드-노드 사이의 최단 거리가 주어졌을 때, 각 노드에 인접해있는 노드들의 목록을 구하는 문제이다. (즉, 트리를 복원하면 된다.)

모든 거리들을 정렬했을 때 최단 거리는 무조건 인접한 노드 사이의 간선이다.

따라서 거리들을 정렬한 뒤 짧은 거리부터 분리 집합을 활용하여 그룹으로 묶어가면서 확인해보면 된다. (두 노드가 같은 그룹이 아닐 경우 서로 인접하다.)

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

struct s { int a, b, c; };

bool cmp(s x, s y) { return x.c < y.c; }

vector<int> v;

int f(int x) {
    if(v[x] == x) return x;
    else return v[x] = f(v[x]);
}

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

    int N; cin >> N;

    vector<s> adj;

    for(int i=1; i<=N; i++)
        for(int j=i+1; j<=N; j++) {
            int x; cin >> x;

            adj.push_back({i, j, x});
        }

    sort(adj.begin(), adj.end(), cmp);

    v.resize(N+1);
    for(int i=1; i<=N; i++) v[i] = i;

    vector<vector<int>> u(N+1);

    for(int i=0; i<adj.size(); i++) {
        int a = adj[i].a, b = adj[i].b;

        if(f(a) == f(b)) continue;

        u[a].push_back(b);
        u[b].push_back(a);

        v[f(a)] = f(b);
    }

    for(int i=1; i<=N; i++) {
        sort(u[i].begin(), u[i].end());

        cout << u[i].size() << " ";

        for(int j=0; j<u[i].size(); j++) cout << u[i][j] << " ";

        cout << "\n";
    }
}

백준 BOJ 1368번 : 물대기

문제 난이도 : Gold II

알고리즘 분류 : 최소 스패닝 트리 (MST)

N개의 논이 있는데 각 논에 서로 다른 비용을 들여 우물을 파도 되고, 또는 N x N 행렬로 a_ij = (i번째 논에서 j번째 논에 물을 끌어오는데 필요한 비용)이 주어질 때 모든 논에 물을 들이기 위해 필요한 최소 비용을 구하는 문제이다.

처음 생각해볼 수 있는 것은 여러 개의 부분 그래프를 만들고 각 부분 그래프에서 우물을 파는 가장 작은 비용을 골라 답에 합산하는 것이다.

그러나 이렇게 구현할 경우 부분 그래프를 어떻게 연결할지가 결정되지 않는다.

이러한 문제의 경우 0번 노드를 하나 만들어서 i번 논에 우물을 파는 비용을 0번 노드와 i번 노드를 연결하는 간선의 비용으로 설정해주고, 0 ~ N번 노드에 대한 최소 스패닝 트리의 비용을 구해주면 된다.

이렇게 구현할 경우 문제에서 요구하는 조건과 완전히 대응되는 그래프가 얻어진다.

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

struct s { int a, b, c; };

bool cmp(s x, s y) { return x.c < y.c; }

vector<int> v;

int f(int x) {
    if(v[x] == x) return x;
    else return v[x] = f(v[x]);
}

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

    int N; cin >> N;

    vector<s> adj;

    for(int i=1; i<=N; i++) {
        int x; cin >> x;

        adj.push_back({0, i, x});
    }

    for(int i=1; i<=N; i++)
        for(int j=1; j<=N; j++) {
            int x; cin >> x;

            if(i >= j) continue;

            adj.push_back({i, j, x});
        }

    sort(adj.begin(), adj.end(), cmp);

    v.resize(N+1);
    for(int i=0; i<=N; i++) v[i] = i;

    int ans = 0, cnt = 0;

    for(int i=0; i<adj.size(); i++) {
        int a = adj[i].a, b = adj[i].b, c = adj[i].c;

        if(f(a) == f(b)) continue;

        v[f(a)] = f(b);

        ans += c;
        cnt++;

        if(cnt == N) break;
    }

    cout << ans << "\n";
}

백준 BOJ 23743번 : 방탈출

문제 난이도 : Gold II

알고리즘 분류 : 최소 스패닝 트리 (MST)

위의 문제와 동일한 문제이다.

비용의 개념이 시간의 개념으로 바뀌긴 했지만 풀이도 같으며, 코드 또한 똑같이 구현해주면 된다.

여담으로 이 문제의 기존 난이도가 Gold III이었는데 난이도 기여를 하여 Gold II로 상향 조정되었다.

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

struct s { int a, b, c; };

bool cmp(s x, s y) { return x.c < y.c; }

vector<int> v;

int f(int x) {
    if(v[x] == x) return x;
    else return v[x] = f(v[x]);
}

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

    int N, M; cin >> N >> M;

    vector<s> adj;

    while(M--) {
        int a, b, c; cin >> a >> b >> c;

        adj.push_back({a, b, c});
    }

    for(int i=1; i<=N; i++) {
        int x; cin >> x;

        adj.push_back({0, i, x});
    }

    sort(adj.begin(), adj.end(), cmp);

    v.resize(N+1);
    for(int i=0; i<=N; i++) v[i] = i;

    int ans = 0, cnt = 0;

    for(int i=0; i<adj.size(); i++) {
        int a = adj[i].a, b = adj[i].b, c = adj[i].c;

        if(f(a) == f(b)) continue;

        v[f(a)] = f(b);

        ans += c;
        cnt++;

        if(cnt == N) break;
    }

    cout << ans << "\n";
}

백준 BOJ 20335번 : Generators

문제 난이도 : Gold I

알고리즘 분류 : 최소 스패닝 트리 (MST)

N개의 섬이 있고 그들 중 M개는 발전소 설치 후보일 때, M개의 줄에 걸쳐 섬의 번호와 설치 비용이 주어지고, N개의 정수 a_i = i번 섬과 i+1번 섬을 연결하는 비용이 주어질 때, 모든 섬들에 전력을 공급하기 위한 최소 비용을 구하는 문제이다.

이 문제 역시 위의 문제와 동일하지만, 이 문제의 경우에는 대놓고 그래프를 떠올릴 수 있는 문제는 아니므로 위의 문제를 이해하고 풀이하는 것이 수월하다.

"발전소 설치 = 0번 노드와의 연결"이라고 생각하고, 0 ~ N번 노드들에 대한 최소 스패닝 트리의 비용을 구해주면 된다.

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

struct s { int a, b, c; };

bool cmp(s x, s y) { return x.c < y.c; }

vector<int> v;

int f(int x) {
    if(v[x] == x) return x;
    else return v[x] = f(v[x]);
}

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

    int N, M; cin >> N >> M;

    vector<s> adj;

    while(M--) {
        int a, b; cin >> a >> b;

        adj.push_back({0, a, b});
    }

    for(int i=1; i<=N; i++) {
        int x; cin >> x;

        if(i != N) adj.push_back({i, i+1, x});
        else adj.push_back({N, 1, x});
    }

    sort(adj.begin(), adj.end(), cmp);

    v.resize(N+1);
    for(int i=0; i<=N; i++) v[i] = i;

    int ans = 0, cnt = 0;

    for(int i=0; i<adj.size(); i++) {
        int a = adj[i].a, b = adj[i].b, c = adj[i].c;

        if(f(a) == f(b)) continue;

        v[f(a)] = f(b);

        ans += c;
        cnt++;

        if(cnt == N) break;
    }

    cout << ans << "\n";
}

백준 BOJ 10423번 : 전기가 부족해

문제 난이도 : Gold II

알고리즘 분류 : 최소 스패닝 트리 (MST)

N개의 노드와 M개의 간선이 있는 그래프가 주어지고, K개의 노드는 이미 발전소가 설치되어 있다고 할 때, 적절한 간선들을 선택하여 모든 노드에 전기가 통하도록 하는 최소 비용을 구하는 문제이다.

위의 문제들과 비슷한 방식으로, 0번 노드를 가상으로 만들어 K개의 발전소 노드들과 연결하고 N개의 간선을 갖는 N+1 노드들의 최소 스패닝 트리를 구성하는 최소 비용을 크루스칼 알고리즘으로 구현해주면 된다.

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

struct s { int a, b, c; };

bool cmp(s x, s y) { return x.c < y.c; }

vector<int> v;

int f(int x) {
    if(v[x] == x) return x;
    else return v[x] = f(v[x]);
}

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

    int N, M, K; cin >> N >> M >> K;

    vector<s> adj;

    while(K--) {
        int x; cin >> x;

        adj.push_back({0, x, 0});
    }

    while(M--) {
        int a, b, c; cin >> a >> b >> c;

        adj.push_back({a, b, c});
    }

    sort(adj.begin(), adj.end(), cmp);

    v.resize(N+1);
    for(int i=1; i<=N; i++) v[i] = i;

    int ans = 0, cnt = 0;

    for(int i=0; i<adj.size(); i++) {
        int a = adj[i].a, b = adj[i].b, c = adj[i].c;

        if(f(a) == f(b)) continue;

        v[f(a)] = f(b);

        ans += c;
        cnt++;

        if(cnt == N) break;
    }

    cout << ans << "\n";
}

백준 BOJ 5818번 : SPIJUNI

문제 난이도 : Gold II

알고리즘 분류 : 최소 스패닝 트리 (MST)

N x N 행렬로 a_ij = i번째 스파이가 j번째 스파이에게 정보를 전달하는 비용이 주어지고, 마지막 줄에 주어지는 N개의 값에 대해 b_i = i번째 스파이에게 정보를 최초로 전달하는데 필요한 비용이 있다면, 모든 스파이에게 정보를 전달하는데 필요한 최소 비용을 구하는 문제이다.

역시 마찬가지로 최초로 정보를 전달하는 곳을 0번 노드라고 생각하고 간선들을 이은 뒤, N+1개의 노드에 대해 최소 스패닝 트리의 비용을 구해주면 된다.

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

struct s { int a, b, c; };

bool cmp(s x, s y) { return x.c < y.c; }

vector<int> v;

int f(int x) {
    if(v[x] == x) return x;
    else return v[x] = f(v[x]);
}

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

    int N; cin >> N;

    vector<s> adj;

    for(int i=1; i<=N; i++)
        for(int j=1; j<=N; j++) {
            int x; cin >> x;

            if(i >= j) continue;

            adj.push_back({i, j, x});
        }

    for(int i=1; i<=N; i++) {
        int x; cin >> x;

        adj.push_back({0, i, x});
    }

    sort(adj.begin(), adj.end(), cmp);

    v.resize(N+1);
    for(int i=0; i<=N; i++) v[i] = i;

    int ans = 0, cnt = 0;

    for(int i=0; i<adj.size(); i++) {
        int a = adj[i].a, b = adj[i].b, c = adj[i].c;

        if(f(a) == f(b)) continue;

        v[f(a)] = f(b);

        ans += c;
        cnt++;

        if(cnt == N) break;
    }

    cout << ans << "\n";
}

백준 BOJ 10661번 : Median Tree

문제 난이도 : Gold II

알고리즘 분류 : 최소 스패닝 트리 (MST)

N개의 노드와 M개의 간선을 가지는 그래프가 주어질 때, 이들 중 N-1개의 간선을 선택하여 트리를 만들 때, N-1개의 간선들 중 중앙값이 최소가 되는 트리에서 중앙값을 구하는 문제이다.

크루스칼 알고리즘을 기본적으로 이해하고 있다면 문제의 의도를 파악할 수 있다.

애초에 MST를 구하는 크루스칼 알고리즘은 가장 낮은 비용의 간선부터 검사하면서 트리에 추가하기 때문에, 결국에는 최소 스패닝 트리를 구했을 때 간선들의 중앙값이 최소가 된다.

따라서 최소 스패닝 트리를 구하면서 N/2번째로 추가된 간선을 답으로 구해주면 된다.

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

struct s { int a, b, c; };

bool cmp(s x, s y) { return x.c < y.c; }

vector<int> v;

int f(int x) {
    if(v[x] == x) return x;
    else return v[x] = f(v[x]);
}

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

    while(true) {
        int N, M; cin >> N >> M;
        if(N == 0 && M == 0) break;

        vector<s> adj(M);

        for(int i=0; i<M; i++)
            cin >> adj[i].a >> adj[i].b >> adj[i].c;

        sort(adj.begin(), adj.end(), cmp);

        v.resize(N+1);
        for(int i=1; i<=N; i++) v[i] = i;

        int ans = 0, cnt = 0;

        for(int i=0; i<adj.size(); i++) {
            int a = adj[i].a, b = adj[i].b, c = adj[i].c;

            if(f(a) == f(b)) continue;

            v[f(a)] = f(b);

            cnt++;

            if(cnt == N/2) ans = c;
            if(cnt == N-1) break;
        }

        cout << ans << "\n";
    }
}

백준 BOJ 20757번 : Roadside optimization

문제 난이도 : Gold III

알고리즘 분류 : 분리 집합

크기가 N x N인 인접 행렬이 주어졌을 때 해당 형태의 그래프를 만들기 위해서 필요한 최소 간선의 수를 구하는 문제이다.

분리 집합을 이용하여 몇 개의 그룹이 존재하는지를 찾으면, N - (그룹의 개수)가 필요한 최소 간선의 수가 된다.

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

vector<int> v;

int f(int x) {
    if(v[x] == x) return x;
    else return v[x] = f(v[x]);
}

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

    int T; cin >> T;

    while(T--) {
        int N; cin >> N;

        v.clear();
        v.resize(N+1);
        for(int i=1; i<=N; i++) v[i] = i;

        for(int i=1; i<=N; i++)
            for(int j=1; j<=N; j++) {
                int x; cin >> x;

                if(i >= j || x == 0) continue;

                if(f(i) == f(j)) continue;

                v[f(i)] = f(j);
            }

        vector<int> u;
        for(int i=1; i<=N; i++) u.push_back(f(i));

        sort(u.begin(), u.end());
        u.erase(unique(u.begin(), u.end()), u.end());

        int ans = N - u.size();

        cout << ans << "\n";
    }
}

백준 BOJ 16393번 : Lost Map

문제 난이도 : Gold II

알고리즘 분류 : 최소 스패닝 트리 (MST)

N x N 크기의 행렬이 주어지고 a_ij = i번 마을에서 j번 마을로 가는 도로의 거리라고 할 때, 최소 비용으로 모든 도로를 연결해야 한다면 연결해야 하는 도로들의 목록(양 끝 마을)을 구하는 문제이다.

크루스칼 알고리즘을 활용하여 최소 스패닝 트리를 찾으면 된다.

여담으로 다른 MST 문제들과 비교해 보았을 때 난이도가 높게 책정되어 있다고 생각하여 난이도 기여로 Gold III으로 투표했다.

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

struct s { int a, b, c; };

bool cmp(s x, s y) { return x.c < y.c; }

vector<int> v;

int f(int x) {
    if(v[x] == x) return x;
    else return v[x] = f(v[x]);
}

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

    int N; cin >> N;

    vector<s> adj;

    for(int i=1; i<=N; i++)
        for(int j=1; j<=N; j++) {
            int x; cin >> x;

            if(i >= j) continue;

            adj.push_back({i, j, x});
        }

    sort(adj.begin(), adj.end(), cmp);

    v.resize(N+1);
    for(int i=1; i<=N; i++) v[i] = i;

    int ans = 0, cnt = 0;
    vector<pair<int, int>> u;

    for(int i=0; i<adj.size(); i++) {
        int a = adj[i].a, b = adj[i].b, c = adj[i].c;

        if(f(a) == f(b)) continue;

        v[f(a)] = f(b);

        ans += c;
        cnt++;

        u.push_back({a, b});

        if(cnt == N-1) break;
    }

    for(int i=0; i<u.size(); i++)
        cout << u[i].first << " " << u[i].second << "\n";
}

백준 BOJ 20010번 : 악덕 영주 혜유

문제 난이도 : Gold II

알고리즘 분류 : 최소 스패닝 트리 (MST), 트리의 지름

그래프가 주어질 때, 이들 중 일부 간선을 선택하여 연결 비용이 최소가 되도록 할 때 이 때의 비용과 가장 거리가 먼 두 노드 사이의 거리를 구하는 문제이다.

먼저 모든 노드들을 연결 비용이 최소가 되도록 하는 것은 최소 스패닝 트리를 찾으라는 것과 같으므로, 크루스칼 알고리즘으로 풀어주면 된다.

이제 이 그래프에서 가장 거리가 먼 두 점 사이의 거리라는 것은 트리의 지름을 의미하는 것이므로, 선택된 간선들을 추가하여 그래프를 다시 구성해준 뒤, 이 그래프에서 트리의 지름을 찾는 DFS 탐색을 수행해주면 된다.

트리의 지름을 찾는 코드는 백준 BOJ 1167번 : 트리의 지름 문제를 참고하면 도움이 될 것이다.

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

struct s { int a, b, c; };

bool cmp(s x, s y) { return x.c < y.c; }

vector<int> v;

int f(int x) {
    if(v[x] == x) return x;
    else return v[x] = f(v[x]);
}

vector<vector<pair<int, int>>> ad;
int Max = 0, node = 0;

void g(int cur, int pre, int sum) {
    if(sum > Max) {
        Max = sum;
        node = cur;
    }

    for(int i=0; i<ad[cur].size(); i++)
        if(ad[cur][i].first != pre) g(ad[cur][i].first, cur, sum + ad[cur][i].second);
}

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

    int N, M; cin >> N >> M;

    vector<s> adj(M);

    for(int i=0; i<M; i++)
        cin >> adj[i].a >> adj[i].b >> adj[i].c;

    sort(adj.begin(), adj.end(), cmp);

    v.resize(N);
    for(int i=0; i<N; i++) v[i] = i;

    int ans = 0, cnt = 0;
    vector<s> u;

    for(int i=0; i<adj.size(); i++) {
        int a = adj[i].a, b = adj[i].b, c = adj[i].c;

        if(f(a) == f(b)) continue;

        v[f(a)] = f(b);

        ans += c;
        cnt++;

        u.push_back({a, b, c});

        if(cnt == N-1) break;
    }

    ad.resize(N);

    for(int i=0; i<u.size(); i++) {
        int a = u[i].a, b = u[i].b, c = u[i].c;

        ad[a].push_back({b, c});
        ad[b].push_back({a, c});
    }

    g(0, -1, 0);

    Max = 0;

    g(node, -1, 0);

    cout << ans << "\n" << Max << "\n";
}

백준 BOJ 22813번 : Building a Space Station

문제 난이도 : Gold III

알고리즘 분류 : 최소 스패닝 트리 (MST)

3차원 공간 상에 N개의 구가 있고, 접하거나 겹치지 않는 구들에 대해 구의 표면과 표면 사이를 연결하여 모든 구들을 연결할 때, 필요한 길이의 최솟값을 구하는 문제이다.

3차원 공간 상에서 최소 스패닝 트리를 그대로 구현해주면 된다.

구가 만약 접하거나 겹친다면 비용이 0인 간선으로 처리해주고, 그렇지 않은 경우 두 구의 중심 사이의 거리에서 두 구의 반지름의 합을 빼주면 된다.

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

struct s { double a, b, c; };
struct ss { double x, y, z, r; };

bool cmp(s x, s y) { return x.c < y.c; }

vector<int> v;

int f(int x) {
    if(v[x] == x) return x;
    else return v[x] = f(v[x]);
}

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

    cout << fixed;
    cout.precision(3);

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

        vector<ss> u(N+1);
        for(int i=1; i<=N; i++)
            cin >> u[i].x >> u[i].y >> u[i].z >> u[i].r;

        vector<s> adj;

        for(int i=1; i<=N; i++)
            for(int j=i+1; j<=N; j++) {
                double d = sqrt(pow(u[i].x - u[j].x, 2) + pow(u[i].y - u[j].y, 2) + pow(u[i].z - u[j].z, 2));

                if(d <= u[i].r + u[j].r) adj.push_back({i, j, 0});
                else adj.push_back({i, j, d - (u[i].r + u[j].r)});
            }

        sort(adj.begin(), adj.end(), cmp);

        v.clear();
        v.resize(N+1);
        for(int i=1; i<=N; i++) v[i] = i;

        double ans = 0, cnt = 0;

        for(int i=0; i<adj.size(); i++) {
            double a = adj[i].a, b = adj[i].b, c = adj[i].c;

            if(f(a) == f(b)) continue;

            v[f(a)] = f(b);

            ans += c;
            cnt++;

            if(cnt == N-1) break;
        }

        cout << ans << "\n";
    }
}

백준 BOJ 23941번 : Cherries Mesh

문제 난이도 : Gold III

알고리즘 분류 : 최소 스패닝 트리 (MST), 분리 집합

N개의 체리가 M개의 검은 설탕으로 연결되어 있고, 나머지 두 체리 쌍들에 대해서는 빨간 설탕으로 연결되어 있으며 검은 설탕은 1의 당도이고 빨간 설탕은 2의 당도라면 일부 설탕을 제거하여 모든 체리를 연결하는 최소 당도를 구하는 문제이다.

우선 최소 스패닝 트리를 만드는 문제이고, 검은 설탕의 당도가 더 작으므로 검은 설탕을 최대한 간선으로 구성해야 한다.

그렇게 때문에 분리 집합을 활용하여 사이클이 생기지 않는 선에서 M개의 검은 설탕 간선으로 노드들을 최대한 연결해주고, 최종적으로 K개의 부분 그래프(트리)가 만들어졌다면 이들은 K-1개의 빨간 설탕으로 연결이 가능하므로 답에 (K-1) * 2를 더해주면 된다.

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

struct s { int a, b, c; };

bool cmp(s x, s y) { return x.c < y.c; }

vector<int> v;

int f(int x) {
    if(v[x] == x) return x;
    else return v[x] = f(v[x]);
}

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

    int T; cin >> T;

    for(int t=1; t<=T; t++) {
        int N, M; cin >> N >> M;

        vector<s> adj(M);

        for(int i=0; i<M; i++) {
            cin >> adj[i].a >> adj[i].b;

            adj[i].c = 1;
        }

        sort(adj.begin(), adj.end(), cmp);

        v.resize(N+1);
        for(int i=1; i<=N; i++) v[i] = i;

        int ans = 0, cnt = 0;

        for(int i=0; i<adj.size(); i++) {
            int a = adj[i].a, b = adj[i].b, c = adj[i].c;

            if(f(a) == f(b)) continue;

            v[f(a)] = f(b);

            ans += c;
            cnt++;

            if(cnt == N-1) break;
        }

        vector<int> u;
        for(int i=1; i<=N; i++) u.push_back(f(i));

        sort(u.begin(), u.end());
        u.erase(unique(u.begin(), u.end()), u.end());

        ans += (u.size() - 1) * 2;

        cout << "Case #" << t << ": " << ans << "\n";
    }
}