Submission #1332104

#	Time	Username	Problem	Language	Result	Execution time	Memory
1332104		QuocSensei	Robot Contest (IOI23_robot)	C++20	100 / 100	39 ms	5936 KiB

robot

#include "robot.h"
#include <bits/stdc++.h>

#define ll long long 
#define el cout << endl
#define DEBUG(...) [](auto &&...x) {int i = 0; ((cout << (i++ ? " " : "") << x), ...), el;} (__VA_ARGS__)

using namespace std;

const char DIR[] = {'W', 'S', 'E', 'N'};
const int COLOR[] = {2, 3, 4, 5};

namespace SUBTASK_1
{
    void program_pulibot()
    {
        set_instruction({0, 1, -2, -2, 0}, 1, 'T');
        set_instruction({0, -2, 0, 0, -2}, 1, 'S');
        set_instruction({0, -2, 0, 0, 1}, 1, 'S');
        set_instruction({0, -2, -2, 0, 1}, 1, 'E');
        set_instruction({0, 1, -2, 0, 0}, 1, 'E');
    }
};
namespace SUBTASK_2
{
    void program_pulibot()
    {
        auto genE = [&] ()
        {
            for (int x = -2; x <= 1; x++)
                for (int y = -2; y <= 1; y++)
                    for (int q = -2; q <= 1; q++)
                    {
                        int p = 0;
                        set_instruction({0, x, y, p, q}, 1, 'E');
                    }
        };
        auto genN = [&] ()
        {
            for (int x = -2; x <= 1; x++)
                for (int y = -2; y <= 1; y++)
                {
                    for (int p = -2; p <= -1; p++)
                    {
                        if (y == -2 && p == -2)
                            continue;
                        int q = 0;
                        set_instruction({0, x, y, p, q}, 1, 'N');
                    }
                }
        };
        auto genS = [&] ()
        {
            for (int x = -2; x <= 1; x++)
                for (int p = -2; p <= -1; p++)
                    for (int q = -2; q <= -1; q++)
                    {
                        int y = 0;
                        set_instruction({0, x, y, p, q}, 1, 'S');
                    }
        };
        auto genT = [&] ()
        {
            for (int x = -2; x <= 1; x++)
                for (int q = -2; q <= 1; q++)
                {
                    int y = -2;
                    int p = -2;
                    set_instruction({0, x, y, p, q}, 1, 'T');
                }
        };
        genE();
        genN();
        genS();
        genT();
    }
}
namespace SUBTASK_3
{
    void gen_dfs()
    {
        vector<int> val = {-1, -2, 0, 2, 3};
        for (int x : val)
            for (int y : val)
                for (int p : val)
                    for (int q : val)
                    {
                        auto f = [&] (int x)
                        {
                            return x == 3;
                        };
                        bool is_root = x == -2 && q == -2;
                        int cnt = f(x) + f(y) + f(p) + f(q);

                        if (cnt != 1 && !(is_root && cnt == 0))
                            continue;
                        if (y == -2 && p == -2)
                            continue;

                        vector<int> v = {x, y, p, q};
                        bool flag = 0;
                        for (int k = 0; k < 4; k++)
                            if (v[k] == 0)
                            {
                                set_instruction({0, x, y, p, q}, 3, DIR[k]);
                                set_instruction({3, x, y, p, q}, 3, DIR[k]);
                                flag |= 1;
                                break;
                            }
                        if (flag)
                            continue;
                        for (int k = 0; k < 4; k++)
                            if (v[k] == 3)
                            {
                                set_instruction({0, x, y, p, q}, 2, DIR[k]);
                                set_instruction({3, x, y, p, q}, 2, DIR[k]);
                            }
                    }
    }
    void gen_ans()
    {
        vector<int> val = {-1, -2, 0, 2, 3};
        for (int x : val)
            for (int q : val)
            {
                auto f = [&] (int x)
                {
                    return x == 3;
                };
                if (f(x) + f(q) != 1)
                    continue;
                vector<int> v = {x, q};
                vector<char> dir = {'W', 'N'};
                for (int k = 0; k < 2; k++)
                    if (v[k] == 3)
                        set_instruction({0, x, -2, -2, q}, 1, dir[k]);
            }
        val.push_back(4);
        for (int x : val)
            for (int y : val)
                for (int p : val)
                    for (int q : val)
                    {
                        vector<int> v = {x, y, p, q};
                        int cnt3 = 0;
                        for (int k : v)
                            cnt3 += k == 3 || k == 4;
                        if (cnt3 != 1)
                            continue;
                        bool flag = 0;
                        for (int k = 0; k < 4; k++)
                            if (v[k] == 2)
                            {
                                set_instruction({4, x, y, p, q}, 4, DIR[k]);
                                set_instruction({2, x, y, p, q}, 4, DIR[k]);
                                flag |= 1;
                                break;
                            }
                        if (flag)
                            continue;
                        for (int k = 0; k < 4; k++)
                            if (v[k] == 3 || v[k] == 4)
                            {
                                set_instruction({2, x, y, p, q}, 0, DIR[k]);
                                set_instruction({4, x, y, p, q}, 0, DIR[k]);
                            }
                    }
        val.pop_back();
        val.push_back(1);
        for (int x : val)
            for (int y : val)
                for (int p : val)
                    for (int q : val)
                    {
                        vector<int> v = {x, y, p, q};
                        int cnt1 = 0;
                        int cnt3 = 0;
                        bool is_root = x == -2 && q == -2;
                        for (int k : v)
                        {
                            cnt1 += k == 1;
                            cnt3 += k == 3;
                        }
                        if (cnt1 != 1)
                            continue;
                        if (cnt3 != 1 && !is_root)
                            continue;
                        bool flag = 0;
                        for (int k = 0; k < 4; k++)
                        {
                            if (v[k] == 2)
                            {
                                set_instruction({3, x, y, p, q}, 3, DIR[k]);
                                flag |= 1;
                                break;
                            }
                        }
                        if (flag)
                            continue;
                        for (int k = 0; k < 4; k++)
                            if (v[k] == 3)
                            {
                                set_instruction({3, x, y, p, q}, 1, DIR[k]);
                            }
                    }
        val = {-2, -1, 0, 1};
        for (int y : val)
            for (int p : val)
            {
                int x = -2;
                int q = -2;
                if ((y == 1) + (p == 1) != 1)
                    continue;
                set_instruction({3, x, y, p, q}, 1, 'T');
            }
    }

    void program_pulibot()
    {
        gen_dfs();
        gen_ans();
    }
}
namespace SUBTASK_4
{
    void gen_dfs()
    {
        vector<int> val = {-1, -2, 0, 2, 3};
        for (int x : val)
            for (int y : val)
                for (int p : val)
                    for (int q : val)
                    {
                        auto f = [&] (int x)
                        {
                            return x == 3;
                        };
                        bool is_root = x == -2 && q == -2;
                        int cnt = f(x) + f(y) + f(p) + f(q);

                        if (cnt != 1 && !(is_root && cnt == 0))
                            continue;
                        if (y == -2 && p == -2)
                            continue;

                        vector<int> v = {x, y, p, q};
                        vector<int> dir = {1, 2};
                        bool flag = 0;
                        for (int k : dir)
                            if (v[k] == 0)
                            {
                                set_instruction({0, x, y, p, q}, 3, DIR[k]);
                                set_instruction({3, x, y, p, q}, 3, DIR[k]);
                                flag |= 1;
                                break;
                            }
                        if (flag)
                            continue;
                        dir = {0, 3};
                        for (int k : dir)
                            if (v[k] == 3)
                            {
                                set_instruction({0, x, y, p, q}, 2, DIR[k]);
                                set_instruction({3, x, y, p, q}, 2, DIR[k]);
                            }
                    }
    }
    void gen_ans()
    {
        vector<int> val = {-1, -2, 0, 2, 3};
        for (int x : val)
            for (int q : val)
            {
                auto f = [&] (int x)
                {
                    return x == 3;
                };
                if (f(x) + f(q) != 1)
                    continue;
                vector<int> v = {x, q};
                vector<char> dir = {'W', 'N'};
                for (int k = 0; k < 2; k++)
                    if (v[k] == 3)
                        set_instruction({0, x, -2, -2, q}, 1, dir[k]);
            }
        val.push_back(4);
        for (int x : val)
            for (int y : val)
                for (int p : val)
                    for (int q : val)
                    {
                        vector<int> dir = {1, 2};
                        vector<int> v = {x, y, p, q};
                        int cnt3 = 0;
                        for (int k : v)
                            cnt3 += k == 3 || k == 4;
                        if (cnt3 != 1)
                            continue;
                        bool flag = 0;
                        for (int k : dir)
                            if (v[k] == 2)
                            {
                                set_instruction({4, x, y, p, q}, 4, DIR[k]);
                                set_instruction({2, x, y, p, q}, 4, DIR[k]);
                                flag |= 1;
                                break;
                            }
                        if (flag)
                            continue;
                        dir = {0, 3};
                        for (int k : dir)
                            if (v[k] == 3 || v[k] == 4)
                            {
                                set_instruction({2, x, y, p, q}, 0, DIR[k]);
                                set_instruction({4, x, y, p, q}, 0, DIR[k]);
                            }
                    }
        val.pop_back();
        val.push_back(1);
        for (int x : val)
            for (int y : val)
                for (int p : val)
                    for (int q : val)
                    {
                        vector<int> v = {x, y, p, q};
                        int cnt1 = 0;
                        int cnt3 = 0;
                        bool is_root = x == -2 && q == -2;
                        for (int k : v)
                        {
                            cnt1 += k == 1;
                            cnt3 += k == 3;
                        }
                        if (cnt1 != 1)
                            continue;
                        if (cnt3 != 1 && !is_root)
                            continue;
                        bool flag = 0;
                        for (int k = 0; k < 4; k++)
                        {
                            if (v[k] == 2)
                            {
                                set_instruction({3, x, y, p, q}, 3, DIR[k]);
                                flag |= 1;
                                break;
                            }
                        }
                        if (flag)
                            continue;
                        for (int k = 0; k < 4; k++)
                            if (v[k] == 3)
                            {
                                set_instruction({3, x, y, p, q}, 1, DIR[k]);
                            }
                    }
        val = {-2, -1, 0, 1};
        for (int y : val)
            for (int p : val)
            {
                int x = -2;
                int q = -2;
                if ((y == 1) + (p == 1) != 1)
                    continue;
                set_instruction({3, x, y, p, q}, 1, 'T');
            }
    }

    void program_pulibot()
    {
        gen_dfs();
        gen_ans();
    }
}
namespace SUBTASK_AC
{
    bool is_direct(int col)
    {
        return col >= 2 && col <= 5;
    }
    bool is_inver(int color_a, int pos_b, int color_b)
    {
        if (!is_direct(color_a) || !is_direct(color_b))
            return 0;
        if (abs(color_a - color_b) != 2)
            return 0;
        int pos_a = color_a - 2;
        return pos_a == pos_b;
    }
    void gen_bfs()
    {
        auto gen_empty = [&] ()
        {
            vector<int> val = {-2, -1, 0, 2, 3, 4, 5};
            
            for (int y : {-1, 0})
                for (int p : {-1, 0})
                {
                    int x = -2;
                    int q = -2;
                    if (y == 0)
                        set_instruction({0, x, y, p, q}, COLOR[1], DIR[1]);
                    else if (p == 0)
                        set_instruction({0, x, y, p, q}, COLOR[2], DIR[2]);
                }
            for (int x : val)
                for (int y : val)
                    for (int p : val)
                        for (int q : val)
                        {
                            vector<int> v = {x, y, p, q};
                            vector<int> dir = {0, 1, 2, 3};

                            function<bool()> check_state = [=] () -> bool
                            {
                                if (x == -2 && q == -2)
                                    return 0;
                                if (y == -2 && p == -2)
                                    return 0;
                                int cnt = 0;
                                for (int k : dir)
                                    cnt += is_inver(COLOR[k], k, v[k]);
                                return cnt == 1;
                            };
                            if (!check_state())
                                continue;
                            for (int k : dir)
                                if (is_inver(COLOR[k], k, v[k]))
                                {
                                    set_instruction({0, x, y, p, q}, COLOR[k], DIR[k]);
                                }
                        }
        };
        auto gen_state = [&] ()
        {
            vector<int> val = {-2, -1, 0, 2, 3, 4, 5};
            for (int state : COLOR)
                for (int x : val)
                    for (int y : val)
                        for (int p : val)
                            for (int q : val)
                            {
                                vector<int> v = {x, y, p, q};
                                vector<int> dir;

                                if (!is_inver(state, state - 2, v[state - 2]))
                                    continue;

                                dir.push_back((state + 3) % 4);
                                for (int _ = 0; _ < 3; _++)
                                    dir.push_back((dir.back() + 1) % 4);
                                for (int k : dir)
                                {
                                    if (v[k] == 0 || is_inver(COLOR[k], k, v[k]))
                                    {
                                        set_instruction({state, x, y, p, q}, COLOR[k], DIR[k]);
                                        break;
                                    }
                                }
                            }
        };

        gen_empty();
        gen_state();
    }
    void gen_ans()
    {
        auto gen_en = [=] ()
        {
            vector<int> val = {-1, 0, 1, 2, 3, 4, 5};
            for (int x : val)
                for (int q : val)
                {
                    int y = -2;
                    int p = -2;
                    if (is_inver(COLOR[0], 0, x))
                        set_instruction({0, x, y, p, q}, COLOR[2], DIR[0]);
                    else if (is_inver(COLOR[3], 3, q))
                        set_instruction({0, x, y, p, q}, COLOR[1], DIR[3]);
                    if (x == 1 || q == 1)
                        for (int state : COLOR)
                            set_instruction({state, x, y, p, q}, 1, 'T');
                }
        };
        auto gen_st = [=] ()
        {
            vector<int> val = {-1, 0, 2, 3, 4, 5};
            for (int state : COLOR)
            {
                for (int y : val)
                    for (int p : val)
                    {
                        int x = -2;
                        int q = -2;
                        if (is_inver(COLOR[1], 1, y) || is_inver(COLOR[2], 2, p))
                            continue;
                        if (is_direct(y))
                            set_instruction({state, x, y, p, q}, 1, DIR[1]);
                        else if (is_direct(p))
                            set_instruction({state, x, y, p, q}, 1, DIR[2]);
                    }
            }
        };
        auto gen_dfs = [=] ()
        {
            vector<int> val = {-2, -1, 0, 1, 2, 3, 4, 5};
            for (int state : COLOR)
                for (int x : val)
                    for (int y : val)
                        for (int p : val)
                            for (int q : val)
                            {
                                vector<int> v = {x, y, p, q};
                                vector<int> dir = {0, 1, 2, 3};
                                int cnt1 = 0;
                                
                                auto check_state = [&] () -> bool
                                {
                                    if (x == -2 && q == -2)
                                    {
                                        int cnt = 0;
                                        for (int k : dir)
                                            cnt += is_inver(COLOR[k], k, v[k]);
                                        return !is_inver(state, state - 2, v[state - 2]) && cnt;
                                    }
                                    if (y == -2 && p == -2)
                                        return 0;
                                    for (int k : dir)
                                        cnt1 += v[k] == 1;
                                    return cnt1 <= 1 && !is_inver(state, state - 2, v[state - 2]);
                                };
                                if (!check_state())
                                    continue;
                                bool flag = 0;
                                for (int k : dir)
                                    if (is_inver(COLOR[k], k, v[k]))
                                    {
                                        set_instruction({state, x, y, p, q}, state, DIR[k]);
                                        flag = 1;
                                        break;
                                    }
                                if (flag)
                                    continue;
                                for (int C : dir)
                                    cnt1 += v[C] == 1;
                                if (cnt1)
                                    set_instruction({state, x, y, p, q}, 1, DIR[state - 2]);
                                else
                                    set_instruction({state, x, y, p, q}, 0, DIR[state - 2]);
                            }
        };

        gen_en();
        gen_st();
        gen_dfs();
    }

    void program_pulibot()
    {
        gen_bfs();
        gen_ans();
    }
}

void program_pulibot()
{
    SUBTASK_AC::program_pulibot();
}

• Subtask 0: 0 / 0
• Subtask 1: 6 / 6
• Subtask 2: 10 / 10
• Subtask 3: 18 / 18
• Subtask 4: 20 / 20
• Subtask 5: 46 / 46