정찡이

[JAVA] 백준 21610 마법사 상어와 비바라기

정찡이 — Sun, 12 Mar 2023 17:01:23 +0900

1. 문제 링크

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

21610번: 마법사 상어와 비바라기

마법사 상어는 파이어볼, 토네이도, 파이어스톰, 물복사버그 마법을 할 수 있다. 오늘 새로 배운 마법은 비바라기이다. 비바라기를 시전하면 하늘에 비구름을 만들 수 있다. 오늘은 비바라기

www.acmicpc.net

2. 문제 요약

# 초기 비구름 생성: (N, 1), (N, 2), (N-1, 1), (N-1, 2) 명령대로 아래 순서 진행
1. 모든 구름이 di 방향으로 si칸 이동한다.
2. 각 구름에서 비가 내려 구름이 있는 칸의 바구니에 저장된 물의 양이 1 증가한다.
3. 구름이 모두 사라진다.
4. 마법 시전
- 2번에서 구름이 존재한 곳에서 대작선 거리 1인 칸에 있는 수만큼 증가 + 1
- 여기서는 경계 넘어가면 안쳐줌
5. 바구니에 저장된 물의 양이 2 이상인 모든 칸에 구름이 생기고, 물의 양이 2 줄어든다.
이때 구름이 생기는 칸은 3에서 구름이 사라진 칸이 아니어야 한다.

3. 아이디어 정리

초기화 비구름 생성: (N, 1), (N, 2), (N-1, 1), (N-1, 2)

명령 순서대로 아래 진행

구름 이동: 모든 구름이 di 방향으로 si칸 이동한다.
바구니 물 증가: 1위치에 +1 증가한다.
마법 시전: 구름 위치 대각선 위치에 물이 있는 수만큼 + 1
다음 구름 생성: 바구니에 저장된 물의 양이 2 이상인 모든 칸& 3에서 구름 제거 x에 구름이 생기고 2 줄어든다.
다음 구름을 현재 구름으로 변경

4. 문제 풀이

4-1. 내 풀이

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

public class Main{
	static int result, n, m = 0 ;
	static int[][] arr, cloud;
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
	static StringTokenizer st;
	//  ←, ↖, ↑, ↗, →, ↘, ↓, ↙
	static int[] dx = {0, -1, -1, -1, 0, 1, 1, 1};
	static int[] dy = {-1, -1, 0, 1, 1, 1, 0, -1};
	
	static int[] dx2 = {-1, -1, 1, 1};
	static int[] dy2 = {-1, 1, 1, -1};
	
public static void main(String[] args) throws Exception {
    	
    	st = new StringTokenizer(br.readLine());
    	n = Integer.parseInt(st.nextToken());
        m = Integer.parseInt(st.nextToken());
         
        arr = new int[n][n];      // 바구니 물의 양 저장 
        cloud = new int[n][n];    // 구름 존재 저장 
        
        // 구름 초기화 
        cloud[n - 1][0] = 1;
        cloud[n - 1][1] = 1;
        cloud[n - 2][0] = 1;
        cloud[n - 2][1] = 1;
    	 // 바구니 물의 양 
    	 for (int i = 0; i < n; i++) {
    		 st = new StringTokenizer(br.readLine());
    		 for (int j = 0; j < n; j++) {
    			 arr[i][j] = Integer.parseInt(st.nextToken());
    		 }
    	 }
    	 // m번의 이동 
    	 for(int i = 0; i < m; i++) {
    		 st = new StringTokenizer(br.readLine());
    	     int d = Integer.parseInt(st.nextToken());
    	     int s = Integer.parseInt(st.nextToken()) % n;
    	     
    	     // 1. 모든 구름이 이동 
    	     cloud = move(d - 1, s);
    	     // 2. 각 구름에 비가 내려 바구니 + 1
    	    rain();
    	     // 3. 구름 사라짐 (pass) 
    	     // 4. 구름있는 칸 마법 시전 
    	      // - 대각선 방향 1인 칸 바구니 물 양 증가. 칸 넘는 것은 취급 안함
    	    magic();
    	     // 5. 물 2이상인 칸&3에서 구름이 없는 경우 =>  구름 생기고, 바구니 -2
    	    cloud = make_cloud();
    	     
    	   
    	 }
    	 // 결과 
 	    for(int x = 0; x < n; x++) {
	    	 for(int y = 0; y < n; y++) {
	    		 result += arr[x][y];
	    		 }
	    	 }
    	 
       bw.append(Integer.toString(result));
       bw.flush();    
    }
	
	public static int[][] move(int d, int s){
	     int[][] ncloud = new int[n][n];
	     for(int x = 0; x < n; x++) {
	    	 for(int y = 0; y < n; y++) {
	    		 if (cloud[x][y] == 1) {
	    			 int nx = (x + dx[d] * s + n) % n;
	    			 int ny = (y + dy[d] * s + n) % n;
	    			 ncloud[nx][ny] = 1;

	    		 }
	    	 }
	     }
	     return ncloud;
	}
	
	public static void rain() {
		 for(int x = 0; x < n; x++) {
	    	 for(int y = 0; y < n; y++) {
	    		 if (cloud[x][y] == 1) {
	    			 arr[x][y] += 1;
	    		 }
	    	 }
	     }
	}
	
	public static void magic() {
		for(int x = 0; x < n; x++) {
	    	 for(int y = 0; y < n; y++) {
	    		 int res = 0;
	    		 if(cloud[x][y] == 1) {
	    			 for(int i = 0; i < 4; i++) {
	    				 int nx = x + dx2[i];
	    				 int ny = y + dy2[i];
	    				 if (nx < 0 || ny < 0 || nx >= n || ny >=n) {
	    					 continue;
	    				 }
	    				 if(arr[nx][ny] >= 1) {
	    					 res += 1;
	    				 }
	    				 
	    			 }
	    		 }
	    		 arr[x][y] += res;
	    	 
	    	 	}
	    	 }
		
	}
	
	public static int[][] make_cloud() {
		// 물 2이상인 칸&3에서 구름이 없는 경우 =>  구름 생기고, 바구니 -2
		int[][] ncloud = new int[n][n];
		for(int x = 0; x < n; x++) {
	    	 for(int y = 0; y < n; y++) {
	    		 if(arr[x][y] >= 2 && cloud[x][y] != 1) {
	    			 ncloud[x][y] = 1;
	    			 arr[x][y] -= 2;
	    		 }
	    	 }
	    	}
		
		return ncloud;
	}

}

5. 결론

구현 문제

[자바의 정석] 6장 객체지향 언어 1. 4~6 변수의 초기화

정찡이 — Sun, 12 Mar 2023 16:42:18 +0900

아래 내용은 자바의 정석 강의&책을 보면서 정리한 내용입니다.

들어가기 전에

자바의 정석 6장 내용 리스트

이번 시간에는 아래 내용 중 오버로딩~변수의 초기화 부분을 정리하겠습니다.

4. 오버로딩

4.1 오버로딩이란?

⭐ 오버로딩? 한 클래스 내에 같은 이름의 메서드를 여러 개 정의하는 것

4.2 오버로딩 조건

⭐ 1. 메서드 이름이 같다.
2. 매개변수의 개수 또는 타입이 다르다.
주의! 반환 타입은 오버로딩 구현 시 아무런 영향을 주지 못함

4.3 오버로딩의 예

가장 대표적인 것은 println 메서드이다. 아래와 같이 매개변수 타입에 따라서 오버로딩 되어 있다.

1) 리턴 타입만 다른 경우 - 오버로딩이 아님

아래 add() 메서드에서 리턴값만 다른 경우 아래와 같은 에러가 발생한다. 이는 오버로딩이 아니다!!

class Math{
    int add(int a, int b) {return a + b;}
    long add(int a, int b){return long(a + b);}
}

2) 매개변수 타입 순서만 다른 경우 - 오버로딩

아래는 두 메서드 모두 int형과 long형 매개변수가 하나씩 선언되어 있지만 서로 순서가 다른 경우이다. 이 경우 구분하여 호출이 가능하므로 오버로딩으로 간주한다. 하지만 이렇게 선언하는 것은 순서를 외워야 하기 때문에 단점이 된다.

아래 m.add(1, 2)와 같은 호출은 불가능하다. 왜냐하면 어떤 메서드를 호출해야할지 알 수가 없다. 따라서 java: reference to add is ambiguous라는 컴파일 에러가 발생한다.

class Math{
    long add(int a, long b) {return a + b;}
    long add(long a, int b){return a + b;}
}

public class Test {
    public static void main(String[] args) {
        Math m = new Math();
        System.out.println(m.add(1, 2L));
        System.out.println(m.add(1, 2));    // 에러 발생:reference to add is ambiguous
    }
}

4.4 오버로딩의 장점

⭐ 모두 근본적으로 같은 기능을 하는 메서드지만 서로 다른 이름을 가져야하면 이름 짓기도 어렵고 메서드를 사용하는 쪽에서 이름을 일일이 구분해서 기억해야 한다. 하지만 오버로딩을 하면 한 개만 기억하면 되고 메서드 명만 보고도 예측이 쉽다.

오버로딩을 사용 안하는 경우, 아래와 같이 정의해야 한다.

4.5 가변인자와 오버로딩

매개변수 개수가 고정이 아닌 동적으로 지정할 수 있다. 가변 인자 선언을 진행하면 가능하다.

가변인자 선언 방식: 타입… 변수명
주의: 가변인자는 마지막에 선언

1) 가변인자 vs 배열 차이점

배열을 매개변수로 하는 경우, 아래와 같이 빈 값으로 넣을 수 없고 반드시 null을 넣어줘야 한다.

2) 가변인자 오버로딩 시, 주의점

아래 예시를 보면 concatenate 메서드를 오버로딩했다. delim이 없는 경우를 오버로딩하였지만, 실제 컴퓨터는 이 두 메서드를 구분할 수 없기 때문에 에러가 발생한다. 따라서 가변인자 메서드는 오버로딩하지 않는 것을 추천한다.

public class Test {
    static String concatenate(String delim, String ... args){
        String result = "";

        for(String str: args){
            result += str + delim;
        }
        return result;
    }
    // 아래 오버로딩 시, 에러 발생!!
    static String concatenate(String ... args){
        return concatenate("", args);
    }
    public static void main(String[] args) {
        String[] strArr = {"100", "200", "300", "400"};
        System.out.println(concatenate("", "100", "200", "300", "400"));           // 100200300400
        System.out.println(concatenate("-", strArr));                                    // 100-200-300-400-
        System.out.println(concatenate(",", new String[]{"100", "200", "300", "400"}));  // 100,200,300,400,
        System.out.println("[" + concatenate(",", new String[0]) + "]");                 // []
        System.out.println("[" + concatenate(",") +  "]");                               // []
    }
}

5. 생성자

5.1 생성자란?

⭐ 생성자란? 인스턴스가 생성될 때 호출되는 인스턴스(iv) 초기화 메서드이다. 따라서 인스턴스 변수의 초기화 작업에 주로 사용되며, 인스턴스 생성 시에 실행되어야 할 작업을 위해서 사용된다. ⇒ 주의! 생성자는 인스턴스를 생성하는 것은 아님!

생성자 조건

생성자의 이름은 클래스의 이름과 같다.
생성자는 리턴값이 없다. ⇒ void 생략

특징

오버로딩이 가능하여 하나의 클래스에 여러 개의 생성자 존재

인스턴스 생성 코드 순서

Card c = new Card();

연산자 new에 의하여 메모리(heap)에 Card 클래스의 인스턴스가 생성된다.
생성자 Card()가 호출되어 수행된다.
연산자 new의 결과로 생성된 Card인스턴스의 주소가 반환되어 참조변수 c에 저장된다.

5.2 기본 생성자

⭐ 기본 생성자란? 컴파일러가 자동으로 생성해 주는 매개변수가 없고 아무런 내용 없는 생성자
주의: 기본 생성자는 생성자가 하나도 없을 때 컴파일러가 자동으로 생성되는 것!!

아래 예제를 통해 주의: 기본 생성자는 생성자가 하나도 없을 때 자동으로 생성되는 것!! 을 알 수 있다.

Data2 클래스는 매개변수가 있는 생성자를 정의하였다. 그러면 컴파일러는 자동으로 기본 생성자를 추가하지 않는다.

class Data1{
    int val;
}

class Data2{
    int val;
    // 매개변수가 존재하는 생성자 정의 
    Data2(int x){
        val = x;
    }
}

public class Test {
    public static void main(String[] args) {
        Data1 d1 = new Data1();
        Data2 d2 = new Data2();  // 컴파일 에러!!
        
    }
}

5.3 매개변수가 있는 생성자 - 초기화

생성자도 메서드와 같이 매개변수를 선언하여 호출 시 인스턴스의 초기화 작업을 사용할 수 있다.

class Car{
    String color; 
    String gearType;
    int door;
    
    Car(){}
    Car(String c, String g, int d){
        color = c;
        gearType = g;
        door = d;
    }
}
public class Test {
    public static void main(String[] args) {
        // 인스턴스 초기화 방법 1. 직접 
        Car c1 = new Car();
        c1.color = "white";
        c1.gearType = "auto";
        c1.door = 4;

        // 인스턴스 초기화 방법 2. 생성자 사용  
        Car c2 = new Car("white", "auto", 4);
    }
}

5.4 생성자에서 다른 생성자 호출하기 - this(), this

⭐ this: 인스턴스 자신을 가리키는 참조변수. 인스턴스 주소가 저장되어 있다.
모든 인스턴스메서드에 지역변수로 숨겨진 채 존재.
this(), this(매개변수): 생성자. 같은 클래스의 다른 생성자 호출 시 사용
- 생성자의 이름으로 클래스 이름 대신 this를 사용한다.
- 한 생성자에서 다른 생성자를 호출할 때는 반드시 첫 줄에서만 호출이 가능하다.

주의: this는 static 메서드(클래스 메서드)에서 사용할 수 없다. this는 인스턴스를 의미하기 때문!: this는 static 메서드(클래스 메서드)에서 사용할 수 없다. this는 인스턴스를 의미하기 때문!

첫 줄에서만 호출이 가능한 이유?
- 다른 생성자 호출하기 이전 초기화 작업이 무의미해질 수 있다. → 7장에서 자세히 배움!
결과적으로 아래 예시는 에러가 발생한다.

class Car{
    String color;
    String gearType;
    int door;

    Car(){
        this("white", "auto", 4);
    }
    Car(String color){
        door = 5;              // this가 첫번째줄에 존재하지 않음! 
        Car(color, "auto", 4); // this로 생성자를 호출해야한다. 
    }
    Car(String c, String g, int d){
        color = c;
        gearType = g;
        door = d;
    }
}

수정된 올바른 예시

class Car{
    String color;
    String gearType;
    int door;

    Car(){
        this("white", "auto", 4);   // 아무것도 지정 안하는 경우, default값 설정 
    }
    Car(String color){
        this(color, "auto", 4);
    }
    Car(String c, String g, int d){
        color = c;
        gearType = g;
        door = d;
    }
}
public class Test {
    public static void main(String[] args) {
        // 인스턴스 초기화 방법 1. 직접
        Car c1 = new Car();
        c1.color = "white";
        c1.gearType = "auto";
        c1.door = 4;

        // 인스턴스 초기화 방법 2. 생성자 사용
        Car c2 = new Car("white", "auto", 4);
    }
}

this.인스턴스 사용
- 아래와 같이 this.인스턴스로 적어야 인스턴스와 매개변수 구분이 가능하다.

class Car{
    String color;
    String gearType;
    int door;

    Car(){
        this("white", "auto", 4);
    }
    Car(String color){
        this(color, "auto", 4);
    }
    Car(String color, String gearType, int door){
        this.color = color;
        this.gearType = gearType;
        this.door = door;
    }
}

5.5 생성자를 이용한 인스턴스의 복사

아래 Car(Car c)를 통해 인스턴스를 복사하여 사용한 예시이다. c1.door = 100;로 값을 변경했지만 c2.door는 변경되지 않음을 알 수 있다.
this()를 호출하여 인스턴스 복사를 하였다.

class Car{
    String color;
    String gearType;
    int door;

    Car(){
        this("white", "auto", 4);
    }
    Car(Car c){
        this(c.color, c.gearType, c.door);   //this를 활용하여 복사 
    }
    Car(String color, String gearType, int door){
        this.color = color;
        this.gearType = gearType;
        this.door = door;
    }
}
public class Test {
    public static void main(String[] args) {
        // 인스턴스 초기화 방법 1. 직접
        Car c1 = new Car();
        Car c2 = new Car(c1);
        System.out.println("c1: " + c1.color + " " + c1.gearType + " " + c1.door);    // c1: white auto 4
        System.out.println("c2: " + c2.color + " " + c2.gearType + " " + c2.door);    // c2: white auto 4
        c1.door = 100;
        System.out.println("c1: " + c1.color + " " + c1.gearType + " " + c1.door);    // c1: white auto 100
        System.out.println("c2: " + c2.color + " " + c2.gearType + " " + c2.door);    // c2: white auto 4
    }
}

6. 변수의 초기화

6.1 변수의 초기화

⭐ 멤버변수(클래스변수와 인스턴스변수)와 배열의 초기화: 선택적 ⇒ 기본값으로 자동 초기화됨 (대부분 0으로 초기화)
* 지역변수의 초기화: 필수

멤버변수(cv, iv) 초기화 방법

자동 초기화: 0으로 기본 초기화
간단 초기화(=명시적 초기화) : =
복잡 초기화
1. 생성자
2. 초기화 블럭
- 인스턴스 초기화 블럭: 인스턴스변수를 초기화 하는데 사용
- 클래스 초기화 블럭: 클래스변수를 초기화 하는데 사용

6.2 멤버변수 초기화 방식 1. 명시적 초기화

변수를 선언과 동시에 초기화 하는 것

class Car {
	int door = 4;             // 기본형 초기화 
	Engine e = new Engine();  // 참조형 초기화. null이 아닌 객체 주소를 넣기 

}

6.3 멤버변수 초기화 방식 2. 초기화 블럭

⭐ - 클래스 초기화 블럭: 클래스변수의 복잡한 초기화에 사용된다.
- 인스턴스 초기화 블럭: 인스턴스변수의 복잡한 초기화에 사용된다. 거의 사용 안 함!!

클래스 초기화 인스턴스 초기화 (거의 사용 안 함)→ 생성자 사용

방법	static { /* 클래스 초기화블럭 */}	{/* 인스턴스 초기화블럭 */}
수행 시기	클래스가 메모리에 처음 로딩될 때 한 번	- 인스턴스 생성할 때 마다 수행

인스턴스 초기화 사용 목적 예시

Car 생성자 수행 시 count ++; serialNo = count; 해당 부분은 중복이 된다.

Car(){
        count ++;           // 중복 
        serialNo = count;   // 중복 
        color = "White";
        gearType = "Auto";
    }
    
    Car(String color, String gearType){
        count ++;          // 중복 
        serialNo = count;  // 중복 
        this.color = color;
        this.gearType = gearType;
    }

아래와 같이 초기화 블럭으로 초기화 수행을 하면 중복을 제거할 수 있다.

{ count ++; serialNo = count; } 초기화 블럭을 추가하여 중복을 제거할 수 있다.

Car(){
        color = "White";
        gearType = "Auto";
    }

    Car(String color, String gearType){
        this.color = color;
        this.gearType = gearType;
    }
    {
        count ++;
        serialNo = count;
    }

클래스 초기화, 인스턴스 초기화 사용 예시

아래예시는 초기화 블럭 호출 시기를 알 수 있다.

class BlockTest {
    static {
        System.out.println("static {}");   // 클래스 초기화. 1번 호출. BlockTest가 메모리에 로딩 시 가장 먼저 수행
    }

    {
        System.out.println("{ }");        //  인스턴스 초기화. 3번 호출. 객체 생성 시 인스턴스 초기화 블록 수행
    }

    public BlockTest(){
        System.out.println("생성자");       // 4번 호출. 인스턴스 초기화 -> 생성자 호출 
    }
    public static void main(String[] args) {
        System.out.println("BlockTest bt = new BlockTest();");  // 2번 호출
        BlockTest bt = new BlockTest();
        System.out.println("BlockTest bt2 = new BlockTest();");
        BlockTest bt2 = new BlockTest();
    }
}

결과

static {}
BlockTest bt = new BlockTest();
{ }
생성자
BlockTest bt2 = new BlockTest();
{ }
생성자

6.4 멤버변수의 초기화 시기와 순서

	클래스 변수	인스턴스 변수
초기화 시점	클래스가 처음 로딩될 때 한번	인스턴스가 생성될 때마다 각 인스턴스별로 초기화
초기화 순서	기본값 → 명시적초기화 → 클래스 초기화 블럭	기본값 → 명시적초기화 → 인스턴스 초기화 블럭 → 생성자

초기화 순서 예시

class InitTest {
 // 명시적 초기화 (간단 초기화) 
	static int cv = 1;
	int iv = 1;

	static {cv = 2;}   // 클래스 초기화 블럭 
	{iv = 2;}          // 인스턴스 초기화 블럭 

	InitTest() {       // 생성자 
		iv = 3;
	}

}

위 예시의 순서는 아래와 같이 이뤄진다.

cv 초기화 → iv 초기화 진행
자동(0으로 초기화) → 간단(=) → 복잡 초기화(static {}, 생성자)

사용 예시

아래 예시는 초기화 사용 예시다.

예를 들어 공장에서 제품 생산 시 생산일련번호(serialNo)를 제품마다 부여한다. 이때 {} 블럭(초기화 블럭)을 사용한다.

class Product {
    static int count = 0;  // 인스턴스 수 저장
    int serialNo;

    {
        ++count;
        serialNo = count;
    }
    public Product(){}
}
public class Test {
    public static void main(String[] args) {
        Product p1 = new Product();
        Product p2 = new Product();
        Product p3 = new Product();

        System.out.println("p1: " + p1.serialNo );       // p1: 1
        System.out.println("p2: " + p2.serialNo );       // p2: 2
        System.out.println("p3: " + p3.serialNo );       // p3: 3
        System.out.println("count: " + Product.count );  // count: 3
    }
}

다음 시간에는 자바의 정석 7장 객체지향 언어 2에 대해서 정리하겠습니다.

[자바의 정석] 6장 객체지향 언어 1. 1~3 변수와 메서드

정찡이 — Tue, 7 Mar 2023 23:43:24 +0900

아래 내용은 자바의 정석 강의&책을 보면서 정리한 내용입니다.

들어가기 전에

자바 공부 방식

공부 방식은 아래와 같습니다.

객체지향 개념: 자바의 정석 6, 7장 보기 → 내가 이해한 개념을 A4용지에 2장으로 정리하여 암기하기!
공부 순서: 자바 기초&자바의 정석 ⇒ jsp, spring ⇒ 설계(디자인 패턴, 객체지향)

자바의 정석 6장 내용 리스트

이번 시간에는 아래 내용 중 객체지향언어 ~변수와 메서드 부분을 정리하겠습니다.

1. 객체 지향 언어

객체지향은 기존에 있는 프로그래밍 언어에 객체지향 개념만 추가된 것이다.

⭐ 객체지향언어: 프로그래밍 언어 + 객체지향 개념(규칙)[암기 필요]

OOP(객체 지향 프로그래밍) 핵심 개념

캡슐화
상속
추상화
⭐️ 다형성: 가장 중요!

객체지향언어 특징

코드의 재사용성
코드의 관리 용이
신뢰성이 높은 프로그래밍 : 제어자와 메서드를 이용하여 데이터를 보호

2. 클래스와 객체

2.1 클래스와 객체의 정의와 용도

	클래스	객체
의미	객체를 정의해 놓은 것 → 객체를 생성하는데 사용	실제로 존재하는 것 → 객체가 가지고 있는 기능과 속성에 따라 다름
예시	제품 설계도 TV 설계도	제품 TV

2.2 객체와 인스턴스

간단하게 같은 의미라고 생각하자.

	객체	인스턴스
의미	일반적으로 ‘객체’를 사용	* 클래스 -(인스턴스화)→ 인스턴스(객체) * 어떤 클래스로부터 만들어진 객체를 강조할 때 사용 ex) TV 인스턴스 ⇒ TV 클래스로부터 만들어진 객체

2.3 객체의 구성요소 - 속성과 기능

⭐ 객체 = 속성(멤버변수) + 기능(메서드) 집합

아래와 같이 TV의 속성과 기능을 나눌 수 있고, 실제로 java에서 클래스 선언 시 변수와 메서드로 구성한다.

2.4 인스턴스 생성과 사용

객체를 생성하는 과정 두 가지를 살펴보자.

1) 객체 생성 과정

아래 객체 생성을 그림으로 한 줄씩 살펴보자.

// 1. 클래스 작성 (설계도) 
class Tv {
    // Tv 속성 (멤버 변수)
    String color;
    boolean power;
    int channel;
    // Tv의 기능(메서드)
    void power(){ power =!power;}
    void channelUp(){ ++channel;}
    void channelDown() {--channel;}

}

public class TvTest {
    public static void main(String[] args) {
				// 2. 객체 생성 
        Tv t;
        t = new Tv();
				// 3. 객체 사용 
        t.channel = 7;
        t.channelDown();
        System.out.println("현재 채널은 " + t.channel + "입니다.");
    }
}

- 메모리에 참조변수(리모컨) t 공간이 확보가 된다.
  - 참조변수: 다른 변수의 메모리 위치를 저장하고 있는 변수를 의미한다. 참조변수 생성: Tv t;

2. 객체 생성 & 참조변수에 넣기 : t = new Tv();

연산자 new에 의해 Tv클래스의 인스턴스가 메모리의 빈 공간에 생성
- 객체의 멤버들은 초기화되어 생성
대입 연산자를 통해 객체의 주소값이 t에 저장

3. 객체 사용: t.channel = 7;

channel에 7을 저장한다.

4. 객체 사용: t.channelDown();

channelDown 메서드를 호출하여 channel를 1 감소시킨다.

5. System.out.println("현재 채널은 " + t.channel + "입니다.");

감소된 6이 출력된다.

2) 객체 생성 과정 - 두 개

아래 예제에서 주의할 부분은 t2 = t1;이다. t2가 지닌 참조변수가 변경되는 부분이다.

class Tv {
    // Tv 속성 (멤버 변수)
    String color;
    boolean power;
    int channel;
    // Tv의 기능(메서드)
    void power(){ power =!power;}
    void channelUp(){ ++channel;}
    void channelDown() {--channel;}

}

public class TvTest {
    public static void main(String[] args) {
        Tv t1 = new Tv();
        Tv t2 = new Tv();
        System.out.println("t1 현재 채널은 " + t1.channel + "입니다.");
        System.out.println("t2 현재 채널은 " + t2.channel + "입니다.");
        t2 = t1;
        t1.channel = 7;
        System.out.println("t1 현재 채널은 " + t1.channel + "입니다.");  // t1 현재 채널은 7입니다.
        System.out.println("t2 현재 채널은 " + t2.channel + "입니다.");  // t2 현재 채널은 7입니다.

    }
    }

Tv t1 = new Tv(); Tv t2 = new Tv();

2. t2 = t1;

t2도 t1과 동일한 값을 참조한다.
결과적으로 0x200번지 객체는 참조하지 않아 GC에 의해 제거된다.

2.5 객체 배열

⭐ 객체 배열 == 참조변수 배열

아래는 3개의 Tv 객체를 만드는 방법입니다.

class Tv {
    // Tv 속성 (멤버 변수)
    String color;
    boolean power;
    int channel;
    // Tv의 기능(메서드)
    void power(){ power =!power;}
    void channelUp(){ ++channel;}
    void channelDown() {--channel;}

}

public class TvTest {
    public static void main(String[] args) {
       Tv[] tvArr = new Tv[3];
       
       for(int i = 0; i < tvArr.length; i++){
           tvArr[i] = new Tv();
       }
       
    }
    }

Tv [] tvArr = new Tv[3];
- new Tv[3]는 참조변수 배열을 의미한다.

2. for(int i = 0; i < tvArr.length; i++){ tvArr[i] = new Tv(); }

for문을 돌려 Tv라는 객체를 생성해준다.

2.6 클래스의 또 다른 정의

클래스는 크게 3가지 의미를 지닌다.

설계도
- 객체를 생성하기 위한 틀
데이터 + 함수 (구조체 + 함수)
- 클래스는 데이터와 함수의 결합으로 즉, 구조체 + 함수이다.
사용자 정의 타입
- 사용자가 원하는 타입을 직접 만들 수 있다.

3. 변수와 메서드

3.1 선언위치에 따른 변수의 종류

변수는 클래스 변수, 인스턴스 변수, 지역 변수 모두 세 종류가 있다. 자세한 부분은 표를 보면 알 수 있다.

변수의 종류	선언 위치	생성 시기	설명
클래스 변수 (CV)	클래스 영역	클래스가 메모리에 올라갈 때	- 클래스 변수 선언 방법은 앞에 static를 붙이면 됨 - 인스턴스마다 독립적인 저장공간을 갖는 인스턴스 변수와 다르게 클래스 변수는 모든 인스턴스가 공유하게 된다. - 객체 생성이 필요없이 사용 가능 - 접근하기 위해 “클래스이름.클래스변수” - public을 넣으면 프로그램 내 어디서나 접근할 수 있는 전역변수 성격을 지님
인스턴스 변수 (IV)	클래스 영역	인스턴스 생성 시	- 값을 읽거나 저장을 위해서는 인스턴스를 생성해야함 - 인스턴스는 독립적인 저장공간을 가진다.
지역 변수 (LV)	클래스 영역 이외의 영역 (메서드, 생성자, 초기화 블럭 내부)	변수 선언문이 수행되었을 때	- 메서드 내에서만 사용 가능하며 메서드 종료되면 소멸되어 사용이 불가능하다. - {} 블록 내에서만 사용 가능

3.2 클래스변수와 인스턴스변수

⭐ 클래스 변수:
아래 예시와 같이 모든 카드가 공통으로 가진 속성을 선언한다. ex) 카드의 폭, 높이
⭐ 인스턴스 변수:
개별 속성인 경우 사용 ex) 카드의 무늬, 숫자

c1.width = 50;
- 클래스 변수를 변경하면 인스턴스가 하나의 저장공간을 공유하여 모두 변경된 값을 지닌다.

class Card {
    String kind;
    int number;
    // 클래스 변수: 모든 객체가 동일한 경우 사용
    static int width = 100;
    static int height = 200;
}

public class CardTest {
    public static void main(String[] args) {
        System.out.println(Card.width + " " + Card.height); // 100 200 

        Card c1 = new Card();
        c1.kind = "Heart";
        c1.number = 7;

        Card c2 = new Card();
        c1.kind = "Space";
        c1.number = 4;

        c1.width = 50;
        System.out.println(c1.width);  // 50 
        System.out.println(c2.width);  // 50
        System.out.println(Card.width);// 50
    }
    }

메모리 구조로 그려보기!
- jvm 메모리 구조 개념은 아래 3.7에서 자세히 나온다.
- 여기서 중요하게 파악할 부분은 클래스 변수는 공유된다는 점이다.

3.3 메서드

메서드는 크게 선언부와 구현부로 이루어져 있다.

선언부

메서드 이름
반환 타입
- 반환 값을 적어준다.
- 반환값이 없는 경우 ‘void’ 적어야 한다.

구현부

return문
- void가 아닌 경우 return 반환값이 반시드 존재
- 반환타입과 일치하거나 자동 형변환이 가능한 것만 가능

3.7 JVM 메모리 구조

응용프로그램이 실행되면 JVM은 시스템으로부터 프로그램을 수행하는데 필요한 메모리를 할당받고, JVM은 이 메모리를 용도에 따라 여러 영역으로 나눠 관리한다. 그중 주요 영역인 메서드, 스택, 힙 영역에 대해 알아보자. 주요 영역은 스택을 제외한 나머지 영역은 스레드 간 공유를 한다.

Runtime Data Area

JVM 메모리 구조

1) 메서드 영역

클래스파일(*. class)을 읽어 분석하여 이곳에 저장한다. 이곳에는 클래스, 인터페이스 static 영역 등을 저장한다.
스레드 간 공유

2) 스택 영역

메서드의 작업에 필요한 메모리 공간을 제공한다.
메서드가 호출되면 호출스택에 호출된 메서드를 위한 메모리가 할당된다.
메서드가 완료되면 할당된 메모리공간은 반환되어 비워진다.
쓰레드간 해당 공간을 공유하지 않는다.
지역 변수, 리턴값 등 임시 값 생성

3) 힙 영역

인스턴스가 생성되는 공간
쓰레드간 공유
new 키워드로 생성되는 객체, 배열로 gc가 주기적으로 제거하는 영역

3.8 기본형 매개변수와 참조형 매개변수

⭐ 기본형 매개변수: 변수의 값을 읽기만 가능 (read) → 값 전달
⭐ 참조형 매개변수: 변수의 값을 읽고 변경 가능 (read & write) → 주소를 전달

아래는 기본형, 참조형 매개변수 예제이다.

class Data {int x;}

public class PrimitiveEx {
    static void primitiveChange(int x){
        x = 100;
        System.out.println("primitiveChange x:" + x);  // primitiveChange x:100
    }
    static void ReferChange(Data d){
        d.x = 1000;
        System.out.println("ReferChange x: " + d.x);  // ReferChange x: 1000
    }
    public static void main(String[] args) {
        Data d = new Data();
        d.x = 10;
        System.out.println("main x:" + d.x);   // main x:10 
        // 1. 기본형 매개변수: 변경 안됨  
        primitiveChange(d.x);
        System.out.println("main x:" + d.x);   // main x:10
        // 2. 참조형 매개변수: 변경됨 
        ReferChange(d);
        System.out.println("main x:" + d.x);   // main x:1000
    }
}

1) 기본형 매개변수 과정

ReferChange 메서드 호출되면서, d.x가 ReferChange 메서드의 매개변수 x로 복사됨
- 값 자체를 copy

2. ReferChange 메서드에서 x 값을 1000 변경

지역 변수 값 1000 변경

3. ReferChange 메서드가 종료되면서 매개변수 x는 스택에서 제거

2) 참조형 매개변수 과정

ReferChange 메서드가 호출되면서 참조변수 d의 값(주소)이 매개변수 d에 복사됨
- 주소값을 복사

2. ReferChange 메서드에서 매개변수 d로 x 값 1000 변경

3. ReferChange 메서드 종료되면서 매개변수 d는 스택에서 제거됨

3.11 클래스 메서드(static 메서드)와 인스턴스 메서드

⭐ 클래스 메서드(static 메서드): 인스턴스와 관계없는(인스턴스 변수나 인스턴스 메서드 사용하지 않는) 메서드를 정의
⭐ 인스턴스 메서드: 인스턴스 변수와 관련된 작업을 하는. 즉, 메서드 작업을 수행하는데 인스턴스 변수를 필요로 하는 메서드
⇒ 인스턴스 변수(iv)를 사용하는지 여부에 따라 구분됨

클래스 메서드(static 메서드) 인스턴스 메서드

	클래스 메서드(static 메서드)	인스턴스 메서드
정의	인스턴스와 관계없는(인스턴스 변수나 인스턴스 메서드 사용하지 않는) 메서드를 정의 ex) Math.random()	인스턴스 변수와 관련된 작업을 하는. 즉, 메서드 작업을 수행하는데 인스턴스 변수를 필요로 하는 메서드
언제 사용	- 인스턴스 변수(iv) & 인스턴스 메소드를 사용하지 않는 경우	인스턴스 변수를 사용하는 경우
특징	- 인스턴스 변수 사용 불가 - 인스턴스 메소드 사용 불가
호출 방식	클래스이름.메서드이름()	참조변수.메서드이름()

두 클래스 사용 방법은 아래 예시와 같다.

class MyMath2 {
    long a, b;

    // 인스턴스 메소드 - 인스턴스 변수를 사용 
    long add(){return a + b;}
    long subtract(){return a - b;}
    long multiply(){return a * b;}
    long divide(){return a / b;}

    // 클래스 메소드(static 메서드) - 인스턴스 변수를 사용 안함! 
    static long add(long a, long b){return a + b;}
    static long subtract(long a, long b){return a - b;}
    static long multiply(long a, long b){return a * b;}
    static long divide(long a, long b){return a / b;}
}

public class MyMathTest2 {
    public static void main(String[] args) {
        // 1. 클래스 메소드 호출 - 객체 생성 필요 없음
        System.out.println(MyMath2.add(200L, 100L));
        System.out.println(MyMath2.subtract(200L, 100L));
        System.out.println(MyMath2.multiply(200L, 100L));
        System.out.println(MyMath2.divide(200L, 100L));

        // 2. 인스턴스 메소드 호출 - 객체 생성 필요
        MyMath2 mm = new MyMath2();
        mm.a = 200L;
        mm.b = 100L;
        System.out.println(mm.add());
        System.out.println(mm.subtract());
        System.out.println(mm.multiply());
        System.out.println(mm.divide());

    }
}

3.12 클래스 멤버와 인스턴스 멤버 간의 참조와 호출

아래 예시와 같이 클래스 메서드는 인스턴스 메소드 or 변수를 호출할 수 없다.

이유? 클래스 메서드가 존재하는 시점에 인스턴스 멤버가 존재하지 않을 수 있다.
- 객체를 생성하지 않으면 인스턴스 멤버는 없다.

class Test {
    int iv;
    static int cv;

    // 인스턴스 메소드
    void instanceMethod2(){
    }
    void instanceMethod(){
        
    }

    // 클래스 메소드
    static void classMethod2(){
    }
    static void classMethod(){
        classMethod2();
        instanceMethod2();     // 인스턴스 메소드 호출 불가 
        System.out.println(cv);
        System.out.println(iv); // 인스턴스 변수 호출 불가 
        
    }
}

다음 시간에는 자바의 정석 6장 객체지향 언어 1 - 오버로딩, 생성자, 변수의 초기화에 대해서 알아 보겠습니다.

개발자에게 선물로 좋은 도커(docker) 각티슈 케이스

정찡이 — Mon, 6 Mar 2023 22:20:35 +0900

개발 블로그하면서 처음으로 협찬이 들어왔습니다

도커를 블로그에 많이 올리기도 하고 많이 사용해서 그런지 협찬을 받아서 너무 좋았습니다!!

개발자라면 정말 가지고 싶은 티슈 케이스입니다!!

빨리 배포하고 싶은 마음이 드네요... 개발자 친구가 있다면 선물 받으면 좋아할 것 같아요

컨테이너 조립전

컨테이너를 조립하기 전 구성품입니다. 빨리 조립을 하고 싶네요!

컨테이너 티슈 케이스 조립 전

컨테이너 정면

조립을 못하는 저에게도 간편하게 조립 가능하고 티슈만 넣으면 완성!!!

완성된 모습의 정면 사진입니다.

컨테이너 옆면

위에는 컨테이너 옆면 모습입니다.

회사에 가져가서 쓰고 싶네요. 동기들이 부러워할 것 같아요

구매는 아래 사이트에서 구매할 수 있습니다~

https://incatos.cafe24.com/product/%EB%8F%84%EC%BB%A4-%EC%BB%A8%ED%85%8C%EC%9D%B4%EB%84%88-%EA%B0%81%ED%8B%B0%EC%8A%88-%ED%9C%B4%EC%A7%80-%EC%BC%80%EC%9D%B4%EC%8A%A4-%ED%8B%B0%EC%8A%88%EC%BB%A4%EB%B2%84-%EC%82%AC%EA%B0%81-%EC%95%84%ED%81%AC%EB%A6%B4-%EA%B0%81%ED%8B%B0%EC%8A%88-%EC%BB%A4%EB%B2%84/11/category/24/display/1/

도커 컨테이너 각티슈 휴지 케이스 티슈커버 사각 아크릴 각티슈 커버 - 푸르가즘

교환 및 반품 주소 - 교환 및 반품이 가능한 경우 - 계약내용에 관한 서면을 받은 날부터 7일. 단, 그 서면을 받은 때보다 재화등의 공급이 늦게 이루어진 경우에는 재화등을 공급받거나

incatos.shop

장고란?

정찡이 — Sun, 31 Jul 2022 13:12:45 +0900

장고란?

The web framework for perfectionists with deadlines. (마감에 쫓기는 완벽주의자를 위한 웹 프레임워크)

장고는 웹 프로그램을 개발하는 데 사용하는 파이썬 웹 프레임워크다. 장고의 특징으로는 다른 프레임워크에 비하면 많은 기능이 존재한다. 예를 들어 Flask는 데이터베이스 관리, 사용자 인증 등 대부분의 것을 직접 다 개발을 해야한다.

장고의 장점

파이썬의 라이브러리를 사용할 수 있다.
오픈소스
기본적인 기능들을 미리 만들어 제공해 쉽고 빠르게 개발
Full Stack Framework : front, backend 등 서버가 필요로 하는 것을 모두 Django가 맡아서 함.

장고의 단점

수많은 만들어진 기능을 제공하지만 원하는 대로 커스텀은 어렵다.
파이썬의 단점을 가진다.
- 인터프리터 언어라서 느리다는 단점

장고의 특징

1) MVT(Model-View-Template)

  Python의 Django 프레임워크에서 사용하는 디자인 패턴이다.

Model ⇒ Model
- 데이터베이스에 저장되는 데이터를 CRUD 하는 부분
View ⇒ Template
- 사용자에게 보이는 UI 부분
Controller ⇒ View
- 프로그램의 비즈니스 로직을 구현하여 데이터를 요청 및 가져오고 가져 온 데이터를 Template에 전달

MVT 순서

클라이언트로부터 요청을 받으면 URLconf를 이용하여 URL을 분석
URL 분석 결과를 통해 해당 URL에 대한 처리를 담당할 View를 결정
View는 자신의 로직을 실행하면서 만일 데이터 베이스 처리가 필요하면 해당 모델에 요청하고 그 결과를 반환 받음
View는 자신의 로직 처리가 끝나면 Template 을 사용하여 클라이언트에 전송할 HTML 파일을 생성
View 는 최종 결과로 HTML 파일을 클라이언트에 보내어 응답

Django Model API

all(): 테이블 데이터를 전부 가져옴
value(*fields): dictionary 형태로 변환하여 데이터를 가져옴
get(): 하나의 row만을 가져옴
filter(): 특정 조건에 맞는 row들을 가져옴
exclude(): 특정 조건을 제외하고 나머지 row들을 가져옴
count(): 데이터의 개수(row의 수)를 가져옴
order_by(): 데이터를 키에 따라 정렬하기 위해 order_by() 사용, -붙으면 내림차순
disinct(): 중복된 값은 하나로 표시하여 필드 중복 방지
first(): 데이터들 중 처음에 있는 row만 가져옴
last(): 데이터들 중 마지막 row만 가져옴
create(**kwargs): 새로운 object를 생성하는 동시에 저장. 테이블에 새로운 데이터 추가하고 생성된 instance를 반환 (insert)
save(): 테이블에 데이터 갱신 (update)
delete(): 테이블에 데이터 삭제
model api를 연결해서 사용 가능
- ex) Object.objects.filter(category = 1). values()

2) 객체 관계 매핑(ORM:Object-Relation Mapping)

   ORM이란, 객체(Object)와 관계형 데이터베이스(Relational)을 연결(Mapping) 해 주는 것을 의미한다.⇒ 데이터베이스의 테이블을 객체(Object)와 연결하여 테이블에 CRUD를 할 때, SQL 쿼리를 사용하지 않고도, 가능하게 하는 것을 말한다.

장점

별도의 SQL문을 사용하지 않아도 객체 지향 프로그래밍 언어로 구현이 가능하며 이는 곧 생산성 증가로 이어진다.
- 대량의 SQL Query를 쓰지 않고도 객체 간의 관계를 풀어낼 수 있기 때문에 개발자가 좀 더 직관적으로 객체간의 관계를 파악할 수 있다.
재사용 및 유지보수가 편리하다.
- 매핑하게 되면 정보가 명확해지기 때문에 ERD를 보는 것에 대한 의존도를 낮출 수 있다.
- ORM은 독립적으로 작성이 되어 있고 해당 객체들은 재사용이 가능하다.
DBMS에 대한 종속성이 줄어든다.
- 대부분의 ORM 프레임워크들은 DB에 종속적이지 않다. 그러므로 개발자들은 객체에 집중함으로써 DBMS를 교체하는 극단적인 작업에도 비교적 적은 리스크와 시간이 소요된다. (여기서 종속적이라는 것은 프로그램 구조가 데이터 구조에 영향을 받는 것을 의미한다)
DB의 마이그레이션을 쉽게 할 수 있다.

단점

직접 SQL문을 작성하는 것보다 상대적으로 복잡할 수가 있고 프로젝트의 복잡성이 높아질 경우 난이도가 그만큼 올라간다.
- 모든 것을 ORM을 통해서만 구현하는 것은 힘들다. 잘못 구현된 경우에 속도 저하 및 심각할 경우 일관성이 무너지는 문제점이 생길 수도 있다.
기존의 기업들은 ORM을 고려하지 않은 DB를 사용하고 있어 ORM에 적합하게 변환하려면 많은 시간과 노력이 필요로 한다.
DB와 바로 연결하는 것보다 초기 설정이 더 많아지거나 복잡해질 수 있다.
DB와 ORM 프레임워크, 내부 코드에 대한 충분한 이해가 없는 경우 문제 해결이 힘들다.
DB에 직접 Query문을 보내는 것이 아니기 때문에 성능 저하가 발생한다.

3) 자동으로 구성되는 관리자 화면

장고는 웹 서버의 콘텐츠, 즉 데이터베이스에 대한 관리 기능을 위하여 프로젝트를 시작하는 시점에 기본 기능으로 관리자 화면을 제공한다.

4) URL 설계의 유연성

장고에서는 우아한 URL 방식을 채택하여 URL을 직관적이고 쉽게 표현할 수 있다. 또한 정규 표현식을 사용하여 복잡한 URL도 표현할 수 있으며, 각 URL 형태를 파이썬 함수에 1:1로 연결할 수 있도록 되어있어 개발이 편리하며, 이해하기도 쉽다.

참고

[Python] leetcode Valid Palindrome

정찡이 — Tue, 8 Mar 2022 01:12:57 +0900

1. 문제 링크

https://leetcode.com/problems/valid-palindrome/submissions/

Valid Palindrome - LeetCode

Level up your coding skills and quickly land a job. This is the best place to expand your knowledge and get prepared for your next interview.

leetcode.com

2. 문제 요약

문자열이 팰린드롬(뒤집어도 같은 말) 인지 확인하자.
* 대소문자를 구분하지 않고, 영문자와 숫자만 대상으로 함

3. 아이디어 정리

4. 문제 풀이

4-1. 내 풀이

class Solution:
    def isPalindrome(self, s: str) -> bool:
        new = ''
        for c in s:
            if c.isalnum():
                new += c.lower()
        return new[:] == new[::-1]

5. 결론 및 느낀 점

문자열 다루기로 편하게 구현 가능
그 외 방법은 데크로 하나씩 pop 하면서 확인한다.

[Python] 백준 20055 컨베이어 벨트 위의 로봇

정찡이 — Mon, 7 Mar 2022 15:04:49 +0900

1. 문제 링크

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

20055번: 컨베이어 벨트 위의 로봇

길이가 N인 컨베이어 벨트가 있고, 길이가 2N인 벨트가 이 컨베이어 벨트를 위아래로 감싸며 돌고 있다. 벨트는 길이 1 간격으로 2N개의 칸으로 나뉘어져 있으며, 각 칸에는 아래 그림과 같이 1부

www.acmicpc.net

2. 문제 요약

1. 벨트가 각 칸 위에 있는 로봇과 함께 한 칸 회전한다.
2. 가장 먼저 벨트에 올라간 로봇부터, 벨트가 회전하는 방향으로 한 칸 이동할 수 있다면 이동한다.
   만약 이동할 수 없다면 가만히 있는다.
- 로봇이 이동하기 위해서는 이동하려는 칸에 로봇이 없으며, 그 칸의 내구도가 1 이상 남아 있어야 한다.
3. 올리는 위치에 있는 칸의 내구도가 0이 아니면 올리는 위치에 로봇을 올린다.
4. 내구도가 0인 칸의 개수가 K개 이상이라면 과정을 종료한다. 그렇지 않다면 1번으로 돌아간다.

* 로봇은 올리는 위치에만 올리기 가능 
* 언제든지 n(내리는 위치)에 있으면 바로 내림 
* 로봇은 컨베이어벨트 위에서는 스스로 이동 가능 
* 로봇을 올리는 위치에 올리거나 어떤 칸으로 이동 시 그 칸 내구도는 -1 

return: 몇번째 단계가 진행중일 때 종료되었는지 출력

3. 아이디어 정리

회전을 쉽게 하기 위해 deque를 사용한다.
n개의 벨트만 로봇이 존재할 수 있음 ⇒ n길이의 로봇 유무를 저장하는 배열을 만든다.

벨트를 회전한다. ⇒ deque rotate사용
로봇 이동하기
1. 가장 먼저 올라간 로봇부터 앞으로 이동
2. 다음칸이 내구도 존재하고, 로봇도 없고, 현재 로봇이 존재하는 경우 진행
올리는 위치에 내구도 0이 아니고, 로봇이 처음에 존재하지 않으면 로봇 올리기
내구도 0인 칸 수가 k이상이면 그만

4. 문제 풀이

4-1. 내 풀이

from collections import deque

n, k = map(int, input().split())
a = deque(map(int, input().split()))  # 내구도. A1, A2, ..., A2N
robot = deque([0] * n)  # 벨트위에 있는 로봇
result = 0

while True:
    result += 1
    # 1. 벨트 회전한다.
    a.rotate(1)
    robot[-1] = 0
    robot.rotate(1)
    robot[-1] = 0    # 내리는 위치에 도달한 경우, 즉시 내림
    # 2. 로봇 이동하기. 이동하려는 칸에 로봇 x, 내구도 1이상 남아야함.
    for i in range(n - 2, -1, -1):  # 먼저 올라간 로봇부터 진행
        if a[i + 1] >= 1 and robot[i + 1] == 0 and robot[i] == 1:
            robot[i + 1] = 1
            robot[i] = 0
            a[i + 1] -= 1
    robot[-1] = 0  # 내리는 위치에 도달한 경우, 즉시 내림
    # 3. 올리는 위치에 내구도 0 아니면 로봇 올리기 & 내구도 감소
    if a[0] != 0 and robot[0] != 1:
        robot[0] = 1
        a[0] -= 1
    # 4. 내구도 0인 칸 수가 k이상이면 종료
    if a.count(0) >= k:
        break
print(result)

5. 결론 및 느낀 점

이해하기가 어려웠던 문제

[Python] 백준 14889 스타트와 링크

정찡이 — Fri, 11 Feb 2022 15:20:21 +0900

1. 문제 링크

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

14889번: 스타트와 링크

예제 2의 경우에 (1, 3, 6), (2, 4, 5)로 팀을 나누면 되고, 예제 3의 경우에는 (1, 2, 4, 5), (3, 6, 7, 8)로 팀을 나누면 된다.

www.acmicpc.net

2. 문제 요약

첫째 줄에 스타트 팀과 링크 팀의 능력치의 차이의 최솟값을 출력

3. 아이디어 정리

조합을 이용하여 2개의 팀으로 나눈다.
각 팀의 능력치를 구한다.
각 팀의 능력치 합의 차를 구한 뒤 갱신한다.

4. 문제 풀이

4-1. 내 풀이

"""
    return : 스타트 팀과 링크 팀의 능력치 차이 최솟값
"""
import sys
from itertools import combinations

n = int(sys.stdin.readline())
graph = [list(map(int, sys.stdin.readline().split())) for _ in range(n)]
result = int(1e9)  # 최솟값

for comb in combinations(range(0, n), n // 2):
    a_team = list(comb)
    b_team = [i for i in range(0, n) if i not in a_team]

    a_score = 0
    b_score = 0

    for i in range(0, len(a_team) - 1):
        for j in range(i + 1, len(a_team)):
            a_score += graph[a_team[i]][a_team[j]] + graph[a_team[j]][a_team[i]]
            b_score += graph[b_team[i]][b_team[j]] + graph[b_team[j]][b_team[i]]

    result = min(result, abs(a_score - b_score))

print(result)

5. 결론

구현 문제

[Python] programmers 방금 그곡

정찡이 — Fri, 11 Feb 2022 15:17:22 +0900

1. 문제 링크

https://programmers.co.kr/learn/courses/30/lessons/17683

코딩테스트 연습 - [3차] 방금그곡

방금그곡 라디오를 자주 듣는 네오는 라디오에서 방금 나왔던 음악이 무슨 음악인지 궁금해질 때가 많다. 그럴 때 네오는 다음 포털의 '방금그곡' 서비스를 이용하곤 한다. 방금그곡에서는 TV,

programmers.co.kr

2. 문제 요약

방금 그 곡 서비스에서는 음악 제목, 재생이 시작되고 끝난 시각, 악보를 제공한다.
네오가 기억한 멜로디와 악보에 사용되는 음은 C, C#, D, D#, E, F, F#, G, G#, A, A#, B 12개이다.
각 음은 1분에 1개씩 재생된다. 음악은 반드시 처음부터 재생되며 음악 길이보다 재생된 시간이 길 때는 음악이 끊김 없이 처음부터 반복해서 재생된다. 음악 길이보다 재생된 시간이 짧을 때는 처음부터 재생 시간만큼만 재생된다.
음악이 00:00을 넘겨서까지 재생되는 일은 없다.
조건이 일치하는 음악이 여러 개일 때에는 라디오에서 재생된 시간이 제일 긴 음악 제목을 반환한다. 재생된 시간도 같을 경우 먼저 입력된 음악 제목을 반환한다.
조건이 일치하는 음악이 없을 때에는 “(None)”을 반환한다.

3. 아이디어 정리

곡 정보를 가공한다 - 음악이 흐른 시간만큼 곡을 만들어준다.
- #이 들어간 데이터인 경우 소문자로 대체 - 1글자로 만들어서 파악하기 쉽게 하기 위해
매칭 되는 것이 있는지 찾기 ⇒ python 문자열 찾기 사용
결과 찾기 - 재생된 시간이 제일 긴 음악 제목 > 먼저 입력된 음악 제목 ⇒ 정렬

4. 문제 풀이

4-1. 내 풀이

def solution(m, musicinfos):
    """
    :param m: 네오가 기억한 멜로디
    :param musicinfos: 곡의 정보가 담긴 배열 - 음악이 시작한 시각, 끝난 시각, 음악 제목, 악보 정보
    :return: 조건과 일치하는 음악 제목 출력
    """
    def get_minute(str_):
        h, m_ = str_.split(':')
        return int(h) * 60 + int(m_)

    def replace(data):
        return data.replace('C#', 'c').replace('D#', 'd').replace('F#', 'f').replace('G#', 'g').replace('A#', 'a')

    m = replace(m)
    answer = list()
    music = list()
    # 1. 곡 정보를 가공
    for mus in musicinfos:
        s, e, n, d = mus.split(',')  # 음악이 시작한 시각, 끝난 시각, 음악 제목, 악보 정보
        total = get_minute(e) - get_minute(s)   # 총 재생 시간
        d = replace(d)
        if total >= len(d):
            data = d * (total // len(d)) + d[:(total % len(d))]
        else:    # 작은 경우 자르기
            data = d[:total]
        music.append((n, data))  # 이름, 음악이 흘러간 데이터

    # 2. 매칭되는 것이 있는지 찾기
    for i, d in enumerate(music):
        name, mus = d
        if len(m) > len(mus):  # 찾는 곡이 더 긴 경우 그만
            continue
        if mus.find(m) != -1:
            answer.append((i, len(mus), name))

    # 3. 결과 찾기  - 재생된 시간이 제일 긴 음악 제목 > 먼저 입력된 음악 제목
    if answer:
        answer.sort(key=lambda x: (-x[1], x[0]))
        answer = answer[0][2]
    else:
        answer = '(None)'
    return answer

5. 결론

구현 문제

[Python] programmers 3차 압축

정찡이 — Fri, 11 Feb 2022 15:15:08 +0900

1. 문제 링크

https://programmers.co.kr/learn/courses/30/lessons/17684

코딩테스트 연습 - [3차] 압축

TOBEORNOTTOBEORTOBEORNOT [20, 15, 2, 5, 15, 18, 14, 15, 20, 27, 29, 31, 36, 30, 32, 34]

programmers.co.kr

2. 문제 요약

길이가 1인 모든 단어를 포함하도록 사전을 초기화한다.
사전에서 현재 입력과 일치하는 가장 긴 문자열 w를 찾는다.
w에 해당하는 사전의 색인 번호를 출력하고, 입력에서 w를 제거한다.
입력에서 처리되지 않은 다음 글자가 남아있다면(c), w+c에 해당하는 단어를 사전에 등록한다.
단계 2로 돌아간다.

3. 아이디어 정리

길이가 1인 모든 단어를 포함하도록 사전을 초기화한다. ⇒ A~Z까지 딕셔너리에 등록한다.
사전에서 현재 입력과 일치하는 가장 긴 문자열 w를 찾는다. ⇒ 투 포인터로 긴 문자열 찾는다.
w에 해당하는 사전의 색인 번호를 출력하고, 입력에서 w를 제거한다. ⇒ w에 해당하는 색인을 결과에 추가하고 msg를 업데이트한다.
입력에서 처리되지 않은 다음 글자가 남아있다면(c), w+c에 해당하는 단어를 사전에 등록한다. ⇒ 남은 글자가 있으면 사전 등록한다.
단계 2로 돌아간다.

4. 문제 풀이

4-1. 내풀이

from collections import defaultdict

def solution(msg):
    """
    :return: 주어진 문자열을 압축한 후의 사전 색인 번호를 배열
    """
    def get_long_str():
        """
            가장 긴 문자열 출력
        :return:
        """
        w = msg[0]
        right = 1
        while right < len(msg):
            if dict_[msg[0:right + 1]] != 0:  # 사전에 존재하면, w 변경&더 긴 문자열 있는지 찾기
                w = msg[0:right + 1]
                right += 1
            else:
                break
        return w

    answer = list()
    dict_ = defaultdict(int)
    index = 1
    # 1. 길이가 1인 사전 만들기 (1부터 시작)
    for i in range(ord('A'), ord('Z') + 1):
        dict_[chr(i)] = index
        index += 1
    while msg:
        # 2. 현재 입력과 일치하는 가장 긴 문자열 w 찾기
        w = get_long_str()
        # 3. w 색인 넣기 &  입력에서 w를 제거한다.
        answer.append(dict_[w])
        msg = msg[len(w):]
        # 4. 입력에서 처리되지 않은 다음 글자가 남아있다면(c), w+c에 해당하는 단어를 사전에 등록한다.
        if msg:  # 마지막 글자가 아니면 남은 글자 사전 추가
            dict_[w + msg[0]] = index
            index += 1
        else:
            break
    return answer

5. 결론

구현 문제

[Python] programmers 양궁대회

정찡이 — Sun, 23 Jan 2022 00:16:07 +0900

1. 문제 링크

https://programmers.co.kr/learn/courses/30/lessons/92342

코딩테스트 연습 - 양궁대회

문제 설명 카카오배 양궁대회가 열렸습니다. 라이언은 저번 카카오배 양궁대회 우승자이고 이번 대회에도 결승전까지 올라왔습니다. 결승전 상대는 어피치입니다. 카카오배 양궁대회 운영위원

programmers.co.kr

2. 문제 요약

k점을 많은 화살을 맞힌 선수가 k점을 가져간다.
라이언이 가장 큰 점수 차이로 우승하기 위해 n발의 화살을 어떤 과녁 점수에 맞혀야 하는지 10~0점까지 점수를 배열에 담기

3. 아이디어 정리

중복조합을 이용해 라이언 점수를 만든다.
라이언 점수와 어피치 점수를 비교해서 총점수를 구한다.
총점수를 비교해 라이언이 큰 점수를 얻는 경우 업데이트한다.

4. 문제 풀이

4-1. 내 풀이

from itertools import combinations_with_replacement

def solution(n, info):
    answer = [0 for _ in range(11)]
    win = False
    max_num = 0   # 라이언이 이길때 가장큰 점수 차이
    # 1. 중복 조합을 이용해 라이언의 점수를 만든다.
    for res in list(combinations_with_replacement(range(0, 11), n)):
        now = [0 for _ in range(11)]
        for r in res:
            now[10 - r] += 1
        lion = 0
        peach = 0
        # 2. 라이언 점수와 어피치 점수 비교한다.
        for i, (l, p) in enumerate(zip(now, info)):
            if l == p == 0:
                continue
            if p >= l:
                peach += (10 - i)
            elif l > p:
                lion += (10 - i)
        # 3. 총 점수를 비교해 라이언이 큰 경우 결과를 업데이트 해준다.
        if lion > peach:
            win = True
            if (lion - peach) > max_num:
                max_num = lion - peach
                answer = now
    if not win:
        return [-1]
    return answer

5. 결론

구현

[Python] programmers k진수에서 소수 개수 구하기

정찡이 — Sat, 22 Jan 2022 12:54:35 +0900

1. 문제 링크

https://programmers.co.kr/learn/courses/30/lessons/92335

코딩테스트 연습 - k진수에서 소수 개수 구하기

문제 설명 양의 정수 n이 주어집니다. 이 숫자를 k진수로 바꿨을 때, 변환된 수 안에 아래 조건에 맞는 소수(Prime number)가 몇 개인지 알아보려 합니다. 0P0처럼 소수 양쪽에 0이 있는 경우 P0처럼 소

programmers.co.kr

2. 문제 요약

진수 변환 후 0을 기준으로 나눠서 소수의 개수를 출력하기

3. 아이디어 정리

진수 변환
0을 기준으로 쪼갠다
각 쪼갠 수에 대해 소수 판별 진행

4. 문제 풀이

4-1. 내 풀이

import string
import math

tmp = string.digits+string.ascii_lowercase
def convert(num, base) :
    """
    진수 변환 후 0을 기준으로 나눠서 소수 판별 
    :param num:
    :param base:
    :return:
    """
    q, r = divmod(num, base)
    if q == 0 :
        return tmp[r]
    else :
        return convert(q, base) + tmp[r]

def is_prime_number(x):
    """
    소수 판별
    :param x:
    :return:
    """
    for i in range(2, int(math.sqrt(x)) + 1):
        if x % i == 0:
            return False
    return True

def solution(n, k):
    answer = 0
    convert_num = convert(n, k)
    for i in convert_num.split('0'):
        if i:   # 빈값이 아닌 경우
            if int(i) == 1:
                continue
            elif is_prime_number(int(i)):  # 소수인 경우 + 1
                answer += 1

    return answer

print(solution(n=110011,k=10))

5. 결론

구현

[Python] programmers 주차요금계산

정찡이 — Sat, 22 Jan 2022 12:38:11 +0900

1. 문제 링크

https://programmers.co.kr/learn/courses/30/lessons/92341

코딩테스트 연습 - 주차 요금 계산

[180, 5000, 10, 600] ["05:34 5961 IN", "06:00 0000 IN", "06:34 0000 OUT", "07:59 5961 OUT", "07:59 0148 IN", "18:59 0000 IN", "19:09 0148 OUT", "22:59 5961 IN", "23:00 5961 OUT"] [14600, 34400, 5000]

programmers.co.kr

2. 문제 요약

차량 번호가 작은 자동차부터 청구할 주차 요금을 차례대로 정수 배열에 담아서 return
출차된 내역이 없는 경우, 23:59에 출차된 것으로 간주
초과한 시간이 단위 시간으로 나누어 떨어지지 않으면, 올림

3. 아이디어 정리

records를 통해 총 주차 시간 구하기
출차를 안 한 경우 처리
차량별 요금 계산하기
차량 번호 정렬 후 주차 요금 리턴

4. 문제 풀이

4-1. 내풀이

from collections import defaultdict
import math

def solution(fees, records):
    """
    :param fees: 기본 시간(분) 기본 요금(원)	단위 시간(분)	단위 요금(원)
    :param records: 시각, 차량번호, 내역
    :return: 차량 번호가 작은 자동차부터 청구할 주차 요금을 차례대로 정수 배열에 담아
    """

    def get_minute(time):
        h, m = time.split(":")
        return int(h) * 60 + int(m)

    answer = list()
    parking = dict()
    total = defaultdict(int)

    # 1. records를 통해 총 주차 시간 구하기
    for r in records:
        t, n, f = r.split()  # 시각, 차량번호, 내역
        minute = get_minute(t)   # 분으로 변환
        if n in parking:  # 이미 입차한 경우, 출차로 총 시간 측정
            total[n] += minute - parking[n]
            del parking[n]
        else:   # 입차인 경우
            parking[n] = minute

    # 2. 출차를 안 한 경우 처리
    end_minute = get_minute('23:59')
    for k, v in parking.items():
        total[k] += (end_minute - v)

    # 3. 요금 계산하기
    s1, m1, s2, m2 = fees   # 기본 시간(분) 기본 요금(원) 단위 시간(분) 단위 요금(원)
    for k, v in total.items():
        all = m1  # 기본요금 내기
        if v > s1:
            all += math.ceil((v - s1) / s2) * m2
        answer.append((k, all))

    answer.sort()
    return [a[1] for a in answer]

5. 결론

구현

[Python] programmers 신고 결과 받기

정찡이 — Sat, 22 Jan 2022 12:00:52 +0900

1. 문제 링크

https://programmers.co.kr/learn/courses/30/lessons/92334

코딩테스트 연습 - 신고 결과 받기

문제 설명 신입사원 무지는 게시판 불량 이용자를 신고하고 처리 결과를 메일로 발송하는 시스템을 개발하려 합니다. 무지가 개발하려는 시스템은 다음과 같습니다. 각 유저는 한 번에 한 명의

programmers.co.kr

2. 문제 요약

정지 기준이 되는 신고 횟수 k가 매개변수로 주어질 때, 각 유저별로 처리 결과 메일을 받은 횟수를 배열에 담아 return

3. 아이디어 정리

누가 누구를 신고했는지 dict 담기 & 신고당한 횟수 세기
이용자별로 자신이 신고한 사람이 k번 이상이면 처리된 횟수 + 1

4. 문제 풀이

4-1. 내 풀이

from collections import defaultdict

def solution(id_list, report, k):
    answer = list()
    count = defaultdict(int)   # 몇번 신고했는지
    user = defaultdict(set)  # 신고 리스트
    # 1. 누가 누구를 신고했는지 dict 담기 & 신고당한 횟수 세기
    for r in report:
        a, b = r.split()  # a가 b를 신고
        if b not in user[a]:   # 같은 사람이 1번 이상 신고 x
            user[a].add(b)
            count[b] += 1  # 신고당한 수
    # 2. 이용자별로 자신이 신고한 사람이 k번 이상이면 처리된 횟수 + 1
    for id in id_list:
        result = 0
        for u in user[id]:
            if count[u] >= k:
                result += 1
        answer.append(result)
    return answer

5. 결론

구현 문제

[Python] 백준 14890 경사로

정찡이 — Sun, 16 Jan 2022 12:26:55 +0900

1. 문제 링크

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

14890번: 경사로

첫째 줄에 N (2 ≤ N ≤ 100)과 L (1 ≤ L ≤ N)이 주어진다. 둘째 줄부터 N개의 줄에 지도가 주어진다. 각 칸의 높이는 10보다 작거나 같은 자연수이다.

www.acmicpc.net

2. 문제 요약

총 2n개의 길이 존재할 때, 지나갈 수 있는 길의 개수를 출력한다.
낮은 칸과 높은 칸의 차이는 1이고, 낮은 칸에 경사로를 L길이만큼 설치해야 한다.

3. 아이디어 정리

한 줄 씩 확인해야하기 때문에 한줄 기준으로 지나갈 수 있는 길인지 확인하는 함수를 작성한다.
지나갈 수 있는지 확인하는 함수는 아래 로직을 따른다.
1. 이전 칸과 현재 칸이 1칸 높이 이상이면 False
2. 현재 높이 < 이전 높이, 경사로 설치를 위해 오른쪽 스캔 (낮은 곳에 경사로 설치)
3. 현재 높이 > 이전 높이, 경사로 설치를 위해 왼쪽 스캔 (낮은 곳에 경사로 설치)

4. 문제 풀이

4-1. 내 풀이

import sys

def pos(now):
    """
    1. 차이가 1만 경사로 설치 가능
    2. 현재 높이 < 이전 높이, 경사로 설치를 위해 오른쪽 스캔 (낮은 곳에 경사로 설치)
    3. 현재 높이 > 이전 높이, 경사로 설치를 위해 왼쪽 스캔 (낮은 곳에 경사로 설치)
    :param i:
    :return:
    """
    for j in range(1, n):
        if abs(now[j] - now[j - 1]) > 1:   # 1. 차이가 1만 가능
            return False
        if now[j] < now[j - 1]:            # 2.  현재 < 이전, 경사로를 만들기 위해 오른쪽을 스캔함(낮은 곳에 경사로 설치)
            for k in range(l):  # l 만큼 경사로 너비 필요 
                if j + k >= n or used[j + k] or now[j] != now[j + k]: # 범위 넘어감 or 이미 설치함 or 낮은 곳의 높이가 다른 경우, 그만  
                    return False
                if now[j] == now[j + k]:   # 높이가 같은 경우 사용 여부 체크 
                    used[j + k] = True
        elif now[j] > now[j - 1]:         # 3.  현재 > 이전, 경사로를 만들기 위해 왼쪽을 스캔함
            for k in range(l):
                if j - k - 1 < 0 or now[j - 1] != now[j - k - 1] or used[j - k - 1]:  # 범위 넘어감 or 이미 설치함 or 낮은 곳의 높이가 다른 경우, 그만
                    return False
                if now[j - 1] == now[j - k - 1]:   # 높이가 같은 경우 사용 여부 체크 
                     used[j - k - 1] = True
    return True   # 모두 문제없이 설치된 경우 가능함을 출력 

n, l = map(int, sys.stdin.readline().split())
graph = [list(map(int, sys.stdin.readline().split())) for _ in range(n)]
result = 0

# 1. 가로 확인
for i in range(n):
    used = [False for _ in range(n)]  # 사용 여부
    if pos(graph[i]):  # 현재 확인할 길을 넣어준다.
        result += 1

# 2. 세로 확인
for i in range(n):
    used = [False for _ in range(n)]
    if pos([graph[j][i] for j in range(n)]):  # 현재 확인할 길을 넣어준다.
        result += 1

print(result)

5. 결론

구현 문제

[Python] 백준 23290 마법사 상어와 복제

정찡이 — Sat, 8 Jan 2022 22:40:05 +0900

1. 문제 링크

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

23290번: 마법사 상어와 복제

첫째 줄에 물고기의 수 M, 상어가 마법을 연습한 횟수 S가 주어진다. 둘째 줄부터 M개의 줄에는 물고기의 정보 fx, fy, d가 주어진다. (fx, fy)는 물고기의 위치를 의미하고, d는 방향을 의미한다. 방향

www.acmicpc.net

2. 문제 요약

1. 모든 물고기 복제

2. 물고기 이동

상어가 있는 칸, 물고기 냄새 칸, 벗어나는 칸 x
45도 반시계 회전 후 이동. 이동 못하는 경우 그대로

3. 상어 이동

제외되는 물고기 수가 많고 > 이동 방법 사전 순 이동하게 됨
상어가 이동한 곳은 물고기가 있으면 물고기 냄새가 생김

4. 2번 전 물고기 냄새 사라짐

5. 복제 마법

3. 아이디어 정리

1. 모든 물고기 복제 ⇒ 물고기 위치 복제 (copy)

2. 물고기 이동 ⇒ 구현 move_fish()

상어가 있는 칸, 물고기 냄새 칸, 벗어나는 칸 x
45도 반시계 회전 후 이동. 이동 못하는 경우 그대로

3. 상어 이동 ⇒ 백트래킹 dfs

제외되는 물고기 수가 많고 > 이동 방법 사전 순 이동하게 됨
상어가 이동한 곳은 물고기가 있으면 물고기 냄새가 생김

4. 2번 전 물고기 냄새 사라짐 ⇒ 냄새 -1

5. 복제 마법 ⇒ 기존 물고기 + 복제된 물고기 추가

4. 문제 풀이

4-1. 내 풀이

import copy

def move_fish():
    """
    물고기 이동
    1. 상어가 있는 칸, 물고기 냄새 칸, 벗어나는 칸 x 
    2. 45도 반시계 회전 후 이동. 이동 못하는 경우 그대로 
    :return:
    """
    res = [[[] for _ in range(4)] for _ in range(4)]
    for x in range(4):
        for y in range(4):
            while temp[x][y]:
                d = temp[x][y].pop()
                for i in range(d, d - 8, -1):
                    i %= 8
                    nx, ny = x + f_dx[i], y + f_dy[i]
                    if (nx, ny) != shark and 0 <= nx < 4 and 0 <= ny < 4 and not smell[nx][ny]:
                        res[nx][ny].append(i)
                        break
                else:
                    res[x][y].append(d)
    return res

def dfs(x, y, dep, cnt, visit):
    """
    상어 3칸 이동
    1. 제외되는 물고기 수가 많고 > 이동방법 사전순(백트래킹하면 자동으로 됨) 
    2. 이동한 곳을 저장 > 물고기 냄새가 됨  
    """
    global max_eat, shark, eat
    if dep == 3:   # 3번 이동한 경우 그만 
        if max_eat < cnt:
            max_eat = cnt
            shark = (x, y)
            eat = visit[:]
        return
    for d in range(4):
        nx = x + dx[d]
        ny = y + dy[d]
        if 0 <= nx < 4 and 0 <= ny < 4:
            if (nx, ny) not in visit:  # 처음 방문, cnt에 죽은 물고기 수 추가  
                visit.append((nx, ny))
                dfs(nx, ny, dep + 1, cnt + len(temp[nx][ny]), visit)
                visit.pop()
            else:  # 방문한 경우
                dfs(nx, ny, dep + 1, cnt, visit)

#       ←, ↖,   ↑,  ↗, →, ↘, ↓, ↙
f_dx = [0, -1, -1, -1, 0, 1, 1, 1]
f_dy = [-1, -1, 0, 1, 1, 1, 0, -1]
dx = [-1, 0, 1, 0]
dy = [0, -1, 0, 1]

m, s = map(int, input().split())
fish = [list(map(int, input().split())) for _ in range(m)]
graph = [[[] for _ in range(4)] for _ in range(4)]

for x, y, d in fish:
    graph[x - 1][y - 1].append(d - 1)

shark = tuple(map(lambda x: int(x) - 1, input().split()))
smell = [[0] * 4 for _ in range(4)]

for _ in range(s):
    eat = list()
    max_eat = -1
    # 1. 모든 물고기 복제
    temp = copy.deepcopy(graph)
    # 2. 물고기 이동
    temp = move_fish()
    # 3. 상어이동 - 백트래킹
    dfs(shark[0], shark[1],0, 0, list())
    for x, y in eat:
        if temp[x][y]:
            temp[x][y] = []
            smell[x][y] = 3   # 3번 돌아야 없어짐
    # 4. 냄새 사라짐 
    for i in range(4):
        for j in range(4):
            if smell[i][j]:
                smell[i][j] -= 1
    # 5. 복제 마법
    for i in range(4):
        for j in range(4):
            graph[i][j] += temp[i][j]

# 물고기 수 구하기 
answer = 0
for i in range(4):
    for j in range(4):
        answer += len(graph[i][j])

print(answer)

5. 결론

구현
백트래킹

참고 사이트

[Python] 백준 11404 플로이드

정찡이 — Sat, 8 Jan 2022 22:38:44 +0900

1. 문제 링크

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

11404번: 플로이드

첫째 줄에 도시의 개수 n이 주어지고 둘째 줄에는 버스의 개수 m이 주어진다. 그리고 셋째 줄부터 m+2줄까지 다음과 같은 버스의 정보가 주어진다. 먼저 처음에는 그 버스의 출발 도시의 번호가

www.acmicpc.net

2. 문제 요약

a → b로 가는 비용의 최솟값 모두 구하기

3. 아이디어 정리

플로이드 와샬. 모든 정점 최단 거리 구하기

참고 - 플로이드 와샬

모든 노드에서 다른 모든 노드까지의 최단 경로를 모두 계산한다. - 특정 노드를 거쳐 가는 경우 사용

플로이드 워셜 점화식

각 단계마다 특정한 노드 k를 거쳐 가는 경우를 확인한다.

a에서 b로 가는 최단 거리, a에서 k를 거쳐 b로 가는 거리 비교

4. 문제 풀이

4-1. 내 풀이

"""
 모든 a> b로 최소 비용
"""

import sys
INF = int(1e9)

n = int(sys.stdin.readline())  # 도시의 수
m = int(sys.stdin.readline())  # 버스의 수

graph = [[INF] * (n + 1) for _ in range(n + 1)]    # 모든 최단 거리를 저장
for i in range(1, n + 1):
    for j in range(1, n + 1):
        if i == j:
            graph[i][j] = 0

for _ in range(m):
    a, b, c = map(int, sys.stdin.readline().split())
    graph[a][b] = min(c, graph[a][b])   # 노선이 하나가 아닐 수 있음 > 최소값 넣기 

# 2. 다이나믹 프로그래밍
for k in range(1, n + 1):
    for a in range(1, n + 1):
        for b in range(1, n + 1):
            graph[a][b] = min(graph[a][b], graph[a][k] + graph[k][b])

for a in range(1, n + 1):
    for b in range(1, n + 1):
        if graph[a][b] == INF:
            print("0",  end=" ")
        else:
            print(graph[a][b], end=" ")
    print()

5. 결론

플로이드 와샬

[Python] 백준 17135 캐슬 디펜스

정찡이 — Sat, 1 Jan 2022 16:46:27 +0900

1. 문제 링크

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

17135번: 캐슬 디펜스

첫째 줄에 격자판 행의 수 N, 열의 수 M, 궁수의 공격 거리 제한 D가 주어진다. 둘째 줄부터 N개의 줄에는 격자판의 상태가 주어진다. 0은 빈 칸, 1은 적이 있는 칸이다.

www.acmicpc.net

2. 문제 요약

3명 궁수 배치
적 공격: 거리가 D 이하인 적 중에서 가장 가까운 적이고, 그러한 적이 여럿일 경우에는 가장 왼쪽에 있는 적을 공격한다.
적 아래로 한칸 이동
모든 적이 없으면 끝!

출력: 궁수의 공격으로 제거할 수 있는 적의 최대 수

3. 아이디어 정리

구현 문제

3명 궁수 배치 ⇒ 삼성 문제라서 combinations 함수를 직접 구현하였다.⇒ 삼성 코테는 지원 안 함
적이 있는 동안 아래 로직 반복
1. 적 공격: 거리가 D 이하인 적 중에서 가장 가까운 적이고, 그러한 적이 여럿일 경우에는 가장 왼쪽에 있는 적을 공격한다.
2. 적 아래로 한 칸 이동

4. 문제 풀이

4-1. 내 풀이

import sys
import copy

def combinations(array, r):
    for i in range(len(array)):
        if r == 1:  # 종료 조건
            yield [array[i]]
        else:
            for next in combinations(array[i + 1:], r - 1):
                yield [array[i]] + next

def attack(list_):
    """
    공격하기
    거리가 D이하인 적 중에서 가장 가까운 적이고, 그러한 적이 여럿일 경우에는 가장 왼쪽에 있는 적을 공격한다.
    - 0은 빈 칸, 1은 적
    - 거리: |r1-r2| + |c1-c2|
    :return:
    """
    # 궁수별 가까운 적 공격하기
    attack_list = list()
    cnt = 0
    for l in list_:
        pos = list()
        for i in range(n):
            for j in range(m):
                if temp[i][j] == 1:
                    now_d = abs(i - n) + abs(j - l)
                    if d >= now_d:
                        pos.append((now_d, i, j))
        pos.sort(key=(lambda x: (x[0], x[2])))  # 거리가깝고 > 왼쪽 기준 정렬
        if pos:
            attack_list.append(pos[0])   # 제거해야할 적

    for a in attack_list:
        _, i, j = a
        if temp[i][j] == 1:
            temp[i][j] = 0
            cnt += 1
    return cnt

def move():
    """
    적 아래로 이동
    :return:
    """

    for i in range(-1, -n, -1):
        temp[i] = temp[i - 1]

    temp[0] = [0 for _ in range(m)]

def is_empty():
    """
    적 존재 유무
    :return:
    """
    for i in range(n):
        for j in range(m):
            if temp[i][j] == 1:
                return False
    return True

n, m, d = map(int, sys.stdin.readline().split())  # 행, 열, 궁수의 공격 거리 제한
graph = [list(map(int, sys.stdin.readline().split())) for _ in range(n)]
items = [i for i in range(m)]
result = 0

for a in combinations(items, 3):  # 1. 궁수 배치 - 모든 경우의 수 배치 3명
    temp = copy.deepcopy(graph)
    count = 0
    while not is_empty():  # 적이 있는 동안 계속 반복
        # 2. 적 공격하기 - 가장 가까운 적 중 왼쪽에 있는
        count += attack(a)
        # 3. 적 아래로 이동
        move()
    result = max(result, count)

print(result)

5. 결론

구현 문제

[Python] 백준 2252 줄세우기

정찡이 — Wed, 15 Dec 2021 18:04:41 +0900

1. 문제 링크

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

2252번: 줄 세우기

첫째 줄에 N(1 ≤ N ≤ 32,000), M(1 ≤ M ≤ 100,000)이 주어진다. M은 키를 비교한 회수이다. 다음 M개의 줄에는 키를 비교한 두 학생의 번호 A, B가 주어진다. 이는 학생 A가 학생 B의 앞에 서야 한다는 의

www.acmicpc.net

2. 문제 요약

학생들을 키 순서대로 줄을 세운 결과를 출력한다.

3. 아이디어 정리

위상 정렬

진입 차수가 0인 모든 노드에 큐 넣기
큐가 빌 때까지 반복
- 큐에서 한 개 빼고 결과에 넣기
- 큐에서 원소를 꺼내 나가는 간선 제거
- 새롭게 진입차수가 0이 된 노드에 큐 넣기

4. 문제 풀이

4-1. 내풀이

import sys
from collections import deque

def topology_sort():
    result = []
    q = deque()
    # 1. 진입차수가 0인 모든 노드를 큐에 넣는다.
    for i in range(n):
        if indegree[i] == 0:  # 처음은 진입차수가 0인 것부터. 진입차수 0이 시작하는 노드이기 때문
            q.append(i)
    # 2. 큐가 빌 때까지 아래 과정 반복한다.
    while q:
        # 2-1. 큐에서 원소를 꺼내 해당 노드에서 나가는 간선을 그래프에서 제거한다.
        now = q.popleft()
        result.append(now + 1)
        for i in graph[now]:   
            indegree[i] -= 1
            if indegree[i] == 0: # 2-2. 새롭게 진입차수가 0이된 노드를 큐에 넣는다.
                q.append(i)

    print(*result)

n, m = map(int, sys.stdin.readline().split())  # 학생 수, 키를 비교한 수
indegree = [0] * n
result = [1] * n
graph = [[] for i in range(n)]

for _ in range(m):
    a, b = map(int, sys.stdin.readline().split())
    graph[a - 1].append(b - 1)  # a > b
    indegree[b - 1] += 1    # 진입 차수

topology_sort()

5. 결론

위상 정렬 문제

[Python] 백준 2623 음악프로그램

정찡이 — Wed, 15 Dec 2021 17:58:51 +0900

1. 문제 링크

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

2623번: 음악프로그램

첫째 줄에는 가수의 수 N과 보조 PD의 수 M이 주어진다. 가수는 번호 1, 2,…,N 으로 표시한다. 둘째 줄부터 각 보조 PD가 정한 순서들이 한 줄에 하나씩 나온다. 각 줄의 맨 앞에는 보조 PD가 담당한

www.acmicpc.net

2. 문제 요약

PD들이 만든 가수 순서 주어질 때, 전체 가수 순서를 정하여 순서를 출력한다.

3. 아이디어 정리

위상 정렬

진입차수가 0인 모든 노드에 큐 넣기
큐가 빌 때까지 반복
1. 큐에서 한 개 빼고 결과에 넣기
2. 큐에서 원소를 꺼내 나가는 간선 제거
3. 새롭게 진입차수가 0이 된 노드에 큐 넣기

4. 문제 풀이

4-1. 내풀이

import sys
from collections import deque

def topology_sort():
    result = []
    q = deque()
    # 1. 진입차수가 0인 모든 노드를 큐에 넣는다.
    for i in range(n):
        if indegree[i] == 0:  # 처음은 진입차수가 0인 것부터. 진입차수 0이 시작하는 노드이기 때문
            q.append(i)
    # 2. 큐가 빌 때까지 아래 과정 반복한다.
    while q:
        # 2-1. 큐에서 원소를 꺼내 해당 노드에서 나가는 간선을 그래프에서 제거한다.
        now = q.popleft()
        result.append(now + 1)   # 결과 넣기 
        for i in graph[now]:
            indegree[i] -= 1
            if indegree[i] == 0:   # 2-2. 새롭게 진입차수가 0이된 노드를 큐에 넣는다.
                q.append(i)

    if sum(indegree) > 0:  # 순서 정하는 게 불가능한 경우
        print(0)
    else:
        [print(i) for i in result]

n, m = map(int, sys.stdin.readline().split())  # 가수의 수, 보조 pd 수
indegree = [0] * n
result = [1] * n
graph = [[] for i in range(n)]

for _ in range(m):
    list_ = list(map(int, sys.stdin.readline().split()))
    for a, b in zip(list_[1:], list_[2:]):
        graph[a - 1].append(b - 1)  # a > b
        indegree[b - 1] += 1    # 진입 차수

topology_sort()

5. 결론

위상 정렬 문제

[Python] 백준 14567 선수과목

정찡이 — Wed, 15 Dec 2021 17:31:20 +0900

1. 문제 링크

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

14567번: 선수과목 (Prerequisite)

3개의 과목이 있고, 2번 과목을 이수하기 위해서는 1번 과목을 이수해야 하고, 3번 과목을 이수하기 위해서는 2번 과목을 이수해야 한다.

www.acmicpc.net

2. 문제 요약

1번 과목부터 N번 과목까지 차례대로 최소 몇 학기에 이수할 수 있는지 출력한다.

3. 아이디어 정리

위상 정렬

진입 차수가 0인 모든 노드에 큐 넣기
큐가 빌 때까지 반복
- 큐에서 원소를 꺼내 나가는 간선 제거
- 새롭게 진입차수가 0이 된 노드에 큐 넣기 & 결과 넣기(최소 이수 학기, 현재 노드 결과 + 1)

4. 문제 풀이

4-1. 내풀이

import sys
from collections import deque

def topology_sort():
    q = deque()
    # 1. 진입차수가 0인 모든 노드를 큐에 넣는다.
    for i in range(n):
        if indegree[i] == 0:  # 처음은 진입차수가 0인 것부터. 진입차수 0이 시작하는 노드이기 때문
            q.append(i)
    # 2. 큐가 빌 때까지 아래 과정 반복한다.
    while q:
        # 2-1. 큐에서 원소를 꺼내 해당 노드에서 나가는 간선을 그래프에서 제거한다.
        now = q.popleft()
        for i in graph[now]: 
            indegree[i] -= 1
            if indegree[i] == 0:  # 2-2. 새롭게 진입차수가 0이된 노드를 큐에 넣기 & 결과 넣기 
                result[i] = result[now] + 1  # [추가된 부분] 현재 노드 결과에 + 1한(다음 학기) 학기로 넣기 
                q.append(i)

    print(*result)

n, m = map(int, sys.stdin.readline().split())  # 과목수, 선수 조건 수
indegree = [0] * n
result = [1] * n
graph = [[] for i in range(n)]

for _ in range(m):
    a, b = map(int, sys.stdin.readline().split())
    graph[a - 1].append(b - 1)  # a > b
    indegree[b - 1] += 1    # 진입 차수

topology_sort()

5. 결론

위상 정렬 문제

[Python] 백준 14888 연산자 끼워넣기

정찡이 — Wed, 15 Dec 2021 17:18:14 +0900

1. 문제 링크

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

14888번: 연산자 끼워넣기

첫째 줄에 수의 개수 N(2 ≤ N ≤ 11)가 주어진다. 둘째 줄에는 A1, A2, ..., AN이 주어진다. (1 ≤ Ai ≤ 100) 셋째 줄에는 합이 N-1인 4개의 정수가 주어지는데, 차례대로 덧셈(+)의 개수, 뺄셈(-)의 개수,

www.acmicpc.net

2. 문제 요약

N개의 수와 N-1개의 연산자가 주어졌을 때, 만들 수 있는 식의 결과가 최대인 것과 최소인 것 구하기

3. 아이디어 정리

백트래킹으로 진행

Base condition(종료 조건): 모든 연산자를 넣은 경우
재귀: 사칙연산을 4개를 돌려 계산을 하고 백트래킹 진행

4. 문제 풀이

4-1. 내 풀이

"""
 1. 결과의 최댓값
 2. 최솟값
"""
def dfs(cnt, res):
    global min_
    global max_
    if cnt == n - 1:     # 1. Base condition(종료 조건), 모든 연산자를 넣은 경우
        min_ = min(min_, res)
        max_ = max(max_, res)
        return

    for i in range(4):  # 2. 백트래킹 - 사칙 연산 계산하기 
        temp = res
        if num[i] == 0:  # 해당 사칙 연산이 없는 경우 넘어가기 
            continue
        if i == 0:       # 더하기  
            res += a[cnt + 1]
        elif i == 1:     # 빼기 
            res -= a[cnt + 1]
        elif i == 2:     # 곱하기 
            res *= a[cnt + 1]
        else:            # 나누기 
            if res < 0:
                res = -(abs(res) // a[cnt + 1])
            else:
                res //= a[cnt + 1]
        num[i] -= 1
        dfs(cnt + 1, res)
        num[i] += 1
        res = temp

n = int(input())
a = list(map(int, input().split()))
num = list(map(int, input().split()))   # 연산자 수, 덧셈, 뺄셈, 곱셈, 나눗셈 수
min_ = int(1e9)
max_ = -int(1e9)

dfs(0, a[0])
print(max_)
print(min_)

5. 결론

백트래킹 문제

위상정렬(Topological Sorting)

정찡이 — Tue, 14 Dec 2021 23:46:50 +0900

이번 시간에는 위상 정렬에 대한 개념과 동작 과정을 알아본다. 이후 위상 정렬을 Python으로 구현해 본다.

1. 위상 정렬(Topological Sorting)

정렬 알고리즘의 일종으로, 순서가 정해진 일련의 작업을 차례대로 수행해야 할 때 사용하는 알고리즘이다.
⇒ 사이클이 없는 방향 그래프의 모든 노드를 방향성에 거스르지 않도록 순서대로 나열하는 것을 의미한다.

1-1. 예시 - 선수과목을 고려한 학습 순서 설정

그림과 같이 총 3개의 과목이 있다고 가정하자.

세 과목을 모두 듣기 위해서는 자료구조 -> 알고리즘 -> 고급 알고리즘 (O) 순서로 과목을 들어야 한다.

만약 알고리즘 -> 자료구조 -> 고급 알고리즘 (X) 순서로 과목을 듣는다고 가정하자. 해당 순서는 올바른 학습 순서가 아니다.

1-2. 진입 차수(Indegree)란?

위상 정렬을 학습하기 전에 먼저 진입 차수를 알아야 한다.

특정한 노드로 들어오는 간선의 개수를 의미한다.

위 예시에서는

자료구조: 0 개
알고리즘: 1 개
고급 알고리즘: 2 개

2. 위상 정렬 알고리즘 동작 과정

여기서는 큐를 이용한다.

진입 차수가 0인 모든 노드를 큐에 넣는다.
큐가 빌 때까지 아래 과정 반복한다.
1. 큐에서 원소를 꺼내 해당 노드에서 나가는 간선을 그래프에서 제거한다.
2. 새롭게 진입 차수가 0이 된 노드를 큐에 넣는다.

⇒ 결과적으로 각 노드가 큐에 들어온 순서가 위상 정렬을 수행한 결과와 같다

2-1. 위상 정렬 동작 예시

아래 그림을 통해 동작 과정을 이해해보자.

[step 0] 진입 차수가 0인 모든 노드를 큐에 삽입. 현재 1번 노드의 진입 차수만 0이므로 큐에 1번 노드만 삽입하게 된다.

우선 진입 차수를 노드별 세팅을 모두 한다. 그 이후 0인 진입 차수를 찾아서 큐에 넣어준다.

[step 1] 큐에 있는 1번 노드를 꺼낸다. 이후 1번 노드와 연결되어 있는 간선들을 제거한다. 그러면 2번 노드와 5번 노드의 진입 차수가 0이 되고, 2번 노드와 5번 노드의 진입 차수가 0이므로 큐에 삽입한다.

[step 2] 큐에 있는 2번 노드를 꺼낸다. 2번 노드와 연결되어 있는 간선들을 제거한다. 그러면 3번 노드의 진입 차수가 0이 되므로 3번 노드를 큐에 삽입한다.

[step 3] 큐에 있는 5번 노드를 꺼낸다. 5번 노드와 연결되어 있는 간선들을 제거한다. 그러면 6번 노드의 진입 차수가 0이 되므로 6번 노드를 큐에 삽입한다.

[step 4] 큐에 있는 3번 노드를 꺼낸다. 3번 노드와 연결되어 있는 간선들을 제거한다. 이번 단계에서는 새롭게 진입 차수가 0이 되는 노드가 없으므로 넘어간다.

[step 5] 큐에 있는 6번 노드를 꺼낸다. 6번 노드와 연결되어 있는 간선들을 제거한다. 그러면 4번 노드의 진입차수가 0이 되므로 4번 노드를 큐에 삽입한다.

[step 6] 큐에 있는 4번 노드를 꺼낸다. 4번 노드와 연결되어 있는 간선들을 제거한다. 그러면 7번 노드의 진입차수가 0이 되므로 7번 노드를 큐에 삽입한다.

3. 위상 정렬의 특징

위상 정렬은 사이클이 없는 방향 그래프 (DAG)에 대해서만 수행할 수 있다.※ DAG (Direct Acyclic Graph) : 순환하지 않는(=사이클이 없는) 방향 그래프
위상 정렬에서는 여러 가지 답이 존재할 수 있다. 한 단계에서 큐에 새롭게 들어가는 원소가 2개 이상인 경우가 있다면 여러 가지 답이 존재할 수 있다는 의미이다.
모든 원소를 방문하기 전에 큐가 비게 된다면 사이클이 존재한다고 판단할 수 있다. 왜냐하면 사이클에 포함된 원소 중에서 해당되는 어떠한 원소도 큐에 들어가지 못하게 되기 때문이다.
- 위상 정렬 문제에서는 사이클이 없음을 가정한다.

4. 구현하기 (Python)

위상 정렬 문제는 아래 코드를 베이스로 일부만 변경하여 문제 풀 수 있다.

진입차수가 0인 모든 노드를 큐에 넣는다.
큐가 빌 때까지 아래 과정 반복한다.
1. 큐에서 원소를 꺼내 해당 노드에서 나가는 간선을 그래프에서 제거한다.
2. 새롭게 진입차수가 0이 된 노드를 큐에 넣는다.

"""
[입력]
7 8
1 2
1 5
2 3
2 6
3 4
4 7
5 6
6 4
[출력]
1 2 5 3 6 4 7
"""
from collections import deque
import sys

def topology_sort():
    result = []
    q = deque()
    # 1. 진입차수가 0인 모든 노드를 큐에 넣는다.
    for i in range(1, v + 1):
        if indegree[i] == 0:
            q.append(i)
        # 2. 큐가 빌 때까지 아래 과정 반복한다.
    while q:
        # 2-1. 큐에서 원소를 꺼내 해당 노드에서 나가는 간선을 그래프에서 제거한다.
        now = q.popleft()
        result.append(now)
        for i in graph[now]:
            indegree[i] -= 1
            # 2-2. 새롭게 진입차수가 0이된 노드를 큐에 넣는다.
            if indegree[i] == 0:
                q.append(i)
    # 3. 위상 순서 출력
    for i in result:
        print(i, end=' ')

v, e = map(int, sys.stdin.readline().split())  # 노드 수, 간선 수

indegree = [0] * (v + 1)  # 진입차수
graph = [[] for i in range(v + 1)]  # 선후 관계

# 1. 초기세팅 - 선후 관계, 진입 차수 세팅
for _ in range(e):
    a, b = map(int, sys.stdin.readline().split())
    graph[a].append(b)  # a > b
    indegree[b] += 1  # 진입 차수

# 2. 위상정렬 진행
topology_sort()

5. 위상 정렬 시간 복잡도

시간 복잡도는 O(V+E) 위상 정렬을 수행할 때,

1. 차례대로 모든 노드를 확인하면서 O(V)

2. 해당 노드에서 출발하는 간선을 차례대로 제거 O(E) 해야 한다.

=> 따라서 노드와 간선을 모두 확인하는 것을 고려하여 O(V) + O(E) = O(V+E)의 시간이 소요된다.

6. 위상 정렬(Topological Sort)과 관련된 문제 유형

1, 2번 유형은 필수 유형 문제이니 꼭 풀어보기! ✍️

큐를 이용한 위상 정렬
- 선수과목 - 백준 14567
- 줄 세우기 - 백준 2252
우선순위 큐를 이용한 위상 정렬
- 문제집 - 백준 1766
여러 위상 순서 중 가장 짧게 걸리는 위상 정렬 방법 구하기
- 작업 - 백준 2056
- 게임 개발 - 백준 1516

참고

'이것이 취업을 위한 코딩 테스트다 with 파이썬' 책

[Python] programmers 여행 경로

정찡이 — Sun, 12 Dec 2021 12:49:03 +0900

1. 문제 링크

https://programmers.co.kr/learn/courses/30/lessons/43164

코딩테스트 연습 - 여행경로

[["ICN", "SFO"], ["ICN", "ATL"], ["SFO", "ATL"], ["ATL", "ICN"], ["ATL","SFO"]] ["ICN", "ATL", "ICN", "SFO", "ATL", "SFO"]

programmers.co.kr

2. 문제 요약

방문하는 공항 경로를 배열에 담아 return

3. 아이디어 정리

백트래킹으로 진행합니다.

처음 ICN를 배열에 담아 넘겨줍니다.
티켓들 중 마지막으로 탐색한 값과 시작값이 같은 티켓 & 방문 안한 경우 재귀를 진행합니다.

4. 문제 풀이

4-1. 내 풀이

"""
 항상 ICN 공항에서 출발
 [a, b]는 a 공항에서 b 공항으로 가는 항공권이 있다는 의미입니다.
"""
import copy
first = True
def solution(tickets):
    def dfs(arr):
        global first
        global answer
        if len(tickets) + 1 == len(arr):  # 1. Base condition(종료 조건)
            if first:
                answer = copy.deepcopy(arr)
                first = False
            return
				# 2. 백트래킹. 다음으로 갈수 있는 모든 티켓 사용 
        for i, a in enumerate(tickets):
            s, e = a
            if arr[-1] == s and not visit[i]:  # 마지막 방문 도시 == 현재 시작 도시 & 방문 안한 경우 
                arr.append(e)
                visit[i] = True
                dfs(arr)
                arr.pop()
                visit[i] = False
    visit = [False] * len(tickets)
    tickets.sort()
    dfs(["ICN"])
    return answer

5. 결론

백트래킹

[Python] 백준 2580 스도쿠

정찡이 — Sun, 12 Dec 2021 12:47:23 +0900

1. 문제 링크

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

2580번: 스도쿠

스도쿠는 18세기 스위스 수학자가 만든 '라틴 사각형'이랑 퍼즐에서 유래한 것으로 현재 많은 인기를 누리고 있다. 이 게임은 아래 그림과 같이 가로, 세로 각각 9개씩 총 81개의 작은 칸으로 이루

www.acmicpc.net

2. 문제 요약

각각의 가로줄과 세로줄에는 1부터 9까지의 숫자가 한 번씩만 나타나야 한다.
굵은 선으로 구분되어 있는 3x3 정사각형 안에도 1부터 9까지의 숫자가 한 번씩만 나타나야 한다.

3. 아이디어 정리

백트래킹으로 진행

0으로 된 부분 모두 수를 채운 경우 그만
0으로 된 좌표에 어떤 값이 가능한지 모두 백트래킹 진행

4. 문제 풀이

4-1. 내 풀이

import sys

def pos(x, y):
    """
    해당 좌표가 가능한 수 얻기
    """
    p = set(range(1, 10))
    # 1. 가로줄, 세로줄에 있는 수 제거
    for i in range(9):
        if graph[x][i] in p:
            p.remove(graph[x][i])
        if graph[i][y] in p:
            p.remove(graph[i][y])
    # 2. 굵은 선으로 구분되어 있는 3x3 수 제거
    x = x // 3   # 몇 번째 큰 칸에 있는지
    y = y // 3
    for i in range(x * 3, (x + 1) * 3):
        for j in range(y * 3, (y + 1) * 3):
            if graph[i][j] in p:
                p.remove(graph[i][j])
    return p

def dfs(cnt):
    if cnt == len(zero):     # 1. Base condition(종료 조건)
        [print(*a) for a in graph]
        sys.exit()
    x, y = zero[cnt]         # 0인 좌표 얻기
    for i in pos(x, y):      # 2. 해당 좌표가 들어갈 수 있는 값 얻어 백트래킹
        graph[x][y] = i
        dfs(cnt + 1)
        graph[x][y] = 0

graph = [list(map(int, sys.stdin.readline().split())) for _ in range(9)]
zero = [(i, j) for i in range(9) for j in range(9) if graph[i][j] == 0]

dfs(0)

5. 결론

백트래킹 문제

[Python] 백준 15656 N과 M (7)

정찡이 — Sun, 12 Dec 2021 12:43:52 +0900

1. 문제 링크

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

15656번: N과 M (7)

N개의 자연수와 자연수 M이 주어졌을 때, 아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성하시오. N개의 자연수는 모두 다른 수이다. N개의 자연수 중에서 M개를 고른 수열

www.acmicpc.net

2. 문제 요약

N개의 자연수 중 M개를 고른 수열
같은 수를 여러 번 골라도 된다.

3. 아이디어 정리

증가하는 순서 출력이므로 정렬을 진행한다.
백트래킹으로 M개를 선택할 때 출력하게 한다. ⇒ 종료 조건
같은 수 여러 개 가능하기 때문에 for 문에 조건을 없이 넣는다.

4. 문제 풀이

4-1. 내 풀이

import sys

def dfs(list_):
    if len(list_) == m:   # 1. Base condition(종료 조건)
        print(*list_)
        return

    for i in arr:         # 2. 백트래킹 
        list_.append(i)
        dfs(list_)
        list_.pop()

n, m = map(int, sys.stdin.readline().split())
arr = list(map(int, sys.stdin.readline().split()))
arr.sort()

dfs(list())

5. 결론

백트래킹 문제

Queue 두 개를 이용하여 Stack을 구현 & Stack 두 개를 이용하여 Queue를 구현

정찡이 — Thu, 9 Dec 2021 17:30:00 +0900

1. Queue 두 개를 이용하여 Stack을 구현해 보세요

큐 한 개는 메인 큐, 다른 큐는 임시 큐 용도로 둔다.

메인 큐에 값을 넣는다.(put) ex) 1→ 2→ 3 → 4
메인 큐에 1개의 원소가 남을 때까지 get 한 값을 임시 큐에 put 한다.
마지막 남은 원소는 result 변수에 저장한다.
임시 큐에 있는 원소들을 메인 큐로 모두 이동시킨다. (get → put)
result 값을 리턴한다.

1-1. 순서 설명

메인큐에 값을 넣는다.(put) ex) 1→ 2→ 3 → 4
메인 큐에 1개의 원소가 남을 때까지 get 한 값을 임시 큐에 put 한다.
마지막 남은 원소는 result 변수에 저장한다.
임시 큐에 있는 원소들을 메인 큐로 모두 이동시킨다. (get → put)
result 값을 리턴한다.

1-2. 코드

from queue import Queue

class Stack:
    def __init__(self):
        self.main = Queue()
        self.sub = Queue()

    def push(self, x):
        self.main.put(x)

    def pop(self):
        if self.main.empty():
            return

        while self.main.qsize() != 1:  # 메인 큐가 1개 남을 때까지 임시 큐에 넣기
            self.sub.put(self.main.get())

        result = self.main.get()

        self.main, self.sub = self.sub, self.main  # swap
        return result

s = Stack()
s.push(1)
s.push(2)
s.push(3)
s.push(4)
print(s.pop())  # 4
print(s.pop())  # 3

2. Stack 두 개를 이용하여 Queue를 구현해 보세요

스택 한개는 InBox, 한 개는 OutBox 용도로 만든다.

inBox에 데이터를 push(삽입)한다. ex) 4→ 3→ 2→ 1
inBox에 있는 데이터를 pop(추출) 하여 outBox에 push(삽입) 한다. ex) 1→ 2→ 3→ 4
outBox에 있는 데이터를 pop(추출) 한다. - 4→ 3→ 2→ 1

2-1. 순서

inBox 에 데이터를 push(삽입)한다. ex) 4→ 3→ 2→ 1
inBox에 있는 데이터를 pop(추출) 하여 outBox에 push(삽입) 한다. ex) 1→ 2→ 3→ 4
outBox에 있는 데이터를 pop(추출) 한다. - 4→ 3→ 2→ 1

2-2. 코드

class Queue:
    def __init__(self):
        self.inbox = list()
        self.outbox = list()

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

    def pop(self):
        if not self.outbox:
            while self.inbox:
                self.outbox.append(self.inbox.pop())
        return self.outbox.pop()

queue = Queue()
queue.push(4)
queue.push(3)
queue.push(2)
queue.push(1)
print(queue.pop())
print(queue.pop())
print(queue.pop())
print(queue.pop())

참고

https://hyerios.tistory.com/48

https://www.geeksforgeeks.org/implement-stack-using-queue/

[Python] programmers 뉴스 클러스터링

정찡이 — Sat, 4 Dec 2021 23:36:41 +0900

1. 문제 링크

https://programmers.co.kr/learn/courses/30/lessons/17677

코딩테스트 연습 - [1차] 뉴스 클러스터링

뉴스 클러스터링 여러 언론사에서 쏟아지는 뉴스, 특히 속보성 뉴스를 보면 비슷비슷한 제목의 기사가 많아 정작 필요한 기사를 찾기가 어렵다. Daum 뉴스의 개발 업무를 맡게 된 신입사원 튜브

programmers.co.kr

2. 문제 요약

두 문자열의 자카드 유사도를 출력

자카드 유사도: 교집합 크기 / 합집합 크기

3. 아이디어 정리

문자열 2개씩 끊기
교집합, 합집합 구하기
다중집합 구하기
- 교집합: 두 교집합에서 갯수 최소값
- 합집합: 두 교집합에서 갯수 최대값

4. 문제 풀이

4-1. 내 풀이

import math

def get_set(s):
    list_ = list()
    for c1, c2 in zip(s, s[1:]):
        new = str(c1 + c2).lower()
        if new.isalpha():
            list_.append(new)
    return list_

def solution(str1, str2):
    # 1. 문자열 끊기
    list_1 = get_set(str1)
    list_2 = get_set(str2)
    if len(list_1) == 0 and len(list_2) == 0:
        answer = 1
    else:
        # 2. 교집합, 합집합 구하기
        inter = set(list_1) & set(list_2)
        uni = set(list_1) | set(list_2)
        # 3. 다중집합 구하기
        inter_list = [min(list_1.count(i), list_2.count(i)) for i in inter]
        uni_list = [max(list_1.count(i), list_2.count(i)) for i in uni]

        answer = sum(inter_list) / sum(uni_list)
    answer = math.trunc(answer * 65536)
    return answer

5. 결론

구현

[Python] programmers 입국심사

정찡이 — Sat, 4 Dec 2021 23:34:35 +0900

1. 문제 링크

https://programmers.co.kr/learn/courses/30/lessons/43238

코딩테스트 연습 - 입국심사

n명이 입국심사를 위해 줄을 서서 기다리고 있습니다. 각 입국심사대에 있는 심사관마다 심사하는데 걸리는 시간은 다릅니다. 처음에 모든 심사대는 비어있습니다. 한 심사대에서는 동시에 한

programmers.co.kr

2. 문제 요약

모든 사람이 심사를 받는데 걸리는 시간 최솟값 구하기

3. 아이디어 정리

이분 탐색을 통해 걸리는 예측 시간을 구한다.
해당 예측 시간으로 몇 명이 허용되는지 확인
허용 가능한 인원으로 left, right 값을 조절

4. 문제 풀이

4-1. 내 풀이

def solution(n, times):
    answer = 0
    left = 0
    right = max(times) * n

    while left <= right:
        mid = (left + right) // 2     # 걸리는 예측 시간
        all_ = 0                      # 해당 시간 동안 몇 명이 허용되는지 확인
        for time in times:
            all_ += mid // time
        if all_ < n:
            left = mid + 1
        elif all_ >= n:
            answer = mid
            right = mid - 1
    return answer

5. 결론

이분 탐색

[Python] 백준 15683 감시

정찡이 — Sat, 4 Dec 2021 23:29:59 +0900

1. 문제 링크

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

15683번: 감시

스타트링크의 사무실은 1×1크기의 정사각형으로 나누어져 있는 N×M 크기의 직사각형으로 나타낼 수 있다. 사무실에는 총 K개의 CCTV가 설치되어져 있는데, CCTV는 5가지 종류가 있다. 각 CCTV가 감

www.acmicpc.net

2. 문제 요약

사각지대의 최소 크기를 출력

3. 아이디어 정리

각 cctv 모든 경우의 수 구하기 ⇒ 각 경우 별 감시 가능한 좌표를 모두 구한다.
백트래킹으로 모든 경우의 조합을 탐색한다.
- 최댓값인 경우 갱신한다.

4. 문제 풀이

4-1. 내풀이

def watch(x, y, dir):
    """
    해당 방향으로 보기
    :return:
    """
    set_ = set()
    for d in dir:
        nx, ny = x, y
        while True:
            nx += dx[d]
            ny += dy[d]
            if nx < 0 or ny < 0 or nx >= n or ny >= m:  # 범위 넘어가면 그만 탐색
                break
            if graph[nx][ny] == 6:                      # 벽이면 그만 탐색
                break
            if graph[nx][ny] == 0:
                set_.add((nx, ny))
    return set_

def dfs(count, all_):
    """
    백트래킹으로 모든 방향 조합
    :return:
    """
    global  max_
    if count == len(cctv_watch):  # 최댓값인지 확인하기
        max_ = max(max_, len(all_))
        return

    for i in cctv_watch[count]:
        dfs(count + 1, all_.union(i))

# 북, 동, 남, 서
dx = [-1, 0, 1, 0]
dy = [0, 1, 0, -1]

n, m = map(int, input().split()) # 세로, 가로
graph = [list(map(int, input().split())) for _ in range(n)]
cctv_watch = list()   # 각 cctv가 확인 가능한 좌표를 저장
zero = 0
max_ = 0

for i in range(n):
    for j in range(m):
        if graph[i][j] == 0:
            zero += 1
                # 각 cctv가 확인 가능한 좌표를 모두 확인 
        if graph[i][j] == 1:    # 한 방향, 4가지 경우 존재
            cctv_watch.append([watch(i, j, [0]), watch(i, j, [1]), watch(i, j, [2]), watch(i, j, [3])])
        elif graph[i][j] == 2:  # 서로 반대 방향
            cctv_watch.append([watch(i, j, [0, 2]), watch(i, j, [1, 3])])
        elif graph[i][j] == 3:  # 직각
            cctv_watch.append([watch(i, j, [0, 1]), watch(i, j, [1, 2]), watch(i, j, [2, 3]), watch(i, j, [3, 0])])
        elif graph[i][j] == 4:  # 3 방향
            cctv_watch.append([watch(i, j, [0, 1, 2]), watch(i, j, [1, 2, 3]), watch(i, j, [2, 3, 0]),  watch(i, j, [3, 0, 1])])
        elif graph[i][j] == 5:  # 4방향
            cctv_watch.append([watch(i, j, [0, 1, 2, 3])])

dfs(0, set())
print(zero - max_)

5. 결론

구현 문제