2164 : ์นด๋“œ2

2164 : ์นด๋“œ2#

์‹œ๊ฐ„์ œํ•œ

๋ฉ”๋ชจ๋ฆฌ์ œํ•œ

์ •๋‹ต๋น„์œจ

2์ดˆ

128MB

50.9%

input#

N์žฅ์˜ ์นด๋“œ๊ฐ€ ์žˆ๋‹ค.
๊ฐ๊ฐ์˜ ์นด๋“œ๋Š” ์ฐจ๋ก€๋กœ 1๋ถ€ํ„ฐ N๊นŒ์ง€์˜ ๋ฒˆํ˜ธ๊ฐ€ ๋ถ™์–ด ์žˆ์œผ๋ฉฐ,
1๋ฒˆ ์นด๋“œ๊ฐ€ ์ œ์ผ ์œ„์—, N๋ฒˆ ์นด๋“œ๊ฐ€ ์ œ์ผ ์•„๋ž˜์ธ ์ƒํƒœ๋กœ ์ˆœ์„œ๋Œ€๋กœ ์นด๋“œ๊ฐ€ ๋†“์—ฌ ์žˆ๋‹ค.

์ด์ œ ๋‹ค์Œ๊ณผ ๊ฐ™์€ ๋™์ž‘์„ ์นด๋“œ๊ฐ€ ํ•œ ์žฅ ๋‚จ์„ ๋•Œ๊นŒ์ง€ ๋ฐ˜๋ณตํ•˜๊ฒŒ ๋œ๋‹ค.
์šฐ์„ , ์ œ์ผ ์œ„์— ์žˆ๋Š” ์นด๋“œ๋ฅผ ๋ฐ”๋‹ฅ์— ๋ฒ„๋ฆฐ๋‹ค.
๊ทธ ๋‹ค์Œ, ์ œ์ผ ์œ„์— ์žˆ๋Š” ์นด๋“œ๋ฅผ ์ œ์ผ ์•„๋ž˜์— ์žˆ๋Š” ์นด๋“œ ๋ฐ‘์œผ๋กœ ์˜ฎ๊ธด๋‹ค.

์˜ˆ๋ฅผ ๋“ค์–ด N=4์ธ ๊ฒฝ์šฐ๋ฅผ ์ƒ๊ฐํ•ด ๋ณด์ž.
์นด๋“œ๋Š” ์ œ์ผ ์œ„์—์„œ๋ถ€ํ„ฐ 1234 ์˜ ์ˆœ์„œ๋กœ ๋†“์—ฌ์žˆ๋‹ค.
1์„ ๋ฒ„๋ฆฌ๋ฉด 234๊ฐ€ ๋‚จ๋Š”๋‹ค. ์—ฌ๊ธฐ์„œ 2๋ฅผ ์ œ์ผ ์•„๋ž˜๋กœ ์˜ฎ๊ธฐ๋ฉด 342๊ฐ€ ๋œ๋‹ค.
3์„ ๋ฒ„๋ฆฌ๋ฉด 42๊ฐ€ ๋˜๊ณ , 4๋ฅผ ๋ฐ‘์œผ๋กœ ์˜ฎ๊ธฐ๋ฉด 24๊ฐ€ ๋œ๋‹ค.
๋งˆ์ง€๋ง‰์œผ๋กœ 2๋ฅผ ๋ฒ„๋ฆฌ๊ณ  ๋‚˜๋ฉด, ๋‚จ๋Š” ์นด๋“œ๋Š” 4๊ฐ€ ๋œ๋‹ค.

N์ด ์ฃผ์–ด์กŒ์„ ๋•Œ, ์ œ์ผ ๋งˆ์ง€๋ง‰์— ๋‚จ๊ฒŒ ๋˜๋Š” ์นด๋“œ๋ฅผ ๊ตฌํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜์‹œ์˜ค.
1<=N<=500,000 6->4

from collections import deque
import os, sys


def step1(dq):
    dq.popleft()
    return dq

def step2(dq):
    dq.rotate(-1)
    return dq

problem_num = 2164
path = os.getcwd() + f'\\txt\\{problem_num}'  + '.txt'
sys.stdin = open(path,'r')
input = sys.stdin.readline()
n = int(input)
n_dq = deque([i for i in range(1,n+1)])
while len(n_dq) != 1:
    n_dq = step1(n_dq)
    n_dq = step2(n_dq)
print(*n_dq)

if n_dq[0] == 4:
    print('right')
else:
    print('wrong')
4
right

Deque : double-ended queue#

from collections import deque
dq = deque()
dq.append([i for i in range(n)])
  • ์Šค๋ ˆ๋“œ ์•ˆ์ „ํ•˜๊ณ  ๋ฉ”๋ชจ๋ฆฌ ํšจ์œจ์ ์ธ ๋ฐํฌ์˜ ์–‘์ชฝ ๋์—์„œ์˜ ์ถ”๊ฐ€(append)์™€ ํŒ(pop)์„ ์–‘์ชฝ์—์„œ ๊ฑฐ์˜ ๊ฐ™์€ O(1) ์„ฑ๋Šฅ์œผ๋กœ ์ง€์›ํ•œ๋‹ค. ์ผ๋ฐ˜์ ์ธ ๋ฆฌ์ŠคํŠธ๋Š” O(n) ๋ฉ”๋ชจ๋ฆฌ ์ด๋™ ๋น„์šฉ

  • max len์ด ์ง€์ •๋˜์–ด ์žˆ์œผ๋ฉด ํ•ญ๋ชฉ์ด ์ถ”๊ฐ€๋  ๋•Œ๋งˆ๋‹ค ๋ฐ˜๋Œ€์ชฝ ๋์—์„œ ์‚ญ์ œ๋œ๋‹ค.

  • stack์ฒ˜๋Ÿผ ์‚ฌ์šฉํ• ์ˆ˜๋„ ์žˆ๊ณ , queue์ฒ˜๋Ÿผ ์‚ฌ์šฉํ• ์ˆ˜๋„ ์žˆ๋‹ค.

method

do

append

๋ฐํฌ์˜ ์˜ค๋ฅธ์ชฝ์— x๋ฅผ ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.

appendleft(x)

๋ฐํฌ์˜ ์™ผ์ชฝ์— x๋ฅผ ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.

clear()

๋ฐํฌ์—์„œ ๋ชจ๋“  ์š”์†Œ๋ฅผ ์ œ๊ฑฐํ•˜๊ณ  ๊ธธ์ด๊ฐ€ 0์ธ ์ƒํƒœ๋กœ ๋งŒ๋“ญ๋‹ˆ๋‹ค.

copy()

๋ฐํฌ์˜ ์–•์€ ๋ณต์‚ฌ๋ณธ์„ ๋งŒ๋“ญ๋‹ˆ๋‹ค.

count(x)

x ์™€ ๊ฐ™์€ ๋ฐํฌ ์š”์†Œ์˜ ์ˆ˜๋ฅผ ์…‰๋‹ˆ๋‹ค.

extend(iterable)

iterable ์ธ์ž์—์„œ ์˜จ ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜์—ฌ ๋ฐํฌ์˜ ์˜ค๋ฅธ์ชฝ์„ ํ™•์žฅํ•ฉ๋‹ˆ๋‹ค.

extendleft(iterable)

iterable์—์„œ ์˜จ ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜์—ฌ ๋ฐํฌ์˜ ์™ผ์ชฝ์„ ํ™•์žฅํ•ฉ๋‹ˆ๋‹ค.์ผ๋ จ์˜ ์™ผ์ชฝ ์ถ”๊ฐ€๋Š” iterable ์ธ์ž์— ์žˆ๋Š” ์š”์†Œ์˜ ์ˆœ์„œ๋ฅผ ๋’ค์ง‘๋Š” ๊ฒฐ๊ณผ๋ฅผ ์ค๋‹ˆ๋‹ค.

index(x[, start[, stop]])

๋ฐํฌ์— ์žˆ๋Š” x์˜ ์œ„์น˜๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค (์ธ๋ฑ์Šค start ๋˜๋Š” ๊ทธ ์ดํ›„, ๊ทธ๋ฆฌ๊ณ  ์ธ๋ฑ์Šค stop ์ด์ „). ์ฒซ ๋ฒˆ์งธ ์ผ์น˜๋ฅผ ๋ฐ˜ํ™˜ํ•˜๊ฑฐ๋‚˜ ์ฐพ์„ ์ˆ˜ ์—†์œผ๋ฉด ValueError๋ฅผ ๋ฐœ์ƒ์‹œํ‚ต๋‹ˆ๋‹ค.

insert(i, x)

x๋ฅผ ๋ฐํฌ์˜ i ์œ„์น˜์— ์‚ฝ์ž…ํ•ฉ๋‹ˆ๋‹ค.์‚ฝ์ž…์œผ๋กœ ์ธํ•ด ์ œํ•œ๋œ ๊ธธ์ด์˜ ๋ฐํฌ๊ฐ€ maxlen ์ด์ƒ์œผ๋กœ ์ปค์ง€๋ฉด, IndexError๊ฐ€ ๋ฐœ์ƒํ•ฉ๋‹ˆ๋‹ค.

pop()

๋ฐํฌ์˜ ์˜ค๋ฅธ์ชฝ์—์„œ ์š”์†Œ๋ฅผ ์ œ๊ฑฐํ•˜๊ณ  ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ์š”์†Œ๊ฐ€ ์—†์œผ๋ฉด, IndexError๋ฅผ ๋ฐœ์ƒ์‹œํ‚ต๋‹ˆ๋‹ค.

popleft()

๋ฐํฌ์˜ ์™ผ์ชฝ์—์„œ ์š”์†Œ๋ฅผ ์ œ๊ฑฐํ•˜๊ณ  ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ์š”์†Œ๊ฐ€ ์—†์œผ๋ฉด, IndexError๋ฅผ ๋ฐœ์ƒ์‹œํ‚ต๋‹ˆ๋‹ค.

remove(value)

value์˜ ์ฒซ ๋ฒˆ์งธ ํ•ญ๋ชฉ์„ ์ œ๊ฑฐํ•ฉ๋‹ˆ๋‹ค. ์ฐพ์„ ์ˆ˜ ์—†์œผ๋ฉด, ValueError๋ฅผ ๋ฐœ์ƒ์‹œํ‚ต๋‹ˆ๋‹ค.

reverse()

๋ฐํฌ์˜ ์š”์†Œ๋“ค์„ ์ œ์ž๋ฆฌ์—์„œ ์ˆœ์„œ๋ฅผ ๋’ค์ง‘๊ณ  None์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

rotate(n=1)

๋ฐํฌ๋ฅผ n ๋‹จ๊ณ„ ์˜ค๋ฅธ์ชฝ์œผ๋กœ ํšŒ์ „ํ•ฉ๋‹ˆ๋‹ค. n์ด ์Œ์ˆ˜์ด๋ฉด, ์™ผ์ชฝ์œผ๋กœ ํšŒ์ „ํ•ฉ๋‹ˆ๋‹ค.๋ฐํฌ๊ฐ€ ๋น„์–ด ์žˆ์ง€ ์•Š์œผ๋ฉด, ์˜ค๋ฅธ์ชฝ์œผ๋กœ ํ•œ ๋‹จ๊ณ„ ํšŒ์ „ํ•˜๋Š” ๊ฒƒ์€ d.appendleft(d.pop())๊ณผ ๋™๋“ฑํ•˜๊ณ , ์™ผ์ชฝ์œผ๋กœ ํ•œ ๋‹จ๊ณ„ ํšŒ์ „ํ•˜๋Š” ๊ฒƒ์€ d.append(d.popleft())์™€ ๋™๋“ฑํ•ฉ๋‹ˆ๋‹ค.

maxlen

(attribute)๋ฐํฌ์˜ ์ตœ๋Œ€ ํฌ๊ธฐ ๋˜๋Š” ์ œํ•œ์ด ์—†์œผ๋ฉด None.