문제출처 : https://www.acmicpc.net/problem/1065


1. 문제요약

- 입력이 N일 때, 각 자릿수의 차이가 같은 수(한수)의 개수는?


※ 한 자릿수와 두 자릿수의 경우 어떻게 처리되나 했더니

예제에


입력 : 110

출력 : 99


즉, 2자리수 까지는 모두 등차수열로 판단 == 한수


2. 접근방법

n <= 1000보다 작은 자연수 이므로 세 자릿수만 한수인지 확인하면 된다.


3. 시간복잡도

- 두 자릿수 입력만 받는다면 O(1)이겠지만, 3자릿수가 넘어가면 각각의 수에 대해 확인해야하므로 O(N)


1) 각 자릿수의 차를 직접 구해보기

- 세 번째 자릿수 - 두 번째 자릿수 == 두 번째 자릿수 - 첫 번째 자릿수


소스코드



2) 등차수열의 특징을 활용

- 사실 특징이라고 할게 있나...

- a, a+d, a+2d ... 이므로 a + a+2d = (a+d) * 2


소스코드



[출처 : BOJ, 문제에 대한 모든 권리는 BOJ(acmicpc.net, startlink)에 있음]

'먹고살려면 > boj' 카테고리의 다른 글

BOJ 1966 프린터 큐  (0) 2017.12.26
BOJ 7568 덩치  (0) 2017.12.19
BOJ 6603 로또  (0) 2017.12.19
BOJ 1182 부분집합의 합  (0) 2017.12.16
BOJ 2309 일곱난쟁이  (0) 2017.12.13

1. 무식하게 풀기(brute-force)

- 가장 많이 하는 실수 중 하나가 쉬운 문제를 어렵게 푸는 것

- 공부를 열심히 할수록 복잡하지만 우아한 답안에 집착하기에..

- 부르트포스 문제는 빠르면서도 정확한 구현능력을 요구함

- 부르트포스는 더 빠른 알고리즘의 근간이 되기에 잘 익혀둘 필요가 있음



2. 재귀 호출과 완전 탐색

1) 재귀 호출

※ tail recursion 이라는 것도 있긴하지만 여기서 설명은 하지 않음

- 큰 조각을 반복되는 유사한 작은 조각들로 나누어 접근하는 것

- 작은 조각들 중 하나를 자신이 해결하고 나머지 조각들을 자기 자신을 호출해서 해결


예) 1 ~ n까지 합

int recursum(int n){
	if(n == 1) return 1;
	return n + recursum(n-1);
}

  n 과 1 ~ n-1 까지의 합으로 구분 => n-1과 1~ n-2 까지의 합으로 다시 구분 ... => 2와 1 ~ 1 까지의 합으로 마지막 구분

  n 의 합을 스스로 처리하고 나머지 1 ~ n-1 까지의 합을 자기자신을 호출하여 처리함


- 재귀는 크게 두 부분으로 구성됨

  base case : 더이상 쪼개지지 않는 작업, 최소 입력에 대한 작업, 답이 없을 경우에 대한 작업

  general case : base case를 제외한 재귀를 호출할 작업



예제. 문제 : PICNIC

- 절차적 접근

https://algospot.com/judge/problem/read/PICNIC


1) 문제를 읽고 이해하기

  : 시간제한 1000ms

  : 메모리제한 2^16kb

  : 2 <= n <= 10


2) 문제 재정의

  : 서로 친구인 학생 끼리 짝을 짓는 경우의 수


3) 계획 세우기

  : 짝이 지어지지 않은 학생을 골라서 친구사이인 다른 학생과 짝을 지어줌

  : 아직 짝이 지어지지 않은 학생을 대상으로 위 과정을 반복

  => "한쌍" 과 "짝이 지어지지 않은 학생" 으로 문제를 분할 => 재귀


4) 계획 검증하기

  : 시간복잡도 : 첫 짝이 없는 친구를 고르는 경우(1)(0 학생이 무조건 처음이므로) * 0학생과 친구인 관계(N-1) * 0과 0 친구를 제외한 다음 짝이 없는 친구를 고르는 경우(N-2) * 두 번째 고른 학생과 친구인 관계(N-3) * ... * 1 = 9! ≒ 360,000 

   즉, 1억번 내에 들어옴

  : 공간복잡도 : global variable - int * 3 = 12byte

                    local variable - bool * 100 + bool * 10 = 110byte

                    ≒ 122byte

   즉, 2^16kb 이내


5, 6) 계획 수행하기 및 회고하기


실패한 소스코드

- 중복처리를 안해줌

- 해당 코드에서는 (0, 1) (2, 3) 과 (2, 3) (0, 1) 이 다른 경우로 판단함.



성공한 소스코드

- 중복처리는 시작점을 고정하는게 제일 좋음

- 단, 이 방법은 a와 b가 친구이면 isfriend[a][b] = isfriend[b][a] = true로 해줘야 (1,2) (3,0) 같은 경우를 골라낼 수 있음

- 아니면 0과 3이 친구가 아니므로 경우의 수가 빠지게 됨


※ 시간복잡도 : 학생 하나 고르는데 걸리는 시간(1) * 고른 학생과 친구인 학생 고르는데 걸리는 시간(N-1) * 두명을 제외한 학생 한명과 그 친구를 고르는데 걸리는 시간(N-3) * ... * 1= 9 * 7 * 5 * 3 * 1 = 945

   공간복잡도 : 위 공간복잡도 + 각 재귀마다 int student가 추가됨(int * (9 * 7 * 5 * 3 * 1) = 3780byte

   즉, 3920byte




※ 왜 종만북의 코드와 속도는 동일하지만 종만북 코드로 제출한 사람들의 코드는 0ms도 있음

   무슨 차이일까 코드를 보았더니

   눈에 띄는 차이는 cin, cout과 scanf, printf

   나중에 입출력 속도에 대해 정리된거 줍줍해와야겠음



- 알고리즘 문제 해결전략 1편 중 -

- 저작권 문제시 삭제하겠습니다 -

1. 왜 필요한가

- 알고리즘의 수행 속도를 대략적으로 측정하기 위해서

- A 알고리즘이 B 알고리즘 보다 빠르다 느리다 얼마만에 수행이 된다 등


※ 왜 프로그램 수행 속도가 아닌 알고리즘의 수행 속도를 사용하는가?

- 프로그램 수행 속도는 하드웨어, OS, 컴파일러, 언어 등에 따라 바뀔 수 있기 때문

- 위의 외적인 이유를 같게 하더라도 어떤 STL을 썼는가, 파라미터, 반복문 내 수행되는 명령문의 개수 등에 따라도 바뀔 수 있기 때문

- 프로그램 수행 속도는 다양한 입력에 대한 실행 시간을 반영하지 못함(입력이 커지면 수행 속도도 달라지기 때문)



2. 속도 측정 기준

- 반복문이 돌아가는 횟수를 기준으로 함

※ 반복문을 제외한 나머지는?

- 입력의 크기가 충분히 크다면 반복문을 제외한 나머지 명령문의 수행 횟수는 전체 명령문의 수행 횟수에서 비율이 점점 줄어들 것이기 때문

 

- 입력의 크기에 따라 알고리즘 내 반복문의 수행 횟수가 달라지기 때문에 "입력의 크기에 대한 함수"로 표현 =>시간 복잡도 표현의 시작



3. 알고리즘 "시간 복잡도"의 표현과 예제

- Big-O Notation

※구술로 말할때는 Order 라고도 함

- Big-Ω

- Big-Θ


- Big-O 계산 방법 : 가장 큰 항만 남김, 상수 제외

※ 단, 알고리즘 문제를 풀면서 상수가 중요한 경우도 있으니 복잡하지 않으면 상수도 포함하여 계산하는 것도 나쁘지 않음


- 예제 : selection sort, insertion sort

1) selection sort

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

void selectionSort(vector<int>& arr){
	for (int i = 0; i < (int)arr.size(); i++){
		int minIndex = i;

		for (int j = i; j < (int)arr.size(); j++){
			if (arr.at(minIndex) > arr.at(j))
				minIndex = j;
		}

		swap(arr[i], arr[minIndex]);
	}
}

int main(void){
	vector<int> a(10, 0);
	
	for (int i = 0; i < (int)a.size(); i++)
		a[i] = (rand() % 10);

	for (int i = 0; i < (int)a.size(); i++)
		cout << a.at(i) << " ";
	cout << "\n";

	selectionSort(a);
	for (int i = 0; i < (int)a.size(); i++)
		cout << a.at(i) << " ";
	cout << "\n";
	return 0;
}

<src 1 : selection sort>

  : (N-1) + (N-2) + ... + 1 = ½N(N-1) = ½N^2 - ½N => O(N^2)


2) insertion sort

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

void insertionSort(vector<int>& arr){
	for (int i = 0; i < (int)arr.size(); i++){
		int j = i;
		while (j > 0 && arr[j] < arr[j-1]){
			swap(arr[j], arr[i]);
			j--;
		}
	}
}

int main(void){
	vector<int> a(10, 0);
	
	for (int i = 0; i < (int)a.size(); i++)
		a[i] = (rand() % 10);

	for (int i = 0; i < (int)a.size(); i++)
		cout << a.at(i) << " ";
	cout << "\n";

	insertionSort(a);
	for (int i = 0; i < (int)a.size(); i++)
		cout << a.at(i) << " ";
	cout << "\n";

	return 0;
}

<src 2 : insertion sort>

  : 1 + 2 + ... + N-2 + N-1 => O(N^2)



4. 시간 복잡도 어림짐작

- 대충 때려 맞추기(개인적으로 가장 많이 이용하는 방법) => 반복의 횟수가 약 1억번(2^20, 10!) 이면 1초에 실행 된다고 판단

  (단, 반복문 안이 길면 그보다 더 걸리고 짧으면 그보다 더 적게 걸림)

  : 1개가 끝나는데 걸리는 시간 * 총 개수

  : selection sort에서 1개가 정렬되려면 최악 N * 총 배열 개수가 N = N^2

  : insertion sort에서 1개가 정렬되려면 최악 N * 총 배열 개수가 N = N^2

  : Map에서 중복되지 않고 모든 칸을 가는 경우 = N^2

  : 선택 하고 안하고의 문제 = 2^N (선택의 경우가 3, 4... 이라면 3^N, 4^N 즉, 경우의 수)


                      (fig 1)

- fig 1 에 있는건 연산 결과 1억번이 나오는 N의 입력 크기

  ex) 1만^2 = 1억



공간복잡도 분석


- 알고리즘 문제 해결전략 1편 중 -

- 저작권 문제시 삭제하겠습니다 -

'먹고살려면 > Algorithm' 카테고리의 다른 글

3-2편 무식하게 풀기 2  (0) 2017.12.18
번외편 c/c++ 입력속도  (0) 2017.12.12
3-1편 무식하게 풀기 1  (0) 2017.12.11
1편 알고리즘 문제 풀이를 위한 전략  (0) 2017.12.01
알고리즘 시작하기  (0) 2017.11.30

+ Recent posts