โจ Algorithm/๐๐ฆบ ๋ฐํน๋ ๊ฐ๋ 10 [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. ์ด์ 1 2 3 ๋ค์