728x90
 

문제

드래곤 커브는 다음과 같은 세 가지 속성으로 이루어져 있으며, 이차원 좌표 평면 위에서 정의된다. 좌표 평면의 x축은 → 방향, y축은 ↓ 방향이다.

  1. 시작 점
  2. 시작 방향
  3. 세대

0세대 드래곤 커브는 아래 그림과 같은 길이가 1인 선분이다. 아래 그림은 (0, 0)에서 시작하고, 시작 방향은 오른쪽인 0세대 드래곤 커브이다.

1세대 드래곤 커브는 0세대 드래곤 커브를 끝 점을 기준으로 시계 방향으로 90도 회전시킨 다음 0세대 드래곤 커브의 끝 점에 붙인 것이다. 끝 점이란 시작 점에서 선분을 타고 이동했을 때, 가장 먼 거리에 있는 점을 의미한다.

2세대 드래곤 커브도 1세대를 만든 방법을 이용해서 만들 수 있다. (파란색 선분은 새로 추가된 선분을 나타낸다)

3세대 드래곤 커브도 2세대 드래곤 커브를 이용해 만들 수 있다. 아래 그림은 3세대 드래곤 커브이다.

즉, K(K > 1)세대 드래곤 커브는 K-1세대 드래곤 커브를 끝 점을 기준으로 90도 시계 방향 회전 시킨 다음, 그것을 끝 점에 붙인 것이다.

크기가 100×100인 격자 위에 드래곤 커브가 N개 있다. 이때, 크기가 1×1인 정사각형의 네 꼭짓점이 모두 드래곤 커브의 일부인 정사각형의 개수를 구하는 프로그램을 작성하시오. 격자의 좌표는 (x, y)로 나타내며, 0 ≤ x ≤ 100, 0 ≤ y ≤ 100만 유효한 좌표이다.

입력

첫째 줄에 드래곤 커브의 개수 N(1 ≤ N ≤ 20)이 주어진다. 둘째 줄부터 N개의 줄에는 드래곤 커브의 정보가 주어진다. 드래곤 커브의 정보는 네 정수 x, y, d, g로 이루어져 있다. x와 y는 드래곤 커브의 시작 점, d는 시작 방향, g는 세대이다. (0 ≤ x, y ≤ 100, 0 ≤ d ≤ 3, 0 ≤ g ≤ 10)

입력으로 주어지는 드래곤 커브는 격자 밖으로 벗어나지 않는다. 드래곤 커브는 서로 겹칠 수 있다.

방향은 0, 1, 2, 3 중 하나이고, 다음을 의미한다.

  • 0: x좌표가 증가하는 방향 (→)
  • 1: y좌표가 감소하는 방향 (↑)
  • 2: x좌표가 감소하는 방향 (←)
  • 3: y좌표가 증가하는 방향 (↓)

출력

첫째 줄에 크기가 1×1인 정사각형의 네 꼭짓점이 모두 드래곤 커브의 일부인 것의 개수를 출력한다.

예제 입력 1

3
3 3 0 1
4 2 1 3
4 2 2 1

예제 출력 1

4

예제 입력 2

4
3 3 0 1
4 2 1 3
4 2 2 1
2 7 3 4

예제 출력 2

11

예제 입력 3

10
5 5 0 0
5 6 0 0
5 7 0 0
5 8 0 0
5 9 0 0
6 5 0 0
6 6 0 0
6 7 0 0
6 8 0 0
6 9 0 0

예제 출력 3

8

예제 입력 4

4
50 50 0 10
50 50 1 10
50 50 2 10
50 50 3 10

예제 출력 4

1992

 

힌트


예제 1 예제 2
 

설명 

이런종류의 문제는 규칙을 찾아보자!

[ 0 = → , 1 = ↑ , 2 = ← , 3 = ↓ ]

세대       |   방향 정보

0               0

1               0  1

2               0  1  2  1

3               0  1  2  1  2  3  2  1

다음 세대의 추가되는 선분의 방향정보 = 이전 세대의 방향정보를 역순으로 탐색하면서 +1 % 4 를 한 것이 된다.

make_dragon_curve() 함수를 이용하여 map에 좌표를 찍어주고

count_square() 함수를 이용하여 좌표에 정사각형을 찾는다!

 

 

 


소스코드

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
#include <iostream>
#include <vector>
#define MAX 101
using namespace std;
int n, x, y, g, d, ans;
vector<int> dir;
int map[MAX][MAX];
int dx[] = { 10-10 };
int dy[] = { 0-101 };
void make_dragon_curve()
{
    int size = dir.size();
    for (int i = size - 1; i >= 0; i--)
    {
        int next_d = (dir[i] + 1) % 4;
        x += dx[next_d];
        y += dy[next_d];
        map[y][x] = 1;
        dir.push_back(next_d);
    }
}
void count_square()
{
    for (int i = 0; i < MAX; i++)
    {
        for (int j = 0; j < MAX; j++)
        {
            if (map[i][j]==1 && map[i][j + 1== 1 && map[i + 1][j] == 1 && map[i + 1][j + 1]==1)
                ans++;
        }
    }
}
int main()
{
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        cin >> x >> y >> d >> g;
 
        dir.clear();
 
        map[y][x] = 1;
        x += dx[d];
        y += dy[d];
        map[y][x] = 1;
        dir.push_back(d);
        for (int j = 0; j < g; j++)
        {
            make_dragon_curve();
        }
    }
    count_square();
    cout << ans;
    return 0;
}
cs

https://yabmoons.tistory.com/60

 

[ 백준 15685 ] 드래곤 커브 (C++)

백준의 드래곤커브(15685) 문제이다. ( 문제 바로가기 ) 삼성의 SW역량테스트 기출문제이다. [ 문제풀이 ] 1. 그냥 문제를 보면 무슨소린지도 잘 모르겠고, 드래곤커브가 뭔지도 잘 모르겠다 사실.

yabmoons.tistory.com

참고하였습니다. 감사합니다.~

LIST
728x90

사다리 조작

사다리 게임은 N개의 세로선과 M개의 가로선으로 이루어져 있다. 인접한 세로선 사이에는 가로선을 놓을 수 있는데, 각각의 세로선마다 가로선을 놓을 수 있는 위치의 개수는 H이고, 모든 세로선이 같은 위치를 갖는다. 아래 그림은 N = 5, H = 6 인 경우의 그림이고, 가로선은 없다.

초록선은 세로선을 나타내고, 초록선과 점선이 교차하는 점은 가로선을 놓을 수 있는 점이다. 가로선은 인접한 두 세로선을 연결해야 한다. 단, 두 가로선이 연속하거나 서로 접하면 안 된다. 또, 가로선은 점선 위에 있어야 한다.

위의 그림에는 가로선이 총 5개 있다. 가로선은 위의 그림과 같이 인접한 두 세로선을 연결해야 하고, 가로선을 놓을 수 있는 위치를 연결해야 한다.

사다리 게임은 각각의 세로선마다 게임을 진행하고, 세로선의 가장 위에서부터 아래 방향으로 내려가야 한다. 이때, 가로선을 만나면 가로선을 이용해 옆 세로선으로 이동한 다음, 이동한 세로선에서 아래 방향으로 이동해야 한다.

위의 그림에서 1번은 3번으로, 2번은 2번으로, 3번은 5번으로, 4번은 1번으로, 5번은 4번으로 도착하게 된다. 아래 두 그림은 1번과 2번이 어떻게 이동했는지 나타내는 그림이다.

1번 세로선 2번 세로선

사다리에 가로선을 추가해서, 사다리 게임의 결과를 조작하려고 한다. 이때, i번 세로선의 결과가 i번이 나와야 한다. 그렇게 하기 위해서 추가해야 하는 가로선 개수의 최솟값을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 세로선의 개수 N, 가로선의 개수 M, 세로선마다 가로선을 놓을 수 있는 위치의 개수 H가 주어진다. (2 ≤ N ≤ 10, 1 ≤ H ≤ 30, 0 ≤ M ≤ (N-1)×H)

둘째 줄부터 M개의 줄에는 가로선의 정보가 한 줄에 하나씩 주어진다.

가로선의 정보는 두 정수 a과 b로 나타낸다. (1 ≤ a ≤ H, 1 ≤ b ≤ N-1) b번 세로선과 b+1번 세로선을 a번 점선 위치에서 연결했다는 의미이다.

가장 위에 있는 점선의 번호는 1번이고, 아래로 내려갈 때마다 1이 증가한다. 세로선은 가장 왼쪽에 있는 것의 번호가 1번이고, 오른쪽으로 갈 때마다 1이 증가한다.

입력으로 주어지는 가로선이 서로 연속하는 경우는 없다.

출력

i번 세로선의 결과가 i번이 나오도록 사다리 게임을 조작하려면, 추가해야 하는 가로선 개수의 최솟값을 출력한다. 만약, 정답이 3보다 큰 값이면 -1을 출력한다. 또, 불가능한 경우에도 -1을 출력한다.

 


문제 :  모든 라인이 자기자신의 번호에 도달하도록 추가 사다리의 최솟값 출력하는 문제!

 

깊이우선탐색을 이용하여 0개일 떄, 1개일때, 2개일때, 3개일때 모든 경우의 수를 찾되, 찾았으면 더이상 코드가 실행하지 않도록 처리 해준다.

 

추가 사다리를 놓을수 있는 경우는 놓고싶은 위치의 [해당 위치, 왼쪽, 오른쪽]에 가로 사다리가 없을 경우 가능하다

(lline 42)

 

이 문제에서는 배열의 범위 때문에 고생을 좀 했다. 

 

코드는 다른분의 코드를 참고하였는데 좀 오래되서 기억이안나는데... 아무튼 감사합니다.

 


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
73
#include <iostream>
#include<algorithm>
#define MAX 30
using namespace std;
 
int n, m, h;
int ladderCnt;
bool flag;
bool map[MAX][11];
 
void dfs(int y, int depth)
{
    if (flag)
        return;
    if (ladderCnt == depth)
    {
        bool possible = true;
        for (int i = 1; i <=n; i++)
        {
            int row = i;
            for (int j = 0; j < h; j++)
            {
                if (map[j][row])
                    row++;
                else if (row > 1 && map[j][row - 1])
                    row--;
            }
            if (i != row)
            {
                possible = false;
                break;
            }
        }
        if (possible)
            flag = true;
        return;
    }
    for (int i = y; i < h; i++)
    {
        for (int j = 1; j < n; j++)
        {
            if (!map[i][j - 1&& !map[i][j] && !map[i][j + 1])
            {
                map[i][j] = true;
                dfs(i, depth + 1);
                map[i][j] = false;
            }
        }
    }
    return;
}
int main()
{
    cin >> n >> m >> h;
    for (int i = 0; i < m; i++)
    {
        int y, x;
        cin >> y >> x;
        map[y - 1][x] = true;
    }
    for (int i = 0; i <= 3; i++)
    {
        ladderCnt = i;
        dfs(00);
        if (flag)
        {
            cout << ladderCnt;
            return 0;
        }
    }
    cout << -1;
    return 0;
}
cs
LIST
728x90

문제

스타트링크의 사무실은 1×1크기의 정사각형으로 나누어져 있는 N×M 크기의 직사각형으로 나타낼 수 있다. 사무실에는 총 K개의 CCTV가 설치되어져 있는데, CCTV는 5가지 종류가 있다. 각 CCTV가 감시할 수 있는 방법은 다음과 같다.

1번 2번 3번 4번 5번

1번 CCTV는 한 쪽 방향만 감시할 수 있다. 2번과 3번은 두 방향을 감시할 수 있는데, 2번은 감시하는 방향이 서로 반대방향이어야 하고, 3번은 직각 방향이어야 한다. 4번은 세 방향, 5번은 네 방향을 감시할 수 있다.

CCTV는 감시할 수 있는 방향에 있는 칸 전체를 감시할 수 있다. 사무실에는 벽이 있는데, CCTV는 벽을 통과할 수 없다. CCTV가 감시할 수 없는 영역은 사각지대라고 한다.

CCTV는 회전시킬 수 있는데, 회전은 항상 90도 방향으로 해야 하며, 감시하려고 하는 방향이 가로 또는 세로 방향이어야 한다.

0 0 0 0 0 0
0 0 0 0 0 0
0 0 1 0 6 0
0 0 0 0 0 0

지도에서 0은 빈 칸, 6은 벽, 1~5는 CCTV의 번호이다. 위의 예시에서 1번의 방향에 따라 감시할 수 있는 영역을 '#'로 나타내면 아래와 같다.

0 0 0 0 0 0
0 0 0 0 0 0
0 0 1 # 6 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
# # 1 0 6 0
0 0 0 0 0 0
0 0 # 0 0 0
0 0 # 0 0 0
0 0 1 0 6 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 1 0 6 0
0 0 # 0 0 0

CCTV는 벽을 통과할 수 없기 때문에, 1번이 → 방향을 감시하고 있을 때는 6의 오른쪽에 있는 칸을 감시할 수 없다.

0 0 0 0 0 0
0 2 0 0 0 0
0 0 0 0 6 0
0 6 0 0 2 0
0 0 0 0 0 0
0 0 0 0 0 5

위의 예시에서 감시할 수 있는 방향을 알아보면 아래와 같다.

0 0 0 0 0 #
# 2 # # # #
0 0 0 0 6 #
0 6 # # 2 #
0 0 0 0 0 #
# # # # # 5
0 0 0 0 0 #
# 2 # # # #
0 0 0 0 6 #
0 6 0 0 2 #
0 0 0 0 # #
# # # # # 5
0 # 0 0 0 #
0 2 0 0 0 #
0 # 0 0 6 #
0 6 # # 2 #
0 0 0 0 0 #
# # # # # 5
0 # 0 0 0 #
0 2 0 0 0 #
0 # 0 0 6 #
0 6 0 0 2 #
0 0 0 0 # #
# # # # # 5
왼쪽 상단 2: ↔, 오른쪽 하단 2: ↔ 왼쪽 상단 2: ↔, 오른쪽 하단 2: ↕ 왼쪽 상단 2: ↕, 오른쪽 하단 2: ↔ 왼쪽 상단 2: ↕, 오른쪽 하단 2: ↕

CCTV는 CCTV를 통과할 수 있다. 아래 예시를 보자.

0 0 2 0 3
0 6 0 0 0
0 0 6 6 0
0 0 0 0 0

위와 같은 경우에 2의 방향이 ↕ 3의 방향이 ←와 ↓인 경우 감시받는 영역은 다음과 같다.

# # 2 # 3
0 6 # 0 #
0 0 6 6 #
0 0 0 0 #

사무실의 크기와 상태, 그리고 CCTV의 정보가 주어졌을 때, CCTV의 방향을 적절히 정해서, 사각 지대의 최소 크기를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 사무실의 세로 크기 N과 가로 크기 M이 주어진다. (1 ≤ N, M ≤ 8)

둘째 줄부터 N개의 줄에는 사무실 각 칸의 정보가 주어진다. 0은 빈 칸, 6은 벽, 1~5는 CCTV를 나타내고, 문제에서 설명한 CCTV의 종류이다. 

CCTV의 최대 개수는 8개를 넘지 않는다.

출력

첫째 줄에 사각 지대의 최소 크기를 출력한다.


첫 번째 풀이 방법(시간 초과)

0. dfs() 호출

1. map[i][j]을 temp[i][j]에 복사

2. map[i][j] 변경

3. 조건 충족 후 temp[i][j]로 되돌리기.

이때 map[i][j] == 1,2,3,4,5 일 때 모두 배열의 복사, 되돌리기 진행,--> 시간 초과

 

두 번째 풀이 방법(정답)

0. dfs() 호출

1. 동서남북 네 가지 방향에 대한 반복문 안에서 감시범위 체크, dfs(), 다시 되돌리기 함수 실행

2. visited[][] 배열에 감시카메라가 닿는 모든 칸에 +1

3. dfs(depth + 1) 호출

4. visited[][] 배열에 감시카메라가 닿는 모든 칸에 -1

5. depth == (1~5)의 개수 일 때 visited[][]의 0의 개수 비교

*주의사항 dx dy를 시계방향, 반시계 방향 순서대로 정의해야 한다.

예를 들어 좌우상하라고 설정하면

2번 케이스일 때 (좌우)(우상)(상하)(하좌) 이런 식으로 방향이 틀려지게 된다.


 

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
#include <iostream>
#include <vector>
#include <algorithm>
#define MAX 8
using namespace std;
int n, m;
int map[MAX][MAX], visited[MAX][MAX];
//하, 좌, 상, 우
int dx[] = { 0-101 };
int dy[] = { 10-10 };
struct pos {
    int y, x;
};
vector<pos> v;
int ans = 1e9;
void check(int y, int x, int dir, int num)
{
    int ny = y;
    int nx = x;
    while (true)
    {
        ny += dy[dir];
        nx += dx[dir];
        if (map[ny][nx] == 6)
            break;
        if (ny >= 0 && nx >= 0 && ny < n && nx < m)
            visited[ny][nx] += num;
        else
            break;
    }
}
void rotate(int depth, int i, int num)
{
    int y = v[depth].y;
    int x = v[depth].x;
    int number = map[y][x];
    switch (number)
    {
    case 1:
        check(y, x, (i + 3) % 4, num);
        break;
    case 2:
        check(y, x, (i + 1) % 4, num);
        check(y, x, (i + 3) % 4, num);
        break;
    case 3:
        check(y, x, (i + 2) % 4, num);
        check(y, x, (i + 3) % 4, num);
        break;
    case 4:
        check(y, x, (i + 1) % 4, num);
        check(y, x, (i + 2) % 4, num);
        check(y, x, (i + 3) % 4, num);
        break;
    case 5:
        check(y, x, (i + 0) % 4, num);
        check(y, x, (i + 1) % 4, num);
        check(y, x, (i + 2) % 4, num);
        check(y, x, (i + 3) % 4, num);
        break;
    }
}
void solve(int depth)
{
    if (depth == v.size())
    {
        int cnt = 0;
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < m; j++)
            {
                if (visited[i][j] == 0)
                    cnt++;
            }
        }
        ans = min(ans, cnt);
        return;
    }
    for (int i = 0; i < 4; i++)
    {
        rotate(depth, i, 1);
        solve(depth + 1);
        rotate(depth, i, -1);
    }
}
int main()
{
    cin >> n >> m;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            cin >> map[i][j];
            if (map[i][j] != 0 && map[i][j] != 6)
            {
                v.push_back({ i,j });
                visited[i][j] = map[i][j];
            }
            if (map[i][j] == 6)
                visited[i][j] = 6;
        }
    }
    solve(0);
    cout << ans;
    return 0;
}
cs

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

 

15683번: 감시

스타트링크의 사무실은 1×1크기의 정사각형으로 나누어져 있는 N×M 크기의 직사각형으로 나타낼 수 있다. 사무실에는 총 K개의 CCTV가 설치되어져 있는데, CCTV는 5가지 종류가 있다. 각 CCTV가 감

www.acmicpc.net

 

LIST
728x90

로봇 청소기 

문제

로봇 청소기가 주어졌을 때, 청소하는 영역의 개수를 구하는 프로그램을 작성하시오.

로봇 청소기가 있는 장소는 N×M 크기의 직사각형으로 나타낼 수 있으며, 1×1크기의 정사각형 칸으로 나누어져 있다. 각각의 칸은 벽 또는 빈 칸이다. 청소기는 바라보는 방향이 있으며, 이 방향은 동, 서, 남, 북중 하나이다. 지도의 각 칸은 (r, c)로 나타낼 수 있고, r은 북쪽으로부터 떨어진 칸의 개수, c는 서쪽으로 부터 떨어진 칸의 개수이다.

로봇 청소기는 다음과 같이 작동한다.

  1. 현재 위치를 청소한다.
  2. 현재 위치에서 현재 방향을 기준으로 왼쪽방향부터 차례대로 탐색을 진행한다.
    1. 왼쪽 방향에 아직 청소하지 않은 공간이 존재한다면, 그 방향으로 회전한 다음 한 칸을 전진하고 1번부터 진행한다.
    2. 왼쪽 방향에 청소할 공간이 없다면, 그 방향으로 회전하고 2번으로 돌아간다.
    3. 네 방향 모두 청소가 이미 되어있거나 벽인 경우에는, 바라보는 방향을 유지한 채로 한 칸 후진을 하고 2번으로 돌아간다.
    4. 네 방향 모두 청소가 이미 되어있거나 벽이면서, 뒤쪽 방향이 벽이라 후진도 할 수 없는 경우에는 작동을 멈춘다.

로봇 청소기는 이미 청소되어있는 칸을 또 청소하지 않으며, 벽을 통과할 수 없다.

입력

첫째 줄에 세로 크기 N과 가로 크기 M이 주어진다. (3 ≤ N, M ≤ 50)

둘째 줄에 로봇 청소기가 있는 칸의 좌표 (r, c)와 바라보는 방향 d가 주어진다. d가 0인 경우에는 북쪽을, 1인 경우에는 동쪽을, 2인 경우에는 남쪽을, 3인 경우에는 서쪽을 바라보고 있는 것이다.

셋째 줄부터 N개의 줄에 장소의 상태가 북쪽부터 남쪽 순서대로, 각 줄은 서쪽부터 동쪽 순서대로 주어진다. 빈 칸은 0, 벽은 1로 주어진다. 지도의 첫 행, 마지막 행, 첫 열, 마지막 열에 있는 모든 칸은 벽이다.

로봇 청소기가 있는 칸의 상태는 항상 빈 칸이다.

출력

로봇 청소기가 청소하는 칸의 개수를 출력한다.


이 문제에서 고려해야할 요소는 map[y][x] == 0 이면 출력 변수 ++ 해주고, 

다음 방향 탐색 -> 4방향 모두 막혀 있으면 뒤로 이동, 이때 뒤에가 벽이면 멈춘다.

그래서 for(int i=0;i< 4;i++){} 구문에 탐색하는 코드를 넣어 탐색에 실패했을경우 문제의 2.3에 해당하는지 2.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
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
/* 로봇 청소기 영역의 개수를 구하는 프로그램 */
//n x m 영역 빈칸 or 벽
//방향 : 동 서 남 북
//로봇청소기 루틴
// 1. 현재 위치 청소
// 2. 현재위치에서 왼쪽방향부터 탐색
//   a. 왼쪽 방향이 청소하지 않았으면 그방향으로 전진 -> 1
//   b. 왼쪽 방향에 청소할 공간이 없으면, 그 방향 회전 -> 2
//   c. 네 방향 모두 청소가 이미 되어있거나 벽이면, 바라보는 방향 유지한 채로 후진 -> 2
//   d. 네 방향 모두 청소가 이미 되어있거나 벽이면서 뒤쪽방향도 벽이면 멈춤
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
int n, m;
int input[50][50];
int y, x;
int ans;
int dir;
//북 동 남 서
int dx[] = { 010-1 };
int dy[] = { -1010 };
 
int left_dir(int d)
{
    if (d == 0)
    {
        return 3;
    }
    else if (d == 1)
    {
        return 0;
    }
    else if (d == 2)
    {
        return 1;
    }
    else
        return 2;
}
void solve()
{
    while (true)
    {
        if (input[y][x] == 0)
        {
            input[y][x] = 2;
            ans++;
        }
        bool nextClean = false;
        for (int i = 0; i < 4; i++)
        {
            dir = left_dir(dir);
            int ny = y + dy[dir];
            int nx = x + dx[dir];
 
            if (input[ny][nx] == 0)
            {
                x = nx;
                y = ny;
                nextClean = true;
                break;
            }
        }
        if (nextClean) continue;
        //뒤
        int back_d = left_dir(left_dir(dir));
        y = y + dy[back_d];
        x = x + dx[back_d];
 
        if (input[y][x] == 1)
            break;
    }
}
int main()
{
    cin >> n >> m;
 
    //입력 y, x, 바라보는 방향 d
    //d = 0 : 북 // d = 1 : 동 // d = 2 : 남 // d = 3 : 서
    cin >> y >> x >> dir;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            cin >> input[i][j];
        }
    }
    solve();
    cout << ans;
    return 0;
}
cs
LIST

+ Recent posts