tenid's dev

엔티티 정의 (작가 - 책)

@Entity
@NoArgsConstructor
@Data
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
public class Author extends BaseEntity {

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;
	
	private String name;
	
	private String country;
	
	@ManyToMany
	private List<Book> books = new ArrayList<>();

}

@Entity
@NoArgsConstructor
@Data
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
public class Book extends BaseEntity {

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;

	/*
		생략
	*/
	
	@ManyToMany
	private List<Author> authors = new ArrayList<>();

}

DDL 생성 로그

중간 매핑 테이블 생성

Hibernate :
	create table author_books (
		author_id bigint not null,
		 books_id bigint not null
	)

다른 예제 - 중간 테이블(매핑 테이블)을 직접 엔티티로 만들기

@JoinTable 없이 N:M 관계를 구현하려면 중간 테이블(매핑 테이블)을 직접 엔티티로 만들어, 2개의 N:1 or 1:N 관계로 구현해야 한다.

                              User - Order(중간 테이블을 대신하는 엔티티/user_products) - Product

장점

• 중간 테이블에 추가 컬럼을 넣을 수 있음
• 쿼리 및 연관관계 제어가 더 명확해짐
• 성능이나 JPA 캐시 관리 측면에서도 이점이 있음

@Entity
@NoArgsConstructor
@Data
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
public class BookAndAuthor extend BaseEntity {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;
	
	@ManyToOne
	private Book book;
	
	@ManyToOne
	private Author author;

}

@Entity
@NoArgsConstructor
@Data
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
public class Book extends BaseEntity {

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;

	/*
		생략
	*/
	
	@OneToMany
	@JoinColumn(name = "book_id")
	@ToString.Exclude
	private List<BookAndAuthor> bookAndAuthors = new ArrayList<>();

}

@Entity
@NoArgsConstructor
@Data
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
public class Author extends BaseEntity {

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;
	
	private String name;
	
	private String country;
	
	@OneToMany
	@JoinColumn(name = "author_id")
	@ToString.Exclude
	private List<BookAndAuthor> bookAndAuthors = new ArrayList<>();

}

DDL 생성 로그

Hibernate :
	create table book_and_author (
		id bigint generated by default as identity,
		 created_at timestamp,
		 updated_at timestamp,
		 author_id bigint,
		 book_id bigint,
		 primary key (id)
	)

N:1 (Many-to-One) 개념

정의: 여러 개의 엔티티(N)가 하나의 엔티티(1)를 참조하는 관계.

관계

• N쪽 (Many): 연관관계의 주인 → 외래키를 가짐
• 1쪽 (One): 외래키가 없음 → mappedBy로 연관관계를 역방향으로 정의 가능

@Entity
@Data
@NoArgsConstructor
public class Post {
    @Id
    @GeneratedValue
    private Long id;

    @ManyToOne
    @JoinColumn(name = "user_id") // Post 테이블에 user_id(FK) 컬럼 생성
    private User user;
}

양방향 매핑 (선택 사항)

@Entity
@Data
@NoArgsConstructor
public class User {

    @Id 
    @GeneratedValue
    private Long id;

    private String name;

    @OneToMany(mappedBy = "user")
    private List<Post> posts = new ArrayList<>();
}

mappedBy = "user": Post의 user 필드가 관계의 주인임을 나타냄 (즉, 외래 키는 Order가 관리함)

N, K = map(int, input().split())

def factorial(N):
    return N * factorial(N-1)  if N>1 else 1



print(int(factorial(N) / (factorial(N-K)*factorial(K))))

정리

이항계수란 주어진 집합에서 원하는 개수만큼 순서없이 뽑는 조합의 개수를 의미한다.

이항계수 공식은 다음과 같다

nCk = N! / (N-K)! K! 

N = int(input())


print(2 ** N)

정리

각층 마다 생기는 경우의 수는 층의 갯수마다 2의 제곱배로 늘어난다

2^N

시간 복잡도는 1번의 연산만 진행하므로 O(1) 

출처 : https://www.acmicpc.net/problem/24723

N = int(input())


print(N * (N-1))

정리

N개의 상의 중에 자신의 색상만 뺀 나머지를 선택하는 경우의 수를 구한다.

N * (N-1)

한번의 연산만 진행하므로 시간 복잡도는 O(1) 

출처 : https://www.acmicpc.net/problem/15439

import sys
from collections import deque

input = sys.stdin.readline
commands = int(input())
class Queue:
    def __init__(self):
        self.items = deque()

    def push(self, item):
        self.items.append(item)

    def pop(self):
        if self.empty():
            return -1
        return  self.items.popleft()

    def size(self):
        return len(self.items)

    def empty(self):
        return int(len(self.items) == 0)

    def front(self):
        if self.empty():
            return -1
        return self.items[0]

    def back(self):
        if self.empty():
            return -1
        return self.items[-1]



q = Queue()
for _ in range(commands):
    command = input().strip()

    if command.startswith("push"):
        _, num = command.split()
        q.push(num)
    elif command == "pop":
        print(q.pop())
    elif command == "size":
        print(q.size())
    elif command == "empty":
        print(q.empty())
    elif command == "front":
        print(q.front())
    elif command == "back":
        print(q.back())
    else:
        print("not matched")

정리

collections.deque 사용

deque는 양쪽에서 O(1) 시간에 삽입/삭제가 가능한 자료구조이므로 큐에 적합

출처 : https://www.acmicpc.net/problem/18258

기본 구조: User (1) ↔ (N) Post

• User는 여러 Post를 가질 수 있다 (1:N)
• Post는 하나의 User에만 속한다 (N:1)
• 관계 주인은 Post (외래키를 가짐)

@Entity
@Data
@NoArgsConstructor
public class User extends AuditableEntity {

    @Id 
    @GeneratedValue
    private Long id;

    private String name;

    @OneToMany
    @JoinColumn(name = "user_id", insertable = false, updatable = false) // 읽기 전용
    private List<Post> posts  = new ArrayList<>();; // post.userId = user.id
}

@Entity
@Data
@NoArgsConstructor
public class Post extends AuditableEntity{

    @Id 
    @GeneratedValue
    private Long id;

    private String content;

    @Column(name = "user_id")
    private Long userId; // 연관 객체 대신 외래키 값만 저장
}

단방향 @OneToMany에서 @JoinColumn을 사용하는 이유

문제점: Join Table이 자동 생성됨

JPA에서 @OneToMany 단방향을 사용할 때 @JoinColumn을 명시하지 않으면,

JPA는 중간에 조인 테이블 (예: user_post) 를 생성해서 User와 Post를 연결.

이것은 일반적인 비즈니스 요구와는 맞지 않고, 불필요한 테이블과 성능 비용이 생김.

비교 정리