๋นํธ๋ง์คํฌ (BitMask)
๐น ๋นํธ๋ง์คํฌ(BitMask)๋ ?
- ์ปดํจํฐ๋ ๋ด๋ถ์ ์ผ๋ก ๋ชจ๋ ์๋ฃ๋ฅผ ์ด์ง์(๋นํธ)๋ก ์ฒ๋ฆฌํ๋ค.
- ์ด๋ฐ ์ปดํจํฐ์ ์ฐ์ฐ ๋ฐฉ์์ ํ์ฌ ์ด์ง์์ ๋นํธ ๋จ์๋ก ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ ๊ธฐ๋ฒ์ด๋ค.
๐น ๋นํธ(Bit)๋ ?
- ๋นํธ๋ ์ด์ง์(0๊ณผ 1๋ก ๊ตฌ์ฑ๋ ์)๋ฅผ ๋ํ๋ด๋ ๋ง๋ก ์ปดํจํฐ์์ ์ฌ์ฉํ๋ ๋ฐ์ดํฐ์ ์ต์ ๋จ์์ด๋ค.
- ๋นํธ๋ 1๊ณผ 0์ ๊ฐ์ ๊ฐ์ง ์ ์๊ณ , true(1) ๋๋ false(0)๋ผ๋ ์ํ๋ฅผ ๋ํ๋ผ ์๋ ์๋ค.
- ์ฐ๋ฆฌ๊ฐ ์ฌ์ฉํ๋ 10์ง์๋ 0๊ณผ 1๋ก ๊ตฌ์ฑ๋ ๋นํธ(์ด์ง์)๋ก ํํ์ด ๊ฐ๋ฅํ๋ค.
๐น ์ ๋นํธ๋ง์คํฌ๋ฅผ ์ฌ์ฉํ ๊น?
- ๋ค๋ฅธ ์๋ฃ ๊ตฌ์กฐ์ ๋นํด ์ํ์๊ฐ์ด ๋น ๋ฅด๋ค.
- ๋๋ถ๋ถ์ ์ฐ์ฐ์ด O(1)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ค.
- ํน์ ์์์ ์กด์ฌ ์ฌ๋ถ๋ฅผ ํ๋จํ ๋, ์ ํ ํ์ํ ํ์ ์์ด AND ์ฐ์ฐ ๊ฒฐ๊ณผ๊ฐ 0์ด ์๋์ง ์ฒดํฌํ์ฌ ๊ฒ์ฌํ๋ค.
- ๋นํธ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ์ฌ ์ฝ๋๊ฐ ๋ ๊ฐ๊ฒฐํด์ง๋ค.
- ์งํฉ์ ๋ฐฐ์ด์ ์ธ๋ฑ์ค๋ก ํํํ ์ ์๋ค.
- ๋นํธ๋ง์คํฌ๋ฅผ ์ฌ์ฉํ์ฌ ๋ ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
- boolean type์ผ๋ก ๋ฐฐ์ด์ ๋ฐฉ๋ฌธ ์ฒดํฌ๋ฅผ ํ๋ ๊ฒฝ์ฐ 1byte๋ฅผ ์ฌ์ฉํ์ง๋ง, ๋นํธ๋ง์คํน์ ์ฌ์ฉํ๋ฉด 1bit๋ก ๋ฐฉ๋ฌธ ์ฒดํฌํจ์ผ๋ก์จ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ค์ผ ์ ์๋ค.
- DP, ์์ด ๋ฑ ๋ฐฐ์ด ํ์ฉ๋ง์ผ๋ก ํด๊ฒฐํ ์ ์๋ ๋ฌธ์
๐น ๋นํธ ์ฐ์ฐ
โฝ AND ์ฐ์ฐ : A & B
A = 27, B = 83์ธ ๊ฒฝ์ฐ, A์ B๋ฅผ ์ด์ง์๋ก ํํํ๋ฉด ์๋์ ๊ฐ๋ค.
A = 11011, B = 1010011
AND ์ฐ์ฐ ์ ์ฉ
0 0 1 1 0 1 1
& 1 0 1 0 0 1 1
---------------------
0 0 1 0 0 1 1
์ถ๋ ฅ : A & B = 19
- AND ์ฐ์ฐ์ ๊ฒฝ์ฐ ๊ฐ ์๋ฆฟ์๋ฅผ ๋น๊ตํ์ฌ ๋ ๋นํธ ๋ชจ๋ 1์ธ ๊ฒฝ์ฐ 1์ ๋ฐํํ๋ค.
- ์์ ์ A์ B๋ ์๋ฆฟ์๊ฐ ๋ค๋ฅด๋ฏ๋ก ์ด๋ฅผ ๋ง์ถฐ์ฃผ๊ธฐ ์ํด A์ ์์ 0์ ์ถ๊ฐํ์ฌ B์ ์๋ฆฟ์๋ฅผ ๋ง์ถฐ์ค๋ค.
โฝ OR ์ฐ์ฐ : A | B
A = 27, B = 83์ธ ๊ฒฝ์ฐ, A์ B๋ฅผ ์ด์ง์๋ก ํํํ๋ฉด ์๋์ ๊ฐ๋ค.
A = 11011, B = 1010011
OR ์ฐ์ฐ ์ ์ฉ
0 0 1 1 0 1 1
| 1 0 1 0 0 1 1
---------------------
1 0 1 1 0 1 1
์ถ๋ ฅ : A | B = 91
- OR ์ฐ์ฐ์ ๋ ๋นํธ ์ค ํ ๊ฐ๋ผ๋ 1์ธ ๊ฒฝ์ฐ 1์ ๋ฐํํ๋ค.
โฝ XOR ์ฐ์ฐ : A ^ B
A = 27, B = 83์ธ ๊ฒฝ์ฐ, A์ B๋ฅผ ์ด์ง์๋ก ํํํ๋ฉด ์๋์ ๊ฐ๋ค.
A = 11011, B = 1010011
XOR ์ฐ์ฐ ์ ์ฉ
0 0 1 1 0 1 1
^ 1 0 1 0 0 1 1
---------------------
1 0 0 1 0 0 0
์ถ๋ ฅ : A ^ B = 72
- XOR ์ฐ์ฐ์ ๋ ๋นํธ๊ฐ ์๋ก ๋ค๋ฅผ ๊ฒฝ์ฐ 1์ ๋ฐํํ๋ค.
โฝ NOT ์ฐ์ฐ : ~ A (๋ณด์)
A = 83์ธ ๊ฒฝ์ฐ, A๋ฅผ ์ด์ง์๋ก ํํํ๋ฉด ์๋์ ๊ฐ๋ค.
A = 01010011
NOT ์ฐ์ฐ ์ ์ฉ
8 ๋นํธ ~A : 10101100
32๋นํธ ~A : 11111111111111111111111110101100
์ถ๋ ฅ : 172(Unsigned), -84(Signed)
- NOT ์ฐ์ฐ์ ๊ฒฝ์ฐ ์ฌ์ฉํ๋ ๋ฐ์ดํฐ์ ์๋ฃํ์ ๋ฐ๋ผ ๊ฒฐ๊ณผ๊ฐ ๋ฌ๋ผ์ง ์ ์๋ค. ์ฃผ๋ก ์ฌ์ฉ๋๋ ๋ฐ์ดํฐ์ ์๋ฃํ์ signed์ unsigned์ด ์๋ค.
- NOT ์ฐ์ฐ์ ์ด์ง์์ ๊ฐ ๋นํธ๋ฅผ ๋ฐ์ ์ํค๋ ์ฐ์ฐ์ด๋ค. ๊ฐ ๋นํธ๋ฅผ 0์ 1๋ก, 1์ 0์ผ๋ก ๋ฐ๊พผ๋ค.
โฝ Left Shift : A << B
A << B
A๋ฅผ B๋งํผ ์ผ์ชฝ์ผ๋ก ๋ฐ์ด์ค๋ค๋ ์๋ฏธ์ ์์ด๋ค.
๋ฐ์ด์ค ๋งํผ ๋์์ 0์ ์ถ๊ฐํด ์ค๋ค.
1 << 0 : 1
1 << 1 : 2 (10)
1 << 2 : 4 (100)
1 << 3 : 8 (1000)
1 << 4 : 16 (10000)
3 << 3 : 24 (11000)
5 << 10 : 5120 (1010000000000)
- A << B ์์ A * 2์ B ์ ๊ณฑ๊ณผ ๊ฐ๋ค.
โฝ Right Shift : A >> B
A >> B
A๋ฅผ B๋งํผ ์ค๋ฅธ์ชฝ์ผ๋ก ๋ฐ์ด์ค๋ค๋ ์๋ฏธ์ ์์ด๋ค.
๋ฐ์ด์ค ๋งํผ ๋์์ 0์ ์ถ๊ฐํด ์ค๋ค.
1 >> 0 : 1
1 >> 1 : 0 (0)
10 >> 1 : 5 (101)
10 >> 2 : 2 (10)
10 >> 3 : 1 (1)
30 >> 1 : 15 (1111)
1024 >> 10 : 1 (1)
- A >> B ์์ A / 2์ B ์ ๊ณฑ๊ณผ ๊ฐ๋ค.
๐น ๋นํธ๋ง์คํฌ๋ฅผ ์ด์ฉํ ์งํฉ ๊ตฌํ
๋นํธ๋ง์คํฌ๋ฅผ ์ด์ฉํ ์งํฉ ๊ตฌํ์ ๊ฐ์ฅ ๋ํ์ ์ด๊ณ , ์์ฃผ ์ฐ์ด๋ ๋ฐฉ๋ฒ์ด๋ค.
ํ๋์ bit๊ฐ ํ๋์ ๋ฐ์ดํฐ ์ํ๋ฅผ ์๋ฏธํ๋ค. bit๊ฐ 1์ด๋ฉด ํด๋น ์์๊ฐ ์งํฉ์ ํฌํจ๋์ด ์๋ค๋ ์๋ฏธ์ด๊ณ , 0์ด๋ฉด ํฌํจ๋์ด ์์ง ์๋ค๋ ์๋ฏธ์ด๋ค.
๋ฐ๋ผ์ N๋นํธ๋ N๊ฐ์ ์์๋ฅผ ๊ฐ๋ ์งํฉ์ ๋ถ๋ถ ์งํฉ๋ค์ ๋ชจ๋ ํํํ ์ ์๋ค.
โฝ ๊ณต์งํฉ๊ณผ ๊ฝ ์ฐฌ ์งํฉ ๊ตฌํ๊ธฐ
int A = 0;
A = (1 << 10) - 1; // 1023
- ๊ธฐ๋ณธ์ ์ผ๋ก ๊ณต์งํฉ์ bit๊ฐ ๋ชจ๋ ๊บผ์ง ์ํฉ์ด๊ธฐ ๋๋ฌธ์ ์์ 0์ด ๊ณต์งํฉ์ ํํํ๋ค.
- ๋ฐ๋๋ก ๊ฝ ์ฐฌ ์งํฉ์ bit๊ฐ ๋ชจ๋ ์ผ์ง ์ํฉ์ด๊ธฐ ๋๋ฌธ์ 1111111111์ ๊ฐ์ผ๋ก ํํํ๋ค
โฝ ์์ ์ถ๊ฐ
A |= (1 << k)
- A ์งํฉ์ ํน์ ์์๋ฅผ ์ถ๊ฐํ๋ ๋ฐฉ๋ฒ์ด๋ค.
- ์์์ ํด๋นํ๋ bit๋ง ์ผ์ผ ํ๊ธฐ ๋๋ฌธ์ ํด๋น bit๋ฅผ ํญ์ 1๋ก ๋ง๋ค๊ธฐ ์ํด OR ์ฐ์ฐ์ ์ด์ฉํ๋ค.
โฝ ์์ ์ญ์
A &= ~(1 << k)
- A ์งํฉ์ ํฌํจ๋ ํน์ ์์๋ฅผ ์ญ์ ํ๋ ๋ฐฉ๋ฒ์ด๋ค.
- A์ k๋ฒ์งธ ์์์ ํฌํจ ์ฌ๋ถ์ ์๊ด์์ด ํด๋น bit๋ฅผ ๋๊ธฐ ์ํด AND ์ฐ์ฐ์ ์ด์ฉํ๋ค,
- 1 << k : k๋ฒ์งธ ์์น์ ๋นํธ๋ฅผ 1๋ก ์ค์
- ~(1 << k) : k๋ฒ์งธ ์์น์ ๋นํธ๋ฅผ 0์ผ๋ก ๋ง๋ฆ (๋ฐ์ )
- A & ~(1 << k) : A ์งํฉ์ ๋ด๊ธด k๋ฒ์งธ ๋นํธ๋ฅผ 0์ผ๋ก ์ค์
โฝ ์์์ ํฌํจ ์ฌ๋ถ ํ์ธ
if ((A & (1 << k)) == (1 << k))
- A ์งํฉ์ ํน์ ์์๊ฐ ํฌํจ๋์ด ์๋์ง ํ์ธํ๋ ๋ฐฉ๋ฒ์ด๋ค.
- k๋ฒ์งธ ์์๊ฐ ํฌํจ๋์ด ์๋์ง ํ์ธํ๊ณ ์ถ๋ค๋ฉด, k๋ฒ์งธ ๋นํธ๊ฐ ์ผ์ ธ ์๋์ง ํ์ธํ๋ฉด ๋๋ค.
- A & (1 << k) : ์งํฉ A์์ k๋ฒ์งธ ์์น์ ๋นํธ๊ฐ 1์ธ์ง ํ์ธ
- (A & (1 << k)) == (1 << k) : AND ์ฐ์ฐ์ ๊ฒฐ๊ณผ๊ฐ 1 << k๊ณผ ๊ฐ์์ง ๋น๊ต
โฝ ์์์ ํ ๊ธ
A ^= (1 << k)
- A ์งํฉ์ ํด๋น ์์๊ฐ ๋น ์ ธ์๋ ๊ฒฝ์ฐ ์ถ๊ฐํ๊ณ , ๋ค์ด์๋ ๊ฒฝ์ฐ ์ญ์ ํ๋ ๋ฐฉ๋ฒ์ด๋ค.
- XOR ์ฐ์ฐ์ ์ด์ฉํ๋ค.
โฝ ๋ ์งํฉ์ ๋ํด ์ฐ์ฐํ๊ธฐ
A | B // A์ B์ ํฉ์งํฉ
A & B // A์ B์ ๊ต์งํฉ
A & (~B) // A์์ B๋ฅผ ๋บ ์ฐจ์งํฉ
A ^ B // A์ B ์ค ํ๋์๋ง ํฌํจ๋ ์์๋ค์ ์งํฉ
- ๋ ์งํฉ์ A์ B๋ผ๊ณ ํ๋ค๋ฉด, ๋นํธ ์ฐ์ฐ์๋ค์ ํตํด A์ B์ ํฉ์งํฉ, ๊ต์งํฉ, ์ฐจ์งํฉ ๋ฑ์ ๊ตฌํ ์ ์๋ค.
โฝ ์งํฉ์ ํฌ๊ธฐ ๊ตฌํ๊ธฐ
int bitCount(int A) {
if (A == 0) return 0;
return A % 2 + bitCount(A / 2);
|
// ๋ด์ฅ ๋ช ๋ น์ด
Integer.bitCount(A)
- ์งํฉ์ ํฌํจ๋ ์์์ ํฌ๊ธฐ๋ฅผ ๊ตฌํ๋ค๋ฉด A์ ์ผ์ง bit ์๋ฅผ ๊ตฌํ๋ฉด ๋๋ค.
- ์ง์ ๋ชจ๋ ๋นํธ๋ฅผ ํ์ธํ๋ฉด์ ๊ฐ์๋ฅผ ์ฒดํฌํ ์ ์๊ณ , ๋ด์ฅ ๋ช
๋ น์ด๋ฅผ ์ด์ฉํ ์๋ ์๋ค.
- if (A == 0) return 0 : A๊ฐ 0์ด๋ฉด ์ด์ง์๋ก '0'์ด๊ธฐ ๋๋ฌธ์ 1์ ๊ฐ์๋ 0๊ฐ์ด๋ค.
- return A % 2 + bitCount(A / 2)
- A % 2 : A์ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ๋นํธ๊ฐ 1์ธ์ง 0์ธ์ง ํ์ธ
- A / 2 : A๋ฅผ ์ค๋ฅธ์ชฝ์ผ๋ก 1๋นํธ ์ด๋ํ ๊ฒ๊ณผ ๊ฐ์
- ์ด๋ฅผ ์ฌ๊ท์ ์ผ๋ก ๋ชจ๋ ๋นํธ๊ฐ ์ฒ๋ฆฌ๋ ๋๊น์ง ๋ฐ๋ณต
โฝ ์ต์ ์์ ์ฐพ๊ธฐ
int first = A & (-A)
- ์งํฉ์ ํฌํจ๋ ๊ฐ์ฅ ์์ ์์๋ฅผ ์ฐพ๋ ๋ฐฉ๋ฒ์ด๋ค.
- ์ฆ, ์ผ์ ธ ์๋ bit ์ค์์ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ์ ์๋ bit๋ฅผ ์ฐพ๋ ๊ฒ์ด๋ค.
- ๋นํธ๋ง์คํฌ๋ฟ๋ง ์๋๋ผ ํ์
ํธ๋ฆฌ(Fenwick Tree)์์๋ ์ฌ์ฉ๋๋ ๊ธฐ๋ฒ์ด๋ค.
- ์๋ฅผ ๋ค์ด, A = 12์ธ ๊ฒฝ์ฐ A๋ฅผ ์ด์ง์๋ก ํํํ๋ฉด 1100์ด๋ค.
- -A์ ์ด์ง์ ํํ : '~A + 1' (๋นํธ NOT ์ฐ์ฐ ํ 1์ ๋ํด์ค๋ค.)
- ~A : 0011 (๋นํธ ๋ฐ์ )
- ~A + 1 : 0100 (๋ฐ์ ๋ ๊ฐ์ 1์ ๋ํจ)
- A & -A : 1100 & 0100 = 0100
- ์ด๋, ๊ฐ์ฅ ์ค๋ฅธ์ชฝ์ ์๋ 1 ๋นํธ๋ฅผ ์ฐพ์ ๋ฐํํ๋ค.
- ์ถ๋ ฅ : 4
โฝ ์ต์ ์์ ์ง์ฐ๊ธฐ
A &= (A - 1)
- ์งํฉ์ ํฌํจ๋ ๊ฐ์ฅ ์์ ์์๋ฅผ ์ง์ฐ๋ ๋ฐฉ๋ฒ์ด๋ค.
- ์๋ฅผ ๋ค์ด, A = 12์ธ ๊ฒฝ์ฐ A๋ฅผ ์ด์ง์๋ก ํํํ๋ฉด 1100์ด๋ค.
- A - 1 : 1011
- A &= (A - 1) : 1000
๐ reference