YB 공부 블로그

# RGB 거리
 
# 그 전의 값들 중 위치가 같지 않는 집들 중 최솟값을 더해주면서 갱신한다.
 
import sys
 
a = int(input())
 
k = [ ]
 
for i in range(a):
    k.append(list(map(int,sys.stdin.readline().rstrip().split(" "))))
 
 
for i in range(1,len(k)):
    k[i][0] += min(k[i-1][1],k[i-1][2])
    k[i][1] += min(k[i-1][0],k[i-1][2])
    k[i][2] += min(k[i-1][1],k[i-1][0])
 
print(min(k[-1]))
 
 

# DP문제 - 그림을 그려보니 점화식을 발견함  
 
 
import sys
from itertools import product
 
 
dp = [0] * 100
 
dp[0] = 1
dp[1] = 1
dp[2] = 2
 
for i in range(3,len(dp)):
    dp[i] = dp[i-2] + dp[i-1]
 
num = int(input())
 
# 0으로 시작하지 않음 / 1이 연속으로 나오지 않음
 
 
print(dp[num-1])
 
 

Rest API란?

- Representational State Transfer 의 약자

- 자원, 행위, 표현으로 구성되어 있음

REST의 특징

- Uniform : 통일되고 한정적인 인터페이스로 수행

- Stateless : 상태정보를 따로 저장하거나 관리하지 않는다.

- Cacheable : 웹에서 사용하는 기존 인프라를 그대로 활용 가능하다.

- Self-descriptiveness : 쉽게 이해할 수 있는 자체 표현 구조로 이루어져 있다.

- Client - Server 구조 : 클라이언트과 서버 간의 의존성이 줄어든다.

- 계층형 구조 : 구조상의 유연성을 둘 수 있다.

REST API 설계 시 중요한 두 가지

- URI는 정보의 자원을 표현해야 한다.

- 자원에 대한 행위는 HTTP Method로 표현한다.

패킷이 크다면 다른 패킷의 흐름을 막을 위험이 있다.

패킷에 번호를 붙여 전송하기 때문에 패킷이 원래 순서대로 정렬될 수 있다.

DMZ는 외부에 공개하기 위한 네트워크(서버를 공개한다.)

온프레미스 : 사내 또는 데이터 센터에 서버를 두고 운영하는 것

데이터를 상대에세 보낼 때 각 계층에서 헤더를 붙여 나가는 것이 캡슐화이다.

데이터를 수신할 때 각 계층에서 헤더를 제거하는 것은 역캡슐화이다.

랜카드 : 2진수의 정보를 전달받아 이를 전기 신호로 변환한다.

트위스트 페어 케이블

- UTP 케이블 : Unshielded - 노이즈 영향 많지만 저렴함 

- STP 케이블 : Shielded - 노이지 영향 적지만 비쌈

트위스트 페어 케이블을 랜 케이블이라고 한다.

허브(컴퓨터 여러대 통신 가능),리피터(일대일 통신만 가능) : 전기 신호를 증폭함

허브는 전기신호를 몬든 포트로 보내서 더비 허브라는 이름으로 불린다. -> 스위치의 등장 배경

이더넷 : 네트워크 장비 간에 신호를 주고 받는 규칙\

MAC주소 :랜카드 번호 ->  24비트(제조사 번호) + 24비트(일련 번호)

전이중 통신 방식 : 데이터 송수신 동시에 통신

반이중 통신 방식 : 송신, 수신 번갈아서 하기

# 십만일개의 원소를 갖는 리스트를 생성해서 해결함. 십만개 정도 리스트는 메모리 초과가 안나서 신기함
# d[k] 가 0이 아니면 방문을 한 것이기 때문에 답을 출력해준다.
 
import sys
from collections import deque
 
 
N,k = list(map(int,sys.stdin.readline().split(" ")))
 
 
# bfs -> 메모리 초과(temp 리스트 때문)  -> 제거했는데도 메모리 초과
 
d = [0]*100001
d[N] = 1
 
queue = deque()
queue.append(N)
 
temp = [ ]
 
while queue:
 
 
 
    x = queue.popleft()
 
    if d[k]!=0:
        print(d[k]-1)        
        break
 
    if 0<=x-1 and d[x-1]==0:
        d[x-1] = d[x] + 1
        queue.append(x-1)
 
    if x+1<=100000 and d[x+1]==0:
        d[x+1] = d[x] +1
        queue.append(x+1)
 
    if 2*x <= 100000 and d[2*x]==0:
        d[2*x] = d[x] + 1
        queue.append(x*2)
 
 
'''
# 리스트를 업데이트 하기 -> 시간 초과 날듯? -> 메모리 초과남
 
a = []
a.append(N)
 
while True:
 
    if K in a:
        print(answer)
        break
 
 
    temp = [ ]
 
    for i in range(0,len(a)):
        for j in range(0,3):
 
            if j==0:
                if a[i]+1<=100000:
                    temp.append(a[i]+1)
 
            if j==1:
                if a[i]-1>=0:
                    temp.append(a[i]-1)
 
            if j==2:
                if a[i]*2<=2*K:
                    temp.append(a[i]*2)
 
 
 
    a = temp
 
    answer += 1
 
'''
 
 
 
 
 
 

 
 
# temp 리스트를 추가해서 count를 계산하려고 했지만 시간 초과가 났다.
# 구글링을 해보니 2차원 리스트를 통한 풀이가 있어 이를 참고했다. 풀 수 있던 문제였는데 아깝네요
 
 
import sys
from collections import deque
 
def bfs(a,b,x,y,length):
 
    # 시작 위치 a,b
 
    # 도착 위치 x,y
 
    count = 0
 
    queue = deque()
 
    queue.append([a,b])
 
    dx = [2,2,1,1,-1,-1,-2,-2]
    dy = [1,-1,2,-2,2,-2,1,-1]
 
    temp = [ ]
 
 
    while queue:       
 
        n,m = queue.popleft()
 
        if n==x and m==y:
            return answer[n][m]-1
 
 
        for i in range(8):
            temp_x = n + dx[i]
            temp_y = m + dy[i]
 
            if 0<=temp_x<length and 0<=temp_y<length and answer[temp_x][temp_y]==0:
 
                answer[temp_x][temp_y] = answer[n][m] + 1
                queue.append([temp_x,temp_y])
 
 
 
 
 
 
 
 
num = int(sys.stdin.readline())
 
for i in range(num):
 
    length = int(sys.stdin.readline())
 
    a,b = list(map(int,sys.stdin.readline().split(" ")))
 
    x,y = list(map(int,sys.stdin.readline().split(" ")))
 
    answer = [[0]*(length+1) for i in range(length+1)]
 
    answer[a][b] = 1
 
    print(bfs(a,b,x,y,length))
 
 
 
 
 
 
 
 
 

[ 5 ] 클래스와 객체 1

생성자의 역할 : 클래스를 만들 때 멤버 변수나 상수를 초기화 함

자바 컴파일러는 생성자가 하나도 없는 경우에만 디폴트 생성자를 제공

클래스에서 일부러 디폴트 생성자를 제공하지 않기도 한다.

매개변수가 있는 생성자를 사용하면 코드가 간결하고 사용하기도 편리함

기본 자료형을 사용하듯이 클래스 자료형 변수를 선언해서 사용하면 편리함

정보 은닉 : 클래스 내부에서 사용할 변수나 메서드를 private 으로 선언에서 외부의 접근을 막는 것

[ 6 ] 클래스와 객체 2

this를 사용하여 생성자를 호출하는 코드 이전에 다른 코드를 넣을 수 없다. ->클래스 생성이 완료되지 않은 시점일 수 있음

클래스내에서 this를 사용하면 자신의 주소 값을 반환할 수 있다.

static 변수는 프로그램이 실행되어 메모리에 올라갔을 때 딱 한 번 메모리 공간이 할당된다. -> 모든 인스턴스가 공유

클래스 메서드와 클래스 변수는 인스턴스가 생성되지 않아도 사용할 수 있다.

인스턴스는 클래스에 메모리를 차지한 상태를 의미함

클래스 매서드 내부에서 지역 변수와 클래스 변수는 사용할 수 있지만, 인스턴스 변수는 사용 불가

지역 변수가 생성되는 메모리를 스택이라고 한다.

지역 변수 : 스택 / 멤버 변수 : 힙 / static 변수 : 데이터 영역

싱글톤 패턴에서는 생성자를 반드시 명시적으로 만들고 그 접근 제어자를 private으로 지정해야 한다.

[ 7 ] 배열과 ArrayList

System.arraycopy() 메서드를 통해 배열을 복사할 수 있다.

주소 값만 복사하는 것은 얕은 복사

[ 8 ] 상속과 다형성

상위 클래스에 작성한 변수나 메서드 중 하위 클래스에서 사용할 수 있도록 한 예약어는 protected 이다.

상위 클래스를 상속받은 하위 클래스가 생성될 때는 반드시 생위 클래스의 생성자가 먼저 호출된다.

상위 클래스의 주소를 가지고 있는 예약어가 super이다.

상속에서 상위 클래스와 하위 클래스에 같은 이름의 메서드가 존재할 때 호출되는 메서드는 인스턴스에 따라 결정됌.

클래스를 생성하여 인스턴스가 만들어지면 멤버 변수는 힙 메모리에 위치한다.

메서드는 인스턴스가 달라도 같은 로직을 수행한다.

자바의 모든 메서드는 가상 메서드이다.

가상 메서드는 상속하는 클래스 내에서 같은 시그니처의 함수로 오버라이딩 될 수 있는 함수 또는 메소드이다. 

상속은 IS-A 관계에서 사용하는 게 효율적이다.

HAS-A 관계에서는 멤버 변수로 사용하는 게 효율적이다.

상속은 "일반적인 클래스"와 "구체적인 클래스"의 관계에서 구현하는 게 효율적이다.

자바는 다중 상속을 지원하지 않는다.

상위 클래스로 형 변환된 인스턴스의 원래 자료형을 확인하는 예약어가 instanceof 이다.

[ 9 ] 추상 클래스

자바에서 추상 메서드는 abstract 예약어를 사용하여 선언만 하는 메서드이다.

추상 클래스를 상속받은 클래스는 추상 클래스가 가진 메소드를 상속받는다.

추상 클래스를 상속받은 클래스는 구현되지 않은 추상 메서드를 모두 구현해야 구체적인 클래스가 된다.

추상 클래스는 인스턴스로 생성할 수 없다. 모든 메서드가 구현되지 않았기 때문이다.

추상 클래스에서 구현하는 메서드는 하위 클래스에서도 구현 내용을 공유할 메서드를 구현한다.

탬플릿 메서드의 역할은 메서드 실행 순서와 시나리오를 정의하는 것이다.

탬플릿 메서드는 final 예약어를 사용해서 선언해야 한다.

여러 파일에서 공유해야 하는 상수 값은 public static final로 선언하는 게 효율적이다.

[ 10 ] 인터페이스

인터페이스는 추상 메서드와 상수로만 이루어져 있다.

인터페이스 변수와 메서드는 컴파일 시 모두 상수와 추상 메서드로 자동 변환된다.

자바 8부터 인터페이스의 활용성을 위해 디폴트 메서드와 정적 메서드 기능을 제공한다.

자바 9부터 인터페이스에 private 메서드를 구현할 수 있다.

private 메서드는 인터페이스를 구현한 클래스에서 사용 및 재정의가 불가능하다.

인터페이스는 한 클래스가 여러 인터페이스를 구현할 수 있다.

인터페이스 간에도 상속이 가능하고 여러 개를 동시에 상속받을 수 있다.

[ 11 ] 기본 클래스

Object는 최상위 클래스이고 컴파일 과정에서 extends Object가 자동으로 쓰인다.

자바에서는 인스턴스를 힙 메모리에 생성하여 관리할 때 해시 알고리즘을 사용한다.

프로그램에서 사용되는 상수값을 저장하는 공간을 "상수 풀" 이라고 한다.

모르는 클래스의 정보를 사용할 경우에 Class 클래스를 활용한다.

Class 클래스를 사용하면 더 복잡하고 예외 처리도 해야한다. 코드가 복잡해지고 속도도 느려진다.

[ 12 ] 컬렉션 프레임워크

어떤 값이 하나의 참조 자료형이 아닌 여러 참조형을 사용할 수 있도록 하는 프로그래밍은 제네릭 프로그래밍이다.

제네릭 프로그램은 참조 자료형이 변환될 때 검증을 컴파일러가 하기에 안정적이다.

제네릭에서는 여러 참조 자료형을 사용하는 부분을 Object가 아닌 하나의 문자로 표현한다.

static 변수의 자료형이나 static 메서드 내부 변수의 자료형으로 T를 사용할 수 없다. -> 인스턴스 생성이 필요하기 때문

컬렉션 프레임워크의 전체 구조는 Collection 인터페이스와 Map 인터페이스 기반으로 이루어져 있다.

멀티스레드 환경이 아닌 경우에는 ArrayList 사용이 권장된다.

Vector의 모든 메서드는 호출될 때 마다 잠금과 해제가 일어나서 수행 속도가 느리다.

링크드 리스트의 각 요소는 요소의 자료와 다음 요소의 주소를 저장하는 부분으로 구현된다.

사용하는 자료의 변동이 많은 경우에는 링크드 리스트, 그렇지 않은 경우는 배열을 사용하는 것이 효과적이다.

순서가 없는 Set 인터페이스 경우 Iterator를 사용한다.

HashSet은 중복을 허용하지 않고, 순서와 상관없이 출력된다.

Tree로 시작하는 클래스는 결과 출력 시 결과 값이 정렬된다.

Comparable, Comparator 인터페이스는 특정 기준을 통해 정렬 할 수 있도록 해주는 인터페이스이다.

멀티스레드 환경이 아니라면 HashTable 보다는 HashMap을 사용하는 것이 낫다.

[ 13 ] 내부 클래스, 람다식, 스트림

내부 클래스 사용 이유 : 외부 클래스와 밀접한 관계 + 그 밖의 다른 클래스와 협력 관계가 없음

인스턴스 내부 클래스에 정적 변수 선언이 불가능하다.

람다식은 함수 이름이 없는 익명 함수를 만드는 것이다.

람다식 문법에서는 매개변수 자료형을 생략할 수 있고 매개변수가 한개인 경우에는 괄호도 생략할 수 있다.

람다식은 한개의 메서드만 선언할 수 있다. -> @FunctionalInterface 어노테이션 사용 하기도 함

여러 자료의 처리에 대한 기능을 구현해 놓은 클래스가 스트림

스트림의 단계 : 스트림 생성 -> 중간 연산 -> 최종 연산

중간 연산 : filter, map / 최종 연산 : forEach, count ,sum, reduce

한 번 생성하고 사용한 스트림은 재사용할 수 없다.

스트림의 reduce(초기값, 수행 할 연산)

[ 14 ] 예외 처리

Throwable 클래스에는 Error와 Exception 두 가지가 있다.

핵심 아이디어가 두 가지 있다.
초기의 토마토들은 동시에 익기 시작한다는 것과 날짜를 구하기 위해 temp 리스트를 사용한 것이다.

 
import sys
from collections import deque
 
 
global count
count = 0
 
 
def bfs(temp,N,M):
 
    global count
 
    dx = [0,0,1,-1]
    dy = [1,-1,0,0]
 
    queue = deque()
 
    for i in range(0,len(temp)):
        queue.append([temp[i][0],temp[i][1]])
 
    # 일 수를 구하기 위해 temp 리스트를 사용하기
 
    temp = [ ]
 
    while queue:
 
 
        x,y = queue.popleft()
 
        for i in range(4):
            temp_x = x + dx[i]
            temp_y = y + dy[i]
 
 
            if 0<=temp_x<M and 0<=temp_y<N and k[temp_x][temp_y]==0:
 
                k[temp_x][temp_y] = 1
 
                # visited[temp_x][temp_y] = True
 
                temp.append([temp_x,temp_y])
 
        if len(queue)==0:
            count += 1
            queue = deque(temp)
            temp = [ ]
 
 
 
N,M = list(map(int,sys.stdin.readline().split(" ")))
 
 
k = [ ]
 
for i in range(M):
    k.append(list(map(int,sys.stdin.readline().split(" "))))
 
 
# 모든 토마토가 익은 상태 : 0 이 없으면 
 
zero = 0
 
for i in range(0,len(k)):
    for j in range(0,len(k[i])):
        if k[i][j] == 0:
            zero += 1
 
if zero == 0:
    print(0)
 
 
else:    
 
    temp = [ ]
 
    for i in range(0,len(k)):
        for j in range(0,len(k[i])):
            if k[i][j] == 1:
                temp.append([i,j])
 
    bfs(temp,N,M)
 
# 토마토가 모두 익지 못하는 상황 : 돌렸는데 0 이 있으면
 
    zeros = 0
 
    for i in range(0,len(k)):
        for j in range(0,len(k[i])):
            if k[i][j] == 0:
                zeros += 1
 
    if zeros != 0:
        print(-1)
 
    # 그렇지 않다면
 
    else:
        print(count-1)