나만의 개발블로그

[ 노트 ] NextJS - TanStack Query 적용 이해

hminor — Mon, 8 Dec 2025 16:06:56 +0900

Q1. 기존 service에서 domainService 메서드를 추가한 이유는 해당 key값인 api가 없다면 별도의 error 문구를 던지기 위해서 작성했는데 이렇게 하지 않으면 어떤식으로 controller에서 error를 던질 수 있어?

A1. controller 단에서 개별 함수(훅)으로 만들어서 각각 export하면 내보낼 당시 없는 메서드의 경우 에러가 발생하게 되니 해결되며, react/nextjs 생태계의 표준 모범에 부합.

Q2. 서버 컴포넌트용 API라는 건 별도의 유저 조작없이 특정 페이지 접속시 보이는 데이터로 예를 들자면 쇼핑몰 페이지에서 추천 상품 목록이 아닌 일반적인 것으로 의류 중 상의 탭을 클릭하면 누구에게나 공통으로 보일 데이터의 경우엔 서버 컴포넌트용 APi를 제작해서 fetch하여 페이지 로드 시 서버에서 데이터를 가져와서 바로 보일 수 있게 하면 좋겠다는거야?

A2. ㅇㅇ 맞음, 누구에게나 공통으로 보일 데이터인 "페이지의 핵심이 되는 초기 콘텐츠"는 서버 컴포넌트에서 fetch로 처리, 초기 콘텐츠 위에서 일어나는 사용자 동적인 상호작용은 클라이언트 컴포넌트와 TanStack Query가 담당.

Q2-1. fetch와 TanStack Query 모두 사용하는 즉, 서버 컴포넌트와 클라이언트 컴포넌트 둘다 처리가 필요하다면 같은 api 작성을 2번해야하는데 이는 어떤식으로 관리해야 효율적일까?

A2-1. 실제 API 요청 로직은 한 번만 작성하고, 해당 로직을 서버 컴포넌트와 TanStack Query에서 가져다 사용하기.

Step 1: 순수 API 함수 계층 만들기

services/domains.ts (새로운 단일 API 계층)

// 이 파일은 React와 무관한 순수 TypeScript/JavaScript 파일입니다.

// 1. 파라미터를 받아 URL을 만들고, fetch를 호출하고, 결과를 반환하는 핵심 로직
async function fetchDomainList(params) {
  const API_BASE_URL = process.env.NEXT_PUBLIC_API_URL || 'http://localhost:8080';
  const queryString = new URLSearchParams(params).toString();
  const url = `${API_BASE_URL}/api/domain/get/list?${queryString}`;

  // Next.js의 확장된 fetch를 사용합니다.
  const response = await fetch(url, {
    // 서버 컴포넌트에서 이 함수를 호출할 때 캐시 전략을 정할 수 있습니다.
    // 클라이언트에서는 이 옵션이 무시됩니다.
    cache: 'no-store', 
  });

  if (!response.ok) {
    // 에러 처리는 여기서 일관되게 할 수 있습니다.
    throw new Error('도메인 목록을 가져오는데 실패했습니다.');
  }

  return response.json(); // Promise<Data>를 반환합니다.
}

// 필요하다면 다른 API 함수들도 이런 식으로 만듭니다.
async function fetchDomainDetail(id) {
  // ...
}

// 2. 작성한 함수들을 export 합니다.
export const domainAPI = {
  getList: fetchDomainList,
  getDetail: fetchDomainDetail,
};

Step 2: 서버 컴포넌트에서 이 함수를 직접 사용하기

app/domains/page.tsx (서버 컴포넌트)

import { domainAPI } from '@/services/domains'; // Step 1에서 만든 함수를 import

export default async function DomainsPage() {
  // 서버에서 페이지를 렌더링하기 전에 데이터를 직접 호출하고 기다립니다.
  const initialDomains = await domainAPI.getList({ page: 1, limit: 10 });

  return (
    <main>
      <h1>도메인 목록 (초기 데이터는 서버 렌더링)</h1>
      {/* 
        이 초기 데이터를 클라이언트 컴포넌트에 넘겨주어
        클라이언트에서의 추가적인 상호작용을 처리하게 합니다.
      */}
      <DomainListClient initialData={initialDomains} />
    </main>
  );
}

Step 3: TanStack Query 훅(Controller)에서 이 함수를 재사용하기

controllers/domainController.ts (기존 Controller 수정)

import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
import { domainAPI } from '@/services/domains'; // Step 1에서 만든 함수를 import

export const useFetchDomain = (params) => {
  return useQuery({
    queryKey: ['domainList', params],
    // ✅ 핵심: 실제 API 호출 로직을 재사용합니다.
    queryFn: () => domainAPI.getList(params),
    enabled: !!params,
    staleTime: 1000 * 60 * 5, // 5분
  });
};

// Mutation을 위한 래퍼 훅도 동일한 원리로 만들 수 있습니다.
// export const useUpdateDomain = ...```
이제 `useFetchDomain` 훅은 TanStack Query의 캐싱, 상태관리 등의 기능만 담당하는 **"래퍼(Wrapper)"**가 되고, 핵심 API 로직은 `services/domains.ts`에 위임됩니다.

---

#### Step 4: 클라이언트 컴포넌트에서 완성하기 (하이브리드 패턴)

서버 컴포넌트로부터 초기 데이터를 받고, 이후의 상호작용은 TanStack Query 훅을 사용하는 클라이언트 컴포넌트를 만듭니다.

**`components/DomainListClient.tsx` (클라이언트 컴포넌트)**
```tsx
'use client';

import { useState } from 'react';
import { useFetchDomain } from '@/controllers/domainController';

export default function DomainListClient({ initialData }) {
  const [page, setPage] = useState(1);
  const [filters, setFilters] = useState({});

  // TanStack Query 훅을 사용합니다.
  const { data, isLoading } = useFetchDomain(
    // 현재 페이지와 필터 상태를 파라미터로 전달
    { page, ...filters },
    {
      // ✅ 최적화: 서버에서 받아온 초기 데이터가 있으므로, 첫 렌더링 시에는 API를 다시 호출하지 않습니다.
      initialData: initialData,
    }
  );
  
  // ... 필터링, 페이지네이션 등 UI 로직 ...
  const handleFilterChange = () => { /* setFilters(...) */ };
  const handleNextPage = () => setPage(p => p + 1);

  return (
    <div>
      {/* 필터 UI */}
      {/* ... */}
      
      {isLoading && <p>데이터 갱신 중...</p>}
      
      <ul>
        {data?.items.map((domain) => (
          <li key={domain.id}>{domain.name}</li>
        ))}
      </ul>

      <button onClick={handleNextPage}>다음 페이지</button>
    </div>
  );
}

Docker&Container - Docker로 MySQL 구동하기

hminor — Sat, 6 Dec 2025 16:23:02 +0900

개인프로젝트를 진행하며 관련 자료 학습을 진행하던 중

개발자 유미님의 영상을 보고 Docker로 MySQL을 구동하는 방법에 대해 알게 되어 포스팅하게 되었습니다.

방법은 아주 간단하며 다음과 같습니다.

1, docker 설치 후 상단 검색창에 mysql 검색 후 Run

2. Optional settings 내 Container name을 작성

3. Host port 입력 (상단 것만 입력했음, ex. 3306)

4. Environment variables에 필요한 값 추가 후 Run 클릭하여 생성
- MYSQL_DATABASE: 생성할 데이터베이스 이름
- MYSQL_USER: MYSQL_DATABASE에 모든 권한을 가질 새로운 사용자의 이름
- MYSQL_PASSWORD (필수) : MYSQL_USER의 비밀번호 지정

5. Spring의 경우 application.properties에 하단의 값 추가하면 사용 가능

# MySQL DB connection
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://:3306/디비명?useSSL=false&useUnicode=true&serverTimezone=Asia/Seoul&allowPublicKeyRetrieval=true
spring.datasource.username=root
spring.datasource.password=

# JPA ddl, Naming and log
spring.jpa.hibernate.ddl-auto=update
spring.jpa.hibernate.naming.physical-strategy=org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
spring.jpa.show-sql=true

[백준, 자바, 14500번] 테트로미노

hminor — Mon, 16 Dec 2024 16:02:39 +0900

풀이

해당 문제는 어떻게 푸는 방법이 좋을지 고민했을 때
각 도형에 따른 변형을 최소화하면서, 기준 좌표로부터
이동가능한 좌표 탐색을 4방향을 우선적으로 작성 후 값을 도출하는 것이 좋을 것 같다고 판단.
다만, 이러한 노가다가 과연 적절한지 고민해봤는데 나쁘지 않을 듯해서 아래와 같이 작성
그리고 무슨 5중 for문으로 해결한 문제는 이번이 처음인듯...
그래도 최대한 코드를 가독성 좋으며, 구조적으로 작성하려고 노력하여 아래와 같이 작성.
문제 자체는 크게 어려운 건 아니지만, 번거로웠다? 정도였음.

import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;
public class _14500 {
    static BufferedReader br;
    static StringTokenizer st;
    static int[][][][] li;
    static int[][] mtx;
    static int N;
    static int M;
    static int result = 0;
    public static void main(String[] args) throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        li = new int[5][][][];
        addDefault();
        findTetro();
        System.out.println(result);
    }

    private static void addDefault() throws IOException {
        li[0] = new int[][][] {
                {{0, 0}, {0, 1}, {0, 2}, {0, 3}},
                {{0, 0}, {1, 0}, {2, 0}, {3, 0}}
        };
        li[1] = new int[][][] {
                {{0, 0}, {0, 1}, {1, 1}, {1, 0}}
        };
        li[2] = new int[][][] {
                {{0, -1}, {0, 0}, {0, 1}, {1, 0}},
                {{0, -1}, {0, 0}, {-1, 0}, {1, 0}},
                {{0, -1}, {0, 0}, {-1, 0}, {0, 1}},
                {{-1, 0}, {0, 0}, {0, 1}, {1, 0}}
        };
        li[3] = new int[][][] {
                {{0, 0}, {1, 0}, {1, 1}, {2, 1}},
                {{0, 0}, {1, 0}, {1, -1}, {2, -1}},
                {{0, 0}, {0, 1}, {-1, 1}, {-1, 2}},
                {{0, 0}, {0, 1}, {1, 1}, {1, 2}}
        };
        li[4] = new int[][][] {
                {{0, 0}, {1, 0}, {2, 0}, {2, 1}},
                {{0, 0}, {1, 0}, {2, 0}, {2, -1}},
                {{0, 0}, {1, 0}, {0, 1}, {0, 2}},
                {{0, 0}, {1, 0}, {0, -1}, {0, -2}},
                {{0, 0}, {0, 1}, {1, 1}, {2, 1}},
                {{0, 0}, {0, -1}, {1, -1}, {2, -1}},
                {{0, 0}, {-1, 0}, {0, -1}, {0, -2}},
                {{0, 0}, {-1, 0}, {0, 1}, {0, 2}}
        };

        mtx = new int[N][M];
        for (int i=0; i<N; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j=0; j<M; j++) mtx[i][j] = Integer.parseInt(st.nextToken());
        }
    }

    private static void findTetro() {
        for (int i=0; i<N; i++) {
            for (int j=0; j<M; j++) {
                detailTetro(i,j);
            }
        }
    }

    private static void detailTetro(int i, int j) {
        for (int t=0; t<5; t++) { // 각 도형
            for (int x=0; x<li[t].length; x++) { // 도형 별 회전&대칭
                boolean state = true;
                int hap = 0;
                for (int y=0; y<4; y++) {
                    if ((0<=i+li[t][x][y][0]&&i+li[t][x][y][0]<N)&&(0<=j+li[t][x][y][1]&&j+li[t][x][y][1]<M)) hap+=mtx[i+li[t][x][y][0]][j+li[t][x][y][1]];
                    else {
                        state = false;
                        break;
                    }
                }
                if (state&&hap>result) result = hap;
            }
        }
    }
}

Docker&Container - Network 2. 컨테이너간 통신

hminor — Sun, 15 Dec 2024 12:30:51 +0900

컨테이너간 통신

네트워크 생성
- 터미널
  - docker network create 작명
  - ex) docker network create mynet1
  - 명령어
    - docker network: 모든 명령어 조회
    - docker network ls: 실행 중인 네트워크
- 터미널에 컨테이너 넣기
  - 실행 중인 컨테이너를 넣는 방법도 있지만
  - 이미지 생성 시 해당 네트워크에 바로 넣는 방법을 배우고자 함 (더 편리)
    - 터미널
      - docker run -d -p 포트 —network 네트워크 —name 작명 실행이미지:태그
      - ex) docker run -d -p 80:80 —network mynet1 —name nginx-container nginx:1 (nginx)
      - ex) docker run -d -p 8080:8080 —network mynet1 —name server-container nodeserver:v1 (server)
  - 입력하게 되면 두 개의 컨테이너가 생성되고
    - 특정 컨테이너 클릭 후 inspect에 들어가서 Networks에 들어가면
      - 연결되어 있는지와 할당된 IP 주소 등 확인 가능
서로 다른 컨테이너 간 통신 확인
- 현재 nginx의 가상 주소는 172.18.0.2 이고
- server의 가상 주소는 172.18.0.3 이기에
- nginx에서 server로 접속 가능한 지 확인해보기 (172.18.0.3로 접속해보기)
  - nginx 컨테이너에서 Exec에서 아래와 같이 코드 작성해보기
```
curl 172.18.0.3:8080
```
  - 숫자로 접속하기 번거롭고 어렵다면 —name으로 작성한 것으로 접속 가능
    - DNS 기능이 내부적으로 작동되고 있기에 가능
```
curl server-container:8080
```
  - 그리고 좀 더 정확하게 입력을 하고자면, network 이름도 함께 작성하기
```
curl server-container.mynet:8080
```
다만
- 여전히 nginx 서버(컨테이너1,80)로 접속 하더라도, server(컨테이너2,8080)으로 전달이 안됨
- 이유는 myconfig1.conf에 그냥 localhost:8080으로 이동하라고만 입력했기에
- 그래서 웹서버컨테이너IP:8080으로 보내라고 코드 수정하기
  - 또는 DNS으로 —name으로 작성한 컨테이너 이름으로 하기
  - config를 수정 후 터미널에서 다시 아래 명령어를 입력하여 다시 빌드하기
```
docker build -t nginx:1 ./nginx
```
  - 코드 해석(잊어버려서)
    - ./nginx 폴더에 있는 dockerfile을 빌드
    - -t는 태그를 옵션으로 작성할 것이다는 의미
    - 그래서 nginx이름으로 태그를 1로 설정하여 빌드
- 여기서 중요한 것은 컨테이너를 실행할 때(run)
  - 웹 서버가 실행된 이후 서버를 실행하기
  - 또한 기존 실행 코드는 다음과 같이 수정할 수 있음
    - 왜냐하면 이젠 nginx를 실행하면 웹서버로 이동하도록 설정했기 때문.
```
// 기존
docker run -d -p 8080:8080 --network mynet1 --name server-container n
odeserver:v1

docker run -d -p 80:80 --network mynet1 --name nginx-container nginx:
1

// 변경
docker run -d --network mynet1 --name server-container nodeserver:v1

docker run -d -p 80:80 --network mynet1 --name nginx-container nginx:1
```
그리고
- 네트워크를 생성하게 되면 모드가 bridge가 기본적으로 설정되어짐
- 이를 host 모드로 변경하면, 나의 실제 컴퓨터 자원을 사용할 수 있음
  - 다만 일반적으로 굳이 이렇게까지 변경할 필요는 없다고 함.
  - 그리고 변경하게 되면 보안적으로 더욱 유의해야함.

Docker&Container - Network 1. nginx 만들기

hminor — Sat, 14 Dec 2024 23:27:14 +0900

nginx 만들기

컨테이너 간 통신하는 방법
- Reverse Proxy
  - 서버로 들어오는 요청 가로채는 프로그램
  - Web Server와 함께 사용할 것임
  - 순서
    - 클라이언트가 Reverse Proxy로 들어오게 되면
    - Reverse Proxy가 Web Server로 안내
  - 사용 이유(장점)
    - 서버 정보를 숨길 수 있음
    - https 인증서 설치가 쉬움
    - 로드밸런싱 가능
    - 로그 남기기
    - IP차단
  - 종류
    - Nginx
    - caddy
Nginx 로컬 설치 및 셋팅
- NginX 실행 순서
  - Nginx 설치
    - 도커를 사용할 것이기에 우선 패스
  - Nginx 설정 파일 작성
    - Docker 폴더에 폴더와 파일 생성
      - ex) nginx/myconfig1.conf
    - 이후 nginx 문법에 맞게 설정 코드를 작성해야 함.
      - 다만 따로 배운 적이 없기에 아래와 같이 우선 작성
      - 간단히 설명하자면
        
        listen 80 ← 80 포트로 들어오면
        
        location ← 해당 코드를 실행해라는 의미
        
        여기서 / 는 모든 경로 접속 시를 의미
        
        그리모 http://localhost:8080 여기로 보내기
        
        아래 코드는 웹서버에 도움되는 유저의 부가 정보 채워서 보내라는 의미
        
        server { listen 80; location / { proxy_pass <http://localhost:8080>; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header X-Forwarded-Proto $scheme; } }
        
        리눅스의 경우엔
        
        /etc/nginx/conf.d 폴더에 해당 파일을 넣으면 된다고 함
        
        그리고 기존 폴더에 default.conf 파일이 있는데
        
        우선 순위가 기존 파일이 더 높기에
        
        삭제 후 새롭게 작성한 파일을 넣으면 됨.
        
        이후 nginx -g daemon off; 를 터미널에 입력하면 nginx 실행됨
  - Nginx 실행 명령어 입력
- 코드 작성하기
  - 생성한 nginx 폴더에 Dockerfile 만들기
    - 이후 해당 파일에 아래와 코드 작성
      - 코드 설명
        
        FROM docker에서 nginx 이미지 불러오기
        
        COPY로 우리가 만든 myconfig1.conf 를 특정 경로로 옮기기
        
        기존 conf 파일을 지우기 위해 RUN 사용
        
        EXPOSE로 특정 포트 열기
        
        CMD로 실행 명령어 작성
        
        코드 설명
        
        nginx
        
        Nginx 웹 서버 실행 명령어
        
        -g
        
        글로벌 설정으로, 뒤에 오는 설정은 모든 Nginx 설정 파일에 영향을 미침
        
        daemon off;
        
        Nginx는 기본적으로 데몬 모드(백그라운드 실행)으로 동작
        
        Docker 컨테이너는 포그라운드에서 실행되는 프로세스를 필요로 하기에, daemon off; 를 설정하여 데몬 모드로 전환되지 않고, 포그라운드에서 실행되도록 함.
        
        포그라운드 프로세스란?
        
        현재 사용자의 터미널(콘솔)과 직접 연결된 상태에서 실행되는 프로세스를 의미
        
        즉, 실행 결과가 즉시 화면에 출력됨.
        
        프로세스가 종료될 때까지 터미널 제어권을 유지
        
        예를 들어, 터미널에서 실행한 명령어가 작업을 마칠 때까지 기다리는 상태.
        
        기존 데몬 모드(백그라운드 프로세스)란?
        
        사용자의 터미널과 분리된 상태로 실행되는 프로세스
        
        즉, 실행 결과는 화면에 출력X, 로그도 별도 저장
        
        프로세스가 독립적으로 실행되며, 사용자는 터미널 다른 작업을 할 수 있음.
        
        쉽게 이해하자면, 데몬 모드로 실행하면 컨테이너가 실행 중단된 것으로 간주되기에, 컨테이너가 바로 종료됨.
        
        이렇게 하면 Dcoker가 Nginx 프로세스를 주 프로세스로 인식하고, 컨테이너가 종료되지 않으며 정상적으로 동작.
        
        FROM nginx:1.27.2-alpine COPY ./myconfig1.conf /etc/nginx/conf.d/myconfig1.conf RUN rm /etc/nginx/conf.d/default.conf EXPOSE 80 CMD ["nginx", "-g", "daemon off;"]
- 실행하기
  - 터미널에서 이미지 만들기
    - docker build -t nginx:1 ./nginx
  - 생성한 nginx 이미지 실행
    - option에서 Host port를 80 으로 변경 후 실행
  - 이후 이전 생성한 nodeserver인 web server를 실행
    - option에서 Host port를 myconfig1.conf에서 설정한 것처럼 8080으로 변경 후 실행
  - 다만 nginx 서버에서 80 포트로 접속하면
    - nodeserver 서버인 8080 포트로 안내가 되어야 하는데 안됨
  - 이유?
    - 현재 나의 컴퓨터(Host)에선 아래와 같이 2개의 가상 컴퓨터가 있음
      - 가상 컴퓨터1(nginx, 80)
        
        localhost:80 → localhost:8080 안내하라고 되어 있음.
      - 가상 컴퓨터2(nodeserver, 8080)
    - 다만
      - 가상 컴퓨터1에는
        
        8080 포트도 뚫려있지 않고
        
        8080 포트에서 실행중인 서버도 없기에 동작을 안함
      - 가상 컴퓨터2에 뚫려 있고, 실행중인 8080서버와는 완전히 구분된 별도의 컴퓨터
  - 해결 방법
    - 가상 컴퓨터1(nginx, 80)
      - localhost:80 → 가상 컴퓨터2의 localhost:8080 안내하라고 되어야 함.
    - 안전하며, 간단한 방법
      - network 내에 컨테이너를 넣으면 가상 IP 주소를 부여함
        
        따라서 가상 컴퓨터1,2 를 함께 넣어서 관리
        
        같은 네트워크 내에선
        
        가상 IP주소가 생기기에 가상 컴퓨터끼리 통신이 가능.

[백준, 자바, 1551번] 수열의 변화

hminor — Fri, 13 Dec 2024 22:10:12 +0900

풀이

오늘은 간단하게 하나 풀기로 함
우선 해당 문제는 단순히 수열이 주어질 때
특정 인덱스를 앞 인덱스 값에서 뺀 값을 구하는 수를 구하는 문제이며
M번 반복하게 되면 결과로 나오는 값의 개수는
기존 N의 길이에서 N-M개로 줄어들기에 그것을 유념하여 풀어야 함
또한 결과를 출력 시 ,를 기준으로 출력을 하는 것으로 해결하는 것으로
다음과 같이 해결.

import java.io.*;
import java.util.*;
import java.util.stream.Collectors;

public class _1551 {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static List<Integer> li = new ArrayList<>();
    public static void main(String[] args) throws IOException {

        st = new StringTokenizer(br.readLine());
        int N = Integer.parseInt(st.nextToken());
        int M = Integer.parseInt(st.nextToken());
        addData(N);
        findResult(N,M);
        System.out.println(li.stream().map(String::valueOf).collect(Collectors.joining(",")));
    }

    private static void addData(int N) throws IOException {
        st = new StringTokenizer(br.readLine(),",");
        for (int i=0; i<N; i++) li.add(Integer.parseInt(st.nextToken()));
    }

    private static void findResult(int N, int M) {
        int cnt = M;
        int ln = N;
        while (cnt>0) {
            List<Integer> n_li = new ArrayList<>();
            for (int j=0; j<ln-1; j++) n_li.add(li.get(j+1)-li.get(j));
            li = new ArrayList<>(n_li);
            cnt--;
            ln--;
        }
    }
}

[백준, 자바, 6064번] 카잉 달력

hminor — Tue, 10 Dec 2024 20:41:18 +0900

풀이

해당 문제는 처음에 무슨 말인가 하고
쭉 보다보니 x,y가 서로 독립적으로 변하는 문제인 것을 확인
이후 우선 단순히 1씩 증가하고 M과N위를 벗어날 경우
나머지를 활용하여 해결하고자 함.
다만 이렇게 하니 시간 초과가 발생...
역시나 정답 비율이 낮은 이유는 있다는 것을 느낌
그래서 어떻게 해결할 수 있을지 고민하다가
뭔가 규칙을 발견하게 됨.
우선 아래 코드를 보면
- 입력 값이 10 12 3 9의 경우엔
  - x를 기준으로 y를 변경 후
  - M만큼 계속 y에 더하고 초과 시 나머지로 변경한다면
  - 간단히 해결이 됨
- 입력 값이 10 12 7 2의 경우엔
- 출력이 -1로 나오는 것으로 해결 방법에 대해 고민해 본 결과
- 우선 공통적으로 x가 y보다 작은 값이 들어가도록 조건 처리하기
- 이후 마찬가지로 10 12 3 9 입력 값처럼 연산을 하지만
- 가장 마지막 줄에 14 20 (2 10) 이후 다시 (2 2) 가 나오는 것을 확인 후
- y의 값이 계속 반복되는 것을 확인
- 그래서 Set을 통해서 y의 값을 추가하며
- 변경된 y의 값이 Set에 존재할 경우 탈출하도록 하여 해결.
이렇게만 하니 또 틀렸다고 나와서
입력 값을 아래와 같이 넣어보니
- 1
- 1 1 1 1
원하는 1의 값이 출력이 안되어 조건 처리한 결과
아주 힘겹게 퍼센트가 올라가며 해결 완료

// 10 12 3 9
// 1 1 -> 3 3 -> 13 13 (3 1) -> 13 11 -> (3 11) -> 13 21 (3 9)

// 10 12 7 2
// 12 10 2 7
// 1 1 -> 2 2 [2]-> 14 14 (2 4) [14]-> 14 16 (2 6) [26]-> 14 18 (2 8) 
//	-> 14 20 (2 10) -> 14 22(2 2) -> 14 14 (2 2)

// 성공 코드

import java.io.*;
import java.util.*;

public class _6064 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        StringTokenizer st;
        int T = Integer.parseInt(br.readLine());
        while (T>0) {
            st = new StringTokenizer(br.readLine());
            int M = Integer.parseInt(st.nextToken());
            int N = Integer.parseInt(st.nextToken());
            int x = Integer.parseInt(st.nextToken());
            int y = Integer.parseInt(st.nextToken());

            if (x>y) {
                int tmp1 = M;
                int tmp2 = x;
                M = N;
                x = y;
                N = tmp1;
                y = tmp2;
            }

            int result = findKaing(M,N,x,y);
            bw.write(result+"\n");
            T--;
        }
        bw.flush();
    }

    private static int findKaing(int M, int N, int x, int y) {
        Set<Integer> s_li = new HashSet<>(Arrays.asList(x));
        int cnt = x;
        int now = x;
        boolean state = false;
        if (x!=y) {
            while (true) {
                now=(now+M)%N==0?N:(now+M)%N;
                cnt+=M;
                if (now==y) {
                    state = true;
                    break;
                } else if (s_li.contains(now)) break;
                s_li.add(now);
            }
        } else state = true;
        return state?cnt:-1;
    }
}

// 시간초과 코드

import java.io.*;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        StringTokenizer st;
        int T = Integer.parseInt(br.readLine());
        while (T>0) {
            st = new StringTokenizer(br.readLine());
            int M = Integer.parseInt(st.nextToken());
            int N = Integer.parseInt(st.nextToken());
            int x = Integer.parseInt(st.nextToken());
            int y = Integer.parseInt(st.nextToken());
            int result = findKaing(M,N,x,y);
            bw.write(result+"\n");
            T--;
        }
        bw.flush();
    }

    private static int findKaing(int M, int N, int x, int y) {
        int cnt = 1;
        int[] now = {1,1};
        boolean state = x==M&&y==N;
        while (now[0]!=M || now[1]!=N) {
            if (now[0]==x && now[1]==y) {
                state = true;
                break;
            }
            now[0]=now[0]+1>M?1:now[0]+1;
            now[1]=now[1]+1>N?1:now[1]+1;
            cnt++;
        }
        return state?cnt:-1;
    }
}

[백준, 자바, 5525번] IOIOI

hminor — Tue, 10 Dec 2024 16:40:09 +0900

풀이

해당 문제를 처음 봤을 때는
substring으로 특정 문자열을 찾으면 되겠구나 했지만
이렇게 쉬운데 정답 비율이 낮다는 건, 무슨 의도가 있겠구나 싶었음
그래도 우선 시도해보고 그에 따라 변화를 주는 것이 좋을 것 같다고 판단하여
그대로 실행했지만 역시나... 50%까지만 정답
이후 어떻게 해볼까 고민하다가
단순히 I와O의 반복되는 길이를 찾고
해당 구간에서 N길이에 따른 문자열의 길이를 카운팅하면 되지 않을까하고
알고리즘을 작성한 결과 무난히 통과!

// 성공 코드

import java.io.*;
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());
        int M = Integer.parseInt(br.readLine());
        String s = br.readLine();
        System.out.println(findResult(M,N*2+1,s));
    }
    private static int findResult(int M, int ms_ln, String s) {
        int cnt = 0;
        int ln = 0;
        char[] check = {'I','O'};
        for (int i=0; i<M; i++) {
            if (check[ln%2]==s.charAt(i)) ln++;
            else {
                cnt+=cal(ms_ln, ln);
                ln=check[0]==s.charAt(i)?1:0;
            }
        }
        if (ln!=0) cnt+=cal(ms_ln, ln);
        return cnt;
    }

    private static int cal(int ms_ln, int ln) {
        return ln>=ms_ln?(ln-ms_ln)/2+1:0;
    }
}

// 50% 코드

import java.io.*;
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());
        int M = Integer.parseInt(br.readLine());
        String s = br.readLine();
        System.out.println(findResult(M,N*2+1,makeString(N),s));
    }
    private static String makeString(int N) {
        StringBuilder sb = new StringBuilder();
        for (int i=0; i<N; i++) sb.append("IO");
        sb.append("I");
        return sb.toString();
    }

    private static int findResult(int M, int ms_ln, String ms, String s) {
        int cnt = 0;
        for (int i=0; i<=M-ms_ln; i++) {
            if (s.substring(i,i+ms_ln).equals(ms)) cnt++;
        }
        return cnt;
    }
}

[백준, 자바, 1389번] 케빈 베이컨의 6단계 법칙

hminor — Mon, 9 Dec 2024 17:51:02 +0900

풀이

해당 문제는 단순히 데이터 추가 후
결과를 찾고자는 곳에 가장 마지막 유저를 제외하고
BFS로 찾으며, 조건에 따라 mtx에 단계를 변경하는 것으로 해결
내가 작성한 풀이에서 아쉬운 점은 예를 들어 N=5의 경우
1번은 모든 사람에 대한 조사를 하기에
2,3,4,5번의 모든 1번 mtx가 채워져 있기에
2번은 2번은 같으니 제외하고
3번부터 5번까지만 찾도록 하고 싶은데
이를 어떻게 해결할 수 있을지를 고민해도
잘 떠오르지 않아 그냥 마지막 사람을 제외한 모든 사람을 BFS로 탐색하는 것으로 해결...

import java.io.*;
import java.util.*;
public class _1389 {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static int[][] mtx;
    static List<Set<Integer>> relationArr = new ArrayList<>();
    static StringTokenizer st;
    static int[] result;
    public static void main(String[] args) throws IOException {
        st = new StringTokenizer(br.readLine());
        int N = Integer.parseInt(st.nextToken());
        int M = Integer.parseInt(st.nextToken());
        mtx = new int[N+1][N+1];
        result = new int[]{-1,-1};
        addData(N,M);
        findResult(N);
        System.out.println(result[0]);
    }

    private static void addData(int N, int M) throws IOException {
        for (int i=0; i<=N; i++) relationArr.add(new HashSet<>());
        for (int i=0; i<M; i++) {
            st = new StringTokenizer(br.readLine());
            int a = Integer.parseInt(st.nextToken());
            int b = Integer.parseInt(st.nextToken());
            relationArr.get(a).add(b);
            relationArr.get(b).add(a);
        }
    }

    private static void findResult(int N) {
        for (int i=1; i<=N; i++) {
            if (i!=N) BFS(i,N);
            int hap = 0;
            for (int j=1; j<=N; j++) hap+=mtx[i][j];
            if (result[0]==-1 || result[1]>hap) {
                result[0]=i;
                result[1]=hap;
            }
        }
    }

    private static void BFS(int a, int N) {
        Deque<int[]> dq = new ArrayDeque<>(Arrays.asList(new int[]{a,0}));
        boolean[] visit = new boolean[N+1];
        visit[a]=true;

        while (!dq.isEmpty()) {
            int[] now = dq.pollFirst();
            for (int next: new ArrayList<>(relationArr.get(now[0]))) {
                if (!visit[next]) {
                    dq.add(new int[]{next,now[1]+1});
                    visit[next]=true;
                    if (mtx[a][next]==0) {
                        mtx[a][next]=now[1]+1;
                        mtx[next][a]=now[1]+1;
                    }
                }
            }
        }
    }
}

[백준, 자바, 30804번] 과일 탕후루

hminor — Fri, 6 Dec 2024 17:01:50 +0900

풀이

해당 문제는 뭔가 어려웠다.
우선 처음에는 어떻게 해결할 수 있을지 고민하다가
누적합으로 해결 할 수 있지 않을까 했는데
생각하다보니 20만 배열의 경우엔 너무 반복이 심할 것 같아서
고민을 했지만 우선 진행
하지만 역시나 시간초과...
그래서 아래에 태그를 확인해보니 투 포인터
물론 두 개의 인덱스로 어찌어찌 한다는 정도는 알지만
어떤 경우에 사용하면 좋은지 이해하고자,
우선 개념을 이해하기로 함.

주요 개념
	포인터: 배열이나 리스트에서 특정 위치를 가리키는 인덱스입니다.
	두 포인터:
		왼쪽 포인터와 오른쪽 포인터를 초기화하고, 조건에 따라 이동시키면서 필요한 값을 찾습니다.
	시간 복잡도: 보통 **O(N)**으로 동작하며, 완전 탐색(O(N²))에 비해 효율적입니다.

투 포인터의 활용
	구간 합 문제:
		연속된 부분 구간(subarray)의 합을 빠르게 찾기.
	두 배열의 교집합:
		두 정렬된 배열에서 공통 요소 찾기.
	특정 조건 만족 구간:
		최소 길이의 구간 찾기, 예를 들어 슬라이딩 윈도우와 결합.


장점
	효율적: 시간 복잡도를 줄임.
	메모리 절약: 추가적인 자료 구조 없이 인덱스만으로 해결 가능.

이에 대한 개념과 추가 자료를 참고하여 아래와 같이 해결
우선 입력 값을 배열에 추가한 뒤
배열을 순차적으로 돌면서 Map에 해당 인덱스의 값을 key로 두고 카운팅
다만 put을 하며 해당 key의 기존 value를 가져오려고 하다보니
그냥 get 만 하게 되면 key가 없을 경우 null이기에
연산을 진행하면 에러처리가 발생
그래서 getOrDefault 메서드를 활용하여 없을 경우 0으로 초기화하는 작업을 진행
이후 탐색 구간에 주어진 과일 종류가 3개 이상의 경우엔
시작 포인트 부터 하나씩 차감 후 종류가 2개가 되도록 만들고
이후 시작 포인트를 1씩 증가
마지막으로 while 문 탈출 후
현재 거리를 계산한 값 중 가장 큰 값을 리턴하여 해결.

// 성공 코드(투 포인터)

import java.io.*;
import java.util.*;

public class _30804 {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static int[] li;
    public static void main(String[] args) throws IOException {
        int N = Integer.parseInt(br.readLine());
        addFruits(N);
        System.out.println(findManyFruits(N));
    }


    private static void addFruits(int N) throws IOException {
        li = new int[N];
        st = new StringTokenizer(br.readLine());
        for (int i=0; i<N; i++) li[i]=Integer.parseInt(st.nextToken());
    }

    private static int findManyFruits(int N) {
        Map<Integer, Integer> fruits = new HashMap<>();
        int result = 0;
        int s = 0;
        for (int e=0; e<N; e++) {
            fruits.put(li[e],fruits.getOrDefault(li[e],0)+1);
            while (fruits.size()>2) {
                fruits.put(li[s],fruits.get(li[s])-1);
                if (fruits.get(li[s])==0) fruits.remove(li[s]);
                s++;
            }
            if (e-s+1>result) result = e-s+1;
        }
        return result;
    }
}

// 실패 코드(누적합)

import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static int[][] li;
    public static void main(String[] args) throws IOException {
        int N = Integer.parseInt(br.readLine());
        addFruits(N);
        System.out.println(findManyFruits(N));
    }

    private static void addFruits(int N) throws IOException {
        li = new int[N+1][10];
        st = new StringTokenizer(br.readLine());
        for (int i=1; i<=N; i++) {
            li[i]= Arrays.stream(li[i-1]).toArray();
            li[i][Integer.parseInt(st.nextToken())]++;
        }
    }

    private static int findManyFruits(int N) {
        int result = 0;
        for (int i=1; i<N; i++) { // 기준
            for (int j=i+1; j<=N; j++) { // 이동
                int[] f_cnt = {0,0}; // 과일 종류, 총 개수
                for (int k=0; k<9; k++) {
                    if (li[j][k]-li[i-1][k]!=0) {
                        f_cnt[0]++; // 과일 카운팅
                        f_cnt[1]+=li[j][k]-li[i-1][k]; // 총 개수 카운팅
                        if (f_cnt[0]>2) break;
                    }
                }
                if (!(f_cnt[0]>2)&&f_cnt[1]>result) result=f_cnt[1];
            }
        }
        return result;
    }
}