๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ์ ๊ทผ๋ฐฉ์
๋ฌธ์ ์์ ์ฃผ์ด์ง ๊ฒ
- n : ์ ์ฒด ํ์์ ์
- lost : ์ฒด์ก๋ณต ๋๋๋นํ ํ์๋ค์ ๋ฒํธ๋ค (๋ฐฐ์ด)
- reserve : ์ฌ๋ฒ ๊ฐ์ ธ์จ ํ์ ๋ฒํธ๋ค (๋ฐฐ์ด)
์ฒด์ก๋ณต์ ์,๋ค ๋ฒํธ ํ์ ์๋ง ๋น๋ ค์ค ์ ์์.
๋๋ ๋นํ ํ์๋ค์ ์ฌ๋ถ์ด ์์ด์ ์ฒด์ก๋ณต ๋น๋ ค์ค ์ ์์.
1. `lost`์ `reserve` ๋ฐฐ์ด ์ ๋ ฌ
2. ์ฒด์ก์์ ์ ์ฐธ์ฌํ ์ ์๋ ํ์์ ์ = ์ฒด์ก๋ณต์ด ์๊ฑฐ๋ ๋น๋ฆด ์ ์๋ ํ์๋ค์ ์
`์ฒด์ก๋ณต์ ๋๋ ๋นํ์ง ์์ ํ์์ ์` + `๋๋๋นํ์ง๋ง ์๋น๋ก ๋ค๊ณ ์จ ํ์์ ์` + `๋๋๋นํ์ง๋ง ์ฒด์ก๋ณต์ ๋น๋ฆด ์ ์๋ ํ์์ ์`
์ด ๋ชจ๋ ํ์๋ค์ ์๋ฅผ ๋์ ํด์ answer ๋ณ์์ ๋ด์ ์ค๋ค.
โ ์ฒด์ก๋ณต์ ๋๋ ๋นํ์ง ์์ ํ์์ ์
= ์ ์ฒด ํ์์ ์ - ์ฒด์ก๋ณต์ ๋๋๋นํ ํ์ ์ ์
`n - lost.length`
โ
๋๋๋นํ์ง๋ง ์๋น๋ก ๋ค๊ณ ์จ ํ์์ ์
- `lost`๋ฐฐ์ด๊ณผ `reserve`๋ฐฐ์ด์ ๋๋ค ์๋ ํ์์ ๋ณธ์ธ ์ฒด์ก๋ณต์ ์์ง๋ง ๋น๋ ค์ค ์ ์๋ค.
- ์ฒด์ก๋ณต์ด ์์ด ์ฒด์ก์์ ์ ๋ค์ ์ ์๊ธฐ ๋๋ฌธ์ answer์ ๋ํด์ค๋ค.
- ๋ค๋ฅธ ํ์์๊ฒ ์ฒด์ก๋ณต์ ๋น๋ฆด ํ์๊ฐ ์์ผ๋ฏ๋ก lost[i]์ ์๊ด์๋ ๊ฐ -1 ์ ์ฅํด์ ํด๋น ๋ฐฐ์ด์์ ์ ์ธํด์ค๋ค.
- ๋ง์ฐฌ๊ฐ์ง๋ก ๋ค๋ฅธ ํ์์๊ฒ ๋น๋ ค์ค ์ ์์ผ๋ฏ๋ก reserve[i]์ -1 ์ ์ฅํด์ ํด๋น ๋ฐฐ์ด์์ ์ ์ธ.
โ ๋๋๋นํ์ง๋ง ์ฒด์ก๋ณต์ ๋น๋ฆด ์ ์๋ ํ์์ ์
- ์ฒด์ก๋ณต์ ํ์ฌ ํ์์ ์๋ค ๋ฒํธ ํ์์๊ฒ๋ง ๋น๋ฆด ์ ์๋ค.
- ์์ ํ์์๊ฒ ๋น๋ฆด ์ ์์ `lost[i] - 1 == reserve[j] ` ๋๋
- ๋ค์ ํ์์๊ฒ ๋น๋ฆด ์ ์์ `lost[i] + 1 == reserve[j]`
- ์ฒด์ก๋ณต์ ๋น๋ ธ๋ค๋ฉด answer์ ๋์ ํด์ค๋ค.
- ์ฒด์ก๋ณต์ ์ด๋ฏธ ๋น๋ ค์คฌ์ผ๋ฏ๋ก reserve[j]์ -1 ๋ฅผ ์ ์ฅํด์ ์ ์ธํด์ค๋ค.
โญ 3. ์ ๋ต์ฝ๋
๋ด๊ฐ ํผ ์ฝ๋
import java.util.Arrays;
class Solution {
public int solution(int n, int[] lost, int[] reserve) {
int answer = 0;
// ๋ฐฐ์ด ์ ๋ ฌ
Arrays.sort(reserve);
Arrays.sort(lost);
// ์ฒด์ก๋ณต ๋๋๋นํ์ง ์์ ํ์ ์
// ์ ์ฒดํ์์ - ๋๋๋นํ ํ์ ์
answer = n - lost.length;
// ์ฌ๋ฒ ์ฒด์ก๋ณต ๊ฐ์ ธ์์ผ๋ ๋๋๋นํ ํ์ ์
// ์ฒด์ก์๊ฐ์ ์ฐธ์ฌํ ์ ์์ผ๋ ๋ค๋ฅธ ํ์์๊ฒ ๋น๋ ค์ค ์ ์์ผ๋ฏ๋ก
// lost ๋ฐฐ์ด๊ณผ reserve ๋ฐฐ์ด์์ ํด๋น ํ์์ ๋ฒํธ๋ฅผ ์ญ์ ํด ์ฃผ์ด์ผ ํจ.
// ๋๋ ์๊ด ์๋ ๊ฐ -1๋ก ์ค์ ํด ์ค
for (int i = 0; i < lost.length; i++) {
for (int j = 0; j < reserve.length; j++) {
if (lost[i] == reserve[j]) {
answer++;
lost[i] = -1;
reserve[j] = -1;
break;
}
}
}
// ๋๋๋นํ์ง๋ง ์ฒด์ก๋ณต์ ๋น๋ฆด ์ ์๋ ํ์ ์
for (int i = 0; i < lost.length; i++) {
for (int j = 0; j < reserve.length; j++) {
if (lost[i] - 1 == reserve[j] || lost[i] + 1 == reserve[j]) {
answer++;
reserve[j] = -1;
break;
}
}
}
return answer;
}
}
ํ ์คํธ์ฉ ์ฝ๋
public class programmers {
public static void main(String[] args) {
// TODO Auto-generated method stub
int n = 5;
int[] lost = { 2, 4 };
int[] reserve = { 1, 3, 5 };
int result = Solution.solution(n, lost, reserve);
System.out.println("์ฒด์ก๋ณต์ ์
์ ์ ์๋ ํ์ ์: " + result);
}
}
์ ์ฒ๋ผ ๋ฉ์ธ์์ ํ ์คํธ ํ ๋ ๊ฐ์ฒด๋ฅผ ์์ฑํ์ง ์๊ณ , ํด๋์ค ์ด๋ฆ์ผ๋ก ๋ฐ๋ก solution ๋ฉ์๋๋ฅผ ํธ์ถํ๋ ค๋ฉด Solution ๋ฉ์๋๋ฅผ `static` ๋ฉ์๋๋ก ๋ฐ๊ฟ์ผ ํฉ๋๋ค. solution ๋ฉ์๋๋ฅผ ์ธ์คํด์ค ๋ฉ์๋๋ก ์ ์ํ์๋ฉด ์ธ์คํด์ค ๋จผ์ ์์ฑํ์ ์ ํด์ผ ํด์. ์๊ทธ๋ฌ๋ฉด ์ค๋ฅ ๋น๋๋ค~
๐๐ป ์ข์์ ๊ฐ์ฅ ๋ง์ด ๋ฐ์ ์ฝ๋
class Solution {
public int solution(int n, int[] lost, int[] reserve) {
int[] people = new int[n];
int answer = n;
for (int l : lost)
people[l-1]--;
for (int r : reserve)
people[r-1]++;
for (int i = 0; i < people.length; i++) {
if(people[i] == -1) {
if(i-1>=0 && people[i-1] == 1) {
people[i]++;
people[i-1]--;
}else if(i+1< people.length && people[i+1] == 1) {
people[i]++;
people[i+1]--;
}else
answer--;
}
}
return answer;
}
}
๐ฆ 4. ๊ฐ์ ์ ํ ๋ฌธ์ (๊ทธ๋ฆฌ๋)
'Algorithm > Programmers_Best' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ์กฐ์ด์คํฑ (๊ทธ๋ฆฌ๋) (58) | 2024.12.07 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ๋ชจ์์ฌ์ (์์ ํ์) (56) | 2024.11.23 |
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ์ ๋ ฅ๋ง์ ๋๋ก ๋๋๊ธฐ (์์ ํ์) (6) | 2024.11.23 |
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ํผ๋ก๋ (์์ ํ์) (56) | 2024.11.22 |
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ์นดํซ (์์ ํ์) (70) | 2024.11.22 |