๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ
Algorithm

ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค[Java] - ๊ธฐ์ง€๊ตญ ์„ค์น˜(๊ทธ๋ฆฌ๋””)

by ์ฃผ๋ฐœ2 2020. 2. 7.
๋ฐ˜์‘ํ˜•

https://programmers.co.kr/learn/courses/30/lessons/12979

 

์ฝ”๋”ฉํ…Œ์ŠคํŠธ ์—ฐ์Šต - ๊ธฐ์ง€๊ตญ ์„ค์น˜ | ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค

N๊ฐœ์˜ ์•„ํŒŒํŠธ๊ฐ€ ์ผ๋ ฌ๋กœ ์ญ‰ ๋Š˜์–ด์„œ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด ์ค‘์—์„œ ์ผ๋ถ€ ์•„ํŒŒํŠธ ์˜ฅ์ƒ์—๋Š” 4g ๊ธฐ์ง€๊ตญ์ด ์„ค์น˜๋˜์–ด ์žˆ์Šต๋‹ˆ๋‹ค. ๊ธฐ์ˆ ์ด ๋ฐœ์ „ํ•ด 5g ์ˆ˜์š”๊ฐ€ ๋†’์•„์ ธ 4g ๊ธฐ์ง€๊ตญ์„ 5g ๊ธฐ์ง€๊ตญ์œผ๋กœ ๋ฐ”๊พธ๋ ค ํ•ฉ๋‹ˆ๋‹ค. ๊ทธ๋Ÿฐ๋ฐ 5g ๊ธฐ์ง€๊ตญ์€ 4g ๊ธฐ์ง€๊ตญ๋ณด๋‹ค ์ „๋‹ฌ ๋ฒ”์œ„๊ฐ€ ์ข์•„, 4g ๊ธฐ์ง€๊ตญ์„ 5g ๊ธฐ์ง€๊ตญ์œผ๋กœ ๋ฐ”๊พธ๋ฉด ์–ด๋–ค ์•„ํŒŒํŠธ์—๋Š” ์ „ํŒŒ๊ฐ€ ๋„๋‹ฌํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด 11๊ฐœ์˜ ์•„ํŒŒํŠธ๊ฐ€ ์ญ‰ ๋Š˜์–ด์„œ ์žˆ๊ณ , [4, 11] ๋ฒˆ์งธ ์•„ํŒŒํŠธ ์˜ฅ์ƒ์—๋Š” 4g ๊ธฐ์ง€๊ตญ์ด ์„ค์น˜๋˜์–ด ์žˆ์Šต๋‹ˆ๋‹ค. ๋งŒ์•ฝ ์ด 4g

programmers.co.kr

์‹œ๊ฐ„ ์ดˆ๊ณผ ์ฝ”๋“œ

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๋กœ ๋‚˜๋ˆด์„๋•Œ ์˜ฌ๋ฆผ์„ ํ•ด์ฃผ๋ฉด ๋œ๋‹ค.

 

์ œ์ถœํ•˜๋ฉด ํ…Œ์ŠคํŠธ์ผ€์ด์Šค๋„ ์ผ๋ถ€ ํ‹€๋ฆฌ๊ณ ,, ์‹œ๊ฐ„์ดˆ๊ณผ๊ฐ€ ๋‚˜์˜จ๋‹ค .......... ใ… ใ… 

๊ทธ๋ž˜์„œ ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค์˜ ๊ฐ•์˜๋ฅผ ๋ดค๋‹ค .......

๋ฐ˜์‘ํ˜•

๋Œ“๊ธ€