728x90

 

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

 

2668번: 숫자고르기

세로 두 줄, 가로로 N개의 칸으로 이루어진 표가 있다. 첫째 줄의 각 칸에는 정수 1, 2, …, N이 차례대로 들어 있고 둘째 줄의 각 칸에는 1이상 N이하인 정수가 들어 있다. 첫째 줄에서 숫자를 적절

www.acmicpc.net

 

이 글을 읽는다면 문제는 이미 다 알고 있다고 생각합니다.

구해야하는 정답은 첫 번째 줄에서 뽑은 수와  두 번째에서 뽑은 수가 같은 집합의 최대 크기이다.

두번째 줄에서 주어진 수에서 인덱스번호가 없는 2와 7은 첫번째 줄에서 선택할 필요가 없다.
-> 왜냐하면 2와 7을 뽑아봤자 2번째 줄에 2와 7이 없기 때문에 같은 수를 뽑을 수가 없기 때문이다.

일단 이해하기 쉽도록 그래프를 그려줍니다.
-> 그래프를 그릴 때 각 노드들은 인덱스 번호이며 연결되어있는 값들은 2번째 줄에서 준 값들의 인덱스 번호입니다.

그럼으로 2와 7을 기준으로  각 노드들에 연결되어 있는 2와 7를 제거합니다.

## 먼저 2를 제거합니다

2가 연결된 곳은 1 번 노드였고 1번 노드에 자식 노드가 있음으로 제거할 대상이 아닙니다. 이후 2가 연결된 곳이 없음으로 7를 제거합니다.

## 7 제거

7이 연결된 곳은 6이었고, 지우니, 자식 노드가 없습니다. 이로 인해 6도 사용하지 못합니다. 그럼으로 6도 지워줍니다.

## 6 제거

6이 연결된 곳은 4였고 지우니, 자식 노드가 없으므로 쓰지 못합니다.

## 4 제거

4가 연결된 곳은 5였고 제거하니 자식 노드가 남아있음으로 제거를 멈춥니다.

다 제거하고 나니  사용가능한 수는 총 3개입니다.

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

int inputs[101];
vector<int> adj[101];

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

    for(int i=1; i<=n; i++) {
        cin >> inputs[i];
        adj[inputs[i]].push_back(i);
    }

    int answer = n;
    for(int i=1; i<=n; i++) {
        if(adj[i].size() == 0) {
            
            int k = i;
            int index = inputs[i];
            
            while(true) {
                // 제거
                for(int j=0; j<adj[index].size(); j++) {
                    if(adj[index][j] == k) {
                        adj[index].erase(adj[index].begin()+ j);
                        answer--;
                        break;
                    }
                }
                
                if(adj[index].size() == 0) {
                    k = index;
                    index = inputs[index];
                    
                } else {
                    break;
                }
            }
        }
    }

    vector<int> answers;
    for(int i=1; i<=n; i++) {
        if(adj[i].size() != 0 ) {
            for(int j=0; j<adj[i].size(); j++) {
                answers.push_back(adj[i][j]);
            }
        }
    }
    sort(answers.begin(), answers.end());

    cout << answer << "\n";
    for(int i=0; i<answers.size(); i++){
        cout << answers[i] << "\n";
    }
}

## 재귀로 작성

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

int inputs[101];
vector<int> adj[101];
int answer;
int n;

void remove(vector<int>& temp, int target){
    for(int j=0; j<temp.size(); j++) {
        if(temp[j] == target) {
            temp.erase(temp.begin()+ j);
            answer--;
            break;
        }
    }
}

void recrucive(int target, int index) {
    
    remove(adj[index], target);
            
    if(adj[index].size() == 0) {
        recrucive(index, inputs[index]);
    } else {
        return;
    }

}

int main() {
    cin >> n;
    answer = n;
    for(int i=1; i<=n; i++) {
        cin >> inputs[i];
        adj[inputs[i]].push_back(i);
    }

    for(int i=1; i<=n; i++) {
        if(adj[i].size() == 0) {
            recrucive(i, inputs[i]);
        }
    }

    vector<int> answers;
    for(int i=1; i<=n; i++) {
        if(adj[i].size() != 0 ) {
            for(int j=0; j<adj[i].size(); j++) {
                answers.push_back(adj[i][j]);
            }
        }
    }
    sort(answers.begin(), answers.end());

    cout << answer << "\n";
    for(int i=0; i<answers.size(); i++){
        cout << answers[i] << "\n";
    }
}

 

반응형

'코딩 관련 > c++' 카테고리의 다른 글

공원 산책 프로그래머스  (0) 2023.06.21
프로그래머스 할인행사  (0) 2022.12.17
백준 1, 2, 3 더하기 5 문제 분석  (0) 2022.08.09
이집트인의 곱셈  (0) 2021.08.24
스택 응용 분석해보기 1편  (0) 2021.08.24
728x90

일단 문제를 확인해보면 1부터 3까지 총 3 가지 수로 주어진 N의 더하기 경우의 수를 구하는 문제임을 알 수 있다.

조건이 있는데 연속된 수를 사용하면 안 된다란 조건이 있다. => 곧 힌트란 의미.

먼저 이를 어떻게 구하는 지 고민을 해보면 완전탐색을 생각할 수 있다.

처음 태블릿으로 적었는데 진짜 못 그렸다... 아이패드 돌려줘;;

각 경우의 수가 총 2개이다.

1 깊이에서 3개, 2 깊이에서 2개씩 총 6개, 3 깊이에서도 2개씩 총 6*2 12개이다. 4 깊이에서는 24개

결국 깊이에서의 경우의 수가 3, 6, 12, 24 순으로 늘어난다. 무슨 수열인지는 모르겠지만 자신의 앞의 수 * 2씩 늘어난다. 딱 봐도 엄청 느리다. 

그래도 수식을 구해야하니까 수열에 공통적으로 3이 곱해져 있으니, 앞으로 빼보니 3*2^n 이다. 문제에서는 n이 100,000보다 작거나 같다고 하니 3*2^n은 계산기도 오버플로우가 난다. 2^100 만 해도 1,267,650,600,228,229,401,496,703,205,376가 나오니 시도조차 하면 안 되는 방법이다.

어차피 완전탐색을 그리다보면 같은 경우의 수를 탐색하며, 똑같은 상태를 매번 계산한다는 점이 느껴진다. 그럼으로 DP로 풀 수 있다고 느껴진다고 해야한다.( 사실 문제의 유형을 보고 풀어서 ... )

이 문제는 조건이 있었다. 만약 없다면 어떻게 풀까?

조건없이 푸는 경우

5를 구한다면 2, 3, 4의 수를 더하면 된다.

근데 이 문제는 연속된 경우를 피해야 한다. 어떻게 피할 수 있을까? 일단 일차원 배열의 경우, 안에 중첩된 경우를 분간하지 못한다.

# 느낌

3차원으로 dp 그리기

# 1의 경우

모양이 똑같다.

# 2의 경우

# 3의 경우

# 4의 경우

근데 표를 돌려본다면?

테이블이 트리 모양이랑 똑같다.

신기하다

 

반응형

'코딩 관련 > c++' 카테고리의 다른 글

프로그래머스 할인행사  (0) 2022.12.17
백준 C++ 숫자고르기 골5 문제 풀이  (0) 2022.08.15
이집트인의 곱셈  (0) 2021.08.24
스택 응용 분석해보기 1편  (0) 2021.08.24
자료구조 Stack 구현하기  (0) 2021.08.23
728x90

이집트 알고리즘은 인류 최초로 기록된 알고리즘 중 하나다. 빠른 곱셈 알고리즘, 빠른 나눗셈 알고리즘이다.

먼저 알아둬야하는 상식은 고대 문명의 알고리즘이기 때문에 자릿수 개념0을 표현하는 방법이 없었다.
자릿수 개념이 없었다는 말이 나중에 나올 이진수와 비슷하다고 생각이 든다.

먼저 곱셈은 1) 1로 곱하기, 2) 1보다 큰 수로 곱하기, 2가지로 정의하여 나눌 수 있다.

1) 1a = a

2) (n+1)a = na+a

 먼저 우리가 알고 있는 일반 상식? "곱셈은 덧셈을 여러번한 것이다"를 구현해보자. 
=> 덧셈을 n-1번 반복해보는 알고리즘(n-1번 반복하니 시간 복잡도는 O(n)라고 알 수 있다.)

우리는 덧셈을 배울 때 결합 법칙을 배웠기 때문에 덧셈의 횟수를 줄일 수 있다.

 중학교 때 배우는 간단한 덧셈의 결합 법칙을 코드에 녹여낸다는 사실 자체가 신비롭다.
다음은 4a = ( (a + a) + a) +a 덧셈을 4번을 한다. 여기서 결합 법칙을 응용한다면, 4a = (a+a) + (a+a), a+a를 한 번하고 a+a끼리 한번 더해주면 총 2번을 한다. 다시 씹어 먹어보자. 4a = (a+a) + (a+a) <= a를 2배로 하고 2배한 만큼 더한다.

우리가 곱셈 시에 a 하나만을 이용하여 곱하는 것은 아님으로 일반적인 식을 n*a라고 했을 때, n을 반으로 줄이고, a를 2배로 키워서 2를 거듭제곱한 횟수만큼 더한 값을 만든다고 할 수 있다. (물론 책에서 이렇게 말한다.)

# 왜 n을 반으로 줄일까?

n = 41, a = 59

1      59
2     118
4     236
8     472
16     944 
32   1888

 이 부분이 제일 어려운 것 같다. 일단 먼저 자릿수 개념이 없던 이집트에서 수를 어떻게 표기하였는지 모르겠다. 또한, 이 알고리즘을 소개한 책에서 이집트에서 어떠한 방식으로 수를 표기하였다고 추가 설명이 없다. 그럼으로 자릿수 개념과 0에 대한 개념이 없는 이집트에서 이진수를 이용하여 표기했다고 가정해보고 41을 2진수로 표기한다.

0010 1001

 위에 비트를 보고 41을 2의 거듭제곱으로 표현했다고 말할 수 있다. 41은 2^6 + 2^4 + 2^1이기 때문이다.
# 책을 보고  이렇게 분석한 것뿐이지 실제로 이런 생각을 스스로 할 수 있을지 걱정이다.

위에서 생각한 결합 법칙을 이용한 알고리즘을 코드로 작성한다면 아래와 같이 할 수 있다.

여기서 덧셈 횟수를 구해보면 #+(n) = ceil(log n) + ( v(n) -1 ) 와 같다. log n의 이유는 재귀함수로 함수가 돌아가며, 한번 돌 때마다 n의 수가 반절씩 줄어들기 때문이고, v(n)은 홀수인 경우의 수를 의미한다. 거기에 n이 1일 때를 빼줌으로 -1을 한다.

알고리즘 개선

이진수로 생각한다는 것은 무엇일까?

이진수의 정의는 0과 1을 이용하여

반응형
728x90

이전 글에서 스택의 고정 관념을 파쇄를 위해서 글을 쓴다고 했다.  이전글  

먼저 백준의 괄호란 문제를 분석해보자!

9012 괄호 문제

괄호 문자열 Parenthesis String은 (, )로만 구성되어있는 문자열이다. 괄호의 모양이 올바르게 구성된 괄호문자열을 VPS라고 부르고, ( )은 기본 VPS이다.. 예를 들어 (())))() ((())), (() 은 VPS가 아니다.

 선입후출! 먼저 넣고 빼면서 생각하는 방법으로 코딩을 한다면 어떻게 될까? 일단 위 문자열 사진처럼 읽으면서, 스택에 다 넣어두고 뒤에서부터 빼면서 쓴다면 내가 데이터를 읽는 흐름이 보라색 선과 같다.

 이렇게 넣은 상태에서 넣은 값을 하나씩 빼면서 생각한다면 어떻게 생각하게 될까? 어떻게 코드를 짜야할지 감이 잡히지 않는다. 왜???? 왜냐면 넣고 빼면서 읽는 것은 단순하게 뒤에서부터 읽는 것과 마찬가지이기 때문이다.

흔한 고정 관념에 따른 생각 

나는 스택 문제를 풀고 있어!, 그래서 스택을 이용해야해(고정관념에 묶인 중), 그래서 스택에 담긴 값을 뺀 것을 다시 넣어주기 위해서 스택을 하나 더 사용해야겠어!!란 생각을 할 수 있다. 이런 경험이 있다면, 고정관념에 묶인 노예란 증거..


스택: 거꾸로 읽기 가능!

스택 없이 거꾸로 읽고 싶다면, 배열과 for문을 이용하여 아래와 같이 코드를 작성해야한다.

스택을 이용한다면?

이로써 스택에 넣고 빼면서 읽는 행위는 거꾸로 읽는 행위란 것을 알 수 있다.

이제 데이터를 원래 흐름대로 읽어보자.


우리는 앞에서부터 읽으면서 ( 일 때 스택에 넣고, )일 때 스택에서 뺀다. 모든 데이터를 다 읽은 뒤에 스택에 아무것도 없다면 올바른 괄호 문자열일 것이다.

만약에 )일 때 스택에 (이 없거나, 스택에 (이 남아 있거다면 올바르지 않은 문자열인 것을 알 수 있다.

상대적으로 처음에 배우는 기초 자료구조인 스택은 특별하지 않다. 하지만 익숙하지 않기 때문에 자유자재로 이용하지 못할 뿐! 다음 글에서는 10799 쇠막대기란 문제로 스택을 응용해보려고 한다.

반응형

'코딩 관련 > c++' 카테고리의 다른 글

백준 1, 2, 3 더하기 5 문제 분석  (0) 2022.08.09
이집트인의 곱셈  (0) 2021.08.24
자료구조 Stack 구현하기  (0) 2021.08.23
백준 2581 소수 코드 포함  (0) 2020.10.10
백준 하노이의 탑 분석 설명  (0) 2020.08.06
728x90

"알고리즘 공부를 하면서 자료구조에 대해서 공부를 해야한다"란 말을 많이 듣는다. 자료구조 라이브러리는 이미 구현되어있는데, 실제 구현 방법에 대해 알고 있는 것이 좋다고 한다. 이유로는 어떻게 돌아가는지를 알기 때문에 실제 구현 시에 도움이 된다고 하는데, 조금 기분이 이상하다.

 우리는 이미 배열이란 자료구조를 애용한다.

 "배열 없이 못 살아"란 말을 할 정도로 배열 자료구조를 많이 사용한다. 조금 코딩하다보면 배열을 찾게 된다. 이처럼 다른 자료구조들도 친근해야하는 것이 중요한 게 아닐까? 친근하다의 기준이 무엇일까? 많이 이용해봤기 때문에 그 자료구조를 적재적소로 이용할 수 있다는 뜻일 것이다. -> 적재적소로 이용하기 위해선 무엇이 필요할까? 어떻게 구현되어있는지 알고 있어야 가능하다.

스택의 개념

스택은 유명한 Stack이란 게임과 같다.

아님 롤에서 나오는 나서스 스택과 같다.

여기서 문제가 생긴다. 스택은 단순히 쌓는 친구야! 맞아! 그리고 처음 쌓은 것은 마지막에 나오지! 바로 선입후출, 후입선출이야!!

그리고.. 내 고정 관념은 선입후출로 굳어졌다.

무조건 쌓는다!란 생각때문에 일단 스택에 데이터를 넣고 본다. 그러니까 스택을 쓴다는 것은 데이터를 넣고 본다. 그리고 빼내면서 사용한다. 선입선출 말 덕분에 방법이 하나로 굳어진다. 넣을 때 연산을 할 수 있지 않을까란? 생각을 해보자. 추후 이어지는 글에서 자세하게 다뤄볼 생각이다.

스택 구현 방법론

스택뿐만 아니라 자료구조를 구현할 때 여러가지 생각이 든다. 1. 내 실력이 좋지 않다. 2. 정해진 방법이 없다.이다. 코딩 시에 정해진 방법이 없으면 더 힘들어진다. 맞는 방법이 없으니까!! 물론 나도 정답을 가지고 있지 않지만, 현재 실력에서의 방법을 정해서 정리해보려고 한다.

1. 정적 배열 이용

 C++은 기억이 가물 가물하지만, 일단 시도한 바에 따르면 배열 길이의 초기화를 배열 선언시 해줘야한다.
Java는 배열을 선언하고 나중에 배열의 길이를 초기화가 가능하다.(와.. 부럽다)

컴파일 에러가 없으니 된다고 본다.

Java로 한번 짜봐야 겠다.

타입이 여러가지로 사용이 가능하니, 배열의 이름을 지어주는 것이 제일 애매하다.

C++로 짠다면 아래와 같이 작성한다.

2.  동적 배열(포인터) 이용

 비주얼 스튜디오에서 위에 올린 클래스랑 이름이 동일하다고 에러 발생!을 알려줘서 이름을 Dstack이라고 바꿨다.
코드를 보면 알겠지만, 동적 생성 부분만 다르지 거의 비슷하다.

정적과 동적의 차이

 정적은 이미 내 스택메모리에 메모리를 쌓는 행위이기 때문에 빠르다. 동적은 내 힙 메모리에 쌓기 때문에 느리다. 실제 알고리즘 문제를 풀 때에 정적을 사용할까? 동적을 사용할까? 의문이다. 
 만약에 회사 면접에 가서 알고리즘 문제를 풀 때 스택을 구현해야한다면 정적으로 구현해야할까? 동적으로 구현해야할까? 모르겠다. 아직 레벨이 부족하기 때문에 모르는 것일까? 


어떤 언어로 구현하는지는 중요하지 않다. 이 자료구조를 배열처럼 익숙해지려면 직접 문제에 적용을 해봐야하니 다음 글에서 문제에서 스택을 어떠한 방식으로 이용하였는지 분석해보자!

반응형

'코딩 관련 > c++' 카테고리의 다른 글

이집트인의 곱셈  (0) 2021.08.24
스택 응용 분석해보기 1편  (0) 2021.08.24
백준 2581 소수 코드 포함  (0) 2020.10.10
백준 하노이의 탑 분석 설명  (0) 2020.08.06
백준 1011 Fly me to the Alpha Centauri 분석  (0) 2020.07.22
728x90

소수 Prime Number'

처음 소수를 판별하여 출력하라! 라고 한다면 소수의 정의를 따라간다.

소수는 1과 자기 자신을 약수로 갖는 값으로
1과 자기 자신외의 약수를 가지지 않는 1보다 큰 수라고 하는데 한번 꼬아놓은 말이라 개인적으로 싫어한다.
그냥 1보다 크고, 약수로 1과 자기 자신을 갖는 값이라고 직설적인 말을 쓰면 좋지 않을까?

하여튼 소수를 구하기 위해서는 자기 자신보다 작은 값들로 나누어서 나누어지면 안된다.
= 나누어진다는 것은 배수라는 의미이기 때문이다.

int number = 4;
bool isPrime = true;
for(int i=number-1; i>1; i++){
	if(number%i==0){
    	isPrime = false;
        break;
    }
 }

내가 가진 수를 for문으로 돌려 나누어진다면 소수가 아니란 것을 알 수 있다.

여기서 더 나아간다면 자기 자신의 값보다 작은 소수의 값으로 나누어보면 된다.

또 다른 방법은 에라토스테네스의 체로 구하는 방법도 있고 그 방법은 아래와 같다.

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

bool number[10001];

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

    int count = ceil(sqrt(10000));
    for(int i=2; i<=count; i++){
        for(int j=i+i; j<=10000; j=j+i){
            number[j] = 1;
        }
    }

    int answer = 0, answer2 = 0;
    for(int i=m; i<=n; i++){
        if(i == 1) continue;
        if(number[i] == false){ answer += i; } 
        if(answer2 == 0 && number[i] == false) answer2 = i;
        
    }
    if(answer) cout << answer << '\n' << answer2;
    else cout << "-1";
}

그런데 또 다른 방법이 있다. 점화식으로도 구할 수 있다.

dl.dongascience.com/magazine/view/M201904N015

아래 링크에 들어가보면 2019년 미국수학회에서 발행한 수학 잡지에 소수 구하는 점화식에 대한 여구가 실려있다고 나와있고 이미지로 소수에 대한 점화식이 존재한다.와우!

반응형
728x90

자료구조를 배우다보면 배우는 하노이의 탑 여전히 그때나 지금이나 직접 생각해서 짜려면 생각보다 곤란하다.

하노이의 탑은 재귀를 사용했지만 재귀를 사용할줄 아는 사람이 직접 구현하는 것보다 이미 구현되어있는 구현 순서를 쉽게 생각해내는 것이 더 빠르고 정확하다.

내가 원숭이라는 증명인걸까?

하노이의 탑은 A, B, C 의 봉 3개에서 A에서 C로 모든 원반을 옮기는 것을 목표로 한다.

각 규칙은 아래와 같다.

  1. 한 번에 한 개의 원판만을 다른 탑으로 옮길 수 있다.
  2. 쌓아 놓은 원판은 항상 위의 것이 아래의 것보다 작아야 한다.

이미 이 글까지 보러왔다면 다 알고 있는 내용이라고 생각한다.(문제에 적혀있으니까..)

하노이의 탑을 어떻게 구현하느냐 아니다. 어떻게 진행되는지 생각해보자.

원반이 총 3개인 경우로 생각하고 기억하는 것이 마음에 편하고 정신건강에 좋다.

그럼 일단 1,2 원반을 B봉에 다 옮겨야한다. 그리고 나머지 3 원반은 C에만 가면 된다.

그러니까 A에서 C를 거쳐 B까지 N-1개 가 옮겨지면 된다는 것이다.

이걸 함수로 적어보자.

void Hanoi(int num, int A, int B, int C){
    Hanoi(num-1, A, C, B);
}

N-1개가 A에서 C를 거쳐 B로 간다.

그럼 그 다음에 B에 있는 원반 1 2를 어떻게 옮기느냐? A를 거쳐 C로 간다.

N-1개가 B에서 A를 거쳐 C로간다.

Hanoi(num -1, B, A, C);

그럼 n이 1인 경우에는 어떻게 될까?

사실 처음 원반 1 2를 B로 옮기고 나머지 3은 그냥 C로 옮기면된다. n이 1인경우에 C로 바로 옮기면된다.

if(num == 1){
        cout << A << ' ' << C;
    }

A B C라고 생각하면 생각하면 문제에 접근하기 좋지만 이는 기억에 잘 남지가 않는다.

여기서 영어가 등장한다. A를 FROM으로 b를 bY로 c를 tO로 한다.

void Hanoi(int num, int from, int by, int to){
    if(num == 1){
        cout << from << ' ' << to << '\n';
    } else {
        Hanoi(num-1, from, to, by);
        cout << from << ' ' << to << '\n';
        Hanoi(num-1, by, from, to);
    }
}

그리고 3개의 원반의 경우 저 함수가 딱 맞아 떨어진다.

궁금하면 직접 실행해보고 저렇게 생각해서 짜는게 정말 편하다.

반응형
728x90

 

#include <iostream>
using namespace std;
int T;
bool check;
int func(long long x,  y, int k){
    
    if(x == y-1){ return 1; }
    else if( x > y-1){ return 0; }
    int count = func(x+k+1, y, k+1);
        count += func(x+k,   y, k  );
    return count;
}
int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    long long x,y;
    cin >> T;
    while(T--){
        cin >> x >> y;
        check = false;
        if( y-x == 1) cout << 1 << '\n';
        else cout << func(x, y, 1)+1 << '\n';
    }
}

애초에 이 글을 읽는 분들은 문제는 이미 읽고 왔을 거라 생각하여 문제 분석만 하겠습니다.

x와 y값은 무엇이 되든 상관이 없으며, x와 y의 사이 값 즉 뺀 값만 유의미합니다.

또한 규칙으로 처음 시작은 1로 시작이 가능하며 뒤에서도 1로 끝나야 합니다.

일단 먼저 앞에서부터 뒤로 가며 체크해나가는 코드를 짜보았습니다.

값도 제대로 출력되며 잘 됩니다.

물론

시간초과가 떴습니다.

재귀니까 역시 느립니다. 지난번까지 별만 찍다보니 재귀에 맛들려버려 아니 재귀적인 사고방식이...

익숙해진걸까 역시 생각하기 쉬운 것 같습니다.

물론 시간초과니 틀렸습니다. 그래서 이미 글러서 다른 분의 영상을 보고 이해해보았습니다.

애초에 하나씩 할 필요가 없는 문제였다는 사실에 슬펐습니다.

앞에서 뒤로 가는 것이 아닌 앞 뒤로 하나씩 증가시켜 보는 것이었습니다.

1, 2, 3, 4, 4, 3, 2, 1이런 식으로 하는 것이었고, 이런 식이 가능한 이유도 횟수만 파악하면 되기 때문이었습니다.

그러니까 x의 값이 y의 값과 동일해지는 것은 무의미한 것이기 때문.. ㅜㅜ 실버 1인데 그래도 쉽네요.

반응형

+ Recent posts