minOS

백준 3184 양

minOE — Sat, 4 Oct 2025 19:33:43 +0900

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

타임라인 & 사고 과정

7:09 AM — 초기 아이디어

BFS로 먼저 같은 영역을 구한다. 울타리 #를 기준으로 연결된 칸들을 하나의 영역으로 본다. visited 배열로 중복 탐색을 막는다. 영역을 구한 뒤, 그 영역 안에서 양/늑대 수를 센다. 영역 탐색이 끝난 다음에 한 번 더 훑어서 o/v 개수를 세려 했다. 두 일을 동시에 할 수 있나? 처음엔 “영역 → 카운트”를 분리해서 생각했는데, BFS가 어차피 모든 칸을 큐에서 꺼낼 때 다 방문하니, 그 순간에 바로 카운트하면 한 번에 끝낼 수 있을 듯.

8:01 AM — 수정된 결론

동시에 해야 했음. 같은 영역을 BFS로 확장해 나갈 때, 그때그때 o와 v를 함께 누적하는 게 맞다. 다만, 이렇게 바꾸다 보니 코드가 길고 분기(조건문) 중복이 생김 → 리팩토링 필요.

왜 “동시에 세기”가 맞나? (논리 근거)

BFS는 한 영역을 정확히 한 번씩 방문한다. “영역을 다 돈 뒤 다시 세기”는 한 영역을 사실상 두 번 훑는 셈이라 비효율. 큐에서 꺼낸 시점에 o/v를 더하면, 영역 탐색과 카운트를 O(R×C) 단일 패스로 끝낼 수 있다. 또한 “영역 내 비교(양 > 늑대면 늑대 0, 아니면 양 0)”는 그 영역의 BFS가 끝나는 시점에만 하면 된다.
from collections import deque
r,c = map(int,input().split())
graph = [input()for _ in range(r)]
visited = [[0 for _ in range(c)] for _ in range(r)]
q= deque()


def bfs():
    global o,v
    direction = [(1,0),(0,-1),(0,1),(-1,0)]
    while q:
        x,y = q.popleft()
        for dx, dy in direction:
            nx = x+ dx
            ny = y+ dy
            
            if 0<=nx<r and 0<=ny<c and not visited[nx][ny] and graph[nx][ny] != "#":
                if graph[nx][ny] == "v":
                    v+=1
                if graph[nx][ny] =="o":
                    o+=1
                q.append((nx,ny))
                visited[nx][ny]=1
    if o> v: 
        v=0
    else:
        o=0
    return (o,v)

ans_o =0
ans_v=0

for i in range(r):
    for j in range(c):
        o=0
        v=0
        if graph[i][j] == "v" and not visited[i][j]:
            v+=1
            q.append((i,j))
            visited[i][j] =1
            a,b=bfs()
            ans_o+=a
            ans_v+=b
          
        if graph[i][j] == "o" and not visited[i][j]:
            o+=1
            q.append((i,j))
            visited[i][j] =1
            a,b=bfs()
            ans_o+=a
            ans_v+=b
          
           
        if graph[i][j] == "." and not visited[i][j]:
            q.append((i,j))
            visited[i][j] =1
            a,b=bfs()
            ans_o+=a
            ans_v+=b
          
        
print(ans_o,ans_v)

프로그래머스 단속카메라

minOE — Fri, 25 Jul 2025 06:03:35 +0900

프로그래머스 탐욕법 문제 중 하나인 '단속카메라'를 풀면서 겪었던 시행착오와, 그 과정에서 얻게 된 깨달음을 정리하려고 합니다.

처음 문제를 접했을 때 저는 '탐욕법'이라는 키워드를 보고, 자연스럽게 정렬을 떠올렸습니다.
그동안 풀었던 탐욕 문제들 대부분이 정렬 기준만 잘 잡으면 쉽게 풀리는 구조였기 때문입니다.
그래서 별다른 의심 없이 이번 문제도 정렬로 접근했습니다.

진입 시점을 기준으로 오름차순 정렬해보고,
내림차순 정렬도 해보고,진출 시점을 기준으로도 바꿔보면서,정렬 기준만 계속 바꿔가며 답을 찾으려고 했습니다.

그런데 반례가 생기고, 정확한 기준을 잡기가 어려웠습니다.

코드

def solution(routes):
    routes.sort(key=lambda x: x[1])  
    check = [0] * len(routes)
    ans = 0

    for i in range(len(routes)):
        if check[i]:
            continue
        camera = routes[i][1]
        ans += 1
        check[i] = 1

        for j in range(i+1, len(routes)):
            if routes[j][0] <= camera <= routes[j][1]:
                check[j] = 1

    return ans

1. 차량 정렬

routes.sort(key=lambda x: x[1])

우선 차량을 진출 시점 기준 오름차순으로 정렬합니다.
이 정렬이 핵심입니다. 이유는 다음과 같습니다.

진출 지점이 빠른 차량을 먼저 처리하면, 해당 차량을 기준으로 가장 많은 차량을 하나의 카메라로 커버할 수 있습니다.
즉, 공통 구간의 끝 지점부터 카메라를 설치해 나가면, 중복 없이 최소 카메라 개수로 커버할 수 있게 됩니다.

2. 방문 여부 배열

check = [0] * len(routes)

각 차량이 이미 카메라에 찍혔는지 확인하기 위한 배열입니다.
중복 체크를 방지하기 위해 사용됩니다.

3. 차량 반복 처리

for i in range(len(routes)):
    if check[i]:
        continue

이미 찍힌 차량이라면 넘어갑니다.
찍히지 않은 차량이라면, 그 차량을 기준으로 새 카메라를 설치합니다.

4. 카메라 설치 및 범위 체크

camera = routes[i][1]
ans += 1
check[i] = 1

현재 차량의 진출 시점에 카메라를 설치합니다.
그 지점은 가장 늦게 차량이 나가는 위치이기 때문에,
다음 차량들이 진입 시점 ≤ 카메라 위치 ≤ 진출 시점인 경우 함께 찍힙니다.

for j in range(i+1, len(routes)):
    if routes[j][0] <= camera <= routes[j][1]:
        check[j] = 1

해당 카메라에 찍히는 차량들을 체크 배열로 표시해둡니다.
이후 다시 돌아왔을 때 이 차량은 건너뛰게 됩니다.

5. 반환

return ans

최종적으로 설치한 카메라 개수를 반환합니다.

진출 시점 기준 오름차순 정렬: 가능한 가장 이른 시점에 카메라를 설치해, 최대한 많은 차량을 한 번에 커버하기 위함입니다.
방문 체크 방식: 중복 카메라 설치를 방지하기 위해 check 배열을 사용합니다.
탐욕적으로 선택: 지금 설치한 카메라로 커버할 수 있는 차량은 모두 커버하고, 다음 안 찍힌 차량부터 다시 새로운 카메라 설치를 시도합니다.

6. 핵심 아이디어

차량을 진출 시점 기준 오름차순으로 정렬합니다.
가장 먼저 나가는 차량의 진출 지점에 카메라를 설치합니다.
이후 이 카메라에 찍히는 차량들을 미리 체크해둡니다.
다음 루프에서는 아직 카메라에 안 찍힌 차량만 골라 새로운 카메라를 설치합니다.
이 과정을 반복하면 최소 개수의 카메라로 모든 차량을 커버할 수 있습니다.

7. 입출력 예시

print(solution([[-20, 15], [-14, -5], [-18, -13], [-5, -3]]))  # 2
print(solution([[-2, -1], [1, 2], [-3, 0]]))  # 2
print(solution([[0, 0]]))  # 1
print(solution([[0, 1], [0, 1], [1, 2]]))  # 1 
print(solution([[0, 1], [2, 3], [4, 5], [6, 7]]))  # 4
print(solution([[-20, -15], [-14, -5], [-18, -13], [-5, -3]]))  # 2
print(solution([[-20, 15], [-20, -15], [-14, -5], [-18, -13], [-5, -3]]))  # 2 
print(solution([[2, 2], [0, 1], [-10, 9]]))  # 2
print(solution([[-7, 0], [-6, -4], [-5, -3], [-3, -1], [-1, 4], [1, 2], [3, 4]]))  # 4
print(solution([[-5, -3], [-4, 0], [-4, -2], [-1, 2], [0, 3], [1, 5], [2, 4]]))  # 2 
print(solution([[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7],[7, 8], [8, 9], [9, 10], [10, 11], [11, 12], [12, 13], [13, 14], [14, 15]]))  # 8
print(solution([[0, 12], [1, 12], [2, 12], [3, 12], [5, 6], [6, 12], [10, 12]]))  # 2 
print(solution([[-191, -107], [-184, -151], [-150, -102], [-171, -124], [-120, -114]]))  # 2

프로그래머스 카펫

minOE — Thu, 24 Jul 2025 18:42:51 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/42842

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

처음에 해당 문제를 보고 입출력 예시를 보았습니다.

가장 먼저 떠오른 생각은 brown과 yellow의 합을 기준으로 그 약수들을 구하고,
그 중에서 (가로, 세로) 쌍의 곱이 brown + yellow가 되면서 조건을 만족하는 가장 작은 가로 값을 찾는 것이 답이 아닐까 하는 것이었습니다.

예를 들어, brown이 10이고 yellow가 2라면 합은 12이고,
12의 약수 쌍은 (1,12), (2,6), (3,4)와 같습니다.
이런 가정하에 문제를 접근했습니다.

def solution(brown, yellow):
    temp = brown + yellow
    ans = 1e9
    result = []
    for i in range(1,brown+1) :
        if temp % i == 0 :
            row = i 
            col = temp //i
        else:
            continue
        if ans > row + col:
            ans = row + col  
            result = [row,col]
    result.sort(reverse=True)
    return result

이러면

반례를 찾았는데

solution( 26, 10) # [12, 3]

기대값과 다르게 [6,6]이 나옵니다.

그래서 그림을 그렸는데 ..

해당 수식으로 일반화 할 수 있었습니다 !

def solution(brown, yellow):
    ans =[]
    for x in range(1,yellow+1):
        if yellow % x == 0:
            y = yellow//x
            if  x*y + 2*x + 2*y + 4 == yellow+ brown:
                ans = [y+2, x+2]
                break
    return ans

백준 2670 연속부분최대곱

minOE — Tue, 15 Jul 2025 17:12:48 +0900

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

n = int(input())
arr = [float(input()) for _ in range(n)]

dp = arr[0]
ans = arr[0]

for i in range(1, n):
    if dp == 0.0:
        dp = arr[i]
    else:
        dp *= arr[i]
        dp = max(dp, arr[i])
    ans = max(ans, dp)

print('%.3f' % ans)

프로그래머스 거리두기 확인하기

minOE — Fri, 11 Jul 2025 07:01:04 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/81302

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

from collections import deque

def bfs(q,graph):
    x,y =  q.popleft()
    for dx,dy in {(1,0),(0,1),(-1,0),(0,-1),(-1,1),(1,-1),(1,1),(-1,-1),(0,2),(0,-2),(-2,0),(2,0)} :
        nx = x + dx
        ny = y + dy
        if 0<=nx < 5 and 0<= ny < 5 and not visited[nx][ny] and  graph[nx][ny] == "P" :
            q.append((nx,ny))
            visited[nx][ny]=1
            while q:
                nnx,nny = q.popleft()
                for kx,ky in {(1,0),(0,1),(-1,0),(0,-1),}:
                    nkx = nnx+kx
                    nky = nny+ky
                    if 0<=nkx < 5 and 0<= nky < 5 and (abs(nx-nnx) + abs(ny-nny)) <2 and not visited[nkx][nky] and graph[nkx][nky]== "O": 
                        q.append((nkx,nky))
                        visited[nkx][nky] =1
                    if 0<=nkx < 5 and 0<= nky < 5 and (abs(nx-nnx) + abs(ny-nny)) <2  and not visited[nkx][nky] and graph[nkx][nky]== "P":
                        visited[nkx][nky] =1
                        return False
    return True
    
    

def fun(graph):
    global visited
    visited = [[0 for _ in range(5)] for _ in range(5)]
    flag = True
    q = deque()
    for i in range(5):
        for j in range(5):
            if graph[i][j] == "X":
                visited[i][j] =1
    for i in range(5):
        for j in range(5):
            if graph[i][j] == "P":
                q.append((i,j))
                if not bfs(q,graph):
                    flag = False
                    break
    if not flag:
        return 0
    return 1
    
                
def solution(places):
    ans =[]
    for i in range(len(places)):
        ans.append(fun(places[i]))
    return ans

오랜만에 머리를 좀 썼다 ..

객체지향 쿼리 언어 - 벌크 연산

minOE — Thu, 10 Jul 2025 18:47:42 +0900

벌크 연산

• 재고가 10개 미만인 모든 상품의 가격을 10% 상승하려면?

    • JPA 변경 감지 기능으로 처리할 경우, 다음과 같은 방식으로 동작함

        1. 재고가 10개 미만인 상품을 리스트로 조회한다.
        2. 조회된 상품 각각의 가격을 10% 증가시킨다.
        3. 트랜잭션 커밋 시점에 JPA의 변경 감지(Dirty Checking)가 동작하여
           변경된 각 상품에 대해 UPDATE SQL을 실행한다.

    → 만약 변경된 상품이 100건이라면, UPDATE SQL이 100번 실행됨
      (비효율적이며 성능 저하 우려 있음)

벌크 연산 예제

• 쿼리 한 번으로 여러 테이블 로우를 변경할 수 있다 (→ 엔티티를 일일이 변경하지 않음)

    • JPA에서는 JPQL의 벌크 연산(Bulk Operation)을 통해 실행

    • 예: UPDATE, DELETE 쿼리

        - UPDATE: 조건에 맞는 여러 엔티티의 값을 한 번에 변경

        - DELETE: 조건에 맞는 여러 엔티티를 한 번에 삭제

        - INSERT: JPQL 자체는 지원하지 않지만, Hibernate는 아래처럼 지원함
            (insert into ... select ... 구문)

    • executeUpdate() 메서드 사용 시, 영향 받은 row 수(int)를 반환

        → 예: 20개의 row가 수정되었다면 executeUpdate()는 20 반환

    • 단, 벌크 연산은 영속성 컨텍스트를 무시하므로 1차 캐시와 동기화 되지 않음
        → 이후 em.clear() 등으로 캐시 초기화 권장
       // 벌크 연산
            int resultCount = em.createQuery("update Member m set m.age = 20")
                .executeUpdate();

            System.out.println("resultCount = " + resultCount);

벌크 연산 주의

• 벌크 연산은 영속성 컨텍스트를 무시하고 데이터베이스에 직접 쿼리 실행

→ 즉, 1차 캐시나 스냅샷을 거치지 않고 DB에 바로 반영됨

• 벌크 연산은 가능한 한 트랜잭션 내에서 가장 먼저 실행하는 것이 안전함

• 벌크 연산 수행 후에는 반드시 em.clear() 또는 flush + clear로
영속성 컨텍스트를 초기화해야 데이터 불일치 문제를 방지할 수 있음

package org.hellojpa;

import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.EntityTransaction;
import jakarta.persistence.Persistence;
import org.hellojpa.jpql.Member;
import org.hellojpa.jpql.Team;

public class JpaMain {
    public static void main(String[] args) {

        EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
        EntityManager em = emf.createEntityManager();

        EntityTransaction tx = em.getTransaction();
        tx.begin();

        try {

            Team teamA = new Team();
            teamA.setName("팀A");
            em.persist(teamA);

            Team teamB = new Team();
            teamB.setName("팀B");
            em.persist(teamB);

            Member member1 = new Member();
            member1.setUsername("회원1");
            member1.setTeam(teamA);
            em.persist(member1);

            Member member2 = new Member();
            member2.setUsername("회원2");
            member2.setTeam(teamB);
            em.persist(member2);

            Member member3 = new Member();
            member3.setUsername("회원3");
            member3.setTeam(teamB);
            em.persist(member3);


            
            // 벌크 연산
            int resultCount = em.createQuery("update Member m set m.age = 20")
                .executeUpdate();

            System.out.println("resultCount = " + resultCount);

            Member findMember = em.find(Member.class, member1.getId());
            System.out.println("findMember = " + findMember.getAge());


            tx.commit();
        } catch (Exception e) {
            tx.rollback();
            e.printStackTrace();
        } finally {
            em.close();
        }
        emf.close();

    }
}

✅ 결과가 0으로 나오는 이유 요약
- 벌크 연산은 영속성 컨텍스트를 무시하고 DB에 직접 쿼리를 실행합니다.
- 즉, em.find()로 가져오는 member1은 이미 영속성 컨텍스트에 존재하는 캐시된 엔티티입니다.

Member findMember = em.find(Member.class, member1.getId());
System.out.println("findMember = " + findMember.getAge());  // → 0

- findMember는 DB가 아닌 1차 캐시(영속성 컨텍스트)에서 조회됨
- 이 캐시에는 age = 0인 원래 값이 남아 있음
- 벌크 업데이트 결과가 영속성 컨텍스트에 반영되지 않음 → 그래서 0으로 보이는 것

✅ JPA 벌크 연산 주의사항 실습 예제 (1차 캐시 동기화 문제)

package org.hellojpa;

import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.EntityTransaction;
import jakarta.persistence.Persistence;
import org.hellojpa.jpql.Member;
import org.hellojpa.jpql.Team;

public class JpaMain {
    public static void main(String[] args) {

        EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
        EntityManager em = emf.createEntityManager();

        EntityTransaction tx = em.getTransaction();
        tx.begin();

        try {

            Team teamA = new Team();
            teamA.setName("팀A");
            em.persist(teamA);

            Team teamB = new Team();
            teamB.setName("팀B");
            em.persist(teamB);

            Member member1 = new Member();
            member1.setUsername("회원1");
            member1.setTeam(teamA);
            em.persist(member1);

            Member member2 = new Member();
            member2.setUsername("회원2");
            member2.setTeam(teamB);
            em.persist(member2);

            Member member3 = new Member();
            member3.setUsername("회원3");
            member3.setTeam(teamB);
            em.persist(member3);



            // 벌크 연산
            int resultCount = em.createQuery("update Member m set m.age = 20")
                .executeUpdate();

            em.clear(); // 영속성 컨텍스트 초기화

            System.out.println("resultCount = " + resultCount);

            Member findMember = em.find(Member.class, member1.getId());
            System.out.println("findMember = " + findMember.getAge());


            tx.commit();
        } catch (Exception e) {
            tx.rollback();
            e.printStackTrace();
        } finally {
            em.close();
        }
        emf.close();

    }
}

객체지향 쿼리 언어 - 페치 조인

minOE — Thu, 10 Jul 2025 14:51:05 +0900

페치 조인(fetch join)

- SQL 조인 종류 X
- JPQL에서 성능 최적화를 위해 제공하는 기능
- 연관된 엔티티나 컬렉션을 SQL 한 번에 함께 조회하는 기능
- join fetch 명령어 사용
- 페치 조인 ::= [ LEFT [OUTER] | INNER ] JOIN FETCH 조인경로

엔티티 페치 조인

- 회원을 조회하면서 연관된 팀도 함께 조회(SQL 한 번에)
- 다음 JPQL은 Hibernate 6에서 실행 시 아래와 같은 SQL로 변환됩니다
-- JPQL
select m from Member m join fetch m.team

-- Hibernate 6에서 변환된 SQL (로깅 기준)
select
    m1_0.id,
    m1_0.age,
    t1_0.id,
    t1_0.name,
    m1_0.username 
from
    Member m1_0 
join
    Team t1_0 on t1_0.id = m1_0.TEAM_ID

컬렉션 페치 조인과 DISTINCT

- 일대다 관계, 컬렉션 페치 조인
- 다음 JPQL은 Hibernate 6에서 실행 시 아래와 같은 SQL로 변환됩니다
-- JPQL
select distinct t 
from Team t 
join fetch t.members 
where t.name = '팀A'

-- Hibernate 6 SQL (로그 출력 기준)
select
    distinct t1_0.id,
    m1_0.TEAM_ID,
    m1_0.id,
    m1_0.age,
    m1_0.username,
    t1_0.name 
from
    Team t1_0 
join
    Member m1_0 
    on t1_0.id = m1_0.TEAM_ID 
where
    t1_0.name = '팀A'
- SQL의 DISTINCT는 중복된 결과를 제거하는 명령
- JPQL의 DISTINCT 2가지 기능 제공
1) SQL에 DISTINCT를 추가
2) 애플리케이션에서 엔티티 중복 제거

페치 조인과 일반 조인의 차이

1. 일반 조인 (join)
-- JPQL
select distinct t 
from Team t join t.members m 
where t.name = '팀B'



-- Hibernate 실행 SQL (쿼리 1)
select
    distinct t1_0.id,
    t1_0.name 
from
    Team t1_0 
join
    Member m1_0 on t1_0.id = m1_0.TEAM_ID 
where
    t1_0.name = '팀B'

-- 추가 SQL (getMembers() 호출 시 지연 로딩 발생)
select
    m1_0.TEAM_ID,
    m1_0.id,
    m1_0.age,
    m1_0.username 
from
    Member m1_0 
where
    m1_0.TEAM_ID = ?
- Team만 select 대상이므로, members는 로딩되지 않음
- team.getMembers() 호출 시점에 추가 SQL 실행됨 (지연 로딩, Lazy)
- 쿼리 2번 실행됨 (N+1 가능성 있음)

2. 페치 조인 (join fetch)
-- JPQL
select distinct t 
from Team t join fetch t.members m 
where t.name = '팀B'

-- Hibernate 실행 SQL (쿼리 1회)
select
    distinct t1_0.id,
    m1_0.TEAM_ID,
    m1_0.id,
    m1_0.age,
    m1_0.username,
    t1_0.name 
from
    Team t1_0 
join
    Member m1_0 on t1_0.id = m1_0.TEAM_ID 
where
    t1_0.name = '팀B'
- Team과 연관된 Member를 한 번의 SQL로 모두 로딩
- getMembers() 호출해도 추가 쿼리 발생하지 않음
- 성능 효율적 , N+1 방지

✅ 정리 비교
페치 조인은 연관 엔티티까지 한 번에 가져와 N+1 문제를 해결하고 성능을 최적화할 수 있습니다.
일반 조인은 연관 객체를 즉시 로딩하지 않기 때문에, 연관 데이터를 사용할 경우추가 쿼리가 발생할 수 있습니다.
출력은 같아 보여도 쿼리 수와 성능은 다릅니다.

객체지향 쿼리 언어 - 경로 표현식

minOE — Wed, 9 Jul 2025 19:16:44 +0900

경로 표현식

- .(점)을 찍어 객체 그래프를 탐색하는 것

select m.username -> 상태 필드
from Member m
join m.team t -> 단일 값 연관 필드
join m.orders o -> 컬렉션 값 연관 필드
where t.name = '팀A'

경로 표현식 용어 정리

- 상태 필드(state field): 단순히 값을 저장하기 위한 필드 (ex: m.username)
- 연관 필드(association field): 연관관계를 위한 필드
1) 단일 값 연관 필드: @ManyToOne, @OneToOne, 대상이 엔티티(ex: m.team)
2) 컬렉션 값 연관 필드: @OneToMany, @ManyToMany, 대상이 컬렉션(ex: m.orders)

경로 표현식 특징

- 상태 필드(state field): 경로 탐색의 끝, 탐색X
ex) JPQL: select m.username, m.age from Member m
SQL: select m.username, m.age from Member m

- 단일 값 연관 경로: 묵시적 내부 조인(inner join) 발생, 탐색O
ex) JPQL: select o.member from Order o
SQL:
select m.*
from Orders o
inner join Member m on o.member_id = m.id
- 컬렉션 값 연관 경로: 묵시적 내부 조인 발생, 탐색X
• FROM 절에서 명시적 조인을 통해 별칭을 얻으면 별칭을 통해 탐색 가능
select m.username from Team t join t.members m

명시적 조인, 묵시적 조인

- 명시적 조인: join 키워드 직접 사용
select m from Member m join m.team t
- 묵시적 조인: 경로 표현식에 의해 묵시적으로 SQL 조인 발생 (내부 조인만 가능)
select m.team from Member m

경로 탐색을 사용한 묵시적 조인 시 주의사항

- 항상 내부 조인
- 컬렉션은 경로 탐색의 끝, 명시적 조인을 통해 별칭을 얻어야함
- 경로 탐색은 주로 SELECT, WHERE 절에서 사용하지만 묵시적 조인으로 인해 SQL의 FROM (JOIN) 절에 영향을 줌

실무 조언

- 가급적 묵시적 조인 대신에 명시적 조인 사용
- 조인은 SQL 튜닝에 중요 포인트
- 묵시적 조인은 조인이 일어나는 상황을 한눈에 파악하기 어려움

백준 2578 빙고

minOE — Tue, 8 Jul 2025 09:20:12 +0900

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

def check_line(cnt):
 
    
    for i in range(5):
        if sum(check[i]) == 5:
            cnt+=1
   
    
    for i in range(5):
        temp =0
        for j in range(5):
            temp += check[j][i]
        if temp == 5:
            cnt+=1
 
    
    temp =0
    for i in range(5):
        for j in range(5):
            if i== j :
                temp += check[i][j]
    if temp ==5 :
        cnt+=1
    
   
    
    temp = 0
    for i in range(5):
        for j in range(5):
            if i+ j ==4:
                temp += check[i][j]
    
    if temp ==5:
        cnt+=1
    
    return cnt >=3





matrix = [list(map(int,input().split())) for _ in range(5)]
elems  = [list(map(int,input().split())) for _ in range(5)]
check = [[0 for _ in range(5)] for _ in range(5)]
d= dict()
for i in range(5):
    for j in range(5):
        d[matrix[i][j]] = (i,j)
ans =0
for i in range(5):
    for j in range(5):
        x,y =d[elems[i][j]]
        check[x][y] =1
        ans +=1
        flag = check_line(0)
        if flag:
            print(ans)
            break
    if flag:
        break

더 깨끗하게 짤 수 있을 것 같다 .. 추후에 다시 리팩토링 해봐야겠다

프로그래머스 야근 지수

minOE — Mon, 7 Jul 2025 11:08:46 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/12927

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

import heapq
def solution(n, works):
    ans = 0
    if sum(works) <= n:
        return ans

    pq = []
    for work in works:
        heapq.heappush(pq,(-work,work))

    while n > 0:
        negative, positive = heapq.heappop(pq)
        if positive > 0:
            negative += 1
            positive -= 1
            n -= 1
            heapq.heappush(pq,(negative,positive))
        else:
            heapq.heappush(pq,(negative,positive))

    for _, elem in pq:
        ans += elem ** 2
    return ans