치킨 날다

내일 다시 시작하기 위해 내용을 정리합니다.

Animation에 notify를 넣는 방법을 찾았습니다.

이를 기반으로 처음부터 다시 만들어 보았는데,

Climb에 Enter하고 Move만 하지 그 뒤로 어떠한 것도 제대로 되지 않습니다.

아마 State와 Trigger가 정상 작동하지 않기 때문이라 생각합니다.

Conduit부터 시작해서 이것저것 쌓아가야 할것 같습니다.

원래 긴장하면 되던 일도 안되던데 지금이 그짝인 것 같습니다.

Teleport로 Climb를 하는 문제는 대부분 해결이 되었습니다.

Enter Climb From Top만 빼면 모든 기능은 작동합니다.

그렇게 보였습니다.

하지만 정신 차리고 보니, Exit Climb가 정상적으로 재생되지 않고 있었습니다.

그래서 일단 Push를 해놓고, Branch를 파서 다시 만들어보고 있습니다.

일지를 지금 쓰는 것도 미리 일지를 쓰고 마저 개발을 하기 위해서입니다.

과제 제출하려면 우선 하던 것은 다 되도록 마무리 해야 되는지라 압박이 조금 됩니다.

열흘 정도 시간이 남았으니 이번주 주말까지는 Climb를, 다음주 주말까지는 Trap/Puzzle을 손보고자 합니다.

저번에는 Teleport를 통한 Exit Climb from Top을 기능적으로는 구현을 해봤고,

오늘은 Collision을 조절해서 Climb를 구현해보려 했습니다.

이를 시도해 보았으나 원하는 결과를 얻지 못하였습니다.

Mesh의 Collision 설정 뿐만 아니라 여러 Trigger도 모두 Collision 설정을 해야 하는건가 싶기도 하고

좀 복잡해서 일단 보류를 했습니다.

남은 시간에는 Teleport 하는 위치를 조절하였습니다.

그래도 붕 뜨게 되는 것은 어떻게 할 수가 없었습니다.

그래서 이 문제도 우선은 보류하였습니다.

그 다음에는 다른 Climb에 FSM을 적용해보았습니다.

현재 Montage 생성을 해서 붙여넣기만 하면 바로 테스트가 가능합니다.

마지막으로 Enter Climb From Top을 구현중입니다.

위치는 Teleport로 조절이 가능한데, Rotator가 원하는 방향으로 되지 않아서 남은 시간을 모두 소모했습니다.

그리고 잘 되는줄만 알았던 Rope가 벽에 붙어 있을 때와 그렇지 않을 때 Move Animation 재생에 차이가 발생했습니다.

단일 객체의 Rope에서의 Move 시 Animation 재생 문제를 따로 고려해봐야 할 것 같습니다.

내일은 먼저 Montage를 붙여서 다른 Climb에서의 상호작용을 확인해볼 것입니다.

그 다음은 Rotator 조절.

마지막으로 단일 Climb에 대한 MoveAnimation 문제를 해결할 것입니다.

오늘은 일지 적는 시간이 꽤 늦습니다.

또한 이래저래 보류를 하는 경우가 많습니다.

오늘 지원한 회사 중 한곳에서 연락이 왔는데, 과제를 제출하라고 하였습니다.

과제 조건을 보니 지금 개발중인 프로젝트가 어느정도 조건에 부합하여 이를 제출하겠다고 했습니다.

때문에 주어진 시간 안에 현재 개발 중인 기능만이라도 마무리를 하여야 합니다.

그렇다 보니 완벽하게는 아니더라도 대략적인 기능은 구현하려고 하는 것 같습니다.

때문에 당분간은 매일 이 프로젝트의 일지를 작성하게 될 것 같습니다.

지원한 회사에서 과제를 제출하라는 연락을 받아 2주 가량 쉽니다.

어제 면접을 보고 몇가지 알아볼 것이 있어서 문제를 풀지 못했습니다.

그리고 오늘은 지원한 회사에서 과제 제출을 하라고 연락을 받았습니다.

아무래도 시간이 걸릴 것 같아 제출일까지 알고리즘 문제 풀이는 비주기적으로 진행하려 합니다.

2주 정도 걸릴 것이고, 그 사이에 여유가 되면 풀 수도 있지만 대부분은 과제에 시간을 할애할 것 같습니다.

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

사실 그저께부터 풀어보려 했으나 번번히 실패하는 문제입니다.

정육점에는 여러 고기 덩어리가 있고, 각 고기 덩어리는 무게와 가격이 천차만별입니다.

은혜는 본인이 필요로 하는 양의 고기를 사면 됩니다.

단, 가격이 더 싸다면 필요한 양보다 더 많은 고기를 살 수도 있습니다.

또한 자신이 구매한 고기보다 싼 고기들은 추가 지불 없이 얼마든지 구매할 수 있습니다.

이 때 은혜가 원하는 양의 고기를 구매하기 위한 최소 비용을 계산해야 합니다.

여태까지 제가 구현한 방식은 다음과 같습니다.

1. 무게합이 필요한 무게보다 작은지 비교한다.

2. 1의 결과가 참일 경우, 최소 비용의 무게와 현재 무게가 동일한지 비교한다.

3. 2의 결과가 참일 경우, 최소 비용과 현재 비용을 비교하여 더 작은 것을 저장한다.

4. 2의 결과가 거짓일 경우, 최소 비용과 그 무게를 현재 비용과 무게로 저장한다.

5. 1의 결과가 거짓일 경우, 최소 비용을 현재 무게와 비교하여 더 작은 것을 저장한다.

6. 무게합이 요구치보다 작을 경우 -1을, 클 경우 최소 비용을 출력한다.

하지만 9%를 넘어가는 정도에서 정답을 맞추지 못하고 실패해버립니다.

오늘은 이쯤에서 멈추고 내일 다시 풀어보겠습니다.

오늘 주말에 지원 했던 회사에서 한 곳, 업로드 한 제 지원서를 열람한 곳에서 한곳 연락이 왔습니다.

지원한 회사는 입사지원서를 당사 형식으로 작성해서 제출해 달라 했고, 열람한 곳은 내일 면접이 잡혔습니다.

그래서 입사지원서를 다시 작성하다 보니까 오늘 개발은 많이 하지 못했습니다.

하지만 그래도 그 어느때보다 효율적인 시간이었습니다.

문제를 해결했기 때문입니다.

저번에 Teleport를 통해 Climb의 윗 부분에 도달에 Exit 하는 문제를 해결 할 수 있는 실마리를 잡았습니다.

오늘은 이 수치를 조금 조절 했더니 갑자기 Animation이 정상적으로 재생되지 않았습니다.

혹시나 해서 수치를 완전히 키웠으나, 역시 제대로 작동하지 않았습니다.

여기서 저는 뭔가 잘못되었다는 것을 느꼈습니다.

코드를 다시 보니, TeleportTo 함수가 그냥 호출이 되고 있는 것이 걸렸습니다.

이전에도 Replicate 문제로 오랜 시간을 잡아 먹었기에, RPC 함수로 TeleportTo를 감쌌습니다.

그러자 거짓말처럼 문제가 해결이 되었습니다.

이번 문제도 역시나 RPC문제였습니다.

이렇게 해서 기능은 동작하지만, 영 만족스럽지 못합니다.

Teleport 해야 하는 높이가 꽤 높아 캐릭터가 붕 떠보이기 때문입니다.

다음에는 이 수치를 한번 조절해볼 생각입니다.

Character를 Z축으로만 이동 시켜보고, 적절하게 작동을 한다면 그대로 둘 것입니다.

만약 그렇지 못한다면, Exit 하는 동안 Mesh와 Capsule의 Overlap 상태를 조절해

Animation이 정상 재생 되는 동안 Overlap이 발생하지 않도록 해볼 계획입니다.

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

100K개의 다항식의 도함수 f'(x)에 대해 x = 2일 때의 값을 1B + 7로 나눈 나머지를 구하는 문제이다.

매우 간단하지만, 연산 시간을 맞추는 것에 어려움이 많았다.

우선 차수가 1B까지 나올 수 있는 지수 연산이 문제였다.

처음에는 greedy하게 하나하나 해봤지만, 역시나 시간이 부족했다.

그 다음에는 2배수로 나눠서 연산을 해보려 했으나,

반대로 입력받은 지수 값을 2진수로 계산하는 것이 너무 오래 걸렸습니다.

결국 답은 지수를 10진수 단위로 끊는 것이었습니다.

10^n 단위로 미리 연산을 해두고, 이를 이용한 pow 함수를 따로 제작하여 이를 사용하였습니다.

하지만 이후에도 수차례 통과하지 못했습니다.

여러 차례 수정을 하다가 깨달은 점은, 지수 부분만 unsigned long long으로 하였으나

sizeof(unsigned int) 크기를 넘어갈 수 있다는 점이었습니다.

그래서 size를 제외한 모든 값을 unsigned long long으로 선언을 해주고 나서야 비로소 통과 할 수 있었습니다.

#include <iostream>
#include <vector>
#include <array>
#include <algorithm>

using namespace std;

array<unsigned long long, 10> decpow;

unsigned long long GetPow(unsigned int dec)
{
    if (dec == 0)
    {
        return 1;
    }
    int rest = 0, index = 0;
    unsigned long long output = 1;

    while (dec > 0)
    {
        rest = dec % 10;
        dec /= 10;
        for (int i = 0; i < rest; ++i)
        {
            output *= decpow[index];
            output %= 1000000007;
        }
        ++index;
    }

    return output;
}

int main()
{
    unsigned int size = 0;
    unsigned long long output = 0, a = 1, b = 0, value = 2, exp = 1;
    vector<pair<unsigned long long, unsigned long long>> input;
    decpow[0] = 2;
    for (int i = 1; i < 9; ++i)
    {
        exp = 1;
        for (int j = 0; j < 10; ++j)
        {
            exp *= value;
            exp %= 1000000007;
        }
        value = exp;
        decpow[i] = value;
    }

    cin >> size;
    for (int i = 0; i < size; ++i)
    {
        cin >> a >> b;
        if (b > 0)
        {
            input.push_back(make_pair(a * b % 1000000007, b - 1));
        }
    }

    sort(input.begin(), input.end(), [](auto& a, auto& b)
        {
            return a.second < b.second;
        });

    for (const auto& iter : input)
    {
        output += iter.first * GetPow(iter.second);
        output %= 1000000007;
    }

    cout << output << endl;
    return 0;
}

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

피자 박스가 N * M으로 쌓여 있습니다.

이 때 정면도와 측면도가 바뀌지 않도록 피자 박스를 제거 할 때, 최대 제거되는 피자 박스의 수를 구하는 문제입니다.

제가 선택한 방식은 다음과 같습니다.

0. 입력 받을 때 모든 상자 박스 높이의 합을 더합니다.

1. row 단위에서 최대 높이인 index를 vector에 저장합니다.

2. column 단위에서 최대 높이인 index를 vector에 저장합니다.

3. 단, 1과 2의 과정에서 vector 안에 동일한 index가 존재하면 저장하지 않습니다.

4. 저장된 indices의 상자 높이 만큼 연산된 상자 높이의 합에서 감산합니다.

처음 시도에는 오답을 받았습니다.

무엇이 문제인지 살펴보니, 상자 높이가 1B까지 입력 받고, 상자 뭉치 갯수는 1M개 만큼 입력을 받을 수 있었습니다.

입력값이 많을 경우, 상자 높이의 합이 int의 범위를 넘어설 수 있습니다.

그래서 상자 높이의 합을 int에서 unsigned long long으로 변경하였고, 정답을 맞출 수 있었습니다.

문제를 다 풀고 상자 순회를 한번에 해결할 수 있나 고민을 해보았습니다.

하지만 column과 row 단위에서 비교를 해 최대값을 뽑아야 하는 만큼,

둘 중 하나는 그 크기 만큼 최대값을 동시에 관리해야 했습니다.

이를 판단하는 것보다 차라리 순회를 두번 하는 것이 덜 복잡할 것 같습니다.

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main()
{
    int column = 0, row = 0, input = 0;
    unsigned long long output = 0;
    vector<vector<int>> tower;
    vector<vector<int>> LiveIndex;
    cin >> column >> row;
    for (int i = 0; i < column; ++i)
    {
        tower.push_back(vector<int>(row));
        for (int j = 0; j < row; ++j)
        {
            cin >> input;
            tower[i][j] = input;
            output += input;
        }
    }

    for (int i = 0; i < column; ++i)
    {
        int max = 0, cIndex = 0, rIndex = 0;
        for (int j = 0; j < row; ++j)
        {
            if (max < tower[i][j])
            {
                cIndex = i;
                rIndex = j;
                max = tower[i][j];
            }
        }
        auto temp = vector<int>{ cIndex, rIndex };
        if (find(LiveIndex.begin(), LiveIndex.end(), temp) == LiveIndex.end())
        {
            LiveIndex.push_back(temp);
        }
    }
    for (int i = 0; i < row; ++i)
    {
        int max = 0, cIndex = 0, rIndex = 0;
        for (int j = 0; j < column; ++j)
        {
            if (max < tower[j][i])
            {
                cIndex = j;
                rIndex = i;
                max = tower[j][i];
            }
        }
        auto temp = vector<int>{ cIndex, rIndex };
        if (find(LiveIndex.begin(), LiveIndex.end(), temp) == LiveIndex.end())
        {
            LiveIndex.push_back(temp);
        }
    }
    for (const auto& iter : LiveIndex)
    {
        output -= tower[iter[0]][iter[1]];
    }

    cout << output << endl;
    return 0;
}

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

입력된 n개의 논문들의 인용 횟수를 받고 k | N(q(i) ≥ k) ≥ k, N(q(i) ≤ k) ≤ k (0 ≤ i ≤ n)인 k를 구하는 문제입니다.

제가 처음 선택한 풀이법은 다음과 같습니다.

1. 입력받은 리스트를 오름차순으로 정렬한다.

2. index를 순회하면서 q(i) ≥ i && q(i) ≤ n - i인지 확인을 한다.

3. 2의 조건이 만족할 경우, i 값을 저장한다.

4. 순회를 모두 마친 후 최후의 저장된 i값을 출력한다.

하지만 이 문제에는 몇가지 큰 문제점이 있었습니다.

1) Q-index 값이 입력된 논문의 인용 횟수 내로 제한된다.

2) 논문 인용 횟수가 논문 갯수보다 월등히 높으면 Q-index가 0으로 연산된다.

하지만 적은 것과 다르게 이를 알아내는데에는 6차례의 추가 시도가 필요했습니다.

그리고 결국 수정한 방안은 다음과 같습니다.

1. 입력받은 리스트를 오름차순으로 정렬한다.

2. 임의의 qindex를 Max(q(i))까지 순회한다.

3. 2의 순회에서 qindex보다 크거나 같은 q(i)를 갖는 index를 구한다.

4. index ≤ qindex && n - index ≥ qindex인 qindex를 저장한다.

5. 순회를 마치고 최종적으로 저장된 qindex를 출력한다.

문제 성격상 내림차순으로 정렬하여 qindex를 내림차순으로 순회하면 조금 더 빠르게 풀 수 있겠지만, 

이대로도 충분히 해결이 되기에 따로 수정을 하지는 않았습니다.

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main()
{
    int size = 0, input = 0, output = 0, max = 0;
    vector<int> report;
    cin >> size;
    for (int i = 0; i < size; ++i)
    {
        cin >> input;
        report.push_back(input);
    }

    sort(report.begin(), report.end());
    max = report[size - 1];

    for (int qIndex = 0; qIndex < max; ++qIndex)
    {
        int index = 0;
        while (report[index] < qIndex)
        {
            ++index;
        }
        if ((index <= qIndex) && (size - index >= qIndex))
        {
            output = qIndex;
        }
    }

    cout << output << endl;

    return 0;
}