프로그래밍에 대한 고찰 및 생각

[2] Spring Boot Version Convention

Source — Sun, 17 Apr 2022 15:37:28 +0900

지난번 Semantic Version 에 이어 버전 옆에 붙는 태그들에 대해 알아보고자 한다.

GA (General Availability)

public 으로 배포된 버전을 의미한다.

CURRENT

GA 중에 가장 최신 버전을 의미한다. 이것은 보통 모든 새로운 프로젝트에 사용된다.

M (Milestone)

release 과정에서 주요한 stage를 마크할 때 사용되며 정해진 주기마다 배포된다.

SNAPSHOT

release 되기 전 버전을 의미한다.

예를 들어 1.0.0 버전이 배포되기 전에는 1.0.0-SNAPSHOT 이 존재하며 이 버전은 이후에 1.0.0 이 될 것이다.

Q. 실제 version 과 snapshot version은 어떤 차이가 있나?

A. snapshot version 은 수시로 업데이트 될 수 있다. 예를 들어 오늘 1.0-SNAPSHOT을 받았을 때 어제 받은 1.0-SNAPSHOT과 내일 받을 1.0-SNAPSHOT이 다를 수 있다.

PRE

아직 변경되지 않았지만 단지 개발자들이 다가오는 GA 릴리즈의 feature를 테스트하기 위해 배포한 것이다. 그것들은 몇몇 버그를 포함할 수 있는데 이것은 후에 같은 버전의 pre release에서 수정된다. (ex 2.0.0 M1 → fix → 2.0.0 M2, M = Milestone)

이렇게 보면 와닿지 않을 것 같다. 실제 버전 리스트를 보면서 확인해보자.

위 리스트는 2022.04.17 PM 02:48 기준 (UTC+09:00) Spring Security Version 목록이다. (https://spring.io/projects/spring-security#learn)

Spring Security

Spring Security is a framework that focuses on providing both authentication and authorization to Java applications. Like all Spring projects, the real power of Spring Security is found in how easily it can be extended to meet custom requirements

spring.io

버전 목록들을 살펴보면 현재 public 으로 배포된 버전들(GA)이 있고 그중 가장 최신 버전인 5.6.2 버전이 CURRENT 인 것을 알 수 있다.

Spring boot 프로젝트에 Spring Security를 새로 적용한다면 5.6.2 버전을 적용하면 될 것 같다.

6.0.0 5.6.3 5.5.6 버전의 경우 SNAPSHOT 이 붙어있다. (이 버전들은 release 되기 전이므로 GA 는 없음을 알 수 있다)

5.6.3-SNAPSHOT 버전을 클릭해보면 아래와 같은 경고 문구를 볼 수 있다.

해당 버전이 스냅샷으로 아직 안정되지 않았으므로 현재 가장 최신 GA 인 5.6.2 버전을 사용하라고 안내하고 있다.

PRE 버전인 6.0.0과 5.7.0도 확인할 수 있다. 이 역시도 안정된 버전이 아니므로 클릭해보면 위와 동일한 문구를 확인할 수 있다.

출처. https://stackoverflow.com/questions/5901378/what-exactly-is-a-maven-snapshot-and-why-do-we-need-it

[1] Semantic Version

Source — Sun, 17 Apr 2022 15:20:38 +0900

Spring boot 를 사용하면서 아래와 같은 다양한 버전들을 보게되는데 버전 이름 생성하는 규칙과 옆에 붙어있는 태그들(CURRENT, GA...) 이 정확히 어떻게 붙여지고 어떤것을 의미하는지 정리를 한번 해봐야겠다는 생각이 들었다.

그 중 5.6.2 5.2.15 처럼 숫자로 이루어진 형태의 버전들에 대해 먼저 알아보았다.

01. 소프트웨어 개발에서 Versioning이 중요한 이유?

소프트웨어 Version 은 특정한 이름/번호를 통해 소프트웨어나 패키지의 상태를 구분할 수 있게 해준다.

여기에는 다양한 Versioning Schemes 가 있지만 그중 유명한 것중 하나는 Semantic Versioning (SemVer) 이다.

02. SemVer ?

출처. https://www.baeldung.com/cs/semantic-versioning

SemVer 의 기본적인 포맷은 위와 같다. X Y Z 는 순차적으로 증가하는 정수로 각각 Major, Minor, Patch 를 나타낸다.

Major
- Major Version은 기존 API 를 break 하는 기능을 새로 개발할 때, 즉 프로젝트에 하위 호환성이 없는 변경사항을 추가할 때 증가되어야 한다.
- 이때 Minor, Patch 는 0으로 초기화 되어야한다.
- 예를 들어, 3.5.2 버전에서 Major 버전을 올린다면 4.0.0 이 될것이다.
Minor
- Minor Version은 기존 API를 기능적으로 변경하였지만 하위 호환성이 존재하는 변경일 때 증가된다. 또는 내부 코드의 상당한 수정이 있었다면 증가할 수 있다.
- 이때 Patch 는 0으로 초기화 되어야한다.
Patch
- 이전 버전과 호환되는 버그 수정을 할 때 증가된다.
- Patch 업데이트 시에는 API가 변경되어서는 안된다.

추가 라벨

Pre-Release
- 1.0.0-alpha.1 은 1.0.0 버전의 사전 릴리즈 버전임을 나타낸다. 이 버전은 불안정하며, 사용할 경우 위험성이 높음을 의미한다.
Build

출처. https://www.baeldung.com/cs/semantic-versioning

[2][오브젝트] - 객체지향 프로그래밍

Source — Tue, 8 Feb 2022 22:06:29 +0900

오브젝트의 두번째 챕터인 '객체지향 프로그래밍'에서는 '영화예매 시스템'을 기반으로 객체지향 패러다임에 대해 설명한다.

해당 시스템에 대해 간략하게 설명하면

- 하나의 예매(Reservation)에는 하나의 상영(Screening) 및 상영시간과 순서가 존재한다.

- 하나의 상영에는 하나의 영화(Movie)가 존재하고, 하나의 영화에는 요금과 할인 정책이 존재한다.

- 할인 정책은 특정 금액을 할인해주는 정책(Amount DiscountPolicy)과 특정 비율을 할인해주는 정책(Percent DiscountPolicy)이 존재하며, 할인 조건으로는 상영순서에 따른 조건(Sequence Condition)과 상영기간에 따른 조건(Period)가 존재한다.

01. 객체지향 패러다임으로의 전환

클래스가 아닌 객체에 초점을 맞출 것. 어떤 클래스가 필요한지를 고민하기 전에 어떤 객체들이 필요한지 고민하자.

객체를 독립적인 존재가 아니라 기능을 구현하기 위해 협력하는 공동체의 일원으로 보자

02. 구현 은닉(Implementation hiding)

클래스를 설계할 때 필요한 부분만 공개하고 나머지는 마음대로 접근할 수 없도록 방지하여 내부를 구현하는 것을 구현 은닉 이라고 한다.

클래스를 구현하는 사람은 인터페이스를 유지한채 내부를 마음대로 변경할 수 있고 (자유로운 구현 가능)

클래스를 사용하는 사람은 내부 구현을 무시한 채 인터페이스만 알고 있어도 클래스를 사용할 수 있다 (알아야할 지식의 양 감소)

03. Money Type

본 책에서는 영화 예매 시스템의 금액을 구현할 때 Money 라는 클래스를 만들어 사용했다.

보통 금액을 구현할 때 Integer 또는 long 타입을 떠올렸는데 새로운 클래스를 만들어서 사용하는 것이 인상깊었다.

이를 통해 다음 두가지의 이점을 얻을 수 있었다.

1. 해당 변수가 금액을 의미한다는 것을 더 명시적으로 전달할 수 있다.

2. 금액과 관련된 로직이 다른 곳에 중복되어 구현되는 것을 방지할 수 있다.

비록 한가지 인스턴스 변수만 포함한 클래스더라도 이러한 설계가 설계의 명확성과 유연성을 높여주었다.

04. 코드의 의존성, 실행 시점의 의존성

DiscountPolicy class가 Abstract class로 구현되어 있을 때, 코드의 의존성과 실행 시점의 의존성이 달라질 수 있다.

Movie에서 DiscountPolicy 인스턴스를 넣어주기 전에는 Amount DiscountPolicy를 의존할지, Percent DiscountPolicy를 의존할지 알 수 없다.

실제로 둘 중 어떤 인스턴스를 넣는지 확인하기 전까지 알 수 없다는 의미이다. 이 두 시점의 의존성이 달라질수록 코드를 이해하기 어려워진다.

설계가 유연해지면, 코드를 이해하고 디버깅하기 어려워지고

유연성을 억제하면 코드를 이해하고 디버깅하기 쉬워지지만, 재사용성과 확장 가능성이 낮아진다.

즉 각각의 방법이 장단점이 존재하며 Trade Off가 존재한다는 것이다.

요즘 개발을 하면서 가장 많이 느끼고 있는 부분이다. 어떤 것을 결정할 때 항상 장점만 있는 선택은 그리 많지 않았다. 한쪽을 추구하면 다른 한쪽을 포기해야하는 상황이 많았다.

05. 상속, 인터페이스 + 다형성 with 할인 정책

부모의 인터페이스를 자식이 상속받으면 자식은 부모의 모든 인터페이스를 사용할 수 있다.

나는 지금까지 인터페이스를 대할 때 중복으로 사용되는 인스턴스 변수나 메서드를 줄이기 위해 사용했던 것 같다. 이 책에서는 대부분의 사람들이 이와같이 생각하고 있다는 것을 정확히 짚어주었다. (뜨금)

이 책에서는 조금 다른 시각으로 인터페이스를 바라본다. 인터페이스는 객체가 이해할 수 있는 메시지의 목록을 정의하는 것이고, 자식 클래스는 부모 클래스가 수신할 수 있는 모든 메시지를 수신할 수 있다.

public class Movie{
	
    ...
    
    public Money calculateMovieFee(Screening screening) {
        return fee.minus(discountPolicy.calculateDiscountAmount(screening));
    }
}

그래서 Movie 에서 할인 가격을 계산할 때 실제로 해당 객체가 Amount DiscountPolicy인지, Percent DiscountPolicy인지 중요하지 않다. 그저 calculateDiscountAmount()라는 메세지를 수신할 수 있기만 하면 그만이다.

이처럼 자식 클래스가 부모 클래스를 대신하는 것을 업캐스팅(Upcasting) 이라고 한다.

그리고 calculateDisCountAmount() 는 메세지이다.

실제로 실행되는 메소드는 실제로 연결된 객체의 클래스가 Amount냐 Percent냐에 따라 Override 된 함수에 따라 달라질 것이다.

이처럼 동일한 메세지를 전송하지만, 메세지를 수신하는 수신하는 객체의 클래스가 무엇이냐에 따라 달라지는 것을 다형성이라고 한다.

Interface vs abstract class

예제들을 보다보니 이 둘의 차이가 궁금해졌다. 사실 interface는 자주 사용해서 익숙했는데 abstract 는 자주 사용하지 않아 익숙하지 않았고, 막상 둘을 비교하니 아주 비슷해보였다.

정의부터 살펴보자.

abstract class : 하나 이상의 추상 메소드(abstract method)가 포함된 클래스.

interface : 오로지 추상메소드와 상수만을 가짐.

* 여기서 추상 메소드란 내부 구현이 되어있지 않아 상속받는 클래스에서 해당 추상 메소드를 재정의 해야하는 메소드를 말한다.

이렇게보면 추상 클래스가 인터페이스를 포함하는 개념같아 보인다. 그렇다. 추상 클래스가 인터페이스를 대체할 수 있다. 그러나 둘은 사용의도에 따라 사용처가 달라진다.

일단 둘의 공통점을 살펴보면 둘다 추상 메소드를 가진다는 점이고, 차이점은 추상 클래스는 추상 메소드가 아닌 일반 메소드도 가질 수 있다는 것이다.

즉 상속받을 클래스들이 일부는 내부 구현이 동일한 메소드를 가져야한다면 추상 메소드를 사용하면 좋을 것이고, 상속받을 클래스들이 모두 다른 내부 구현을 가져야한다면 인터페이스가 적절할 것이다.

그렇다면 위의 내용대로 추상 클래스가 인터페이스를 완벽히 대체하는데 인터페이스는 필요없는 것이 아닌가?

추상 클래스의 단점은 상속받을 때 복수의 추상 클래스를 상속받을 수 없다는 점이다. 그에 반해 인터페이스를 여러 인터페이스를 상속받을 수 있다.

06. 마치며

이번 장에서부터 본격적인 객체지향 설계에 대한 내용들이 많이 나왔던 것 같다. 다형성, 인터페이스, 추상 클래스, 구현 은닉, 상속 등 한번 쯤은 들어왔고 자주 사용하던 것들이지만 해당 내용에 대해 깊게 고민해본 적은 없었던 것 같다. 그래서 하나하나 찾아보는데 시간이 많이 소요가 되어서 이번 챕터를 공부하는데 꽤나 오랜시간이 걸렸던 것 같다.

이 책의 필자가 어떤 생각으로 코드를 설계했는지 의도를 100% 정복하지는 못한 것 같고 다만 어느정도 느낌을 받은 정도에 그쳤던 것 같다. 객체지향 쉽지않다.. 그래도 책을 읽어가면서 실제로 개발하다가 들었던 생각들을 필자가 언급해줄 때마다 그래도 조금씩 객체지향과 가까워지고 있지 않나 하는 생각이 든다.

아무래도 이 책은 한번 읽고 나중에 또 읽어야할 것 같다.

[1][오브젝트] - 객체, 설계

Source — Sat, 8 Jan 2022 18:01:54 +0900

오브젝트의 가장 첫번째 챕터인 "객체, 설계" 파트에서는 극장에서의 티켓판매 시스템을 중심으로 좋은 설계가 무엇이고, 어떤 설계가 문제인지, 그래서 객체지향 설계가 무엇이고 왜 필요한지에 대해 설명한다.

01. 좋은 설계란?

이 책에서는 좋은 소프트웨어 모듈 설계에 있어서 다음 3가지를 만족해야 한다고 설명한다.

1. 잘 작동해야 한다.

2. 변경이 용이해야 한다.

3. 쉽게 읽고 이해할 수 있어야 한다.

그간 소프트웨어 모듈을 설계할 때 1번, 잘 작동하는 것에 모든 초점을 맞추어 설계하였다.

예전에는 무언가 조잡해 보이지만 코드를 실행 했을 때 "잘 작동하니까 나름 문제 없는 코드지!" 라는 생각을 했었다.

그러다가 코드리뷰를 통해 잘 작동하는 것을 넘어서 좋은 설계를 하기 위한 조언들을 받으면서 잘 작동하는 것 이상의 필요한 조건들이 있음은 느꼈다. 그러나 그것이 무엇인지는 잘 알지 못했다.

그 해답이 2,3번 인 것 같다.

물론 2,3번에 대한 필요성을 전혀 몰랐던 것은 아니다. 변경이 쉽고 이해하기 쉽게 짜야하는 것은 알고 있는데(~~말은 쉽다~~) 구체적으로 그것을 실현하기 위해 어떤 방법론을 도입하여야 하는지는 알지 못했다.

02. Low Coupling

이 책에서 강조하는 내용 중 하나는 결합도(Coupling)을 낮추는 것이다.

결합도가 높다는 것은 무엇일까?

public class Theater {
	
    ...

    public void enter(Audience audience){
        if(audience.getBag().hasInvitation()){
            Ticket ticket = ticketSeller.getTicketOffice().getTicket();
            audience.getBag().setTicket(ticket);
        }
        else{
            Ticket ticket = ticketSeller.getTicketOffice().getTicket();
            audience.getBag().minusAmount(ticket.getFee());
            ticketSeller.getTicketOffice().plusAmount(ticket.getFee());
            audience.getBag().setTicket(ticket);
        }
    }
}

위의 Theater 라는 객체는 Audience 라는 청중을 입장시키는 역할을 한다.

이때 Ticket을 가져오는 부분을 보자.

Ticket ticket = ticketSeller.getTicketOffice().getTicket();

TicketSeller로부터, TicketOffice로 부터 티켓을 가져온다.

여기만 봐도 Theater는 TicketSeller, TicketOffice, Ticket 와 모두 연관이 된다.

위의 객체들중 하나라도 수정이 된다면 Theater에도 영향을 미칠 수 있다는 것이다.

어떻게 해결 할까?

03. 객체 책임의 분리

public class Theater {
 
 	...

    // 손님 입장에만 관여하고 TicketSeller에게 다음 권한을 위임
    public void enter(Audience audience){
        ticketSeller.sellTo(audience);
    }
}

Theater의 역할은 그저 Audience 청중을 입장시키는 것이다. Theater가 굳이 TicketOffice, Bag, Audience의 데이터와 함수들을 알고 있을 필요가 없다.

따라서 위처럼 청중이 입장했을 때, TicketSeller 에게 청중을 넘겨주고 다음 역할(초대장이 있는지 확인, 티켓 구매, 정산 등)에 대한 역할을 위임하는 것이다.

이렇게 되면 Theater에서는 그 이후에 TicketSeller가 어떤 방식으로 초대장을 확인하고, Audience가 티켓을 구매하고, Bag에서 정산은 어떻게 이루어지는지 알 필요가 없고 결국 결합도를 낮추게 된다.

이로인해 결국 자율성이 높아지게 된다.

또한 이후에 Audience가 현금이 아닌 카드나 포인트를 이용한다거나, TicketSeller가 돈을 TicketOffice가 아닌 은행에 보관한다고 해도 전혀 영향을 받지 않는다.

이렇게 객체와 연관된 작업만 수행하고 연관되지 않은 작업은 다른 객체에게 위임하는 것을 응집도(Cohesion)가 높다고 한다.

객체를 자율적으로 만들면 응집도는 높아지고, 결합도는 줄어든다. (High Cohesion Low Coupling)

결국 외부의 간섭을 최대한 배제하고 메세지(위 코드의 경우 sellTo()) 를 통해서 협력하는 자율적인 객체들의 공동체를 만드는 것이 훌륭한 객체지향 설계를 얻을 수 있는 지름길이다.

04. 절차적 프로그래밍, 객체지향 프로그래밍

변경하기 이전의 코드는 절차적 프로그래밍(Procedual Programming) 이다.

이처럼 구현을 하게되면 Theater가 모든 클래스를 제어하기 때문에 의존성이 많아진다.

이것을 현재처럼 자신의 데이터를 스스로 처리하게 변경하고 데이터와 프로세스를 동일한 모듈 내에 위치하도록 프로그래밍 하는 것을 객체지향 프로그래밍(Object Oriented Programming) 이라고 한다.

즉 책임을 분리하는 것이다.

- Theater 는 관람객의 입장만을 책임지고

- TicketSeller 는 티켓 판매만을 책임지고

- Audience 는 티켓 구매만을 책임지는 것이다.

05. Trade-Off

Trade-Off 라는 단어는 프로그래밍 세계 뿐만 아니라 현실세계에서도 자주 마주친다. 어떠한 행위에 있어서 항상 장점과 단점이 공존한다.

치킨을 먹는다면 기분이 좋다는 장점이 있지만, 살이 찐다는 단점이 있다.

닭가슴살을 먹는다면 기분은 안좋겠지만, 살이 덜 찐다는 장점이 있다.

우리는 항상 Trade-Off 속에서 가장 현명한 답을 찾아간다.

이러한 Trade-Off 는 객체지향 설계에서도 피해갈 수 없었다.

나는 설계에 있어서 가장 우위에 있는 설계 비법이 존재할 것이라고 믿었지만 현실은 그렇지 않았다.

설계의 방법은 다양하고, 제각각의 장단점을 가지고 있다.

마지막 변경에서는 TicketOffice의 자율성을 높히는 대신, Audience와의 결합도가 증가했다. 다음의 구절이 인상깊었다.

어떤 설계에 있어서 기능설계하는 방법은 한가지 이상일 수 있고 모든 사람들을 만족시킬 수 있는
설계를 만들 수는 없다.
설계는 균형의 예술이다. 훌륭한 설계는 적절한 트레이드 오프의 결과물이다.
이러한 트레이드오프 과정이 설계를 어려우면서도 흥미진진한 작업으로 만드는 것이다.
- Object 33page -

06. 정리하자면

우리는 주어진 요구사항에 맞추어서 기능이 동작하도록 코드를 짜는 동시에 추가적인 요구사항에 쉽게 대처할 수 있는(변경이 용이한) 코드를 짜야한다. 요구사항은 항상 변화하고, 코드가 변경되면 오류의 위험에 노출되기 때문에 유연한 코드를 작성하는 것은 굉장히 중요하다.

07. 무엇을 배웠는가?

극장 예제를 통해 객체지향이란 무엇이고, 왜 필요한지에 대해 알게 되었다. 특히 객체의 역할 분리와, 결합도를 낮춘다는 것이 무엇인지 와닿았다.

또한 코드를 작성할 때 잘 작동하는 것은 기본이고, 이후에 수정하기 용이한(동시에 이해하기 좋은) 코드를 작성하는 것을 항상 염두하고 프로그래밍을 해야겠다.

+ 그리고 책에서 코드들이 자주 나오는데 눈으로만 보는 것보단 실제로 작성해보는 것이 더 직관적으로 이해가 되었다. 코드를 개선해 나가면서 다음 개선점을 책을 보지 않고 미리 내가 시도해 보기도 하였는데 이해하는데 큰 도움이 되었다. 학습을 할 때 내가 귀찮을 수록 더 오래 기억에 남는것으로 알고있는데 그 예가 이것이 아닐까 싶다. 최대한 귀찮게 공부하자!

[0][오브젝트] - 시작

Source — Sat, 8 Jan 2022 17:25:10 +0900

Q 01. 왜 읽는가?

사실 이 책은 회사에 입사할 때 입사선물로 받은 책이다. "오브젝트"라는 책은 이미 객체지향 설계에 있어서 유명한 책이고 평이 좋아서 항상 읽어야지 생각만 하다가 읽지 못했다.

최근에 spring boot를 이용하여 백엔드 개발을 하면서 "설계"에 대해서 고민을 많이 하고 있다.

단순히 동작하는 코드를 넘어서 어떻게 설계해야 "잘" 설계하는가가 궁금했다.

항상 의식의 흐름대로 "잘 동작하는 것"에만 목적을 두고 코딩을 하였는데 무언가 좋은 설계에 대한 갈망이 커진 것 같았다.

그래서 책장 한켠에 놓여있던 오브젝트 라는 책을 펴야겠다는 생각이 들었다.

이 책을 통해 더 좋은 객체지향적인 설계를 할 수 있는 능력을 키우는 것이 목적이다.

Q 02. 목표 기간은?

나는 보통 무언가 목표를 세울 때 구체적인 목표를 세우지는 않는 편이다. 당장 내일의 일도 예측하지 못하는데 며칠 뒤, 몇달 뒤를 예측하여 계획을 세우면, 지키지 못했을 때 나에 대한 실망을 하게되는 경우가 많았기 때문이다.

또한 이 책은 단순히 읽기에 그치지 않고 관련된 코드를 직접 작성해보고 스스로 충분히 고민할 시간이 필요하기 때문에 더더욱 고정적인 기간을 잡고 싶지 않았다.

대략적인 목표는 한 챕터당 1-3주를 목표로 공부하는 것이다. 좀더 길게본다면 2022년안에는 이 책을 정복.. 까진 아니더라도 이 책과 조금 친해질 수 있지 않을까 기대한다.

Q 03. 무엇을 기록할 것인가?

사실 마음같아서는 책 내용을 전부 정리한 내용을 이곳에 기록하고 싶지만 다음과 같은 이유로 전부 기록은 안하기로 결정했다.

1. 책 내용을 너무 그대로 담게되면 저작권에 문제가 생길 수 있다.

2. 모든 챕터를 상세하게 다 정리하는 것은 현실적으로 시간이 너무 오래걸리고, 불필요한 시간 소모가 많을 것 같았다.

3. 너무 자세할 수록 나중에 다시 볼 때 압박감이 생기고, 핵심을 파악하기 어려워진다.

따라서 전체적인 기록은 개인적인 노트나 코드에 기록하고, 여기에는 해당 챕터에 대한 간략한 내용들과 어떤것을 배웠는지, 느낀점 위주로 기록하게 될 것 같다.

[1] Github - Git Flow 전략 시작

Source — Fri, 1 Oct 2021 23:54:59 +0900

새로운 레포지토리를 clone 하는 것 부터 add, commit, push 그리고 branch 생성 및 변경, 마지막으로 PR(Pull Request) 하는 과정까지 간략하게 살펴보자.

시작

0. 레포지토리 clone

git clone <repository>

1. master branch 에서 testfile 생성 ( 내용 : test )

git add . && git commit -m "update" && git push origin master

2. master branch 에서 testfile 내용 변경 (test -> test2)

git add . && git commit -m "update" && git push origin master

3. develop branch 생성

# develop 이라는 브랜치 생성 후 해당 브랜치로 변경
git checkout -b develop 
git push origin develop

4. feature/1 branch 생성

# feature/1 이라는 브랜치 생성 후 해당 브랜치로 변경
git checkout -b feature/1 
git push origin feature/1

5. feature/2 branch 생성

# develop branch로 위치 변경
git checkout develop

# feature/2 라는 브랜치 생성 후 해당 브랜치로 변경
git checkout -b feature/2
git push origin feature/2

6. feature1 에서 파일내용 추가 (+feat1)

7. fix branch 생성

8. fix branch 및 버그 수정 ( +(bugfix)) -> master branch 로 merge ( Pull Request)

9. feature/1 branch 수정사항 develop branch 로 merge

10. feature/2 branch 기능추가 및 develop 으로 merge (+feat2)

여기서 conflict 가 발생하므로 해당 부분을 적절히 수정해준다.(feat1, feat2 가 모두 포함되어야 할것이다)

11. develop branch -> master branch merge

참고. git flow (https://ux.stories.pe.kr/183)

참고. git 사용법 (https://backlog.com/git-tutorial/kr/stepup/stepup1_1.html)

[알고리즘][16][백준_7570] - 줄 세우기

Source — Thu, 23 Sep 2021 14:03:49 +0900

전략

N의 최대크기는 100만이므로 배열이 주어졌을 때 한명한명 맨 앞 또는 맨 뒤로 전부 보내보는 것은 불가능해 보인다.

따라서 다른 전략이 필요할 것 같았다.

이런 문제처럼 감이 잘 안올 때에는 간단한 예제를 통해서 대략적인 전략을 찾아야 한다.

먼저 문제에서 주어진 예제를 먼저 보자.

예제의 입력에 대해서 답을 도출하는 과정은 위와 같다.

이 예제에서 주목한 부분은 "움직인 숫자" 와 "움직이지 않은 숫자" 였다.

아래와 같이 구분하면 좀 더 보기 쉬울 것이다.

2와 3은 그대로 두었고 5,4,1은 앞 또는 뒤로 옮겼다.

왜 2,3은 두고 5,4,1만 옮겼을 때 최소의 움직임이 되는지를 고민해보았다.

이 예제만으로는 감이 잘 안올 수도 있어 다른 예제를 하나 더 살펴보자.

위 예제의 경우 1,2,6,7 이라는 숫자를 옮겼을 때 최소이다.

잘 살펴보면, 움직이지 않는 숫자들은 모두 연속이라는 것을 파악할 수 있다.

그렇다면 왜 연속으로 이루어진 숫자들을 제외하고 나머지를 이동시켰을 때 최대인지 살펴보자.

위와같이 임의의 숫자들이 주어졌다고 가정하자.

이때 위와같이 연속으로 이루어진 부분수열이 있을 것이다 (파란색 네모)

그리고 z~z+2 까지 연속된 수열을 제외하고 나머지 숫자들은 저 수열보다 작거나 크다. 정확히 말하자면 z보다 작거나, z+2 보다 크다.

(중복된 숫자는 없기때문)

빨간색 네모의 숫자들은 z보다 작고, 초록색 네모의 숫자들이 z+2보다 크다고 가정하고 빨간네모를 좌측으로, 초록네모를 우측으로 움직인다면 다음과같이 될것이다.

즉, 연속된 부분수열을 제외한 나머지 숫자들은 크기에 맞추어서 좌측, 혹은 우측으로 배치한다면 연속된 부분수열은 따로 움직이지 않아도 결국 파란 네모처럼 중간에 오름차순으로 정렬되게 된다.

결론적으로 빨간네모와 초록네모의 개수만큼 움직임이 필요하고 그 움직임은 최소화해야 한다.

그말은 반대로 말하면 파란색 네모의 개수가 많을수록 최소의 움직임이 나온다는 뜻이다.

정리하자면, 주어진 수열에서 순차적으로 증가하는 부분수열중 가장 길이가 긴 수열의 원소개수가 k개라고 하고, 전체 개수를 n개라고 한다면 최소 이동수는 n-k이다.

결국 이 문제는 k를 구하는 문제이다.

다만 주의해야 할 점은 주어진 수열에서 순차적으로 증가하는 부분수열중 가장 길이가 긴 수열 에서 LIS 알고리즘처럼 단순히 이전 원소보다 증가만 한다고 되는것이 아니라 연속해서 증가해야한다.

1 2 3 4 5 는 가능 하지만

1 4 10 11 은 불가능 하다는 것이다.

구현

이제 위의 내용을 바탕으로 구현을 해보자.

우리는 연속하는 부분수열중 가장 긴 수열을 구해야한다. 그러므로 주어진 수열에서 연속하는 부분수열의 개수를 k개 라고 한다면 그 부분집합중 가장 선두의 숫자를 루트(root) 라고 부를것이다.

예를 들어 아래와 같은 수열이 주어진다면

아래와 같은 연속하는 부분수열들이 존재할 것이다. (같은 색이면 같은 부분수열에 속한다는 의미이다.)

그리고 3,6,9는 위에서 정의한 루트에 속한다.

따라서 모든 숫자는 선두이거나 선두가 아니다.

이를 구현하기 위해

visited[] 배열과 counts[] 배열을 이용하였다.

visited[x] = x라는 숫자(x번째 인덱스의 숫자가 아니다) 를 이전에 방문했었는지

counts[x] = x라는 숫자(x번째 인덱스의 숫자가 아니다) 까지 이전에 연속한 숫자가 몇개 있었는지

를 뜻한다.

처음에 p라는 숫자를 볼때 루트인지 아닌지를 판단해야한다.

p라는 숫자가 루트이려면 p-1이라는 숫자를 이전에 방문하지 않았어야 하므로 visited[p-1] 이라는 값을 보면 알 수 있을 것이다.

1) 만약 p가 루트다.

먼저 visited[p] 를 방문상태로 체크하고, counts[p] = 1 로 체크한다.

2) 만약 p가 루트가 아니다

역시 visited[p]를 방문상태로 체크하고, counts[p] = counts[p-1]+1 로 체크한다.

이런식으로 반복하다보면 최종적으로 counts[] 배열에는 왼쪽부터 시작해서 현재 자신까지 연속하는 숫자가 몇개인지 나타내는 숫자들이 들어있을 것이다. 따라서 해당 배열의 숫자중 가장 큰 값이 가장 긴 부분수열일 것이다.

C++ 구현 코드

#include <iostream>

using namespace std;

int n;
int arr[1000001];
int visited[1000001];
int counts[1000001];

int main(){
    cin >> n;
    for(int i=0;i<n;i++){
        cin >> arr[i];
        visited[i] = -1;
        counts[i] = 0;
    }
    int now;
    for(int i=0;i<n;i++){ // 연속으로 증가하는 수열중 가장 길이 찾기
        now = arr[i];
        visited[now] = 1;
        if(now == 1){
            counts[now] = 1;
        }
        else{
            // 현재 숫자의 이전 숫자가 아직 발견되지 않은 상태
            if(visited[now-1] == -1){
                counts[now] = 1;
            }
            // 현재 숫자의 이전 숫자가 이전에 이미 발견된 상태
            else{
                counts[now] = counts[now-1] + 1;
            }
        }
    }
    int maxi = 0;
    for(int i=1;i<n+1;i++){
        if(counts[i] > maxi){
            maxi = counts[i];
        }
    }
    int ans = (n-maxi);
    cout << ans;
}

[5][인턴십종료] 2021 카카오 채용연계 여름 인턴십 for Tech Developers

Source — Tue, 31 Aug 2021 12:49:06 +0900

인턴십 시작

6월 28일, 카카오에서의 인턴생활이 본격적으로 시작되었다.

적응을 위해 온보딩 기간을 가지고 바로 과제를 수행했다.

과제내용은 내가 속한 부서의 기본적인 시스템을 구축하는 것이였다.

해당 시스템을 구축하기 위해 Spring boot를 비롯한 여러 오픈소스들이 활용되었다.

Spring boot도 사실 많이 안써봤지만 다른 오픈소스들은 들어본적도 없는것들이 많았다.

초반 일주일은 거의 해당 내용들을 알아보고 공부하는데 보낸 것 같다.

약 6주간 과제에 대한 개발을 진행하고 남은 2주간은 최종 인터뷰를 위한 준비를 했다.

인턴십 초기 7월에는 카카오에서 일한다는 설렘과 신기함이 컸다.

그러나 8월이 넘어갈수록 최종 전환에 대한 압박이 커졌고 이번 기회를 놓치게 되면 다시 여기까지 올 수 있을까 하는 걱정이 겹치며 큰 스트레스로 다가왔다.

8월 중순부터는 소화불량에 두통과 몸살이 오기도 했고, 굉장히 예민해져있었다.

특히나 최종 면접을 준비할 때는 정해진 답이 없음에도 가장 근접한 답을 찾기위해서 시간을 투자했고 그 과정에서도 굉장히 힘들었다.

온종일 인턴십에 대한 생각뿐이였고 8월부터는 집을 나간적이 손에 꼽았던 것 같다.

최종 인터뷰

인턴십의 마지막 여정인 최종 인터뷰를 마치게 되었다.

인터뷰때, 내가 예상했던 인터뷰 시나리오와는 조금 다른방향으로 흘러가면서 뭔가 잘못되었음을 직감했다.

나의 부족한 부분들이 여실히 드러났고 나도 인정할 수 밖에 없었다.

하지만 인터뷰 자체에 후회는 없었다. 지적받았던 부분들은 단편적인 나의 문제점에 대한 지적이 아니라 지금까지 가지고 있었던 나의 습관에 대한 지적이였고, 이것은 변명의 여지가 없었기 때문이다.

오히려 떨어져야 할 이유에 대해 명확히 인지한 것 같아 마음이 놓이기도 했다.

그리고 최종 인터뷰가 끝나자마자 고민에 잠겼다.

앞으로 개발자로서 살아가기 위해 어떤점들을 개선해야하고, 그러기 위해서는 어떻게 준비하고 대비해야할지에 대해서.

전환 결과

결과는 내 예상과는 달랐다.

최종 인터뷰때는 많이 미숙한 모습을 보였지만, 인턴십 기간동안 보였던 모습에서 조금이나마 플러스요인이 있었지 않았을까 싶다.

사실 이번 인턴십 최종 전환 합격은 내가 정말 뛰어났기 때문은 단언코 아니였다.

벼랑끝까지 갔었고 현재 나의 능력보다는 앞으로의 성장 가능성을 높게 봐주신 덕이였을 것이다.

원래는 4학년 2학기까지 마치고 졸업을 한 뒤에 토이프로젝트를 하면서 취준을 할 예정이였는데 생각보다 취업이 빠르게 되어 기분이 좋으면서도 가서 잘 할수 있을까에 대한 고민도 많다.

좋은 기회를 얻은 만큼 열심히 해야겠다는 생각이 많이 든다.

[4][최종결과] 2021 카카오 채용연계 여름 인턴십 for Tech Developers

Source — Wed, 9 Jun 2021 21:23:31 +0900

결과

원래 예정된 발표는 수요일이였다.

지난 서류발표때 예정된 날짜보다 하루 일찍 발표가 나서 혹시 이번에도 하루 일찍 발표가 나오나 했지만 아니였다.

코딩테스트와 서류 결과가 모두 오후 5-6시쯤 나와서 이번에도 그쯤 나올것이라고 생각했는데 생각보다 일찍 오후 1시쯤 나왔다.

면접 중간중간 쉬운 질문에도 못한 대답도 있었고, 자신 있다고 말했던 분야에서 대답하지 못한 질문도 있었다.

지원했던 서버와 크게 관련있는 프로젝트도 거의 없었다.

하지만 모르는 내용은 모른다고 솔직하게 말씀드리고, 아는 내용은 최대한 자세하게 설명하려고 노력했다.

가식없이 있는 그대로, 아는 그대로를 보여준것 같다.

수업시간에 열심히 공부해왔던 CS들, 다양한 프로젝트 경험들, 솔직함

이 세가지가 강점이 아니였나 싶다.

첫 인턴십

첫 인턴십을, 그것도 가고싶어했던 카카오에서 하게 되어 굉장히 기쁘다.

앞으로 두달간 어떤 사람들과 어떤 프로젝트를 맡게될지 기대도 되면서 긴장도 된다.

그 어느때보다 뜨거운 여름을 보낼 수 있을 것 같다.

마치며

4번에 걸쳐 이번 카카오 인턴십에 대한 내용을 적은 이유는, 처음 경험해 보는 것을 기록해놓고 싶었던 것도 있고 이번에 카카오 인턴십을 준비하면서 거의 존재하는 모든 후기들을 다 본것 같은데 생각보다 후기들이 많이 없어서 앞으로 또 인턴십에 지원하실 분들에게 조금이나마 도움이 되었으면 하는 마음에 최대한 많은 것들을 적으려고 노력했다.

아직 카카오 인턴십에 지원하지 않은 분들이라면 한번 도전해봤으면 한다.

코딩테스트 분위기를 보려고 지원했던 인턴십에 서류에 면접까지 합격하게 될줄은 꿈에도 몰랐다. 나는 운이 좋게 붙었지만 준비하면서 그간의 생활들을 돌아보면서 반성도 하고 나름 계획도 세우며 합불을 떠나 얻은 것들이 많았다.

이미 전형을 진행중이신 분들이라면 자신감을 가지자.

지나친 자만은 독이겠지만, 적어도 아는 내용에서는 자신감을 가지고 이상한 내용이 아니라면 자신있게 말하는 것이 좋을 것 같다.

어차피 면접에서 모든 질문에 대답하는 사람 한명도 없다고 생각한다. (특히나 인턴십 면접에서..)

누가 더 솔직하게, 조리있게, 깊게 질문에 리시브를 하느냐가 관건이지 싶다.

중간에 대답 많이 못했다고 주눅들지 말고 면접 1시간 끝까지 멘탈 잡았으면 한다.

~~지나고나니 말로는 쉽지 막상 그상황에서는 멘붕이였다~~

두서없이 적어서 의식의 흐름대로 써내려 간것 같은데

그래도 누군가에게 조금이라도 도움이 되었으면 좋겠다.

끝.

인턴십 후기 : https://source-sc.tistory.com/70

[3][면접] 2021 카카오 채용연계 여름 인턴십 for Tech Developers - 면접 후기

Source — Fri, 4 Jun 2021 15:31:40 +0900

인터뷰 준비

직무와 관련된 면접이 처음이였기에 다른 면접 후기들을 보면서 면접 준비를 했다.

크게보면

코딩테스트 리뷰
자기소개서 기반 프로젝트 정리
CS 지식

이였다.

코딩테스트 리뷰

당시 총 5문제중 3문제를 해결하였고, 한문제는 풀다가 포기했었다.

풀었던 문제중 2문제는 간단한 문제여서 작성했던 코드를 다시 보는 정도로 마무리했다.

세번째 문제에서는 시간을 많이 소요했고 조금 복잡해서 작성했던 로직을 다시 살펴보고 오래 걸린 이유에 대해 정리했다.

풀다가 포기했던 문제는 물어보지는 않을 것 같아서 따로 정리하지 않았다.

자기소개서 기반 프로젝트 정리

자소서에 이런저런 프로젝트들을 써놨는데 막상 그 프로젝트들이 진행한지 오래되어서 생각이 잘 나지않아 기억을 더듬어가며 정리했다.

사용했던 프레임워크에 대해서 동작원리부터 사용이유, 하면서 어려웠던 점들을 정리했다.

CS 지식

CS 와 관련된 지식들은 잘 정리된 깃허브들이 많아서 그곳들을 참고했다.

참고했던 깃허브는 다음과 같다.

https://github.com/JaeYeopHan/Interview_Question_for_Beginner

JaeYeopHan/Interview_Question_for_Beginner

:boy: :girl: Technical-Interview guidelines written for those who started studying programming. I wish you all the best. :space_invader: - JaeYeopHan/Interview_Question_for_Beginner

github.com

https://github.com/WeareSoft/tech-interview

WeareSoft/tech-interview

:loudspeaker: tech interview. Contribute to WeareSoft/tech-interview development by creating an account on GitHub.

github.com

프로젝트 중에 자바와 관련된 프로젝트들은 없어서 자바나 스프링에 대해서는 따로 공부하지 않았다.

운영체제 (OS)
네트워크
데이터베이스
자료구조
알고리즘

이 5가지 위주로 공부했다.

면접 D-1

면접날이 다가오면서 전혀 떨리지 않았는데 전날오후부터 갑자기 떨리기 시작했다.

지금 준비해봤자 이미 늦었다 라는 생각과, 지금 정리한 내용을 내일 물어볼 수도 있다는 생각이 대립하면서 침대와 책상을 오갔다.

오전 10시 면접이였기에 아침에 일찍 일어나기 위해 일찍 자려고 했다.

그러나 너무 일찍 9시에 잠이 들었다. 결국 3시간뒤에 잠에서 깼고 마지막 정리를 하다가 다시 잠에 들었다.

면접 1시간전

전날보다 더 떨렸다. 시간이 다가올수록 더 떨렸다.

오프라인이 아닌 온라인이여서 긴장이 많이 안될줄 알았는데 오산이였다.

에버랜드에서 T-express를 타기 전 내 앞 열차가 출발한 느낌이였다.

마지막으로 내용 정리한 후 마이크와 스피커 상태와 인터넷 상태를 체크했다.

면접 시작

사전 안내에는 면접관이 2명이상이라고 나와있었다.

구글 미팅에 들어가보니 네분이 계셨다.

한 두세분정도 계시면 좋을 것 같다 생각했는데 시작부터 쉽지 않았다.

면접 진행은 면접을 준비했던 과정과 비슷했다.

간단히 자기소개한 뒤, 코딩 테스트를 본인이 본 것이 맞는지 확인을 위한 간단한 리뷰를 진행했다.

실제로 자신이 코딩 테스트를 본것이 맞는지 확인하는 것이기 때문에 웬만한 질문에는 대답할 수 있었다.

이후에는 네분이 번갈아가시면서 질문을 하셨다.

면접을 보기 전에는 CS관련해서 모두 물어본 후 프로젝트 관련해서 물어보는 줄 알았는데, 큰 구분이 없었다.

CS에 대해서 질문하시다가 다른분이 프로젝트 질문하시기도 하였고, 프로젝트 관련해서 이야기를 하다가 관련된 CS지식을 여쭈어보시기도 하였다.

들어봤는데 자세히 모르는 내용도 있었고, 별로 중요하지 않아보여서 공부하지 않는 내용을 질문하시기도 했다.

또 프로젝트나 공부했던 일반적인 CS 지식이 아닌 컨테이너에 대한 질문도 있었다.

단순한 이론적인 공부를 했는지보단, 실제로 서버와 관련해서 개발을 했었는지를 확인하는 것 같은 느낌을 받았다.

대답을 한 질문들도 많았지만 답변을 하지 못한 질문들도 있었다.

"잘 모르겠습니다.." 라는 말을 한 10번은 한 것 같다.

모르겠다고 말 한 뒤 흐르는 몇초의 정적이 몇시간처럼 길게만 느껴졌다.

마치 과거의 흑역사를 남들에게 공개하는 기분이 들었다.

그나마 아는 내용의 질문이 나오면 조금이나마 안심하면서 대답했다.

정신없이 대답을 하던중 시간을 보니 30분이 지나있었다.

이미 지쳐있었고 남은 30분은 또 어떤 무서운 질문들이 나올지 두려웠고, 빨리 끝났으면 좋겠다는 생각을 했다.

45분쯤 지났을까 질문이 끝나고 내게 질문 시간이 주어졌다.

미리 준비해온 두가지 질문을 했다.

하나는 조직내의 갈등에 관련된 질문이였고, 하나는 앞으로의 공부방향에 대한 질문이였다.

사실 전자의 질문의 경우 이미 면접때 나에게 들어왔던 질문이였다.

그 질문은 사실 면접 전부터 미리 생각해 온것이고, 지금도 정답을 찾고있는 질문이였다.

면접관님들의 답변을 듣고나니 조금이나마 해답을 얻은 것 같았다.

준비해온 질문도 모두 끝나고 면접이 종료되었다.

면접 종료

이번 면접을 보고 느낀점은

"정말 아직 많이 부족하다"

였다.

기본적인 CS 지식들부터 시작해서 결과적으로 백엔드와 관련된 프로젝트 경험이 적었다.

면접을 보기 전까지만 해도 붙었으면 좋겠다는 생각이 많았는데, 막상 보고나니 앞으로 더 공부해야겠다는 생각이 더 많이 들었다.

마지막 이야기 : https://source-sc.tistory.com/65

[2][서류전형] 2021 카카오 채용연계 여름 인턴십 for Tech Developers - 자기소개서 작성

Source — Thu, 27 May 2021 16:41:02 +0900

서류 전형

코딩 테스트에 합격을 한 후, 서류전형을 위해 자기소개서를 작성하였다.

고등학교 때 종합전형을 위해서 자소서를 작성해보고 대학교에서 수업시간에 간간히 작성해본게 전부라 실전에서 취업을 위한 자기소개서 작성은 처음이였다. 굳이 따지자면 공채가 아닌 인턴십이긴하지만..

대학교 입학 할 때부터 지금까지 해왔던 것들 중에 어떤 내용을 쓸지 고민했고, 나름 얻은것이 많았다고 생각하는 프로젝트와 경험들을 적었다.

최대한 간결하면서 핵심은 드러나되, 과장되지 않도록 작성하려고 노력했다.

자소서를 작성하면서 느낀점

자소서를 작성하면서 지금껏 해왔던 프로젝트들을 보니 아쉬움이 많았다.

해당 프로젝트마다 github에서 제대로 관리가 되어있지 않은 프로젝트들도 있었고, 최종 결과물을 정리해놓지 않아서 product를 보기 힘들었다. 또한 그당시 사용했던 기술들을 따로 정리해두지 않아서 해당 프로젝트를 했다는 경험은 있지만 남은것이 많지 않은 것 같아서 아쉬웠다.

내가 만약 100만큼의 프로젝트를 했다면, 프로젝트 자체만 수행하고 나면 나중에 타인에게 프로젝트를 설명할 때 60정도 밖에 못보여주는데 그당시 조금 귀찮더라도 이런저런 설명들을 함께 정리했다면 100만큼 보여줄 수 있었을 것 같다는 생각이 들었다.

그리고 지원한 분야와 관련된 토이프로젝트를 하나 했었으면 더 좋았겠다 라는 생각도 들었다.

결과

원래 예정 발표일은 수요일이였는데 하루 일찍 결과가 나왔다.

코딩테스트 경험삼아 지원한 인턴십에 서류까지 붙다보니 꿈인가 싶었다.

내가 지원했던 server 와 관련없는 내용들이 많았는데 다양한 경험들을 한 점에서 플러스가 되었지 않았나 싶다.

면접 진행은 일주일간 진행되는데 자소서에 쓴 내용들중에 다시 봐야할 부분들이 많았기에 최대한 마지막날 쯤에 인터뷰 일정이 잡혔으면 했는데 운좋게도 가장 마지막 날에 잡혀 약 10일간의 준비기간이 생겼다.

github 한번 정리하고 그간 해온 프로젝트들과 cs지식들을 검토해서 인터뷰를 준비할 계획이다.

기왕 이렇게 된거 면접까지 붙었으면 좋겠다.

제발..!

다음 이야기 : https://source-sc.tistory.com/64

[1][코딩테스트] 2021 카카오 채용연계 여름 인턴십 for Tech Developers - 코딩 테스트 후기

Source — Mon, 17 May 2021 00:06:18 +0900

생애 첫 코딩테스트

대학교 1학년때 교내 프로그래밍대회에서 운좋게 수상하여 네이버 D2에서 주최하는 프로그래밍대회 본선에 나간적이 있었는데 그당시에는 알고리즘이 무엇인지도 몰랐고 코딩을 시작한지 반년도 채 되지않은 나에겐 너무나도 어려웠다.

~~당연히 등수는 아래부터 찾는것이 빨랐다.~~

그동안 알고리즘 공부를 많이 해오면서 실제로 기업의 코딩테스트를 본적은 없었는데 이번 카카오가 그 첫번째 코딩테스트였다.

사실 이번 카카오 여름 인턴십은 코딩테스트를 경험해보고 싶어서 지원한 것도 있었다.

시험날짜는 2021년 5월 8일 오후2시.

4시간동안 진행되었고 총 5문제가 출제되었다.

문제 보러가기

1번 문제

영어 알파벳으로 숫자를 받아서 해당 문자를 매칭되는 숫자로 변환해주는 문제였다.

예를 들어 onetwothree 라는 입력이 주어지면 123 을 리턴하는 형식이다.

들어온 문자열과 문자를 비교해서 숫자로 변환해주면 되는 간단한 문제였다.

백준 티어로보면 브론즈1,2 ~ 실버4,5 이지 않았을까 싶다.

2번 문제

이번 코로나 거리두기와 관련된 문제였다.

5x5 배열에서 사람, 책상, 빈공간이 주어지고 각 사람마다 2칸이상 떨어져야 거리두기를 잘했다고 할때 주어진 케이스들의 거리두기 여부를 문자열로 출력하는 문제였다.

BFS를 이용하면 되는문제로 어렵지 않았다. Input size도 5 by 5 로 크지않아 별다른 최적화 없이 진행했다.

백준 티어로 보면 실버1,2~골드4,5 정도 였던것 같다.

1,2번까지는 각 10분, 30분으로 총 40분만에 해결하였다.

3번 문제

여기부터가 문제였다.

1차원 구조에서 특정 셀을 선택하고 이동할수 있으며, 해당 행을 삭제할수 있고 최근에 삭제한 행을 다시 복구할수 있을때 주어진 명령어들을 수행한 뒤 사라진 행을 구분하는 문제였다.

행들이 중간중간 비어있을 수 있고 다시 복구할 수도 있기에 인접리스트를 사용하였다.

그리고 복구는 가장 최근에 삭제된것부터 진행되기에 stack구조를 사용하였다.

해당 문제는 정확성과 효율성을 모두 보는 문제였는데 정확성부분에서는 통과를 했는데 효율성 부분에서 계속 통과를 하지 못했다.

아무리 살펴봐도 로직상에서 시간초과가 나올 수 있는 부분이 없었다.

코드를 살펴보던중 의심될만한 부분은 최종 정답 배열을 만드는 부분(string + char) 이였다.

이부분을 append로 바꾸었더니 효율성도 통과를 하였다. 이부분에서 거의 1시간넘게 헤맨것 같은데 그래도 풀었다는 안도감과 사소한것에 오랜시간을 쓴것에 대한 허탈함도 있었다.

이문제는 골드1~2정도로 예상한다.

4,5번 문제

그리고 남은 약 1시간동안 4,5번을 풀어보려고 했으나 문제가 쉽지 않았다.

5번문제는 내가 풀 수준이 아님을 직감하고 그나마 자신있는 문제였던 4번 그래프문제에 도전하였다.

하지만 4번문제도 쉽지않았다.

결국 1,2,3번 문제만 해결한 채 코딩테스트가 종료되었다.

코딩테스트 종료

보통 알고리즘 문제를 풀면 길게는 2시간 이상 걸리기도 하는데 스트레이트로 4시간동안 알고리즘 문제를 풀어본 적은 없어서 과연 4시간동안 집중을 유지할 수 있을까 걱정도 있었다.

만약 혼자서 푸는 알고리즘 문제였다면 4시간 집중을 유지하기 어려웠을텐데 코딩테스트라는 특별한 환경이여서 4시간이 짧게만 느껴졌다.

그리고 3번 문제에서 많은 시간을 날렸다는 안타까움과 4번문제를 해결하지 못했다는 아쉬움이 남았다.

알고리즘 공부를 아주 많이 해온것은 아니였지만 그래도 그동안 문제들을 풀면서 4번문제정도면 충분히 도전해 볼 만한 수준이라고 생각했다.

앞으로 더 많은 문제들을 풀어보고 연습해야겠다는 생각이 들었다.

결과

코딩테스트를 본 뒤 약 1주일뒤 5월 14일 오후쯤에 코딩테스트 결과가 나온다고 공지가 있었다.

사실 이번 코딩테스트 커트라인이 3~3.5일것이라고 예상했다.

(4,5번 솔직히 좀 어려웠다.)

오후부터는 메일창을 계속 확인했던 것 같다.

그리고 메일이 도착했다.

기대를 안했다고 하면 거짓말이고 그래도 떨어졌을 확률이 더 높다고 생각했는데 운좋게 합격하였다.

그래도 2020년 초부터 지금까지, 꾸준히는 아니여도 알고리즘 공부에 적지않은 시간을 투자해 왔었는데 첫 코딩테스트에서 떨어지면 어떡하지 라는 걱정이 많았는데 참 다행이다.

지금까지 투자해왔던 시간이 그래도 배신은 안한것 같다.

이제 서류와 면접이 남아있는데 잘 준비해서 좋은 경험을 쌓아보고 싶다.

다음 이야기 : https://source-sc.tistory.com/63

[투 포인터 알고리즘][1] - 개요 및 백준1806번

Source — Wed, 24 Mar 2021 13:32:38 +0900

투 포인터 알고리즘(Two Pointer Algorithm)

투 포인터 알고리즘은 선형자료구조에서 특정부분집합을 빠르게 찾아낼때 사용된다.

예를 들어 다음 문제를 보자.

백준 1806번 - 부분합

위 문제같은 경우 N = 100000 일때 모든 부분합의 개수는 N^2 으로 많은 시간이 소요된다.

그렇다고 메모이제이션을 하기에는 부분합인 S의 범위가 1억이하이므로 메모리상으로도 초과가 발생한다.

이때 사용할 수 있는 알고리즘이 투 포인터 알고리즘 이다.

다음과 같은 배열에서 합이 10이상이되는 가장 짧은 길이를 구해보자.

먼저 우리가 찾을 부분배열의 시작 인덱스를 start, 마지막 인덱스를 end라고 하자.

처음에는 두값모두 0이다.

이후 현재 부분배열의 합이 S(10) 이상이 아니라면 end++ 하여 진행한다.

end가 2가 되었을때 부분합이 10이상이 되었다.

현재까지의 최소길이는 3이며 이후부터는 end값과 동시에 start값도 같이 늘려준다.

위의 붉은 네모박스를 한칸씩 오른쪽으로 이동한다고 보면 된다.

또한 한번 이동한 후 아래와같은 로직으로 반복한다.

if ( start 에 있는 값을 뺐을때 S이상이 되는가? )

True-> start값을 빼고 최소길이 최신화 및 start++ -> if문으로 다시이동

False -> start++ end++

아래와같은 경우 위의 로직에서 True에 해당되며 최소길이가 갱신된다.

이렇게 진행하게되면 최소길이가 1이라는것을 알아낼수 있다.

이 알고리즘의 시간복잡도는 2n으로 O(N)이다.

#include <iostream>

using namespace std;

int n,target;
int p[100001];

int main(){
    cin >> n >> target;
    for(int i=0;i<n;i++){
        cin >> p[i];
    }

    int minimum = 99999999; // 합이 S이상인 것중 가장 짧은 길이
    bool notFound = true;
    bool tmp = true;
    int total = 0;
    int s,e;
    s = 0;
    for(int i=0;i<n;i++){ // i 번째를 마지막으로 한 부분합
        if(notFound){ // 합이 S이상인것을 못찾았을때
            total = total + p[i];
            if(total >= target){ // 처음으로 합이 S이상인 것을 찾았을때
                minimum = i-s+1;
                notFound = false;
            }
        }
        else{
            total = total - p[s] + p[i]; // 현재 길이가 x인것을 찾았는데 그 이후로는 길이가 x이상인것은 찾을 필요가 없다.
            s = s + 1;
        }
        if(total >= target){ // 만약 minimum 개씩 합을 확인하다가 타겟보다 커지면
            tmp = true;
            while(tmp){ // 가장 왼쪽부터 하나씩 빼면서 최소길이를 구한다.
                if(total - p[s] >= target){
                    total = total - p[s];
                    s = s + 1;
                    minimum = minimum - 1;
                }
                else{
                    tmp = false;
                }
            }
        }
    }
    if(minimum >= 99999999){
        cout << 0;
    }
    else{
        cout << minimum;
    }
}

Q. 투 포인터 알고리즘이 과연 모든 경우의수를 고려했다고 볼 수 있나?

위 알고리즘에 따르면 end값은 인덱스 0부터 n-1 까지 진행된다.

다르게 생각하면 한 Loop를 돌때마다(end값이 증가될때마다 하나의 Loop라고 가정) end값을 인덱스로 할때 길이가 S이상이 되는 최소길이를 구한다고 생각할 수 있다.

모든 경우의 수들은 항상 end를 마지막 인덱스로하는 집합에 속하므로 모든 경우의수를 고려한다고 볼 수 있다.

또한 처음으로 S이상이 되는 부분합을 찾았을 때 그 이후로 start 와 end 값을 동시에 ++하는 이유는 이미 합이 S이상이 되는 길이 k를 찾았는데 굳이 end값만 ++해서 길이가 k+1 이 되는 경우는 굳이 고려할 필요가 없기때문이다. 따라서 이미 길이가 k인 부분합을 구했으면 계속 k기준으로 부분합을 구하다가 더 짧아질수 있다면 길이를 최신화하는 방향으로 진행한 것이다.

[탐욕 알고리즘][2] - 회의실 배정 문제

Source — Wed, 17 Mar 2021 02:52:34 +0900

유명한 Greedy 알고리즘 - 회의실 배정 문제

백준 1931 - 회의실 배정

회의실 배정 문제는 그리디 알고리즘에서 빠지지 않고 등장하는 문제이다.

이문제는 각 회의마다 시작시간과 종료시간이 정해져있고 하나의 회의실에 대해 가장 많은 회의를 진행하게 하고 싶을때 그 개수를 구하는 문제이다.

이 문제에서의 최종 목표는 최대한 많은 회의를 진행시키는 것 이다.

여기서 조건은 회의마다 시작시간과 끝나는시간이 정해져있다는 것과, 두 회의간 겹쳐서는 안된다는 점이다.

Think1. 가장 짧은 회의들 먼저 진행시키면 되지않을까?

굉장히 Greedy한 접근법이다.

최대한 많은 회의를 진행시키려면 결국 회의시간이 짧은 회의들을 골라서 넣는것이 최적의 해를 만들어 줄것같다.

과연 그럴까?

위와같이 a~g까지 7개의 회의들이 있다고 가정해보자.

여기서 위의 방법대로라면 아래와같이 회의시간이 가장 짧은 순서대로 골라서 g -> a -> d 순으로 회의를 골라서 진행할 것이다.

그러면 총 3개의 회의를 진행할수 있게된다.

하지만 아래와같이 선택하면 4개의 회의를 진행할 수 있다.

따라서 이 방법은 항상 최적의 해를 구해줄수 없다.

Think2. 가장빨리 끝나는 회의부터 넣으면 어떨까?

이것 또한 굉장히 Greedy한 접근이다. 위의 예시를 이방법으로 접근해본다면

가장 빨리 끝나는 회의가 a이므로 a 회의를 선택한다.

이후 빨리끝나는 회의는 b지만 a와 겹치므로 다음으로 빨리끝나는 회의인 c,d중 하나를 고르는데 끝나는 시간이 같을경우 더 늦게시작하는 회의를 고르도록 하자 (이 이유는 뒤에서 다루도록하자)

그리고 다음으로 빨리끝나는 회의인 f를 선택하고 마지막으로 g 회의를 선택하게 된다.

총 4개의 회의를 진행할수 있게되었고 주어진 상황에 있어서 최적의 해이다.

Proof. 해당 접근법에 대한 증명

과연 이 해가 도출된 것이 우연일까 아니면 항상 최적의 해를 도출해낼까?

만약 아래와같이 전체 회의 시간이 있고 가장 빨리 끝나는 회의가 k에 끝나는 회의라고 하자.

이 회의를 진행하게 되면 앞으로 우리는 하늘색 영역에 있는 시간들만 이용할수 있게된다.

그런데 만약 k보다 늦게 끝나는 회의를 먼저 잡으면 어떻게 될까?

아래와 같이 k'에 끝나는 회의를 선택하게 되면 회의에 사용할수 있는 시간이 적어진다.

k에 끝나는 회의를 고르는것이 k'에 끝나는 회의를 고르는것보다 최적의 방법이라는 것을 반박하기 위해서는 L이라는 남은 시간보다 L'라는 남은시간에 회의들을 배치하는것이 더 많은 회의를 넣을 수 있다는 것을 증명해야한다.

과연 같은 회의목록들을 가지고 더 적은 타임에 많은 회의들을 넣는것이 가능할까?

당연히 불가능 하다.

따라서 항상 가장 빨리 끝나는 회의를 선택하는것이 최적의 해를 도출해낸다고 볼수 있다.

구현.

이를 구현하기 위해서는 먼저 빨리 끝나는 회의들을 구하기 위해 우선순위 큐(priority queue) 를 이용하였다.

또한 위에서 끝나는 시간이 같을 경우 시작시간이 짧은것부터 회의에 넣는다고 했는데 그 이유는 문제에서 "회의의 시작시간과 끝나는 시간이 같을 수도 있다" 라는 조건 때문이다.

만약 5-10 까지 진행되는 회의와 10-10까지 진행되는 회의가 있다면

- 10-10 회의를 먼저 진행하면 5-10 회의를 진행할수 없지만

- 5-10 회의를 먼저 진행하면 10-10 회의를 진행할수 있기때문이다.

따라서 아래와 같이 구현할수 있다.

구현언어 : C++

#include <iostream>
#include <queue>
#include <utility>


using namespace std;

int n;

struct Sub{
    int start;
    int end;
};

struct cmp{
    bool operator()(Sub a, Sub b){
        if(a.end == b.end){ // 종료시간이 같을 경우 시작시간이 작은것부터
            return a.start > b.start;
        }
        return a.end > b.end; // 종료시간이 빠른것부터
    }
};

priority_queue<Sub, vector<Sub>, cmp> pq;


int main(){
    int tmp1,tmp2;
    cin >> n;
    Sub sub;
    for(int i=0;i<n;i++){
        cin >> tmp1 >> tmp2;
        sub.start = tmp1;
        sub.end = tmp2;
        pq.push(sub);
    }

    int end = 0;
    int tot = 0;

    while(pq.size() > 0){
        sub = pq.top();
        if(end <= sub.start){ // 현재 꺼낸 회의가 현재 가장 최근에 종료된 회의 이후일때
            tot++;
            end = sub.end;
        }
        pq.pop();
        
    }
    cout << tot;
}

[탐욕 알고리즘][1] - 개요

Source — Wed, 17 Mar 2021 02:06:02 +0900

탐욕 알고리즘(Greedy Algorithm)

탐욕 알고리즘(이하 그리디)은 어떤 문제를 해결할때 모든 경우의 수를 전부 고려하지 않고 항상 최적이 되는 것만 골라서 진행해나가는 알고리즘을 의미한다.

모든 경우의 수를 전부 고려해서 최적의 해를 계산해내는 dynamic programming과는 다르다.

그렇다면 두가지 의문이 들수있다.

1. 항상 최적의 해만 골라서 탐색하면 지금까지 왜 dynamic programming으로 모든 경우의 수를 분석했나?

왜냐하면 그리디 알고리즘으로 모든 문제를 해결할 수 있는것이 아니기때문이다.

현재 상황에서는 가장 최적의 해라고 생각했지만 이후에 상황에 따라 그때의 선택이 최선의 결과를 만들지 않을수도 있기때문이다.

2. 그렇다면 그리디 알고리즘은 최선일수도 있고 아닐수도 있는 찔러보기식 알고리즘인가?

다른 알고리즘으로 구현하였을때 시간복잡도가 굉장히 높게나올경우 그리디 알고리즘으로 대체하여 사용할수 있다.

(물론 그 해가 best 라고 장담할수는 없지만 그래도 나름 최적화가 되어서 실용적으로 사용할 정도는 될수있다.)

또한 정확한 증명만 뒷받침되어있다면 최적의 해를 도출해 낼수도 있다.

Greedy 적인 접근(1)

그렇다면 Greedy하게 접근한다는 것이 무엇일까

아래 문제를 통해 살펴보자.

백준 1541번 - 잃어버린 괄호

이 문제는 아래와 같이 숫자와 + - 기호들로 이루어진 식이 주어졌을때 괄호를 자유롭게 사용해서 최종 결과가 최소가 되게 만드는 문제이다.

일반적인 dp 방법으로 해결하려 한다면 괄호를 사용할수 있는 모든 경우의 수를 계산해서 그중 가장 최소가 되는 답을 골라낼것이다.

그러나 Greedy한 접근에서는 모든 경우의 수를 고려하지 않고 각 상황마다 최적의 해를 도출하기 위한 액션을 취한다.

그러기 위해서는 먼저 문제에서 주어진 목적에 대해 잘 살펴봐야한다.

이 알고리즘의 최종 목표는 이 식의 값을 최소로 만드는 것이다.

그리고 주어진 조건들의 성질에 대해서도 잘 살펴봐야한다.

괄호의 경우 - 바로 뒤에 붙이면 그 이후 양수들을 모두 음수로 바꿀수있다.

위의 식에서 -10 에 괄호를 쳐서 40까지 묶으면 원래는 +40으로 계산될값이 -40으로 계산되어 더 최소값을 만들게된다.

바로 이 성질을 이용하여 일련의 조건들을 정하는 것이다.

condition. 음수 기호가 나올경우 해당 숫자부터 다음 음수기호가 나오기전 or 식의 끝까지 묶어준다.

위의 조건을 사용하게 되면 기존에 +로 계산될 값들이 -로 치환되어 최종적으로 값을 작게 만드므로 뭔가 야매? 스러운 방법처럼 되었다.

그렇다면 마지막으로 이러한 접근이 진짜 모든 경우에 있어서 항상 최적의 해를 만드는 조건인지 생각해보자.

문제에서는 양수기호와 음수기호가 주어진다. 최종 값을 만드려면 음수 기호들은 살리고 최대한 양수기호들을 음수기호로 바꾸어야한다.

음수 기호뒤에 나오는 모든 양수 기호들은 위의 조건에 의해 음수 기호로 바꿀수있다.

하지만 양수기호 이전에 음수기호가 없다면 아무리 괄호를 쳐도 그 기호를 음수로 바꿀수 없다.

즉 문제에서 우리에게 권한을 준것은 오로지 괄호를 치는것뿐이고 우리가 여기서 할수있는 것은 음수기호뒤에 있는 양수기호들을 모두 음수기호로 바꿔주는것이다.

따라서 이 방법이 항상 최적의 해(가장 최소가 되는값)를 만들어 줄것이라고 확신할수 있다.

Greedy 적인 접근(2)

다른 문제를 보자.

이 문제의 경우 알고리즘의 최종 목적은 각 사람이 돈을 인출하는데 필요한 시간의 합의 최솟값이다.

이런 문제의 경우 매우 극단적인 예시를 통해 그리디한 접근을 찾는것이 방법이 될수있다.

만약 5명이 사람이 있고 각각 인출하는데 필요한 시간이 1000분, 1분, 1분, 1분, 1분 이라고 하자.

그렇다면 인출하는데 1분이 걸리는 사람들이 먼저하고 마지막에 1000분이 걸리는 사람이 하는것이 시간의 합이 최소가 될지,

아니면 1000분이 걸리는 사람이 먼저 인출하고 나머지 1분이 걸리는 사람들이 인출을 할지

고민을 해보면 답이 나올것이다.

너무나 당연하게도 1분이 걸리는 사람들이 먼저 인출을 빠르게 마치고 마지막에 1000분이 걸리는 사람이 인출을 하는것이 시간의 합이 최소가 될것이다.

여기서 알수있는 접근법은 사람들의 인출시간을 오름차순으로 정렬한뒤 맨 앞부터 sum값을 sum하는것이다.

인출시간이 짧은 사람이 먼저 인출하는것에 대한 수학적인 증명도 간단히 할수있다.

위의 수식에 따르면 1번이 먼저 인출할때가 2번이 먼저 인출할때보다 k분을 절약할수있다.

[알고리즘][15][백준_2533] - 사회망 서비스

Source — Thu, 4 Mar 2021 12:34:56 +0900

이 문제에서 핵심이 되는 부분은

얼리 아답터가 아닌 사람들은 자신의 모든 친구들이 얼리 아답터일 때만 이 아이디어를 받아들인다.

이 부분이다.

이 말을 다르게 해석하면 결국 만약 자신이 일반인이라면 자신의 모든 친구들이 얼리어답터여야 함을 의미한다.

또한 만약 자신이 얼리어답터라면 자신의 친구가 일반인이던, 얼리어답터이던 중요하지 않다. 모두 가능하다.

정리하자면

얼리어답터 -> 얼리어답터 or 일반인
일반인 -> 얼리어답터

따라서 이것을 이용해 한정점에서 시작해 DFS로 순회하면서 위의 조건을 통해 최소의 얼리어답터 수를 구할 수 있을것이다.

만약 위와같은 트리로 전체적인 흐름을 파악해보자.

1번 정점부터 DFS를 수행한다고 할때 1번 정점에서 가능한 경우는 다음과 같이 두가지이다.

최종답은 두 경우중 얼리어답터가 더 적은 쪽이 될것이다.

[참고1,2] 1번이 얼리어 답터일때(좌측) 와 일반인일때(우측)

이후 3번 정점을 통해 dp를 어떻게 설계해야하는지 살펴보자.

a) 1번이 얼리어답터 일때

자신이 얼리어답터이므로 3번은 얼리어답터이거나(좌측 그림) 일반인이다(우측 그림).

2번도 마찬가지로 그 두경우 모두 가능하다.

[참고 3,4]

b) 1번이 일반인 일때

자신이 일반인이므로 3번은 반드시 얼리어답터여야한다.

2번도 마찬가지로 반드시 얼리어답터여야한다.

[참고 5]

중복 확인

이제 a,b 두 경우에서 각각 3번이 얼리어답터일때를 보자.

3번의 부모에서 부모가 얼리어답터건 일반인이건 상관없이 3번 이후로 (6,7,8)번의 선택에는 영향을 주지못한다.

따라서 두 경우 이후 최소가 되는 얼리어답터 수는 같을 것이고 이를 처리해주지않으면 중복호출로 시간복잡도가 증가한다.

따라서 해당 정점번호 + (얼리어답터 or 일반인여부) 를 가지고 메모이제이션을 해주면 중복을 해결 할 수 있다.

d[i][0] = i 번째 정점이 일반인 일때 이후 정점들의 최소 얼리어답터 수

d[i][1] = i 번째 정점이 얼리어답터 일때 이후 정점들의 최소 얼리어답터 수

코드 (C++)

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

int n;
vector<vector<int> > v;
int vt[1000002];
int dp[1000002][2];

int run(int now, int type){
    // now 정점을 type으로 했을때 최소값 리턴
    // type = 0 : 일반인 / 1 : 얼리어답터
    int next;
    int r1;
    int r2;
    int total = 0;
    int check = 0;

    if(dp[now][type] != -1){
        return dp[now][type];
    }

    for(int i=0;i<v[now].size();i++){ // 해당 정점에서 갈수있는 정점 모두 탐색
        next = v[now][i];
        r1 = 99999999;
        r2 = 99999999;
        if(vt[next] == -1){ // 다음노드가 아직 방문전이라면
            vt[next] = 1;
            if(type == 1){ // 현재 자신이 얼리어답터라면 다음 정점은 일반인이 될수있다.
                r1 = run(next,0);
            }
            r2 = run(next, 1); // 현재 자신이 일반인이던 얼리어답터건 다음 정점은 얼리어답터가 될수있다.
            vt[next] = -1;
        }
        if(!(r1 >= 99999999 && r2 >= 99999999)){
            if(r1 < r2){ // 다음 정점이 일반인, 얼리어답터 중에 더 적은 얼리어답터를 만든 경우를 계속 합산
                total = total + r1;
            }
            else{
                total = total + r2;
            }
        }
    }

    if(type == 1){ // 최종 최소치에 자신이 얼리어답터라면 본인도 포함
        total = total + 1;
    }
    dp[now][type] = total;
    return total;
}

int main(){
    int x,y;
    cin >> n;
    for(int i=0;i<=n;i++){
        v.push_back(vector<int>());
        vt[i] = -1;
        for(int j=0;j<2;j++){
            dp[i][j] = -1;
        }
    }
    for(int i=0;i<n-1;i++){
        cin >> x;
        cin >> y;
        v[x].push_back(y);
        v[y].push_back(x);
    }
    vt[1] = 1;
    int ans1, ans2;
    ans1 = run(1,0);
    for(int i=0;i<=n;i++){
        vt[i] = -1;
    }
    vt[1] = 1;
    ans2 = run(1,1);
    cout << min(ans1,ans2);
}

[5][그래프 이론] - 오일러 서킷, 한붓그리기 (Eulerian Circuit)

Source — Thu, 11 Feb 2021 15:33:02 +0900

1. 오일러 서킷 ( 한붓그리기)

오일러 서킷이란 한 정점에서 시작해서 모든 간선을 지나 시작 정점으로 돌아오는 것을 의미한다.

오일러서킷의 예 : 1번 정점에서 시작해 모든 간선을 순회한뒤 1번으로 돌아온다.

2. 오일러 서킷의 조건

정점들과 간선들이 주어졌을때, 해당 자료에서 오일러 서킷이 존재하는지 판단하려면 어떻게 해야할까?

오일러 서킷이 되기위한 2가지 조건은 다음과 같다.

1. 모든 간선들이 하나의 컴포넌트에 속해야한다.

2. 각 정점마다 간선의 수가 짝수개여야한다.

그 이유에 대해 하나씩 알아보자.

2-1. 모든 간선들이 하나의 컴포넌트에 속해야한다.

위와같은 경우 각 컴포넌트별로는 오일러서킷이 존재하지만, 전체 정점들로 보았을때는 컴포넌트간 순회 할 수 없기때문에 반드시 모든 간선들이 하나의 컴포넌트에 속해야한다.

2-2. 각 정점마다 간선의 수가 짝수개여야한다.

각 정점마다 간선의 수가 짝수여야한다는 의미는 위의 그림처럼 2번 정점에서 뻗어나간 간선이 4개인것 처럼 모든 정점에 대해 뻗어나간 간선들의 개수가 짝수개여야 한다는것이다.

그 이유는 간단하다. 만약 아래와같은 그래프가 있고 u 정점에서 출발해서 v정점을 경유하는 경우라고 생각하자.

중간의 간선들을 통과하다가 1번 정점에서 v로 들어간 후

v 정점에서 나와 2번 정점으로 간다.

이후 다시 3번 정점에서 v정점으로 들어가면, v정점에서는 다시 나올수가 없다. 따라서 시작 정점인 u 정점으로 돌아갈수 없고 오일러 서킷을 만족시키지 못함을 알수있다.

따라서 그래프내에 속한 어떠한 하나의 정점이라도 연결된 간선의 수가 홀수개면 한번 들어간 후 나올수 없으므로 오일러 서킷을 만족시키지 못한다.

따라서 모든정점에 있어서 연결된 간선의 수가 짝수여야한다.

3. 구현

오일러 서킷은 DFS로 간단하게 구현할 수 있다.

아직 방문하지 않은 간선들을 2차원 배열에 저장해놓고 DFS를 수행하면서 모든 간선을 방문했을때 오일러 서킷을 발견할 수 있다.

아래와같이 구현하게 되면 모든 오일러서킷을 구할 수 있다.

+ 오일러 서킷은 방향이 없는 그래프이므로 하나의 간선 (a,b)가 존재한다면 (b,a)도 존재한다.

#include <iostream>
#include <vector>
#include <stack>

using namespace std;

int n,k;
int v[101][101];
stack<int> s;
stack<int> answer;


void euerian_circuit(int start){
    if(k == 0){ // 오일러서킷 발견했을때
        answer = s;
        while(answer.size() > 0){
            cout << answer.top() << " ";
            answer.pop();
        }
        cout << start << endl;
    }
    else{
        for(int now = 0; now < n; now++){
            if(now != start && v[start][now] > 0){ 
                // 현재정점과 이동할 정점이 같지않으면서 해당 목적지 정점으로 남은 간선이 존재할때
                k--;
                v[start][now]--;
                v[now][start]--;
                s.push(now);
                euerian_circuit(now);
                k++;
                v[start][now]++;
                v[now][start]++;
                s.pop();
            }
        }
    }
}

int main(){
    int x,y,start;
    cin >> n; // 정점개수
    cin >> k; // 간선개수
    cin >> start; // 시작정점
    
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            v[i][j] = 0;
        }
    }

    for(int i=0; i<k; i++){
        cin >> x;
        cin >> y;
        v[x][y] = v[x][y] + 1; 
        v[y][x] = v[y][x] + 1; 
    }


    euerian_circuit(start);
}

/*
input 

5
7
1
0 1
0 2
1 2
1 3
2 3
1 4
2 4

output
1 4 2 3 1 2 0 1
1 3 2 4 1 2 0 1
1 4 2 1 3 2 0 1
1 2 4 1 3 2 0 1
1 3 2 1 4 2 0 1
1 2 3 1 4 2 0 1
1 4 2 3 1 0 2 1
1 3 2 4 1 0 2 1
1 4 2 0 1 3 2 1
1 0 2 4 1 3 2 1
1 3 2 0 1 4 2 1
1 0 2 3 1 4 2 1
1 4 2 1 0 2 3 1
1 2 4 1 0 2 3 1
1 4 2 0 1 2 3 1
1 0 2 4 1 2 3 1
1 2 0 1 4 2 3 1
1 0 2 1 4 2 3 1
1 3 2 1 0 2 4 1
1 2 3 1 0 2 4 1
1 3 2 0 1 2 4 1
1 0 2 3 1 2 4 1
1 2 0 1 3 2 4 1
1 0 2 1 3 2 4 1
*/

[알고리즘] [14][백준_11724] - 연결 요소의 개수

Source — Sun, 31 Jan 2021 23:11:34 +0900

1. 문제이해

주어진 정점과 간선으로 그래프를 만들었을때 서로 이어져있는 그래프의 집합이 몇개인지를 구하는 문제이다.

2. 알고리즘 전략

문제 자체는 간단하지마 한가지 고려해야 할 사항은 그래프를 표현할때 다음과 같이

1. 2차원 배열로 나타낼수도 있고

2. 벡터를 사용하여 정점과 그 간선의 연결상태만

나타낼 수 있다.

위 문제의 경우 정점의 개수가 최대 1000개 이므로 배열의 크기는 1000*1000*4byte(int)로 약 400MB정도 되어 문제에서의 최대 메모리인 512MB보다는 작지만, 아마 프로그램 실행을 위한 기본 메모리값으로 인해, 최대 메모리인 512MB를 넘어 메모리초과가 발생한다.

따라서 벡터를 이용해서 각 정점들과 이어진 정점들만 넣어 구현하고,

1차원 배열을 만들어 방문한 정점은 체크해두면서 그래프 순회를 하면된다.

#include <iostream>
#include <utility>
#include <vector>

using namespace std;

int t,m,n,k;
int Count = 0;
vector<vector<int> > v;
int graph[1001];
// graph[x] = 1 -> 아직 방문 안한 상태
// graph[x] = 0 -> 방문 한 상태

void sub_loop(int now){
    for(int i=0;i<v[now].size();i++){
        if(graph[v[now][i]] == 1){
            graph[v[now][i]] = 0;
            sub_loop(v[now][i]);
        }
    }
}

void main_loop(){
    for(int i=0;i<n;i++){
        if(graph[i] == 1){
            Count++;
            graph[i] = 0;
            sub_loop(i);
        }
    }
}

int main(){
    int tmp1, tmp2;
    cin >> n;
    cin >> m;
    for(int i=0;i<n;i++){
        v.push_back(vector<int>());
        graph[i] = 1;
    }

    for(int i=0;i<m;i++){
        cin >> tmp1;
        cin >> tmp2;
        v[tmp1-1].push_back(tmp2-1);
        v[tmp2-1].push_back(tmp1-1);
    }

    main_loop();
    cout << Count;
}

[알고리즘][13][백준_2618][c++] - 경찰차

Source — Fri, 29 Jan 2021 00:35:16 +0900

1. 문제 이해

경찰차 문제는 (1,1), (n,n) 에 위치한 경찰차 두대가 w개의 사건들을 가장 짧은 거리를 이동하여 처리하는 문제이다.

주의해야할 부분은 한 경찰차가 하나의 사건을 처리한후 다시 원래자리로 돌아가는 것이 아니라 그 자리에서 다음사건을 처리하게 되고,

사건들은 같은 장소에서 여러번 일어날 수 있다는 점이다.

2. 알고리즘 전략

먼저 문제의 예시를 통해 시나리오를 분석해보자.

경찰차는 (1,1) 그리고 (6,6)에 위치해있고 3개의 사건이 분포되어있다.

만약 첫번째 사건을 처리한다고 가정해보자.

위와같이 1번 경찰차가 6칸을 이동하여 1번 사건을 처리할수도 있고,

2번 경찰차가 4칸을 이동하여 1번 사건을 처리할수도 있다.

그렇다면 총 몇번 시도를 해봐야 모든 경우의 수를 다 탐색해 볼 수 있을까.

각 사건마다 두개의 경찰차중 하나가 사건을 처리할수 있으므로

위와같이 한 사건마다 2개의 가지로 분리될것이다.

따라서 w개의 사건이 있다면 총 2^w 개 만큼의 경우의 수가 생긴다.

문제에서 w의 범위가 1 <= w <= 1000 이므로 만약 w = 1000일때

최대 2^1000 가지의 경우의 수가 발생하므로 모든 경우를 brute-force로 해보는것은 불가능하다.

이 문제에서 DP를 적용할 수 있는 부분은 어디일까?

위 문제를 조금 간소화 시켜보자.

위는 10개의 사건을 처리할수 있는 경우의 수 중 하나를 나타낸 표이다.

간단히 설명하자면 1번 사건은 1번경찰차가 처리하였고,

2번 사건 역시 1번 경찰차가 처리하였다.

그리고 3번 사건은 2번 경찰차가 처리하였고...

이런식으로 진행되는 경우의 수 이다.

그렇다면 여기서 만약 5번 사건까지 파악을 했다고 하자.

그렇다면 6~10번까지의 사건이 아직 배정되지 않은 상황이다.

그리고 경찰차가 배정된 사건묶음을 초록박스로, 배정되지 않은 묶음을 노란 박스로 표시하였다.

이렇게되면 초록박스의 경우의 수는 2^5 개가 되며, 노란박스의 경우의 수도 역시 2^5이 된다.

따라서 총 경우의수는 2^5 * 2^5 = 2^10 임을 알수있다.

이 경찰차 문제에서 가장 중요한 포인트중 하나는 현재 진행 상태를 각 경찰차들의 마지막으로 맡은 사건으로 표현할 수 있다는 점이다.

위와같은 경우 1,2,4,5 번사건을 1번 경찰차가, 3번 사건을 2번 경찰차가 담당하였다.

이는 아래의 4가지 경우와 모두 동일하다.

즉 위 4가지 경우에 있어서 이후 6~10까지의 결과값은 모두 동일 할 것이므로 4번 모두 시행해 볼 필요가 없다.

왜 이것이 가능할까?

6번 사건에서 거리의 합에 영향을 받는 부분은 현재 경찰차1,2의 위치이다. 즉 그 위치는 각 경찰차가 마지막으로 맡은 사건의 위치이며 그 위치 이전에 어느 곳을 방문했는지는 이후의 사건에 영향을 주지 못한다.

따라서 2차원배열로 각 경찰차들의 최종 사건을 파라미터로 최소값을 저장하여 DFS에서 DP를 설계할 수 있을것이다.

이렇게되면 경찰차가 이동한 총거리의 최솟값은 구할수있다.

문제는 경찰차가 이동한 총거리 외에 경찰차들이 맡았던 사건들을 나열해야 한다는 것이다.

만약 위의 DP를 활용하여 최솟값과 해당 사건 처리 결과를 string이나 다른 형태로 저장한다고 해도

w^3 = 1000^3 바이트만큼의 메모리를 요구하며 128mb인 문제의 메모리 조건을 뛰어넘게 될것이다.

그래서 생각해 낸 방법은 모든 결과를 항상 누적해서 저장하지 않고 현재 경찰차들의 마지막 사건번호 x,y 를 통해 해당 x,y일때 이후에 최소거리를 만들수 있는 경찰차를 기록해 두는 것이다.

예를 들어 다음과 같은 상황을 가정해보자.

사건은 총 4개이며 현재까지 1번 사건을 1번 경찰차가, 2번 사건을 2번 경찰차가 수행했다고 가정할때, 이후 2번 경찰차가 3번 사건을 담당하는 것이 최소거리를 만든다고 하면 (1,2) 지점의 값은 2가 된다. # 배열에서 인덱싱은 0번부터지만 그림상 1번부터 하도록 하자

해당 지점에는 다음 사건을 담당해야 할 경찰차의 번호가 들어가야한다.

그리고 3번 사건을 2번경찰차가 담당한 후 4번째 사건을 담당해야 할 경찰차의 번호가 (1,3) 지점에 들어가야한다.

이같은 방법으로 DFS를 통해 뿌리까지 탐색하는 동안 minimum 값이 도출될때마다 현재 경찰차들의 마지막 담당 사건 번호 2가지로 이후 다음사건을 담당해야할 경찰차의 번호를 넣음으로써 최종적으로 모든 사건의 담당 경찰차 순서를 구할 수 있을것이다.

#include <iostream>
#include <utility>
#include <vector>
#include <algorithm>

using namespace std;

int n,w;
vector<pair<int,int> > p;
int store[1010][1010];
int police_store[1010][1010];
// 0 방문전

int calculate_distance(int police, int target, int start){
    // start : 
    // 0 : 두 경찰차 모두 1개이상의 사건을 담당하였다.
    // 1 : police가 1,1에 있다.
    // 2 : police가 n,n에 있다.
    int police_x,police_y,target_x,target_y;
    if(start == 1){
        police_x = 1;
        police_y = 1;
    }
    else if(start == 2){
        police_x = n;
        police_y = n;

    }
    else{
        police_x = p[police-1].first;
        police_y = p[police-1].second;
    }
    target_x = p[target-1].first;
    target_y = p[target-1].second;
    return abs(police_x-target_x) + abs(police_y-target_y);
}

int find_distance(int police1, int police2){
    /*
    두 경찰차가 현재 police1, police2 사건을 마지막으로 맡았을때
    이후로 최소 비용 출력
    ex) find_distance(3,5) 라고 하면
        이제 6번째 사건을 처리할 차례이므로
        첫번째 경찰차가 6번사건을 맡거나 = find_distance(6,5) + 3->6 거리
        두번째 경찰차가 6번사건을 맡아야한다. = find_distance(3,6) + 5->6 거리

        그리고 두 경찰차중 어느 경찰차가 움직여야하는 지를
        police_store[police1][police2]에 저장한다.(1 or 2)

    */


    // cout << police1 << " | " << police2 << endl;
    if(police1 == w || police2 == w){
        return 0;
    }

    int tmp1, tmp2, move;

    move = max(police1, police2) + 1;
    if(store[police1][police2] != -1){
        return store[police1][police2];
    }
    if(police1 == 0){
        tmp1 = find_distance(move,police2) + calculate_distance(police1, move, 1);
    }
    else{
        tmp1 = find_distance(move,police2) + calculate_distance(police1, move, 0);
    }
    if(police2 == 0){
        tmp2 = find_distance(police1,move) + calculate_distance(police2, move, 2);
    }
    else{
        tmp2 = find_distance(police1,move) + calculate_distance(police2, move, 0);
    }

    store[police1][police2] = min(tmp1,tmp2);

    if(tmp1 < tmp2){
        police_store[police1][police2] = 1;
    }
    else{
        police_store[police1][police2] = 2;
    }
    return min(tmp1,tmp2);
}

int main(){
    int tmp1,tmp2;
    cin >> n;
    cin >> w;
    for(int i=0;i<w;i++){
        cin >> tmp1;
        cin >> tmp2;
        p.push_back(make_pair(tmp1,tmp2));
    }

    for(int i=0;i<1010;i++){
        for(int j=0;j<1010;j++){
            store[i][j] = -1;
            police_store[i][j] = -1;
        }
    }

    cout << find_distance(0,0) << endl;

    int x = 0;
    int y = 0;
    
    for(int i=0;i<w;i++){
        cout << police_store[x][y] << endl;
        if(police_store[x][y] == 1){
            x = i+1;
        }
        else{
            y = i+1;
        }
    }
}

[4][그래프 이론] - 위상정렬 (Topological Sorting)

Source — Wed, 27 Jan 2021 14:54:51 +0900

올해로 20살이된 민수는 코로나 여파로 겨울방학임에도 불구하고 집에서 나갈 수 없어 옛 추억을 떠올리며 오랜만에 스타크래프트 게임을 시작했다.

평소에 프로토스 종족을 좋아하던 민수는 부푼마음으로 게임을 시작했지만 너무 오랜만에 하는 탓에 지어야 할 건물들의 순서를 몰라 난관에 부딪혔다.

스타크래프트 라는 게임에서는 각 종족마다 많은 건물들이 존재한다.

그러나 이러한 건물들을 게임을 처음 시작하면 바로 건설할수 없는 건물들이 있으며 이 건물들은 지정된 다른 건물들을 먼저 선행으로 건설해야 건설할 수 있다.

예를 들어 0번 건물을 짓기위해서는 1번건물을 지어야한다.

그런데 1번 건물을 지으려면 2번 건물을 지어야한다.

즉 2->1->0 의 순서로 건물을 지을 수 있다.

위와같은 건물의 순서도를 참고해서 10개의 건물을 모두 지을수 있게 민수에게 지어야 할 건물의 순서를 알려주도록 해보자.

위상정렬 (Topological Sorting) 이란?

위상정렬이라함은 방향이 있는 그래프에서 각 정점들의 방향을 거스르지 않게 나열하는 것을 의미한다.

앞선 예시처럼 의존성이 존재하는 건물들의 건설 순서를 구하는것도 결국 위상정렬의 하나의 예시로 볼 수 있다.

위상정렬 조건

위상정렬은 각 정점들의 방향을 거스르지 않게 나열해야하므로 그래프내에서 순환이 존재해서는 안된다.

만약

1. 밥을 먹기위해서는 돈이 필요하고,

2. 돈을 벌기위해서는 일을 해야하고,

3. 일을 하기 위해서는 밥을 먹어야한다고 하자.

이런 경우 3가지일을 순서가 위배되지 않게 정렬할수 없다.

만약 밥을 먹저 먹는다고 하면 밥을 먹었으니 일을 할수 있게되고, 일을 하면 돈을 벌수 있다.

하지만 애초에 밥을 먹으려면 돈이 있어야 하므로 뫼비우스의 띠처럼 끝없이 사전조건을 만족시키지 못하게 된다.

위상정렬 설계

위상정렬은 깊이 우선 탐색(DFS)을 이용하여 설계할 수 있다.

DFS를 통해 모든 정점을 방문하면서 더이상 방문할 정점이 없을때 스택에 해당 정점을 추가하는 과정을 반복하고

모든 정점을 순회한 뒤에 스택을 반대로 뒤집으면 위상정렬의 결과가 나온다.

다음은 위의 스타크래프트 건물의 예시를 c++로 작성한 위상정렬 코드이다.

#include <iostream>
#include <vector>
#include <stack>

using namespace std;

vector<vector<int> > graph;
stack<int> s;

int visited[10]; // 0 - 미방문 / 1 - 방문

void dfs_togological(int v){
    visited[v] = 1;
    for(int i=0; i<graph[v].size(); i++){
        if(visited[graph[v][i]] == 0){
            dfs_togological(graph[v][i]);
        }
    }
    s.push(v);
}

void dfs_all_topological(){
    for(int i=0;i<graph.size();i++){
        if(visited[i] == 0){
            dfs_togological(i);
        }
    }
}

void print_topological_sort(){
    int tmp;
    while(s.size() > 0){
        tmp = s.top();
        s.pop();
        cout << tmp << " ";
    }
}

int main(){
    for(int i=0;i<10;i++){
        graph.push_back(vector<int>());
        visited[i] = 0;
    }

    graph[1].push_back(0);
    graph[2].push_back(1);
    graph[2].push_back(3);
    graph[3].push_back(6);
    graph[6].push_back(5);
    graph[6].push_back(8);
    graph[6].push_back(9);
    graph[5].push_back(4);
    graph[8].push_back(7);
    graph[7].push_back(4);

    dfs_all_topological();
    print_topological_sort();
}

정렬 결과

결과적으로 아래와같은 위상정렬 결과를 얻게되고 아래와같은 순서로 건물을 짓는다면 문제없이 모든 10개의 건물을 건설 할 수 있을 것이다.

[3][그래프 이론] - 너비 우선 탐색 BFS (Breadth-First Search)

Source — Wed, 27 Jan 2021 11:33:06 +0900

너비 우선 탐색 BFS (Breadth-First Search)

너비 우선 탐색 (이하 BFS) 는 시작 정점에서 방문할 수 있는 정점들을 우선 방문한후, 이후에 그 정점들에서 방문 할수 있는 정점들을 방문 하는 탐색 방법이다.

예를 들어 위와같은 그래프에서 0번 정점으로 부터 BFS를 시행한다고 하면 ( 방문할수 있는 정점이 여러개라면 번호가 낮은 정점을 우선 방문한다고 가정 )

이전의 DFS에서는 1번 정점을 방문한뒤, 1번 정점에서 방문할 수 있는 2번 정점을 방문하였지만

BFS에서는 1번 정점을 방문한뒤, 바로 9번 정점을 방문한다.

이후 1번 정점에서 방문할 수 있는 2,5,7번 정점을 방문한 후, 9번 정점에서 방문할 수 있는 정점을 방문한다. ( 위 그래프 상황에서는 이미 9번과 연결된 7번 정점을 1번 정점에서 방문했으므로 방문하지 않는다 )

따라서 아래와 같이 방문을 하게된다.

아래에서

분홍색 정점은 현재 방문을 해서 해당 정점에서 다음 정점으로 방문을 해볼 필요가 있는 정점들이다.

노란색 정점은 이제 막 방문한 정점을 의미한다.

연두색 정점은 방문이 완료되고, 해당정점에서 나아갈 수 있는 정점의 방문까지 완료된 정점들이다.

재귀로 해결이 가능했던 DFS와는 다르게 BFS에서는 미리 정점들을 방문하고, 이후에 그 정점들의 다음 정점들을 방문해야하므로 큐(queue)가 필요하다.

vector<vector<int> > graph;
queue<int> q1;
queue<int> q2;

int visited[10]; // 0 - 미방문 / 1 - 방문

void bfs(){
    int now;
    int len;
    q1 = q2;
    while(q2.size() > 0){
        q2.pop();
    }
    len = q1.size();
    if(len > 0){
        for(int i=0;i<len;i++){
            now = q1.front();
            q1.pop();
            cout << "visit " << now << endl;
            for(int j=0; j<graph[now].size(); j++){
                if(visited[graph[now][j]] == 0){
                    q2.push(graph[now][j]);
                    visited[graph[now][j]] = 1;
                }
            }

        }
        bfs();
    }
}

따라서 위와같이 queue를 선언해주었고 q1은 직전에 방문을 한 정점이며, q2는 현재 방문한 정점들을 누적하는 큐이다.

따라서 bfs()가 실행되면 현재 방문한 정점들의 다음 정점으로 나아가야 하기에 q2를 q1으로 변경시켰다.

다음은 c++로 작성된 BFS 전체 코드이다.

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

vector<vector<int> > graph;
queue<int> q1;
queue<int> q2;

int visited[10]; // 0 - 미방문 / 1 - 방문

void bfs(){
    int now;
    int len;
    q1 = q2;
    while(q2.size() > 0){
        q2.pop();
    }
    len = q1.size();
    if(len > 0){
        for(int i=0;i<len;i++){
            now = q1.front();
            q1.pop();
            cout << "visit " << now << endl;
            for(int j=0; j<graph[now].size(); j++){
                if(visited[graph[now][j]] == 0){
                    q2.push(graph[now][j]);
                    visited[graph[now][j]] = 1;
                }
            }

        }
        bfs();
    }
}

int main(){
    for(int i=0;i<10;i++){
        graph.push_back(vector<int>());
        visited[i] = 0;
    }
    graph[0].push_back(1);
    graph[0].push_back(9);
    graph[1].push_back(0);
    graph[1].push_back(2);
    graph[1].push_back(5);
    graph[1].push_back(7);
    graph[2].push_back(1);
    graph[2].push_back(3);
    graph[2].push_back(4);
    graph[2].push_back(5);
    graph[3].push_back(2);
    graph[4].push_back(2);
    graph[5].push_back(2);
    graph[5].push_back(6);
    graph[5].push_back(1);
    graph[7].push_back(1);
    graph[7].push_back(8);
    graph[7].push_back(9);
    graph[8].push_back(7);
    graph[9].push_back(0);
    graph[9].push_back(7);

    q2.push(0);
    visited[0] = 1;

    bfs();
}

최종적으로 다음과같이 출력이된다.

[2][그래프 이론] - 깊이 우선 탐색 DFS (Depth-First Search)

Source — Wed, 27 Jan 2021 11:06:29 +0900

깊이 우선 탐색 DFS (Depth-First Search)

깊이 우선 탐색(이하 DFS)은 하나의 정점에서 시작해서 그래프를 탐색 하는 방법중 하나로 한 정점에서 갈수있는 정점을 방문하고 해당 정점에서 갈수 있는곳을 계속해서 방문하여 더이상 방문할 정점이 없을때까지 방문하는 방법이다.

쉽게생각해서 미로탈출 게임을 할때 만약 세가지 갈림길이 나왔을 때, 셋중 하나를 골라서 끝까지 진행해본후 막혀있다면 다시 원점으로 돌아와 다른 길로 가는 것과 같이 생각하면 될것이다.

다음과 같은 방향이 없는 그래프로 생각해보자.

0번 정점에서 시작해서 DFS를 수행하는 과정은 다음과 같다.

이번 DFS에서는 현재 정점에서 갈 수 있는 정점들 중 가장 번호가 낮은 정점부터 방문한다고 가정하자.

0번 정점에서 처음에 갈수 있는 정점은 1과 9번이다.

이중 1번을 먼저 방문한다.

1번에서는 0,2,5,7 번을 방문할수 있는데 이중 0번은 이미 방문 했으므로 제외하고 가장 낮은 번호인 2번부터 방문하고

이같은 과정을 계속 반복한다.

순환하는 과정을 보아하니 재귀함수로 해결할수 있을 것 같다.

이미 방문한 곳을 제외하고 방문하는 과정만 잘 설계하면 될것이다.

vector<vector<int> > graph;

int visited[10]; // 0 - 미방문 / 1 - 방문

void dfs(int v){
    cout << "visit " << v << endl;
    visited[v] = 1;
    for(int i=0; i<graph[v].size(); i++){
        if(visited[graph[v][i]] == 0){
            dfs(graph[v][i]);
        }
    }
}

해당 코드는 c++로 설계되었으며 그래프 상태는 2중 벡터를 사용하였다.

그리고 방문 상태를 체크하기 위해 1차원 배열을 사용하여 방문 이력을 기록하였고

현재 정점에서 갈수 있는 정점들 중 아직 방문을 하지 않은( visited[i] == 0 인 ) 정점들에 대해 재귀로 dfs(i) 를 수행하였다.

DFS 를 c++로 구현한 전체 코드

#include <iostream>
#include <vector>

using namespace std;

vector<vector<int> > graph;

int visited[10]; // 0 - 미방문 / 1 - 방문

void dfs(int v){
    cout << "visit " << v << endl;
    visited[v] = 1;
    for(int i=0; i<graph[v].size(); i++){
        if(visited[graph[v][i]] == 0){
            dfs(graph[v][i]);
        }
    }
}

int main(){
    for(int i=0;i<10;i++){
        graph.push_back(vector<int>());
        visited[i] = 0;
    }
    graph[0].push_back(1);
    graph[0].push_back(9);
    graph[1].push_back(0);
    graph[1].push_back(2);
    graph[1].push_back(7);
    graph[2].push_back(1);
    graph[2].push_back(3);
    graph[2].push_back(4);
    graph[2].push_back(5);
    graph[3].push_back(2);
    graph[4].push_back(2);
    graph[5].push_back(2);
    graph[5].push_back(6);
    graph[5].push_back(1);
    graph[7].push_back(1);
    graph[7].push_back(8);
    graph[7].push_back(9);
    graph[8].push_back(7);
    graph[9].push_back(0);
    graph[9].push_back(7);

    dfs(0);
}

최종적으로 다음과 같이 출력이 된다.

[1][그래프 이론] - 그래프 표현 및 정의

Source — Tue, 26 Jan 2021 19:58:26 +0900

그래프(Graph) 란?

그래프는 어떤 자료나 개념을 각각의 정점들(vertex)의 집합 V와 그 정점들을 이어주는 간선들(edge)의 집합 E로 구성된 자료 구조이다.

이러한 그래프는 크게 두가지로 표현이 가능하다.

1. 인접 리스트 표현

2. 인접 행렬 표현

1. 인접 리스트 표현

첫번째로 그래프를 표현할 수 있는 방법은 인접 리스트 이다.

#include <iostream>
#include <vector>

using namespace std;

int main(){
    vector<vector<int>> v;

    for(int i=0;i<4;i++){
        v.push_back(vector<int>());
    }
    v[0].push_back(1);
    v[0].push_back(2);

    v[1].push_back(0);
    v[1].push_back(2);
    v[1].push_back(3);

    v[2].push_back(0);
    v[2].push_back(1);
    v[2].push_back(3);

    v[3].push_back(1);
    v[3].push_back(2);
}

상단에 주어진 그래프를 표현하는 코드이다.

vector내에 int형을 가지는 vector를 포함하는 타입을 활용해서 각 정점마다 간선이 존재하는 정점들을 추가하여 구성하였다.

예를들어

v[2].push_back(1) 의 경우는 2번 정점에서 1번 정점으로 가는 간선이 존재하므로 추가해준것이고 결국

v[2] 는 0,1,3 을 가지는 벡터가 될것이고 이것은 2번 정점에서 0,1,3 정점으로 갈수 있다는 의미이다.

2. 인접 행렬 표현

두번째로 그래프를 표현할 수 있는 방법은 인접 행렬이다.

#include <iostream>
#include <vector>

using namespace std;

int main(){
    int graph[4][4];

    for(int i=0;i<4;i++){
        for(int j=0;j<4;j++){
            graph[i][j] = 0;
        }
    }
    graph[0][1] = 1;
    graph[0][2] = 1;
    graph[1][0] = 1;
    graph[1][2] = 1;
    graph[1][3] = 1;
    graph[2][0] = 1;
    graph[2][1] = 1;
    graph[2][3] = 1;
    graph[3][1] = 1;
    graph[3][2] = 1;
}

graph[i][j] 가 0이면 i 정점에서 j 정점으로 갈수있는 간선이 없다는 의미이고, 반대로 1이라면 간선이 존재한다는 의미이다.

[알고리즘][12][백준_7576][c++] - 토마토

Source — Sat, 23 Jan 2021 13:13:26 +0900

문제 이해

토마토 문제에서는 각 박스내에 3가지 상태가 존재한다. 익은 토마토(1), 안익은 토마토(0), 비어있는 칸(-1).

주의할 점은 익은 토마토는 자신의 상하좌우에 위치한 토마토만을 익힐 수 있고, 비어있는칸이 존재할 수 있기때문에, 문제의 예제2 처럼 모든 토마토를 전부 익힐 수 없는 상황이 주어질 수도 있다는 점을 고려해야한다.

알고리즘 설계

문제에서 주어진 예제3의 경우를 시각화했을 때의 모습이다.

간단하게 생각해보면,

1. 현재 익은토마토(1)의 상하좌우의 토마토들의 상태를 1로 바꾼다.

2. 현재 익은토마토들 주변에 익힐수 있는 토마토가 없을 경우 종료 / 아닐 경우 1 반복

로 표현할수 있다.

그런데 현재 익은 토마토의 개수는 매번 달라지므로 일반적인 재귀함수로 표현하기는 힘들것 같다.

위 그림을 보면 비어있지 않은 칸을 제외한 모든 토마토들의 연결 관계가 표현되어있다.

즉 이 토마토들의 관계를 그래프로 생각하고 익은 토마토들부터 시작해서 자신과 연결된 토마토들을 익히고 이 과정을 반복하면서 모든 토마토를 익혔을때의 횟수를 체크하면 될것같다.

즉 너비 우선 탐색 BFS를 이용하여 현재 익은 토마토들을 큐에 넣고, 다음에 익힐수 있는 토마토들을 새로운 큐에 넣고, 새로운 큐에 넣어진 토마토들이 익힐 수 있는 토마토들을 또 새로운 큐에 넣어주고...

이 과정을 반복하면 될것이다.

대신 주의해야 할 점은,

1. 이미 익은 토마토 혹은 비어있는 칸으로는 이동해서는 안되고

2. 현재 익혀야할 전체 토마토 개수를 저장해두고 모든 BFS가 끝났을 때 모든 토마토를 익혔는지 확인 할 필요가 있다.

// 그래프 이론에서 너비우선 탐색 - pair를 속성으로 가지는 queue를 이용함.
// 2차원 배열을 사용해서 각 지점들의 상태 표현

#include <iostream>
#include <vector>
#include <utility>
#include <queue>

using namespace std;

int M,N;
int input[1001][1001];
int maximum = -1;
int leftCount = 0; // 현재 더 익혀야할 토마토수

queue<pair<int, int> > now_queue;
queue<pair<int, int> > next_queue;


void check_around_tomato(int i, int j){
    // (i,j) 주변에 자신이 익힐수 있는, 상태가 0인 토마토들을 next 큐에 pair 형태로 넣어준다. 
    if(i != N-1){ // down
        if(input[i+1][j] == 0){
            next_queue.push(make_pair(i+1,j));
            input[i+1][j] = 1;
            leftCount--;
        }
    }
    if(i != 0){ // up
        if(input[i-1][j] == 0){
            next_queue.push(make_pair(i-1,j));
            input[i-1][j] = 1;
            leftCount--;
        }
    }
    if(j != M-1){ // right
        if(input[i][j+1] == 0){
            next_queue.push(make_pair(i,j+1));
            input[i][j+1] = 1;
            leftCount--;
        }
    }
    if(j != 0){ // left
        if(input[i][j-1] == 0){
            next_queue.push(make_pair(i,j-1));
            input[i][j-1] = 1;
            leftCount--;
        }
    }
}

void tomato(){
    now_queue = next_queue;
    while(next_queue.size() > 0){
        next_queue.pop();
    }

    int len;
    len = now_queue.size();
    if(len > 0){
        for(int i=0;i<len; i++){
            check_around_tomato(now_queue.front().first, now_queue.front().second);
            now_queue.pop();
        }
        maximum++;
        tomato();
    }
}

int main(){

    cin >> M;
    cin >> N;
    int tmp;
    for(int i=0; i<N; i++){
        for(int j=0; j<M; j++){
            cin >> tmp;
            input[i][j] = tmp;
            if(tmp == 1){
                next_queue.push(make_pair(i,j));
            }
            if(tmp == 0){
                leftCount++;
            }
        }
    }

    tomato();
    if(leftCount > 0){
        cout << -1;
    }
    else{
        cout << maximum;
    }
}

[알고리즘][11][백준_1029][C언어] - 그림교환

Source — Wed, 4 Mar 2020 21:56:17 +0900

알고리즘 설계

문제에서 주어지는 n명의 그림 소유상태를 비트마스킹으로 표현하고 DP를 이용해서 해결할수 있는문제이다.

만약 비트연산을 처음 들어봤다면 비트연산을 먼저 공부하고 오는 것을 추천한다.

전체 코드는 다음과 같다.

#include <stdio.h>

int n;

int pp[16][16];
int dp[15][32768] = {0};
int ddp(int state, int before, int price);
int max(int x, int y);


int main(){
    int i,j;
    scanf("%d",&n);
    for(i=0;i<n;i++){
        for(j=0;j<n;j++){
            scanf("%1d",&pp[i][j]);
        }
    }    
    printf("%d",ddp(1,0,0)+1);

}

int ddp(int state, int before, int price){
    printf("state : %d\n",state);
    int i,j;
    int tmp1, tmp2;
    int maximum = 0;
    if(state == (1<<n)-1){ // 모든 사람이 그림을 소유했거나 소유하고있으면 정상적으로 종료
        return 0;
    }

    if(dp[before][state] != 0){
        return dp[before][state];
    }
    for(i=1;i<n;i++){
        if((state & (1<<i)) == 0 && pp[before][i] >= price){
        // i번째 사람이 그림을 소유한적이 없다 && 이전사람에서 i번째사람한테 파는 가격이 
        // 이전에 판 가격보다 같거나 높다
            maximum = max(maximum,1+ddp(state+(1<<i),i,pp[before][i]));
        }
    }
    dp[before][state] = maximum;
    return maximum;
}

int max(int x, int y){
    return x > y ? x : y;
}

비트 마스킹은 오른쪽부터 1번째 사람으로 정할수도 있고 왼쪽부터 1번째사람이라고 정할수도 있는데 본인이 편한 쪽으로 하면된다.

이 코드에서는 맨 오른쪽부터 1번째 사람으로 고정했다.

따라서 만약 n = 5 라면 초기 값이 00001, 즉 1로 시작하게된다.

맨 처음사람도 그림을 소유했던 사람에 속하기 때문이다.

예를들어 첫번째사람이 두번째사람에게 그림을 주었고 두번째 사람이 다섯번째 사람에게 그림을 주었다면

현재 상태는 10011이 된다.

따라서 처음에 함수를 실행할때 state 부분에 1을 넣고 시작한다.

printf("%d",ddp(1,0,0)+1);

그 다음은 그림을 판매할 다음 사람을 선택하는 부분인데

1. 구매자는 그림을 소유한적이 없었어야 한다.

2. 현재소유자->구매자 판매가격이 이전의 판매가격보다 크거나 같아야한다.

이 두가지 조건을 동시에 만족하는 사람에게만 판매할수 있고 그 부분이 아래 if문으로 표현되어있다.

여기서

state : 현재 그림 소유상태 (ex 10101, 10111 ...)

before : 이전에 그림을 소유했던 사람의 인덱스

price : 이전 거래에서 판매되었던 가격

을 의미한다.

int ddp(int state, int before, int price){

    int maximum = 0;
	
    ...
    
    for(i=1;i<n;i++){
        if((state & (1<<i)) == 0 && pp[before][i] >= price){
            maximum = max(maximum,1+ddp(state+(1<<i),i,pp[before][i]));
        }
    }

    return maximum;
}

그리고 마지막으로 dp배열을 이용해서 인덱스가 before번째인사람이 판매해야하는 상황에서 그림소유 상태가 state 일때 값을 메모이제이션 해두면된다.

int ddp(int state, int before, int price){
    if(dp[before][state] != 0){
        return dp[before][state];
    }
    
    ...
    
    dp[before][state] = maximum;
    return maximum;
}

[2][Knapsack][0/1 배낭 문제] (0/1Knapsack Problem)

Source — Wed, 4 Mar 2020 21:34:46 +0900

배낭 문제

배낭문제는 n개의물건이 있고 각각 무게와 가치가 주어질때, 물건을 m이하의 무게로 담을때 가능한 최대 가치를 구하는 문제이다.

이 배낭 문제는 크게 3가지로 분류된다.

배낭 빈틈없이 채우기 문제 ( Fractional Knapsack Problem)
0/1 배낭 문제 (0/1 Knapsack Problem)
개수제한 없는 0/1 배낭 문제 (Unbounded Knapsack Problem)

이 중 0/1 배낭 문제 (0/1 knapsack problem) 에 대해 알아보자.

0/1 배낭 문제 ( 0/1 Knapsack Problem)

0/1배낭 문제는 최대 가방무게 이하로 물건을 담을때 가치가 최대로 최게 담아야하는데

단, 물건을 일부만 담을 수 없고 담거나 담지 않거나 둘중 한가지를 택해야한다.

첫번째로 생각해볼 수 있는 방법은 가치 순으로 내림차순으로 정렬해서 가치가 큰것부터 먼저 담는 방법이다.

그러나 아래의 예처럼 아무리 가치 높은 물건을 먼저담아도 그 후에 가치가 작은 물건 여러개를 고름으로써 더 큰 가치가 나올수도있다.

따라서 이방법으로는 안될것이다.

두번째로 생각해볼수 있는 방법은 무게가 가벼운 순서대로 오름차순해서 가벼운것을 먼저 넣는 전략이다.

그러나 아래 예처럼 처음에 가벼운것들을 먼저 넣는것보다 나중에 무거운것 하나를 넣는것이 더 큰 가치가 나올수도 있다.

이 방법또한 사용하지 못한다.

그렇다면 fractional knapsack에서 사용했던 방법처럼 가치/무게 값으로 내림차순해서 무게대비 가치의 효율이 높은것 먼저 넣으면 되지않을까.

아쉽게도 이방법으로도 불가능하다.

아래의 경우처럼 가장 효율이 좋은 물건 하나보다 효율이 좀 떨어지는 물건 두개를 고르는것이 더큰 가치가 만들어질수 있다.

이 문제를 풀기위해서는 동적계획법을 이용해서 풀어야한다.

각 상품에 대해 담을지 말지 두가지 경우가 있으므로 총 n개의 상품을 가방에 넣을때 총 경우의 수는 2^n인데

동적계획법을 이용해 불필요한 반복을 줄여서 시간복잡도를 줄일수 있다.

#include <stdio.h>

#define INF 987654321;

typedef struct KNAPSACK{
    int w,v; // 각각의 상품에 대한 무게,가치를 저장하는 구조체
}Knapsack;

Knapsack ks[101]; // 입력으로 상품이 최대 100개 들어온다고 가정

int ddp(int now, int weight);
int maximum(int x, int y);

int dp[101][100001] = {0};
int n,k; // n : 전체상품의 개수, k : 담을 수 있는 최대 상품 무게

int main(){
    int i;
    scanf("%d %d",&n,&k);
    for(i=0;i<n;i++){
        scanf("%d %d",&ks[i].w,&ks[i].v);
    }
    printf("%d",ddp(0,0)); // 시작할때 인덱스는 0이고 무게는 0으로 시작

}

int ddp(int now, int weight){ 
// now : 담을지말지 고민하고 있는 상품의 인덱스
// weight : now번째 이전까지 담은 상품들의 총 무게

    int tmp1,tmp2,ans;
    if(weight > k){ // 만약 현재까지 담은 상품들 무게가 최대무게를 초과한다면 매우 작은수를 내보낸다(약 -9억)
        return (-1) * INF;
    }
    if(now == n){ // 만약 모든 상품들을 순회했다면 정상적으로 0을 리턴해서 최종 합을 리턴시킨다.
        return 0;
    }
    if(dp[now][weight] != 0){ 
    // 만약 현재 now번째 물건을 담기 전까지 weight만큼 가방을 채웠었고
    //현재 now번째 물건을 채워야하는 상황이 이전에 있었다면 이후로는 결과값이 동일하므로 저장된 값을 가져온다 
        return dp[now][weight];
    }
    tmp1 = ks[now].v + ddp(now+1,weight+ks[now].w); // 현재 물건을 가방에 담는 케이스
    tmp2 = ddp(now+1,weight); // 현재 물건을 담지 않고 넘어가는 케이스

    ans = maximum(tmp1, tmp2); // 위 두케이스 중 큰 케이스가 최종값이 된다.
    dp[now][weight] = ans; 
    // 현재 weight의 무게까지 채웠고 now를 담을지 말지 고민하는 경우의 최대값을 
    // 나중에 재방문 했을때 불필요한 중복을 없애기 위해 저장해둔다.
    return ans;
}

int maximum(int x, int y){
    return x > y ? x : y;
}

[1][Knapsack][배낭 빈틈없이 채우기 문제] (Fractional Knapsack Problem)

Source — Tue, 3 Mar 2020 22:26:13 +0900

배낭 문제

배낭문제는 n개의물건이 있고 각각 무게와 가치가 주어질때, 물건을 m이하의 무게로 담을때 가능한 최대 가치를 구하는 문제이다.

이 배낭 문제는 크게 3가지로 분류된다.

배낭 빈틈없이 채우기 문제 ( Fractional Knapsack Problem)
0/1 배낭 문제 (0/1 Knapsack Problem)
개수제한 없는 0/1 배낭 문제 (Unbounded Knapsack Problem)

이 중 배낭을 빈틈없이 채우는 문제에 대해 알아보자.

Fraction Knapsack Problem

배낭 빈틈없이 채우기 문제는 최대 가방무게 이하로 물건을 담을때 가치가 최대로 최게 담아야하는데

단, 물건을 일부만 담을 수도 있다.

예를 들어 무게가 10이고 가치가 20인 물건 A를 절반만 담으면 무게가 5고 가치가 10인 물건처럼 담을 수 있다는 의미이다.

이 조건 때문에 가치/무게 값으로 값들을 환산해서 가장 무게대비 가치가 높은 물건부터 차례대로 넣고 무게를 초과하게 되는 물건이 생기면 남은 배낭 무게만큼 잘라서 넣으면 된다.

다음 예를 보자.

최대로 가방에 담을 수 있는 무게는 20이고

총 4개의 보석이 있고 가치와 무게, 가치/무게값은 다음과 같다.

이 보석들을 무게대비 가치가 높은 순으로 담게되면 다음과 같다.

여기서 노란보석을 담을때 무게가 초과하므로 최대무게에 맞게 절반만 담게되면 최종적으로 55의 가치가 최대 가치가 된다.

[1][연쇄행렬 최소곱셈 알고리즘] (Matrix chain multiplication)

Source — Tue, 3 Mar 2020 16:03:58 +0900

연쇄행렬 최소곱셈 알고리즘 (Matrix chain multiplication)

연쇄행렬 최소곱셈 알고리즘이란 주어진 행렬들의 곱을 최소의 연산으로 수행하는 최소횟수를 구하는 알고리즘이다.

행렬의 곱셈에서 결합법칙은 성립하지만 어떤 형태로 결합되느냐에 따라 계산 횟수는 달라질수 있다.

예를 들어 아래와같은 행렬이 있다고 할때 결합 형태에 따른 연산횟수 차이는 다음과 같다.

위와 같이 결합되는 순서에 따라 전체 연산횟수가 달라짐을 알수 있다.

그렇다면 본격적으로 연쇄행렬 최소곱셈 알고리즘에 대해 알아보자.

먼저 행렬의 개수가 5개일때 모든 결합의 마지막 결합 형태는 크게 다음과같이 네가지로 분류가 가능하다. ( 행렬의 개수가 n개일때 (n-1)가지로 분류가 가능하다.)

예를 들어

(AB)(C(DE)) 는 최종적으로 AB와 CDE의 곱이므로 type 2 에 해당하고

(A(B(CD)))E 는 최종적으로 ABCD와 E의 곱이므로 type 4에 해당한다.

따라서 위 4가지 방법들 중 가장 최소값이 최종적인 답이 될것이다.

이를 DP로 구현하면

DP[i][j] = i번째 행렬부터 j번째행렬까지 최소 연산 횟수

가 된다.

점화식은 주어진 행렬을 다음과 같이 표현할때

i번째에 n by m 행렬을 matrix[i][0] = n, matrix[i][1] = m

DP[i][j] = min(DP[i][k] + DP[k+1][j] + matrix[i][0] * matrix[k][1] * matrix[j][1]) (i<=k<j)

가 된다.

따라서 c언어로 작성된 최종 코드는 다음과 같다.

// 연쇄행렬 최소곱셈 알고리즘
#include <stdio.h>

int matrix[501][2];
int dp[501][501];
int mat(int n);

int main(){
    int n,i,j;
    scanf("%d",&n);
    for(i=0;i<n;i++){
        scanf("%d %d",&matrix[i][0],&matrix[i][1]);
    }
    int ans = mat(n);
    printf("최소연산 횟수 : %d\n",ans);
}

int mat(int n){
    int a,b;
    int i,j,k;
    for(i=0;i<n;i++){
        for(j=0;j<n-i;j++){
            a = j;
            b = j+i;
            if(a == b){
                dp[a][b] = 0;
            }
            else{
                dp[a][b] = 987654321;
                for(k = a; k < b; k++){
                    dp[a][b] = min(dp[a][b],dp[a][k] + dp[k+1][b] + ( matrix[a][0] * matrix[k][1] * matrix[b][1] ));
                }
            }
        }
    }
    return dp[0][n-1];
}

int min(int x, int y){
    return x < y ? x : y;
}

처음의 예제를 실행했을때 채워지는 dp 배열은 다음과 같다.

[c언어 기초] - 자료형

Source — Tue, 3 Mar 2020 13:39:26 +0900

상수 변수

초깃값을 변경할 수 없는 변수를 상수 변수라고 한다.(줄여서 상수)

const int MAX_SIZE = 10;

와 같이 사용한다.

자료형

정수

char - 1byte
short - 2byte
int - 4byte
long 4byte

실수

float - 4byte
double - 8byte

int 의 범위가 약 21억~21억 인이유

int 의 크기는 4byte로 32bit 이다.

한 비트당 1 또는 0의 상태를 가지므로 총 2^32(4294967296) 가지의 숫자를 표현할수 있는데 맨 앞자리 비트는 부호를 의미하기 때문에 양수 음수 각각 2^31인 2147483648까지 표현이 가능한데 실제 표현 가능 범위는

-2147483648 ~ 2147483647 이다.

마지막 1의자리수가 다른 이유는 2147483648가지 표현중에 0을 양수로 포함하기 때문에 양수쪽에서 숫자하나가 빠진것이다.

따라서 다음과 같이 unsigned로 선언하게 되면 부호를 결정하는 비트까지 포함해서 수를 저장하기 때문에 음수범위가 사라진

0 ~ 4294967295 까지 표현이 가능하다.

unsigned int n = 4294967295;

long long

int의 최대 범위가 약-21억 ~ 21억이고 unsigned int를 사용한다고 해도 최대 약42억이다. 그렇다면 그보다 큰수는 어떻게 저장할수있을까.

long long 이라는 자료형은 8byte로 총 64bit를 할당할수 있다.

따라서 -9223372036854775808 ~ 9223372036854775807 까지 표현이 가능하다.

(약 -922경~922경)

unsigned long long 도 마찬가지로

0 ~ 18446744073709551615 까지 표현이 가능하다.

(약 1844경)

[알고리즘][10][백준_1126][C언어] - 같은 탑

Source — Sat, 29 Feb 2020 19:55:39 +0900

문제이해

N개의 높이가 다른 블록들로 높이가 같은 두개의 탑을 쌓는데 그 탑의 높이가 최대일때의 그 높이를 구하는 문제이다.

단, 모든 블록을 사용할 필요가 없다.

알고리즘 설계

만약 블록을 쌓을때 구역 a와 b에 쌓아서 두개의 탑을 만든다고 할때

각 블록마다

1. a에 쌓는다

2. b에 쌓는다

3. 둘다 쌓지않는다 ( 사용하지 않는다 )

3가지 경우가 있다.

여기서 한가지 정해놓고 갈 부분.

위 그림은 블록 4개로 탑을 쌓는과정중 일부인데 두 상황이 좌우에 누가 더 높냐만 다르지 25와 30으로 두 상황에서 두 탑의 높이가 동일하다. 따라서 함수를 진행하면서 a구역을 두 탑중 높은 탑, b구역을 두 탑중 낮은 탑으로 진행을 하게될것이고 해당 변수는 l ( large )과 s ( small )이다.

따라서 블록마다 가능한 경우를 다시 살펴보면

1. l 에 쌓는다 ( 높은곳에 쌓는다 )

2. s 에 쌓는다 ( 낮은곳에 쌓는다 )

3. 둘다 쌓지않는다 ( 사용하지 않는다 )

와 같다.

이렇게 하는 이유는 높이 구분 없이 좌,우로 쌓게되면 중복들이 많이 발생하고 비효율적이기 때문이다.

위의 경우대로 모두 해보면 n개의 블록에 대해 n^3 번의 결과를 살펴봐야하므로 더 효율적인 방안을 생각해볼 필요가 있다.

1. dp 이용

dp를 이용해 중복으로 방문하게 되는 경우를 체크해 시간을 줄여야한다.

위와 같이 만약 k번째 블록을 놓는 상황에서 왼쪽 상황을 이전에 방문했을경우 이후에 오른쪽 상황이 발생할 경우 이후에 최대로 쌓은수있는 같은 탑은 가보지 않아도 구할수 있다.

만약 좌측 상황에서 n까지 쌓았을때 최대 같은 탑의 높이가 100이였다고 해보자. 그렇다면 오른쪽 상황에서도 그 이전에 사용된 블록의 조합은 다르지만 최종적으로 k부터 n까지 블록을 사용해서 쌓을 수있는 최대 같은 탑 높이가 100인것은 동일할것이다.

그러나 이 규칙은 두 탑의 높이가 전부 같을 필요없이 두 탑의 차가 같아도 성립한다.

위의 상황을 보자. 둘다 동일하게 k번째 블록을 쌓아야하는 상황일때 좌측이 이미 방문했던 상황이고 우측이 아직 방문하지 않은 상황이다.

좌측에서 이미 높이가(50,40)일때 최대로 쌓을수 있는 높이가 100이라고 구했으므로 이는 결국 앞으로 큰쪽에+40, 작은쪽에+50 만큼 더 쌓을 수있다는 의미이므로 오른쪽 상황에서는 k번째부터 쌓아보지않아도 40+40, 30+50 = 80,80 으로 높이가 80인 두 탑을 쌓을 수 있다는 것을 알수있다.

따라서 dp배열에 저장할때 현재 블록 인덱스와 두 높이차를 이용해 앞으로 더 높은탑에 쌓을수 있는 최대 높이를 저장해두면된다.

dp[i][j] : i번째 인덱스를 쌓을때 현재 두 탑의 높이차가 j일때 높은탑에 쌓을수 있는 최대 블록들의 높이.

가 된다.

2. 조건 활용

문제에 주어진 조건을 활용해 불필요한 함수 진행을 줄이는 방법이 있다. 문제에서 각각의 블록들의 높이는 500000이하이고 모든 블록들의 높이의 합이 500000을 넘지 않는다고 했으므로 모든 블록들의 높이의 합의 최대는 500000미만이다.

따라서 최대로 두탑을 같게 쌓아도 250000을 넘길수 없다.

따라서 함수 진행중에 두탑중 높은쪽의 탑의 높이가 250000이 넘어가면 그 뒤로는 무조건 불가능함을 알수 있다. 따라서 입력된 블록들의 총 높이의 합이 h라면 그 때 최대 같은 탑 높이는 h/2 이하이다.

또한 이를 활용하여 위의 dp배열에서 j의 범위를 알수 있는데 탑의 높이가 250000을 넘어갈수 없으므로

dp[51][250001] 로 정의할수 있다.

이를 c언어로 구현하면 다음과 같다.

#include <stdio.h>
#include <stdlib.h>

int bl[51];
int dplarge[51][250001] = {0};
int n;
int max;
int maximum;

int block(int l, int s, int now);
int fmaximum(int x, int y);

int main(){
    int i;
    max = -2;
    maximum = 0;
    scanf("%d",&n);
    for(i=0;i<n;i++){
        scanf("%d",&bl[i]);
        maximum = maximum + bl[i];
    }
    block(0,0,0);
    
    if(max == 0){
        printf("%d",-1);  
    }
    else{
        printf("%d",max);
    }
}

int block(int l, int s, int now){
    int tmp1,tmp2,tmp3,m;
    if(l == s){
        if(l > max){
            max = l;
        }
    }
    if(now == n || l > maximum/2){
        if(l == s){
            return l;
        }
        else{
            return -1;
        }
    }
    if(dplarge[now][l-s] != 0){
        if(dplarge[now][l-s] < 0){
            return -1;
        }
        else{
            if(l+dplarge[now][l-s] > max){
                max = l+dplarge[now][l-s];
            }
            return l+dplarge[now][l-s];
        }
    }
    tmp1 = block(l+bl[now],s,now+1);
    if(s+bl[now] > l){
        tmp2 = block(s+bl[now],l,now+1);
    }
    else{
        tmp2 = block(l,s+bl[now],now+1);
    }
    tmp3 = block(l,s,now+1);
    m = fmaximum(tmp1,fmaximum(tmp2,tmp3));
    dplarge[now][l-s] = m-l;
    return m;
}

int fmaximum(int x, int y){
    return (x > y) ? x : y;
}

[알고리즘][9][백준_11723][C언어] - 집합

Source — Sat, 29 Feb 2020 19:16:29 +0900

문제이해

이 문제는 집합에서의 기본적인연산 ( 원소의 추가, 삭제, 확인, 반전, 전체 변경, 전체 삭제 등) 을 수행하는 알고리즘을 설계하는 문제이다.

다만 수행해야하는 연산의 수가 최대 3,000,000 이므로 배열연산보다는 비트마스크를 활용해서 문제를 해결해야할것이다.

알고리즘 설계

사실 비트마스크를 사용해본적이 있다면 쉽게 해결할수 있을것이다.

집합의 원소개수가 1부터 20까지 20개 이므로 한개의 int에서 20bit를 사용해서 n번째 원소가 채워져있으면

2^(n-1) 에 해당하는 부분을 1로 아니라면 0으로 채워서 현재 집합의 상태를 표현할수 있다.

#include <stdio.h>
#include <string.h>

int ss = 0;

int bit(char ar[], int k);

int main(){
    int n,i,j;
    char arr[10] = {};
    char ar[10];
    int tmp;
    int check = 1;
    scanf("%d",&n);
    for(i=0;i<n;i++){
        scanf("%s",&arr);
        scanf("%d",&tmp);
        bit(arr,tmp);
    }
}

int bit(char ar[], int k){
    if(!strcmp(ar,"add")){
        if((ss & (1<<k)) == 0){
            ss = ss + (1<<k);
        }
    }
    else if(!strcmp(ar,"remove")){
        if((ss & (1<<k)) > 0){
            ss = ss - (1<<k);
        }
    }
    else if(!strcmp(ar,"check")){
        if((ss & (1<<k)) > 0){
            printf("1\n");
        }
        else{
            printf("0\n");
        }

    }
    else if(!strcmp(ar,"toggle")){
        if((ss & (1<<k)) == 0){
            ss = ss + (1<<k);
        }
        else{
            ss = ss - (1<<k);
        }
    }
    else if(!strcmp(ar,"all")){
        ss = (1<<21) - 1;
    }
    else{ // empty
        ss = 0;
    }
    return 0;
}

[C언어] 비트연산

Source — Sat, 29 Feb 2020 19:01:48 +0900

비트연산을 쓰는 이유에 대하여

비트연산은 여러분야에서 활용도가 높다. 컴퓨팅 시스템에서 오류검출, 네트워크 시스템에서의 오류검출, 그리고 알고리즘에서의 상태저장 등등에 쓰인다.

그중 알고리즘측면에서 비트연산은 N개의 지점에 대해 0과1로 그 상태를 저장해둘때 유용하다.

예를들어 N개의 도시를 한번씩 방문하면서 순회하는 외판원 문제에서 각 도시들의 방문상태를 저장할때

일반적인 배열을 사용하게 되면 N만큼의 int를 사용하게 되고 N * 4byte의 공간을 사용하게 된다.

그러나 N이 15라고 가정할때 배열에서는 15 * 4byte = 60 byte를 사용하게 되는데

비트연산에서는 2^15 = 32768 이므로 1개의 int(약 -21억~21억)내에 들어오게되므로 4byte에 처리가 가능하다.

이렇게 보면 별 차이가 없어보이지만

외판원처럼 순회하면서 이 도시들의 방문상태를 저장해두고 dp를 이용해야할때 큰 차이가 생긴다.

비트연산 사용법

비트연산에 대해 알아보기 전에 2진수에 대해서 살펴보자.

다음과 같이 10진수들을 2진수로 변환할수 있고 2진수에서 1과 0을 통해 외판원 문제의 경우 1은 방문한도시, 0은 아직 방문하지 않은 도시로 값을 저장할수 있다.

예를 들어 7개의 도시가 있고 1번째,5번째 도시를 방문한 상태면

위의 4번째 예제처럼 1000100 으로 표시할수 있고 실제 저장되는 값은 68이다.

논리 연산자 & | ^

& : AND

| : OR

^ : XOR

을 의미한다.

n = 85, m = 35 일때 각각의 연산의 실행결과이다.

시프트 연산자 << >>

<< >> 기호는 현재 비트를 해당 방향으로 시프트하는 것을 의미한다.

n = 87일때

n << 3 과 n >> 2 의 실행결과는 다음과 같다.

위 실행결과의 n >> 2를 보면 알수 있듯 우측으로 밀려서 짤린 값들은 그대로 사라진다. 다시 n << 2한다고 그 전값이 나오지 않는다.

또한 << 연산으로 int 범위를 초과하지 않게 주의할 필요가있다.

이를 이용해 위의 실행결과를 출력시킬때 사용한 함수를 만들어보자

이 함수는 정수를 입력했을때 위의 결과처럼 2진수로 표현해주는 함수이다.

int bit(int n){
    int i = 0;
    printf("0");
    for(i=30;i>=0;i--){
        if((1<<i) <= n && n > 0){
            printf("1");
            n = n - (1<<i);
        }
        else{
            printf("0");
        }
        if(i%4 == 0){
            printf(" ");
        }
    }
    printf("\n");
    return 0;
}

[1][LCS : 최장 공통 부분 수열 알고리즘] (Longest Common Substring)

Source — Thu, 27 Feb 2020 14:07:59 +0900

최장 공통 부분 수열( LCS : Longest common substring )

최장 공통 부분 수열(이하 LCS)은 주어진 여러 개의 수열 모두의 부분수열이 되는 수열들 중에 가장 긴 것을 찾는 문제이다.

여기서 공통 부분 수열이라함은 예를 들어 ABCD ADEFB 두 문자열이 있을 때, 공통 부분 수열은

A D AD AB 라고 할 수 있다. 여기서 최장 공통 부분 수열은 이들중 가장 길이가 긴 수열이므로 AD 혹은 AB가 된다.

이 LCS를 구하기 위해서 대표적으로 사용되는 예인 ACAYKP 와 CAPCAK 로 살펴보자.

위의 표로 설명을 할텐데 안에 채워질 숫자의 의미는 해당 열와 행까지의 수열에서 LCS를 의미한다.

다음 그림을 참고해보자.

맨 첫칸부터 (0,0) 이라하면 ? 가 있는 부분은 (2,3) 이고 (2,3)의 의미는 첫번째문자열("ACAYKP") 에서 3번째 문자열까지("ACA"), 두번째문자열("CAPCAK")에서 2번째 문자열("CA")까지 중 LCS값을 의미한다.

따라서 두 문자열중 하나가 비어있는 (0,0) (1,0) ... (6,0) 과 (0,1) (0,2) ... (0,6) 은 0으로 모두 채운다.

앞으로 채워야할 칸을 ( i , j ) 라고 하고 첫번째 문자열을 arr1[], 두번째 문자열을 arr2[] 라고하자. 그리고 해당 테이블을 저장할 배열을 dp[][]라고 하자.

(1,1)부터 채우게 될텐데 여기서 두가지 경우가 있다.

1. arr1[ j ] = arr2[ i ] 인 경우

이 경우 왼쪽 대각선 위칸(dp[i-1][j-1])의 값에 1을 더하면된다.

이유는 해당 문자를 제외하고 지금까지 최대값이 dp[i-1][j-1] 인데 공통인 문자가 하나 추가되었으니 지금까지의 최대값에 1을 더해주는것이다.

2. arr1[ j ] ≠ arr2[ i ] 인 경우

이 경우는 새로 추가된 문자를 써도 추가되는 공통부분이 없으므로 현재까지 최대를 가져와야한다.

이경우 바로위칸(dp[i-1[j]) 또는 바로왼쪽칸(dp[i][j-1]) 중 큰 값을 가져오면된다.

직접 테이블을 채워나가면서 보면 이해가 쉬울것이다.

그 다음줄을 채우는 것도 살펴보자

이런 식으로 계속 채워나가게 되면 마지막 (6,6) 값이 최종 LCS가 된다.

이를 C코드로 구현하면 다음과 같다.

#include <stdio.h>

char arr[1001]; 
char arr2[1001];
int dp[1002][1002] = {0};
int max(int a, int b);
int main(){
    scanf("%s",arr);
    scanf("%s",arr2);
    int i,j;
    for(i=0;i<strlen(arr)+1;i++){
        for(j=0;j<strlen(arr2)+1;j++){
            if(i == 0 || j == 0){
                dp[i][j] = 0;
            }
            else if(arr[i-1] == arr2[j-1]){
                dp[i][j] = dp[i-1][j-1]+1;
            }
            else{
                dp[i][j] = max(dp[i-1][j],dp[i][j-1]);    
            }
        }
    }
    printf("%d",dp[strlen(arr)][strlen(arr2)]);
}

int max(int a, int b){
    if(a < b){
        return b;
    }
    else{
        return a;
    }
}

[알고리즘][8][백준_2515][C언어] - 전시장

Source — Mon, 24 Feb 2020 02:17:25 +0900

문제이해

문제에서는 총 N개의 그림이 주어지고 각 그림마다 높이와 가격이 존재한다.

중요한 부분은 앞에서 보았을때 보이는 폭의 길이가 특정정수 S이상이 되어야 판매가능한 그림이 된다는점이다.

이부분을 중점으로 생각해보자

알고리즘 전략

먼저 앞에서 봤을때 보이는 폭의 길이가 중요한 포인트이므로 높이와 가격을 가진 각각의 그림들을 구조체로 선언해주고 높이를 오름차순으로 정렬해주자.

그리고 배열 dp[i]를 이렇게 정의하자.

dp[i] : i번째그림까지중 i번째그림을 무조건 선택한다고 했을때 최대 가격의 합

그리고 문제에서는 모든 그림들을 배열한다고 했지만 편의상 총가격에 포함되는 그림들을 선택하고 불필요한 그림들은 선택하지 않는다고 생각하자.

그렇다면 점화식은 어떻게되는지 보자.

price[i] 를 i번째 그림의 가격이라고 하면

dp[i] = max ( price[i] + dp[j] ) (0 <= j < i)

가 될것이다. 단 여기서 dp[j] 는 j번째 그림을 무조건 선택했다는 의미이고 price[j]를 더해주었던 값이므로 i번째 그림과 j번째그림의 높이차이가 s이상 된다는 조건을 만족해야한다.

이런구조로 알고리즘을 설계하면 아래와같이 이중for문으로

O(N^2) 의 시간복잡도를 가지게되고 n 크기가 최대 30만 이므로 시간초과일것이다.

따라서 시간을 더 줄일수 있는 방안을 생각해보아야한다.

for(i=0;i<n;i++){
    for(j=0;j<i;j++){
    	code
    }
}

여기서 시간을 줄일수 있는 방법은 두번째 for문을 없애는 것이다.

다음 예제를 보면서 생각해보자.

N=5이고 S=5 이면서

각각의 그림들의 높이와 가격이 다음과 같다고 가정하자.

여기서 기본적인 위 방식으로는 dp[4]를 구하기위해서 j=0일때부터 j=3일때까지 dp[j]를 모두 순회해야하지만 그러지 않고 마지막 그림과 연관이 있는(4번째 그림보다 앞에있는 그림중 차이가 S이상 안나는 그림들)그림들과 그렇지 않은 그림들로 구분을 해보자.

위 그림에서 회색그림을 기준으로 노란그림들은 회색그림과 길이가 s이상( 5 이상 ) 차이나는 그림들이고 빨간그림은 s미만으로 차이가 나는 그림이다. 이와같이 구분을 하는 이유는 회색그림의 dp인 dp[4] 를 구할때 dp[0] dp[1] dp[2] dp[3] 이 네가지를 전부 고려할 필요없이 노란그림들의 dp값중 최대값에 price[4] 를 더한값이 dp[4]가 된다.

그이유는 dp[i]의 정의가 해당그림을 무조건 선택했다는 의미이므로 만약 빨간그림인 dp[3]을 고려하게되면 i=4,5인 그림 모두를 선택하는의미인데 두 그림의 높이차이가 5 미만이므로 둘다 선택할수는 없기에 노란그림들중 최대가격을 만들수 있는 조합을 선택하면 dp[4]를 구할수 있다. 따라서 i 가 증가함에 따라 어디까지가 노란그림들 구역이고 어디부터가 빨간그림 구역인지 알려주는 변수가 하나 필요하고 반복 순회를 피하기 위해 노란그림들중 dp값이 가장 큰 값과 그 인덱스를 저장할 변수 두개가 필요하다.

최종적인 코드는 아래와같다.

#include <stdio.h>
#include <stdlib.h>

typedef struct PIC{
    int height;
    int price;
}Pic;

int dp[300001] = {}; // i번째 그림을 맨끝에 세울때 최대 수익
Pic arr[300001];

int cmp(const void* a, const void* b);
int partition(int n, int s, int e);

int main(){
    int n,s,i,j;
    scanf("%d %d",&n,&s);
    for(i=0;i<n;i++){
        scanf("%d %d",&arr[i].height,&arr[i].price);
    }
    qsort(arr, n, sizeof(Pic), cmp);

    int max = 0;
    dp[0] = arr[0].price;
    int m = 0;
    int max_index = 0;
    int now_max = 0;
    for(i=1;i<n;i++){
        while(arr[i].height - arr[m].height >= s && m <= i){
            if(now_max < dp[m]){ // m이전까지 최대이익을 갖는 인덱스 최신화
                now_max = dp[m];
                max_index = m;
            }
            m++; // m전까지가 해당그림과 겹치지 않는 그림들이다.
        }
        dp[i] = now_max + arr[i].price;
    }
    for(i=m;i<n;i++){
        if(now_max < dp[i]){
            now_max = dp[i];
        }
    }
    printf("%d",now_max);
}

int cmp(const void* a, const void* b){
    return (*(Pic*)a).height > (*(Pic*)b).height;
}

위 코드에서 while문이 현재 i 값을 기준으로 노란그림들의 구역을 나눠주는 역할을 하고 m 이라는 변수가 가장 최초의 빨간그림 인덱스를 말한다. 위 예시에서는 dp[4] 를 구할때 m은 3이된다.

그리고 현재까지의 최대값(노란그림들중)을 나타내는 변수인 now_max값은 노란그림들까지만 고려한 변수이고 마지막에 for문이 끝나면 끝나기 직전에 빨간그림들까지는 고려해주지 못하므로 마지막에 빨간그림들영역을 for문으로 한번 돌면서 최종적으로 최대 총합을 계산하게 된다.

WHY : dp[i]의 조합이 dp[i+k]를 고려할때도 과연 dp[i]가 최선의 선택이였는가?

이 문제는 점화식을 설계할때 해당 i 번째 그림을 선택할때 어디까지가 독립적이고 어디까지가 독립적이지 않은지 판단하는것이 중요했다. 사실 이 점화식을 세우면서 헷갈렸던 부분은 dp[i]를 i까지 그림들중 i번째 그림을 무조건 선택할때 최대값이라고 했을때, 가능한 모든 경우의 수들이 다 고려되는것인지 의문이 들었고, dp[i]의 조합이 dp[i+k]를 고려할때도 과연 dp[i]가 최선의 선택이였는가? 이런부분이 의문이 들었었다.

어떤 의미냐면, 만약 k그림 이전까지 가능했던 조합이 A가지이고 k이전 dp[i] (i < k) 들의 조합을 P, 그 외의 조합들을 Q라고 하자. 현재 dp를 구하는 과정은 dp[k]를 구할때 P 의 원소들 중에 k번째 그림을 포함해서 최선의 결과가 dp[k]에 담긴다. 그러나 만약 Q의 조합들중 하나와 k가 결합해서 최선의 결과가 나올수 있지 않을까?

이부분은 dp[k] 까지 진행했을때 dp[k+1]은 k그림까지의 모든 경우들중 최선의 결과를 따라간다. 이유는 만약 Q 조합중 하나인 q가 있고 그 q조합에서마지막에 k 그림을 포함했을때 최선의 결과가 나왔다고 가정해보자. 이 q에서 마지막 그림의 인덱스가 j라고 하면, 마지막그림을 j로 하는 최선의 조합 + 마지막에 k를 놓는것인데, 여기서 "마지막그림을 j로 하는 최선의 조합" 이라는 뜻은 사실 dp[j] 를 의미한다. 따라서 이 dp[j]는 Q집합이 아닌 P집합에 속해야 하므로 거짓이다.

[2][LIS : 최장증가수열 알고리즘] - Lower Bound 를 이용한 알고리즘 (Longest Increasing Subsequence Algorithm)

Source — Thu, 20 Feb 2020 21:13:27 +0900

2. Lower Bound 를 이용한 알고리즘

두번째로 알아볼 알고리즘은 Lower Bound를 이용한 알고리즘이다.

시작하기에 앞서 Lower Bound란 정렬된 배열에서 찾고자 하는 값 이상이 처음으로 나타나는 위치를 말한다.

다음과 같은 배열에서 35의 lower bound는 40 이다.

위의 정의대로 처음으로 나타나는 자신보다 큰값 이라고 생각해도 되고

자신보다 큰 값들중 가장 작은 값 으로 생각해도 된다.

이 lower bound 알고리즘을 이분탐색으로 구현하게 될텐데 여기서는 lis[] 배열을 만들어서 사용할것이다.

lis[i] 의 정의는 (i+1)의 길이를 갖는 최대증가수열을 만들때, 가능한 가장 작은 수를 의미한다.

먼저 전체코드는 다음과 같다

int lis_lowerbound(int n){
    int i,j;
    int len = 0; // 현재 lis 배열의 마지막 원소 인덱스
    lis[0] = arr[0];
    for(i=1;i<n;i++){
        len = len + lower_bound(arr[i],len);
    }
    return len+1;
}


int lower_bound(int target, int len){ // 자신보다 큰 값들 중 가장 작은 값의 인덱스 리턴
    int start,end,mid;
    start = 0;
    end = len;
    if(target > lis[end]){
        lis[len+1] = target;
        return 1; // lis 배열에 새로 추가되었을때(최대증가수열의 값이 증가하였을때)만 1을 리턴해서 최종길이를 1씩 늘려준다
    }

    while(1){
        if(end-start == 1){ // 이분탐색중 두개의 원소만 남았을때
            if(lis[start] < target){
                lis[end] = target;
            }
            else{
                lis[start] = target;
            }
            return 0; // 기존의 값이 대체된것이므로 0을 리턴해서 최대길이를 늘리지않는다
        }
        if(end == start){ // lis의 원소가 1개일때
            if(lis[end] > target){
                lis[end] = target;
                return 0;  // 기존의 값이 대체된것이므로 0을 리턴해서 최대길이를 늘리지않는다
            }
        }
        mid = (start+end)/2;
        if(lis[mid] < target){
            start = mid;
        }
        else{
            end = mid;
        }
    }
    return 0; // 사실 while내에서 함수가 종료되기때문에 이값은 의미가 없다.
}

위 알고리즘에서 lis_lowerbound 내의 for문의 i가 아래 그림에서의 i이며 한번 for문을 수행할때마다 변화하는 lis[] 배열의 형태를 보여준다

i 가 증가함에 따라 변화하는 lis 배열

여기서 중요한점은 이 알고리즘이 끝난후 lis 배열의 원소개수가 최대증가수열 값을 의미하는것이지 그 배열자체가 최대증가수열을 말하지는 않는다. 즉 위 lis 배열의 최종적인 배열인 [10, 30, 50, 70] 이라는값이 이 예제에서는 우연히 최대증가수열이지만 항상 그것을 만족하지는 않는다. 그렇다면 LIS 의 값과 동시에 그값을 만족시키는 부분수열을 구하려면 어떻게 해야할까? 해당내용은 다음 포스팅에서 다룬다.

위의 과정을 자세히 살펴보면

i = 0
arr[0] = 20 이고 lis가 비어있으므로 20을 넣는다.

i = 1
arr[1] = 40 이고 lis 에서 40보다 큰 수가 없으므로 가장 뒤에 추가한다.

i = 2
arr[2] = 30 이고 lis 에서 30의 lower_bound는 40이 있는 자리이므로 40자리에 30을 넣는다

i = 3
arr[3] = 50 이고 lis 에서 50보다 큰 수가 없으므로 가장 뒤에 추가한다.

i = 4
arr[4] = 10 이고 lis 에서 10의 lower_bound는 20이 있는 자리이므로 20자리에 10을 넣는다

i = 5
arr[5] = 80 이고 lis 에서 80보다 큰 수가 없으므로 가장 뒤에 추가한다.

i = 6
arr[6] = 70이고 lis 에서 70의 lower_bound는 80이 있는 자리이므로 80자리에 70을 넣는다

위의 알고리즘을 사용하면 i가 n번 순회(O(N))하면서 이진탐색(O(logN))을 하므로

O(NlogN) 의 시간복잡도를 가지게 된다.

따라서 이전 포스팅에서 다뤘던 DP를 이용한 N^2 LIS 알고리즘보다 훨씬 빠른 속도를 보이며

1000000의 길이를 가진 랜덤배열에서

약 0.19초만에 LIS 값을 찾아낸다.

n=1000000일때 c언어를 이용한 Lower_bound LIS 알고리즘의 실행속도

[1][LIS : 최장증가수열 알고리즘] - DP 를 이용한 알고리즘 (Longest Increasing Subsequence Algorithm)

Source — Thu, 20 Feb 2020 19:44:12 +0900

LIS Algorithm

LIS 알고리즘 (Longest Increasing Subsequence Algorithm) 은 최장증가수열 알고리즘으로 증가하는 원소들의 가장 긴 부분집합을 찾는 알고리즘이다.

다음과 같이 7개의 숫자가 나열되어있을때

여기서 LIS는

위와같이 20 40 50 80 으로 최대길이는 4이다.

물론 아래와 같은 경우도 모두 LIS에 속한다. (LIS알고리즘에서 최대길이를 구성하는 모든 원소들을 구할경우 아래와같이 가능한 경우의 수가 여려개 일수 있기때문에 백준저지에서는 스페셜 저지로 채점을 한다.)

+ 주의할점은 항상 이전에 선택한 원소보다 커야하기때문에 같은원소역시 연속으로 선택할수 없다.

1. DP(Dynamic Programming) 를 이용한 알고리즘

첫번째로 알아볼 알고리즘은 DP를 이용한 알고리즘이다.

주어진 배열을 arr[], 값을채워나갈 배열을 dp[] 라고 하자.

dp[i] 를 "arr[i]를 마지막 원소로 갖을때 최대증가수열 값" 이라고 정의하자.

전체 알고리즘은 다음과 같다.

int lis_dp(int n){ // dp를 이용한 lis algorithm
    int i,j;
    int max = 1;
    for(i=0;i<n;i++){
        dp[i] = 1;
        for(j=0;j<i;j++){
            if(arr[j] < arr[i] && dp[j]+1 > dp[i]){
                dp[i] = dp[j]+1;
                if(max < dp[i]){
                    max = dp[i];
                }
            }
        }
    }
    return max;
}

위의 알고리즘에서 가장 중요한 부분은 아래의 if문이다.

for(j=0;j<i;j++){
    if(arr[j] < arr[i] && dp[j]+1 > dp[i]){
        dp[i] = dp[j]+1;
        if(max < dp[i]){
            max = dp[i];
        }
    }
}

i 는 0부터 배열의 길이인 n번 순회하면서 dp[i]를 채워나가고

j 는 0부터 i 이전까지 순회하게 된다.

if 문 내의 두 조건을 보면

1. arr[j] < arr[i]

i 이전의 값이 현재 i 보다 작은지 확인하는 부분이다. LIS 알고리즘이 항상 증가하는 수열이여야하므로 이 조건이 필요하다.

2. dp[j]+1 > dp[i]

j 번째 원소를 마지막으로 갖는 최대증가수열이 dp[j]인데 마지막 i값을 끝에 추가했을때 현재까지의 최대값보다 커야하므로 이 조건이 필요하다

따라서 두 조건 모두 만족하게 된다면 해당 해당 j 번째 인덱스에 있는 값이 현재 i 인덱스 값보다 작으며 따라서 i 번째 인덱스 값을 그 뒤에 추가했을때라는 가정하에 가장 최댓값을 가지게 된다.

이 조건에 따라 2중 for문을 다 돌게되면 dp에 있는 값중 가장 큰 값이 최종 답이된다.

위의 코드에서는 max값으로 최대값이 나올때마다 갱신을 해주었다.

위 알고리즘은 O(N^2) 의 시간복잡도를 가진 알고리즘으로 배열의 길이가 100000만 넘어도 매우 오랜시간이 걸리게된다.

따라서 다음에는 Lower bound를 이용한 O(NlogN)의 시간복잡도를 가진 알고리즘을 알아보도록하자.

[백준] python3 입출력 관련

Source — Mon, 17 Feb 2020 16:16:07 +0900

from sys import stdin
import sys
sys.setrecursionlimit(10000000) 

def tile(answer,n,now):
    if(now == 0 or now == 1):
        return 1
    elif(now == 2):
        return 3
    if(answer[now] != 0):
        return answer[now]
    tmp1 = 2*tile(answer,n,now-2)
    tmp2 = tile(answer,n,now-1)
    total = tmp1 + tmp2
    answer[now] = total
    return total

answer = [0] * (251)

for n in map(int, stdin.read().split()):
    print(tile(answer,n,n))

위와같은 문제의 입력을 받을때는 위 코드와 같이 하면 된다.

[1] 소수찾기 - 에라토스테네스의 체

Source — Mon, 10 Feb 2020 17:47:56 +0900

소수의 정의

소수라 함은 자신보다 작은 두개의 자연수를 곱하여 만들수 없는 1보다 큰 자연수 이다.

예를 들어 2, 3, 5, 7 ,11 ... 등이 있다.

소수 구하기

소수를 구하는 대표적인 방법은 고대 그리스 수학자 에라토스테네스가 발견한 <에라토스테네스의 체> 방법을 사용하는 것이다.

이 방법은 2부터 n까지의 자연수 수열에서 가장 앞에 있는 숫자가 소수가 되고 그 뒤로 그수의 배수들을 전부 지운다.

그리고 그 다음 남아있는 숫자가 소수가 되고 또 그 뒤로 그 수의 배수들을 전부 지운다

...

이 과정을 반복하다보면 n까지의 소수들을 찾을 수 있다.

아래 자료를 보면 쉽게 이해가 될것이다.

출처 : 위키백과

이를 코드로 구현하는 것은 어렵지 않다.

아래는 파이썬으로 구현한 코드이다.

n = int(input(""))

arr = list(range(2,n+1))
answer = []
while(len(arr) != 0):
    tmp = arr[0]
    answer.append(tmp)
    arr.remove(tmp)
    for i in arr:
        if(i%tmp == 0):
            arr.remove(i)

print(answer)

[알고리즘][7][백준_1648][Python3] - 격자판 채우기

Source — Thu, 6 Feb 2020 19:20:22 +0900

문제 이해

백준저지에는 이미 n x m의 격자상에 특정 블록을 넣어 채우는 경우의 수를 구하는 문제들이 많다.

2 x N 격자에 2 x 1 , 1 x 2 크기의 타일로 채우는 경우의 수를 구하는 11726번 <2xn 타일링>

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

2 x N 격자에 2 x 1 , 2 x 2 크기의 타일로 채우는 경우의 수를 구하는 11727번 <2xn 타일링 2>

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

3 x N 격자에 2 x 1 , 1 x 2 크기의 타일로 채우는 경우의 수를 구하는 2133번 <타일 채우기>

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

좌우대칭을 고려해야하는 1720번 <타일 코드>

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

위의 타일링 문제들은 기본적인 유형도 있고 조금 응용된 유형도 있으므로 이런 종류의 문제를 한번도 풀어보지 않았다면 위의 문제들을 먼저 풀어보는것을 추천한다.

이번문제는 보통 격자판의 열의 길이를 고정해주는 여느 타일링 문제들과 다르게 행과 열 모두 1~14칸으로 유동적으로 변화한다.

따라서 n,m에 따른 규칙성을 찾기도 어렵고 n,m이 조금만 늘어나도 값이 커지고 직접구해보기도 까다로운 문제이다.

알고리즘 전략

먼저 재귀를 이용해 brute-force로 모든 경우의 수를 파악하는 것부터 해보자.

칸을 채울때 규칙은 다음과 같이 정의한다.

1. [0,0] 에서 타일을 채우기 시작한다.
2. 무조건 아래로 가는방향으로 채운다
2-1 그 칸을 옆으로 채울경우에는 그다음 아래칸으로 가지만
2-2 그 칸을 아래로 채울경우에는 아래로 2칸을 먹으므로 두칸 아래로 움직인다
3. 맨 아래 바닥에 도착하면 한칸 오른쪽 맨위로 이동한다.
4. 1-3 과정을 반복하다가 맨 오른쪽칸을 넘어갔을때 타일을 올바르게 채운 경우들의 합을 구한다.

위의 규칙을 바탕으로

6 x 6 에서 어떤식으로 채워지는지 보자

위와같은 격자판에 위 규칙을 이용해 타일을 채운 경우중 한가지이다.

타일 위의 번호는 위 규칙에 따라 채워진 순서이다.

위에서아래로 그리고 아래에 도달하면 한칸 오른쪽으로 이동해서 또 아래로...

이 과정이 반복되어 타일들이 모두 채워진것을 알수있다.

우리가 첫번째로 해야할 일은 이 과정(brute-force)를 구현하는 것이다.

이과정에서 필자는 열의 개수에 해당하는 n사이즈의 2진수를 이용해서

현재 채우고 있는 행과 그 다음행에서 어느 인덱스가 채워졌고 안채워졌는지를 저장해두었다.

이 과정을 통해 칸을 순회하다가 이미 채워진 칸이면 넘어가고 채워지지 않으면 채우는 방식으로 재귀를 구성하였다.

여기까지 하면 작은 수에서는 문제없이 돌아가지만 수가 커지면 단순 brute-force이므로 시간이 매우 오래걸리게 된다.

이미 답을 알고있는(이미 같은 상황에서 가본적이 있는) 구간을 반복적으로 방문하기 때문이다.

따라서 메모이제이션을 해주어야하는데

단순히 현재 인덱스인 [i,j] 만 고려해버리면 안된다.

왜냐하면 현재 [i,j]는 같아도 앞으로 채울수있는 칸이 다를수도 있기때문이다.( 위에서 2진수를 이용해서 값을 저장한 이유가 이것이다)

따라서 i,j뿐만 아니라 해당행과 다음행의 칸 정보를 가지고있는 2진수를 모두 사용해서 메모이제이션을 해주어야하는데

이 4가지 변수를 모두 고려하면 아주 좋겠지만 n=14고 m=14 일때 필요한 개수가 14*14*2^14*2*14 이므로 메모리 초과의 위험이 있으므로 이진수 두개중 하나만 이용하는 방법을 이용하면 된다.

대신 이렇게 하려면 아무 인덱스에서 막 저장해서는 안되고 맨 위에칸에 방문했을때, 즉 현재 행의 오른쪽 행들이 모두 채울수 있는 비어있는 칸일때 메모이제이션을 이용해주면 된다.

def dp(answer,n,m,i,j,now_state,next_state): # 진행우선방향 : 아래->오른쪽
    tmp1, tmp2 = 0,0
    if(j == m): # 맨 오른쪽 넘었을때
        if(now_state == 1 << n): 
            return 1 # 맨오른쪽을 넘었고 마지막줄을 빈칸없이 다 채웠을때
        else:
            return 0 # 맨오른쪽을 넘었고 마지막줄에 빈칸이 있을때
    if(i == n+1):
        return 0 # 맨 아래 한칸 초과
    if(i == n): # 맨 아래쪽 넘었을때
        now_state = next_state
        next_state = 1<<n
        return dp(answer,n,m,0,j+1,now_state,next_state) # 다음줄로 이동
    else:
        if(next_state == (1<<n) and answer[i][j][now_state] != -1):
            return answer[i][j][now_state]
        if(now_state & 1<<i): # 현재칸이 채워져있다면 다음칸으로 전진
            tmp1 = dp(answer,n,m,i+1,j,now_state,next_state) 
        else:
            tmp1 = dp(answer,n,m,i+1,j,now_state,next_state+(1<<i)) # 옆으로채우기
            if(not(now_state & 1<<(i+1))):
                tmp2 = dp(answer,n,m,i+2,j,now_state,next_state) # 아래로채우기
    total = (tmp1+tmp2)%9901
    if(next_state == (1<<n)):
        answer[i][j][now_state] = total
    return total

n,m = input().split(" ")
n = int(n)
m = int(m)

answer = [[[-1]*(1<<(n+1)) for i in range(m)] for j in range(n)]
now_state = 1 << n
next_state = 1 << n
print(dp(answer,n,m,0,0,now_state,next_state))

타일링 문제는 아니지만 이문제를 풀기전에 미리 풀어서 도움이 되었던 문제가 있다.

5721번 <사탕 줍기 대회> 인데

메모이제이션 방법을 떠올리는것이 까다롭다는 점에서 같이 풀어보면 좋은 문제이다.

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

[알고리즘][6][백준_1670][Python3] - 정상 회담 2

Source — Thu, 6 Feb 2020 11:34:07 +0900

문제 이해

문제자체는 간단하지만 n이 조금만 커져도 경우의수가 커지고 점화식도 쉽게 발견되지 않아 조금은 까다로웠던 문제였다.

서로 팔이 교차하지 않는 것을 중점으로 생각해봐야 할것같다.

알고리즘 전략

점화식에 접근할때 n이 주어졌을때 그 상황들을 분해하려고 고민을 했다.

먼저 n = 8 일때로 먼저 분석을 해보자. ( 편의상 n=k일때 가능한 경우의 수를 dp[k]라고 하자 )

n = 8 일때

이 상황에서 악수를 할수 있는 경우의 수를 찾다보면 한가지 규칙을 찾을 수 있다.

어떤사람과 어떤사람이 악수할때 그 둘 사이에 있는 사람의 수가 홀수가 되면 안된다는 것이다.

첫 사람이 잘못 악수한 경우들 - 나머지사람에서 교차가 무조건 생기게 된다.

따라서 파란색 점을 기준으로 할때 이 사람이 악수 할수 있는 사람은 위의 3점과 자신을 제외한 4개의 점이다.

파란색이 악수 할수있는 점은 다음과 같다.

이제 위의 4가지 경우들 안에서 가능한 모든 경우의 수들을 구한것이 dp[8]이 될것이다.

그런데 맨왼쪽과 맨오른쪽, 그리고 가운데 두가지는 좌우 반전만 되었을뿐 그 내부 구조는 같다.

따라서 4가지상황을 모두 고려할 필요없이 좌측 2개의 상황만 고려해서 경우의 수를 구한뒤 2배를 해주면 된다.

#1

이경우 나머지 6명이 악수하는 경우의 수가 되므로 dp[6] 이될것이다.

다음과정에서 이해하기 쉽게 dp[0]*dp[6]이라고 하자 (dp[0]은 0명이 악수하는 경우의 수 이므로 1)

#2

이경우 악수한 선 기준으로 좌측과 우측으로 보면

좌측은 2명이 악수하는경우 dp[2]

우측은 4명이 악수하는경우 dp[4]

이 둘이 독립이므로 dp[2]*dp[4]가 될것이다.

따라서 정리하면

dp[8] = ( dp[0]*dp[6] + dp[2]*dp[4] ) * 2

가 될것이다.

위 예시를 보면 8일때를 구하는데 2,4,6일때의 경우가 모두 쓰였다.

몇가지 경우를 더 살펴보면

dp[n]을 구할때 dp[n-2-k]*dp[k] + ... 의 꼴이 나오는것을 알수 있고

또한 n이 4의 배수일때는 위와같이 전체 구한경우의수에 2를 곱해서 최종 답을 도출해냈지만

그렇지않은 수 (10, 14, 18 등등.. ) 에서는 마지막 dp[(n-2)/2]*dp[(n-2)/2] 빼고 2배를 해야함을 알수있다.

n = int(input(""))

dp = [0] * 10001
dp[0] = 1
dp[2] = 1
dp[4] = 2
i = 6
while(i <= n):
    total = 0
    for j in range(i//4): # n이 4의 배수던 아니던 공통이다
        j = j*2
        total = total + dp[j]*dp[i-j-2]*2

    if(i%4 == 2): # n이 4의 배수가 아닐때만 아래경우를 더해주어야한다
        total = total + dp[(i-2)//2]*dp[(i-2)//2]
    dp[i] = total%987654321
    i = i+2

print(dp[n])

보통 점화식에서 n을 구할때 n-1이나 n-2까지만 고려하면 구할수 있었는데

이문제같은경우 n을 구할때 그 이전에 구했던 n-k들을 모두 이용했다는 점에서 조금 까다로웠다.

[알고리즘][5][백준_1103][Python3] - 게임

Source — Sun, 2 Feb 2020 15:35:10 +0900

문제이해

n x m 의 보드에 숫자들이 주어지고 특정지점에서 출발해서 특정조건에 따라 상하좌우로 이동하며 최대,최소의 경우를 구하는 전형적인 문제이다. 다만 여기서는 무한번 움직인다면 -1을 출력해야하므로 이부분이 까다로울수 있다.

알고리즘 전략

[0][0] 지점에서 시작해서 해당칸의 숫자만큼 상하좌우로 이동할수 있으므로 모든 경우를 확인해봐야한다.

따라서 재귀함수를 이용한 brute-force 와 메모이제이션을 이용해 DP로 해결하면 될것같다.

문제에따르면 최대한 보드 내에서 많이 움직여야하는데 보드바깥으로 나가거나 H를 만나면 종료되므로 해당조건으로 설계하면 이부분은 간단하다.

중요한 부분은 무한번 움직이는것을 어떻게 캐치해낼것인지이다.

쉽게생각하면 이런경우를 떠올릴수 있다.

위 상황은 1-3을 보면 [3][0]과 [3][2] 에서 무한루프가 생기는것을 알수있다.

그렇다고 단순히 직전에있던 좌표와 현재좌표만 비교해서는 안된다.

이경우 [3][0]에서 [3][4] [1][4] [1][1] [3][1] 4칸을 거친후에 다시 [3][0]으로 돌아오게된다. 이또한 무한루프이다.

이런 무한루프를 캐치해낼수 있는 방법은 원소가 0인 n x m 의 2차원리스트(tmp라고하자) 를 만들고 어떤 칸에 접근할때 해당 i , j 인덱스가 0인지 1인지(기본이 0이므로 0이면 아직 방문을 안한상태, 1이면 방문을 한상태로 가정) 확인해서 0이라면 해당 칸의 인덱스를 1로 바꿔주고, 1이라면 이미 방문했는데 또 방문한것이므로 무한루프임을 알수있다.

그런데 m x n 칸에서 움직일수 있는 경로의 가지수가 매우 많은데 같은 칸을 방문했더라도 다른 경로라면 서로 충돌이 일어나서는 안된다.

따라서 재귀를 돌때 해당칸의 방문상태를 확인하고, 다시 미방문으로 처리해주는 순서가 매우 중요하다.

재귀에서는 return을 만나기전까지는 하나의 경로를 의미하므로 return을 만나기전까지는 tmp 배열의 값을 0으로 다시 초기화할필요가 없다. 하지만 return을 만난다면 무한루프임을 확인했거나 경로가 없어서 종료해야하는 상황이므로 return 하기전에 방문했던 해당 칸의 tmp를 0으로 다시 바꿔주어야한다.

import sys
sys.setrecursionlimit(10000000) 

def dpp(check,maze,dp,i,j,n,m,bi,bj,first):
    if(i < 0 or j < 0 or i > (n-1) or j > (m-1)):
        return 0
    if(maze[i][j] == 'H'):
        return 0
    if(check[i][j] == 0):
        check[i][j] = 1
    else:
        return "inf"
    maximum = 0
    if(dp[i][j] != -1):
        check[i][j] = 0
        return dp[i][j]
    tmp1 = dpp(check,maze,dp,i+maze[i][j],j,n,m,i,j,first)
    tmp2 = dpp(check,maze,dp,i,j+maze[i][j],n,m,i,j,first)
    tmp3 = dpp(check,maze,dp,i-maze[i][j],j,n,m,i,j,first)
    tmp4 = dpp(check,maze,dp,i,j-maze[i][j],n,m,i,j,first)
    if(tmp1 == "inf" or tmp2 == "inf" or tmp3 == "inf" or tmp4 == "inf"):
        check[i][j] = 0
        dp[i][j] = 'inf'
        return "inf"
        # "inf"는 무한루프가 생겼음을 의미하며 하나라도 inf가 있다면 어떤경로가 더 최대인지 상관없이 inf만
        # 리턴하게되며 최종 리턴도 inf가 되어 마지막에 -1을 출력하게 된다.
    maximum = max(tmp1,tmp2,tmp3,tmp4)+1
    dp[i][j] = maximum
    check[i][j] = 0
    return maximum

n,m = input().split(" ")
n = int(n)
m = int(m)
maze = [[0]* (m+1) for i in range(n+1)]
check = [[0]* (m+1) for i in range(n+1)]

for i in range(n):
    a = input()
    for j in range(len(a)):
        if(a[j] != "H"):
            maze[i][j] = int(a[j])
        else:
            maze[i][j] = a[j]

dp = [[-1]* (m+1) for i in range(n+1)]
first = False
final = dpp(check,maze,dp,0,0,n,m,0,0,first)
if(final == "inf"):
    print(-1)
else:
    print(final)

[알고리즘][4][백준_2482][Python3] - 색상환

Source — Wed, 15 Jan 2020 23:12:33 +0900

문제이해

문제에서는 다채로운 색이 등장하지만 단순하게 n등분 되어있는 원에서 인접하지않게 k개를 색칠하는 경우의 수를 구하는 문제이다.

알고리즘 전략

알고리즘 구현을 위한 첫걸음은 노트북에서 잠시 손을 내려놓고 펜과 종이로 직접 구해보는것이다.

무언가 규칙성이 있을것같았고 점화식이 있을것같았다.

N=6 K=2 일때의 경우로 생각해보자

6개의 칸이 있고 2칸을 이웃하지않게 색칠하는 경우의 수를 구하는 문제이다.

이를 편의상 앞으로 color(6,2) 라고 하자

color(6,2)를 구하기 전에 color(5,2) 를 한번보자

color(5,2)는 다음과 같이 5가지이다

여기서 마지막 칸을 두개로 쪼갠다면 다음과 같다.

바로 위의 5가지 경우는 color(6,2) 의 경우의 수들중 일부이다.

color(6,2) = color(5,2) + A

이런식으로 점화식이 될것만 같은 느낌이온다.

그렇다면 나머지 A는 어떻게 접근해야할까?

한번 역으로 접근해보자.

color(6,2)의 모든 경우는 9가지로 다음과 같다.

잘 살펴보면 위의 5가지가 color(5,2)와 같은 형태임을 알수 있다.

그렇다면 아래 4가지는 어떻게 도출해내는것일까?

먼저 전에 color(5,2)로부터 5개를 추출해왔을때로 돌아가보자 현재 5개까지는 6번째구역이 생기기전 5개의 구역만으로 만든 경우의수 이므로 마지막 6번째자리를 채운 경우의수가 빠져있다. 그경우가 바로 바로 위그림에서 아랫줄에서 오른쪽 3개이고 마지막으로 아랫줄 맨왼쪽 하나가 남아있다.

새로추가한 색을 무조건 하나 칠한다고 가정해보자

다음은 color(4,1)의 경우이다

여기서 color(6,2)의 아랫줄 4개를 대입해보면 다음과같다

먼저 case 2의 경우 새로추가된 a(위 그림에서 빨간글씨 a) 를 반드시 칠한다는 조건하에 가능한 경우의 수이다.

여기까지는 좋다

그러나 case 1 에서 이런 의문점이 들어야한다.

A에서는 a를 무조건 칠하는 경우의 수라고 했는데 왜 case1 에서는 a가 색칠되어있지 않는지?

사실 정확히 말하자면

case 1에서 a에 색이 칠해졌어야 맞는것인데 그러면 그 오른쪽과 맞닿아 버리기 때문에 한칸 왼쪽으로 옮긴것이다.

이것이 왜 가능한가?

천천히 생각해보면 우리는 처음에 6칸짜리의 경우의 수를 고려하고 있고 현재는 4칸에서의 경우의 수를 보고있다.

사실 color(5,2)의 측면에서는 a 한칸이 추가된것이지만

color(4,1)의 입장에서는 a와 b 두칸이 추가된 것이다. 이얘기는 원래 color(4,1)의 경우에서 c 와 f는 본래 동시에 칠해질수 없는 구역이다.

따라서 c와 f 둘중 최대 한구역만 색칠되어있으므로 만약 c구역이 칠해져있는 경우면 b를, 그렇지 않다면 a를 칠할수 있는것이다.

여기서 한가지더 생각해볼 부분이 있다.

위의 그림에서 두번째상황일때(a,d 가 칠해져있을때) a말고 b를 칠할수도 있으니 c, f 두곳 모두 비어있다면 a,b모두 칠할수 있으므로 경우의수가 두개여서 color(4,1)보다 커져야 되는것 아닌가?

하지만 신기하게도 a를 못칠하는 경우가 아닌데 b대신 a를 칠해버리면 color(5,2)에서 구한 것과 중복이 발생한다.

그 이유는 case 1 에서 a대신 b를 칠해도 중복이 발생하지 않는 이유에 있다.

바로 color(5,2) 관점에서 봤을 때 a가 없다면 사실 b와 c는 붙어있는 구간이므로 둘다 색칠할수 없는 경우이다. 따라서 이는 어디에서도 중복되지않고 첫 경우이므로 옮길수 있는것이다.

지금까지 한 내용을 정리하면 정리하면 다음과 같다

따라서

color(n,k) = color(n-1,k) + color(n-2,k-1) 로 일반화 할수 있다.

표를 조금만 그려보면 알수 있듯이

k = 1일때는 항상 경우의수가 n을 따라가며

n/k = 2일때는 항상 두가지 경우만 존재한다

이를 이용해서 최종적으로 코드를 작성하면 다음과 같다.

import sys
sys.setrecursionlimit(10000000) 

def color(n,k,answer):
    if(n/k == 2):
        return 2
    if(k == 1):
        return n
    if(answer[n][k] == 0):
        total = color(n-1,k,answer) + color(n-2,k-1,answer)
        answer[n][k] = total
        return total
    else:
        return answer[n][k]
        
n = int(input(""))
k = int(input(""))

answer = [[0]*(n+1) for i in range(n+1)]

if(n/2 < k):
    print(0)
else:
    print(color(n,k,answer)%1000000003)

사실 이문제는 몇가지 케이스를 직접 구해보고 점화식을 유추해서 풀수도 있지만 왜 그런 점화식이 나오게 되는지 본질을 공부하는것이 나중에 이보다 더 심화된 문제가 주어졌을때 그 연관성을 스스로 유추할수 있는 능력을 키워준다고 생각한다.

그런 관점에서 이 문제는 생각하는 힘을 길러주는데 아주 좋은 문제인것 같다.

[알고리즘][3][백준_2228][Python3] - 구간 나누기

Source — Wed, 15 Jan 2020 21:28:01 +0900

문제이해

설명에 앞서 문제에 제시된 M(1≤M≤⌈(N/2)⌉) 에서

⌈x⌉ 기호는 x보다 작지않은 최소 정수를 의미한다.

예를들어 N=10 M=3일때 가능한 조합들중 일부는 다음과같다.

알고리즘 전략

가장 쉽게 떠올릴수 있는 방법은 모든 경우의 수를 전부 해보는것이다.

단 일반 재귀로 작성하면 재귀호출만 해도 말그대로 2^N 만큼의 시간복잡도를 가지므로 중복호출되는 함수는 그 값을 미리 메모이제이션을 해두고 바로 값을 불러오도록 처리를 하면 될것이다.

또한 이 문제는 k번째 값을 선택할지말지 고를때 그 앞의 (k-1)개의 선택 현황에 따라 선택지가 달라질수 있다. 즉 앞의 상황과 독립적이지 않다는 것이다. 만약 앞에서 주어진 구간개수를 모두 만들었다면 k이후로는 모든 수를 선택하지 못할수도있다.

여기서 앞에서 주어진 구간개수를 모두 만들었어도 만약 직전에 k-1번째의 값을 만약 선택했었다면 k를 넣을수도 있을것이다.

왜냐하면 k-1까지 선택했다는것은 만약 M=3일때 세번째 구간의 마지막이 k-1번째라는것이기 때문이다.

따라서 k부터 특정 k+i 까지 넣을수도 있다는의미이고 대신 k 이후로 선택하지 않은 숫자가 존재한다면 그 이후로는 전부 선택하지 못할것이다.

정리하자면 k번째 인덱스값을 선택할지 말지 정할때 우리가 알아야 할 값들은

1. 현재 몇개의 구간을 더 만들수 있는지

2. 직전에 값이 선택되었었는지 아닌지

이 두가지이다.

이 변수들이 코드에서는 remain 과 state로 기술되어있다.

이 문제의 경우 재귀호출을 함에 있어서 필요한 파라미터들은 다음과같다.

arr = 처음에 주어지는 N개의 숫자들을 담고있는 리스트
answer = 메모이제이션을 위한 리스트(초기값은 'no' 이며 해당값이 존재하면 그값을, 존재하지않으면 None 으로 저장된다)
n = N
now = 현재 선택할지말지 결정해야할 index 번호
state = 직전에 숫자를 선택했는지(0) 안했는지(1) 알려주는 변수
remain = 앞으로 만들수있는 구간의 개수

메모이제이션을 통한 재귀적 동적계획법에서 중요한 것은 딱 두가지이다.

종료조건과 분류이다.

1. 종료조건

만약 N,M이 주어졌을때 0번째 index값부터 시작한다면
그 값을 선택할지말지 두가지 선택권 있을것이다.

그리고 각각의 경우에따라 1번째 index값을 연속해서 선택할수도
아니면 선택하지 않을수도 있다.

이런식으로 재귀를 통해 다음함수를 실행하다가 n-1번째 인덱스값인 마지막값에 도달하게 되면 현재까지 만들어온 상황이 가능한 상황인지 불가능한 상황인지 판단후 불가능하다면 None을, 가능하다면 마지막 값을 넣을지 말지 적절하게 판단해서 리턴시켜야한다.

2. 분류

이 분류는 위의 빨간 글씨로 쓰인 부분과 연관이 있다. 아래 코드에서는 총 4가지 경우가 나타나있다.
k번째를 선택할지 결정할때

1. k-1 번째를 선택하지않았고 k번째도 선택하지않는 경우
2. k-1 번째를 선택하지않았고 k번째는 선택하는 경우
3. k-1 번째를 선택했고 k번째는 선택하지않는 경우
4. k-1 번째를 선택했고 k번째도 선택하는 경우

사실 1,3번은 호출하는 함수가 같지만 편의상 따로 분류해두었다.
어차피 처음에 if문에서 1,3은 갈라지므로 둘다 한 함수내에서 호출되는 일은 없다.

최종 코드는 다음과 같다

import sys
sys.setrecursionlimit(10000000) 

def divide(arr,answer,n,now,state,remain): 
    # state : 0 : 직전에 선택하지 않았다. 1 : 직전에 선택했다.
    # remain : 앞으로 만들수있는 구간 개수
    if(now == n-1):
        if(remain == 0):
            if(state == 1 and arr[now] > 0):
                return arr[now]
            else:
                return 0
        elif(remain == 1 and state == 0):
            return arr[now]
        else:
            return None
    if(remain < 0):
        return None

    if(answer[now][remain][state] != 'no'):
        return answer[now][remain][state]
    tmp1 = (-1) * float('inf')
    tmp2 = (-1) * float('inf')
    if(state == 0):
        tmp1 = divide(arr,answer,n,now+1,0,remain)
        tmp2 = divide(arr,answer,n,now+1,1,remain-1)
    else:
        tmp1 = divide(arr,answer,n,now+1,0,remain)
        tmp2 = divide(arr,answer,n,now+1,1,remain)

    if(tmp1 == None or tmp2 == None):
        if(tmp1 == None):
            if(tmp2 == None):
                final = None
            else:
                final = tmp2 + arr[now]
        else:
            final = tmp1
    else:
        final = max(tmp1,tmp2+arr[now])
    answer[now][remain][state] = final
    return final

n, m = input().split(" ")
n = int(n)
m = int(m)

arr = []
answer = [[['no' for col in range(2)] for row in range(m+1)] for depth in range(n+1)]
for i in range(0,n):
    x = int(input(""))
    arr.append(x)

print(divide(arr,answer,n,0,0,m))

[알고리즘][2][백준_2629][Python3] - 양팔저울

Source — Tue, 14 Jan 2020 19:46:26 +0900

문제이해

이 문제에서 헷갈릴수 있는 부분은 주어진 추들을 모두 사용할 필요가 없다는 것이다.

예를들어 추가 1g 3g 5g짜리가 있다면, 5g짜리 하나만 사용해서 5g짜리 구슬을 측정할수있다.

알고리즘 전략

따라서 예를들어 3개의 추(1g, 3g, 7g)를 가지고 있다고 할때,

첫번째 추(1g)의 경우 세가지 선택권이 있다.

1. 왼쪽저울에 놓는다

2. 오른쪽저울에 놓는다

3. 저울에 아예 올리지 않는다.

그리고 각각의 경우에따라 두번째 추(3g)도 역시 세가지 선택권이 있다.

1. 왼쪽저울에 놓는다

2. 오른쪽저울에 놓는다

3. 저울에 아예 올리지 않는다.

마지막추도 역시 동일하다

1. 왼쪽저울에 놓는다

2. 오른쪽저울에 놓는다

3. 저울에 아예올리지 않는다.

따라서 3^3 만큼의 경우의수가 존재한다.

이를 일반화하면 n개의 추가 주어질때 3^n만큼의 경우의 수가 존재한다.

이 문제에서 n = 30까지 이므로 모든 경우의수를 순수하게 다 돌다가는 제한시간 1초를 넘어 하루가 걸릴지도 모른다.

여기서 시간을 줄일수 있는 방법은 재귀를 돌면서 중복되는(이미 간적이 있어서 갈필요가 없는) 부분을 체크해서 stop하고 다음으로 넘어가는 방법을 사용하면 된다.

그러기 위해서는 어떤상황에서 중복이 발생하는지 알 필요가 있다.

하나의 예를 보자

n = 9이고

1g 2g 3g 4g 5g 6g 7g 8g 9g 의 추가 있다고 할때

# 첫번째 상황

현재까지

왼쪽저울에 1g 2g 3g 을

오른쪽 저울에 4g을 올렸고

(5g추는 사용하지 않았다)

6g 추를 올리기 전상황이라고 하자

# 두번째 상황

현재까지

왼쪽저울에 4g 을

오른쪽 저울에 2g을 올렸고

(1g 3g 5g 추는 사용하지 않았다)

6g 추를 올리기 전상황이라고 하자

첫번째상황과 두번째 상황 구체적인 상황은 다르다.

먼저 양쪽의 저울의 각각의 무게합도 다르며, 좌,우를 구성하는 추의 구성도 다르다.

하지만 둘은 같은 경우이다.

이유는

왼쪽에 100g 오른쪽에 200g의 추가 있다면 측정할수 있는 구슬의 무게는 100g이다

왼쪽에 150g 오른쪽에 250g의 추가 있다면 측정할수 있는 구슬의 무게도 역시 100g이다

왼쪽 오른쪽 각각 몇g씩 추가 있는지가 중요한것이 아니라 두 무게의 차가 몇인지가 중요하다.

또한 그 100g을 이루고 있는 추가 어떤것인지도 중요하지않다.

20g + 30g + 50g의 구성이던

10g + 90g의 구성이던 구할수 있는 구슬의 무게가 100g인것은 변함이 없다.

따라서 현재까지 왼쪽,오른쪽 저울에 올라간 총 무게의 차값과 현재 몇번째 추를 사용할 차례인지 알면 그 뒤로 더 진행을 해봐야하는지 말아야하는지 알수 있다.

#1 #2 두 상황모두

양쪽 저울의 차 = 2g

현재 사용할 추의 순번 = 6번째 추(6g)

따라서 (2,6) 의 경우라고 볼수 있고 한번도 구한적이 없다면(처음이라면) 재귀를 돌면서 가능한 무게종류들을 리스트에 넣어주면되고

이미 구한적이 있다면 stop하고 다음 경우로 넘어가면 된다.

이제 코드를 보면서 최종적으로 설계를 해보자

def scale(n_list,n,now,left,right,possible):
    new = abs(left-right)
    if(new not in possible):
        possible.append(new)
    if(now == n):
        return 0
    if(answer[now][new] == 0):
        # 저울의 왼쪽에 놓는경우
        scale(n_list,n,now+1,left+n_list[now],right,possible)

        # 저울의 오른쪽에 놓는경우
        scale(n_list,n,now+1,left,right+n_list[now],possible)

        # 저울에 아예 안놓는경우
        scale(n_list,n,now+1,left,right,possible)
        
        answer[now][new] = 1
    
n = int(input(""))
n_list = list(map(int, input().split()))
m = int(input(""))
m_list = list(map(int, input().split()))
possible = []
answer = [[0]*15001 for i in range(n+1)]


scale(n_list,n,0,0,0,possible)
for i in range(0,len(m_list)):
    if(m_list[i] in possible):
        print("Y",end=' ')
    else:
        print("N",end=' ')

[알고리즘][1][백준_1339][Python3] - 단어 수학

Source — Tue, 14 Jan 2020 01:14:37 +0900

문제이해

이 문제의 포인트는 단어의 자릿수에 따라 해당 알파벳의 파워가 달라진다는 것이다.

예를 들어

GCF + ACDEB 의 경우

ACDEB라는 단어는 5글자로 A,C,D,E,B에 각각 9,8,7,6,5 를 대입해주면

98765 라는 숫자가 나온다.

즉 A에는 9를 넣고 B에는 5를 넣었는데 결론적으로

A = 90000 B = 5가 된 셈이다.

즉 단어의 길이가 길면서 앞쪽에 있는 알파벳들이 가지는 영향력이 크다는 의미이다.

따라서 ACDEB라는 단어가 주어졌을때 각각의 알파벳이 0~9중에 어떤 숫자를 배정받게 될지는 모르지만 확실한것은

각각 배정받은 숫자에서

A는 10000배의

C는 1000배의

D는 100배의

E는 10배의

B는 그 숫자만큼의 영향력(전체 합의 수치를 바꿔주는)을 가지게 된다.

알고리즘 전략

따라서 단어들이 주어졌을 때 각각의 알파벳들이 가지는 영향력의 크기들을 모두 더해서 배열에 저장해놓은뒤 그 영향력이 가장 큰 순서대로 9,8,7,6... 을 배정해주고 그 최종 합을 구해주면 그 답이 수의 합을 최대로 만드는 숫자가 될것이다.

n = int(input(""))
arr = []

answer = []
for i in range(0,100):
    answer.append(0)

for i in range(0,n):
    x = input("")
    arr.append(x)

# 단어의 위치에 따라 각각의 알파벳들의 영향력들을 누적해서 배열에 저장해준다
for i in range(0,n):
    for j in range(0,len(arr[i])):
        answer[ord(arr[i][j])] = answer[ord(arr[i][j])] + pow(10,len(arr[i]) -j -1)

ans = []
for i in range(0,100):
    if(answer[i] != 0):
        ans.append(answer[i])

# 최종적으로 등장했던 알파벳들의 영향력을 큰 순서대로 정렬해서 9,8,7.. 순서대로 곱한값들의 합을 출력한다
ans.sort(reverse=True)
count = 9
final = 0
for i in range(0,len(ans)):
    final = final + ans[i]*count
    count = count - 1
print(final)

사실 이 문제에서는 N개의 단어들의 수의 합을 최대로 만드는 프로그램을 만드는것이기 때문에 최종적으로 최대합값만 출력하면된다.

따라서 어떤 알파벳에 어떤 숫자를 배정했는지는 궁금하지 않다.

따라서 마지막 sort부분부터 각각의 알바펫들이 가진 영향력들만 가지고(각각에 해당하는 알파벳이 무엇인지 모른채로) 최종 답을 도출하게 된다.