๋ถ๋ฅ ์ ์ฒด๋ณด๊ธฐ
[Java] 133. Clone Graph
๋ฌธ์ ํ์ ๋ ธ๋๋ก ์ฐ๊ฒฐ๋ ๊ทธ๋ํ๊ฐ ์ฃผ์ด์ง๊ณ , ํด๋น ๊ทธ๋ํ๋ฅผ ๊น์ ๋ณต์ฌํด์ ๋ฐํํด์ผํ๋ค. ํ์ด 1๏ธโฃ bfs ๋ฅผ ์ด์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea ๊น์ ๋ณต์ฌ๋ฅผ ํ๊ธฐ ์ํด์๋ ์ด์ฉ๋ , ๋ชจ๋ ๋ ธ๋์ ๋ฐฉ๋ฌธํด๋ณด๊ณ ํด๋น ๊ฐ์ ๊ฐ๋ ์๋ก์ด ๋ ธ๋๋ฅผ ์์ฑํด์ผํ๋ค. ๋ฌธ์ ์์ val ๊ฐ์ unique ํ๋ค๊ณ ํ์ผ๋ฏ๋ก map์ val ์ ํค๊ฐ์ผ๋ก ํด์ ๋ ธ๋๋ฅผ ์ฐธ์กฐํด์ค๋ค. ์ฒซ๋ฒ์งธ ๋ ธ๋๋ถํฐ ์ด์ ๋ ธ๋๋ค์ ๋ฐฉ๋ฌธํด๋ณด๊ณ , map์ ๋ค์ด์์ง ์์(์์ง ๋ฐฉ๋ฌธํ์ง ์์) ๋ ธ๋๋ค์ ํ์ ์ง์ด๋ฃ์ด ์ด์ ๋ ธ๋๋ค์ ๋ฐฉ๋ฌธํ๊ธฐ๋ฅผ ๋ฐ๋ณตํ๋ค. ๋ง์ฝ map์ ๋ค์ด์๋(๋ฐฉ๋ฌธํ๋) ๋ ธ๋๋ผ๋ฉด ํ์ ๋ฃ์ง ์๊ณ ์ด์์ผ๋ก์ ์ถ๊ฐ๋ง ํด์ค๋ค. class Solution { Map map = new HashMap(); Queue q = new LinkedList(); pu..
[Java] 373. Find K Pairs with Smallest Sums
๋ฌธ์ ํ์ ๋น ๋ด๋ฆผ์ฐจ์์ธ ๋ ์ ์ ๋ฐฐ์ด nums1 ๊ณผ nums2 ๊ทธ๋ฆฌ๊ณ k๊ฐ ์ฃผ์ด์ง๋ค. k๊ฐ์ ๊ฐ์ฅ ํฉ์ด ์์ pair ๋ฅผ ๋ฐํํด์ผํ๋ค. ํ์ด 1๏ธโฃ PriortyQueue ์ ์ผ์ข ์ ๊ทธ๋ฆฌ๋ ๋ฒ์ ํ์ฉ ๐ก ์ฐธ๊ณ ํ Idea ์ด๋ฒ ๋ฌธ์ ๋, ์๋ฌด๋ฆฌ ์ด์ฌํ ๋ ์ฌ๋ ค๋ด๋ ์๊ฐ ์ด๊ณผ & ๋ฉ๋ชจ๋ฆฌ ์ด๊ณผ ๋๋ฌธ์ ํด๊ฒฐํ์ง ๋ชปํ๊ณ ๋ค๋ฅธ ์ฌ๋์ ์์ด๋์ด๋ฅผ ์ฐธ๊ณ ํ์ฌ ํด๊ฒฐํ์๋ค. ํต์ฌ ์์ด๋์ด๋ ๋ค์๊ณผ ๊ฐ๋ค. ๋จผ์ , ๋ ์์์ ํฉ์ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ์ฐ์ ์์ ํ๋ฅผ ์ค๋นํ๋ค. nums1 ๋ฐฐ์ด์ ์ธ๋ฑ์ค๋ 0 ์ผ๋ก ๊ณ ์ ํ ์ฑ, nums2 ๋ฐฐ์ด์ ์ํํ๋ฉฐ ํฉ์ ๊ตฌํ๊ณ ์ฐ์ ์์ ํ์ ์ ๋ ฅํ๋ค. ์ฐ์ ์์ ํ์๋ [ nums1์ ๊ฐ, nums2 ์ ๊ฐ, nums1์ ์ธ๋ฑ์ค, nums1์ ๊ฐ +nums2์ ๊ฐ ] ์ผ๋ก ์ ๋ ฅํด์ค๋ค. ..
[Java] 215. Kth Largest Element in an Array
๋ฌธ์ ํ์ ์ ์ ๋ฐฐ์ด nums ๊ฐ ์ฃผ์ด์ง๊ณ k๊ฐ ์ฃผ์ด์ง๋ค. k๋ฒ์งธ๋ก ํฐ ์์๋ฅผ ๋ฐํํ๋ฉด ๋๋ค. ํ์ด 1๏ธโฃ PriorityQueue๋ฅผ ํ์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ์ฐ์ ์์ํ์ ์์๋ค์ ๋ฃ๊ณ k๋ฒ์งธ์ ์์๋ฅผ ๋ฐํํ๋ค. import java.util.*; class Solution { public int findKthLargest(int[] nums, int k) { PriorityQueue pq = new PriorityQueue((a, b) -> b - a); for (int num : nums) { pq.offer(num); } int ans = 0; while (k-- > 0) { ans = pq.poll(); } return ans; } } ๊ฒฐ๊ณผ ๐ ํ๊ณ ๋๋ฌด ๊ฐ๋จํ๊ฒ ๋ฌธ์ ..
[Java] 212. Word Search II
๋ฌธ์ ํ์ ๋ฌธ์๊ฐ ์ฑ์์ ธ์๋ m*n ํฌ๊ธฐ์ ๋ณด๋๊ฐ ์ฃผ์ด์ง๋ค. ๋ฌธ์์ด์ด ์ฃผ์ด์ง๋๋ฐ, ํด๋น ๋ฌธ์์ด์ ๋ง๋ค ์ ์์ผ๋ฉด ๋ฐํํ๋ค. ํ์ด 1๏ธโฃ ๋ฐฑํธ๋ํน๊ณผ Set ์ด์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea ๋ฐฑํธ๋ํน์ผ๋ก ๋ง๋ค ์ ์๋ ๋ฌธ์์ด์ ๋ชจ๋ ๊ตฌํด๋ณธ๋ค. ( ์ต๋ ๊ธธ์ด 10์ผ๋ก) ๊ตฌํ ๋ฌธ์์ด์ Set ์ ๋ฃ๊ณ , ์ฃผ์ด์ง๋ ๋ฌธ์์ด์ด Set์ ๋ค์ด์๋์ง ํ์ธํ๋ค. import java.util.*; class Solution { int R; int C; boolean[][] checked; StringBuilder str = new StringBuilder(); int[] dr = {1, -1, 0, 0}; int[] dc = {0, 0, 1, -1}; char[][] board; Set set = new HashSet(); ..
[Java] 211. Design Add and Search Words Data Structure
๋ฌธ์ ํ์ ํน์ ๋ฌธ์์ด์ ๋ณด๊ดํ๊ณ search ํ์ ๋, ์กด์ฌํ๋ฉด true๋ฅผ ๋ฐํํ๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๋ง๋ค์ด์ผํ๋ค. . ์ด ํฌํจ๋ ๊ฒฝ์ฐ๋ ์ด๋ ํ ๋ฌธ์๊ฐ ๋ค์ด๊ฐ๋ ํ์ฉ๋๋ค. ํ์ด 1๏ธโฃ Trie ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea Trie ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ๋ฉด ์ ๋์ด๋ ๋ถ๋ถ ๋ฌธ์์ด์ ๊ฒ์ํ ์ ์๋ค. ๋ฐ๋ผ์, Trie ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ตฌํํ์๋ค. ํนํ, ์ด ๋ฌธ์ ์์๋ search ๊ณผ์ ์์ . ์ด ํฌํจ๋์ด ์๋ ๊ฒฝ์ฐ๋ ํด๋น ๋ ธ๋๊ฐ ๊ฐ๋ ๋ชจ๋ ์์ ๋ ธ๋๋ค์ ํ์ํ๋๋ก ๊ตฌํํ์ฌ ํด๊ฒฐํ ์ ์์ ๊ฒ์ด๋ผ ํ๋จํ์๋ค. import java.util.*; class WordDictionary { static class Node { Map children; boolean isEndOfWord; public Node() { t..
[Java] 208. Implement Trie (Prefix Tree)
๋ฌธ์ ํ์ Trie ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ตฌํํด์ผํ๋ ๋ฌธ์ ์ด๋ค. ํธ๋ผ์ด๋ ๋ฌธ์์ด์ ์ ์ฅํ๊ณ ํจ์จ์ ์ผ๋ก ํ์ํ๊ธฐ ์ํ ํธ๋ฆฌ ํํ์ ์๋ฃ๊ตฌ์กฐ์ด๋ค. ํด์ ํ ์ด๋ธ์ ์ฌ์ฉํ๋ฉด ๋๋๋ฐ, ์ ํธ๋ผ์ด๋ฅผ ์ฌ์ฉํด์ผํ ๊น? ๐จ ํด์ ํ ์ด๋ธ์ ๊ฒฝ์ฐ ์ ๋์ฌ๋ ๋ถ๋ถ ๋ฌธ์์ด๋ก ๊ฒ์ํ๊ธฐ ํ๋ค๋ค. ๋ํ, ํด์ ์ฝ๋๋ก ์ ์ฅํ๊ธฐ ๋๋ฌธ์ ์ ๋ ฌ๋์ด ์์ง ์๋ค. ํ์ด 1๏ธโฃ Node ํด๋์ค ์ ์ class Trie { Node root; static class Node { Map children; boolean isEndOfWord; public Node() { this.children = new HashMap(); this.isEndOfWord = false; } } public Trie() { this.root = new Node(); } } Trie..
[JAVA] ๋ฐฑ์ค 1781๋ฒ ใG2.์ปต๋ผ๋ฉดใ
๋ฌธ์ 1781๋ฒ: ์ปต๋ผ๋ฉด ์์ฑ ์กฐ๊ต๋ ๋ํธ์๊ฒ N๊ฐ์ ๋ฌธ์ ๋ฅผ ์ฃผ๊ณ ์, ๊ฐ๊ฐ์ ๋ฌธ์ ๋ฅผ ํ์์ ๋ ์ปต๋ผ๋ฉด์ ๋ช ๊ฐ ์ค ๊ฒ์ธ์ง ์ ์ ํ์๋ค. ํ์ง๋ง ๋ํธ์ ์ฐ๋ฅผ๋ฏํ ์์ ๊ฐ์ ์์ฌํ ์์ฑ ์กฐ๊ต๋ ๊ฐ๊ฐ์ ๋ฌธ์ ์ ๋ํด ๋ฐ๋๋ผ www.acmicpc.net ํ์ด 1๏ธโฃ ์ฐ์ ์์ ํ์ ๊ทธ๋ฆฌ๋๋ฅผ ์ด์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea ์ปต๋ผ๋ฉด์ ๋ฐ๋๋ผ์ธ์ด ์งง๊ณ ์ปต๋ผ๋ฉด์ ๋ง์ด ์ฃผ๋ ๋ฌธ์ ๋ถํฐ ๊ฒฐ์ ํด์ ํ์ ์ง์ด๋ฃ๋๋ค. ์ฆ, ํ์ ํฌ๊ธฐ = ํ๊ธฐ๋ก ๊ฒฐ์ ํ ๋ฌธ์ ์ = ๋ด๊ฐ ๋ฌธ์ ๋ฅผ ํธ๋๋ฐ ์ฌ์ฉํ ์๊ฐ์ด ๋๋ค. ๊ทธ๋ฆฌ๊ณ , ์ดํ์ ๋์ค๋ ๋ฌธ์ ๋ค์ด ๋ด ํ์ ํฌ๊ธฐ๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ผ๋ฉด์ ๋ด ํ์ ๋ค์ด์๋ ์ปต๋ผ๋ฉด๋ณด๋ค ๋ง์ด ์ค๋ค๋ฉด ๋ด ํ์ ๋ค์ด์๋ ๊ฐ์ฅ ์ปต๋ผ๋ฉด์ ์ ๊ฒ ์ฃผ๋ ๋ฌธ์ ๋ฅผ ์ ๊ฑฐํ๊ณ , ์ถ๊ฐํด์ค๋ค. ์์ ๋ก ์๋ฆฌ๋ฅผ ์ค๋ช ํด๋ณด๋ฉด, ๋จผ์ , ๋ฐ๋๋ผ์ธ์ด ์งง์ ..
[JAVA] ๋ฐฑ์ค 1655๋ฒ ใG2.๊ฐ์ด๋ฐ๋ฅผ ๋งํด์ใ
๋ฌธ์ 1655๋ฒ: ๊ฐ์ด๋ฐ๋ฅผ ๋งํด์ ์ฒซ์งธ ์ค์๋ ๋ฐฑ์ค์ด๊ฐ ์ธ์น๋ ์ ์์ ๊ฐ์ N์ด ์ฃผ์ด์ง๋ค. N์ 1๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 100,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค. ๊ทธ ๋ค์ N์ค์ ๊ฑธ์ณ์ ๋ฐฑ์ค์ด๊ฐ ์ธ์น๋ ์ ์๊ฐ ์ฐจ๋ก๋๋ก ์ฃผ์ด์ง๋ค. ์ ์๋ -1 www.acmicpc.net ํ์ด 1๏ธโฃ ์ฐ์ ์์ ํ ๋๊ฐ๋ฅผ ํ์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea ์ฐ์ ์์ ํ๋ ์ด์ง ํ ๋ฐฉ์์ผ๋ก ๊ตฌ์ฑ๋์ด ์๊ธฐ ๋๋ฌธ์, ์ฌ์ฉํ๋ฉด ์ ๋ ฌ์ ์ ์งํ ์ฝ์ ๊ณผ์ ์ O(logN) ์ ์ํํ ์ ์๋ค. ๊ทธ๋ฆฌ๊ณ , ์ฐ์ ์์ ํ์ ๋ฐ๋ผ ์ ๋ ฌ๋ ๋ฐ์ดํฐ๋ฅผ ๊บผ๋ผ ๋ ์ญ์, O(logN) ๋ก ์ํํ ์ ์๋ค. ๋ฐ๋ผ์ ์ฐ์ ์์ ํ๋ฅผ ์ฌ์ฉํ๋๊ฒ ์๊ฐ ๋ณต์ก๋๋ฅผ ๋ง์กฑ์ํฌ ์ ์๋ค๊ณ ํ๋จํ์๋ค. ๊ฐ์ด๋ฐ ์๋ฅผ ํญ์ ๋งํด์ผ ํ๋ฏ๋ก, ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌ๋ ์ฐ์ ์์ ํ (l..
[Java] 637. Average of Levels in Binary Tree
๋ฌธ์ ํ์ ๊ฐ level(depth)์ ๋ ธ๋๋ค์ val ๊ฐ ํ๊ท ์ ๊ตฌํด์ ๋ฐํํด์ผํ๋ค. ํ์ด 1๏ธโฃ ๊ทธ๋ํ ํ์์ ์ด์ฉํ ํ์ด (์ ์ ํ์) ๐ก ๋ ์ค๋ฅธ Idea ์ ์ ํ์์ depth๋ฅผ 1์ฉ ์ฆ๊ฐ์ํค๋ฉด์ ํ์์ ํ๋ค. ๊ฐ depth์ ๋๋ฌํ์ ๋, ํด๋น depth์ ํฉ๊ณผ ๊ฐ์๋ฅผ ์ ์ฅํ๋ List๋ฅผ ํตํด ์ ๋ณด๋ฅผ ๊ฐฑ์ ํ๋ค. ํ์์ด ๋๋๊ณ ๋์, ํ๊ท ๊ฐ์ ๊ตฌํด์ ๋ฐํํด์ค๋ค. import java.util.*; class Solution { List list = new ArrayList(); public List averageOfLevels(TreeNode root) { List ans = new ArrayList(); preOrder(root, 0); for (int i = 0; i < list.size()..
[Java] 199. Binary Tree Right Side View
๋ฌธ์ ํ์ ์ฃผ์ด์ง๋ ํธ๋ฆฌ๋ฅผ, ์ค๋ฅธ์ชฝ์์ ๋ฐ๋ผ๋ณด์์ ๋ ๋ณด์ด๋ ๋ ธ๋๋ค์ ๋ฐํํด์ผํ๋ค. ๋ฌธ์ ํด์ ์, ์ฝ๊ฐ ํผ๋์ด ์์ด์ ์ฒ์์๋ ํธ๋ฆฌ์ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ๋ ธ๋๋ค์ ์ถ๋ ฅํด์ผํ๋ ์ค ์์๋ค. ๋ฐ๋ผ์ ์์ ๊ฐ์ด ๊ตฌ์ฑ๋ ํธ๋ฆฌ์ ๊ฒฝ์ฐ, root ๋ ธ๋์ right node ๋ ์๊ธฐ ๋๋ฌธ์ ๊ฒฐ๊ณผ๊ฐ [1] ์ด ๋์์ผ ๋๋ค๊ณ ์๊ฐํ๋๋ฐ ์๊ตฌํ๋ ๋ต์ [1,2] ์๋ค. ํด์์ ์ฐพ์๋ณด๋, ์ด ํธ๋ฆฌ๋ฅผ ์ค๋ฅธ์ชฝ์์ ๋ฐ๋ผ๋ดค์ ๋ ๋ณด์ด๋ ๋ ธ๋๋ค์ ์ถ๋ ฅํ๋ผ๋ ๋ป์ด์๋ค. ํ์ด 1๏ธโฃ ์ ์ ํ์์ ์ด์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea ์ ์ ํ์์ ๊ฒฝ์ฐ ์์ ๊ฐ์ด ๋ฃจํธ ๋ ธ๋์์ ์์ํ์ฌ ์ผ์ชฝ ํน์ ์ค๋ฅธ์ชฝ ๊ฒฝ๋ก์ ๋์ ๋๋ฌํ๋ฉด ๋ถ๋ชจ์ ๋ฐ๋ํธ ๋ ธ๋๋ก ๋์ด๊ฐ๋ ๋ฐฉ์์ผ๋ก ํ์ํ๋ค. ์ ๋ฌธ์ ์ ๊ฒฝ์ฐ๋ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ์ ํ์ํด์ผํ๋ฏ๋ก ๊ฒฝ๋ก๋ฅผ ์ค๋ฅธ์ชฝ์ผ๋ก ์์ํ๋๋ก ..
[Java] 230. Kth Smallest Element in a BST
๋ฌธ์ ํ์ k๋ฒ์งธ๋ก ์์ ๊ฐ์ ์ถ๋ ฅํด์ผํ๋ค. ํ์ด 1๏ธโฃ ์ค์ ์ํ๋ฅผ ์ด์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea ํธ๋ฆฌ ๊ตฌ์กฐ์์ ์ค์ ์ํ๋ฅผ ํ๋ฉด ์ค๋ฆ์ฐจ์ ์์๋ก ๋ ธ๋ ๋ฐ์ดํฐ๋ฅผ ์ถ๋ ฅํ ์ ์๋ค. ์ด๋ฌํ ์๋ฆฌ๋ฅผ ์ ์ฉํ์ฌ k๋ฒ์งธ ๋ ธ๋์ ์ ๊ทผํ์ ๋, ๊ฐ์ ์ ์ฅํ๋๋ก ๊ตฌํํ๋ฉด ๋๊ฒ ๋ค๊ณ ํ๋จํ์๋ค. class Solution { int ans = 0; int idx = 1; public int kthSmallest(TreeNode root, int k) { inOrder(root, k); return ans; } private void inOrder(TreeNode node, int k) { if (node == null) { return; } inOrder(node.left, k); if (idx == k) { ans =..
[Java] 530. Minimum Absolute Difference in BST
๋ฌธ์ ํ์ ํธ๋ฆฌ ์์ ์กด์ฌํ๋ ์์์ ๋ ๋ ธ๋์ ์ฐจ ์ค ์ต์๊ฐ์ ๋ฐํํด์ผํ๋ค. ํ์ด 1๏ธโฃ ์ค์ ์ํ๋ฅผ ์ด์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea ๋ ธ๋ ๊ตฌ์กฐ์์ ์ค์ ์ํ๋ฅผ ํ๋ฉด์ ๋ ธ๋ ๊ฐ์ ์ถ๋ ฅํ๋ฉด ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋ ๋ฐ์ดํฐ๋ฅผ ์ป์ ์ ์๋ค๋ ํน์ง์ ์ด์ฉํ์๋ค. ์ฒซ๋ฒ์งธ ๋ ธ๋๋ ์ด์ ๋ ธ๋๊ฐ ์กด์ฌํ์ง ์์ผ๋ฏ๋ก, ๊ณ์ฐ์ ์๋ตํ๋ค. ๊ทธ๋ฆฌ๊ณ ์ด์ ๋ ธ๋ ๊ฐ์ ๊ธฐ๋กํด์ค๋ค. ๋๋ฒ์งธ ๋ ธ๋์ ๋๋ฌํ์ ๋, ์ด์ ๋ ธ๋ ๊ฐ๊ณผ์ ์ฐจ์ด๋ฅผ ๊ตฌํ๊ณ ๊ฐฑ์ ํ๋ค. ๊ฐฑ์ ํ, ์ด์ ๋ ธ๋ ๊ฐ์ ๋๋ฒ์งธ ๊ฐ์ ๊ธฐ๋กํด์ค๋ค. .... ์ ๊ณผ์ ์ ๋ฐ๋ณตํ๋ ๋ฐฉ์์ด๋ค. class Solution { int ans = Integer.MAX_VALUE; Integer prev = null; public int getMinimumDifference(TreeNode r..
[JAVA] ๋ฐฑ์ค 1715๋ฒ ใG4.์นด๋ ์ ๋ ฌํ๊ธฐใ
๋ฌธ์ 1715๋ฒ: ์นด๋ ์ ๋ ฌํ๊ธฐ ์ ๋ ฌ๋ ๋ ๋ฌถ์์ ์ซ์ ์นด๋๊ฐ ์๋ค๊ณ ํ์. ๊ฐ ๋ฌถ์์ ์นด๋์ ์๋ฅผ A, B๋ผ ํ๋ฉด ๋ณดํต ๋ ๋ฌถ์์ ํฉ์ณ์ ํ๋๋ก ๋ง๋๋ ๋ฐ์๋ A+B ๋ฒ์ ๋น๊ต๋ฅผ ํด์ผ ํ๋ค. ์ด๋ฅผํ ๋ฉด, 20์ฅ์ ์ซ์ ์นด๋ ๋ฌถ์๊ณผ 30์ฅ www.acmicpc.net ํ์ด 1๏ธโฃ PriorityQueue ๋ฅผ ํ์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea ์ฝ๊ฐ, ๊ทธ๋ฆฌ๋ ์ฒ๋ผ ์๊ฐ์ ํด๋ณด์๋ค. ๋์ ์ผ๋ก ๋ฌถ์์ ์๋งํผ ํฉ์ณ์ง๋ฏ๋ก, ๊ฐ์ฅ ์์ ๋ฌถ์์ ์๋ง ์ค๋ณต์ผ๋ก ๊ฐ์ ๋ํด์ ธ์ผํ๋ค. ๊ฒฐ๋ก ์, ์นด๋ ๋ฌถ์์ ํฉ์น๋๋ฐ ๋จ์ ์นด๋ ๋ฌถ์ ์ค์์ ๊ฐ์ฅ ์์ ๋ ๋ฌถ์์ ๊ณจ๋ผ์ ํฉ์ณ์ผ ํ๋ค. ์นด๋ ๋ฌถ์์ ํฉ์น๊ฒ ๋๋ฉด, ๋ค๋ฅธ ํ๋ณด ๋ฌถ์๋ค ๋ณด๋ค ์ปค์ง๊ฒ ๋ ์๋ ์๊ณ ์ฌ์ ํ ์์ ์๋ ์๋ค. ๋ฐ๋ผ์, ์ผ๋จ์ ์ด ์นด๋ ๋ฌถ์์ ๋ค์ ํ๋ณด๋ก ์ฌ๋ ค๋๊ณ ,..
[JAVA] ๋ฐฑ์ค 23326๋ฒ ใG3.ํ์ต ํฌ์ด๋ฆฌ์คํธใ
๋ฌธ์ 23326๋ฒ: ํ์ต ํฌ์ด๋ฆฌ์คํธ ๋ํ์ด๋ ํ์ต ํฌ์ด๋ฆฌ์คํธ๊ฐ ๋์ด ํ์ต๋ํ๊ต๋ฅผ ๊ฒฌํํ๋ ค๊ณ ํ๋ค. ํ์ต๋ํ๊ต๋ $N$๊ฐ์ ๊ตฌ์ญ์ด ์ํ์ผ๋ก ๋ฐฐ์น๋ ๋ชจ์ต์ด๋ค. $1$๋ฒ ๊ตฌ์ญ์์ ์๊ณ ๋ฐฉํฅ์ผ๋ก ๊ฐ๊ฐ $2$๋ฒ, ... , $N$๋ฒ ๊ตฌ์ญ์ด ์กด์ฌํ๊ณ , www.acmicpc.net ํ์ด 1๏ธโฃ treeSet์ ์ด์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea ๊ตฌ์ญ์ ๊ฐ์๊ฐ 500000 ์ด๊ณ ์ฟผ๋ฆฌ์ ๊ฐ์๊ฐ 100000 ์ด๋ฏ๋ก ์ ํํ์์ ํ๊ฒ๋๋ฉด ์๊ฐ๋ณต์ก๋๊ฐ ์ต๋ 500000*100000 ์ผ๋ก ์ ๋ ํต๊ณผ ๋ชปํ๋ ์์น๊ฐ ๋์จ๋ค. ๋ฐ๋ผ์, treeSet์ ์ด์ฉํ ํ์ด๊ฐ ํ์ํ๋ค. treeSet์ ๋๋ถ๋ถ์ ๋ฉ์๋๋ log(N) ์ ์ฑ๋ฅ์ผ๋ก ๋์ํ๊ธฐ ๋๋ฌธ์ด๋ค. treeSet์ ๋ช ์ ๋ฒํธ๋ฅผ ๊ฐฑ์ ํ๊ณ , ์ฟผ๋ฆฌ๋ฌธ์ ์ํํ๋ฉด์ ๋ํ์ด์ ์์น๋ ๊ฐฑ์ ํ๋ค...
Hash ์๋ฃ๊ตฌ์กฐ์ ํด์ ์ถฉ๋
Hash Table ์ด๋ Hash Table์ ๋ฐ์ดํฐ๋ฅผ key-value ํ์์ผ๋ก ๋ณด๊ดํ์ฌ ๊ฒ์ · ์ฝ์ · ์ญ์ ๋ฅผ O(1) ์๊ฐ ๋ณต์ก๋๋ก ์ํํ ์ ์๋ ์๋ฃ๊ตฌ์กฐ์ด๋ค. Hash Table์ key ๊ฐ์ ํตํด ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๊ธฐ ๋๋ฌธ์, key ๊ฐ์ ๊ณ ์ ํด์ผํ๋ค. ์ด๋ฌํ ๊ณ ์ ํ key ๊ฐ์ ๋ง๋๋ ์์ ์ ํด์ ํจ์๊ฐ ๋ด๋นํ๋๋ฐ, ๋ํ์ ์ผ๋ก๋ key ๊ฐ์ ASCII ๊ฐ์ ํฉํ์ฌ ๋ง๋๋ ๊ฐ๋จํ ๋ฐฉ๋ฒ์ด ์๋ค. ์ด๋ฌํ ํด์ ํจ์๊ฐ key๋ฅผ ๋ง๋๋ ๊ณผ์ ์์, ์๋ํ์ง ์๊ฒ ์ฐ์ฐํ key ๊ฐ์ด ์ผ์นํ๋ ๊ฒฝ์ฐ๊ฐ ๋ฐ์ํ ์ ์๋๋ฐ ๐ก ์ด๋ฅผ ํด์ ์ถฉ๋์ด๋ผ๊ณ ํ๋ค. ํด์ ์ถฉ๋์ด ๋ฐ์ํ๋ฉด, key ๊ฐ์ด ์ค๋ณต๋์ด ๋ฐ์ดํฐ๊ฐ ์ฌ๋ผ์ง ์ ์๋ค. ๋ฐ๋ผ์ ํด์ ์ถฉ๋์ด ๋ฐ์ํ๋ฉด ๋์ฒํด์ผํ๋ค. ๋ํ์ ์ธ ๋ฐฉ๋ฒ์ผ๋ก๋ ์ฒด์ธ๋ฒ (Seperate C..