바위타는 두루미

[CleanCode]10.클래스

DoRoMii — Thu, 10 Mar 2022 01:38:39 +0900

코드의 표현력과 그 코드로 이루어진 함수에 아무리 신경을 쓰더라도 더 높은 차원의 단계까지 신경쓰지 않으면 깨끗한 코드를 얻기 어렵다. 이 장에서는 깨끗한 클래스에 대해 다룬다.

- 클래스 체계

- 자바의 경우 정적공개상수 -> 정적 비공개상수 ->비공개 인스턴스변수 ( 공개 변수가 필요한 경우는 거의 없음 ) 순으로 나오고

- 변수 다음에는 공개함수, 비공개함수는 자신을 호출하는 공개 함수 직후에 넣는다.

- 캡슐화

- 변수와 유틸함수는 공개하지 않는 편이 낫지만, protected로 선언해 테스트 코드에 접근을 허용하기도함.

- 클래스는 작아야 한다.

- 얼마나 작아야하는가 ? -> 클래스가 맡은 책임을 센다.

- 클래스 이름은 그 클래스의 책임을 기술해야하고 간결해야한다 ( 책임의 크기가 작도록 )

- SRP (단일 책임 원칙)은 클래스나 모듈을 변경할 이유가 하나뿐이어야한다.

- 큰 클래스 몇개가 아니라 작은 클래스 여럿으로 이루어진 시스템이 바람직하다.

- 응집도

- 일반적으로 메서드가 변수를 더 많이 사용할 수록 메서드와 클래스의 응집도가 높다.

- 때떄로 몇몇 메서드만이 사용하는 인스턴스 변수가 많아지면 -> 클래스로 쪼개야한다는 신호다

- 변경하기 쉬운 클래스

- SRP 뿐만아니라 OCP(Open-closed Principle )도 지원해야한다. : 확장에 개방적이고 수정에 폐쇄적

- 새 기능을 수정하거나 변경할때 건드릴 코드가 최소인 시스템이 바람직하다.

- 변경으로부터 격리

- 상세한 구현에 의존하는 코드는 테스트가 어렵다.

- 시스템의 결합도를 낮추면 유연성과 재사용성도 높아진다.

- 결합도가 낮다는 것은 각 시스템 요소가 다른 요소로부터 그리고 변경으로부터 잘 격리되어있다는 의미다.

- 결합도를 낮추면 DIP(Dependency Inversion Principle)을 따르는 클래스가 나온다. : 상세 구현 보다추상화에 의존하자

[CleanCode]9.단위테스트

DoRoMii — Sun, 6 Mar 2022 00:00:27 +0900

TDD 법칙 세가지

1. 실패하는 단위 테스트를 작성할 때까지 실제 코드를 작성하지 않는다.

2. 컴파일은 실패하지 않으면서 실행이 실패하는 정도로만 단위테스트를 작성한다.

3. 현재 실패하는 테스트를 통과할 정도만 실제 코드를 작성한다.

=> 이렇게 일하면 테스트케이스가 너무많아지고, 많은 테스트케이스는 관리 문제를 유발하기도 한다.

깨끗한 테스트 코드 유지하기.

- 지저분한 테스트 코드일수록 실제 코드가 변경할때 함께 변화하기 어렵다.

테스트는 유연성, 유지보수성, 재사용성을 제공한다.

- 이를위해서는 단위테스트가 필요하다. 단위테스트가 없다면 수정이 두렵다.

깨끗한 테스트코드란 ?

- "가독성"

- 테스트는 명확히 세부분으로 나뉨 : 테스트자료를 만들기 -> 테스트자료 조작하기 -> 결과가 올바른지 확인하기

- 테스트에 적용하는 표준은 실제코드에 적용하는 표준과 달라도된다.

- 실제코드만큼 효율적일 필요는 없다.

테스트당 assert 하나!

- 가혹하다 느낄 수 있지만, 결론이 하나이기 때문에 코드를 이해하기 좋다.

- 즉, 테스트 함수마다 한 개념만 테스트하라

F.I.R.S.T

- Fast : 테스트는 빨라야 한다.

- Independent : 각 테스트는 의존성이 없어야한다. 어떤 순서로 실행해도 괜찮아야 한다.

- Repeatable : 어떤 환경에서도 반복 가능하도록! 네트워크 없는 환경에서도 !

- Self-Validating : 테스트는 bool로 결과를 내서 스스로 성공과 실패를 가늠하도록 해야한다.

- Timely : 적시에, 즉 테스트하려는 실제 코드를 구현하기 직전에 구현한다.

[CleanCode]7.오류처리

DoRoMii — Thu, 3 Mar 2022 23:06:13 +0900

오류처리 때문에 프로그램의 논리를 이해하기 어렵다면 그것은 깨끗한 코드가 아니다.

-오류코드보다 예외를 사용하라.

- Try-Catch-Finally 문부터 작성하라

강제로 예외를 일으키는 테스트 케이스를 작성한 후 테스트를 통과하게 코드를 작성하는 방법을 권장한다.

- 미확인 예외를 사용하라.

확인된 예외는 OCP를 위반한다. 하위단계에서 코드를 변경하면 상위단계 메서드 선언부를 전부 고쳐야한다.

아주 중요한 라이브러리를 작성한다면 확인된 예외를 이용해 모든 예외를 잡아야하지만, 일반적인 어플리케이션은 의존성이라는 비용이 매우크다.

- 예외의 의미를 제공하라.

-예외를 던질때에는 정보를 담아 예외와 함께 던지자.

- 실패한 연산 이름과 실패 유형도 언급한다.

- logging을 사용한다면 catch블록에서 오류를 기록하도록 정보를 넘겨준다.

- 호출자를 고려하여 예외 클래스를 정의하라.

- 오류를 분류할때 가장 중요한 관심사는 오류를 잡아내는 방법

- 외부라이브러리의 예외를 설정할때 감싸는 class는 매우 유용하다.

- 외부 라이브러리에 대한 의존성이 줄어든다.

- 예외 클레스가 한개만 있어도 충분한 코드가 많다.

- 정상흐름을 정의하라

예외상황을 처리할 필요가 없도록 클레스나 객체가 예외적인 상황을 캡슐화해서 처리하도록 하면 더 깔끔

- null을 반환하지 마라

- null을 반환하면 null체크 누락시 큰 문제가 발생한다.

- null을 반환하고 싶다면 예외를 던지거나 특수사례 객체를 반환하도록 하자.

- null을 전달하지 마라.

- null을 전달할 가능성이 있으면 애초에 넘기지 못하도록 정책을 만드는게 나을 수 있다.

- exception class를 만든다.

- assert를 이용한다.

[CleanCode]6.객체와 자료구조

DoRoMii — Wed, 2 Mar 2022 01:19:08 +0900

단순히 get, set함수를 만들어 변수를 다룬다고 class가 아니다.

그보다는 추상 인터페이스를 이용해 사용자가 구현을 모른 채 자료의 핵심을 조작할 수 있어야 진정한 의미의 class이다.

객체 vs 자료구조

- 자료구조를 사용코드 : 자료구조 변경없이 새 함수를 추가하기 쉽다. | 함수 변경없이 새로운 자료구조 추가하기 어렵다.

- 객체지향 코드 : 함수 변경없이 class 추가하기 쉽다. | class변경없이 새로운 함수 추가하기 어렵다.

- 분별있는 프로그래머는 모든 것이 객체라는 생각이 미신임을 잘 안다. 때로는 단순한 자료구조와 절차적인 코드가 적합한 상황이 있다.

디미터 법칙

-> 모듈은 자신이 조작하는 객체의 속사정을 몰라야한다.

클레스 C의 메서드 f는 다음과 같은 객체의 메서드만 호출해야한다.

( Class C, f가 생성한 객체, f인수로 들어온 객체, C인스턴스 변수에 저장된 객체 )

ex) final String outputDir = ctxt.getOptions().getScratchDir().getAbsolutePath() => (X)

=> 위와 같은 코드를 기차충돌이라고 부른다. 피하는편이 좋다.

Option opts = ctxt.getOptions();

File scratchDir = opts.getScratchDir();

final String outputDir = scratchDir.getAbsolutePath();

=> 이렇게 나누는 편이 좋다.

하지만 ctxt, Options, ScratchDir이 객체라면 내부구조를 숨겨야 하므로 디미터 규칙을 위반한다.

자료구조라면 디미터 법칙이 적용되지 않는다.

조회함수를 사용하는 바람에 혼란을 일으킨다.

fianl String outputDir = ctxt.options.scratchDir.absolutePath; 이렇게 구현되었다면 디미터 법칙을 거론할 필요가 없다.

- 잡종 구조

반은 객체, 반은 자료구조인 잡종 구조가 나온다. 이러한 잡종구조는 함수는 물론 새로운 자료구조도 추가하기 어렵다. 따라서 피해야한다. - 구조체 감추기

만약 ctxt, options, scratchDir이 모두 객체라면 outputDir 경로는 어떻게 얻어야 할까

ctxt가 객체라면 뭔가를 하라고 말해야지, 속을 드러내면 안된다.

ctxt에게 임시 파일을 생성하라고 말하자 ctxt.crateScratchFileStream(classFileName)이런식으로

자료 전달 객체

- 자료구조체 : 공개 변수만 있고 함수가 없는 클레스 => Data Transfer Object (DTO) 라고 하기도 함

- Bean 구조 : 비공개 변수를 조회/설정 함수로 조작한다. => 특별한 이익을 제공하진 않는다.

- 활성 레코드 : 공개 변수가 있거나 비공개 변수에 조회/설정 함수가 있지만, save나 find같은 탐색함수도 제공한다.

활성 레코드에 비즈니스 코드를 추가하는 경우가 있지만, 이는 바람직하지 않음.

[CleanCode] 5. 형식맞추기

DoRoMii — Tue, 1 Mar 2022 03:08:02 +0900

형식을 맞추는 일은 매우 중요하다

기능은 바뀌더라도, 맨 처음 잡아둔 구현 스타일과 가독성수준은 유지보수 용이성과 확장성에 계속 영향을 미친다.

좋은 형식은 무엇일까?

1. 적절한 행길이를 유지하라

- 큰 파일보다 작은 파일이 이해하기 쉽다.

- 신문기사처럼 작성하라 : 상단은 고차원 , 하단으로 갈수록 저차원 (세부구현)

- 개념은 빈 행으로 분리하라

- 수직거리 : 밀접한개념은 세로로 가까이 두어야한다.

- 변수는 사용하는 위치에 최대한 가까이 선언한다.

- 인스턴스 변수는 모아라 : 자바는 상단에, c++는 하단에 선언하는 편

- 종속함수 : 함수가 다른함수를 호출한다면 두 함수는 세로로 가까이, 가능하다면 호출하는 함수가 먼저!

- 개념적 유사성이 높으면 가까이

2. 가로형식 맞추기

- 짧은 행이 선호되지만, 저자는 개인적으로 120자 정도의 행길이를 제한한다.

- 공백을 사용해 밀접한 개념과 느슨한 개념을 표현

- 들여쓰기

- 들여쓰기를 무시하고 싶은 상황(짧은 조건문, 짧은 함수) 에서도 들여쓰기!

- 빈 while이나 for문의 경우 세미콜론은 새 행에 제대로 들여써주기

3. 팀규칙

[CleanCode]4.주석

DoRoMii — Thu, 24 Feb 2022 16:22:44 +0900

주석은 코드로 의도를 표현하지 못해서 사용하므로 실패이다.

주석은 거짓말을 하는 경우가 많다.

진실은 오직 code!

그럼 좋은 주석은?

1. 법적인 주석 : file 첫머리에 저작권정보와 소유권정보 ->Good

2. 의미를 명로하게 밝히는 주석 : 인수나 반환값이 표준 라이브러리나 변경하지 못하는 코드에 속한다면 의미를 명료하게 밝히는 주석이 유용하다.

3. 경고하는 주석

4. todo주석

느낀점

- 이 책에서 말하는 나쁜 주석들은

이제는 형상관리툴로 커버가 가능한 부분들이고, 책 앞부분에 언급된 대로 함수를 쪼개고 이름을 잘 짓는 것 만으로도 없앨수 있는 부분들이 매우 큰 것 같다. 가능하다면 최대한 작성하지 않도록 하는것, 이전에 주석들은 이제는 다른 적절한 방법들로 개선하는 부분이 필요해 보인다.

[CleanCode]3.함수

DoRoMii — Tue, 22 Feb 2022 02:15:59 +0900

좋은 함수를 만드는 법

1. 작게만들기

- if/else문 , while문 등에 들어가는 블록은 한줄이여야한다.

- 장점 : 바깥을 감싸는 함수가 작아지고, 함수명이 적절하다면 코드 이해도 쉽다.

2. 한가지만 하기

- 함수가 한가지만 하는지 확인하는 방법

- 추상화 수준이 1개인지

- 의미있는 이름으로 다른함수를 추출할 수 있다면 그것은 여러작업을 하고있다!

- 섹션으로 나뉘어지는지 확인

3. 함수의 추상화 수준은 하나로!

- 이유 : 근본개념인지 세부사항인지 알기 어렵고, 사람들이 세부사항을 점점 더 추가한다.

- 코드는 위에서 아래로 읽히도록, 아래로 갈수록 추상화 수준을 낮추기

4. Switch문

- switch문은 길고, 본질적으로 여러작업을함

- 꼭 써야한다면 추상 factory에 꽁꽁숨겨서 단 한번만 사용하도록

5. 서술적인 이름을 사용하라

- 길어도 겁먹지 말고, 서술적으로 작성

- 일관성있는 서술어를 사용하기

6. 함수 인수

- 이상적인 인수는 0

- 단항형식

- 인수로 질문을 던지는 경우 bool fileExists("MyFile") = > O

- 인수로 인해 상태를 바꾸는 이벤트 => O

- 그외는 가급적 피하기, 특히 void transform(Stringbuffer out) 금지 ! (출력인자를 넘기는것)

- 플레그 인수 -> 끔찍 : 이미 여러가지를 한다는 의미! ( true면 A , False면 B를 한다는 것 )

- 이항 함수

- 자연적인 순서가 있는 경우엔 인정 ex) Point(0,0)

- 그 외에는 혼란을 줄 수 있음

- 삼항 함수

- 마찬가지로, 그만한 가치가 있는 경우엔 인정 ex ) assertEquals (1.0, amount, .001)

- 인수 객체 : 차라리 여러개의 인수가 필요하다면 객체로 넘기는것이 개념을 표현하기 때문에 더 낫다

- 같은 함수명의 다양한 인수를 갖는 여러개의 함수 -> 필요한 경우도 있음 But 3항을 넘기지 말것

- 동사와 키워드 : 동사, 명사를 잘 정하고, 키워드를 추가하여 인수 순서를 기억하지 않아도 되도록 할 수도 있음.

7.부수 효과를 일으키지 마라

- 한가지만 하는것 처럼 보이지만 숨겨진 부수효과를 꼭 체크하기

8.명령과 조회를 분리하라

9.오류코드보다 예외를 사용하라

- 예외를 사용할때 try/catch는 본래 추하기 때문에, 별도의 함수로 뽑아내는 것이 좋다.

- 오류처리할때도 한가지만 작업해야한다. 오류만! 처리하기

- enum으로 error코드를 지정하고 사용하면, 의존성도 높고 새 enum추가시 재컴파일 해야하지만, 예외를 사용하면 새로운 예외는 Exception클레스에서 파생되어서 더 낫다.

10. 반복하지 마라

11. 구조적 프로그래밍

- 구조적 프로그래밍 : 함수내 모든 입구와 출구가 하나여야한다 , loop에서 break, continue사용 X, goto 금지

- 하지만 함수가 작다면 별 이익을 제공하지 못함

그럼 함수를 어떻게 짜야되나요?

- 처음에는 길고 복잡하게 짜고, testcase를 만든 후 점차 다듬기 (testcase는 통과해야함)

[CleanCode 정리] 2.의미있는 이름

DoRoMii — Sun, 20 Feb 2022 21:31:58 +0900

기억하고 싶은 내용

Naming 이름지을때 생각해보아야 할 규칙

- 의도를 분명히 하기. thelist ( X) , gameBoard (O)

-그릇된 정보를 피하기

- 개발시 이용하는 용어 주의하기 List가 아닌데 List사용 X

- 흡사한 이름 사용하지 않기 - 한눈에 보기 어려운 이름

- 의미있게 구분하기 : 컴파일러만 통과하는 코드는 x

- 연속적인 숫자를 추가하는경우 : 의미없는 이름

- 두 변수가 구분이 안되는 경우 ~Data, ~Info => 구분하기 어렵다

- 발음하기 쉬운 이름 사용하기

- 검색하기 쉬운 이름

- 이름길이는 범위크기에 비례해야한다.

-인코딩을 피하라

- 타입표기할 필요없다.

- 접두어 붙일 필요없다. -> 클래스, 함수는 작아져야하고, 멤버변수를 다른 색상으로 표시하는 IDE를 사용해야 마땅함.

- 인터페이스클레스의 경우에는 구체클레스에 접두어 또는 접미어를 붙이는 것이 낫다 ~Imp, C~

-자신의 기억력을 자랑하지 마라

- 클레스 이름 : 명사나 명사구 | but Manager, Processor, Data, Info 단어 피하고 , 동사는 사용하지 않는다.

ex ) Customer, AddressParser

- 메서드 이름 : 동사나 동사구 | 접근자, 변경자, 조건자는 get, set, is를 붙인다

ex) postPayment, deletePage, save

* 생성자를 중복 정의할때는 정적 펙토리 메서드를 이용한다.

ex) Complex fulcrumPoint = Complex.FromRealNumber(23.0) (O)

Complex fulcrumPoint = new Complex(23.0) (X)

- 한개념에 한단어 사용하기

ex ) 똑같은 메서드를 class에 따라 fetch, retrieve, get 으로 사용 X

비슷한 코드 기반에 controller, manager, driver을 섞어쓰면 혼란

- 한 단어를 두가지 목적으로 사용하지 마라

ex ) 두개를 더해서 새로운 값을 만드는 것 : add , 다른 숫자 한개를 더하는것 : add =>X

- 해법용어 (전산용어, 알고리즘이름, 패턴, 수학 용어)를 사용하는것 추천

- 문제 영역과 관련이 깊다면 문제 영역의 용어를 사용해도 됨

- 의미있는 맥락을 추가하라

오늘 읽은 소감

대부분의 내용은 상식선으로 알고 있었지만 의외의 조언들이 있어서 신기했다.

- 멤버변수에 접두어를 붙일 필요없다. 대신 멤버변수를 다른 색상으로 표시하는 IDE를 사용해야 마땅하다는 사실

- Data, Info 를 주의하자

- 이름 길이는 범위에 비례하도록 하자.

[ 2012,Alexnet] ImageNet Classification with Deep ConvolutionalNeural Networks 논문 리뷰

DoRoMii — Sat, 15 May 2021 18:07:22 +0900

오늘 리뷰해볼 논문은 2012년에 Alex Krizhevsky 님께서 작성한 "ImageNet Classification with Deep ConvolutionalNeural Networks " 입니다. 저자의 이름을 따서 AlexNet으로 더 유명한 CNN 네트워크 구조를 소개하고 있습니다.

[Abstract]

- ILSVRC 대회는 약 1.2million 고해상도 이미지를 1000개의 class로 분류해 내는 대회인데, 2010년 대회기준 test set에서 top-1, top-5 error rate이 각각 37.5%, 17.0%로 앞선 SOTA보다 확실히 더 나은 성적을 갖는 neural network를 구성함.

- 그 neural network는 60 milion 파라미터랑 650,000 뉴런을 으로 구성되어있는데, 네트워크 구성은 5개의 CNN 레이어(일부 레이어는 max pooling 적용)와 3개의 Fully connected 레이어(마지막은 1000class에 대한 softmax 연산 적용)로 되어 있음.

- 학습을 빠르게 하기 위해 non-saturating neuron ( non-saturationg 되는 activation function (ReLU) ) 를 적용하고, GPU로 연산할 수 있도록 구현함.

- overfitting을 방지하기 위해서 FC(fully connected)레이어에 dropout 기법을 적용함.

- 결국 ILSVRC 2012대회에서 top-5 error를 15.3%로 달성하며 2위인 26.2%와 상당한 격차로 1등을 차지함.

[ 1. Introduction ]

Machine learning method 에서 성능을 높이기 위해서는 1. 많은 dataset이 필요하고 , 2. 강력한 모델로 학습시키고 , 3. overfitting을 방지하기 위한 기술을 적용해야한다.

- 큰 dataset의 등장

이전에는 공개된 데이터셋의 양도 많지 않은 편이였고, 인식 task도 간단한 편이였으나 실제 물체를 인식하려고 했을때에는

variability가 크기( 형체나 모습이 다양함 )때문에 더 큰 데이터셋이 필요했는데 최근 LabelMe 나 ImageNet 과 같은 방대한 데이터셋이 등장하고 사용할 수 있게 되었다.

- CNN

큰 데이터셋을 학습시켜도 그 많은 지식을 가지고 있을만한 모델이 필요하다. CNN은 넓이나 깊이를 통해 모델의 크기를 조절할 수 있고,

stationarity of statistics and locality of pixel dependencies (이미지의 한 부분에 대한 통계가 어떤 다른 부분들과 동일하다는 특징 and 이미지를 구성하는 특징들은 이미지 전체가 아닌 일부 지역에 근접한 픽셀들로만 구성되고, 근접한 픽셀들끼리만 종속성을 가지는 특징

) 이라는 이미지의 특성을 잘 살려서 연산할 수 있다. 또한 일반적인 feed-forword (모든 픽셀이 각 node와 연결되어있는 형태)에 비해 연결이 적기 때문에 학습이 쉽다는 특징이 있다.

ref : https://seongkyun.github.io/study/2019/10/27/cnn_stationarity/

- GPU

gpu가 2d conv net 을 연산하기에 최적화되어 있고, 큰 CNN architecture를 학습시키기에 충분히 좋다.

따라서 이 논문의 주요 contribution은 다음과 같다.

1. 가장 큰 CNN architecture 구성했고 그 모델로 ILSVRC 2010, 2012 대회 기준 최고의 성적을 얻었다.

2. 2D convolution에 최적화한 GPU 연산을 구현했다.

3. 성능을 향상시키기 위한 기법과 학습 시간을 줄이기 위한 기법을 적용했다. -> section 3

4. overfitting을 방지하기 위한 기법을 적용했다. -> section 4

[ 2. The Dataset ]

ImageNet은 15 million장의 label된 고해상도 이미지와 약 22,000 categorie로 구성된 거대한 데이터 셋입니다.

ILSVRC 대회는 ImageNet데이터에서 각 카테고리당 약 1000장의 이미지를 갖는 1000개의 label에 대해서 classificaton을 하는 task에 대해 경쟁을 하는 대회입니다.

ImageNet 에서는 2개의 error rate을 이용해 구분을 합니다 : top-1 , top-5.

각 class 에 대한 confidence score을 sort했을때 가장 높은 score을 가진 1개의 class가 정답이 아닌경우의 비율 : top-1

상위 score에 대해서 5개의 class들 중 정답이 아닌 경우의 비율 : top-5 입니다.

ImageNet은 다양한 resolution을 갖는 이미지들이 있지만, 여기서는 256x256으로 down sampling을 진행해서 이미지를 사용했고.

직사각형 형태의 이미지는 짧은 쪽에 대해 256으로 맞추고 중앙을 기준으로 crop 하여 256x256으로 변환하여 사용했다고 한다.

픽셀 값에 대해서 평균값을 각 픽셀에 대해 빼주는 연산을 제외하고는 따로 preprocessing하지는 않았다고 한다.

[3. The Architecture ]

이 네트워크의 구조는 5개의 conv레이어와 3개의 fc레이어로 구성되어 있고, 이 구조를 이용해서 더 나은 성능과 빠른 학습 속도를 위해 적용한 기술들을 알아보자.

3.1 ReLU Nonlinearity

기존의 네트워크들은 전통적으로 sigmoid 나 tanh 함수를 이용하여 각 레이어의 Nonlinearity 를 부여했지만, 이 네트워크에서는 Relu라는 연산을 이용했다. Relu 는 f(x) = max(0,x) 형태를 띄며 기존에 saturating nonlinearity 방식이 아닌 양수에 대해서는 saturating하지 않는 특징을 갖으며, 학습속도가 매우 빠르다.

이 그래프는 CIFAR-10 데이터 셋을 4개의 conv 레이어로 구성된 네트워크로 실험한 것을 보여주는데, 이경우 error-rate 가 0.25에 도달하는데 Relu가 tanh에 비해 6배정도 빠름을 알 수 있습니다.

사실 여기서 처음으로 전통적인 activation fucntion이 아닌 새로운 방식을 도입한 것은 아니다. contrast nomalization과

local average pooling 과 함께 f(x) = | tanh(x) |를 적용해서 Caltech-101에 대해 잘 작동하도록 시도한 적이 있지만 이경우에는 overfitting을 막고자 하는게 주 목적이였고, 빠른 학습속도를 만들고자 하는 우리의 목적과는 다름을 알 수 있다. 빠른 학습속도는 큰 데이터셋을 큰 규모의 모델에서 학습시킬때 좋은 효과를 주기 때문입니다.

3.2 Training on Multiple GPUs

1개의 GTX 580 GPU 는 3GB of memory 뿐이기 때문에 모델의 최대 크기는 거기에 맞춰서 제한적일 수 밖에 없습니다.

1.2 milion 개의 뉴런들을 1개의 GPU에 맞추기에는 너무 많았고, 그래서 2개의 GPU로 나눠서 학습시키기로 했습니다.

또한 다른 GPU의 memory에 직접 읽고 쓸 수 있기때문에 GPU병렬화에 잘 맞았습니다.

그래서 전체 커널의 반씩 각 GPU 에서 연산할 수 있도록 나누었고, layer 3의 커널만 layer2의 모든(다른 GPU에 있는 것까지 포함한) output을 가지고 연산할 수 있도록 추가적인 기술을 첨가했습니다. 나머지는 같은 GPU에 있는 커널의 output만 가지고 연산합니다.

이 방식은 GPU 한개만 사용한 것에 비해 top-1 and top-5 error rated을 각각 1.7% 과 1.2% 감소시켰습니다.

[ 4.Reducing Overfitting ]

이어서,,,,

CS231n 한글 정리 | Lecture 3 | Loss Fuctions and Optimization ( Optimization , gradient )

DoRoMii — Thu, 5 Mar 2020 18:18:49 +0900

자, 그럼 이제는 어떻게 실제 Loss를 줄이는 W를 찾을 수 있는걸까요?

이 질문을 우리는 "최적화 (Optimization) " 라고 합니다.

최적화를 한다는 것은 우리가 다양한 산과 계곡이 있는 엄청 큰 골짜기를 걷고 있는 것입니다.

내가 위치하고 있는 곳의 높이가 Loss가 되는것이고 우리의 임무는 이 골짜기의 밑바닥을 찾는 것입니다.

하지만 이문제는 매우 어렵습니다. 그래서 우리는 다양한 iterative한 방법을 사용합니다.

가장 먼저 생각할 수 있는것은 "Random search(임의 탐색)" 입니다.

*매우 구린방법입니다.

CIFAR-10에서는 클래스가 10개니까 임의확률은 10%가 되고, 무작위 시행을 거치게 되면 약 15%의 정확도를 보이는군요.

최신 알고리즘의 성능 SOTA가 95%인것을 생각하면 매우 좋지 않죠.

두번째 방법은 "local geometry(기하학적 특성 이용하기)" 입니다.

우리는 발로 경사를 느끼고 어느 방향으로 가야 내려갈 수 있을지를 알 수 있을 것입니다.

경사를 느끼고 방향을 정하는 것을 계속 반복하다보면 골짜기를 다 내려갈 수 있을 것입니다.

이 방법은 우리가 NN이나 Linear Classifer같은 것은 훈련시킬때 일반적으로 사용합니다.

그렇다면 경사(slope)는 무엇일까요? 미분 수업이 기억나나요?

어떤 점 (x)에서 도함수(derivative)를 계산해보면 작은 스텝(h)가 있고 그 스탭간의 함수 차이를 비교하기 위해 뺄셈을 하고, 그 스텝사이즈를 0에 가깝게 만들면 이것이 바로 그 점(x)에서의 경사가 됩니다.

이 개념은 다변수함수(multi-variable function)로도 확장시킬 수 있습니다.

실제로 x는 스칼라가 아니라 벡터입니다. x가 벡터이기 때문에 이 개념을 다변수로 확장시켜야 합니다.

다변수인 상황에서 미분으로 일반화 시키면 gradient이고 gradient는 벡터 x의 각 요소를 편도함수들의 집합입니다.

입력이 3개면 gradient도 3개가 되겠죠.

그리고 이 gradient의 각 요소가 알려주는 것은 바로 "우리가 그쪽으로 갈때 함수 f의 경사가 어떤지" 일것입니다.

즉 gradient는 편도함수들의 벡터가 되고, 방향은 함수에서 "가장 많이 올라가는 방향"이 됩니다.

gradient의 방향이 반대가 되면 가장 많이 내려가는 방향이 되겠죠.

그렇다면 특정방향에서 얼마나 가파른지 알고싶으면 어떻게 해야할까요?

그것은 그 방향의 유닛벡터와 gradient벡터를 내적한 것과 같습니다.

gradient는 매우 중요합니다.

왜냐하면 gradient가 함수의 어떤 점에서의 선형 1차 근사 함수를 알려주기 때문입니다.

그래서 실제로 많은 딥러닝 알고리즘들이 gradient를 계산하고 파라미터 벡터를 반복적으로 업데이트 하는데에 사용합니다.

컴퓨터로 gradient를 유용하게 사용할 수 있는 방법은 유한 차분법(finite difference method)를 이용하는 것입니다.

다시 gradient의 극한식으로 돌아가봅시다.

왼쪽에 W가 있습니다 .이 W의 loss는 1.25정도 되는군요.

우리가 첫번째 요소에 아주작은값 h (0.0001)을 더해보고 loss를 구해봅시다. 그러면 1.24342에서 1.24322로 감소하는 군요.

이제 극한식을 이용하여 gradient를 구합니다.

이것을 각 요소마다 반복합니다

실제로는 시간이 매우 많이 걸리므로 매우 끔찍합니다.

하지만 우리는 미적수업을 들었으므로 미분이라는 마법을 이용하여 바로 gradient를 구할 수 있습니다.

아래와 같은 식으로 간단히 구할 수 있죠.

해석적으로 푸는 것이 수치적으로 푸는 것보다 더 효율적입니다. (물론 디버깅을위해 수치적으로 계산하는 방식이 쓰일 수는 있습니다.)

그럼 우리가 구한 gradient를 이용하여 gradient의 반대방향으로 업데이트를 하고 아주 조금씩 이동하여 결국 수렴할 것입니다!

하지만 스텝사이즈(이동하는 정도, learning rate)는 하이퍼파라미터입니다.

스텝사이즈를 올바르게 결정하는 것도 매우 중요한 문제입니다.

근데 앞으로 더 쩌는 스탭들을 볼 수 있을 것입니다.

기본은 gradient를 이용하는 것이지만 다음 스텝을 결정하기 위해서 이전의 모든 스탭의 gradient의 정보를 이용하는 방법들도 있습니다.

우리가 배워야할 한가지가 더 있습니다.

손실함수를 정의한 것을 다시 상기해보면, Loss를 구할때 전체 트레이닝셋 loss의 평균으로 사용했습니다.

하지만 실제로는 N이 매우 커질 수 있습니다. ImageNet 데이터 셋의 경우 N은 130만개입니다.

그러면 시간이 매우 걸리게 되겠죠.

gradient 계산하는 과정을 살펴보면 Loss는 그저 각 데이터 Loss의 Gradient의 합이라는 것을 알 수 있고, 그러니 N개의 전체 트레이닝셋을 한번 더 돌면서 계산해야하는 것입니다.

그래서 실제로는 stochastic gradient descent라는 방식을 사용합니다.

전체 데이터 셋의 gradient와 loss를 계산하기 보다는 Minibatch라는 작은 트레이닝 샘플로 나누어서 학습하는 방식입니다.

보통 2의 승수로 정하며 32,64,128로 쓰는편입니다.

그래서 이 작은 minibatch를 이용하여 Loss의 전체합의 추정치와 실제 gradient의 추정치를 계산하는 것입니다.

앞으로 이 더 간지나는 update rules들이 정확히 어떻게 여러 gradient들을 통합시키는지 알아보겠습니다.

또한 방금 설명한 SGD는 거의 모든 DNN알고리즘에 사용되는 기본적인 학습 알고리즘입니다.

사실 Linear Classifier는 이미지에서는 그리 좋은 방법은 아닙니다.

그래서 DNN이 유행하기 전에 Linear Classifier를 이용하기 위해서는 두가지 스테이지를 거쳐서 사용했습니다.

첫번째는, 이미지의 여러가지 특징표현을 계산하는 것입니다.

이미지나 모양새와 같은 특징표현을 연결하여 특징 벡터로 만들고

두번째는, 이 특징벡터를 Linear Classifier에 입력값으로 주는 것입니다.

특징변환의 한 예로는 컬러 히스토그램이 있습니다.

이미지에서 Hue값만 뽑아서 모든 픽셀을 양동이에 넣고 각 양동이에 담긴 픽셀의 갯수를 세는것입니다.

이 개구리의 경우에는 초록색이 많은 것을 알 수 있습니다.

또다른 예로는 HoG가 있습니다.

이번에는 이미지를 8*8 픽셀로 나누어서 각 픽셀의 지배적인 edge방향을 계산하고 각 edge들에 대해서 양동이에 넣는것입니다.

그럼 edge에 대한 히스토그램이 되는것이죠

이러한 방법도 있습니다. 바로 Bag of words 입니다.

NLP에서 영감을 받은 방식으로, 어떤 문장에서 여러 단어들의 발생빈도를 세서 특징벡터로 사용하는 방식을 이미지에 적용한것입니다.

우리는 이미지에 적용하기 위해 이미지들을 임의대로 조각내고, 각 조각을 K-means와 같은 알고리즘으로 군집화 합니다.

다양하게 구성된 각 군집들은 다양한 색과 다양한 방향에 대한 edge도 포착할 수 있습니다.

(이러한 것들을 시각 단어 (visual words) 라고 부릅니다. )

그래서 5-10년전에는 대부분 이런식으로 특징벡터를 뽑아서 Linear Classifier의 input으로 사용했습니다.

사실 이 개념들은 CNN과 DNN으로 넘어간다고 크게 달라지는 개념은 아닙니다.

유일하게 다른 점이 있다면 이미 만들어 놓은 특징을 쓰기 보다는 데이터로부터 특징을 직접 학습하려 한다는 점입니다.

다음시간에는 CNN에 대해 심도있게 살펴볼 것이고 역전파(Backpropagation)에 대해 알아보겠습니다.

CS231n 한글 정리 | Lecture 3 | Loss Fuctions and Optimization ( SVM Loss & Softmax )

DoRoMii — Thu, 5 Mar 2020 17:57:50 +0900

Stanford University에서 2017년에 강의한 영상을 보며 정리한 자료입니다.

Link : https://www.youtube.com/playlist?list=PL3FW7Lu3i5JvHM8ljYj-zLfQRF3EO8sYv

자료출처 : http://cs231n.stanford.edu/slides/2017/cs231n_2017_lecture3.pdf

참조 : https://github.com/insurgent92/CS231N_17_KOR_SUB/blob/master/kor/Lecture%203%20%20%20Loss%20Functions%20and%20Optimization.ko.srt

지난시간에는 임의의 W 행렬을 가지고 Linear Classification을 진행했는데요

임의로 정한 것이기 때문에 스코어는 좋을 수도, 나쁠 수도 있습니다.

위의 사진에서는 고양이 이미지의 경우에는 car의 스코어가 가장 높습니다. 잘못된 분류죠

하지만, 자동차 이미지의 경우에는 자동차의 스코어가 가장 높습니다. 좋은 분류입니다.

이렇게 스코어를 눈으로 훑으면서 어느게 좋고 어느게 나쁜지를 살펴보기만 하는것은 좋지 않습니다.

이런 알고리즘을 만들고, 어떤 W가 가장 좋은지를 결정하기위해 좋다,나쁘다를 정량화 할 방법이 필요합니다. W가 얼마나 거지같은지 정량적으로 알려주는 함수를 손실함수(Loss Fuction)이라고 합니다.

이번강의에서는 몇가지 손실함수에 대해 알아보겠습니다.

우선 Linear Classification에서 W와 X로 구성된 함수f 기억나시나요?

X는 입력데이터고, W는 가중치입니다. 이 둘을 입력받아 예측값 y를 반환하는 함수였습니다.

손실함수 L_i는 예측함수f와 정답값 Y를 입력받아 이 W가 얼마나 구리게 예측하는지 정량화 시키는 함수라고 보시면 됩니다.

최종Loss는 N개의 샘플들의 Loss의 평균값을 의미합니다.

결국 우리는 이 Loss함수를 이용해 Loss를 최소화하는 어떤 W를 찾아야 할것입니다.

positive와 negative로 분류하기만 하는 SVM 모델을 일반화 시켜 여러개의 클레스를 다룰 수 있도록 하는 Loss함수입니다.

Loss함수를 구하는 방식을 살펴보겠습니다.

우선 "정답인 카테고리의 스코어 (True score)"와 "나머지 카테고리의 스코어(False score)"들을 나누고 True score - False score 를 봐서 safety margin 이상이라면 Loss는 0이 됩니다. (예제에서는 safety margin을 1로 설정했습니다.)

그 차이가 safety margin보다 작다면, (즉 False score가 True score보다 크거나, True가 False보다 크지만 그 차이가 safety margin보다 작다면 ) 그것은 잘못된 경우니까 Loss가 생기고 여기서 Loss는 False score - True score + safety margin으로 구할 수 있습니다.

아래의 예제를 보시면 이해가 더 잘될 겁니다.

ex 1

ex 2

이렇게 Loss를 구할 수 있고, 최종 Loss는 각 Loss값을 더한것에 input의 갯수(3개)를 나누어서 구할 수 있습니다.

즉 정리를 하자면, 우리는 정답인 카테고리의 스코어가 다른 스코어에 비해 얼마나 더 큰 스코어를 가지고 있는지, 그 상대적인 차이가 궁금한것이고 그 차이를 보여주는게 Loss함수라고 볼 수 있을것입니다.

여기 흥미로운 사실이 있습니다. 손실함수라는 것이 분류기에서 우리가 어떤 W를 찾고있는지를 말해주는 것이라면, Loss가 0인것을 선택하는 것은 모순이 아닐까요?

왜냐하면 우리는 오직 데이터의 loss만 신경쓰고 있고, 분류기에게 트레이닝 데이터에 꼭 맞는 W를 찾으라는 말과 같아 보입니다. 그러니 분류기에게 트레이닝 데이터의 loss에만 신경쓰게 한다면 우리가 원하는 값을 찾지 못할 수도 있을 것입니다.

여기 예시가 있습니다. 파란점(train set)들에 피팅되게 선을 예측한다면 초록네모(test set)에 들어왔을때 원하지 않는 결과 값을 얻을 수 있을 것입니다. 오히려 의도했던 것은 초록색 선일 것입니다.

그래서 보통 이를 해결하는 방법을 통틀어 Regularizaion이라고 합니다.

이는 모델이 더 단순한 W를 선택하도록 도와줍니다.

그래서 Regularizaion은 모델이 더 복잡해지지 않도록 도와주며, 모델에 soft한 제약을 추가한다고 볼 수 있습니다. "만약 너가 복잡한 모델을 계속 쓰고싶으면, 이 패널티를 감수해야 할꺼야!"라고 하는것과 같은거죠.

Regularizaion에는 다양한 종류가 있습니다.

가장 보편적인것은 L2 Regularizaion(Weight decay)입니다. L2 Regularization은 Euclidean Norm에 패널티를 주는 것입니다.

또다른 방식으로는 L1 Regularization도 있습니다. 이것은 W를 희소행렬이 될 수 있도록 합니다. Elastic net이라고 L1과 L2 를 짬뽕해둔 것도 있으며, Max Norm도 있습니다.

하지만 Regularization기법중 특히 딥러닝에 관련된 기법들을 더 배우게 될 것입니다. Dropout이나 Batch Normalization, Stochastic depth와 같은 최근의 멋있는 기법들 말입니다.

L1과 L2는 어떻게 모델이 복잡하다고 인지하는 걸까요?

여기 예시가 있습니다.

트레이닝데이터 x가 있고, 서로다른 W행렬 w1과 w2가 있습니다.

이걸가지고 Linear classification을 할때 우리는 x와 w의 내적을 구합니다.

Linear classification의 관점에서는 w1과 w2는 같습니다.

하지만 L2에서는 w1과 w2 중 어느것이 더 좋은 W라고 인지할까요?

L2에서는 w2를 선호합니다. 왜냐하면 L2는 분류기의 복잡도를 각 값들이 얼마나 차이가 없는지로 비교합니다.

Linear classificaion에서 W는 얼마나 x가 output class와 비슷한지를 계산합니다.

따라서 L2는 변동이 심한 어떤 입력 x 가 있고 그 특정요소에 의존하기 보다는 모든 x의 요소가 골고루 영향을 미치길 원할때 사용합니다.

L1은 어떨까요? L1은 w1을 선호합니다. 왜냐하면 L1은 행렬에서 0이 아닌 요소가 많을때 복잡하다고 생각합니다.

따라서 우리가 어떤 문제를 가지고 있고, 우리가 그 문제에서 '복잡하다'를 어떻게 정의할 것인지를 고민하여 적절한 Regularizaion 을 사용해야할 것입니다.

Softmax는 스코어를 가지고 클래스별 확률 분포를 계산하는 방식입니다.

스코어를 모두 이용하고, 각 스코어에 지수를 취해 양수가 되게 만든 후, 지수들의 합으로 정규화 시킵니다. 그래서 softmax 함수를 거치게 되면 결국 확률분포를 얻을 수 있고 그것이 바로 해당 클래스일 확률이 되는 것입니다.

확률이기 때문에 0에서 1사이의 값이고, 모든 확률들의 합은 1이 되겠죠

그러면 우리가 원하는 것은 정답 클래스에 해당하는 클래스의 확률이 1에 가깝게 계산되는 것입니다. 그렇게 되면 Loss는 -log(정답클래스 확률) 이 될 것입니다.

손실함수는 "얼마나 좋은지"가 아니라 "얼마나 구린지"를 측정하는 것이기 때문에 log에 -를 붙이는 겁니다. 그러면 0에 가까울수록 loss값은 무한대로 커질거고 1에 가까울수로 loss는 0에 가까워 지겠죠. 우리는 이것을 Softmax 또는 Multinomial Logistic Regressison (다항 로지스틱 회귀) 라고 합니다.

그렇다면 softmax의 최댓값과 최솟값은 얼마일까요? 이론적으로는 최댓값은 무한대, 최솟값은 0이 될 것입니다. 하지만 컴퓨터는 무한대 연산을 잘 못하기 때문에(유한 정밀도 때문에) Loss가 0인경우는 절대 없을 것입니다.

만약 스코어들이 모두 0근처에 모여있는 작은 수 일때 Loss는 어떻게 될까요? 디버깅할때 이 사실은 매우 유용한데요. 스코어들이 매우 비슷하다면 -log ( 1/class갯수) 가 되겠죠. log는 분자와 분모를 뒤집을 수 있으니까 log ( class의 갯수 )가 될 것입니다. 그렇지 않으면 뭔가 잘못된 것이겠죠?

그렇다면 지금까지 배운 두 손실함수를 한번 비교해 보겠습니다.

이 두 손실함수의 가장 큰 차이점은 "얼마나 구린지"를 측정하기 위해 스코어를 해석하는 방식이 조금 다르다는 것입니다.

SVM에서는 정답 스코어와, 정답이 아닌 스코어 간의 마진(margin)을 신경썼습니다.

반면 Softmax는 확률을 구해서 -log(정답클래스의 확률)에 신경을 썼습니다.

그러면 이전 예제에서 car클래스에서 car의 스코어는 다른 클래스보다 훨씬 높았습니다.

그래서 car스코어가 조금 변한다고 해서 SVM Loss가 변하거나 하진 않았죠, 왜냐하면 SVM은 정답과 그 외의 클래스의 margin만 관심 있기 때문이죠.

이런점에서 softmax는 상당히 다릅니다. softmax는 언제나 확률을 1로 만들려고 노력할 것이기 때문에 정답 스코어가 충분히 높고 다른 클래스 스코어가 충분히 낮아도 최대한 정답 클래스에 확률을 몰아 넣으려고 함으로써 정답 클래스는 무한대로, 그외의 클래스는 음의 무한대로 보내려고 할 것입니다.

즉, SVM은 일정 margin만 넘기면 더이상 성능 개선에 신경을 쓰지 않지만, softmax는 성능을 계속해서 좋게 만들려고 노력할 것입니다.

이것이 매우 흥미로운 차이점인 것이죠.

실제 딥러닝에서는 이 두 손실함수간의 성능차이는 엄청나게 크지는 않지만 그래도 차이를 알고 있다는 것은 유용할 것입니다.

자, 그럼 이제는 어떻게 실제 Loss를 줄이는 W를 찾을 수 있는걸까요?

우리는 이 방법을 '최적화 (Optimization)' 이라고 합니다.

최적화에 대한 것은 다음 게시물에서 이어집니다.

CS231n 한글 정리 | Lecture 2 | Image Classification

DoRoMii — Thu, 5 Mar 2020 17:07:02 +0900

Stanford University에서 2017년에 강의한 영상을 보며 정리한 자료입니다.

Link : https://www.youtube.com/playlist?list=PL3FW7Lu3i5JvHM8ljYj-zLfQRF3EO8sYv

자료출처 : http://cs231n.stanford.edu/slides/2017/cs231n_2017_lecture2.pdf

참조 : https://github.com/insurgent92/CS231N_17_KOR_SUB/blob/master/kor/Lecture%202%20%20%20Image%20Classification.ko.srt

Image Classification 은 어떻게 할 수 있을까요?

우선 이미지를 입력받아 어떤 카테고리에 속할지 판단하면 되겠죠

우리의 시각체계는 매우 고도화 되어있기 때문에 물체를 보자마자 바로 분류가 가능하지만 컴퓨터에게 이미지는 큰 격자모양의 숫자들의 집합이기 때문에 쉽게 분류하기가 어렵죠.

ViewPoint variation → 보는 방향의 변화
Iiiumiation → 조명에 따른 변화
Deformaion → 형태의 변화
Occlusion → 물체가 가려져 일부만 보여지는 경우
Background Clutter → 배경과 비슷한 경우
Interclass variation → 하나의 클레스에 속하는 물체들의 다양성

여러 문제들 때문에 인식의 어려움이 있을 수 있습니다.

*이전에도 이미지를 분류하기 위한 다양한 시도가 있었다

Huble과 Wiesel의 연구덕분에 Edges가 중요하다는 사실을 알게 되었고

Corner와 Edges를 이용하여 명시적인 규칙 집합을 만들어 분류하는 방식을 시도한 적이 있다.

이미지를 분류하는 방법에는 다양한 방식이 있지만 가장 첫번째로 생각해 볼 수 있는 방법은 NN입니다.

NN ( Nearest Neighbor )

가장 가까운 경우를 찾아서 그 레이블로 추측하는 방식입니다.

이를 위해서는 두가지 함수가 필요합니다. "Train" 과 "Predict"

Train : 모든 training 데이터에 lable을 달아 저장하는 기능

Predict : 가장 유사한 training 데이터로 예측하는 기능

그렇다면 어떻게 유사도를 구할 수 있을까요?

여러 비교방법들이 있지만, 가장 단순한 방법은 L1 distance를 이용하는 것입니다.

L1 distance는 같은 자리의 픽셀값을 서로 빼고 절댓값을 취하여 모두 더하는 방식입니다.

*Image classification 문제에서 이 방법이 별로인 것 같지만 연습용으로는 매우 좋습니다 :)

왜냐하면 Train에 소요되는 시간은 O(1)이지만, Test시에는 N개의 학습데이터를 모두 비교해야하기 때문에 O(N)이 소요됩니다.

실제로 우리는 Train에서는 조금 느려도 되지만, Test 시에는 빠르게 동작하기를 원합니다.

따라서 그런 관점에서는 image classification에서 NN은 적합하지 않은 방법입니다.

( 앞으로 다루게될 CNN같은 모델은 소요시간적 관점에서 반대입니다! )

이 방법을 적용한다면 이러한 모양이 나올 것입니다.

위의 사진을 보면 이 분류방식은 그리 적절하지 않음을 알 수 있습니다.

NN은 가장 가까운 이웃만을 보기때문에 녹색구역 가운데에 노란색구역이 생긴 것을 볼 수 있습니다.

이부분또한 노란색이 아니라 녹색이어야 테스트시 더 좋은 성능을 낼 수 있을 것입니다.

( 그 노란색은 아마 noise거나 spurious일 것이기 때문이죠 )

이러한 문제를 위해 K-NN 알고리즘이 탄생했습니다.

K-NN 알고리즘은 가까운 이웃을 K개만큼 찾아 자신의 lable을 예측하는 방식입니다.

거리별 가중치를 가지고 예측할수도 있지만, 가장 단순하면서도 잘 동작하는 방식은 각 이웃들의 lable의 갯수만을 고려하는 것입니다.

이 사진을 보면 K가 달라지면서 경계가 더 부드러워 지는 것을 볼 수 있습니다.

하지만 사이사이에 생기는 흰색 영역은 어떻게 처리할 수 있을까요?

흰색영역은 k-nn에서 결정할 수 없는 지역입니다.

따라서 어떤식으로든 추론을 해보거나, 임의로 정할 수도 있을 것입니다.

이번에도 비교함수를 어떤 것을 사용할지 결정해보아야 할 것입니다.

지금까지는 L1 distance를 이용했지만 L2 distance를 이용할 수도 있을 것입니다.

L2 distance는 Euclidean distance 입니다.

이 두가지 척도간에는 아주 흥미로운 차이점이 있습니다.

L1은 좌표 시스템에 따라 영향을 받습니다.

가령, 좌표시스템을 회전시키면 L1 distance도 변화합니다.

L2는 영향을 받지 않습니다.

따라서 예컨데 특징 벡터의 각 요소들이 개별적 의미를 가지고 있다면 ( e.g. 키, 몸무게 ) L1이 더 잘 맞을 수 있겠죠.

하지만 각 요소간의 실질적인 의미를 잘 모르는 경우에는 L2가 좋을 수 있을 것입니다.

K나 L1/L2 같은 것들 처럼 학습전에 미리 선택해야하는 변수들을 "하이퍼 파라미터"라고 부릅니다.

이런 값들은 어떤것이 가장 좋은 성능을 낼 지 모르기 때문에 각 값들을 모두 시행해 보면서 실험하며 가장 적절한 값을 찾는 경우 도 있습니다.

하지만 test를 할때 유의해야 할 점이 있습니다.

training set에서의 정확도를 최대화 하는 것이 아니라 training set에 없는 데이터에 대해 높은 정확도를 가지도록 해야한다는 것입니다.

따라서 K=1인 경우가 training set에서 정확도가 가장 높겠지만 그 특정 training set에만 정확한 분류기가 될 가능성이 높습니다.

그러면 가지고 있는 data set에서 일부를 training set으로 사용하고 일부를 test set으로 나눠서 사용하는건 어떨까요?

이 방법도 매우 위험합니다. 그 특정 test set에서만 잘 동작하는 분류기가 될 수 있기 때문입니다.

그래서 더 일반적으로는 데이터를 3개로 쪼개는 방식을 사용합니다.

train, validation , test 로 데이터셋을 분리합니다.

training set으로 학습하고 validation으로 검증하고 test로 test를 진행하는것이죠.

검증시 가장 좋았던 분류기로 test는 딱 한번만 진행하는 것입니다.

아래 보이는 사진은 Cross-Validation 방식입니다.

*이 방법은 데이터셋이 작은 경우에 많이 쓰입니다.

테스트셋을 제외한 데이터를 N개로 나누고 (여기서는 5개로 나누었습니다 )

4개의 fold에서 테스트를 하고 나머지 한개에서 validation을 진행하는 방식을 반복합니다.

각 하이퍼 파라미터에 대해서 이런식으로 테스트를 할 수 있을 것입니다.

하지만 이렇게 K-NN에 대해 열심히 배웠으나 이미지의 경우에서는 잘 사용하지 않습니다.

첫번째 문제점은, 앞서 말한대로 너무 느리다는 점입니다.

두번째 문제점은, L1/L2 Distance가 이미지간의 거리를 측정하기에 적절하지 않다는 점입니다.

아래의 사진에서 왼쪽의 한 여성이 있고 나머지 세개의 사진은 왜곡된 이미지입니다.

하지만 이들은 모두 같은 L2 Distance를 갖습니다. 즉, L2 Distance가 지각적 유사도를 측정하기에 적합하지 않다는 의미가 되겠죠

이미지들이 모두 같은 사람이므로 distance가 같으면 좋은것이 아닐까요?

이 예시에서는 그럴 수 있지만, 예컨데 다른 두개의 이미지가 있는데 어떤 적절한 위치에 박스를 놓거나 색을 더하거나 한 경우에 두 이미지가 다름에도 불구하고 Distance를 매우 근접하게 만들 수 있는 경우가 생길 수 있겠죠.

세번째 문제점은, 차원의 저주입니다. K-NN은 트레이닝 데이터를 이용하여 공간을 분할합니다.

그말은 즉, K-NN이 잘 동작하려면 전체 공간을 조밀하게 커버할 만큼 충분한 트레이닝 샘플이 필요하다는 말입니다. 하지만 차원이 증가하면서 필요한 데이터의 양은 기하급수적으로 증가합니다.

따라서 K-NN은 잘 쓰이지 않습니다.

다음은 Linear Classification입니다.

Linear Classification 은 NN과 CNN의 기반 알고리즘이며 "parametric model"의 가장 기본적인 모습입니다.

왼쪽의 고양이는 입력이미지 입니다.

입력이미지는 일반적으로 "X"로 사용합니다.

우리는 데이터 "X"와 parameter "W"를 가지고 10개의 숫자를 출력할 것입니다.

여기서 W는 가중치, "W"라고도 하고 theta(세타)라고도 합니다.

10개의 숫자는 학습을 위해 사용할 데이터인 CIFAR-10의 각 10개의 카테고리 스코어입니다.

여기서 스코어란, "고양이"의 스코어가 높다면 X가 고양이일 가능성이 높다는 뜻으로 해석될 것입니다.

우리는 어떤식으로 W와 데이터를 조합할지 여러가지 방법을 생각해 볼 수 있지만 가장 단순한 방법은 둘을 곱하는 것입니다.

그리고 그것이 Linear Classificaion입니다.

이제 이들의 차원을 보겠습니다. 입력이미지는 32 * 32 * 3 입니다.

이 이미지를 길게 펴면 3072 벡터가 됩니다.

이제 이 3072벡터가 10개의 스코어로 되어야합니다.

따라서 행렬 W은 10*3072가 되어야 합니다.

그리고 가끔 b (Bias)를 보게 될 텐데 이것은 데이터와 무관하게 특정 클레스에 우선권을 부여합니다.

예를들어, 데이터 셋이 불균형한 경우 (고양이<개 인경우) 고양이의 바이어스가 더 커지게 됩니다.

이제 이 함수가 어떻게 동작하는지 보겠습니다.

*이 예제에서는 3가지 클레스로의 분류만 보도록 하겠습니다.

왼쪽의 2*2 고양이 이미지가 있습니다.

이미지를 4-dim 열벡터로 펼칩니다.

3개의 분류를 할 것이므로 가중치 W는 4*3행렬이 될 것이고, bias는 3-dim 열이 되겠죠

그러면 W와 4-dim 열벡터 (data)를 내적하고 , bias를 더해주면 각 분류에 맞는 스코어가 나오겠죠.

(내적은 클래스간 탬플릿의 유사도를 측정하는 것과 유사하다고 보면 좋습니다. )

Linear Classification은 고차원의 공간에서 NN처럼 일종의 "결정경계"를 학습한다고 볼 수 있습니다.

그 공간의 차원은 이미지의 픽셀 값에 해당되는 것입니다.

하지만 이미지가 고차원의 공간의 하나의 점이라는 관점에서 생각하면 Linear Classification이 직면할 수 있는 문제가 있습니다.

아래와 같은 케이스는 분류하기 매우 까다롭습니다.

하지만 Linear Classification은 매우 쉽게 이해하고 해석할 수 있는 알고리즘 입니다.

여기서는 W행렬을 어떻게 구하는 지에서는 아직 다루지 않았습니다.

다음 강의에서는 가중치 행렬 W를 구하는 방법과 다양한 알고리즘에 대해 다루겠습니다.

[leetcode]376. Wiggle Subsequence

DoRoMii — Thu, 15 Aug 2019 23:55:03 +0900

376. Wiggle Subsequence

A sequence of numbers is called a wiggle sequenceif the differences between successive numbers strictly alternate between positive and negative. The first difference (if one exists) may be either positive or negative. A sequence with fewer than two elements is trivially a wiggle sequence.

For example, [1,7,4,9,2,5] is a wiggle sequence because the differences (6,-3,5,-7,3) are alternately positive and negative. In contrast, [1,4,7,2,5] and [1,7,4,5,5] are not wiggle sequences, the first because its first two differences are positive and the second because its last difference is zero.

Given a sequence of integers, return the length of the longest subsequence that is a wiggle sequence. A subsequence is obtained by deleting some number of elements (eventually, also zero) from the original sequence, leaving the remaining elements in their original order.

Example 1:

Input: [1,7,4,9,2,5] Output: 6 Explanation: The entire sequence is a wiggle sequence.

Example 2:

Input: [1,17,5,10,13,15,10,5,16,8] Output: 7 Explanation: There are several subsequences that achieve this length. One is [1,17,10,13,10,16,8].

Example 3:

Input: [1,2,3,4,5,6,7,8,9] Output: 2

Follow up:
Can you do it in O(n) time?

class Solution(object):
    def wiggleMaxLength(self, nums):
        TurnNeg = None
        if nums ==[] :
            return 0
        cnt =0
        for i, num in enumerate(nums[:-1]):
            if TurnNeg is None and nums[i]-nums[i+1] !=0:
                TurnNeg  = nums[i]-nums[i+1]>0
                cnt +=1
            if (TurnNeg and nums[i]-nums[i+1]<0 ) or (not TurnNeg and nums[i]-nums[i+1]>0):
                #print(nums[i])
                cnt +=1
                TurnNeg = not TurnNeg
        return cnt+1

[leetcode]134. Gas Station

DoRoMii — Thu, 15 Aug 2019 23:38:35 +0900

134. Gas Station

There are N gas stations along a circular route, where the amount of gas at station i is gas[i].

You have a car with an unlimited gas tank and it costs cost[i] of gas to travel from station i to its next station (i+1). You begin the journey with an empty tank at one of the gas stations.

Return the starting gas station's index if you can travel around the circuit once in the clockwise direction, otherwise return -1.

Note:

If there exists a solution, it is guaranteed to be unique.
Both input arrays are non-empty and have the same length.
Each element in the input arrays is a non-negative integer.

Example 1:

Input: gas = [1,2,3,4,5] cost = [3,4,5,1,2] Output: 3 Explanation: Start at station 3 (index 3) and fill up with 4 unit of gas. Your tank = 0 + 4 = 4 Travel to station 4. Your tank = 4 - 1 + 5 = 8 Travel to station 0. Your tank = 8 - 2 + 1 = 7 Travel to station 1. Your tank = 7 - 3 + 2 = 6 Travel to station 2. Your tank = 6 - 4 + 3 = 5 Travel to station 3. The cost is 5. Your gas is just enough to travel back to station 3. Therefore, return 3 as the starting index.

Example 2:

Input: gas = [2,3,4] cost = [3,4,3] Output: -1 Explanation: You can't start at station 0 or 1, as there is not enough gas to travel to the next station. Let's start at station 2 and fill up with 4 unit of gas. Your tank = 0 + 4 = 4 Travel to station 0. Your tank = 4 - 3 + 2 = 3 Travel to station 1. Your tank = 3 - 3 + 3 = 3 You cannot travel back to station 2, as it requires 4 unit of gas but you only have 3. Therefore, you can't travel around the circuit once no matter where you start.

class Solution(object):
    def canCompleteCircuit(self, gas, cost):
        
        start = 0
        l_path = len(gas)
        while start<l_path:
            if gas[start] < cost[start]:
                start +=1
                continue
            far = 0
            cur_gas = 0
            while far < l_path and cur_gas>=0 :
                pos = (start+far)%l_path
                cur_gas += gas[pos] - cost[pos]
                far +=1
                
            if far == l_path and cur_gas >=0:
                return start
            start +=1
        return -1

class Solution(object):
    def canCompleteCircuit(self, gas, cost):
        start = 0
        if sum(gas) < sum(cost):
            return -1
        
        cur_gas =0
        for i in range(len(gas)):
            cur_gas += gas[i]-cost[i]
            if cur_gas <0:
                start = i+1
                cur_gas = 0
        return start

[leetcode]43. Multiply Strings

DoRoMii — Thu, 15 Aug 2019 23:10:31 +0900

43. Multiply Strings

Given two non-negative integers num1 and num2represented as strings, return the product of num1and num2, also represented as a string.

Example 1:

Input: num1 = "2", num2 = "3" Output: "6"

Example 2:

Input: num1 = "123", num2 = "456" Output: "56088"

Note:

The length of both num1 and num2 is < 110.
Both num1 and num2 contain only digits 0-9.
Both num1 and num2 do not contain any leading zero, except the number 0 itself.
You must not use any built-in BigInteger library or convert the inputs to integerdirectly.

class Solution(object):
    def multiply(self, num1, num2):
        if num1 =="0" or num2 =="0":
            return "0"
        partialMult = []
        for i in range(len(num2)-1,-1,-1):
            cur_mult = [0 for _ in range(len(num2)-1-i)]
            n2 = int(num2[i])
            carry = 0
            
            for j in range(len(num1)-1,-1,-1):
                mult = n2 * int(num1[j]) + carry 
               
                carry = mult/10
                r = mult%10
                cur_mult.append(r)
            if carry >0:
                cur_mult.append(carry)
            partialMult.append(cur_mult)
        
       
        multSum = partialMult[0]
        for part in partialMult[1:]:
            carry = 0
            i = 0
            while i<len(multSum) or i<len(part) or carry>0:
                curSum = carry
                if i<len(multSum):
                    curSum +=multSum[i]
                if i<len(part):
                    curSum +=part[i]
                carry = curSum/10
                r = curSum%10
                if i < len(multSum):
                    multSum[i] = r
                else :
                    multSum.append(r)
                i+=1
        multSum.reverse()
        return ''.join(map(str,multSum))

차근차근 풀면 풀리는 문제지만

덜렁대면 절대 못푸는 문제이다.

우선 가장 오른쪽끝부터 계산해야한다는 점을 기억해야한다. 그래서 뒤에서부터 계산하는 연산과정을 넣어야하고

0을 체워넣을때에도 인덱스로 바로 하면안되고 뒤집어 있기때문에 len(num2)-1-i로 해서 체워넣어야한다.

그리고나서 partialMult를 처리할때에도 while문 을 or로 처리했기 때문에 i가 범위를 초과하는지를 꼭 체크해야하고

join은 문자열만 하기때문에 multSum이 integer로 이루어져있는것을 str로 변경후 concat해야한다.

[leetcode]1140. Stone Game II

DoRoMii — Thu, 15 Aug 2019 19:06:06 +0900

1140. Stone Game II

Alex and Lee continue their games with piles of stones. There are a number of piles arranged in a row, and each pile has a positive integer number of stones piles[i]. The objective of the game is to end with the most stones.

Alex and Lee take turns, with Alex starting first. Initially, M = 1.

On each player's turn, that player can take all the stones in the first X remaining piles, where 1 <= X <= 2M. Then, we set M = max(M, X).

The game continues until all the stones have been taken.

Assuming Alex and Lee play optimally, return the maximum number of stones Alex can get.

class Solution(object):
    def stoneGameII(self, piles):
        n = len(piles)
        for i in range(n-2,-1,-1):
            piles[i] += piles[i+1]
        cache ={}
        def dfs(i, m):
            if (i,m) in cache:
                return cache[(i,m)]
            
            if i+2*m >=n:
                cache[(i,m)] = piles[i]
                return cache[(i,m)]
            
            max_piles = piles[i] - min([dfs(i+x,max(x,m)) for x in range(1,2*m+1)])
            cache[(i,m)] = max_piles
            return cache[(i,m)]
        return dfs(0,1)

minmax알고리즘 쓰는 문제 처음풀어본다...

너무신기하다

너무어려다

여기에다가 dp 메모이제이션을 추가한 코드이다.

와우 와우와우

[leetcode]1143. Longest Common Subsequence

DoRoMii — Thu, 15 Aug 2019 18:28:13 +0900

1143. Longest Common Subsequence

Given two strings text1 and text2, return the length of their longest common subsequence.

A subsequence of a string is a new string generated from the original string with some characters(can be none) deleted without changing the relative order of the remaining characters. (eg, "ace" is a subsequence of "abcde" while "aec" is not). A common subsequence of two strings is a subsequence that is common to both strings.

If there is no common subsequence, return 0.

Example 1:

Input: text1 = "abcde", text2 = "ace" Output: 3 Explanation: The longest common subsequence is "ace" and its length is 3.

Example 2:

Input: text1 = "abc", text2 = "abc" Output: 3 Explanation: The longest common subsequence is "abc" and its length is 3.

Example 3:

Input: text1 = "abc", text2 = "def" Output: 0 Explanation: There is no such common subsequence, so the result is 0.

Constraints:

1 <= text1.length <= 1000
1 <= text2.length <= 1000
The input strings consist of lowercase English characters only.

class Solution(object):
    def longestCommonSubsequence(self, text1, text2):
        l1 , l2 = len(text1), len(text2)
        
        pre = [0]*(l2+1)
        cur = [0]*(l2+1)
        for i in range(1, l1+1):
            for j in range(1, l2+1):
                if text1[i-1] == text2[j-1]:
                    cur[j] = pre[j-1]+1
                else :
                    cur[j] = max(cur[j-1], pre[j])
            pre, cur = cur, pre
            
        return pre[-1]

		t	e	n	s
	0	0	0	0	0
t	0	1	1	1	1
h	0	1	1	1	1
e	0	1	2	2	2

여기서 [t,t]를 보면 't'와 't' 사이에 가장긴 subsequence의 길이를 의미하는거다.

다음 [t,n]은 ' t'와 'ten'사이에 가장 긴 subsequence의 길이를 의미하는거다

순차적으로 문자가 포함됬을경우를 확인하며 subsequence길이를 업데이트 해주는 것인데

두 문자열의 글자가 같다면 두 문자열에서 그 글자가 포함되지 않은 경우 즉, 왼쪽 위 대각선부분의 값+1을 해주어야 한다.

같지 않다면 현재 단어가 포함되지 않은 상황 즉 , [h,e]에 서 h가 포함되지 않은 상황 (위쪽 값), e가 포함되지 않은 값 (왼쪽 값)중에 큰 값을

가지도록 하여 현재 상황에서 최대길이를 가지고 있도록 한다.

만약 이 상황에서 subsequence를 구하고 싶다면

배열의 가장끝부터 체크하면서 큰값의 가장 작은 인덱스를 확인하고 현재 열보다 인덱스가 작은 열에서 다시 확인하고 반복하여 체크하면 된다. 처음에는 e가 있는 열 (3번)에서 2가 끝나는 지점인 (2번행)을 확인하고

그다음에 h가 있는 열 (2번)에서 (2번행)부터 체크하여 가장 큰값이 언제 끝나는지 확인하고 (1번행)이라는 것을 확인하여 "t,e"라는 것을 알 수 있다.

		t	e	n	s
	0	0	0	0	0
t	0	1	1	1	1
h	0	1	1	1	1
e	0	1	2	2	2

[leetcode]31. Next Permutation

DoRoMii — Thu, 15 Aug 2019 16:51:19 +0900

31. Next Permutation

Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers.

If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).

The replacement must be in-place and use only constant extra memory.

Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the right-hand column.

1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1

class Solution(object):
    def sort(self, nums, start ):
        for i in range(start, len(nums)-1):
            min_index = i
            for j in range(i+1, len(nums)):
                if nums[j] < nums[min_index]:
                    min_index =j
            if min_index != i :
                nums[min_index] , nums[i] = nums[i], nums[min_index]
        
        
    def getNext(self, nums, start ):
        if start >= len(nums)-1:
            return False
        
        IsChanged = self.getNext(nums, start+1)
        if IsChanged:
            return True
        nextNum = -1 
        for i in range(start+1,len(nums)):
            if nums[start]<nums[i] and (nextNum <0  or nums[nextNum] > nums[i]):
                nextNum = i 
        if nextNum < 0 :
            return False
        else :
            nums[start], nums[nextNum] = nums[nextNum], nums[start]
            self.sort(nums, start+1)
        return True
        
    
    def nextPermutation(self, nums):
        IsChanged = self.getNext(nums, 0)
        if IsChanged :
            return 
        else :
            nums.sort()
            return

getNext를 통해서 현재 위치보다 오른쪽에 있는 것들중에 더 큰 수가 잇는지 확인하고, 그 큰수들 중에 가장 작은 수와 현재 위치를 바꾸고

현재 위치 다음부분을 정렬한다. in-place라서 선택정렬로 정렬을 할 수 있도록 했다.

BigO(N^2)일 것같다.

하지만 좋은 코드를 보고 큰 깨달음을 얻었는데,

사실 현재 위치보다 오른쪽에 자신보다 큰수가 없다는 것은 현재 위치로부터 오른쪽으로 내림차순 정렬 되어있다는 것이고

그것을 반복적으로 하다가 현재 위치보다 오른쪽에 큰수가 있을때에는 그 오른쪽은 이미 내림차순 정렬 되어있다고 가정해도 좋다는 것이다. 그러면 현재 위치의 숫자와 가장 오른쪽 끝 숫자부터 비교하다가 현재 위치 숫자보다 큰 수를 발견하고 교환을 한다는 것은 오른쪽에 있는 수중에 현재 숫자보다는 크면서 오른쪽에 있는 숫자중에서는 작은편에 속하는 숫자를 선택했다는 것을 보장할 수 있다.

그러면 그 두 수를 교환하고 나서도 원래 현재숫자는 오른쪽에 있던 숫자보다는 더 작으므로 자리가 바뀌여도 내림차순 정렬 되어있다는 것을 보장 할 수 있으며, 그말은 즉 오른쪽 부분을 reverse하면 오름차순으로 정렬된다는 것과 같은 의미가 될 것이다.

WOW 정말 대단하다.

class Solution(object):
    
    def nextPermutation(self, nums):
        i = len(nums)-1
        
        while i>0 and nums[i] <= nums[i-1]:
            i -=1
        if i==0:
            nums.reverse()
            return
        changePoint = i-1
        j = len(nums)-1
        
        while j>=0 and nums[changePoint] >= nums[j]:
            j -=1
        nums[changePoint], nums[j] = nums[j], nums[changePoint]
        l = changePoint+1
        r = len(nums)-1
        
        while l < r:
            nums[l] , nums[r] = nums[r], nums[l]
            l +=1
            r -=1
        
        return

그리고 이 코드에서 신경써야 할 점은 <= 과 < 어떤 선택을 할 지이다.

nums[i] < nums[i-1]: 인 경우에는

num[i]== nums[i-1]에도 멈추고 변경하려고 하므로 <= 해야한다.

[leetcode]29. Divide Two Integers

DoRoMii — Thu, 15 Aug 2019 15:25:15 +0900

29. Divide Two Integers

Given two integers dividend and divisor, divide two integers without using multiplication, division and mod operator.

Return the quotient after dividing dividend by divisor.

The integer division should truncate toward zero.

Example 1:

Input: dividend = 10, divisor = 3 Output: 3

Example 2:

Input: dividend = 7, divisor = -3 Output: -2

class Solution(object):
    def divide(self, dividend, divisor):
        if dividend == 0: return 0

        # initialize
        i, result, p, q = map(abs, (0, 0, dividend, divisor))

        # phase 1
        while q << i <= p: i += 1

        # phase 2
        for j in reversed(range(i)):
            if q << j <= p: p, result = p - (q << j), result + (1 << j)

        # stupid leetcode restrictions
        if (dividend > 0) != (divisor > 0) or result < -1 << 31: result = -result
        return min(result, (1 << 31) - 1)

이거는 손계산할때 나눗셈하는 것과 같은 원리이다.

phase 1은

divisor을 왼쪽으로 몇번 쉬프트 할때까지 dividend보다 작은지를 체크한다.

그말은 몫이 2진수로 몇자리가 되는지를 체크하는것

그다음 큰수부터 나누면서 dividend를 나눈만크 줄여주고, 결과는 나눈 수 만큼 더해준다.

그리고 음수거나 , 음수범위보다 더 크면 부호를 바꿔서

dividend나 divisor중에 하나라도 음수면 음수의 결과가 나올 수 있도록 하고,

음수 범위보다 더 크면 부호를 바꿔서 양수이면서 integer범위보다 더 큰 수가 될것이고

그러면 return시에 min에서 1<<31 -1보다 크므로 1<<31 -1이 나올 수 있도록 처리된다.

어려웠다.... 개념적으로는 알겠는데

이걸 구현하려니까 어떻게 해야할지 잘 모르겠었고

2진수로 만들려니까 어렵다........

[leetcode]120. Triangle

DoRoMii — Thu, 15 Aug 2019 14:25:34 +0900

120. Triangle

Given a triangle, find the minimum path sum from top to bottom. Each step you may move to adjacent numbers on the row below.

For example, given the following triangle

[ [2], [3,4], [6,5,7], [4,1,8,3] ]

The minimum path sum from top to bottom is 11(i.e., 2 + 3 + 5 + 1 = 11).

Note:

Bonus point if you are able to do this using only O(n) extra space, where n is the total number of rows in the triangle.

class Solution(object):
    def minimumTotal(self, triangle):
        curMinList = triangle[-1]
        
        for level in range(len(triangle)-2,-1,-1):
            nextList = curMinList
            curMinList = []
            curList = triangle[level]
            for i , num in enumerate(curList):
                curMinList.append( min(num+nextList[i],num+nextList[i+1]))
        
        return curMinList[0]

더 깔끔한 코드

class Solution(object):
    def minimumTotal(self, triangle):
        for i in range(len(triangle)-1,0, -1):
            for j in range(i):
                triangle[i-1][j] += min(triangle[i][j] ,triangle[i][j+1])
        return triangle[0][0]

16.11 다이빙 보드

DoRoMii — Wed, 14 Aug 2019 13:36:57 +0900

문제

다량의 널빤지를 이어 붙여서 다이빙 보드를 만들려고 한다. 널빤지는 길이가 긴 것과 짧은 것 두가지 종류가 있는데 정확히 K개의 널빤지를 사용하여 다이빙 보드를 만들어야 한다. 가능한 다이빙 보드의 길이를 모두 구하는 메서드를 작성하라

해결법

1. 재귀적 해법

재귀적으로 K번의 널빤지를 선택하면 다이빙 보드를 완성할 수 있고 완성된 보드를 리스트에 추가하면 된다.

+ 메모이제이션

def getAllLengths(k, long, short):
    memo = set()
    lengths = set()

def allLengths(k, lengths , total, long, short, memo):
    if k == 0:
        lengths.add(total)
    key = (total, k)
    if key in memo :
        return
    allLengths(k-1, lengths, total+long, long, short, memo)
    allLengths(k-1, lengths, total-short, long, short, memo)
    memo.add(key)
    return

2. 수열의 합만을 구하기

어쩌피 널빤지는 2가지종류밖에 없으니 나올수 있는 경우의 수는 K+1밖에 없다.

K = 7이면 long이 0개일때 shourt는 7, long이 1개일때 shourt는 6, ... 이런식으로

그러면 그냥 loop를 이용해서 구할 수 있다.

하지만 한가지 생각해야할 부분이 있다. 두 판자의 길이가 같은 경우를 생각해야한다

그런경우에는 원소가 하나인 배열을 반환하면 된다!!

def getAllLengths(k, long, short):

    lengths = []
    cnt_s = k
    if long != short:
        while cnt_s >=0 :
            cnt_l = k - cnt_s
            length = long*cnt_l + short*cnt_s
            lengths.add(length)
            cnt_s -=1
    else :
        return [long*k]
    return lengths

16.10 살아있는 사람

DoRoMii — Wed, 14 Aug 2019 12:49:50 +0900

문제

사람의 태어난 연도와 사망한 연도가 리스트로 주어졌을때, 가장 많은 사람이 동시에 살았던 연도를 찾는 메서드를 작성하라. 모든사람이 1900년도에서 2000년도 사이에서 태어났다고 가정해도 좋다. 또한 해당 연도의 일부만 살았더라도 해당 년도에 살아있었다고 봐야한다. 예르르들어 어떤 사람이 1908년에 태어나서 1909년에 사망했다면 이 사람은 1908년과 1909년 모두에 삶을 살았던 사람이된다.

해결법

1. 무식한 방법

각 년도를 순회하면서 각 년도에 살아있는 사람들을 카운트한다.

R이 가능한 연도의 범위이고 P가 사람의 수라고 했을때 시간 복잡도는 O(RP)가 된다.

2. 무식하지만 조금 나은 방법

해마다 태어난 인구수를 기록하는 배열을 만들고, 사람을 순회하면서 배열에 기록한다.

(배열을 잡을때 1900-2000 = 100개로 잡으면안되고 101개로 잡아야한다. 1900과 2000이 포함되기 때문)

R이 가능한 연도의 범위이고 P가 사람의 수라고 하고 그사람이 살았던 구간을 Y라고 하면

O(PY + R) 이 된다. 하지만, Y=R이면 1번방법과 크게 달라지지 않는다.

3. 더 최적화

어쩌피 사람들의 정보 (태어난시간, 사망한시간)을 그대로 보존할 필요가 없다는 사실을 안다면 정렬을 해도좋다.

태어난 시간끼리 정렬, 사망한 시간끼리 정렬을 한 다음에 하나씩 읽어들어가면서 사람이 태어났을때 +1 죽었을때는 -1을 하면서 최대 시간을 확인하면된다.

def maxAliveYear(births, deaths, min, max):
    births.sort()
    deaths.sort()

    maxAlive = 0
    maxYear = 0
    curAlive = 0
    
    birthIndex = 0
    deathIndex = 0
    len_peoples = len(births)
    while deathsIndex != len_peoples:
        if birth[birthIndex] <= deaths[deathIndex] :
            curAlive +=1
            if maxAlive < curAlive :
                maxAlive = curAlive
                maxYear = births[birthIndex]
            birthIndex +=1
        else :
            curAlive -=1
            deathIndex +=1

    return maxYear

이코드를 짤때에 주의해야할 점은 바로 birth[birthIndex] <= deaths[deathIndex] 이다.

<= 인지 < 인지를 결정할때 태어난 년도에 사망한 사람이 있는 경우를 어떻게 처리할지에 대해 생각하면 답이 나온다.

누군가가 해당 년도에 태어났고 누군가는 사망했다면 먼저 태어난것을 먼저 체크하고 그다음에 사망을 체크해주어야한다.

그러려면 같은 경우에도 살아있는 사람 +1을 먼저 해야할 것이다.

이경우의 Time complexity 는 사람들의 명수가 P일때 O(PlogP)일 것이다. sort가 있기 때문에

4. 더 최적화!

PlogP보다 더 빨라지려면 정렬을 하지 말아야한다. 정렬을 안하면서도 최대 명수를 알기 위해서는 각 년도에 몇명이 태어났고 죽었는지를 미리 체크해두면 알 수 있을 것이다.

def getPopulation(populationYears, births, deaths, min):
    for birth in births:
        populationYears[birth-min] +=1
    for death in deaths:
        populationYears[death-min+1] -=1



def maxAlive(births, deaths, min, max):
    populationYears = [0]*(max-min+1)
    getPopulation(populationYears, births, deaths , min)
    
    maxAlive = 0
    maxYear  = 0
    curAlive = 0
    for i, p in enumerate(populationYears):
        curAlive +=p
        if curAlive > maxAlive:
            maxAlive = curAlive
            maxYear = min+i

    return maxYear

이 경우에 조심해야할 부분은 사람이 태어난 년도에 인구+1을 하는 것은 맞지만 사망한 년도에 -1을 하게되면 해당년도에 누군가가 태어나고 누군가가 사망한경우는 상쇄되어 0으로 저장되어진다. 그러면 태어난 것을 카운트 할 수 없기 때문에 이런경우에는 사망년도 다음 년도에 -1을 하게 되면 간단하게 해결이 가능하다.

16.1 숫자 교환

DoRoMii — Wed, 14 Aug 2019 10:34:43 +0900

문제

임시 변수를 사용하지 않고 숫자를 교환하는 함수를 작성하라.

해법

이 문제는 두 수중 하나의 수에 그 둘의 '차이'를 가지고 있도록 하면 해결할 수 있는 문제이다.

숫자 a, b가 있다면 a = a-b 를 통해 a가 차이를 가지고 있도록 하고, b = a +b 를 통해 a가 된다.

그리고 다시 a = b -a를 통해 a 는 b가 된다.

a = 9 b = 4라고 할때

a = a- b ( a = 9 - 4 =5)

b = a+b (b = 5+4 =9)

a = b-a ( a = 9-5 =4)

비트로도 같은 연산이 가능하다. 이러면 정수 이외의 자료형에서도 동작한다는 이점이 있다.

a = a^b

b = a^b

a = a^b

[leetcode]300. Longest Increasing Subsequence

DoRoMii — Sun, 11 Aug 2019 17:47:45 +0900

300. Longest Increasing Subsequence

Given an unsorted array of integers, find the length of longest increasing subsequence.

Example:

Input: [10,9,2,5,3,7,101,18] Output: 4 Explanation: The longest increasing subsequence is [2,3,7,101], therefore the length is 4.

Note:

There may be more than one LIS combination, it is only necessary for you to return the length.
Your algorithm should run in O(n2) complexity.

Follow up: Could you improve it to O(n log n) time complexity?

class Solution(object):
    def lengthOfLIS(self, nums):
        sub =[]
        def binarySearch(sub, num):
            l,r = 0, len(sub)-1
            while l<=r:
                mid = (l+r)//2
                if sub[mid] == num :
                    return mid
                elif sub[mid] < num:
                    l = mid+1
                else :
                    r = mid-1
            return l
        
        for n in nums:
            pos = binarySearch(sub, n)
            #print(pos)
            if len(sub)== pos:
                sub.append(n)
            else:
                sub[pos] = n
        return len(sub)

[leetcode]322. Coin Change

DoRoMii — Sun, 11 Aug 2019 16:16:51 +0900

322. Coin Change

You are given coins of different denominations and a total amount of money amount. Write a function to compute the fewest number of coins that you need to make up that amount. If that amount of money cannot be made up by any combination of the coins, return -1.

Example 1:

Input: coins = [1, 2, 5], amount = 11 Output: 3 Explanation: 11 = 5 + 5 + 1

Example 2:

Input: coins = [2], amount = 3 Output: -1

Note:
You may assume that you have an infinite number of each kind of coin.

class Solution(object):
    def coinChange(self, coins, amount):
        dp = [0]*(amount+1)
        for i in range(1, amount+1):
            if i in coins:
                dp[i] = 1
                continue
            min_coins = float("inf")
            for coin in coins:
                if i-coin >= 0:
                    min_coins = min(dp[i-coin], min_coins)
            dp[i] = min_coins+1
        if dp[-1] == float("inf"):
            return -1
        return dp[-1]

[leetcode]62. Unique Paths

DoRoMii — Sun, 11 Aug 2019 13:54:37 +0900

62. Unique Paths

A robot is located at the top-left corner of a m x n grid (marked 'Start' in the diagram below).

The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).

How many possible unique paths are there?

Above is a 7 x 3 grid. How many possible unique paths are there?

Note: m and n will be at most 100.

Example 1:

Input: m = 3, n = 2

Output: 3

Explanation: From the top-left corner, there are a total of 3 ways to reach the bottom-right corner:

1. Right -> Right -> Down 2. Right -> Down -> Right 3. Down -> Right -> Right

Example 2:

Input: m = 7, n = 3

Output: 28

Solution 1 :

중학교때 배운 최단거리 경우의수 구하는방식

class Solution(object):
    def uniquePaths(self, m, n):
        paths = [[0]*m for _ in range(n)]
        paths[0][0] = 1
        for i in range(n):
            for j in range(m):
                if i==0 and j ==0 :
                    continue
                paths[i][j] += paths[i-1][j] if i>0 else 0
                paths[i][j] += paths[i][j-1] if j>0 else 0
        
        return paths[i][j]

Solution 2:

순열을 이용한 방법

같은 것 p개 q개 r개 있는 n개의 것을 순서를 생각하며 나열하는 경우의 수는

n! /(p! * q! * n!)

class Solution(object):
    def uniquePaths(self, m, n):
        return self.factorial(m+n-2) / (self.factorial(m-1) * self.factorial(n-1))
    
    def factorial(self, n):
        num = 1
        while n >= 1:
            num = num * n
            n = n - 1
        return num

[leetcode]55. Jump Game

DoRoMii — Sun, 11 Aug 2019 13:36:30 +0900

55. Jump Game

Given an array of non-negative integers, you are initially positioned at the first index of the array.

Each element in the array represents your maximum jump length at that position.

Determine if you are able to reach the last index.

Example 1:

Input: [2,3,1,1,4]

Output: true

Explanation: Jump 1 step from index 0 to 1, then 3 steps to the last index.

Example 2:

Input: [3,2,1,0,4]

Output: false

Explanation: You will always arrive at index 3 no matter what. Its maximum jump length is 0, which makes it impossible to reach the last index.

DFS + memorization 으로 풀었더니 Time limit exceeded 에러가 발생해서

Discussion참고한 Solution

class Solution(object):
    def canJump(self, nums) :
        last = len(nums) - 1
        for i in range(len(nums)-1, -1, -1):
            if i + nums[i] >= last:
                last = i
        return nums[0] >= last

[leetcode]33. Search in Rotated Sorted Array

DoRoMii — Sat, 10 Aug 2019 16:49:21 +0900

33. Search in Rotated Sorted Array

Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.

(i.e., [0,1,2,4,5,6,7] might become [4,5,6,7,0,1,2]).

You are given a target value to search. If found in the array return its index, otherwise return -1.

You may assume no duplicate exists in the array.

Your algorithm's runtime complexity must be in the order of O(log n).

Example 1:

Input: nums = [4,5,6,7,0,1,2], target = 0

Output: 4

Example 2:

Input: nums = [4,5,6,7,0,1,2], target = 3

Output: -1

class Solution(object):
    def search(self, nums, target):
        l, r = 0 , len(nums)-1
        while l<=r :
            mid = (l+r)//2
            if nums[mid]== target:
                return mid
            elif nums[l] <= nums[mid] :
                if nums[mid] < target or (nums[mid] > target and nums[l] > target):
                    l = mid+1
                else :
                    r = mid-1
            else :
                if nums[mid] > target or(nums[mid] < target and nums[r] < target):
                    r = mid-1
                else :
                    l = mid +1
        return -1

[leetcode] 56. Merge Intervals

DoRoMii — Sat, 10 Aug 2019 16:15:01 +0900

56. Merge Intervals

Given a collection of intervals, merge all overlapping intervals.

Example 1:

Input: [[1,3],[2,6],[8,10],[15,18]]

Output: [[1,6],[8,10],[15,18]]

Explanation: Since intervals [1,3] and [2,6] overlaps, merge them into [1,6].

Example 2:

Input: [[1,4],[4,5]]

Output: [[1,5]]

Explanation: Intervals [1,4] and [4,5] are considered overlapping.

NOTE: input types have been changed on April 15, 2019. Please reset to default code definition to get new method signature.

class Solution(object):
    def merge(self, intervals):
        intervals.sort()
        if len(intervals) <2:
            return intervals
        
        first = intervals[0]
        result = []
        for interval in intervals:
            if interval[0] > first[1]:
                result.append(first)
                first = interval
            else :
                first[1]= max(first[1],interval[1])
        result.append(first)
        return result

[leetcode]34. Find First and Last Position of Element in Sorted Array

DoRoMii — Sat, 10 Aug 2019 15:54:52 +0900

34. Find First and Last Position of Element in Sorted Array

Given an array of integers nums sorted in ascending order, find the starting and ending position of a given target value.

Your algorithm's runtime complexity must be in the order of O(log n).

If the target is not found in the array, return [-1, -1].

Example 1:

Input: nums = [5,7,7,8,8,10], target = 8

Output: [3,4]

Example 2:

Input: nums = [5,7,7,8,8,10], target = 6

Output: [-1,-1]

class Solution(object):
    def searchRange(self, nums, target):
        l, r= 0 ,len(nums)-1
     
        while l<=r :
            mid = (l+r)//2
            if nums[mid] == target:
                l,r = mid, mid
                while l>=0 and nums[l]==target:
                    l-=1
                while r <len(nums) and nums[r]==target:
                    r+=1
                return [l+1, r-1]
            elif nums[mid] < target:
                l = mid+1
            else :
                r = mid-1
                
        return [-1,-1]

https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/

[leetcode]162. Find Peak Element

DoRoMii — Sat, 10 Aug 2019 15:38:39 +0900

162. Find Peak Element

A peak element is an element that is greater than its neighbors.

Given an input array nums, where nums[i] ≠ nums[i+1], find a peak element and return its index.

The array may contain multiple peaks, in that case return the index to any one of the peaks is fine.

You may imagine that nums[-1] = nums[n] = -∞.

Example 1:

Input: nums = [1,2,3,1] Output: 2

Explanation: 3 is a peak element and your function should return the index number 2.

Example 2:

Input: nums = [1,2,1,3,5,6,4] Output: 1 or 5

Explanation: Your function can return either index number 1 where the peak element is 2, or index number 5 where the peak element is 6.

Note:

Your solution should be in logarithmic complexity.

solution 1

좌우 살피기 pick인지

souluton 2

사실 내려가는 점만 찾으면 됨

class Solution(object):
    def findPeakElement(self, nums):
        if len(nums) < 2: return 0
        n = len(nums)
        for i in range(n):
            if i < n -1 and nums[i + 1] < nums[i]: return i
        return n - 1

solution 3

logarithmic coplexity를 위한 이진탐색법

while <=잊지말기

class Solution(object):
    def findPeakElement(self, nums):
        len_nums = len(nums)
        if len_nums <2:
            return 0
        if nums[0]>nums[1]:
            return 0
        if nums[-1]>nums[-2]:
            return len_nums -1
        l = 1
        r = len_nums-2
        while l <= r:
            mid = (l+r)//2
            if nums[mid] >= nums[mid-1] and nums[mid]>= nums[mid+1]:
                return mid
            if nums[mid-1] < nums[mid+1]:
                l = mid+1
            else :
                r = mid-1
        return -1

https://leetcode.com/problems/find-peak-element

[leetcode]347. Top K Frequent Elements

DoRoMii — Sat, 10 Aug 2019 15:03:46 +0900

347. Top K Frequent Elements

Given a non-empty array of integers, return the kmost frequent elements.

Example 1:

Input: nums = [1,1,1,2,2,3], k = 2 Output: [1,2]

Example 2:

Input: nums = [1], k = 1 Output: [1]

Note:

You may assume k is always valid, 1 ≤ k ≤ number of unique elements.
Your algorithm's time complexity must bebetter than O(n log n), where n is the array's size.

1 solution

class Solution(object):
    def topKFrequent(self, nums, k):
        cnt = {}
        for n in nums:
            cnt[n] = cnt.get(n,0)+1
            
        items = cnt.items()
        items.sort(key=lambda k: k[1], reverse=True)
        return [item[0] for item in items[:k]]

2 solution

import random
class Solution(object):
    def findKthLargest(self, nums, k):
        pivot = random.randint(0,len(nums)-1)
        nums[0], nums[pivot] = nums[pivot], nums[0]
        bigger = [n for n in nums[1:] if n > nums[0]]
        
        if len(bigger) == k-1 :
            return nums[0]
        elif len(bigger) > k-1 :
            return self.findKthLargest(bigger, k)
        
        smaller = [n for n in nums[1:]  if n<= nums[0]]
        return self.findKthLargest(smaller, k-1-len(bigger))

https://leetcode.com/problems/kth-largest-element-in-an-array/

[leetcode]347. Top K Frequent Elements

DoRoMii — Sat, 10 Aug 2019 12:38:14 +0900

347. Top K Frequent Elements

Given a non-empty array of integers, return the kmost frequent elements.

Example 1:

Input: nums = [1,1,1,2,2,3], k = 2 Output: [1,2]

Example 2:

Input: nums = [1], k = 1 Output: [1]

Note:

You may assume k is always valid, 1 ≤ k ≤ number of unique elements.
Your algorithm's time complexity must bebetter than O(n log n), where n is the array's size.

class Solution(object):
    def topKFrequent(self, nums, k):
        cnt = {}
        for n in nums:
            cnt[n] = cnt.get(n,0)+1
            
        items = cnt.items()
        items.sort(key=lambda k: k[1], reverse=True)
        return [item[0] for item in items[:k]]

https://leetcode.com/problems/top-k-frequent-elements/

[leetcode]75. Sort Colors

DoRoMii — Sat, 10 Aug 2019 12:35:37 +0900

75. Sort Colors

Given an array with n objects colored red, white or blue, sort them in-place so that objects of the same color are adjacent, with the colors in the order red, white and blue.

Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.

Note: You are not suppose to use the library's sort function for this problem.

Example:

Input: [2,0,2,1,1,0] Output: [0,0,1,1,2,2]

Follow up:

A rather straight forward solution is a two-pass algorithm using counting sort.
First, iterate the array counting number of 0's, 1's, and 2's, then overwrite array with total number of 0's, then 1's and followed by 2's.
Could you come up with a one-pass algorithm using only constant space?

첫번째 solution:

two-pass algorithm using counting sort.

class Solution(object):
    def sortColors(self, nums):
        count = [0]*3
        for n in nums:
            count[n] += 1
        index = 0
        for i in range(len(nums)):
            while count[index] == 0:
                index +=1
            nums[i] = index
            count[index]-=1

두번째 solution:

one-pass algorithm using only constant space

class Solution(object):
    def sortColors(self, nums):
        red_point = 0
        blue_point = len(nums)-1
        
        
        for i in range(len(nums)):
            while nums[i] != 1 :
                if nums[i] == 0:
                    if i == red_point :
                        red_point +=1
                        break
                    else :
                        nums[red_point], nums[i] = nums[i], nums[red_point]
                        red_point +=1
                elif nums[i]==2:
                    if i> blue_point :
                        return
                    nums[blue_point], nums[i] = nums[i], nums[blue_point]
                    blue_point -=1

세번째 solution:

두번째 솔루션을 더 간단하게!

def sortColors(self, nums):			 
        l=len(nums)
        left=0
        right=l-1
        i=0
        while i<=right:
            if nums[i]==0:
                nums[i],nums[left]=nums[left],nums[i]
                left+=1
            elif nums[i]==2:
                nums[i],nums[right]=nums[right],nums[i]
                right-=1
                i-=1
            i+=1

https://leetcode.com/problems/sort-colors/

[leetcode]79. Word Search

DoRoMii — Sat, 10 Aug 2019 11:19:15 +0900

79. Word Search

Given a 2D board and a word, find if the word exists in the grid.

The word can be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once.

Example:

board = [ ['A','B','C','E'], ['S','F','C','S'], ['A','D','E','E'] ]

Given word = "ABCCED", return true.

Given word = "SEE", return true.

Given word = "ABCB", return false.

class Solution(object):
    def dfs(self, board, word, point):
        if not word:
            return True

        direct = [[-1,0,1,0],[0,-1,0,1]]
        for i in range(4):
            cur_y = point[0]+ direct[0][i]
            cur_x = point[1]+ direct[1][i]
            if cur_y >=0 and cur_y < len(board) and cur_x >=0 and cur_x < len(board[0]) and board[cur_y][cur_x]== word[0]:
                origin = board[cur_y][cur_x]
                board[cur_y][cur_x] = '0'
                result = self.dfs(board, word[1:], (cur_y, cur_x))
                if result : 
                    return True
                board[cur_y][cur_x] = origin 
        return False

    def exist(self, board, word):
        if len(board) == 0 or len(board[0])== 0:
            return False
        
        for i in range(len(board)):
            for j in range(len(board[0])):
                if board[i][j] == word[0]:
                    origin = board[i][j]
                    board[i][j] = '0'
                    result = self.dfs(board, word[1:], (i,j))
                    if result:
                        return True
                    board[i][j] = origin 
        return False

https://leetcode.com/problems/word-search/

[leetcode]78. Subsets

DoRoMii — Sat, 10 Aug 2019 10:54:52 +0900

78. Subsets

Given a set of distinct integers, nums, return all possible subsets (the power set).

Note: The solution set must not contain duplicate subsets.

Example:

Input: nums = [1,2,3] Output: [ [3], [1], [2], [1,2,3], [1,3], [2,3], [1,2], [] ]

class Solution(object):
    def subsets(self, nums):
        index = 0
        curs = [[]]
        len_nums = len(nums)
        
        while index < len_nums:
            next_step =[]
            for cur in curs:
                next_step.append([i for i in cur])
                next_step.append([i for i in cur]+[nums[index]])
            index +=1
            curs = next_step
        return next_step

https://leetcode.com/problems/subsets/

[leetcode]46. Permutations

DoRoMii — Sat, 10 Aug 2019 10:36:12 +0900

46. Permutations

Given a collection of distinct integers, return all possible permutations.

Example:

Input: [1,2,3] Output: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ]

class Solution(object):
    def Permute(self, cur ,nums, len_nums, result):
        if not nums:
            result.append([i for i in cur])
            return
        
        for i in range(len(nums)) :
            cur.append(nums[i])
            self.Permute(cur, nums[:i]+nums[i+1:], len_nums, result)
            cur.pop()
        return 
    
    def permute(self, nums):
        result = []
        len_nums = len(nums)
        self.Permute([] , nums, len_nums, result)
        return result

https://leetcode.com/problems/permutations/

[leetcode]22. Generate Parentheses

DoRoMii — Fri, 9 Aug 2019 16:11:09 +0900

22. Generate Parentheses

Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.

For example, given n = 3, a solution set is:

[ "((()))", "(()())", "(())()", "()(())", "()()()" ]

class Solution(object):
    def makeCombi(self, prefix, n , openp, closep, result):
        #print(prefix)
        if openp < closep :
            return 
        if openp+ closep == 2*n :
            result.append(prefix)
            
        if openp < n:
            self.makeCombi(prefix+"(", n, openp+1, closep, result)
        if closep < openp:
            self.makeCombi(prefix+")",n, openp, closep+1, result)
        return 
        
    def generateParenthesis(self, n):
        result = []
        self.makeCombi("", n , 0, 0, result)
        return result

[leetcode]17. Letter Combinations of a Phone Number

DoRoMii — Fri, 9 Aug 2019 15:49:12 +0900

17. Letter Combinations of a Phone Number

Given a string containing digits from 2-9 inclusive, return all possible letter combinations that the number could represent.

A mapping of digit to letters (just like on the telephone buttons) is given below. Note that 1 does not map to any letters.

Example:

Input: "23" Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

Note:

Although the above answer is in lexicographical order, your answer could be in any order you want.

class Solution(object):
    def makeCombi(self, digits, prefix, numberdict,result ):
        if digits == "":
            result.append(''.join(prefix))
            return 
        
        charlist = numberdict[digits[0]]
        for c in charlist:
            prefix.append(c)
            self.makeCombi(digits[1:], prefix, numberdict, result)
            prefix.pop()
        return 
    
    def letterCombinations(self, digits):
        result = []
        
        if digits == "":
            return result
        
        numberdict ={'2': ['a','b','c'],
                    '3' : ['d','e','f'],
                    '4' : ['g','h','i'],
                    '5' : ['j','k','l'],
                    '6' : ['m','n','o'],
                    '7' : ['p','q','r','s'],
                    '8' : ['t','u','v'],
                    '9' : ['w','x','y','z']}
        
      
        self.makeCombi(digits,[],numberdict,result)
        return result

https://leetcode.com/problems/letter-combinations-of-a-phone-number/

[leetcode] 200. Number of Islands

DoRoMii — Fri, 9 Aug 2019 13:05:49 +0900

200. Number of Islands

Given a 2d grid map of '1's (land) and '0's (water), count the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.

Example 1:

Input:

11110

11010

11000

00000

Output: 1

Example 2:

Input:

11000

00100

00011

Output: 3

BFS 또는 DFS로 풀면 되는 문제

BFS로 풀었다.

class Solution(object):
    def numIslands(self, grid):
        cnt_land = 0
        q = []
        d = [[-1,0,1,0],[0,-1,0,1]]
        len_y = len(grid)
        if len_y ==0 :
            return 0
        len_x = len(grid[0])
        if len_x == 0:
            return 0
        for i in range(len_y):
            for j in range(len_x):
                if grid[i][j] == "1":
                    grid[i][j] = "-1"
                    q.append((i,j))
                    while q :
                        cur = q.pop(0)
                        for k in range(4):
                            next_y = cur[0]+d[0][k]
                            next_x = cur[1]+d[1][k]
                            if next_y >= 0 and next_y <len_y and next_x >=0 and next_x <len_x and grid[next_y][next_x] == "1":
                                grid[next_y][next_x] ="-1"
                                q.append((next_y, next_x))
                    cnt_land +=1
        return cnt_land

https://leetcode.com/problems/number-of-islands/

[leetcode]230. Kth Smallest Element in a BST

DoRoMii — Fri, 9 Aug 2019 12:44:11 +0900

230. Kth Smallest Element in a BST

Given a binary search tree, write a function kthSmallest to find the kth smallest element in it.

Note:
You may assume k is always valid, 1 ≤ k ≤ BST's total elements.

Example 1:

Input: root = [3,1,4,null,2]

k = 1

/ \

1 4

Output: 1

Example 2:

Input: root = [5,3,6,2,4,null,null,1], k = 3

/ \

3 6

/ \

2 4

Output: 3

Follow up:
What if the BST is modified (insert/delete operations) often and you need to find the kth smallest frequently? How would you optimize the kthSmallest routine

1. 나의 첫번째 solution

BST 를 inorder하면 정렬된 숫자를 갖는다는 점에서 착안하여 순차적으로 data를 넣고 그중에 i 번째 원소 return

TimeComplexity = O(N) SpaceComplextiy = O(N)

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def kthSmallest(self, root, k):
        li = []
        self.inorder(root, li)
        return li[k-1]
    
    def inorder(self, root, li):
        if root is None:
            return
        
        self.inorder(root.left,li)
        li.append(root.val)
        self.inorder(root.right,li)
        return

2번째 솔루션 : leetcode의 다른 사람 코드를 보고 배움

재귀를 없애고 반복적으로 inorder탐색을 하고 k번째에서 바로 리턴하기

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def kthSmallest(self, root, k):
        stk =[]
        while True:
            while root:
                stk.append(root)
                root = root.left
            root = stk.pop()
            k -=1
            if k ==0 :
                return root.val
            root = root.right

https://leetcode.com/problems/kth-smallest-element-in-a-bst/

[leetcode]116. Populating Next Right Pointers in Each Node

DoRoMii — Fri, 9 Aug 2019 12:31:44 +0900

116. Populating Next Right Pointers in Each Node

You are given a perfect binary tree where all leaves are on the same level, and every parent has two children. The binary tree has the following definition:

struct Node{
int val;
Node *left;
Node *right;
Node *next; }

Populate each next pointer to point to its next right node.

If there is no next right node, the next pointer should be set to NULL.

Initially, all next pointers are set to NULL.

"""
# Definition for a Node.
class Node(object):
    def __init__(self, val, left, right, next):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""
class Solution(object):
    def connect(self, root):
        parents =[]
        currents = []
        if root : 
            currents.append(root)
        
        while currents:
            parents = currents
            currents = []
            for p in parents:
                if p.left :
                    currents.append(p.left)
                if p.right:
                    currents.append(p.right)
            len_p = len(parents)
            for i in range(len_p):
                if i < len_p-1 :
                    parents[i].next = parents[i+1]
                else :
                    parents[i].next = None
        return root

같은 알고리즘 더 간단한 코드

"""
# Definition for a Node.
class Node(object):
    def __init__(self, val, left, right, next):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""
class Solution(object):
    def connect(self, root):
        nodes = [root] if root else []
        
        while nodes:
            next_nodes = []
            last = None
            for node in nodes:
                if last :
                    last.next = node
                if node.left :
                    next_nodes.append(node.left)
                if node.right:
                    next_nodes.append(node.right)
                last = node
            nodes = next_nodes
        return root

https://leetcode.com/problems/populating-next-right-pointers-in-each-node/

[leetcode]105. Construct Binary Tree from Preorder and Inorder Traversal

DoRoMii — Fri, 9 Aug 2019 12:08:15 +0900

105. Construct Binary Tree from Preorder and Inorder Traversal

Given preorder and inorder traversal of a tree, construct the binary tree.

Note:
You may assume that duplicates do not exist in the tree.

For example, given

preorder = [3,9,20,15,7] inorder = [9,3,15,20,7]

Return the following binary tree:

/ \

9 20

/ \

15 7

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def buildTree(self, preorder, inorder):
        if not inorder:
            return None
        
        root_index = 0
        for i in range(len(inorder)):
            if inorder[i] == preorder[0]:
                root_index = i
        root = TreeNode(preorder.pop(0))
        root.left = self.buildTree(preorder,inorder[:root_index])
        root.right = self.buildTree (preorder, inorder[root_index+1:])
        return root

https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/

[leetcode]103. Binary Tree Zigzag Level Order Traversal

DoRoMii — Fri, 9 Aug 2019 11:40:45 +0900

103. Binary Tree Zigzag Level Order Traversal

Given a binary tree, return the zigzag level ordertraversal of its nodes' values. (ie, from left to right, then right to left for the next level and alternate between).

For example:
Given binary tree [3,9,20,null,null,15,7],

/ \

9 20

/ \

15 7

return its zigzag level order traversal as:

[ [3], [20,9], [15,7] ]

class Solution(object):
    def zigzagLevelOrder(self, root):
        level = 0
        result = []
        parents = []
        currents = []
        if root :
            currents.append(root)
        while currents:
            tmp =[]
            parents = currents
            currents = []
            for p in parents:
                tmp.append(p.val)
                if p.left :
                    currents.append(p.left)
                if p.right :
                    currents.append(p.right)
           
            result.append(tmp if level %2 ==0 else tmp[::-1] )
            level +=1
            
        return result

[leetcode]94. Binary Tree Inorder Traversal

DoRoMii — Fri, 9 Aug 2019 10:48:15 +0900

94. Binary Tree Inorder Traversal

Given a binary tree, return the inorder traversal of its nodes' values.

Example:

Input: [1,null,2,3]

Output: [1,3,2]

class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return []
        else:
            return self.inorderTraversal(root.left) + [root.val] + self.inorderTraversal(root.right)

[leetcode]160. Intersection of Two Linked Lists

DoRoMii — Thu, 8 Aug 2019 12:39:54 +0900

160. Intersection of Two Linked Lists

Write a program to find the node at which the intersection of two singly linked lists begins.

For example, the following two linked lists:

begin to intersect at node c1.

Example 1:

Input: intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 Output: Reference of the node with value = 8 Input Explanation: The intersected node's value is 8 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [4,1,8,4,5]. From the head of B, it reads as [5,0,1,8,4,5]. There are 2 nodes before the intersected node in A; There are 3 nodes before the intersected node in B.

Example 2:

Input: intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1 Output: Reference of the node with value = 2 Input Explanation: The intersected node's value is 2 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [0,9,1,2,4]. From the head of B, it reads as [3,2,4]. There are 3 nodes before the intersected node in A; There are 1 node before the intersected node in B.

Example 3:

Input: intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2 Output: null Input Explanation: From the head of A, it reads as [2,6,4]. From the head of B, it reads as [1,5]. Since the two lists do not intersect, intersectVal must be 0, while skipA and skipB can be arbitrary values. Explanation: The two lists do not intersect, so return null.

Notes:

If the two linked lists have no intersection at all, return null.
The linked lists must retain their original structure after the function returns.
You may assume there are no cycles anywhere in the entire linked structure.
Your code should preferably run in O(n) time and use only O(1) memory.

나의 solution :

우선 한번 순회를 통해 A, B의 길이와 각 끝점이 만나는지를 확인한다.

만나지 않으면 둘의 intersection은 없기 때문에 None을 반환한다.

그리고 길이가 긴쪽의 포인터를 차이만큼 움직여서 같은 길이에서 탐색을 시작해서 같은 점을 발견하면 그점이 intersection!

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    
    def changeStart(self,head, cnt):
        while cnt >0:
            head = head.next
            cnt -=1
        return head
        
    def getIntersectionNode(self, headA, headB):
        tailA, tailB = headA, headB
        cntA, cntB = 0, 0
        while tailA :
            tailA = tailA.next
            cntA +=1
        while tailB :
            tailB = tailB.next
            cntB +=1
        if tailA != tailB :
            return None 
        
        if cntA > cntB :
            headA = self.changeStart(headA, cntA-cntB)
        elif cntB > cntA :
            headB = self.changeStart(headB, cntB-cntA)
            
        while headA != headB:
            headA = headA.next
            headB = headB.next
            
        return headA

신기한 솔루션

class Solution(object):
    def getIntersectionNode(self, headA, headB):
        
        a, b = headA, headB
        while a != b:
            if a is None:
                a = headB
            else:
                a = a.next
            if b is None:
                b = headA
            else:
                b = b.next
        return a

[leetcode] 2. add two numbers

DoRoMii — Wed, 7 Aug 2019 17:26:29 +0900

2. Add Two Numbers

You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

Example:

Input: (2 -> 4 -> 3) + (5 -> 6 -> 4) Output: 7 -> 0 -> 8 Explanation: 342 + 465 = 807.

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def addTwoNumbers(self, l1, l2): 
        result = None
        tail = None
        carry = 0
        while l1 is not None or l2 is not None or carry != 0 :
            l1_num = l1.val if l1 else 0
            l2_num = l2.val if l2 else 0
            if result is None :
                result = ListNode((l1_num + l2_num + carry)%10)
                tail = result
            else :
                tail.next = ListNode((l1_num + l2_num + carry)%10)
                tail = tail.next
            carry = 0 if l1_num + l2_num + carry < 10 else 1
            l1 = l1.next if l1 else None
            l2 = l2.next if l2 else None
        return result

* 실수한 부분

l1 과 l2가 없어도 carry가 있으면 연산을 해야하는데 그부분을 간과함

carry 만들때도 l1_num + l2_num + carry를 해야했는데 carry를 빠뜨렸음.

10.11 Peak과 Valley

DoRoMii — Wed, 7 Aug 2019 14:51:43 +0900

문제

정수 배열에서 peak란 현재 원소가 인접한 정수보다 크거나 같을 때를 말하고, 'valley'란 현재 원소가 인접한 정수보다 작거나 같을 때를 말한다. 예를 들어 {5,8,6,2,3,4,6}이 있으면, {8,6}은 peak고 {5,2}는 valley인 것이다.

정수배열이 주어졌을때 'peak'와 'valley'가 번갈아 등장하도록 정렬하는 알고리즘을 작성하라.

해법

1. 부분 최적 해법

배열을 정렬하고 위치를 바꿈으로써 peak와 valley를 순차적으로 나올 수 있도록 만들 수 있을 것이다.

정렬된 배열 0 1 4 7 8 9 가 있다고 하자.

0은 올바른 위치고

1은 잘못 놓였다 0과 4중에 자리를 바꿀 수 있으나 0와 바꿔보자

7도 잘못 놓였다. 4과 8중에 자리를 바꿀 수 있으나 4과 바꿔보자

9도 잘못 놓였다 8과 자리를 바꿀 수 있으니 8과 바꿔보자

그러면 0 4 1 8 7 9로 peak와 valley가 번갈아 나타나는 배열이 나타난다.

이 알고리즘의 TimeComplexity = O(NlogN)이다.

def sortValleyPeak(array):
    array.sort()
    for i in range(1,len(array)):
        array[i] , array[i+1] = array[i+1] , array[i]

2. 최적 해법

저 알고리즘보다 더 최적이되려면 정렬을 하지 말아야한다.

그냥 배열을 가지고는 peak와 valley가 번갈아 나오도록 만들 수 없는 걸까?

9 1 0 4 8 7 이라는 배열이 있다고 가정하자.

그전에 더 짧은 배열을 통해 규칙을 확인해보자

0 1 2 라는 배열이 있을때

0 2 1 ->peak

1 0 2

1 2 0 ->peak

2 1 0

2 0 1

나머지 배열도 수정해서 peak가 되게 할 수 있을까?

가운데 원소와 인접한 원소 중에 가장 큰수와 바꾸면 된다.

"두 원소를 맞바꿨을때 이전에 처리했던 수열의 규칙이 깨지는 경우가 있지는 않을까?" -> 이문제에서 중간값과 왼쪽 값을 바꾼다고 했을때 왼쪽값은 여전히 valley일 것이다 중간 값이 왼쪽 값보다 작으므로 더 작은 수를 놓게 되기 때문이다.

def bigIndex(array, a,b,c):
    len_a = len(array)
    a = array[a] if a>=0 and a < len_a else - int('inf')
    b = array[b] if b>=0 and b < len_a else - int('inf')
    c = array[c] if c>=0 and c < len_a else - int('inf')

    max_num = max(a,b,c)
    if array[a] == max_num :
        return a
    elif array[b] == max_num :
        return b
    else :
        return c

10.10 스트림에서의 순위

DoRoMii — Wed, 7 Aug 2019 14:21:57 +0900

문제

정수 스트림을 읽는다고 하자. 주기적으로 어떤 수 x의 랭킹(x보다 같거나 작은 수의 갯수)를 확인하고 싶다. 해당 연산을 지원하는 자료구조와 알고리즘을 구현하라. 수 하나를 읽을 때마다 호출되는 메서드 track(int x)와, x보다 작거나 같은 수의 갯수( x자신을 제외)를 반환하는 메서드 getRankOfNumber(int x)를 구현하라

입력 : 5,1,4,4,5,9,7,13,3

출력 : getRankOfNumber(1) = 0

getRankOfNumber(3 ) = 1

getRankOfNumber(4 ) = 3

해법

모든 원소를 정렬된 상태로 보관하는 배열을 사용하면 구현하기가 상대적으로 간단해진다.

새로운 원소를 삽입할때마다 다른 원소들을 옆으로 옮겨 공간을 확보해야하는데 그렇다보면 track() 호출시 효율성이 떨어진다. 원소간의 상대적 순서를 유지할 수 있으면서도 새로운 원소를 삽입하기에 도 효율적인 자료구조가 필요하다 -> 이진 탐색 트리가 적당할 것같다.

원소들을 배열에 보관하는 대신 이진 탐색 트리에 삽입하며 track()은 O(logN)시간에 가능하고, 각 노드가 자신의 왼쪽에 있는 자식 노드의 수를 알고있도록 하면 중위 탐색을 모두 하지 않고도 최소한의 탐색으로 랭킹을 확인할 수 있을 것이다.

이런식으로 트리가 구성되어 있다고 가정해보자 그러면 만약 24의 랭킹은 어떻게 구할 수 있을까?

각 노드의 옆에 있는 작은 숫자는 왼쪽 노드의 갯수이다. 루트 20과 24를 비교해보면 24는 오른쪽에 있어야 하기때문에 20의 왼쪽 노드의 갯수인 4 + 1 (20을 포함) = counter은 5개가 된다. 그다음, 25와 비교해보자 24는 25의 왼쪽에 잇어야하므로 갱신하지 않는다.

다음 23과 비교해보자 23보다는 24는 오른쪽에 있어야하므로 23의 왼쪽 노드의 갯수인 0 + 1 (23을 포함) = 1 만큼을 counter에 더해준다.

그다음 오른쪽으로 가면 24와 만나기 때문에 24의 counter인 6을 반환하면 된다.


class Ranknode :
    def __init__(self, data):
        self.data = data
        self.right = None
        self.left = None
        self.leftcount = 0

    def insert(d):
        if d <= data :
            if self.left is None :
                self.left = Node(d)
            else :
                self.left.insert(d)
            leftcount +=1
        else :
            if self.right is None :
                self.right = Node(d)
            else :
                self.right.insert(d)

    def getRank(d):
        if d == self.data :
            return leftcount
        elif d < self.data :
            if self.left is None :
                return -1
            else :
                self.left.getRank(d)
        else :
            rightrank = right.getRank(d) if self.right is not None else -1
            if rightrank == -1 :
                return -1
            else :
                return leftcount + 1 + rightrank


Root = None

def track(number):
    if Root is None :
        Root = Ranknode(number)
    else :
        Root.insert(number)

def getRank(number):
    return Root.getRank(number)

10.9 정렬된 행렬 탐색

DoRoMii — Wed, 7 Aug 2019 13:42:47 +0900

문제

각 행과 열이 오름차순으로 정렬된 MXN 행렬이 주어졌을대, 특정한 원소를 찾는 메서드를 구현하라

해결법

첫번째 : 행마다 이진탐색을 할 수있다.

M개의 행이 있고 각 행을 탐색하는데 O(logN)이 걸리기 떄문에 O(MlogN)이 될 것이다.

두번재 해결법을 생각해보기 전에 규칙을 찾아보자

15	20	40	85
20	35	80	95
30	55	95	105
40	80	100	200

이런 행렬이 주어졌을때 55를 찾아보자.

행의 시작점이나 열의 시작점을 보면 위치를 유추해 볼 수 있다. 열의 시작점 원소의 값이 55보다 크다면 탐색할 필요가 없고, 마찬가지로 행의 시작점 원소의 값이 55보다 크다면 탐색할 필요가 없을 것이다.

그러면 행이나 열의 마지막점에서도 똑같이 적용할 수 있다. 어떤 행이나 열의 값이 x보다 작으면 다음 행이나 열로 이동해야한다.

- 어떤 열의 시작점 열의 원소보다 x가 크면 x는 해당 열 왼쪽에 있다.

- 어떤 열의 마지막 원소 값이 x보다 작으면, x는 해당열 오른쪽에 있다.

- 어떤 행의 시작점 행의 원소가 x보다 크면 x는 해당 행 위쪽에 있다.

- 어떤 행의 시작점 행의 원소가 x보다 작으면 x는 해당 행 아래쪽 있다.

가장 큰 값을 가지는 열부터 시작해서 좌측으로 진행할 필요ㅏ 있다. 즉, 첫번째 비교대상 원소는 array[0][c-1] =85이다.

15	20	40	85
20	35	80	95
30	55	95	105
40	80	100	200

여기서 c는 열의 갯수이다. 열의 시작점 원소들을 x(55)와 비교해보면 x는 0,1,2열에 있을 수 있다는 사실을 알 수 있다.

따라서 array[0][2]에서 진행을 멈춘다.

15	20	40	85
20	35	80	95
30	55	95	105
40	80	100	200

그다음은 array[0][2]는 40으로 55보다는 작으니까 아래쪽으로 진행한다.

이런식으로 범위를 줄여가면서 정답을 찾을 수 있다.

def findElement(matrix, elem):
    row =0
    col =matrix[0].length -1
    while row <matrix.length and col >=0 :
        if matrix[row][col] == elem:
            return (row, col)
        elif matrix[row][col] > elem :
            col -=1
        else :
            row +=1
    return None