- ์ด๋ถํ์
- ํ๋ก๊ทธ๋๋จธ์ค
- LCs
- Union-Find
- ์นด์นด์ค2021
- C++
- ๋์ ํ๋ก๊ทธ๋๋ฐ
- js
- ์ฌ๋ผ์ด๋ฉ ์๋์ฐ
- ์นด์นด์ค ์ฝํ
- ์ํฐ๋
- ์น๋ฆฐ์ด
- ๊ฐ์ฅ๊ฐ๊น์ด๊ณตํต์กฐ์
- DFS
- DP
- BFS
- ๋นํธ๋ง์คํน
- ์์ฝ๋
- ์๊ณ ๋ฆฌ์ฆ
- Python
- ๋นํธ๋งต
- ์ฌ๊ท
- ํธ๋ฆฌ
- nestjs
- golang
- ํ๋ฆฌ์จ๋ณด๋ฉ
- go
- ๋ฐฑ์๋ ํ๋ฆฌ์จ๋ณด๋ฉ
- ๋ค์ต์คํธ๋ผ
- ๋ฐฑ์ค
- Today
- Total
Hello Ocean! ๐ผ
[์คํฐ๋] ๋นํธ์กฐ์ , ์์ ํ์ ๋ณธ๋ฌธ
๋นํธ ์กฐ์
๋นํธ ์ฐ์ฐ์
AND
- ๋ ๋ค 1์ด๋ฉด 1, ๋ ์ค ํ๋๋ผ๋ 0์ด๋ฉด 0์ด๋ค.
- 1010 AND 1110 = 1010
- ์ฐ์ฐ์ : &
OR
- ๋ ์ค ํ๋๋ผ๋ 1์ด๋ฉด 1, ๋๋ค 0์ด๋ฉด 0์ด๋ค.
- 1010 OR 1110 = 1110
- ์ฐ์ฐ์ : |
NOT
- ๋ชจ๋ bit๊ฐ์ ๋ฐ๋๋ก ๋ฐ๊พผ๋ค
- NOT ( 1010 ) = 0101
- ์ฐ์ฐ์ : ~
XOR
- ๊ฐ์ด ๊ฐ์ผ๋ฉด 0, ๋ค๋ฅด๋ฉด 1์ด๋ค.
- 1010 XOR 1110 = 0100
- ์ฐ์ฐ์ : ^
๋นํธ ์ํํธ
- ์ฐ์ ์ฐ์ธก ์ํํธ
- ๊ฐ์ 2๋ก ๋๋ ๊ฒ๊ณผ ๊ฐ๋ค.
- ์ฐ์ฐ์ : >>
- ๋ถํธ ๋นํธ๋ ๋ฐ๋์ง ์์.
- ๋
ผ๋ฆฌ ์ฐ์ธก ์ํํธ
- ์ผ๋ฐ์ ์ผ๋ก ๋นํธ๋ฅผ ์ฎ๊ธธ ๋ ์ฒ๋ผ ๋์ํ๋ค.
- ์ฐ์ฐ์ : >>>
- ๋นํธ๋ฅผ ์ฐ์ธก์ผ๋ก์ฎ๊ธด ํ์, ์ต์์ ๋นํธ์ 0์ ๋ฃ๋๋ค.
์ถ๊ฐ ์ ๋ณด
- 0s : ๋ชจ๋ bit๊ฐ 0
- 1s : ๋ชจ๋ bit๊ฐ 1
2์ ๋ณด์, ์์
- ์ปดํจํฐ๋ ์ผ๋ฐ์ ์ผ๋ก ์ ์๋ฅผ 2์ ๋ณด์ ํํ๋ก ์ ์ฅํ๋ค.
- ์์์ ๋ํด์๋, ๋ถํธ๋นํธ๋ฅผ 1๋ก ์ธํ ํ ํ 2์ ๋ณด์๋ฅผ ์ทจํ ํํ๋ก ํํํ๋ค.
- n๋นํธ ์ซ์์ ๋ํ 2์ ๋ณด์๋, 2์ n์น์ ๋ํ ๋ณด์์ ๊ฐ๋ค.
C++ ์์์ ๋นํธ ์กฐ์
- std::bitset์ ์ฌ์ฉํ๋ ค๋ฉด, header๋ฅผ ํฌํจํด์ผ ํ๋ค.
๋นํธ ์กฐ์ ์๊ณ ๋ฆฌ์ฆ
- ์ฝ๋ฉ ์ธํฐ๋ทฐ ์ค๋น์์ ๋ฅ์ํ ๋นํธ์กฐ์ ๋ฅ๋ ฅ์ ์ค์ํ๋ค.
Get
- ํน์ ์์น์ ์๋ bit๊ฐ์ ๊ฐ์ ธ์จ๋ค.
- idx = 0์, LSB์ ์์น๋ฅผ ์๋ฏธํ๋ค.
bool getBit(int num, int idx){
return (1<<idx)& num != 0;
}
์ ๋ ฅ
๋์ ์ซ์, bit๋ฅผ ๊ฐ์ ธ์ค๊ณ ์ ํ๋ ์์น
์ถ๋ ฅ
0 or 1 (boolean value)
์ด ๋ ๊ฐ์ ๊ฐ์ ธ์ค๊ณ ์ ํ๋ ์์น๋ LSB์์ 0์ด๋ค.
Set
- ํน์ ์์น์ bit๊ฐ์ 1๋ก ์ค์ ํ๋ค.
int setBit(int num, int idx){
return num | (1 << idx);
}
Clear
- ํน์ ์์น์ bit๊ฐ์ ์ง์ด๋ค. (0์ผ๋ก ์ค์ ํ๋ค.)
int clearBit(int num, int idx){
int mask = ~(1 << idx);
return num & mask;
}
- ํ ๊ฐ๊ฐ ์๋, ํน์ ๋ฒ์์ ๋นํธ ์ฌ๋ฌ๊ฐ๋ฅผ ์ง์ฐ๊ณ ์ถ์ ๋
int clearBits(int num, int start, int end){
int headMask = (~0 >> start) << start;
//32๋นํธ ์ ์์ด๊ธฐ ๋๋ฌธ์ 31
int tailMask = (~0 << (31-end)) >> (31 - end);
int mask = headMask & tailMask;
return num & mask;
}
Update
- ํน์ ์์น์ bit๋ฅผ ์ํ๋ ๊ฐ์ผ๋ก ๊ฐฑ์ ํ ์ ์๋ค.
- ํน์ ์์น์ bit์ clearํ ํ์, ๋ค์ ์ํ๋ value๋ก setํ๋ฉด ๋๋ค.
int updateBit(int num, int idx, int val){
return (num & ~(1 << idx)) | (val << idx);
}
Toggle
- 0 -> 1, 1 -> 0์ผ๋ก ๋ฐ๊พธ์ด ์ฃผ๋ ๊ฒ.
- xor์ฐ์ฐ์ ํตํด ํ ์ ์๋ค
int Toggle(int num, int idx){
return num ^ (1 << idx);
}
MSB, LSB
Serial Communication์ ํ ๋, ํ๋์ ๋จ์์๊ฐ์ ํ๋์ ๋นํธ๋ง ๋ณด๋ผ ์ ์๊ธฐ ๋๋ฌธ์, ์ด๋ค ์์น์ bit ๋ถํฐ ์ ์ก๋๋์ง๋ฅผ ์์์ผ ํ๋ค.
MSB๋ถํฐ ๋ณด๋ด๋์ง, LSB๋ถํฐ ๋ณด๋ด๋์ง๋ฅผ ์๋ ๊ฒ์ ๋งค์ฐ ์ค์ํ๋ค.
์ก์์ ์ธก์์ ์ด ๋ถ๋ถ์ ํต์ผํ์ง ๋ชปํ๋ฉด ์์ ์ด ์๋ชป๋๋ค.
LSB
Least Significant Bit์ ์ฝ์.
ํ๋์ ๋ฐ์ดํฐ ํ์์ ๊ฐ์ฅ ๋ฎ์ ์์น์ bit์ ์๋ฏธํ๋ค.
2์ 0์น ์๋ฆฌ
bool getLSB(int num){
int mask = ~(num) + 1; return num & mask;
}
MSB
Most Significant Bit์ ์ฝ์.
ํ๋์ ๋ฐ์ดํฐ ํ์์ ๊ฐ์ฅ ๋์ ์์น์ bit์ ์๋ฏธํ๋ค.
unsinged char type์์ MSB๋ 2์ 7์น์์น์ ๊ฐ์ ์๋ฏธํ๋ค.
signed char type์์ MSB๋ ๋ถํธ ์๋ฆฌ๋ฅผ ๋ํ๋ธ๋ค. ๋ฐ๋ผ์ MSB๋ก ํด๋น ์๊ฐ ์์์ธ์ง ์์์ธ์ง ์ ์ ์๋ค.
bool getMSB(int num){
return num >> 31;
}
์ฐธ๊ณ ์๋ฃ
์์ ํ์
์ฌ๊ท ํธ์ถ
์ฌ๊ท ํจ์
ํจ์ ๋ด์์ ์๊ธฐ ์์ ์ ๋ค์ ํธ์ถํ๋ ํํ์ ํจ์๋ฅผ ๋งํ๋ค.
- ์ปค๋ค๋ ๋ฌธ์ ๋ฅผ ์ ์ฌํ ์ฌ๋ฌ ์์ ์กฐ๊ฐ์ผ๋ก ์ชผ๊ฐ ๋ค, ํ ์กฐ๊ฐ์ ์ํํ๊ณ ๋๋จธ์ง๋ฅผ ์๊ธฐ ์์ ์ ํธ์ถํด์ ์คํํ๋ ํจ์
void recurFunction(void){ recurFunction(); }
์์ ์ฝ๋์ฒ๋ผ ํจ์ ๋ด๋ถ์ ์๊ธฐ ์์ ์ ๋ค์ ํธ์ถํ๋ ํํ์ด๋ฉด ๋์ง๋ง, ์์ ์ฝ๋๋ ์ ์์ ์ธ ์ฌ๋ก๊ฐ ์๋๋ค. base case๊ฐ ์๊ธฐ ๋๋ฌธ์ด๋ค.
base case
๋ ์ด์ ์ชผ๊ฐค ์ ์๋ ๊ฐ์ฅ ์์ ์์ . (์ต์ํ์ ์์ )
์ฌ๊ทํธ์ถ์ ํ์ง ์๊ณ ๋ฐ๋ก returnํ๋ ์กฐ๊ฑด๋ฌธ์ ํฌํจ๋๋ค
base case๊ฐ ์กด์ฌํ์ง ์๋ ์ฌ๊ท ํจ์๋ ์์ํ ์ข ๋ฃ๋์ง ์์ ์ค๋ฅ๋ฅผ ์ผ์ผํจ๋ค.
base case๋ฅผ ์ ํํ ๋๋, ๋ชจ๋ ๊ฒฝ์ฐ์ ์์ ๋ํด ํญ์ base case๋ฅผ ์ด์ฉํด ๊ณ์ฐ๋ ์ ์๋๋ก ๊ณ ๋ คํด์ ์ ํํด์ผ ํ๋ค.
์์ ํ์
brute - force (๋ฌด์ํ๊ฒ ํผ๋ค)๋ผ๊ณ ๋ ๋ถ๋ฆฐ๋ค.
์ปดํจํฐ์ ๋น ๋ฅธ ๊ณ์ฐ ์๋๋ฅผ ์ด์ฉํด ์ด๋ค ๋ฌธ์ ์ ๋ํด ๊ฐ๋ฅํ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ์ ๋ถ ๋ง๋ค์ด๋ณด๋ ์๊ณ ๋ฆฌ์ฆ์ ๋ปํ๋ค.
์ฝ๋ฉ ํ ์คํธ์์ ์ฃผ์ด์ง ์ ํ ์๊ฐ๊ณผ ํด๋น ๋ฌธ์ ์ ์๊ฐ ๋ณต์ก๋ ๋ฐ ๊ฐ๋ฅํ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๋น๊ตํด์ ์์ ํ์์ผ๋ก ํ์ด๋ ๊ด์ฐฎ์์ง ํ๋จํด์ผ ํ๋ค.
์๋ฅผ๋ค์ด 4์๋ฆฌ ์ซ์๋ก ์ด๋ฃจ์ด์ง ๋น๋ฐ๋ฒํธ๋ฅผ ๋ง์ถฐ์ผ ํ๋ ๋ฌธ์ ์์, 0000 ~ 9999์ ๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ๋ค ์ง์ด๋ฃ์ด ๋ณด๋ ๋ฐฉ์์ ๋งํ๋ค.
์์ ํ์ ๋ฐฉ๋ฒ
- ๋ฐ๋ณต๋ฌธ ์ฌ์ฉ
- ๋ฐ๋ณต๋ฌธ์ ์ค์ฒฉํด์ ๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ํ์ํ๋ค
- ๋นํธ ๋ง์คํฌ
- ์ ์๋ฅผ ๋นํธ์ด๋ก ํํํ๋ฉด ์งํฉ์ ๋ํ๋ผ ์ ์๋ค.
- 5์๋ฆฌ ๋นํธ๋ก ์ด๋ฃจ์ด์ง ์ ์๋ก 5๋ช ์ item์ ๋ํ ๋ชจ๋ ์งํฉ์ ๋ํ๋ผ ์ ์๋ค.
- n๋ฒ์งธ ์์๋ฅผ ํฌํจํ๊ณ ์ถ์ผ๋ฉด n๋ฒ์งธ bit๋ฅผ 1๋ก ์ค์ ํ๊ณ , ์ ์ธํ๊ณ ์ถ์ผ๋ฉด 0์ผ๋ก ์ค์ ํ๋ฉด ๋๋ค.
- ์์ ์๋ ๋นํธ ์กฐ์ ์ฐ์ฐ์ ์ด์ฉํ์ฌ ํ ์ ์๋ค.
- ์์ด, ์กฐํฉ ์ฌ์ฉ
- ์์ด, ์กฐํฉ ํจ์๋ฅผ ์ง์ ๊ตฌํํด์ ์ฌ์ฉํด๋ ๋์ง๋ง, C++์ ๊ฒฝ์ฐ STL์ algorithm์ ํด๋น ํจ์๊ฐ ๊ตฌํ๋์ด ์๋ค.
- next_permutation
- prev_permutation
- ์์ด, ์กฐํฉ ํจ์๋ฅผ ์ง์ ๊ตฌํํด์ ์ฌ์ฉํด๋ ๋์ง๋ง, C++์ ๊ฒฝ์ฐ STL์ algorithm์ ํด๋น ํจ์๊ฐ ๊ตฌํ๋์ด ์๋ค.
- ์ฌ๊ท ํจ์ ์ฌ์ฉ
์ฐธ๊ณ ์๋ฃ
https://ikso2000.tistory.com/75
https://twpower.github.io/82-next_permutation-and-prev_permutation
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค/C++] H-index , K๋ฒ์งธ ์ (0) | 2020.08.31 |
---|---|
[์๊ณ ๋ฆฌ์ฆ] ์ ๋ ฌ(์ฝ์ , ๋ฒ๋ธ, ํต) (0) | 2020.08.17 |
[์๊ณ ๋ฆฌ์ฆ ์คํฐ๋] ์๋ฃ๊ตฌ์กฐ_2 (0) | 2020.07.28 |
[์๊ณ ๋ฆฌ์ฆ ์คํฐ๋] ์๋ฃ๊ตฌ์กฐ_1 (0) | 2020.07.20 |
go ์ธ์ด ์์ํ๊ธฐ (0) | 2020.07.07 |