๐จ๐ป๐ป PS
[Java] 162. Find Peak Element
๋ฌธ์ ํ์ ์ฃผ๋ณ ์์๋ค๋ณด๋ค ํฐ ์์๋ฅผ peak element๋ผ๊ณ ํ๋ค. ๊ทธ๋ฌํ ์์๊ฐ ์ฌ๋ฌ๊ฐ๋ผ๋ฉด ์๋ฌด ์์์ ์ธ๋ฑ์ค๋ฅผ ๋ฐํํ๋ฉด ๋๋ค. ์๊ฐ ๋ณต์ก๋๊ฐ O(logN) ์ด ๋๋๋ก ๊ตฌํํด์ผํ๋ค. ํ์ด 1๏ธโฃ ์ด๋ถ ํ์์ ์ด์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea ์๊ฐ๋ณต์ก๋๋ฅผ ํตํด ์ด๋ถ ํ์์ ์ด์ฉํด์ผํจ์ ์ ์ ์์๋ค. ๋ณดํต ์ด๋ถํ์์ ์ ๋ ฌ๋ ๋ฐฐ์ด์์๋ง ์ฌ์ฉํด์์, ์ด๋ถ ํ์์ ์ด๋ป๊ฒ ํ์ฉํ ์ ์์์ง ์ค๋ซ๋์ ์๊ฐํด๋ณด์๋ค. mid ํฌ์ธํธ ๊ฐ์ด mid + 1 ํฌ์ธํธ ๊ฐ๋ณด๋ค ์๋ค๋ฉด? mid ํฌ์ธํธ ๊ฐ์ peak element ๊ฐ ๋ ํ๋ฅ ์ด ์กด์ฌํ์ง ์๋๋ค. ๋ฐ๋ผ์ ํ์ ๋ฒ์๋ฅผ mid+1 ์ด์์ผ๋ก ์ก์์ค์ผ ํ ๊ฒ์ด๋ค. ๋ง์ฝ, mid ํฌ์ธํธ ๊ฐ์ด mid + 1 ํฌ์ธํธ ๊ฐ ๋ณด๋ค ํฌ๋ค๋ฉด mid ํฌ์ธํธ ๊ฐ์ peak element ..
[Java] 148. Sort List
๋ฌธ์ ํ์ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ head๊ฐ ์ฃผ์ด์ง๋ค. ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํด์ ๋ฐํํด์ผํ๋ค. ํ์ด 1๏ธโฃ ๋ฐฐ์ด๊ณผ mergeSort ๐ก ๋ ์ค๋ฅธ Idea O(NlogN) ๋ฐฉ์์ผ๋ก ํด๊ฒฐํ๊ธฐ ์ํ ๋ฐฉ๋ฒ์ ๋ ์ฌ๋ ค๋ดค๋ค. ํด๋น ์๊ฐ ๋ณต์ก๋๋ก ์ ๋ ฌํ ์ ์๋ Merge Sort ๋ฐฉ์์ ์ฌ์ฉํด์ผ ํด๊ฒฐํ ์ ์์ ๊ฒ์ด๋ผ ํ๋จํ๋ค. class Solution { public ListNode sortList(ListNode head) { int cnt = getCount(head); System.out.println(cnt); int[] arr = new int[cnt]; ListNode dummyHead = new ListNode(0, head); ListNode node = head; for (int i = 0; i < cnt; i..
[JAVA] ๋ฐฑ์ค 22939๋ฒ ใG4.๋ฌธ์ ์ถ์ฒ ์์คํ Version 1ใ
๋ฌธ์ 21939๋ฒ: ๋ฌธ์ ์ถ์ฒ ์์คํ Version 1 tony9402๋ ์ต๊ทผ ๊นํ์ ์ฝ๋ฉํ ์คํธ ๋๋น ๋ฌธ์ ๋ฅผ ์ง์ ๋ฝ์์ "๋ฌธ์ ๋ฒํธ, ๋์ด๋"๋ก ์ ๋ฆฌํด๋จ๋ค. ๊นํ์ ์ด์ฉํ์ฌ ๊ณต๋ถํ์๋ ๋ถ๋ค์ ์ํด ์๋ก์ด ๊ธฐ๋ฅ์ ์ถ๊ฐํด๋ณด๋ ค๊ณ ํ๋ค. ๋ง๋ค๋ ค๊ณ ํ๋ ๋ช ๋ น www.acmicpc.net ํ์ด 1๏ธโฃ TreeMap ๊ณผ TreeSet์ ์ด์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea 1. ์๊ตฌ์ฌํญ์ ๊ฐ์ฅ ๋์ด๋๊ฐ ๋ฎ์ ๊ฒ์์ ๊ฐ์ฅ ๋ฌธ์ ๋ฒํธ๊ฐ ์์ ๊ฒ๊ณผ ๊ฐ์ฅ ๋์ด๋๊ฐ ๋์ ๊ฒ์์ ๊ฐ์ฅ ๋ฌธ์ ๋ฒํธ๊ฐ ํฐ ๊ฒ์ ์ถ๋ ฅํ๋ผ๊ณ ํ๋ค. ๋ฐ๋ผ์, ๋์ด๋๋ฅผ key๋ก ์ ๋ ฌํด์ฃผ๋ TreeMap์์ value๋ก ๋ฌธ์ ๋ฒํธ์ ํฌ๊ธฐ์์ผ๋ก ์ ๋ ฌํด์ฃผ๋ TreeSet์ ์ฌ์ฉํ๋ฉด ๋๊ฒ ๋ค๊ณ ํ๋จํ๋ค. 2. ๋ํ, solved ์์ฒญ ์ ๋ฌธ์ ๋ฒํธ๋ฅผ ์ ๋ ฅ๋ฐ์ ์ง์์ผ ํ๋..
[JAVA] ๋ฐฑ์ค 20166๋ฒ ใG4.๋ฌธ์์ด ์ง์ฅ์ ๋น ์ง ํธ์ใ
๋ฌธ์ 20166๋ฒ: ๋ฌธ์์ด ์ง์ฅ์ ๋น ์ง ํธ์ K๊ฐ์ ์ค์ ๊ฑธ์ณ์, ์ ์ด ์ข์ํ๋ ๋ฌธ์์ด์ ๋ง๋ค ์ ์๋ ๊ฒฝ์ฐ์ ์๋ฅผ ์์๋๋ก ์ถ๋ ฅํ๋ค. www.acmicpc.net ํ์ด 1๏ธโฃ ๋ฐฑํธ๋ํน๊ณผ map์ ์ด์ฉํ ํ์ด ์ด ๋ฌธ์ ๋ ๋ฐฑํธ๋ํน๊ณผ ํด์๋ฅผ ํตํด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ์๋ค. ๋ฐฑํธ๋ํน์ ํตํด์ ๋ง๋ค ์ ์๋ ๋ฌธ์์ด์ ์กฐํฉ๋ณ ๊ฐ์๋ฅผ ๊ธฐ๋กํ์๋๋ฐ, ๊ฒฝ๋ก๊ฐ ๋ค๋ฅด๋ฉด ๋ค๋ฅธ ๊ฒฝ์ฐ์ ์๋ก ์น๊ธฐ ๋๋ฌธ์ด๋ค. ๋ฐฑํธ๋ํน์ map์ ๊ฐ ํฌ์ธํธ์์ ์์ํ๋๋ก ์ค์ ํ์๊ณ ํ์ถ ์กฐ๊ฑด์ ์ค์ ํ ๊ธธ์ด์ ๋๋ฌํ์ ๋ ๊ธฐ๋กํ๋ ๋ฐฉ์์ ์ฌ์ฉํ๋ค. ์๋ํ๋ฉด, ์๋ฅผ ๋ค์ด (1,1) ์์ ์์ํด์ ๊ธธ์ด๊ฐ 2๋ฅผ ๋ง์กฑํ ๋์ ๊ฒฝ์ฐ์ ์๋ ๋ค๋ฅธ ํฌ์ธํธ์์ ์์ํ ๊ธธ์ด๊ฐ 2์ธ ๊ฒฝ์ฐ์ ์ ๋ ์ค๋ณต์ด ๋ฐ์ํ์ง ์์ ๊ฒ์ด๋ผ ํ๋จํ๊ธฐ ๋๋ฌธ์ด๋ค. import java.io.*;..
[Java] 242. Valid Anagram
๋ฌธ์ ํ์ ๋ ๋ฌธ์์ด s์ t๊ฐ ์ฃผ์ด์ง๋ค. ๋ ๋ฌธ์์ด์ ์ด๋ฃจ๋ ๋ฌธ์์ ์ข ๋ฅ์ ๊ฐ์๊ฐ ๋์ผํ ๋, Anagram ์ด๋ผ๊ณ ํ๋๋ฐ Anagram์ธ์ง ํ๋จํ๋ ๋ฌธ์ ์ด๋ค. ํ์ด 1๏ธโฃ map์ ์ด์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea s ๋ฌธ์์ด์ ์ชผ๊ฐ ํ, ๊ฐ ๋ฌธ์๋ณ ๊ฐ์๋ฅผ map์ ๊ธฐ๋กํ๋ค. ๊ทธ๋ฆฌ๊ณ t ๋ฌธ์์ด์ ์ชผ๊ฐ ํ, ์ํํ๋ฉด์ map์ ๊ธฐ๋ก๋์ด์๋์ง ํ์ธํ๊ณ ๊ฐ์๋ฅผ -1 ํ๋ค. ๋ง์ฝ, ๋ฌธ์๊ฐ ์กด์ฌํ์ง ์๊ฑฐ๋ ๊ฐ์๊ฐ 0๋ฏธ๋ง์ด ๋๋ฉด false๋ฅผ ๋ฐํํ๋ค. ๋ํ, ์ ์ด์ ๋ฌธ์์ด์ ๊ธธ์ด๊ฐ ๋ค๋ฅด๋ค๋ฉด false๋ฅผ ๋ฐํํ๋ค. [Java] 383. Ransom Note ๋ฌธ์ ํ์ ransomNote ๋ฌธ์์ด์ด magazine ๋ฌธ์์ด์ ๋ฌธ์๋ค๋ก ๊ตฌ์ฑ๋ ์ ์์ผ๋ฉด true๋ฅผ, ๊ทธ๋ ์ง ์๋ค๋ฉด false๋ฅผ ๋ฐํํด์ผํ๋ค. magazine์..
[Java] 383. Ransom Note
๋ฌธ์ ํ์ ransomNote ๋ฌธ์์ด์ด magazine ๋ฌธ์์ด์ ๋ฌธ์๋ค๋ก ๊ตฌ์ฑ๋ ์ ์์ผ๋ฉด true๋ฅผ, ๊ทธ๋ ์ง ์๋ค๋ฉด false๋ฅผ ๋ฐํํด์ผํ๋ค. magazine์ ๋ฌธ์๋ ์ค๋ณต์ผ๋ก ์ฌ๋ฌ๋ฒ ์ฐ์ผ ์ ์๋ค. ํ์ด 1๏ธโฃ map์ ์ด์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea magazine ๋ฌธ์์ด์ ๋ฌธ์๋ก ์ชผ๊ฐ ํ, map ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ด์ฉํด์ ๋ฌธ์ ๋ณ ๊ฐ์๋ฅผ ๊ธฐ๋กํ๋ค. ๊ทธ๋ฆฌ๊ณ , ransomNote ๋ฌธ์์ด์ ๋ฌธ์๋ฅผ ์ํํ๋ฉด์ ๊ธฐ๋กํ map ์๋ฃ๊ตฌ์กฐ์ ๋ฌธ์๊ฐ ์กด์ฌํ๋์ง ์ฒดํฌํ๊ณ ์๋ค๋ฉด ๊ฐ์๋ฅผ -1 ํ๋ค. ๊ธฐ๋ก๋์ด ์๋ ๋ฌธ์๊ฐ ์๊ฑฐ๋ ๊ฐ์๊ฐ ๋ชจ์๋ฅธ ๊ฒฝ์ฐ false ๋ฅผ ๋ฐํํ๋ค. import java.util.*; class Solution { public boolean canConstruct(String ransomNote, S..
[Java] 219. Contains Duplicate II
๋ฌธ์ ํ์ ์ ์ ๋ฐฐ์ด์ธ nums ์์ ๋ ์ธ๋ฑ์ค์ ์ฐจ์ด๊ฐ k ์ดํ์ด๋ฉด์ ๊ฐ์ด ๊ฐ์ผ๋ฉด true๋ฅผ ๋ฐํํ๊ณ ์๋ค๋ฉด false๋ฅผ ๋ฐํํด์ผํ๋ค. ํ์ด 1๏ธโฃ Map์ ์ด์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea nums๋ฅผ ์ํํ๋ฉด์ map์ ๊ฐ์ key๋ก ์ธ๋ฑ์ค๋ฅผ value๋ก ์ ์ฅํ๊ณ , map์ ์ด๋ฏธ ์กด์ฌํ๋ฉด ํ์ฌ ์์น์ map์ ์ ์ฅ๋์ด ์๋ ์ธ๋ฑ์ค์ ์ฐจ์ด๋ฅผ ๊ตฌํด์ ๋น๊ตํด๋ณธ๋ค. ๋ง์ฝ, ์ธ๋ฑ์ค๊ฐ ์ฐจ์ด๊ฐ k๋ณด๋ค ํฌ๋ค๋ฉด map์ ๊ฐฑ์ ํด์ค๋ค. ์๋ํ๋ฉด ์ดํ์ ์ธ๋ฑ์ค ์ฐจ์ด๊ฐ k ์ดํ์ธ ๊ฒฝ์ฐ๊ฐ ์๊ธธ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. import java.util.*; class Solution { public boolean containsNearbyDuplicate(int[] nums, int k) { HashMap map = new HashMa..
[Java] 1. Two Sum
๋ฌธ์ ํ์ ์ ์ ๋ฐฐ์ด nums ๊ฐ ์ฃผ์ด์ง๋ค. ๋ฐฐ์ด์ ๋ ์์๋ฅผ ๋ํ์ ๋, target์ด ๋๋ ๊ฐ์ ์ธ๋ฑ์ค๋ฅผ ๋ฐํํด์ผํ๋ค. ๋ต์ ์ ํํ 1๊ฐ ์กด์ฌํ๋ค. ํ์ด 1๏ธโฃ HashMap ์ ์ด์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea ๊ฐ ๊ฐ์ key ๋ก, ์ธ๋ฑ์ค ๊ฐ์ value ๋ก ์ ์ฅํ๋ map์ ์ ์ํ๋ค. nums ๋ฐฐ์ด์ ์ํํ๋ฉด์ target-nums[i] ๊ฐ map ์ ์กด์ฌํ๋์ง ํ์ธํ๊ณ , ์กด์ฌํ๋ค๋ฉด ๋ต์ผ๋ก ๋ฐํํ๋ค. import java.util.*; class Solution { public int[] twoSum(int[] nums, int target) { HashMap map = new HashMap(); for(int i=0;i a[0] - b[0]); int left = 0, right = nodes.l..
[Java] 150. Evaluate Reverse Polish Notation
๋ฌธ์ ํ์ ์ญ ํด๋๋ ํ๊ธฐ๋ฒ์ ๋ฐ๋ฅธ ์ฐ์ฐ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํด์ผํ๋ค. ์ฐ์ฐ์๋ฅผ ๋ง๋๋ฉด ์ด์ ์ ๋ง๋ฌ๋ ์ซ์ 2๊ฐ๋ฅผ ์ฐ์ฐํ๋ ๋ฐฉ์์ด๋ค. ์๋ก, 4 13 5 / + ์ ๊ฒฝ์ฐ / ์ฐ์ฐ์๋ฅผ ๋ง๋๊ธฐ ์ง์ 13 ๊ณผ 5๊ฐ ์์ผ๋ฏ๋ก 13 / 5 ๋ฅผํด์ฃผ๊ณ ๋์จ ๊ฒฐ๊ณผ๋ฅผ ๋ค์ ๋ฃ์ด์ฃผ๋ฉด 4 2 + ๊ฐ ๋๋ค. ๊ทธ๋ฆฌ๊ณ + ์ฐ์ฐ์๋ฅผ ๋ง๋๊ธฐ ์ง์ 4์ 2๊ฐ ์์ผ๋ฏ๋ก 4 + 2 ๋ฅผ ํ ๊ฐ์ธ 6์ ๋ฐํํ๋ฉด ๋๋ค. ํ์ด 1๏ธโฃ ์คํ์ ์ด์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea ์ญ ํด๋๋ ํ๊ธฐ๋ฒ์ ์ฐ์ฐ ๋ฐฉ์ ์, ์คํ์ ์ด์ฉํด์ ํ์ด์ผ๊ฒ ๋ค๋ ์๊ฐ์ด ๋ฐ๋ก ๋ค์๋ค. ์ฐ์ฐ์๋ฅผ ๋ง๋๋ฉด, ๊ฐ์ฅ ๊ทผ์ฒ์ ์๋ ์๋ฅผ ๋ค๋ก ๋๊ณ ์ฐ์ฐํ ๋ค์, ๋ค์ ์คํ์ ๋ฃ๋ ๋ฐฉ์์ผ๋ก ์งํํ๋ฉด ๋ ๊ฒ์ด๋ค. import java.util.*; class Solution { Stack stac..
[Java] 155. Min Stack
๋ฌธ์ ํ์ O(1) ์๊ฐ ๋ณต์ก๋๋ก ํด๋น ๋ฉ์๋ ๋ค์ ๋์ํ ์ ์๋๋ก ๊ตฌํํด์ผํ๋ค. ํ์ด 1๏ธโฃ Stack ํด๋์ค ์ด์ฉ ์ ๋ฌธ์ ์์, ๊ฐ์ฅ ์ค์ํ ๋ฉ์๋๋ getMin() ๋ฉ์๋์ด๋ค. ๋ค๋ฅธ, push(), pop(), top() ๋ฉ์๋๋ ๊ธฐ์กด Stack ํด๋์ค์์๋ O(1) ์ ์ํํ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. ๋ฐ๋ผ์, ์คํ์ ์์๋ฅผ ์ฝ์ ํ ๋, ์ต์๊ฐ์ ์ ์ฅํ๊ณ getMin() ๋ฉ์๋๋ฅผ ํธ์ถํ ๋ ๋ฐ๋ก ๋ฐํํ ์ ์๋๋ก ํด์ผ O(1)์ ๋ง์กฑํ ์ ์์ ๊ฒ์ด๋ค. ์ต์๊ฐ์ ์ ์ฅํ๋ ์คํ์ ๋ฐ๋ก ์ถ๊ฐํด์, ๊ฐ์ push ํ ๋๋ง๋ค ํด๋น ์์น์ ์คํ ๊ฐ๊น์ง์ ์ต์๊ฐ์ ๊ธฐ๋กํ๋๋ก ๊ตฌํํ์๋ค. import java.util.*; class MinStack { Stack stack; Stack stackForMin; pub..
[JAVA] ๋ฐฑ์ค 13414๋ฒ ใS3.์๊ฐ์ ์ฒญใ
๋ฌธ์ 13414๋ฒ: ์๊ฐ์ ์ฒญ ์ ๋ ฅ ๋ฐ์ดํฐ๋ ํ์ค ์ ๋ ฅ์ ์ฌ์ฉํ๋ค. ์ ๋ ฅ์ 1๊ฐ์ ํ ์คํธ ๋ฐ์ดํฐ๋ก ๊ตฌ์ฑ๋๋ค. ์ ๋ ฅ์ ์ฒซ ๋ฒ์งธ ์ค์๋ ๊ณผ๋ชฉ์ ์๊ฐ ๊ฐ๋ฅ ์ธ์ K(1 ≤ K ≤ 100,000)์ ํ์๋ค์ด ๋ฒํผ์ ํด๋ฆญํ ์์๋ฅผ ๊ธฐ๋กํ ๋๊ธฐ๋ชฉ www.acmicpc.net ํ์ด ๋จผ์ ์ด ๋ฌธ์ ๋, ์๊ฐ ์ ์ฒญ์ ํ ํ์๋ค์ ์์๋๋ก ์๋ฃ๊ตฌ์กฐ์ ๋ฃ์ด์ผ ํ๋๋ฐ, ์ด๋ฏธ ๊ทธ ์๋ฃ๊ตฌ์กฐ์ ๋ค์ด๊ฐ ์๋ ํ์์ธ ๊ฒฝ์ฐ, ์ ์ผ ๋ท ์์๋ก ๋ค์ ์ง์ด๋ฃ์ด์ผ ํ๋ค. ์ด ์์ด๋์ด๋, ์ด ๋ฌธ์ ๋ฅผ ํธ๋ ๋๊ตฌ๋ ๋ ์ฌ๋ ธ์ํ ๋ฐ ์๊ฐ๋ณด๋ค ๊ฐ๋จํ๊ฒ ํ๋ฆด ์ค ์์๋๋ฐ ์๋์๋ค. 1๏ธโฃ map๊ณผ priority queue ์ฌ์ฉ set์ ์ด์ฉํด์ ์ค๋ณต์ฌ๋ถ๋ฅผ ํ์ธํ ์ ์์ง๋ง, ์๊ฐ ์ ์ฒญ ์์๋ฅผ ํ์ธํ ์ ์๋ค. HashMap map = new HashMap()..
[JAVA] ๋ฐฑ์ค 20366๋ฒ ใG3.๊ฐ์ด ๋์ฌ๋ ๋ง๋ค๋?ใ
๋ฌธ์ 20366๋ฒ: ๊ฐ์ด ๋์ฌ๋ ๋ง๋ค๋? ๋์ด๊ฐ (2, 5), (3, 5)๋ก ๊ตฌ์ฑ๋ ๋์ฌ๋ ๋์ ๋ง๋๋ ๊ฒ์ด ์ต์ ์ ๊ฒฝ์ฐ ์ค ํ๋์ด๋ค. |7-8| = 1 ๋ค๋ฅธ ๊ฒฝ์ฐ๋ก๋ (2, 9), (5, 5)๋ก ๋ ๋์ฌ๋์ ๋ง๋๋ ๊ฒฝ์ฐ๊ฐ ์๋ค. |11-10| = 1 www.acmicpc.net ํ์ด 1๏ธโฃ ์กฐํฉ์ ์ด์ฉํ ํ์ด ์ฃผ์ด์ง ๋๋ฉ์ด ์ค 2๊ฐ๋ก ๋ง๋ค ์ ์๋ ๋์ฌ๋์ ๋์ด๋ฅผ ๋ชจ๋ ๊ตฌํ๋ค. ๋จ, ๋ ์ฌ๋์ด ๊ฐ์ ๋๋ฉ์ด๋ฅผ ์ฌ์ฉํ ์ ์๋ค. ์๋ก ๋ค๋ฅธ ๋๋ฉ์ด 4๊ฐ๊ฐ ์ฌ์ฉ๋์ด์ผ ํ๋ค. ๋ฐ๋ผ์, ๊ทธ๋ฅ ํฉ์ ์กฐํฉ๋ง ๊ตฌํ๋ฉด ์ด๋ฌํ ๋ถ๋ถ์ ์ฒดํฌํ ์ ์๊ธฐ ๋๋ฌธ์ ์ด๋ค ์ธ๋ฑ์ค์ ๋๋ฉ์ด๋ก ๋์ฌ๋์ ๋ง๋ ๊ฑด์ง ์ ๋ณด๊ฐ ํ์ํ๋ค. ๋ฐ๋ผ์, ํด๋์ค๋ฅผ ์๋กญ๊ฒ ํ๋ ์ ์ํด์ผํ๋ค. static class SnowMan{ int idx1; int..
[Java] 74. Search a 2D Matrix
๋ฌธ์ ํ์ m x n ํ๋ ฌ์ด ์ฃผ์ด์ง๋ค. ๊ฐ ํ์ ๋น๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌ๋์ด์๋ค. ๊ฐ ํ์ ์ฒซ ์์๋ ์ด์ ํ์ ๋ง์ง๋ง ์์๋ณด๋ค ํฌ๋ค. target์ด ํ๋ ฌ์ ์กด์ฌํ๋์ง ์ฐพ์์ผํ๋ค. ์๊ฐ ๋ณต์ก๋๋ O(log(m*n)) ์ผ๋ก ์ํํด์ผํ๋ค. ํ์ด 1๏ธโฃ ์ด๋ถ ํ์ ๐ก ๋ ์ค๋ฅธ Idea ํ๋ ฌ ๋ด์ ์์๊ฐ ์กด์ฌํ๋์ง๋ง ํ๋จํ๋ฉด ๋๊ธฐ ๋๋ฌธ์, 2์ฐจ์ ํ๋ ฌ์ 1์ฐจ์์ผ๋ก ๋ณํ์ํจ ํ ์ด๋ถํ์์ ์งํํ๋ฉด ์๊ฐ๋ณต์ก๋ O(log(m*n)) ๋ ๋ง์กฑํ๋ฉด์, ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์์ ๊ฒ์ด๋ผ ์๊ฐ์ด ๋ค์๋ค. ๋ํ, ๊ฐ ํ ๋ด ์์์ ํ๋ค ๋ผ๋ฆฌ ์ ๋ ฌ๋์ด ์์ด์ ํธํ๊ฒ ์ด๋ถํ์์ ์ฌ์ฉํ ์ ์์ ๊ฒ์ด๋ผ๊ณ ํ๋จํ์๋ค. ์ ์์ด๋์ด๋ฅผ ๋ฐํ์ผ๋ก, ํน์ ์์๋ฅผ ์ฐพ์๋ด๋ ์ด๋ถํ์ ์ฝ๋๋ฅผ ๊ตฌํํ์๋ค. class Solution { public bool..
[Java] 35. Search Insert Position
๋ฌธ์ ํ์ ์ค๋ณต๋์ง ์๋, ์ ๋ ฌ๋ ์ ์ ๋ฐฐ์ด์ด ์ฃผ์ด์ง๋ค. target ์ ํด๋นํ๋ ์์์ ์์น๋, ์๋ค๋ฉด ์ฝ์ ํ์๋ ์ ๋ ฌ์ ์ ์งํ ์ ์๋ ์ธ๋ฑ์ค์ ์์น๋ฅผ ๋ฐํํด์ผํ๋ค. ๊ทธ๋ฆฌ๊ณ ์๊ฐ ๋ณต์ก๋๋ O(logN) ์ด์ด์ผ ํ๋ค. ํ์ด 1๏ธโฃ ์ด๋ถ ํ์ ๐ก ๋ ์ค๋ฅธ Idea ์๊ฐ ๋ณต์ก๋๋ฅผ O(logN) ์ผ๋ก ํด์ผํ๋ค๋ ๋ง์ ๋ณด์๋ง์, ์ด๋ถํ์์ผ๋ก ํด๊ฒฐํด์ผ๊ฒ ๊ตฌ๋ ์๊ฐ์ด ๋ค์๋ค. ์ด๋ถํ์์ ๊ตฌํํด์, target ์ด ๋ค์ด๊ฐ ์ ์๋ ์ ์ ํ ์์น๋ฅผ ์ฐพ์ผ๋ฉด ๋๋ค. nums๊ฐ ์ ๋ ฌ๋์ด์๊ธฐ ๋๋ฌธ์ target์ด nums์ ์ด๋ ํ ์์๋ณด๋ค ์๊ฑฐ๋ ํฐ ๊ฒฝ์ฐ๋ ์์ ์์ ์ฒ๋ฆฌํด์ฃผ์๋ค. ์ด๋ถํ์์์๋, ์ ๋ ฌ์ ์ ์งํ๋ฉด์ target ๊ฐ ์ดํ๋ฅผ ๋ฐฐ์ด์ ์ ๋ ฅํ ์ ์๋ ์ธ๋ฑ์ค๋ฅผ ๋ฐํํ๋๋ก ๊ตฌ์ฑํ์๋ค. class Solution { publ..
[Java] 21. Merge Two Sorted Lists
๋ฌธ์ ํ์ ์ ๋ ฌ๋ ๋ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ์ฒซ๋ฒ์งธ ๋ ธ๋๋ฅผ ์ ๋ ฅ๋ฐ๋๋ค. ๋ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ฅผ ํ๋์ ์ ๋ ฌ๋ ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ก ๋ง๋ค์ด์ผํ๋ค. ๋ฐ๋์ ์ ๋ ฅ๋ฐ์ ๋ ธ๋๋ก ๊ตฌ์ฑํด์ผํ๋ค. ํ์ด 1๏ธโฃ ๐ก ๋ ์ค๋ฅธ Idea ๊ฐ ๋ฆฌ์คํธ์ ๊ฐ์ ๋น๊ตํ๊ณ , ์์ ๊ฐ์ ํฌํจํ๋ ๋ ธ๋๋ฅผ ์ถ๊ฐํ๋ ์์ผ๋ก ํฉ์น๋ฉด ๋๋ค. ๋จ, ๋น๊ตํ ๋ ธ๋๊ฐ ์์ด์ง ๊ฒฝ์ฐ ๋จ์์๋ ๋ ธ๋๋ฅผ ์์ฐจ์ ์ผ๋ก ์ถ๊ฐํด์ฃผ๋ฉด ๋๋ค. class Solution { public ListNode mergeTwoLists(ListNode list1, ListNode list2) { ListNode head = new ListNode(); ListNode ans = head; ListNode result; while (list1 != null || list2 != null) { if (list..