문제 설명

두 전봇대 A와 B 사이에 하나 둘씩 전깃줄을 추가하다 보니 전깃줄이 서로 교차하는 경우가 발생하였다. 합선의 위험이 있어 이들 중 몇 개의 전깃줄을 없애 전깃줄이 교차하지 않도록 만들려고 한다.

예를 들어, < 그림 1 >과 같이 전깃줄이 연결되어 있는 경우 A의 1번 위치와 B의 8번 위치를 잇는 전깃줄, A의 3번 위치와 B의 9번 위치를 잇는 전깃줄, A의 4번 위치와 B의 1번 위치를 잇는 전깃줄을 없애면 남아있는 모든 전깃줄이 서로 교차하지 않게 된다.

< 그림 1 >

전깃줄이 전봇대에 연결되는 위치는 전봇대 위에서부터 차례대로 번호가 매겨진다. 전깃줄의 개수와 전깃줄들이 두 전봇대에 연결되는 위치의 번호가 주어질 때, 남아있는 모든 전깃줄이 서로 교차하지 않게 하기 위해 없애야 하는 전깃줄의 최소 개수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에는 두 전봇대 사이의 전깃줄의 개수가 주어진다. 전깃줄의 개수는 100 이하의 자연수이다. 둘째 줄부터 한 줄에 하나씩 전깃줄이 A전봇대와 연결되는 위치의 번호와 B전봇대와 연결되는 위치의 번호가 차례로 주어진다. 위치의 번호는 500 이하의 자연수이고, 같은 위치에 두 개 이상의 전깃줄이 연결될 수 없다.

출력

첫째 줄에 남아있는 모든 전깃줄이 서로 교차하지 않게 하기 위해 없애야 하는 전깃줄의 최소 개수를 출력한다.

문제 분석 과정

문제를 분석하는 과정에서 시행착오가 있었다. 첫 시도는 데이터를 튜플형태로 받은 후 각 인덱스 마다 교차하는 갯수를 구하였다. 그리고 2차원 dp 테이블을 활용하여 dp 테이블을 초기화 시켜간후, 교차하는 갯수가 0일 때 활성화된 인덱스가 최소인 것을 찾으려했다.

 dp = [0]*(n+1)
 ALinkB = [(0,0)]

 for _ in range(n):
     ALinkB.append(tuple(map(int,input().split())))

 for i in range(1,n+1):
     for j in range(1,n+1):
         if isCross(i,j):
             cross[i] += 1

교차함을 확인하는 함수

def isCross(x,y):
    if x != y:
        if ALinkB[x][0] < ALinkB[y][0] and ALinkB[y][1] < ALinkB[x][1]:
            return True
        if ALinkB[x][0] > ALinkB[y][0] and ALinkB[y][1] > ALinkB[x][1]:
            return True
    return False

그렇다. 진심 개어렵다. 코드를 짜내려가다보니 이방법이 아닌것 같다는 생각이들어서 테스트 케이스를 분석해보았다.

문제 예시를 통한 분석을 해보자 . 문제설명에서 주어진 (1,8),(3,9),(4,1) 이 녀석들은 제거되는 녀석들이다.

8 1 8 (X) 2 2 3 9 (X) 4 1 (X) 6 4 7 6 9 7 10 10

B를 관찰해 보면 2, 4, 6, 7, 10 로 증가 하는 수열임을 알 수 있다. 없애는 전기줄이 최소이기 위해선 가장 긴 증가 수열을 만들면 된다. 우선 입력받은 리스트(튜플)을 정렬하고 리스트[][1] 은 하나의 리스트이므로 이 리스트에대한 가장 긴 증가 수열을 만들어보자.

가장 긴 증가 수열은 에서 볼 수 확인 할 수 있다.

소스코드

n = int(input())
ALinkB = [(0,0)]
for _ in range(n):
    ALinkB.append(tuple(map(int,input().split())))

# 문제 예시를 통한 분석을 해보자 . 
# 문제에선 (1,8),(3,9),(4,1)
# 8
# 1 8 (X)
# 2 2
# 3 9 (X)
# 4 1 (X)
# 6 4
# 7 6
# 9 7
# 10 10
# B를 관찰해 보면 2, 4, 6, 7, 10 로 증가 하는 수열임을 알 수 있다.
# 없애는 전기줄이 최소이기 위해선 가장 긴 증가 수열을 만들면 된다.
# 우선 입력받은 리스트(튜플)을 정렬하고 
# 리스트[][1] 은 하나의 리스트이므로 이 리스트에대한 가장 긴 증가 수열을 만들어보자.
# [가장 긴 증가 수열](https://hwangbbang.tistory.com/12)은 에서 볼 수 확인 할 수 있다.

ALinkB.sort()
dp = [1]*(n+1)
for i in range(1,n+1):
    for j in range(1,i+1):
        if ALinkB[i][1] > ALinkB[j][1]:
            dp[i] = max(dp[i], dp[j]+1)



print(n - max(dp))


# <시행 착오 >
# dp = [0]*(n+1)
# ALinkB = [(0,0)]
# def isCross(x,y):
#     if x != y:
#         if ALinkB[x][0] < ALinkB[y][0] and ALinkB[y][1] < ALinkB[x][1]:
#             return True
#         if ALinkB[x][0] > ALinkB[y][0] and ALinkB[y][1] > ALinkB[x][1]:
#             return True
#     return False

# for _ in range(n):
#     ALinkB.append(tuple(map(int,input().split())))

# for i in range(1,n+1):
#     for j in range(1,n+1):
#         if isCross(i,j):
#             cross[i] += 1

# dp table 만들기 .. 
# 근데 너무 비효율적,, 다른 방법없을까?

분류

다이나믹 프로그래밍(dp)

문제 원본 소스코드 원본

INSERT 문 을 사용하여 테이블에 새 행을 입력한다.

테이블 생성

create table sawon(
id number(5),
name varchar2(20),
salary number(20)
);

테이블 확인

select * from sawon;

insert 구문

지정하지않고 넣기

insert into sawon values( 100, '김구', 3300);

지정해서 넣기

insert into sawon (name,id) values('홍길동', 200);

다른 테이블에서 추출해서 넣기

같은 쿼리문 2번 수행하면 중복 값이 추가됨

insert into sawon select empno,ename,sal*2
from emp
where deptno = 10;

UPDATE 구문

UPDATE 문 을 사용하여 특정 열의 값을 변경할 수 있음 WHERE 절을 생략하면 테이블의 모든 행이 수정됨의 유의

update sawon 
set salary = 5500, name='김구성'
where name ='김구';

sawon 테이블을 수정할거야 name 이 김구 인 녀석의 salary 를 5500으로 name을 김구성으로 바꿔줘

서브쿼리를 이용한 UPDATE

-- sawon 테이블의 id =200 인 녀석을 emp 테이블 10번 부서 급여 합계로 변경해줘
update sawon
set salary = (select sum(sal) 
              from emp
              where deptno = 10)
where id = 200;

sawon 테이블의 id =200 인 녀석을 emp 테이블 10번 부서 급여 합계로 변경해줘

DELETE 구문

delete sawon where id = 100;

-- player 선수중에서 서동명 선수와 포지션이 같은 선수는??
-- "=" 을 사용하면 결과 한개만 가능 
select player_name, height, position
from player 
where position = (select position
                  from player
                  where player_name = '서동명');


-- player 선수중에서 박동우 선수와 포지션이 같은 선수는??
-- "in" 을 사용하면 결과 한개만 가능 
select player_name, height, position
from player 
where position in (select position
                  from player
                  where player_name = '박동우');                  

ANY

-- emp 테이블 30번 부서에서 소속된 아무 사원 보다 급여를 더 많이 받는 사원을 조회 
select ename, sal, deptno 
from emp
where sal > any(select sal from emp
                where deptno = 30);     

같은 의미로 Any 을 사용하지 않고 표현 할 수 있다.

 -- emp 테이블 30번 부서에서 소속된 아무 사원 보다 급여를 더 많이 받는 사원을 조회 
select ename, sal, deptno 
from emp
where sal > (select min(sal) from emp
                where deptno = 30);   

ALL

-- emp 테이블 30번 부서에서 소속된 모든 사원 보다 급여를 더 많이 받는 사원을 조회 
select ename, sal, deptno 
from emp
where sal > all(select sal from emp
                where deptno = 30);    

같은 의미로 All 을 사용하지 않고 표현 할 수 있다.

select ename, sal, deptno 
from emp
where sal > (select max(sal) from emp
                where deptno = 30);

다중 컬럼 서브퀴리 사용 예시

(player_name이 '사샤','박동우' 둘 중 하나랑 같으면 돼요) AND (position이 '사샤','박동우' 둘 중 하나랑 같으면 돼요)

select team_id, player_name, height, position
from player 
where team_id in (select team_id from player
                  where player_name in('샤샤', '박동우'))
      and
      position in ( select position from player
                  where player_name in('샤샤', '박동우'));

player_name,position이 '사샤','박동우' 둘과 같아야 돼요

select team_id, player_name, height, position
from player 
where (team_id,position) in ( select team_id,position
                  from player
                  where player_name in('샤샤', '박동우'));

두 원이 주어졌을 때, 교차하는 영역의 넓이를 소수점 셋째자리까지 구하는 프로그램을 작성하시오.

입력

첫째 줄에 두 원의 중심과 반지름 x1, y1, r1, x2, y2, r2가 주어진다. 실수는 최대 소수점 둘째자리까지 주어진다.

출력

첫째 줄에 교차하는 영역의 넓이를 반올림해 소수점 셋째자리까지 출력한다.

문제 분석 과정

주어진 값은 두 원의 중심과 반지름이다. 우선 두 원의 중심을 알고 있으니 두 원의 중심 사이 거리를 구할 수 있다. (점과 점사이의 거리)

두 원의 중심 사이의 거리를 알았다면 두 원의 포지션을 3가지로 나눌 수 있게된다.

Case1. 교집합 면적이 작은원 그 자체인 경우 : |r1-r2|>=d Case2. 교집합 면적이 없는 경우 : r1+r2<=d Case3. 그 외의 모든 경우

우선 Case1.의 경우 작은 원이 교집합되는 면적 그 자체이기 때문에 추가적인 계산 없이 작은 원의 넓이를 출력하면 된다.

다음으로 Case2.의 경우 작은 원이 교집합되는 면적이 없기 때문에 0.000 을 출력하면 된다.(한 점에서 만나는 경우도 포함시켰으나 한 점에서 만나는 경우는 두 원이 접하는 경우 이므로 카운팅하지않는다.)

마지막으로 Case3. 의 경우가 가장 일반적인 경우인데 이때의 두 원을 관찰해보자. Case3.의 두 원은 반드시 두점에서 만나게 된다. 이 경우 우리는 각 원의 중심과 반지름 그리고 각 원의 중심 사이 거리를 알 수 있다. 두 원의 중심끼리 선(이하 d)으로 이어보자. 그럼 d를 공유하는 두개의 삼각형이 만들어진다.이때 두 삼각형은 SSS합동이고, 이 두 삼각형의 모든 변의 길이를 우리는 알고 있게된다. 모든 변의 길이를 알고 있으므로 제 2 코사인 법칙을 이용해 각도 또한 알 수있고, 두 삼각형은 합동이므로 두 삼각형을 합친 각도까지 알 수 있다.

교집합을 구하기위해서는 각 원의 부채꼴의 넓이와 선분d 를 공유하는 두 삼각형의 넓이를 알아야한다. (부채꼴 - 삼각형) 삼각형의 넓이는 두 변과 끼인 사잇각을 통해서 구할 수 있다.

위 과정을 거치면 정답을 구할 수 있다.

점과 점사이의 거리

$$ d = \sqrt{(x_1-x_2)^2+(y_1-y_2)^2} $$

제 2 코사인 법칙

$$ \cos\theta = (r_1^2 + d^2 - r_2^2) \over (2r_1d) $$ $$ \theta = \arccos({ r_1^2 + d^2 - r_2^2 \over 2r_1d}) $$

삼각형의 넓이

$$ S = {sin(\theta)*r_1^2\over2} $$

소스코드

import math

x1, y1, r1, x2, y2, r2 = map(float,input().split())
# 두 원의 중심사이 거리
d = math.sqrt(pow(x1-x2,2)+pow(y1-y2,2))

def getS(d,r1,r2):
    # 제2 코사인 으로 사잇각 구하기
    theta = math.acos((pow(r1,2) + pow(d,2) - pow(r2,2)) / (2*r1*d))

    s2 = math.sin(2*theta)*pow(r1,2)/2
    s1 = pow(r1,2)*theta

    return(s1-s2)

#영역이 없다.
if r1+r2<=d :
    result = 0.000

# 큰원에 작은원이 포함된 경우
elif abs(r1-r2)>=d :    
    result = math.pi * pow(min(r1,r2),2) 

else:
    result = getS(d,r1,r2)+ getS(d,r2,r1)  




print('%.3f' % result)

소스코드 원본 문제 원본

수열 A가 주어졌을 때, 가장 긴 증가하는 부분 수열을 구하는 프로그램을 작성하시오.

예를 들어, 수열 A = {10, 20, 10, 30, 20, 50} 인 경우에 가장 긴 증가하는 부분 수열은 A = {10, 20, 10, 30, 20, 50} 이고, 길이는 4이다.

입력

첫째 줄에 수열 A의 크기 N (1 ≤ N ≤ 1,000)이 주어진다.

둘째 줄에는 수열 A를 이루고 있는 Ai가 주어진다. (1 ≤ Ai ≤ 1,000)

출력

첫째 줄에 수열 A의 가장 긴 증가하는 부분 수열의 길이를 출력한다.

문제분석과정

가장 긴 증가하는 부분 수열을 구하기 위해서 어떻게해야할까 ? 일단 메모지에이션을 하기위해 dp를 정의하고 dp[1]뭔지 찾아보자 dp를 어떻게 정의해야할지 감이 오지않으니까 증가부분수열을 관찰해보자

i에 대한 분석

6 10 20 10 30 20 50 이 주어졌을 때,

10 - 1 / 10 20 - 2 / 10 20 10 - 1 /
10 20 10 30 - 3 /
10 20 10 30 20 - 2 /
10 20 10 30 20 50 - 4 /

dp[끝나는 인덱스] = 끝나는 인덱스 일때 최장 부분 수열

한칸씩 이동하며 전체적으로 증가시킴 모든 초기값은 자기자신 한 개인 경우로 1개이다.

10 20 10 30 20 50 일 때 1 1 1 1 1 1 1 / i = 2 1 1 2 1 1 1 1 / i = 3 1 1 2 1 3 1 1 / i = 4 1 1 2 2 3 2 1 / i = 5 1 1 2 2 3 2 4 / i = 6

j에 대한 분석

점화식 을 찾기 위해서 i = 5를 관찰해보자, 20과 같거나 큰 녀석들은 무시한다.

1 1 2 1 3 1 1 / 현재 dp Table 10 10 20(현재 피벗) dp[4] = 1

1 1 2 1 3 1 1 / 현재 dp Table / j = 1 10(체크)10 20(현재 피벗) dp[4] = (1 , dp[1]+1 = 2)

1 1 2 1 3 1 1 / 현재 dp Table / j = 4 10 10(체크)20(현재 피벗) dp[4] = max(1 , dp[4]+1 = 2)

i를 조사할때, 현재까지 인덱스i로 끝나는 녀석 인덱스j로 조사하는데 인덱스j로 끝나는 녀석에게 인덱스i를 붙힌 녀석 둘중 큰값을 dp[i]로 최신화 되며, j를 다돌면 dp[i]가 산정된다.

각 i 마다 위과정들을 다 거친후 max(dp) 하게되면 정답을 구할 수 있다. 한 가지 주의 사항은 0번째 index를 추가해줄때 입력값을 고려해서 추가해줘야한다.

입력으로 1000 보다 큰 수가 나올 수 없으므로 정답에 영향을 주지 못한다. 다른 방법으로는 dp ,arr 의 크기를 n+1 이아니라 n으로 초기화해도 가능하지만 다이나믹 프로그래밍 알고리즘은 리스트의 인덱스를 헷갈리지않게 처리해야하므로 입력값을 고려하는게 더 좋은 선택이라고 생각한다.

n = int(input())

arr = [1001] + list(map(int,input().split()))

# 가장 긴 증가하는 부분 수열을 구하기 위해서 어떻게해야할까 ? 
# 일단 메모지에이션을 하기위해 dp를 정의하고 dp[1]뭔지 찾아보자
# dp를 어떻게 정의해야할지 감이 오지않으니까 증가부분수열을 관찰해보자
# 10 - 1   
# 10 20  - 2   
# 10 20 10  - 1   
# 10 20 10 30  - 3    
# 10 20 10 30 20  - 2    
# 10 20 10 30 20 50 -  4 


# dp[끝나는 인덱스] =  끝나는 인덱스 일때 최장 부분 수열
# 한칸씩 이동하며 전체적으로 증가시킴
# 모든 초기값은 자기자신 한 개인 경우로 1개이다.

# 10 20 10 30 20 50 일 때
#1 1  1  1  1  1  1 / i = 2
#1 1  2  1  1  1  1 / i = 3
#1 1  2  1  3  1  1 / i = 4
#1 1  2  2  3  2  1 / i = 5
#1 1  2  2  3  2  4 / i = 6

# 점화식 을 찾기 위해서 i = 5를 관찰해보자 
# 20과 같거나 큰 녀석들은 무시한다.

# 1  1   2   1  3  1  1  / 현재 dp Table 
#    10     10     20(현재 피벗)   dp[4] = 1

# 1  1   2   1  3  1  1  / 현재 dp Table / j = 1
#    10(체크)10     20(현재 피벗)   dp[4] = (1 , dp[1]+1 = 2)

# 1  1   2   1  3  1  1  / 현재 dp Table / j = 4
#    10     10(체크)20(현재 피벗)   dp[4] = max(1 , dp[4]+1 = 2)
# i를 조사할때
# 현재까지 인덱스i로 끝나는 녀석
# 인덱스j로 조사하는데 인덱스j로 끝나는 녀석에게 인덱스i를 붙힌 녀석
# 둘중 큰값을 dp[i]로 최신화. j를 다돌면 dp[i]가 산정된다.
# 위과정들을 다
# 정답은 max(dp)
dp = [1]*(n+1)

for i in range(2,n+1):
    for j in range(1,i):
        if arr[i] > arr[j]:
            dp[i] = max(dp[i], dp[j] + 1)

print(max(dp))

분류

다이나믹 프로그래밍(dp)

소스코드 원본

문제원본

45656이란 수를 보자.

이 수는 인접한 모든 자리의 차이가 1이다. 이런 수를 계단 수라고 한다.

N이 주어질 때, 길이가 N인 계단 수가 총 몇 개 있는지 구해보자. 0으로 시작하는 수는 계단수가 아니다.

입력

첫째 줄에 N이 주어진다. N은 1보다 크거나 같고, 100보다 작거나 같은 자연수이다.

출력

첫째 줄에 정답을 1,000,000,000으로 나눈 나머지를 출력한다.

문제분석과정

45656 ? 인잡한 자리가 1 씩 차이가난다.

N 주어질 때, 총 계단의 길이가 N 인 계단수를 구하자.

N = 1 일때는 어떻게 될까?

N = 1 일때는 한자리 모든수가 가능하다 0씩 차이난다고 볼 수 있기 때문이다.

N = 2 일때는? 10의자리는 N = 1일때와같다.

겹치니 점화식을 사용하기위해 N = k 일때 dp[k]는 계단 수의 갯수라고 하자.

다시 N = 2 일때를 살펴보자 10의자리는 N = 1일때와 같으므로 (십의 자리])(일의 자리) = (dp[1])(dp[1]+-1) = dp[1]*2 - 1(10일때)

dp 테이블이만들어지기위해서는 자리수와 앞에오는 자리를 통제할 수있어야한다. 따라서 2차원 dp 테이블로 만들어야한다.

dp[자리 수 1][앞에 어떤 수?] = 현재 자리수 + 앞에 어떤 수 = 갯수
정답은 sum(dp[n])

dp[1][1] ~ dp[1][9] = 1 1 2 3 4 5 6 7 8 9
1 1 1 1 1 1 1 1 1

dp[2][1] = 1 , dp[2][2] ~ dp[2][8] = 2 ,dp[2][9] = 1 0 1 2 3 4 5 6 7 8 9
1 1 2 2 2 2 2 2 2 1

dp[3][1]~ dp[3][8] 1 2 3 4 5 6 7 8 dp[3][18] = dp[2][07] + dp[2][1~9] dp[3][9] = dp[2][8]

dp[현재 자리수][0] = dp[현재 자리수 -1][1] dp[현재 자리수][1~8] = dp[현재 자리수 -1][앞의 수 +-1] dp[현재 자리수][9] = dp[현재 자리수 -1][8]

#  
import sys
input = sys.stdin.readline

# 45656 ? 인잡한 자리가 1 씩 차이가난다.
# N 주어질 때, 총 계단의 길이가 N 인 계단수를 구하자.
# N = 1 일때는 어떻게 될까? 

# N = 1 일때는 한자리 모든수가 가능하다 0씩 차이난다고 볼 수 있기 때문
# N = 2 일때는? 10의자리는 N = 1일때와같다. 겹치니 점화식을 사용하기위해 
# N = k 일때 dp[k]는 계단 수의 갯수라고 하자.
# 다시 N = 2 일때를 살펴보자 10의자리는 N = 1일때와 같으므로
# (십의 자리])(일의 자리) = (dp[1])(dp[1]+-1) = dp[1]*2 - 1(10일때)
# dp 테이블이만들어지기위해서는 자리수와 앞에오는 자리를 통제할 수있어야한다.
# 따라서 2차원 dp 테이블로 만들어야한다. 

# dp[자리 수 1][앞에 어떤 수?] = 현재 자리수 + 앞에 어떤 수 = 갯수  
# 정답은 sum(dp[n])

# dp[1][1] ~ dp[1][9] = 1
#  1  2  3  4  5  6  7  8  9  
#  1  1  1  1  1  1  1  1  1

# dp[2][1] = 1 , dp[2][2] ~ dp[2][8] = 2 ,dp[2][9] = 1
# 0  1  2  3  4  5  6  7  8  9  
# 1  1  2  2  2  2  2  2  2  1

# dp[3][1]~ dp[3][8] 
#  1  2  3  4  5  6  7  8 
# dp[3][1~8] = dp[2][0~7] + dp[2][1~9]
# dp[3][9] = dp[2][8]

# dp[현재 자리수][0] = dp[현재 자리수 -1][1]
# dp[현재 자리수][1~8] = dp[현재 자리수 -1][앞의 수 +-1]
# dp[현재 자리수][9] = dp[현재 자리수 -1][8]
n = int(input())

dp = [0]*(n+1)
dp[1] = [1 for _ in range(1,10)] +[0]

for i in range(2,n+1):
    dp[i] = [0 for _ in range(0,11)]


for i in range(2,n+1):

    dp[i][0] = dp[i-1][1]

    for j in range(1,9):
        dp[i][j] = dp[i-1][j-1]+dp[i-1][j+1]

    dp[i][9] = dp[i-1][8]

print(sum(dp[n])%1000000000)

분류

다이나믹 프로그래밍(dp)

문제 설명

n개의 정수로 이루어진 임의의 수열이 주어진다. 우리는 이 중 연속된 몇 개의 수를 선택해서 구할 수 있는 합 중 가장 큰 합을 구하려고 한다. 단, 수는 한 개 이상 선택해야 한다.

예를 들어서 10, -4, 3, 1, 5, 6, -35, 12, 21, -1 이라는 수열이 주어졌다고 하자. 여기서 정답은 12+21인 33이 정답이 된다.

입력

첫째 줄에 정수 n(1 ≤ n ≤ 100,000)이 주어지고 둘째 줄에는 n개의 정수로 이루어진 수열이 주어진다. 수는 -1,000보다 크거나 같고, 1,000보다 작거나 같은 정수이다.

출력

첫째 줄에 답을 출력한다.

문제 분석과정

연속합의 최대는 어떻게 만들어질까?

연속합은 어떤인덱스 x 에서 시작해서 어떤인덱스 y에서 종료된다. 종료되는 y 인덱스 관점에서 살펴보자 dpTable 을 생성하고 dpTable에 의미를 부여하자(정의하자) dpTable은 종료되는 인덱스까지의 연속합의 맥스값이다. 정답은 max(dpTable)이 될 것이다.

테이블을 만들기위해 초기값을 살펴보자 (인덱스가 헷갈릴 수 있으므로 배열으크기를 n+1로 초기화해준다. ) 주어진 배열이 0 10 -4 3 1 5 6 -35 12 21 -1 라고 할때 dp[1]은 무엇일까?

dp[1]은 10이다. dp[2]는? dp[2]은 10 -4 이다. dp[3]는? dp[3]은 10 -4 +3 이다. dp[4]는? dp[4]은 10 -4 +3 +1이다. dp[5]는? dp[5]은 10 -4 +3 +1 +5이다. dp[6]는? dp[6]은 (10 -4 +3 +1 +5+ 6) = 21이다. dp[7]는? dp[7]은 (10 -4 +3 +1 +5+ 6 -35) = -14이다. dp[8]는? dp[8]은 max((10 -4 +3 +1 +5+ 6 -35),12) = 12이다. dp[k] = max(dp[k-1]+arr[k], arr[k]) 위 케이스를 통해서 점화식을 생성할 수 있다. dp[9] = max(dp[8]=12+21, 21) = 33 dp[10] = max (dp[9]-1, -1) = 32

여기서 주의사항이 한가지가 있다. 바로 초기화값인데, 인덱스를 헷갈리지않게 하기위해서 추가하는데이터값에 주의해야한다.

보통이런경우 통상적으로 0을 추가하는데 해당문제에서 0으로 추가하는 경우 통과하지못하는 테스트 케이스가 나온다.

어떤 케이스 일까 ? 바로 모든 수가 음수인 경우이다. -3 -4 -7 -3 다음과 같은 테스트케이스가 들어왔다고 생각해보자. 그럼 arr는 arr = [0,-3,-4,-7,-3]이 될 테고 dp = [0,-3,-4,-7,-3]이 될것이다. 따라서 max(dp) = 0이되고 원하는 답인 -3 이 출력되지않게된다. 그럼 방지하기위해서 어떻게해야할까? 입력데이터를 확인해보자, 입력데이터는 "-1,000보다 크거나 같고, 1,000보다 작거나 같은 정수이다." 라고 주어져있다. 따라서 -1001 보다 같거나 작은수는 절대로 나올 수 없다 . 그럼 이조건을 활용해 인덱스 0번째 데이터를 -1001로 초기화하면 모든 수가 음수인 경우를 문제없이 해결할 수 있다.

소스코드

import math
n = int(input())
arr = [0]+list(map(int,input().split()))
dp = [-1001]*(n+1)
# 연속합의 최대는 어떻게 만들어질까? 

# sol
# 연속합은 어떤인덱스 x 에서 시작해서 어떤인덱스 y에서 종료된다.
# 종료되는 y 인덱스 관점에서 살펴보자 
# dpTable 을 생성하고 dpTable에 의미를 부여하자(정의하자)
# dpTable은 종료되는 인덱스까지의 연속합의 맥스값이다.
# 정답은 max(dpTable)이 될 것이다.
# 테이블을 만들기위해 초기값을 살펴보자 
# (인덱스가 헷갈릴 수 있으므로 배열으크기를 n+1로 초기화해준다. )
# 주어진 배열이 0 10 -4 3 1 5 6 -35 12 21 -1 라고 할때
# dp[1]은 무엇일까? dp[1]은 10이다. 
# dp[2]는? dp[2]은 10 -4 이다. 
# dp[3]는? dp[3]은 10 -4 +3 이다. 
# dp[4]는? dp[4]은 10 -4 +3 +1이다. 
# dp[5]는? dp[5]은 10 -4 +3 +1 +5이다. 
# dp[6]는? dp[6]은 (10 -4 +3 +1 +5+ 6) = 21이다. 
# dp[7]는? dp[7]은 (10 -4 +3 +1 +5+ 6 -35) = -14이다. 
# dp[8]는? dp[8]은 max((10 -4 +3 +1 +5+ 6 -35),12) = 12이다. 
# dp[k] = max(dp[k-1]+arr[k], arr[k]) 위 케이스를 통해서 점화식을 생성할 수 있다.
# dp[9] = max(dp[8]=12+21, 21) = 33
# dp[10] = max (dp[9]-1, -1) = 32

# 여기서 주의사항이 한가지가 있다.
# 바로 초기화값인데, 인덱스를 헷갈리지않게 하기위해서 추가하는데이터값에 주의해야한다.
# 보통이런경우 통상적으로 0을 추가하는데 해당문제에서 0으로 추가하는 경우 통과하지못하는 테스트 케이스가 나온다.
# 어떤 케이스 일까 ? 바로 모든 수가 음수인 경우이다. 
# -3 -4 -7 -3
# 다음과 같은 테스트케이스가 들어왔다고 생각해보자.
# 그럼 arr는 arr = [0,-3,-4,-7,-3]이 될 테고 
# dp = [0,-3,-4,-7,-3]이 될것이다. 따라서 max(dp) = 0이되고 원하는 답인 -3 이 출력되지않게된다.
# 그럼 방지하기위해서 어떻게해야할까?
# 입력데이터를 확인해보자, 입력데이터는 "-1,000보다 크거나 같고, 1,000보다 작거나 같은 정수이다." 라고 주어져있다.
# 따라서 -1001 보다 같거나 작은수는 절대로 나올 수 없다 . 그럼 이조건을 활용해 인덱스 0번째 데이터를 -1001로 초기화하면 
# 모든 수가 음수인 경우를 문제없이 해결할 수 있다.

for i in range (1,n+1):
    dp[i] = max(dp[i-1]+arr[i],arr[i])

print(max(dp))

소스코드 원본

문제 원본

분류

다이나믹 프로그래밍(dp)

오류나 질문에 대한 문의 댓글로 남겨주세요!

상근이는 요즘 설탕공장에서 설탕을 배달하고 있다. 상근이는 지금 사탕가게에 설탕을 정확하게 N킬로그램을 배달해야 한다. 설탕공장에서 만드는 설탕은 봉지에 담겨져 있다. 봉지는 3킬로그램 봉지와 5킬로그램 봉지가 있다.

상근이는 귀찮기 때문에, 최대한 적은 봉지를 들고 가려고 한다. 예를 들어, 18킬로그램 설탕을 배달해야 할 때, 3킬로그램 봉지 6개를 가져가도 되지만, 5킬로그램 3개와 3킬로그램 1개를 배달하면, 더 적은 개수의 봉지를 배달할 수 있다.

상근이가 설탕을 정확하게 N킬로그램 배달해야 할 때, 봉지 몇 개를 가져가면 되는지 그 수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N이 주어진다. (3 ≤ N ≤ 5000)

출력

상근이가 배달하는 봉지의 최소 개수를 출력한다. 만약, 정확하게 N킬로그램을 만들 수 없다면 -1을 출력한다.

문제분석과정

우선 주어진 테스트 케이스로 분석을 시작해보자 에는 dp(k) 는 k만큼 배달해야 할 때 최소 봉지 갯수이다. n 이 3일 때는 1 이되고 dp[3]이다 dp[3] = 1 ,n 이 5일 때 역시 1 이되고 dp[5] = 1 이 된다. n=6 일 때는 2가 되는데 3+3 이합쳐서 2가된다 이것을 다시 표현하면 dp[6] = dp[3]+dp[3]으로 표현 할 수있다 아래같은 방법을 진행하다보면

4가지 경우가 있다는 것을 알 수 있다.

• 3만 가능한 경우 3키로 추가만 가능하다면 3키로 전 dp값에 1 추가

• 5만 가능한 경우 5키로 추가만 가능하다면 5키로 전 dp값에 1추가

• 3,5 둘다 가능한 경우 3,5키로 추가만 가능하다면 5키로 전 dp값에 1추가

• 둘다 불가능한 경우 둘 다 불가능하다면 연산 불가 (-1) 할당

소스코드

n = int(input())

dp = [-1 for _ in range(5001)]


# n = 3 / 1 # dp[3]
# n = 5 / 1 # dp[5]
# n = 6 / 2 # dp[3]+dp[3]
# n = 8 / 2 # dp[3]+dp[5]
# n = 9 / 3 # dp[3]+dp[6]
# n = 10 / 2 # dp[5]+dp[5]
# n = 11 / 3 # dp[5]+dp[6]
# n = 12 / 4 # dp[3]+dp[9]
# n = 13 / 3 # dp[3]+dp[10]
# n = 15 / 3 # min(dp[3]+dp[12], dp[5]+dp[10])
dp[3] = 1
dp[5] = 1

# dp 테이블 작성
for i in range(6, n + 1):
# a : 5키로 추가 전 무게의 봉투 최소값
# b : 3키로 추가 전 무게의 봉투 최소값
    a, b = dp[i], dp[i] 

# 5키로 추가 전 메모라값 할당
    if dp[i - 5] != -1:
        a = dp[i - 5]
# 3키로 추가 전 메모리값 할당
    if dp[i - 3] != -1:
        b = dp[i - 3]

# 3, 5키로 둘 다 가능하다면 둘 중 작은 값 선택
    if a > 0 and b > 0:
        dp[i] = min(a + 1, b + 1)
# 5키로 추가만 가능하다면 5키로 전 dp값에 1추가
    elif a > 0 and b < 0:
        dp[i] = a + 1
# 3키로 추가만 가능하다면 3키로 전 dp값에 1 추가
    elif a < 0 and b > 0:
        dp[i] = b + 1
# 둘 다 불가능하다면 연산 불가 (-1) 할당
    else:
        dp[i] = -1

print(dp[n])

분류

다이나믹 프로그래밍(dp), 그리디 알고리즘(greedy), 수학(math)

#RANK

각 Row 에 순위를 부여하는 함수 order by 절의 기준으로 정렬 동일한 값일 경우 같은 순위로 출력

select empno, ename, deptno, sal,
       rank() over (order by sal desc) 순위
from emp;

select empno, ename, deptno, sal,
       rank() over (partition by deptno order by sal desc) 순위
from emp;

#DENSE_RANK()

RANK()와 모든 기능이 같음

• DENSE_RANK() : 동일한 값일 경우 갯수와 상관없이 다음 순위 +1
• RANK() : 동일한 값일 경우 갯수를 고려해서 +n

select empno, ename, deptno, sal,
        dense_rank() over (order by sal desc) 순위1번,
        rank() over (order by sal desc) 순위2번
from emp;

#ROW_NUMBER()

RANK()와 모든 기능이 같음

select empno, ename, deptno, sal,
        dense_rank() over (order by sal desc) 순위1번,
        rank() over (order by sal desc) 순위2번,
        row_number() over (order by sal desc) 순위3번
from emp;

#NTILE()

NTILE(arg) 은 order by 절 기준을 따라서arg 개 만큼 그룹으로 나누는 함수

select ename,  sal, 
       ntile(3) over (order by sal desc)        
from emp;

select 한 col을 값들로 그룹화 한다.

한 개 그룹으로 묶기

select deptno,count(*),sum(sal), avg(sal)
from emp
group by deptno
order by deptno;

두 개 그룹으로 묶기

select job,deptno,count(*),sum(sal), avg(sal)
from emp
group by job,deptno
order by deptno;

HAVING 의 기능

group by로 집계된 데이터를 having 조건으로 필터링함

그럼 group by 와 having 의 차이는 뭘까?

• where 절은 묶기 전에 조건으로 필터링함
• having절은 묶고 난 후 조건으로 필터링함

having 사용 예시

select team_id, avg(height)
from player
group by team_id
order by avg(height);

select team_id, avg(height)
from player
group by team_id
having avg(height) > 180
order by avg(height);

다중 행 메소드 는 그룹 함수, 집계 함수 라고도 한다.

단일 행 메소드와 달리 그룹 함수 는 전체 집합 또는 그룹으로 분류된 집합에 작용하여 그룹당 하나의 결과를 생성한다.

다중 행 함수의 종류

DISTINCT 와 ALL

다중 행 메소드에서는 DISTINCT 를 사용하여 중복을 제거 할 수 있다. 중복된 데이터들도 표현하기 2 가지 방법이 있는데 , ALL을 사용하여 중복되는 데이터를 표현 하거나 지정을 아예 안하여 중복되는 데이터를 표현할 수 있다. (즉, default 가ALL임)

#COUNT()와 COUNT(*)

#COUNT()

• COUNT() 는 NULL 을 제외하고 처리한다.
• 모든 타입을 사용한다. NULL 을 제외하고 데이터의 갯수를 반환 ```sql select count(sal) from emp where sal > 1000;
• • sal 이 1000 초과인 데이터의 갯수(NULL 제외) 는 12개

    ![](https://velog.velcdn.com/images/hwang_bbang/post/365e0f7f-7a31-4b9e-89b2-4450ffbbb035/image.png)
    
    
    

#COUNT(*)

• COUNT(*) 는 NULL 을 포함하고 처리한다.
• 모든 타입을 사용한다. NULL 을 포함한 데이터의 갯수를 반환 ```sql select count(*) from emp where sal > 1000;
• • sal 이 1000 초과인 데이터의 갯수(NULL 포함) 는 12개

    ![](https://velog.velcdn.com/images/hwang_bbang/post/ac30f7a5-0658-421e-91ec-caa48e5a61e5/image.png)
    

#SUM()

• NULL 을 제외하고 처리한다.
• 숫자 타입만 사용한다.

  select sum(comm)
  from emp;

  

#AVG()

• NULL 을 제외하고 처리한다.
• 숫자 타입만 사용한다.

select avg(comm)
from emp;

NULL 값을 0으로 반환 하여 평균을 내는 경우

select avg(nvl(comm,0))
from emp;

#MAX()

• NULL 을 제외하고 처리한다.
• 모든 타입을 사용한다.

#MIN()

• NULL 을 제외하고 처리한다.
• 모든 타입을 사용한다.

#STDDEV()

• NULL 을 제외하고 처리한다.
• 숫자 타입만 사용한다.

#VARIANCE()

• NULL 을 제외하고 처리한다.
• 숫자 타입만 사용한다.

#문자 함수

LOWER()

UPPER()

#숫자 함수

ROUND()

TRUNC()

MOD(M,N)

ABS()

FLOOR()

CEIL

SIGN

POWER(M,N)

#날짜 함수

#변환 함수

#일반 함수

NVL(par1, par2)

NULL 값을 다른 값으로 변경할 때 사용함

par1가 NULL이라면 par2를 반환 par1가 NULL아니라면 par1를 반환

select ename, sal, comm, NVL(comm,0) from emp;
-- comm 가 NULL 이라면 0
-- comm 가 NULL 이 아니라면 comm

NVL2(par1, par2, par3)

NULL 값을 다른 값으로 변경할 때 사용함

par1가 NULL이라면 par3를 반환 par1가 NULL아니라면 par2를 반환

select ename, comm, NVL2(comm,'[등록O]'||comm, '[등록X]')
from emp;
-- comm 가 NULL 이라면 par3 실행 : '[등록X]'
-- comm 가 NULL 이 아니라면 par2 실행 : '[등록O]'||comm

NULLIF(par1, par2)

par1 값과 par2가 같을 때, NULL 을 반환 par1 값과 par2가 같지 않을 때, par1 을 반환

select ename,job, nullif(job,'SALESMAN')
from emp;

-- job 이 'SALESMAN' 이라면 Null 반환  
-- job 이 'SALESMAN' 이 아니라면 job 을 반환

COALESCE(par1,par2, , , parN)

par1 부터 parN까지 순서대로 조회해서 처음으로 등장하는 NULL 이 아닌 값을 반환 모든 par 가 NULL이라면 NULL 반환

select comm,sal,9999,coalesce( comm ,sal,9999)
from emp;
-- comm 이 NULL 이 아니라면 comm 반환
-- comm 이 NULL 이 라면 sal 확인 
-- sal 이 NULL 이 아니라면 sal 반환 
-- sal 이 NULL 이라면 9999 확인 
-- 9999 는 NULL 이 아니므로 9999 반환 

DECODE(val, comp1, res1, comp2, res2..., default)

select 에 = 조건을 걸어 사용할 때 사용

c.f) where절은 필터링 되어 표시 또한 select 절에 사용 불가함

select ename, sal, decode(sal,
3000,'A팀',
5000,'B팀',
'C팀')
from emp;
-- sal = 3000 이라면 'A팀'
-- sal = 5000 이라면 'B팀'
-- 그 외의 sal 값은 'C팀'

CASE

select 에 다양한 조건을 걸어 사용할 때 사용

case when 조건 then 반환값 when 조건 then 반환값 when 조건 then 반환값 else 디폴트반환값 end

c.f) DECODE는 =만 사용 할 수 있는 반면 , CASE 는 다양한 조건을 걸어서 사용 할 수 있다.

select ename, sal, 
case when sal < 3000 then 'A팀'
when sal > 4000 then 'B팀'
else 'C팀' end
from emp;

char : 1Byte

문자 하나를 1바이트로 표현 1Byte = 8Bit 이고, 8Bit는 0255 까지 이다. 하지만 맨 앞자리에 UTF-8 같은 것을 표현해야하므로, 실질적으로 0127 까지만 표현 할 수 있고 아스키코드 또한 0~127 까지 있다. 이러한 이유로 char 형을 사용하면 한글은 표현 할 수없다.

    char c = 'a';

wchar : 2Byte

문자 하나를 2바이트로 표현

    wchar_t c = L'a';

문자앞에 L을 붙혀준다. (2byte 단위로 사용한다는 의미이다.)

추가적으로, 문자열 이라고 다를껀 없다. c.f) 문자열 끝 NULL이 있는것 까지 생각해서 문자열 크기를 산정해야한다.

    wchar_t c[10] = L"abcdef";

SELECT 구문

select 컬럼명 from 테이블명;

select : 표시할 Column 들을 선택함

from : 테이블을 선택함

산술 연산

산술 연산자 + ,-,*,/ 를 이용해서 숫자나 날짜 데이터에 대한 계산 식을 작성할 수 있다.

select ename, sal, sal*3 
from emp;

결과

Column의 Heading 변경하기

select col명 as 변경할 헤딩명  from ~;
select col명 변경할 헤딩명  from ~;
select col명 as "변경할 헤딩명"  from ~; 

• as 는 생략 가능

• 특수문자나 공백을 쓰고 싶을 땐 " " 을 사용하면 됨

연결연산자

연결연산자를 사용하지않았을 때

  select ename , job from emp;

연결 연산자를 사용하였을 때

select ename || job from emp;

• || 을 사용해서 조회하는 데이터를 붙일 수 있다.

중복 행 제거

select distinct deptno from emp;

• distinct 을 사용해서 중복을 제거 할 수 있다.
• 단, distinct 는 select 바로 뒤에 사용해야 한다.

WHERE 절

where 을 사용하면 조건을 주어서 Row 를 선택 할 수 있음. 다시 말해, select Col 명 으로 Col 을 선택한 후, where 특정조건 으로 Row 를 선택하는 것 임.

select Col명 from 테이블명 where 조건식;

예시

select ename ,sal ,deptno
from emp
where sal > 2000;

between A and B 문

select ename ,sal ,deptno
from emp
where sal between 850 and 1300 ;

Like 문

select ename ,sal ,deptno
from emp
where ename like 'A' ;

like 를 사용하여 포함되는지 확인할 수 있다.

테이블 이름 규칙

• 문자로 시작해야 한다.
• len 30 이하여야 한다.
• 중복된 테이블명이 없어야한다.
• A-z, 0-9, #, $, _ , 한글
• Oracle 의 예약어가 아니여야 한다.

테이블 생성시 주의사항

• 테이블 이름을 지정하고 각 Col 마다 괄호 (, ) 로 묶어야 함
• Col 명 뒤에 데이터 타입을 꼭 지정해야함

여기서 선언한 데이터 타입은 col 에서 받아드릴 데이터의 유형을 설정함

또한, Oracle 에서 제공하는 데이터타입의 종류는 문자형, 숫자형 , 날짜형 이 있음

예시

create table 테이블명(
    col명_1 number [default 기본값][조건], 
    col명_2 char [default 기본값][조건], 
    ...
)

데이터 타입

문자 데이터 타입

• CHAR(size입력) 길이 : 고정 최대 : 2000Byte Default-size : 1

• VARCHAR2(size입력) 길이 : 가변 최대 : 4000Byte Default-size : x / 무조건 size 설정 해줘야야댐

숫자 데이터 타입

• NUMBER(precision, scale) precision : 최대 자릿수 설정 scale : 소수점 이하 자릿수 설정 특징 : 정수, 실수 모두 표현하고 저장한다. 최대크기 : 21 Byte

날짜 데이터 타입

• DATE 특징 : 고정 길이의 날짜와 시간을 표현 길이 : 7 Byte
• TIMESTAMP 특징 : ms 까지 표현가능 길이 : 7~11 Byte

포인터 변수란?

int* pInt1 = nullptr; 
int* pInt2 = &p ; 

포인터 변수:  주소를 가리키는 변수이다.

### 포인터 변수의 자료형
>어떤 데이터 타입을 가리킬건지 정하는 용도이다.
포인터 변수에 자료형이 있는 이유는 다음과 같다.
만약에 포인터 변수에 자료형이 없다면?
![](https://velog.velcdn.com/images/hwang_bbang/post/50a7628f-feda-4512-b8c7-01d5858757d9/image.png)
가리키는 주소로 접근하였을 때 어디까지 읽어야하는지 알 수 없다.
예를 들어 ```int``` 형은 4 Byte 인데 ```double```형은 8 Byte 이다.
이런 경우 ```double``` 형을 ```int```형으로 읽었을 떄 잘못 된 값으로 해석해서 전혀 이상한 주소로 접근 할 수 있다. 
이런 경우 때문에 주소를 가리키는 변수(포인터 변수)의 자료형이 필요하다.
>
즉, 정리하자면 ```자료형``` + ```* 변수명``` 에서 ```자료형``` 은 해당 포인터에게 전달된 주소를 해석하는 단위 이다.


```cpp

// nullptr : null_Pointer == 아무것도 가리키지않는다.

int* pInt = nullptr; // int* pInt = 0;


// int* : int자료 변수를 가리키는 포인터 변수라고 선언
// pInt : 포인터 변수로서, 변수 i의 주소 값을 가리킨다(저장한다).

int i = 100;
int* pInt = &i


// 포인터 변수를 이용해 변수의 값을 수정하기

// *pInt : pInt가 가리키는(저장한(주소)) 변수를 참조(접근)할게요.
// pInt는 변수i읠 주소를 저장해두었다. 
// 따라서 *pInt 는 변수i 값을 가리킨다. 

(*pInt) = 200; // i : 100 -> i : 200 

주소(adress)

주소의 단위는 Byte = (8 Bit) 주소는 정수표현 방식

int i = 0;
int* pInt = &i;
pInt += 1;

pInt 는 int* 변수 이기때문에, 따라서 가리키는 곳 (주소)를 int 로 해석한다. 따라서 pInt += 1;"주소값을 1을 증가한다" 라는 의미는 다음 int 위치로 접근 즉, sizeof(int) : 4Byte 단위로 증가하게 된다.

포인터와 배열

배열의 특징

1. 배열의 묶음의 메모리는 연속적인 구조이다.
2. 배열의 이름은 배열의 시작 주소이다. ```cpp int iArr[10] = {}; // int 단위로 접근

*(iArr) = 42; // 배열의 [0]인덱스로 접근 후 초기화 *(iArr + 1) = 16; // 배열의 [1]인덱스로 접근 후 초기화

---
## 상수 (Const)

### 상수란?
> 
```cpp
const int i = 100; 

const : 변하지 않는 값 , 상수를 나타낸다.

상수와 포인터

#1. const 를 사용하지 않은 경우

int a = 0;
int* pA = &a;
>
*pA = 1; // a = 1 ,  가능
pA = nullptr; // 가능

#2. 포인터 변수가 가리키는 원본을 const화 한 경우

c.f) 포인터 변수가 가리키는 원본을 수정하는 기능이 제한되는 것

int a = 0;
const int* pConstA = &a;
>
*pConstA = 1; // 불가능 
pConstA = nullptr; // 가능

#3. 포인터 변수 자체를 const화 한 경우

int a = 0;
int* const pAConst = &a;
>
*pAConst = 1; // 가능 
pAConst = nullptr; // 불가능

#4. 포인터 변수 자체와 포인터 변수가 가리키는 원본을 const화 한 경우

int a = 0;
const int* const pConstAConst = &a;
>
*pAConst = 1; // 불가능 
pAConst = nullptr; // 불가능

🚨주의 사항🚨

int a = 0;
const int* pInt = &a; // 포인터변수가 가리키는 원본을 Const화
>
a = 100;  // 이 코드는 문제가 되지 않는다. 
*pInt = 12; // 단, 이 코드는 문제가 된다.

WHY???

const int* pInt = &a; 이 코드는 a 가 상수화가 된 것이 이라고 말하는게 아니다. int* 포인터의 기능을 제한한 것 이지 a 라는 변수가 상수화가 된 것이 아니기 때문이다.

DML(Data Manipulation Language) 데이터 조작어

• SELECT : DB에서 Data를 검색할 때 사용

• INSERT : Talbe의 새로운 행(row)을 추가한다.

• UPDATE : Talbe의 어떤 행을 변경(업데이트)한다.

• DELETE : Talbe의 행(row)을 제거한다.

• MERGE : INSERT와UPDATE를 동시에 사용한다.

DDL(Data Definition Language) 데이터 정의어

• CREATE : Talbe을 생성한다.

• ALTER :Talbe을 수정한다.

• DROP :Talbe을 삭제한다.

• RENAME : Talbe의 이름을 바꾼다.

• TRUNCATE : Talbe을 초기화 한다.

TCL(Transaction Control Language) 트랜잭션 제어어

• GRANT: 특정 DB 사용자에게 작업에 대한 엑세스 권한을 부여한다.

• REVOKE: 특정 DB 사용자에게 작업에 대한 엑세스 권한을 제거한다.

DCL(Data Control Language) 데이터 제어어

• COMMIT : DML(데이터 조작어) 문을 반영한다. / 작업을 Commit함

• ROLLBACK : DML(데이터 조작어) 문을 취소한다./ 원상태로 롤백(복구)한다.

연관된 데이터를 모아 일정한 형태로 저장해놓은것 통합 + 저장의 형태들의 집합 이라고 할 수 있다.

DB의 4 가지 특징

• *Integrated *
• *Stored *
• *Operational *
• *Shared *

Database Management System(DBMS)

직역 하면, 데이터 베이스 관리 프로그램 DBMS 를 활용하여 데이터를 입력 ,수정,삭제 등의 동작을 수행한다.

DBMS의 6가지 특징

• 데이터 중복의 최소화
• 데이터의 공용화
• 데이터의 일관성 유지
• 데이터의 무결성 유지
• 데이터의 보안성
• 표준화

Entity Relationship Diagram(ERD)

개체-관계 모델. 테이블간의 관계를 설명해주는 다이어그램 즉 DB의 구조 이다.

전처리기란?

#이 붙은 구문은 모든 컴파일 과정 중 가장 먼저 처리된다. 이 과정을 전처리기 라고한다.

define 전처리기

<전처리기 전>

    #define STARVE 0x0
    #define NORMAL 0x1
    #define FULL 0x2

    int main(void)
    {
     unsigned int state = 0x0;
     state = state | STARVE;
     state = state | NORMAL;
     state = state | FULL;

      if (state & STARVE){
          cout << "i'm hungry";
          }
      else if (state & NORMAL){
          cout << "i'm good";
          }
      else if (state & FULL){
          cout << "i'm full";
          }
      else{
          cout << "i don't know";
          }
      int state = NORMAL;          
      int state = FULL;

    }

전처리 과정을 먼저 거친 후 코드가 진행된다.

<전처리기 후>

    #define STARVE 0x0
    #define NORMAL 0x1
    #define FULL 0x2

    int main(void)
    {

     unsigned int state = 0x0;

     state = state | STARVE;
     state = state | NORMAL;
     state = state | FULL;

      if (state & 0x0){
          cout << "i'm hungry";
          }
      else if (state & 0x1){
          cout << "i'm good";
          }
      else if (state & 0x2){
          cout << "i'm full";
          }
      else{
          cout << "i don't know";
          }

      int state = 2;

    }

전처리기를 왜 사용할까?

define 전처리기를 사용하면? -> 가독성 을 얻을 수 있다. -> 유지 보수 에 용이하다.

오류나 질문에 대한 문의 댓글 혹은 메일로 남겨주세요!

비트 연산자

쉬프트

<<, >> 화살표가 가리키는 방향으로 한칸씩 민다.

2진수

$$ 0 \ 0 \ 0 \ 0 \ 0 \ 0 \ 0 \ 1 \ _2 = 1 $$ $$ \ shift \ (\Leftarrow) \qquad \times 2 $$ $$ \0 \ 0 \ 0 \ 0 \ 0 \ 0 \ 1 \ 0 \ _2 = 2 $$ $$ \ shift \ (\Leftarrow) \qquad \times 2 $$ $$ \0 \ 0 \ 0 \ 0 \ 0 \ 1 \ 0 \ 0 \ _2 = 4 $$ $$ \ shift \ (\Leftarrow) \qquad \times 2 $$ $$ \0 \ 0 \ 0 \ 0 \ 1 \ 0 \ 0 \ 0 \ _2 = 8 $$

10진수

$$ \qquad\quad 2 _{10} \ = \ 2 $$ $$ \ shift \ (\Leftarrow) \ \ \ \times 10 $$ $$ \qquad\quad 20 _{10} \ = \ 20 $$ $$ \ shift \ (\Leftarrow) \ \ \ \times 10 $$ $$ \qquad\quad 200 _{10} \ = \ 200 $$ $$ \ shift \ (\Leftarrow) \ \ \ \times 10 $$ $$ \qquad\quad 2000 _{10} \ = \ 200 0 $$

10진수 에서 자릿수 하나가 올라간다. -> 10배 증가 2진수 에서 자릿수 하나가 올라간다. -> 2배 증가

소스코드

    // 쉬프트 <<, >> 화살표가 가리키는 방향으로 한칸씩 민다.

    // 2진수 에서 자릿수 하나가 올라간다. -> 2배 증가
    // 10진수 에서 자릿수 하나가 올라간다. -> 10배 증가

    int n ; 

    unsigned char byte = 1;

    byte = byte << 1; // 한 칸 민다.
    byte <<= 1; // 한 칸 민다. 2배 한다.
    byte <<= 3; // 세 칸 민다. 2^3배 한다.
    byte <<= n; // 2^n 배 한다.


    // >> 으로 밀때는 
    // 나누기  만약 나머지가 남는다면 ?
    // 주어진 구간밖으로 밀려남 -> 사라짐 

    byte = byte >> 1; // 한 칸 민다.
    byte >>= 1; // 한 칸 민다. 2으로 나눈 몫이된다.
    byte >>= 3; // 세 칸 민다. 2^3 으로 나눈 몫이된다.
    byte >>= n; // 2^n 으로 나눈 몫이된다.

비트 곱

& 비트간의 AND 연산이다.

$$ 10010011 \ & \ 10000001 \ =
10000001 $$

비트 합

| 비트간의 OR 연산이다.

$$ 10010011 \ | \ 10000001 \ =
10010011 $$

비트 역

~ 비트간의 NOT 연산이다.

$$ \sim 10010011 \ =
01101100 $$

특정 자리의 비트값 제거

특정 비트값을 제거하기위해선 많은 방법이 있다. 그 중에서 ~역 연산 후 &곱 연산을 하여 비트 값을 제거할 수 있다.

    unsigned int A;
    unsigned int B;

    A = A & (~B);

$$ 111010\mathbf10 \ &=
(\sim 00000010) $$ $$ 111010\mathbf10 \ &=
(11111101) $$ $$ 111010\mathbf00 $$

오류나 질문에 대한 문의 댓글 혹은 메일로 남겨주세요!