์ ์ฒด ๊ธ199 [0x0A] DFS DFS depth first search ๋ค์ฐจ์ ๋ฐฐ์ด์์ ๊ฐ ์นธ์ ๋ฐฉ๋ฌธํ ๋ ๊น์ด๋ฅผ ์ฐ์ ์ผ๋ก ๋ฐฉ๋ฌธํ๋ ์๊ณ ๋ฆฌ์ฆ ์์ ๋ชจ๋ ์นธ์ด ์คํ์ 1๋ฒ์ฉ ๋ค์ด๊ฐ๋ฏ๋ก ์๊ฐ ๋ณต์ก๋๋ ์นธ์ด N๊ฐ์ผ ๋ O(N) ์์ํ๋ ์นธ์ ์คํ์ ๋ฃ๊ณ ๋ฐฉ๋ฌธํ๋ ํ์๋ฅผ ๋จ๊น ์คํ์์ ์์๋ฅผ ๊บผ๋ด์ ๊ทธ ์นธ๊ณผ ์ํ์ข์ฐ๋ก ์ธ์ ํ ์นธ์ ๋ํด (3)์ ์งํ ํด๋น ์นธ์ ์ด์ ์ ๋ฐฉ๋ฌธํ๋ค๋ฉด ์๋ฌด ๊ฒ๋ ํ์ง ์๊ณ , ์ฒ์์ผ๋ก ๋ฐฉ๋ฌธํ๋ค๋ฉด ๋ฐฉ๋ฌธํ๋ค๋ ํ์๋ฅผ ๋จ๊ธฐ๊ณ ํด๋น ์นธ์ ์คํ์ ์ฝ์ ์คํ์ด ๋น ๋๊น์ง (2)๋ฅผ ๋ฐ๋ณต #include using namespace std; #define X first #define Y second // pair์์ first, second๋ฅผ ์ค์ฌ์ ์ฐ๊ธฐ ์ํด์ ์ฌ์ฉ int board[502][502] = { ... }; // 1.. 2023. 6. 26. [0x09] BFS BFS breadth first search ๋ค์ฐจ์ ๋ฐฐ์ด์์ ๊ฐ ์นธ์ ๋ฐฉ๋ฌธํ ๋ ๋๋น๋ฅผ ์ฐ์ ์ผ๋ก ๋ฐฉ๋ฌธํ๋ ์๊ณ ๋ฆฌ์ฆ ๊ณผ์ ๋ชจ๋ ์นธ์ด ํ์ 1๋ฒ์ฉ ๋ค์ด๊ฐ๋ฏ๋ก ์๊ฐ ๋ณต์ก๋๋ ์นธ์ด N๊ฐ์ผ ๋ O(N) ์์ํ๋ ์นธ์ ํ์ ๋ฃ๊ณ ๋ฐฉ๋ฌธํ๋ค๋ ํ์ ๋จ๊ธฐ๊ธฐ ํ์์ ์์๋ฅผ ๊บผ๋ด์ด ๊ทธ ์นธ์ ์ํ์ข์ฐ๋ก ์ธ์ ํ ์นธ์ ๋ํด (3)์ ์งํ ํด๋น ์นธ์ ์ด์ ์ ๋ฐฉ๋ฌธํ๋ค๋ฉด, ์๋ฌด ๊ฒ๋ ํ์ง ์๊ณ , ์ฒ์์ผ๋ก ๋ฐฉ๋ฌธํ๋ค๋ฉด ๋ฐฉ๋ฌธํ๋ค๋ ํ์๋ฅผ ๋จ๊ธฐ๊ณ ํด๋น ์นธ์ ํ์ ์ฝ์ ํ๊ฐ ๋น ๋๊น์ง (2)๋ฅผ ๋ฐ๋ณต // x๊ฐ ํ, y๊ฐ ์ด #include #include using namespace std; #define X first #define Y second // pair์์ first, second๋ฅผ ์ค์ฌ์ ์ฐ๊ธฐ ์ํด์ ์ฌ์ฉ int board[502.. 2023. 6. 26. [0x08] ์คํ์ ํ์ฉ(์์์ ๊ดํธ ์) ์์์ ๊ดํธ ์ ๊ดํธ์์ด ์ฌ๋ฐ๋ฅธ์ง ์ฒดํฌ ๊ด์ฐฐ ๊ดํธ 1์ข ๋ฅ ๊ดํธ 2์ข ๋ฅ → ์ฐ์๋ ๊ดํธ ์ญ์ ๋ ๊ฐ๋ฅ ํด๊ฒฐ ๋ฐฉ๋ฒ ๋ฌธ์์ด์ ์์์๋ถํฐ ์ฝ์ด๋๊ฐ ๋, ๋ซ๋ ๊ดํธ๋ ๋จ์์๋ ๊ดํธ ์ค์์ ๊ฐ์ฅ ์ต๊ทผ์ ๋ค์ด์จ ์ฌ๋ ๊ดํธ์ ์ง์ ์ง์ด ์์ ๋ฒ๋ฆฌ๋ ๋ช ๋ น์ด๋ผ๊ณ ์๊ฐํด๋ ๋๋ค 2023. 6. 26. [0x07] ๋ฑ ์ ์์ ์ฑ์ง ์ ์ double-ended queue ์์ชฝ ๋์์ ์ฝ์ ๊ณผ ์ญ์ ๊ฐ ์ ๋ถ ๊ฐ๋ฅํ ์๋ฃ ๊ตฌ์กฐ ์ฑ์ง ์์์ ์ถ๊ฐ์ ์ ๊ฑฐ : O(1) ์ ์ผ ์/๋ค์ ์์ ํ์ธ : O(1) ์ ์ผ ์/๋ค์ด ์๋ ๋๋จธ์ง ์์๋ค์ ํ์ธ/๋ณ๊ฒฝ์ด ์์น์ ์ผ๋ก ๋ถ๊ฐ๋ฅ ์ธ๋ฑ์ค๋ก ์์ ์ ๊ทผ ๊ฐ๋ฅ ๊ธฐ๋ฅ๊ณผ ๊ตฌํ const int MAX = 1e7; int data[2*MAX + 1]; int head = MAX, tail = MAX; // ์์ ์ง์ ์ ๋ฐฐ์ด์ ์ค๊ฐ์ผ๋ก : ์๋ค๋ก ํ์ฅ // head : ์์. tail : ๋ค์์ ๋ค์ด๊ฐ ์์์ ์๋ฆฌ void push_front(int x) data[--head] = x; void push_back(int x) data[tail++] = x; void pop_front() head++; v.. 2023. 6. 26. [0x06] ํ ์ ์์ ์ฑ์ง ์ ์ ํ์ชฝ ๋์์ ์์๋ฅผ ๋ฃ๊ณ ๋บ ์ ์๋ ์๋ฃ๊ตฌ์กฐ ์ฑ์ง ์์์ ์ถ๊ฐ์ ์ ๊ฑฐ : O(1) ์ ์ผ ์/๋ค์ ์์ ํ์ธ : O(1) ์ ์ผ ์/๋ค์ด ์๋ ๋๋จธ์ง ์์๋ค์ ํ์ธ/๋ณ๊ฒฝ์ด ์์น์ ์ผ๋ก ๋ถ๊ฐ๋ฅ ๊ธฐ๋ฅ๊ณผ ๊ตฌํ const int MAX = 1e7; int data[MAX]; int head = 0, tail = 0; void push(int x) data[tail++] = x; void pop() head++; int front() return data[head]; int back() return data[tail--]; STL queue #include 2023. 6. 20. [0x05] ์คํ ์ ์์ ์ฑ์ง ์ ์ ํ์ชฝ ๋์์๋ง ์์๋ฅผ ๋ฃ๊ฑฐ๋ ๋บผ ์ ์๋ ์๋ฃ ๊ตฌ์กฐ (restricted structure) ์ฑ์ง ์์์ ์ถ๊ฐ์ ์ ๊ฑฐ : O(1) ์ ์ผ ์๋จ์ ์์ ํ์ธ : O(1) ์ ์ผ ์๋จ์ด ์๋ ๋๋จธ์ง ์์๋ค์ ํ์ธ/๋ณ๊ฒฝ์ด ์์น์ ์ผ๋ก ๋ถ๊ฐ๋ฅ ๊ธฐ๋ฅ๊ณผ ๊ตฌํ ๊ตฌํ const int MAX = 1000005; int data[MAX]; int pos = 0; // ๋ค์์ ์์๊ฐ ์ถ๊ฐ๋ ๋ ์ฝ์ ํด์ผ ํ๋ ๊ณณ (์คํ ๋ด ์์์ ์) void push(int x) data[pos++] = x; void pop() pos--; int top() return data[pos-1]; STL stack #include 2023. 6. 20. [0x04] ์ฐ๊ฒฐ๋ฆฌ์คํธ ์ ์์ ์ฑ์ง ์ฑ์ง ์์์ ์์น์ ์๋ ์์๋ฅผ ํ์ธ/๋ณ๊ฒฝ : O(N) (๋ถ์ฐ์์ด๊ธฐ ๋๋ฌธ์ ๊ทธ ์์๊น์ง ์ฐพ์๊ฐ์ผ ํจ) ์์์ ์์น์ ์์๋ฅผ ์ถ๊ฐ/์ ๊ฑฐ : O(1) ์์๋ค์ด ๋ฉ๋ชจ๋ฆฌ ์์ ์ฐ๊ฒฐ๋์ด ์์ง ์์ cache hit rate๊ฐ ๋ฎ์ง๋ง ํ ๋น์ด ๋ค์ ์ฌ์ ์ข ๋ฅ ๋จ์ผ ์ฐ๊ฒฐ ๋ฆฌ์คํธ single linked list ์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ doubly linked list ์ํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ circular linked list ๋ฐฐ์ด vs ์ฐ๊ฒฐ ๋ฆฌ์คํธ overhead : ์, ๋ค ์์์ ์ฃผ์๊ฐ์ ๊ฐ์ง๊ณ ์์ด์ผ ํ๋ค (2^n byte์ด๋ฉด n๋งํผ ์ถ๊ฐ๋ก ํ์) ๊ตฌํ struct Node { struct Node *prev, *next; int data; } ์ผ๋งค ์ฐ๊ฒฐ๋ฆฌ์คํธ const int MAX = 1000005; in.. 2023. 6. 20. [0x03] ๋ฐฐ์ด ๋ฐฐ์ด ์ ์ ๋ฉ๋ชจ๋ฆฌ ์์ ์์๋ฅผ ์ฐ์ํ๊ฒ ๋ฐฐ์นํ ์๋ฃ๊ตฌ์กฐ ์ฑ์ง O(1)์ k๋ฒ์งธ ์์๋ฅผ ํ์ธ/๋ณ๊ฒฝ ๊ฐ๋ฅ ์ถ๊ฐ์ ์ผ๋ก ์๋ชจ๋๋ ๋ฉ๋ชจ๋ฆฌ์ ์ overhead๊ฐ ๊ฑฐ์ ์์ ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ถ์ด์์ผ๋ฏ๋ก cache hit rate๊ฐ ๋์ ๋ฉ๋ชจ๋ฆฌ ์์ ์ฐ์ํ ๊ตฌ๊ฐ์ ์ก์์ผ ํด์ ํ ๋น์ ์ ์ฝ์ด ๊ฑธ๋ฆผ ์ฐ์ฐ ์์์ ์์น ์์ ํ์ธ/๋ณ๊ฒฝ : O(1) ์์๋ฅผ ๋์ ์ถ๊ฐ / ๋ง์ง๋ง ์์ ๋ณ๊ฒฝ : O(1) ์์์ ์์น์ ์์ ์ถ๊ฐ/์ ๊ฑฐ : O(N) → ๋ค์ ์์๋ค ํ ์นธ ๋ค๋ก ๋ฐ์ด์ผ ํจ ์ด๊ธฐํ ์ ์ญ๋ณ์๋ก ์ ์ธํ ๊ฒฝ์ฐ int๋ 0์ผ๋ก ์ด๊ธฐํ ์ง์ญ๋ณ์๋ ์ฐ๋ ๊ธฐ๊ฐ ๋ค์ด๊ฐ๊ธฐ ๋๋ฌธ์ { } ๋ฑ์ผ๋ก ์ด๊ธฐํํด์ผ ํจ int a[21]; int b[21][21]; memset (๋น์ถ์ฒ) memset(a, 0, sizeof a); memset(b, 0, .. 2023. 6. 20. [0x02] ๊ธฐ์ด ์ฝ๋ ์์ฑ ์๋ น 2 ํจ์ ์ธ์ ๋ฐฐ์ด์ ์ธ์๋ก ๋๊ธฐ๋ฉด ์ฃผ์๊ฐ์ด ๋์ด๊ฐ๋ค ๋ณ์๋ฅผ ์ธ์๋ก ๋๊ธฐ๋ฉด ๋ณต์ฌ๋ ๊ฐ์ด ๋ค์ด๊ฐ๋ค & (reference)๋ฅผ ์ฌ์ฉํ๋ฉด ์ฐธ์กฐ ๋์์ ์ฃผ์ ์ ๋ณด๋ง ๋์ด๊ฐ STL standard template library STL์ ํจ์ ์ธ์๋ก ๋๊ธธ ๋ ๊ทธ๋ฅ STL์ ํจ์ ์ธ์๋ก ์ค์ด๋ณด๋ด๋ฉด ๋ณต์ฌ๋ณธ์ ๋๊ธฐ๋ ๊ฒ // ํฌ๊ธฐ๊ฐ n์ธ vector 2๊ฐ๋ฅผ ๋น๊ตํ๋ค๊ณ ํ์ ๋ // n๋งํผ ๋ณต์ฌํ๊ณ ๋ณด๋ด์ผ ํ๊ธฐ ๋๋ฌธ์ O(N) ์๊ฐ ๋ณต์ก๋ bool cmp1(vector v1, vector v2, int idx){ return v1[idx] > v2[idx] } ํ์ค ์ ์ถ๋ ฅ ๊ณต๋ฐฑ ํฌํจ ๋ฌธ์์ด ์ ๋ ฅ scanf์ cin ๋ชจ๋ ๊ณต๋ฐฑ ํฌํจ ๋ฌธ์์ด ์ ๋ ฅ์ด ๊น๋ค๋กญ๋ค ํด๊ฒฐ ๋ฐฉ๋ฒ scanf์ ์ต์ char a1[10]; scanf("%[^\.. 2023. 6. 20. ์ด์ 1 2 3 4 5 6 ยทยทยท 23 ๋ค์