๐ bitmasking ์ฐ์ฐ์ ๋งค์ฐ ๋น ๋ฅธ ์ฐ์ฐ์ผ๋ก O(1)์ time complexity๋ฅผ ๋ณด์ด๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ ๋ง์ด ์ฐ์ด๋ ๊ธฐ๋ฒ ์ค ํ๋
๐ ๋ค๋ง, 0๊ณผ 1์ ์ด์ฉํ 2์ง์ ์ฐ์ฐ์ด๊ธฐ ๋๋ฌธ์ ์ปดํจํฐ๊ฐ ์ค์ ๋ก ์ฐ์ฐํ๋ ํ๋์จ์ด์ ์ธ ์ฑ๊ฒฉ์ด ๋ค์ด๊ฐ๋ฏ๋ก ๋จ์ ์ฐ์ฐ๋ณด๋ค ์ข ๋ ์ ๊ฒฝ์ ์จ์ผ ํจ
๐ ์๋ ๊ฐ๋ ์ ๋ฆฌ ๋งํฌ ์ฐธ์กฐ
๐ ํนํ ์งํฉ ๊ด๋ จ ์ฐ์ฐ์ ์ฌ์ฉํ ๋ bitmasking ๊ธฐ๋ฒ์ด ๋ง์ด ์ฐ์ธ๋ค. ์ฌ๋ฌ ๋ฌธ์ ๋ฅผ ํตํด์ ์ ์ํ๋๋ก ํ์
๐ ๋นํธ ์ฐ์ฐ์ ์๋ 6๊ฐ๋ ํ์์ ์ผ๋ก remind
โ 11723 ์งํฉ โ
๐ ํ์ด์ฌ ์งํฉ set() ๊ด๋ จ ํจ์(add(), discard(), remove(), clear())๋ฅผ ์ฌ์ฉํ๋ ํ์ด๋ ์กด์ฌ
โป set() ๊ด๋ จ ๋ฉ์๋ add(), discard(), remove(), clear(), pop() ๋ชจ๋ time-complexity O(1)์ ๋ณด์ฌ ์ข์ ์ฑ๋ฅ์ ๋ํ๋ธ๋ค. โป
import sys
input=sys.stdin.readline
S=set()
for _ in range(int(input())):
op=input().rstrip()
o=op.split()[0]
if o not in ['all','empty']:
n = int(op.split()[1])
if o=='add':S.add(n)
elif o=='remove':S.discard(n)
elif o=='check':print(1 if n in S else 0)
else:S.remove(n)if n in S else S.add(n)
elif o=='all':S={i for i in range(1,21)}
else:S.clear()
๐ ์ด์ set()๊ฐ ์๋, bitmasking์ผ๋ก code๋ฅผ ํํํด๋ณด๋๋ก ํ๋ฉด,
โ 1๋ถํฐ 20๊น์ง์ ์๊ฐ ๊ฐ๊ฐ ์งํฉ์ ์กด์ฌํ๋ค๋ฉด, ์ด์ง์์ ํด๋น ์๋ฆฌ์๊ฐ 1, ์กด์ฌํ์ง ์๋๋ค๋ฉด ํด๋น ์๋ฆฌ์๋ฅผ 0์ผ๋ก ํํ
(ex) 1๊ณผ 3์ด ์งํฉ์ ์กด์ฌํ๋ค๋ฉด S๋ผ๋ ์๋ฅผ 1010๋ก ํํ)
โป 1<<num ์ฐ์ฐ์์, 1์ด ์กด์ฌํ๋ค๋ฉด 1<<1 ๊ฒฐ๊ณผ๋ก 10์ผ๋ก ํํ๋๋ฏ๋ก
์ด์ง์ ์์์ ๋งจ ๋ง์ง๋ง ์๋ฆฌ๋ 0์ ์๋ฆฌ์, 1์ ์ค๋ฅธ์ชฝ ๊ธฐ์ค ๋๋ฒ์งธ ์๋ฆฌ์,
2๋ ์ค๋ฅธ์ชฝ ๊ธฐ์ค ์ธ๋ฒ์งธ ์๋ฆฌ์๋ก ์ค์ โป
(<<์ฐ์ฐ์์ ํธ์์ฑ์ ์ํด ์ด๋ ๊ฒ ์ ์ ๋ฅผ ๋ง๋ ๋ค ์งํํจ์ ์์ง ๋ง์!)
โก 1๋ถํฐ 20์ฌ์ด์ ์ x๋ฅผ ์ถ๊ฐํ๋ add ์ฐ์ฐ
→ 1010์์ 2๋ฅผ ์ถ๊ฐํ๋ค๋ฉด ๋๋ฒ์งธ ์๋ฆฌ์๊ฐ 1๋ก ๋ณํ๋ฉด์ 1110๋ก ๋์ด์ผ ํ๋ค.
→ idea) ๊ธฐ์กด 1010์์ 1์ << ์ฐ์ฐ์๋ก ์ x์ ๋ง๊ฒ ์ฎ๊ธด ๋ค(0100), 1010๊ณผ 0100์ or | ์ฐ์ฐ ๊ฒฐ๊ณผ๋ก 111๋ก ๋ฐ๊พผ๋ค.
S=S|(1<<num)
โข 1๋ถํฐ 20์ฌ์ด์ ์ x๋ฅผ ์ ๊ฑฐํ๋ remove ์ฐ์ฐ
→ 1010์์ 3์ ์ ๊ฑฐํ๋ค๋ฉด ์ธ๋ฒ์งธ ์๋ฆฌ์๊ฐ 0์ผ๋ก ๋ณํ๋ฉด์ 0010๋ก ๋์ด์ผ ํ๋ค
→ idea) ๊ธฐ์กด 1010์์ 1์ << ์ฐ์ฐ์๋ก ์ x์ ๋ง๊ฒ ์ฎ๊ธด ๋ค(1000), ~ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํด 1๊ณผ 0์ ์๋ก ๋ฐ๊พผ ๋ค์(0110), 1010๊ณผ 0110์ and & ์ฐ์ฐ ๊ฒฐ๊ณผ๋ก 0010๋ก ๋ฐ๊พผ๋ค.
S=S&~(1<<num)
โฃ 1๋ถํฐ 20์ฌ์ด์ ์ x๊ฐ ์๋ ์ง ํ์ธํ๋ check ์ฐ์ฐ
→ idea) 1010์์ 3์ด ์กด์ฌํ๋ ์ง ์๊ณ ์ถ๋ค๋ฉด, ๊ธฐ์กด 1010์์ 1์ << ์ฐ์ฐ์๋ก ์ x์ ๋ง๊ฒ ์ฎ๊ธด ๋ค(1000), 1010๊ณผ 1000์ and & ์ฐ์ฐ์ ์งํํด ์ค๋ค. ๋ง์ฝ ์กด์ฌํ๋ค๋ฉด & ์ฐ์ฐ์ผ๋ก 1๊ณผ 1์ ๊ฒฐ๊ณผ 1์ด ๋์ค๊ณ , ์กด์ฌํ์ง ์๋๋ค๋ฉด 1๊ณผ 0์ ๊ฒฐ๊ณผ 0์ด ๋์จ๋ค.
1 if S&(1<<num) else 0
โค 1๋ถํฐ 20์ฌ์ด์ ์ x๊ฐ ์งํฉ์ ์์ผ๋ฉด ์ญ์ , ์์ผ๋ฉด ์ถ๊ฐํ๋ toggle ์ฐ์ฐ
→ idea) 1010์์ 3์ด ์กด์ฌํ๋ค๋ฉด ์ญ์ , 3์ด ์๋ค๋ฉด ์ถ๊ฐํ๊ณ ์ถ๋ค๋ฉด, ๊ธฐ์กด 1010์์ 1์ << ์ฐ์ฐ์๋ก ์ x์ ๋ง๊ฒ ์ฎ๊ธด ๋ค(1000), 1010๊ณผ 1000์ xor ^ ์ฐ์ฐ์ ์งํํด์ค๋ค. ^ ์ฐ์ฐ์ 1๊ณผ 0 ์๋ก ๋ค๋ฅด๋ค๋ฉด 1, 0๊ณผ 0 ๋๋ 1๊ณผ 1์ด๋ผ๋ฉด 0์ ์ถ๋ ฅํด์ฃผ๋ ์ฐ์ฐ์ด๋ค.
→ (1) ๋ฃ๊ณ ์ถ์ ์์ ์๋ฆฌ์์์(1), ์๋ ์์ ๋ง์ฝ ์์ ๊ฒฝ์ฐ(0), xor ์ฐ์ฐ ๊ฒฐ๊ณผ(0๊ณผ 1) 1์ด ๋์ด ์๊ธฐ๊ณ
→ (2) ๋ฃ๊ณ ์ถ์ ์์ ์๋ฆฌ์์์(1), ์๋ ์์ ๋ง์ฝ ์์ ๊ฒฝ์ฐ(1), xor ์ฐ์ฐ ๊ฒฐ๊ณผ(1๊ณผ 1) 0์ด ๋์ด ์ฌ๋ผ์ง๋ค.
S=S^(1<<num)
โฅ ๋ชจ๋ ์๊ฐ ์งํฉ์ ์กด์ฌํ๊ฒ ๋ง๋๋ all ์ฐ์ฐ / ๋ชจ๋ ์๊ฐ ์กด์ฌํ์ง ์๊ฒ ๋ง๋๋ empty ์ฐ์ฐ
→ idea) 1๋ถํฐ 20๊น์ง ๋ชจ๋ ์๊ฐ ์กด์ฌํ๋ ์ด์ง์๋ 111111111111111111110์ด๋ค. ์ด๋ 1์ 21๋ฒ์งธ ์๋ฆฌ์๋ก ์ฎ๊ธด ๊ฒฐ๊ณผ(1<<21; 1000000000000000000000)์์ 2๋ฅผ ๋นผ๋ฉด ์ํ๋ ์ด์ง์ 111111111111111111110๊ฐ ๋์จ๋ค. ((1<<21)-2)
S=(1<<21)-2
โป ์ฃผ์ โป
<<์ ์ฐ์ ์์๊ฐ ๋บ์ (-)๋ณด๋ค ๋ฎ์ผ๋ฏ๋ก ๋ฐ๋์ ๊ดํธ๋ฅผ ํด์ผ ํ๋ค!
→ idea) ๋ชจ๋ ์๊ฐ ์กด์ฌํ์ง ์์ผ๋ ค๋ฉด ๋ชจ๋ ์๋ฆฌ์๊ฐ 0์ด๋ฏ๋ก S=0
S=0
๐ ์ add, remove, check, toggle, all, empty ์ฐ์ฐ์ ๋ง๊ฒ bitmasking์ผ๋ก code๋ฅผ ์ง๋ณด๋ฉด ์ ๋ฆฌํ๋ฉด ์๋์ ๊ฐ๋ค
import sys
input=sys.stdin.readline
S=0
for _ in range(int(input())):
op=input().rstrip()
o=op.split()[0]
if o not in ['all','empty']:
num = int(op.split()[1])
if o=='add': #S์ x์ถ๊ฐ
S=S|(1<<num)
elif o=='remove':#S์ x์ ๊ฑฐ
S=S&~(1<<num)
elif o=='check':#S์ x๊ฐ ์์ผ๋ฉด 1, ์์ผ๋ฉด 0 ์ถ๋ ฅ
print(1 if S&(1<<num) else 0) #0b0์ด๋ฉด False, 1์ด์์ด๋ฉด True
else:#toggle S์ x๊ฐ ์์ผ๋ฉด x์ ๊ฑฐ, ์์ผ๋ฉด x ์ถ๊ฐ
S=S^(1<<num)
elif o=='all':S=(1<<21)-2
else:#empty
S=0
โ 14569 ์๊ฐํ ์ง๊ธฐ โ
import sys
input=sys.stdin.readline
l=[]
for _ in range(int(input())):
yonsei_class=list(map(int,input().split()))
class_code=0
for i in range(1,yonsei_class[0]+1):
class_code=class_code|(1<<yonsei_class[i])
l.append(class_code)
for student in range(int(input())):
student_empty=list(map(int,input().split()))
student_empty_code=0
subject=0
for i in range(1,student_empty[0]+1):
student_empty_code=student_empty_code|(1<<student_empty[i])
for code in l:
if code == (code&student_empty_code): subject+=1
print(subject)
๐ bitmasking ๊ธฐ๋ฒ์ ์ฌ์ฉํ๋ฉด code ์คํ ์๊ฐ์ ํ์คํ ๋จ์ถ ์ํฌ ์ ์๋ค(ํ ํ์ด ์คํ ์๊ฐ๋ณด๋ค ํจ์ฌ ์ ๊ฒ ๋์์)
๐
โ ๋จผ์ ๊ฐ ๊ณผ๋ชฉ๋ณ๋ก class_code๋ฅผ ๋ง๋ ๋ค
(ex) ํด๋น ๊ณผ๋ชฉ์ด 2,3๊ต์์ ์์ ํ๋ค๋ฉด class_code๋ 2์ง์๋ก 1100์ผ๋ก ํํ)
→ ๊ทธ๋ฆฌ๊ณ ๋ชจ๋ ๊ณผ๋ชฉ์ class_code๋ฅผ l list์ ๋ฃ์
class_code=class_code|(1<<yonsei_class[i])
โป << ์ฐ์ฐ์์ ๊ธฐ์กด class_code์์ | ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํด class_code๋ฅผ ์์ฑ โป
โก ๋์ผํ ๋ฐฉ์์ผ๋ก ์ด์ ๊ฐ ํ์๋ณ student_empty_code๋ฅผ ๋ง๋ ๋ค
(ex) ์๋ฅผ ๋ค์ด ํ ํ์์ 2,3๊ต์์ ์ฐ๋ค๋ฉด student_empty_code๋ 2์ง์๋ก 1100์ผ๋ก ํํ)
student_empty_code=student_empty_code|(1<<student_empty[i])
โข ์ด์ class_code์ student_empty_code์ ๋น๊ต
(ex) class_code๊ฐ 1100์ด๊ณ , student_empty_code๊ฐ 11100์ด๋ผ๋ฉด, & ์ฐ์ฐ์ ๊ฒฐ๊ณผ 1100 ์ฆ class_code๊ฐ ๋๋ค. ์ด ๋ป์ ๊ธฐ์กด class_code์์ 1์ด ์๋ ์๋ฆฌ์ ํ์์ด ์ฐ๋ค๋ฉด, ์ฆ 1์ด ์๋ค๋ฉด 1 & 1 ๊ฒฐ๊ณผ๋ก ๊ณ์ 1์ด ๋์ด ๋จ๊ฒ ๋จ. ๋ฐ๋ผ์ class_code๋ก ๊ทธ๋๋ก ๋จ๋ ๋ค๋ฉด, ํด๋น ํ์์ ์ด class๋ฅผ ๋ค์ ์ ์๋ค๋ ๋ป!)
if code == (code&student_empty_code): subject+=1
โ 1094 ๋ง๋๊ธฐ โ
print(bin(int(input()))[2:].count('1'))
๐ ์ฃผ์ด์ง ์ซ์๊ฐ 2์ ์ ๊ณฑ์์ ํด๋น๋๋, ๋ช ๊ฐ์ ๋๋ฌด ์ข ๋ฅ๋ก X๋ฅผ ๋ํ๋ผ ์ ์๋ ์ง ์์๋ณด๋ ๋ฌธ์ . ์๋ฅผ ๋ค์ด 23์ ์ด์ง์๋ก ๋ํ๋์ ๋ 10111์ด๋ฏ๋ก ์ด 4๊ฐ์ ๋๋ฌด ์ข ๋ฅ์ ํฉ์ผ๋ก 23์ ๋ํ๋ผ ์ ์๋ค. ๋ฐ๋ผ์ 2์ง์๋ก ๋ํ๋์ ๋ 1์ ๊ฐ์๊ฐ ์ ๋ต. 2์ ์ ๊ณฑ์์ ํฉ ํํ์ ๋นํธ๋ง์คํฌ ๊ธฐ๋ฒ์ ์ฌ์ฉํด์ผ ํ๋ ์ง๊ด ๊ธฐ์ต
'BOJ > ๐ฅ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
โ PQ ์ค์๊ธ - 6๋ฌธ์ ()โ (0) | 2023.01.11 |
---|---|
โ Stack & Queue & Deque Upper-Intermediate I - 12 Solvedโ (0) | 2023.01.08 |
โ DP Upper-Intermediate I - 15 Solvedโ (0) | 2023.01.03 |
โ DP Intermediate I - 20 Solvedโ (0) | 2022.12.22 |
โ Sorting Upper-Intermediate I - 6 Solvedโ (1) | 2022.12.20 |
๋๊ธ