2023. 11. 8. 14:33ใ์ธํ๋ฐ/์๋ฐ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํ์ด ์ ๋ฌธ : ์ฝ๋ฉํ ์คํธ ๋๋น
https://hyejin.tistory.com/1244
-> ์ด์ ๋ฌธ์ ํ์ด
6. ์ฅ๋ ๊พธ๋ฌ๊ธฐ
์ค๋ช
์ ํ๊ธฐ๊ฐ ์์๋์์ต๋๋ค. ์ฒ ์๋ ์ ์ง๊ฟ์ ๋ง๋ ๋๋ฌด ์ ์ด ๋ฌ์ต๋๋ค.
์ฒ ์๋ค ๋ฐ์๋ N๋ช ์ ํ์๋ค์ด ์์ต๋๋ค.
์ ์๋์ ๋ฐ ํ์๋ค์๊ฒ ๋ฐ ๋ฒํธ๋ฅผ ์ ํด ์ฃผ๊ธฐ ์ํด ์ด๋์ฅ์ ๋ฐ ํ์๋ค์ ํค๊ฐ ๊ฐ์ฅ ์์ ํ์๋ถํฐ ์ผ๋ ฌ๋ก ํค์์ผ๋ก ์ธ์ ์ต๋๋ค.
์ ์ผ ์์ ๊ฐ์ฅ ์์ ํ์๋ถํฐ ๋ฐ ๋ฒํธ๋ฅผ 1๋ฒ๋ถํฐ N๋ฒ๊น์ง ๋ถ์ฌํฉ๋๋ค. ์ฒ ์๋ ์ง๊ฟ๋ณด๋ค ํค๊ฐ ํฝ๋๋ค.
๊ทธ๋ฐ๋ฐ ์ฒ ์๊ฐ ์ ๋ฒํธ๋ฅผ ๋ฐ๊ณ ์ถ์ด ์ง๊ฟ๊ณผ ์๋ฆฌ๋ฅผ ๋ฐ๊ฟจ์ต๋๋ค.
์ ์๋์ ์ด ์ฌ์ค์ ๋ชจ๋ฅด๊ณ ํ์๋ค์๊ฒ ์์๋ ์์๋๋ก ๋ฒํธ๋ฅผ ๋ถ์ฌํ์ต๋๋ค.
์ฒ ์์ ์ง๊ฟ์ด ์๋ฆฌ๋ฅผ ๋ฐ๊พผ ๋ฐ ํ์๋ค์ ์ผ๋ ฌ๋ก ์์๋ ํค ์ ๋ณด๊ฐ ์ฃผ์ด์ง ๋ ์ฒ ์๊ฐ ๋ฐ์ ๋ฒํธ์ ์ฒ ์ ์ง๊ฟ์ด ๋ฐ์ ๋ฒํธ๋ฅผ
์ฐจ๋ก๋ก ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์.
์ ๋ ฅ
์ฒซ ๋ฒ์งธ ์ค์ ์์ฐ์ N(5<=N<=100)์ด ์ฃผ์ด์ง๋ค.
๋ ๋ฒ์งธ ์ค์ ์ ์ผ ์์๋ถํฐ ์ผ๋ ฌ๋ก ์์๋ ํ์๋ค์ ํค๊ฐ ์ฃผ์ด์ง๋ค.
ํค(๋์ด) ๊ฐ H๋ (120<=H<=180)์ ์์ฐ์ ์ ๋๋ค.
์ถ๋ ฅ
์ฒซ ๋ฒ์งธ ์ค์ ์ฒ ์์ ๋ฐ ๋ฒํธ์ ์ง๊ฟ์ ๋ฐ ๋ฒํธ๋ฅผ ์ฐจ๋ก๋ก ์ถ๋ ฅํฉ๋๋ค.
์์ ์ ๋ ฅ 1
9
120 125 152 130 135 135 143 127 160
์์ ์ถ๋ ฅ 1
3 8
ํํธ
์ถ๋ ฅํด์ค : ํค ์ ๋ณด 152๊ฐ ์ฒ ์์ด๊ณ , 127์ด ์ฒ ์ ์ง๊ฟ์ ๋๋ค.
๋ฌธ์ ํ์ด 1
public ArrayList<Integer> solution(int n, int[] arr)
{
ArrayList<Integer> answer = new ArrayList<>();
int[] copyArrs = Arrays.copyOf(arr, arr.length);
Arrays.sort(arr);
for (int i = 0; i < n; i++)
{
if (arr[i] != copyArrs[i]) {
answer.add(i+1);
}
}
return answer;
}
๐ฉ๐ป๐ป : ์ด ๋ฌธ์ ๋ฅผ ์ ๋ ฌํด์ ํธ๋ ๋ฐฉ๋ฒ ๋ง๊ณ ์ฒ์์๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ผ๋ก ํ์ด๋ณด๋ ค๊ณ ํ๋๋ฐ ํค๊ฐ ๊ฐ์ ํ์์ด ์ฌ๋ฌ๋ช ๋์ค๋ ์์์์ ์๊พธ ์ค๋ต์ด ๋์์.. ๊ฒฐ๊ตญ ์ ๋ ฌ๋ก ํธ๋ ๋ฐฉ๋ฒ์ ์ฐพ์์ ์์ ํ์ด ๋ฐฉ์์ผ๋ก ์ ๋ต์ด ๋์๋ค.
๋จผ์ Arrays.copyOf ๋ฉ์๋๋ฅผ ์ด์ฉํด์ arr๋ฅผ arr.length ๋งํผ ๋ณต์ฌ๋ฅผ ํด์ copyArrs ๋ก ์ฃผ์ด์ง arr ๋ฐฐ์ด๊ณผ ๋๊ฐ์ ๋ฐฐ์ด์ ๋ง๋ค์ด์ฃผ๊ณ ,
๊ทธ ๋ค์ Arrays.sort ๋ฉ์๋๋ฅผ ์ด์ฉํด์ copyArrs ๋ฐฐ์ด์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํด์คฌ๋ค.
๊ทธ๋ค์ for๋ฌธ์ ๋๋ฉด์ copyArrs์ arr์ด ์๋ก ๋ค๋ฅธ ๊ฐ์ด ์กด์ฌํ ๋, ๊ฑฐ๊ธฐ๊ฐ ์ฒ ์๊ฐ ํค๊ฐ ์์ ํ์๊ณผ ์๋ฆฌ๋ฅผ ๋ฐ๊พผ ๊ฒ์ด ๋๊ธฐ ๋๋ฌธ์ Arraylist์ ํด๋น ํ์์ i + 1 ์์น๋ฅผ add ํด์คฌ๋ค.
๋ฌธ์ ํ์ด 2
public ArrayList<Integer> solution2(int n, int[] arr) {
ArrayList<Integer> answer = new ArrayList<>();
int[] tmp = arr.clone(); // ๊น์ ๋ณต์ฌ
Arrays.sort(tmp);
for (int i = 0; i < n; i++) {
if (arr[i] != tmp[i]) {
answer.add(i + 1);
}
}
return answer;
}
๐พ : ๊ฐ์ฌ๋๋ ๋ง์ฐฌ๊ฐ์ง๋ก ์ ๋ ฌ์ ์ด์ฉํด์ ํธ์ จ๋ค. ์ด ๋ฌธ์ ๋ฅผ ์ ๋ ฌ๋ก ํ๋ฉด ๊ต์ฅํ ๋น ๋ฅด๊ณ ๊ฐ๋จํ๊ฒ ํ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค.
์ฃผ์ด์ง ๋ฐฐ์ด arr๋ฅผ ๊น์ ๋ณต์ฌ clone() ๋ฉ์๋๋ฅผ ์ด์ฉํด์ tmp ๋ฐฐ์ด์ ๋ง๋ค๊ณ ,
for๋ฌธ์ ์ด์ฉํด์ arr[i] ์ tmp[i]์ ๊ฐ์ด ๋ค๋ฅด๋ฉด ์๋ฆฌ๋ฅผ ๋ฐ๊ฟจ๋ค๋ ๊ฒ์ด๋ฏ๋ก ๊ทธ ํ์๋ค์ i ์์น + 1 ์ answer ์ ๋ด์์คฌ๋ค.
i+ 1 ์ ๋ด๋ ์ด์ ๋ ๋ฐฐ์ด์ 0 ๋ถํฐ ์์์ด์ง๋ง, ํ์๋ค์ ์์น๋ 1๋ถํฐ ์์ํ๊ธฐ ๋๋ฌธ์ด๋ค.