๐ Self Study/๐ Programmers26 ํ๋ก๊ทธ๋๋จธ์ค (๋จ์ฒด์ฌ์ง ์ฐ๊ธฐ, 2017 ์นด์นด์ค๋ณธ์ ์ฝ๋) C++ ์ฝ๋ฉ์ผ๋ก ์์ด ์กฐํฉ์ ๋ํด์ ์นด์ดํธ ํด์ฃผ๋ ๋ฌธ์ ๋ฅผ ์ ํด๋ณธ ์ ์ด ์์๋ค. ์์ผ๋ก ํ์ด๋ดค๋๋ฐ ์ด๊ฑฐ๋ฅผ ์ด๋ป๊ฒ ์กฐ๊ฑด์ ํ๋ ํ๋ ์ฒดํฌํ์ง ๋ผ๋ ์๊ฐ ๋ฟ์ด์๊ณ , ํด๊ฒฐํ ๋ฐฉ๋ฒ์ ๋ชฐ๋๋ค. ๊ฒฐ๊ตญ ๊ตฌ๊ธ๋ง์ผ๋ก ๋ค๋ฅธ ์ฌ๋์ ๋ต์์ ๋ณด๋ฉด์ ๊ณต๋ถํ๋ค. next_permutation์ ์ด์ฉํด์ ์ค๋ฆ์ฐจ์์์ ๋ด๋ฆผ์ฐจ์๊น์ง์ ๋ชจ๋ ์์ด ์กฐํฉ์ ๊ณ ๋ คํ ์ ์์๋ค. do while ๋ฌธ์ ํตํด์ ์กฐ๊ฑด์ด ์๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ ์ ์์๊ณ ์ํ๋ ์กฐ๊ฑด์ flag๋ฅผ ํตํด์ ์นด์ดํธํ ์ง ๋ง์ง๋ฅผ ๊ฒฐ์ ํด์ผ ํ๋ ์๊ณ ๋ฆฌ์ฆ์ด์๋ค. #include #include #include using namespace std; // ์ ์ญ ๋ณ์๋ฅผ ์ ์ํ ๊ฒฝ์ฐ ํจ์ ๋ด์ ์ด๊ธฐํ ์ฝ๋๋ฅผ ๊ผญ ์์ฑํด์ฃผ์ธ์. int solution(int n, vector data) {.. 2022. 1. 2. ํ๋ก๊ทธ๋๋จธ์ค (ํํ, 2019 ์นด์นด์ค ๊ฐ๋ฐ์ ๊ฒจ์ธ ์ธํด์ญ) C++ ํ๋์ ๋ฌธ์์ด์ ์ฝค๋ง์ ์ค๊ดํธ๋ฅผ ๊ตฌ๋ถํ์ฌ ์ซ์๋ก ์ธ์ํ ์ ์๊ณ ๋ ๊ฐ์ฅ ๊ธด ๋ฐฐ์ด์ ์์๋ฅผ ๊ฐ์ ธ์ค๋ฉด ๊ฐ๋ฅํ๋ค๊ณ ์๊ฐํด์ ์ด๋ ๊ฒ ์ ๊ทผํด์ ํ์๋ค. ํ์ง๋ง answer์ ์ ๋ ฌ ์์๋ ํด๋น ์ซ์๊ฐ ์ผ๋ง๋ ๋ฐ๋ณต๋์ด์ ๋์๋์ง๋ฅผ ๊ธฐ์ค์ผ๋ก ํ๋ค. ์ด๋ Map์ ์ด์ฉํด์ value์ ๊ฐ์ ๊ณ์์ ์ผ๋ก count๋ฅผ ์์ผ์ ์ ์ฅํด์ผ ํ๋ค. 1. map map ์ ์ ์ธํ๊ณ ์ฌ์ฉํ ๋ value๊ฐ์ด 0์ผ๋ก ์ด๊ธฐํ๊ฐ ๋๋์ง๊ฐ ๊ถ๊ธํ๋ค. -> 0์ผ๋ก ์ด๊ธฐ๊ฐ์ด ๊ธฐ๋ณธ ์ค์ ๋์ด ์๋ค. 2. sort(map.begin(), map.end())๋ฅผ ํตํด์ value ์ ์ค๋ฆ์ฐจ์, ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌ์ํฌ ๋ฐฉ๋ฒ์ด ์กด์ฌํ๋๊ฐ -> vector๋ก ๋ณต์ฌํ ํ sort๊ฐ ๊ฐ๋ฅํ๋ค ํ๊ต ๊ณผ์ ์์ ์ํํ์๋ ๋ฌธ์์ด ๊ตฌ๋ถํ๋ ๊ฒ๋ณด๋ค ๋ณต์กํ์ง ์์์ ๊ตฌ๋ถํ๋.. 2022. 1. 1. ํ๋ก๊ทธ๋๋จธ์ค (์ ๊ตญ์ฌ์ฌ, ์ด๋ถํ์) C++ n ๋ช ์ ์ฌ๋๋ค์ด times ๋ฐฐ์ด์ ํฌ๊ธฐ๋งํผ์ ์ ๊ตญ ์ฌ์ฌ๋ฅผ ๊ฐ์ฅ ๋นจ๋ฆฌ ํต๊ณผํ ์ ์๋ ์๊ณ ๋ฆฌ์ฆ์ ์์ฑํ๋ ๋ฌธ์ ์ด๋ค. ๋ณด์๋ง์ while ๋ฌธ ์์์ sec๋ฅผ ํ๋์ฉ ์ฆ๊ฐํด์ฃผ๊ณ ์นด์ดํธ๋ฅผ ํด์ฃผ๋ฉด์ ๋ง์ง๋ง ํ ๋ช ์ด ๋จ์์ ๋ ์ด๋ ์ ๊ตญ ์ฌ์ฌ๋๋ฅผ ํต๊ณผํด์ผ ๊ฐ์ฅ ์งง์ ์๊ฐ์ด ๋์ฌ ์ ์๋์ง ์ฐพ์ ์ ์๋ค๊ณ ์๊ฐํด์ ์ฝ๋๋ฅผ ์์ฑํด๋ณด์๋ค. ๋ค์์ ํ ์คํธ ์ผ์ด์ค ํ๋๋ฅผ ํต๊ณผํ ์ฝ๋ ์์ฑ์ด๋ค. #include #include #include using namespace std; long long solution(int n, vector times) { long long answer = 0; int sec = 0; int sum = 0; long long min = 1000000001; int member = 0; vect.. 2022. 1. 1. ํ๋ก๊ทธ๋๋จธ์ค (๋ ๋งต๊ฒ, ํ(Heap)) C++ // ๊ธฐ๋ณธ์ ์ผ๋ก ๋ง๋ค์ด์ง๋ ํ๊ฐ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ์ด ๋๋ค. Priority_queue pq; // ์ค๋ฆ์ฐจ์์ผ๋ก ๋ฒกํฐ๋ฅผ ์ ๋ ฌํ ๋ Priority_queue pq; // ์ฐ์ ์์ ํ์ ์์ ์ฝ์ pq.push(์์); // ์ฐ์ ์์์ ๊ฐ์ฅ ์์ ์์ ํ์ธ pq.top(); // ์ฐ์ ์์์ ๊ฐ์ฅ ์์ ์์ ์ ๊ฑฐ pq.pop(); // ํฌ๊ธฐ ํ์ธ ๋ฐ ๋น์ด์๋์ง ์ ๋ฌด pq.size(); pq.empty(); ์ฐ์ ์์ ํ๋ฅผ ์ฐ์ง ์๊ณ ๋ ์ ๋ต์ฒ๋ฆฌ๊ฐ ๋์ง ์๋ ๋ฌธ์ ์๋ค. ๊ธฐ์กด์๋ sort๋ฅผ ์ด์ฉํด์ while ๋ฌธ ์์์ ๊ณ์์ ์ผ๋ก ์ ๋ ฌ์ ์์ผ์คฌ๋๋ฐ ์ด๋ ํจ์จ์ฑ ์ธก๋ฉด์์ ์ข์ง ์์์ ๋ฐฐ์ธ ์ ์์๋ค. priority_queue๋ฅผ ์ ์ธํ๋ฉด ์ค๋ฆ์ฐจ์์ผ๋ก ์๋ ์ ๋ ฌ๋๊ณ ์ด๋ฅผ ์ด์ฉํด topํ์ธpop ์ ๊ฑฐ push ์ถ๊ฐ๋ฅผ ํ๋ค๋ฉด .. 2022. 1. 1. ํ๋ก๊ทธ๋๋จธ์ค (์์ ๋ง๋ค๊ธฐ, Summer/Winter Coding(~2018)) C++ ์ผ์ค ๋ฃจํ๋ฅผ ๋๋ ธ๋ค๋ผ๋ ๊ฒ ๋ง๊ณ ๋ ์์ฌ์ ์ฐ๋ฆฌ๋ ๋ถ๋ถ์ด ์๋ ๋ฌธ์ . ๋ณ๋ก ์ค๋ช ํ ๊ฒ์ด ์์ด ๋ณด์ธ๋ค. #include #include using namespace std; bool pass(int sum) { int count = 0; for(int i = 1 ; i 2021. 12. 30. ํ๋ก๊ทธ๋๋จธ์ค (๋จ์ด ๋ณํ, ๊น์ด/๋๋น ์ฐ์ ํ์(DFS/BFS)) C++ DFS๊ฐ ์๋๋ผ BFS ์ธ๊ฒ ๊ฐ๊ธดํ๋ฐ ์ผ๋จ ํจ์๋ช ์ ์ด๋ ๊ฒ dfs๋ก ํด๋ฒ๋ ธ๋ค. ์๋๊ฐ... ์์ง ๊ฐ๋ ์ด ํ์คํ ์กํ์ง ์์๋ฏ.. ์๋ฌดํผ DFS์ BFS๋ฅผ ํ ๋ ํ๋ผ๋ฏธํฐ๋ก ํ๋์ฉ ๋ฐ๋์ด์ ๋๊ฒจ์ง๊ฒ ๋๋ ๊ฒ์ Focus๋ฅผ ๋ง์ถ๋ค. ๊ทธ๋ฆฌ๊ณ visited๊ฐ ๊ฐ์ฅ ์ค์!! ๊ทธ๋ฆฌ๊ณ ์ด ๋ฌธ์ ์ ๊ฒฝ์ฐ ๋ฐฉ๋ฌธํ์ง ์์ ๊ฒฝ์ฐ์ node๋ฅผ queue์ ๋ชจ๋ ๋ฃ๊ณ ์ดํผ๋ ๊ฒ์ด ์๋๊ธฐ ๋๋ฌธ์ dfs ์ฌ๊ท๋ฅผ ํ์ถํ๊ฒ ๋๋ฉด ์ด์ค for๋ฌธ ์ค nested๋ for๋ฌธ์์ visited ํ ๋ ธ๋์ visited๋ฅผ 0์ผ๋ก ๋ง๋ค์ด์ผ ํ๋ค๋ ๊ฒ์ด ํฌ์ธํธ #include #include #include using namespace std; int answer = 100; string value; vector visited(50,0); void.. 2021. 12. 30. ํ๋ก๊ทธ๋๋จธ์ค (๋คํธ์ํฌ, ๊น์ด/๋๋น ์ฐ์ ํ์(DFS/BFS)) C++ ์ด๋ฐ์ ๋ฌธ์ Setting ํ ๋ ์๊ฐ์ด ๋ง์ด ๊ฑธ๋ ธ๊ณ ๋ฌถ์ธ ๊ฒ์ด ๋ช ๊ฐ์ธ์ง ํ์ ํ๋ ๊ฒ์์๋ ๋ง์ด ์๊ฐ์ ์ผ๋ค. ํ๋ค๋ณด๋๊น visited ํ์ง ์์ ๊ฒ์ ์์ํ ๋๊ฐ ๋คํธ์ํฌ๊ฐ ๋ฌ๋ผ์ง๋ ์๊ฐ์ด์๋ค. #include #include #include #include using namespace std; int solution(int n, vector computers) { int answer = 0; vector adj(n+1); vector visited(n+1, 0); queue queue; // Diagonal Matrix ์ด๋ฏ๋ก Upper์ ํด๋นํ๋ ๊ฒ๋ง ์ทจํด์ adjacent list ๋ง๋ค๊ธฐ for(int i = 0 ; i < n ; i++) { for(int j = i+1 ; j < n ; j++.. 2021. 12. 30. ํ๋ก๊ทธ๋๋จธ์ค (๊ฐ์ฅ ๋จผ ๋ ธ๋, ๊ทธ๋ํ) C++ ๊ทธ๋ํ์ DFS์ ๋๋์ด ํ๊ธด๋ค๋ฉด ์ด์ค ๋ฒกํฐ๋ฅผ ์ด์ฉํด์ Adjacent List๋ฅผ ๋ง๋ค๊ณ visited ๋ฒกํฐ๋ฅผ ์ด์ฉํด์ BFS๋ฅผ iterativeํ๊ฒ ๊ตฌ์ฑํ๋ค. ๊ทธ๋ฆฌ๊ณ BFS์ ๊ฒฝ์ฐ ์์ ๋ ธ๋์ ์ผ๋ง๋ ๋จ์ด์ ธ ์๋์ง๋ ์๋ก์ด ๋ฐฐ์ด์ ํ๋ ๋ง๋ค์ด์ค์ ์๊ณ ๋ฆฌ์ฆ์ ์์ฑํ๋ฉด ๋๋ค. while ๋ฌธ ์์ for ๋ฌธ์ ๊ฒฝ์ฐ ํ๋์ node๋ฅผ ์ค์ ํด๋๊ณ ๊ทธ ์ฃผ๋ณ ์ฐ๊ฒฐ๋ node๋ง์ ํ์ํ๋ ๊ฒ์ด๊ธฐ์ queue์์ front๋ก ์ฐธ์กฐํ node๋ ๋ณํ์ง ์๋๋ค๋ ์ฑ์ง์ ์ด์ฉํ์ฌ level์ ์ฒดํฌํด์ฃผ๋ฉด ๋๋ค. #include #include #include #include #include using namespace std; int solution(int n, vector edge) { int answer = 0; vect.. 2021. 12. 29. ํ๋ก๊ทธ๋๋จธ์ค (ํ๊ฒ ๋๋ฒ, ๊น์ด/๋๋น ์ฐ์ ํ์(DFS/BFS)) C++ ์ฝ๊ฐ ์.... ์ด๋ฐ ๋ถ์๊ธฐ์ ๋ฌธ์ ๊ฐ ์๋ค. ๋ฑ ํ๋ ์ ๋ ์ฐจ์ด๋๋ +์ - / ์ธ์ ํ ์ฃผ๋ณ์ ๊ฒ๋ค์ ๋น๊ตํ๊ณ ๋ฑ๋ฑ ์ด๊ฒ ๋ฐ๋ก dfs ์ฌ๊ทํจ์๋ฅผ ํ๋ผ๋ ๊ฒ์ด๋ค. ์นด์นด์ค ์ปฌ๋ฌ๋ง๋ถ ๋ฌธ์ ๋ ๋น์ทํ๋ค. ๋๋์ ์ ์งํ์. #include #include using namespace std; int answer = 0; void recur(vector numbers, int target, int sum, int count) { // count๋ ๊ณ์์ ์ผ๋ก ์์ count๊ฐ numbers ๋ฐฐ์ด์ ํฌ๊ธฐ์ ๊ฐ์์ง ๊ฒฝ์ฐ์ // sum ๋ํ ์ํ๋ ํฉ target๊ณผ ๋์ผํ๋ค๋ฉด answer๋ฅผ ์ฆ๊ฐ์ํค๊ณ return;์ผ๋ก ๋์๊ฐ๋ค. if(count == numbers.size()) { if(sum == target) answe.. 2021. 12. 29. ํ๋ก๊ทธ๋๋จธ์ค (์๋ ์ซ์ ๋ํ๊ธฐ, ์๊ฐ ์ฝ๋ ์ฑ๋ฆฐ์ง ์์ฆ3) C++ ๊ทธ๋ฅ ๋ฌด๋ํ ์ฝ๋ฉ. ์ ์ฒด ๋ง์ ์์ ํด๋นํ๋ ์ซ์๋ฅผ ๋นผ๋ ๊ฒ๋ ํ๋์ ๋ฐฉ๋ฒ์ด๋ผ๊ณ ํ๋ค. #include #include #include using namespace std; int solution(vector numbers) { int answer = 0; vector arr(10); // arr ๋ผ๋ ๋ฒกํฐ๋ฅผ ๋ง๋ค์ด ์ฃผ์ด์ง ๋ฒํธ์ ํด๋นํ๋ index์ ๊ฐ์ ์ฆ๊ฐ์ํจ๋ค. for(int i =0 ; i < numbers.size() ; i++) { arr[numbers[i]]++; } // ๋ค์ arr ๋ฒกํฐ๋ฅผ ๋๋ฆฌ๋ฉด์ 0์ธ ๊ฐ์ answer์ ๋์ ์ํจ๋ค. for(int i =0 ; i < 10 ; i++) { if(arr[i] == 0) answer += i; } return answer; } 2021. 12. 29. ์ด์ 1 2 3 ๋ค์