검색결과 리스트

삼성에 해당되는 글 35건

글

[삼성 SW 역량 테스트] 아기 상어

삼성 SW 역량 테스트 기출 풀이 2019. 1. 11. 18:05





?
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
#include <stdio.h>
#include <queue>
using namespace std;
 
struct SHARK {
    int y, x, time;
};
 
int n;
int map[20][20];
 
int shark_size, shark_eat;
SHARK shark;
 
const int dy[] = { 0, 0, -1, +1 };
const int dx[] = { -1, +1, 0, 0 };
 
int main()
{
    scanf("%d", &n);
    for (int y = 0; y < n; ++y) {
        for (int x = 0; x < n; ++x) {
            scanf("%d", &map[y][x]);
            if (map[y][x] == 9) {
                shark.y = y, shark.x = x, shark.time = 0;
                shark_size = 2, shark_eat = 0;
                map[y][x] = 0;
            }
        }
    }
 
    bool is_update = true;
    while (is_update) {
        is_update = false;
 
        bool visited[20][20] = { false, };
        queue<shark> q;
        visited[shark.y][shark.x] = true;
        q.push(shark);
 
        SHARK candi;
        candi.y = 20, candi.time = -1;
        while (!q.empty()) {
            SHARK cur = q.front();  q.pop();
 
            if (candi.time != -1 && candi.time < cur.time) {
                break;
            }
 
            if (map[cur.y][cur.x] < shark_size && map[cur.y][cur.x] != 0) {
                is_update = true;
                if (candi.y > cur.y || (candi.y == cur.y && candi.x > cur.x)) {
                    candi = cur;
                }
            }
 
            for (int dir = 0; dir < 4; ++dir) {
                SHARK next;
                next.y = cur.y + dy[dir];
                next.x = cur.x + dx[dir];
                next.time = cur.time + 1;
 
                if (next.y < 0 || next.y >= n || next.x < 0 || next.x >= n) {
                    continue;
                }
 
                if (visited[next.y][next.x] == false && shark_size >= map[next.y][next.x]) {
                    visited[next.y][next.x] = true;
                    q.push(next);
                }
            }
        }
 
        if (is_update) {
            shark = candi;
            ++shark_eat;
            if (shark_eat == shark_size) {
                ++shark_size;
                shark_eat = 0;
            }
            map[shark.y][shark.x] = 0;
        }
    }
 
    printf("%d\n", shark.time);
 
    return 0;
}
</shark>


저작자표시 비영리 변경금지

설정

트랙백

댓글

글

[삼성 SW 역량 테스트]나무 재태크

삼성 SW 역량 테스트 기출 풀이 2019. 1. 11. 18:02





?
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
#include <stdio.h>
#include <algorithm>
using namespace std;
 
struct TREE {
    int y, x, age;
};
 
bool cmp(TREE& a, TREE& b) {
    return (a.age < b.age);
}
 
struct QUEUE {
    int f, b;
    TREE tree[684000];
 
    QUEUE() {
        init();
    }
 
    void init() {
        f = 0, b = 0;
    }
 
    bool isempty() {
        return (f == b);
    }
 
    void push(TREE val) {
        tree[b++] = val;
    }
 
    void pop() {
        ++f;
    }
 
    TREE front() {
        return tree[f];
    }
 
    int size() {
        return (b - f);
    }
};
 
int n, m, k;
QUEUE tree[2];
QUEUE new_tree;
QUEUE dead_tee, birth_of_child_tree;
 
TREE init_tree[100];
 
int map[10][10], add[10][10];
 
int main()
{
    scanf("%d %d %d", &n, &m, &k);
    for (int y = 0; y < n; ++y) {
        for (int x = 0; x < n; ++x) {
            scanf("%d", &add[y][x]);
            map[y][x] = 5;
        }
    }
 
    for (int i = 0; i < m; ++i) {
        scanf("%d %d %d", &init_tree[i].y, &init_tree[i].x, &init_tree[i].age);
        init_tree[i].y--, init_tree[i].x--;
    }
 
    sort(init_tree, init_tree + m, cmp);
     
    int cur = 0, next = 0;
    for (int i = 0; i < m; ++i) {
        tree[cur].push(init_tree[i]);
    }
     
    for (int i = 0; i < k; ++i) {
 
        next = (cur + 1) % 2;
         
        dead_tee.init();
        birth_of_child_tree.init();
        tree[next].init();
 
        while (!new_tree.isempty()) {
            TREE cur_tree = new_tree.front(); new_tree.pop();
 
            if (map[cur_tree.y][cur_tree.x] >= cur_tree.age) {
                map[cur_tree.y][cur_tree.x] -= cur_tree.age;
 
                ++cur_tree.age;
                tree[next].push(cur_tree);
            }
            else {
                dead_tee.push(cur_tree);
            }
        }
 
        while (!tree[cur].isempty()) {
            TREE cur_tree = tree[cur].front(); tree[cur].pop();
 
            if (map[cur_tree.y][cur_tree.x] >= cur_tree.age) {
                map[cur_tree.y][cur_tree.x] -= cur_tree.age;
 
                ++cur_tree.age;
                tree[next].push(cur_tree);
 
                if ((cur_tree.age % 5) == 0) {
                    birth_of_child_tree.push(cur_tree);
                }
            }
            else {
                dead_tee.push(cur_tree);
            }
        }
 
        while (!dead_tee.isempty()) {
            TREE cur_tree = dead_tee.front();   dead_tee.pop();
            map[cur_tree.y][cur_tree.x] += (cur_tree.age / 2);
        }
 
        const int dy[] = { -1, -1, -1, 0, 0, +1, +1, +1 };
        const int dx[] = { -1, 0, +1, -1, +1, -1, 0, +1 };
 
        new_tree.init();
        while (!birth_of_child_tree.isempty()) {
            TREE cur_tree = birth_of_child_tree.front();    birth_of_child_tree.pop();
            for (int dir = 0; dir < 8; ++dir) {
                TREE next_tree;
                next_tree.y = cur_tree.y + dy[dir];
                next_tree.x = cur_tree.x + dx[dir];
                next_tree.age = 1;
                if (next_tree.y < 0 || next_tree.y >= n || next_tree.x < 0 || next_tree.x >= n) {
                    continue;
                }
                new_tree.push(next_tree);
            }
        }
 
        for (int y = 0; y < n; ++y) {
            for (int x = 0; x < n; ++x) {
                map[y][x] += add[y][x];
            }
        }
 
        cur = next;
    }
 
    printf("%d\n", tree[next].size() + new_tree.size());
 
    return 0;
}


저작자표시 비영리 변경금지

설정

트랙백

댓글

글

[삼성 SW 역량 테스트] 인구 이동

삼성 SW 역량 테스트 기출 풀이 2019. 1. 11. 17:54





?
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
#include <stdio.h>
#include <algorithm>
#include <queue>
using namespace std;
 
struct POSI {
    int y, x;
};
 
int n, l, r;
int map[50][50];
 
void create_area(int sy, int sx, int status[][50], int index, int& count, int& sum) {
    int visited[50][50] = { 0, };
 
    const int dy[] = { 0, 0, -1, +1 };
    const int dx[] = { -1, +1, 0, 0 };
 
    queue<posi> q;
    POSI head;
    head.y = sy;
    head.x = sx;
    visited[sy][sx] = 1;
    q.push(head);
 
    while (!q.empty()) {
        POSI cur = q.front();   q.pop();
 
        status[cur.y][cur.x] = index;
        ++count;
        sum += map[cur.y][cur.x];
 
        for (int dir = 0; dir < 4; ++dir) {
            POSI next;
            next.y = cur.y + dy[dir];
            next.x = cur.x + dx[dir];
 
            if (next.y < 0 || next.y >= n || next.x < 0 || next.x >= n) {
                continue;
            }
 
            int delta = abs(map[cur.y][cur.x] - map[next.y][next.x]);
            if (visited[next.y][next.x] == 0 && l <= delta && delta <= r) {
                visited[next.y][next.x] = 1;
                q.push(next);
            }
        }
    }
}
 
 
int main()
{
    scanf("%d %d %d", &n, &l, &r);
    for (int y = 0; y < n; ++y) {
        for (int x = 0; x < n; ++x) {
            scanf("%d", &map[y][x]);
        }
    }
 
    int ret = 0;
    bool is_update = true;
    while (is_update) {
        is_update = false;
 
        int status[50][50] = { 0, };
        int area_index = 0;
        int count[2501] = { 0, };
        int sum[2501] = { 0, };
        for (int y = 0; y < n; ++y) {
            for (int x = 0; x < n; ++x) {
                if (status[y][x] == 0) {
                    ++area_index;
                    create_area(y, x, status, area_index, count[area_index], sum[area_index]);
                }
            }
        }
 
        for (int y = 0; y < n; ++y) {
            for (int x = 0; x < n; ++x) {
                int  index = status[y][x];
                int avg = sum[index] / count[index];
                if (map[y][x] != avg) {
                    map[y][x] = avg;
                    is_update = true;                  
                }
            }
        }
        if (is_update) {
            ++ret;
        }
    }
 
    printf("%d\n", ret);
    return 0;
}


저작자표시 비영리 변경금지

설정

트랙백

댓글

글

[삼성 SW 역량 테스트] 치킨 배달

삼성 SW 역량 테스트 기출 풀이 2019. 1. 11. 17:51





?
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
#include <stdio.h>
#include <algorithm>
#include <vector>
using namespace std;
 
struct POSI {
    int y, x;
};
 
int n, m, type, ret;
vector<POSI> house, shop, pick;
 
void dfs(int pos) {
    if (pick.size() == m) {
 
        int candi = 0;
        for (int i = 0; i < house.size(); ++i) {
            int min_dist = 1000000;
            for (int j = 0; j < pick.size(); ++j) {
                min_dist = min(min_dist,
                    abs(house[i].y - pick[j].y) + abs(house[i].x - pick[j].x));
            }
            candi += min_dist;
        }
 
        if (ret > candi) {
            ret = candi;
        }
 
        return;
    }
 
    for (int i = pos; i < shop.size(); ++i) {
        pick.push_back(shop[i]);
        dfs(i + 1);
        pick.pop_back();
    }
}
 
 
int main()
{
    POSI target;
    scanf("%d %d", &n, &m);
    for (int y = 0; y < n; ++y) {
        for (int x = 0; x < n; ++x) {
            scanf("%d", &type);
            if (type == 1) {
                target.y = y, target.x = x;
                house.push_back(target);
            }
            if (type == 2) {
                target.y = y, target.x = x;
                shop.push_back(target);
            }
        }
    }
 
    ret = 0x7fffffff;
    dfs(0);
    printf("%d\n", ret);
 
    return 0;
}


저작자표시 비영리 변경금지

설정

트랙백

댓글

글

[삼성 SW 역량 테스트] 드래곤 커브

삼성 SW 역량 테스트 기출 풀이 2019. 1. 11. 17:48





?
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
#include <stdio.h>
 
const int dy[] = { 0, -1, 0, +1 };
const int dx[] = { +1, 0, -1, 0 };
 
int main()
{
    int n;
    int map[101][101] = { 0, };
 
    scanf("%d", &n);
    for (int i = 0; i < n; ++i) {
         
        int curve_size = 0;
        int curve[1024] = { 0, };
 
        int x, y, d, g;
        scanf("%d %d %d %d", &x, &y, &d, &g);
 
        curve[curve_size++] = d;
        map[y][x] = 1;
 
        for (int j = 0; j < g; ++j) {
            for (int k = curve_size - 1; k >= 0; --k) {
                curve[curve_size++] = (curve[k] + 1) % 4;
            }
        }
 
        for (int j = 0; j < curve_size; ++j) {
            y += dy[curve[j]];
            x += dx[curve[j]];
            if (y < 0 || y >= 101 || x < 0 || x > 101) {
                continue;
            }
            map[y][x] = 1;
        }
    }
 
    int ret = 0;
    for (int y = 0; y < 100; ++y) {
        for (int x = 0; x < 100; ++x) {
            if (map[y][x] && map[y][x + 1] && map[y + 1][x] && map[y + 1][x + 1]) {
                ++ret;
            }
        }
    }
 
    printf("%d\n", ret);
 
    return 0;
}


저작자표시 비영리 변경금지

설정

트랙백

댓글

1 2 3 4 5 6 7
지역로그 : 태그 : 방명록 : 관리자 : 글쓰기
ㄴ ㅏ구팔이's Blog is powered by Daum & Tattertools / Designed by Tistory

티스토리툴바