๐จ๐ป๐ป PS/LeetCode 150
[Java] 55. Jump Game
๋ฌธ์ ํ์ ์ ์ ๋ฐฐ์ด nums ๊ฐ ์ฃผ์ด์ง๊ณ , ์ฒซ๋ฒ์งธ ์ธ๋ฑ์ค์์ ์์ํ๋ค. ์ธ๋ฑ์ค์ ์ฃผ์ด์ง ๊ฐ์ ์ต๋๋ก ์ ํํ ์ ์๋ ๊ฐ์ด๋ค. ๋ง์ง๋ง ์ธ๋ฑ์ค์ ๋๋ฌํ ์ ์์ผ๋ฉด true ๋ฅผ ์์ผ๋ฉด false๋ฅผ ๋ฐํํด์ผํ๋ค. ํ์ด 1๏ธโฃ ๋ด๊ฐ ๋ ์ฌ๋ฆฐ ์์ด๋์ด๋ ๋ค์๊ณผ ๊ฐ๋ค. ํ์ฌ ์์น์์ ๊ฐ์ฅ ๋ฉ๋ฆฌ ๋ธ ์ ์๋ ์ธ๋ฑ์ค๋ฅผ ํ์ธํ๋ค. ๋ง์ฝ ๊ฐ์ฅ ๋ฉ๋ฆฌ ๋ธ ์ ์๋ ์์น๊ฐ ๋ฐฐ์ด์ ๋ง์ง๋ง ์ธ๋ฑ์ค ( nums.length - 1 ) ์ด์์ด๋ผ๋ฉด true ๋ฅผ ๋ฐํํ๋ค. ํ์ฌ ์์น์์ ๊ฐ์ฅ ๋ฉ๋ฆฌ ๋ธ ์ ์๋ ์ธ๋ฑ์ค ๊น์ง ์ํํ๋ฉด์, ๋ค์์ผ๋ก ๊ฐ์ฅ ๋ฉ๋ฆฌ ๊ฐ ์ ์๋ ์ธ๋ฑ์ค๋ฅผ ์ฐพ๊ณ ์ด๋ํ๋ค. [2, 3, 1, 1, 4] ๋ฅผ ์์๋ก ๋ค์๋ฉด, ํ์ฌ ์์น 0์ธ 2์์ ๊ฐ ์ ์๋ ์ธ๋ฑ์ค๋ 1๊ณผ 2์ด๊ณ ์ธ๋ฑ์ค 1์ (1 + 3) = 4๋ฒ ์ธ๋ฑ์ค ๊น..
[Java] 122. Best Time to Buy and Sell Stock 2
๋ฌธ์ ํ์ i๋ ์ฃผ์ ๊ฐ๊ฒฉ์ prices[i] ๊ณผ ๊ฐ์ด ๋ฐฐ์ด ํํ๋ก ์ฃผ์ด์ง๋ค. ๋งค์ผ ์ฃผ์์ ์ด์ง ํ์ง ๊ฒฐ์ ํด์ผํ๋ค. ๊ฒฐ๊ณผ์ ์ผ๋ก ์ป์ด์ง๋ ์ต๋ ์์ต์ ๋ฐํํด์ผํ๋ค. ํ์ด 1๏ธโฃ ๋ด๋ฆผ ์ฐจ์์ผ๋ก ๋ฐ๋๋ ์๊ฐ ์์ต ๊ณ์ฐ ํ์ด๊ฐ ์ ๋ ์ค๋ฅด์ง ์์์ ๋ช ๊ฐ์ง ์์๋ฅผ ๋ค์ด๋ดค๋ค. Case 1. 1, 6, 7, 100 ์ ๊ฒฝ์ฐ๋ 1์ ์ฌ์ 6์ ํ๊ณ 7์ ์ฌ์ 100์ ํ๋ฉด, 1์ ์ฌ์ 100์ ํ๋๊ฒ๋ณด๋ค ์ํด์ด๋ค. 6~7 ์ ๊ณต๋ฐฑ์ด ์๊ธฐ๊ธฐ ๋๋ฌธ์ด๋ค. Case 2. 1, 6, 5, 100 ์ ๊ฒฝ์ฐ๋ 1์ ์ฌ์ 6์ ํ๊ณ , 5์ ์ฌ์ 100์ ํ๋ฉด, 1์ ์ฌ์ 100์ ํ๋ ๊ฒ๋ณด๋ค ์ด๋์ด๋ค. 5~6 ๊ต์งํฉ ๋ถ๋ถ์ด ์๊ฒจ ์ถ๊ฐ์ ์ธ ์ด๋์ด ๋ ์ ์๋ค. Case 3. 1, 6, 6, 100 ์ ๊ฒฝ์ฐ๋ 1์ ์ฌ์ 6์ ํ๊ณ 6์..
[Java] 121. Best Time to Buy and Sell Stock
๋ฌธ์ ํ์ i๋ ์ฃผ์ ๊ฐ๊ฒฉ์ prices[i] ๊ณผ ๊ฐ์ด ๋ฐฐ์ด ํํ๋ก ์ฃผ์ด์ง๋ค. ์ต๋๋ก ์์ต์ ๋ฐํํด์ผํ๋ค. ๋ง์ฝ, ์ด๋ ํ ์์ต๋ ์ป์ง ๋ชปํ๋ค๋ฉด 0 ์ ๋ฐํํ๋ค. ํ์ด 1๏ธโฃ ์ด์ค for๋ฌธ ํ์ด - ์๊ฐ ์ด๊ณผ ๊ฐ์ฅ ๋จผ์ ๋ ์ค๋ฅธ ํ์ด๋, ํ๋ ๋ ์ ๊ณ ์ ํ๊ณ ํ๋ ๋ ์ด์ ์ ๊ฐ๊ฒฉ๋ค์ ์ํํ๋ฉด์ ์ต๋๊ฐ์ ๊ตฌํด์ผ๊ฒ ๋ค๊ณ ์๊ฐํ๋ค. class Solution { public int maxProfit(int[] prices) { int ans = 0; for (int i = 1; i < prices.length; i++) { int sell = prices[i]; for (int j = 0; j < i; j++) { int buy = prices[j]; int profit = sell - buy; if (profit ..
[Java] 189. Rotate Array
๋ฌธ์ ํ์ ์ ์ ๋ฐฐ์ด nums ๊ฐ ์ฃผ์ด์ง๋ค. ์์๊ฐ ์๋ k ๋งํผ ์ค๋ฅธ์ชฝ์ผ๋ก ๋ฐฐ์ด์ ํ์ ์์ผ์ผ ํ๋ค. ํ์ด 1๏ธโฃ ๋ฐฐ์ด 2๊ฐ๋ฅผ ์ด์ฉํ ํ์ด ๋จผ์ , ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง k๋ฅผ ํ๋ฒ ์ ์ฒ๋ฆฌ ํด์ผํ๋ค. ์๋ํ๋ฉด, ๊ธธ์ด๊ฐ N์ธ ๋ฐฐ์ด nums๋ฅผ N๋ฒ rotate ํ๋ฉด ์์ํ๋ก ๋์์ค๊ธฐ ๋๋ฌธ์ k๋ฅผ N์ผ๋ก ๋๋ ๋๋จธ์ง๋งํผ๋ง rotate ํ๋ค๊ณ ๋ณผ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. ๊ทธ๋ฌ๋ฉด, ์ด๋์ํฌ ์์์ ๊ฐ์๋ k%N ๊ฐ๊ฐ ๋๋ค. ์ด๋ ์ํฌ ๋ถ๋ถ์ tmp๋ผ๋ ๋ฐฐ์ด์ ์ ์ํด์ ๋ด์ฉ์ ๋ณต์ฌํด๋๋ค. ๊ทธ๋ฆฌ๊ณ ๋ค์์๋ถํฐ ์ด๋์ํจ๋ค. ๊ทธ๋ฆฌ๊ณ ๋ณด๊ดํด๋์๋ ๋ด์ฉ์ ์์ ๋ถ์ฌ์ฃผ๋ฉด ๋๋ค. class Solution { public void rotate(int[] nums, int k) { int N = nums.length; k = k % N; int..
[Java] 169. Majority Element
๋ฌธ์ ํ์ ํฌ๊ธฐ๊ฐ n์ธ ๋ฐฐ์ด nums ๊ฐ ์ฃผ์ด์ง๋ค. n/2 ๋ณด๋ค ๋ง์ด ๋ฑ์ฅํ๋ ์๋ฅผ ๋ฐํํด์ผํ๋ค. ํ์ด 1๏ธโฃ ํด์ ํ์ฉ ๋ฐ๋ก ๊ฐ๋จํ๊ฒ ๋ ์ค๋ฅธ ํ์ด์ด๋ค. ๋จผ์ , ๋ฐฐ์ด์ ์ํํ๋ฉด์ ์์๋ฅผ key ๊ฐ์ผ๋ก ์์๊ฐ ๋ํ๋ ํ์๋ฅผ value ๊ฐ์ผ๋ก map์ ๊ธฐ๋กํ ๋ค, map์ ํ๋ฒ ๋ ์ํํ๋ฉด์, ๋ํ๋ ํ์๊ฐ n/2 ๋ณด๋ค ํฐ ๊ฒฝ์ฐ ๋ฐํํ๋ ๋ฐฉ์์ด๋ค. import java.util.*; class Solution { public int majorityElement(int[] nums) { int n = nums.length; int result = nums[0]; HashMap map = new HashMap(); for (int num : nums) { map.put(num, map.getOrDefault(n..
[Java] 80. Remove Duplicates from Sorted Array II
๋ฌธ์ ํ์ nums ๋ ๋น๋ด๋ฆผ์ฐจ์ ์ ์ ๋ฐฐ์ด์ด๋ฉฐ, ์ต๋ 2๊ฐ๊น์ง ์ค๋ณต๋ ์ ์๋๋ก ๋๋จธ์ง ์ค๋ณต์ ์ ๊ฑฐํด์ผํ๋ค. ๊ทธ๋ฆฌ๊ณ , ์๋์ ์ธ ์์น๋ฅผ ์ ์งํด์ผํ๋ค. ์ฃผ์ด์ง ์กฐ๊ฑด์ ๋ง๊ฒ ์ค๋ณต์ ์ ๊ฑฐํ ์์์ ๊ฐ์ k๋ฅผ ๋ฐํํด์ผํ๋ค. nums ๋ฐฐ์ด ์ธ ๋ค๋ฅธ ๋ฐฐ์ด์ ์ฌ์ฉํ๋ฉด ์๋๋ค. ํ์ด 1๏ธโฃ ํฌ์ธํฐ ๋ฐฉ์ nums ๋ฐฐ์ด๋ง ์ฌ์ฉํด์ผํ๊ธฐ ๋๋ฌธ์, nums ๋ฐฐ์ด์ ์์๋ค์ ๊ฐฑ์ ํด๋๊ฐ๋ฉฐ ์ค๋ณต์ ์ต๋ 2๊ฐ๊น์ง ํ์ฉํ๋ฉด์ ์ค๋ณต์ ์ ๊ฑฐํด์ผ๊ฒ ๋ค๊ณ ์๊ฐํ๋ค. ๋จผ์ , ๊ฐฑ์ ํ ์ ์๋ ์กฐ๊ฑด์ด ๋ญ์ง ์๊ฐํด๋ดค๋ค. ์์๊ฐ ๋ฌ๋ผ์ง๋ ์๊ฐ ๊ฐฑ์ ํ๊ณ ํฌ์ธํฐ๋ฅผ ์ด๋ ์์๊ฐ ๊ฐ์ ๊ฒฝ์ฐ ์ค๋ณต๋ ์์๊ฐ 2๊ฐ๊น์ง๋ ํ์ฉ๋๋ฏ๋ก, 2๊ฐ๊น์ง๋ ๊ฐฑ์ ํ๊ณ ํฌ์ธํฐ๋ฅผ ์ด๋ ๋จ, 3๊ฐ๋ถํฐ๋ ๊ฐฑ์ ํ์ง ์๊ณ ์์๊ฐ ๋ฌ๋ผ์ง๋ ์๊ฐ๊น์ง ํฌ์ธํฐ๋ฅผ ์์ง์ผ ์ ์์ ์ ์กฐ๊ฑด์ ๋จผ์ ์๊ฐ..
[Java] 26. Remove Duplicates from Sorted Array
๋ฌธ์ ํ์ nums๋ ๋น๋ด๋ฆผ์ฐจ์ ๋ฐฐ์ด์ด๋ค. ์ค๋ณต๋๋ ์์๋ค์ 1๊ฐ์ ์์๋ค๋ก ๋ฐ๊พธ๊ณ , ์๋์ ์ธ ์์น๋ ์ ์งํด์ผํ๋ค. ์ฆ, [1, 1, 2, 2, 3] ์ธ ๊ฒฝ์ฐ, [1, 2, 3, _, _ ] ์ผ๋ก ๋ง๋ค์ด์ผ ํ๋ค๋ ๊ฒ์ด๋ค. ๊ทธ๋ฆฌ๊ณ , ์ค๋ณต์ ์ ๊ฑฐํ ์์ ๊ฐ์ k๋ฅผ ๋ฐํํด์ผํ๋ค. ํ์ด 1๏ธโฃ ํฌ์ธํฐ ๋ฐฉ์ ๋จผ์ , unique ํ ์์๋ฅผ ๊ฐฑ์ ํ๊ธฐ ์ํ ํฌ์ธํฐ๊ฐ ํ์ํ๋ค๋ ์๊ฐ์ ํ๋ค. ๊ทธ๋ฆฌ๊ณ , ๋ฐฐ์ด nums ๋ฅผ ์ํํ๋ฉด์ ๊ฐ์ด ๋ฌ๋ผ์ง๋ ์ธ๋ฑ์ค๋ฅผ ๋จผ์ ์ถ์ถํด๋ด์ผ๊ฒ ๋ค๊ณ ์๊ฐํ๋ค. for(int i=1; i
[Java] 27. Remove Element
๋ฌธ์ ํ์ ์ ์ ๋ฐฐ์ด nums์ val์ด ์ฃผ์ด์ง๋ค. ๋ฐฐ์ด nums ์์ val๊ณผ ์ผ์นํ๋ ์์๋ฅผ ๋ชจ๋ ์ ๊ฑฐํด์ผํ๋ค. ๊ทธ๋ฆฌ๊ณ nums ๋ฐฐ์ด์์ val๊ณผ ์ผ์นํ์ง ์๋ ์์์ ๊ฐ์๋ฅผ ๋ฐํํด์ผํ๋ค. ์ผ์นํ์ง ์๋ ์์์ ๊ฐ์๊ฐ k ์ผ ๋, nums์ k๋ฒ ์ธ๋ฑ์ค ๊น์ง๋ val๊ณผ ์ผ์นํ์ง ์๋ ์์๋ค๋ก ์ฑ์๋ฃ์ด์ผ ํ๋ค. ํ์ด 1๏ธโฃ Arrays.sort() ์ฌ์ฉ ๋จผ์ , ๋ฌธ์ ์กฐ๊ฑด์ ๋ณด๋ nums ๋ฐฐ์ด์ ์์ ์ต๋๊ฐ์ 50์์ ์ ์ ์์๋ค. ๋ฐ๋ผ์, nums ๋ฐฐ์ด์์ val๊ณผ ์ผ์นํ๋ ์์๋ฅผ 51๋ก ๋ชจ๋ ๋ณํํด๋๊ณ ์ ๋ ฌ์ ์ํํ๋ฉด, ๋ฐฐ์ด์ ๋ท๋ถ๋ถ์ผ๋ก ๋ฐ๋ ค๋ ์์ ๊ฒ์ผ๋ก ์์ํ๋ค. import java.util.*; class Solution { public int removeElement(int[] nums, ..
[Java] 88. Merge Sorted Array
๋ฌธ์ ํ์ ๋ ์ ์ ๋ฐฐ์ด nums1 ๊ณผ nums2 ๋ ๋น๋ด๋ฆผ์ฐจ์(non-decreasing) ๋ฐฐ์ด์ด๋ค. ๋น๋ด๋ฆผ์ฐจ์ : ๊ฐ์ ํฌ๊ธฐ์ ์์๊ฐ ์กด์ฌํ ์ ์๋ ๊ฒ ex) 1 2 3 ex) 1 1 2 nums1 ๋ฐฐ์ด์ ๊ธธ์ด๋ m+n ์ผ๋ก, ์ฒซ m๋ฒ์งธ๊น์ง์ ์์๋ merged ๋์ด์ผ ํ๊ณ ๋๋จธ์ง n๊ฐ๋ 0์ผ๋ก ์ค์ ๋์ด ์๋ค. ๊ทธ๋ฆฌ๊ณ ๊ทธ n๊ฐ์ 0 ์ nums2์ ์์๋ค์ด ๋ค์ด๊ฐ์ผํ๊ณ ์ต์ข ๊ฒฐ๊ณผ๋ ๋น๋ด๋ฆผ์ฐจ์์ผ๋ก ๋ฐํํ๋ฉด ๋๋ค. ํ์ด 1๏ธโฃ Array.sort() ๊ฐ์ฅ ๊ฐ๋จํ๊ฒ ๋ ์ค๋ฅธ ํ์ด์ด๋ค. ๋จผ์ nums1 ๋ฐฐ์ด์ 0 ๋ถ๋ถ์ nums2 ๋ฐฐ์ด์ ์์๋ฅผ ์ ๋ ฅํ ํ, Arrays.sort() ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด๋ค. ์ ๋ ฅํ๋ ๋ฐฉ๋ฒ์ ๊ฐ๋จํ๋ค. nums1์ m+1 ๋ฒ์งธ ๋ถํฐ m+n๋ฒ์งธ ๊น์ง 0์ผ๋ก ์ ๋ ฅ๋์ด ์์ผ๋ฏ๋ก for(..