컴공과고씨

타입스크립트 맵드 타입 - typescript mapped type

시간빌게이츠 — Mon, 17 Feb 2025 12:31:44 +0900

타입스크립트의 맵드 타입

객체 타입을 조작하는 기능이다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// 맵드 타입
 
interface User {
    id: number;
    name: string;
    age: number;
}
 
// 한 명의 유저 정보를 불러오는 기능
function fetchUser(): User {
    //...기능
    id: 1,
    name: "go",
    age: 27,
}
 
// 한 명의 정보를 수정하는 기능
function updateUser(user: User) {
    //... 수정하는 기능
}
 
updateUser({
    id: 1,
    name: "go",
    age: 28
});

cs

만약 이런식으로 유저의 정보를 수정한다고 할때 나이만 수정을 하려면

{ age: 28}을 넣어야하지만 지금처럼 user:User로 타입을 선언해버리면

{ id: 1, name: "go", age: 28 } 이런식으로 기존과 같은 id, name 값을 넣어주어야하는 번거로움이 있다.

이 때 사용하면 좋은 것이 mapped type 이다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// 맵드 타입
 
interface User {
    id: number;
    name: string;
    age: number;
}
 
type PartialUser = {
    [key in keyof User]?: User[key];
}

// 한 명의 유저 정보를 불러오는 기능
function fetchUser(): User {
    //...기능
    id: 1,
    name: "go",
    age: 27,
}
 
// 한 명의 정보를 수정하는 기능
function updateUser(user: PartialUser) {
    //... 수정하는 기능
}
 
updateUser({
   // id: 1, => 생략 가능
   // name: "go", => 생략 가능
    age: 28
});

kcs

mapped type은 일단 interface에서 사용을 하는 것이 아닌 type에서 사용한다.

그리고 [key in keyof User] 에는 될 수 있는 key 값이고 User[key]는 value 값이다.

참고로 keyof 연산자를 사용하면 모든 key를 union 으로 만들어 준다.

keyof User = "id" | "name" | "age" 가 된다.

그럼 결국 key는 "id" 가 될 수 있고 "name"이 그리고 "age" 가 될 수 있다는 뜻이다.

그 다음은 value는 User["id"] => number, User["name"] => string , User["age"] => number가 되는 것이다.

그리고 마지막에 있는 ? 가 모든 프로퍼티를 선택적으로 만들어 준다!

이렇게 되면 updateUser에서 id 와 name을 생략하고 수정할 age만 들어가도 된다.

이렇게 맵드 타입을 이용하면 다양하게 활용할 수 있다.

또 다른예로 readonly를 이용해보면

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// 맵드 타입
 
interface User {
    id: number;
    name: string;
    age: number;
}
 
type PartialUser = {
    [key in keyof User]?: User[key];
}
 
 
type ReadonlyUser = {
    readonly [key in keyof User]: User[key];
}
 
// 한 명의 유저 정보를 불러오는 기능
function fetchUser():  ReadonlyUser {
    //...기능
    id: 1,
    name: "go",
    age: 27,
}
 
const user1 = fetchUser();
// user1.id = 1 => 불가능
 
// 한 명의 정보를 수정하는 기능
function updateUser(user: User) {
    //... 수정하는 기능
}
 
updateUser({
    id: 1,
    name: "go",
    age: 28
});
Colored by Color Scripter

cs

이런식으로 readonly를 앞에 붙여주면 모든 키에 readonly가 적용되면서 user1의 프로퍼티의 값을 고정 시킬 수 있다.

끝

참고: 한 입 크기로 잘라먹는 타입스크립트 - 이정환

타입스크립트 인데스드 액세스타입 - typescript indexed access type

시간빌게이츠 — Mon, 17 Feb 2025 11:43:34 +0900

타입스크립트에서의 인덱스드 액세스 타입

만약에 밑과 같은 Post라는 객체가 있을 때 Post안에 author를 출력한다고 치자

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//인덱스드 액세스 타입
 
interface Post {
    title: string;
    content: string;
    author : {
        id: number;
        name: string;
    };
}
 
const post: Post {
    title: computer ko,
    content: typescript,
    author: {
        id: 1,
        name: go,
    },
};
 
function printAuthorInfo(author: { id: number; name: string}) {
    console.log(`${author.id}-${author.name}`);
}
Colored by Color Scripter

cs

그러면 이런식으로 나타나게 될것이다

그런데 이때 author 프로퍼티안에 age라는 프로퍼티를 추가하라는 수정사항이 생기면 Post 변수에도 추가를 해주어야 하며

함수에도 또 추가를 해주어야 한다.

그런데 이때 함수가 너무 많으면 하나씩 추가 해줘야 하는 번거로움이 생긴다.

이때 사용하면 좋은 것이 인덱스드 액세스 타입을 이용하면 된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//인덱스드 액세스 타입
 
interface Post {
    title: string;
    content: string;
    author : {
        id: number;
        name: string;
    };
}
 
const post: Post {
    title: computer ko,
    content: typescript,
    author: {
        id: 1,
        name: go,
    },
};
 
function printAuthorInfo(author: Post["author"]) {
    console.log(`${author.id}-`${author.name});
}
Colored by Color Scripter

cs

이런식으로 Post 타입에 뽑아내고 싶은 프로퍼티의 타입을 써주면 된다.

그러면 author 객체만 가져올 수 있게 된다.

이렇게 되면 새로운 프로퍼티가 추가되더라도 별도로 함수에 수정이 필요하지 않게 된다.

또한 인덱스 타입은 연결해서 쓸 수 있는데 에를 들면 author의 id만 뽑아내고 싶다면

Post["author"]["id"] 이런식으로도 가능하다

주의해야할 점은

인덱스에 타입을 쓸 때 변수는 들어가면 안된다. 타입만 가능하다.

예를 들면 "author" 대신에 const key = "author" 후 Post[key]는 안된다는 뜻이다.

"author"는 스트링 리터럴 타입이라 가능, key는 값이기 때문에 안된다.

배열에서의 인덱스드 액세스 타입

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//인덱스드 액세스 타입
 
type PostList = {
    title: string;
    content: string;
    author : {
        id: number;
        name: string;
    };
}[];
 
const post: PostList[number] {
    title: computer ko,
    content: typescript,
    author: {
        id: 1,
        name: go,
    },
};
 
function printAuthorInfo(author: PostList[number]["author"]) {
    console.log(`${author.id}-`${author.name});
}
Colored by Color Scripter

cs

이렇게 타입의 배열이 있다고 하면

PostList[number] 이렇게 하면 PostList에서 하나의 Post를 뽑아낼 수 있게 된다.

끝

참고: 한 입 크기로 잘라먹는 타입스크립트 - 이정환

MVC 패턴 간단 이해 [컴공과고씨]

시간빌게이츠 — Mon, 23 Oct 2023 16:54:02 +0900

mvc패턴을 적용해보려고 공부한 내용을 최대한 쉽게 정리해보려고 함

MVC 패턴이란?

model, view, controller의 약자임

하나의 애플리케이션, 프로젝트를 구성할 때 그 구성요소를 3가지 역할로 구분한 것

각각에 대한 간단 설명

모델

- 애플리케이션의 정보인 데이터가 있음 - 백그라운드에서 동작하는 비즈니스 로직(데이터) 처리

컨트롤러

- 컨트롤러를 조작해서 model에 있는 데이터를 가져와 수정 - 사용자의 입력 처리와 흐름 제어, model과 view를 연결 시켜 주는 역할

뷰

- 컨트롤러가 가져온 데이터를 바탕으로 사용자에게 시각적으로 보여줌 - 정보를 화면으로 보여줌

MVC 모델

좀 더 자세히 들어가자

각 파트마다 규칙이 있음

모델의 규칙

사용자가 편집하길 원하는 모든 데이터를 가지고 있어야만 함
뷰나 컨트롤러에 대해서 어떠한 정보도 알지 말아야 함
변경이 일어나면, 변경 통지에 대한 처리방법을 구현해야 함

뷰의 규칙

모델이 가지고 있는 정보를 따로 저장해서는 안됨
모델이나 컨트롤러와 같이 다른 구성 요소를 몰라야 함
변경이 일어나면, 변경 통지에 대한 처리방법을 구현해야 함

컨트롤러의 규칙

모델이냐 뷰에 대해서 알고 있어야 함
모델이나 뷰의 변경을 모니터링해야 함

장점

1. 비즈니스 로직과 UI로직을 분리하여 유지보수를 독립적으로 수행가능하게 함

2. Model과 View가 다른 컴포넌트들에 종속되지 않아 애플리케이션의 확장성, 유연성에 유리함

3. 중복 코딩의 문제점 제거함

요약

Model은 무엇을 할지 정의. 비지니스 로직에서의 알고리즘, 데이터 등의 기능을 처리

Controller는 어떻게 할지를 정의. 요청을 받아서 화면과 Model과 View를 연결 시켜주는 역할을 함

View는 사용자 화면에 보여주는 역할.

수고.

초보자도 쉬운 워드프레스 도메인 주소 설정하는법 [컴공과고씨]

시간빌게이츠 — Tue, 13 Jun 2023 19:40:55 +0900

자 저번글에서 클라우드웨이에서 서버, 워드프레스까지 설치했죠? 안했다면 https://hagisilecoding.tistory.com/159

집으로 따지면 땅사고 집까지 지은거죠. 이제는 주소를 등록해주어야 합니다.

이번글도 겁나 쉽게 설명드릴려고 노력했어요

바로 가시죠.

*가비아는 우리나라 1등 도메인업체여서 사용했음

1. 먼저 가비아 접속

https://www.gabia.com

웹을 넘어 클라우드로. 가비아

그룹웨어부터 멀티클라우드까지 하나의 클라우드 허브

www.gabia.com

2. 오른쪽 위에 로그인 클릭하면 구글, 네이버, 카카오로 쉽게 가입가능해 회원가입 ㄱㄱ해

3. 자 그다음 로그인을 하면 이런 페이지가 떠

자 저 www.뒤에 원하는 주소를 적어주는 거지 이런식으로

그럼 이런식으로 가능한 도메인이 뜰거야 여기서 원하는거 선택하고 신청하기 버튼 클릭해줘

도메인 주소도 서버와 같이 돈을 내야하는데 도메인 주소는 보통 1년 단위로 가격이 책정 되어있어.

한번 할때 더 구입할 수도 있는데 일단 우리는 1년만 하고 나중에 연장하는 식으로 하자.

여기서 기간을 1년으로 설정

밑으로 내려가면 이러한 설정이 나오는데 내 그림처럼 설정해주고 다음단계 클릭

그럼 결재 창이 나올거니까 결재 해주면 됩니다~

자 그럼 여기까지 주소를 샀으니 우리집에 주소를 등록해주는 과정이 있어야겠지?

바로 ㄱㄱㄱ

클라우드 웨이즈 접속 후 로그인

왼쪽상단 servers를 클릭해줘 그 후 자신의 서버 클릭 아이콘쪽 클릭

그럼 저기 Public IP: 하고 자신의 IP가 적혀있을거야 그럼 그걸 클릭 그럼 복사됨

이제 가비아 홈페이지로 와서 그림과 같이 오른쪽 위에 My가비아라고 있지 그걸 클릭해

그 다음 DNS관리 툴 클릭

자신의 도메인 체크 박스 누룬다음 DNS 설정 클릭

자 화면이 뜨는데 난 이미 등록해서 조금 다를거야 어차피 위처럼 똑같이 적어주면되는거지

일단 저 줄이 한줄 밖에 없을건데 레코드 추가 버튼을 누루면 한줄 더 추가 될거야

그리고 첫줄부터 건드릴거는 호스트에 @ 써주고, 그 다음 노란색 위치는 아까 우리가 복사한 public ip를 넣어주면되고

두번째줄은 호스트부분에 www 넣어주고 똑같이 그다음은 public ip를 넣어주면됨 그리고 상태쪽에 확인 버튼 눌러줘( 위 그림에는 수정이라고 되어있어)

그 다음 그 밑에 저장 눌러주면 이 부분은 끝.

자 다시 클라우드 웨이즈로 돌아와서 application에서 자신의 어플리케이션 아이콘 클릭

그 다음 왼쪽에서 Domain Management를 클릭해주면 이런 화면이 나와

여기서 오른쪽에 있는 ADD DOMAIN을 클릭해줘

그럼 이런 창이 뜨거든? 여기에 아까 너가 생성했던 도메인 주소를 입력해줘

예를 들면 learngabia.com 이런식으로 (www안붙여도됨) 그 다음 ADD DOMAIN클릭

그럼 이런식으로 두 개가 나올 텐데 이 중 너가 구매한 도메인 오른쪽에 있는 점3개 있는 버튼을 눌러줘

그럼 Make primary라는게 뜨면 그걸 누루면 다음 창에서 set as primary가 뜰거야 그거까지 클릭하면됨 설정 시간 좀 걸림

자 여기까지 했으면 집 주소까지 등록한거야.

그런데 아마 자기가 등록한 주소를 들어가면 이런 문구가 뜰텐데 이것도 해결하자구

*이 오류는 인증서때문에 뜨는건데 인증서를 인증해주면 없어져. 쉽게 말하면 그냥 보안이 되지 않는 사이트라는 뜻으로 집에 cctv 설치해라 이 뜻임. 그래서 cctv 설치해주자구

자 클라우스 웨이즈에서 어플리케이션 클릭해서 정보창으로 와주고 여기서 왼쪽에 SSL Certificate 클릭해주면

이런 화면이 뜨거든? 여기서 자기 이메일 주소하고 그 밑에는 도메인 주소를 입력하고 INSTALL CERTIFICATE을 클릭됨 시간 좀 걸림

그럼 여기서 왼쪽에 Access Details를 클릭해주면

APPLICATION URL이 밑에 자신의 도메인 주소가 등록되어있고 들어갔을 때 페이지가 뜨면 완료된거야!

여기까지가 도메인 주소를 설정하는 법 끝.

(쿠폰있음) 워드프레스(wordpress), 클라우드웨이즈(cloudways) 시작, 설치하는법 - [컴공과고씨]

시간빌게이츠 — Tue, 13 Jun 2023 19:32:35 +0900

뭐 워드프레스로 6억을 벌었다 이런 말들이 생기고 있죠. 그래서 진짜 쉽고 간결하게 워드프레스 제작 설명할게요. 그냥 따라만 하면 됩니다. 할아버지, 할머니도 할 수 있도록 설명했어요.

정말 쉽고 간단하게 완전 초보 코딩에 코짜도 몰라도 구축할 수 있도록 설명할게욥

글에 중간중간에 *로 추가 설명 부분 달아놓는거는 이해하고 싶은 분들 읽고 아니면 넘어가도 무방합니다.

*자 일단 자신만의 홈페이지를 만들려고 워드프레스를 하는 것입니다.

그렇다면 워드프레스가 뭐냐? 홈페이지를 만드는 것은 집을 짓는 것이라고 생각하면 편합니다.

집을 지을라면 땅이 있어야죠? 땅이 서버라고 생각하면 됩니다. 그리고 이 위에 집을 짓잖아요. 그게 서버에 워드프레스를 설치하는 것입니다. 즉 서버는 클라우드 웨이즈, 워드프레스가 집이라고 생각하면 되겠네요.

먼저 땅사러 갑시다. 참고로 서버는 돈을 내야해요. 월세랑 비슷한 개념입니다. 달에 3만원 정도합니다. 처음 3일은 무료고 밑 링크 타고 들어가면 $25 지원이해줘요. 그러니 한달해보고 런하셔도 될듯합니다. ㅋㅋ

1. 자 밑 cloudways 홈페이지 접속

https://vrlps.co/xo1biw7/cp

Want a 1GB Cloudways server FREE for 2 Months?

Signup with Cloudways now and get $25 Free credits as soon as you signup (enough to get you a 1GB server Free for 2 months).

vrlps.co

2. 홈페이지의 start free 버튼 클릭

그럼 이 페이지가 뜨고 이름 입력, 가입할 이메일 패스워드 입력 그 밑은 원하시는거 하면 되는데 대부분 블로그 하시러 온걸 테니 blogger. 그 밑은 $0~$50 그 후 start free 클릭. 참고로 나중에 이메일 인증해야하니까 로그인 되는걸로 하세염

이런거 뜰텐데 start now 누르시고

여기서 이제 아까 가입할 때 입력했던 이메일로 가보면 cloudways에서 메일 하나 와있을거에요

거기서 acivate my account 클릭해주시면됨 위 그림이 이제 서버를 사기전에 서버의 설정을 어떻게 할지 결정하거에요

여기서 name your managed app, name your managed server 그냥 집이름 짓는거라고 생각하고 쓰면됨 어차피 나중에 바꿀수 있음 적어주고, 그 다음 digital ocean이 아마 기본일 텐데 그거 클릭, 그다음 server size도 어차피 나중에 변경할 수 있고 처음에 많은 사람이 안올거기 때문에 2gb로 설정해주면 됨. 그리고 마지막 location은 san francisco로 설정. 하면 끝

*워드프레스 버전은 그냥 최신으로 냅두면 되고 location은 san francisco가 가장 빠르다는 글이 있어서 그걸로 함

이제 맨 왼쪽 아래에 launch now 클릭하면 됨. 달에 28달러 나간다고 적혀있지? 아마 첫달은 위 링크로 들어가면 25달러 할인 받을 수 있을거야

자 그럼

아마 이런 화면이 뜨면서 서버를 만들기 시작하는데 한 7분 정도 걸림

저 맨 위창 x눌러서 닫고 7분 기다려

자 그럼 위쪽에 보면 3 days 즉 무료기간 3일 남았다 라는 뜻이야 그래서 3일이 지나면 서버가 없어지기 때문에 업그레이드를 해줘야해

그래서 UPGRADE MY ACCOUNT를 클릭해줘 아까도 말했지만 위 링크로 가면 첫달 25달러 지원해줄거야

이런게 뜰거야 영문 주소는 구글에 자신의 주소 뒤에 영문 주소 이렇게 치면 잘 나와 우편번호도 나오니까 POSTAL CODE에 넣어주면됨

그 address칸하고 state /province / region 칸에는 그냥 주소에서 ~~구 ~~길 이정도만 넣어주면됨

그다음 Keep my billing ~~ 체크 표시하면 밑에 복사되고 핸드폰번호만 적어주면됨 +82010......이런식으로 ㅇㅇ

그다음 company에는 회사든 뭐 개인이면 personal해도 됨 그리고 맨 밑에 초록색 버튼 눌러주면 카드정보입력이 나와

자신의 카드 입력해주고 초록색 버튼 눌러주면 적용완료. 이 카드에서 이제 달마다 서버값이 빠져나가는 구조야

자 그럼 맨 위에 보면 servers 와 applications이 있지 server는 땅, applications 은 집이라고 생각하면되

그래서 applications을 클릭해보면

너가 아까 지은 이름이 있을거야 저 goragoraki 쪽을 클릭해바

그럼 Aaccess Details에 자신의 워드프레스 정보가 나오게되는 거지

이럼 여기서 저 빨간색 박스 옆에 아이콘을 클릭하게 되면 자신의 홈페이지 주소로 이동되는거지

저 주소는 아직 임시 주소기 때문에 나중에 .com .co.kr 처럼 사람들이 보기 편한 주소로 등록해줄거야

그냥 집 주소를 등록하는거라고 생각하면되. 그걸 도메인 주소라고 하는데 그건 다음 글에 설명하도록 할게.

여기까지가 서버를 생성하고 워드프레스를 서버위에 설치했다고 보면되는 거지

다음글은 워드프레스 도메인 주소 등록하기 https://hagisilecoding.tistory.com/160

[자료구조] Trie (트라이) c++ 구현, 설명

시간빌게이츠 — Tue, 28 Feb 2023 13:55:17 +0900

Trie(트라이)

트라이라는 것은 문자열 집합을 관리하는 트리이다.

하나의 간선은 하나의 알파벳을 나타내고,

트리를 내려가면서 만나는 간선의 알파벳을 모두 이어주면 원래의 문자열을 얻을 수 있다.

트라이

*그림이 좀 잘못되었는데 문자열 집합 중 abd가 아니라 ad가 맞음.

여기서 T라는 것은 문자열의 끝을 표시하는 것으로 T까지 경로를 이어주면 원래 문자열이 나오게 되는것이다.

그래서 트라이에 들어있는 문자열은 abc, ad, e,eg, f 가 된다.

이러한 트라이는 문자열의 삽입/ 삭제/탐색의 시간복잡도는 O(문자열의 길이)로 해시와 같은 복잡도로 빠른 편에 속한다.

또한 트라이를 응용하여 해시로는 할 수 없는 것들을 할 수 있다.

에를 들면 접두사 찾기 등등. 또한 정렬의 효과를 낼 수도 있다.

구현한 코드는 알파벳이 소문자로 들어올 때 적용이 되는 코드이다.

응용문제

주어진 문자열에서 서로 다른 부분 문자열을 사전순으로 나열 했을 때 K번째 부분 문자열을 구하는 문제.

*최대 문자열의 길이는 400으로 가정함.

전체 코드는 github에 업로드

-> https://github.com/goragoraki/Data-Structure

[자료구조] Segment Tree(세그먼트 트리) c++ 구현, 설명

시간빌게이츠 — Sun, 26 Feb 2023 15:28:26 +0900

세그먼트 트리

세그먼트 트리는 이진 트리로 구성하면됨.

구간의 길이가 1인 구간은 리프 노드가 되고, 나머지 노드는 자식 노드를 합친 구간 합을 들고 있음.

배열의 길이가 N이라면 세그먼트 트리의 노드 개수는 2N - 1 개가 됨.

루트를 배열 1번 부터 시작 한다고 하면 필요한 배열의 길이는 2N이 된다.

Init

처음 세그먼트 배열을 초기화 할 때는 N부터 시작해서 길이가 1인 구간을 N개 만큼 채워넣어준다.

그 후 N-1부터 자식노드의 두 개를 합쳐서 구간의 합을 구하면서 위로 올라가면 위과 같은 그림이 나오게 된다.

Update

만약 중간에 배열의 값이 바뀐다면 노드의 값을 바꿔준 후 부모쪽으로 올라가며 다시 구간 합을 구해서 넣어주면 된다.

[l,r) 구간 합 찾기

구간 합 찾는 과정은 구간의 시작점 노드 l과 끝점의 다음 노드 r에서 부모 노드로 올라가면서, 해당 노드에 적힌 값을 결과값에 더해야하면 더하고, 아니면 건너뛰면 된다.

이때 l노드가 부모 노드의 왼쪽 자식일 경우(인덱스가 짝수)이면 그 위쪽 부모 노드에서 더해도 포함이 되어 상관이 없기 때문에 넘어가 준다. 반면 부모의 오른쪽 자식일 경우(인덱스 홀수)면 그대로 부모로 올라가면 더하면 안되는 구간이 포함이 되기 때문에 먼저 더해준다.

이때 중요한 것은 l 같은 경우 시작 점이기 때문에 만약 홀수라면 더해주고 노드가 오른쪽으로 이동해주고 그 부모로 이동해야 한다.

r같은 경우는 끝점이기 때문에 홀수일 경우 먼저 -1을 해주어서 포함되는 구간으로 이동 후 구간합을 더한 후 그 부모로 이동을 해주어야 한다.

그 후 l과 r이 같아지면 작업이 끝이 나게된다.

이 부분은 직접 그림을 그린 후 하나씩 해보면 이해가 쉽다.

노드 순서

위 그림에서 볼 수 있듯이 노드의 순서가 섞여있다. 왼쪽 자식이 오른쪽 구간을, 오른쪽 자식이 왼쪽 구간을 나타내는 경우도 있고 중간이 끊긴 구간을 나타내는 노드도 있음.

그래서 포화이진트리모양을 이용해서 순서를 정갈하게 해줄 수 있음.

트리에서 첫번째 리프노드의 인덱스를 구해주고 그 리프노드부터 채워주는 것이다.

그리고 나머지 리프노드를 더미 노드로 두고 채워주면 된다.

이 때 리프 노드의 인덱스는 2의 거듭제곱이 되어야 한다.

그래서 리프노드의 시작 인덱스는 N <= 2^(k-1) 를 만족할 수 있는 k의 가장 작은 값이 되면된다.

리프노드의 마지막 인덱스는 2^k -1이 되기 때문에 세그먼트 트리의 개수는 2^k로 잡아주면 된다.

응용 문제

각 구간에서의 최대 값, 최소 값을 구하는 세그먼트 트리 구성하기.

전체 코드는 github에 업로드

1. 구간 합 구하는 세그먼트 트리.

2. 각 구간에서의 최대 값, 최소 값을 구하는 세그먼트 트리.

-> https://github.com/goragoraki/Data-Structure

[자료구조] 힙(Heap), 우선순위 큐(priority queue) c++ 구현, 설명

시간빌게이츠 — Thu, 23 Feb 2023 19:52:40 +0900

힙은 우선순위 큐를 위해 만들어진 자료구조임.

우선순위큐란 완전이진트리인데 부모가 가지는 값은 자식보다 무조건 큰 값을 가지고 있음.( 혹은 무조건 작은 값).

큰 값을 가지는 것을 최대 힙, 작은 값을 가지는 것을 최소 힙이라고 함.

그래서 루트에는 항상 제일 큰 값 혹은 제일 작은 값을 가지고 있는 것이 특징입니다.

최대 힙

기본적으로 구현 같은 경우 배열을 사용하거나 linked를 사용할 수 있습니다.

저는 배열을 사용하여 구현했습니다.

인덱스

루트 노드의 인덱스를 1로 시작하게 하면 (0번 노드는 버림)

부모 인덱스 = (자식 인덱스) / 2

왼쪽 자식 인덱스 = (부모 인덱스) * 2

오른쪽 자식 인덱스 = (부모 인덱스) * 2

이렇게 나타 낼 수 있겠죠. 위 그림에서 99는 인덱스 1, 50은 2, 21은 3 .....이 될 것입니다.

이러한 트리 구조를 만들기 위해서는 삽입과 삭제 부분이 중요합니다.

삽입

배열의 맨 마지막에 데이터를 삽입하고, 힙 구조를 계속 유지하도록 부모와 값을 바꾸면서 올라가는 방법을 사용합니다.

이 방법을 bubble up이라고 부르고 있습니다.

예를 들어 위 그림에서 80이 들어가면 37의 왼쪽 노드로 들어가게 됩니다.

그 후 부모(37) 과 비교하면 80이 더 크기 때문에 37과 바꿉니다. 그 후 50과 다시 비교하여 바꾸어주고 99와 비교했을 때 더 작기 때문에 종료 됩니다.

삭제

삭제 같은 경우 루트(부모)를 제거합니다.

제거 후 트리를 유지하기 위해 제거 할 때 우리는 마지막의 원소를 루트노드로 가져옵니다.

그 후 자신 보다 더 큰 자식 값과 바꾸며 내려갑니다.

예를 들어 위 그림에서 삭제 연산을 하게 되면 99와 9 가 바뀔 것이고(배열의 크기를 -1 하여 99는 삭제)

9는 50과 21 보다 작고 그 중 50이 더 크기 때문에 50과 바뀌게 됩니다. 그 다음 42, 37 과 비교 하여 42와 바뀌게 되고

그 다음 13과 바뀌고 연산이 종료 됩니다.

시간 복잡도

완전 이진트리는 높이가 O(logN).

삽입과 삭제 모두 최악의 경우에 루트부터 리프까지의 값을 모두 비교하기 때문에 시간복잡도는

O(트리의 높이) = O(logN)이 된다.

Library

C++에 queue에 heap을 응용한 priority_queue가 있음.

기본적으로 최대 힙으로 적용 되어있음.

우선순위 큐에 대한 간단 사용법 -> https://hagisilecoding.tistory.com/60

응용 문제(Library 쓰지 않고 구현)

유저의 id와 재산이 주어질 때 우선순위가 높은 10명을 뽑아내는 문제.

* 재산이 클수록 우선순위가 높으며 재산이 동일한 경우 id가 작은 user가 우선순위가 높음.

* id는 순차적으로 증가하며 주어짐.

전체 코드는 github에 업로드

-> https://github.com/goragoraki/Data-Structure

[자료구조] Binary Search Tree c++ 구현 [컴공과고씨]

시간빌게이츠 — Thu, 26 Jan 2023 13:39:31 +0900

트리

트리는 사이클이 없는 연결 그래프로 각 노드가 하나의 부모 노드와 간선으로 연결되어있는 구조이다.

많은 트리가 있는데 그중 binary search tree에 대해서 알아보자.

일단 트리에 구조를 보면

이런 식으로 되어있다.

자신보다 바로 위에 있는 노드를 부모 노드 parent node 라 하고 그 아래에 있는 노드를 child node라고 한다.

맨 위의 노드를 root node라 하고

이 곳부터 level 0 이고 그 밑에 줄이 level 1 이런식으로 내려간다. 지금 예는 level 2 트리인 것이다.

leaf node는 노드가 없는 노드를 말합니다.

ancestor(조상)은 부모 노드로만 이동해서 갈 수 있는 노드들이고

descendent(자손)은 자식 노드로만 이동해서 갈 수 있는 노드들입니다.

subtree(서브트리)는 어떤 노드가 부모 노드 간의 연결을 끊었을 때 만들어지는 새로운 트리를 말합니다.

Binary Search Tree는 원소의 중복을 허용하지 않고, 왼쪽 서브 트리는 자기보다 작은 값을, 오른쪽 서브트리는 자기보다 큰 값을 저장하는 특징이 있습니다.

binary search tree

동적할당 방식으로 구현을 했습니다.

Insert(삽입)

- 왼쪽은 작은 값, 오른쪽은 큰 값 즉, 값을 비교하면서 쭉쭉 들어가다가 NULL이 되면 노드를 삽입해주면 된다.

이때 중요한 것이 재귀로 구현을 할건데 2가지 방법으로 나뉜다.

래퍼런스 타입을 사용하는 것과 return 값을 주어 마지막에 노드가 전부 이어지도록 하는 방법이 있다.

Delete(삭제)

- 삭제 같은 부분은 삭제할 노드를 찾고 그 노드에 다른 대체할 노드를 찾아주는 것입니다.

1. 두 자식 모두 있는 경우

트리는 트리의 구조를 유지해야하고 그래서 왼쪽 서브 트리는 조상 노드보다 작은 값들이고 오른쪽 서브 트리는 큰 값들 입니다. 그래서 삭제할 노드 기준으로 왼쪽 서브트리에서 가장 큰 값과 바꾸어 주거나 오른쪽 서브 트리에서 가장 작은 값과 위치를 바꾸어주고 삭제를 해주면 됩니다.

2. 한쪽 자식이 없는 경우

왼쪽 자식이 없는 경우는 오른쪽 서브트리를 붙여주면된다.

오른쪽 자식이 없는 경우는 왼쪽 서브트리를 붙여주면된다.

트리의 순회

1) pre-order(전위 순회)

cout -> 왼쪽 -> 오른쪽

2) in-order(중위 순회)

왼쪽 -> cout -> 오른쪽

3) post-order(후위 순회)

왼쪽 -> 오른쪽 -> cout

cout은 쉽게 이해하기 위해서 적어놓은 것이고 저건 자신을 방문한다고 보면 됩니다.

이게 무슨 말이나면 트리를 순회할 때 순서로 새로운 노드로 갈 때 마다 저 사이클을 반복한다고 보시면 됩니다.

in-order로 예를 들면 왼쪽 노드로 감 -> 새로운 노드에서 또 왼쪽 .. 계속 왼쪽가다가 null을 만나면 이제 cout (자신노드)

그 후 오른쪽으로 감 만약 오른쪽에 또 노드가 있다면 다시 새로운 노드로 왔기 때문에 왼쪽으로 가는 사이클 반복 이런식으로 된다. 이 부분은 코드로 보면 이해하기 편하다.

Destroy

트리를 전부 삭제하는 것으로 중요한 것은 동적할당을 해주었기 때문에 메모리 해제 부분을 당담한다.

나머지 함수 부분은 코드를 보면서 이해하는 것이 편할 것이다.

* 참고서적 c++ plus data structures

* 코드는 https://github.com/goragoraki/Data-Structure 에서 볼 수 있습니다.

DP - TSP(Traveling Salesman Problem) 최소 여행 경비 c++ [컴공과고씨]

시간빌게이츠 — Thu, 26 Jan 2023 00:36:28 +0900

TSP

한 정점에서 출발하여 다른 정점을 각각 한번씩만 방문하고 다시 처음 정점으로 돌아오는 가장 짧은 경로를 결정하는 것.

*음이 아닌 가중치가 있는, 방향성 그래프를 대상으로 함.

여행을 다 한 후 정점 1로 돌아오는 것으로 가정했을 때

아이디어는 dp[i][A]를 i에서 A에 속한 각 정점을 한번씩 거쳐서 정점 1로 가는 최단 경로의 길이라고 정의하는 것이다.

자 그럼 dp[1][A-{1}] = min(w[1][j] + dp[j][v-{1,j}) j는 2부터 나머지 정점 , w[i][j]는 i부터 j까지 거리.

무슨 말이냐면 정점 1에서 1를 제외하고 나머지 정점을 돌고 1로 돌아오는 것은?

1에서 다음 정점으로 이동한 가중치 + 다음 이동한 정점에서 출발하여 정점 1과 자신을 제외한 정점을 여행한 후 1로 돌아가는 정점이다. 이때 다음 정점이 여러개이기 때문에 모든 다음 정점에 대해서 구한 후 최소값을 구하는 것이다.

그렇다면 이것을 반복하여 다음 정점에 다음 정점 다음 정점 쭉쭉 들어가서 더 작은 문제로 분해가 가능하게 된다.

이때 이미 방문한 정점은 방문 처리를 해 중복으로 방문하는 것을 막아야하는데 이때는 bit mask를 이용하여 막아준다.

비트 마스크 연산을 모른다면 https://hagisilecoding.tistory.com/54 여기서 간단히 보고 오시면 된다.

0000 0000 이런식의 비트가 있고 2번 정점을 방문했다면 0000 0100 이런식으로 표시를 하는 방법이다.

코드로 풀어보면

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#define MAX 17
#define INF 98765432
int dp[MAXN][1<<MAX]; // 부분집합의 개수2^MAX(1<<MAX)
int w[MAX][MAX];
 
int TSP(int st, int visit){
    int &ret = dp[st][visit];
    if(ret != -1) return ret; // 방문 했으면 값 그대로 리턴
    
    ret = INF;
    if(visit == (1 << N) - 1) // 모든 마을 방문 하면 ( (1<<5)-1= 1 0000 - 1 => 0 1111)  
        return ret = w[st][0]; //0번 마을로 돌아옴
    
    for(int j = 1; j < N; j++){
        if(!(visit & (1 << j))){ // 다음 정점이 방문을 안한 곳이면
            int nvisit = (visit | (1<<j)); // 다음 방문할 장소 표시
            ret = MIN(ret, TSP(j, nvisit) + w[st][j]);
        }
    }
    return ret;
}
 
int main(){
    memset(dp, -1, sizeof(dp));
    cout << TSP(0,1) << " "; // 0번에서 시작, 0번 방문 상태 체크 
    return 0;
}
Colored by Color Scripter

cs

시간 복잡도

코드를 보면 TSP 함수를 보면 각 함수는 dp의크기인 n*2^n번 호출이 된다.

여기서 각 마을을 돌았는지 확인해야해서 n-1번 돌아야하니

시간 복잡도는 O(n*n*2^n)이다.

이게 이 문제를 풀 때 가장 빠른 알고리즘이지만 n =40 정도만 되어도 6년 이상 걸린다고 한다.

DP - LIS(Longest Increasing Subsequence) c++ [컴공과고씨]

시간빌게이츠 — Wed, 25 Jan 2023 22:55:23 +0900

최장 증가 수열의 길이(LIS)

다음과 같은 수열이 있을 때 순서를 유지하면서 크기가 점진적으로 커지는 가장 긴 부분의 수열의 길이를 말함.

-> 3,2,6,4,5,1 일 경우는

2,4,5 | 3,5,6 => 즉, 3 이다.

이걸 구하는 알고리즘이 LIS이다.

Brute-force 방법으로 푼다면

길이가 0 일때 모든 부분집합.

1일 때 2일 때 ... 쭉 불가능 할 때 까지 가는 것이다.

이 경우 같은 경우 부분집합의 총 개수가 2^N이기 때문에 O(2^n)이 나오게 된다.

Dynamic programming(DP)

숫자열 - a,b,c,d,e ....

LIS[i] : a,b,c,d,e에서 가장 긴 부분 수열의 길이라 하면

1번 : LIS(i)가 i번째 원소를 포함하지 않는다면, LIS(i) = LIS(i-1)이다.

2번 : LIS(i)가 i번째 원소를 포함한다면?

i번째 원소보다 작은 원소를 그 전에 있던 원소에서 찾는다.

그 전에 있던 원소를 찾기 위해서는 모두 검색을 해야만 찾을 수 있음.

그 중 최대값을 찾아 1증가시켜서 LIS(i)에 저장해주면 된다.

시간 복잡도는 O(N^2)이 됩니다.

ex) {3,2,6,4,5,1}

dp(1) = 1

dp(2) = 1

dp(3) = {3,6} -> 2

dp(4) = {3,4} -> 2

dp(5) = {3,4,5} = 3

dp(6) = 1

코드로 푼다면 이런식이 될 것이다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

int last = 0;
int len = 1;
int prev[10], dp[10];
for(int i =0; i<n; i++){
    dp[i] = 1;
    prev[i] = -1; 
    
    for(int j=0; j<i; j++){
        if(a[j] > a[i])
            continue;
        
        if(dp[i] < dp[j]+1){
            dp[i] = dp[j]+1;
            prev[i] = j;
            if(len < dp[i]){
                last = i;
                len = dp[i];
            }
        }
    }
}
void PrintArray(int pos){
    if(pos<0)
        return;
    PrintArray(prev[pos]);
    cout << a[pos] << " ";
}
void PrintArray(int pos){
    int idx = pos;
    for(int i = 0; idx >= 0; i++){
        ans[i] = idx;
        idx = prev[idx];
    }
    for(int i = dp[n-1]-1; i>=0; i--)
        cout << a[ans[i]] << " ";
}
Colored by Color Scripter

cs

prev는 출력을 위해 i번째 원소를 붙이기 이전의 index를 저장하고 있다.
출력하는 버전이 2개 있는데 재귀로 출력할 경우 stack overflow가 발생할 수 있기 때문에 
되도록이면 for문을 이용하는 것이 좋다.

백준 1753 최단경로 c++ [컴공과고씨]

시간빌게이츠 — Mon, 23 Jan 2023 21:49:25 +0900

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

1753번: 최단경로

첫째 줄에 정점의 개수 V와 간선의 개수 E가 주어진다. (1 ≤ V ≤ 20,000, 1 ≤ E ≤ 300,000) 모든 정점에는 1부터 V까지 번호가 매겨져 있다고 가정한다. 둘째 줄에는 시작 정점의 번호 K(1 ≤ K ≤ V)가

www.acmicpc.net

문제 간단 정리

정점이 주어질 때 시작점이 주어지고 그 시작점으로 부터 각 정점의 최단거리를 출력하는 문제.

문제 해결 방법

다익스트라 알고리즘을 사용하여 쉽게 풀 수 있는 문제이다.

다익스트라를 모른다면 https://hagisilecoding.tistory.com/134 여기서 보고 오시면 쉽게 풀 수 있습니다.

전체 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#include <iostream>
#include <queue>
#include <cstring>
#include <vector>
using namespace std;
int INF = 98765432; 
int dp[20003];
vector<pair<int, int>> v[20003];
void fc(int st){ // 다익스트라 
    memset(dp, INF, sizeof(dp)); // 초기값 
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq; // 우선순위 큐
    pq.push({0, st});
    dp[st] = 0; // 시작정점 거리 0
    while(!pq.empty()){
        int x = pq.top().second; // 현재 정점
        int cost = pq.top().first; // 현재 정점까지 거리
        pq.pop();
        for (int i = 0; i < v[x].size();i++){
            int nx = v[x][i].first; // 다음 정점
            int ncost = cost + v[x][i].second; // 다음정점까지 거리
 
            if(dp[nx] > ncost){ // 다음 정점에 기록된 거리와 비교
                pq.push({ncost, nx}); 
                dp[nx] = ncost;
            }
        }
    }
}
int main(){
    int V, E, K;
    cin >> V >> E >> K;
    int a1, a2, a3;
    for (int i = 0; i < E;i++){
        cin >> a1 >> a2 >> a3;
        v[a1].push_back({a2, a3});
    }
    fc(K);
    for (int i = 1; i <= V;i++){
        if(dp[i] < INF)
            cout << dp[i] << '\n';
        else
            cout << "INF" << '\n';
    }
    return 0;
}
Colored by Color Scripter

cs

백준 1504 특정한 최단 경로 c++ [컴공과고씨]

시간빌게이츠 — Sat, 21 Jan 2023 22:13:07 +0900

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

1504번: 특정한 최단 경로

첫째 줄에 정점의 개수 N과 간선의 개수 E가 주어진다. (2 ≤ N ≤ 800, 0 ≤ E ≤ 200,000) 둘째 줄부터 E개의 줄에 걸쳐서 세 개의 정수 a, b, c가 주어지는데, a번 정점에서 b번 정점까지 양방향 길이 존

www.acmicpc.net

문제 간단 정리

방향성 없는 그래프 주어짐.

1번 부터 n 정점까지 최단 거리로 이동함.

조건은 임의로 주어진 두 정점은 반드시 통과해야함.

그리고 한 번 이동했던 정점은 물론, 한번 이동했던 간선도 다시 이용가능.

1번에서 n정점으로 이동할 때 주어진 두 정점을 반드시 거치면서 최단 경로로 이동하는 길이를 출력하라

경로가 없으면 -1을 출력.

문제 해결 방법

다익스트라를 활용하여 풀면 쉽게 풀 수 있는 문제이다.

다익스트라를 모른다면 https://hagisilecoding.tistory.com/134 한번 보고 오면 이해가 쉽다.

다익스트라를 이용해서 무조건 거쳐야하는 정점까지 최단 거리를 구한후 다시 그 정점 부터 n정점까지

최단거리를 구해 주면 쉽게 해결할 수 있다.

즉, 다익스트라 함수를 총 3번을 써야한다.

예를 들어 목적지 C가 있고 거치는 정점 A B가 있다고 하자.

그럼 다익스트라를 이용해서 출발점 부터 A 와 B까지 최단거리를 구할 수 있다.

그 후 A 부터 C 까지 거리한번 B 부터 C까지 거리를 구해준다.

그 후 출발점-A-C 가 가까운지 출발점-B-C가 가까운지 비교해준다.

이때 전부 갈 수 없는 길이면 -1을 출력한다.

전체 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

#include <iostream>
#include <queue>
#include <vector>
#include <cstring>
using namespace std;
int INF = 98765432;
vector<pair<int, int>> v[802];
int dist[803];
void bfs(int a)
{
    memset(dist, INF, sizeof(dist));
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> q;
    q.push(make_pair(0, a));
    dist[a] = 0;
    while (!q.empty())
    {
        int sum_distance = q.top().first;
        int x = q.top().second;
        q.pop();
        
        if(dist[x] < sum_distance)
            continue;
        for (int i = 0; i < v[x].size(); i++){
            int nx = v[x][i].first;
            int ncost = sum_distance + v[x][i].second;
 
            if(dist[nx] > ncost){
                q.push({ncost, nx});
                dist[nx] = ncost;
            }
        }
    }
}
int mn(int a, int b){
    if(a<b)
        return a;
    else
        return b;
}
int main(){
    int n, e;
    cin >> n >> e;
    int a1,a2,a3;
    for (int i = 0; i < e; i++){
        cin >> a1 >> a2 >> a3;
        v[a1].push_back({a2, a3});
        v[a2].push_back({a1, a3});
    }
    int dt1, dt2;
    cin >> dt1 >> dt2;
    
    bfs(1);
    int To_dt1 = dist[dt1];
    int To_dt2 = dist[dt2];
 
    bfs(dt1);
    int dt1_To_dt2 = dist[dt2];
    int dt1_To_n = dist[n];
 
    bfs(dt2);
    int dt2_To_n = dist[n];
 
    int result;
 
    result = mn(INF, To_dt1 + dt1_To_dt2 + dt2_To_n);
    result = mn(result, To_dt2 + dt1_To_dt2 + dt1_To_n);
    if(result >= INF)
        cout << -1;
    else
        cout << result;
    return 0;
}
Colored by Color Scripter

cs

[자료구조] Quick sort(퀵 정렬) 구현 c++ [컴공과고씨]

시간빌게이츠 — Fri, 20 Jan 2023 18:49:55 +0900

Quick Sort는 배열을 더 작은 하위 배열로 분할하고 해당 하위 배열을 재귀적으로 정렬합니다.

즉, 분할 정복 알고리즘(divide-and-conquer)를 이용한 정렬이라고 볼 수 있습니다.

평균 및 최선의 시간 복잡도는 O(n log n)이고 최악의 시간 복잡도는 O(n^2)입니다. 효율적인 분할 및 무작위화 기술로 인해 버블 정렬 및 삽입 정렬과 같은 다른 정렬 알고리즘보다 빠른 경우가 많습니다. 또한 내부 알고리즘이므로 배열을 정렬하는 데 추가 메모리가 필요하지 않습니다.

Quick sort 구현

1. 배열에서 "pivot" 요소를 선택합니다. 이 요소는 배열을 두 개의 하위 배열로 분할하는 데 사용됩니다. 하나는 피벗보다 작은 요소를 포함하고 다른 하나는 피벗보다 큰 요소를 포함합니다.

ex) 6,9,7,3,5,2,4,1,8 라는 배열이 있다고 할 때 이 중 pivot 을 하나 선택해줍니다.

이 코드에서는 맨 앞쪽 원소를 pivot으로 잡고 있습니다. 그럼 6이 pivot이 되는 겁니다.

2. 배열을 반복하고 피벗보다 작은 모든 요소를 왼쪽으로 이동하고 피벗보다 큰 모든 요소를 오른쪽으로 이동하여 배열을 분할합니다.

ex) 6,9,7,3,5,2,4,1,8 여기서 왼쪽부터 오른쪽으로 가는 변수, 오른쪽 부터 왼쪽으로 가는 변수를 선언해줍니다. 그러면

9부터 확인하면서 9는 6보다 큰 값인데 왼쪽에 있으므로 오른쪽으로 몰아줘야합니다.

그래서 이동하는 것을 멈춰주고 오른쪽에서 확인하면서 8은 6보다 큰 값이고 오른쪽에 이미 있기 때문에 패스 다음은 1 인데 1은 6보다 작음에도 불구하고 오른쪽에 있기 때문에 아까 확인했던 9와 값을 바꾸어 줍니다.

6,1,7,3,5,2,4,9,8 이 되겠네요. 이것을 왼쪽 변수가 오른쪽 변수를 넘어 갈때 까지 반복해 줍니다.

6,1,4,3,5,2,7,9,8 이런식으로 될겁니다.

3. 2번 과정 후 오른쪽 변수는 2가 6보다 작은 수였기 때문에 멈췄을 것입니다.

마지막으로 pivot과 2를 바꾸어주면 2,1,4,3,5,6,7,8,9 이런식으로 만들어져 6기준으로 작은 수와 큰 수를 나눌 수 있는 것이죠. 자 그렇다면 이제는 재귀를 이용하여 6을 기준으로 2부터 5까지 다시 pivot을 정해서 정렬하고 7부터 9까지 다시 pivot을 정해서 정렬해주는 식으로 반복해주면 정렬이 되어지게됩니다.

전체코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

#include <iostream>
using namespace std;
typedef int ItemType;
void Swap(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}
void Split(ItemType values[], int first, int last, int& splitPoint)
{
  ItemType splitVal = values[first]; // pivot point
  int saveFirst = first;
  bool onCorrectSide;
 
  first++;
  do
  {
    onCorrectSide = true;
    while (onCorrectSide)         // Move first toward last.
      if (values[first] > splitVal)
        onCorrectSide = false;
      else
      {  
        first++;
        onCorrectSide = (first <= last);
      }
 
    onCorrectSide = (first <= last);
    while (onCorrectSide)             // Move last toward first.
      if (values[last] <= splitVal)
        onCorrectSide = false;
      else
      {
        last--;
        onCorrectSide = (first <= last);
      }
   
    if (first < last)
    {
      Swap(values[first], values[last]);
      first++;
      last--;
    }
  } while (first <= last);
 
  splitPoint = last;
  Swap(values[saveFirst], values[splitPoint]);
}
 
 
template<class ItemType>
void QuickSort(ItemType values[], int first, int last)
{
  if (first < last)
  {
    int splitPoint;
 
    Split(values, first, last, splitPoint);
    // values[first]..values[splitPoint-1] <= splitVal
    // values[splitPoint] = splitVal
    // values[splitPoint+1]..values[last] > splitVal
 
    QuickSort(values, first, splitPoint-1);
    QuickSort(values, splitPoint+1, last);
  }
}
int main() {
    int arr[9] = { 1,4,6,3,2,9,8,7,5 };
    QuickSort(arr, 0, 8);
    for (int i = 0; i < 9; i++) {
        cout << arr[i] << " ";
    }
    cout << '\n';
    return 0;
}
 
Colored by Color Scripter

cs

* 참고서적 c++ plus data structures

* 다른 자료구조에 대한 코드는 https://github.com/goragoraki/Data-Structure 에서 볼 수 있습니다.

[자료구조] Linked List(링크드 리스트) c++ 구현 [컴공과고씨]

시간빌게이츠 — Thu, 19 Jan 2023 17:43:53 +0900

https://hagisilecoding.tistory.com/140

[자료구조] 리스트(unsorted & sorted list) c++ [컴공과고씨]

* 참고서적 c++ plus data structures * 전체코드는 https://github.com/goragoraki/Data-Structure 에서 볼 수 있습니다. 리스트는 배열과 같이 원소들을 저장하고 있는 것을 말합니다. 이 리스트를 두 개로 나눕니다

hagisilecoding.tistory.com

이 글을 보기 전에 위 링크를 먼저 보고 오시는게 좋습니다.

위 글 처럼 sorted 리스트의 가장 큰 문제점은 삽입과 삭제할 때 발생을 합니다.

예를 들면 1,2,3,4,6,7,8,9,10,11,12,13,14 라는 리스트가 있다고 할 때 5를 삽입한다고 한다면

배열을 이용하여 구현을 했다면 6부터 그 뒤에 있는 모든 원소들을 한 칸씩 밀어주어야 하고 삭제할 때도 마찬가지로

뒤에 모든 원소들을 앞쪽으로 땡겨야 하기 때문에 많은 오버헤드가 발생하게 됩니다.

이러한 문제점을 해결하기 위해 나온 것이 linked list라고 할 수 있습니다.

NodeType

이러한 노드 타입을 여러개를 이어주는 것인데 이때 다음 노드는 next라는 곳이 가르켜 다음 노드로 이동할 수 있게 만드는 것입니다.

그림으로 표현하자면

이런식으로 되어있는 셈입니다.

그리고 중간에 노드를 삽입할 때 어떤 과정을 거치냐면

이런식으로 가르키는 곳을 변경 해주기만하면 쉽게 삽입이 가능합니다.

만약 정렬 리스트라면 앞에서 부터 이동하면서 넣으려는 값보다 큰 값이 나왔을 경우 뒤의 노드의 next를 바꾸어 주어야하기 때문에 전 노드를 가르키고 있는 포인터를 임시로 저장해 두어야 합니다.

그래서 링크드 리스트를 이용하여 비정렬 리스트 같은 경우 중간에 삽입하도록 코드를 구현할 때 배열로 구현하는 것보다 더 많은 이점을 얻을 수 있습니다. 중간의 값을 삭제 할 때도 마찬가지 입니다.

* 참고서적 c++ plus data structures

* 전체코드는 https://github.com/goragoraki/Data-Structure 에서 볼 수 있습니다.

[자료구조] Queue(큐) 구현 c++ [컴공과고씨]

시간빌게이츠 — Sun, 15 Jan 2023 00:47:59 +0900

들어가기 앞서 Linked Queue 구현을 위한 더 쉬운 이해를 위해 스택에 관한 앞 글인 https://hagisilecoding.tistory.com/141 를 보고 오시는게 좋습니다.

큐는 스택과 반대입니다. 스택은 들어간 것이 먼저 나중에 나오지만 큐는 먼저 들어간 것이 먼저 빠져 나온다고 생각하면 됩니다.

그렇기에 구현 할 때도 조금 더 생각을 해주어야 합니다.

스택은 top 변수로 늘려주고 빼주고 하면 되지만 큐 같은 경우는 변수를 두 개 두고 앞쪽 dequeue할 변수 한 개 enqueue할 변수 한 개 총 두개를 컨트롤 해주어야합니다.

문제는 이렇게 하면 Dequeue를 했을 때 낭비되는 칸이 생기게 됩니다.

이런식으로 그래서 %연산을 이용해서 circular(순환) 하도록 만들어 주는 것입니다.

front 변수가 이제 dequeue를 담당하고 rear가 enqueue를 담당하는 변수라 생각하고 똑같이 +1을 해주는데

이때 %를 사용하여 circular하게 해준다.

이거 처럼 배열이 다 차고 만약 dequeue를 했다면 앞쪽에 빈칸이 있기 때문에 앞 공간을 다시 이용해준다.

여기서 우리는 주의할점이 큐가 다 찬것과 비어있다는 것을 구분하기 위해서 한 공간을 비어둔다.

처음 시작 점이 두 변수 둘다 -1이기 때문에 큐가 비어있다는 것은 rear와 front가 같을 때 이다.

그럼 큐가 다 찼다는 것은? front 하고 rear+1하고 같을 때로 정의 한다. 위처럼 말이다.

위 그림 상 front가 가르키는 곳이 비어있지만 저기를 채워버리게 되면 큐가 비어있다는 정의와 가득차있다는 것과 같게 되어 구별이 어려워진다. 그래서 rear+1 이 front와 같은 경우를 큐가 다 찼다고 정의를 해준다.

그럼 하나의 공간만 낭비하고 나머지 공간들은 순환하며 계속 사용할 수 있게 된다.

Linked Queue

위쪽은 dynamic array를 활용한 queue 구현이였다면 이제는 Linked Queue를 구현해보자.

스택과 마찬가지로 NodeType을 사용합니다.

NodeType의 구성은 stack에서의 NodeType 처럼 info와 next가 있습니다.

class에서 변수를 보면 front 와 rear가 있는데 둘다 노드타입을 가르키는 포인터로 선언되어있습니다.

처음 생성자에는 front와 rear를 둘다 NULL로 초기화 합니다.

즉 큐가 비어있다는 것은 NULL입니다.

스택을 이해하셨다면 Linked queue는 더욱 쉽습니다.

Enqueue

Enqueue할 때는 새로운 노드타입을 생성 후에 info에 정보 넣고 next에는 NULL을 넣어줍니다.

그리고 front가 NULL이라면 처음 값을 생성하는 것이기 때문에 front에 새로운 노드를 연결한 후

rear에 연결해주고 NULL이 아니라면 rear->next 즉, 마지막 노드의 next가 새로운 노드를 가르키게 한 후 rear에 새로운 노드를 넣어주면 됩니다.

또한 Linked를 이용한 방법은 순환이 아닌 뒤로 쭉 노드를 연결하는 방식입니다. 그래서 dequeue을 할 때도 맨 앞의 노드를 그냥 삭제하면 되어서 순환 방식을 쓰지 않아도 됩니다. 즉, 가득 찬 상태는 그냥 새로운 노드를 만들때 오류가 나면 try catch 문으로 처리를 해줍니다.

Dequeue

Dequeue 같은 경우 임시 포인터를 만들어 front가 가르키고 있는 노드를 저장해 줍니다. 그 후 front 포인터를 front->next가 가르키고 있는 노드에 연결 해줍니다. 만약 마지막 노드라면 front->next에는 NULL이 저장되어있기 때문에 큐가 비었다는 것은 front가 NULL이 될때라는 것을 알 수 있습니다. 그렇기 때문에 이때는 rear도 NULL로 만들어줍니다.

그 후 임시 포인터를 delete 해주면됩니다.

MakeEmpty

MakeEmpty 함수는 큐를 비우는 것으로 이것은 주의를 해주어야합니다. 마찬가지로 소멸자에 MakeEmpty 함수를 주어 메모리가 누수되는 것을 방지해야합니다. 이거 같은경우 큐가 빌때까지 즉, front 포인터가 NULL이 될때까지 while문을 걸어주고 그 후 는 dequeue하는 거 처럼 임시 포인터를 삭제하는 식으로 진행 해주면 됩니다.

시간복잡도

시간 복잡도

main.cpp

제일 위에 있는 카드를 바닥에 버린다. 그 다음, 제일 위에 있는 카드를 제일 아래에 있는 카드 밑으로 옮긴다.

다음과 같은 동작을 카드가 한 장 남을 때까지 반복하게 된다.

버린 카드들을 순서대로 출력하고, 마지막에 남게 되는 카드를 출력하는 프로그램을 큐를 통해 구현해 놓았다.

예시로 N = 7 일 때는 카드가 위에서부터 1,2,3,4,5,6,7 이 되고 1 버리고 2를 맨 밑으로, 3 버리고 4를 맨 밑으로 ....

하면 1,3,5,7,4,2,6 이 답이다.

전체코드는 https://github.com/goragoraki/Data-Structure 여기에서 볼 수 있습니다.

백준 2630 색종이 만들기 c++ [컴공과고씨]

시간빌게이츠 — Sat, 14 Jan 2023 17:40:52 +0900

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

2630번: 색종이 만들기

첫째 줄에는 전체 종이의 한 변의 길이 N이 주어져 있다. N은 2, 4, 8, 16, 32, 64, 128 중 하나이다. 색종이의 각 가로줄의 정사각형칸들의 색이 윗줄부터 차례로 둘째 줄부터 마지막 줄까지 주어진다.

www.acmicpc.net

문제 간단 정리

NxN의 모눈 색종이가 있을때 각 칸에 1 또는 0이 적혀있음.

모든 숫자가 같아 정사각형이 되지 않으면 4등분하여 색종이를 나누어가면서 정사각형이 될 때 까지 나누었을 때

잘려진 흰색 종이와 파란색 종이의 개수를 구하시오.

*이 문제는 본문에 있는 그림을 보면 더 쉽게 이해가능.

문제 해결 방법

분할 정복(divide and conquer), 재귀를 써서 간단히 풀 수 있다.

먼저 색종이를 보고 값을 체크하며 하나로 이루어져있는지 아닌지를 판단함.

만약 중간에 다른 값이 섞여 있다면 잘라야하는 파트임.

값을 자를 때 한번 자를 때 마다 변의 길이는 1/2이 된다.

예를 들어 n = 8 이면 처음에는 8 그 파트는 4 그 다음은 2 이런식으로 갈 것이다.

이것을 이용해서 파트를 나누었을 때 우리는 4등분을 하고 그것들을 다시 함수에 넣어 색종이를 잘라야하는지

판단하는 것을 반복해준다.

여기서 4등분이란 이런식으로 위쪽에 왼쪽 파트, 위쪽에 오른쪽 파트, 아래쪽에 왼쪽 파트, 아래쪽에 오른쪽 파트로 구성이 되며 이것들을 다시 함수에 넣어 더 잘라야하는지 보는 것이다.

만약 더 이상 자를 필요가 없는 파트는 무슨 색인지 확인 후 색깔 별 총 개수에 +1 해주면 된다.

이 정도로 하고 전체 코드를 보면 더욱 이해가 쉬울 것이다.

전체 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

#include <iostream>
using namespace std;
int arr[129][129]; 
int white = 0; // 흰 종이
int blue = 0; // 파란 종이
void fc(int x, int y, int k){
    bool cut = false; // 잘라야하는지 
    int first_color = arr[x][y]; // 첫번째칸의 색
    for (int i = x; i < x + k;i++){
        for (int j = y; j < y + k;j++){
            if(arr[i][j] != first_color){ // 중간에 다른색이 나오면
                cut = true; // 잘라야함.
                break; 
            }
        }
    }
    if(cut){ // 잘라야하는 색종이면 
        fc(x, y, k / 2); // 위쪽에 왼쪽 파트
        fc(x, y + k / 2, k / 2); //위쪽에 오른쪽 파트
        fc(x + k / 2, y, k / 2); // 아래쪽에 왼쪽 파트
        fc(x + k / 2, y + k / 2, k / 2); // 아래쪽에 오른쪽 파트
    }else{
        if(first_color == 1) // 파란색
            blue++;
        else // 흰색
            white++;
    }    
}
int main(){
    int n;
    cin >> n;
    for (int i = 0; i < n;i++){
        for (int j = 0; j < n;j++){
            cin >> arr[i][j];
        }
    }
    fc(0, 0, n);
    cout << white << '\n';
    cout << blue << '\n';
    return 0;
}
Colored by Color Scripter

cs

[자료구조] Stack(스택) 구현 c++ [컴공과고씨]

시간빌게이츠 — Fri, 13 Jan 2023 19:53:34 +0900

Stack

stack은 단어가 쌓다 뭐 이런 뜻이죠.

말 그래도 쌓는다 이렇게 이해하면 됩니다.

위 그림 처럼 동전을 쌓는다고 생각하고 원소를 하나씩 push (넣는다) 하면 밑에 부터 쌓이게 됩니다.

pop을 하는 것은 원소를 빼는 것이고 stack은 위에서부터 하나씩 빼는 방식을 가지고 있습니다.

stack

스택 클래스는 위 처럼 구성할 것이고 STL 스택을 써보신 분들은 아시겠지만 data type을 stack을 선언할 때 사용자가 정할 수 있습니다. 그것과 똑같이 만들기 위해 template class를 사용하여 data type을 사용자가 설정할 수 있도록 만들었습니다.

그래서 코드를 보시면 template<class ItemType> 으로 선언된 것을 볼 수 있습니다.

Stack을 구현하는 세 가지 방법이 있습니다.

하나는 배열을 이용한 방법(static 방식).

두번째는 pointer를 이용하는 방법 이렇게 말이죠(dynamic 방식).

세번째는 Linked structure를 이용한 방법이 있습니다.

세 가지 모두 구현해 보도록 하겠습니다.

Static Allocation

메모리 공간이 compile time에 결정이 됩니다.

Dynamic Allocation

메모리 공간이 run time에 operator new를 사용할 때 결정이 됩니다.

전체 코드는 https://github.com/goragoraki/Data-Structure 에 주석과 함께 올려두었으니

코드를 참고 하실분은 여기서 보시면 됩니다.

배열

top이라는 변수를 설정해주고 현재 높이를 나타냅니다. -1을 초기값으로 해서 push가 될때마다 +1을 해주고

pop이 될때마다 -1을 해주면 됩니다.

그리고 item을 저장하는 배열을 선언해줍니다. 그리고 push라면 item[top]에 원소 추가 후 top++, pop이라면 top--.

top 함수는 stack 맨 위에 있는 원소를 리턴하는 함수로 그냥 return item[top]을 해주면 됩니다.

Pointer

포인터로 구성할 때도 많이 달라지는 것은 없습니다.

여기에는 생성자에 파라미터를 이용해서 max공간을 잡을 수 있도록 만들어 놓았습니다.

생성자에서

Constructor

이런식으로 items에 동적 할당을 하기 위해서 new라는 operator를 써주시면 됩니다.

그 다음은 배열과 동일 합니다.

Linked structure

이 구현 방식이 3가지 중에서는 제일 어렵다고 생각이 됩니다.

이것을 이해하기 위해서는 pointer에 대한 부분을 잘 이해를 해야지 구현이 가능합니다.

일단 구현하기 앞서 NodeType이라는 것을 이해해 주어야합니다.

또노드 타입을 가르키는 포인터를 잘못 바꾸게 되면 노드 타입이 메모리에 남아 메모리 누수를 일으킬 수 있기 때문에 주의 해야합니다.

NodeType

우리는 이 노드타입이라는 구조체를 연결 시켜 stack을 구성합니다.

이런식으로 말입니다. 하나의 NodeType은 info와 next 변수를 가집니다.

info는 말 그대로 우리가 보관하고 싶은 원소를 저장합니다.

next는 다음 NodeType을 가르키는 포인터 변수입니다. 그렇기 때문에 우리는 이 next를 이용하여 다음 NodeType을 연결시켜 스택을 유지합니다.

Push 함수 구현

항상 pointer를 다룰때는 순서에 주의해야합니다.

먼저 새로운 노드타입의 노드를 생성해주고 그 안에 값들을 채워 넣습니다.

그 후 새로운 노드타입의 next에 topPtr이 가르키고 있던 노드타입을 가르키도록 넣어주고

topPtr을 새로운 노드타입을 가르키게 하면 됩니다.

이렇게 하면 새로운 노드타입을 추가할 수 있습니다.

Pop 함수 구현

tempPtr로 만들어서 top의 노드타입을 가르칩니다.

그 다음 topPtr을 topPtr = topPtr->next로 해서 다음 노드를 가르킨 후 delete를 이용해 맨 앞쪽 노드였던 것을 삭제해주면 됩니다.

시간 복잡도

시간복잡도

main.cpp는

이런식으로 기둥이 있다고 하고 왼쪽에서 볼 때 보이는 기둥의 개수를 출력하는 것으로 만들어 놓았습니다.

Stack을 활용하면 쉽게 풀 수 있겠죠.

전체 코드는 https://github.com/goragoraki/Data-Structure 에 방문해서 봐주시면 됩니다.

다음글은 queue에 대한 설명으로 stack을 잘 이해하셨다면 queue는 쉽게 이해가 가능합니다.

[자료구조] 리스트(unsorted & sorted list) c++ [컴공과고씨]

시간빌게이츠 — Thu, 12 Jan 2023 20:30:57 +0900

* 참고서적 c++ plus data structures

* 전체코드는 https://github.com/goragoraki/Data-Structure 에서 볼 수 있습니다.

리스트는 배열과 같이 원소들을 저장하고 있는 것을 말합니다.

이 리스트를 두 개로 나눕니다.

1. 비정렬 리스트

2. 정렬 리스트.

책에서는 class를 사용하여 리스트에 대해 설명하고 있습니다.

ItemType()

이 class 경우 두 리스트에서

ItemType()

이렇게 구성이 되어있습니다.

리스트에 원소를 넣을 때 우리는 ItemType() 객체를 넣어주는 것입니다.

우리는 Initialize()를 통해서 value에 값을 초기화 합니다. 즉, value 값이 실제 원소 값이 되는 것이죠.

그 생성한 ItemType() 객체를 리스트에 넣어주는 형식인 것이죠.

비정렬 리스트

ㅁㅁㅁㅁㅁㅁㅁㅁㅁㅁㅁ 이런식으로 칸이 있으면 각 칸마다 원소를 넣어주는 것이죠.

정렬를 하지 않기 때문에 그냥 앞에서 순서대로 채워주게 됩니다.

UnsortedType

UnsortedType() 객체의 경우 이런식으로 구성이 되어있습니다.

info가 ItemType()의 객체를 담는 배열이고 length를 이용하여 리스트에 insert를 해줍니다.

InsertItem()은 info[length]에 값을 넣어주고 length의 값을 1을 늘려주면 됩니다.

GetNextItem()은 말 그대로 다음 item 정보를 불러오는 것입니다. 이것은 currentPos를 이용합니다.

currentPos가 초기 -1로 시작하여 함수가 호출되면 currentPos+1을 하고 info[currentPos]의 값을 가져오는 식입니다.

ResetList()는 currentPos를 -1로 만들어 다시 처음부터 리스트의 값을 가져올 수 있게 만듭니다.

DeleItem() 은 삭제하고 싶은 값을 처음부터 읽으면서 찾은 후 삭제합니다.

주의해야할 것은 리스트 중간에 있는 값이 삭제 되면 리스트가 중간에 비기 때문에 이것을 방지하기 위해

맨 뒤에 있는 length-1에 들어있는 값을 삭제 된 자리에 넣어주고 length - 1을 해주어야 합니다.

*정렬이 되어있지 않기 때문에 binary search는 불가합니다.

정렬 리스트

정렬 리스트는 리스트가 정렬이 되어있는 것을 말합니다.

SortedType() 같은 경우는 비정렬 객체와 구성은 같다.

하지만 비정렬 리스트의 insert 부분과 deleltem 함수 부분을 수정하여 정렬 되어지도록 만들어주어야한다.

그래서 insert를 할 때 앞에서 부터 리스트를 검사하면서 더 작은 값이 나올때 까지 이동한다.

값을 찾으면 그 자리의 값 부터 한 자리 씩 쭉 뒤로 밀어주어 자리를 만든 후 값을 넣어준다.

ex) 현재 리스트 : 1234789 넣을 값 : 5

1. 앞에서 부터 리스트 검사 -> 7을 만남 7>5 이므로 멈춤.

2. 5가 들어갈 자리는 만들어 줌. 1234 ㅁ 789.

3. 5를 넣어줌. 1234 5 789 이런식으로 작동한다.

delete같은 경우는 정렬 리스트이기 때문에 binary search를 사용하여 삭제할 값을 찾을 수 있다.

삭제한 후 맨 뒤에 값을 앞으로 땡기면 정렬이 무너지기 때문에 삭제한 뒤의 값부터 모든 원소를 앞으로

땡겨주는 작업을 해주어야한다.

12345678에서 5를 삭제하면

1234 ㅁ 678

1234 678 이런식으로.

시간 복잡도

OPERATION	UnsortedList	SortedList
RetrieveItem ( 값을 찾는 함수)	O(N)	O(N) linear search O(logN) binary search
InsertItem Find Put Combined	O(1) O(1) O(1)	O(N) search O(N) moving down O(N)
DeleteItem Find Put Combined	O(N) O(1) swap O(N)	O(N) search O(N) moving up O(N)

백준 1916 최소비용 구하기 c++ [컴공과고씨]

시간빌게이츠 — Fri, 6 Jan 2023 16:41:19 +0900

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

1916번: 최소비용 구하기

첫째 줄에 도시의 개수 N(1 ≤ N ≤ 1,000)이 주어지고 둘째 줄에는 버스의 개수 M(1 ≤ M ≤ 100,000)이 주어진다. 그리고 셋째 줄부터 M+2줄까지 다음과 같은 버스의 정보가 주어진다. 먼저 처음에는 그

www.acmicpc.net

문제 간단 정리

여러 도시가 있고 그 도시를 다닐수 있는 여러 버스가 있다.

시작 도시에서 도착 도시까지 비용을 최소로 하는 비용을 구하여라.

문제 해결 방법

다익스트라 알고리즘을 사용하면 풀 수 있는 문제이다.

다익스트라를 모른다면 https://hagisilecoding.tistory.com/134 여기서 한번 어떤 알고리즘인지 보고 오면

어떤 식으로 이 문제를 해결할지 눈에 보일 거에요.

전체 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

#include <iostream>
#include <vector>
#include <queue>
#include <cstring>
using namespace std;
int vis[1003]; // 각 도시까지 비용 
vector<pair<int, int>> v[1003]; // <도착도시, 비용>
void fc(int a){
    priority_queue<pair<int, int>, vector<pair<int,int>>, greater<pair<int, int>>> pq;
    // 우선순위 큐 오름차순 정렬
    // <비용, 도착 도시>
    pq.push(make_pair(0, a));  
    vis[a] = 0; // 출발 도시 비용 = 0
    while (!pq.empty())
    {
        int cost = pq.top().first; // 현재 도시까지 비용
        int x = pq.top().second; // 현재 도시
        pq.pop();
        
        // 현 도시까지 비용이 이미 기록된 비용보다 크면 pass
        if (vis[x] < cost) 
            continue;
        
        // x 도시와 이어진 도시들 검사
        for (int i = 0; i < v[x].size(); i++){
            int nx = v[x][i].first; // 다음 도시 
            int ncost = cost+v[x][i].second; // 다음 도시까지 비용
 
            // 기록되어진 비용보다 지금 비용이 더 작다면
            // 큐에 넣어줌 
            if (vis[nx] > ncost){ 
                pq.push(make_pair(ncost, nx));
                vis[nx] = ncost; // 비용 다시 기록
            }
        }
    }
}
int main(){
    int n, m;
    cin >> n >> m;
    
    v[0].push_back(make_pair(0, 0));
    memset(vis, 98765432, sizeof(vis)); // 모든 비용 최대로 
    for (int i = 0; i < m; i++){
        int a, b, c;
        cin >> a >> b >> c;
        v[a].push_back(make_pair(b, c));
    }
    int st, dt; // 출발 도시, 도착 도시
    cin >> st >> dt;
    fc(st); 
    cout << vis[dt]; // dt 도시의 비용 출력
    return 0;
}
Colored by Color Scripter

cs

백준 15686 치킨 배달 c++ [컴공과고씨]

시간빌게이츠 — Thu, 5 Jan 2023 13:04:05 +0900

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

15686번: 치킨 배달

크기가 N×N인 도시가 있다. 도시는 1×1크기의 칸으로 나누어져 있다. 도시의 각 칸은 빈 칸, 치킨집, 집 중 하나이다. 도시의 칸은 (r, c)와 같은 형태로 나타내고, r행 c열 또는 위에서부터 r번째 칸

www.acmicpc.net

문제 간단 정리

N x N 도시에 집과 치킨집이 있음.

한 집과 치킨 집의 거리는 | 집의 행 - 치킨집의 행 | + | 열 - 열 | 이런식으로 계산됨.

각 집과 가장 가까운 치킨 집 사이의 거리를 모두 합한 거리를 도시의 치킨 거리라고 한다.

문제에 M이 주어지는데 M개 만큼 치킨 집을 폐업했을 때 도시의 치킨 거리 가장 작게 되는 도시의 치킨 거리를 구하시오.

문제 해결 방법

간단하게 생각하면 주어진 개수 만큼 치킨 집을 없애고 도시의 치킨 거리를 구하면 된다.

여기서 중요한 것은 어떤 치킨 집을 폐업할 것인가가 핵심이 된다.

만약 1,2,3,4,5 치킨 집이 있고 이 중 2개를 폐업한다고 할 때 중복 없이 폐업하는 경우의 수는

1,2,3 | 1,2,4 | 1,2,5 | 1,3,4 | 1,3,5 | 1,4,5 | 2,3,4 | 2,4,5 | .... 쭉 갈 것이다.

이것을 우리는 조합이라고 한다. n개 중 r개를 뽑는 것이기 때문에.

*이 순열에 관한 문제는 백준에 n과 m 시리즈 문제를 풀면 도움이 될 것이다.

조합을 구현하기 위해 재귀 함수를 통해 구현했다.

조합 구현 방식

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

void combination(int cnt, int next){
    if(cnt == m){ // 순열이 다 찬 경우
        int temp = 0; // 도시의 치킨 거리
        for (int i = 0; i < idx2; i++){
            int mndis = 987654321; // 각 집과 가까운 치킨 집 사이의 거리
            // 도시의 치킨 거리
            for (int j = 0; j < m; j++){
                // 각 집과 가까운 치킨 집 사이의 거리
                 int dis= abs(hx[i] - bbqx[permu[j]]) + abs(hy[i] - bbqy[permu[j]]);
                if(mndis > dis)
                    mndis = dis; // 가장 가까운 치킨집 거리
            }
            temp += mndis;  
        }
        if(result > temp) // 최단의 도시의 치킨 거리일 경우
            result = temp;
    }else{
        // 조합 
        for (int i = next; i < idx; i++){
            permu[cnt] = i;
            combination(cnt + 1, i + 1);
        }
    }
}
Colored by Color Scripter

cs

else 부분이 핵심이라고 볼 수 있다.

우리는 permu[] 배열에 원하는 개수 m만큼 숫자를 채울 것이다. 여기서 숫자는 치킨 집 번호가 될 것이다.

0번 치킨 집, 1번 치킨 집 ......

1,2,3 | 1,2,4 | .... 이런식으로 그러기 위해서 cnt라는 변수를 두어서 permu 배열의 원소가 몇 개인지 세주고

next 같은 경우는 1,2,2 같은 불가능 한 경우 혹은 1,2,3 | 1,3,2 처럼 같은 경우의 수를 제외하기 위해 사용해준다.

cnt == m 즉 원하는 개수 만큼 permu 배열에 원소를 채웠을 때 여기에 있는 치킨 집 번호를 가지고 도시의 치킨 거리를 구해주면 된다.

전체 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

#include <iostream>
#include <cmath>
using namespace std;
int n, m;
int bbqx[15]; // 치킨 집의 x 좌표
int bbqy[15]; // 치킨 집의 y 좌표
int hx[2520]; // 집의 x 좌표
int hy[2520]; // 집의 y 좌표 
int permu[15]; // 순열 배열
int idx = 0; // 치킨 집의 개수
int idx2 = 0; // 집의 개수 
int result = 987654321; // 도시의 치킨 거리
 
void combination(int cnt, int next){
    if(cnt == m){ // 순열이 다 찬 경우
        int temp = 0; // 도시의 치킨 거리
        for (int i = 0; i < idx2; i++){
            int mndis = 987654321; // 각 집과 가까운 치킨 집 사이의 거리
            // 도시의 치킨 거리
            for (int j = 0; j < m; j++){
                // 각 집과 가까운 치킨 집 사이의 거리
                 int dis= abs(hx[i] - bbqx[permu[j]]) + abs(hy[i] - bbqy[permu[j]]);
                if(mndis > dis)
                    mndis = dis; // 가장 가까운 치킨집 거리
            }
            temp += mndis;  
        }
        if(result > temp) // 최단의 도시의 치킨 거리일 경우
            result = temp;
    }else{
        // 조합 
        for (int i = next; i < idx; i++){
            permu[cnt] = i;
            combination(cnt + 1, i + 1);
        }
    }
}
 
int main(){
    cin >> n >> m;
    int a;
    for (int i = 0; i < n; i++){
        for (int j = 0; j < n; j++){
            cin >> a;
            if(a == 2){
                bbqx[idx] = i;
                bbqy[idx] = j;
                idx++;
            }
            else if(a == 1){
                hx[idx2] = i;
                hy[idx2] = j;
                idx2++;
            }
        }
    }
    combination(0, 0);
    cout << result << '\n'; 
    return 0;
}
Colored by Color Scripter

cs

백준 2096 내려가기 c++ [컴공과고씨]

시간빌게이츠 — Tue, 3 Jan 2023 13:18:43 +0900

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

2096번: 내려가기

첫째 줄에 N(1 ≤ N ≤ 100,000)이 주어진다. 다음 N개의 줄에는 숫자가 세 개씩 주어진다. 숫자는 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 중의 하나가 된다.

www.acmicpc.net

문제 간단 정리

n * 3 개의 행렬 칸이 있고 각 칸에는 숫자가 적혀 있음.

맨 위 부터 출발 하여 내려오는데 바로 아래와 한 칸 대각선으로만 이동 가능함.

이 때 얻을 수 있는 최대, 최소 점수를 구하시오.

문제 해결 방법

이 문제 같은 경우 위에서 내려온다는 생각을 하지말고 도착할 칸이 위에서 내려오는 점수를 받는 다고 생각하면 쉽다.

이런식으로 첫번째 칸은 점수를 바로 위와 그 옆에서 밖에 올 수 없기 때문에 이 두 칸을 비교해서 더 큰 수에서 오는 것으로 하면 된다.

그러면 첫 번째 칸에 최대 점수를 넣기 위해서는 그냥 바로 위와 그 옆 점수를 비교해서 더 큰 수를 현재 칸 점수와 더해주면된다. 마찬가지로 가운데는 위 3개를 전부 비교해주며 된다. 3번째 칸도 올 수 있는 칸 두 개의 점수를 비교 해주고 현재 칸을 더해주면 결국 이렇게 내려오면 각 칸의 최대값을 얻게 되고 이 3개 중 가장 큰 것을 찾으면 그 사다리에서 얻을 수 있는 최대 값이 된다. 결국 다이나믹 프로그래밍을 이용한 문제인 것이다.

전체 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

#include <iostream>
using namespace std;
int n;
int arr[3]; // 현재 칸 점수
int mn_dp[3] = {0}; // 각 칸 최소값 기록
int mx_dp[3] = {0}; // 각 칸 최대값 기록
int mn(int a, int b){ // 최소 값 리턴
    if(a>b)
        return b;
    return a;
}
int mx(int a, int b){ // 최대 값 리턴
    if(a<b)
        return b;
    return a;
}
int main(){
    cin >> n;
    int temp0; // 윗 줄 첫번째 칸
    int temp1; // 윗 줄 두번째 칸
    int temp2; // 윗 줄 세번째 칸
    for (int i = 1; i <= n; i++){
        cin >> arr[0] >> arr[1] >> arr[2]; // 현재 칸 점수 
        // 최소 값 기록
        temp0 = mn_dp[0]; // 윗 줄 첫 번째 칸 
        temp1 = mn_dp[1]; // 윗 줄 두 번째 칸
        temp2 = mn_dp[2]; // 윗 줄 세 번째 칸
 
        // 서로 비교 후 현재 칸 점수 더함
        mn_dp[0] = mn(temp0, temp1) + arr[0]; 
        mn_dp[2] = mn(temp1, temp2) + arr[2];
        mn_dp[1] = mn(mn(temp0, temp1), temp2) + arr[1];
 
        // 최대 값 기록
        temp0 = mx_dp[0];
        temp1 = mx_dp[1];
        temp2 = mx_dp[2];
 
        mx_dp[0] = mx(temp0, temp1) + arr[0];
        mx_dp[2] = mx(temp1, temp2) + arr[2];
        mx_dp[1] = mx(mx(temp0, temp1), temp2) + arr[1];
    }
    // 마지막 칸 3개 중 가장 큰 값과 작은 값 추출
    cout << mx(mx(mx_dp[0], mx_dp[1]), mx_dp[2]) << " " << mn(mn(mn_dp[0], mn_dp[1]), mn_dp[2]);
    return 0;
}
Colored by Color Scripter

cs

백준 13549 숨박꼭질3 c++ [컴공과고씨]

시간빌게이츠 — Tue, 3 Jan 2023 12:55:40 +0900

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

13549번: 숨바꼭질 3

수빈이는 동생과 숨바꼭질을 하고 있다. 수빈이는 현재 점 N(0 ≤ N ≤ 100,000)에 있고, 동생은 점 K(0 ≤ K ≤ 100,000)에 있다. 수빈이는 걷거나 순간이동을 할 수 있다. 만약, 수빈이의 위치가 X일

www.acmicpc.net

문제 간단 정리

수빈이는 일직성 상에 n이라는 점에 있고 동생은 k라는 점에 있다.

수빈이는 걷거나 순간이동을 하는데 위치가 x일때 걷는다면 1초 후 x-1 or x+1로 이동하고

순간이동하면 0초 후 2*x 만큼 이동할 때 동생을 찾을 수 있는 가장 빠른 시간을 구해라.

문제 해결 방법

저는 bfs를 통해서 해결해 주었습니다.

수빈이의 점에서 일직성 상 범위 내에서 x+1, x-1, 2*x와 걸린 초를 큐에 넣어 해결해 주는 방식입니다.

코드를 보면서 이해하면 쉽게 이해가 가능하고 bfs에 대해 잘 모르겠다면 밑 코드를 보면서 bfs가 어떤식으로 돌아가는지

머리속에서 코드를 돌릴 수 있으면 bfs 문제가 나오면 쉽게 풀 수 있을 것이다.

전체 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

#include <iostream>
#include <queue>
#include <cstring>
using namespace std;
int n, k;
int vis[100003]; // 각 점에 도달하는 최단 시간을 기록
int result = 987654321; // 결과값
void bfs(int a){
    queue<pair<int, int>> q; // <위치, 시간>
    q.push(make_pair(a, 0)); // <초기위치, 0초>
    while(!q.empty()){
        int x = q.front().first; // 현재 위치
        int cnt = q.front().second; // 현재 위치까지 걸린 시간
        q.pop();
        if (x == k){ // 도착 지점 도달 시
            if(result > cnt) // 최단 시간일 경우 기록
                result = cnt;
        }else if (result < cnt){ // 기록된 결과을 넘은 시간인 경우 pass
            continue;
        }
        else{
            for (int i = -1; i <= 1;i++){ 
                int nx; // 다음 위치
                if (i == 0) // 순간이동한 경우
                    nx = 2 * x;
                else // 걷는 경우
                    nx = x + i;
            
                if(nx >= 0 && nx <= 100000){ // 일직성 상 범위 준수
                    // 순간이동을 하면 초가 변하지 않으므로 현재까지 걸린
                    // 시간이 다음 위치에 기록된 시간보다 적으면 
                    // 그것이 최단 시간이 됨.(-1 경우는 한번도 방문 안함)
                    if(i == 0 && (vis[nx] > cnt || vis[nx] == -1)){
                        q.push(make_pair(nx, cnt));
                        vis[nx] = cnt;
                    }// 걷는 경우 현재 시간에 +1 한 것이 더 작아야함.
                    else if(vis[nx] > cnt +1 || vis[nx]== -1){
                        q.push(make_pair(nx, cnt + 1));
                        vis[nx] = cnt + 1;
                    }
                }
            }
        }
    }
}
int main(){
    cin >> n >> k;
    memset(vis, -1, sizeof(vis)); // 0초인 경우도 있으니 -1로 초기화
    bfs(n);
    cout << result;
    return 0;
}
Colored by Color Scripter

cs

 

백준 1238 파티 c++ [컴공과고씨]

시간빌게이츠 — Mon, 2 Jan 2023 15:05:56 +0900

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

1238번: 파티

첫째 줄에 N(1 ≤ N ≤ 1,000), M(1 ≤ M ≤ 10,000), X가 공백으로 구분되어 입력된다. 두 번째 줄부터 M+1번째 줄까지 i번째 도로의 시작점, 끝점, 그리고 이 도로를 지나는데 필요한 소요시간 Ti가 들어

www.acmicpc.net

다익스트라 알고리즘을 활용한 문제로 bfs를 이용해도 가능하지만 시간 측면으로 볼때 다익스트라가 더 빠르고 나중에 다른 문제를 풀 때 다익스트라로 풀지않고 bfs로 풀면 시간 초과가 걸리는 문제들이 많기 때문에 최단 경로 문제 같은 경우 다익스트라로 풀어주는게 좋다. 다익스트라 알고리즘는 https://hagisilecoding.tistory.com/134 여기서 살펴보고 오면 이 문제를 쉽게 이해할 수 있다.

문제 간단 설명

n명의 학생이 파티를 해서 x번 학생 집에 모이기로 함.

각 집과 집을 잇는 도로가 있고 이 도로들을 이용해서 학생들이 x번 학생 집까지 최단거리로 다녀간다고 함.

x번 학생의 집까지 오고 가는 거리가 가장 긴 학생의 거리를 찾는 문제.

이 때 오고 가는 길은 단방향임.

문제 해결 방법

다익스트라 알고리즘을 사용하여 각각의 학생들의 x 학생집까지의 거리와 x 학생집에서 자신의 집까지의 거리를 구하고

두 거리를 합 한 후 가장 긴 학생의 거리를 찾아준다.

위 다익스트라 알고리즘 포스터를 보고 전체 코드를 보면 이해하기 쉬움.

전체 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

#include <iostream>
#include <queue>
#include <vector>
#include <cstring>
#define INF 98765432
using namespace std;
int n,x,m;
vector<pair<int, int>> v[1002];
int dst[1002]; // 정점까지의 최단거리를 기록
int result; // 최단거리
 
// 다익스트라
void fc(int a, int d){
    memset(dst, INF, sizeof(dst)); // 초기값 INF
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq; 
 // 우선순위 큐(최소 거리가 루트로)
    pq.push({0, a});// pq(거리, 정점)
    dst[a] = 0; // 시작 지점 거리 0으로 초기화
    while(!pq.empty()){
        int cx = pq.top().second; // 현재 정점
        int cdst = pq.top().first; // 현재 정점까지 거리
        pq.pop();
        if(cx == d){ // 현재 정점에 도착했다면
            result = dst[cx]; // 최단 거리 기록
            break;
        }
        for (int i = 0; i < v[cx].size();i++){ 
            // 현재 정점과 이어진 다음 정점들 
            int nx = v[cx][i].first; // 다음 정점 
            int ndst = v[cx][i].second + cdst; // 다음 정점까지 거리 계산
            if(dst[nx] > ndst){
                 // 다음 정점까지 거리와 기록된 정점까지 거리와 비교해
                 // 최단거리라면
                dst[nx] = ndst; // 최단거리 기록
                pq.push({ndst, nx}); // 큐에 넣어줌
            }
        }
    }
}
int main(){
    cin >> n >> m >> x;
    int ans1, ans2, ans;
    ans = 0;
    int a, b, t;
    for (int i = 0; i < m;i++){
        cin >> a >> b >> t;
        v[a].push_back({b, t});
    }
    for (int i = 1; i <= n;i++){
        fc(i, x); // 가는 길 최단 거리 
        ans1 = result; 
        fc(x, i); // 오는 길 최단 거리
        ans2 = result;
        if(ans < ans1+ans2)
            ans = ans1 + ans2; // 합
    }
    cout << ans << '\n'; // 최단 거리 출력
    return 0;
}
Colored by Color Scripter

cs

다익스트라(Dijkstra) 간단 정리 [컴공과고씨]

시간빌게이츠 — Mon, 2 Jan 2023 14:50:58 +0900

백준을 풀다보면 마주하는 최단 경로 탐색 알고리즘 다익스트라이다.

다이나믹 프로그래밍을 활용한 알고리즘으로 하나의 정점에서 다른 모든 정점으로 가는 최단 경로를 알려준다.

다만 이때 음의 간선을 포함하면 안된다. 간선에 음수가 포함 되어있을 때에는 벨만-포드 알고리즘을 사용해야하는데 이것은 나중에 다루어 보고 일단 다익스트라에 대해서 살펴보자.

핵심은

1. 목표 정점까지의 최단 거리는 여러개의 최단 거리로 이루어져있다.

2. 그래서 하나의 최단 거리를 구할 때 그 전까지 최단거리를 이용해준다.

먼저 선언해주어야 하는 것이 우선순위 큐, 각 정점까지의 거리를 담을 dst[] 배열이다.

우선순위 큐는 다음 정점의 번호와, 다음 정점까지 거리를 담고 있고 다음 정점까지 거리를 최소로 하는 것이 루트로 갈 수 있도록 선언해준다. dst[]배열 같은 경우 초기 값을 INF(가장 큰 값)으로 초기화 해준다.

0에서 5번 정점까지 간다고 할 때 다익스트라로 계산을 해본다면

자 우선순위 큐에 들어가기 위한 조건은 현재 정점까지의 거리와 다음 정점까지 거리를 합했을 때 다음 정점의 dst 값보다 작으면 넣을 수 있다.

그럼 처음에 0번 정점에서 시작한다면 우선순위 큐에 0(시작 정점)과 0 (현재 정점까지 거리)를 넣고 시작한다.

while문을 들어간 후 큐 루트에 있는 정점과 거리를 가져오고 pop을 해준다.

그 후 for문을 통해 0번과 이어진 정점들과 거리를 큐에 넣어준다.

이 때 조건문에는

1번 정점까지의 경우 현재 정점까지 거리 = 0 + 다음 정점까지는 = 1 -> 총 1

dst값은 INF 이므로 dst[1]에는 1이 기록되고 우선순위 큐에 1(다음 정점번호) 와 1(정점 1까지의 거리) 가 들어가게 된다.

마찬가지로 2번 정점, 3번 정점도 조건을 통과하여 들어가게 된다.

현재까지 상황 큐에 (1,2,3 정점), dst[1] = 1, dst[2] =2, dst[3] =3.

위 그림과 같은 그림

다음 반복에는

먼저 큐에 담긴 거리가 가장 작은 1번 정점이 큐에서 나오게 된다. (pop)

for문에 들어가 1번과 이어진 정점 추출 후 조건에 맞는 것들 큐에 넣어줌.

2번 정점으로 가는 길인 경우 현재 정점까지 거리 = 1 + 2번으로 가는 길까지의 거리 = 3 -> 총 4

현재 dst[2] = 2 이므로 현재 dst[2]가 더 작으므로 큐에 넣지 않음.

5번으로 가는 길은 총 거리가 8, dst[5]가 INF이기 때문에 큐에 넣어줌.

그 다음 반복에는 큐에 들어있는 거리 중 가장 짧은 2번 정점이 나옴 마찬가지로 큐에 넣을 정점들을 보면

dst[5]까지 거리가 현재 8인데 2번에서 총 거리는 6으로 계산이 되므로 dst[5]에 6을 넣어주고 큐에 넣어줌

그 다음 반복에는 3번 정점이 또 그 다음 정점에는 4번 정점이 4번 정점에서 dst[5]가 5로 업데이트 되고 큐에 들어가게 되고 결국 5번까지 최단 거리가 dst에 기록되면서 반복문이 끝나게 된다.

여기서 결과적으로 dst배열에는 0번으로 부터 각 정점까지의 최단거리가 남게 된다.

이정도로 이해하고 밑에 백준 문제를 한번 풀어보고 코드를 보면 더욱더 이해가 쉽다.

https://hagisilecoding.tistory.com/135 다익스트라를 이용한 백준 문제 풀이 (1238 파티)

백준 1043 거짓말 c++ [컴공과고씨]

시간빌게이츠 — Sun, 20 Nov 2022 19:11:16 +0900

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

1043번: 거짓말

지민이는 파티에 가서 이야기 하는 것을 좋아한다. 파티에 갈 때마다, 지민이는 지민이가 가장 좋아하는 이야기를 한다. 지민이는 그 이야기를 말할 때, 있는 그대로 진실로 말하거나 엄청나게

www.acmicpc.net

문제 간단 정리

지민이가 여러 개의 파티에 감.

파티마다 참석하는 사람이 주어짐.

지민이가 거짓말을 할 건데 진실을 아는 사람이 주어짐.

진실을 아는 사람에게 거짓말을 하면 안됨. 또한 어느 파티에서는 거짓을 듣고 다른 파티에서 진실을 듣는 것도 안됨.

즉, 거짓말이라는 것을 아무도 알아채지 못하게 거짓말을 많이 할 수 있는 파티의 개수를 구하라.

문제 해결 방법

이 문제 같은 경우 유니온 파인드를 쓰면 쉽게 풀 수 있다.

유니온 파인드를 모를 경우 https://hagisilecoding.tistory.com/122 여기서 보시고 오면 된다.

간단히 말하면 같은 부류끼리 분류를 해주는 것이다.

일단 사람들은 자신의 사람 번호로 그룹으로 분류해준다.

그 다음 진실을 아는 사람은 그룹 0번으로 분류를 해준다.

그 후 첫번째 온 사람 기준으로 그룹을 합쳐 주는데

그룹을 합칠 때 0번 그룹이 진실을 아는 사람이기 때문에 더 작은 그룹으로 합쳐주어야 한다.

이렇게 하면 진실을 아는 그룹과 모르는 그룹으로 나누어지게 되고

그 후 각 파티에 진실을 아는 사람이 있을 경우 거짓말을 하지 못하는 파티의 수를 셀 수 있다.

전체 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

#include <iostream>
using namespace std;
// 자신의 그룹이 어디에 속해있는지 리턴
int find_p(int parent[], int x){
    if(x != parent[x])
        return parent[x] = find_p(parent, parent[x]);
    else
        return parent[x];
}
// x와 y를 같은 그룹으로 만들어줌
void mer(int parent[], int x, int y){
    int px = find_p(parent, parent[x]);
    int py = find_p(parent, parent[y]);
    if(px != py){
        if(px < py)
            parent[py] = parent[px];
        else
            parent[px] = parent[py];
    }
}
int main(){
    int n,m; // 사람 수, 파티 수
    cin >> n >> m;
 
    int know_tru; // 진실을 아는 사람 수
    cin >> know_tru; 
    
    int parent[53]; // 어느 그룹에 속해 있는지 
    
    for(int i =0;i<=n; i++)
        parent[i] = i; // 각자 자신의 그룹으로 먼저 분류
    
    int temp; // 진실을 아는 사람
    for(int i =0 ;i<know_tru;i++){
        cin >> temp;
        parent[temp] = 0; // 진실을 아는 사람은 0 집합으로 분류
    }
 
    int Pnum;
    int temp2;
 
    int arr[53][53]; // 파티번호, 파티 사람 번호
    int arrsiz[53]; // 각 파티의 인원수 저장
    for(int i =0;i<m;i++){
        cin >> Pnum; // 파티에 오는 사람 수 
        cin >> temp; // 파티에 오는 첫번째 사람
        arrsiz[i] = Pnum; // 각 파티의 인원 수 저장
        arr[i][0] =temp; 
        // 첫번째 사람만 올 경우 혼자 오는 것이기 때문에
        // 다른 사람과 그룹을 합치지 않아도 돼서 분류
        for(int j = 1; j < Pnum; j++){
            cin >> temp2; // 파티에 오는 사람 번호
            arr[i][j] = temp2; // 파티에 오는 사람 번호 저장
            mer(parent, temp ,temp2); // 파티에 오는 사람 그룹 합침
        }
    }
    int answer = m; // 전부 거짓말을 할 경우 수 부터 시작
    
    // 각 파티마다 진실을 아는 사람이 한명이라도 있으면 거짓말을 할 수 없음
    // -> 하나 빼줌
    for(int i =0; i<m;i++){
        for(int j=0;j<arrsiz[i]; j++){
            if(find_p(parent, parent[arr[i][j]]) == 0){
                answer--;
                break;
            }
        }
    }
    cout << answer;
    return 0;
}
Colored by Color Scripter

cs

백준 2407 조합 c++ [컴공과고씨]

시간빌게이츠 — Tue, 15 Nov 2022 00:05:43 +0900

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

2407번: 조합

n과 m이 주어진다. (5 ≤ n ≤ 100, 5 ≤ m ≤ 100, m ≤ n)

www.acmicpc.net

문제 간단 정리

이 문제는 말 그대로 nCm을 구해주면 되는 문제이다.

nCm 이란 서로 다른 n개 중 m개를 뽑는 방법을 말한다.

구하는 법은 n!/m!(n-m)! 이다.

문제 해결 방법

이런 문제 같은 경우 공식을 구현하기 할 수는 있겠지만 답이 겁나게 크게 나오는 걸 볼 수 있다.

즉, c++에서는 저런 큰 수를 정수로 담을 변수가 없기도 하고 공식 구현 하더라도 일일이 다 곱하는 팩토리얼이 있기 때문에 시간초과가 걸릴 수 밖에 없다.

일단 써봐서 규칙을 찾아보는 것이다.

1C0 1C1

2C0 2C1 2C2

. . . . . . . . . .. . . . 이걸 구해 보면

1 1

1 2 1

1 3 3 1

1 4 6 4 1

1 5 10 10 5 1 이렇게 보면 규칙을 찾을 수 있다.

자신의 윗 줄 2개를 더하면 자신이 되는 걸 볼 수 있다.

우리는 배열에 저장을 할 거기 때문에 배열에 쉽게 적용하기 위해서

1 1

1 2 1

1 3 3 1

1 4 6 4 1 이런식으로 만들어 주면

dp[i][j] = dp[i-1][j] + dp[i-1][j-1] 로 구할 수 있다.

즉, 다이나믹 프로그래밍을 이용하면 된다. (동적 계획법)

여기서 주의할 점은 문자열로 이 숫자들을 처리를 해주어야한다. 너무 큰 수 이기 때문에

일단 더 할 두 수를 string 으로 받아 준다.

그리고 한 자리씩 더하고 그것을 string 변수에 push해 줄 것이다.

이 부분 같은 경우 코드를 보면서 이해하는 게 편하다.

전체 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main(){
    int n, m;
    cin >> n >> m;
 
    string dp[102][102];
    
    for (int i = 1; i <= n; i++){
        for (int j = 0; j <= i; j++){
            if(j == 0 || j == i)
                dp[i][j] = "1"; // m = 0 or n 이면 1
            else{
                int sum = 0; // 두 문자열의 한 자리를 더한 값
                string n1 = dp[i - 1][j]; // 더 할 문자열1
                string n2 = dp[i - 1][j - 1]; // 더 할 문자열2
 
                // 두 문자열 수를 더하기
                // 두 문자열을 모두 처리하고 남은 자릿수 sum까지 처리했으면 종료 
                while(!n1.empty() || !n2.empty() || sum){
                    if(!n1.empty()){  // 비어있으면 처리할 필요없음.
                        sum += n1.back() - '0'; // 한 자리 더해줌
                        n1.pop_back(); // 한 자리 제거
                    }
                    if(!n2.empty()){ // 비어있으면 처리할 필요없음.
                        sum += n2.back() - '0'; // 한 자리 더해줌
                        n2.pop_back(); // 한 자리 제거 
                    }
                    // sum의 값 중 일의 자릿수 만 넣어주어함.
                    // 10의 나머지를 push해주고
                    dp[i][j].push_back((sum%10) + '0');
                    sum /= 10; // 10의 몫을 저장해주면 다음 자리수가 남음
                }
                // 위 방식대로 했다면 수가 일의 자리부터 시작됨.
                // 반대로 뒤집어주어서 답을 구해줌.
                reverse(dp[i][j].begin(), dp[i][j].end());
            }
        }
    }
    cout << dp[n][m];
    return 0;   
}
Colored by Color Scripter

cs

백준 1692 곱셈 c++ [컴공과고씨]

시간빌게이츠 — Thu, 10 Nov 2022 22:41:46 +0900

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

1629번: 곱셈

첫째 줄에 A, B, C가 빈 칸을 사이에 두고 순서대로 주어진다. A, B, C는 모두 2,147,483,647 이하의 자연수이다.

www.acmicpc.net

문제 간단 정리

정말 간단하다

a,b,c가 주어짐.

a^b을 구하는 문제임.

단 a^b값이 너무 클 수 있으니 c로 나눈 나머지를 구하면됨.

문제 해결 방법

일단 나머지 정리를 알아야함.

나머지 정리는 그냥 간단하게 그냥 ((a%c) * (b%c) %c) 하고 (a*b)%c 같다.

즉, 이런 문제가 나오면 그냥 나머지 구하고 곱해주고 나머지 구해주면 된다.

제한 시간이 2초이기 때문에 1초에 3~5억번 연산을 한다고 했을 때 문제의 주어진 수가 최대 21억이기 때문에

무작정 하나하나 곱해주게 되면 시간 복잡도가 O(n)이기 때문에 시간 초과가 난다.

그래서 이 문제는 분할 정복(divide and conquer)을 사용해야한다.

원리는 이거다 a^8 = a*a*a*a*a*a*a*a 이면 연산을 8번해야하는데

이걸 ((a^2)^2)^2 으로 바꾸어주면 3번의 연산으로 처리할 수 있게 된다.

그래서 재귀 함수를 이용해서 b/2로 넣어주고 b=0일 때는 1을 리턴해준다.

그리고 임시 변수 temp에 함수 리턴값을 넣어주고 그럼 이 리턴 값이 a^(b/2)가 될것이니

이것을 (a^(b/2))^2 해주는것을 반복해주면 된다.

주의할점은 b/2가 홀수 일 경우 리턴 값을 a하나를 더 곱해주어야한다.

예를 들면 2^5 -> 2^2 * 2^2 * 2 이런식으로 말이다.

전체코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#include <iostream>
using namespace std;
long long mt(long long a, long long b, long long c){
    if(b == 0) // a^0 일때
        return 1; // 1을 리턴해주고
    long long temp = mt(a, b / 2, c); //c^(b/2) 을 구해주고
    temp = (temp * temp) % c; // (c^(b/2))^2 꼴로 해줌 
    if (b % 2 == 0) // b가 짝수일 경우
        return temp; // 계산된거 리턴
    else // 홀수인 경우는 남은거 하나 곱해주어야함. 
        return (temp*a)%c; 
}
int main(){
    long long a, b, c;
    cin >> a >> b >> c;
    long long result = mt(a, b, c);
    
    cout << result;
    return 0;
}
Colored by Color Scripter

cs

 

백준 1932 정수 삼각형 c++ [컴공과고씨]

시간빌게이츠 — Wed, 26 Oct 2022 15:57:33 +0900

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

1932번: 정수 삼각형

첫째 줄에 삼각형의 크기 n(1 ≤ n ≤ 500)이 주어지고, 둘째 줄부터 n+1번째 줄까지 정수 삼각형이 주어진다.

www.acmicpc.net

문제 정리

3 8

8 1 0

2 7 4 4

처럼 삼각형이 주어짐

이때 삼각형의 크기가 주어지는데 높이를 나타냄

이 삼각형의 크기는 4임.

이렇게 해서 위에서 부터 숫자를 더해 밑으로 내려온다. 내려갈때는 왼쪽, 오른쪽 대각선으로 이동이 가능하다.

이때 숫자의 최대 합은?

문제 해결 방법

일단 다이나믹 프로그래밍을 이용해서 문제를 풀어야한다.

그리고 쉽게 문제를 풀기 위해 위 삼각형을

0 7 ------ 1번 줄

0 3 8 ------ 2번 줄

0 8 1 0 -------- 3번 줄

0 2 7 4 4

이런식으로 생각해주는 것이다.

그러면 dp[i][j] 이 배열에서 i는 삼각형의 높이를 담당, j는 몇번째 숫자인지를 담당한다.

j가 0일 때는 0을 넣어준다.

그렇게 되면 윗 줄에서 밑 줄로 내려올 때 한 밑 줄에서의 j 번 칸의 최대 크기는

dp[i-1][j-1], dp[i-1][j] 이 두 개 즉, 윗 줄에 왼쪽 대각선 혹은 바로 위쪽의 값 중 큰 것을 선택하고

자신의 칸에 값을 더해주면 그 칸에 올 수 있는 최대값이 된다.

(j가 0일 때 0을 넣어준것 처럼 나머지 8위의 빈칸 이런곳들은 0으로 다 채워 넣어주면 된다.)

그럼 마지막 줄에 각 칸에 최대값이 저장되어 있고 그 중 가장 큰 것을 고르면 된다.

전체코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <iostream>
using namespace std;
int t[504][504]={0}; // 정수 삼각형 입력 받을 배열
int dp[504][504] = {0}; // 최대 합을 저장할 배열
int result = -1;
int mx(int a, int b){ // 두 수 중 큰 값을 반환하는 함수
    if(a>b)
        return a;
    else
        return b;
}
int main(){
    int n;
    cin >> n;
    int idx = 1;
    for (int i = 1; i <= n; i++){ // 정수 삼각형 입력 받음
        for (int j = 1; j <= i;j++){
            cin >> t[i][j];
        }
    }
    dp[1][1] = t[1][1]; // 맨 꼭대기 층은 같음
    for (int i = 2; i <= n; i++){ // 2번째 줄 부터 시작
        for (int j = 1; j <= i;j++){ // 1번째 칸 부터 시작
            dp[i][j] = mx(dp[i - 1][j - 1], dp[i - 1][j]) + t[i][j];
            // 윗 줄 중 바로 위쪽, 왼쪽 대각선 중 큰 것을 골라
            // 자기 칸의 값과 더함.
        }
    }
    for (int i = 1; i <= n;i++){ // 마지막 줄 중 가장 큰 것을 고름
        if(result < dp[n][i])
            result = dp[n][i];
    }
    cout << result; // 결과 출력
    return 0;
}
Colored by Color Scripter

cs

 

백준 5639 이진 검색 트리(linked list 활용) c++ [컴공과고씨]

시간빌게이츠 — Sat, 22 Oct 2022 22:58:38 +0900

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

5639번: 이진 검색 트리

트리를 전위 순회한 결과가 주어진다. 노드에 들어있는 키의 값은 106보다 작은 양의 정수이다. 모든 값은 한 줄에 하나씩 주어지며, 노드의 수는 10,000개 이하이다. 같은 키를 가지는 노드는 없다

www.acmicpc.net

문제 간단 정리

이진트리가 있음

- 노드의 왼쪽 서브트리에 있는 모든 노드의 값은 부모의 값보다 작음.

- 노드의 오른쪽 서브트리에 있는 모든 노드이 값은 부모의 값보다 큼.

이 이진 트리에서

전위 순회 -> 루트 - 왼쪽 - 오른쪽 방문 하며 출력.

후위 순회 -> 왼쪽 - 오른쪽 - 루트 방문 하며 출력.

인데 전위 순회 결과가 주어졌을 때

후위 순회한 결과를 한 줄에 하나씩 출력해라.

방문 순회 이해하기

이 방문 순회가 이해가 힘든 분들은 이렇게 이해하면 쉽습니다.

3줄 코드가 한 세트로 보시고

코드 구성은 루트에 출력코드가 나머지는 이동코드로 구성되어있다고 생각하시고

새로운 노드에 도착할 때마다 한 세트가 다시 시작된다. (마치 재귀 함수 처럼)

즉, 전위 순회는 cout -> 왼쪽이동 -> 오른쪽이동

후위 순회는 왼쪽이동 -> 오른쪽이동 -> cout

문제 예시에서 전위 순회를 해봅시다.

cout -> left -> right를 기억하시고

노드 도착 cout -> 50출력 go left 30에 도착 다시 한 세트 시작 cout -> 30 다시 왼쪽 이동

....... 해서 cout << 5 후 왼쪽 비어있고 오른쪽 비어있기 때문에 24 노드로 가면

24노드는 go right가 남은 상태이기 때문에 go right 그럼 28에 도착 새로운 세트 코드 시작

28 출력 이런식인거죠

똑같이 후위 노드에 적용해보면

왼쪽 이동 30 도착 다시 왼쪽이동 24 도착 다시 왼쪽이동 5 도착

여기서 왼쪽 이동불가 오른쪽 이동 불가 cout << 5

24에서 go left 했었으니까 go right 그럼 28 도착 28에서 go left right 후 cout

다시 24로 가면 go left go right 완료한 상태이기 때문에 cout << 24

이런식으로 반복됩니다.

여기까지 순회 내용이였고 이제 본론으로 들어가겠습니다.

참고로 전위 순회해서 나온 값을 새로운 트리에 넣어주면 똑같은 트리를 만들 수 있습니다.

문제 해결 방법

일단 저는 이진트리를 만드는 방법으로 문제를 해결하였습니다.

여기서 이진트리를 만드는 방법은 2가지가 있습니다.

1. 배열을 이용한 방법

2. 링크드 리스트 (linked list)를 이용한 방법 (포인터를 쓸 수 있어야함)

저는 오랜만에 linked list도 다시 사용해볼겸 linked list로 만들어 보았습니다.

코드는 배열이 포인터도 안쓰고 간단하지만 말이죠.

어차피 원리는 같기 때문에 링크드 리스트로 풀 수 있으면 배열로는 더 쉽게 풀 수 있습니다.

그래서 배열로 트리를 구성하는 방법만 알려드리겠습니다.

배열 같은 경우는 루트 노드 index를 0으로 두고 왼쪽으로 갈 때는 2n+1로 하고 오른쪽으로 갈때는 2n+2로 구성해주면

이진트리를 쉽게 만들 수 있습니다.

이렇게 트리를 구성한 뒤 전위 순회해서 나온 값을 트리에 넣어서

똑같은 트리를 구성해준 후 해준 후 후위 순회를 해주면 됩니다.

1. 트리 만들기

* 포인터를 모르시는 분은 그냥 푸는 원리만 보고 트리를 배열로 구성하셔도 무방합니다.

자 linked list를 만들기 위해서 먼저 구조체를 선언해 줍니다. 여기서 구조체는 하나의 노드라고 보시면 됩니다.

구조체의 명은 노드 타입이고 안에는 노드의 값을 담는 int info 변수와 오른쪽, 왼쪽 노드를 가르키는 포인터 1개씩을 가지고 있습니다.

그림으로 표현하면 이렇게 됩니다.

하나의 직사각형이 하나의 노드가 되며 이 노드는 3개의 값을 가진다.

class tree 선언

tree 객체를 만들어 줍니다.

tree의 구성

1. NodeType* root (노드 타입을 가르키는 포인터)

2. enqueue(트리에 값을 푸쉬하는 함수)

3. 후위 탐색하는 함수

이렇게 3개가 필요하겠죠. 트리의 초기 상태는 root가 null이기 때문에 생성자에 root=NULL을 추가해줍니다.

자 먼저 enqueue 함수를 구성해 봅시다.

이해는 a값을 넣는 다면 먼저 root 포인터 부터 시작합니다.

root 포인터가 0이라면 root 포인터가 가르키는 NodeType 노드를 생성한 후 왼쪽, 오른쪽 포인터에 NULL을 넣어주고

info에 a를 넣어주면 됩니다.

만약 NULL이 아니라면 다시 함수에 값을 비교하여 큰 값이면 오른쪽 포인터로 이동 아니면 왼쪽 포인터로 이동시키면

됩니다. 코드를 보시면

tree 클래스에서 enqeue를 해주면 insert 함수로 가고

insert 함수에서 왼쪽 오른쪽 이동을 하다가 아무것도 가르키고 있지 않는 포인터에 도달하면 거기에

노드를 생성한 후 값을 저장합니다.

중요한것은 insert() 파라미터에 NodeType*& 레퍼런스가 붙는 것을 주의 하시면 됩니다.

&가 있어야 tr = new NodeType 한 것이 유지가 됩니다.

이렇게 하면 push 하는 함수는 끝났습니다. 이제 마지막으로 후위 순회하는 함수를 만들어 주면됩니다.

자 inorder 함수는 root 를 넣어주면 아까 위에서 설명했듯이 먼저 포인터가 비어있지 않다면 왼쪽으로 이동

그 다음 오른쪽으로 이동 값을 queue에 넣어줌. 이렇게 구성이 되고 왼쪽으로 이동이 되었다면 다시 함수를 실행해 주면됩니다. (재귀함수 처럼)

이해가 어렵다면 전체코드 보면서 이해하셔도 되고 아니면 배열로 짜셔도 무방합니다.

전체코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

#include <iostream>
#include <queue>
using namespace std;
struct NodeType{ // 하나의 노드를 구조체로 표현
    int info; // 노드의 값
    NodeType *right; // 노드의 오른쪽을 가르킴
    NodeType *left; // 노드의 왼쪽을 가르킴
};
void InOrder(NodeType* tr ,queue<int>& q){
    if(tr != NULL){ // 가르키는 포인터가 있으면
        InOrder(tr->left, q); // 왼쪽으로 이동 
        InOrder(tr->right, q); // 오른쪽으로 이동
        q.push(tr->info); // 값을 저장
    }
}
void insert(NodeType*& tr, int a){ // &를 붙여주어야 포인터가 노드를 생성하고 
// 가르키고 있는 것이 유지가 됨.
    if(tr == NULL){ // 노드에 값이 없는 경우
        tr = new NodeType; // 새로운 노드를 생성해서 포인터로 연결
        tr->left = NULL; // 왼쪽 포인터 NULL
        tr->right = NULL; // 오른쪽 포인터 NULL
        tr->info = a; // 값 삽입
    }else if(a > tr->info){ // 넣을 값이 크다면
        insert(tr->right, a); // 오른쪽 포인터로 이동
    }else{
        insert(tr->left, a); // 왼쪽 포인터로 이동
    }
}
class tree{
    public:
        tree(){
            root = NULL; // 초기 tree 상태 root = NULL
        }
        void enqueue(int a){
            insert(root, a); // root pointer와 a를 넣어줌
        }
 
        void InOrderTree(queue<int>& q){
            InOrder(root, q);
        }
 
    private:
        NodeType *root;
};
int main(){
    ios::sync_with_stdio(false);
 
    queue<int> q; // 후위 순회한 값들을 저장할 큐
    tree t;
    int n;
    while(cin >> n){
        if(n == EOF)
            break;
        t.enqueue(n); // 전위 순회한 값을 트리에 넣음
    }
    t.InOrderTree(q);
    while(!q.empty()){
        cout << q.front() << '\n'; // 후위 순회 값 출력 
        q.pop();
    }
 
    return 0;
}
Colored by Color Scripter

cs

리눅스(linux) File I/O의 system calls [컴공과고씨]

시간빌게이츠 — Tue, 11 Oct 2022 22:44:37 +0900

리눅스에서의 file i/o에 대한 system call과 c를 이용해서 파일 입출력을 해보겠습니다.

일단 system call이란 application 즉, 사용자가 쉽게 프로그래밍할 수 있도록 만든 언어들 c++ 이런것 들은 하드웨어를 직접 access할 수 없습니다. hardware는 운영체제가 관리를 하기 때문에 하드웨어 접근이 필요할 때 운영체제에게 서비스를 요청할 때 system call을 사용하여 요청한다고 볼 수 있습니다.

리눅스에서의 file i/o에 관한 system call은

open, read, write, close

lseek, fcntl, ioctl 이 있습니다.

#include <unistd.h>를 하게되면

자동적으로

STDIN_FILENO (0)

STDOUT_FILENO(1)

STDERR_FILENO(2)

열리게 됩니다.

리눅스는 기본적으로 파일을 오픈하면 3개가 오픈이 되고 각각 정수 0,1,2의 리턴값을 가집니다.

그래서 파일을 여는 open의 리턴값은 정수이고 3부터 값을 가지게 됩니다.

int open(char *filename, int option, mode)

options에는

O_RDONLY, O_WRONLY, O_RDWR

O_APPEND, O_CREAT, O_EXCL, O_TRUNC, O_NONBLOCK, O_SYNC

이 있고

O_RDONLY : 읽기만

O_WRONLY : 쓰기만 (이때 파일안에 내용이 있으면 싹다 지우고 씀)

O_RDWR : 읽고 쓰고 둘다.

O_APPEND : 쓰는데 내용 뒤에 추가

O_CREAT : 파일을 새로 만듬

O_TRUNC : 파일을 오픈할 때 기존 내용 없애기.

O_CREAT : O_CREAT 옵션과 함께 사용할 경우 기존에 없는 파일이면 파일을 생성하지만, 이미 있으면 파일을 생성하지 않고 오류 메시지를 출력한다.

O_SYNC : 파일에 쓰기 동작을 할 때 보통 버퍼에만 쓰고 나중에 디스크와 같은 저장 장치로 옮겨쓰는데, 이 옵션이 설정되어 있으면 저장 장치에 쓰기를 마쳐야 쓰기 동작을 완료한다. O_SYNC 플래그는 파일의 수정 시각 속성도 수정할 때까지 기다린다. 이 옵션을 설정하면 프로그램의 실행 속도는 느려질 수 있지만 디스크에 확실하게 저장됨을 보장한다.

mode에는 유저에 대한 읽기 쓰기 권한이 들어간다.

예를 들어 0644다 하면 0은 8진수를 나타내고 나머지는 rwx의 권한이다.

그리고 파일 작업이 끝난 후에는

close(int fd)를 통해 파일을 닫아주면된다.

여기서 int fd는 open함수를 이용해서 받은 리턴 값을 전달하는 것이다.

read(int fd, void *buf, size_t nbyte);

write(int fd, void *buf, size_t nbyte);

먼저 read는 파일에 최대 nbyte만큼 버퍼에 담는 것이다.

만약 nbyte보다 적은 량의 byte가 파일에 남아있으면 그 만큼 버퍼에 담는다.

그래서 리턴 값은 읽은 byte 수를 리턴한다. 파일의 끝은 0, 에러는 -1 리턴

write는 파일에 nbyte만큼 buf를 쓰는 것이다. 리턴 값은 쓴 값이지만 이 경우는 항상 값이 nbyte일 것이다.

에러는 -1 리턴

int lseek(int fd, long offset, int whence);

이것은 파일 포인터를 찾는 함수이다.

파일 포인터란 파일을 읽을 때 한 칸씩 파일 포인터가 움직이면서 파일을 읽는다.

이 파일 포인터를 조작할 때 사용한다.

whence는 기준점이고 이 기준점을 기준으로 offset만큼 이동하라는 것이다.

기준점에는 0,1,2가 들어간다.

0 (SEEK_SET)은 파일의 맨 처음

1 (SEEK_CUR)은 파일 포인터의 현재 위치

2 (SEEK_END)는 파일의 맨 끝을 의미 한다.

int creat(char* pathname, mode);

이건 파일을 생성하는 함수로 write-only의 파일의 정수를 반환함. 에러는 -1

open(pathname, O_WRONLY | O_TRUNC | O_CREAT, mode)랑 같은 표현이다.

나머지 fcntl과 ioctl은 read wirte할 때의 옵션을 지정해 주는 건데

fcntl regular files에 대한 ioctl은 special files에 대한 것이다.

regular files이란 우리가 흔히 하는 그 파일이고

리눅스에서는 키보드, 마우스 등 i/o 장치도 파일로 만들어 관리를 하는데 이것을 special files이라고 한다.

백준 9935 문자열 폭발 c++ [컴공과고씨]

시간빌게이츠 — Mon, 10 Oct 2022 22:56:31 +0900

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

9935번: 문자열 폭발

첫째 줄에 문자열이 주어진다. 문자열의 길이는 1보다 크거나 같고, 1,000,000보다 작거나 같다. 둘째 줄에 폭발 문자열이 주어진다. 길이는 1보다 크거나 같고, 36보다 작거나 같다. 두 문자열은 모

www.acmicpc.net

문제 간단 정리

문자열이 2개 주어짐

하나는 전체 문자열 다른 하나는 폭발 문자열.

전체 문자열 안에 폭발 문자열이 있으면 그 폭발 문자열이 폭발하여 없어짐.

모든 폭발 문자열이 없어지고 난 후 전체 문자열에 남아 있는 문자열 구하라.

해결 방법

최대한 반복을 적게 해야지 시간 초과가 나지 않는다.

즉, 그냥 무작정 한 개씩 비교하다 폭발이 일어나고 다시 앞에서 비교하면 당연히 시간 초과가 난다.

전체 문자열 : qwd012301230123444klsmvk

폭발 문자열 : 01234

라고 했을 때 01234가 나오고 폭발한 다음 그 전에 있던 0123과 4가 합쳐지면 폭발이 연쇄적으로

일어난다. 이것을 효율적으로 처리해주어야 된다.

그래서 나는 전체 문자열을 하나씩 다른 문자열에 넣어주면서 이 문자열의 길이가 폭발 문자열의 길이가 같거나

커지면 문자열의 뒤에서 폭발 문자열 길이 만큼을 폭발 문자열과 비교해 같으면 폭발 시키고

아니면 문자열을 추가시키는 식으로 간단히 구현해 주었다.

예를 들면,

전체 문자열 : qwd012301230123444klsmvk

폭발 문자열 : 01234

임시 문자열을 t라고 하면

t="";

t="q", t="w" ... t="qwd01"이 되면 뒤에서 부터 5개 문자를 비교하여 폭발 문자열과 같은지 확인.

다르기 때문에 계속 추가 그러다가 t="qwd0123012301234" 가 되어서 폭발 문자열과 같아지면 폭발.

그럼 t="qwd012301230123"이 되고 다시 뒤에 문자 추가 하면 t="qwd0123012301234"가 되어서

폭발 ... 이렇게 반복이되다 보면 폭발 문자열이 모두 폭발하게 된다.

코드를 보면 더욱 쉽게 이해가 가능하다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#include<iostream>
#include<string.h>
using namespace std;
int main(){
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    string a; // 전체 문자열 변수
    string b; // 폭발 문자열 변수
    string t = ""; // 임시 문자열 
    cin >> a >> b;
    int a_len = a.length(); // 전체 문자열 길이
    int b_len = b.length(); // 폭발 문자열 길이
    for (int i = 0; i < a.length(); i++)
    {
        t += a[i]; // 문자 추가
        if(t.length()>=b_len){ // 임시 문자 길이가 폭발 문자열 보다 크거나 같을 때
            bool flag = true; // 폭발 문자열 있는지 확인하는 flag
            for (int j = 0; j < b_len; j++){ 
                if(t[t.length()-b_len+j] != b[j]){
                    flag = false;
                    break;
                } // t뒤에서 폭발 문자열 길이만큼 비교
            }
 
            if(flag) // 폭발 문자열일 경우 삭제 
                t.erase(t.end() - b_len, t.end());
        }
    }
        if (t.empty()) // 남아 있는 문자열이 없는 경우
            cout << "FRULA" << '\n';
        else
            cout << t << '\n';
    return 0;
}
Colored by Color Scripter

cs

Linux(리눅스) vi 편집기 간단 설명 [컴공과고씨]

시간빌게이츠 — Tue, 20 Sep 2022 18:54:36 +0900

앞서 글에서 말했듯이 리눅스에서는 vi 편집기를 사용합니다.

기본적으로 vi 편집기는 커맨드 기반이기 때문에 사용을 할 때 모든 것은 명령어로 이루어집니다.

윈도우에서 visual studio를 사용할 때 마우스로 했던 작업들을 모두 키보드로 한다고 생각하시면 됩니다.

vi 편집기는 command Mode, Insert Mode, Command-line Mode로 나누어 집니다.

vi편집기 실행 명령어

$ vi main.c

하면 main.c라는 파일을 vi 편집기로 열게 됩니다.

처음에 딱 들어가면 Command Mode로 시작이 됩니다.

여기서 i, a, o, I, A, O 중 하나를 입력하면 insert mode로 가서 입력을 할 수 있게 됩니다.

insert mode에서 command mode로 돌아가고 싶다면 esc를 눌러주면 됩니다.

command mode에서 :, /, ? 중 하나를 입력하면 Command-line Mode로 가게 됩니다.

vi main.txt -> i -> hi~ -> esc

순서대로 입력한 모습입니다.

i로 insert 모드 진입 삽입 후 esc로 커맨드 모드로 돌아옴.

그 후 :로 통해 명령어 라인 모드로 가서

:wq -> 저장 후 종료

:x -> 저장 후 종료

:q! -> 저장하지 말고 종료

하면 됩니다.

여기까지는 vi에 대해 전체적인 것을 알아보았고 다음 글에는 자주 사용하는 명령어와 실행 결과를 모아서 올릴 것입니다.

Linux(리눅스) 컴파일의 전체적 과정 (윈도우와 차이점) [컴공과고씨]

시간빌게이츠 — Tue, 20 Sep 2022 18:35:35 +0900

Editor(편집기) : 윈도우에서는 visual studio와 같은 편집기를 사용한다면, 리눅스에서는 vi라는 편집기를 사용합니다.

1. 그래서 편집기 vi에서 소스파일들을 작성을 하겠죠.

2. 여기서 만든 소스파일들을 컴파일러(gcc, g++)을 통해 object 파일로 만들어줍니다. *gcc->c, g++->c++

파일 확장자는 *.c ->*.o 로 됩니다.

이때 한 개의 소스파일 당 하나의 object 파일을 만들게 됩니다.

*여러개의 소스파일 중 어떤 소스파일들을 object파일로 할지를 결정하는 것이 윈도우 visual studio에서는

프로젝트라고 볼 수 있습니다. 리눅스에서는 그 역할을 하는 것이 make 입니다.

make file은 object파일로 만들 소스파일들을 지정해주고 make라는 명령어를 사용하여 object파일로 만들어 줍니다.

여러개의 소스파일을 이제 object파일로 만들었다면 이것을 하나의 실행파일로 이어주어야 합니다.

그것을 바로 Linking이라고 합니다. Linking을 수행하는 애를 Linker라고 합니다.

이때 object 파일 뿐만 아니라 library도 링킹을 하게 됩니다.

아까 말했든 make file에 있는 소스파일은 사용 여부에 상관없이 무조건 linking됩니다.

하지만 Library은 경우 우리가 사용한 함수들 혹은 class만 linking이 됩니다.

*library : 개발할 때 많이 사용되는 함수 혹은 class들을 미리 만들어 둔 곳. 그래서 쓴것만 가져다 씀.

*리눅스에서 library의 확장자는 *.a 입니다.

이렇게 링킹을 통해 하나의 실행파일을 만듭니다.

윈도우에서는 .exe라는 파일로 나오지만

리눅스에서는 따로 이름을 지정해주지 않으면 a.out이라는 하나의 실행파일로 나오게 됩니다.

그리고 마지막으로 컴파일, 링킹 이 과정들은 debugging을 통해 어디서 오류가 났는지 오류를 잡아낼 수 있습니다.

디버거의 이름은 gdb입니다.

백준 1149 RGB거리 c++ [컴공과고씨]

시간빌게이츠 — Tue, 20 Sep 2022 14:23:33 +0900

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

1149번: RGB거리

첫째 줄에 집의 수 N(2 ≤ N ≤ 1,000)이 주어진다. 둘째 줄부터 N개의 줄에는 각 집을 빨강, 초록, 파랑으로 칠하는 비용이 1번 집부터 한 줄에 하나씩 주어진다. 집을 칠하는 비용은 1,000보다 작거나

www.acmicpc.net

문제 정리

집을 3가지 색으로 칠할 수 있음.

각 집마다 각 색으로 칠하는 비용이 다름.

각 집의 색깔은 바로 앞 집과 바로 다음 집의 색깔과 같으면 안됨.

비용을 최소로 칠하는 비용은?

문제 해결 방법

이 문제의 경우 다이나믹 프로그래밍을 이용하면 쉽게 풀 수 있다.

일단 dp[3][n]이라는 배열을 만든다.

이 배열의 의미를 먼저 알아보자.

앞에 3이라는 것은 3가지 색깔을 말하고 n은 집을 말한다.

그럼 한 집당 3가지 색깔을 칠 할 수 있다.

그래서 dp[1][1]이 뜻하는 바는 1번째 색깔로 1번째 집을 칠한 것을 말한다.

dp[0][1]은 0번째 색깔로 1번째 집을 칠한 것을 말합니다.

그렇다면 3번째 집을 0번 색으로 칠하기 위한 조건은 뭐냐?

바로 2번째 집에서 1번으로 칠한 값, 2번으로 칠한 값 중 최소값을 골라주면 된다.

3번째 집을 1번 색으로 칠하기 위한 조건은?

쉽게 2번째 집에서 0번, 2번으로 칠한 값 중 최소를 골라주면 되는 것이다.

그래서 우리가 구하고자 하는 집의 최소 비용은

dp[0][j] = min(dp[1][j-1], dp[2][j-1]) + 현재 집을 0번 색으로 칠하는 비용 : j집을 0번 색으로 칠할 때 최소 비용

dp[1][j] = min(dp[0][j-1], dp[2][j-1]) + 현재 집을 0번 색으로 칠하는 비용 : j집을 0번 색으로 칠할 때 최소 비용

dp[2][j] = min(dp[0][j-1], dp[1][j-1]) + 현재 집을 0번 색으로 칠하는 비용 : j집을 0번 색으로 칠할 때 최소 비용

이런 식으로 나아가면 현재 집 기준 앞 뒤 모두 다르게 색을 칠하면서 최소 비용을 얻을 수 있다.

전체 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include <iostream>
using namespace std;
int minum(int a, int b){
    if(a>b)
        return b;
    else
        return a;
}
int main(){
    int n;
    int dp[3][1003]; // i번 색으로 j번 집을 칠하는데 드는 최소 비용 저장
    int rgb[3][1003]; // 집을 칠하는데 드는 비용
    cin >> n;
    for (int i = 0; i < n;i++){ 
        cin >> rgb[0][i] >> rgb[1][i] >> rgb[2][i];
    }
    dp[0][0] = rgb[0][0]; // 초기 값
    dp[1][0] = rgb[1][0];
    dp[2][0] = rgb[2][0];
    for (int i = 1; i < n;i++){
        dp[0][i] = minum(dp[1][i - 1] + rgb[0][i], dp[2][i - 1] + rgb[0][i]); //0번 색으로 i번 집 색을 칠하는데 드는 최소비용
        dp[1][i] = minum(dp[0][i - 1] + rgb[1][i], dp[2][i - 1] + rgb[1][i]); //1번 색으로
        dp[2][i] = minum(dp[1][i - 1] + rgb[2][i], dp[0][i - 1] + rgb[2][i]); //2번 색으로 
    }
    cout << minum(minum(dp[0][n - 1], dp[1][n - 1]), dp[2][n - 1]); 
 // 마지막 집에서 3개의 색 중 가장 최소비용인 것 선택
    return 0;
}
Colored by Color Scripter

cs

백준 11660 구간 합 구하기 5 c++ [컴공과고씨]

시간빌게이츠 — Sun, 18 Sep 2022 03:03:15 +0900

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

11660번: 구간 합 구하기 5

첫째 줄에 표의 크기 N과 합을 구해야 하는 횟수 M이 주어진다. (1 ≤ N ≤ 1024, 1 ≤ M ≤ 100,000) 둘째 줄부터 N개의 줄에는 표에 채워져 있는 수가 1행부터 차례대로 주어진다. 다음 M개의 줄에는 네

www.acmicpc.net

문제 정리

1. 행렬이 주어짐.

2. 시작 좌표 (x1,y1)이 주어지고 도착 좌표 (x2,y2)가 주어짐

3. 좌표 사이에 있는 값의 합들을 구해야함.

예를 들어 초록색이 시작 좌표, 파란색이 끝 좌표라고 하면 저런식으로 보라색 빗금의 부분의 합들을 구해주면됨.

문제 해결 방법

그 전 구간 합 구하기를 해보면 알듯이 일일이 for문을 돌리면서 구해주면 시간 초과가 난다.

그래서 다이나믹 프로그래밍을 이용해 풀어주어야 한다.

일단 나는 map[i][j]의 배열의 의미를 정의를 어떻게 했냐면

(1,1) 부터 (i,j)의 구간의 합으로 정의를 해주었다.

이런식으로 보라색 좌표의 값은 빨간색의 합을 구한 것으로 정의하는 것이다.

그럼 저 것을 어떻게 구해나가면 되냐?

이런식으로 가면됩니다.

1번 부분은 map[i-1][j] 이고

2번 부분은 map[i][j-1] 입니다.

그리고 겹쳐지는 노란색 3번 부분은 map[i-1][j-1]이 되죠?

그럼 1번과 2번을 더해서 3번 부분을 빼주고 (i,j)좌표 칸의 값을 더해주면 map[i][j]의 값이 됩니다.

그럼 똑같이 x1,y1에서 x2,y2까지 합을 구하려면?

st이 x1, y1

dt가 x2,y2라고 하면

map[x2][y2](빨강) - map[x1-1][y2](파란) - map[x2][y1-1](초록) + map[x1-1][y1-1](갈색)

이 사이 구간의 합이 된다.

전체코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include <iostream>
 
using namespace std;
int map[1206][1206] = {0}; // i,j까지 합
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n, m;
    cin >> n >>  m;
    int temp;
    
    for (int i = 1; i <= n; i++){
        int sum = 0;
        for (int j = 1; j <= n;j++){
            cin >> temp;
            map[i][j] = map[i - 1][j] + map[i][j - 1] + temp - map[i - 1][j - 1]; 
 // i,j 까지 합 구하기
        }
    }
 
    int x1, y1, x2, y2;
    
    for (int i = 0; i < m;i++){
        int result = 0;
        cin >> x1 >> y1 >> x2 >> y2;
        result = map[x2][y2] - map[x1 - 1][y2] - map[x2][y1 - 1] + map[x1 - 1][y1 - 1]; 
 // 사이 구간 합
        cout << result << '\n';
    }
 
    return 0;
}
Colored by Color Scripter

cs

유니온 파인드(Union Find) C++ [컴공과고씨]

시간빌게이츠 — Wed, 14 Sep 2022 22:01:44 +0900

알고리즘 문제들을 풀다보면 각 원소들이 속해 있는 집합을 구별해야하는 문제를 볼 수 있다.

유니온 파인드에 대한 자세한 설명은 생략하고 간단히 설명하고 구현 함수들을 보여드리겠습니다.

기본 개념

속해있는 집합이라고 생각하시면 됩니다.

1,2,3,4,5 라는 원소가 있다고 하면 처음에는 자신의 숫자가 속해있는 그룹 번호라고 합시다.

그룹 번호-원소로 나타내면 1-1 2-2 3-3 4-4 5-5.

여기서 1번 원소와 2번 원소를 합친다는 것은 1번 원소가 속한 그룹과 2번 원소가 속한 그룹을 합치는 것입니다.

나타내면 1-1,2 3-3, 4-4, 5-5 가 되겠죠.

여기서 2번원소와 4번 원소를 합치면? -> 1-1,2,4 3-3 4-4 5-5 가 됩니다.

이렇게 해서 같은 그룹을 만들어 나가는 것을 유니온 파인드라고 합니다.

parent[] : 자신이 속한 그룹 번호를 저장하는 배열.

Find함수 : 자신의 그룹 번호를 반환해주는 함수.

merge함수 : 그룹을 합치는 함수.

코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

int find_parent(int x){
    if(parent[x] != x)
        return parent[x] = find_parent(parent[x]) 
    return x;     
}
void merge(int a, int b){
    int x = find_parent(a);
    int y = find_parent(b);
 
    if(x != y){
        if(x < y) // 그룹번호가 더 작은 쪽으로 합치기
            parent[y] = x;
        else
            parent[x] = y;
    }    
}
 
Colored by Color Scripter

cs

find 함수를 보시면 return find_parent(parent[x])를 해도 되지만 저렇게 하는 이유는 함수를 호출 할 때 재귀하는 횟수가 적어지기 때문입니다.

이유는 만약 return find_parent(parent[x]) 이러한 형태라면

merge를 할 때 어떤 식으로 구성이 되냐면 1,2,3,4 가 있다고 하면

merge(1,2) -> 1-1,2

merge(3,4) -> 1-1,2 3-3,4

merge(1,3) -> 1-1,2,3 3-4

이런식으로 구성이 되게 됩니다.

find_parent(4)를 하게 되면 3를 찾고 다시 재귀해서 1로가게 됩니다.

하지만 parent[x] = find_parent(parent[x]) 처럼 구현하게 된다면

merge(1,3) 후 find_paarent(4)를 하면 1-1,2,3,4 이런식으로 한번에 이어지기 때문에 나중에 부모를 찾을 때 한번에

그룹 번호를 알게 되는 것입니다.

그리고 merge 함수에 if(x<y) 이 조건은 언제든 상황에 맞게 바꾸어 줄 수 있습니다.

예를 들어 난 루트 그룹 번호를 큰 쪽으로 합치고 싶으면 if(x>y) 이런식으로 말이죠.

백준 1389 케빈 베이컨의 6단계 법칙 c++ [컴공과고씨]

시간빌게이츠 — Sat, 10 Sep 2022 17:14:56 +0900

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

1389번: 케빈 베이컨의 6단계 법칙

첫째 줄에 유저의 수 N (2 ≤ N ≤ 100)과 친구 관계의 수 M (1 ≤ M ≤ 5,000)이 주어진다. 둘째 줄부터 M개의 줄에는 친구 관계가 주어진다. 친구 관계는 A와 B로 이루어져 있으며, A와 B가 친구라는 뜻

www.acmicpc.net

문제 정리

1. 유저가 번호로 주어짐

2. 관계가 주어짐. 관계라는 것은 예를 들어 1 2 이렇게 주어지면 1과 2는 연결되어 있다는 것을 말함.

3. 관계가 1 2 주어지고 2 4 로 주어진다고 치면 1에서 4로 갈때의 단계는 1 2(1단계) 2 4(2단계)

그래서 총 2단계를 걸처 1에서 4가 연결되어 있다고 함.

이 때 다른 사람과의 관계의 총 합을 케빈 베이컨의 수라고 함.

케빈 베이컨의 수가 가장 적은 수의 사람을 출력해라. 같은 케빈 베이컨의 수가 있을 경우 가장 작은 번호의 사람을 출력하라.

문제 해결 방법

bfs를 이용하여 사람 마다 다른 사람까지 가는데 걸리는 단계를 측정한다.

그 단계들을 합해준다.

그 후 다음 사람과 다른 사람까지의 단계를 측정해 케빈 베이컨 수를 구해 전에 측정해준 값과 비교하여 더 작은 값을 저장해준다.

bfs 같은 경우 기본 bfs와 같다.

코드 주석을 보면 이해가 쉽게 될 것입니다.

전체 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
int n, m;
vector<int> v[102];
int a, b;
int count = 0; // 시작 사람에서 목표 사람 까지의 단계 수
void bfs(int a,int b, bool visit[102]){
    queue<pair<int, int>> q;
    q.push(make_pair(a,0));
    visit[a] = true;
    while(!q.empty()){
        int x = q.front().first;
        int cnt = q.front().second;
        q.pop();
 
        if(x == b){
            count = cnt;
            break;
        }
 
        for (int i = 0; i < v[x].size(); i++){
            if(!visit[v[x][i]]){
                q.push(make_pair(v[x][i], cnt+1));
                visit[v[x][i]] = true;
            }
        }
    }
}
 
int main(){
    cin >> n >> m;
    for (int i = 0; i < m;i++){
        cin >> a >> b;
        v[a].push_back(b); // 사람 관계는 양방향임.
        v[b].push_back(a);
    }
    int result = 98765432; // 케빈 베이컨의 수
    int num; // 케빈 베이컨의 수에 해당하는 사람 번호
    for (int i = 1; i <= n;i++){ // 시작하는 사람
        int temp = 0; // 한 사람이 다른 사람까지 가는 단계
        for (int j = 1; j <= n;j++){ // 목표사람
            bool visit[102] = {0}; 
            if(i==j) // 시작 사람과 목표 사람이 같은 경우 넘김
                continue;
            bfs(i, j, visit); 
            temp += count; // 각 목표 사람의 단계를 모두 합쳐 케빈 베이컨의 수를 구함
            count = 0; // 목표 사람의 단계 초기화
        }
        if(result > temp){ // 전의 케빈 베이컨의 수와 비교하여 더 작은 값을 저장
            result = temp;
            num = i;
        }
            
    }
    cout << num << '\n';
    return 0;
}
Colored by Color Scripter

cs

백준 11286 절댓값 힙 c++ [컴공과고씨]

시간빌게이츠 — Mon, 5 Sep 2022 13:07:52 +0900

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

11286번: 절댓값 힙

첫째 줄에 연산의 개수 N(1≤N≤100,000)이 주어진다. 다음 N개의 줄에는 연산에 대한 정보를 나타내는 정수 x가 주어진다. 만약 x가 0이 아니라면 배열에 x라는 값을 넣는(추가하는) 연산이고, x가 0

www.acmicpc.net

문제 정리

0이 아니면 원소 추가.

0이면 추가된 원소 중 절대값이 가장 작은 원소를 출력 후 제거.

원소의 개수가 0일 경우 0이 입력되면 0을 출력.

문제 해결 방법

우선순위 큐를 떠올리면 간단하게 풀 수 있는 문제이다.

우선 순위 큐를 간단하게 보려면

https://hagisilecoding.tistory.com/60?category=1050177

위 링크에서 간단하게 어떤건지 볼 수 있다.

우선순위 큐에서 구조체와 operator 함수를 사용하여 정렬 구조를 바꾸어 준다.

그리고 입력 받은 것을 큐에 push 해주고 입력 값이 0이라면 큐가 비어있는지 확인 후 조건에 맞게 구현해 주면 됩니다.

전체 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

#include <iostream>
#include <queue>
#include <vector>
#include <cmath>
using namespace std;
 
struct cmp{ // 정렬 기준 바꾸는 함수
    bool operator()(int a, int b){
        if(abs(a) == abs(b))
            return a > b; // 절대값이 같은 경우 가장 작은 원소로
        return abs(a) > abs(b); // 절대값이 작은 원소로
    }
};
 
int main(){
    int n, x;
    priority_queue<int, vector<int>, cmp> q;
    vector<int> v;
    cin >> n;
 
    for (int i = 0; i < n;i++){
        cin >> x;
        if(x == 0){
            if(q.empty()){
                // 큐가 비어있을 때 0을 출력
                v.push_back(0);
            }else{
                v.push_back(q.top()); // 가장 작은 원소 출력
                q.pop(); // 제거
            }
        }else{
            q.push(x); // 원소 추가
        }
    }
 
    for (int i = 0; i < v.size(); i++){
        cout << v[i] << '\n'; // 정답 출력
    }
 
    return 0;
}
Colored by Color Scripter

cs

백준 11659 구간 합 구하기 4 c++ [컴공과고씨]

시간빌게이츠 — Sun, 4 Sep 2022 15:18:16 +0900

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

11659번: 구간 합 구하기 4

첫째 줄에 수의 개수 N과 합을 구해야 하는 횟수 M이 주어진다. 둘째 줄에는 N개의 수가 주어진다. 수는 1,000보다 작거나 같은 자연수이다. 셋째 줄부터 M개의 줄에는 합을 구해야 하는 구간 i와 j

www.acmicpc.net

문제 정리

n개의 숫자가 주어짐

구간이 주어지면 그 구간안에 있는 숫자의 합을 구하라.

문제 해결 방법

무작정 구간이 주어질때마다 더하게 되면 시간 초과가 남.

숫자가 주어질때마다 거기까지의 합을 구해놈.

그 후 구간이 주어지면 마지막 구간까지의 합에서 시작 구간 전까지의 합을 빼주면 됨.

전체코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include <iostream>
using namespace std;
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n, m;
    int num[100002];
    int sum[100002];
    cin >> n >> m;
    for (int i = 0; i < n;i++){
        cin >> num[i];
        if(i==0)
            sum[i] = num[i];
        else
            sum[i] = sum[i - 1] + num[i];
    }
    int a, b;
 
    while (m--){
        cin >> a >> b;
        if(a-2 >= 0)
            cout << sum[b - 1] - sum[a - 2] << '\n';
        else
            cout << sum[b - 1] << '\n';
    }
    return 0;
}
 
Colored by Color Scripter

cs

백준 16236 아기 상어 c++ [컴공과고씨]

시간빌게이츠 — Sat, 3 Sep 2022 14:57:19 +0900

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

16236번: 아기 상어

N×N 크기의 공간에 물고기 M마리와 아기 상어 1마리가 있다. 공간은 1×1 크기의 정사각형 칸으로 나누어져 있다. 한 칸에는 물고기가 최대 1마리 존재한다. 아기 상어와 물고기는 모두 크기를 가

www.acmicpc.net

문제 간단 정리.

상어가 물고기를 먹으러 다님.

상어는 물고기의 크기보다 크면 물고기를 먹을 수 있음.

크기가 같다면 지나갈 수만 있음. -> 작으면 못지나 감.

물고기를 먹으면 그 칸은 빈칸이 됨.

상어가 한 크기에서 물고기를 먹은 횟수와 상어의 크기가 같게 되면 상어 크기가 1 증가함.

물고기를 먹을 때는 가장 작은 것을 우선으로 먹고 같은 크기가 많다면 가장 위쪽 우선 그 다음은 왼쪽 우선으로 함.

한 칸 움직일 때마다 1초가 지나고 먹을 수 있는 물고기칸에 도착하면 그 즉시 먹음.

이 때 먹을 물고기가 없을 때 까지의 걸리는 시간을 구해라.

문제 해결 방법

문제를 읽었을 때 bfs 탐색 문제라는 것을 쉽게 알 수 있습니다.

조건을 잘 지켜주어야 합니다.

저는 물고기를 한 마리 먹을 때까지 bfs로 탐색 후 먹으면 조건들에 구현해 주었고 다시 bfs를 넣어서 또 한마리를 먹을때 까지 탐색하는 방법으로 구현했습니다.

bfs 내부 같은 경우 일반적인 bfs 구현과 비슷하지만 먹을 물고기를 찾았을 때 그 위치를 저장하고 다른 같은 크기의 같은 시간이 걸리는 물고기 중에서 가장 위쪽, 왼쪽에 있는 좌표가 있다면 그 좌표에 있는 물고기를 먹도록 구현해 주었습니다.

자세한 것은 전체 코드의 주석을 보면 이해가 더욱더 쉬울 것입니다.

중요한 것은 가장 위쪽, 왼쪽을 우선시 한다는 것을 잘 지켜주는 것이 중요합니다.

전체코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

#include <iostream>
#include <queue>
 
using namespace std;
int n;
int map[22][22];
int dx[] = {0, -1, 1, 0}; // 상좌우하
int dy[] = {-1, 0, 0, 1};
int bx, by;
int result = 0; // 총 걸린 시간
int count = 0; // 물고기 먹은 횟수
int sz = 2; // 상어 사이즈
bool stop = false; // 먹을 물고기가 없는 경우
bool eat = false; // 한 마리를 먹은 경우
void bfs(int a, int b, bool visit[][22], int shSize){
    queue<pair<pair<int, int>, int>> q;
    q.push(make_pair(make_pair(a, b), 0));
    visit[b][a] = true;
    int temp; // 한 마리를 먹는데 걸린 시간
    while(!q.empty()){
        int x = q.front().first.first; // 열 좌표
        int y = q.front().first.second; // 행 좌표
        int cnt = q.front().second; // 현재 시간
        // 가장 위쪽을 먼저 그 다음 왼쪽을 우선적으로 먹는 것을 고려
        if(map[y][x] > 0 && map[y][x] <shSize && temp == cnt){
            if((by > y) || (by == y && bx > x)){
                by = y; // 물고기를 먹은 상어 위치 저장
                bx = x;
                continue;
            }
        }
        q.pop();
        for (int i = 0; i < 4; i++){
            int nx = x + dx[i]; // 방향 이동
            int ny = y + dy[i];
 
            if(nx>=0 && nx <n && ny>=0 && ny <n && !visit[ny][nx]){
                if(map[ny][nx] <= shSize){// 지나가거나 먹을 수 있는 경우
                    if(map[ny][nx] > 0 && map[ny][nx] < shSize && !eat){ //물고기를 먹을 수 있는 경우
                        eat = true; // 한 마리 먹음
                        bx = nx; //시작 위치를 물고기를 먹었던 위치로
                        by = ny;
                        temp = cnt + 1; // 한 마리 먹는데걸린 시간
                        result += temp; // 총 시간에 추가
                    }else{ // 물고기를 못먹는 경우
                        q.push(make_pair(make_pair(nx, ny), cnt + 1));
                        visit[ny][nx] = true;  
                    }                      
                }
            }
        }
    }
}
int main(){
    cin >> n;
    for (int i = 0; i < n; i++){
        for (int j = 0; j < n;j++){
            cin >> map[i][j];
            if(map[i][j] == 9){
                by = i; // 상어 시작 위치
                bx = j;
                map[i][j] = 0;
            }
        }
    }
 
    while(!stop){
        bool visit[22][22] = {0};
        bfs(bx, by, visit, sz); // 한 마리 먹을때까지 이동
        if(eat){ // 먹었을 경우
            eat = false; 
            count += 1; // 현재 크기에서 물고기 먹은 횟수 증가
            map[by][bx] = 0; // 먹은 물고기 삭제
            if(count == sz){ // 상어 크기가 증가하는 경우
                sz += 1; // 상어 사이즈 +1
                count = 0; //현재 크기에서 물고기 먹은 횟수 초기화
            }
        }else{ // 한 마리도 못먹는 경우
            stop = true; // 엄마 상어에게 도움 요청해야함.
        }
    }
    cout << result << '\n';
    return 0;
}
Colored by Color Scripter

cs

백준 17219 비밀번호 찾기 c++ [컴공과고씨]

시간빌게이츠 — Sat, 3 Sep 2022 14:26:39 +0900

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

17219번: 비밀번호 찾기

첫째 줄에 저장된 사이트 주소의 수 N(1 ≤ N ≤ 100,000)과 비밀번호를 찾으려는 사이트 주소의 수 M(1 ≤ M ≤ 100,000)이 주어진다. 두번째 줄부터 N개의 줄에 걸쳐 각 줄에 사이트 주소와 비밀번

www.acmicpc.net

이 문제는 굉장히 간단합니다.

map 컨테이너를 사용하면 간단히 풀 수 있습니다.

이러한 문제류는 pair같은 것으로 저장 후 탐색을 for문으로 돌리게 되면 시간초과가 나기 때문에

map 컨테이너를 이용해 key값을 찾아주는 것이 시간 복잡도 측면에서 유리합니다.

전체 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
int main(){
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    int n, m;
    map<string, string> ps; // 맵 선언
    string s1, s2; 
    vector<string> re;
    cin >> n >> m;
    for (int i = 0; i < n; i++){
        cin >> s1 >> s2;
        ps.insert(make_pair(s1, s2)); // 사이트, 비밀번호
    }
    for (int i = 0; i < m; i++){
        cin >> s1;
        re.push_back(ps[s1]); // 비밀번호 찾은 후 저장
    }
    for (int i = 0; i < m;i++){
        cout << re[i] << '\n';
    }
    return 0;
}
Colored by Color Scripter

cs

백준 5525 IOIOI c++ [컴공과고씨]

시간빌게이츠 — Mon, 22 Aug 2022 23:07:42 +0900

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

5525번: IOIOI

N+1개의 I와 N개의 O로 이루어져 있으면, I와 O이 교대로 나오는 문자열을 PN이라고 한다. P1 IOI P2 IOIOI P3 IOIOIOI PN IOIOI...OI (O가 N개) I와 O로만 이루어진 문자열 S와 정수 N이 주어졌을 때, S안에 PN이 몇

www.acmicpc.net

문제 정리

I와 O가 반복된 배열이 주어짐.

1: IOI

2: IOIOI

3: IOIOIOI

이런 식으로 반복되는 수열의 길이 N이 주어짐.

배열안에 N으로 이루어진 IOI가 얼마나 있는지 구함.

예를 들어 N이 4라는 것은 IOIOIOIOI 이 부분이 배열에 얼마나 있냐는 것이다.

주어진 배열이 OOOIOIOIOIOIOIOOO라고 하면 답은 2개가 된다.

이유는 OOOIOIOIOIOIOIOOO 1개

그 다음 OOOIOIOIOIOIOIOOO 2개 이렇게 해서 2개이다.

문제 해결 방법

저는 bool 변수를 통해서 배열에서 탐색을 하는데 전전인덱스, 전인덱스, 현인덱스 이렇게 비교를 해서

IOI이면 카운트를 세주었습니다.

bool변수가 true이면 I이고 false면 O로 했습니다.

IOI가 얼마나 연속으로 이어지는지 센 후 길이 N을 빼준 다음 +1을 하면 그것이 연속된 IOI에서 나올 수 있는 길이 N의 IOI배열이 되겠습니다.

주의해야할 것은 IOI가 한번 나오면 그 다음 연속 IOI는 IOIIOI가 아니라 IOIOI이기 때문에 카운트가 한번된 상황이라면

IOI이후 OI라면 연속된 배열이라고 판단해주어야합니다. 그 후 연속된 배열을 세다가 연속하지 않는다면 카운트를 0으로 만들어주고 연속된 배열안에서 몇개의 N개의 연속된 IOI를 만들 수 있는지 더해준후 다시 반복해주면됩니다.

전체 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

#include <iostream>
#include <string>
using namespace std;
int main(){
    int n, m;
    cin >> n >> m;
 
    string s;
    cin >> s;
    bool bbe; // 전전것이 무엇이였는지
    bool be; // 전것이 무엇이였는지
    if(s[0] == 'I')  
        bbe = true;
    else 
        bbe = false;
 
    if(s[1] == 'I')
        be = true;
    else
        be = false;
 
    bool cur; // 현재 것
    int cnt = 0;
    int result = 0;
    for (int i = 2; i < m;i++){
        if(s[i] == 'I') // 현재 인덱스
            cur = true;
        else
            cur = false;
        
        if(bbe && !be && cur){ // IOI 일 때
            cnt++;
        }else if(cnt > 0 && !bbe && be && !cur){ 
            //IOI가 앞에 있고 그 뒤에 IOIOI이런 상황이라면 연속된 것으로 판단.
            true;
        }else{ // IOI연속이 깨졌을 경우
            if(cnt - n > -1) 
                result += cnt - n + 1; // 정답에 저장
            cnt = 0; // 카운트 초기화
        }
 
        bbe = be; // 전전것에 전것을 옮겨주고
        be = cur; // 전것에 현재것을 옮겨줌
    }
    if(cnt - n > -1){ // 마지막으로 연속된 IOI가 있을 경우를 처리
        result += cnt - n + 1;
    }
    cout << result << '\n';
    return 0;
}
Colored by Color Scripter

cs

백준 6064 카잉 달력 c++ [컴공과고씨]

시간빌게이츠 — Tue, 16 Aug 2022 15:36:38 +0900

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

6064번: 카잉 달력

입력 데이터는 표준 입력을 사용한다. 입력은 T개의 테스트 데이터로 구성된다. 입력의 첫 번째 줄에는 입력 데이터의 수를 나타내는 정수 T가 주어진다. 각 테스트 데이터는 한 줄로 구성된다.

www.acmicpc.net

문제 정리

몇번 째 해인지 나타내는 방법을 <x,y>라고 정의

여기서 x와 y의 최대값이 문제에서 주어짐.

예를 들어 m = 10, n = 12 라는 것은 x의 최대값은 10 y의 최대값은 12

1번째 해 = 1,1

2번째 해 = 2,2

이런식으로 해가 최대값을 넘지 않으면 +1 씩 증가

그러다가 최대값을 넘어가면 1로 다시 시작

10번째 해 = 10, 10

11번째 해 = 1, 10

이렇게 넘어감. 이 때 만약 둘다 동시에 최대값이 되면 최대 해가 되어서 더 이상의 해는 없음.

이때 x, y가 주어질 때 그때가 몇 번째 해인지 구하라.

문제 해결 방법

문제를 보시면 알겠지만 1씩 증가시키면서 일일이 하면 시간초과가 날것입니다.

이 문제는 2가지 방법으로 풀 수 있습니다.

1. 덧셈과 뺄셈을 이용해서 푸는 법.

2. 최대공약수와 최소공배수를 이용하여 나눗셈을 이용한 방법.

저는 처음 문제를 풀 때 1번 방법을 이용해서 풀어주었습니다.

물론 2번 방법도 설명해드리고 코드도 올려드렸습니다.

1번 방법

먼저 1번 방법 같은 경우 간단하게 1씩 증가시키는 방법에서 시간을 줄이기 위해서 1씩 증가시키는 것이 아니라

x,y 둘 중에 최대값이 빠르게 되는 것을 뺄셈을 통해 최대값으로 만들어주고 1로 초기화하여서 정답을 비교해주는 방법입니다.

예를 들어서 m =10, n=12일 때 x와 y는 1부터 시작함으로

최대값이 되기 위한 값은 x는 10-1 = 9, y는 12-1=11 이기때문에 9번째 해에 x는 최대값을 도달하게 되고 10해에 x=1로 초기화가 됩니다. 그렇기 때문에 1씩 증가시키는 것이 아니라 10을 더해서 <1,11>을 만들어주는 것입니다.

그다음은 반복입니다. x는 10 - 1 = 9, y는 12-11 = 1 이기 때문에 y가 더 작습니다. 그래서 y가 1로 초기화가 될 수 있도록

2를 증가시켜 <3,1>로 만들어 줍니다.

여기서 우리는 항상 어떠한 값을 1로 맞추어 주기 때문에 정답이 <3,9>라면 <1,7> 즉, 하나가 1이 되는 순간을 타겟으로 삼아 주고 <1,7>가 되는 해를 구한 후 정답인 <3,9>가 되도록 해를 뺄셈을 통해 구해줍니다.

여기서도 1씩 증가시키는 것은 최대값이 크면 반복횟수가 많아짐으로 뺄셈을 통해 구해주는 것입니다.

말로 하면 복잡하지만 코드로 보면 굉장히 쉽습니다.

2번 방법

이 방법도 간단하게 구현할 수 있습니다.

일단 보시면 알겠지만 m=10, n=12라고 하면 만약 51번째 해를 <x,y>로 표현하려면 어떻게 해야할까요?

최대값으로 나눈 나머지가 되겠죠?

51은 10이 몇번? 5번 들어가고 그 후 1해가 지난가면 51번째입니다. x=1

51은 12가 몇번? 4번 들어가고 그 후 3해가 지나가면 51번째이기 때문에. y= 3 이겠죠.

주의해야 할 것은 나머지가 0이면 최대값으로 바꾸어주어야합니다.

예를 들어 50번째 해는 x로 표현하면 10이겠죠?

멸망해는 어떻게 되냐면 m과n의 값이 동시에 나누어지는 최소값이 멸망해가 되겠죠?

즉, 멸망해는 m과 n의 최소공배수가 됩니다.

그러면 우리는 구하려는 x가 3이라고 하면 x가 3이 되는 해에서 y 값을 구해서 구하려는 y와 맞는지 비교만 하면 됩니다.

m=10일때 x가 3이 되는 해는? 10을 계속 더해주면 됩니다. 3 13 23 이렇게 가면 x값이 3인 해가 되겠죠?

그럼 3번째 해 일때 n=12라고 하면 y는 3을 12로 나눈 나머지 3 이겠고 13번째 해는 12로 나누어주면 1이겠고

이렇게 되겠죠 그래서 정답인 y와 같아지면 해를 찾을 수 있고 없으면 -1를 출력해주면 됩니다.

전체 코드(1번 방법)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

#include <iostream>
using namespace std;
int main(){
    int T;
    cin >> T;
    for (int t = 0; t < T;t++){
        int m, n, x, y;
        cin >> m >> n >> x >> y;
        int rx, ry; // 타겟 x,y를 구해줌 어느 한 쪽이 1이 되도록
        if(x > y){ // y가 1인 경우
            rx = x - y + 1;
            ry = 1;
        }
        else{ // x가 1인 경우
            ry = y - x + 1;
            rx = 1;
        }
 
        int cnt = 1; // 몇 번째 해
        int nx = 1; // 다음 번째 x
        int ny = 1; // 다음 번째 y
        bool stop = false; // 멸망해 이거나 정답을 찾았거나
        while(!stop){
            //다음해가 타겟 x와 같은 경우 -> 정답
            if(nx == rx && ny == ry){ 
                cnt = cnt + x - rx; // 정답해로 갈 수 있도록 더해줌
                nx = x;
                ny = y;
                stop = true;
            }        
            else if(m - nx < n - ny){// x가 먼저 1이되는 경우
                ny = ny + m - nx + 1;
                cnt = cnt + m - nx + 1;
                nx = 1;  
            }else if(m - nx > n- ny){ // y가 먼저 1이 되는 경우
                nx = nx + n - ny + 1;
                cnt = cnt + n - ny + 1;
                ny = 1;
            }else{ // 멸망해인 경우
                cnt = cnt + n - ny;
                nx = m;
                ny = n;
                stop = true;
            }
        }
        if(nx == x && ny == y){ // 정답 해
            cout << cnt << endl;
        }else{ // 멸망해까지 없는 경우
            cout << -1 << endl;
        }
    }
    return 0;
}
Colored by Color Scripter

cs

2번째 방법

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include <iostream>
using namespace std;
 
int gcd(int a, int b){ // 최대 공약수
    if(b==0)
        return a;
    return gcd(b, a % b);
}
int lcm(int a, int b){ // 최소 공배수
    return (a * b) / gcd(a, b);
}
int main(){
    int T;
    cin >> T;
    for (int t = 0; t < T; t++){
        int m, n, x, y;
        int result = -1;
        cin >> m >> n >> x >> y;
        int maxi = lcm(m, n); // 멸망해
        for (int i = x; i <= maxi; i+=m){
            int ny = i % n; // y값
            if(ny == 0) // 이때는 y가 최대값이 됨
                ny = n;
            
            if(ny == y){ // 정답
                result = i;
                break;
            }
        }
        cout << result << '\n';
    }
    return 0;
}
Colored by Color Scripter

cs

 

백준 5430 AC c++ [컴공과고씨]

시간빌게이츠 — Sun, 14 Aug 2022 19:09:54 +0900

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

5430번: AC

각 테스트 케이스에 대해서, 입력으로 주어진 정수 배열에 함수를 수행한 결과를 출력한다. 만약, 에러가 발생한 경우에는 error를 출력한다.

www.acmicpc.net

문제 정리

배열이 주어짐.

명령어가 주어짐.

명령어는 문자열 형태로 R은 배열 뒤집기 D는 배열의 맨 앞 원소 빼기 두 가지로 구성됨.

명령어를 수행후 남은 배열 원소를 구해라.

단, 원소가 없을 때 D가 수행되면 error를 출력하라.

문제 해결 방법

이 문제 같은 경우는 deque를 이용해서 풀 수 있습니다.

저 같은 경우는 인덱스를 조작을 이용해서 deque를 사용하지 않고 풀었습니다.

deque는 queue와 비슷하지만 다른 점은 양쪽에서 pop과 push를 사용할 수 있습니다.

제가 푼 방식과 deque를 이용한 방법 모두 문제를 푸는 큰 틀은 같기 때문에 제가 푼 방법으로 설명하겠습니다.

이 문제는 사실 문제의 해결 방법은 쉬운데 문자열을 받고 출력하는 부분을 잘 체크해 주어야 합니다.

1. 입력 배열 숫자로 바꾸기

먼저 명령어와 주어진 배열을 string으로 받아 줍니다.

주어지는 배열을 보면 [1,2,3] 이런 식으로 주어지기 때문에 숫자만 분리해주어야 합니다.

string으로 받아 하나씩 읽으면서 숫자면 string 변수에 +를 해줍니다. 이유는 [100,99] 이런식으로 한 자리 숫자가 아닐 경우 때문입니다. 그 후 숫자가 아닌 것이 나오면 모아둔 숫자를 int형으로 바꾸어주고 배열에 넣어 줍니다.

2. 명령어 수행

명령어를 수행하기 앞서 시작 인덱스와 끝 인덱스를 정해줍니다.

만약 배열에 있는 숫자가 1,2,3,4 라면 시작 인덱스는 0, 끝 인덱스는 3. 이런식으로 만들어줍니다.

그리고 숫자가 하나도 없는 경우 끝 인덱스를 -1로 만들어줍니다.

이렇게 한 후 D가 나오기 전까지 R의 개수를 세어줍니다.

그 후 D가 나오면 앞의 R의 개수가 짝수개이면 뒤집을 필요가 없고 홀수개면 뒤집어 주어야 하기 때문에

시작 인덱스와 끝 인덱스를 바꾸어 줍니다.

그 후 먼저 원소가 하나도 없는지 확인합니다. 원소가 하나도 없다면 error를 출력해 주어야 함으로 표시를 위해 끝 인덱스를 -1해줍니다.

원소를 빼는 경우 맨 앞에서 빼주어야합니다.

시작 인덱스가 더 크면 시작 인덱스 -1를 해주면 되고 시작 인덱스가 더 작다면 시작 인덱스에 +1을 합니다.

만약 둘다 같다면 마지막 원소이므로 끝 인덱스를 -1로 만들어주어서 원소가 비었다고 표시해 줍니다.

마지막으로 명령어 수행이 끝난 후 위에서는 D가 나올때 까지 R의 개수를 세어 D가 나오면 R을 처리했기 때문에

명령어가 RDRRR이런식으로 D가 나오지 않고 R에서 끝난 경우가 있습니다.

그래서 마지막에 남은 R명령어를 처리를 해주어야합니다.

예를 들면 1,2,3,4 가 있을 때 명령어가 RD라고 하면 시작 : 0, 끝 : 3

먼저 R이 홀수이기 때문에 시작과 끝을 바꾸어주면 시작: 3, 끝: 0 이 되고

시작이 끝 보다 크기 때문에 -1을 해서 시작 : 2, 끝 0 이 됩니다. 그 후 시작 부터 끝까지 출력해주면

3,2,1이 나오게 됩니다.

그 후 출력하는 부분입니다.

끝이 -1 이라면 원소가 비어있음을 출력.

끝이 -2 라면 error 출력

그 후 시작과 끝의 인덱스 크기 비교 후 그 사이의 값을 출력해주면됩니다.

만약 deque를 사용한다면 D가 나올때까지 R의 개수를 세어서 뒤집기라면 뒤에서 빼주고 뒤집지 않으면 앞에서 빼주면 됩니다.

전체코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

#include <iostream>
#include <string>
using namespace std;
int main(){
    int T;
    cin >> T;
    for (int t = 0; t < T; t++){
        int n;
        string p, a;
        int num[100002] = {0};
        cin >> p;
        cin >> n;
        cin >> a;
 
        int idx = 0; // 배열 인덱스
        int tdx = 0; // 명령어 인덱스
        string tm = "";
        while(a[tdx] != ']'){
            if(a[tdx] == '[')
                tdx++;
            else if(a[tdx] == ','){
                num[idx] = stoi(tm); // int 형 변환 후 배열에 저장
                idx++; 
                tdx++;
                tm = "";
            }else{
                tm += a[tdx]; // 숫자 +
                tdx++;
            }
        }
        // 마지막 숫자 배열에 저장
        if(tm != ""){
            num[idx] = stoi(tm);
            idx++;
        }
 
        int start_pos = 0; // 시작 인덱스
        int end_pos = idx-1; // 끝 인덱스
        int cnt = 0; // R개수
        for (int i = 0; i < p.length();i++){ // 명령어 수행
            if(p[i] == 'R'){ // 뒤집기
                cnt++;
            }else{
                if(end_pos == -1){ // 원소 하나도 없는 경우
                    end_pos--;
                    cnt = 0;
                    break;
                }
                if(cnt%2 != 0){ // 뒤집기 실행
                    int tmp = start_pos;
                    start_pos = end_pos;
                    end_pos = tmp;
                }
                if(start_pos > end_pos)
                    start_pos -= 1;
                else if(start_pos < end_pos)
                    start_pos += 1;
                else 
                    end_pos = -1;
                cnt = 0; // R개수 초기화
            }
        }
        if(cnt != 0){ // 마지막에 남은 R명령 처리
            if(cnt%2 != 0 && end_pos > -1){ 
                int tmp = start_pos;
                start_pos = end_pos;
                end_pos = tmp;
            }            
        }
        
        if(end_pos == -1){
            cout << '[' << ']';
        }else if(end_pos == -2){
            cout << "error";
        }else if(start_pos >= end_pos){
            cout << '[';
            for (int i = start_pos; i > end_pos; i--){
                cout << num[i] << ',';
            }
            cout << num[end_pos] << ']';
        }else if(start_pos < end_pos){
            cout << '[';
            for (int i = start_pos; i < end_pos; i++){
                cout << num[i] << ',';
            }
            cout << num[end_pos] << ']';
        }
        cout << endl;
    }
    return 0;
}
Colored by Color Scripter

cs

백준 14500 테트로미노 C++ [컴공과고씨]

시간빌게이츠 — Sun, 14 Aug 2022 16:35:08 +0900

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

14500번: 테트로미노

폴리오미노란 크기가 1×1인 정사각형을 여러 개 이어서 붙인 도형이며, 다음과 같은 조건을 만족해야 한다. 정사각형은 서로 겹치면 안 된다. 도형은 모두 연결되어 있어야 한다. 정사각형의 변

www.acmicpc.net

문제 정리

바둑판이 주어지고 각 칸에는 숫자가 써있음.

여기에 4칸으로 이루어진 도형 5개 주어짐.

바둑판에 도형 한 개를 놓아서 놓아진 칸의 숫자 합이 최대가 되도록 만들어라.

문제 해결 방법

이 문제를 해결하는 방법은 대표적으로 DFS를 사용하는 방법이 있습니다.

제가 처음 푼 방법은 DFS를 쓰지 않고 풀었습니다.

하지만 DFS를 쓰는 방법에 대해 설명하고 제가 푼 방법을 설명하도록 하겠습니다.

전체 코드는 제가 처음 푼 방법과 dfs로 푼 방법 둘다 작성해 두었습니다.

DFS

도형들을 보시면 ㅗ 모양 빼고는 깊이가 4인 dfs로 탐색을 하면 도형을 만들 수 있다.

즉, 칸 마다 dfs를 돌려서 깊이가 4까지 탐색을 해서 각 칸의 합을 구해줍니다.

그후에 ㅗ모양을 따로 빼서 구해주는 방식으로 해주면 됩니다.

다른 방법

근데 저는 어차피 ㅗ모양을 회전시키면서 따로 또 구해주어야 하니 처음부터 도형의 경우를 나누었습니다.

제 방식은 ㅡㅡㅡㅡ 모양은 쉽게 구할 수 있기 때문에 따로 구해주고

위 처럼 6칸짜리 직사각형에서 2칸을 빼서 도형을 만들어 주는 식으로 구현했습니다.

이렇게 하면 직사각형에서 위 5가지 경우 도형을 빼주면 일자를 제외한 도형을 만들 수 있습니다.

주의해야 할 것은

이런 모양이 나올때는 제외 시켜주면 됩니다.

전체코드 (처음 푼 코드)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

#include <iostream>
#include <queue>
using namespace std;
int result = 0;
int cnt = 0;
int map[502][502];
int dx1[] = {1, 2, 2, 0, -2};
int dy1[] = {0, 1, 0, 1, 1};
int dx2[] = {1, 1, -1, 0, 0};
int dy2[] = {0, 2, 2, 2, 1};
 
bool IsAns(int a){ 
    return result < a;
}
bool IsMin(int a, int b){
    return a < b;
}
int main(){
    int n, m;
    cin >> n >> m;
 
    for (int i = 0; i < n;i++){
        for (int j = 0; j < m;j++){
            cin >> map[i][j];
        }
    }
 
    for (int i = 0; i < n; i++){
        for (int j = 0; j < m;j++){
 
            if(j+3 < m){ // 가로 일자 도형 
                int wids = 0;
                for (int k = j; k <= j+3; k++){
                    wids += map[i][k];
                }
                if(IsAns(wids)){
                    result = wids;
                }
            }
 
            if(i+3 < n){ // 세로 일자 도형
                int wids = 0;
                for (int k = i; k <= i+3; k++){
                    wids += map[k][j];
                }
                if(IsAns(wids)){
                    result = wids;
                }
            }
 
            if(i+1 < n && j+2 < m){ // 2행 3열 직사각형
                int sum = 0; // 직사각형 전체 합.
                int temp = 98765432; // 2칸 빼줄 숫자 합.
                // 직사각형에서 2칸씩 빼주는 과정
                for (int k = i; k <= i + 1;k++){ 
                    for (int q = j; q <= j + 2;q++){
                        sum += map[k][q];
                        for (int t = 0; t < 5;t++){
                            int temp2;
                            int ny = k + dy1[t];
                            int nx = q + dx1[t];
                            if(t == 3 && nx == j+1) // 제외할 모양
                                continue;
                            if(ny >= i && ny <= i+1 && nx >=j && nx <= j+2){
                                temp2 = map[k][q] + map[ny][nx];
                                //빼주는 도형의 합이 최소가 되어야함.
                                if(IsMin(temp2, temp))
                                    temp = temp2; 
                            }
                        }
                    }
                }
                sum -= temp;
                // 정답 가능 여부 체크
                if(IsAns(sum)){
                    result = sum;
                }
            }
 
            if(i+2 < n && j+1 < m){ //3행 2열 직사각형 위와 똑같은 과정
                int sum = 0;
                int temp = 98765432;
                for (int k = i; k <= i + 2;k++){
                    for (int q = j; q <= j + 1;q++){
                        sum += map[k][q];
                        for (int t = 0; t < 5;t++){
                            int temp2;
                            int ny = k + dy2[t];
                            int nx = q + dx2[t];
                            if(t == 0 && ny == i+1)
                                continue;
                            if(ny >= i && ny <= i+2 && nx >=j && nx <= j+1){
                                temp2 = map[k][q] + map[ny][nx];
                                if(IsMin(temp2, temp))
                                    temp = temp2;
                            }
                        }
                    }
                }
                sum -= temp;
                if(IsAns(sum)){
                    result = sum;
                }
            }
        }
    }
 
    cout << result << endl;
    return 0;
}
Colored by Color Scripter

cs

DFS

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

#include <iostream>
using namespace std;
int map[502][502];
bool visit[502][502];
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int n, m;
int result;
void dfs(int a,int b, int cnt, int sum){
    if(cnt == 3){
        if(sum > result){
            result = sum;   
        }
        return;
    }
    for (int i = 0; i < 4;i++){
        int nx = a + dx[i];
        int ny = b + dy[i];
 
        if(nx >= 0 && nx < m && ny >=0 && ny < n && !visit[ny][nx]){
            visit[ny][nx] = true;
            dfs(nx, ny, cnt + 1, sum + map[ny][nx]);
            visit[ny][nx] = false;
        }
    }
}
 
int main(){
    cin >> n >> m;
 
    for (int i = 0; i < n;i++){
        for (int j = 0; j < m;j++){
            cin >> map[i][j];
        }
    }
 
    for (int i = 0; i < n;i++){
        for (int j = 0; j < m; j++){
            visit[i][j] = true;
            dfs(j, i, 0, map[i][j]);
            visit[i][j] = false;
            int sum = 0;
 
            // ㅗ 모양들
            if(i-1 >=0 && j+2<m){ 
                sum = map[i][j] + map[i][j + 1] + map[i][j + 2] + map[i-1][j + 1];
                if(sum > result)
                    result = sum;
                sum = 0;
            }
 
            if(i+1 <n && j+2<m){
                sum = map[i][j] + map[i][j + 1] + map[i][j + 2] + map[i+1][j + 1];
                if(sum > result)
                    result = sum;
                sum = 0;                
            }
 
            if(i+2 <n && j+1<m){
                sum = map[i][j] + map[i+1][j] + map[i+2][j] + map[i+1][j + 1];
                if(sum > result)
                    result = sum;
                sum = 0;
            }
 
            if(i+1 <n && i-1>=0 && j+1 < m){
                sum = map[i][j] + map[i - 1][j+1] + map[i][j+1] + map[i+1][j +1];
                if(sum > result)
                    result = sum;
                sum = 0;
            }
                        
        }
    }
    cout << result << endl;
    return 0;
}
Colored by Color Scripter

cs

백준 13459 구슬 탈출 c++ [컴공과고씨]

시간빌게이츠 — Sat, 13 Aug 2022 16:57:19 +0900

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

13459번: 구슬 탈출

첫 번째 줄에는 보드의 세로, 가로 크기를 의미하는 두 정수 N, M (3 ≤ N, M ≤ 10)이 주어진다. 다음 N개의 줄에 보드의 모양을 나타내는 길이 M의 문자열이 주어진다. 이 문자열은 '.', '#', 'O', 'R', 'B'

www.acmicpc.net

이 문제 같은 경우 제약 조건이 많아 차근차근 조건을 생각해 나가야 풀 수 있는 문제 였습니다.

문제 정리

바둑판 있음.

바둑판 가장자리는 벽으로 막혀있고 중간 중간에 벽이 있을 수 있음.

바둑판에 빨강, 파랑 1개씩 구슬 주어지고 구슬이 빠지는 구멍이 주어짐.

바둑판을 상하좌우로 기울일 수 있음.

바둑판을 기울이면 그 방향 끝까지 감. (구슬은 곂쳐질 수 없음.)

-> #......RB 였을때 왼쪽으로 기울이면 #RB..... 이 됨.

빨강 구슬을 구멍에 넣어야함.

이때 기울이는 횟수는 10번 이하로 해야하면 파란색 구슬은 구멍에 빠지면 안됨.

또한 빨강, 파란 구슬이 동시에 빠져서도 안됨.

기울이면 구슬은 동시에 움직이기 시작.

문제 해결 방식

이런 문제는 제약 조건을 잘 정리를 해서 하나씩 구현해 나아가면 됩니다.

파란 구슬 먼저 그 다음 빨간 구슬을 이동시키는 방식으로 구현했습니다.

(동시에 움직인다는 조건은 조건문을 통해 해결 할 수 있음.)

바둑판을 기울일 때 일어나는 상황

1. 벽을 만났다.

2. 구멍을 만났다.

3. 구슬을 만났다.

1번을 구현하기 위해 파란 구슬 부터 반복문을 사용하여서 기울인 방향으로 좌표를 벽을 만나기 전까지 하나씩 옮겨줍니다. 벽을 만나면 그 위치가 파란 구슬 위치가 됩니다.

그런데 가는 도중 2번 조건 구멍을 만났다면 파란 구슬이 빠졌기 때문에 이미 이것은 더 이상 볼 필요가 없습니다.

bool 변수로 불가능 표시를 해줍니다.

이제는 빨간 구슬을 이동 시킵니다.

이동 도중 2번 조건 구멍을 만났다면 빨간 구슬이 빠졌기 때문에 이 경우는 성공일 수도 있고 실패 일 수도 있습니다.

실패의 경우는 위의 파란 구슬이 들어간 경우입니다.

일단 빨간 구슬이 통과했으므로 bool 변수에 표시를 해 둡니다.

그 후 아까 말했던 동시에 빠진 경우를 체크하여서 동시에 빠진 경우 불가능으로 해주고 빨간 구슬만 빠진 경우는 정답으로 체크해 줍니다.

만약 그것이 아니라 구슬들이 만난 경우.

이 경우는 우리는 빨간 구슬과 파란 구슬을 독립적으로 벽까지 이동시켰기 때문에

위의 좌표 이동을 했을 때 빨간 색 구슬과 파란색 구슬의 위치가 같은 경우 생겨납니다.

이 경우 어느 구슬이 기울이는 방향 쪽에 있었는지가 중요합니다.

예를 들어서 우측으로 기울일 때 구슬들의 위치가 같다면 두 가지 경우가 생깁니다.

1. R..B...#

2. .B..R...#

위 두 경우를 고려해서 B가 앞 쪽일 때는 결과가 ...RB#

2번의 경우는 ..BR# 이렇게 됩니다.

그래서 방향으로 기울일 때 어느 구슬이 앞쪽에 있는지 확인 후 뒤쪽에 있던 구슬의 좌표를 빼줍니다.

여기서 중요한 건 우측과 좌측으로 기울이는 것은 X좌표에만 영향 받고

상하로 기울이는 것은 Y좌표에만 영향을 받기 때문에 조건식을 줄일 수 있습니다.

그래서 R의 X좌표가 B의 X좌표보다 큰 경우 오른쪽으로 기울일 때, 왼쪽으로 기울일 때 이렇게 두 조건을 고려해 주면됩니다.

마찬가지로 BX > RX 경우 오른쪽으로 기울일 때, 왼쪽으로 기울일 때 고려

다음 BY > RY는 위로 기울이는 경우, 아래로 기울이는 경우

마지막으로 RY > RX도 위 아래 고려

이렇게 해서 각 좌표를 구해주면 다음 빨간 구슬과 파란 구슬의 좌표를 구할 수 있습니다.

그 다음 이 좌표를 바로 큐에 넣는 것이 아니라 중복한 것을 빼주어야 합니다.

1. 전에 기울였던 방향으로 돌아가는 경우

2. 빨간 파란 구슬위치가 둘 다 기울이기 전과 똑같은 경우

1번 경우는 생각해보면 오른쪽으로 기울였다가 다시 왼쪽으로 기울이면 결국 똑같은 것을 반복하는 것이기 때문에 걸러주어야 하고

2번 경우도 마찬가지 입니다.

그래서 정답인지 아니면 불가능한 좌표인지 기울이는 횟수가 10이하인지 확인 후

큐에 구슬 좌표와 기울인 횟수, 기울인 방향(중복 확인 용) 이렇게 넣어주면 됩니다.

큐에 넣는 변수가 6개 이다 보니 tuple을 사용했습니다.

튜플은 간단히 pair와 비슷한데 pair 2개의 변수를 저장했다면 tuple은 다수의 변수를 저장할 수 있습니다.

조건들이 조금 복잡해서 이해가 안가신다면 코드 주석을 보면서 이해하셔도 좋습니다.

물론 제 코드가 엄청 깔끔하게 짜인 것은 아니지만 문제를 이해하는데는 충분할 것 같습니다.

전체코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

#include <iostream>
#include <tuple>
#include <queue>
#include <vector>
using namespace std;
char map[11][11];
int n, m;
int bx, by, rx, ry; // 구슬 위치
int hx, hy; // 구멍 위치
int dx[] = {0, 0, 1, -1}; //하상우좌
int dy[] = {1, -1, 0, 0};
bool stop = false; // 빨간 구슬이 구멍에 들어갔는지
int result = 0;
 
bool checkHall(int a, int b){ // 구슬이 구멍에 빠졌는지 확인
    if(a != hx || b != hy)
        return false;
    return true;
}
 
void bfs(){
    queue<tuple<int, int, int ,int, int, int>> q;
    q.push(make_tuple(bx, by, rx, ry, 1, -1));
    while(!q.empty()){
        if(stop){
            result = 1;
            return;
        }
        int bbx = get<0>(q.front()); // 현재 파란 구슬 좌표 변수
        int bby = get<1>(q.front());
        int rrx = get<2>(q.front()); // 현재 빨간 구슬 좌표 변수
        int rry = get<3>(q.front());
        int cnt = get<4>(q.front()); // 기울인 횟수 
        int bef = get<5>(q.front()); // 전에 어느 방향으로 기울였는지
        q.pop();
        for (int i = 0; i < 4; i++){
 
            // 전에 왔던 방향으로 다시 가는 것은 중복 -> 갈 필요없음
            if(bef == 0 && i ==1)
                continue;
            if(bef == 1 && i ==0)
                continue;
            if(bef == 2 && i ==3)
                continue;
            if(bef == 3 && i ==2)
                continue;
            
            if(stop){ // 빨간 구슬 들어간 경우
                result = 1;
                return;
            }
 
            int nbx = bbx; // 다음 파란 구슬 좌표 변수
            int nby = bby;
            int nrx = rrx; // 다음 빨간 구슬 좌표 변수
            int nry = rry;
            bool possible = true; // 다음 좌표로 갈 수 있는 경우인지
 
            while(map[nby][nbx] != '#'){ // 벽을 만나면 종료
                nbx += dx[i]; // 한 칸씩 좌표 이동
                nby += dy[i];
                if(checkHall(nbx, nby)){ // 구멍을 만났다.
                    possible = false; // 파란 구슬 들어감.
                    break;
                }
            }
            while(map[nry][nrx] != '#'){
                nrx += dx[i]; // 한 칸씩 좌표 이동
                nry += dy[i];
                if(checkHall(nrx, nry)){ // 구멍을 만났다.
                    stop = true;
                    break;
                }
            }
 
            if(!possible && stop){ // 빨강 파란 구슬 동시에 빠진 경우
                stop = false; // 불가능으로 바꾸어줌.
            }else if(stop){
                result = 1;
            }
 
            // 벽을 만날 때 까지 좌표를 + 해서 그 전 좌표로 이동 시켜줌
            nbx -= dx[i]; 
            nby -= dy[i];
            nrx -= dx[i];
            nry -= dy[i];
 
            //두 개의 구슬이 만난 경우
            if(nbx == nrx && nby == nry){
                if(bbx > rrx){ // B좌표가 더 큰 경우
                    if(i == 2){ // 우측 기울 일 때.
                        nrx -= dx[i];
                    }else if (i == 3){ // 좌측 기울 일 때.
                        nbx -= dx[i];
                    }
                }else if(bbx < rrx){
                    if(i == 2){
                        nbx -= dx[i];
                    }else if (i == 3){
                        nrx -= dx[i];
                    }                    
                }else if(bby > rry){
                    if(i == 0){
                        nry -= dy[i];
                    }else if (i == 1){
                        nby -= dy[i];
                    }                    
                }else if(bby < rry){
                    if(i == 0){
                        nby -= dy[i]; 
                    }else if (i == 1){
                        nry -= dy[i];
                    }                    
                } 
            }
 
            if(nbx == bbx && nby == bby && rrx == nrx && rry ==nry){
                //두 구슬 위치가 기울이기 전과 같은 경우
                possible = false;
            }
            if(!stop && possible && cnt + 1 <= 10){
                q.push(make_tuple(nbx, nby, nrx, nry, cnt + 1,i));
            } 
        }
 
    }
}
 
int main(){
    cin >> n >> m;
    for (int i = 0; i < n; i++){
        for (int j = 0; j < m; j++){
            cin >> map[i][j];
            if(map[i][j] == 'B'){ // 초기 파란 구슬 위치
                bx = j;
                by = i;
            }else if(map[i][j] == 'R'){ // 초기 빨간 구슬 위치
                rx = j;
                ry = i;
            }else if(map[i][j] == 'O'){ // 구멍 위치
                hx = j;
                hy = i;
            }
        }   
    }
    bfs();
    if(stop) // 성공했다면
        cout << result;
    else
        cout << 0;
    return 0;
}
Colored by Color Scripter

cs

체감 난이도	걸린 시간	후기	사용 알고리즘
중상	1.5h	조건들을 놓치지 않고 하나씩 생각하는데 시간이 조금 걸림	BFS

백준 2665 미로만들기 c++ [컴공과고씨]

시간빌게이츠 — Fri, 12 Aug 2022 15:36:22 +0900

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

2665번: 미로만들기

첫 줄에는 한 줄에 들어가는 방의 수 n(1 ≤ n ≤ 50)이 주어지고, 다음 n개의 줄의 각 줄마다 0과 1이 이루어진 길이가 n인 수열이 주어진다. 0은 검은 방, 1은 흰 방을 나타낸다.

www.acmicpc.net

문제 정리

바둑판 모양이 있음.

각 방 마다 지나갈 수 있는 방과 없는 방으로 나뉨.

갈수 없는 방은 뚫 수 있음.

(0,0) 에서 (n-1,n-1)까지 가는데 방을 최소한으로 뚫어서 갈 때 몇 개를 뚫어야 하는가?

문제 해결 방법

BFS를 사용해서 탐색을 하는데 각 방 마다 뚫고 온 방의 개수를 적어서 BFS 탐색을 해주면 됩니다.

방의 초기 값은 크게 잡아 줍니다. 그 후 시작점은 0으로 해줍니다.

BFS를 시작하면 각 방으로 들어갑니다.

이 때 다음 방이 막힌 방이라면 이제 까지 뚫고 온 개수에 1을 더하고 저장된 개수와 비교하여 저장된 개수 보다 적을 때만 저장해 줍니다.

다음 방이 빈 방이라면 이제 까지 뚫고 온 개수와 저장된 개수를 비교하여 저장된 개수 보다 뚫고 온 개수가 더 적을 때만 저장해주고 다음 방으로 넘어가도록 합니다.

왜냐하면 저장된 개수보다 뚫은 개수가 더 크다면 이미 정답이 될 수 없으므로 더 이상 탐색할 필요가 없습니다. 또한 같은 경우는 중복 탐색이므로 마찬가지로 더 이상 탐색 할 필요가 없습니다.

전체 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

#include <iostream>
#include <queue>
#include <vector>
#include <cstring>
using namespace std;
int n;
int map[52][52]; // 빈 방, 막힌 방
int visit[52][52]; // 뚫고 온 개수 저장
int dx[] = {0, 0, -1, 1}; // 상하좌우
int dy[] = {1, -1, 0, 0}; // 상하좌우
 
void bfs(){
    queue<pair<int, int>> q;
    q.push(make_pair(0, 0));
    visit[0][0] = 0; // 시작 점은 0으로 세팅
    while(!q.empty()){
        int x = q.front().first; 
        int y = q.front().second;
        q.pop();
        
        for (int i = 0; i < 4; i++){
            int nx = x + dx[i]; // 다음 x 좌표
            int ny = y + dy[i]; // 다음 y 좌표
            if(nx >=0 && nx < n && ny>=0 && ny <n){
                if(map[ny][nx] == 1){ // 갈 수 있는 방
                    if(visit[ny][nx] > visit[y][x]){
                        //뚫고 온 방의 개수 비교 
                        visit[ny][nx] = visit[y][x];
                        q.push(make_pair(nx, ny)); // 다음 방으로 이동
                    } 
                }else{ // 비어 있는 방
                    if(visit[ny][nx] > visit[y][x]+1){
                        //뚫고 온 방의 개수 비교
                        visit[ny][nx] = visit[y][x]+1;
                        q.push(make_pair(nx, ny)); // 다음 방으로 이동
                    } 
                }
            }
        }  
    }     
}
 
int main(){
    ios::sync_with_stdio(false);
    cin >> n;
    char a;
    for (int i = 0; i < n; i++){
        for (int j = 0; j < n; j++){
            cin >> a;
            map[i][j] = a - '0'; // 입력을 int로 바꾸어줌
        }
    }
    for (int i = 0; i < n; i++){
        for (int j = 0; j < n; j++){
            visit[i][j] = 987654321; // 최대 값
        }
    }
    bfs();
    cout << visit[n - 1][n - 1] << endl;
 
    return 0;
}
Colored by Color Scripter

cs

 

체감 난이도	걸린 시간	후기	사용 알고리즘
중	1H	간단한 문제 였는데 처음에 백트래킹으로 풀어 시간초과로 푸는데 오래 걸렸음.	BFS

백준 20055 컨베이어 벨트 위의 로봇 c++ [컴공과고씨]

시간빌게이츠 — Fri, 12 Aug 2022 15:18:30 +0900

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

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

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

www.acmicpc.net

문제 정리

컨베이어 벨트가 있음

벨트 구성은

이런식으로 벨트는 회전합니다.

올리는 위치에서 로봇을 올리고 내리는 위치에 로봇이 도착하면 로봇을 즉시 내립니다.

또한 벨트마다 내구도가 주어짐.

벨트 작동 순서

1. 벨트가 각 칸 위에 있는 로봇과 한 칸 움직임

2. 벨트에 먼저 올라간 로봇 부터 벨트가 움직이는 방향으로 로봇을 한 칸 움직임

2-1) 움직이는 조건은 다음 칸의 내구도가 0보다 커야하고 로봇이 없어야 함.

3. 올리는 위치에 내구도가 0보다 크다면 로봇을 올림

4. 내구도가 0인 칸의 개수가 K개 이상이면 종료.

위 과정을 1 단계라고 하고 몇 번째의 단계 중에 종료가 되는지 구하는 문제.

문제 해결 방법

2N개의 배열을 선언을 하여 벨트를 만들어 주고 로봇이 있는지 여부도 배열로 선언해 줍니다.

1번째 단계 과정을 할 때 벨트를 직접 모두 한 칸 씩 옮기면 매 단계마다 엄청난 시간이 들게 됩니다.

그래서 저는 시작점과 끝나는 지점 즉, 올리는 위치와 내리는 위치 인덱스를 옮겨서 마치 벨트가 움직인 것처럼 만들어 주었습니다.

그림으로 설명하면

이런 식으로 시작 위치와 끝 위치 인덱스를 조작해서 문제를 해결 해 주었다.

1번째 작동은 start 위치와 end 위치를 -1씩 해주는데 (문제에서 인덱스 0부터 시작으로 해서 풀었음)

여기서 만약 인덱스가 0이라면 인덱스를 2N-1로 옮겨주는데 주의해야 한다.

또한 문제에서 내리는 위치에 로봇이 있으면 바로 내리기 때문에 인덱스를 옮긴 후

end 위치에 로봇이 있으면 바로 내려주어야합니다.

2번째 작동은 로봇을 옮겨주는 과정이다.

여기도 마찬가지로 start 위치와 end위치를 잘 사용하면 해결 할 수 있다.

(첫 번째 단계에서는 올라간 로봇이 없기 때문에 수행하지 않는다.)

일단 맨 먼저 올라간 로봇이 당연히 end위치와 가깝기 때문에 end에서 부터 start까지 인덱스를 감소시키며 확인해줍니다.

1. 다음 위치에 로봇이 없는지

2. 현재 위치에 로봇이 존재하는지

3. 다음 위치의 내구도가 0보다 큰지

위의 3조건을 만족하면 로봇을 옮길 수 있으므로

다음 위치의 내구도를 감소시킨다.

내구도가 0이 되었다면 개수를 추가해주고 총 개수가 k개 이상이면 종료 flag에 표시를 해줍니다.

다음 좌표에 로봇을 추가하고 현재 좌표에 로봇은 없애줍니다.

3번째 작동은 로봇을 올리는 과정입니다.

올리는 위치 인덱스로 벨트 내구도 확인 후에 로봇을 올려주고 내구도 0의 개수가 k이상인지 확인해주면 됩니다.

위 전체 작동 과정이 단계이므로 위 3 작동이 다 완수 되면 result +1 을 해주면 됩니다.

전체코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

#include <iostream>
#include <vector>
using namespace std;
int n, k;
int belt[202];
bool robot[202] = {0};
int start_pos = 0;
int end_pos;
int inital_robot_pos = -1;
int result = 1;
int cnt = 0;
bool stop = false;
 
void rotation_belt(){
    if(start_pos == 0) // 0이면 맨 뒤의 인덱스로 옮김
        start_pos = 2 * n - 1;
    else
        start_pos--;
    
    if(end_pos == 0) // 0이면 맨 뒤의 인덱스로 옮김
        end_pos = 2 * n - 1;
    else
        end_pos--;
 
    if(robot[end_pos])
        robot[end_pos] = false;
}  
 
void move_robot(){
    if(inital_robot_pos != -1){ 
        // 첫번째 단계에서는 로봇이 없기 때문에 패스
        int idx = end_pos;
        for (int i = 0; i < n-1;i++){
            int next = idx; // 로봇이 갈 다음 위치
            if(idx == 0)
                idx = 2 * n - 1; // 현재 위치      
            else
                idx--; 
 
            if(!robot[next] && robot[idx] && belt[next] > 0){
                // 다음 위치에 로봇이 없는지
                // 현재 위치에 로봇 존재 하는지
                // 다음 위치의 내구도가 0보다 큰지
                belt[next] -= 1; // 내구도 감소
                if(belt[next] == 0){ // 내구도가 0이면
                    cnt++; // 내구도 0 개수 추가
                    if(cnt >= k){
                        stop = true; // 종료 flag
                        break;
                    }
                }
                robot[next] = true; // 다음 좌표 로봇 true
                robot[idx] = false; // 현재 좌표 로봇은 옮겼으니 false
            }
        }
        robot[end_pos] = false; // 내리는 위치 로봇 내려줌
 
    }
}
 
void put_robot(){
    if(belt[start_pos] > 0){ 
        belt[start_pos] -= 1; // 내구도 감소
        if(belt[start_pos] == 0){ // 종료 조건
            cnt++;
            if(cnt >= k){
                stop = true;
            }
        }
        robot[start_pos] = true; // 로봇 올림
        inital_robot_pos = 0; // 로봇 올리기 시작.
    }
}
 
int main(){
    cin >> n >> k;
    int temp;
    for (int i = 0; i < 2*n;i++){
        cin >> belt[i];   
    }
    end_pos = n - 1;
    while(!stop){
        rotation_belt();
        move_robot();
        put_robot();
        if(stop) // 종료
            break;
        result++; // 단계 완수
    }
    cout << result << endl;
    return 0;
}
Colored by Color Scripter

cs

 

체감 난이도	걸린시간
중	1h

백준 14890 경사로 c++ [컴공과고씨]

시간빌게이츠 — Fri, 12 Aug 2022 14:06:50 +0900

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

14890번: 경사로

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

www.acmicpc.net

문제 간단 정리

한 행렬이 있을 때 한 행으로 쭉 갈거나 한 열로 쭉 갈 수 있다면 그것은 길이다.

길의 개수를 세야함.

근데 각 좌표에는 높이가 있음.

높이가 다르면 경사로를 설치해서 지나갈 수 있음.

경사로 설치 조건

1. 높이 차는 1이여야함.

2. L이 주어지는데 높이가 낮은 쪽에 L개수 만큼 같은 높이로 좌표가 있어야 설치가 가능함.

3. 경사로는 곂쳐지면 안됨.

문제 해결 방법

일단 행렬이 있을 때 가로 길을 확인 하는 함수를 구현했습니다.

한 행을 정하고 그 행 1열 부터 N까지 하나씩 나아갑니다.

이 때 다음 좌표를 높이를 보고 3가지 경우로 일단 나누어 줍니다.

1. 다음 좌표가 높이 차가 1보다 더 크게 날 때 => 이미 길이 될 수 없으므로 이 행은 X

2. 다음 좌표가 1만큼 작아 지나갈 길에 경사로를 설치 할 때

2-1) 지나갈 좌표 중 L만큼의 같은 높이로 이루어져 있는지

2-2) 위 조건을 만족하지 않으면 경사로 설치 불가능.

2-3) 만족하면 경사로가 설치된 마지막 좌표에 경사로가 설치되었다고 표시 -> 경사로 곂치는 것을 막기 위해.

3. 다음 좌표가 1만큼 커서 지나온 길에 경사로를 설치 할 때

3-1) 지나온 좌표를 확인하며 L만큼 같은 높이로 이루어져 있는지 확인

3-1) 이 부분에서는 지나온 길에 경사로가 설치되어있는지 꼭 확인해주어야 함.

3-2) 불가능 하면 경사로 설치 불가능.

1,2,3을 모두 통과하면 길로 인정함.

이렇게 가로를 확인하는 행렬을 만들었다면 그 세로 길을 확인하는 방법은 세로로 된 길을 가로길로 만들어서 함수에 넘겨주면 된다.

무슨 말이냐면 문제에서 준 행렬의 X좌표와 Y좌표를 바꾸어주면 세로였던 길이 가로로 가게 되고 가로였던길이 세로로 간다.

그래서 바꾸어준 행렬을 다시 함수에 넣어주어 길의 개수를 세주면 된다.

전체 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

#include <iostream>
#include <cmath>
using namespace std;
int road1[101][101];
int road2[101][101];
int n, l;
int result = 0;
void PassCnt(int road[][101]){
    //가로 확인
    for (int i = 0; i < n; i++){  
        bool slope[101] = {0}; // 경사로 여부
        bool possible = true; // 가능한 길인지 확인
        for (int h = 0; h < n-1; h++){
            if(abs(road[i][h]-road[i][h+1]) > 1){
                // 1. 높이차가 1보다 크면 불가능한 길 
                possible = false;
                break;
            }
            
            // 2. 경사로를 위에서 아래로 설치 할 때
            if(road[i][h] == road[i][h+1] + 1){
                int cur_hight = road[i][h + 1];
                for (int k = h+2; k < h+1+l; k++){
                    if(k >= n || road[i][k] != cur_hight){
                        //L만큼의 여유가 있는지 확인
                        possible = false;
                        break;
                    }
                }
                if(possible){
                    //경사로 설치하면 설치했다고 표시
                    slope[h + l] = true;
                }else{
                    break;
                }
            }
 
            // 3. 경사로를 아래에서 위로 설치 할 때
            if(road[i][h] == road[i][h+1] - 1){
                int cur_hight = road[i][h];
                for (int k = h; k > h - l; k--){
                    if(k < 0 || road[i][k] != cur_hight || slope[k]){
                        // L만큼의 여유와 경사로 설치 여부 확인
                        possible = false;
                        break;
                    }
                }
                if(!possible){
                    break;
                }
            }
        }        
        if(possible){
            result++; // 길이면 카운트
        }
    }
}
 
int main(){
    cin >> n >> l; // 입력
    for (int i = 0; i < n; i++){
        for (int j = 0; j < n; j++){
            cin >> road1[i][j]; // 가로로 가는 길 확인
            road2[j][i] = road1[i][j]; // 세로로 가는 길 확인
        }
    }
    PassCnt(road1); // 가로로 가는 길 개수
    PassCnt(road2); // 세로로 가는 길 개수
    cout << result << endl;
 
    return 0;
}
Colored by Color Scripter

cs

체감 난이도	걸린 시간
중	40M

문제가 복잡해 보여도 하나씩 따라가면 풀 수 있는 문제였습니다.