반응형

스마일게이트 희망스튜디오의 게임잼 행사에 1기 멤버로 참여하게되었다.

보통 짧은 기간의 게임잼과 달리 스마일게이트에서 제공해주는 장소에 2박3일동안 프로토타입을 개발하고 나머지 2개월동안 완성시키는 프로그램이다. 


프로그래머 직군으로 혼자지원했는데 팀 빌딩하는 과정을 통해 7인이나 되는 상당히 큰 팀을 이루어 새로운 프로젝트를 시작하게 되었다.


확실히 협업경험이 많이 적어서 그런지 많은 구성원들의 의견이나 프로젝트를 매니지하는게 어려웠다. 또 구성원들이 역량도 알 수 없었기에 더 힘든 부분도 있었던게 사실이다.

다행인건 3일동안 열심히한 결과 대략적인 프로타입은 어찌어찌해서 나왔다!

앞으로 남은 2개월동안 프로젝트를 마무리해야하는데 열심히해야겠다...ㅎ...








반응형
저작자표시 (새창열림)

'Etc' 카테고리의 다른 글

게임회사 취업 후기 및 근황 Part 2  (0) 2020.03.29
게임회사 취업 후기 및 근황 Part 1  (0) 2020.03.22
학교 SW Festival 후기  (0) 2018.11.18

반응형


1932번 문제 : 피보나치 함수


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
#include <iostream>
using namespace std;
 
struct MyFibo
{
    int value;
    int zeroCount;
    int oneCount;
};
 
MyFibo fib[50];
int GetFibo(int n)
{
    if (n == 0)
    {
        fib[0].value = 0;
        fib[0].zeroCount = 1;
        return 0;
    }
 
    else if (n == 1)
    {
        fib[1].value = 1;
        fib[1].oneCount = 1;
        return 1;
    }
    
    if (fib[n].value != 0)
    {
        return fib[n].value;
    }
    else
    {
        fib[n].value = GetFibo(n - 1) + GetFibo(n - 2);
        fib[n].zeroCount = fib[n - 1].zeroCount + fib[n - 2].zeroCount;
        fib[n].oneCount = fib[n - 1].oneCount + fib[n - 2].oneCount;
    }
}
 
int main() {
    int inp;
    cin >> inp;
 
    while (inp > 0)
    {
        int a;
        cin >> a;
        zeroCounter = 0;
        oneCounter = 0;
        GetFibo(a);
        cout << fib[a].zeroCount << " " << fib[a].oneCount << endl;
 
        inp--;
    }
 
    return 0;
}
cs



1149번 문제 : RGB거리

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


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
#include <iostream>
#include <algorithm>  
using namespace std;
 
int DP[1001][4] = { 0 };
 
int main() {
    int inp;
    cin >> inp;
 
    for (int i = 1; i <= inp; i++)
    {
        int r, g, b;
        cin >> r >> g >> b;
 
        DP[i][1] = r;
        DP[i][2] = g;
        DP[i][3] = b;
    }
 
    for (int i = 2; i <= inp; i++)
    {
        for (int j = 1; j <= 3; j++)
        {
            if (j == 1)
                DP[i][j] += min(DP[i - 1][2], DP[i - 1][3]);
            else if (j == 2)
                DP[i][j] += min(DP[i - 1][1], DP[i - 1][3]);
            else if (j == 3)
                DP[i][j] += min(DP[i - 1][1], DP[i - 1][2]);
        }
    }
 
    int min = DP[inp][1];
    for (int j = 1; j <= 3; j++)
    {
        if (DP[inp][j] < min)
            min = DP[inp][j];
    }
 
    cout << min << endl;
 
 
    return 0;
}
cs


1932번 문제 : 정수 삼각형

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


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
#include <iostream>
#include <algorithm>
using namespace std;
 
int DP[501][501] = { 0 };
 
int main()
{
    int size;
    cin >> size;
    for (int i = 1; i <= size; i++)
    {
        for (int j = 1; j <= i; j++)
        {
            int inp;
            cin >> inp;
            DP[i][j] = inp;
        }
    }
 
    for (int i = 2; i <= size; i++)
    {
        for (int j = 1; j <= i; j++)
        {
            if (j == 1)
            {
                DP[i][j] += DP[i - 1][j];
            }
            else if (j == i)
            {
                DP[i][j] += DP[i - 1][j - 1];
            }
            else
            {
                DP[i][j] += max(DP[i - 1][j - 1], DP[i - 1][j]);
            }
        }
    }
 
    int max = 0;
    for (int j = 1; j <= size; j++)
    {
        if (DP[size][j] > max)
            max = DP[size][j];
    }
 
    cout << max << endl;
 
    return 0;
}
 
cs

메모:
-위쪽부터 누적 최대값을 취하는 방식으로 풀어야함
-양쪽끝 (위 코드에서는 j =1 또는 j =i)일때는 받을 수 있는 값은 하나 밖에 없음
-가운데에 있는 숫자들은 양쪽에서 값을 받을 수 있음



1463번 문제 : 1로 만들기
https://www.acmicpc.net/problem/1463

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>
#include <algorithm>
using namespace std;
 
int arr[1000001] = { 0 };
 
int GetValue(int num)
{
    if (num == 0 || num == 1)
    {
        arr[num] = 0;
        return 0;
    }
    else if (num == 2 || num == 3)
    {
        arr[num] = 1;
        return 1;
    }
 
    if (arr[num] != 0)
        return arr[num];
    else
    {
        arr[num] = arr[num - 1] + 1;
 
        if (num % 2 == 0)
        {
            arr[num] = min(arr[num], arr[num / 2] + 1);
        }
 
        if (num % 3 == 0)
        {
            arr[num] = min(arr[num], arr[num / 3] + 1);
        }
        
 
        return arr[num];
    }
}
 
int main()
{
    int inp;
    cin >> inp;
 
    for (int i = 1; i <= inp; i++)
    {
        GetValue(i);
    }
 
    cout << arr[inp] << endl;
 
    return 0;
}
cs

메모:
-3부터 나뉘어지면 무조건 취소값이라고 생각하면 안됨
-그래서 그 전의 수와 비교하면서 루프를 돌아야함


9461번 문제 : 파도반 수열


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
#include <iostream>
#include <vector>
using namespace std;
 
signed long long value[101] = { 0,1,1,1,2,2,3,4,5,7 };
vector<signed long long> result;
 
int GetValue(int num)
{
    if (num <= 8)
        return value[num];
    else
    {
        if (value[num] != 0)
            return value[num];
        else
        {
            value[num] = value[num - 1] + value[num - 5];
            return value[num];
        }
    }
}
 
 
int main() {
    
    int t;
    cin >> t;
 
    for (int i = 0; i <= 100; i++)
    {
        GetValue(i);
    }
 
    while (t > 0)
    {
        int inp;
        cin >> inp;
 
        result.push_back(value[inp]);
 
        t--;
    }
 
    for (auto i : result)
        cout << i << endl;
 
 
    return 0;
}
cs




메모:
-i가 80정도 이상이면 long long 범위를 벗어나 답을 못구함...



반응형
저작자표시 (새창열림)

'C++ Algorithm > 백준 알고리즘 문제 풀이' 카테고리의 다른 글

트리 사용하기  (0) 2019.04.29
그리디 알고리즘  (0) 2019.04.28
그래프(DFS, BFS)  (0) 2019.04.04
브루트 포스  (0) 2019.04.01
수학  (0) 2019.03.20
반응형

DFS(Deep First Search) 깊이 우선 탐색    BFS(Breadth First Search) 너비 우선 탐색                인접행렬


      





2606번 문제 : 바이러스


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
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
 
int const MAX_VALUE = 101;
int matrix[MAX_VALUE][MAX_VALUE] = { 0 };
bool visit[MAX_VALUE] = { false };
int counter = 0;
 
void DFS(int v, int N) {
    if(visit[v] != true)
        counter++;
 
    visit[v] = true;
    
    for (int i = 1; i <= N; i++)
    {
        if (matrix[i][v] == 0 || visit[i] == true)
            continue;
 
        DFS(i, N);
    }
}
 
int main()
{
    int N, M;
    cin >> N >> M;
 
    for (int i = 1; i <= M; i++)
    {
        int x, y;
        cin >> x >> y;
        matrix[x][y] = matrix[y][x] = 1;
    }
 
    DFS(1, N);
 
    cout << counter - 1 << endl;
 
    return 0;
}
 
cs

메모:
-중복체크를 하면서 count해야함


2309번 문제 : 순열 사이클

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


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
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
 
int const MAX_VALUE = 1001;
int matrix[MAX_VALUE][MAX_VALUE] = { 0 };
int visit[MAX_VALUE] = { 0 };
int index = 0;
vector<int> result;
 
void DFS(int v, int N, int index) {
    visit[v] = index;
    for (int i = 1; i <= N; i++)
    {
        if (matrix[i][v] != index || visit[i] == index)
            continue;
 
        DFS(i, N, index);
    }
}
 
int main()
{
    int num;
    cin >> num;
 
    while (num > 0)
    {
        int M; 
        cin >> M;
        int counter = 0;
        index++;
 
        for (int i = 1; i <= M; i++)
        {
            int x = i;
            int y;
            cin >> y;
            matrix[x][y] = matrix[y][x] = index;
        }
 
        for (int i = 1; i <= M; i++)
        {
            if (visit[i] != index)
            {
                DFS(i, M, index);
                counter++;
            }
        }
        result.push_back(counter);
        num--;
    }
 
    for (auto i : result)
        cout << i << endl;
 
    return 0;
}
cs



메모:
-matrix를 사용 후에 초기화 하는 방식으로 하면 시간 초과 발생 -> index를 활용하여 기존의 matrix를 재활용

-아래 코드는 코드를 이해하는데 더 직관적이나 initializing하는 과정(시간복잡도: O (n 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
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
 
int const MAX_VALUE = 1001;
int matrix[MAX_VALUE][MAX_VALUE] = { 0 };
bool visit[MAX_VALUE] = { 0 };
vector<int> result;
int counter = 0;
 
void DFS(int v, int N) {
    //    cout << v << " "; //for debug
    visit[v] = true;
    for (int i = 1; i <= N; i++)
    {
        if (matrix[i][v] == 0 || visit[i] == true)
            continue;
 
        DFS(i, N);
    }
}
 
void InitializeMatrix()
{
    for (int i = 0; i < MAX_VALUE; i++)
    {
        for (int j = 0; j < MAX_VALUE; j++)
        {
            matrix[i][j] = 0;
        }
    }
 
    for (int i = 0; i < MAX_VALUE; i++)
    {
        visit[i] = false;
    }
 
    counter = 0;
}
 
int main() //시간초과 발생하는 코드
{
    int num;
    cin >> num;
 
    while (num > 0)
    {
        int M;
        cin >> M;
 
        InitializeMatrix();
 
        for (int i = 1; i <= M; i++)
        {
            int x = i;
            int y;
            cin >> y;
            matrix[x][y] = matrix[y][x] = 1;
        }
 
        /*
        //Matrix Debug
        cout << endl;
        for (int i = 1; i <= M; i++)
        {
            for (int j = 1; j <= M; j++)
            {
                cout << matrix[i][j] << "  ";
            }
            cout << endl;
        }
        cout << endl;
        */
 
        for (int i = 1; i <= M; i++)
        {
            if (visit[i] != true)
            {
                DFS(i, M);
                counter++;
            }
        }
 
        result.push_back(counter);
        num--;
    }
 
    for (auto i : result)
        cout << i << endl;
 
    return 0;
}
 
cs


반응형
저작자표시 (새창열림)

'C++ Algorithm > 백준 알고리즘 문제 풀이' 카테고리의 다른 글

그리디 알고리즘  (0) 2019.04.28
동적 계획법 기초  (0) 2019.04.08
브루트 포스  (0) 2019.04.01
수학  (0) 2019.03.20
시뮬레이션  (0) 2019.03.20
반응형

2309번 문제 : 일곱 난쟁이
https://www.acmicpc.net/problem/2309

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
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
 
int main()
{
    int num = 9;
    int sum = 0;
    vector<int> v;
    int a, b;
 
    while (num > 0)
    {
        int inp;
        cin >> inp;
        v.push_back(inp);
        sum += inp;
        num -- ;
    }
 
    sort(v.begin(), v.end());
 
    bool flag = false;
    for (int i = 0; i < v.size(); i++)
    {
        for (int j = 0; j < v.size(); j++)
        {
            if (sum - (v.at(i) + v.at(j)) == 100)
            {
                a = i;
                b = j;
                flag = true;
                break;
            }
        }
        if (flag)
            break;
    }
    
    for (int i = 0; i < v.size(); i++)
    {
        if (i == a || i == b)
            continue;
        cout << v.at(i) << endl;
    }
    
    
    return 0;
}
cs


메모:
- 모든 숫자의 합 - 2개의 합 = 100인 숫자 찾음 -> 이 생각을 못하면 문제가 상당히 어려워짐...
- 2개의 합 모든 경우의 수를 for문에 돌려서 찾음
- iterator를 이용해 깔끔하게 erase하고 싶었지만 첫번째 index를 erase하는 순간 값들이 shift하면서 두번째 index값이 바뀜... 그래서 erase하지 못함. 특정 index 여러개를 동시에 erase하는 방법은 없는듯 (remove로는 범위밖에 못함)

2231번 문제 : 분해합

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

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 <iostream>
#include <queue>
#include <vector>
using namespace std;
 
int GetContrustor(int num)
{
    int sum = num;
    while (num > 0)
    {
        sum += num % 10;
        num /= 10;
    }
 
    return sum;
}
 
int main()
{
    int inp;
    cin >> inp;
 
    for (int i = 0; i < inp; i++)
    {
        if (inp == GetContrustor(i))
        {
            cout << i << endl;
            break;
        }
        
        if (i == inp - 1)
            cout << 0 << endl;
    }
 
    return 0;
}
cs


1065번 문제 : 한수
https://www.acmicpc.net/problem/1065

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
#include <iostream>
#include <vector>
 
using namespace std;
 
bool CheckIfSansoo(int n)
{
    if (n < 100)
    {
        return true;
    }
 
    vector<int> v;
 
    while (n > 0)
    {
        int num = n % 10;
        v.push_back(num);
        n /= 10;
    }
    
    int diff = v.at(0) - v.at(1);
    for (int i = 0; i < v.size() - 1; i++)
    {
        int temp = v.at(i) - v.at(i + 1);
        if (diff != temp)
            return false;
    }
    return true;
 
}
 
int main()
{
    int inp;
    cin >> inp;
    int num = 0;
 
    for (int i = 1; i <= inp; i++)
    {
        if (CheckIfSansoo(i))
            num++;
    }
 
    cout << num;
 
    return 0;
}
 
cs


1038번 문제 : 감소하는 수
https://www.acmicpc.net/problem/7568

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
#include <iostream>
#include <vector>
using namespace std;
 
struct PersonInfo
{
    int weight;
    int height;
    int ranking;
};
 
int main()
{
    int num;
    cin >> num;
 
    vector<PersonInfo> v;
 
    while (num > 0)
    {
        int inpA, inpB;
        cin >> inpA >> inpB;
        v.push_back({ inpA, inpB, 1 });
        num--;
    }
 
    for (int i = 0; i < v.size(); i++)
    {
        for (int j = 0; j < v.size(); j++)
        {
            if (v.at(i).height < v.at(j).height && v.at(i).weight < v.at(j).weight)
                v.at(i).ranking++;
        }
    }
 
    for (auto i : v)
        cout << i.ranking << " ";
 
    return 0;
}
 
cs

1038번 문제 : 감소하는 수
https://www.acmicpc.net/problem/1038

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
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
 
int main()
{
    int inp;
    cin >> inp;
    vector<long long> v;
 
    for (int i = 0; i <= 9; i++)
    {
        int vSize = v.size();
        //v.size() should not be used due to the change of the size changing after pushing back the result inside a loop
        for (int j = 0; j < vSize; j++) 
        {
            string result = to_string(i) + to_string(v.at(j));
            v.push_back(stoll(result)); //stoi -> int       stol -> long       stoll -> long long
        }
        v.push_back(i);
    }
    sort(v.begin(), v.end());
 
    if (v.size() > inp)
        cout << v.at(inp) << endl;
    else
        cout << -1 << endl;
 
    return 0;
}
cs


메모:
-규칙을 찾으면 0 / 10, 1, 0 / 210 21, 20, 2, 10, 1, 0 / 3210, 321, 320 ,32, 310 , 31, 30, 3 ....
-루프문에 동적배열인 vector.size() (벡터 크기) 기준으로 루프가 돌때 루프안에서 vector를 push하거나 erase, remove하면 size()가 변하기 때문에 이를 감안하면서 코드를 짜야함
-문자열을 int, long, long long로 변환할때: stoi -> int       stol -> long       stoll -> long long (c++11이상)






반응형
저작자표시 (새창열림)

'C++ Algorithm > 백준 알고리즘 문제 풀이' 카테고리의 다른 글

동적 계획법 기초  (0) 2019.04.08
그래프(DFS, BFS)  (0) 2019.04.04
수학  (0) 2019.03.20
시뮬레이션  (0) 2019.03.20
최대공약수/최소공배수  (0) 2019.03.18
반응형

네트워크 RPG게임 'Raid' 개발일지 8


한달동안 꾸준히 만들고 있었다. 개발일지를 작성하기 귀찮았던 것도 있었지만 워낙 여기저기 코드 내부를 바꾼게 많다보니 막 정리하기 쉽지 않았다... 그래도 가장 큰 추가 및 수정 사항을 정리해면 다음과 같다.


1. 서브몬스터 완성

총 3개의 서브몬스터, EnemyNormal를 완성시켰다. 기존 EnemyBoss와 같은 클래스(Enemy Movement, Enemy Manager, Enemy Health, 등등)를 공유하기 때문에 네트워크에 instantiate했을때 InGame Manager에서 Enemy Type을 결정한 후 리스트에 추가하는식으로 구성되어있다.

서브몬스터 같은 경우 기존 Boss와 움직임이 다른데 InGame Manager에서 관리는 구역 A0~A4 에 따라 서로 다른 Patrol Point을 왔다갔다 한다. 이때 플레이어가 충분히 가까워지면 플레이어를 쫓아가게끔 구성했다. 또 플레이어가 일정 범위이상 멀어지면 다시 Patrol Point 사이를 랜덤으로 움직인다.



2. 구역 설정

맵을 보면 총 구역이 6개로 나뉜다. 시작지점인-A0, 일반스테이지인-A1~A3, 보스스테이지인-A4, 그리고 보너스 지역 S0이다. 각각 구역을 클리어 할 시 다음 지역으로 나아갈 수 있다.



3. 네트워크 관련 부분 대응
사실 이 부분이 가장 많이 어려웠다. 여러 클라이언트중 하나만 Master Client이기때문에 이 Master Client가 나가면 다시 설정해줘야하는 부분들이 많다. (Master Client가 기본적인 게임 진행을 이끄는 부분이 많다) 또한 공격처리하는 부분의 경우 각각의 클라이언트에서 처리하기 때문에 이 처리한 결과를 동기화시켜줘야 하는 방식이다. 어쨋든 게임 구조가 복잡해질 수록 자꾸 헷갈린다... (단순하게 모든 오브젝트들을 Network Instantiate할 수는 없는 노릇이다...) 게임이 복잡해질수록 스파케티코드가 되는것 같은 느낌이 든다... 이래서 클래서 구조가 중요한건가?...ㅎㅎ


4. 메쉬 컴바인(Mesh Combine/Bake)

모바일 게임이다 보니 최적화를 위해 하나의 게임오브젝트로 맵의 Mesh Object들을 에셋을 활용하여 컴바인했다. 메쉬를 컴바인하니 Batch수가 확실히 많이 줄어들었다.


반응형
저작자표시 (새창열림)

'Game Development > 프로젝트: 레이드' 카테고리의 다른 글

네트워크 RPG게임 'Raid' 개발일지 7  (0) 2019.02.18
네트워크 RPG게임 'Raid' 개발일지 6  (0) 2019.01.09
네트워크 RPG게임 'Raid' 개발일지 5  (0) 2018.12.23
네트워크 RPG게임 'Raid' 개발일지 4  (0) 2018.12.08
네트워크 RPG게임 'Raid' 개발일지 3  (1) 2018.12.04
반응형

1977번 문제 : 완전제곱수

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


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
#include <iostream>
#include <cmath>
using namespace std;
 
int main() {
 
    double a, b;
    cin >> a >> b;
    int min = ceil(sqrt(a));
    int max = floor(sqrt(b));
 
    if (min <= max)
    {
        int sum = 0;
        for (int i = min; i <= max; i++)
        {
            sum += pow(i, 2);
        }
 
        cout << sum << endl;
        cout << pow(min, 2) << endl;
 
    }
    else
    {
        cout << "-1" << endl;
    }
 
    return 0;
}
cs




반응형
저작자표시 (새창열림)

'C++ Algorithm > 백준 알고리즘 문제 풀이' 카테고리의 다른 글

그래프(DFS, BFS)  (0) 2019.04.04
브루트 포스  (0) 2019.04.01
시뮬레이션  (0) 2019.03.20
최대공약수/최소공배수  (0) 2019.03.18
이항 계수  (0) 2019.03.13
반응형

2455번 문제 : 지능형 기차

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


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
#include <iostream>
using namespace std;
 
int main() {
 
    int stationNum = 4;
    int currentNum = 0;
    int maxNum = 0;
    while (stationNum > 0)
    {
        int a, b;
        cin >> a >> b;
        int change = b - a;
        currentNum += change;
        if (currentNum > maxNum)
            maxNum = currentNum;
 
        stationNum--;
    }
 
    cout << maxNum << endl;
 
    return 0;
}
 
cs

1094번 문제 : 막대기


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
using namespace std;
 
int main() {
 
    int inp;
    cin >> inp;
 
    int counter = 0;
    while (inp != 0)
    {
        if (inp % 2 != 0)
            counter++;
        
        inp /= 2;    
    }
    
    cout << counter << endl;
 
    return 0;
}
 
cs

메모:
-2진수로 바꿨을때 1의 개수를 세면 필요한 막대기의 개수를 구할 수 있다





반응형
저작자표시 (새창열림)

'C++ Algorithm > 백준 알고리즘 문제 풀이' 카테고리의 다른 글

브루트 포스  (0) 2019.04.01
수학  (0) 2019.03.20
최대공약수/최소공배수  (0) 2019.03.18
이항 계수  (0) 2019.03.13
피보나치 수  (0) 2019.03.11

+ Recent posts

티스토리툴바