๐ฅ์ฝ๋ฉํ
์คํธ:Algorithm
https://www.acmicpc.net/problem/17142 ํ์ด๊ณผ์ 0. ์
๋ ฅ์ ๋ฐ์ ๋ ์ฑ์์ผ ํ ๋น์นธ์ ๊ฐฏ์๋ฅผ ์ ์ฅํฉ๋๋ค. 1. ๋ฐฑํธ๋ํน์ ํ์ฉํด์ ๋ฐ์ด๋ฌ์ค๋ค์ ์กฐํฉ์ ์ ํํฉ๋๋ค. 2. ์ ํ๋ ๋ฐ์ด๋ฌ์ค๋ค์ ๋ํด bfs๋ฅผ ์ํํ์ฌ ํผํธ๋ฆฝ๋๋ค. ๋ฐ์ด๋ฌ์ค๋ฅผ ํผํธ๋ฆด ๋, ๋น์นธ๊ณผ ๋ฐ์ด๋ฌ์ค๊ฐ ์๋ ์นธ์ ๋ํด ๊ตฌ๋ถํด์ ์ฝ๋๋ฅผ ์์ฑํด์ผ ํฉ๋๋ค. ๋น ์นธ์ ๊ฒฝ์ฐ 0๋ฒ ํ์ด๊ณผ์ ์์ ์ ์ฅํ ๋ชฉํ์ ๋น๊ตํ๊ธฐ ์ํด cnt๊ฐ์ ์ฆ๊ฐ์์ผ ์ค๋๋ค. ๋ฐ์ด๋ฌ์ค์ ๊ฒฝ์ฐ cnt ๊ฐ์ ์ฆ๊ฐ์ํค์ง ์๊ณ ๋ฐฉ๋ฌธ์ฒ๋ฆฌ์ bfsํ์ ๋ฃ๋ ๋์๋ง ์ํํฉ๋๋ค. ์ฒ์์๋ swea์ ์ง๋ขฐ๋ฌธ์ ์ ํท๊ฐ๋ ค์ ๋ฐ์ด๋ฌ์ค๋ฅผ ๋ง๋๋ฉด ๊ณ์ ํผ์ง๋๋ก ๊ตฌํํด์ ๊ณ์ ํ๋ ธ์ต๋๋ค ใ
ใ
3. ๋น ์นธ์ ๋ค ์ฑ์ ์ผ๋ฉด ์ด๋ํ ์๊ฐ์ return ํฉ๋๋ค. bfs์์ ์๊ฐ์ ๊ณ์..
๐ฅ์ฝ๋ฉํ
์คํธ:Algorithm
N = ํ ๊ธธ์ด M = ์ด ๊ธธ์ด int[][] origin = { {1,2,3}, {4,5,6}, {7,8,9} }; // ์๋ณธ ๋ฐฐ์ด int[][] result; // ํ์ ๋ฐฐ์ด ์๊ณ ๋ฐฉํฅ 90๋ ํ์ : (i,j) = (N-1-j, i) ํน์ (j, N-1-i) = (i,j) for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { rotate_arr[i][j] = arr[N - 1 - j][i]; } } ๋ฐ ์๊ณ ๋ฐฉํฅ 90๋ ํ์ : (i,j) = (j, N-1-i) ํน์ (N-1-j, i) = (i, j) for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { rotate_arr[i][j] = ar..
๐ฅ์ฝ๋ฉํ
์คํธ:Algorithm
๊ตฌํ ์ฝ๋๋ง ๊ฐ๋ตํ๊ฒ ์์ฑ..(์ธ์ฐ๊ธฐ ์ํด์ ๐) ๋ฆฌ์คํธ์ ์์ฐจ์ ์ผ๋ก ์ ๊ทผํด์ผ ํ ๋ ์ฌ์ฉํ ์ ์์ต๋๋ค. ํฌ ํฌ์ธํฐ ์๊ณ ๋ฆฌ์ฆ ๊ธฐ๋ณธ ํฌ๋ฉงint N = 5; // ๋ฐ์ดํฐ์ ๊ฐ์ Nint M = 5; // ์ฐพ๊ณ ์ ํ๋ ๋ถ๋ถ ํฉ Mint[] data = {1,2,3,2,5};int cnt = 0;int interval_sum = 0;int end = 0;for(int start=0;start
๐ฅ์ฝ๋ฉํ
์คํธ:Algorithm
๋ฌธ์ : https://www.acmicpc.net/problem/15685 ํ์ด๊ณผ์ 1. ๋๋๊ณค ์ปค๋ธ๋ฅผ ๊ทธ๋ฆฌ๋ ํจ์๋ฅผ ๊ตฌํํด์ผ ํฉ๋๋ค. 1-1. ๋ฆฌ์คํธ๋ฅผ ํ์ฉ ๋๋๊ณค ์ปค๋ธ๋ ํ์ฌ๊น์ง ๋ง๋ค์ด์ง ๋ชจ์์ ๋ฐํ์ผ๋ก ์๋ก์ด ๋ชจ์์ ๋ง๋ค๊ฒ ๋ฉ๋๋ค. ๋ฆฌ์คํธ๋ฅผ ํ์ฉํด์ ๋๋๊ณค ์ปค๋ธ์ ๋ฐฉํฅ์ ๊ตฌํํ์ต๋๋ค. 1-2. 90๋ ํ์ 90๋ ํ์ ์ ๊ฒฝ์ฐ 0 ๋ฐฉํฅ์ 1 1 ๋ฐฉํฅ์ 2 2 ๋ฐฉํฅ์ 3 3 ๋ฐฉํฅ์ 0 ์ด ๋ฉ๋๋ค. (ํ์ฌ๋ฐฉํฅ+1)%4 ์ฐ์ฐ์ ํตํด ์ด๋ฅผ ๊ตฌํํ ์ ์์ต๋๋ค. static void update_history(){ // g๋ฒ ์ด๋์ํค๊ธฐ for(int i=0;i=0;j--){ history.add((history.get(j)+1)%4); } } } 1-3. ๋ ๋ฒ ์ด๋ ์ํค๊ธฐ ์ ์ฌ๊ฐํ์ ๊ฐฏ์๋ฅผ ๊ตฌํ๊ธฐ ์ํด ๋..
๐ฅ์ฝ๋ฉํ
์คํธ:Algorithm
๋ฌธ์ : https://school.programmers.co.kr/learn/courses/30/lessons/42587 ํ์ด๊ณผ์ 1. ์ฐ์ ์์๊ฐ ๊ฐ์ฅ ๋์ ํ๋ก์ธ์ค๋ฅผ ์ฐพ์์ผ ํฉ๋๋ค. ๐์ฐ์ ์์ ํ๋ฅผ ํ์ฉ O(logn)ํ์ฌ ๊ตฌํ ์ ์์ต๋๋ค. 2. ๋ฌธ์ ์ 2๋ฒ ์กฐ๊ฑด์ ๊ตฌํํด์ผ ํฉ๋๋ค. 2๋ฒ ์กฐ๊ฑด์ ๋์์์ ๋ค์ ํ์ ๋ฃ๋ ์์๋ค์ ์์๋ ์ ์ง๋ฉ๋๋ค. ์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด (2,1)์ ๋ค๋ก ๊ฐ์ผํ๋๋ฐ ์ด๋ ๋ค๋ก ๊ฐ๋ (2,1)์ ์์๋ ์ ์ง๋ฉ๋๋ค. ๋ฐ๋ผ์ ํ๋ฅผ ํ์ฉํด์ ๊ตฌํํ ํ์ ์์ด ์ฃผ์ด์ง priorities ๋ฐฐ์ด๋ค์ ์์๋๋ก ๋ฌดํ์ํ(?)ํ๋ฉด ๋ฉ๋๋ค. 3. ๋ฌธ์ ์์ ์๊ตฌํ๋ ์ ๋ต์ธ ํด๋น ํ๋ก์ธ์ค๊ฐ ๋ช ๋ฒ์งธ๋ก ์คํ๋๋์ง ํ์
ํด์ผ ํฉ๋๋ค. ๋ฐฐ์ด๋ค์ ๋ฌดํ์ํ(2๋ฒ ํ์ด๊ณผ์ ) ํ๋ฉฐ ์ฐ์ ์์๊ฐ ๊ฐ์ฅ ๋์ ํ๋ก์ธ์ค..
๐ฅ์ฝ๋ฉํ
์คํธ:Algorithm
๋ฌธ์ ์ถ์ฒ : https://school.programmers.co.kr/learn/courses/30/lessons/42578 ํ์ด๊ณผ์ ์ฒ์์ ์ ๊ทผ : ์ท ์ข
๋ฅ ๋ณ ๊ฐฏ์๋ฅผ ์ ์ฅํ๋ ๋ฐฐ์ด์ ์์ฑํ๊ณ , ๊ทธ ๋ฐฐ์ด์ ๋ฐฑํธ๋ํน์ผ๋ก ํ์ํ๋ฉฐ ๋ชจ๋ ๊ฒฝ์ฐ์ ๋ํด ๊ณ์ฐ์ ์งํํ๋ ค ํ์ต๋๋ค. ํ์ง๋ง ์ด๋ ๊ฒ ํ๋ฉด ์๊ฐ๋ณต์ก๋๋ฅผ ๋ง์กฑํ ์ ์์์ต๋๋ค. ์๋ก์ด ์ ๊ทผ์ ๋ํ ์๊ฐ : ์ง ๋ถ๋ถ์งํฉ์ ๋ํด ์๊ฐํ์ต๋๋ค. ์ง ๋ถ๋ถ์งํฉ์ ๊ฐฏ์๋ 2^n - 1 ์ด๋ฏ๋ก, ์ด ๋ฌธ์ ์์ ์ต์
์ ๊ฒฝ์ฐ n = 30์ด ๋๋ฏ๋ก ์ฒ์์ ์ ๊ทผ๊ณผ ๊ฐ์ด ์์ ํ์์ ์งํํ๋ฉด ๋น์ฐํ ์๊ฐ์ด๊ณผ๊ฐ ๋ฐ์ํ๋ ๊ฒ์ด์์ต๋๋ค. ์ฌ๋ฐ๋ฅธ ํ์ด 1. ์ท ์ข
๋ฅ๋ณ๋ก ์ท์ ๊ฐฏ์๋ฅผ + 1 ํด์ค์ผ ํฉ๋๋ค. ์ฌ๊ธฐ์ +1์ (์
์ง์์์ ์๋ฏธํฉ๋๋ค) 2. +1๋ ์ท ์ข
๋ฅ๋ณ ์ท์ ๊ฐฏ์๋ค ๋ผ๋ฆฌ์..
๐ฅ์ฝ๋ฉํ
์คํธ:Algorithm
์ถ์ฒ: ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ฉ ํ
์คํธ ์ฐ์ต, https://school.programmers.co.kr/learn/challenges ํ์ด๊ณผ์ ์ฐ์ ๋ฐฉ์ด ์์ฑ๋๋ ์กฐ๊ฑด์ ๋ํด ํ์
ํด์ผ ํฉ๋๋ค. ๋ฐฉ์ด ์์ฑ๋๋ ์กฐ๊ฑด์ 1. ์ด์ ์ ๋ฐฉ๋ฌธํ๋ ์ ์ ์ ๋ค์ ๋ฐฉ๋ฌธํด์ผ ํจ 2. ์ด์ ์ ์ฐ๊ฒฐํ ์ ๋ถ์ด ์๋ ์๋ก ์๊ธด ์ ๋ถ์ด์ด์ผ ํจ ๊ฐ ์ ์ ์ ๋ํ ๊ทธ๋ํ๋ฅผ ์ฝ๋๋ก ๋ํ๋ด๋ ๊ณผ์ ์ด ์ค์ํ๋ค๊ณ ์๊ฐํฉ๋๋ค. ์ด๋, ๊ธฐ์กด์ ๊ทธ๋ํ ๋ฌธ์ ์ ๋ค๋ฅด๊ฒ ์ธ์ ํ๋ ฌ์ด๋ ์ธ์ ๋ฆฌ์คํธ๋ก๋ ํด๋น ๋ฌธ์ ๋ฅผ ๊ตฌํํ ์ ์์ต๋๋ค. arrows์ ํฌ๊ธฐ๊ฐ 1 ์ด์ 100,000์ดํ๋ผ๋ ์กฐ๊ฑด์ผ๋ก ์ธํด ์ธ์ ํ๋ ฌ์ ๊ฒฝ์ฐ200_001 * 200_001 ์ ํฌ๊ธฐ๊ฐ ๋๊ธฐ ๋๋ฌธ์
๋๋ค. ์๋์ ๊ฐ์ด HashMap ์๋ฃ๊ตฌ์กฐ์ Node ํด๋์ค๋ฅผ ํตํด์ ๊ทธ๋ํ๋ฅผ ๊ตฌํํ ์ ์์ต๋..
๐ฅ์ฝ๋ฉํ
์คํธ:Algorithm
์ด๋ถํ์์ ํฌ๊ฒ ์กด์ฌ์ฌ๋ถ๋ฅผ ํ์
ํ๋ ์๊ณ ๋ฆฌ์ฆ, lower bound์ upper bound๋ฅผ ์ฐพ๋ ์๊ณ ๋ฆฌ์ฆ ๋ ๊ฐ์ง๊ฐ ์๋ค. ์กด์ฌ์ฌ๋ถ๋ฅผ ํ์
ํ๋ ๊ฒฝ์ฐ = ์ค๋ณต์์๋ฅผ ๊ณ ๋ คํ์ง ์์lower bound์ upper bound = ์ค๋ณต์์๋ฅผ ๊ณ ๋ ค์กด์ฌ์ฌ๋ถ ํ์
(์ค๋ณต์์ ๊ณ ๋ คํ์ง ์์)public static int binarySearch(int[] arr, int key) { int lo = 0; // ํ์ ๋ฒ์์ ์ผ์ชฝ ๋ ์ธ๋ฑ์ค int hi = arr.length - 1; // ํ์ ๋ฒ์์ ์ค๋ฅธ์ชฝ ๋ ์ธ๋ฑ์ค while(lo arr[mid]) { lo = mid + 1; } }} ์ค๋ณต์์ ๊ณ ๋ คlower boundprivate static int lowerBound(int[] arr, in..