๐ Self Study65 ํ๋ก๊ทธ๋๋จธ์ค (์ง์ง์ด ์ ๊ฑฐํ๊ธฐ, 2017 ํ์คํ์ด) C++ Stack์ ๊ฐ๋ ์ ์ฌ์ฉํ๊ฒ ๋๋ ๊ฒฝ์ฐ๋ฅผ ๋ฐฐ์ธ ์ ์์๋ ๋ฌธ์ ์ด๋ค. ํ์ฌ์ ๊ฒ๊ณผ ์ด์ ์ ๊ฒ์ ๋น๊ตํ๊ณ erase ํ๊ฒ ๋๋ ๊ฒฝ์ฐ stack์ ์ฌ์ฉํ๋ฉด ํจ์จ์ฑ ์ธก๋ฉด์์ ํจ์ฌ ๋น ๋ฅด๊ฒ ์ ๊ทผ์ด ๊ฐ๋ฅํ๋ค๋ ๊ฒ์ ๋ฐฐ์ ๋ค. #include #include #include using namespace std; int solution(string s) { int answer = -1; stack st; // ๋ฌธ์์ด์ ๊ธธ์ด๋งํผ ๊ฒ์ฌ๋ฅผ ํ๋ค. for(int i = 0 ; i < s.size() ; i++) { // stack์ด ๋น์ด์๊ฑฐ๋ ๋ฌธ์์ด์ ํ์ฌ ๋ฌธ์์ top์ด ๊ฐ์ง ์๋ค๋ฉด push๋ฅผ ํ๋ค. if(st.empty() || st.top() != s[i]) st.push(s[i]); // top๊ณผ ํ์ฌ ๋ฌธ์๊ฐ ๊ฐ๋ค๋ฉด ์ ๊ฑฐ.. 2022. 1. 4. ํ๋ก๊ทธ๋๋จธ์ค (๊ธฐ๋ฅ ๊ฐ๋ฐ, ์คํ/ํ) C++ Queue๋ฅผ ์ฌ์ฉํ์ง ์๊ณ ๋์ผํ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ์งํํ๋๋ฐ Time ์ด๊ณผ๋๋ ๊ฒฝ์ฐ๊ฐ ์๊ธด๋ค. ๋ค๋ฅธ ๊ฒฝ์ฐ๋ ๋ค ํต๊ณผํ๋๋ฐ Queue๋ Vector์ ์ฐจ์ด๊ฐ ์ด๋ ๊ฒ ์ฌํ๊ฐ... ์๊ฐ์ด ๋ ๋ค. #include #include #include using namespace std; vector solution(vector progresses, vector speeds) { vector answer; int front_index = 0; int count = 0; while(front_index != progresses.size()) { // ๊ฐ ์์ ์ ํ ๋ฒ์ฉ ์งํ์ํค๋ for๋ฌธ for(int i =0 ; i < progresses.size() ; i++) { progresses[i] += speeds[i]; } .. 2022. 1. 3. ํ๋ก๊ทธ๋๋จธ์ค (124 ๋๋ผ, ์ฐ์ต๋ฌธ์ ) C++ ์ฌ๊ทํจ์๋ก ํ์๋ค๊ฐ ์ฝ๋ ๋ญ๋น๊ฐ ๋ง์์ ธ์ ๋ฌดํ๋ฃจํ ์์์ ํด๊ฒฐํ๋ค. #include #include #include using namespace std; string solution(int n) { string answer = ""; int top = n; int bottom = 0; while(true) { bottom = top % 3; top = top / 3; switch(bottom) { case 0: answer = '4' + answer; top -= 1; break; case 1: answer = '1' + answer; break; case 2: answer = '2' + answer; break; } if(top == 0) break; } return answer; } 2022. 1. 3. ํ๋ก๊ทธ๋๋จธ์ค (์คํจ์จ, 2019 KAKAO BLIND RECRUITMENT) C++ ์นด์นด์ค ๋ฌธ์ ๋ก vector๊ฐ ์ฃผ์ด์ง๋ ๊ฒฝ์ฐ ๊ฑฐ์ ์ด์ค for๋ฌธ์ผ๋ก ์์ํด์ผ ํ๋ ๋ฌธ์ ๊ฐ ๋ง์ ๊ฒ ๊ฐ๋ค. ์ค๋๋ง์ ์ฃผ์์ ๋จผ์ ๋ฌ๊ณ ์ฝ๋๋ฅผ ์งฐ๋๋ฐ ์๊ฐ๋ณด๋ค ์ ์ง์ก๋ค. Map์ ํ์ฉํด์ value์ ๋ํด ์ค๋ฆ์ฐจ์/๋ด๋ฆผ์ฐจ์ ์ ๋ ฌํ๋ ๋ฒ์ ์ฒดํํ ๊ฒ ๊ฐ๋ค. #include #include #include #include #include using namespace std; bool cmp(const pair& a, const pair& b) { // value๊ฐ ๊ฐ๋ค๋ฉด key์ ํด๋นํ๋ ๊ฒ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ค. if(a.second == b.second) return a.first b.second; .. 2022. 1. 3. ํ๋ก๊ทธ๋๋จธ์ค (๋ฉ์ฉกํ ์ฌ๊ฐํ, Summer/Winter Coding(2019)) C++ ์ต์๊ณต๋ฐฐ์๋ฅผ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ผ๋ก "์ ํด๋ฆฌ๋ ํธ์ ๋ฒ"์ด ๊ตฌ๊ธ์ ๊ฐ์ฅ ๋ง์ด ๋์์์ด์ ํด๋น ๋ฐฉ๋ฒ์ ์ตํ๋ณด์ ๋ค์๊ณผ ๊ฐ์ด ์ฌ์ฉ์ ํ๋ค. ๊ฐ๋ก์ ์ธ๋ก๋ฅผ ์ต๋๊ณต์ฝ์๋ก ๋๋์ด์ ๊ท์น์ ์ฐพ์๋ณด๋ ค๊ณ ํ์ง๋ง ์๊ฐ๋ณด๋ค ๊ท์น์ ์ฐพ๋๊ฒ ์ฝ์ง ์์์ ํ๋ค์๋ค. GCD ๊ตฌํ๋ ๋ฐฉ๋ฒ ํ๋ ์ ๋๋ ์ธ์ฐ๋ ๊ฒ๋ ๋์์ง ์์๋ณด์ธ๋ค. using namespace std; long long gcd(int x, int y) { long long temp =0 ; while(y != 0) { temp = x % y; x = y; y = temp; } return x; } long long solution(int w,int h) { long long answer = 1; long long W = w; long long H = h; long long.. 2022. 1. 3. ํ๋ก๊ทธ๋๋จธ์ค (ํฌ์ผ๋ชฌ, ์ฐพ์๋ผ ํ๋ก๊ทธ๋๋ฐ ๋ง์คํฐ) C++ ์ค๋ณต์ฑ์ ์ ๊ฑฐํด์ค์ผ ํ๋ค. -> Set ์ด์ฉ set set; ์๋ก์ด ์์ ์ถ๊ฐ set.insert(์์); #include #include #include using namespace std; int solution(vector nums) { int answer = 0; int number = nums.size()/2; set set; // nums ๋ฐฐ์ด์ ๋ด๊ธด ์ซ์์ ์ค๋ณต์ฑ์ ์์ ์ฃผ๊ธฐ ์ํด์ set์ ์ ์ธํ๊ณ ๋ฃ์ด์ค๋ค. for(int i = 0 ; i < nums.size() ; i++) { set.insert(nums[i]); } // ์ข ๋ฅ๊ฐ N/2 ๋ณด๋ค ์๋ค๋ฉด ๊ทธ๋๋ก answer์ ๋ฃ์ด์ฃผ๊ณ // ์๋๋ฉด N/2๋ฅผ answer๋ฅผ ๋ต์ ๋ฃ์ด์ค๋ค. if(number 2022. 1. 2. ํ๋ก๊ทธ๋๋จธ์ค (๋จ์ฒด์ฌ์ง ์ฐ๊ธฐ, 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. ์ด์ 1 2 3 4 5 6 7 ๋ค์