Submission #747818

#	Time	Username	Problem	Language	Result	Execution time	Memory
747818		finn__	Stray Cat (JOI20_stray)	C++17	15 / 100	44 ms	16192 KiB

Anthony

#include "Anthony.h"
#include <bits/stdc++.h>
using namespace std;

constexpr bool pattern[6] = {0, 0, 1, 1, 0, 1};

vector<int> Mark(int n, int m, int a, int b, vector<int> u, vector<int> v)
{
    vector<vector<int>> g(n);
    for (size_t i = 0; i < m; ++i)
        g[u[i]].push_back(v[i]), g[v[i]].push_back(u[i]);

    queue<int> q;
    q.push(0);
    vector<int> d(n, -1), pattern_index(n, -1);
    vector<bool> color(n, 0);
    d[0] = pattern_index[0] = 0;
    while (!q.empty())
    {
        int const x = q.front();
        q.pop();

        for (auto const &y : g[x])
            if (d[y] == -1)
            {
                d[y] = d[x] + 1;
                q.push(y);

                if (g[y].size() <= 2)
                {
                    pattern_index[y] = (pattern_index[x] + 1) % 6;
                    color[y] = color[x];
                }
                else
                {
                    pattern_index[y] = 0;
                    color[y] = !color[x];
                }
            }
    }

    vector<int> ans(m);
    if (a >= 3)
    {
        for (size_t i = 0; i < m; ++i)
            ans[i] = min(d[u[i]], d[v[i]]) % 3;
    }
    else
    {
        for (size_t i = 0; i < m; ++i)
        {
            if (d[u[i]] > d[v[i]])
                swap(u[i], v[i]);
            ans[i] = pattern[pattern_index[u[i]]] ^ color[u[i]];
        }
    }

    return ans;
}

Catherine

#include "Catherine.h"
#include <bits/stdc++.h>
using namespace std;

bool is_tree, initialized;
vector<int> colors;

constexpr bool pattern[6] = {0, 0, 1, 1, 0, 1};

void Init(int a, int b)
{
    colors.clear();
    is_tree = a == 2;
    initialized = 0;
}

int Move(vector<int> y)
{
    if (!is_tree)
    {
        if (!colors.empty())
            y[colors.back()]++;

        if ((bool)y[0] + (bool)y[1] + (bool)y[2] == 1)
        {
            if (y[0])
            {
                colors.push_back(0);
                return 0;
            }
            else if (y[1])
            {
                colors.push_back(1);
                return 1;
            }
            else
            {
                colors.push_back(2);
                return 2;
            }
        }

        if (!y[0])
        {
            colors.push_back(1);
            return 1;
        }
        else if (!y[1])
        {
            colors.push_back(2);
            return 2;
        }
        else
        {
            colors.push_back(0);
            return 0;
        }
    }
    else
    {
        if (colors.empty() && y[0] + y[1] >= 3)
        {
            initialized = 1;
            if (y[0] == 1)
            {
                colors.push_back(0);
                return 0;
            }
            else
            {
                colors.push_back(1);
                return 1;
            }
        }
        if (!initialized)
        {
            if (!colors.empty() && y[0] + y[1] >= 2)
            {
                initialized = 1;
                if (!y[colors.back()])
                    return -1;
                else
                    return !colors.back();
            }
            else
            {
                if (!(y[0] + y[1]))
                {
                    initialized = 1;
                    return -1;
                }
                if (colors.size() == 4)
                {
                    initialized = 1;
                    for (size_t i = 0; i < 6; ++i) /*  pattern */
                    {
                        bool correct = 1;
                        for (size_t j = 0; j < 4; ++j)
                            correct &= colors[j] == pattern[(i + j) % 6];
                        if (correct)
                            return -1;
                    }
                    for (size_t i = 0; i < 6; ++i) /* inverted pattern */
                    {
                        bool correct = 1;
                        for (size_t j = 0; j < 4; ++j)
                            correct &= colors[j] == !pattern[(i + j) % 6];
                        if (correct)
                            return -1;
                    }
                    return !colors.back();
                }
                if (colors.empty())
                {
                    if (y[0] == 2)
                        colors.push_back(0);
                    else
                        colors.push_back(1);
                }
                if (y[0])
                {
                    colors.push_back(0);
                    return 0;
                }
                else
                {
                    colors.push_back(1);
                    return 1;
                }
            }
        }
        else
        {
            if (y[0] + y[1] >= 2)
            {
                colors.push_back(!colors.back());
                return !colors.back();
            }
            colors.push_back(y[1]);
            return y[1];
        }
    }
}

Compilation message (stderr)

Anthony.cpp: In function 'std::vector<int> Mark(int, int, int, int, std::vector<int>, std::vector<int>)':
Anthony.cpp:10:26: warning: comparison of integer expressions of different signedness: 'size_t' {aka 'long unsigned int'} and 'int' [-Wsign-compare]
   10 |     for (size_t i = 0; i < m; ++i)
      |                        ~~^~~
Anthony.cpp:45:30: warning: comparison of integer expressions of different signedness: 'size_t' {aka 'long unsigned int'} and 'int' [-Wsign-compare]
   45 |         for (size_t i = 0; i < m; ++i)
      |                            ~~^~~
Anthony.cpp:50:30: warning: comparison of integer expressions of different signedness: 'size_t' {aka 'long unsigned int'} and 'int' [-Wsign-compare]
   50 |         for (size_t i = 0; i < m; ++i)
      |                            ~~^~~

• Subtask 1: 2 / 2
• Subtask 2: 2 / 2
• Subtask 3: 2 / 2
• Subtask 4: 9 / 9
• Subtask 5: 0 / 5
• Subtask 6: 0 / 71
• Subtask 7: 0 / 9