Submission #1160218

#	Time	Username	Problem	Language	Result	Execution time	Memory
1160218		Zero_OP	Wild Boar (JOI18_wild_boar)	C++20	12 / 100	864 ms	21064 KiB

wild_boar

#include <bits/stdc++.h>

using namespace std;

#define FOR(i, l, r) for(int i = (l); i < (r); ++i)
#define ROF(i, r, l) for(int i = (r) - 1; i >= (l); --i)

#define mp make_pair
#define mt make_tuple
#define ff first
#define ss second

#define all(v) begin(v), end(v)
#define rall(v) rbegin(v), rend(v)
#define sz(v) (int)v.size()
#define compact(v) v.erase(unique(all(v)), end(v))
#define pb push_back
#define eb emplace_back

#define readFile(task) freopen(task, "r", stdin)
#define writeFile(task) freopen(task, "w", stdout)
#define dbg(x) "[" #x " = " << (x) << "]"

template<typename T>
      bool minimize(T& a, const T& b){
            if(a > b) return a = b, true;
            return false;
      }

template<typename T>
      bool maximize(T& a, const T& b){
            if(a < b) return a = b, true;
            return false;
      }

using ll = long long;
using db = double;
using str = string;

using ull = unsigned long long;
using ldb = long double;

using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<db, db>;

using vi = vector<int>;
using vl = vector<ll>;
using vb = vector<bool>;
using vc = vector<char>;
using vs = vector<str>;

using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;

using vvi = vector<vi>;
using vvl = vector<vl>;

void setIO(){
      ios_base::sync_with_stdio(0); cin.tie(0);
#ifdef LOCAL
      readFile("task.inp");
      writeFile("task.out");
#endif // LOCAL
}

template<typename T, typename U>
ostream& operator << (ostream& out, const pair<T, U>& p){
      return out << "(" << p.ff << ", " << p.ss << ")";
}


const int MAX = 2e3 + 5;
const int BOUND = 1e5 + 5;
const ll inf = 1e15;

struct edge{
      int u, v, w;
      edge() : u(), v(), w(){}
      edge(int u, int v, int w) : u(u), v(v), w(w) {}
      int get(int x){ return x ^ u ^ v; }
} e[MAX];

int N, M, L, T, nn, deg[MAX], X[BOUND];
pi inv[MAX * 2];
vi adj[MAX];
int idx[MAX][MAX];
vl F[MAX * 2], G[MAX * 2];

using nd = pair<ll, int>;

vl dijkstra_with_obstacles(int p){
      vl d(nn, inf);
      d[p] = 0;

//      cout << dbg(inv[p]) << '\n';

      priority_queue<nd, vector<nd>, greater<nd>> pq;
      pq.push(mp(0, p));

      while(!pq.empty()){
            ll dist; int pos; tie(dist, pos) = pq.top(); pq.pop();
            if(d[pos] != dist) continue;

            int u, bid; tie(u, bid) = inv[pos];

//            cout << dbg(inv[pos]) << dbg(dist) << '\n';
            for(auto id : adj[u]) if(bid != id){
                  int v = e[id].get(u);
                  int to = idx[v][id];
//                  cout << dbg(v) << dbg(id) << dbg(to) << '\n';
                  if(minimize(d[to], d[pos] + e[id].w)){
                        pq.push(mp(d[to], to));
                  }
            }
      }

//      cout << '\n';
      return d;
}

vl dijkstra_without_obstacles(int s){
      vl d(nn, inf);
      priority_queue<nd, vector<nd>, greater<nd>> pq;
      for(auto id : adj[s]){
            int v = e[id].get(s);
            d[idx[v][id]] = e[id].w;
            pq.push(mp(e[id].w, idx[v][id]));
      }

//      cout << dbg(s) << '\n';

      while(!pq.empty()){
            ll dist; int pos; tie(dist, pos) = pq.top(); pq.pop();
            if(d[pos] != dist) continue;

//            cout << dbg(inv[pos]) << ' ' << dist << '\n';

            int u, bid; tie(u, bid) = inv[pos];
            for(auto id : adj[u]) if(bid != id){
                  int v = e[id].get(u);
                  int to = idx[v][id];
                  if(minimize(d[to], d[pos] + e[id].w)){
                        pq.push(mp(d[to], to));
                  }
            }
      }

//      cout << '\n';

      return d;
}

ll solve(){
      vl dp(nn, inf);
      for(auto id : adj[X[1]]){
            int des = idx[X[1]][id];
            dp[des] = G[X[0]][des];
//            cout << inv[des] << " : " << dp[des] << '\n';
      }

      FOR(i, 1, L-1){
            vl nw(nn, inf);

            for(auto id_des : adj[X[i+1]]){
                  int des = idx[X[i+1]][id_des];
                  for(auto id_st : adj[X[i]]){
                        int st = idx[X[i]][id_st];
                        minimize(nw[des], dp[st] + F[st][des]);
                  }
            }

            swap(dp, nw);
      }

      ll result = *min_element(all(dp));
      if(result == inf) result = -1;
      return result;
}

void testcase(){
      cin >> N >> M >> T >> L;
      memset(idx, -1, sizeof(idx));
      FOR(i, 0, M){
            int u, v, w;
            cin >> u >> v >> w;
            --u, --v;
            e[i] = edge(u, v, w);
            adj[u].eb(i);
            adj[v].eb(i);
            inv[idx[u][i] = nn++] = mp(u, i);
            inv[idx[v][i] = nn++] = mp(v, i);
      }

//      FOR(i, 0, nn) cout << dbg(inv[i]) << '\n'; cout << '\n';
//      FOR(i, 0, N) for(auto j : adj[i]) cout << i << ' ' << j << '\n';

      FOR(i, 0, nn) F[i] = dijkstra_with_obstacles(i);
      FOR(i, 0, N) G[i] = dijkstra_without_obstacles(i);

      FOR(i, 0, L) cin >> X[i], --X[i];

      while(T--){
            int P, Q;
            cin >> P >> Q;
            --P, --Q;
            X[P] = Q;
            cout << solve() << '\n';
      }
}

int main(){
      setIO();

      int T = 1;
//      cin >> T;
      while(T--) testcase();
      return 0;
}

• Subtask 1: 12 / 12
• Subtask 2: 0 / 35
• Subtask 3: 0 / 15
• Subtask 4: 0 / 38