Submission #749992

#	Time	Username	Problem	Language	Result	Execution time	Memory
749992		I_love_Hoang_Yen	Cyberland (APIO23_cyberland)	C++17	20 / 100	38 ms	3540 KiB

cyberland

#include "cyberland.h"
#include <bits/stdc++.h>
#define SZ(s) ((int) ((s).size()))
using namespace std;

const int ZERO = 0;
const int NORMAL = 1;
const int DIV2 = 2;

void upMin(double& res, double val) {
    if (res < -0.5) res = val;
    else res = min(res, val);
}

// N <= 3
double sub1(
        int n, int maxDiv2, int target,
        const vector<tuple<int,int,int>>& edges,
        const vector<int>& node_types) {
    if (target == 0) {
        return 0.0;
    }

    double res = -1;
    vector<vector<double>> costs(n, vector<double> (n, -1));
    for (auto [u, v, cost] : edges) {
        costs[u][v] = costs[v][u] = cost;
    }

    // go directly from 0 -> target
    if (costs[0][target] >= 0)
        upMin(res, costs[0][target]);
    if (n <= 2) return res;

    // go 0 -> other vertex -> target
    int other = 3 - target;
    if (costs[0][other] >= 0 && costs[other][target] >= 0) {
        switch (node_types[other]) {
            case NORMAL:
                upMin(res, costs[0][other] + costs[other][target]);
                break;
            case ZERO:
                upMin(res, costs[other][target]);
                break;
            case DIV2:
                if (maxDiv2 >= 1) {
                    upMin(res, costs[0][other] / 2.0 + costs[other][target]);
                } else {
                    upMin(res, costs[0][other] + costs[other][target]);
                }
                break;
        }
    }
    return res;
}

// All nodes are NORMAL
double sub25(
        int n, int target,
        const vector<vector<pair<int,int>>> g) {
    const int64_t INF = 1e18;
    vector<int64_t> dists(n, INF);
    set<pair<int64_t, int>> all;
    dists[0] = 0;
    all.insert({0LL, 0});
    while (!all.empty()) {
        auto [dist, u] = *all.begin();
        all.erase(all.begin());
        if (dist != dists[u]) continue;

        for (auto [v, cost] : g[u]) {
            int64_t cur = dist + cost;
            if (cur < dists[v]) {
                dists[v] = cur;
                all.insert({cur, v});
            }
        }
    }
    if (dists[target] == INF) dists[target] = -1;
    return dists[target];
}

double solve(
        int n, int m, int maxDiv2, int target,
        vector<int> edge_froms,
        vector<int> edge_tos,
        vector<int> edge_costs,
        vector<int> node_types) {

    assert(m == SZ(edge_froms));
    assert(m == SZ(edge_tos));
    assert(m == SZ(edge_costs));
    assert(n == SZ(node_types));

    if (n <= 3) {
        vector<tuple<int,int,int>> edges(m);
        for (int i = 0; i < m; ++i) {
            assert(0 <= edge_froms[i] && edge_froms[i] < n);
            assert(0 <= edge_tos[i] && edge_tos[i] < n);
            assert(1 <= edge_costs[i] && edge_costs[i] < 1000111000);
            edges[i] = {
                edge_froms[i],
                edge_tos[i],
                edge_costs[i]
            };
        }

        return sub1(
                n, maxDiv2, target,
                edges, node_types);
    }

    int minType = *min_element(node_types.begin(), node_types.end());
    int maxType = *max_element(node_types.begin(), node_types.end());
    if (minType == 1 && maxType == 1) {
        vector<vector<pair<int,int>>> g(n);
        for (int i = 0; i < m; ++i) {
            int u = edge_froms[i];
            int v = edge_tos[i];
            int cost = edge_costs[i];

            g[u].emplace_back(v, cost);
            g[v].emplace_back(u, cost);
        }
        return sub25(n, target, g);
    }
    return 0.0;
}

• Subtask 1: 5 / 5
• Subtask 2: 8 / 8
• Subtask 3: 0 / 13
• Subtask 4: 0 / 19
• Subtask 5: 7 / 7
• Subtask 6: 0 / 16
• Subtask 7: 0 / 29
• Subtask 8: 0 / 3