반응형

문제 출처

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

 

문제 설명

스택 성질에 대해 이해가 필요한 문제입니다. 처음에 고민하다가 입력받은 숫자가 나올때까지 push하다가 입력받은 숫자가 나오면 pop해주면 쉽게 풀 수 있는 문제입니다. idea가 필요했던 문제!

 

소스 코드

//
//  main.cpp
//  BOJ_1874
//
//  Created by sw on 17/12/2019.
//  Copyright © 2019 seungwoo. All rights reserved.
//

#include <iostream>
#include <stack>
#include <vector>
using namespace std;
int main(int argc, const char * argv[]) {
    ios_base::sync_with_stdio(0); cin.tie(0);
    int n;
    cin>>n;
    int num[n];
    vector<char> ret;
    stack<int> st;
    
    for (int i=0; i<n; i++) cin>>num[i];
    
    int idx=0;
    for (int i=1; i<=n; i++) {
        st.push(i);
        ret.push_back('+');

        while (!st.empty() && st.top() == num[idx]) {
            idx++;
            st.pop();
            ret.push_back('-');
        }
    }
    
    if (!st.empty()) cout<<"NO"<<"\n";
    else for (auto c : ret) cout<<c<<"\n";
    
    return 0;
}
반응형

'Algorithm' 카테고리의 다른 글

[BOJ 14888] 연산자 끼워넣기  (0) 2020.01.02
[BOJ 9021] 괄호  (0) 2019.12.18
[BOJ 15649] N과 M(1)  (0) 2019.10.30
[BOJ 13460] 구슬 탈출2  (0) 2019.10.09
[SWEA 1953] 탈주범 검거  (0) 2019.08.23
반응형

[문제 출처]

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

 

1부터 N까지 자연수중 길이가 M인 순열을 출력하는 문제입니다.

 

[순열 ?]

 순열은 주어진 수열에서 순서에 따라 결과가 달라지는 방식입니다. 즉 순서가 존재하는 열인 것이죠.

c++기준 next_permutation / prev_permutation과 같은 STL함수를 통해 쉽게 구현할 수 있습니다. 

 

[문제풀이]

 완전 탐색을 통해 문제를 풀이합니다. DFS방식으로 basecase조건 충족시 출력을 하고 함수에서 나오는 방법입니다. 이때 visit배열로 방문여부를 체크하여 중복 값이 사용되는 것, 다시말해 같은 수를 여러번 고르는 경우를 방지하면 됩니다.

 

[소스코드]

#include <iostream>
#include <vector>
using namespace std;
int n,m;
vector<int> v;
bool visit[9];
void solve(int cnt) {
	if (cnt == m) {
		for (int i=0; i<v.size(); i++) cout<<v[i]<<" ";
		cout<<"\n";
		return;
	}
	
	for (int i=1; i<=n; i++) {
		if (visit[i]) continue;
		visit[i] = 1;
		v.push_back(i);
		solve(cnt+1);
		visit[i] = 0;
		v.pop_back();
	}
}
int main() {
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cin>>n>>m;
	solve(0);
	return 0;	
}

 

반응형

'Algorithm' 카테고리의 다른 글

[BOJ 9021] 괄호  (0) 2019.12.18
[BOJ 1874] 스택 수열  (0) 2019.12.17
[BOJ 13460] 구슬 탈출2  (0) 2019.10.09
[SWEA 1953] 탈주범 검거  (0) 2019.08.23
[SWEA 5644] 무선충전  (0) 2019.08.19
반응형

문제출처

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


문제풀이

 삼성 역량테스트 기출문제 입니다.

문제에서 원하는 답은 보드를 상,하,좌,우 방향으로 기울였을때 빨간구슬만을 구멍으로 빼낼 수 있는 최소횟수입니다. 이때, 파란구슬은 빠지면 안되고 보드는 총 10번 이하로 움직여야 합니다. 출력은 목적을 달성하는 최소횟수이고 파란구슬이 빠지거나 보드를 10번이상 움직였다면 -1을 출력하면 됩니다.


문제이해를 위해 예제를 따라해보면 더 쉽게 이해하실 수 있습니다.

예제를 따라하면 처음에 왼쪽으로 움직이고 다음번에 오른쪽으로 움직인경우 구슬의 위치가 같은 것을 알 수 있습니다. 또한 같은 방향으로 반복적으로 움직여도 구슬의 위치에는 영향을 받지 않는다는 것을 알 수 있습니다.

즉, 같은방향 혹은 이전방향과 반대방향으로 움직일 경우는 제외해도 됩니다. (구슬의 위치가 같다면 이러한 경우에 해당됩니다.)


문제풀이 과정은 다음과 같습니다.

1.  빨간공을 움직입니다.


2. 파란공을 움직입니다.


3. 파란공이 구멍으로 빠진경우 잘못된 경우이므로 제외합니다.


4. 빨간공과 파란공의 위치가 중복된 경우 공의 위치를 재조정합니다.

    만약 빨간공이 3칸, 파란공이 2칸이동했다면 빨간공의 위치를 이동방향 기준으로 1번 뒤로 되돌립니다.

    예를 들어 # . . R B #일때 왼쪽으로 기울인다면 공의 위치가 겹치기 때문에 # (R,B) . . . # 와 같은 상태입니다.

    이 경우 빨간공이 2칸, 파란공이 3칸움직였기 때문에 파란공을 오른쪽으로 1번 되돌려야 정상적인 좌표를 가지게 됩니다.


5. 이과정을 반복하면서 빨간공만 빠지고 움직인 횟수가 10번이내라면 횟수를 출력하고 이외의 경우에는 -1을 출력합니다.


소스코드


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
//
//  main.cpp
//  BOJ_13460(구슬탈출2)
//
//  Created by seungwoo on 08/10/2019.
//  Copyright © 2019 seungwoo. All rights reserved.
//
#include <iostream>
#include <queue>
#define MAX 10
using namespace std;
int n, m, srx, sry, sbx, sby;
char board[MAX][MAX+1]; // x축 공간을 +1한 이유는 char형시 널문자를 저장하기 위함
const char BLOCK     = '#';
const char HOLE      = 'O';
const char RED_BALL  = 'R';
const char BLUE_BALL = 'B';
struct BALL {
    int ry, rx, by, bx, moveCnt;
};
 
int bfs() {
    const int dy[] = {001-1};
    const int dx[] = {1-100};
    bool visit[MAX][MAX][MAX][MAX] = {0,};
    queue<BALL> q;
    q.push({sry, srx, sby, sbx, 0});
    visit[sry][srx][sby][sbx] = 1;
    
    while (!q.empty()) {
        BALL curBall = q.front();
        q.pop();
        
        // 7. 빨간공이 현재 구멍으로 빠졌을 경우 정답 return
        if (board[curBall.ry][curBall.rx] == HOLE) {
            return curBall.moveCnt;
        }
        
        for (int i=0; i<4; i++) {
            int nry = curBall.ry;
            int nrx = curBall.rx;
            int nby = curBall.by;
            int nbx = curBall.bx;
            int moveRedCnt = 0;
            int moveBlueCnt = 0;
            
            // 1. 빨간공을 움직임
            // 빨간공의 다음위치가 벽이 아니고 현위치가 구멍이 아닐때까지 반복
            while (board[nry + dy[i]][nrx + dx[i]] != BLOCK && board[nry][nrx] != HOLE) {
                nry += dy[i];
                nrx += dx[i];
                moveRedCnt++;
            }
            
            // 2. 파란공을 움직임
            // 파란공의 다음위치가 벽이 아니고 현위치가 구멍이 아닐때까지 반복
            while (board[nby + dy[i]][nbx + dx[i]] != BLOCK && board[nby][nbx] != HOLE) {
                nby += dy[i];
                nbx += dx[i];
                moveBlueCnt++;
            }
            
            // 3. 파란공이 빠진경우 제외
            if (board[nby][nbx] == HOLE) continue;
            
            // 4. 공이 겹친경우 위치를 재조정
            // 더 많이 움직인 공을 재조정
            if (nry == nby && nrx == nbx) {
                moveRedCnt > moveBlueCnt ? (nry-=dy[i], nrx-=dx[i]) : (nby-=dy[i], nbx-=dx[i]);
            }
            
            // 5. 이미 방문한 위치는 무의미하므로 제외
            if (visit[nry][nrx][nby][nbx]) continue;
            
            // 6. 판을 기울인 횟수가 10번이내일 경우 반복
            if (curBall.moveCnt < 10) {
                visit[nry][nrx][nby][nbx] = 1;
                q.push({nry, nrx, nby, nbx, curBall.moveCnt+1});
            }
            
        }
    }
    
    // 7. 불가능하거나 10번이상인 경우 -1 return
    return -1;
}
 
void solve() {
    cin>>n>>m;
    for (int y=0; y<n; y++) {
        for (int x=0; x<m; x++) {
            cin>>board[y][x];
            if (board[y][x] == RED_BALL) sry=y, srx=x;
            if (board[y][x] == BLUE_BALL) sby=y, sbx=x;
        }
    }
    
    cout<<bfs();
}
 
int main(int argc, const char * argv[]) {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    solve();
    return 0;
}
 
cs


반응형

'Algorithm' 카테고리의 다른 글

[BOJ 1874] 스택 수열  (0) 2019.12.17
[BOJ 15649] N과 M(1)  (0) 2019.10.30
[SWEA 1953] 탈주범 검거  (0) 2019.08.23
[SWEA 5644] 무선충전  (0) 2019.08.19
[SWEA 1949] 등산로 조성  (0) 2019.08.19
반응형

문제풀이

 일반적인 bfs로 풀이 하였다. 큐에 소요시간 정보와 현재 위치를 저장한 구조체를 넣어 문제를 해결했다.

하지만 여기서 다음 파이프의 조건을 판단할때 반대로 생각해야 한다는 것이 매우 중요했다. 이 문제의 핵심 포인트이다!! 

계속 지체되었던 부분인데 현재 위치에서 오른쪽으로 간다고 가정한다면, 다음위치의 파이프는 왼쪽이 뚫려있어야 한다! 


소스코드


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
#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
int n, m, r, c, l;
int dy[] = {-1100};
int dx[] = {00-11};
int map[50][50];
bool visit[50][50];
struct node {
    int y, x, time;
    node(int _y, int _x, int _time) {
        y = _y;
        x = _x;
        time = _time;
    }
};
void init() {
    memset(map, 0sizeof(map));
    memset(visit, 0sizeof(visit));
 
    cin>>n>>m>>r>>c>>l;
    for (int y=0; y<n; y++
        for (int x=0; x<m; x++)
            cin>>map[y][x];
}
void bfs() {
    queue<node> q;
    q.push(node(r, c, 1));
    visit[r][c]=1;
    
    while (!q.empty()) {
        int y = q.front().y;
        int x = q.front().x;
        int elapsedTime = q.front().time;
        int curPipeType = map[y][x];
        q.pop();
        
        if (elapsedTime == l) continue;
        
        for (int i=0; i<4; i++) {
            int ny = y + dy[i];
            int nx = x + dx[i];
            int nextPipeType = map[ny][nx];
            
            if (ny<0 || nx<0 || ny>=|| nx>=|| nextPipeType == 0 || visit[ny][nx]) continue;
            /*******************************************************
                                 dx, dy 조건         
                    i=0 -> 상 / i=1 -> 하 / i=2 -> 좌 / i=3 -> 우
                    
                                 PipeType 조건
               1 -> 상/하/좌/우
               2 -> 상/하
               3 -> 좌/우
               4 -> 상/우
               5 -> 하/우
               6 -> 하/좌
               7 -> 상/좌
            *******************************************************/ 
            if (curPipeType == 2 && (i == 2 || i == 3)) continue;
            else if (curPipeType == 3 && (i == 0 || i == 1)) continue;
            else if (curPipeType == 4 && (i == 1 || i == 2)) continue;
            else if (curPipeType == 5 && (i == 0 || i == 2)) continue;
            else if (curPipeType == 6 && (i == 0 || i == 3)) continue;
            else if (curPipeType == 7 && (i == 1 || i == 3)) continue;
            
            // 여기서 반대가 되어야함
            // 즉 현재위치에서 왼쪽으로 간다면 다음 파이프는 오른쪽이 뚫려있어야 통과 가능 
            if (i == 0) {
                if (nextPipeType == 1 || nextPipeType == 2 || nextPipeType == 5 || nextPipeType == 6) {
                    visit[ny][nx]=1;
                    q.push(node(ny, nx, elapsedTime+1));
                }
            } else if (i == 1) {
                if (nextPipeType == 1 || nextPipeType == 2 || nextPipeType == 4 || nextPipeType == 7) {
                    visit[ny][nx]=1;
                    q.push(node(ny, nx, elapsedTime+1));
                }
            } else if (i == 2) {
                if (nextPipeType == 1 || nextPipeType == 3 || nextPipeType == 4 || nextPipeType == 5) {
                    visit[ny][nx]=1;
                    q.push(node(ny, nx, elapsedTime+1));
                }
            } else {
                if (nextPipeType == 1 || nextPipeType == 3 || nextPipeType == 6 || nextPipeType == 7) {
                    visit[ny][nx]=1;
                    q.push(node(ny, nx, elapsedTime+1));
                }
            }
        }
    }
}
int getAnswer() {
    int ans=0;
    for (int y=0; y<n; y++)
        for (int x=0; x<m; x++)
            if (visit[y][x]) ans++;
            
    return ans;    
}
int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    int tc;
    cin>>tc;
    for (int t=1; t<=tc; t++) {
        init();
        bfs();
        
        cout<<"#"<<t<<" "<<getAnswer()<<"\n";    
    }
    return 0;    
}
cs


반응형

'Algorithm' 카테고리의 다른 글

[BOJ 15649] N과 M(1)  (0) 2019.10.30
[BOJ 13460] 구슬 탈출2  (0) 2019.10.09
[SWEA 5644] 무선충전  (0) 2019.08.19
[SWEA 1949] 등산로 조성  (0) 2019.08.19
[SWEA 1208] Flatten  (0) 2019.07.29
반응형

문제풀이

상당히 어렵게 푼 문제이다. 단순히 구현하는 문제(시뮬레이션)인데 공유하는 BC가 있을경우 선택을 잘 해야한다.

유저 a와 b의 경로를 2차원 배열에 저장하고 이동이 끝나면 시작위치의 좌표를 재조정한다.

이때 1) 유저 a만 충전하는 경우 2) 유저 b만 충전하는 경우 3) 유저 a,b 모두 충전하는 경우

총 3가지로 나누어 처리하였다.


소스코드


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
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
using namespace std;
typedef struct BC{
    int x, y, c, p;
}BC;
vector<BC> bc;
int ax, ay, bx, by;
int m, a, c, p;
int chargeA, chargeB;
// 정지, 상, 우, 하, 좌
int dx[]={0010-1};
int dy[]={0-1010};
int userPath[2][101];
 
int solve() {
    ax=ay=1;
    bx=by=10;
    chargeA=chargeB=0;
 
    for (int k=0; k<=m; k++) {
        vector<int> a,b;
        for (int i=0; i<bc.size(); i++) {
            if (abs(ax - bc[i].x) + abs(ay - bc[i].y) <= bc[i].c) 
                a.push_back(i);
            if (abs(bx - bc[i].x) + abs(by - bc[i].y) <= bc[i].c) 
                b.push_back(i);
        }
 
        int pA=0, pB=0, tmpSum=0;
        if (!a.empty() && b.empty()) {
            for (int i=0; i<a.size(); i++) {
                int tmpA = bc[a[i]].p;
                if (tmpSum < tmpA) {
                    tmpSum = tmpA;
                    pA = tmpA;
                }
            }
        }
        else if (a.empty() && !b.empty()) {
            for (int i=0; i<b.size(); i++) {
                int tmpB = bc[b[i]].p;
                if (tmpSum < tmpB) {
                    tmpSum = tmpB;
                    pB = tmpB;
                }
            }
        }
        else {
            for (int i=0; i<a.size(); i++) {
                for (int j=0; j<b.size(); j++) {
                    int tmpA = bc[a[i]].p;
                    int tmpB = bc[b[j]].p;
                    if (a[i] == b[j]) {
                        tmpA/=2;
                        tmpB/=2;
                    }
                    if (tmpSum < tmpA+tmpB) {
                        tmpSum = tmpA+tmpB;
                        pA = tmpA;
                        pB = tmpB;
                    }
                }
            }
        }
 
        ax += dx[userPath[0][k]];
        ay += dy[userPath[0][k]];
        bx += dx[userPath[1][k]];
        by += dy[userPath[1][k]];
        chargeA += pA;
        chargeB += pB;
    }
    return chargeA + chargeB;
}
 
int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    int tc;
    cin>>tc;
    for (int t=1; t<=tc; t++) {
        cin>>m>>a;
        memset(userPath[0], 0sizeof(userPath[0]));
        memset(userPath[1], 0sizeof(userPath[1]));
        bc.clear();
 
        for (int i=0; i<m; i++cin>>userPath[0][i];
        for (int i=0; i<m; i++cin>>userPath[1][i];
 
        int y, x;
        for (int i=0; i<a; i++) {
            cin>>x>>y>>c>>p;
            bc.push_back(BC{x, y, c, p});
        }
 
        cout<<"#"<<t<<" "<<solve()<<"\n";
    }
    return 0;
}
cs


반응형

'Algorithm' 카테고리의 다른 글

[BOJ 13460] 구슬 탈출2  (0) 2019.10.09
[SWEA 1953] 탈주범 검거  (0) 2019.08.23
[SWEA 1949] 등산로 조성  (0) 2019.08.19
[SWEA 1208] Flatten  (0) 2019.07.29
[SWEA 1219] 길찾기  (0) 2019.07.24
반응형

문제풀이

dfs로 완전탐색하여 풀이하였다.

문제의 핵심은 가장 높은곳에서 시작하는 것과 공사를 오직 1번만 진행할 수 있다는 것이다.

input을 받을때 가장 큰 높이를 저장한 뒤 값을 참조하여 탐색한다. 처음에는 좌표를 저장하여 그 좌표에서만 시작하려 했는데 큰 차이는 없을것 같아 높이를 참조하여 시작점을 찾았다.

1. 내리막길인 경우 dfs로 길이를 구해주면 되고

2. 오르막길이고 공사를 진행한 적이 없다면 최소한의 높이를 깎은 뒤 내리막 길이 되면 dfs로 길이를 구해주면 된다. 이때 최대값 k만큼의 높이를 깎는다면 다음 좌표로 이동할 수 없을 수도 있으니 주의하자.


이후 dfs를 통해 등산로 길이의 최대값을 출력해주는 문제이다.


소스코드


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 <iostream>
#include <cstring>
#include <algorithm>
#define MAX 8
#define endl "\n"
using namespace std;
int n, k, maxHeight, ans;
int map[MAX][MAX];
bool visit[MAX][MAX];
int dx[] = {1-100};
int dy[] = {00-11};
 
// 모의 SW 역량테스트 1949 등산로 조성 
// 가장 높은곳에서 시작
// 높은 지형 -> 낮은 지형 상/하/좌/우 이동 
// 최대 k만큼 지형을 깎는다. (오직 한 지점에만 가능) 
 
// y좌표, x좌표, 현재까지 길이, 공사 여부 
void dfs(int y, int x, int cnt, bool isCutting) {
    ans = max(ans, cnt);
    
    for (int i=0; i<4; i++) {
        int ny=y+dy[i];
        int nx=x+dx[i];
        
        // map범위를 초과하거나 이미 방문한 지점이면 continue 
        if (ny<0 || nx<0 || ny>=|| nx>=|| visit[ny][nx]) continue;
        
        // 내리막길 
        if (map[y][x] > map[ny][nx]) {
            visit[ny][nx]=1;
            dfs(ny, nx, cnt+1, isCutting);
            visit[ny][nx]=0;
        } 
        
        // 오르막길 && 공사진행 X 
        else if (map[y][x] <= map[ny][nx] && !isCutting) {
            
            // 최소한으로 높이를 깎는다. 
            for (int d=1; d<=k; d++) {
                isCutting=1;
                map[ny][nx] -= d;
                
                // 내리막길이 되면 
                if (map[y][x] > map[ny][nx]) {
                    visit[ny][nx]=1;
                    dfs(ny, nx, cnt+1, isCutting);
                    visit[ny][nx]=0;
                }
                map[ny][nx] += d;
                isCutting=0;
            }    
        }
    }
}
 
void solve() {
    for (int y=0; y<n; y++) {
        for (int x=0; x<n; x++) {
            if (map[y][x] == maxHeight)    {
                visit[y][x]=1;
                dfs(y, x, 10);
                visit[y][x]=0;
            }
        }
    }
}
 
void init() {
    int tc;
    cin>>tc;
    for (int t=1; t<=tc; t++) {
        cin>>n>>k;
        memset(map, 0sizeof(map));
        memset(visit, 0sizeof(visit));
        ans = 1;
        maxHeight = 0;
        
        for (int y=0; y<n; y++) {
            for (int x=0; x<n; x++) {
                cin>>map[y][x];
                maxHeight = max(maxHeight, map[y][x]);    
            }
        }
        
        solve();
        
        cout<<"#"<<t<<" "<<ans<<endl;    
    }
}
 
int main() {
    ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
    init();
    return 0;
}
cs


반응형

'Algorithm' 카테고리의 다른 글

[SWEA 1953] 탈주범 검거  (0) 2019.08.23
[SWEA 5644] 무선충전  (0) 2019.08.19
[SWEA 1208] Flatten  (0) 2019.07.29
[SWEA 1219] 길찾기  (0) 2019.07.24
[SWEA 2805] 농작물 수확하기  (0) 2019.07.23
반응형

최대점과 최소점의 차이를 가장 작게 하기 위해서는 가장 큰값을 빼고 가장 낮은값을 더해주면 된다.

즉, 배열을 먼저 sorting한 다음 덤프하는 수만큼 연산을 하고 sorting을 반복해주면 된다.


소스코드


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <cstdio>
#include <algorithm>
#define MAX 100
using namespace std;
void solve() {
    int dumpCnt;
    for (int tc=1; tc<=10; tc++) {
        int map[MAX]={0,};
        scanf("%d"&dumpCnt);
        for (int i=0; i<MAX; i++scanf("%d"&map[i]);
        sort(map, map+MAX);
        for (int i=0; i<dumpCnt; i++) {
            map[0]++;
            map[MAX]--;
            sort(map, map+MAX);
        }
        
        printf("#%d %d\n", tc, map[MAX]-map[0]);
    }
}
int main() {
    solve();
    return 0;
}
cs


반응형

'Algorithm' 카테고리의 다른 글

[SWEA 5644] 무선충전  (0) 2019.08.19
[SWEA 1949] 등산로 조성  (0) 2019.08.19
[SWEA 1219] 길찾기  (0) 2019.07.24
[SWEA 2805] 농작물 수확하기  (0) 2019.07.23
[SWEA 5162] 두가지 빵의 딜레마  (0) 2019.07.23
반응형

문제 설명이 좀 어렵게 되있는데 

dfs로 정점의 마지막까지 탐색한 뒤 길이 존재하면 1, 존재하지 않으면 0을 출력해주면 된다.



소스코드

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
#include <cstdio>
#include <cstring>
#define MAX 100
using namespace std;
int n, m;
bool isExisitRoad;
bool visit[MAX];
bool map[MAX][MAX];
void dfs(int s) {
    visit[s]=1;
    if(s==99) {
        isExisitRoad=1;
        return;
    }
    for (int x=0; x<MAX; x++) {
        if (map[s][x] && !visit[x])
            dfs(x);
    }
}
void solve() {
    for (int t=0; t<10; t++) {
        memset(map, 0sizeof(map));
        memset(visit, 0sizeof(visit));
        isExisitRoad=0;
        scanf("%d %d"&n, &m);
        int y, x;
        for (int i=0; i<m; i++) {
            scanf("%d %d"&y, &x);
            map[y][x]=1;
        }
        
        dfs(0);
        if (isExisitRoad) printf("#%d\n", n);
        else printf("#%d\n", n);
    }
}
int main() {
    solve();
    return 0;
}
cs


반응형

'Algorithm' 카테고리의 다른 글

[SWEA 1949] 등산로 조성  (0) 2019.08.19
[SWEA 1208] Flatten  (0) 2019.07.29
[SWEA 2805] 농작물 수확하기  (0) 2019.07.23
[SWEA 5162] 두가지 빵의 딜레마  (0) 2019.07.23
[BOJ 7576] 토마토  (0) 2019.07.05
반응형

별찍기 문제처럼 접근했다. 

항상 map의 가로, 세로 길이가 홀수인것에서 힌트를 얻을 수 있었다.

가운데를 기준으로 세로로 접으면 대칭되는데 이 값들만 for루프를 통해 더해주면 되는 문제이다.

처음에 많이 헷갈렸는데 그림을 그려가면 규칙을 금방 찾을 수 있었던 문제


소스코드


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
#include <cstdio>
#include <cstring>
#define MAX 49
using namespace std;
int n;
int map[MAX][MAX];
int calcProfit() {
    int ret=0;
    int nHalf = n/2;
    for (int y=0; y<nHalf; y++
        for (int x=nHalf-y; x<=nHalf+y; x++
            ret += map[y][x];
        
    for (int y=nHalf; y>=0; y--
        for (int x=nHalf-y; x<=nHalf+y; x++)
            ret += map[n-1-y][x];
            
    return ret;
}
void solve() {
    int t;
    scanf("%d"&t);
    for (int i=1; i<=t; i++) {
        scanf("%d"&n);
        memset(map, 0sizeof(map));
        for (int y=0; y<n; y++)    
            for (int x=0; x<n; x++
                scanf("%1d"&map[y][x]);
        
        printf("#%d %d\n", i, calcProfit());
    }
}
int main(int argc, char** argv) {
    solve();
    return 0;
}
cs


반응형

'Algorithm' 카테고리의 다른 글

[SWEA 1208] Flatten  (0) 2019.07.29
[SWEA 1219] 길찾기  (0) 2019.07.24
[SWEA 5162] 두가지 빵의 딜레마  (0) 2019.07.23
[BOJ 7576] 토마토  (0) 2019.07.05
[BOJ 1206] DFS와 BFS  (0) 2019.07.05
반응형

현미빵(a), 단호박 빵(b)중 더 싼 가격의 빵으로 현재 가지고 있는 돈(c)을 나눠주면 된다.


소스코드

1
2
3
4
5
6
7
8
9
10
11
#include <cstdio>
using namespace std;
int main(int argc, char** argv) {
    int t, a, b, c;
    scanf("%d"&t);
    for (int i=1; i<=t; i++) {
        scanf("%d %d %d"&a, &b, &c);
        printf("#%d %d\n", i, a>b?c/b:c/a);
    }
    return 0;
}
cs


반응형

'Algorithm' 카테고리의 다른 글

[SWEA 1219] 길찾기  (0) 2019.07.24
[SWEA 2805] 농작물 수확하기  (0) 2019.07.23
[BOJ 7576] 토마토  (0) 2019.07.05
[BOJ 1206] DFS와 BFS  (0) 2019.07.05
[BOJ 1120]문자열  (0) 2019.07.03

+ Recent posts