์ฐ์ ๊ธฐ๋ก ๐ช
[ํ๋ก๊ทธ๋๋จธ์ค] ํํ ๊ฐ๋ฅํ ์ด์งํธ๋ฆฌ (C++) ๋ณธ๋ฌธ
[ํ๋ก๊ทธ๋๋จธ์ค] ํํ ๊ฐ๋ฅํ ์ด์งํธ๋ฆฌ (C++)
kite707 2025. 2. 6. 17:59https://school.programmers.co.kr/learn/courses/30/lessons/150367
ํ๋ก๊ทธ๋๋จธ์ค
SW๊ฐ๋ฐ์๋ฅผ ์ํ ํ๊ฐ, ๊ต์ก, ์ฑ์ฉ๊น์ง Total Solution์ ์ ๊ณตํ๋ ๊ฐ๋ฐ์ ์ฑ์ฅ์ ์ํ ๋ฒ ์ด์ค์บ ํ
programmers.co.kr
๋ฌธ์ ๋ถ์
๋ฌธ์ ์์ ์๊ตฌํ๋ ๊ฒ์ ์ฃผ์ด์ง ์ซ์๋ฅผ ์ด์ง์๋ก ๋ฐ๊พธ๊ณ ํฌํ ์ด์งํธ๋ฆฌ๋ก ๋ํ๋์ ๋ ํด๋น ํธ๋ฆฌ๊ฐ ์ด์งํธ๋ฆฌ๊ฐ ๋ง๋์ง๋ฅผ ํ๋ณํ๋ ๊ฒ์ด๋ค.
์ด์ง์๋ฅผ ํฌํ ์ด์งํธ๋ฆฌ๋ก ๋ํ๋ด๋ ค๋ฉด ์์ 0์ ์ฑ์์ ๊ฐ์ ๊ฐ๊ณตํด์ค์ผ ํ๋ค. ์ด ๋ถ๋ถ์ ์ข ๋ ๋ถ์ํด๋ณด๋๋ก ํ์.
์๋์ ๊ฐ์ด ์๊ธด ๊ฒ์ด ํฌํ ์ด์งํธ๋ฆฌ์ด๋ค. ๋ฆฌํ๋
ธ๋๋ฅผ ์ ์ธํ๊ณ ๋ชจ๋ 2๊ฐ์ ์์๋
ธ๋๋ฅผ ๊ฐ์ง๊ณ ์๋ ๊ฒ์ ํฌํ ์ด์งํธ๋ฆฌ๋ผ๊ณ ํ๋ค.
1์ธต์ง๋ฆฌ ํฌํ ์ด์งํธ๋ฆฌ๋ผ๋ฉด ๋
ธ๋์ ์๋ 1๊ฐ, 2์ธต์ด๋ฉด 3๊ฐ, 3์ธต์ด๋ฉด 7๊ฐ์ด๋ค. ์ฆ N์ธต์ง๋ฆฌ ํฌํ ์ด์งํธ๋ฆฌ์ ๋
ธ๋ ๊ฐ์๋ 2^N - 1๊ฐ์ด๋ค.
๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ๋ง์ฝ 7์ ์ด์ง์๋ก ๋ฐ๊ฟ 1011์ ๋์ถํด๋๋ค๋ฉด 0001011๋ก ๋ฐ๊พธ์ด 7์๋ฆฌ๋ก ๋ง์ถฐ์ค์ผํ๋ค. ์ด๋ ๊ฒ ๊ตฌํ ์์ด๋ก ์ด์งํธ๋ฆฌ๊ฐ ์ฑ๋ฆฝ๋๋์ง๋ฅผ ํ๋จํ๋ฉด ๋๋ค.
์ด์งํธ๋ฆฌ์ ์ ์๋ ์์ ๋
ธ๋์ ๊ฐ์๊ฐ ์ต๋ 2์ธ ํธ๋ฆฌ์ด๋ค. ์ฆ ์๋์ ๊ฐ์ด ํธํฅ๋ ํธ๋ฆฌ๋ ์ด์งํธ๋ฆฌ์ด๋ค.
๊ทธ๋ฆฌ๊ณ ๋ฌธ์ ์ ๋์จ ํฌํ ์ด์งํธ๋ฆฌ๋ ์์ ์ด์งํธ๋ฆฌ์ ํผ๋ํ๊ธฐ ์ฌ์ด๋ฐ ์ฐจ์ด์ ์ ์๋์ ๊ฐ๋ค. ์ฆ ํฌํ ์ด์งํธ๋ฆฌ๋ ์์ ์ด์งํธ๋ฆฌ์ ํฌํจ๋๋ ๊ฐ๋ ์ด๋ค.
์์ด๋์ด
๋ฌธ์ ํ์ด ๊ณผ์ ์ ํฌ๊ฒ ๋ ๋ถ๋ถ์ผ๋ก ๋๋๋ค.
1. ์ฃผ์ด์ง ์๋ฅผ ์ด์ง์๋ก ๋ฐ๊พธ๊ธฐ. ์ด๋ ํฌํ ์ด์งํธ๋ฆฌ ๋
ธ๋์ ๊ฐ์์ ๋ง์ถฐ ๊ฐ์ ๋ณด์ ํด์ค์ผ ํ๋ค.
2. ์ด์ง์ ์์ด์ ๋ณด๊ณ ํด๋น ์์ด๋ก ์ด์งํธ๋ฆฌ๊ฐ ์ฑ๋ฆฝ๋๋์ง๋ฅผ ํ๋จํ๋ค.
์ด์ง์๋ฅผ ๊ตฌํ๋ ๊ณต์์ ์๋์ ๊ฐ๋ค.
์ด๋ ๊ฒ ๋๋จธ์ง๋ค์ ๊ฑฐ๊พธ๋ก ๋ชจ์ผ๋ฉด ์ด์ง์๊ฐ ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ด์ง์๋ฅผ ๊ตฌํ๋ ์ฝ๋๋ ์๋์ ๊ฐ์ด ์์ฑํ๋ค.
while(num!=0){
st+=to_string(num%2);
num/=2;
}
reverse(st.begin(),st.end());
๊ทธ๋์ st์๋ 1011์ด ๋ค์ด๊ฐ๋ค๊ฐ ๋ค์ง์ผ๋ฉฐ 13์ ์ด์ง์์ธ 1101์ด ์์ฑ๋๋ค. ๊ทธ๋ ๊ธฐ์ 0์ ์ถ๊ฐํ์ฌ ์๋ฆฟ์๋ฅผ ๋ง์ถ๊ณ ์ถ์ผ๋ฉด ๋ค์ง๊ธฐ ์ ์ 0์ ์ถ๊ฐํ๋ฉด ๋๋ค.
1011 > 1011000 > 0001101
์ด์ ์ด์งํธ๋ฆฌ๊ฐ ์ฑ๋ฆฝ๋๋์ง ํ๋จํ ๋ฐฉ๋ฒ์ ๋ํด ์์๋ณด์. ์ด์งํธ๋ฆฌ๋ ์์ ๋ดค๋ฏ์ด ์์์ ๊ฐ์๊ฐ ์ต๋ 2๊ฐ์ธ ํธ๋ฆฌ์ด๋ค. ์ฆ ์์์ด 0๊ฐ, 1๊ฐ, 2๊ฐ์ฌ๋ ๋๋ค. ๊ทธ๋ฐ๋ฐ ์ด ๋ฌธ์ ์์๋ ํฌํ ์ด์งํธ๋ฆฌ๋ฅผ ๋ง๋ค๊ณ , 0์ธ ๋
ธ๋๋ ์๋ ๋
ธ๋๋ก ์น๊ธฐ ๋๋ฌธ์ ์์์ด 2๊ฐ๊ฐ ๋์ด๊ฐ ๊ฒฝ์ฐ๋ ์๋ค. ๊ทธ๋ ๊ธฐ์ ์ค๊ฐ์ ๋์ด์ก๋์ง(0์ ์์์ค์ 1์ด ์๋์ง)๋ง ๊ฒ์ฌํ๋ฉด ๋๋ค.
๋๋ ์ด ๋ถ๋ถ์ checkํจ์๋ฅผ ํตํด ๊ตฌํํ๋๋ฐ ์๋ ๋ฐฉ์์ ์์๋ฅผ ํตํด ์ดํด๋ณด๋๋ก ํ๊ฒ ๋ค.
์๋์ ๊ฐ์ด ์ฃผํฉ์๋ถ๋ถ์ด ๋น์ด์๋ค๊ณ ๊ฐ์ ํด๋ณด์. ์ด ๊ฒฝ์ฐ ๋์ด์ง ๋ถ๋ถ์ด ์๊ธฐ ๋๋ฌธ์ ์ด์งํธ๋ฆฌ๊ฐ ์ฑ๋ฆฝํ์ง ์๋๋ค.
1011111์ด๋ผ๋ ์์ด์ด ์ฃผ์ด์ก์ ๋ checkํจ์๋ ํด๋น ์์ด์ ์ผ์ชฝ, ๊ฐ์ด๋ฐ, ์ค๋ฅธ์ชฝ์ผ๋ก ๋ถ๋ฆฌํ๋ค.
์ผ์ชฝ: 101
๊ฐ์ด๋ฐ: 1
์ค๋ฅธ์ชฝ: 111
๊ทธ๋ฆฌ๊ณ ๊ฐ์ด๋ฐ๊ฐ 1์ด๋ฉด ์ผ์ชฝ๊ณผ ์ค๋ฅธ์ชฝ ์๋ธํธ๋ฆฌ์ ๋ํด ์ฌ๊ท์ ์ผ๋ก ์ด์งํธ๋ฆฌ๋ฅผ ์ฑ๋ฆฝํ๋์ง ๊ฒ์ฌํ๊ณ , 0์ด๋ผ๋ฉด ์์๋ค์ด ๋ชจ๋ ์๋์ง(0์ธ์ง)๋ฅผ ๊ฒ์ฌํ๋ค.
์ ์์ ์ ๊ฒฝ์ฐ ๊ฐ์ด๋ฐ๊ฐ 1์ด๋ ์ผ์ชฝ๊ณผ ์ค๋ฅธ์ชฝ ์๋ธํธ๋ฆฌ๋ฅผ ๊ฒ์ฌํ๋ ค๊ณ ํ ๊ฒ์ด๋ค.
์ผ์ชฝ ์๋ธํธ๋ฆฌ๋ฅผ ๋ค์ ์ชผ๊ฐ๋ฉด ์๋์ ๊ฐ์ด ๋๋ค.
์ผ์ชฝ: 1
๊ฐ์ด๋ฐ: 0
์ค๋ฅธ์ชฝ: 1
๊ฐ์ด๋ฐ๊ฐ 0์ด๋ ์์๋ค์ด ๋ชจ๋ 0์ธ์ง๋ฅผ ๊ฒ์ฌํ๋ค. ์์๋ค์ด ๋ชจ๋ 0์ด๋ผ๋ฉด ์์ด ์์ฒด๊ฐ 0์ด์ฌ์ผํ๋ ์ธ์๋ก ๋ฐ์ ์์ด(101)์ ์ํํ๋ฉฐ ๋ชจ๋ 0์ธ์ง ๊ฒ์ฌํ๋ค. ๊ทธ๋ฐ๋ฐ ์ธ์๋ก ๋ฐ์ ์์ด(101)์๋ 1์ด ํฌํจ๋์ด์์ผ๋ ์ด์งํธ๋ฆฌ๋ฅผ ์ฑ๋ฆฝํ์ง ์๋๋ค๊ณ ํ๋ณํ๊ฒ ๋๋ค.
์ค์ํ ๊ฒ์ ์ธ์๋ก ๋ค์ด์จ ์์ด์ ๊ธธ์ด๊ฐ 1์ด๋ฉด ์ฌ๊ทํธ์ถ์ ์ค๋จํ๋ ๊ฒ์ด๋ค. ์์ด์ ๊ธธ์ด๊ฐ 1์ด๋ผ๋ ๊ฒ์ ๋ฆฌํ๋
ธ๋๊น์ง ๋๋ฌํ๋ค๋ ๋ป์ด๊ณ , ๋ฆฌํ๋
ธ๋๋ ์์์ด ์๊ธฐ ๋๋ฌธ์ ๋ฃจํธ๊ฐ 1์ด๋ , 0์ด๋ ์ด์งํธ๋ฆฌ ์กฐ๊ฑด์ ๋ง์กฑํ๋ค.
๋ชจ๋ ์ดํดํ๋ค๋ฉด ๋ค์ ๋ถ๋ถ์ผ๋ก ๋์ด๊ฐ๋ ๋์ง๋ง ์ดํด๊ฐ ์๋ ๋ถ๋ถ์ด ์๋ค๋ฉด ์๋ ์์ ๋ ๋ณด๋๋ก ํ์. ์ด๋ฒ ์์ ๋ ์ด์งํธ๋ฆฌ๋ฅผ ์ฑ๋ฆฝํ๋ ๊ฒฝ์ฐ์ด๋ค.
์ฒ์์๋ ์๋์ ๊ฐ์ด ์ชผ๊ฐ์ง ๊ฒ์ด๋ค.
์ผ์ชฝ: 111
๊ฐ์ด๋ฐ: 1
์ค๋ฅธ์ชฝ: 011
์ฌ๊ธฐ์๋ ๊ฐ์ด๋ฐ๊ฐ 1์ด๋ ์ผ์ชฝ๊ณผ ์ค๋ฅธ์ชฝ์ ๋ํด ์ด์งํธ๋ฆฌ ์ฌ๋ถ๋ฅผ ํ๋ณํ๋ค.
์ผ์ชฝ์ ๋ํด ์ด์งํธ๋ฆฌ๋ฅผ ํ๋ณํ๋ฉด ์๋์ ๊ฐ๋ค.
์ผ์ชฝ: 1
๊ฐ์ด๋ฐ: 1
์ค๋ฅธ์ชฝ: 1
๊ฐ์ด๋ฐ๊ฐ 1์ด๋ ์ฌ๊ท์ ์ผ๋ก ์ผ์ชฝ(๊ทธ๋ฆผ์ 4๋ฒ๋
ธ๋)๊ณผ ์ค๋ฅธ์ชฝ(๊ทธ๋ฆผ์ 5๋ฒ ๋
ธ๋) ์๋ธํธ๋ฆฌ์ ๋ํด ์ด์งํธ๋ฆฌ ์ฌ๋ถ๋ฅผ ๊ฒ์ฌํ๊ณ , ํด๋น ๋
ธ๋๋ค์ ๋ฆฌํ๋
ธ๋์ด๋ ์ฌ๊ทํธ์ถ์ ์ค๋จํ๋ค.
์ด์ ์ค๋ฅธ์ชฝ ์๋ธํธ๋ฆฌ(3,6,7๋ฒ ๋
ธ๋๋ค)์ ๋ํด ์ด์งํธ๋ฆฌ ์ฌ๋ถ๋ฅผ ํ๋ณํ๊ฒ ๋๋ค. ๊ทธ๋ฌ๋ฉด ์๋์ ๊ฐ์ด ์ชผ๊ฐ์ง๊ฒ ๋๋ค.
์ผ์ชฝ: 0
๊ฐ์ด๋ฐ: 1
์ค๋ฅธ์ชฝ: 1
๊ฐ์ด๋ฐ ๋
ธ๋๊ฐ 1์ด๋ ์ผ์ชฝ๊ณผ ์ค๋ฅธ์ชฝ์ ๋ํด ์ฌ๊ท์ ์ผ๋ก ์ด์งํธ๋ฆฌ ์ฌ๋ถ๋ฅผ ํ๋ณํ๊ฒ ๋๊ณ ํด๋น ๋
ธ๋๋ค ์ญ์ ๋ฆฌํ ๋
ธ๋์ด๋ ์ฌ๊ทํธ์ถ์ด ์ค๋จ๋๋ค.
๋ชจ๋ ์ฌ๊ทํธ์ถ์ด ์ค๋จ๋ ๋ ๊น์ง ์ด์งํธ๋ฆฌ๊ฐ ์๋๋ผ๋ ๊ฒฐ๊ณผ๊ฐ ๋์จ ์ ์ด ์๊ธฐ ๋๋ฌธ์ ํด๋น ์์ด์ ์ด์งํธ๋ฆฌ๋ฅผ ๋ง์กฑํ๋ค๊ณ ๋ณผ ์ ์๋ค.
์ฝ๋
์ ์ฒด ์ฝ๋๋ ์๋์ ๊ฐ๋ค.
#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
bool isPossible;
string toBinary(long long num){
string st="";
while(num!=0){
st+=to_string(num%2);
num/=2;
}
long long full = floor(log2(st.size()))+1; // ํฌํ ์ด์งํธ๋ฆฌ ์ธต ๊ตฌํ๊ธฐ
for(int i=st.size();i<pow(2,full);i++){ // ํฌํ ์ด์งํธ๋ฆฌ ๋
ธ๋ ์ ๋ง์ถ๊ธฐ ์ํด 0์ถ๊ฐ
st+='0';
}
reverse(st.begin(),st.end());
return st;
}
void check(string binary){ //ํฌํ์ด์งํธ๋ฆฌ๋ฅผ ๋ํ๋ด๋ ๋ฌธ์์ด์ด ์ด์งํธ๋ฆฌ๋ฅผ ์ฑ๋ฆฝํ๋์ง ํ์ธ
if(!isPossible||binary.size()==1)return;
char middle = binary[binary.size()/2];
string left = binary.substr(0,binary.size()/2);
string right=binary.substr(binary.size()/2+1,binary.size()/2);
if(middle=='0'){ //๋ง์ฝ ๊ฐ์ด๋ฐ ์ซ์๊ฐ 0์ด๋ฉด(๋ฃจํธ๊ฐ 0์ด๋ฉด), ์ ์์ ์ซ์๋ 0์ด์ฌ์ผ ํจ. ๋ง์ฝ ๋ฃจํธ๊ฐ 0์ธ๋ฐ ์์์ด ์๋ค๋ฉด ๋์ด์ง ๊ฒ
for(auto c:binary){
if(c!='0'){
isPossible=false;
return;
}
}
}else{ //๊ฐ์ด๋ฐ ์ซ์๊ฐ 1์ด๋ฉด(๋ฃจํธ๊ฐ 1์ด๋ฉด), ์ข์ฐ ์๋ธํธ๋ฆฌ์ ๋ํด ๊ฒ์ฌ
check(left);
check(right);
}
}
vector<int> solution(vector<long long> numbers) {
vector<int> answer;
for(auto num:numbers){
isPossible=true;
string binary=toBinary(num);
check(binary);
isPossible?answer.push_back(1):answer.push_back(0);
}
return answer;
}
'Problem Solving > ํ๋ก๊ทธ๋๋จธ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค] ๋๋๊ณผ ๋ง๋ ๊ทธ๋ํ (C++) (0) | 2025.01.15 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค/C++] ์ ๊ตญ์ฌ์ฌ (1) | 2024.09.29 |