Submission #410061

#	Time	Username	Problem	Language	Result	Execution time	Memory
410061		534351	Connecting Supertrees (IOI20_supertrees)	C++17	100 / 100	250 ms	26080 KiB

supertrees

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

using namespace std;

template<class T, class U>
void ckmin(T &a, U b)
{
    if (a > b) a = b;
}

template<class T, class U>
void ckmax(T &a, U b)
{
    if (a < b) a = b;
}

#define MP make_pair
#define PB push_back
#define LB lower_bound
#define UB upper_bound
#define fi first
#define se second
#define FOR(i, a, b) for (auto i = (a); i < (b); i++)
#define FORD(i, a, b) for (auto i = (a) - 1; i >= (b); i--)
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int) (x).size())

const int MAXN = 1013;

typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vpi;
typedef vector<pll> vpl;

int N;
int grid[MAXN][MAXN];
int dsu[MAXN], cc[MAXN], cc1[MAXN];
vi heads[MAXN];
vector<vi> ans;

int get(int u)
{
    return (u == dsu[u] ? u : dsu[u] = get(dsu[u]));
}
bool merge(int u, int v)
{
    u = get(u);
    v = get(v);
    if (u == v) return false;
    dsu[u] = v;
    return true;
}
void addedge(int i, int j)
{
    if (i == j) return;
    ans[i][j] = 1;
    ans[j][i] = 1;
}

int construct(vector<vi> p)
{
	N = SZ(p);
    FOR(i, 0, N)
    {
        FOR(j, 0, N)
        {
            grid[i][j] = p[i][j];
            if (grid[i][j] == 3)
            {
                return 0;
            }
        }
    }
    ans.resize(N);
    FOR(i, 0, N)
    {
        ans[i].resize(N);
    }
    iota(dsu, dsu + N, 0);
    FOR(i, 0, N)
    {
        FOR(j, 0, N)
        {
            if (grid[i][j] != 0)
            {
                merge(i, j);
            }
        }
    }
    FOR(i, 0, N)
    {
        cc[i] = get(i);
    }
    FOR(i, 0, N)
    {
        FOR(j, 0, N)
        {
            if (cc[i] == cc[j] && grid[i][j] == 0)
            {
                return 0;
            }
        }
    }
    iota(dsu, dsu + N, 0);
    FOR(i, 0, N)
    {
        FOR(j, 0, N)
        {
            if (grid[i][j] == 1)
            {
                merge(i, j);
            }
        }
    }
    FOR(i, 0, N)
    {
        cc1[i] = get(i);
    }
    FOR(i, 0, N)
    {
        FOR(j, 0, N)
        {
            if (cc1[i] == cc1[j] && grid[i][j] != 1)
            {
                return 0;
            }
        }
        addedge(i, cc1[i]);
    }
    FOR(i, 0, N)
    {
        if (cc1[i] == i)
        {
            heads[cc[i]].PB(i);
        }
    }
    FOR(i, 0, N)
    {
        if (cc[i] == i)
        {
            if (SZ(heads[i]) == 2)
            {
                return 0;
            }
            FOR(j, 0, SZ(heads[i]) - 1)
            {
                addedge(heads[i][j], heads[i][j + 1]);
            }
            addedge(heads[i][0], heads[i].back());
        }
    }
    build(ans);
    //first connect all the stuff that are 1's. if you get any 0's in between then bad.
    return 1;
}

• Subtask 1: 11 / 11
• Subtask 2: 10 / 10
• Subtask 3: 19 / 19
• Subtask 4: 35 / 35
• Subtask 5: 21 / 21
• Subtask 6: 4 / 4