https://programmers.co.kr/learn/courses/30/lessons/12979
์๊ฐ ์ด๊ณผ ์ฝ๋
import java.util.LinkedList;
import java.util.Queue;
class Solution {
public int solution(int n, int[] stations, int w) {
int answer = 0; // ๊ธฐ์ง๊ตญ์ ๊ฐฏ์
Queue<Integer> sq = new LinkedList<Integer>();
for(int s : stations) {
sq.offer(s); // ํ์ฌ ๊ธฐ์ง๊ตญ์ด ์ค์น๋ ์ํํธ ์ถ๊ฐ
}
int position = 1; // ์ํํธ 1๋๋ถํฐ ๋๊น์ง
while(position <= n) { // ๋ ์ ์ฒด์ ๋๋ฉด์
// ๊ธฐ์กด์ ์ค์น๋ ๊ธฐ์ง๊ตญ์ด ์กด์ฌํด์ผํ๊ณ ,
// ํ์ฌ์ ์์น(position)๊ฐ ๊ธฐ์กด ์ค์น๋ ๊ธฐ์ง๊ตญ(sq.peek())์ ์ ํ ๋ฒ์(w) ์์ ์๋์ง ํ์ธ
if(!sq.isEmpty() && position >= sq.peek() - w) {
// ๋ค์ ์ด๋ํด์ผ ํ ํฌ์ง์
position = sq.poll() + w + 1; // ๊ธฐ์ง๊ตญ์ ์ค๋ฅธ์ชฝ ๋
}
else {
answer += 1; // ๊ธฐ์ง๊ตญ ํ๋ ์ค์น
// ๊ธฐ์ง๊ตญ ์ค์น์ ์ํด ๋ฐ์ํ๋ ์ต๋ ์ ํ๋ฒ์
// ์ผ์ชฝ ์ ํ๋ฒ์ + ๊ธฐ์ง๊ตญ์ค์น(1) + ์ค๋ฅธ์ชฝ ์ ํ๋ฒ์
position += (w*2) + 1;
}
}
return answer;
}
}
์ ์ฝ๋๋ ํ ์คํธ ์ผ์ด์ค๋ ์ ๋ถ ๋ง์ง๋ง ์๊ฐ์ด๊ณผ๊ฐ ๋ฐ์ํ๋ ์ฝ๋์ด๋ค.
์๊ฐ ์ด๊ณผ?(ํจ์จ์ฑํ ์คํธ) => ๋ ๋น ๋ฅด๊ฒ ๋์ํ๋๋ก ํ๋ก๊ทธ๋จ์ ๋ฐ๊พผ๋ค.
Tip. ํจ์จ์ฑ ๋์ด๊ธฐ
1. Loop ๊ฐ์
2. ์ ์ ํ ๋ฐ์ดํฐ ๊ตฌ์กฐ ์ฌ์ฉ
3. ๋ถํ์ํ ์ค๋ธ์ ํธ ์ ๊ฑฐ
์ต์ข ์ฝ๋
public int solution(int n, int[] stations, int w) {
int answer = 0; // ๊ธฐ์ง๊ตญ์ ๊ฐฏ์
int si = 0; // station์ ์ธ๋ฑ์ค
int position = 1; // ์ํํธ 1๋๋ถํฐ ๋๊น์ง
while(position <= n) { // ๋ ์ ์ฒด์ ๋๋ฉด์
// ๊ธฐ์ง๊ตญ์ด ์ค์น๋(stations ๋ฐฐ์ด์ ์์๊ฐ ์กด์ฌํ ๋ ๊น์ง) ๊ณณ ๊น์ง๋ง ํ์
// ํ์ฌ์ ์์น(posotion)๊ฐ ๊ธฐ์กด ์ค์น๋ ๊ธฐ์ง๊ตญ(stations[si])์ ์ ํ ๋ฒ์(w) ์์ ์๋์ง ํ์ธ
// ๋ง์ฝ ๊ธฐ์กด ์ค์น๋ ๊ธฐ์ง๊ตญ์ ๋ฒ์ ์์ ์์๊ฒฝ์ฐ => ์ ํ ๋ฒ์์ด๋ฏ๋ก ๊ธฐ์ง๊ตญ์ ์ค์นํ ํ์๊ฐ ์๋ค.
if(si < stations.length && position >= stations[si] - w) {
// ๋ค์ ์ด๋ํด์ผ ํ ํฌ์ง์
position = stations[si] + w + 1; // ๊ธฐ์ง๊ตญ์ ์ค๋ฅธ์ชฝ ๋
si ++; // ๋ค์ ์ค์นํ ๊ธฐ์ง๊ตญ์ ์ฐพ๊ธฐ ์ํด ์ธ๋ฑ์ค +1
}
else {
answer += 1; // ๊ธฐ์ง๊ตญ ํ๋ ์ค์น
// ๊ธฐ์ง๊ตญ ์ค์น์ ์ํด ๋ฐ์ํ๋ ์ต๋ ์ ํ๋ฒ์
// ์ผ์ชฝ ์ ํ๋ฒ์ + ๊ธฐ์ง๊ตญ์ค์น(1) + ์ค๋ฅธ์ชฝ ์ ํ๋ฒ์
position += (w*2) + 1;
}
}
return answer;
}
Queue ๋์ ์ค์น๋ ๊ธฐ์ง๊ตญ์ ์ธ๋ฑ์ค๋ฅผ ํ์ํ๋ฉฐ ํผ ์ฝ๋ .........
์ ์ถ๋ ฅ ์ 1๋ฒ์ ๋ณด๋ฉด...
์ํํธ N = 11
๊ธฐ์กด ๊ธฐ์ง๊ตญ์ด ์ค์น๋ ์ํํธ stations[] = {4, 11}
์ ํ ๊ฑฐ๋ฆฌ W = 1
์ ์์ 1๋์ํํธ๋ถํฐ ํ์์ ํ๋ค.
1๋์ ๊ธฐ์กด ์ค์น๋ ๊ธฐ์ง๊ตญ์ ๋ฒ์๊ฐ ์๋๋ฏ๋ก, ๊ธฐ์ง๊ตญ์ ์ค์นํ ๋ ๋ฐ์ํ๋ ์ต๋ ์ ํ๋ฒ์๋ฅผ ์ฐพ๋๋ค.
์์์ 2๋ฒ ์ํํธ์ ๊ธฐ์ง๊ตญ์ ์ค์นํ๋ฉด ์ํํธ(1, 2, 3) ๋ชจ๋ ์ ํ๋ฒ์์ด๋ฏ๋ก ์ต๋๊ฐ ๋๋ค.
๊ทธ ํ ํ์ํ ์ํํธ๋ 4๋ฒ๋ถํฐ ํ์ํ๋ฉด ๋๋ค.
(์ผ์ชฝ ์ ํ๋ฒ์(1) + ๊ธฐ์ง๊ตญ ์ค์น(2) + ์ค๋ฅธ์ชฝ ์ ํ๋ฒ์(3)) = (w*2) + 1
4๋ฒ ์ํํธ์ ๊ฒฝ์ฐ ๊ธฐ์กด์ ๊ธฐ์ง๊ตญ์ด ์ค์น๋ ์ํํธ์ด๋ค.
๊ธฐ์กด์ ๊ธฐ์ง๊ตญ์ด ์ค์น๋ ์ํํธ์ ๊ฒฝ์ฐ ๋ฐ์ด๋๊ณ , ์ด๋ ์ํํธ๋ถํฐ ํ์ํ ์ง ์์ position์ ๋ค์ ์ก์์ฃผ๋ฉด๋๋ค.
๋ํ ๋ค์ ๊ธฐ์ง๊ตญ์ด ์ค์น๋ ์ํํธ๋ฅผ ์ฐพ๊ธฐ์ํด stations์ ์ธ๋ฑ์ค si๋ฅผ ++ํ๋ค.
์ฆ ๊ธฐ์กด์ ๊ธฐ์ง๊ตญ์ด ์ค์น๋ ์ํํธ(4๋)์์ ์ ํ๋ฒ์(w)๋งํผ ๋ํ ํ, 1์ ๋ํด์ฃผ๋ฉด ๊ทธ๋ค์์ ํ์์์๋ฒ์๊ฐ ๋๋ค.
๋ค์ 6๋ฒ๋ถํฐ ์์ ๊ณผ์ ์ ๋ฐ๋ณตํด์ ์คํํ๋ฉด ๋๋ค ...
์ ์ฒด ์ํํธ๋ฅผ ๋๋ฉด์ ๊ธฐ์กด์ ๊ธฐ์ง๊ตญ์ด ์ค์น๋ ์ํํธ๋ ๋ฐ์ด๋๊ณ , ๊ธฐ์ง๊ตญ์ ์ด๋ ์ํํธ์ ์ค์นํ๋๊ฒ ์ต์๊ฐ ๋๋์ง ์๊ฐ์๊ฐ ์ต์ ์ ํด๋ฅผ ์ฐพ๋ ๊ทธ๋ฆฌ๋, ํ์๋ฒ ๋ฌธ์
์ฝ๋๋ ๊ฐ๊ฒฐํ์ง๋ง ์ด๋ป๊ฒ ์ ๋ฐ์์ผ๋ก ์๊ฐํ๊ณ ํ์ด์ผํ ์ง ๋ง๋งํ๋ค ......
๋ค์์ ๋ค์ ํ๋ฉด ๋ชปํ๊ฒ๊ฐ์ง๋ง ๋ ๋ค์ํ ๋ฌธ์ ๋ค ํ๊ณ ์ตํ๋ฉฐ ๋ค์ํ๊ฒ ์๊ฐํด๋ด์ผ๊ฒ ๋ค ...
ํ๋ฆฐ ์ฝ๋
public class Solution{
public static int solution(int n, int[] stations, int w) {
int answer = 0;
boolean[] check = new boolean[n+1];
// ๊ธฐ์กด์ ์ฃผ์ด์ง 4g ๊ธฐ์ง๊ตญ์ด ์ค์น๋ ์ํํธ ์ฒดํฌ
for(int i=0; i<stations.length; i++)
check[stations[i]] = true;
for(int i=1; i<=w; i++){
for(int j=0; j<stations.length; j++){
// ์ค์น๋ ์ํํธ๋ฅผ ๊ธฐ์ค์ผ๋ก ์ข,์ฐ ์ํํธ ๊ธฐ์ง๊ตญ ์ค์น
// ์ด๋, ์ข ์ฐ์ ์ํํธ๊ฐ ์๋๊ฒฝ์ฐ => ์ค์นํ ์ ์์
if(stations[j]-i >= 1){ // ์ผ์ชฝ์ ์ํํธ๊ฐ ์๋ ๊ฒฝ์ฐ
check[stations[j]-i] = true;
}
if(stations[j]+i <= n){ // ์ค๋ฅธ์ชฝ์ ์ํํธ๊ฐ ์๋ ๊ฒฝ์ฐ
check[stations[j]+i] = true;
}
}
}
for(int i=0; i<check.length; i++){
int count = 0; // ๊ธฐ์ง๊ตญ์ด ์ค์น๋ ์ํํธ ์ ๊น์ง ์ค์น๋์ง ์์ ์ํํธ์ ๊ฐฏ์
while(!check[i]){
count ++;
i ++;
if(i == n)
break;
}
if(count != 0){ // ๊ธฐ์ง๊ตญ์ ์ค์นํด์ผ ํ ์ํํธ๊ฐ ์๋ ๊ฒฝ์ฐ
/*
* w(์ ํ ๋๋ฌ ๊ฑฐ๋ฆฌ)์ ๋ฐ๋ผ ์ฆ์คํด์ผ ํ ๊ธฐ์ง๊ตญ์ ๊ฐ์๊ฐ ๋ฌ๋ผ์ง.
* w=1 => ์ต๋ 3๊ฐ ์ํํธ ์ค์น ๊ฐ๋ฅ (w*2) + 1
* w=2 => ์ต๋ 5๊ฐ ์ํํธ ์ค์น ๊ฐ๋ฅ (w*2) + 1
* w=3 => ์ต๋ 7๊ฐ ์ํํธ ์ค์น ๊ฐ๋ฅ (w*2) + 1
*/
int wPlus = (w*2) + 1;
// ์์์ ๊ณ์ฐํ w์ ๊ท์น๋งํผ ๊ธฐ์ง๊ตญ์ ์ค์นํ๋ค.
// w=1 --> count๊ฐ 1, 2, 3 ์ผ๋ 1๊ฐ์ค์น
// w=1 --> count๊ฐ 4, 5, 6 ์ผ๋ 2๊ฐ์ค์น
double plus = Math.ceil((double)count / wPlus);
answer += (int)plus;
}
}
return answer;
}
๋์ ํ์ด
N = ์ํํธ์ ๊ฐฏ์
stations[] = ํ์ฌ ๊ธฐ์ง๊ตญ์ด ์ค์น๋ ์ํํธ์ ๋ฒํธ
W = ์ ํ์ ๋๋ฌ๊ฑฐ๋ฆฌ
์ ์ธ๊ฐ๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋ค.
๋ฐ๋ผ์ ๋๋ boolean[]ํ check ๋ฐฐ์ด์ ํตํด ์ํํธ์ ๊ธฐ์ง๊ตญ์ด ์ค์น๋ฌ๋์ง ์๋ฌ๋์ง ํ๋จํ๋ ์์ผ๋ก ํด๊ฒฐํ๋ ค ํ๋ค.
๋จผ์ ํ์ฌ ๊ธฐ์ง๊ตญ์ด ์ค์น๋ stations[]์ ์ํํธ ๋ฒํธ๋ฅผ check ๋ฐฐ์ด์ ์ฒดํฌํ๋ค.
๊ทธ ํ ํ์ฌ ๊ธฐ์ง๊ตญ์ด ์ค์น๋ ์ข, ์ฐ ์ํํธ์ W ๋งํผ ์ฒดํฌ๋ฅผ ํ์ํ๋ค.
(์ด ๋, ํ์ฌ ์ค์น๋ ๊ธฐ์ง๊ตญ์ ์ข,์ฐ ์ ์ํํธ๊ฐ ์๋๊ฒฝ์ฐ ๊ธฐ์ง๊ตญ์ ์ค์นํ ์ ์๋ค.)
์ ์ถ๋ ฅ ์ 1๋ฒ์ ๋ค๋ฉด
N = 11, stations = [4, 11] , W = 1 ์์,
์ฒซ๋ฒ์งธ๋ก check[4] = check[11] = true ๋ก ์ค์ ํ๋ค.
๋ค์์ผ๋ก W = 1์ด๋ฏ๋ก, ์ข ์ฐ ํ์นธ์ฉ true๋ก ํ์ํ๋ค.
check[3] = check[5] = true
check[10] = true (์ํํธ๊ฐ 11๊ฐ์ด๋ฏ๋ก, check[12] ๋ ์ฒดํฌํ ํ์๊ฐ ์๋ค.)
๊ทธ ํ ๊ธฐ์ง๊ตญ์ด ์ค์น๋์ง ์์(false) ์ํํธ๋ค์ ๊ธฐ์ค์ผ๋ก ๋ช๊ฐ์ ๊ธฐ์ง๊ตญ์ ์ค์นํด์ผ ํ๋์ง ๊ตฌํด์ค๋ค.
์ด ๋, ์ ํ์ ๋๋ฌ ๊ฑฐ๋ฆฌ(W)์ ๊ท์น์ ์ฐพ์๋ดค๋๋ฐ ...
W=1 --> ์์ ํ์นธ์ฉ ๊ธฐ์ง๊ตญ์ ์ค์นํ ์ ์์ผ๋ฏ๋ก 3๊ฐ๊ฐ ์ค์น๊ฐ๋ฅํ๋ค.
W=2 --> ์์ ๋์นธ์ฉ ๊ธฐ์ง๊ตญ์ ์ค์นํ ์ ์์ผ๋ฏ๋ก 5๊ฐ๊ฐ ์ค์น๊ฐ๋ฅํ๋ค.
W=n --> ์์ n ์นธ์ฉ ๊ธฐ์ง๊ตญ์ ์ค์นํ ์ ์์ผ๋ฏ๋ก (n*2) +1 ๊ฐ๊ฐ ์ค์น๊ฐ๋ฅํ๋ค.
์์ ๊ฐ์ ๊ท์น์ ํตํด W์ ์ซ์์ ๋ฐ๋ผ ํ์ํ ๊ธฐ์ง๊ตญ์ ๊ฐฏ์๋ฅผ ๊ตฌํด์ค๋ค.
double plus = Math.ceil((double)count / wPlus);
์ ๋ฌธ์ฅ์ ๊ฒฝ์ฐ,
W=1 ์ผ๋,
count๊ฐ 1~3์ 1๊ฐ, 4~6์ 2๊ฐ, 7~9๋ 3๊ฐ์ ๊ธฐ์ง๊ตญ์ด ํ์ํ๋ค.
๋ฐ๋ผ์ (w*2)+1๋ก ๋๋ด์๋ ์ฌ๋ฆผ์ ํด์ฃผ๋ฉด ๋๋ค.
์ ์ถํ๋ฉด ํ ์คํธ์ผ์ด์ค๋ ์ผ๋ถ ํ๋ฆฌ๊ณ ,, ์๊ฐ์ด๊ณผ๊ฐ ๋์จ๋ค .......... ใ ใ
๊ทธ๋์ ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ์๋ฅผ ๋ดค๋ค .......
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฐฑ์ค] 2161๋ฒ: ์นด๋1(์๋ฎฌ๋ ์ด์ ) (0) | 2020.02.07 |
---|---|
[๋ฐฑ์ค] 1012๋ฒ: ์ ๊ธฐ๋ ๋ฐฐ์ถ(dfs, bfs) (0) | 2020.02.07 |
[๋ฐฑ์ค] 11586๋ฒ: ์ง์ ๊ณต์ฃผ๋์ ๋ง๋ฒ ๊ฑฐ์ธ(๋ฌธ์์ด) (0) | 2020.02.06 |
[๋ฐฑ์ค] 11724๋ฒ: ์ฐ๊ฒฐ ์์์ ๊ฐ์(dfs, bfs) (0) | 2020.02.06 |
[๋ฐฑ์ค] 2262๋ฒ: ํ ๋๋จผํธ ๋ง๋ค๊ธฐ(๊ทธ๋ฆฌ๋) (0) | 2020.02.06 |
๋๊ธ