3 ๋ถ„ ์†Œ์š”

๐Ÿ“š ALGORITHM


๐Ÿ“š DP ( Dynamic )

ํ”ผ๋ณด๋‚˜์น˜ ์ˆ˜์—ด ์ด๋ž€ ๋ฌด์—‡์ธ๊ฐ€ ?

-> ํฐ ๋ฌธ์ œ์ ์ด ์žˆ๋‹ค.
๊ทธ๊ฒƒ์€ ์—„์ฒญ๋‚œ ์ค‘๋ณต ํ˜ธ์ถœ์ด ์กด์žฌํ•œ๋‹ค๋Š” ๊ฒƒ์ด๋‹ค.
ํ”ผ๋ณด๋‚˜์น˜ ์ˆ˜์—ด์˜ Call Tree ( ์ƒํƒœ ๊ณต๊ฐ„ ํŠธ๋ฆฌ )


์ด ์‚ฌ์ง„์€ ์ˆ˜๊ฐ€ ์ ์–ด์„œ ์ค‘๋ณต์ด ์ ์–ด ๋ณด์ด์ง€๋งŒ ์ˆ˜๊ฐ€ ํฌ๋‹ค๋ฉด ์ค‘๋ณต์˜ ๋นˆ๋„๋Š” ๋” ๋งŽ์•„์งˆ ๊ฒƒ์ด๋‹ค.

-ยป ์ด ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•  ๋ฐฉ๋ฒ•์€ ๋ฉ”๋ชจ์ด์ œ์ด์…˜ !!

๋ฉ”๋ชจ์ด์ œ์ด์…˜ ( memoization ) ์ด๋ž€ ๋ฌด์—‡์ธ๊ฐ€?

static int fibo1(int n){
    if(n >= 2 && memo[n] == 0){
        memo[n] = fibo[n-1] + fibo[n-2];
    }
    return memo[n];
}
  • ๊ณ ๋ คํ•ด์•ผํ•  ์ 
    • ์ถ”๊ฐ€์ ์ธ ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„์ด ํ•„์š”ํ•˜๋‹ค
    • ์žฌ๊ท€ ํ•จ์ˆ˜ ํ˜ธ์ถœ๋กœ ์ธํ•œ ์‹œ์Šคํ…œ ํ˜ธ์ถœ ์Šคํƒ์„ ์‚ฌ์šฉํ•˜๊ฒŒ ๋˜๊ณ  ์‹คํ–‰ ์†๋„ ์ €ํ•˜ ๋˜๋Š” ์˜ค๋ฒ„ํ”Œ๋กœ์šฐ๊ฐ€ ๋ฐœ์ƒํ•  ์ˆ˜ ์žˆ๋‹ค.
    • ์ˆœ์ˆ˜ํ•จ์ˆ˜ ์ผ ๋•Œ๋งŒ ๋ฉ”๋ชจ์ด์ œ์ด์…˜์„ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.
      • ์ˆœ์ˆ˜ํ•จ์ˆ˜๋ž€ ๊ฐ™์€ ๊ฐ’์„ ๋„ฃ์„ ๋•Œ ๊ฐ™์€ ๊ฐ’๋งŒ์„ ์ถœ๋ ฅํ•˜๋Š” ๊ฒƒ ( ๋„ฃ์„๋•Œ๋งˆ๋‹ค ๊ฐ’์ด ๋ณ€ํ•˜๋ฉด ์•ˆ๋œ๋‹ค )
    • ์•Œ๊ณ ๋ฆฌ์ฆ˜ ๋ฌธ์ œํ’€ ๋•Œ dp ์ ํ™”์‹์œผ๋กœ ๋ชปํ’€๊ฒ ๋Š” ๊ฒฝ์šฐ ๋ฉ”๋ชจ์ด์ œ์ด์…˜ํ•ด๋„ ํ’€๋ฆฌ๋Š” ๊ฒฝ์šฐ๊ฐ€ ๋งŽ๋‹ค.
    • ์ผ๋ฐ˜ ์žฌ๊ท€ -> ์žฌ๊ท€ ( ๋ฉ”๋ชจ์ด์ œ์ด์…˜, ํ•˜ํ–ฅ์‹ ) -> DP ( ๋ฉ”๋ชจ์ด์ œ์ด์…˜, ์ƒํ–ฅ์‹ ( ์ ํ™”์‹, for ) ) -> ์ˆ˜ํ•™์ผ๋ฐ˜ํ•ญ

๋™์  ๊ณ„ํš๋ฒ• ( Dynamic Programming ) ์ด๋ž€ ๋ฌด์—‡์ธ๊ฐ€?

  • ๋™์ ๊ณ„ํš๋ฒ• ( Dynamic Programming ) ์€ ๊ทธ๋ฆฌ๋”” ์•Œ๊ณ ๋ฆฌ์ฆ˜๊ณผ ๊ฐ™์ด ์ตœ์ ํ™” ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•˜๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด๋‹ค.

  • ๋™์  ๊ณ„ํš๋ฒ•์€ ๋จผ์ € ์ž‘์€ ๋ถ€๋ถ„ ๋ฌธ์ œ๋“ค์˜ ํ•ด๋“ค์„ ๊ตฌํ•˜๊ณ  ์ด๋“ค์„ ์ด์šฉํ•˜์—ฌ ๋ณด๋‹ค ํฐ ํฌ๊ธฐ์˜ ๋ถ€๋ถ„ ๋ฌธ์ œ๋“ค์„ ํ•ด๊ฒฐํ•˜์—ฌ ์ตœ์ข…์ ์œผ๋กœ ์›๋ž˜ ์ฃผ์–ด์ง„ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•˜๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜ ์„ค๊ณ„ ๊ธฐ๋ฒ•์ด๋‹ค.


๋™์  ๊ณ„ํš๋ฒ• ( Dynamic Programming ) ์ด ๊ฐ€์ง€๊ณ  ์žˆ์–ด์•ผ ํ•˜๋Š” 2๊ฐ€์ง€ ์š”๊ฑด

๋™์  ๊ณ„ํš๋ฒ• ( Dynamic Programming ) ๊ณผ ๋ถ„ํ• ์ •๋ณต ๋น„๊ต

  • DP
    • ๋ถ€๋ถ„ ๋ฌธ์ œ๋“ค์ด ์—ฐ๊ด€์ด ์—†์œผ๋ฉด ์ ์šฉ ๋ถˆ๊ฐ€.
    • ๋ชจ๋“  ๋ถ€๋ถ„ ๋ฌธ์ œ๋ฅผ ํ•œ๋ฒˆ๋งŒ ๊ณ„์‚ฐํ•˜๊ณ  ๊ฒฐ๊ณผ๋ฅผ ์ €์žฅํ•˜์—ฌ ์‚ฌ์šฉํ•œ๋‹ค.
    • ์ƒํ–ฅ์‹ ๋ฐฉ๋ฒ•


  • ๋ถ„ํ• ์ •๋ณต
    • ์—ฐ๊ด€ ์—†๋Š” ๋ถ€๋ถ„ ๋ฌธ์ œ๋กœ ๋ถ„ํ•  ํ•œ๋‹ค.
    • ๋ถ€๋ถ„๋ฌธ์ œ๋ฅผ ์žฌ๊ท€์ ์œผ๋กœ ํ•ด๊ฒฐํ•œ๋‹ค.
    • ๋ถ€๋ถ„๋ฌธ์ œ์˜ ํ•ด๋ฅผ ๊ฒฐํ•ฉํ•œ๋‹ค.
    • ํ•˜ํ–ฅ์‹ ๋ฐฉ๋ฒ•
    • ์˜ˆ ) ๋ณ‘ํ•ฉ ์ •๋ ฌ, ํ€ต ์ •๋ ฌ


๋™์  ๊ณ„ํš๋ฒ• ( Dynamic Programming ) ์ ์šฉ ์ ‘๊ทผ ๋ฐฉ๋ฒ•

  1. ์ตœ์ ํ•ด ๊ตฌ์กฐ์˜ ํŠน์„ฑ์„ ํŒŒ์•…ํ•˜๋ผ
    • ๋ฌธ์ œ๋ฅผ ๋ถ€๋ถ„ ๋ฌธ์ œ๋กœ ๋‚˜๋ˆˆ๋‹ค.
  2. ์ตœ์ ํ•ด์˜ ๊ฐ’์„ ์žฌ๊ท€์ ์œผ๋กœ ์ •์˜ํ•˜๋ผ
    • ๋ถ€๋ถ„ ๋ฌธ์ œ์˜ ์ตœ์ ํ•ด ๊ฐ’์— ๊ธฐ๋ฐ˜ํ•˜์—ฌ ๋ฌธ์ œ์˜ ์ตœ์ ํ•ด ๊ฐ’์„ ์ •์˜ํ•œ๋‹ค.
  3. ์ƒํ–ฅ์‹ ๋ฐฉ๋ฒ•์œผ๋กœ ์ตœ์ ํ•ด์˜ ๊ฐ’์„ ๊ณ„์‚ฐํ•˜๋ผ
    • ๊ฐ€์žฅ ์ž‘์€ ๋ถ€๋ถ„ ๋ฌธ์ œ๋ถ€ํ„ฐ ํ•ด๋ฅผ ๊ตฌํ•œ ๋’ค ํ…Œ์ด๋ธ”์— ์ €์žฅํ•œ๋‹ค. ( ๋ฉ”๋ชจ์ด์ œ์ด์…˜ )
    • ํ…Œ์ด๋ธ”์— ์ €์žฅ๋˜์–ด ์žˆ๋Š” ๋ถ€๋ถ„ ๋ฌธ์ œ์˜ ํ•ด๋ฅผ ์ด์šฉํ•˜์—ฌ ์ ์ฐจ์ ์œผ๋กœ ์ƒ์œ„ ๋ถ€๋ถ„ ๋ฌธ์ œ์˜ ์ตœ์ ํ•ด๋ฅผ ๊ตฌํ•œ๋‹ค. ( ์ƒํ–ฅ์‹ ๋ฐฉ๋ฒ• )



ํ”ผ๋ณด๋‚˜์น˜ ์ˆ˜ DP ์ ์šฉ

  • ํ”ผ๋ณด๋‚˜์น˜ ์ˆ˜๋Š” ๋ถ€๋ถ„ ๋ฌธ์ œ์˜ ๋‹ต์œผ๋กœ๋ถ€ํ„ฐ ๋ณธ ๋ฌธ์ œ์˜ ๋‹ต์„ ์–ป์„ ์ˆ˜ ์žˆ์œผ๋ฏ€๋กœ ์ตœ์  ๋ถ€๋ถ„ ๊ตฌ์กฐ๋กœ ์ด๋ฃจ์–ด์ ธ ์žˆ๋‹ค.
  1. ๋ฌธ์ œ๋ฅผ ๋ถ€๋ถ„ ๋ฌธ์ œ๋กœ ๋ถ„ํ• ํ•œ๋‹ค.
  2. ์ ํ™”์‹์œผ๋กœ ์ •์˜ํ•œ๋‹ค.
  3. ๊ฐ€์žฅ ์ž‘์€ ๋ถ€๋ถ„ ๋ฌธ์ œ๋ถ€ํ„ฐ ํ•ด๋ฅผ ๊ตฌํ•œ๋‹ค. ๊ฒฐ๊ณผ๋Š” ํ…Œ์ด๋ธ”์— ์ €์žฅํ•˜๊ณ  ํ…Œ์ด๋ธ”์— ์ €์žฅ๋œ ๋ถ€๋ถ„ ๋ฌธ์ œ์˜ ํ•ด๋ฅผ ์ด์šฉํ•˜์—ฌ ์ƒ์œ„ ๋ฌธ์ œ์˜ ํ•ด๋ฅผ ๊ตฌํ•œ๋‹ค.
    ํ”ผ๋ณด๋‚˜์น˜ DP ์ ์šฉ ์•Œ๊ณ ๋ฆฌ์ฆ˜
    static int fibo_dp(int n){
        dp[0] = 0;
        dp[1] = 1;
        for(int i=2; i<N; i++){
            dp[i] = dp[i-1] + dp[i-2];
        }
        return dp[i];
    }


ํ”ผ๋ณด๋‚˜์น˜ ์ˆ˜ ๊ตฌํ•˜๊ธฐ - DP ์•Œ๊ณ ๋ฆฌ์ฆ˜ ๋ถ„์„

  • DP ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด ์ˆ˜ํ–‰์†๋„๊ฐ€ ๋” ๋น ๋ฅด๋‹ค
  • ์ด์œ 
    • ์žฌ๊ท€ ์•Œ๊ณ ๋ฆฌ์ฆ˜๊ณผ๋Š” ๋‹ฌ๋ฆฌ ์ค‘๋ณต ๊ณ„์‚ฐ์ด ์—†๋‹ค
    • ๋˜ํ•œ ๋ฐ˜๋ณต๋ฌธ์„ ์‚ฌ์šฉํ•˜๊ธฐ ๋•Œ๋ฌธ์— ํ•จ์ˆ˜ ํ˜ธ์ถœ์ด ๋ฐœ์ƒํ•˜์ง€ ์•Š๋Š”๋‹ค.
  • ๊ณ„์‚ฐํ•˜๋Š” ํ•ญ์˜ ์ด ๊ฐœ์ˆ˜
    • n+1 ๊ฐœ์ˆ˜์˜ ํ•ญ ๊ณ„์‚ฐ
    • ์ฆ‰ fibo[0] ~ fibo[n] ๊นŒ์ง€ ๋‹จ ํ•œ๋ฒˆ์”ฉ๋งŒ ๊ณ„์‚ฐ