Submission #1246929

#	Time	Username	Problem	Language	Result	Execution time	Memory
1246929		M_SH_O	Olympic Bus (JOI20_ho_t4)	C++20	11 / 100	829 ms	6212 KiB

ho_t4

/*#pragma GCC optimize("O3")
#pragma GCC optimization("Ofast,unroll-loops")
#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")*/
#include <bits/stdc++.h>
/*#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>*/

#define ll long long
#define ll1 long long
#define ull unsigned long long
#define dou long double
#define str string
#define vll vector<ll>
#define vi vector<int>
#define pll pair<ll, ll>
#define vpll vector<pll>
#define vbool vector<bool>
#define vstr vector<str>
#define vvll vector<vll>
#define pb push_back
#define pf push_front
//#define endl "\n"
#define fr first
#define se second
// #define sortcmp(a) sort(a.begin(), a.end(), cmp)
#define sort(a) sort(a.begin(), a.end())
#define reverse(a) reverse(a.begin(), a.end())
#define speed ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define INF 1000000000000000007
#define ordered_set tree<ll, null_type, less_equal<ll>, rb_tree_tag, tree_order_statistics_node_update>

using namespace std;
//using namespace __gnu_pbds;

mt19937 rng(time(0));
ll randll(ll l, ll r) {
    return uniform_int_distribution<ll>(l, r)(rng);
}

struct ed{
    ll a, b, c, d;  
};

vector<vpll> g, rg;

void dijkstra(ll n, vll& d, vector<vpll>& g1) {
    set<pll> s;
    for (int i = 1; i <= n; i ++) {
        s.insert({d[i], i});
    }

    while (s.size()) {
        pll p = *s.begin();
        s.erase(s.begin());
        for (auto i : g1[p.se]) {
            if (p.fr+i.se < d[i.fr]) {
                s.erase({d[i.fr], i.fr});
                d[i.fr] = p.fr+i.se;
                s.insert({d[i.fr], i.fr});
            }
        }
    }
}

void dijkstra_nm(ll n, vll& d, vector<vpll>& g1) {
    vbool us(n+7, 0);
    while (1) {
        pll p = {INF, INF};
        for(int i = 1; i <= n; i ++){
            if(us[i]) continue;
            p = min(p, (pll){d[i], i});
        }
        
        if(p.fr == INF) return;
        us[p.se] = 1;
        for (auto i : g1[p.se]) {
            if (p.fr+i.se < d[i.fr]) {
                d[i.fr] = p.fr+i.se;
            }
        }
    }
}

set<pll> edge;
vbool us;

void dfs(ll v, vll& d, vector<vpll>& g) {
    us[v] = 1;
    pll p = {-1, -1};
    for (auto i : g[v]) {
        if (d[i.fr]+i.se != d[v]) continue;
        p = {i.fr, v};
        if(!us[i.fr]) dfs(i.fr, d, g);
    }
    edge.insert(p);
}

int main(){
    speed;
    srand(time(0));

    ll n, m;
    cin >> n >> m;
    vector<ed> v(m);
    g.resize(n+7);
    rg.resize(n+7);
    for(int i = 0; i < m; i ++){
        ll a, b, c, d;
        cin >> a >> b >> c >> d;
        v[i] = {a, b, c, d};
        g[a].pb({b, c});
        rg[b].pb({a, c});
    }
    
    vll d_1(n+7, INF), d_n(n+7, INF), rd_1(n+7, INF), rd_n(n+7, INF);
    d_1[1] = d_n[n] = rd_1[1] = rd_n[n] = 0;
    dijkstra(n, d_1, g);
    dijkstra(n, d_n, g);
    dijkstra(n, rd_1, rg);
    dijkstra(n, rd_n, rg);
    
    us.resize(n+7, 0);
    dfs(1, d_n, rg);
    
    ll minl = INF;
    minl = min(minl, d_1[n]+d_n[1]);
    
    for(auto& i : v){
        if(edge.find({i.a, i.b}) == edge.end()){
            ll mn = d_n[1];
            mn = min(mn, d_n[i.b]+rd_1[i.a]+i.c);
            minl = min(minl, mn+d_1[i.b]+rd_n[i.a]+i.d+i.c);
            continue;
        }
        vector<vpll> g1(n+7);
        for(auto& j : v){
            if(j.a == i.a && j.b == i.b && j.c == i.c && j.d == i.d) g1[j.b].pb({j.a, j.c});
            else g1[j.a].pb({j.b, j.c});
        }
        
        vll d(n+7, INF);
        d[n] = 0;
        dijkstra_nm(n, d, g1);
        minl = min(minl, d[1]+d_1[i.b]+rd_n[i.a]+i.d+i.c);
    }
    
    
    us.clear();
    us.resize(n+7, 0);
    edge.clear();
    dfs(n, d_1, rg);
    //cout << d_1[n] << endl;
    
    for(auto& i : v){
        if(edge.find({i.a, i.b}) == edge.end()){
            //cout << i.a << ' ' << i.b << ' ' << rd_1[i.a]+d_n[i.b] << endl;
            ll mn = d_1[n];
            mn = min(mn, d_1[i.a]+rd_n[i.b]+i.c);
            minl = min(minl, mn+rd_1[i.a]+d_n[i.b]+i.d+i.c);
            continue;
        }
        //cout << i.a << ' ' << i.b << endl;
        vector<vpll> g1(n+7);
        for(auto& j : v){
            if(j.a == i.a && j.b == i.b && j.c == i.c && j.d == i.d) g1[j.b].pb({j.a, j.c});
            else g1[j.a].pb({j.b, j.c});
        }
        
        vll d(n+7, INF);
        d[1] = 0;
        dijkstra_nm(n, d, g1);
        minl = min(minl, d[n]+rd_1[i.a]+d_n[i.b]+i.d+i.c);
    }
    
    if(minl == INF) cout << -1 << endl;
    else cout << minl << endl;
}

• Subtask 1: 0 / 5
• Subtask 2: 11 / 11
• Subtask 3: 0 / 21
• Subtask 4: 0 / 63