๐Ÿ‘ฉโ€๐ŸŽ“๊ณต๋ถ€ - 2024.01.25 ์˜ค๋Š˜์˜ ์ฝ”๋”ฉ๊ณต๋ถ€

์œ ๋ น๊ฐœยท2024๋…„ 1์›” 25์ผ
0

PS-์•Œ๊ณ ๋ฆฌ์ฆ˜2

๋ชฉ๋ก ๋ณด๊ธฐ
20/34
post-thumbnail

11726๋ฒˆ - 2*N ํƒ€์ผ๋ง


๋ถ„์„


์ด๋Ÿฐ ๋ฌธ์ œ์ž…๋‹ˆ๋‹ค.

2xn์ด๋ผ๋Š” ์ด ๊ณต๊ฐ„์ด ์ฃผ์–ด์กŒ์„ ๋•Œ 1x2ํƒ€์ผ๊ณผ 2x1ํƒ€์ผ์„ ์ด์šฉํ•ด์„œ ์ด ๊ณต๊ฐ„์„ ์ฑ„์šธ ์ˆ˜ ์žˆ๋Š” ๊ฒฝ์šฐ์˜ ์ˆ˜๋ฅผ ๊ตฌํ•˜๋ฉด ๋˜๋Š” ๋ฌธ์ œ์ž…๋‹ˆ๋‹ค.


์ด๋Ÿฐ ๊ฒฝ์šฐ ๋‘ ๊ฐ€์ง€ ์œ ํ˜•์œผ๋กœ ๋‚˜๋ˆŒ ์ˆ˜ ์žˆ๋Š”๋ฐ
๋จผ์ € ํƒ€์ผ์ด 1x2ํƒ€์ผ๋กœ ๋๋‚˜๋Š” ๊ฒฝ์šฐ ์™€ ํƒ€์ผ์ด 2x1 ํƒ€์ผ๋กœ ๋๋‚˜๋Š” ๊ฒฝ์šฐ์ž…๋‹ˆ๋‹ค.
๋”ฐ๋ผ์„œ ์ ํ™”์‹์€ DP(N) = DP(N-1) + DP(N-2)๋ผ๋Š” ํ˜•ํƒœ๋กœ ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.


์ฝ”๋”ฉ

N = int(input())
print(dp(N)%10007)

์ž…๋ ฅ์„ ๋ฐ›๊ณ  ํฐ๊ฐ’์ด ๋‚˜์˜ค๋‹ˆ๊นŒ ํ•ด๋ฅผ 10007๋กœ ๋‚˜๋ˆ„๋ผ ํ–ˆ์œผ๋ฏ€๋กœ ๋ฌธ์ œ๋Œ€๋กœ ๋”ฐ๋ผ์ค๋‹ˆ๋‹ค.

memo = [0] * 1001
def dp(n):
    if n == 1:
        return 1
    if n == 2:
        return 2

์ตœ๋Œ€ ๊ฐ’์ด 1000์ด๋ฏ€๋กœ ๋ฉ”๋ชจ์ด์ œ์ด์…˜ ํฌ๊ธฐ๋Š” 1001๋กœ ์„ค์ •ํ•ด์ฃผ๊ฒ ์Šต๋‹ˆ๋‹ค.
1์ธ ๊ฒฝ์šฐ 1๊ฐ€์ง€ ๊ฒฝ์šฐ๋ฐ–์— ์•ˆ๋˜๋ฏ€๋กœ 1 return, 2์ธ๊ฒฝ์šฐ 2๊ฐ€์ง€ ๊ฒฝ์šฐ๋ฐ–์— ์•ˆ๋˜๋ฏ€๋กœ 2 return ํ•˜๊ณ 

    if memo[n]:
        return memo[n]

๋ฉ”๋ชจ์ด์ œ์ด์…˜์— ๋ฐ์ดํ„ฐ๊ฐ€ ์กด์žฌํ•  ๊ฒฝ์šฐ ํ•ด๋‹น ๋ฐ์ดํ„ฐ๋ฅผ return

    memo[n] = dp(n-1) + dp(n-2)
    return memo[n]

์•„๊นŒ ๋„์ถœํ•œ ์ ํ™”์‹์„ return ํ•ด์ฃผ๋ฉด ์ตœ์ข…์ ์œผ๋กœ DP๋ฅผ ํ™œ์šฉํ•ด ๋ฌธ์ œํ’€์ด๊ฐ€ ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.




11727๋ฒˆ - 2*N ํƒ€์ผ๋ง 2

์œ„ ๋ฌธ์ œ๋ฅผ ์‘์šฉํ•œ ๋ฌธ์ œ์ž…๋‹ˆ๋‹ค.
์ด๋ฒˆ์—” 2x2 ํƒ€์ผ์ด ํ•˜๋‚˜ ์ถ”๊ฐ€๋ฌ๋„ค์š”.
์ดˆ๊ธฐ๊ฐ’ํ•˜๊ณ  ์ ํ™”์‹๋งŒ ์กฐ๊ธˆ ๋ฐ”๊ฟ”์ฃผ๋ฉด ๋ ๋“ฏ ์‹ถ์Šต๋‹ˆ๋‹ค.

N = int(input())
print(dp(N)%10007)

N์„ ์ž…๋ ฅ๋ฐ›๊ณ 

memo = [0] * 1001
def dp(n):
    if n == 1:
        return 1
    if n == 2:
        return 3

๊ธธ์ด๊ฐ€ 2์ผ๋•Œ 2x2ํƒ€์ผ ํ•˜๋‚˜, 1x2ํƒ€์ผ 2๋ฒˆ, 2x1ํƒ€์ผ 2๋ฒˆ ์ด 3๋ฒˆ์œผ๋กœ ๋งŒ๋“ค์ˆ˜ ์žˆ๊ธฐ ๋•Œ๋ฌธ์— 3์œผ๋กœ ์ดˆ๊ธฐํ™”๋ฅผ ์ง„ํ–‰ํ•ด์ค์‹œ๋‹ค.

    if memo[n]:
        return memo[n]
    memo[n] = dp(n-1) + dp(n-2) + dp(n-2)
    return memo[n]

๊ทธ๋ฆฌ๊ณ  ๋งˆ์ง€๋ง‰ ๋ถ€๋ถ„์— 2x2ํƒ€์ผ๋„ ์˜ฌ ์ˆ˜ ์žˆ์œผ๋ฏ€๋กœ dp(n-2)๋ฅผ ํ•˜๋‚˜ ๋” ์ถ”๊ฐ€ํ•˜๋ฉด ์ •๋‹ต์„ ๋„์ถœํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.


2133๋ฒˆ - ํƒ€์ผ ์ฑ„์šฐ๊ธฐ

ํƒ€์ผ ์ฑ„์šฐ๊ธฐ ๋ํŒ์™• ๋ฌธ์ œ์ž…๋‹ˆ๋‹ค.
์ด๋ฒˆ์—๋Š” ํฌ๊ธฐ๊ฐ€ 3xN์ธ ๋ฒฝ์„ 1x2, 2x1 ํƒ€์ผ๋กœ ์ฑ„์šฐ๋Š” ๋ฐฉ๋ฒ•์„ ๊ณ„์‚ฐํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.


๋ถ„์„

1. ํƒ€์ผ ๊ฐ’ ์„ ์–ธ

ํƒ€์ผ์„ ์ฑ„์šฐ๊ธฐ ์‹œ์ž‘ํ•˜๋Š” ๋ถ€๋ถ„(์ดˆ๊ธฐํ™”๊ฐ’)๋ถ€ํ„ฐ ํ•œ๋ฒˆ ์‚ดํŽด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.
์ผ๋‹จ ๊ณต๊ฐ„์ด 1์ธ ๊ฒฝ์šฐ์—๋Š” ํƒ€์ผ์„ ์„ธ์›Œ์„œ ๊ณต๊ฐ„์„ ๋ชป๋งŒ๋“ญ๋‹ˆ๋‹ค!
๊ทธ๋ฆฌ๊ณ  ๊ณต๊ฐ„์ด 2์ธ ๊ฒฝ์šฐ์—๋Š”

์ด๋ ‡๊ฒŒ 3๊ฐœ์˜ ๊ฒฝ์šฐ๋กœ ์Šคํƒ€ํŠธ๋ฅผ ๋Š์„ ์ˆ˜ ์žˆ๊ฒ ์Šต๋‹ˆ๋‹ค.
๊ทธ๋ฆฌ๊ณ  ์ œ๊ฐ€ ํ•˜๋‚˜ ๊ฐ„๊ณผํ–ˆ๋˜ ์ ์ด ์žˆ๋Š”๋ฐ GPTํ•œํ…Œ ๋ฌผ์–ด๋ณด๋‹ˆ ๋ช…์พŒํ•œ ํ•ด๋‹ต์„ ๋‚ด๋†“๋”๊ตฐ์š”.

๊ทธ๊ฑด ๋ฐ”๋กœ ๊ณต๊ฐ„์ด 0์ธ ๊ฒฝ์šฐ๋„ ํ•˜๋‚˜์˜ ๊ฒฝ์šฐ์˜ ์ˆ˜๋กœ ์ทจ๊ธ‰๋˜์–ด 1๋กœ ์Šคํƒ€ํŠธ๋ฅผ ๋Š์„ ์ˆ˜ ์žˆ๋‹ค๋Š” ๊ฒ๋‹ˆ๋‹ค!
์ด์ œ ์ด๊ฑธ ์ฝ”๋“œ๋กœ ํ‘œํ˜„ํ•˜๋ฉด

    if n == 0:
        return 1
    if n == 1:
        return 0
    if n == 2:
        return 3

์ด๋Ÿฐ ๋Š๋‚Œ์œผ๋กœ ์ดˆ๊ธฐ๊ฐ’์„ ์„ ์–ธํ•˜๊ณ  ์‹œ์ž‘ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

2. ํƒ€์ผ์„ ๋๋งบ์„ ๋•Œ ๊ฒฝ์šฐ์˜ ์ˆ˜

์ด๊ฒŒ ์ข€ ๋ณต์žกํ•ฉ๋‹ˆ๋‹ค.
์ผ๋‹จ ์œ„์˜ ์˜ˆ์‹œ์ฒ˜๋Ÿผ 2์นธ๋งŒ ๋‚จ์•˜์„ ๋•Œ๋Š” 3 X DP(N-2) ๊ฐ’์œผ๋กœ ์ ํ™”์‹์„ ์„ธ์šฐ๋Š” ๊ฒŒ ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.

๊ทธ๋Ÿฐ๋ฐ ์ด์ œ ์ œ๊ฐ€ ๊ทธ๋ ค๋‘” ์˜ค๋ฅธ์ชฝ ์˜ˆ์‹œ๋ฅผ ๋ณด์‹œ๋ฉด 2XDP(N-์ง์ˆ˜) ๋งŒํผ ๊ณ„์†ํ•ด์„œ ์ ํ™”์‹์„ ์„ธ์šฐ๋Š” ๊ฒŒ ๊ฐ€๋Šฅํ•˜์—ฌ ๊ฒฐ๊ณผ์ ์œผ๋กœ N-i๊ฐ€ 0์ด ๋ ๋•Œ๊นŒ์ง€ ์ ํ™”์‹์„ ์„ธ์šฐ๋Š” ๊ฒŒ ๊ฐ€๋Šฅํ•ด์ง‘๋‹ˆ๋‹ค...

For๋ฌธ์„ ์‚ฌ์šฉํ•˜์—ฌ N-i๊ฐ€ 0์ด ๋ ๋•Œ๊นŒ์ง€ ์ ํ™”์‹์„ ์„ธ์šฐ๊ณ  ๋ฉ”๋ชจ์ด์ œ์ด์…˜์— ์ถ”๊ฐ€ํ•ด์ฃผ๋Š” ๋ฐฉ์‹์œผ๋กœ ์ฝ”๋”ฉํ•ด์•ผ ๋ฌธ์ œํ’€์ด๊ฐ€ ๊ฐ€๋Šฅํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.


์ฝ”๋”ฉ

N = int(input())
print(dp(N))

N ์ž…๋ ฅ์„ ๋ฐ›์•„์ฃผ๊ณ  dp(N)์„ ์‹คํ–‰์‹œ์ผœ์ค๋‹ˆ๋‹ค.

memo = [0] * 1001
def dp(n):  
    tmp = 0

    if n == 0:
        return 1
    if n == 1:
        return 0
    if n == 2:
        return 3

๋ฉ”๋ชจ์ด์ œ์ด์…˜์„ ํ•˜๋‚˜ ๋งŒ๋“ค์–ด์ฃผ๊ณ  ์œ„์— ๋ถ„์„์ฒ˜๋Ÿผ ์‹œ์ž‘ ํฌ๊ธฐ์— ์•Œ๋งž๊ฒŒ return ๊ฐ’์„ ๋Œ€์ž…ํ•ด์ค์‹œ๋‹ค.

    if memo[n]:
        return memo[n]

๋ฉ”๋ชจ์ด์ œ์ด์…˜์— ์žˆ๋Š” ๊ฐ’์ด๋ฉด ํ•ด๋‹น ๋ฉ”๋ชจ๋กœ ๊ฐ’์„ return ํ•ด์ฃผ๊ณ 

    tmp = 3 * dp(n-2)

์—†๋Š” ๊ฐ’์ด๋ฉด ์ผ๋‹จ 2์นธ ๋‚จ์•˜์„ ๊ฒฝ์šฐ์˜ ์ ํ™”์‹์„ ์„ธ์šฐ๊ณ  ํ•ด๋‹น ๊ฐ’์„ tmp์— ์ถ”๊ฐ€์‹œํ‚ค๊ฒ ์Šต๋‹ˆ๋‹ค.

    for i in range(3,n+1):
        if i%2 == 0:
            memo[n] += 2 * dp(n-i)

ํ•ต์‹ฌ ๋ถ€๋ถ„์ž…๋‹ˆ๋‹ค.

4์นธ ์ด์ƒ์˜ ์ง์ˆ˜์นธ์ด ๋‚จ์•˜์„ ๊ฒฝ์šฐ์—๋Š” 2 X DP( N - ๋ฐ˜๋ณต๋ฌธ๋ณ€์ˆ˜)๋ผ๋Š” ์ ํ™”์‹์„ 0์ด ๋˜๊ธฐ ์ „๊นŒ์ง€ ๊ณ„์†ํ•ด์„œ ๋Œ๋ ค์ค๋‹ˆ๋‹ค.

ํ•ด๋‹น ๋ถ€๋ถ„์€ 4์นธ,6์นธ,8์นธ...๊ณ„์†ํ•ด์„œ N ์ „๊นŒ์ง€ ๊ฒฝ์šฐ์˜ ์ˆ˜๊ฐ€ ๋Š˜์–ด๋‚  ์—ฌ์ง€๊ฐ€ ์žˆ๊ธฐ ๋•Œ๋ฌธ์— for๋ฌธ์•ˆ์— ์ ํ™”์‹์„ ๋„ฃ์–ด ์ฒ˜๋ฆฌํ•ด์ฃผ๋„๋ก ํ•ฉ์‹œ๋‹ค.

    return memo[n]

๋งˆ์ง€๋ง‰์œผ๋กœ return ๋ฉ”๋ชจ์ด์ œ์ด์…˜์„ ํ•˜๋ฉด ์ •๋‹ต์„ ๋„์ถœํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.




profile
ํ•œ๋ฆผ๋Œ€ํ•™๊ต ์ •๋ณด๊ณผํ•™๋Œ€ 2ํ•™๋…„ ์žฌํ•™์ค‘ / ์œก๊ตฐ ์ •๋ณด๋ณดํ˜ธ๋ณ‘ 22-2๊ธฐ

0๊ฐœ์˜ ๋Œ“๊ธ€