QOJ.ac

QOJ

ID题目提交者结果用时内存语言文件大小提交时间测评时间
#884308#3505. Flightsduongnc00015 12ms4224kbC++2020.3kb2025-02-05 23:49:382025-02-05 23:49:38

Judging History

This is the latest submission verdict.

  • [2025-02-05 23:49:38]
  • Judged
  • Verdict: 15
  • Time: 12ms
  • Memory: 4224kb
Show
  • [2025-02-05 23:49:38]
  • Submitted

Ali

#include "Ali.h"
#include <bits/stdc++.h>
#define taskname ""
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define i64 long long
#define isz(x) (int)x.size()
using namespace std;

namespace {

int N, nn;
vector<bool> ig;
vector<vector<pair<int, int>>> g;
vector<vector<int>> group;
vector<pair<int, int>> lab;
vector<int> par, dep, sz, lst, trr, head;
vector<string> sub_hash;

bool already_process;
map<string, pair<vector<vector<int>>, pair<vector<int>, int>>> fake_shit;
map<string, pair<vector<vector<int>>, pair<int, int>>> real_shit;
map<vector<int>, int> mp;

vector<string> six = {
    "000011001111",
    "000010110111",
    "000001110111",
    "000000111111",
    "000001011111",
    "000011100111",
    "000101100111",
    "000011011011",
    "000001111011",
    "000001101111",
    "000010111011",
};
vector<int> add = {3, 3, 2, 3, 4, 1, 2, 5, 2, 0, 3};

int dfs1(int u, int p) {
    int sz = 1;
    for (auto [v, id] : g[u]) if (v != p) {
        dep[v] = dep[u] + 1;
        int val = dfs1(v, u);
        if (val >= 7) ig[id] = true;
        else sz += val;
    }
    return sz;
}

void new_node() {
    g.emplace_back();
    ig.emplace_back(0);
    trr.emplace_back(-1);
    lab.emplace_back(-1, -1);
    sub_hash.emplace_back("");
}

void get_group(int u, int p) {
    sz[u] = 1;
    lab[u] = {isz(group) - 1, isz(group.back())};
    group.back().emplace_back(u);
    for (auto [v, id] : g[u]) if (v != p and id < N - 1 and not ig[id]) {
        par[v] = lab[u].second;
        get_group(v, u);
        sz[u] += sz[v];
        lst[u] = lst[v];
    }
    if (lst[u] == -1) lst[u] = u;
}

void add_nodes(int u) {
    int cnt = 0;
    for (auto [v, id] : g[u]) if (not ig[id]) {
        ++cnt;
        int clst = lst[v];
        while (sz[v] < 6) {
            new_node();
            g[clst].emplace_back(nn, nn - 1);
            g[nn].emplace_back(clst, nn - 1);
            clst = nn, sz[v]++, nn++;
        }
    }
    while (cnt < 2) {
        int clst = u;
        for (int i = 0; i < 6; ++i) {
            new_node();
            g[clst].emplace_back(nn, nn - 1);
            g[nn].emplace_back(clst, nn - 1);
            clst = nn, nn++;
        }
        ++cnt;
    }
}

int get_centroid() {
    vector<int> sz(N);
    auto dfs_sz = [&](auto self, int u, int p) -> void {
        sz[u] = 1;
        for (auto [v, id] : g[u]) if (v != p) {
            self(self, v, u);
            sz[u] += sz[v];
        }
    };
    dfs_sz(dfs_sz, 0, -1);
    auto dfs_cen = [&](auto self, int u, int p) -> int {
        for (auto [v, id] : g[u]) if (v != p) {
            if (sz[v] > sz[0] / 2) return self(self, v, u);
        }
        return u;
    };
    int root = dfs_cen(dfs_cen, 0, -1);
    queue<int> q;
    vector<int> vis(N);
    q.emplace(root);
    vis[root] = true;
    while (not q.empty()) {
        int u = q.front();
        if (isz(g[u]) < 3) {
            root = u;
            break;
        }
        q.pop();
        for (auto [v, id] : g[u]) if (not vis[v]) {
            q.emplace(v);
            vis[v] = true;
        }
    }
    vis.assign(N, -1);
    q = queue<int>();
    vis[root] = 0;
    q.emplace(root);
    while (not q.empty()) {
        int u = q.front();
        q.pop();
        for (auto [v, id] : g[u]) if (vis[v] == -1) {
            vis[v] = vis[u] + 1;
            q.emplace(v);
        }
    }
    assert(*max_element(all(vis)) <= 5000);
    return root;
}

int callitacheck(int u, int p) {
    int sz = 1;
    vector<int> vec;
    for (auto [v, id] : g[u]) if (v != p and not ig[id]) {
        int val = callitacheck(v, u);
        if (p == -1) vec.emplace_back(val);
        sz += val;
    }
    if (p == -1) {
        sort(all(vec));
        assert(vec[0] == 6);
        assert(vec[1] == 7);
        assert(sz == 14);
    }
    return sz;
}

// bool print;
string get_hash(int u, int p) {
    vector<string> vec;
    for (auto [v, id] : g[u]) if (v != p and not ig[id]) {
        // if (print) cout << v << " <-> " << u << endl;
        vec.push_back(get_hash(v, u));
    }
    sort(all(vec));
    string res = "";
    res.push_back('0');
    for (auto s : vec) res += s;
    res.push_back('1');
    return sub_hash[u] = res;
};

void relabel_dfs(int u, int p, int &cnt) {
    // cout << u << " = " << cnt << endl;
    lab[u].second = cnt++;
    vector<pair<string, int>> vec;
    for (auto [v, id] : g[u]) if (v != p and not ig[id]) {
        vec.push_back({sub_hash[v], v});
    }
    sort(all(vec));
    for (auto [_, v] : vec) {
        relabel_dfs(v, u, cnt);
    }
}

void add_to_make_7(int u, int p, int tp) {
    // print = true;
    // cout << get_hash(u, p) << endl;
    // print = false;
    queue<int> q;
    q.emplace(u);
    while (not q.empty()) {
        int u = q.front(); q.pop();
        if (lab[u].second == add[tp]) {
            // int deg = 0;
            // for (auto [v, id] : g[u]) if (not ig[id]) ++deg;
            // assert(deg < 3);
            // cout << u << endl;
            new_node();
            g[u].emplace_back(nn, nn - 1);
            g[nn].emplace_back(u, nn - 1);
            nn++;
            break;
        }
        for (auto [v, id] : g[u]) if (v != p and not ig[id] and lab[v].second > lab[u].second) {
            q.emplace(v);
        }
    }
}

void relabel_bfs(int u) {
    queue<array<int, 3>> q;
    q.push({u, -1, 0});
    vector<pair<int, pair<string, int>>> vec;
    while (not q.empty()) {
        auto [u, p, d] = q.front(); q.pop();
        vec.push_back({d, {sub_hash[u], u}});
        for (auto [v, id] : g[u]) if (v != p and not ig[id]) {
            q.push({v, u, d + 1});
        }
    }
    group.back().clear();
    sort(all(vec));
    for (auto tmp : vec) {
        int u = tmp.second.second;
        lab[u].first = isz(group) - 1;
        lab[u].second = isz(group.back());
        group.back().emplace_back(u);
    }
}

array<int, 3> bfs(int gX, int gY) {
    queue<int> q;
    vector<int> trace(nn, -1), d(nn, -1);
    d[group[gX][0]] = 0;
    q.emplace(group[gX][0]);
    while (not q.empty()) {
        auto u = q.front(); q.pop();

        if (lab[u].first == gY) {
            int len = 0, ou = u;
            while (lab[u].first != gX) {
                u = trace[u];
                ++len;
            }
            return {u, ou, len};
        }

        for (auto [v, id] : g[u]) {
            if (d[v] == -1) {
                d[v] = d[u] + 1;
                trace[v] = u;
                q.emplace(v);
            }
        }
    }
}

void dfs2(int u, int p, int d) {
    lab[u].first = d;
    for (auto [v, id] : g[u]) if (v != p and not ig[id]) {
        dfs2(v, u, d + 1);
    }
}

void process() {
    if (already_process) return;
    auto add_edge = [&](auto &g, int u, int v) -> void {
        g[u].emplace_back(v);
        g[v].emplace_back(u);
    };

    auto get_dist = [&](const auto &g, int root) -> vector<int> {
        queue<int> q;
        vector<int> d(isz(g), -1);
        q.emplace(root);
        d[root] = 0;
        while (not q.empty()) {
            int u = q.front();
            q.pop();
            for (auto v : g[u]) if (d[v] == -1) {
                d[v] = d[u] + 1;
                q.emplace(v);
            }
        }
        sort(all(d));
        return d;
    };

    auto get_hash = [&](auto &self, auto &g, int u, int p) -> string {
        vector<string> vec;
        for (auto v : g[u]) if (v != p) {
            vec.push_back(self(self, g, v, u));
        }
        sort(all(vec));
        string res = "";
        res.push_back('0');
        for (auto s : vec) res += s;
        res.push_back('1');
        return res;
    };

    for (int i = 0; i < isz(six); ++i) {
        vector<vector<int>> g(6);
        stack<int> st;
        int cur = -1;
        st.push(cur++);
        for (char ch : six[i]) {
            if (ch == '0') {
                int p = st.top();
                st.push(cur++);
                if (p != -1) {
                    add_edge(g, p, st.top());
                }
            }
            else {
                st.pop();
            }
        }
    }

    for (int i = 0; i < isz(six); ++i) for (int j = i; j < isz(six); ++j) {
        vector<vector<int>> g(14);
        int cur = 1;
        stack<int> st; st.push(0);
        for (char ch : six[i]) {
            if (ch == '0') {
                int p = st.top();
                st.push(cur++);
                add_edge(g, p, st.top());
            }
            else {
                st.pop();
            }
        }
        assert(cur == 7);
        for (char ch : six[j]) {
            if (ch == '0') {
                int p = st.top();
                st.push(cur++);
                add_edge(g, p, st.top());
            }
            else {
                st.pop();
            }
        }
        add_edge(g, 7 + add[j], cur++);
        assert(st.top() == 0 and cur == 14);
        auto dist = get_dist(g, 0);
        if (not mp.count(dist)) mp[dist] = isz(mp);
        fake_shit[get_hash(get_hash, g, 0, -1)] = {g, {dist, isz(fake_shit)}};
        for (int i = 0; i < 14; ++i) if (isz(g[i]) < 3) {
            auto str = get_hash(get_hash, g, i, -1);
            if (not real_shit.count(str)) real_shit[str] = {g, {i, isz(real_shit)}};
        }
    }
    already_process = true;
}

string encode(int ans) {
    int len = 1;
    assert(ans < (1 << 25) - 2);
    while (ans >= (1 << len)) {
        ans -= (1 << len);
        ++len;
    }
    assert(len < 25);
    string res = "";
    for (int i = 0; i < len; ++i) {
        res.push_back((ans >> i & 1) + '0');
    }
    return res;
}

}

void Init(int N, vector<int> U, vector<int> V) {
    ::N = N;
    g.assign(N, {});
    for (int i = 0; i < N - 1; ++i) {
        int u = U[i], v = V[i];
        g[u].emplace_back(v, i);
        g[v].emplace_back(u, i);
    }

    dep.assign(N, 0);
    ig.assign(N - 1, false);
    int root = get_centroid();
    dfs1(root, -1);

    nn = N;
    vector<int> avec(N);
    iota(all(avec), 0);
    sort(all(avec), [&](int x, int y) {
        return dep[x] < dep[y];
    });
    head.clear();
    group.clear();
    sz.assign(N, 0);
    lst.assign(N, -1);
    par.assign(N, -1);
    trr.assign(N, -1);
    sub_hash.assign(N, "");
    lab.assign(N, {-1, -1});
    for (int i : avec) if (lab[i].first == -1) {
        // cout << i << endl;
        head.emplace_back(i);
        group.emplace_back();
        get_group(i, -1);
        add_nodes(i);

        vector<pair<int, int>> wai;
        int cnt_child = 0;
        for (auto [v, id] : g[i]) if (not ig[id]) {
            ++cnt_child;
            auto str = get_hash(v, i);
            int idx = find(all(six), str) - six.begin();
            wai.emplace_back(idx, v);
            assert(idx < isz(six));
            int tmp = 0;
            relabel_dfs(v, i, tmp);
        }
        assert(cnt_child == 2);
        sort(all(wai));
        // cout << wai[1].second << " " << i << " " << wai[1].first << endl;
        add_to_make_7(wai[1].second, i, wai[1].first);
        get_hash(i, -1);
        relabel_bfs(i);

        callitacheck(i, -1);
    }

    for (int i = 0; i < N; ++i) {
        // cout << i << " " << lab[i].first * 13 + lab[i].second << endl;
        SetID(i, lab[i].first * 14 + lab[i].second);
    }
}

string SendA(string S) {
    int val = 0, cnt = 0;
    for (int i = 0; i < 20; ++i) {
        val += (S[i] - '0') << i;
    }
    int gX = -1, gY = -1;
    for (int i = 0; i < 1429; ++i) for (int j = i; j < 1429; ++j) {
        if (val == cnt) gX = i, gY = j;
        ++cnt;
    }

    // cout << -1 << endl;
    // return "11";

    process();

    if (gX == gY) {
        auto str = get_hash(head[gX], -1);
        assert(fake_shit.count(str));
        int idx = fake_shit[str].second.second;
        string res = "";
        for (int i = 0; i < 5; ++i) res.push_back((idx >> i & 1) + '0');
        return res;
    }

    auto [vX, vY, len] = bfs(gX, gY);
    // assert(gX <= gY);

    int ans = 0;
    if (len <= 5000) {
        assert(vY == head[gY]);
        auto strX = get_hash(vX, -1);
        auto strY = get_hash(vY, -1);
        assert(real_shit.count(strX));
        assert(fake_shit.count(strY));
        auto distY = fake_shit[strY].second.first;
        assert(mp.count(distY));
        ans += (len - 1) * 288 * 21 + real_shit[strX].second.second * 21 + mp[distY];
        assert(ans < 5000 * 288 * 21);
    }
    else {
        ans += 5000 * 288 * 21;
        assert(vX == head[gX]);
        assert(vY == head[gY]);
        auto strX = get_hash(vX, -1);
        auto strY = get_hash(vY, -1);
        assert(fake_shit.count(strX));
        assert(fake_shit.count(strY));
        auto distX = fake_shit[strX].second.first;
        auto distY = fake_shit[strY].second.first;
        assert(mp.count(distX));
        assert(mp.count(distY));
        ans += (len - 5001) * 21 * 21 + mp[distX] * 21 + mp[distY];
    }
    // cout << ans << endl;
    return encode(ans);

    // dfs2(vX, -1, 0); dfs2(vY, -1, 0);

    // string res = "";

    // sort(all(group[gX]), [&](const auto &lhs, const auto &rhs) {
    //     return lab[lhs].second < lab[rhs].second;
    // });
    // for (auto u : group[gX]) for (int i = 0; i < 4; ++i) {
    //     res.push_back((lab[u].first >> i & 1) + '0');
    // }
    // while (isz(res) < 52) res.push_back('0');

    // sort(all(group[gY]), [&](const auto &lhs, const auto &rhs) {
    //     return lab[lhs].second < lab[rhs].second;
    // });
    // for (auto u : group[gY]) for (int i = 0; i < 4; ++i) {
    //     res.push_back((lab[u].first >> i & 1) + '0');
    // }
    // while (isz(res) < 104) res.push_back('0');

    // for (int i = 0; i < 14; ++i) {
    //     res.push_back((len >> i & 1) + '0');
    // }

    // return res;
}
源文件, 语言: C++20

Benjamin

#include "Benjamin.h"
#include <bits/stdc++.h>
#define taskname ""
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define i64 long long
#define isz(x) (int)x.size()
using namespace std;

namespace {

int gX, nX, gY, nY;

bool already_process;
map<string, pair<vector<vector<int>>, pair<vector<int>, int>>> fake_shit;
map<string, pair<vector<vector<int>>, pair<int, int>>> real_shit;
map<vector<int>, int> mp;

vector<string> six = {
    "000011001111",
    "000010110111",
    "000001110111",
    "000000111111",
    "000001011111",
    "000011100111",
    "000101100111",
    "000011011011",
    "000001111011",
    "000001101111",
    "000010111011",
};
vector<int> add = {3, 3, 2, 3, 4, 1, 2, 5, 2, 0, 3};

void process() {
    if (already_process) return;
    auto add_edge = [&](auto &g, int u, int v) -> void {
        g[u].emplace_back(v);
        g[v].emplace_back(u);
    };

    auto get_dist = [&](const auto &g, int root) -> vector<int> {
        queue<int> q;
        vector<int> d(isz(g), -1);
        q.emplace(root);
        d[root] = 0;
        while (not q.empty()) {
            int u = q.front();
            q.pop();
            for (auto v : g[u]) if (d[v] == -1) {
                d[v] = d[u] + 1;
                q.emplace(v);
            }
        }
        sort(all(d));
        return d;
    };

    auto get_hash = [&](auto &self, auto &g, int u, int p) -> string {
        vector<string> vec;
        for (auto v : g[u]) if (v != p) {
            vec.push_back(self(self, g, v, u));
        }
        sort(all(vec));
        string res = "";
        res.push_back('0');
        for (auto s : vec) res += s;
        res.push_back('1');
        return res;
    };

    for (int i = 0; i < isz(six); ++i) {
        vector<vector<int>> g(6);
        stack<int> st;
        int cur = -1;
        st.push(cur++);
        for (char ch : six[i]) {
            if (ch == '0') {
                int p = st.top();
                st.push(cur++);
                if (p != -1) {
                    add_edge(g, p, st.top());
                }
            }
            else {
                st.pop();
            }
        }
    }

    for (int i = 0; i < isz(six); ++i) for (int j = i; j < isz(six); ++j) {
        vector<vector<int>> g(14);
        int cur = 1;
        stack<int> st; st.push(0);
        for (char ch : six[i]) {
            if (ch == '0') {
                int p = st.top();
                st.push(cur++);
                add_edge(g, p, st.top());
            }
            else {
                st.pop();
            }
        }
        assert(cur == 7);
        for (char ch : six[j]) {
            if (ch == '0') {
                int p = st.top();
                st.push(cur++);
                add_edge(g, p, st.top());
            }
            else {
                st.pop();
            }
        }
        add_edge(g, 7 + add[j], cur++);
        assert(st.top() == 0 and cur == 14);
        auto dist = get_dist(g, 0);
        if (not mp.count(dist)) mp[dist] = isz(mp);
        fake_shit[get_hash(get_hash, g, 0, -1)] = {g, {dist, isz(fake_shit)}};
        for (int i = 0; i < 14; ++i) if (isz(g[i]) < 3) {
            auto str = get_hash(get_hash, g, i, -1);
            if (not real_shit.count(str)) real_shit[str] = {g, {i, isz(real_shit)}};
        }
    }
    already_process = true;
}

vector<int> get_label(const vector<vector<int>> &g) {
	vector<string> sub_hash(isz(g));
	auto get_hash = [&](auto self, int u, int p) -> string {
	    vector<string> vec;
	    for (auto v : g[u]) if (v != p) {
	        vec.push_back(self(self, v, u));
	    }
	    sort(all(vec));
	    string res = "";
	    res.push_back('0');
	    for (auto s : vec) res += s;
	    res.push_back('1');
	    return sub_hash[u] = res;
	};
	get_hash(get_hash, 0, -1);

	vector<int> nl(isz(g));
	queue<array<int, 3>> q;
    q.push({0, -1, 0});
    vector<pair<int, pair<string, int>>> vec;
    while (not q.empty()) {
        auto [u, p, d] = q.front(); q.pop();
        vec.push_back({d, {sub_hash[u], u}});
        for (auto v : g[u]) if (v != p) {
            q.push({v, u, d + 1});
        }
    }
    sort(all(vec));
    for (int i = 0; i < isz(vec); ++i) {
    	nl[i] = vec[i].second.second;
    }
    return nl;
}

int bfs(const vector<vector<int>> &g, int st, int en) {
	queue<int> q;
	vector<int> d(isz(g), -1);
	d[st] = 0; q.emplace(st);
	while (not q.empty()) {
		int u = q.front(); q.pop();
		for (auto v : g[u]) if (d[v] == -1) {
			d[v] = d[u] + 1;
			q.emplace(v);
		}
	}
	return d[en];
}

}

string SendB(int N, int X, int Y) {
	if (X > Y) swap(X, Y);

	gX = X / 14, nX = X % 14;
	gY = Y / 14, nY = Y % 14;

	int val = -1, cnt = 0;
	for (int i = 0; i < 1429; ++i) for (int j = i; j < 1429; ++j) {
		if (i == gX and j == gY) val = cnt;
		++cnt;
	}

	string res = "";
	for (int i = 0; i < 20; ++i) {
		res.push_back((val >> i & 1) + '0');
	}
	return res;
}

int Answer(string T) {
	process();

	if (gX == gY) {
		int grp = 0;
		for (int i = 0; i < 5; ++i) {
			grp += (T[i] - '0') << i;
		}
		vector<vector<int>> g;
		for (auto [_, tmp] : fake_shit) if (tmp.second.second == grp) {
			g = tmp.first;
		}
		assert(isz(g) == 14);
		auto nl = get_label(g);
		return bfs(g, nl[nX], nl[nY]);
	}

	// cout << gX << " " << gY << " " << nX << " " << nY << endl;
	int enc = 0;
	for (int i = 1; i < isz(T); ++i) {
		enc += 1 << i;
	}
	for (int i = 0; i < isz(T); ++i) {
		enc += (T[i] - '0') << i;
	}
	// cout << enc << endl;

	int res = 0;
	if (enc < 5000 * 288 * 21) {
		int len = enc / (288 * 21) + 1; enc %= 288 * 21;
		res += len;

		int tpX = enc / 21; enc %= 21;
		for (auto [_, tmp] : real_shit) if (tmp.second.second == tpX) {
			auto g = tmp.first;
			auto root = tmp.second.first;
			auto nl = get_label(g);
			res += bfs(g, root, nl[nX]);
			break;
		}

		int tpY = enc;
		for (auto [dist, idx] : mp) if (idx == tpY) {
			res += dist[nY];
			break;
		}
	}
	else {
		enc -= 5000 * 288 * 21;
		int len = enc / (21 * 21) + 5001; enc %= 21 * 21;
		res += len;

		int tpX = enc / 21; enc %= 21;
		for (auto [dist, idx] : mp) if (idx == tpX) {
			res += dist[nX];
			break;
		}

		int tpY = enc;
		for (auto [dist, idx] : mp) if (idx == tpY) {
			res += dist[nY];
			break;
		}
	}

	return res;
}
源文件, 语言: C++20

详细

Subtask #1:

score: 15
Accepted

Test #1:

score: 15
Accepted
time: 1ms
memory: 3968kb

input:

1
2 2 0
01110

output:

00000000000000000000
1

input:

output:

1
5

result:

points 1.0 L = 5 (test case 1)

Test #2:

score: 15
Accepted
time: 1ms
memory: 3968kb

input:

1
3 1 2
01110

output:

00000000000000000000
2

input:

output:

2
5

result:

points 1.0 L = 5 (test case 1)

Test #3:

score: 15
Accepted
time: 1ms
memory: 3968kb

input:

1
4 1 0
01110

output:

00000000000000000000
1

input:

output:

1
5

result:

points 1.0 L = 5 (test case 1)

Test #4:

score: 15
Accepted
time: 2ms
memory: 3968kb

input:

1
5 4 2
00001

output:

00000000000000000000
1

input:

output:

1
5

result:

points 1.0 L = 5 (test case 1)

Test #5:

score: 15
Accepted
time: 3ms
memory: 4224kb

input:

1
10000 5784 15710
10110010110110100

output:

00001011111011011110
28

input:

output:

28
17

result:

points 1.0 L = 17 (test case 1)

Test #6:

score: 15
Accepted
time: 1ms
memory: 4224kb

input:

1
10000 12390 1758
0100110110100001

output:

11001110011110010100
20

input:

output:

20
16

result:

points 1.0 L = 16 (test case 1)

Test #7:

score: 15
Accepted
time: 2ms
memory: 4224kb

input:

1
10000 12544 10839
01010111010011100

output:

10010110000010100011
29

input:

output:

29
17

result:

points 1.0 L = 17 (test case 1)

Test #8:

score: 15
Accepted
time: 1ms
memory: 4096kb

input:

1
10000 13679 7449
10110100100001010

output:

11000101110011101001
31

input:

output:

31
17

result:

points 1.0 L = 17 (test case 1)

Test #9:

score: 15
Accepted
time: 2ms
memory: 4224kb

input:

1
10000 6492 8170
11110001101001011010

output:

01010100111011100001
240

input:

output:

240
20

result:

points 1.0 L = 20 (test case 1)

Test #10:

score: 15
Accepted
time: 2ms
memory: 4096kb

input:

1
8191 12812 2327
1001000001101011

output:

00110000001101101100
23

input:

output:

23
16

result:

points 1.0 L = 16 (test case 1)

Test #11:

score: 15
Accepted
time: 2ms
memory: 3968kb

input:

1
9996 6309 4571
100101100001011000

output:

11010010101100100110
54

input:

output:

54
18

result:

points 1.0 L = 18 (test case 1)

Test #12:

score: 15
Accepted
time: 2ms
memory: 4096kb

input:

1
9996 7899 11049
100110111111000001

output:

11101111000001111001
70

input:

output:

70
18

result:

points 1.0 L = 18 (test case 1)

Test #13:

score: 15
Accepted
time: 0ms
memory: 3968kb

input:

1
10000 10410 10382
1111111110001000000

output:

10001010100111111101
96

input:

output:

96
19

result:

points 1.0 L = 19 (test case 1)

Test #14:

score: 15
Accepted
time: 1ms
memory: 4096kb

input:

1
10000 19990 20004
001110110101111101110111

output:

10100100111010011111
9999

input:

output:

9999
24

result:

points 1.0 L = 24 (test case 1)

Test #15:

score: 15
Accepted
time: 1ms
memory: 4096kb

input:

1
9997 2964 5899
00101101001111001100

output:

01101000001000100010
218

input:

output:

218
20

result:

points 1.0 L = 20 (test case 1)

Subtask #2:

score: 0
Interactor Runtime Error

Test #16:

score: 85
Accepted
time: 12ms
memory: 4096kb

input:

15
2 0 2
01110
3 1 0
01110
4 2 1
01110
5 4 0
00001
10000 5211 4891
1000100001110110
10000 2839 8277
0101100101111110
10000 3646 7520
1001100001110110
10000 382 10208
0010111010011001
10000 8549 4442
11111011100000011101010
8191 13054 13972
1001001101100101
9996 8404 2978
100100011000010000
9996 8787...

output:

00000000000000000000
1
00000000000000000000
1
00000000000000000000
2
00000000000000000000
2
01000000111101010110
20
01010011100110000010
24
11000111000101001010
20
01101000000110010000
21
00000000111001000110
1866
00000000001011011011
20
01010001100100100010
50
10101000001010001110
62
10110011110100...

input:

output:

1
1
2
2
20
24
20
21
1866
20
50
62
172
9999
659
24

result:

points 1.0 L = 24 (test case 15)

Test #17:

score: 0
Interactor Runtime Error

input:

50
2 2 0
01110
3 0 2
01110
4 0 1
01110
5 1 2
01110
6 1 2
01110
7 8 4
11110
8 17 15
11010
9 20 15
10101
10 20 19
10101
11 16 18
00001
12 0 19
00000101010
13 19 2
0010111111
14 24 17
01101
15 24 23
00101
16 9 23
1001110100
17 7 14
0100111111
18 14 0
001000010000
19 34 19
10100011110
20 25 15
10010
21 ...

output:

00000000000000000000
1
00000000000000000000
1
00000000000000000000
1
00000000000000000000
2
00000000000000000000
2
00000000000000000000
1
10101001101000000000
1
10101001101000000000
1
10101001101000000000
4
10101001101000000000
1
10000000000000000000
3
10000000000000000000
3
10101001101000000000
5
1...

input:

output:

result:
English 繁體中文 简体中文

服务器时间: 2025-02-14 04:11:27 | 开源项目