반응형

1.  문제

■ URL : https://www.acmicpc.net/problem/1012

■ 난이도 : 하 (DFS 기본문제)

 

2. 핵심요약

■ 예제입력

    - 첫번째 줄: Test Case
    - 두번째 줄: 10행 8열, 17개의 배추

    - 세번째 줄 이하: 17개 배추의 위치 (행 열)

2
10 8 17
0 0
1 0
1 1
4 2
4 3
4 5
2 4
3 4
7 4
8 4
9 4
7 5
8 5
9 5
7 6
8 6
9 6
10 10 1
5 5

 

"예제 입력"을 "그래프"로 표현

    - 0: 배추가 없는 곳
    - 1: 배추를 심은 곳

 

3. 문제풀이 접근

■ (0행 0열)부터 시작하여 (M형 N열)까지 순차적으로 하나씩 DFS를 수행한다. (모든 위치에서 시작)

DFS 수행 중 탐색이 처리된 위치는 visited 방문 기록을 남긴다.

■ DFS 수행이 1회라도 된 위치는 answer 횟수를 1회 증가한다.

 

4. JavaScript 코딩

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
let isLocal = true          // 로컬 환경에서 입력을 받을지, stdin에서 받을지 결정하는 변수
 
let fs = require('fs');     // 파일 시스템 모듈을 사용하여 파일 읽기
let input;
 
if (isLocal) {
    input = fs.readFileSync('./1012.txt').toString().split('\n'); // 파일에서 입력 받기
else {
    input = fs.readFileSync('/dev/stdin').toString().split('\n'); // stdin에서 입력 받기
}
 
// 깊이 우선 탐색(DFS) 함수
const dfs = (graph, currY, currX, rowSize, colSize) => {
    // 현재 위치가 유효한지, 범위 밖이면 종료
    if (currY < 0 || currY >= rowSize || currX < 0 || currX >= colSize) return false;
 
    // 현재 위치에 양배추가 없으면 종료
    if (graph[currY][currX] == 0return false;
 
    // 현재 위치의 양배추를 방문 처리
    graph[currY][currX] = 0;
 
    // 상, 하, 좌, 우로 DFS 탐색
    dfs(graph, currY-1, currX, rowSize, colSize);   // 현재위치 기준 상
    dfs(graph, currY+1, currX, rowSize, colSize);   // 현재위치 기준 하
    dfs(graph, currY, currX-1, rowSize, colSize);   // 현재위치 기준 좌
    dfs(graph, currY, currX+1, rowSize, colSize);   // 현재위치 기준 우
 
    return true;    // 연결된 양배추를 모두 방문한 후 true 반환
}
 
// 테스트 케이스의 수를 첫 번째 줄에서 읽어옴
let testCase = Number(input[0]);
let nextCase = 1;
 
// 각 테스트 케이스에 대해 처리
while (testCase--) {
    // 각 테스트 케이스의 크기 및 양배추 개수를 읽어옴
    const [rowSize, colSize, cabageCnt] = input[nextCase].split(' ').map(Number);
 
    // 주어진 크기(rowSize, colSize)로 graph 초기화 (모두 0으로 초기화)
    let graph = [];
    for (let y = 0; y < rowSize; y++) {
        let graphRow = new Array(colSize).fill(0); // 각 행을 0으로 초기화
        graph.push(graphRow);
    }
 
    // 양배추가 있는 위치를 graph에 설정
    for (let i = 1; i <= cabageCnt; i++) {
        const [cabageY, cabageX] = input[nextCase + i].split(' ').map(Number);
        graph[cabageY][cabageX] = 1;    // 양배추가 있는 곳을 1로 설정
    }
 
    let answer = 0// 연결된 양배추 군집 수
 
    // 그래프에서 모든 칸을 탐색
    for (let y = 0; y < rowSize; y++) {
        for (let x = 0; x < colSize; x++) {
            // (y, x) 위치에서 양배추가 있으면 DFS 탐색
            if (dfs(graph, y, x, rowSize, colSize)) {
                answer += 1// 연결된 양배추 군집을 발견할 때마다 카운트 증가
            }
        }
    }
 
    // 각 테스트 케이스 결과 출력
    console.log(answer);
 
    // 다음 테스트 케이스로 넘어갈 때, 양배추 개수 + 1을 더하여 다음 입력 시작 위치로 이동
    nextCase += cabageCnt + 1;
}
 
cs

 

 

5. 참고

https://languagestory.tistory.com/380

 

[DFS] 개념(Depth First Search; 깊이 우선 탐색) - 자바스크립트

1. DFS(Depth First Search; 깊이 우선 탐색)의 개념■ 그래프에서 모든 노드를 한번씩 탐색하기 위한 방법■ 스택 또는 재귀함수를 이용하여 구현■ 루트 노드[또는 임의의 노드]에서 시작하여 형제(si

languagestory.tistory.com

 

반응형
반응형

1. DFS(Depth First Search; 깊이 우선 탐색)의 개념

 그래프에서 모든 노드를 한번씩 탐색하기 위한 방법

■ 스택 또는 재귀함수를 이용하여 구현

■ 루트 노드[또는 임의의 노드]에서 시작하여 형제(sibling) 노드로 넘어가기 전에 시작한 분기의 마지막 노드까지 깊게 탐색하는 방법

 

2. DFS 노드 방문 순서

■ 결과 : 1 → 2 → 4 → 5 → 6 → 3 → 7 → 10 → 8 → 9

    - step1) 도달 가능한 마지막 노드(막다른 길)까지 이동한다.

    - step2) 지나처 온 최근 갈림길(형제노드)로 되돌아 간다.

    - step3) 모든 노드를 탐색할 때까지 step1과 step2를 반복한다.

 

3. 그래프 표현

"그래프"는 "인접 리스트"로 표현하여 보다 이해하기 쉬운 형태로 만들 수 있다.

1 2, 3
2 1, 4
3 1, 7, 8, 9
4 2, 5, 6
5 4
6 4
7 3, 10
8 3
9 3
10  

 

■ "인접 리스트"는 "2차원 배열[리스트]" 또는 "테이블[dictionary]" 자료구조로 코드화 한다.

1
2
3
4
5
6
7
8
9
10
11
12
let graph = []
graph['0'= []         // index 0: 사용하지 않음.
graph['1'= ['2''3']
graph['2'= ['1''4']
graph['3'= ['1''7''8''9']
graph['4'= ['2''5''6']
graph['5'= ['4']
graph['6'= ['4']
graph['7'= ['3''10']
graph['8'= ['3']
graph['9'= ['3']
graph['10'= ['7']
cs

 

4. JavaScript 코딩

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 깊이우선탐색(DFS) 함수
const dfs = (graph, currNode, visited = []) => {
  
  visited[currNode] = true;   // 현재 노드 방문 처리
  console.log(currNode);      // 현재 노드 출력
 
  // 현재 노드와 연결된 다른 노드들에 대해 탐색
  for (let nextNode of graph[currNode]) {
      if (!visited[nextNode]) {           // 아직 방문하지 않은 노드에 대해서만 재귀 호출
          dfs(graph, nextNode, visited);  // 재귀 호출로 다음 노드 탐색
      }
  }
}
 
dfs(graph, '1')        // 노드1 부터 깊이우선탐색(DFS) 시작
 
cs

 

반응형
반응형

1.  문제

■ URL : https://www.acmicpc.net/problem/13305

 

2. 핵심요약

■ 문제유형 : 탐욕(Greedy) 알고리즘

■ 1번째 Row: 도시의 개수를 나타내는 정수 

■ 2번째 Row: 인접한 두 도시를 연결하는 도로의 길이가 제일 왼쪽 도로부터 N-1개의 자연수로 구성

■ 3번째 Row: 주유소의 리터당 가격이 제일 왼쪽 도시부터 순서대로 N개의 자연수로 구성

 

3. 문제풀이 접근

■ 첫번째 도시에서는 가격에 상관없이 주유를 할 수밖에 없다.

■ 두번째 도시부터는 다음(오른쪽) 도시들의 가격과 비교하여 미리 주유 여부를 결정한다.

 

4. 파이썬 코딩

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
isTest = True
if isTest:
    f = open("./13305.txt"'r')
    city_cnt = int(f.readline())
    distArr = list(map(int, f.readline().split(' ')))
    priceArr = list(map(int, f.readline().split(' ')))
else:
    city_cnt = int(input())
    distArr = list(map(int, input().split(' ')))
    priceArr = list(map(int, input().split(' ')))
 
sum = 0
minPrice = priceArr[0]
for i in range(len(priceArr) - 1):
  if minPrice > priceArr[i]:
    minPrice = priceArr[i]
 
  sum += minPrice * distArr[i]
 
print(sum)
cs

 

5. JavaScript 코딩

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
let isTest = true
 
let fs = require('fs');
let input;
if (isTest) {
    input = fs.readFileSync('./13305.txt').toString().split('\n');
else {
    input = fs.readFileSync('/dev/stdin').toString().split('\n');
}
 
city_count = parseInt(input[0]);
distArr = input[1].split(' ').map(Number);
priceArr = input[2].split(' ').map(Number).slice(0, city_count - 1);
 
let sum = BigInt(0);
let minPrice = priceArr[0];
for (let i = 0; i < priceArr.length; i++) {
  if (minPrice > priceArr[i]) {
    minPrice = priceArr[i];
  }
  sum += BigInt(minPrice) * BigInt(distArr[i]);
}
 
console.log(String(sum));
 
cs

 

반응형
반응형

1.  문제

■ URL : https://www.acmicpc.net/problem/1789

 

2. 핵심요약

■ 문제유형 : 탐욕(Greedy) 알고리즘

■ S: 자연수의 합 (문제의 Input)

N: 합계 S가 성립하는 자연수들의 최대 갯수

 

3. 문제풀이 접근

최대한 많은 숫자를 이용하여 합계 S를 만들기 위해서는 가장 작은값(1)부터 차례대로 더해 나가야 한다.

그 다음 더해지는 숫자를 고려하여 더해지는 값이 S 보다 더 크게 될때까지 카운트한다.

 

4. 파이썬 코딩

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
isTest = True
if isTest:
    f = open("./1789.txt"'r')
    s = int(f.readline())
else:
    s = int(input())
 
current = 0
cnt = 0
 
adder = 1
 
while (s >= current):
    current += adder
 
    adder += 1
    cnt += 1
 
    if adder > s - current:
        break
 
print(cnt)
cs

 

 

5. JavaScript 코딩

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
let isTest = true
 
let fs = require('fs');
let input;
if (isTest) {
    input = fs.readFileSync('./1789.txt').toString().split('\n');
else {
    input = fs.readFileSync('/dev/stdin').toString().split('\n');
}
 
= parseInt(input[0]);
 
current = 0
cnt = 0;
 
adder = 1;
 
while (s >= current) {
    current += adder;
    console.log(current);
 
    adder++;
    cnt++;
 
    if (adder > s - current) {
        break;
    }
}
 
console.log(cnt);
cs

 

 

반응형

'알고리즘(코딩테스트)' 카테고리의 다른 글

[DFS] 개념(Depth First Search; 깊이 우선 탐색) - 자바스크립트  (1) 2025.02.16
[백준] 주유소  (0) 2024.10.05
[백준] 설탕 배달  (0) 2024.10.04
[백준] 읽어버린 괄호  (0) 2024.10.04
[백준] ATM  (1) 2024.10.03
반응형

1.  문제

■ URL : https://www.acmicpc.net/problem/2839

 

2. 핵심요약

■ 문제유형 : 탐욕(Greedy) 알고리즘

 

3. 문제풀이 접근

먼저 큰 봉지(5kg)를 이용하여 설탕을 담는다.

남은 분량을 작은 봉지(3kg) 단위로 배분하여 정확히 떨어지는지(나머지가 0) 여부를 확인한다.

■ 작은 봉지(3kg) 단위로 배분하여 떨어지지 않으면(나머지가 0 아님) 큰 봉지(5kg)의 갯수를 하나씩 줄인다.

남은 분량이 작은 봉지(3kg) 단위로 배분하여 정확히 떨어지는면(나머지가 0) 봉지의 합이 최소값이 된다.

 

4. 파이썬 코딩

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
isTest = True
if isTest:
    f = open("./2839.txt"'r')
    N = int(f.readline())
else:
    N = int(input())
 
answer = -1
for i in range(int(N / 5), -1-1):
    remains = N - i * 5
 
    if remains % 3 == 0:
        answer = i + int(remains / 3)
        break
 
print(answer)
cs

 

 

5. JavaScript 코딩

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
let isTest = true
 
let fs = require('fs');
let input;
if (isTest) {
    input = fs.readFileSync('./2839.txt').toString().split('\n');
else {
    input = fs.readFileSync('/dev/stdin').toString().split('\n');
}
 
let N = input[0];
 
let answer = -1;
for(let i = parseInt(N / 5); i >= 0; i--) {
    let remains = N - i * 5;
 
    if (remains % 3 === 0) {
        answer = i + parseInt(remains / 3);
        break;
    }
}
 
 
console.log(answer);
cs

 

반응형

'알고리즘(코딩테스트)' 카테고리의 다른 글

[백준] 주유소  (0) 2024.10.05
[백준] 수들의 합  (0) 2024.10.05
[백준] 읽어버린 괄호  (0) 2024.10.04
[백준] ATM  (1) 2024.10.03
[백준] 동전 0  (0) 2024.10.03
반응형

1.  문제

■ URL : https://www.acmicpc.net/problem/1541

 

2. 핵심요약

첫째 줄에 식이 주어진다.

■ 식은 ‘0’~‘9’, ‘+’, 그리고 ‘-’만으로 이루어져 있다.

■ 가장 처음과 마지막 문자는 숫자이다. → 식의 가장 첫 부분은 양수로 시작한다.

■ 연속해서 두 개 이상의 연산자가 나타나지 않는다.

 

3. 문제풀이 접근

문제의 내용을 종합하면 아래와 같은 형태를 만들어야만 식의 결과가 최소값으로 나타난다.

 

4. 파이썬 코딩

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
isTest = True
if isTest:
    f = open("./1541.txt"'r')
    input = f.readline()
else:
    input = input()
 
q_tkn_arr = input.split('-')
 
answer = 0
for i in range(len(q_tkn_arr)):
    sub_sum = 0
    s_tkn_arr = map(int, q_tkn_arr[i].split('+'))
    for s_tkn in s_tkn_arr:
        sub_sum += s_tkn
 
    if len(q_tkn_arr) == 1 or i == 0:
        answer = sub_sum
    else:
        answer -= sub_sum
 
print(answer)
cs

 

5. JavaScript 코딩

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
let isTest = true
 
let fs = require('fs');
let input;
if (isTest) {
    input = fs.readFileSync('./1541.txt').toString().split('\n');
else {
    input = fs.readFileSync('/dev/stdin').toString().split('\n');
}
 
let q = input[0];
q_tkn_arr = q.split('-')
 
answer = 0
for (let i = 0; i < q_tkn_arr.length; i++) {
    let sub_sum = 0;
    s_tkn_arr = q_tkn_arr[i].split('+').map(Number)
    for (let j = 0; j < s_tkn_arr.length; j++) {
        sub_sum += s_tkn_arr[j];
    }
 
    if (q_tkn_arr.length === 1 || i === 0) {
        answer = sub_sum;
    } else {
        answer -= sub_sum;
    }
}
 
console.log(answer);
cs

 

반응형

'알고리즘(코딩테스트)' 카테고리의 다른 글

[백준] 주유소  (0) 2024.10.05
[백준] 수들의 합  (0) 2024.10.05
[백준] 설탕 배달  (0) 2024.10.04
[백준] ATM  (1) 2024.10.03
[백준] 동전 0  (0) 2024.10.03
반응형

1.  문제

■ URL : https://www.acmicpc.net/problem/11399

 

2. 핵심요약

■ 1번째 Row : 사람의 수 N(1 ≤ N ≤ 1,000)

2번째 Row : 각 사람이 돈을 인출하는데 걸리는 시간

1
2
5
3 1 4 3 2
cs

 

3. 문제풀이 접근

■ 문제유형 : 탐욕(Greedy) 알고리즘

최소 시간의 합을 구하기 위해서 점유시간이 낮은 사람부터 먼저 처리 되어야 한다.

 

4. 파이썬 코딩

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
isTest = True
if isTest:
    f = open("./11399.txt"'r')
    cnt = int(f.readline())
    occupy = list(map(int, f.readline().split()))
else:
    cnt = int(input())
    occupy = list(map(int, input().split()))
 
# 배열을 오름차순으로 정렬
occupy.sort()
 
sum = 0
answer = 0
for x in occupy:
    sum += x            # 각 사람이 (대기한 시간 + 돈을 인출하는데 걸리는 시간)
    answer += sum       # 각 사람이 (대기한 시간 + 돈을 인출하는데 걸리는 시간)의 누적합
 
print(answer)
cs

 

5. JavaScript 코딩

■ 배열.sort()와 배열.sort((a, b) => a - b)의 정렬 방식 차이점

    - 배열.sort() : ['3', '12', '215']인 경우, ['12', '215', '3']으로 정렬된다.

    - 배열.sort((a, b) => a - b) : ['3', '12', '215']인 경우, ['3', '12', '215']으로 정렬된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
let isTest = true
 
let fs = require('fs');
let input;
if (isTest) {
    input = fs.readFileSync('./11399.txt').toString().split('\n');
else {
    input = fs.readFileSync('/dev/stdin').toString().split('\n');
}
 
let cnt = Number(input[0]);         // 사람 수
let occupy = [];                    // 각 사람이 돈을 인출하는데 걸리는 시간
for (let i = 0; i < cnt; i++) {
    occupy.push(Number(input[1].split(' ')[i]));
}
 
// 배열을 오름차순으로 정렬
occupy.sort((a, b) => a - b);
//occupy.sort()   // 위의 것과 차이점 중요
 
let sum = 0;
let answer = 0;
for (let i = 0; i < occupy.length; i++) {
    sum += occupy[i];       // 각 사람이 (대기한 시간 + 돈을 인출하는데 걸리는 시간)
    answer += sum;          // 각 사람이 (대기한 시간 + 돈을 인출하는데 걸리는 시간)의 누적합
}
 
console.log(answer);
cs

 

 

반응형

'알고리즘(코딩테스트)' 카테고리의 다른 글

[백준] 주유소  (0) 2024.10.05
[백준] 수들의 합  (0) 2024.10.05
[백준] 설탕 배달  (0) 2024.10.04
[백준] 읽어버린 괄호  (0) 2024.10.04
[백준] 동전 0  (0) 2024.10.03
반응형

1.  문제

■ URL : https://www.acmicpc.net/problem/11047

 

2. 핵심요약

■ 1번째 Row, 1번째 Col : 동전의 갯수

■ 1번째 Row, 2번째 Col : 주어진 동전 가격의 합으로 만들어야할 합계 가격

■ 2번째 Row 부터 : 각 동전의 가격

1
2
3
4
5
6
7
8
9
10
11
10 4790
1
5
10
50
100
500
1000
5000
10000
50000
cs

 

 

3. 문제풀이 접근

■ 문제유형 : 탐욕(Greedy) 알고리즘

최소한의 동전 갯수만 사용하기 위해 동전 단가가 큰 것부터 써야 한다.

■ 몫 연산자와 나머지 연산자 문법을 알고 주어진 합계 가격으로부터 필요한 동전의 갯수(최소값)을 구한다.

    - 파이썬 연산자 문법 : 나눗셈의 몫(//), 나눗셈의 나머지(%)

    - 자바스크립트 연산자 문법 : 나눗셈의 몫(/), 나눗셈의 나머지(%)

 

4. 파이썬 코딩

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
isTest = True
if isTest:
    f = open("./11047.txt"'r')
    cnt, target = map(int, f.readline().split(' '))
else:
    cnt, target = map(int, input().split(' '))
 
arr = []
for i in range(1, cnt+1):
    if isTest:
        arr.append(int(f.readline()))
    else:
        arr.append(int(input()))
 
answer = 0
arr.reverse()
for item in arr:
    answer += target // item
    target = target % item
 
    if target == 0:
        break
 
print(answer)
 
cs

 

5. JavaScript 코딩

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
let isTest = true
 
let fs = require('fs');
let input;
if (isTest) {
    input = fs.readFileSync('./11047.txt').toString().split('\n');
else {
    input = fs.readFileSync('/dev/stdin').toString().split('\n');
}
 
let cnt = Number(input[0].split(' ')[0]);       // 동전의 갯수
let target = Number(input[0].split(' ')[1]);    // 목표값
 
arr = [];
for(let i = 1; i < cnt + 1; i++) {
    arr.push(Number(input[i]));
}
 
// 문제에서 동전의 가치는 이미 오름차순으로 주어짐.
answer = 0;
for(let i = arr.length - 1; i >= 0; i--) {
    answer += parseInt(target / arr[i]);
    target = target % arr[i];
 
    if (target === 0) {
        console.log(answer);
        return answer;
    }
}
cs

 

 

반응형

'알고리즘(코딩테스트)' 카테고리의 다른 글

[백준] 주유소  (0) 2024.10.05
[백준] 수들의 합  (0) 2024.10.05
[백준] 설탕 배달  (0) 2024.10.04
[백준] 읽어버린 괄호  (0) 2024.10.04
[백준] ATM  (1) 2024.10.03

+ Recent posts