hoonDEV

Angular에서 Tailwind CSS 사용해보기

훈개발자 — Tue, 14 Jul 2020 17:09:32 +0900

이 문서는 개발을 하면서 차차 채워나갈 예정입니다.

회사에서 Tailwind CSS를 도입하게 되면서, Tailwind CSS에 대해서 알아보기로 하였다.

Angular 프로젝트에 Tailwind CSS 도입하기

너무 감사하게도 ng eject로 Webpack 설정을 바꾸지 않고, Angular 프로젝트에 Tailwind CSS를 도입할 수 있는 ng-tailwindcss라는 좋은 CLI가 있다.

설치 방법

npm i ng-tailwindcss -g : 글로벌에 Angular 프로젝트에 Tailwind CSS를 도입할 수 있도록 도와주는 ng-tailwindcss를 설치한다.
npm i tailwindcss -D : 해당 프로젝트에 tailwindcss 라이브러리를 추가한다.
npx tailwind init : Tailwind CSS를 프로젝트에서 사용할 수 있도록 초기 파일을 생성한다.
ngtx configure : ng-tailwindcss가 해당 프로젝트의 Tailwind CSS를 관리할 수 있도록 하는 설정 파일을 생성한다.
touch src/tailwind.scss : Tailwind CSS는 이 파일에 있는 Utility들을 프로젝트가 실행되는 내내 감시(watch)하며 변동된 사항이 있을 경우 이를 스타일에 반영한다. 그러한 기능을 담당하는 tailwind.scss를 생성한다.

사용 방법

처음 설치 과정이 끝나면 루트 폴더에 ng-tailwind.js가 생성된다.

module.exports = {
  // Tailwind Paths
  configJS: 'tailwind.config.js',
  sourceCSS: 'src/tailwind.scss',
  outputCSS: 'src/styles.scss',
  // Sass
  sass: false,
  // PurgeCSS Settings
  purge: false,
  keyframes: false,
  fontFace: false,
  rejected: false,
  whitelist: [],
  whitelistPatterns: [],
  whitelistPatternsChildren: [],
  extensions: [
    '.ts',
    '.html',
    '.js'
  ],
  extractors: [],
  content: []
}

처음에는 sourceCSS와 outputCSS의 확장자가 모두 css로 되어 있을탠데, 우리는 SCSS를 사용하므로, 확장자를 모두 scss로 바꿔주었다.

실제로 src/tailwind.scss를 Tailwind가 프로젝트가 실행되는 동안 감시하며 Tailwind에서 정의된 Utility 스타일과 사용자가 정의한 Custom 스타일을 조합 및 생성하여 src/styles.scss로 output된다. 이를 이용해 프로그램 전역에 적용하는 것이다.

src/tailwind.scss에 아래와 같이 써줘서 Tailwind CSS를 시작한다.

@tailwind base; @tailwind components; @tailwind utilities;

Pre-flight

첫 번째 줄인 @tailwind base는 Tailwind CSS에서 Pre-flight라고 부른다.

브라우저 간의 스타일 불일치를 줄이고, 브라우저의 제약 조건 내에서 스타일링을 쉽게 해주기 위해 Tailwind CSS에서 제공하는 기본 스타일 세트이다.

거의 기본 스타일을 제거하여 커스터마이징을 쉽게 하도록 하는 역할을 하는 것 같다. 어차피 Tailwind CSS에서 제공하는 다양한 스타일링 유틸리티 들을 이용하면 되기 때문이다.

@tailwind base을 적용할 경우 아래와 같은 스타일들이 style.scss로 output된다.

제목, 인용 부호, 단락 등과 같은 요소에 기본 margin이 제거됩니다.

blockquote, dl, dd, h1, h2, h3, h4, h5, h6, figure, p, pre { margin: 0; }

기본 설정된 margin으로 인해 스타일링에 있어서 실수를 줄이기 위함이라고 합니다.

제목(h1, h2..) 태그에 스타일이 없습니다.

h1, h2, h3, h4, h5, h6 { font-size: inherit; font-weight: inherit; }

CSS에서 Type scale 스타일링에 문제가 생기지 않도록 도와준답니다. (무슨 의미인지는 모르겠..)
UI 개발에 있어서 종종 제목이 강조되지 않아야 할 때가 있는데, 이를 위해 일단 제거한다고 합니다.

리스트 태그에 스타일이 없습니다.

ol, ul { list-style: none; margin: 0; padding: 0; }

이미지는 block입니다.

img, svg, video, canvas, audio, iframe, embed, object { display: block; vertical-align: middle; }

display: inline으로 지정되어 있음으로서 발생하는 다양한 문제들을 사전에 차단합니다.

테두리 스타일들을 전역적으로 재설정합니다.

\*, \*::before, \*::after { border-width: 0; border-style: solid; border-color: theme('borderColor.default', currentColor); }

테두리 커스터마이징을 쉽게 하기 위함입니다.

이보다 더 많은 스타일들이 있지만, 가장 중요한 몇 개만 설명하였습니다. 자세한 내용은 여기를 클릭하세요.

커스터마이징

Pre-flight Extension

@tailwind base;
h1 { @apply text-2xl; }
h2 { @apply text-xl; }
h3 { @apply text-lg; }
a { @apply text-blue-600 underline; }
@tailwind components;
@tailwind utilities;

위와 같이 @tailwind base 아래에 기본 스타일에 대한 커스터마이징을 할 수 있습니다.

tailwind.config.js

module.exports = { purge: \[\], theme: { extend: {}, }, variants: {}, plugins: \[\], }

이는 아직 사용해보지 못하였으므로 추후에 기재하겠습니다. 이 링크를 클릭하여 자세히 알아볼 수 있습니다.

루트 폴더에 생성된 tailwind.config.js에서 다양한 기능들을 사용하고 설정할 수 있다.

References

Angular 의존성 주입 - (4) 선택적 의존성 주입

훈개발자 — Tue, 7 Jul 2020 14:38:08 +0900

선택적 의존성 주입

@Optional 데코레이터를 사용하여 의존성 주입이 필수가 아님을 Angular에 명시한다. 이를 사용하면 의존성이 없더라고 앱이 중단되지 않는다.

export class TheComponent {
    constructor(**@Optional** private apiUrl: TheService) {
        ...
    }
}

Angular 서비스 주입 - (3) 인젝션 토큰

훈개발자 — Tue, 7 Jul 2020 14:37:32 +0900

인젝션 토큰

앞서 알아본 값 프로바이더에서 문자열이나 숫자 등을 토큰으로 문자열을 사용하거나, 클래스를 사용하여야 했다. 값 프로바이더에서 문자열을 토큰으로 사용할 경우 중복될 위험이 있고, 클래스를 토큰으로 사용할 경우 로직이 이상해졌다.

인젝션 토큰은 클래스가 아닌 객체, 문자열, 함수 등을 위한 토큰을 주입받기 위해 사용한다.

export const GET_API_URL: string = 'https://api.myapp.com/api/get';

export const API_URL = new InjectionToken<string>('api-url');

export const ApiUrlProvider = {
    provider: API_URL,
    useValue: GET_API_URL
};

~

@Component({
    ~
    providers: [ApiUrlProvider]
})
export class TheComponent {
    constructor(@Inject(API_URL) private apiUrl: string) {
        ...
    }
}

Angular 의존성 주입 - (2) 프로바이더 (Provider)

훈개발자 — Tue, 7 Jul 2020 11:37:59 +0900

프로바이더 (Provider)

Angular는 서비스의 인스턴스 생성과 구성요소에 그 서비스를 주입하는 권한을 위임 받았다. 그러나, Angular는 인스턴스를 어떻게 생성하는지 모르므로 이를 알려줘야 한다. 그 역할을 프로바이더가 한다.

따라서 프로바이더는 Angular에 의존성 인스턴스의 생성 정보를 알린다.

프로바이더 사용 방법

@Injectable의 provideIn 프로퍼티

// 루트 인젝터에 제공
@Injectable({
    providedIn: 'root',
})

// 특정 모듈에 등록
// 그 모듈의 **모든 구성요소에서 주입할 수 있음.**
@Injectable({
    providedIn: YourModule,
})

@Component 메타데이터의 providers 프로퍼티

    // 해당 컴포넌트와 하위 컴포넌트에 주입할 수 있음.
@Component({
    ...
    providers: [TempService]
})

@NgModule 메타데이터의 providers 프로퍼티

// 그 모듈의 **모든 구성요소에서 주입할 수 있음.**
@NgModule({
    ...
    providers: [TempService]
})

프로바이더의 종류

클래스 프로바이더 : 앞에서 설명했으므로 생략
값 프로바이더
팩토리 프로바이더

값 프로바이더

주입 대상의 타입이 클래스가 아닌 문자열, 숫자, 불리언 타입일 경우

providers: [
    {
        provide: 'API',
        useValue: 'https://api.myserver.com/get'
        // provide 토큰을 클래스로 지정할 수 없으므로 문자열로 한다.
    }
]

~

constructor(
    // 문자열은 타입 추론이 안되므로 @Inject 데코레이터를 사용한다.
    @Inject('API') private api: string
)

팩토리 프로바이더

의존성 인스턴스를 생성할 때 어떠한 로직을 거쳐야 할 때, 팩토리 함수를 통해 로직을 처리하고 인스턴스를 생성한다.

~~.service.provider.ts를 만들어서 팩토리 프로바이더와 팩토리 함수를 정의한다. 아래 예시를 보자.

import { TestService } from './test-service-1';
import { MockTestService } from './test-service-2';

// Factory Function
const factoryFunc = (param) => param ? new TestService : new MockTestService;

// Factory Provider
export const TestServiceProvider = {
    provide: TestService, 
    use**Factory**: factoryFunc, // 팩토리 함수 등록
    deps: ['param']
};

// Provider that injects value to factory function
export const SetParamProvider = {
    provide: 'param',
    useValue: false
}

~

// Component
@Component({
    ...
    providers: [
        TestServiceProvider,
        SetParamProvider
    ]
})

provide : 최종적으로 생성될 인스턴스 Type
useFactory : 사용할 팩토리 함수
deps : 팩토리 함수에 주입할 의존성 토큰 배열

Angular 의존성 주입 - (1) 서비스

훈개발자 — Tue, 7 Jul 2020 11:37:14 +0900

서비스 (Service)

사용하는 이유

컴포넌트의 독립성을 보장하여 재사용성을 높이기 위해
프로젝트의 복잡성을 낮추기 위해
특정 기능을 어플리케이션 전역으로 분리하여 사용하기 위해

코드

서비스를 처음 생성하면 아래와 같은 기본 코드가 생성된다.

import { Injectable } from '@angular/core';

@Injectable({
  providedIn: 'root',
})
export class TempService {
  constructor() { }
}

@Injectable 데코레이터

서비스를 정의하는 클래스 위에 @Injectable이라는 데코레이터가 있다. 이 데코레이터는 Angular가 서비스를 정의하는 이 클래스를 서비스로서 인식하고 Dependency로 주입할 수 있도록 인젝터에 프로바이더로 등록한다.

provideIn : Angular 6에서 도입된 것으로, 프로퍼티 값으로 root를 설정하면 루트 인젝터에게 서비스를 제공하도록 지시한다. 이 경우, 싱글톤으로 생성되어 앱 전역에서 서비스를 Injection할 수 있게 한다.

서비스를 컴포넌트에서 사용하기

// 의존성 주입 패턴
constructor(private tempService: TempService) {} // Angular에게 인스턴스 주입 위임
// 위와 같이 생성자 파라미터에 접근 제한자를 선언하면 프로퍼티로 생성된다.

// 사용하지 말아야 할 패턴
tempService: TempService; // Property 생성
constructor() {
    this.tempService = new TempService(); // 직접 인스턴스 생성하고 할당
}

두 번째 코드와 같이 컴포넌트에서 서비스의 인스턴스를 생성하면, 서비스와 컴포넌트는 긴밀한 결합을 하게 된다. 이 경우 컴포넌트와 서비스가 서로 크게 의존하게 되어, 하나의 객체를 변경하면 다른 하나의 객체 또한 변경하여야 한다. 이는 큰 프로젝트일 수록 변경점을 확인하고 수정점에 대해 대응하기가 어렵다.

이를 해결하기 위해 인스턴스 생성을 Angular에서 하고, 그 인스턴스를 Angular가 컴포넌트에 주입해주는 첫 번째 코드 즉, 인스턴스 주입 방식을 이용한다. → 느슨한 결합

앞서 설명했던 provideIn: 'root' 가 느슨한 결합을 구현하기 위해 Angular에게 인스턴스 생성 주체를 위임하는 것이다.

서비스는 항상 컴포넌트에서만 사용할 수 있는 것은 아니므로, 앞으로는 구성요소라고 칭합니다.

JavaScript에서의 this와 this 바인딩

훈개발자 — Sat, 27 Jun 2020 02:14:23 +0900

흔한 객체지향 언어에서의 this

this는 Java와 같은 객체지향 언어에서 주로 이 인스턴스(즉, 자신)를 가리키기 위해 사용한다. 아래 코드와 같이.

class Person {
  private String name;

  Person(String name) {
      this.name = name;
  }
}

위 예제는 Java에서의 this의 용례를 보여주기 위한 코드이다. Java에서 this는 주로 매개변수와 인스턴스 자신의 프로퍼티(멤버) 변수의 이름이 같을 경우 이를 구분하기 위해 사용한다.

JavaScript에서의 this

그러나, JavaScript에서의 this는 함수 호출을 어떻게 하느냐(선언이 아님!!)에 따라 다른 객체들이 바인딩된다.

this는 기본적으로 전역객체를 참조한다.
전역 함수는 물론이거나와, 그 함수의 내부에 있는 함수까지도 this는 전역객체를 참조한다.

this를 생성자 함수에서, 혹은 객체의 메소드에서 사용하는 경우가 아니면, this는 전역객체를 참조한다. 브라우저에서는 window를 참조하게 된다.

그냥 함수를 호출했을 때의 this

function Person(name) {
  this.name = name; // this === window
}

const me = Person('hoondev');

console.log(me); // undefined
console.log(name); // hoondev
console.log(this); // window 객체
console.log(this.name); // hoondev

이번에는 생성자 함수로서가 아니라, 그냥 함수의 호출로서 사용하였다. 그러므로 this는 자연스레 전역객체를 참조하게 되었다. 따라서, name은 전역변수로서 선언이 된 것이다. Person 함수의 리턴값이 없으므로 undefined이다.

일반 함수의 내부 함수에서의 this

function func() {
  console.log(this); // window 객체
  function nestedFunc() {
    console.log(this); // window 객체
  }
  nestedFunc();
}
func();

내부 함수에서도 this는 외부 함수가 아닌 전역 객체를 참조한다.

메소드의 내부 함수에서의 this

const obj = {
  text: 'hoondev',
  func: function() {
    console.log(this); // obj 객체
    console.log(this.text); // hoondev
    function nestedFunc() {
      console.log(this); // window
      console.log(this.text); // undefined
    }
    nestedFunc();
  }
};

객체의 함수, 즉 메소드를 호출하는 경우, 그 메소드의 this는 해당 메소드를 프로퍼티로 가지는 객체를 참조한다.
그래서, func에서의 this는 obj를 가리킨다.

그러나, 메소드의 내부 함수에서의 this는 전역 객체를 참조한다.

생성자 함수를 호출했을 때 this

function Person(name) {
  this.name = name; // this === window
}

const me = new Person('hoondev');
console.log(me.name); // hoondev
console.log(name); // ReferenceError: name is not defined

const me2 = Person('hoondev');
console.log(me2.name); // ReferenceError: name is not defined
console.log(name); // hoondev

함수를 생성자로서 사용하는 경우, this는 여느 객체지향 언어와 같이 자기 자신을 참조한다.

콜백함수에서의 this

let a = 1;
const obj = {
  let a = 1;
  func: function() {
    setTimeout(function() {
      console.log(this); // window
      console.log(this.a); // 1
    }, 100);
  }
}

obj.func();

this 바인딩

this는 함수 호출 패턴에 따라 결정된다고 하였다. 그러나 이를 무시하고, this가 무엇을 가리키는지 명시적 바인딩을 해줄 수 있다. 그러나 이 바인딩 방식은 Arrow Function에서는 적용할 수 없다.

apply

this에 특정 객체를 바인딩하고, 바인딩한 그 함수를 호출한다.

const School = function (name, pos) {
  this.name = name;
  this.pos = pos;
}

const obj = {};

School.apply(obj, ['Namsan Mid-School', 'Busan']);
console.log(obj); // { name: 'Namsan Mid-School', pos: 'Busan' }

call

apply와 동일하지만, 두 번째 인자로 넘겨주는 arguments를 배열의 형태가 아니라 각각 전달해준다.

const School = function (name, pos) {
  this.name = name;
  this.pos = pos;
}

const obj = {};

School.call(obj, 'Namsan Mid-School', 'Busan');
console.log(obj); // { name: 'Namsan Mid-School', pos: 'Busan' }

bind

bind에 인자로 전달한 객체가 this에 바인딩되고, 바인딩된 그 함수를 리턴한다. 리액트의 Class Component에서 많이 사용한다.

const obj = {};
const Home = function() {
  ...
}.bind(obj);

브라우저의 렌더링 원리

훈개발자 — Fri, 26 Jun 2020 22:39:43 +0900

이 문서에서 사용되는 그림은 모두 네이버 D2의 브라우저는 어떻게 동작하는가?에서 발췌하였습니다.

브라우저의 구성 요소

출처 : 네이버 D2

사용자 인터페이스 - 주소 표시줄, 이전/다음 버튼, 북마크 메뉴 등. 요청한 페이지를 보여주는 창을 제외한 나머지 모든 부분이다.
브라우저 엔진 - 사용자 인터페이스와 렌더링 엔진 사이의 동작을 제어.
렌더링 엔진 - 요청한 콘텐츠를 표시. 예를 들어 HTML을 요청하면 HTML과 CSS를 파싱하여 화면에 표시함.
통신 - HTTP 요청과 같은 네트워크 호출에 사용됨. 이것은 플랫폼 독립적인 인터페이스이고 각 플랫폼 하부에서 실행됨.
UI 백엔드 - 콤보 박스와 창 같은 기본적인 장치를 그림. 플랫폼에서 명시하지 않은 일반적인 인터페이스로서, OS 사용자 인터페이스 체계를 사용.
자바스크립트 해석기 - 자바스크립트 코드를 해석하고 실행.
자료 저장소 - 이 부분은 자료를 저장하는 계층이다. 쿠키를 저장하는 것과 같이 모든 종류의 자원을 하드 디스크에 저장할 필요가 있다. HTML5 명세에는 브라우저가 지원하는 '웹 데이터 베이스'가 정의되어 있다.

크롬은 대부분의 브라우저와 달리 각 탭마다 별도의 렌더링 엔진 인스턴스를 유지한다. 즉, 각 탭은 독립된 프로세스로 처리된다.

~~(그래서 메모리를 많이 먹나보다...)~~

렌더링 엔진이란?

렌더링 엔진은 서버로부터 요청 받은 내용을 브라우저의 화면에 표시하는 일을 한다.

렌더링 엔진은 HTML, XML 문서, 이미지를 표시할 수 있다. 플러그인, 브라우저 확장 기능 등을 이용해 PDF와 같은 다른 리소스도 표현할 수 있다.

렌더링 엔진의 종류

Chrome의 V8
Safari의 WebKit
Firefox의 Gecko~~(개코..?)~~
...

렌더링 엔진의 동작 과정

출처 : 네이버 D2

HTML 문서를 파싱하고 변환하여 DOM(Document Object Model) 트리를 생성한다.
외부 CSS 파일과 함께 인라인 스타일 요소를 파싱하고 변환하여 CSSOM(CSS Object Model) 트리를 생성한다.
DOM 트리와 CSSOM 트리를 이용하여 렌더 트리를 생성한다.
렌더 트리의 생성이 종료되면, 렌더 트리의 각 노드들을 정확한 위치에 배치하고 다양한 값을 계산한다.
브라우저의 실제 화면에 그리기 과정을 한다.

출처 : 네이버 D2

이 그림은, Safari의 WebKit 엔진의 동작 과정을 나타낸 것이다.

HTML5에서의 Sementic Tag(시맨틱 태그)

훈개발자 — Fri, 26 Jun 2020 22:17:16 +0900

Sementic Tag란?

글자 그대로 해석하면, "의미론적인" 태그라는 뜻이다.
즉, 보다 더 명시적으로 의미를 알아볼 수 있는 태그를 쓸 수 있다는 것이다.

<header>라는 이름의 태그는 딱 봐도 앱의 헤더 부분을 나타내는 태그라는 것을 알 수 있고, <footer>는 딱 봐도 앱의 아래 부분을 나타내는 태그라는 것을 알 수 있다.

반면에 <div>나 <span> 태그는 내부의 요소가 어떤 의미를 가지는지 알 수 없다. 따라서, non-sementic 태그인 것이다.

또한, 시맨틱 태그는 SEO 최적화가 된다. 검색 엔진이 정보를 검색할 때, 시맨틱 태그에서 중요한 정보를 뽑아 탐색에 반영한다. 이처럼 시맨틱 태그를 통해 웹 문서가 구조화되어 의미 있는 내용을 탐색할 수 있도록 하는 웹을 시맨틱 웹이라고 한다.

출처 : w3schools

자세히 알아보기

ES6에서 Arrow Function 사용하기

훈개발자 — Fri, 26 Jun 2020 04:03:19 +0900

Arrow Function의 특징

function 표현에 비해 구문이 짧다.
자신의 this, arguments를 바인딩하지 않는다.
항상 익명 함수로만 사용된다.
생성자로서 사용할 수 없다.

Arrow Function 사용하기

매개변수가 없을 때

const func = () => { ... }

매개변수가 1개일 때

const func1 = i => { ... } // 소괄호의 지정 불필요!
const func2 = (i) => { ... } // 소괄호 지정해도 무관!

매개변수가 2개 이상일 때

const func = (x, y) => { ... }

함수 Body

const func = i => { 
  return i * i;
}

한 줄의 구문만 있는 경우

const func = i => i * i; // 중괄호와 return을 생략할 수 있음. i * i 값이 리턴된다.

Arrow Function 호출하기

const add = (a, b) => a + b;
console.log(add(1, 2)); // 3

Arrow Function 콜백 함수로 전달하기

const arr = [1, 2, 3, 4, 5];
const isEven = arr.map((i) => i % 2);
console.log(isEven); // [0, 1, 0, 1, 0]

`중요` Arrow Function에서의 this

일반 함수에서의 this

JavaScript에서의 this와 this 바인딩

Arrow Function에서의 this

일반 함수에서의 this는 함수가 선언될 때가 아닌, 호출될 때, 그 호출 Context에 따라 동적으로 바인딩된다. 반면에, Arrow Function은 함수가 선언될 때 정적으로 바인딩된다.

Arrow Function에서의 this는 항상, 상위 스코프의 this를 가리킨다.
이를 Lexical this라고 부른다. JavaScript의 Lexical scope 개념과 유사하다.

const me = {
  arr: [1, 2, 3],
  show() {
    function func() {
      console.log(this.arr); // undefined
    }
    func();
  },
  showArrow() {
    func = () => {
      console.log(this.arr); // [1, 2, 3]
    };
    func();
  },
};

me.show();
me.showArrow();

Arrow Function을 사용해서는 안되는 경우

메소드 정의로 사용하는 경우

객체의 함수, 즉 메소드로서 정의해서는 안된다. 일반 함수가 객체의 메소드로 정의되는 경우에는 인스턴스 자기 자신을 가리키지만, Arrow Function은 항상 상위 스코프의 this를 가리키므로 사용해서는 안된다.

const me = {
  name: 'Hoon',
  getMyName: () => this.name; // this는 상위 스코프의 this인 window를 가리키게 됨.
}
console.log(me.getMyname()); // undefined

이런 경우에는 ES6에서 제공하는 축약 메소드 표현을 사용하자.

const me = {
  name: 'Hoon',
  getMyName() { return this.name; }
}
console.log(me.getMyname()); // Hoon

prototype의 메소드

생성자 함수

참고문서

PolemaWEB

ES6에서 let/const로 Block-scoped 변수 선언하기

훈개발자 — Fri, 26 Jun 2020 03:29:08 +0900

변수의 Block-scoped 선언

let

let을 이용해 Block-scoped인 변수를 선언할 수 있다. 중괄호로 구분된 영역을 Block-scoped 영역이라고 한다. 이는 기존의 var 키워드의 문제점을 해결할 수 있다.

function funcVar() {
  console.log(k); // undefined
  var k = 1;
  console.log(k); // 1
}
funcVar();

function funcLet() {
  console.log(a); // ReferenceError: Cannot access 'a' before initialization (오류 발생)
  let a = 1;
  console.log(a); // 1
}
funcLet();

var로 선언된 변수 k는 호이스팅에 의해 변수 선언문 이전에도 접근이 가능하며, undefined라는 값을 가진다.
그 이유는 JavaScript에서 var를 사용하면 안되는 이유에서 설명하였으니 패스!

반면에 let은 var와 같이 스코프에 진입할 때 변수가 만들어지지만, 코드 위치에 도달할 때까지 액세스가 불가능하게 해놓았다. (호이스팅이 안되는 것은 아니다!) 따라서 ReferenceError: Cannot access 'a' before initialization과 같은 오류가 뜨는 것이다.

이에 관해 깊이 있게 공부하고 싶다면, 여기를 참고하면 된다.

const

const는 let과 대부분 동일하나, 선언과 동시에 값이 할당되어야 한다. 또한 const이라는 글자 그대로 상수로서 취급되므로 이후 값의 수정이 불가능하다.

JavaScript에서 var를 사용하면 안되는 이유

훈개발자 — Fri, 26 Jun 2020 02:59:52 +0900

var

var는 ES6 등장 이전에 사용되던 키워드이며, 변수를 생성할 때 앞에 붙여서 변수임을 명시합니다.
그러나 이는 개발에 있어서 엄청 큰 단점을 가지고 있어 현재에는 거의 사용하지 않습니다. (사용하면 안됩니다..)

먼저 아래 코드를 봅시다.

var a = 123;
console.log(a); // 123

var a = 567;
console.log(a); // 567

a가 2번 선언되었음에도 불구하고, 오류는 발생하지 않았습니다.

만약 방대한 프로젝트를 개발한다면 똑같은 이름의 변수를 몇 번이나 사용해도 오류는 발생하지 않으니, 로직 상의 오류는 빈번해질 것이고 그 오류를 발견하기는 또 굉장히 어렵게 될 것입니다.

그런데, 왜 이런 현상이 나타나는 것일까요?
그 이유는 바로 Hosting(호이스팅) 때문입니다.

호이스팅?

var 키워드를 사용하여 변수 선언 시, 해당 변수의 선언부를 스코프 최상단으로 올려버리는 것을 말합니다.
JavaScript의 변수 생성과 초기화의 작업이 분리되어 진행되기 때문에 이런 현상이 발생한다.

var는 우리가 기존 C나 Java의 Block-scoped가 아니라 Function-scoped입니다. 따라서, 코드 전체의 최상단이 아닌 함수 내부의 최상단으로 이동합니다. 아래 예시를 봅시다.

Function-scoped는 중괄호로 구분된 영역의 범위를 갖는 것이 아니라, 함수 내부의 영역을 범위로 갖는 것을 의미합니다.

var a = 123;
function func() {
  console.log(a); // undefined
  var a = 456;
  console.log(a); // 456
}
func();

이 코드는 var의 호이스팅에 의해 아래와 같이 인식됩니다.

var a = 123;
function func() {
  var a;
  console.log(a); // undefined
  a = 456;
  console.log(a); // 456
}
func();

호이스팅 떄문에 a를 참조할 Reference는 있으니 Reference Error는 나지 않고, 대신 undefined라는 값이 출력됩니다.

참고로 undefined는 JavaScript의 Primitive Value로 어떠한 값도 할당되지 않아 자료형이 정해지지 않은 상태를 의미합니다.

그래서 var의 문제점은..?

변수의 중복 선언이 가능하다.

글의 최상단에서 설명한 예시를 통해 알 수 있듯이, var는 a라는 이름의 변수가 있음에도 불구하고 또 그 아래에서 a라는 이름의 변수를 선언할 수 있습니다.

이처럼 이미 선언했던 변수명을 모르고 또 사용할 경우, 기존에 있던 변수는 전혀 다른 값을 가지게 됩니다. 그 경우, 그 변수를 사용하는 다양한 로직들에 치명적인 문제가 생깁니다.

for문에서의 문제점

ar는 Function-scoped이기 때문에 for문에서 for문의 순회를 위해 i라는 변수를 var로 선언한 경우, 이 변수는 for문이 종료되어도 접근이 가능하게 됩니다.

또한, 만약 for문의 함수 내부가 아닌, 함수 외부에 전역적으로 돌아갈 경우 for문에서 사용한 var 변수들은 전역 변수로서 역할을 하므로, 전역 변수가 남발될 수 있습니다.

JavaScript ECMAScript란?

훈개발자 — Fri, 26 Jun 2020 01:12:07 +0900

ECMAScript란?

ECMA International이라는 정보통신 비영리 표준화 기구에서 정의한 스크립트 언어에 대한 '사양'입니다. 스크립트 언어로서 준수해여 하는 규칙, 지침들을 규정합니다.

ECMAScript vs JavaScript?

JavaScript는 ECMAScript의 사양을 준수하는 스크립트 언어입니다. 즉, JavaScript는 ECMAScript의 사양을 따라 제작된 '언어'이며, 우리는 이 '언어'를 이용해 스크립트 코딩을 할 수 있는 것입니다.

ECMAScript 6 === ES6란?

ES6은 ECMAScript의 여섯 번째 릴리즈라고 생각하시면 됩니다. 기존의 콜백 지옥과 같은 불편했던 부분들을 상당 부분 개선하여 내놓은 표준으로, 많은 개발자들이 사랑하고 애용합니다.

그러나, 이러한 ECMAScript 표준은 브라우저에 따라 지원되는 범위가 다릅니다. 이는 브라우저마다 JavaScript를 Interpreting하는 엔진이 다르기 때문입니다. 따라서 개발자들은 다양한 브라우저에서 웹앱이 정상적으로 실행될 수 있도록 크로스 브라우징을 구현해야 합니다.

Babel

개발자들은 ES6에서 도입된 다양한 기능들과 Syntax들을 사용하여 개발의 편의성을 얻을 수 있었지만, 브라우저 간의 호환성 문제를 해결하는 대에는 고역을 겪었습니다. 특히 국내에서 심지어 최근까지도 사용되고 있는 Internet Explorer가 ES6를 대부분 지원하지 않으므로, 한국에서 웹앱을 서비스하기 위해서는 크로스 브라우징의 구현은 필수였습니다.

이러한 비생산적이고 귀찮은 과정을 단 한 번에 해결해주는 놈이 등장하였습니다. 바로, 유명한 Transpiler, 바벨(Babel)입니다. 바벨은 ES6으로 작성된 코드를 크로스 브라우징을 할 수 있도록 ES5의 코드로 바꿔줍니다. 이 Babel의 등장으로, JavaScript 코딩에서는 크로스 브라우징을 고려하지 않게 되었습니다.

그렇다면..

그렇다면 JavaScript 개발자라면, 최신 기술과 Syntax가 적용된 ES6를 써보고 싶다는 생각.. 드시지 않나요? 지금 바로 ES6에 추가된 새로운 기능들과 Syntax를 확인해보세요. 다양한 글들이 있습니다!

Java Type-casting (타입 캐스팅)

훈개발자 — Thu, 25 Jun 2020 17:28:56 +0900

Implicit Casting (암시적 캐스팅)

정보의 손실, 오류의 가능성이 없는 경우에 허용
(ex: double d = 3;) : int -> double

Explicit Casting (명시적 캐스팅)

오류의 가능성이 있다.
따라서 프로그래머의 판단에 오류의 가능성이 없고, 타당성이 있을 경우에만 시행함.
(ex: int i = (int)3.0;) : double -> int, 소수점이 없으므로 손실이 없음.
(ex: int i = (int)3.3;) : double -> int, 소수점이 손실됨.

Java Literals (리터럴 상수)

훈개발자 — Thu, 25 Jun 2020 15:46:34 +0900

Number Literals

Integer Literals, Floating-Point Literals 등을 포괄하는 의미

Integer Literals

Integer Literal은 Integer Variable(정수 자료형)에 할당될 수 있다.
Literal 값이 Variable의 최대 할당 크기를 초과하면 컴파일 오류가 발생한다.
long type를 명시적으로 표현하려면 L 또는 l을 붙인다. (ex: long longVal = 3141592L;)

Floating-Point Literals

기본적으로 Floating-Point Literal은 double 타입으로 취급된다. (5.0 리터럴은 double이다.)
float임을 명시적으로 표현하려면 숫자 뒤에 F 또는 f를 붙인다.
double임을 명시적으로 표현하려면 숫자 뒤에 D 또는 d를 붙인다.

Scientific Notation

Floating-Point Literals는 Scientific Notation으로 표현할 수 있다.
1.2345e+2, 1.2345e2와 같은 것을 Scientific Notation이라고 한다.
E 혹은 e를 붙여 지수를 나타내는 표현이다.
(ex: 1.2345e+2 == 1.2345e2 == 1.2345E2 == 123.45)

Java Modifiers (접근 제어자)

훈개발자 — Thu, 25 Jun 2020 15:34:03 +0900

Modifiers의 종류

public
protected
default
private

접근 허용범위 : public > protected > default > private

public

public이 붙은 변수, 메소드는 어떤 클래스에서라도 접근이 가능하다.

default

접근 제어자가 따로 설정되지 않았을 때를 뜻한다. 동일 패키지 내에서만 접근이 가능하다.

protected

default 처럼 동일 패키지 내에서는 모두 접근이 가능하다. default와 다른 점은 다른 패키지에서도 제한적으로 접근이 가능하다는 것이다.
정확히 말하면, 다른 패키지에서 해당 클래스를 상속받는 파생 클래스에서 접근이 가능하다.

private

가장 접근 권한이 적은 접근 제어자이다. 해당 클래스에서만 접근이 가능하다.

ES6에서 배열을 활용하는 다양한 방법

훈개발자 — Thu, 25 Jun 2020 03:59:34 +0900

기존의 forEach()

배열 전체를 돌며 해당 배열의 요소에 어떠한 작업을 수행할 수 있는 메소드이다.

사용법

arr.forEach((element, index, arr) => { 작업 });
(return은 undefined)

예시

let arr = [1, 2, 3];
let arr2 = [];
arr.forEach((element, index, arr) => {
  console.log('현재 값은 ' + element + '이며, 인덱스는 ' + index + '입니다.'); // A
  arr2.push(element * index); // B
  element *= 2;
  /*
  현재 값은 1이며, 인덱스는 0입니다.
  현재 값은 2이며, 인덱스는 1입니다.
  현재 값은 3이며, 인덱스는 2입니다.
  */
}, []);
console.log(arr); // [ 1, 2, 3 ]
console.log(arr2); // [ 0, 4, 12 ]

A와 B와 같이 배열의 원소들을 이용해 다양한 작업을 할 수 있다.

눈여겨볼 점은 콜백 내부에서 element *= 2를 해줬음에도 불구하고, 기존 배열의 값은 변하지 않았음을 알 수 있다. 즉, 기존의 값은 변경시키지 않는 메소드이다. (immutable)

콜백 내부에서 element, index, arr를 이용하여 아래에서 소개할 filter(), map(), find(), reduce()와 같은 기능들을 구현할 수 있다. 그러나 매번 이를 구현하기는 매우 귀찮으므로, ES6에서는 아래와 같은 훌륭한 메소드들을 제공한다.

filter()

기존의 배열에서 조건에 맞는 원소만 뽑아 새로운 배열을 만들어 리턴한다.

사용법

arr.filter((element, index, arr) => { return (condition) });

예시

let arr = [1, 2, 3, 4, 5, 6];
let arr2 = arr.filter((i) => i % 2 === 0);
console.log(arr[1] === arr2[0]); // true

첫 번째 출력 : arr에 있는 원소와 같은 원소임을 알 수 있음.

find()

찾으려는 값을 리턴한다. 여러 개가 있을 경우 처음 값만 리턴한다.

사용법

arr.find((element, index, arr) => { return (condition) });

예시

let arr = [1, 2, 3, 4, 5, 6];
let value = arr.find((i) => i % 2 === 0;
console.log(value); // 2
console.log(arr[1] === value); // true

첫 번째 출력 : arr의 여러 2의 배수인 원소들 중 첫 번째 원소만 리턴됨.
두 번째 출력 : arr[1](2)와 value(2)는 같은 원소임을 알 수 있음.

map()

반복문을 돌면서 배열의 요소 각각에 대해 인자로 넘겨준 콜백 함수를 적용시킨다(매핑한다).

사용법

arr.map((element, index, arr) => { return (new element) });

예시

let arr = [1, 2, 3, 4, 5, 6];
let arr2 = arr.map((i) => i * 2);
console.log(arr); // [1, 2, 3, 4, 5, 6]
console.log(arr2); // [2, 4, 6, 8, 10, 12]

첫 번째 출력 : arr의 원소들의 값은 변하지 않았다. 즉, map은 immutable한 메소드이다.
두 번째 출력 : arr2의 원소들은 arr의 각각의 원소 i에 대해 i * 2한 것이다.

reduce()

뭔가 말로 설명하기가 굉장히 애매한 메소드.. 이지만, 굉장히 많은 곳에서 사용된다. 예시를 통해 체득하자.

사용법

arr.reduce(
    (accumulator(누적값), currentValue(현재값), index, arr) => {
        return (new element)
    }, 초기값);

초기값 1을 부여했을 때

let arr = [1, 2, 3, 4, 5, 6];
let arr2 = arr.reduce((acc, cur, i) => {
  console.log(acc, cur, i);
  return acc + cur;
  /*
  1 1 0
  2 2 1
  4 3 2
  */
}, 1);
console.log(arr2); // 7

초기값으로 1을 주고, reducing을 진행한 결과이다. 콜백 내부의 출력을 통해 알 수 있듯이, 1을 초기값으로 Accumulating이 진행되는 모습을 볼 수 있다.

초기값이 없을 때

let arr = [1, 2, 3, 4, 5, 6];
let arr2 = arr.reduce((acc, cur, i) => {
  console.log(acc, cur, i);
  return acc + cur;
  /*
  1 2 1
  3 3 2
  */
});
console.log(arr2); // 6

초기값을 주지 않으면 기본적으로 0이 초기값이다. 이 경우, 콜백 내부의 출력에서는 초기값의 Accumulating 과정은 없으므로 출력되지 않는다.

reduce() 콜백 내부에서의 출력을 보면 다음 acc의 값이 현재 acc의 값과 cur이 더해져 갱신되는 것을 볼 수 있다.

활용 예시

let arr = [1, 2, 3];
let arr2 = arr.reduce((acc, cur, i) => {
  console.log(acc, cur);
  acc.push(cur % 2 ? 'Odd Number' : 'Even Number');
  return acc;
  /*
  [] 1
  [ 'Odd Number' ] 2
  [ 'Odd Number', 'Even Number' ] 3
  */
}, []);
console.log(arr2); // [ 'Odd Number', 'Even Number', 'Odd Number' ]

초기값을 빈 배열로 할당해준 후, 배열의 원소가 짝수인지, 홀수인지 판단하여 acc의 배열에 push() 해주는 콜백을 받는 reduce()이다. 이 로직은 똑같이 map()으로도 구현할 수 있다.

콜백 내부의 출력의 양상을 보자.
첫 번째 출력에서 acc는 빈 배열, cur는 1이다. cur이 1이고, 1은 홀수이므로, 다음 acc는 Odd Number라는 문자 1개가 들어 있는 배열이다.

이렇게 reducer()는 acc를 계속 cur의 값에 대해 갱신(누적)시켜 리턴해주는 메소드이다.

SW마에스트로 11기 최종 불합격 후기

훈개발자 — Mon, 18 May 2020 22:26:44 +0900

소마에 지원하게 되다.

소마 지원공고가 뜬게 아마 1월 쯤이었을 것이다. 평소 '나 같은 사람은 소마 힘들겠지'라는 생각으로 지원할 생각도 없었는데, 동기 한 명이 지원한다고 해서 나도 도전해볼까?하다가 지원하였다.

평소 사소한 일에도 노력을 많이 기울이는 성격이라, 자소서를 쓰는 대에만 2~3주 정도 걸린 것 같다. 소마 붙으신 선배님은 자소서는 잘 안본다고 하셨지만 그래도 부족한 내 실력을 어필할 수 있는 유일한 기회라고 생각했기에 열심히 했다.

1차 온라인 코딩 테스트

정말 알고리즘의 '알'자도 몰랐기에, 친구의 도움을 받아 알고리즘 세계에 입문하게 되었다. 백준 온라인 강의를 이용해 BFS, DFS, DP, 그리디와 같은 기본적인 알고리즘 지식들을 습득하였다.

처음에는 코딩 테스트가 4월 중순인가 그랬는데, 망할 코로나19로 코딩 테스트를 온라인으로 보게 되었다. 불행 중 다행으로, 내가 평소에 자신있었던 웹과 SQL 문제가 나와서 후딱 맞추고 알고리즘 문제를 봤는데..

분명 어떻게 해야 하는지는 알겠는데, 내 손이 따라주지를 않았다. 알고리즘 문제를 많이 풀어본 것도 아니었고, 어떤 알고리즘을 써야 빨리 풀릴 지도 몰랐기 때문이다. 그렇게 나는 무조건 불합격이라고 생각하고 마음을 놓고 있을 찰나.. 합격 통지 문자가 왔다..(?)

2차 온라인 코딩 테스트

2차 코딩 테스트까지는 시간이 한 1달 넘게 있었기 때문에 오롯이 코딩 테스트 준비에만 집중할 수 있었다. 매일 백준 문제를 풀고 실버 문제부터 골드 문제까지 열심히 풀었다. 이제 BFS, DFS만 보면 1~2분 만에 풀 수 있는 정도이다. 1달 간의 빡센 여정 끝에 백준 골드4를 찍기도 했다.

그러나 이 정도의 노력으로는 힘들었는지 코딩 테스트에서 알고리즘 1번 문제밖에 풀어내지 못했다. 1번은 엄청 쉬운 DP였는데, 기본값을 LLONG_MIN이 아니라 0으로 했고.. 2번 문제는 웹이랑 SQL 풀고 나니 10분 남아서 제대로 풀지도 못하고 제출했다.

이번에도 탈락할 것을 예상했지만, 결과는 합격이었다...

심층 면접

심층 면접은 정말 정말 정말 운이 안좋게도, 필자 빼고 모두 96년생, 95년생이었다.. 그래서 질문 수준도 너무 어려웠고, 갑자기 '분산 컴퓨팅에 대해서 자유롭게 논해보'라길래.. 개 뻘소리를 짓거렸던 기억이 있다.

그래도 자신감 있게 모든 질문에 먼저 대답하려고 손을 들었고 이 부분에 대해서 어린 나이이지만 가산점을 받지 않을까 기대했다. 그 외의 대부분의 답변에 대해서는 무난하게 했지만, 어린 나이답게 깊이없는 답변에 아마 많이 실망했을 것이라고 생각한다..

대진운도 안좋았고, 여러모로 모든게 안좋았던 면접이었다.

최종 불합격

기다림에 지쳐 친구들이랑 잠깐 놀러왔는데, 갑자기 문자가 왔다. 기대를 품고 문자를 열었는데 그대로 굳어버렸다.. 너무 오랜 기간 소마만 바라보고 준비해왔기 때문에 그 실망감이 너무 컸었다.

하지만, 그만큼 내가 부족하고 미숙하다는 것이기에 크게 연연치 않았다.

소마를 준비하는 과정에서 알고리즘 공부도 해보고, 또 실제 현업 면접을 겪어보기도 하면서 많은 것들을 얻었다고 생각한다. 이제 군대를 어떻게 할지에 대해서 고민해야 한다. 내년에 한 번 더 도전해보고 결정해보는 것도 나쁘지 않은 것 같다.

많이 실망스러운 결과지만, 인생은 실전이기에.. 내년을 기약하며

4월 22일 공부 계획

훈개발자 — Wed, 22 Apr 2020 16:37:23 +0900

알고리즘

복습

~~BOJ 11053~~
~~BOJ 11054~~
~~BOJ 2565~~
~~BOJ 9251~~
~~BOJ 1912~~
~~BOJ 12865~~

구현

~~BOJ 2573~~
BOJ 9019

4월 21일 공부 계획

훈개발자 — Tue, 21 Apr 2020 15:17:41 +0900

알고리즘

복습

~~BOJ 2748~~
~~BOJ 1003~~
~~BOJ 1904~~
~~BOJ 9461~~
~~BOJ 1149~~
~~BOJ 1932~~
~~BOJ 2579~~
~~BOJ 1463~~
~~BOJ 10844~~
~~BOJ 2156~~
~~BOJ 11047~~
~~BOJ 11399~~

구현

~~BOJ 1138~~

4월 20일 공부 계획

훈개발자 — Mon, 20 Apr 2020 16:36:33 +0900

알고리즘

복습

~~BOJ 1436~~
~~BOJ 1018~~
~~BOJ 2751~~
~~BOJ 10989~~
~~BOJ 1181~~
~~BOJ 10814~~
~~BOJ 15649~~
~~BOJ 15650~~
~~BOJ 15651~~
~~BOJ 15652~~
~~BOJ 9663~~
~~BOJ 2580~~

구현

~~BOJ 1022~~
~~BOJ 1051~~
~~BOJ 3190 (골드 5 맞냐..?)~~

BOJ 1202 - 보석 도둑 문제풀이

훈개발자 — Mon, 20 Apr 2020 01:17:03 +0900

문제를 읽고 이해하기

세계적인 도둑 상덕이는 보석점을 털기로 결심했다.

상덕이가 털 보석점에는 보석이 총 N개 있다. 각 보석은 무게 Mi와 가격 Vi를 가지고 있다. 상덕이는 가방을 K개 가지고 있고, 각 가방에 담을 수 있는 최대 무게는 Ci이다. 가방에는 최대 한 개의 보석만 넣을 수 있다.

상덕이가 훔칠 수 있는 보석의 최대 가격을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N과 K가 주어진다. (1 ≤ N, K ≤ 300,000)

다음 N개 줄에는 각 보석의 정보 Mi와 Vi가 주어진다. (0 ≤ Mi, Vi ≤ 1,000,000)

다음 K개 줄에는 가방에 담을 수 있는 최대 무게 Ci가 주어진다. (1 ≤ Ci ≤ 100,000,000)

모든 숫자는 양의 정수이다.

출력

첫째 줄에 상덕이가 훔칠 수 있는 보석 가격의 합의 최댓값을 출력한다.

재정의와 추상화

이 문제는 STL의 multiset을 모른다면 꽤 애를 먹을 수 있는 문제이다. (자주 사용하는 STL 컨테이너는 다 외워두자..)

입력받은 보석 정보는 보석의 가치에 대한 내림차순으로 우선순위 큐에 담아둔다.
multiset을 이용하여 가방의 최대 무게 정보를 저장한다. 이때, multiset의 특징에 따라 오름차순 정렬된다.
우선순위 큐에 있는 원소가 하나도 없을 때까지 아래 과정을 진행한다.
1. 우선순위 큐 최상단에 있는 보석의 무게를 m이라고 할 때, m 이상의 무게를 담을 수 있는 가방들 중 첫 번째 것을 찾는다.
2. 찾았을 경우, 담은 보석의 가치 총합(result)에 우선순위 큐 최상단에 있는 보석의 가치 v를 더해준다.
3. 그리고, 사용한 가방은 multiset에서 제거(erase)해준다. -> 시간복잡도 logn
4. 보석을 가방에 담든, 담지 않든 최상단의 보석은 사용했거나 더 이상 사용하지 않을 것이므로 우선순위 큐에서 제거해준다.

코드 작성

#include <iostream>
#include <algorithm>
#include <set>
#include <queue>
#define ULL unsigned long long
using namespace std;

priority_queue<pair<int, int>> pq;
multiset<int> ms;

ULL result = 0;

int main() {
    cin.sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    int n, k;
    cin >> n >> k;
    for (int i = 0; i < n; i++) {
        int m, v;
        cin >> m >> v;
        pq.push({v, m});
    }
    for (int i = 0; i < k; i++) {
        int c;
        cin >> c;
        ms.insert(c);
    }

    while (!pq.empty()) {
        int v = pq.top().first;
        int m = pq.top().second;

        auto it = ms.lower_bound(m);
        if (it != ms.end()) {
            result += v;
            ms.erase(it);
        }

        pq.pop();
    }
    cout << result;
    return 0;
}

BOJ 2003 - 수들의 합 2 문제풀이

훈개발자 — Sun, 19 Apr 2020 20:50:45 +0900

문제를 읽고 이해하기

N개의 수로 된 수열 A[1], A[2], …, A[N] 이 있다. 이 수열의 i번째 수부터 j번째 수까지의 합 A[i]+A[i+1]+…+A[j-1]+A[j]가 M이 되는 경우의 수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N(1≤N≤10,000), M(1≤M≤300,000,000)이 주어진다. 다음 줄에는 A[1], A[2], …, A[N]이 공백으로 분리되어 주어진다. 각각의 A[x]는 30,000을 넘지 않는 자연수이다.

출력

첫째 줄에 경우의 수를 출력한다.

재정의와 추상화

대표적인 투 포인터 알고리즘(Two Pointers Algorithm) 문제이다. 정말 딱 투 포인터 알고리즘만 쓰면 풀리는 문제.

알고리즘 배우기

투 포인터(Two Pointers Algorithm), 슬라이딩 윈도우(Sliding Window)

투 포인터(Two Pointers Algorithm), 슬라이딩 윈도우(Sliding Window) (수정: 2019-09-09)

조금 성향이 비슷하다고 생각하는 기법 2개를 함께 쓰려 합니다.첫 번째로 소개해드릴 기법은 투 포인터(tw...

blog.naver.com

코드 작성

#include <iostream>
using namespace std;

int A[10000];

int main() {
    int n, m, ans = 0;
    cin >> n >> m;

    for (int i = 0; i < n; i++) cin >> A[i];

    int s = 0, e = 0, psum = 0;
    while (1) {
        if (psum >= m) psum -= A[s++];
        else if (e == n) break;
        else psum += A[e++];

        if (psum == m) ans++;
    }
    cout << ans;
    return 0;
}

BOJ 10942 - 팰린드롬? 문제풀이

훈개발자 — Sun, 19 Apr 2020 20:03:17 +0900

문제를 읽고 이해하기

명우는 홍준이와 함께 팰린드롬 놀이를 해보려고 한다.

먼저, 홍준이는 자연수 N개를 칠판에 적는다. 그 다음, 명우에게 질문을 총 M번 한다.

각 질문은 두 정수 S와 E(1 ≤ S ≤ E ≤ N)로 나타낼 수 있으며, S번째 수부터 E번째 까지 수가 팰린드롬을 이루는지를 물어보며, 명우는 각 질문에 대해 팰린드롬이다 또는 아니다를 말해야 한다.

예를 들어, 홍준이가 칠판에 적은 수가 1, 2, 1, 3, 1, 2, 1라고 하자.

S = 1, E = 3인 경우 1, 2, 1은 팰린드롬이다.
S = 2, E = 5인 경우 2, 1, 3, 1은 팰린드롬이 아니다.
S = 3, E = 3인 경우 1은 팰린드롬이다.
S = 5, E = 7인 경우 1, 2, 1은 팰린드롬이다.

자연수 N개와 질문 M개가 모두 주어졌을 때, 명우의 대답을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 수열의 크기 N (1 ≤ N ≤ 2,000)이 주어진다.

둘째 줄에는 홍준이가 칠판에 적은 수 N개가 순서대로 주어진다. 칠판에 적은 수는 100,000보다 작거나 같은 자연수이다.

셋째 줄에는 홍준이가 한 질문의 개수 M (1 ≤ M ≤ 1,000,000)이 주어진다.

넷째 줄부터 M개의 줄에는 홍준이가 명우에게 한 질문 S와 E가 한 줄에 하나씩 주어진다.

출력

총 M개의 줄에 걸쳐 홍준이의 질문에 대한 명우의 답을 입력으로 주어진 순서에 따라서 출력한다. 팰린드롬인 경우에는 1, 아닌 경우에는 0을 출력한다.

재정의와 추상화

지금까지의 DP는 입력을 먼저 받은 후, 그 입력받은 수들에 대해서 DP를 진행했다면, 이 문제에서는 입력 하나가 들어올 때마다 DP 처리를 해주는 방식으로 한다.

입력받은 수는 0번째 인덱스(i)부터 n - 1번째 인덱스까지 arr[i]에 저장한다. 입력이 들어올 때마다, 아래와 같은 알고리즘을 시행한다.

i번째부터 i번째 범위의 수들은 Palindrome이다. -> isPalindrome[i][i] = true (자기 자신밖에 없으므로)
i 인덱스 이전의 수 k에 대해서 arr[k] == arr[i]일 때 (두 수가 같을 때), Palindrome[k][i]가 true인지 false인지 결정하려고 한다.
k - 1 인덱스부터 i - 1 인덱스까지의 수가 Palindrome이면 arr[k] == arr[i]인 k와 i에 대해서, k 인덱스부터 i 인덱스까지의 수도 Palindorme이다.
만약 i - k가 2 이하의 수면 arr[k] == arr[i]인 k와 i에 대해서, k 인덱스부터 i 인덱스까지의 수는 항상 Palindrome이다.
(예: 1 2 1 -> Palindrome, 1 1 -> Palindrome)

이렇게 isPalindrome을 모두 구한 뒤, 입력받은 s와 e에 대해 isPalindrome[s - 1][e - 1]을 출력하면 된다.

코드 작성

#include <iostream>
using namespace std;

int arr[2000];
bool isPalindrome[2000][2000];

int main() {
    cin.sync_with_stdio(false);
    cin.tie(NULL);
    int n, m;
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> arr[i];
        isPalindrome[i][i] = true;
        for (int k = i - 1; k >= 0; k--) {
            if (arr[k] == arr[i]) {
                if (i - k > 2) {
                    if (!isPalindrome[k + 1][i - 1]) continue;
                }
                isPalindrome[k][i] = true;
            }
        }
    }
    cin >> m;
    while (m--) {
        int s, e;
        cin >> s >> e;
        cout << isPalindrome[s - 1][e - 1] << '\n';
    }
    return 0;
}

BOJ 1806 - 부분합 문제풀이

훈개발자 — Sun, 19 Apr 2020 18:44:54 +0900

문제를 읽고 이해하기

10,000 이하의 자연수로 이루어진 길이 N짜리 수열이 주어진다. 이 수열에서 연속된 수들의 부분합 중에 그 합이 S 이상이 되는 것 중, 가장 짧은 것의 길이를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N (10 ≤ N < 100,000)과 S (0 < S ≤ 100,000,000)가 주어진다. 둘째 줄에는 수열이 주어진다. 수열의 각 원소는 공백으로 구분되어져 있으며, 10,000이하의 자연수이다.

출력

첫째 줄에 구하고자 하는 최소의 길이를 출력한다. 만일 그러한 합을 만드는 것이 불가능하다면 0을 출력하면 된다.

재정의와 추상화

이 문제는 투 포인터 알고리즘(Two Pointers Algorithm)을 이용한 대표적인 문제다. 이 문제를 처음 시도할 때 아무것도 모른 채 접근했기 때문에 너무 힘들었는데, 역시 30분이 걸려도 갈피를 못 잡겠으면 구글링이 답이라는 것을 깨달았다..

투 포인터(Two Pointers Algorithm), 슬라이딩 윈도우(Sliding Window)

투 포인터(Two Pointers Algorithm), 슬라이딩 윈도우(Sliding Window) (수정: 2019-09-09)

조금 성향이 비슷하다고 생각하는 기법 2개를 함께 쓰려 합니다.첫 번째로 소개해드릴 기법은 투 포인터(tw...

blog.naver.com

위 문서를 읽고 나면 쉽게 풀 수 있을 것이다. 다른 점이라면, 문제에서 그 합이 S 이상이 되는 것들 중, 가장 짧은 것의 길이를 구한다는 점이다. 이걸 깨닫지 못해서 6번이나 재시도했던 경험이 있다..ㅠㅠ

코드 작성

#include <iostream>
#include <climits>
#include <algorithm>
using namespace std;

int arr[100000];
int shortest = INT_MAX;

int main() {
    cin.sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    int n, s;
    cin >> n >> s;
    for (int i = 0; i < n; i++) cin >> arr[i];

    int start = 0, end = 0, result = 0;
    while (true) {
        if (result >= s) { result -= arr[start++]; }
        else if (end == n) break;
        else result += arr[end++];

        if (result >= s) shortest = min(end - start, shortest);
    }
    cout << ((shortest == INT_MAX) ? 0 : shortest);
    return 0;
}

4월 19일 공부 계획

훈개발자 — Sun, 19 Apr 2020 02:00:55 +0900

알고리즘

동적 계획법

~~BOJ 10942~~

알고리즘 스터디

~~BOJ 14731~~
~~BOJ 7795~~

그리디

~~BOJ 1202~~
BOJ 1339

투 포인터 알고리즘

~~BOJ 1806~~
~~BOJ 2003~~

기타

~~자료구조 과제 3 제출~~

BOJ 12015 - 가장 긴 증가하는 부분 수열 2 문제풀이

훈개발자 — Sun, 19 Apr 2020 01:35:17 +0900

문제를 읽고 이해하기

수열 A가 주어졌을 때, 가장 긴 증가하는 부분 수열을 구하는 프로그램을 작성하시오.

예를 들어, 수열 A = {10, 20, 10, 30, 20, 50} 인 경우에 가장 긴 증가하는 부분 수열은 A = {10, 20, 10, 30, 20, 50} 이고, 길이는 4이다.

입력

첫째 줄에 수열 A의 크기 N (1 ≤ N ≤ 1,000,000)이 주어진다.

둘째 줄에는 수열 A를 이루고 있는 A_i가 주어진다. (1 ≤ A_i ≤ 1,000,000)

출력

첫째 줄에 수열 A의 가장 긴 증가하는 부분 수열의 길이를 출력한다.

재정의와 추상화

BOJ 11053 - 가장 긴 증가하는 부분 수열 문제에서는 N의 범위가 작기 때문에 DP로 풀 수 있었지만 이 문제는 N의 범위가 100만으로 엄청 커져버려서 시간 제한 안에 풀 수 없다.

이 문제를 통해 범위가 바뀌면 알고리즘 자체가 바뀌어야 할 수도 있다는 것을 알게 되었다.

순차적으로 입력되는 수에 대해서 알고리즘은 아래와 같이 구성된다.

입력받은 수가 벡터의 맨 뒤에 있는 수보다 클 경우 수를 맨 뒤에 집어 넣는다.
그렇지 않을 경우, 이분 탐색의 lower_bound를 이용하여 입력받은 수보다 크거나 같은 값이 처음 위치한 곳(lower_bound의 리턴값)에 입력 값을 대치시킨다.

이를 구현하기 위해 처음 climits 헤더에 있는 INT_MAX값(2^31 - 1)을 벡터에 추가한다. 이는 처음 입력받은 수에 대해서 따로 for문 내부에서 예외처리를 하지 않고 lower_bound를 통해 첫 인덱스에 값을 대입하기 위함이다.

그리고, 이후에 들어온 입력값에 대해 알고리즘을 시행한다.

2020/04/03 - [언어/C, C++] - [C++ STL] upper_bound, lower_bound 알아보기

[C++ STL] upper_bound, lower_bound 알아보기

lower_bound 개요 특징 이진 탐색(binary_search)의 근간이 된다. algorithm 헤더에 포함되어 있다. 설명 이진 탐색 기반의 탐색이므로, 배열 또는 리스트가 오름차순 정렬되어 있어야 한다. 찾으려고 하는 key 값..

hoondev.tistory.com

코드 작성

#include <iostream>
#include <algorithm>
#include <vector>
#include <climits>
using namespace std;

vector<int> v;

int main() {
    int n;
    cin >> n;
    v.push_back(INT_MAX);
    for (int i = 0; i < n; i++) {
        int input;
        cin >> input;
        if (v.back() < input) {
            v.push_back(input);
        } else {
            *lower_bound(v.begin(), v.end(), input) = input;
        }
    }
    cout << v.size();
    return 0;
}

BOJ 1074 - Z 문제풀이

훈개발자 — Sat, 18 Apr 2020 21:52:06 +0900

문제를 읽고 이해하기

한수는 2차원 배열 (항상 2^N * 2^N 크기이다)을 Z모양으로 탐색하려고 한다. 예를 들어, 2*2배열을 왼쪽 위칸, 오른쪽 위칸, 왼쪽 아래칸, 오른쪽 아래칸 순서대로 방문하면 Z모양이다.

만약, 2차원 배열의 크기가 2^N * 2^N라서 왼쪽 위에 있는 칸이 하나가 아니라면, 배열을 4등분 한 후에 (크기가 같은 2^(N-1)로) 재귀적으로 순서대로 방문한다.

다음 예는 2^2 * 2^2 크기의 배열을 방문한 순서이다.

N이 주어졌을 때, (r, c)를 몇 번째로 방문하는지 출력하는 프로그램을 작성하시오.

다음 그림은 N=3일 때의 예이다.

입력

첫째 줄에 N r c가 주어진다. N은 15보다 작거나 같은 자연수이고, r과 c는 0보다 크거나 같고, 2^N-1보다 작거나 같은 정수이다

출력

첫째 줄에 문제의 정답을 출력한다.

재정의와 추상화

전형적인 분할 정복 문제이지만, 그 구현부가 조금 독특하다는 점이 특징이다.

주어진 길이가 2일 때까지 계속 4등분한다. 4등분할 때 순서는 왼쪽 위, 오른쪽 위, 왼쪽 아래, 오른쪽 아래 순서(Z)를 꼭 지켜주어야 한다.
주어진 길이가 2일 경우, 아까 언급한 순서를 지켜 왼쪽 위, 오른쪽 위, 왼쪽 아래, 오른쪽 아래 순서로 방문한다. 방문할 때마다 cnt 값을 1씩 증가시키고, 만약 좌표가 (r, c)일 경우 진행을 중단한다.

코드 작성

#include <iostream>
#include <cmath>
using namespace std;

typedef struct {
    int y, x;
} Position;

Position pos[4] = {
        {0, 0},
        {0, 1},
        {1, 0},
        {1, 1}
};

int n, r, c, cnt;

bool divide_and_conquer(int y, int x, int length) {
    if (length != 2) {
        if (divide_and_conquer(y, x, length / 2)) return true;
        if (divide_and_conquer(y, x + length / 2, length / 2)) return true;
        if (divide_and_conquer(y + length / 2, x, length / 2)) return true;
        if (divide_and_conquer(y + length / 2, x + length / 2, length / 2)) return true;
        return false;
    }
    for (auto & p : pos) {
        int now_y = y + p.y;
        int now_x = x + p.x;
        cnt++;
        if (now_y == r && now_x == c) return true;
    }
    return false;
}

int main() {
    cin >> n >> r >> c;
    divide_and_conquer(0, 0, pow(2, n));
    cout << cnt - 1;
    return 0;
}

BOJ 7579 - 앱 문제풀이

훈개발자 — Sat, 18 Apr 2020 20:59:36 +0900

문제를 읽고 이해하기

우리는 스마트폰을 사용하면서 여러 가지 앱(App)을 실행하게 된다. 대개의 경우 화면에 보이는 ‘실행 중’인 앱은 하나뿐이지만 보이지 않는 상태로 많은 앱이 '활성화'되어 있다. 앱들이 활성화 되어 있다는 것은 화면에 보이지 않더라도 메인 메모리에 직전의 상태가 기록되어 있는 것을 말한다. 현재 실행 중이 아니더라도 이렇게 메모리에 남겨두는 이유는 사용자가 이전에 실행하던 앱을 다시 불러올 때에 직전의 상태를 메인 메모리로부터 읽어 들여 실행 준비를 빠르게 마치기 위해서이다.

하지만 스마트폰의 메모리는 제한적이기 때문에 한번이라도 실행했던 모든 앱을 활성화된 채로 메인 메모리에 남겨두다 보면 메모리 부족 상태가 오기 쉽다. 새로운 앱을 실행시키기 위해 필요한 메모리가 부족해지면 스마트폰의 운영체제는 활성화 되어 있는 앱들 중 몇 개를 선택하여 메모리로부터 삭제하는 수밖에 없다. 이러한 과정을 앱의 ‘비활성화’라고 한다.

메모리 부족 상황에서 활성화 되어 있는 앱들을 무작위로 필요한 메모리만큼 비활성화 하는 것은 좋은 방법이 아니다. 비활성화된 앱들을 재실행할 경우 그만큼 시간이 더 필요하기 때문이다. 여러분은 이러한 앱의 비활성화 문제를 스마트하게 해결하기 위한 프로그램을 작성해야 한다

현재 N개의 앱, A₁, ..., A_N이 활성화 되어 있다고 가정하자. 이들 앱 A_i는 각각 m_i 바이트만큼의 메모리를 사용하고 있다. 또한, 앱 A_i를 비활성화한 후에 다시 실행하고자 할 경우, 추가적으로 들어가는 비용(시간 등)을 수치화 한 것을 c_i 라고 하자. 이러한 상황에서 사용자가 새로운 앱 B를 실행하고자 하여, 추가로 M 바이트의 메모리가 필요하다고 하자. 즉, 현재 활성화 되어 있는 앱 A₁, ..., A_N 중에서 몇 개를 비활성화 하여 M 바이트 이상의 메모리를 추가로 확보해야 하는 것이다. 여러분은 그 중에서 비활성화 했을 경우의 비용 c_i의 합을 최소화하여 필요한 메모리 M 바이트를 확보하는 방법을 찾아야 한다.

입력

입력은 3줄로 이루어져 있다. 첫 줄에는 정수 N과 M이 공백문자로 구분되어 주어지며, 둘째 줄과 셋째 줄에는 각각 N개의 정수가 공백문자로 구분되어 주어진다. 둘째 줄의 N개의 정수는 현재 활성화 되어 있는 앱 A₁, ..., A_N이 사용 중인 메모리의 바이트 수인 m₁, ..., m_N을 의미하며, 셋째 줄의 정수는 각 앱을 비활성화 했을 경우의 비용 c₁, ..., c_N을 의미한다

단, 1 ≤ N ≤ 100, 1 ≤ M ≤ 10,000,000이며, 1 ≤ m₁, ..., m_N ≤ 10,000,000을 만족한다. 또한, 0 ≤ c₁, ..., c_N ≤ 100이고, M ≤ m₁ + m₂ + ... + m_N이다.

출력

필요한 메모리 M 바이트를 확보하기 위한 앱 비활성화의 최소의 비용을 계산하여 한 줄에 출력해야 한다.

재정의와 추상화

이 문제는 DP의 냅색 알고리즘을 이용해 풀면 된다. 냅색 문제 중 개인적으로 조금 어려웠던 문제였다. 다른 블로그를 보니, 1차원 DP 배열로도 문제를 푸는 사람도 있었는데, 필자는 그 방식이 더 어려워서 2차원 DP 배열로 풀었다.

// i는 i 인덱스까지의 원소를 사용한다는 의미
// j는 사용한 총 비용
dp[i][j] = max(activate[i] + dp[i - 1][j - resume[i]], dp[i][j])

냅색 알고리즘의 원리를 이용한다. i는 1번째부터 i번째 앱들 중에서 임의의 개수를 비활성화하겠다는 의미이고, j는 앱을 재실행했을 때 드는 비용의 합이 j라는 의미이다.

dp[i][j]는 1번째부터 i번째 앱들 중에서 임의의 개수를 비활성화하여 그 비활성화된 앱을 재실행했을 때 드는 총 비용이 j가 될 때, 확보한 메모리 값의 합을 의미한다.

따라서 우리가 구해야하는 값은 1번째부터 N번째 앱들 중에서 임의의 개수를 비활성화하였을 때, 확보한 메모리 값의 합이 M일 때의 앱을 재실행했을 때 드는 비용의 합이 정답이다.

2020/04/09 - [알고리즘/문제풀이] - BOJ 12865 - 평범한 배낭(냅색 알고리즘) 문제풀이

BOJ 12865 - 평범한 배낭(냅색 알고리즘) 문제풀이

문제를 읽고 이해하기 이 문제는 아주 평범한 배낭 에 관한 문제이다. 한 달 후면 국가의 부름을 받게 되는 준서는 여행을 가려고 한다. 세상과의 단절을 슬퍼하며 최대한 즐기기 위한 여행이기 때문에, 가지고 다..

hoondev.tistory.com

코드 작성

#include <iostream>
#include <algorithm>
using namespace std;

int n, m;

int activate[101];
int resume[101];

int dp[101][10001];

int main() {
    int sum = 0;
    cin >> n >> m;

    for (int i = 1; i <= n; i++) cin >> activate[i];
    for (int i = 1; i <= n; i++) { cin >> resume[i]; sum += resume[i]; }

    for (int i = 1; i <= n; i++) {
        for (int j = 0; j <= sum; j++) {
            dp[i][j] = dp[i - 1][j];
            if (j - resume[i] >= 0)
                dp[i][j] = max(activate[i] + dp[i - 1][j - resume[i]], dp[i][j]);
        }
    }

    for (int i = 0; i <= sum; i++) {
        if (dp[n][i] >= m) {
            cout << i;
            break;
        }
    }

    return 0;
}

BOJ 12852 - 1로 만들기 2 문제풀이

훈개발자 — Sat, 18 Apr 2020 15:43:56 +0900

문제를 읽고 이해하기

정수 X에 사용할 수 있는 연산은 다음과 같이 세 가지 이다.

X가 3으로 나누어 떨어지면, 3으로 나눈다.
X가 2로 나누어 떨어지면, 2로 나눈다.
1을 뺀다.

정수 N이 주어졌을 때, 위와 같은 연산 세 개를 적절히 사용해서 1을 만들려고 한다. 연산을 사용하는 횟수의 최솟값을 출력하시오.

입력

첫째 줄에 1보다 크거나 같고, 10의 6제곱 보다 작거나 같은 자연수 N이 주어진다.

출력

첫째 줄에 연산을 하는 횟수의 최솟값을 출력한다.

둘째 줄에는 N을 1로 만드는 방법에 포함되어 있는 수를 공백으로 구분해서 순서대로 출력한다. 정답이 여러 가지인 경우에는 아무거나 출력한다.

재정의와 추상화

참고로 이 문제는 clang 컴파일러에서 실행할 경우 메모리 오류가 발생합니다..!

DP를 이용해 문제를 풀 수 있다. DP 구현부는 코드를 보면 이해할 수 있으므로 따로 설명하지 않고, 최소 연산으로 1을 만드는 데까지의 과정을 저장하는 방법에 대해서만 설명하겠다. (중요함)

그 과정은 procedure라는 이름의 배열에 저장하는데, 배열의 인덱스는 현재의 값을 의미하고, 그 배열의 값은 최소 연산을 구현하는 다음 값을 의미한다. 즉, 배열의 값은 (현재의 값 - 1), (현재의 값 / 2), (현재의 값 / 3) 중 하나가 된다.

그리고 DP의 전 과정을 끝낸 후, 최소 연산을 구현하는 과정을 모두 출력할 때, procedure[idx]를 출력하고 idx의 값을 procedure[idx]로 갱신하며 procedure[idx]가 1일 때까지 반복한다. 그 후 1을 출력해주면 끝!

코드 작성

#include <iostream>
using namespace std;

int dp[1000001];
int procedure[1000001];

int process(int start) {
    if (start == 1) { return 0; }

    auto & ref = dp[start];
    if (ref) return ref;

    ref = process(start - 1) + 1;
    procedure[start] = start - 1;
    if (start % 2 == 0) {
        int temp = process(start / 2) + 1;
        if (ref > temp) {
            ref = temp;
            procedure[start] = start / 2;
        }
    }
    if (start % 3 == 0) {
        int temp = process(start / 3) + 1;
        if (ref > temp) {
            ref = temp;
            procedure[start] = start / 3;
        }
    }
    return ref;
}

int main() {
    int n;
    cin >> n;
    cout << process(n) << '\n';
    cout << n << ' ';

    int idx = n;
    while (procedure[idx] != 1) {
        cout << procedure[idx] << ' ';
        idx = procedure[idx];
    }
    cout << 1;
    return 0;
}

4월 18일 공부 계획

훈개발자 — Sat, 18 Apr 2020 13:51:53 +0900

알고리즘

동적 계획법(DP)

~~BOJ 12852~~
~~BOJ 7579~~

분할 정복

~~BOJ 1074~~

이분 탐색

~~BOJ 12015~~
~~BOJ 1806~~

BOJ 1520 - 내리막 길 문제풀이

훈개발자 — Sat, 18 Apr 2020 00:03:10 +0900

문제를 읽고 이해하기

여행을 떠난 세준이는 지도를 하나 구하였다. 이 지도는 아래 그림과 같이 직사각형 모양이며 여러 칸으로 나뉘어져 있다. 한 칸은 한 지점을 나타내는데 각 칸에는 그 지점의 높이가 쓰여 있으며, 각 지점 사이의 이동은 지도에서 상하좌우 이웃한 곳끼리만 가능하다.

현재 제일 왼쪽 위 칸이 나타내는 지점에 있는 세준이는 제일 오른쪽 아래 칸이 나타내는 지점으로 가려고 한다. 그런데 가능한 힘을 적게 들이고 싶어 항상 높이가 더 낮은 지점으로만 이동하여 목표 지점까지 가고자 한다. 위와 같은 지도에서는 다음과 같은 세 가지 경로가 가능하다.

지도가 주어질 때 이와 같이 제일 왼쪽 위 지점에서 출발하여 제일 오른쪽 아래 지점까지 항상 내리막길로만 이동하는 경로의 개수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에는 지도의 세로의 크기 M과 가로의 크기 N이 빈칸을 사이에 두고 주어진다. 이어 다음 M개 줄에 걸쳐 한 줄에 N개씩 위에서부터 차례로 각 지점의 높이가 빈 칸을 사이에 두고 주어진다. M과 N은 각각 500이하의 자연수이고, 각 지점의 높이는 10000이하의 자연수이다.

출력

첫째 줄에 이동 가능한 경로의 수 H를 출력한다. 모든 입력에 대하여 H는 10억 이하의 음이 아닌 정수이다.

재정의와 추상화

DFS + DP

이 문제를 한 마디로 DFS 구현에 DP가 추가된 것이라고 말할 수 있다. 처음 이 문제를 접할 때 DFS로만 접근을 시도했는데, 그 방법으로는 답이 다르게 나왔다.

그 이유를 문제에 나온 예제 이미지를 보고 파악할 수 있었다.

첫 번째 사진과 두 번째 사진을 보자면, 17에서 20으로 가는 동선이 겹친다. 만약 첫 번째 사진의 동선을 먼저 DFS가 처리했다면, 두 번째 사진의 동선에서 17 > 15 > 10 으로 가는 동선은 이미 왔던 곳(check[y][x]가 true인 곳)이므로 더 이상 진행하지 않게 된다.

이 문제를 해결하기 위해 DP를 사용했다. 17이 적혀있는 위치에서 종착점(10)으로 가는 동선은 이미 첫 번째 사진에서 갔다 왔으므로 똑같은 루트를 한 번 더 가는 것은 시간 낭비이다. 따라서 DP(동적 계획법)를 이용해 해당 위치에서 종착점까지 가는 루트의 개수를 저장해놓고 만약 재방문했을 시 O(1)로 값을 리턴하게 한다.

코드 작성

// DFS 중심 풀이 (초기점부터 종착점까지 순차적으로 재귀하는 DFS의 원리에 중점)

#include <iostream>
using namespace std;

typedef struct {
    int y, x;
} Position;

Position pos[4] = { {1, 0}, {0, 1}, {-1, 0}, {0, -1} };

int arr[500][500];
bool check[500][500];
int dp[500][500];
int m, n;

bool isInside(int y, int x) {
    return y >= 0 && y < m && x >= 0 && x < n;
}

int dfs(int y, int x) {
    if (y == m - 1 && x == n - 1)
        return 1;

    check[y][x] = true;
    auto & ref = dp[y][x];

    for(auto & p : pos) {
        int next_y = y + p.y;
        int next_x = x + p.x;
        if (isInside(next_y, next_x) && arr[y][x] > arr[next_y][next_x] && !check[next_y][next_x])
            ref += dfs(next_y, next_x);
        else if (isInside(next_y, next_x) && arr[y][x] > arr[next_y][next_x] && check[next_y][next_x])
            ref += dp[next_y][next_x];
    }
    return ref;
}

int main() {
    cin.sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    cin >> m >> n;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            cin >> arr[i][j];
        }
    }
    dfs(0, 0);
    cout << dp[0][0];
    return 0;
}

// DP 중심 풀이 (Top-down 재귀에 중점)

#include <iostream>
using namespace std;

typedef struct {
    int y, x;
} Position;

Position pos[4] = { {1, 0}, {0, 1}, {-1, 0}, {0, -1} };

int arr[500][500];
bool check[500][500];
int dp[500][500];
int m, n;

bool isInside(int y, int x) {
    return y >= 0 && y < m && x >= 0 && x < n;
}

int dfs(int y, int x) {
    if (y == 0 && x == 0)
        return 1;

    check[y][x] = true;
    auto & ref = dp[y][x];

    for(auto & p : pos) {
        int next_y = y + p.y;
        int next_x = x + p.x;
        if (isInside(next_y, next_x) && arr[y][x] < arr[next_y][next_x] && !check[next_y][next_x])
            ref += dfs(next_y, next_x);
        else if (isInside(next_y, next_x) && arr[y][x] < arr[next_y][next_x] && check[next_y][next_x])
            ref += dp[next_y][next_x];
    }
    return ref;
}

int main() {
    cin.sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    cin >> m >> n;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            cin >> arr[i][j];
        }
    }
    dfs(m - 1, n - 1);
    cout << dp[m - 1][n - 1];
    return 0;
}

4월 17일 공부 계획

훈개발자 — Wed, 15 Apr 2020 15:02:03 +0900

알고리즘

동적 계획법(DP)

~~BOJ 1520~~
BOJ 12852

기타

~~창설 과제 제출~~

4월 14일 알고리즘 공부 계획

훈개발자 — Tue, 14 Apr 2020 17:27:25 +0900

알고리즘

동적 계획법(DP)

BOJ 1520

분할 정복

BOJ 11401

이분 탐색

BOJ 2110

큐, 덱

~~BOJ 1021~~
~~BOJ 5430~~
~~BOJ 2164~~
~~BOJ 11866~~

기타

~~자료구조 과제 2 제출~~

BOJ 11049 - 행렬 곱셈 순서 문제풀이

훈개발자 — Tue, 14 Apr 2020 17:23:00 +0900

문제를 읽고 이해하기

크기가 N×M인 행렬 A와 M×K인 B를 곱할 때 필요한 곱셈 연산의 수는 총 N×M×K번이다. 행렬 N개를 곱하는데 필요한 곱셈 연산의 수는 행렬을 곱하는 순서에 따라 달라지게 된다.

예를 들어, A의 크기가 5×3이고, B의 크기가 3×2, C의 크기가 2×6인 경우에 행렬의 곱 ABC를 구하는 경우를 생각해보자.

AB를 먼저 곱하고 C를 곱하는 경우 (AB)C에 필요한 곱셈 연산의 수는 5×3×2 + 5×2×6 = 30 + 60 = 90번이다.
BC를 먼저 곱하고 A를 곱하는 경우 A(BC)에 필요한 곱셈 연산의 수는 3×2×6 + 5×3×6 = 36 + 90 = 126번이다.

같은 곱셈이지만, 곱셈을 하는 순서에 따라서 곱셈 연산의 수가 달라진다.

행렬 N개의 크기가 주어졌을 때, 모든 행렬을 곱하는데 필요한 곱셈 연산 횟수의 최솟값을 구하는 프로그램을 작성하시오. 입력으로 주어진 행렬의 순서를 바꾸면 안 된다.

입력

첫째 줄에 행렬의 개수 N(1 ≤ N ≤ 500)이 주어진다.

둘째 줄부터 N개 줄에는 행렬의 크기 r과 c가 주어진다. (1 ≤ r, c ≤ 500)

항상 순서대로 곱셈을 할 수 있는 크기만 입력으로 주어진다.

출력

첫째 줄에 입력으로 주어진 행렬을 곱하는데 필요한 곱셈 연산의 최솟값을 출력한다. 정답은 231-1 보다 작거나 같은 자연수이다. 또한, 최악의 순서로 연산해도 연산 횟수가 2^31-1보다 작거나 같다.

재정의와 추상화

DP 문제 중 파일 합치기 문제와 비슷하게 진행되는 문제이다. 이런 유형의 문제가 많이 있는 것 같으니 정확하게 공부해두자!

처음 N개의 행렬의 세로, 가로 길이를 입력받는다. 입력받은 N개의 행렬 정보는 Matrix 구조체 변수의 arr에 저장된다. 그 후, 우리는 행렬의 곱셈 연산의 수를 계산해야 한다. 우리는 dp라는 이름의 2차원 배열을 선언하여 첫 번째 인덱스부터 두 번째 인덱스까지의 행렬곱을 진행했을 때 그 연산의 수를 저장한다. (dp[i][j])

i번째 인덱스의 행렬과 j번째 인덱스의 행렬까지의 곱셈 연산의 수의 합은 아래와 같은 점화식으로 나타낼 수 있다.

// k는 i부터 j - 1까지의 범위를 가진다.
dp[i][j] = min(dp[i][k] + dp[k + 1][j] + arr[i].height * arr[k].width * arr[j].width)

코드 작성

#include <iostream>
#include <climits>
using namespace std;

typedef struct {
    int height, width;
} Matrix;

Matrix arr[500];
int dp[500][500];

int main() {
    int n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> arr[i].height >> arr[i].width;
    }

    for (int i = 1; i < n; i++) {
        for (int j = 0; j + i < n; j++) {
            dp[j][j + i] = INT_MAX;
            for (int k = 0; k <= i - 1; k++) {
                dp[j][j + i] = min(dp[j][j + k] + dp[j + k + 1][j + i]
                        + arr[j].height * arr[j + k].width * arr[j + i].width, dp[j][j + i]);
            }
        }
    }

    cout << dp[0][n - 1];
    return 0;
}

4월 13일 알고리즘 공부 계획

훈개발자 — Mon, 13 Apr 2020 01:07:26 +0900

알고리즘

동적 계획법(DP)

~~BOJ 11049 (내일 정리하기)~~

분할 정복

~~BOJ 1780~~
~~BOJ 1629~~

이분 탐색

~~BOJ 2805~~

스택

~~BOJ 1874~~
~~BOJ 4949~~
~~BOJ 10773~~

기타

~~소프트웨어프로젝트 과제 2 제출~~

BOJ 10816 - 숫자 카드 2 문제풀이

훈개발자 — Sat, 11 Apr 2020 02:58:03 +0900

문제를 읽고 이해하기

숫자 카드는 정수 하나가 적혀져 있는 카드이다. 상근이는 숫자 카드 N개를 가지고 있다. 정수 M개가 주어졌을 때, 이 수가 적혀있는 숫자 카드를 상근이가 몇 개 가지고 있는지 구하는 프로그램을 작성하시오.

입력

첫째 줄에 상근이가 가지고 있는 숫자 카드의 개수 N(1 ≤ N ≤ 500,000)이 주어진다. 둘째 줄에는 숫자 카드에 적혀있는 정수가 주어진다. 숫자 카드에 적혀있는 수는 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다.

셋째 줄에는 M(1 ≤ M ≤ 500,000)이 주어진다. 넷째 줄에는 상근이가 몇 개 가지고 있는 숫자 카드인지 구해야 할 M개의 정수가 주어지며, 이 수는 공백으로 구분되어져 있다. 이 수도 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다.

출력

첫째 줄에 입력으로 주어진 M개의 수에 대해서, 각 수가 적힌 숫자 카드를 상근이가 몇 개 가지고 있는지를 공백으로 구분해 출력한다.

재정의와 추상화

입력으로 주어진 M개의 수에 대해서, 각 수가 적힌 숫자 카드가 몇 개인지 출력하는게 문제이다. 이 문제를 처음에는 map을 이용해 문제를 풀었다.

map을 이용한 풀이

map은 삽입, 삭제, 접근 모두 시간 복잡도가 logn이므로 모든 M개의 수에 대해서 검사하는 시간은 O(MlogN)이다. N이 500000이고, M이 500000이라고 했을 때, 1억보다 작으므로 1초보다 적은 시간이 걸린다고 생각하였다.

알고리즘은 다음과 같다. 카드에 적혀있는 숫자 int형 key와 그 숫자에 대한 개수를 저장하는 int형 value를 가지는 map<int, int>형 변수를 선언한다. 그리고 처음 N개의 수를 받을 때, map[카드에 적혀있는 숫자]++;를 통해 개수를 증가시킨다.

그리고 M개의 수를 받을 때, 수를 받을 때마다 map[찾을 숫자]를 통해 개수를 출력하게 하였다. 코드는 아래와 같다.

#include <iostream>
#include <map>
using namespace std;

map<int, int> cards;

int main() {
    cin.sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    int n, m;
    cin >> n;
    while (n--) {
        int num;
        cin >> num;
        cards[num]++;
    }
    cin >> m;
    while (m--) {
        int num;
        cin >> num;
        cout << cards[num] << ' ';
    }

    return 0;
}

그러나, map을 이용한 풀이는 이 문제의 의도가 아니므로 그냥 이런 방법이 있다 정도로만 알고 있자.

upper_bound와 lower_bound를 이용한 풀이

2020/04/03 - [언어/C, C++] - [C++ STL] upper_bound, lower_bound 알아보기

[C++ STL] upper_bound, lower_bound 알아보기

hoondev.tistory.com

upper_bound와 lower_bound 모두 logn의 시간 복잡도로 값을 얻을 수 있다. 따라서 총 O(MlogN)의 시간이 걸린다. 처음 N개의 수를 vector를 이용해 저장하고, 그 수를 오름차순으로 정렬한다. 그리고 다음 M개의 수에 대해 아래와 같은 코드를 적용한다.

cout << upper_bound(cards.begin(), cards.end(), num) - lower_bound(cards.begin(), cards.end(), num) << ' ';

(upper_bound와 lower_bound에 대해 이미 알고 있다는 전제 하에 설명하겠습니다.)

아래 예시를 보자.

정렬된 N개의 수가 1, 1, 2, 3, 4, 5, 6, 9 일 때, 우리가 1의 개수를 알고 싶다고 하자.

upper_bound(begin, end, 1)를 하면 세 번째 원소를 가리키는 이터레이터가 반환된다. 그 이유는 upper_bound는 정렬된 배열에서 찾고자 하는 수보다 큰 수 중에서 처음으로 찾은 수를 가리키는 이터레이터를 반환하는 함수이기 때문이다.

lower_bound(begin, end, 1)를 하면 첫 번째 원소를 가리키는 이터레이터가 반환된다. 그 이유는 lower_bound는 정렬된 배열에서 찾고자 하는 수보다 작지 않은 값(이상의 값) 중에서 처음으로 찾은 수를 가리키는 이터레이터를 반환하는 함수이기 때문이다.

따라서, (upper_bound 반환 값 - lower_bound 반환 값)을 하면 (3번째를 가리키는 이터레이터 - 1번째를 가리키는 이터레이터)이므로 찾고자 하는 수인 1의 개수를 얻을 수 있다.

이러한 upper_bound와 lower_bound의 원리를 이용하여 찾고자 하는 수의 개수를 얻을 수 있다.

코드 작성

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> cards;

int main() {
    cin.sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    int n, m;
    cin >> n;
    while (n--) {
        int num;
        cin >> num;
        cards.push_back(num);
    }
    sort(cards.begin(), cards.end());
    cin >> m;
    while (m--) {
        int num;
        cin >> num;
        cout << upper_bound(cards.begin(), cards.end(), num) - lower_bound(cards.begin(), cards.end(), num) << ' ';
    }

    return 0;
}

BOJ 2206 - 벽 부수고 이동하기

훈개발자 — Thu, 9 Apr 2020 22:31:48 +0900

문제를 읽고 이해하기

N×M의 행렬로 표현되는 맵이 있다. 맵에서 0은 이동할 수 있는 곳을 나타내고, 1은 이동할 수 없는 벽이 있는 곳을 나타낸다. 당신은 (1, 1)에서 (N, M)의 위치까지 이동하려 하는데, 이때 최단 경로로 이동하려 한다. 최단경로는 맵에서 가장 적은 개수의 칸을 지나는 경로를 말하는데, 이때 시작하는 칸과 끝나는 칸도 포함해서 센다.

만약에 이동하는 도중에 한 개의 벽을 부수고 이동하는 것이 좀 더 경로가 짧아진다면, 벽을 한 개 까지 부수고 이동하여도 된다.

맵이 주어졌을 때, 최단 경로를 구해 내는 프로그램을 작성하시오.

입력

첫째 줄에 N(1 ≤ N ≤ 1,000), M(1 ≤ M ≤ 1,000)이 주어진다. 다음 N개의 줄에 M개의 숫자로 맵이 주어진다. (1, 1)과 (N, M)은 항상 0이라고 가정하자.

출력

첫째 줄에 최단 거리를 출력한다. 불가능할 때는 -1을 출력한다.

재정의와 추상화

우선 지도에서 특정 위치까지 가는 최단 거리를 구하는 문제이므로, BFS를 이용하여 문제를 풀면 된다. 단, 벽을 한 개 까지 부수고 이동하여도 된다는 조건이 있으므로 이 조건에 유의하여 코드를 짜야한다.

지금까지 BFS를 이용한 최단거리 알고리즘을 풀 때와는 다르게, check 함수를 3차원으로 선언해야 한다. 그 이유는, 벽을 부수고 이동했을 때의 경로와 벽을 부수지 않고 이동했을 때의 경로가 겹칠 경우에 문제가 생기기 때뭉니다.

예를 들어, 벽을 부수고 이동한 경로에서 (2, 4)라는 특정 위치를 통과했다고 치자. 그러면 그 위치에서 check해주는 방문 배열이 true가 된다. 따라서, 벽을 부수지 않고 이동한 경로에서 (2, 4)를 통과할 때 check가 true이므로, 그 위치를 통과할 수 없게 된다. 비록 그 경로가 '최단 경로'여도..

따라서 check[세로위치][가로위치][2]와 같이 3차원 배열로 선언하여, 그 경로가 이미 벽을 부순 적이 있는 경로라면 check[y][x][1]에 기록하고, 그렇지 않은 경로라면 check[y][x][0]에 기록하면 된다.

정리하면 아래와 같다.

큐(Queue)에는 Block이라는 구조체 객체가 들어간다.
Block 구조체는, 현재 위치의
1. 위치 정보 (y, x)
2. 벽을 이미 한 번 부순 적이 있는 경로인지 여부 (isBroken)
3. 현재 위치까지의 거리 (length)
현재 위치에서 오른쪽, 왼쪽, 위, 아래 방향으로 1칸 이동한 위치(next_y, next_x)에 대하여
1. 맵 내부에 있고 (isInside() 함수를 통해 확인)
2. 한 번도 방문한 적 없는 곳일 때 (!check[next_y][next_x][now.isBroken]
그 방향으로 1칸 이동한 위치가 (next_val) 벽(1)이라면 두 가지 선택을 할 수 있다.
1. 벽을 부수고, 그 방향으로 가는 방법. 이때 isBroken을 true로 만든 Block 객체를 큐에 push한다.
2. 벽을 이미 부순 적이 있다면(now.isBroken == true), continue;
그 방향으로 1칸 이동한 위치가 (next_val) 길(0)이라면
1. now.isBroken의 값은 유지한 채, 다음 위치에서의 정보와 함께 큐에 push한다.
check[next_y][next_x][now.isBroken] = true;을 통해 방문 정보를 등록한다.

코드 작성

#include <iostream>
#include <queue>
using namespace std;

int n, m;
int arr[1001][1001];
bool check[1001][1001][2];

typedef struct {
    int y, x;
    bool isBroken;
    int length;
} Block;

typedef struct {
    int y, x;
} Direction;

Direction dir[4] = { { 1, 0 }, { 0, 1 }, { -1, 0 }, { 0, -1 } };

bool isInside(int y, int x) {
    return y >= 1 && x >= 1 && y <= n && x <= m;
}

int bfs() {
   queue<Block> q;
   q.push({1, 1, false, 1});
   check[1][1][0] = true;

   while (!q.empty()) {
       auto now = q.front();
       q.pop();

       if (now.y == n && now.x == m)
           return now.length;

       for (auto & d : dir) {
           int next_y = now.y + d.y;
           int next_x = now.x + d.x;
           auto & next_val = arr[next_y][next_x];
           if (isInside(next_y, next_x) && !check[next_y][next_x][now.isBroken]) {
               if (next_val) {
                   if (now.isBroken)
                       continue;
                   else {
                       q.push({next_y, next_x, true, now.length + 1});
                   }
               } else
                   q.push({next_y, next_x, now.isBroken, now.length + 1});
               check[next_y][next_x][now.isBroken] = true;
           }
       }
   }
   return -1;
}

int main() {
    cin >> n >> m;

    for (int i = 1; i <= n; i++) {
        string temp;
        cin >> temp;
        for (int j = 0; j < temp.length(); j++)
            arr[i][j + 1] = temp[j] - '0';
    }

    cout << bfs();
    return 0;
}

BOJ 12865 - 평범한 배낭(냅색 알고리즘) 문제풀이

훈개발자 — Thu, 9 Apr 2020 15:56:17 +0900

문제를 읽고 이해하기

이 문제는 ~~아주 평범한 배낭~~에 관한 문제이다.

한 달 후면 국가의 부름을 받게 되는 준서는 여행을 가려고 한다. 세상과의 단절을 슬퍼하며 최대한 즐기기 위한 여행이기 때문에, 가지고 다닐 배낭 또한 최대한 가치 있게 싸려고 한다.

준서가 여행에 필요하다고 생각하는 N개의 물건이 있다. 각 물건은 무게 W와 가치 V를 가지는데, 해당 물건을 배낭에 넣어서 가면 준서가 V만큼 즐길 수 있다. 아직 행군을 해본 적이 없는 준서는 최대 K무게까지의 배낭만 들고 다닐 수 있다. 준서가 최대한 즐거운 여행을 하기 위해 배낭에 넣을 수 있는 물건들의 가치의 최댓값을 알려주자.

입력

첫 줄에 물품의 수 N(1 ≤ N ≤ 100)과 준서가 버틸 수 있는 무게 K(1 ≤ K ≤ 100,000)가 주어진다. 두 번째 줄부터 N개의 줄에 거쳐 각 물건의 무게 W(1 ≤ W ≤ 100,000)와 해당 물건의 가치 V(0 ≤ V ≤ 1,000)가 주어진다.

입력으로 주어지는 모든 수는 정수이다.

출력

한 줄에 배낭에 넣을 수 있는 물건들의 가치합의 최댓값을 출력한다.

재정의와 추상화

배낭 알고리즘 (Knapsack Algorithm)

배낭에 담을 수 있는 무게의 최댓값이 정해져 있고, 일정 가치와 무게가 있는 짐들을 배낭에 넣을 때, 가치의 합이 최대가 되도록 짐을 고르는 방법을 찾는 알고리즘을 뜻합니다.

이 문제는 대표적인 배낭 알고리즘 문제입니다. 문제에서 주어진 아래 예시를 가지고 설명하겠습니다.

총 물품의 수는 4개, 배낭에 담을 수 있는 무게의 최댓값은 7입니다. 아래는 4개의 물품을 설명의 편의를 위해 오름차순으로 정렬한 것입니다.

무게 3, 가치 6
무게 4, 가치 8
무게 5, 가치 12
무게 6, 가치 13

dp	j = 0	j = 1	j = 2	j = 3	j = 4	j = 5	j = 6	j = 7
i = 0	0	0	0	0	0	0	0	0
i = 1	0	0	0	6	6	6	6	6
i = 2	0	0	0	6	8	8	8	14
i = 3	0	0	0	6	8	12	12	14
i = 4	0	0	0	6	8	12	13	14

* dp[i][j]는 j의 무게까지 담을 수 있는 배낭에 1번째부터 i번째 물품을 사용하여 배낭에 담을 수 있는 최대 가치를 뜻한다.
* obj[i]는 i번째 물품에 대한 정보를 뜻하고, obj[i].first는 그 물품의 무게, obj[i].second는 그 물품의 가치를 뜻한다.

3가지 예시를 통해 이해해보자.

i = 2, j = 4 -> dp[2][4]
1. obj[2].second == 8
  2번째 물품 하나를 가방에 넣으면 총 가치는 8, 총 무게는 4, 남는 무게는 0이다.
  이때, 1부터 1번째 물품을 사용해 남는 무게에 대한 가치 최댓값을 마저 더해주면 된다.
  --> obj[2].second + dp[2 - 1][4 - 4(obj[2].first)] == 8 + 0 == 8
2. dp[2 - 1][4] == 6
  1번째부터 1번째 물품을 사용하여 총 무게를 4로 맞췄을 때 총 가치는 6
3. 8 > 6이므로, dp[2][4] = obj[2].second + dp[1][0] == 8
i = 2, j = 7 -> dp[2][7]
1. obj[2].second == 8
  2번째 물품 하나를 가방에 넣으면 총 가치는 8, 총 무게는 4, 남는 무게는 3이다.
  이때, 1부터 1번째 물품을 사용해 남는 무게에 대한 가치 최댓값을 마저 더해주면 된다.
  --> obj[2].second + dp[2 - 1][7 - 4(obj[2].first)] == 8 + 6 == 14
2. dp[2 - 1][7] == 6
  1번째부터 1번째 물품을 사용하여 총 무게를 7로 맞췄을 때 총 가치는 6
3. 14 > 6이므로, dp[2][7] = obj[2].second + dp[1][7] == 14

단, 위 예시는 obj[i].first(i번째 물품의 무게)가 j 이하라는 것을 가정하였을 때 할 수 있는 이야기이다.

왜냐하면 j 이상이 아닐 경우, 남는 무게에 대한 dp[i - 1][j - obj[i].first]를 구할 때 j - obj[i].first가 음수가 되버리므로, 메모리 접근 오류가 발생하기 때문이다.

따라서, obj[i].first가 j 이하일 때만 위와 같은 매커니즘이 작동하도록 하고 dp[i][j]에 대한 기본값을 dp[i - 1][j]로 초기화 해놓으면 된다.

문제의 정답은 i = n, j = k일 때를 구하는 것이므로 답은 dp[n][k]이다.

점화식

// dp[i][j]의 초기값
dp[i][j] = dp[i - 1][j]
if (obj[i].first <= j) {
	dp[i][j] = max(obj[i].second + dp[i - 1][j - obj[i].second], dp[i][j])
}

코드 작성

#include <iostream>
#include <algorithm>
using namespace std;

pair<int, int> obj[101];
int arr[101][100001];

int main() {
    cin.sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    int n, k;
    cin >> n >> k;
    for (int i = 1; i <= n; i++)
        cin >> obj[i].first >> obj[i].second;
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j <= k; j++) {
            arr[i][j] = arr[i - 1][j];
            if (obj[i].first <= j)
                arr[i][j] = max(obj[i].second + arr[i - 1][j - obj[i].first], arr[i][j]);
        }
    }
    cout << arr[n][k];
    return 0;
}

BOJ 10250 - ACM 호텔 문제풀이

훈개발자 — Wed, 8 Apr 2020 22:53:37 +0900

문제를 읽고 이해하기

ACM 호텔 매니저 지우는 손님이 도착하는 대로 빈 방을 배정하고 있다. 고객 설문조사에 따르면 손님들은 호텔 정문으로부터 걸어서 가장 짧은 거리에 있는 방을 선호한다고 한다. 여러분은 지우를 도와 줄 프로그램을 작성하고자 한다. 즉 설문조사 결과 대로 호텔 정문으로부터 걷는 거리가 가장 짧도록 방을 배정하는 프로그램을 작성하고자 한다.

문제를 단순화하기 위해서 호텔은 직사각형 모양이라고 가정하자. 각 층에 W 개의 방이 있는 H 층 건물이라고 가정하자 (1 ≤ H, W ≤ 99). 그리고 엘리베이터는 가장 왼쪽에 있다고 가정하자(그림 1 참고). 이런 형태의 호텔을 H × W 형태 호텔이라고 부른다. 호텔 정문은 일층 엘리베이터 바로 앞에 있는데, 정문에서 엘리베이터까지의 거리는 무시한다. 또 모든 인접한 두 방 사이의 거리는 같은 거리(거리 1)라고 가정하고 호텔의 정면 쪽에만 방이 있다고 가정한다.

그림 1. H = 6 이고 W = 12 인 H × W 호텔을 간략하게 나타낸 그림

방 번호는 YXX 나 YYXX 형태인데 여기서 Y 나 YY 는 층 수를 나타내고 XX 는 엘리베이터에서부터 세었을 때의 번호를 나타낸다. 즉, 그림 1 에서 빗금으로 표시한 방은 305 호가 된다.

손님은 엘리베이터를 타고 이동하는 거리는 신경 쓰지 않는다. 다만 걷는 거리가 같을 때에는 아래층의 방을 더 선호한다. 예를 들면 102 호 방보다는 301 호 방을 더 선호하는데, 102 호는 거리 2 만큼 걸어야 하지만 301 호는 거리 1 만큼만 걸으면 되기 때문이다. 같은 이유로 102 호보다 2101 호를 더 선호한다.

여러분이 작성할 프로그램은 초기에 모든 방이 비어있다고 가정하에 이 정책에 따라 N 번째로 도착한 손님에게 배정될 방 번호를 계산하는 프로그램이다. 첫 번째 손님은 101 호, 두 번째 손님은 201 호 등과 같이 배정한다. 그림 1 의 경우를 예로 들면, H = 6이므로 10 번째 손님은 402 호에 배정해야 한다.

입력

프로그램은 표준 입력에서 입력 데이터를 받는다. 프로그램의 입력은 T 개의 테스트 데이터로 이루어져 있는데 T 는 입력의 맨 첫 줄에 주어진다. 각 테스트 데이터는 한 행으로서 H, W, N, 세 정수를 포함하고 있으며 각각 호텔의 층 수, 각 층의 방 수, 몇 번째 손님인지를 나타낸다(1 ≤ H, W ≤ 99, 1 ≤ N ≤ H × W).

출력

프로그램은 표준 출력에 출력한다. 각 테스트 데이터마다 정확히 한 행을 출력하는데, 내용은 N 번째 손님에게 배정되어야 하는 방 번호를 출력한다.

재정의와 추상화

N번째 손님이 들어갈 방의 번호는 (방의 층수)(정문으로부터 떨어진 거리)이다.

방의 층수 = (N - 1) % (호텔의 높이) + 1
정문으로부터 떨어진 거리 = (N - 1) / (호텔의 높이) + 1

그런데, 떨어진 거리가 1~9일 경우, 01, 02, 03.. 처럼 숫자 앞에 0이 붙는다. 이를 위해 정문으로부터 떨어진 거리를 출력하기 전에 2개의 cout 속성을 부여한다.

cout.width(2); : 2칸의 폭에 맞추어 출력한다.
cout.fill(0); : 빈 공간은 0으로 채운다.

이 속성 부여는 속성이 부여된 다음 첫 번째 cout 출력에만 사용되고 그 이후부터는 속성이 삭제된다.

코드 작성

#include <iostream>
using namespace std;

int main() {
    cin.sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    int t;
    cin >> t;
    while (t--) {
        int h, w, n;
        cin >> h >> w >> n;
        cout << (n - 1) % h + 1;
        cout.width(2);
        cout.fill('0');
        cout << (n - 1) / h + 1 << '\n';
    }

    return 0;
}

참고 문서

https://modoocode.com/152

BOJ 2292 - 벌집 문제풀이

훈개발자 — Wed, 8 Apr 2020 21:40:49 +0900

문제를 읽고 이해하기

위의 그림과 같이 육각형으로 이루어진 벌집이 있다. 그림에서 보는 바와 같이 중앙의 방 1부터 시작해서 이웃하는 방에 돌아가면서 1씩 증가하는 번호를 주소로 매길 수 있다. 숫자 N이 주어졌을 때, 벌집의 중앙 1에서 N번 방까지 최소 개수의 방을 지나서 갈 때 몇 개의 방을 지나가는지(시작과 끝을 포함하여)를 계산하는 프로그램을 작성하시오. 예를 들면, 13까지는 3개, 58까지는 5개를 지난다.

입력

첫째 줄에 N(1 ≤ N ≤ 1,000,000,000)이 주어진다.

출력

입력으로 주어진 방까지 최소 개수의 방을 지나서 갈 때 몇 개의 방을 지나는지 출력한다.

재정의와 추상화

1번부터 시작하여 주어진 번호의 방으로 가는데, 최소 개수의 방을 지나서 가려면 1에서 시작하여 대각선으로 쭉 가는 방법 밖에 없다. 아래 그림이 그 예시가 된다.

위 그림과 같이 대각선으로 쭉 가는 거리를 알아내려면 중심인 1로부터 몇 칸 떨어져 있는지 알아내면 된다.

빨간색 영역에 있는 1이 있는 곳을 중심(=0)이라 한다. 그리고 그 주위를 둘러싸고 있는 방들을 1번째 영역이라고 한다. 또 그 1번째 영역을 둘러싸고 있는 방들을 2번째 영역이라고 한다.

이렇게 i번째 영역을 둘러싸고 있는 방들의 영역을 i+1번째 영역이라고 하고, i번째 영역에 있는 방들은 중심으로부터 i + 1만큼 떨어져 있는 것이 되므로 i + 1가 정답이 된다.

아래의 표를 보자.

중심(0)	1번째 영역	2번째 영역	3번째 영역	4번째 영역	5번째 영역
1	6	12	18	24	30
1	1 + 6 = 7	7 + 12 = 19	19 + 18 = 37	37 + 24 = 61	61 + 30 = 91

첫 번째 줄은 각 영역에 있는 원소의 개수이고, 두 번째 줄은 중심부터 i번째 영역까지의 원소의 개수 합이다.

위 표를 통해 13번째 방이 있는 영역을 찾으면 7보다 크고 19보다 작거나 같은 2번째 영역이므로, 13번째 방은 중심으로부터 1 + 2 = 3만큼 떨어져 있으므로 답이 3이 된다.

코드 작성

#include <iostream>
using namespace std;

int main() {
    int total = 1;
    int i;
    int n;
    cin >> n;
    for (i = 0; total <= 1000000000; i++) {
        total += i * 6;
        if (total >= n) break;
    }
    cout << i + 1;
    return 0;
}

BOJ 3053 - 택시 기하학 문제풀이

훈개발자 — Wed, 8 Apr 2020 20:54:33 +0900

문제를 읽고 이해하기

19세기 독일 수학자 헤르만 민코프스키는 비유클리드 기하학 중 택시 기하학을 고안했다. 택시 기하학에서 두 점 T1(x1,y1), T2(x2,y2) 사이의 거리는 다음과 같이 구할 수 있다.

D(T1,T2) = |x1-x2| + |y1-y2|

두 점 사이의 거리를 제외한 나머지 정의는 유클리드 기하학에서의 정의와 같다. 따라서 택시 기하학에서 원의 정의는 유클리드 기하학에서 원의 정의와 같다.

원: 평면 상의 어떤 점에서 거리가 일정한 점들의 집합

반지름 R이 주어졌을 때, 유클리드 기하학에서 원의 넓이와, 택시 기하학에서 원의 넓이를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 반지름 R이 주어진다. R은 10,000보다 작거나 같은 자연수이다.

출력

첫째 줄에는 유클리드 기하학에서 반지름이 R인 원의 넓이를, 둘째 줄에는 택시 기하학에서 반지름이 R인 원의 넓이를 출력한다. 정답과의 오차는 0.0001까지 허용한다.

재정의와 추상화

유클리드 기하학에서 한 점과 다른 한 점 사이의 거리는 아래와 같이 정의된다.

따라서 원은 아래와 같이 그려진다.

유클리드 기하학에서의 원

반면에 택시 기하학에서 한 점과 다른 한 점 사이의 거리는 아래와 같이 정의된다.

따라서 원은 아래와 같이 그려진다.

택시 기하학에서의 원

따라서 유클리드 기하학에서의 원의 넓이는 원래 우리가 알고 있던대로

PI(3.1415...) * r^2

이다.

반면에 택시 기하학에서의 원의 넓이는 아래와 같다.

(2 * r) * (2 * r) / 2

위 공식은 (한 대각선) * (다른 대각선) / 2로, 마름모 넓이 공식이다. 더 나아가, 택시 기하학에서의 원은 항상 정사각형 꼴을 띄므로 정사각형 넓이 공식을 통해 아래와 같이 구할 수도 있다.

((루트 2) * r)^2

코드 작성

#define _USE_MATH_DEFINES
#include <iostream>
#include <cmath>
using namespace std;

int main() {
    int r;
    cin >> r;
    cout << fixed;
    cout.precision(6);
    cout << M_PI * pow(r, 2) << '\n';
    cout << pow(2 * r, 2) / 2;
    return 0;
}

파이 값은 cmath 헤더에 포함된 M_PI 매크로를 사용하면 된다.
단, M_PI 매크로를 사용하려면, 최상단에 #define _USE_MATH_DEFINES를 사용해야 한다.

그림 출처

https://m.blog.naver.com/alwaysneoi/100172516753?view=img_7

BOJ 2580 - 스도쿠 문제풀이

훈개발자 — Wed, 8 Apr 2020 03:29:31 +0900

문제를 읽고 이해하기

스도쿠는 18세기 스위스 수학자가 만든 '라틴 사각형'이랑 퍼즐에서 유래한 것으로 현재 많은 인기를 누리고 있다. 이 게임은 아래 그림과 같이 가로, 세로 각각 9개씩 총 81개의 작은 칸으로 이루어진 정사각형 판 위에서 이뤄지는데, 게임 시작 전 몇 몇 칸에는 1부터 9까지의 숫자 중 하나가 쓰여 있다.

나머지 빈 칸을 채우는 방식은 다음과 같다.

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

위의 예의 경우, 첫째 줄에는 1을 제외한 나머지 2부터 9까지의 숫자들이 이미 나타나 있으므로 첫째 줄 빈칸에는 1이 들어가야 한다.

또한 위쪽 가운데 위치한 3x3 정사각형의 경우에는 3을 제외한 나머지 숫자들이 이미 쓰여있으므로 가운데 빈 칸에는 3이 들어가야 한다.

이와 같이 빈 칸을 차례로 채워 가면 다음과 같은 최종 결과를 얻을 수 있다.

게임 시작 전 스도쿠 판에 쓰여 있는 숫자들의 정보가 주어질 때 모든 빈칸이 채워진 최종 모습을 출력하는 프로그램을 작성하시오.

입력

아홉 줄에 걸쳐 한 줄에 9개씩 게임 시작 전 스도쿠판 각 줄에 쓰여 있는 숫자가 한 칸씩 띄워서 차례로 주어진다. 스도쿠 판의 빈칸의 경우에는 0이 주어진다. 스도쿠 판을 규칙대로 채울 수 없는 경우의 입력은 주어지지 않는다.

출력

모든 빈 칸이 채워진 스도쿠 판의 최종 모습을 아홉 줄에 걸쳐 한 줄에 9개씩 한 칸씩 띄워서 출력한다.

스도쿠 판을 채우는 방법이 여럿인 경우는 그 중 하나만을 출력한다.

재정의와 추상화

8번 시도의 대장정 끝에... 처음 접근을 잘못하면 이 꼴 납니다...

이 문제는 DFS를 이용한 '백트래킹' 기술로 풀 수 있다.

main에서 스도쿠 배열과 스도쿠 배열에서 비어있는 곳의 위치(0)를 v라는 이름의 벡터에 pair 형태로 저장한다.
v[i]의 위치에 1부터 9까지의 수를 넣었을 때 스도쿠 조건에 만족하는지 검사한다. (check 함수)
check가 통과되었을 경우, 해당 위치의 스도쿠 배열에 그 수를 넣고, v[i + 1]에 대해 이 과정을 반복한다.
그 과정이 성공하였을 경우 true를 리턴하고, 그러지 않았을 경우 v[i]의 위치를 다시 '비어있는 상태'로 만든 후 다음 수에 대해 스도쿠 조건에 만족하는지 검사한다.
이 과정을 반복하다가, v의 끝까지 검사했을 경우 true를 리턴한다.

코드 작성

#include <iostream>
#include <vector>
using namespace std;

int arr[9][9];
vector<pair<int, int>> v;

bool check(int y, int x, int i) {
    for (int k = 0; k < 9; k++) {
        if (arr[y][k] == i || arr[k][x] == i)
            return false;
    }
    for (int k = (y / 3) * 3; k < (y / 3) * 3 + 3; k++) {
        for (int j = (x / 3) * 3; j < (x / 3) * 3 + 3; j++) {
            if (arr[k][j] == i)
                return false;
        }
    }
    return true;
}

bool dfs(int cur) {
    if (cur == v.size()) return true;
    int y = v[cur].first;
    int x = v[cur].second;
    for (int i = 1; i <= 9; i++) {
        if (check(y, x, i)) {
            arr[y][x] = i;
            if (dfs(cur + 1)) return true;
            arr[y][x] = 0;
        }
    }
    return false;
}

int main() {
    for (auto & i : arr) for (int & j : i) cin >> j;
    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            if (arr[i][j] == 0)
                v.push_back({i, j});
        }
    }
    dfs(0);
    for (auto & i : arr) {
        for (int & j : i) cout << j << ' ';
        cout << '\n';
    }
    return 0;
}

BOJ 1654 - 랜선 자르기 문제풀이

훈개발자 — Tue, 7 Apr 2020 20:48:36 +0900

문제를 읽고 이해하기

집에서 시간을 보내던 오영식은 박성원의 부름을 받고 급히 달려왔다. 박성원이 캠프 때 쓸 N개의 랜선을 만들어야 하는데 너무 바빠서 영식이에게 도움을 청했다.

이미 오영식은 자체적으로 K개의 랜선을 가지고 있다. 그러나 K개의 랜선은 길이가 제각각이다. 박성원은 랜선을 모두 N개의 같은 길이의 랜선으로 만들고 싶었기 때문에 K개의 랜선을 잘라서 만들어야 한다. 예를 들어 300cm 짜리 랜선에서 140cm 짜리 랜선을 두 개 잘라내면 20cm 은 버려야 한다. (이미 자른 랜선은 붙일 수 없다.)

편의를 위해 랜선을 자르거나 만들 때 손실되는 길이는 없다고 가정하며, 기존의 K개의 랜선으로 N개의 랜선을 만들 수 없는 경우는 없다고 가정하자. 그리고 자를 때는 항상 센티미터 단위로 정수길이만큼 자른다고 가정하자. N개보다 많이 만드는 것도 N개를 만드는 것에 포함된다. 이때 만들 수 있는 최대 랜선의 길이를 구하는 프로그램을 작성하시오.

입력

첫째 줄에는 오영식이 이미 가지고 있는 랜선의 개수 K, 그리고 필요한 랜선의 개수 N이 입력된다. K는 1이상 10,000이하의 정수이고, N은 1이상 1,000,000이하의 정수이다. 그리고 항상 K ≦ N 이다. 그 후 K줄에 걸쳐 이미 가지고 있는 각 랜선의 길이가 센티미터 단위의 정수로 입력된다. 랜선의 길이는 2³¹-1보다 작거나 같은 자연수이다.

출력

첫째 줄에 N개를 만들 수 있는 랜선의 최대 길이를 센티미터 단위의 정수로 출력한다.

재정의와 추상화

이 문제를 완전 탐색으로 접근한다면, O(최대 랜선의 길이) * O(K)로 최대 21억 * 10000, 약 210000초가 걸릴 것이다. 따라서 우리는 선형 연산이 아닌, 로그형 연산을 시행해야 한다. 로그형 연산으로 탐색을 수행할 수 있는 알고리즘은 이분 탐색(Binary Search)이 있다.

(front) 1 ~ (back) 오영식이 가지고 있는 K개의 랜선 중 가장 긴 랜선의 길이

위 범위를 시작으로, 이분 탐색을 시행한다. 아래는 이분 탐색 원리를 안다는 가정 하에 설명한 내용이다.

mid값을 front와 back의 평균값보다 큰 수 중 최소 정수이라고 하자. (401.2 -> 402)

mid 값으로 K개의 랜선을 나눈 값 각각은 mid의 길이로 만들 수 있는 랜선의 개수를 의미하고, 그 각각의 총합은 K개의 랜선을 mid의 길이로 만들 수 있는 랜선의 개수 총합(sum)이다.

sum이 N보다 작으면 mid보다 더 짧은 길이로 만들어야 한다는 것을 의미하므로, back을 mid - 1로 만든다.
sum이 N보다 크거나 같으면 mid보다 길거나 같은 길이로 만들어야 한다는 것을 의미하므로, front를 mid로 만든다.

이 과정을 front와 back이 같아질 때까지 시행하면 된다. 이 때의 front 또는 back값이 N개 이상을 만들 수 있는 랜선의 최대 길이이다.

예시

예제 입력

진행 과정
1. front == 1, back == 21, mid == 11, sum == 0 + 1 + 1 + 1 == 3, sum < n == 8
2. front == 1, back == 10, mid == 6, sum == 1 + 3 + 2 + 2 == 9, sum >= n == 8
3. front == 6, back == 10, mid == 8, sum == 1 + 2 + 2 + 1 == 6, sum < n == 8
4. front == 6, back == 7, mid == 7, sum == 1 + 3 + 2 + 2 == 8, sum >= n == 8
5. front == 7, back == 7 --> 종료

코드 작성

#include <iostream>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;

vector<int> lan;

int main() {
    cout.tie(NULL);
    cin.sync_with_stdio(false);
    cin.tie(NULL);
    int k, n;
    cin >> k >> n;

    for (int i = 0; i < k; i++) {
        int temp;
        cin >> temp;
        lan.push_back(temp);
    }

    long long back = (*max_element(lan.begin(), lan.end()));
    long long front = 1;
    while (front != back) {
        long long sum = 0;
        int mid = ceil((double)(front + back) / 2);
        for (auto & target : lan)
            sum += target / mid;
        if (sum < n)
            back = mid - 1;
        else if (sum >= n)
            front = mid;
    }
    cout << front;
    return 0;
}

BOJ 1436 - 영화감독 숌

훈개발자 — Tue, 7 Apr 2020 03:29:30 +0900

문제를 읽고 이해하기

666은 종말을 나타내는 숫자라고 한다. 따라서, 많은 블록버스터 영화에서는 666이 들어간 제목을 많이 사용한다. 영화감독 숌은 세상의 종말 이라는 시리즈 영화의 감독이다. 조지 루카스는 스타워즈를 만들 때, 스타워즈 1, 스타워즈 2, 스타워즈 3, 스타워즈 4, 스타워즈 5, 스타워즈 6과 같이 이름을 지었고, 피터 잭슨은 반지의 제왕을 만들 때, 반지의 제왕 1, 반지의 제왕 2, 반지의 제왕 3과 같이 영화 제목을 지었다.

하지만 숌은 자신이 조지 루카스와 피터 잭슨을 뛰어넘는다는 것을 보여주기 위해서 영화 제목을 좀 다르게 만들기로 했다.

종말의 숫자란 어떤 수에 6이 적어도 3개이상 연속으로 들어가는 수를 말한다. 제일 작은 종말의 숫자는 666이고, 그 다음으로 큰 수는 1666, 2666, 3666, .... 과 같다.

따라서, 숌은 첫 번째 영화의 제목은 세상의 종말 666, 두 번째 영화의 제목은 세상의 종말 1666 이렇게 이름을 지을 것이다. 일반화해서 생각하면, N번째 영화의 제목은 세상의 종말 (N번째로 작은 종말의 숫자) 와 같다.

숌이 만든 N번째 영화의 제목에 들어간 숫자를 출력하는 프로그램을 작성하시오. 숌은 이 시리즈를 항상 차례대로 만들고, 다른 영화는 만들지 않는다.

입력

첫째 줄에 숫자 N이 주어진다. N은 10,000보다 작거나 같은 자연수이다.

출력

첫째 줄에 N번째 영화의 제목에 들어간 수를 출력한다.

재정의와 추상화

숫자에 6이 3개 연속된 666이라는 수가 포함되어 있으면 된다. 처음에는 수를 문자열 처리해서 Substring이 "666"을 찾는 것으로 하려고 했으나, 더 간단한 방법이 있음을 알게 되었다.

우선 1부터 계속 증가하면서 666이 포함된 수를 N개 찾을 때 까지 탐색시켜야 한다. 이때, 현재의 수에 666이 포함되어 있는지 여부를 알기 위해서 아래와 같은 알고리즘을 적용했다.

while (temp) {
	if (temp % 1000 == 666) {
		i++; break;
    }
	temp /= 10;
}

num : 현재 수를 담아두는 변수
temp : 현재 수를 복사한 변수 (실제 수를 수정하면 안되므로)
while (temp) : temp가 0이 아닐 때까지
if (temp % 1000 == 6666) { i++; break; } : temp % 1000가 666이면 i(찾은 666이 포함된 수)를 1 증가시키고 이 반복문 탈출
temp /= 10 : temp % 1000이 6666이 아닐 경우 10을 나눈다. 또 다시 temp을 10으로 나눈 값에 대해 검사한다.

알고리즘 작동 예시

(temp는 66611이라고 가정)

temp == 166611, temp % 1000 == 611 != 666 이므로 temp /= 10 처리
temp == 16661, temp % 1000 == 661 != 666 이므로 temp /= 10 처리
temp == 1666, temp % 1000 == 666 == 666 이므로 i++하고 반복문 탈출

코드 작성

#include <iostream>
#include <cmath>
using namespace std;

int i, num;

int main() {
    int n;
    cin >> n;
    while (1) {
        int temp = num;
        while (temp) {
            if (temp % 1000 == 666) {i++; break;}
            temp /= 10;
        }
        if(i == n) break;
        num++;
    }
    cout << num;
    return 0;
}

BOJ 1541 - 잃어버린 괄호 문제풀이

훈개발자 — Tue, 7 Apr 2020 01:38:11 +0900

문제를 읽고 이해하기

세준이는 양수와 +, -, 그리고 괄호를 가지고 길이가 최대 50인 식을 만들었다. 그리고 나서 세준이는 괄호를 모두 지웠다.

그리고 나서 세준이는 괄호를 적절히 쳐서 이 식의 값을 최소로 만들려고 한다.

괄호를 적절히 쳐서 이 식의 값을 최소로 만드는 프로그램을 작성하시오.

입력

첫째 줄에 식이 주어진다. 식은 ‘0’~‘9’, ‘+’, 그리고 ‘-’만으로 이루어져 있고, 가장 처음과 마지막 문자는 숫자이다. 그리고 연속해서 두 개 이상의 연산자가 나타나지 않고, 5자리보다 많이 연속되는 숫자는 없다. 수는 0으로 시작할 수 있다.

출력

첫째 줄에 정답을 출력한다.

재정의와 추상화

주어진 식에 괄호를 적절히 쳐서 최솟값을 만들기 위해서는 빼는 수가 최대가 되게 만들면 된다.

따라서, -가 나오기 전까지 모두 더했다가, -가 나오면 다음 -가 나오기 전까지 - 이후의 수의 합을 구한다. 그리고 그 수를 총합에서 뺀다. 다음 -가 나오면 이 과정을 반복하고, 만약 다음 -가 나오지 않으면, 수식의 끝까지 간 경우이므로 함수를 종료한다.

필자는 이 기능을 구현하기 전에, string으로 읽어들인 문자열을 Tokenize 하는 작업을 거쳤다. int형 vector에 숫자는 숫자로, 부호는 -면 -1, +면 -2로 저장해놓았다.

그리고, 토큰화된 정수와 부호(-1, -2로 표현됨)를 읽고 최솟값을 만들어내는 함수를 만들었다.

코드 작성

#include <iostream>
#include <vector>
using namespace std;

vector<int> tokens;

void tokenize(string target) {
    auto it = target.begin();
    while (it != target.end()) {
        if (*it == '-') {
            tokens.push_back(-1);
            it++;
        } else if (*it == '+') {
            tokens.push_back(-2);
            it++;
        } else {
            auto begin = it;
            for (; *it >= '0' && *it <= '9'; it++) {}
            tokens.push_back(stoi(string(begin, it)));
        }
    }
}

int minimized_value() {
    int total = *tokens.begin();

    auto it = tokens.begin() + 1;
    while (it != tokens.end()) {
        if (*it == -1) {
            it++;
            int temp = 0;
            for (;*it != -1 && it != tokens.end(); it++) {
                if (*it != -2) {
                    temp += *it;
                }
            }
            total -= temp;
        } else if (*it == -2) {
            total += *(++it);
            it++;
        } else {
            total += *it;
            it++;
        }
    }
    return total;
}

int main() {
    string input;
    cin >> input;
    tokenize(input);
    cout << minimized_value();
    return 0;
}

BOJ 11399 - ATM 문제풀이

훈개발자 — Sun, 5 Apr 2020 20:12:26 +0900

문제를 읽고 이해하기

인하은행에는 ATM이 1대밖에 없다. 지금 이 ATM앞에 N명의 사람들이 줄을 서있다. 사람은 1번부터 N번까지 번호가 매겨져 있으며, i번 사람이 돈을 인출하는데 걸리는 시간은 Pi분이다.

사람들이 줄을 서는 순서에 따라서, 돈을 인출하는데 필요한 시간의 합이 달라지게 된다. 예를 들어, 총 5명이 있고, P1 = 3, P2 = 1, P3 = 4, P4 = 3, P5 = 2 인 경우를 생각해보자. [1, 2, 3, 4, 5] 순서로 줄을 선다면, 1번 사람은 3분만에 돈을 뽑을 수 있다. 2번 사람은 1번 사람이 돈을 뽑을 때 까지 기다려야 하기 때문에, 3+1 = 4분이 걸리게 된다. 3번 사람은 1번, 2번 사람이 돈을 뽑을 때까지 기다려야 하기 때문에, 총 3+1+4 = 8분이 필요하게 된다. 4번 사람은 3+1+4+3 = 11분, 5번 사람은 3+1+4+3+2 = 13분이 걸리게 된다. 이 경우에 각 사람이 돈을 인출하는데 필요한 시간의 합은 3+4+8+11+13 = 39분이 된다.

줄을 [2, 5, 1, 4, 3] 순서로 줄을 서면, 2번 사람은 1분만에, 5번 사람은 1+2 = 3분, 1번 사람은 1+2+3 = 6분, 4번 사람은 1+2+3+3 = 9분, 3번 사람은 1+2+3+3+4 = 13분이 걸리게 된다. 각 사람이 돈을 인출하는데 필요한 시간의 합은 1+3+6+9+13 = 32분이다. 이 방법보다 더 필요한 시간의 합을 최소로 만들 수는 없다.

줄을 서 있는 사람의 수 N과 각 사람이 돈을 인출하는데 걸리는 시간 Pi가 주어졌을 때, 각 사람이 돈을 인출하는데 필요한 시간의 합의 최솟값을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 사람의 수 N(1 ≤ N ≤ 1,000)이 주어진다. 둘째 줄에는 각 사람이 돈을 인출하는데 걸리는 시간 Pi가 주어진다. (1 ≤ Pi ≤ 1,000)

출력

첫째 줄에 각 사람이 돈을 인출하는데 필요한 시간의 합의 최솟값을 출력한다.

재정의와 추상화

처음 이 문제를 DFS로 접근하려고 했으나, 문제를 제대로 다시 읽어보니 각 사람이 돈을 인출하는 시간을 오름차순으로 정렬하면 그 순서가 바로 필요한 시간의 합의 최솟값을 구하는 것이다.

왜냐하면 오름차순으로 정렬할 경우 본인 순서의 앞에 있는 사람들은 항상 최소 시간이 걸리기 때문이다. (오름차순의 특징)

코드 작성

#include <iostream>
#include <queue>
#include <algorithm>
using namespace std;

int main() {
    int n;
    int arr[1000];
    int result = 0;
    cin >> n;

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

    sort(arr, arr + n);

    for (int i = 0; i < n; i++) {
        for (int k = 0; k <= i; k++) {
            result += arr[k];
        }
    }
    cout << result;
    return 0;
}

BOJ 11047 - 동전 0 문제풀이

훈개발자 — Sun, 5 Apr 2020 19:37:45 +0900

문제를 읽고 이해하기

준규가 가지고 있는 동전은 총 N종류이고, 각각의 동전을 매우 많이 가지고 있다. 동전을 적절히 사용해서 그 가치의 합을 K로 만들려고 한다. 이때 필요한 동전 개수의 최솟값을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N과 K가 주어진다. (1 ≤ N ≤ 10, 1 ≤ K ≤ 100,000,000) 그리고 둘째 줄부터 N개의 줄에 동전의 가치 Ai가 오름차순으로 주어진다. (1 ≤ Ai ≤ 1,000,000, A1 = 1, i ≥ 2인 경우에 Ai는 Ai-1의 배수)

출력

첫째 줄에 K원을 만드는데 필요한 동전 개수의 최솟값을 출력한다.

재정의와 추상화

2020/03/27 - [알고리즘/문제풀이] - BOJ 2293 - 동전 1 문제풀이

BOJ 2293 - 동전 1 문제풀이

문제를 읽고 이해하기 n가지 종류의 동전이 있다. 각각의 동전이 나타내는 가치는 다르다. 이 동전을 적당히 사용해서, 그 가치의 합이 k원이 되도록 하고 싶다. 그 경우의 수를 구하시오. 각각의 동전은 몇 개라..

hoondev.tistory.com

이전에 풀이했던 동전 1 문제를 생각해보자. 동전 1 문제는 주어진 동전을 사용하여 K원을 만들 수 있는 모든 경우의 수를 구하는 문제고, 이 문제는 주어진 동전을 이용하여 K원을 만들 수 있는 경우 중 최소한의 동전을 사용하는 경우에서 사용한 동전의 개수를 구하는 문제이다.

비슷해 보이지만, 근본부터 다른 문제이다. 이 문제는 최솟값이라는 점이 포인트이다. 가장 적은 수의 동전을 사용하려면 주어진 K원보다 작거나 같은 값을 가지는 동전 중에서 가장 큰 값을 가지는 동전부터 차례대로 사용하는 것이다. 따라서 이 문제는 그리디(탐욕법) 알고리즘을 사용한 문제이다.

문제 이해만 하면 코딩은 간단하다. 필자는 우선순위 큐(priority_queue)를 이용하여 큰 값을 가지는 동전부터 사용하도록 구현하였다. (생각해보니 입력이 오름차순으로 주어지니 그냥 배열로 선언해도 될 것 같..네요)

코드 작성

#include <iostream>
#include <queue>
using namespace std;

priority_queue<int> pq;

int main() {
    int count = 0;
    int n, k;
    cin >> n >> k;

    for (int i = 0; i < n; i++) {
        int temp;
        cin >> temp;
        if (temp <= k)
            pq.push(temp);
    }

    while (k != 0) {
        int now_coin = pq.top();
        if (now_coin > k) {
            pq.pop();
            continue;
        }
        k -= now_coin;
        count++;
    }
    cout << count;
    return 0;
}

BOJ 7569 - 토마토 문제풀이

훈개발자 — Sun, 5 Apr 2020 19:08:14 +0900

문제를 읽고 이해하기

철수의 토마토 농장에서는 토마토를 보관하는 큰 창고를 가지고 있다. 토마토는 아래의 그림과 같이 격자모양 상자의 칸에 하나씩 넣은 다음, 상자들을 수직으로 쌓아 올려서 창고에 보관한다.

창고에 보관되는 토마토들 중에는 잘 익은 것도 있지만, 아직 익지 않은 토마토들도 있을 수 있다. 보관 후 하루가 지나면, 익은 토마토들의 인접한 곳에 있는 익지 않은 토마토들은 익은 토마토의 영향을 받아 익게 된다. 하나의 토마토에 인접한 곳은 위, 아래, 왼쪽, 오른쪽, 앞, 뒤 여섯 방향에 있는 토마토를 의미한다. 대각선 방향에 있는 토마토들에게는 영향을 주지 못하며, 토마토가 혼자 저절로 익는 경우는 없다고 가정한다. 철수는 창고에 보관된 토마토들이 며칠이 지나면 다 익게 되는지 그 최소 일수를 알고 싶어 한다.

토마토를 창고에 보관하는 격자모양의 상자들의 크기와 익은 토마토들과 익지 않은 토마토들의 정보가 주어졌을 때, 며칠이 지나면 토마토들이 모두 익는지, 그 최소 일수를 구하는 프로그램을 작성하라. 단, 상자의 일부 칸에는 토마토가 들어있지 않을 수도 있다.

입력

첫 줄에는 상자의 크기를 나타내는 두 정수 M,N과 쌓아올려지는 상자의 수를 나타내는 H가 주어진다. M은 상자의 가로 칸의 수, N은 상자의 세로 칸의 수를 나타낸다. 단, 2 ≤ M ≤ 100, 2 ≤ N ≤ 100, 1 ≤ H ≤ 100 이다. 둘째 줄부터는 가장 밑의 상자부터 가장 위의 상자까지에 저장된 토마토들의 정보가 주어진다. 즉, 둘째 줄부터 N개의 줄에는 하나의 상자에 담긴 토마토의 정보가 주어진다. 각 줄에는 상자 가로줄에 들어있는 토마토들의 상태가 M개의 정수로 주어진다. 정수 1은 익은 토마토, 정수 0 은 익지 않은 토마토, 정수 -1은 토마토가 들어있지 않은 칸을 나타낸다. 이러한 N개의 줄이 H번 반복하여 주어진다.

출력

여러분은 토마토가 모두 익을 때까지 최소 며칠이 걸리는지를 계산해서 출력해야 한다. 만약, 저장될 때부터 모든 토마토가 익어있는 상태이면 0을 출력해야 하고, 토마토가 모두 익지는 못하는 상황이면 -1을 출력해야 한다.

재정의와 추상화

> BOJ 7576 - 토마토 문제풀이

BOJ 7576 - 토마토 문제에서 토마토를 담는 박스가 3차원으로 바뀐 것 뿐이다.

코드 작성

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
using namespace std;

// m은 가로 칸의 수, n은 세로 칸의 수
int m, n, h;
int arr[101][101][101];
vector<tuple<int, int, int>> tomatoes_pos;
bool check[101][101][101];
int day = 0;

typedef struct {
    int z, y, x;
} Position;

Position pos[6] = {
        { -1, 0, 0 }  , { 1, 0, 0 },
        { 0, -1, 0 }, { 0, 0, -1 }, { 0, 1, 0 }, { 0, 0 , 1 }
};

bool isInside(int z, int y, int x) {
    return z >= 0 && y >= 0 && x >= 0 && z < h && y < n && x < m;
}

void bfs() {
    queue<pair<tuple<int, int, int>, int>> q;
    for (auto & tp : tomatoes_pos) {
        q.push({tp, 0});
        check[get<0>(tp)][get<1>(tp)][get<2>(tp)] = true;
    }

    while (!q.empty()) {
        auto now = q.front();
        q.pop();

        for (auto & p : pos) {
            int next_z = get<0>(now.first) + p.z;
            int next_y = get<1>(now.first) + p.y;
            int next_x = get<2>(now.first) + p.x;

            if (isInside(next_z, next_y, next_x) && !check[next_z][next_y][next_x] && arr[next_z][next_y][next_x] == 0) {
                q.push({{next_z, next_y, next_x}, now.second + 1});
                day = max(now.second + 1, day);
                arr[next_z][next_y][next_x] = true;
            }
        }
    }
}

int main() {
    cin >> m >> n >> h;

    for (int k = 0; k < h; k++) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                cin >> arr[k][i][j];
                if (arr[k][i][j] == 1)
                    tomatoes_pos.push_back({k, i, j});
            }
        }
    }
    bfs();
    for (int k = 0; k < h; k++) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (!check[k][i][j] && arr[k][i][j] == 0) {
                    return !(cout << -1);
                }
            }
        }
    }
    cout << day;
    return 0;
}

BOJ 7576 - 토마토 문제풀이

훈개발자 — Sun, 5 Apr 2020 18:32:05 +0900

문제를 읽고 이해하기

철수의 토마토 농장에서는 토마토를 보관하는 큰 창고를 가지고 있다. 토마토는 아래의 그림과 같이 격자 모양 상자의 칸에 하나씩 넣어서 창고에 보관한다.

창고에 보관되는 토마토들 중에는 잘 익은 것도 있지만, 아직 익지 않은 토마토들도 있을 수 있다. 보관 후 하루가 지나면, 익은 토마토들의 인접한 곳에 있는 익지 않은 토마토들은 익은 토마토의 영향을 받아 익게 된다. 하나의 토마토의 인접한 곳은 왼쪽, 오른쪽, 앞, 뒤 네 방향에 있는 토마토를 의미한다. 대각선 방향에 있는 토마토들에게는 영향을 주지 못하며, 토마토가 혼자 저절로 익는 경우는 없다고 가정한다. 철수는 창고에 보관된 토마토들이 며칠이 지나면 다 익게 되는지, 그 최소 일수를 알고 싶어 한다.

입력

첫 줄에는 상자의 크기를 나타내는 두 정수 M,N이 주어진다. M은 상자의 가로 칸의 수, N은 상자의 세로 칸의 수를 나타낸다. 단, 2 ≤ M,N ≤ 1,000 이다. 둘째 줄부터는 하나의 상자에 저장된 토마토들의 정보가 주어진다. 즉, 둘째 줄부터 N개의 줄에는 상자에 담긴 토마토의 정보가 주어진다. 하나의 줄에는 상자 가로줄에 들어있는 토마토의 상태가 M개의 정수로 주어진다. 정수 1은 익은 토마토, 정수 0은 익지 않은 토마토, 정수 -1은 토마토가 들어있지 않은 칸을 나타낸다.

출력

여러분은 토마토가 모두 익을 때까지의 최소 날짜를 출력해야 한다. 만약, 저장될 때부터 모든 토마토가 익어있는 상태이면 0을 출력해야 하고, 토마토가 모두 익지는 못하는 상황이면 -1을 출력해야 한다.

재정의와 추상화

익은 토마토가 하나가 아닐 수도 있기 때문에 여태껏 BFS를 하던 것 처럼 특정 위치((0, 0)과 같은)에서만 시작하면 안됩니다.

main()에서 창고에 있는 토마토의 상태를 받을 때, 토마토의 상태가 1인 경우(익은 토마토) 그 위치를 tomatoes_pos 라는 이름의 벡터에 담아둡니다. 그리고, 처음 BFS 함수를 진입할 때 처음 익은 토마토가 있는 위치를 모두 큐(Queue)에 담아둡니다.

그 이후, 순서대로 큐에 있는 원소를 꺼내면 익은 토마토가 있는 모든 위치에서 각각 BFS를 시행할 수 있습니다.

코드 작성

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <utility>
using namespace std;

// m은 가로 칸의 수, n은 세로 칸의 수
int m, n;
int arr[1001][1001];
vector<pair<int, int>> tomatoes_pos;
bool check[1001][1001];
int day = 0;

typedef struct {
    int y, x;
} Position;

Position pos[4] = { { -1, 0 }, { 0, -1 }, { 1, 0 }, { 0 , 1 } };

bool isInside(int y, int x) {
    return y >= 0 && x >= 0 && y < n && x < m;
}

void bfs() {
    queue<pair<pair<int, int>, int>> q;
    for (auto & tp : tomatoes_pos) {
        q.push({tp, 0});
        check[tp.first][tp.second] = true;
    }

    while (!q.empty()) {
        auto now = q.front();
        q.pop();

        for (auto & p : pos) {
            int next_y = now.first.first + p.y;
            int next_x = now.first.second + p.x;

            if (isInside(next_y, next_x) && !check[next_y][next_x] && arr[next_y][next_x] == 0) {
                q.push({{next_y, next_x}, now.second + 1});
                day = max(now.second + 1, day);
                arr[next_y][next_x] = true;
            }
        }
    }
}

int main() {
    cin >> m >> n;

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> arr[i][j];
            if (arr[i][j] == 1)
                tomatoes_pos.push_back({i, j});
        }
    }

    bfs();

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (!check[i][j] && arr[i][j] == 0) {
                return !(cout << -1);
            }
        }
    }
    cout << day;
    return 0;
}

알고리즘 공부 계획 4/5 ~ 4/10

훈개발자 — Sun, 5 Apr 2020 17:52:05 +0900

공부 계획

기초 알고리즘 학습 계획을 바탕으로, 코딩테스트 주류 문제들을 모두 풀어보는 것을 목표로 한다.

4월 5일	~~BOJ 7576, 7569, 11047, 11399 문제 풀고 분석하기~~ (완료)
4월 6일	~~BOJ 2565, 9251, 1541, 1436 문제 풀고 분석하기~~ (완료)
4월 7일	~~BOJ 1654, 1712, 2869, 7568, 2580 문제 풀고 분석하기~~ (완료)
4월 8일	~~BOJ 12865, 2292, 10250, 3053 문제 풀고 분석하기~~ (완료)
4월 9일	~~BOJ 2206, 14888, 2798, 2231, 1193 문제 풀고 분석하기~~ (완료)
4월 10일	~~BOJ 2775, 2751, 10989, 2108, 11650, 11651, 10814, 10816~~, 11066 (부분완료)

hoonDEV

Angular에서 Tailwind CSS 사용해보기

Angular 프로젝트에 Tailwind CSS 도입하기

설치 방법

사용 방법

Pre-flight

제목, 인용 부호, 단락 등과 같은 요소에 기본 margin이 제거됩니다.

제목(h1, h2..) 태그에 스타일이 없습니다.

리스트 태그에 스타일이 없습니다.

이미지는 block입니다.

테두리 스타일들을 전역적으로 재설정합니다.

커스터마이징

Pre-flight Extension

tailwind.config.js

References

Angular 의존성 주입 - (4) 선택적 의존성 주입

선택적 의존성 주입

Angular 서비스 주입 - (3) 인젝션 토큰

인젝션 토큰

Angular 의존성 주입 - (2) 프로바이더 (Provider)

프로바이더 (Provider)

프로바이더 사용 방법

프로바이더의 종류

값 프로바이더

팩토리 프로바이더

Angular 의존성 주입 - (1) 서비스

서비스 (Service)

사용하는 이유

코드

@Injectable 데코레이터

서비스를 컴포넌트에서 사용하기

JavaScript에서의 this와 this 바인딩

흔한 객체지향 언어에서의 this

JavaScript에서의 this

그냥 함수를 호출했을 때의 this

일반 함수의 내부 함수에서의 this

메소드의 내부 함수에서의 this

생성자 함수를 호출했을 때 this

콜백함수에서의 this

this 바인딩

apply

call

bind

브라우저의 렌더링 원리

브라우저의 구성 요소

렌더링 엔진이란?

렌더링 엔진의 종류

렌더링 엔진의 동작 과정

HTML5에서의 Sementic Tag(시맨틱 태그)

Sementic Tag란?

Sementic Tag 종류

ES6에서 Arrow Function 사용하기

관련 포스트

Arrow Function의 특징

Arrow Function 사용하기

매개변수가 없을 때

매개변수가 1개일 때

매개변수가 2개 이상일 때

함수 Body

한 줄의 구문만 있는 경우

Arrow Function 호출하기

Arrow Function 콜백 함수로 전달하기

중요 Arrow Function에서의 this

일반 함수에서의 this

Arrow Function에서의 this

Arrow Function을 사용해서는 안되는 경우

메소드 정의로 사용하는 경우

prototype의 메소드

생성자 함수

참고문서

ES6에서 let/const로 Block-scoped 변수 선언하기

관련 포스트

변수의 Block-scoped 선언

let

const

JavaScript에서 var를 사용하면 안되는 이유

var

호이스팅?

그래서 var의 문제점은..?

변수의 중복 선언이 가능하다.

`중요` Arrow Function에서의 this