๋ฌธ์ ํ์

์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋์ด ์๋ ๋ฐฐ์ด nums
๊ฐ ์์๋ค.
์ธ๋ฑ์ค k
๋ฒ์งธ ์์๊ฐ ์ ์ผ ์ฒซ ์์๊ฐ ๋๋๋ก rotated
๋์ด์๋ค.
target
์ด ๋ฐฐ์ด nums
์ ํฌํจ๋์ด์๋์ง O(logN) ์ผ๋ก ํ์ํ์ฌ ์ธ๋ฑ์ค๋ฅผ ๋ฐํํด์ผํ๋ค.
ํ์ด
1๏ธโฃ ์ด๋ถ ํ์์ ์ด์ฉํ ํ์ด
๐ก ๋ ์ค๋ฅธ Idea
๋จผ์ , ์ฃผ์ด์ง ์๊ฐ ๋ณต์ก๋๋ฅผ ๋ง์กฑํ๊ธฐ ์ํด์ ์ด๋ถ ํ์์ ์ฌ์ฉํด์ผํจ์ ์ ์ ์์๋ค.
๊ฒฐ๊ณผ์ ์ผ๋ก๋,target
์ดnums
์ ์กด์ฌํ๋์ง๋ฅผ ์ด๋ถ ํ์ํด์ผํ๋๋ฐ
ํน์ ๊ฐ์ ํ์ํ๊ธฐ ์ํด์ ์ ๋ ฌ๋์ด์์ด์ผ ํ๋ค.
๋ฐ๋ผ์, rotated๋ ๋ฐฐ์ด์ ์ ๋ ฌ๋ ๋๊ฐ์ ๋ฐฐ์ด๋ก ๋๋๊ธฐ ์ํด ๋ฐฐ์ด ๋ด์ ์ต์๊ฐ์ ๊ฒ์ํ๋ค.
ex)[4, 5, 6, 7, 0, 1, 2]
๋ฐฐ์ด์ด ์์ ๋,[4, 5, 6, 7]
๊ณผ[0, 1, 2]
๋ฐฐ์ด2
๊ฐ๋ก ๋ถ๋ฆฌํ๋ค. ์ต์๊ฐ์ธ0
์ ์์น๋ฅผ ์ฐพ์์ผ ๋ถ๋ฆฌํ ์ ์์ ๊ฒ์ด๋ค.
์ต์๊ฐ์ mid์ ์์นํ ์์๊ฐ ๊ฐ์ฅ ๋๊ฐ๊ณผ ๋น๊ตํ์ ๋, ์ค๋ฆ์ฐจ์์ ์ ์งํ๊ณ ์๋ค๋ฉด ํ์์ ์ผ์ชฝ ์์ญ์ผ๋ก ์ด๋์ํค๋ ๋ฐฉ๋ฒ์ผ๋ก ๊ตฌํ ์ ์๋ค. ๊ทธ ๋ฐ๋๋ผ๋ฉด ์ค๋ฅธ์ชฝ ์์ญ์ผ๋ก ํ์ํด์ผํ ๊ฒ์ด๋ค.
์ ๋ ฌ๋ ๋ฐฐ์ด 2๊ฐ๋ก ๋ถ๋ฆฌํ๋ค๋ฉด, ์ด๋ถํ์์ผ๋กtarget
์ด ์กด์ฌํ๋์ง ํ์ธํ๋ฉด ์๋ฃ๋๋ค.
class Solution {
public int search(int[] nums, int target) {
int idx = getStartIdx(nums);
int result1 = findIdx(nums,0,idx-1,target);
int result2 = findIdx(nums,idx,nums.length-1,target);
return Math.max(result1,result2);
}
private int getStartIdx(int[] nums){
int left = 0,right = nums.length-1;
if(nums[left]<=nums[right]){
return 0;
}
while(left<right){
int mid = (left+right)/2;
if(nums[mid]<=nums[right]){
right = mid;
}else{
left = mid+1;
}
}
return left;
}
private int findIdx(int[] nums, int left, int right,int target){
while(left<=right){
int mid = (left + right)/2;
if(target<nums[mid]){
right = mid-1;
}else if(target>nums[mid]){
left = mid+1;
}else{
return mid;
}
}
return -1;
}
}
๊ฒฐ๊ณผ

๐ ํ๊ณ
์ ๋ ฌ๋์ด ์์ง ์์ ๋ฐฐ์ด์์ ์ด๋ถํ์์ ์ฌ์ฉํ๊ธฐ ์ํ ์กฐ๊ฑด์ ๋ ์ฌ๋ฆฌ๋๊ฒ ๊ต์ฅํ ๊น๋ค๋ก์ด ๊ฒ ๊ฐ๋ค.
๊ทผ๋ฐ, ์ ์๊ฐํด๋ณด๋ฉด ์ถฉ๋ถํ ๋ ์ฌ๋ฆด ์ ์๋ ์์ด๋์ด๋ค์ด๋ค.
find peak element ๋ฌธ์ ์์๋ mid
๊ฐ์ด mid+1
๋ณด๋ค ์์ผ๋ฉด ์ค๋ฅธ์ชฝ ์์ญ์ ํ์ํ๋ ๋ฐฉ์์ผ๋ก ์งํํ์๊ณ
์ด๋ฒ ๋ฌธ์ ์ ๊ฒฝ์ฐ์๋ mid
๊ฐ์ด right
๊ฐ๋ณด๋ค ์์ ๊ฒฝ์ฐ, ์ค๋ฅธ์ชฝ ์์ญ์ ์ค๋ฆ์ฐจ์์ผ๋ก ๊ตฌ์ฑ๋์ด์์์ ๋ณด์ฅํ๋ฏ๋ก ์ผ์ชฝ ์์ญ์ผ๋ก ํ์ํ๋ ๋ฐฉ์์ด์๋ค.
์ด๋ฌํ ์ด๋ถ ํ์ ์กฐ๊ฑด๋ค์ ์ ์ฐพ์๋ผ ์ ์๋๋ก ๊ณ ๋ฏผ์ ํด๋ด์ผ๊ฒ ๋ค๋ ์๊ฐ์ด ๋ค์๋ค.