728x90
반응형

문제:

이번 계절학기에 심리학 개론을 수강 중인 평석이는 오늘 자정까지 보고서를 제출해야 한다. 보고서 작성이 너무 지루했던 평석이는 노트북에 엎드려서 꾸벅꾸벅 졸다가 제출 마감 1시간 전에 깨고 말았다. 안타깝게도 자는 동안 키보드가 잘못 눌려서 보고서의 모든 글자가 A와 B로 바뀌어 버렸다! 그래서 평석이는 보고서 작성을 때려치우고 보고서에서 '좋은 단어'나 세보기로 마음 먹었다.

평석이는 단어 위로 아치형 곡선을 그어 같은 글자끼리(A는 A끼리, B는 B끼리) 쌍을 짓기로 하였다. 만약 선끼리 교차하지 않으면서 각 글자를 정확히 한 개의 다른 위치에 있는 같은 글자와 짝 지을수 있다면, 그 단어는 '좋은 단어'이다. 평석이가 '좋은 단어' 개수를 세는 것을 도와주자.

입력:

첫째 줄에 단어의 수 N이 주어진다. (1 ≤ N ≤ 100)

다음 N개 줄에는 A와 B로만 이루어진 단어가 한 줄에 하나씩 주어진다. 단어의 길이는 2와 100,000사이이며, 모든 단어 길이의 합은 1,000,000을 넘지 않는다.

출력:

첫째 줄에 좋은 단어의 수를 출력한다.

풀이방법:

단어들을 stack에 다음과 같은 규칙을 따르면서 A나 B를 하나씩 넣도록 한다.

 1. stack이 비어있다면 추가한다.

 2. stack의 마지막 값과 같다면 pop을 하고, 다르다면 append한다.

이 과정을 마치고 난 뒤에 stack에 값이 남아 있다면 이는 '좋은 단어'가 아니라는 것을 의미한다. 따라서 stack이 비어있을 때에만 count를 올려주도록 한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
= int(input())
 
answer = 0
for _ in range(n):
    case = input()
    stack = []
    for c in case:
        if not len(stack):
            stack.append(c)
            continue
            
        if stack[-1]==c:
            stack.pop()
        else:
            stack.append(c)
    if len(stack):
        continue
    else:
        answer+=1
        
print(answer)  
cs

문제링크:

https://www.acmicpc.net/problem/3986

 

3986번: 좋은 단어

이번 계절학기에 심리학 개론을 수강 중인 평석이는 오늘 자정까지 보고서를 제출해야 한다. 보고서 작성이 너무 지루했던 평석이는 노트북에 엎드려서 꾸벅꾸벅 졸다가 제출 마감 1시간 전에

www.acmicpc.net

 

728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]2910. 빈도 정렬  (0) 2022.06.30
[BOJ]2828. 사과 담기 게임  (0) 2022.06.28
[BOJ]1940. 주몽  (0) 2022.06.21
[BOJ]1213. 팰린드롬 만들기  (0) 2022.06.16
[BOJ] 9996. 한국이 그리울 땐 서버에 접속하지  (0) 2022.06.14
728x90
반응형

문제:

창영이는 강산이의 비밀번호를 훔치기 위해서 강산이가 사용하는 컴퓨터에 키로거를 설치했다. 며칠을 기다린 끝에 창영이는 강산이가 비밀번호 창에 입력하는 글자를 얻어냈다.

키로거는 사용자가 키보드를 누른 명령을 모두 기록한다. 따라서, 강산이가 비밀번호를 입력할 때, 화살표나 백스페이스를 입력해도 정확한 비밀번호를 알아낼 수 있다.

강산이가 비밀번호 창에서 입력한 키가 주어졌을 때, 강산이의 비밀번호를 알아내는 프로그램을 작성하시오.

입력:

첫째 줄에 테스트 케이스의 개수가 주어진다. 각 테스트 케이스는 한줄로 이루어져 있고, 강산이가 입력한 순서대로 길이가 L인 문자열이 주어진다. (1 ≤ L의 길이 ≤ 1,000,000) 강산이가 백스페이스를 입력했다면, '-'가 주어진다. 이때 커서의 바로 앞에 글자가 존재한다면, 그 글자를 지운다. 화살표의 입력은 '<'와 '>'로 주어진다. 이때는 커서의 위치를 움직일 수 있다면, 왼쪽 또는 오른쪽으로 1만큼 움직인다. 나머지 문자는 비밀번호의 일부이다. 물론, 나중에 백스페이스를 통해서 지울 수는 있다. 만약 커서의 위치가 줄의 마지막이 아니라면, 커서 및 커서 오른쪽에 있는 모든 문자는 오른쪽으로 한 칸 이동한다.

출력:

각 테스트 케이스에 대해서, 강산이의 비밀번호를 출력한다. 비밀번호의 길이는 항상 0보다 크다.

풀이방법:

 두 개의 스택을 이용해서 "<",  ">", "-"와 같은 특수 문자들을 해결하도록 한다. 

우선 일반적으로는 stack에다가 들어온 값을 저장한다. 그러다가 "<"를 만난다면 왼쪽으로 커서를 이동해야 하므로, stack의 값을 빼서, stack2에 담고, 반대로 ">"를 만난다면 stack2의 값을 빼서 stack에 담도록 한다. "-"는 stack의 값을 제거하면 된다.

 마지막으로 stack2의 값이 남아 있을 수도 있기 때문에, 이 값을 뒤집어 stack과 이어붙이도록 한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
= int(input())
for _  in range(n):
    L = input()
    stack = []
    stack2 = []
    for l in L:
        if l == "<":
            if stack:
                stack2.append(stack.pop())
        elif l == ">":
            if stack2:
                stack.append(stack2.pop())
        elif l == "-":
            if stack:
                stack.pop()
        else:
            stack.append(l)
    stack2.reverse()
    print("".join(stack+stack2))
cs

문제링크:

https://www.acmicpc.net/problem/5397

728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]2589. 보물섬  (0) 2021.07.22
[BOJ]1062. 가르침  (0) 2021.07.20
[BOJ]5557. 1학년  (0) 2021.07.13
[BOJ]10973. 이전 순열  (0) 2021.07.08
[BOJ]16234. 인구 이동  (0) 2021.07.06
728x90
반응형

문제:

크기가 N인 수열 A=A1,A2,...,AN이 있다. 수열의 각 원소 Ai에 대해서 오큰수 NGE(i)를 구하려고 한다. Ai의 오큰수는 오른쪽에 있으면서 Ai보다 큰 수 중에서 가장 왼쪽에 있는 수를 의미한다. 그러한 수가 없는 경우에 오큰수는 -1이다.

 

예를 들어, A = [3,5,2,7]인 경우 NGE(1) = 5, NGE(2) = 7, NGE(3) = 7, NGE(4) = -1이다. A = [9, 5, 4, 8]인 경우에는 NGE(1) = -1, NGE(2) = 8, NGE(3) = 8, NGE(4) = -1이다.

입력:

첫째 줄에 수열 A의 크기 N (1<=N<=1,000,000)이 주어진다. 둘째에 수열 A의 원소 A1,A2,...,AN(1<=Ai<=1,000,000)이 주어진다.

출력:

총 N개의 수 NGE(1), NGE(2),... ,NGE(N)을 공백으로 구분해 출력한다.

풀이방법:

for를 두 번 사용해서 문제를 풀 수 있지만 O(n^2) 시간복잡도로 인해서 시간초과가 발생한다. 따라서 효율적인 방법인 스택을 사용해야 한다.

이와 비슷한 문제들은 수열의 값들을 저장하면서 진행을 하지만, 이 문제는 독특하게 인덱스를 저장하면서 진행한다.

조건에 맞는 오큰수가 없다면 -1을 넣어주어야 하므로, 애초에 크기가 len(A)이고, 값이 -1인 answer 배열을 만들어 준다.

이후에는 배열을 한번 순회할 때, idx의 마지막(top)에 해당하는 값과 반복문의 인덱스값과 비교하고, 이 때, 반복문의 인덱스값이 크다면 idx의 top에 해당하는 값을 인덱스로 해서 answer의 값(answer[idx.pop()])을 반복문의 인덱스(i) 값(A[i])으로 바꿔주도록 한다. 그리고 이는 while로 반복된다.

while이 끝나면 지금 반복문 인덱스를 idx에 넣어준다.

1
2
3
4
5
6
7
8
9
10
= int(input())
= list(map(int,input().split()))
idx = []
answer = [-1 for _ in range(len(A))]
 
for i in range(len(A)):
    while len(idx) and A[idx[-1]] < A[i]:
        answer[idx.pop()] = A[i]
    idx.append(i)
print(*answer)
cs

문제링크:

www.acmicpc.net/problem/17298

 

17298번: 오큰수

첫째 줄에 수열 A의 크기 N (1 ≤ N ≤ 1,000,000)이 주어진다. 둘째에 수열 A의 원소 A1, A2, ..., AN (1 ≤ Ai ≤ 1,000,000)이 주어진다.

www.acmicpc.net

 

728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]10972. 다음 순열  (0) 2020.09.10
[BOJ]9251. LCS  (0) 2020.09.08
[BOJ]16561. 3의 배수  (0) 2020.09.01
[BOJ]10989. 수 정렬하기3  (0) 2020.08.27
[BOJ]11724. 연결 요소의 개수  (0) 2020.08.25
728x90
반응형

문제:

KOI 통신연구소는 레이저를 이용한 새로운 비밀 통신 시스템 개발을 위한 실험을 하고 있다. 실험을 위하여 일직선 위에 N개의 높이가 서로 다른 탑을 수평 직선의 왼쪽부터 오른쪽 방향으로 차례로 세우고, 각 탑의 꼭대기에 레이저 송신기를 설치하였다. 모든 탑의 레이저 송신기는 레이저 신호를 지표면과 평행하게 수평 직선의 왼쪽 방향으로 발사하고, 탑의 기둥 모두에는 레이저 신호를 수신하는 장치가 설치되어 있다. 하나의 탑에서 발사된 레이저 신호는 가장 먼저 만나는 단 하나의 탑에서만 수신이 가능하다.

 

예를 들어 높이가 6, 9, 5, 7, 4인 다섯 개의 탑이 수평 직선에 일렬로 서 있고, 모든 탑에서는 주어진 탑 순서의 반대 방향(왼쪽 방향)으로 동시에 레이저 신호를 발사한다고 하자. 그러면 높이가 4인 다섯 번째 탑에서 발사한 레이저 신호를 높이가 7인 네 번째 탑이 수신을 하고, 높이가 7인 네 번째 탑의 신호는 높이가 9인 두 번째 탑이, 높이가 5인 세 번째 탑의 신호도 높이가 9인 두 번째 탑이 수신을 한다. 높이가 9인 두 번째 탑과 높이가 6인 첫 번째 탑이 보낸 레이저 신호는 어떤 탑에서도 수신을 하지 못한다.

탑들의 개수 N과 탑들의 높이가 주어질 때, 각각의 탑에서 발사한 레이저 신호를 어느 탑에서 수신하는지를 알아내는 프로그램을 작성하라.

입력:

첫째 줄에 탑의 수를 나타내는 정수 N이 주어진다. N은 1이상 500,000 이하이다. 둘째 줄에는 N개의 탑들의 높이가 직선상에 놓인 순서대로 하나의 빈칸을 사이에 두고 주어진다. 탑들의 높이는 1 이상 100,000,000 이하의 정수이다.

출력:

첫째 줄에 주어진 탑들의 순서대로 각각의 탑들에서 발사한 레이저 신호를 탑들의 번호를 하나의 빈칸을 사이에 두고 출력한다. 만약 레이저 신호를 수신하는 탑이 존재하지 않으면 0을 출력한다.

풀이방법:

N이 최대 500,000개 이기 때문에 효율적으로 알고리즘을 구성해야 하고, 따라서 스택 자료 구조를 사용하게 되었다.

알고리즘은 다음과 같은 과정을 반복한다.

1. 현재 인덱스에 존재하는 탑의 높이와 스택의 끝(가장 마지막에 넣은 값)과 비교한다.

    1-1. 만약 스택이 비어 있다면 0을 넣고, 현재 인덱스 값을 (위치, 값) 형식으로 스택에 넣는다.

2. 만약 현재 인덱스 탑 높이가 더 크다면, 스택의 마지막 값이 현재 인덱스의 탑 높이가 커지거나 비워질 때까지 계속 pop한다.

3. 스택의 마지막 값이 현재 인덱스의 탑 높이보다 크다면, 스택의 마지막 값의 위치 값을 answer에 넣고, 스택에 현재 인덱스 값을 (위치, 값) 형식으로 넣는다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
= int(input())
tops = list(map(int,input().split()))
stack = []
answer = []
for i in range(n):
    top = tops[i]
    if len(stack) == 0:
        answer.append(0)
        stack.append((i+1,top))
        continue
    if top > stack[-1][1]:
        while len(stack) and stack[-1][1< top:
            stack.pop()
        if len(stack) == 0:
            answer.append(0)
        else:
            answer.append(stack[-1][0])
    else:
        answer.append(stack[-1][0])
    stack.append((i+1,top))
print(*answer)
cs

문제링크:

https://www.acmicpc.net/problem/2493

 

2493번: 탑

첫째 줄에 탑의 수를 나타내는 정수 N이 주어진다. N은 1 이상 500,000 이하이다. 둘째 줄에는 N개의 탑들의 높이가 직선상에 놓인 순서대로 하나의 빈칸을 사이에 두고 주어진다. 탑들의 높이는 1 ��

www.acmicpc.net

 

728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]2961. 도영이가 만든 맛있는 음식  (0) 2020.08.13
[Programmers]2020 Kakao. 자물쇠와 열쇠  (0) 2020.08.11
[BOJ]19532. 수학은 비대면강의입니다.  (0) 2020.08.04
[BOJ]2580. 스도쿠  (0) 2020.07.30
[BOJ]17362  (0) 2020.07.28
728x90
반응형

문제:

풀이방법:

 연산자를 계산하는 방법으로 주로 스택을 사용하기 때문에 스택을 사용하고, 수식의 갯수가 3개이므로 최대 6가지 조합이 가능하기 때문에 브루트 포스 방법을 사용해서 모든 케이스에 대해 계산을 하고 그 중 최대값을 찾는 방법을 사용한다.

 우선 정규표현식과 itertools의 permutations을 사용해서 입력받은 expression에 대해서 숫자와 수식을 분리해내고, 연산자들의 우선순위를 만든다.

 생성된 우선순위별로 숫자와 연산자들을 스택에 넣고, 연산자가 현재 해당하는 우선순위의 연산자라면 숫자 스택에서 두 개를 빼고, 연산자 스택에서 하나를 빼서 연산을 하고 다시 숫자 스택에 넣도록 한다.

 이 과정을 우선순위와 연산자별로 계속 반복해서 하고 이 중 max 값을 찾아서 반환하도록 한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
def calculate(a,b,op):
    if op=="+":
        return a+b
    elif op=="*":
        return a*b
    else:
        return a-b
 
def solution(expression):
    import re
    from itertools import permutations
    prior = list(permutations(["+","*","-"],3))
    digit = re.compile("[0-9]+")
    operator = re.compile("[^0-9]")
    numbers = list(map(int,digit.findall(expression)))
    oper = list(operator.findall(expression))
    
    answer = 0
    for pr in prior:
        number = numbers
        ope = oper
        for i in range(3):
            stack = [number[0]]
            stack_op = []
            count = 1
            while count < len(number):
                stack.append(number[count])
                stack_op.append(ope[count-1])
                count+=1
                if stack_op[-1]==pr[i]:
                    b = stack.pop(-1)
                    a = stack.pop(-1)
                    op = stack_op.pop(-1)
                    
                    stack.append(calculate(a,b,op))
            number = stack
            ope = stack_op
        answer = max(answer,abs(number[0]))   
    return answer
cs

문제링크:

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

 

코딩테스트 연습 - 수식 최대화

IT 벤처 회사를 운영하고 있는 라이언은 매년 사내 해커톤 대회를 개최하여 우승자에게 상금을 지급하고 있습니다. 이번 대회에서는 우승자에게 지급되는 상금을 이전 대회와는 다르게 다음과 �

programmers.co.kr

 

728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[Programmers]2020 카카오 인턴십. 보석 쇼핑  (0) 2020.07.16
[BOJ]2164. 카드2  (0) 2020.07.14
[Programmers]2020 카카오 인턴십. 키패드 누르기  (0) 2020.07.07
[BOJ]1543. 문서 검색  (0) 2020.07.02
[BOJ]5525. IOIOI  (0) 2020.06.30
728x90
반응형

문제:

풀이방법:

문제에서 주어진대로 구현을 해도 되지만 stack을 활용해서 풀었다. 각 열별로 newboard에 stack으로 정리를 하며, move를 이용해서 각 열에 있는 값들을 pop을 해서 빼온다. move에 해당하는 열에 값이 없다면 continue로 행동을 넘기며 값이 있다면 basket에 값을 넣는다.

 basket에 값을 넣었다면 위의 두 값이 같은지 확인하고 같다면 pop을 사용해서 빼고 answer 카운트를 2 증가시킨다. (두 값이 같아 없어지는 행위를 세는 것이 아니라 없어진 것의 개수를 구하는 것이므로 2를 더하는게 맞다.)

이 행위를 moves에 있는 행동대로 다 하고 난 뒤의 answer를 반환한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def solution(board, moves):
    answer = 0
    newboard=[[]for _ in range(len(board))]
    while len(board):
        last=board.pop()
        for i in range(len(last)):
            if last[i]==0:
                continue
            newboard[i].append(last[i])
    basket=[]
    for move in moves:
        if len(newboard[move-1])==0:
            continue
        basket.append(newboard[move-1].pop())
        if len(basket)>=2 and basket[-1]==basket[-2]:
            basket.pop()
            basket.pop()
            answer+=2
    return answer
cs

문제링크:

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

 

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

 

728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]5014. 스타트링크  (0) 2020.05.07
[2019 Kakao winter internship]튜플  (0) 2020.04.23
[BOJ]2863. 이게 분수?  (0) 2020.04.16
[BOJ]7785. 회사에 있는 사람  (0) 2020.04.14
[BOJ]1718. 암호  (0) 2020.04.09
728x90
반응형

문제:

상근이는 문자열에 폭발 문자열을 심어 놓았다. 폭발 문자열이 폭발하면 그 문자는 문자열에서 사라지며, 남은 문자열은 합쳐지게 된다.

 

폭발은 다음과 같은 과정으로 진행된다.

 

  •   문자열이 폭발 문자열을 포함하고 있는 경우에, 모든 폭발 문자열이 폭발하게 된다. 남은 문자열을 순서대로 이어 붙여 새로운 문자열을 만든다.
  • 새로 생긴 문자열에 폭발 문자열이 포함되어 있을 수도 있따.
  • 폭발은 폭발 문자열이 문자열에 없을 때까지 계속된다.

상근이는 모든 폭발이 끝난 후에 어떤 문자열이 남는지 구해보려고 한다. 남아있는 문자가 없는 경우가 있다. 이 때는 "FRULA"를 출력한다.

 

폭발 문자열은 같은 문자를 두 개 이상 포함하지 않는다.

입력:

첫째 줄에 문자열이 주어진다. 문자열의 길이는 1보다 크거나 같고, 1,000,000보다 작거나 같다.

둘째 줄에 폭발 문자열이 주어진다. 길이는 1보다 크거나 같고, 36보다 작거나 같다.

두 문자열은 모두 알파벳 소문자와 대문자, 숫자 0, 1, ..., 9로만 이루어져 있다.

출력:

첫째 줄에 모든 폭발이 끝난 후 남은 문자열을 출력한다.

풀이방법:

 풀 수 있는 방법은 다양하지만 시간 제한이 빡세게 걸려있던 문제였다. 따라서 일반 string에서 제공해주는 함수인 replace를 사용한다면 시간제한에 막혀서 해결하지 못할 것이다.

최대한 시간복잡도를 적게하면서 풀 수 있는 방법이 무엇일까 생각해보았는데 stack을 이용하는 것이였다. stack은 넣는 것과 빼는 것이 O(1)로 시간복잡도가 적게 발생한다. 또한 폭발 문자열만큼 stack의 끝 부분을 계속해서 확인하면 실시간(?)으로 뺄 수 있으므로 번거롭게 검토를 하는 과정또한 불필요할 것이다.

 따라서 string을 하나씩 answer라는 stack에 넣고 끝 부분이 bomb과 같아질 때마다 그 부분을 빈 리스트로 만들어줌으로써 pop과 같은 기능을 하도록 했다. 이 과정을 모두 마친 뒤에 answer라는 배열에 값이 남아있다면 이를 join으로 이어주고 비어있다면 남아있는 문자가 없는 경우이므로 FRULA를 출력하도록 하였다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import sys
 
string=sys.stdin.readline().rstrip()
bomb=list(sys.stdin.readline().rstrip())
length=len(bomb)
answer=[]
for st in string:
    answer.append(st)
    if answer[-length:]==bomb:
        answer[-length:]=[]
if answer:
    print(''.join(answer))
else:
    print("FRULA")
cs

문제링크:

https://www.acmicpc.net/problem/9935

728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]2133. 타일 채우기  (0) 2019.08.31
[BOJ]1699. 제곱수의 합  (0) 2019.08.30
[BOJ]1120. 문자열  (0) 2019.08.28
[Programmers]Lv 3. N-queen  (0) 2019.08.27
[BOJ]9465. 스티커  (0) 2019.08.24
728x90
반응형

문제:

한 줄로 된 간단한 에디터를 구현하려고 한다. 이 편집기는 영어 소문자만을 기록할 수 있는 편집기로, 최대 600,000글자까지 입력할 수 있다.

 

이 편집기에는 '커서'라는 것이 있는데, 커서는 문장의 맨 앞(첫 번째 문자의 왼쪽), 문장의 맨 뒤(마지막 문자의 오른쪽), 또는 문장 중간 임의의 곳(모든 연속된 두 문자 사이)에 위치할 수 있다. 즉 길이가 L인 문자열이 현재 편집기에 입력되어 있으며, 커서가 위치할 수 있는 곳은 L+1가지 경우가 있다.

 

이 편집기가 지원하는 명령어는 다음과 같다.

 

 L : 커서를 왼쪽으로 한 칸 옮김 (커서가 문장의 맨 앞이면 무시됨)

 D : 커서를 오른쪽으로 한 칸 옮김 (커서가 문장의 맨 뒤이면 무시됨)

 B : 커서 왼쪽에 있는 문자를 삭제함(커서가 문장의 맨 앞이면 무시됨), 삭제로 인해 커서는 한 칸 왼쪽으로 이동한 것처       럼 나타나지만, 실제로 커서의 오른쪽에 있던 문자는 그대로임.

 P $ : $라는 문자를 커서 왼쪽에 추가함

 

초기에 편집기에 입력되어 있는 문자열이 주어지고, 그 이후 입력한 명령어가 차례로 주어졌을 때, 모든 명령어를 수행하고 난 후 편집기에 입력되어 있는 문자열을 구하는 프로그램을 작성하시오.  단, 명령어가 수행되기 전에 커서는 문장의 맨 뒤에 위치하고 있다고 한다.

 

입력:

첫째 줄에는 초기에 편집기에 입력되어 있는 문자열이 주어진다. 이 문자열은 영어 소문자로만 이루어져 있으며, 길이는 100,000을 넘지 않는다. 둘째 줄에는 입력할 명령어의 개수를 나타내는 정수 N(1<=N<=500,000)이 주어진다. 셋째 줄부터 N개의 줄에 걸쳐 입력할 명령어가 순서대로 주어진다. 명령어는 위의 네 가지 중 하나의 형태로만 주어진다.

출력:

첫째 줄에 모든 명령어를 수행하고 난 후 편집기에 입력되어 있는 문자열을 출력한다.

풀이방법:

 명령어대로 구현을 하는 것은 어렵지 않은 것 같지만 시간 제한이 빡세게 걸려있기 때문에 효율적으로 구현을 하는 것이 어려운 문제인 것 같았다. 명령어를 그냥 구현하는 것은 idx , insert함수, pop함수를 사용하면 쉽게 구현할 수 있지만 시간 초과가 발생할 것 같다. insert함수, pop함수는 각각 O(n)의 시간복잡도를 가지고 있기 때문이다. (실제로 구현해보진 않았지만 아마 날 것이다.)

 그래서 넣고 빼는 것의 시간복잡도를 줄일 수 있는 자료구조가 무엇인지 생각해보니 스택과 큐가 생각났다. (이들은 넣고 뺌이 O(1)이다.) 따라서 두 개의 스택을 이용해서 이 문제를 해결하고자 하였다.

 기본적인 개념은 커서를 기준으로 왼쪽에 있는 값들의 스택, 오른쪽에 있는 값들의 스택을 만들어 두 개의 스택을 운영했다. 커서가 이동하는 것은 왼쪽스택->오른쪽스택, 오른쪽스택->왼쪽스택으로 옮기는 행위로 판단을 하였고, B는 그냥 pop, P는 append라고 생각하면 쉽게 구현 할 수 있다. '커서가 문자의 맨 앞(뒤)이면 무시됨'과 같은 말은 스택의 크기가 0임을 판단하는 것으로 해결했다.

 명령어를 다 수행하고 출력을 할 때에는 하나의 스택에 다 몰아넣고 출력해도 되지만 파이썬의 join 함수를 사용해서 한 줄로 코드를 줄일 수 있었다.

 그리고 파이썬의 경우에는 시간초과를 해결하기 위해서 입출력시에 input() 함수를 사용하지 말아야 한다고 한다. 따라서 sys 모듈에서 sys.stdin.readline().rstrip()을 사용해서 값들을 읽었다. (rstrip()은 끝에 '\n'이 붙어있다고 해서 제거하기 위함이다.)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import sys
 
strings = sys.stdin.readline().rstrip()
commands= int(sys.stdin.readline().rstrip())
left=[]
right=[]
for i in range(len(strings)):
    left.append(strings[i])
    
for i in range(commands):
    command=sys.stdin.readline().rstrip().split()
    if command[0]=="P":
        left.append(command[1])
    elif command[0]=='L':
        if len(left):
            move=left.pop()
            right.append(move)
    elif command[0]=='D':
        if len(right):
            move=right.pop()
            left.append(move)
    else:
        if len(left):
            left.pop()
 
print(''.join(left+right[::-1]))
 
cs

문제 링크:

https://www.acmicpc.net/problem/1406

 

728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[Programmers]Lv 3. N-queen  (0) 2019.08.27
[BOJ]9465. 스티커  (0) 2019.08.24
[BOJ]11053. 가장 긴 증가하는 부분 수열  (0) 2019.08.22
[BOJ]1389. 케빈 베이컨의 6단계 법칙  (0) 2019.08.21
[BOJ]4307. 개미  (0) 2019.08.06
728x90
반응형

문제:

세계는 균형이 잘 잡혀있어야 한다. 양과 음, 빛과 어둠 그리고 왼쪽 괄호와 오른쪽 괄호처럼 말이다.

정민이의 임무는 어떤 문자열이 주어졌을 때, 괄호들의 균형이 잘 맞춰져 있는지 판단하는 프로그램을 짜는 것이다.

문자열에 포함되는 괄호는 소괄호 ("()") 와 대괄호 ("[]")로 2종류이고, 문자열이 균형을 이루는 조건은 아래와 같다.

* 모든 왼쪽 소괄호는 ("(")는 오른쪽 소괄호(")")와만 짝을 이룰 수 있다.
* 모든 왼쪽 대괄호는 ("[")는 오른쪽 대괄호("]")와만 짝을 이룰 수 있다.
* 모든 오른쪽 괄호는 자신과 짝을 이룰 수 있는 왼쪽 괄호가 존재한다.
* 모든 괄호들의 짝은 1:1 매칭만 가능하다. 즉, 괄호 하나가 둘 이상의 괄호와 짝지어지지 않는다.
* 짝을 이루는 두 괄호가 있을 때, 그 사이에 있는 문자열도 균형이 잡혀야 한다.

정민이를 도와 문자열이 주어졌을 때 균형잡힌 문자열인지 아닌지를 판단해보자.

입력:

하나 또는 여러줄에 걸쳐서 문자열이 주어진다. 각 문자열은 영문 알파벳, 공백, 소괄호 ("()") 대괄호("[]")등으로 이루어져 있으며, 길이는 100글자보다 작거나 같다.

입력의 종료조건으로 맨 마지막에 점 하나(".")가 들어온다.

출력:

각 줄마다 해당 문자열이 균형을 이루고 있으면 "yes"를, 아니면 "no"를 출력한다.

풀이 방법:

 처음에는 이와 비슷한 문제들은 ( , [ 를 만나면 count +=1 하고 ), ]를 만나면 count -=1 하는 방법으로 쉽게 풀 수 있어서 비슷한 문제인 줄 알았다. 하지만 예제 중에 5번째 줄인 ( [ ) ] 과 같은 케이스는 마지막 조건에 의해서 안된다는 것을 알게 되었다.
 따라서 이 문제를 해결하기 위해서 stack이라는 배열을 만들어서 ( , [를 만나면 담고, ) ] 를 만나면 빼는 ( 예외 케이스 처리 하에) 방법으로 해서 통과를 했다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
while True:
    string=input()
    if string==".":
        break
    stack=[]
    answer=True
    for i in string:
        if i=='(':
            stack.append(i)
        elif i=='[':
            stack.append(i)
        elif i==')':
            if len(stack)==0:
                answer=False
                break
            if stack[-1]=='(':
                stack.pop()
            else:
                answer=False
                break
        elif i==']':
            if len(stack)==0:
                answer=False
                break
            if stack[-1]=='[':
                stack.pop()
            else:
                answer=False
                break
    if len(stack)==0 and answer:
        print("yes")
    else:
        print("no")
cs


728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]1260. DFS와 BFS  (0) 2019.07.19
[BOJ]2164. 카드2  (0) 2019.07.18
[BOJ]2004. 조합 0의 개수  (0) 2019.07.16
[BOJ]2217. 로프  (0) 2019.07.15
[BOJ]11047. 동전0  (0) 2019.07.14
728x90
반응형

문제:

4개의 기호 ‘(’, ‘)’, ‘[’, ‘]’를 이용해서 만들어지는 괄호열 중에서 올바른 괄호열이란 다음과 같이 정의된다.


1. 한 쌍의 괄호로만 이루어진 ‘()’와 ‘[]’는 올바른 괄호열이다. 

2. 만일 X가 올바른 괄호열이면 ‘(X)’이나 ‘[X]’도 모두 올바른 괄호열이 된다. 

3. X와 Y 모두 올바른 괄호열이라면 이들을 결합한 XY도 올바른 괄호열이 된다.


예를 들어 ‘(()[[]])’나 ‘(())[][]’ 는 올바른 괄호열이지만 ‘([)]’ 나 ‘(()()[]’ 은 모두 올바른 괄호열이 아니다. 우리는 어떤 올바른 괄호열 X에 대하여 그 괄호열의 값(괄호값)을 아래와 같이 정의하고 값(X)로 표시한다. 


1. ‘()’ 인 괄호열의 값은 2이다.

2. ‘[]’ 인 괄호열의 값은 3이다.

3. ‘(X)’ 의 괄호값은 2×값(X) 으로 계산된다.

4. ‘[X]’ 의 괄호값은 3×값(X) 으로 계산된다.

5. 올바른 괄호열 X와 Y가 결합된 XY의 괄호값은 값(XY)= 값(X)+값(Y) 로 계산된다.


예를 들어 ‘(()[[]])([])’ 의 괄호값을 구해보자.  ‘()[[]]’ 의 괄호값이 2 + 3×3=11 이므로  ‘(()[[ ]])’의 괄호값은 2×11=22 이다. 그리고  ‘([])’의 값은 2×3=6 이므로 전체 괄호열의 값은 22 + 6 = 28 이다.


여러분이 풀어야 할 문제는 주어진 괄호열을 읽고 그 괄호값을 앞에서 정의한대로 계산하여 출력하는 것이다. 

입력:

첫째 줄에 괄호열을 나타내는 문자열(스트링)이 주어진다. 단 그 길이는 1 이상, 30이하이다.

출력:

첫째 줄에 그 괄호열의 값을 나타내는 정수를 출력한다. 만일 입력이 올바르지 못한 괄호열이면 반드시 0을 출력해야 한다.

풀이 방법:

문제에서 제공된 예시케이스를 보면 예시케이스는 다음과 같이 계산이 되어야 한다.  2×(2+3×3)+2×3 사람이 직접 괄호를 보고 계산을 하면 이렇게 하겠지만 컴퓨터에게 이렇게 연산을 하게끔 하는 것은 어렵다. 따라서 위 식을 다음과 같이 변경하도록 할 것이다. 2×2+2×3×3+2×3 와 같이 괄호를 분배법칙을 이용해 풀어내었다. 이 규칙대로 하기 위해서 ( 나 [ 를 만나면 temp에 2 나 3를 곱하고 stack에 담아두고, ) 나 ] 를 만날 경우에는 그 전의 값이 ( 나 [ 일 경우에만 answer에 더해줬다.. 그 이유는 이 경우에만 올바른 괄호열이기 때문이다. 물론 앞에서 미리 temp에서 곱하면서 움직였으므로 값은 올바르게 구해진다. 그리고 스택의 top 값이 ( 나 [ 이면 pop 해줬다. 계속 이과정을 반복하다가 중간에 스택이 비어버렸는데 빼야하는 경우가 온다거나 끝까지 다 진행했는데도 아직 stack에 남아있다면 올바르지 않은 괄호열이기때문에 0을 출력하고 그렇지 않으면 answer를 출력하도록 한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
answer=0
stack=[]
temp=1
correct=True
string=input()
for i in range(len(string)):
    if string[i]=="(":
        temp*=2
        stack.append("(")
    elif string[i]=="[":
        temp*=3
        stack.append("[")
    elif string[i]==")":
        if string[i-1]=="(":
            answer+=temp
        if not len(stack):
            correct=False
            break
        if stack[-1]=="(":
            stack.pop()
        temp//=2
    else:
        if string[i-1]=="[":
            answer+=temp
        if not len(stack):
            correct=False
            break
        if stack[-1]=="[":
            stack.pop()
        temp//=3
if (len(stack) or not correct):
    print(0)
else:
    print(answer)
cs


728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]2163. 초콜릿 자르기  (0) 2019.04.20
[BOJ]1912. 연속합  (0) 2019.04.19
[BOJ]9012.괄호  (0) 2019.04.17
[BOJ]1874. 스택 수열  (0) 2019.04.16
[BOJ]10828. 스택  (0) 2019.04.15

+ Recent posts