Submission #1137334

#	Time	Username	Problem	Language	Result	Execution time	Memory
1137334		Iwanttobreakfree	Crocodile's Underground City (IOI11_crocodile)	C++17	0 / 100	0 ms	320 KiB

crocodile

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

// Multi-Dijkstra
vector<vector<long long>> Dijkstra(int K, int P[], vector<vector<pair<int,int>>>& lista) {
    int n = lista.size();
    priority_queue<pair<pair<long long,int>, bool>> pq; // log N
    vector<vector<long long>> dist(n, vector<long long> (2, 1e18)); // nos guardamos las rutas alternativas
    // dist[v][0] nos guardamos la segunda distancia mas corta a una de las salidas
    // dist[v][1] nos guardamos la primera distancia mas corta a una de las salidas
    for (int i = 0; i < K; ++i) {
        dist[P[i]][1] = 0;
        pq.push({{dist[P[i]][1], P[i]}, 1});
    }
    while (!pq.empty()) {
        int nodoActual = pq.top().first.second;
        long long distActual = -pq.top().first.first;
        bool masCorta = pq.top().second;
        pq.pop();
        if (dist[nodoActual][masCorta] < distActual) continue;
        for (auto vecino: lista[nodoActual]) {
            int nextNodo = vecino.first, w = vecino.second;
            // Actualizar distancia mas corta
            if (dist[nextNodo][masCorta] > dist[nodoActual][masCorta] + w) { // Hemos encontrado una ruta alternativa que mejora la anterior
                if (masCorta && dist[nextNodo][0] > dist[nextNodo][1]) {
                    dist[nextNodo][0] = dist[nodoActual][1];
                    pq.push({{-dist[nextNodo][0], nextNodo}, false});
                }
                dist[nextNodo][masCorta] = dist[nodoActual][masCorta] + w;
                pq.push({{-dist[nextNodo][masCorta], nextNodo}, masCorta});
            }   // Solo se actualiza la segunda
            else if (masCorta && dist[nextNodo][false] > dist[nodoActual][true] + w) { // Hemos encontrado una ruta alternativa que mejora la anterior
                dist[nextNodo][false] = dist[nodoActual][true] + w;
                pq.push({{-dist[nextNodo][false], nextNodo}, false});
            }   
        }
    }
    return dist;
}

/*
Cocodrilo
Primera prioridad: Conseguir que no salgamos del laberinto
Segunda prioridad: Estemos el máximo de tiempo posible
*/

long long dfs(int nodoActual, vector<vector<long long>>& dist, vector<vector<pair<int,int>>>& lista, vector<bool>& esSalida) {
    if (esSalida[nodoActual]) return dist[nodoActual][0];

    for (auto vecino: lista[nodoActual]) {
        int nextNodo = vecino.first, w = vecino.second;
        if (dist[nextNodo][0] + w == dist[nodoActual][0]) {
            int okSalida = dfs(nextNodo, dist, lista, esSalida);
            if (okSalida != 1e18) return dist[nodoActual][0];
        }
    }
    return 1e18;
}

int travel_plan(int N, int M, int R[][2], int L[], int K, int P[])
{
  vector<vector<pair<int,int>>> lista(N, vector<pair<int,int>>());
  for (int i = 0; i < M; ++i) {
    lista[R[i][0]].push_back({R[i][1], L[i]});
    lista[R[i][1]].push_back({R[i][0], L[i]});
  }
  vector<bool> esSalida(N);
  for (int i = 0; i < K; ++i) esSalida[P[i]] = true;
  vector<vector<long long>> dist = Dijkstra(K, P, lista);
  long long ans = dfs(0, dist, lista, esSalida);
  if (ans == 1e18) return -1;
  return ans;
}

• Subtask 1: 0 / 46
• Subtask 2: 0 / 43
• Subtask 3: 0 / 11