Problem:
鉄道運賃(Train Fare)
JOI 国には $N$ 個の都市があり，それぞれ $1, 2, ..., N$ の番号が付けられている．都市 1 はJOI 国の首都である．
また，JOI 国には鉄道会社がひとつだけあり，この会社は $M$ 個の路線を運行している．これらの路線にはそれぞれ $1, 2, ..., M$ の番号が付けられており，$i$ 番目 $(1 \leq i \leq M)$ の路線は都市 $U_i$ と都市 $V_i$ を双方向に結んでいる．都市と都市の間を鉄道以外で移動することはできない．また，どの都市からどの都市へもいくつかの路線を乗り継いで移動することができるようになっている．
現在，どの路線の運賃も 1 円である．経営不振に陥った鉄道会社は，今後 $Q$ 年間かけていくつかの路線の運賃を値上げする計画を立てた．この計画では，計画開始から $j$ 年目$(1 \leq j \leq Q)$ の年初めに路線 $R_j$ の運賃を 1 円から 2 円に値上げする予定である．値上げされた路線の運賃は，その後ずっと2 円のままであり，再び値上げすることはない．
ところで，この鉄道会社では，毎年，各都市の住民の満足度調査を行っている．計画開始前は，どの都市の住民もこの鉄道会社に満足しているが，値上げによって不満を持つ住民が現れる可能性がある．
それぞれの年の満足度調査は，その年の値上げの実施後に行う．したがって， $j$ 年目$(1 \leq j \leq Q)$ の満足度調査は，路線 $R_1, R_2, ... , R_j$ の運賃の値上げは完了し，それ以外の路線の運賃は値上げされていない状態で行われることになる． $j$ 年目$(1 \leq j \leq Q)$ の満足度調査では，都市 $k$ $(2 \leq k \leq N)$ の住民は，以下の条件が満たされるとき，そしてそのときに限り鉄道会社に不満を抱く．
その時の運賃で都市 $k$ から首都である都市 $1$ へ移動するときの費用の最小値が，計画開始前の運賃で都市 $k$ から都市 $1$ へ移動するときの費用の最小値よりも大きい．
ただし，いくつかの路線を使って移動するときの費用は，それぞれの路線の運賃の合計である．また，都市 $1$ の住民が鉄道会社に対して不満を抱くことはない．値上げ後の運賃で最小の費用を達成する経路は，計画開始前の運賃で最小の費用を達成する経路と異なる可能性があることに注意せよ．
計画の実行に先立って，今後 $Q$ 年間の住民の満足度調査それぞれにおいて，鉄道会社に不満を抱く住民がいる都市の数を計算しておきたい．
課題
JOI 国の鉄道路線の情報と，運賃の値上げ計画が与えられたとき，それぞれの満足度調査において鉄道会社に不満を抱く住民がいる都市の数を求めるプログラムを作成せよ．
入力
標準入力から以下の入力を読み込め．
1 行目には，3 個の整数 $N, M, Q$ が空白を区切りとして書かれている．これらは，JOI 国には $N$ 個の都市と $M$ 個の路線があり，運賃の値上げ計画が $Q$ 年間に渡ることを表している．
続く $M$ 行のうちの $i$ 行目$(1 \leq i \leq M)$ には，2 個の整数 $U_i$, $V_i$ が空白を区切りとして書かれている．これらは，$i$ 番目の路線が都市 $U_i$ と都市 $V_i$ を結んでいることを表している．
続く $Q$ 行のうちの $j$ 行目$(1 \leq j \leq Q)$ には，整数 $R_j$ が書かれている．これは，計画の $j$ 年目に路線 $R_j$ の運賃を値上げすることを表している．
出力
標準出力に $Q$ 行で出力せよ． $j$ 行目$(1 \leq j \leq Q)$ には， $j$ 年目の満足度調査で不満を抱く住民がいる都市の数を出力せよ．
制限
すべての入力データは以下の条件を満たす．
$2 \leq N \leq 100 000$
$1 \leq Q \leq M \leq 200 000$
$1 \leq U_i \leq N$ $(1 \leq i \leq M)$
$1 \leq V_i \leq N$ $(1 \leq i \leq M)$
$U_i \ne V_i$ $(1 \leq i \leq M)$
$1 \leq R_j \leq M$ $(1 \leq j \leq Q)$
$R_j \ne R_k$ $(1 \leq j < k \leq Q)$
どの2 つの都市についても，それらを直接結ぶ路線は 1 個以下である．
どの都市についても，その都市から都市 1 までいくつかの路線を使って移動することができる．
入出力例
入力例1
5 6 5
1 2
1 3
4 2
3 2
2 5
5 3
5
2
4
1
3
出力例1
0
2
2
4
4
この入力例では，計画開始前，及びそれぞれの満足度調査の時点でのそれぞれの都市から都市 $1$ への運賃は，以下の表のようになる．
時点
都市2
都市3
都市4
都市5
計画開始前
1
1
2
2
1 年目
1
1
2
2
2 年目
1
2
2
3
3 年目
1
2
2
3
4 年目
2
2
3
3
5 年目
2
2
4
3
例えば，3 年目の満足度調査では，都市 $3$ と都市 $5$ の住民が不満を抱くので，出力の 3 行目には 2 を出力する．
入力例2
4 6 6
1 2
1 3
1 4
2 3
2 4
3 4
1
4
2
5
3
6
出力例2
1
1
2
2
3
3
入力例3
2 1 1
1 2
1
出力例3
1
第15回 日本情報オリンピック本選 課題   2016 年 2 月 14 日

Submitted solutions:

code_snippet: #include <set>
#include <queue>
#include <vector>
#include <iostream>
#include <algorithm>
#pragma warning(disable : 4996)
using namespace std;
struct edge {
	int to, id;
};
bool operator<(const edge& e1, const edge& e2) {
	if (e1.to != e2.to) return e1.to < e2.to;
	return e1.id < e2.id;
}
int N, M, Q, a[200009], b[200009], dist[100009], r[200009], ans[200009];
vector<int> g[100009]; set<edge> G[100009];
bool ok[200009], vis[200009];
int main() {
	scanf("%d%d%d", &N, &M, &Q);
	for (int i = 0; i < M; i++) {
		scanf("%d%d", &a[i], &b[i]); a[i]--, b[i]--;
		g[a[i]].push_back(b[i]);
		g[b[i]].push_back(a[i]);
	}
	fill(dist + 1, dist + N, 999999999);
	queue<int> que; que.push(0);
	while (!que.empty()) {
		int u = que.front(); que.pop();
		for (int i : g[u]) {
			if (dist[i] == 999999999) {
				dist[i] = dist[u] + 1;
				que.push(i);
			}
		}
	}
	fill(ok, ok + M, true);
	for (int i = 0; i < Q; i++) scanf("%d", &r[i]), ok[--r[i]] = false; r[Q] = M;
	for (int i = 0; i < M; i++) {
		if (dist[a[i]] > dist[b[i]]) swap(a[i], b[i]);
		if (dist[a[i]] != dist[b[i]] && ok[i]) {
			G[a[i]].insert(edge{ b[i], i });
		}
	}
	int sum = 1;
	fill(ok, ok + N, false); ok[0] = true;
	for (int i = Q - 1; i >= 0; i--) {
		if (ok[a[r[i + 1]]]) {
			queue<int> que2; que2.push(a[r[i + 1]]);
			while (!que2.empty()) {
				int u = que2.front(); que2.pop();
				if (!ok[u]) ok[u] = true, sum++;
				vector<int> l;
				for (edge e : G[u]) {
					if (!vis[e.id]) {
						vis[e.id] = true; l.push_back(e.id);
						que2.push(e.to);
					}
				}
				for (int i : l) {
					G[u].erase(edge{ b[i], i });
				}
			}
		}
		ans[i] = sum;
		if (dist[a[r[i]]] != dist[b[r[i]]]) {
			G[a[r[i]]].insert(edge{ b[r[i]], r[i] });
		}
	}
	for (int i = 0; i < Q; i++) printf("%d\n", N - ans[i]);
	return 0;
}
accuracy: 1
time_ms: 80
memory_kb: 26384
final_rank: 16

code_snippet: #include<bits/stdc++.h>
using namespace std;
using ll =long long;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int N,M,Q;
    cin>>N>>M>>Q;
    
    vector<vector<array<ll,2>>> G(N);
    for(int i=0;i<M;i++){
        int U,V;
        cin>>U>>V;
        U--;V--;
        G[U].push_back({V,i});
        G[V].push_back({U,i});
    }
    vector<int> R(M,int(1e9));
    for(int i=0;i<Q;i++){
        int r;
        cin>>r;
        R[r-1]=i;
    }
    priority_queue<array<ll,3>,vector<array<ll,3>>,greater<array<ll,3>>> query;
    query.push({0,-Q,0});
    vector<array<ll,2>> D(N,{ll(1e18),-1});
    D[0]={0,Q};
    while(!query.empty()){
        auto [c,d,n]=query.top();

        query.pop();
        array<ll,2> p={c,-d};
        if(D[n]!=p)continue;
        for(auto [v,id]:G[n]){
            ll w=R[id];
            if(D[v][0]<D[n][0]+1)continue;
            if(D[v][0]>D[n][0]+1){
                D[v][0]=D[n][0]+1;
                D[v][1]=-1;
            }
            ll nw=min(D[n][1],w);
            if(D[v][1]<nw){
                D[v][1]=nw;
                query.push({D[v][0],-D[v][1],v});
            }
        }
    }
    vector<ll> AN(Q+1,0);
    for(int i=0;i<N;i++){
        AN[D[i][1]]++;
    }
    for(int q=0;q<Q;q++){
        cout<<AN[q]<<"\n";
        AN[q+1]+=AN[q];
    }
}
accuracy: 1
time_ms: 60
memory_kb: 21124
final_rank: 13

code_snippet: #include <bits/stdc++.h>




namespace zawa {

using i16 = std::int16_t;
using i32 = std::int32_t;
using i64 = std::int64_t;
using i128 = __int128_t;

using u8 = std::uint8_t;
using u16 = std::uint16_t;
using u32 = std::uint32_t;
using u64 = std::uint64_t;

using usize = std::size_t;

} // namespace zawa


namespace zawa {

void SetFastIO() {
    std::cin.tie(nullptr)->sync_with_stdio(false);
}

void SetPrecision(u32 dig) {
    std::cout << std::fixed << std::setprecision(dig);
}

} // namespace zawa
using namespace zawa;

int main() {
    SetFastIO();

    int N, M, Q;
    std::cin >> N >> M >> Q;
    std::vector<int> U(M), V(M);
    std::vector<std::vector<int>> g(N);
    for (int i{} ; i < M ; i++) {
        std::cin >> U[i] >> V[i];
        U[i]--; V[i]--;
        g[U[i]].push_back(V[i]);
        g[V[i]].push_back(U[i]);
    }
    std::vector<int> dist(N, (int)1e9);
    dist[0] = 0;
    std::queue<int> que;
    que.push(0);
    while (que.size()) {
        int v{que.front()};
        que.pop();
        for (auto x : g[v]) if (dist[x] > dist[v] + 1) {
            dist[x] = dist[v] + 1;
            que.push(x);
        }
    }
    std::vector<bool> use(M); 
    for (int i{} ; i < M ; i++) {
        if (dist[U[i]] > dist[V[i]]) std::swap(U[i], V[i]);
        if (dist[U[i]] + 1 == dist[V[i]]) use[i] = true;
    }
    std::vector<int> R(Q);
    std::vector<bool> app(M);
    for (auto& r : R) {
        std::cin >> r;
        r--;
        app[r] = true;
    }
    std::vector<std::vector<int>> g2(N);
    for (int i{} ; i < M ; i++) if (!app[i] and use[i]) {
        g2[U[i]].push_back(V[i]);
    }
    std::vector<bool> vis(N);
    int val{N};
    auto dfs{[&](auto dfs, int v) -> void {
        val--;
        vis[v] = true;
        for (auto x : g2[v]) if (!vis[x]) {
            dfs(dfs, x);
        }
    }};
    dfs(dfs, 0);
    std::vector<int> ans(Q);
    for (int i{Q} ; i-- ; ) {
        ans[i] = val;
        if (!use[R[i]]) continue;
        g2[U[R[i]]].push_back(V[R[i]]);
        if (vis[U[R[i]]] and !vis[V[R[i]]]) dfs(dfs, V[R[i]]);
    }
    for (auto a : ans) std::cout << a << '\n';
}
accuracy: 1
time_ms: 60
memory_kb: 23784
final_rank: 15

code_snippet: #include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;

#define MAX 100005

struct T {
    int lst, id, v;
};

T tbl[4 * MAX];
int head[MAX], cnt = 1;
int ans[2 * MAX], dis[MAX], ed[MAX];
int que[MAX], top, queue_end;
int N, M, Q;

inline int Min(int a, int b) {
    return a <= b ? a : b;
}

inline void chmax(int &a, int b) {
    if (a < b) a = b;
}

void add(int u, int v) {
    tbl[++cnt] = {head[u], Q + 1, v};
    head[u] = cnt;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);

    cin >> N >> M >> Q;
    for (int i = 0; i < M; ++i) {
        int u, v;
        cin >> u >> v;
        add(u, v);
        add(v, u);
    }

    for (int i = 1; i <= Q; ++i) {
        int x;
        cin >> x;
        x <<= 1;
        tbl[x].id = tbl[x + 1].id = i;
    }

    dis[1] = 1;
    ed[1] = Q + 1;
    que[queue_end++] = 1;

    while (top != queue_end) {
        int u = que[top++];
        ++ans[ed[u]];

        for (int i = head[u]; i; i = tbl[i].lst) {
            int v = tbl[i].v;
            if (!dis[v]) {
                dis[v] = dis[u] + 1;
                que[queue_end++] = v;
            }
            if (dis[v] == dis[u] + 1) {
                chmax(ed[v], Min(ed[u], tbl[i].id));
            }
        }
    }

    for (int i = 1; i <= Q; ++i) {
        ans[i] += ans[i - 1];
        cout << ans[i] << '\n';
    }

    return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 10500
final_rank: 1

code_snippet: #include<bits/stdc++.h>
using namespace std;
typedef pair<int, int> pi;
int n, m, q, u, v, r, node[100010], cnt[100010], age[200010], ans[200010];
vector<pi> edge[100010];
queue<int> que;
int main(){
    cin.tie(0);
    ios::sync_with_stdio(0);
    cin >> n >> m >> q;
    for(int i=1;i<=m;i++){
        cin >> u >> v;
        edge[u].push_back(pi(v, i));
        edge[v].push_back(pi(u, i));
        age[i] = q+1;
    }
    for(int i=1;i<=q;i++){
        cin >> r;
        age[r] = i;
    }
    memset(node, -1, sizeof(node));
    node[1] = 0;
    memset(cnt, -1, sizeof(cnt));
    cnt[1] = q+5;
    que.push(1);
    while(!que.empty()){
        int now = que.front();
        que.pop();
        for(int i=0;i<edge[now].size();i++){
            int to = edge[now][i].first;
            if(node[to]<0){
                node[to] = node[now]+1;
                que.push(to);
            }
            if(node[to]==node[now]+1) cnt[to] = max(cnt[to], min(cnt[now], age[edge[now][i].second]));
        }
    }
    for(int i=1;i<=n;i++) ans[cnt[i]]++;
    int sum=0;
    for(int i=1;i<=q;i++){
        sum += ans[i];
        cout << sum << endl;
    }
    return(0);
}
accuracy: 1
time_ms: 180
memory_kb: 14448
final_rank: 8

code_snippet: #include<bits/stdc++.h>
using namespace std;
typedef pair<int, int> pi;
int n, m, q, u, v, r;
int node[100010]={};
int cnt[100010]={};
int age[200010];
int ans[200010];
vector<pi> edge[100010];

int main(){
        
    cin.tie(0);
    ios::sync_with_stdio(0);

    cin >> n >> m >> q;
    for(int i=1;i<=m;i++){
        cin >> u >> v;
        edge[u].push_back(pi(v, i));
        edge[v].push_back(pi(u, i));
        age[i] = q+1;
    }
    
    for(int i=1;i<=q;i++){
        cin >> r;
        age[r] = i;
    }
    
    memset(node, -1, sizeof(node));
    node[1] = 0;
    memset(cnt, -1, sizeof(cnt));
    cnt[1] = q+1;
    
    queue<int> que;
    que.push(1);
    while(!que.empty()){
        int now = que.front();
        que.pop();
        for(int i=0;i<edge[now].size();i++){
            int to = edge[now][i].first;
            if(node[to]<0){
                node[to] = node[now]+1;
                que.push(to);
            }
            if(node[to]==node[now]+1){
                int e = edge[now][i].second;
                cnt[to] = max(cnt[to], min(cnt[now], age[e]));
            }
        }
    }
    for(int i=1;i<=n;i++) ans[cnt[i]]++;
    for(int i=1;i<q;i++) ans[i+1] += ans[i];
    for(int i=1;i<=q;i++) cout << ans[i] << endl;
    return(0);
}
accuracy: 1
time_ms: 180
memory_kb: 14448
final_rank: 8

code_snippet: #include<bits/stdc++.h>
using namespace std;
typedef pair<int, int> pi;
int n, m, q, u, v, r[200010];
bool qb[200010]={};
vector<int> aru[100010];
vector<pi> edge[100010];
pi medge[200010];
void bfs(){
    int node[100010];
    memset(node, -1, sizeof(node));
    node[1] = 0;
    queue<pi> que;
    que.push(pi(1, 0));
    while(!que.empty()){
        pi now = que.front();
        que.pop();
        for(int i=0;i<edge[now.first].size();i++){
            pi to = edge[now.first][i];
            int cst = node[now.first];
            if(node[to.first]<0){
                node[to.first] = cst+1;
                medge[to.second] = pi(now.first, to.first);
                que.push(to);
            } else if(node[to.first]==cst+1){
                medge[to.second] = pi(now.first, to.first);
            }
        }
    }
}

int sum;
bool one[100010]={};
void unite(int now){
    for(int i=0;i<aru[now].size();i++){
        int to = aru[now][i];
        if(!one[to]){
            sum--;
            one[to] = true;
            unite(to);
        }
    }
}

int main(){
        
    cin.tie(0);
    ios::sync_with_stdio(0);

    cin >> n >> m >> q;
    for(int i=1;i<=m;i++){
        cin >> u >> v;
        edge[u].push_back(pi(v, i));
        edge[v].push_back(pi(u, i));
        medge[i] = pi(0, 0);
    }
    for(int i=1;i<=q;i++){
        cin >> r[i];
        qb[ r[i] ] = true;
    }
    
    bfs();
    
    stack<int> st;
    one[1] = true;
    sum = n-1;
    for(int i=1;i<=m;i++){
        if(!qb[i]){
            if(medge[i].first!=0){
                aru[medge[i].first].push_back(medge[i].second);
                if(one[ medge[i].first ] && !one[ medge[i].second ]){
                    sum--;
                    one[ medge[i].second ] = true;
                    unite(medge[i].second);
                }
            }
        }
    }
    st.push(sum);
    
    for(int i=q;i>1;i--){
        if(medge[r[i]].first!=0){
            aru[ medge[r[i]].first ].push_back(medge[r[i]].second);
            if(one[ medge[r[i]].first ] && !one[ medge[r[i]].second ]){
                sum--;
                one[ medge[r[i]].second ] = true;
                unite(medge[r[i]].second);
            }
        }
        st.push(sum);
    }
    while(!st.empty()){
        cout << st.top() << endl;
        st.pop();
    }
    
    return(0);
}
accuracy: 1
time_ms: 250
memory_kb: 20708
final_rank: 14

code_snippet: #include<bits/stdc++.h>
using namespace std;
typedef pair<int, int> pi;
int n, m, q, u[200010], v[200010], r[200010];
bool qb[100010]={};
vector<int> edge[100010], aru[100010];
set<pi> se;
void bfs(){
    int node[100010];
    memset(node, -1, sizeof(node));
    node[1] = 0;
    queue<int> que;
    que.push(1);
    while(!que.empty()){
        int now = que.front();
        que.pop();
        for(int i=0;i<edge[now].size();i++){
            int to = edge[now][i];
            int cst = node[now];
            if(node[to]<0){
                node[to] = cst+1;
                se.insert(pi(now, to));
                que.push(to);
            } else if(node[to]==cst+1){
                se.insert(pi(now, to));
            }
        }
    }
}

int sum;
bool one[100010]={};
void unite(int now){
    if(!one[now]) return;
    for(int i=0;i<aru[now].size();i++){
        int to = aru[now][i];
        if(!one[to]){
            sum--;
            one[to] = true;
            unite(to);
        }
    }
}

int main(){
    
    cin >> n >> m >> q;
    for(int i=1;i<=m;i++){
        cin >> u[i] >> v[i];
        edge[u[i]].push_back(v[i]);
        edge[v[i]].push_back(u[i]);
    }
    for(int i=1;i<=q;i++){
        cin >> r[i];
        qb[ r[i] ] = true;
    }
    
    bfs();
    
    stack<int> st;
    one[1] = true;
    sum = n-1;
    for(int i=1;i<=m;i++){
        if(!qb[i]){
            if(se.find(pi(u[i], v[i]))!=se.end()){
                aru[u[i]].push_back(v[i]);
                unite(u[i]);
            } else if(se.find(pi(v[i], u[i]))!=se.end()){
                aru[v[i]].push_back(u[i]);
                unite(v[i]);
            }
        }
    }
    st.push(sum);
    
    for(int i=q;i>1;i--){
        if(se.find(pi(u[r[i]], v[r[i]]))!=se.end()){
            aru[ u[r[i]] ].push_back(v[r[i]]);
            unite(u[r[i]]);
        } else if(se.find(pi(v[r[i]], u[r[i]]))!=se.end()){
            aru[ v[r[i]] ].push_back(u[r[i]]);
            unite(v[r[i]]);
        }
        st.push(sum);
    }
    while(!st.empty()){
        cout << st.top() << endl;
        st.pop();
    }
    
    return(0);
}
accuracy: 0.14814814814814814
time_ms: 220
memory_kb: 22652
final_rank: 20

code_snippet: #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) { return (ull)rng() % B; }

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m, q;
    cin >> n >> m >> q;
    vector<int> x(m), y(m);
    vector<vector<int>> g(n);
    for (int i = 0; i < m; ++i) {
        cin >> x[i] >> y[i];
        x[i] -= 1, y[i] -= 1;
        g[x[i]].push_back(y[i]);
        g[y[i]].push_back(x[i]);
    }
    vector<int> d(n, -1);
    d[0] = 0;
    queue<int> que;
    que.push(0);
    while (que.size()) {
        auto s = que.front();
        que.pop();
        for (int t : g[s]) {
            if (d[t] == -1) {
                d[t] = d[s] + 1;
                que.push(t);
            }
        }
    }
    vector<int> query(m);
    vector<int> rq(q + 1);
    for (int i = 0; i < q; ++i) {
        int z;
        cin >> z;
        query[z - 1] = q - i;
        rq[q - i] = z - 1;
    }
    int res = 0;
    vector<int> dp(n, -1);
    dp[0] = 0;
    for (int i = 0; i < n; ++i) {
        g[i].clear();
    }
    vector<int> ans(q);
    for (int i = 0; i <= q; ++i) {
        if (!i) {
            for (int j = 0; j < m; ++j) {
                if (!query[j]) {
                    g[x[j]].push_back(y[j]);
                    g[y[j]].push_back(x[j]);
                }
            }
            que.push(0);
            while (que.size()) {
                int s = que.front();
                que.pop();
                for (int t : g[s]) {
                    if (d[t] == d[s] + 1 and dp[t] == -1) {
                        dp[t] = dp[s] + 1;
                        que.push(t);
                    }
                }
            }
            for (int j = 0; j < n; ++j) {
                res += (dp[j] == d[j]);
            }
        } else {
            ans[q - i] = n - res;
            int j = rq[i];
            g[x[j]].push_back(y[j]);
            g[y[j]].push_back(x[j]);
            if (dp[x[j]] == -1 and dp[y[j]] == d[y[j]] and d[x[j]] == d[y[j]] + 1) {
                res += 1;
                dp[x[j]] = dp[y[j]] + 1;
                que.push(x[j]);
            }
            swap(x[j], y[j]);
            if (dp[x[j]] == -1 and dp[y[j]] == d[y[j]] and d[x[j]] == d[y[j]] + 1) {
                res += 1;
                dp[x[j]] = dp[y[j]] + 1;
                que.push(x[j]);
            }
            while (que.size()) {
                int s = que.front();
                que.pop();
                for (int t : g[s]) {
                    if (dp[t] == -1 and d[t] == d[s] + 1) {
                        dp[t] = dp[s] + 1;
                        que.push(t);
                        res += 1;
                    }
                }
            }
        }
    }
    for (int i = 0; i < q; ++i) {
        cout << ans[i] << "\n";
    }
}
accuracy: 1
time_ms: 60
memory_kb: 14328
final_rank: 5

code_snippet: #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) { return (ull)rng() % B; }

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m, q;
    cin >> n >> m >> q;
    vector<int> x(m), y(m);
    vector<vector<int>> g(n);
    for (int i = 0; i < m; ++i) {
        cin >> x[i] >> y[i];
        x[i] -= 1, y[i] -= 1;
        g[x[i]].push_back(y[i]);
        g[y[i]].push_back(x[i]);
    }
    vector<int> d(n, -1);
    d[0] = 0;
    queue<int> que;
    que.push(0);
    while (que.size()) {
        auto s = que.front();
        que.pop();
        for (int t : g[s]) {
            if (d[t] == -1) {
                d[t] = d[s] + 1;
                que.push(t);
            }
        }
    }
    vector<int> query(m);
    vector<int> rq(q + 1);
    for (int i = 0; i < q; ++i) {
        int z;
        cin >> z;
        query[z - 1] = q - i;
        rq[q - i] = z - 1;
    }
    int res = 0;
    vector<int> dp(n, -1);
    dp[0] = 0;
    for (int i = 0; i < n; ++i) {
        g[i].clear();
    }
    vector<int> ans(q);
    for (int i = 0; i <= q; ++i) {
        if (!i) {
            for (int j = 0; j < m; ++j) {
                if (!query[j]) {
                    g[x[j]].push_back(y[j]);
                    g[y[j]].push_back(x[j]);
                }
            }
            que.push(0);
            while (que.size()) {
                int s = que.front();
                que.pop();
                for (int t : g[s]) {
                    if (d[t] == d[s] + 1 and dp[t] == -1) {
                        dp[t] = dp[s] + 1;
                        que.push(t);
                    }
                }
            }
            for (int j = 0; j < n; ++j) {
                res += (dp[j] == d[j]);
            }
        } else {
            ans[q - i] = n - res;
            int j = rq[i];
            g[x[j]].push_back(y[j]);
            g[y[j]].push_back(x[j]);
            if (dp[x[j]] == d[x[j]]) que.push(x[j]);
            if (dp[y[j]] == d[y[j]]) que.push(y[j]);
            while (que.size()) {
                int s = que.front();
                que.pop();
                for (int t : g[s]) {
                    if (dp[t] == -1 and d[t] == d[s] + 1) {
                        dp[t] = dp[s] + 1;
                        que.push(t);
                        res += 1;
                    }
                }
            }
        }
    }
    for (int i = 0; i < q; ++i) {
        cout << ans[i] << "\n";
    }
}
accuracy: 1
time_ms: 2760
memory_kb: 14328
final_rank: 18

code_snippet: #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;

void reader(int *x) {
  int k = getchar_unlocked();
  *x = k - '0';
  while (1) {
    k = getchar_unlocked();
    if (k < '0' || k > '9')
      break;
    *x = ((*x) << 1) + ((*x) << 3) + k - '0';
  }
}

vector<int> E[100000];
int u[200000], v[200000], r[200000], ans[200000], d[100000], cnt = 1;
bool b[200000], ok[100000], diff[200000];
queue<int> que;

void bfs(int u, int t) {
  que.push(u);
  while (!que.empty()) {
    int p = que.front();
    que.pop();
    for (int v : E[p]) {
      if (t) {
        if (d[v] > d[p] && !ok[v]) {
          ok[v] = 1;
          cnt++;
          que.push(v);
        }
      } else if (!~d[v]) {
        d[v] = d[p] + 1;
        que.push(v);
      }
    }
  }
}

int main() {
  int n, m, q;
  reader(&n);
  reader(&m);
  reader(&q);

  rep(i, m) {
    reader(&u[i]);
    reader(&v[i]);
    u[i]--;
    v[i]--;
    E[u[i]].push_back(v[i]);
    E[v[i]].push_back(u[i]);
  }

  memset(d, -1, sizeof(d));
  d[0] = 0;
  bfs(0, 0);

  rep(i, m) {
    if (d[u[i]] > d[v[i]]) swap(u[i], v[i]);
    diff[i] = (d[v[i]] - d[u[i]] == 1); // Store the result of the computation
  }

  rep(i, n) E[i].clear();

  rep(i, q) {
    reader(&r[i]);
    r[i]--;
    b[r[i]] = true;
  }

  ok[0] = true;

  rep(i, m) {
    if (!b[i] && diff[i]) {
      E[u[i]].emplace_back(v[i]);
    }
  }

  bfs(0, 1);

  for (int i = q - 1; i >= 0; i--) {
    ans[i] = n - cnt;
    if (diff[r[i]] && !ok[v[r[i]]]) {
      E[u[r[i]]].emplace_back(v[r[i]]);
      if (ok[u[r[i]]]) {
        cnt++;
        ok[v[r[i]]] = true;
        bfs(v[r[i]], 1);
      }
    }
  }

  rep(i, q) printf("%d\n", ans[i]);
  return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 14160
final_rank: 4

code_snippet: #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;

void reader(int *x) {
  int k = getchar_unlocked();
  *x = k - '0';
  while (1) {
    k = getchar_unlocked();
    if (k < '0' || k > '9')
      break;
    *x = ((*x) << 1) + ((*x) << 3) + k - '0';
  }
}

vector<int> E[100000];
int u[200000], v[200000], r[200000], ans[200000], d[100000], cnt = 1;
bool b[200000], ok[100000];
queue<int> que;

void bfs(int u, int t) {
  que.push(u);
  while (!que.empty()) {
    int p = que.front();
    que.pop();
    for (int v : E[p]) {
      if (t) {
        if (d[v] > d[p] && !ok[v]) {
          ok[v] = 1;
          cnt++;
          que.push(v);
        }
      } else if (!~d[v]) {
        d[v] = d[p] + 1;
        que.push(v);
      }
    }
  }
}

int main() {
  int n, m, q;
  reader(&n);
  reader(&m);
  reader(&q);
  rep(i, m) {
    reader(&u[i]);
    reader(&v[i]);
    u[i]--;
    v[i]--;
    E[u[i]].push_back(v[i]);
    E[v[i]].push_back(u[i]);
  }
  queue<int> que;
  memset(d, -1, sizeof(d));
  d[0] = 0;
  bfs(0, 0);
  rep(i, m) {
    if (d[u[i]] > d[v[i]])
      swap(u[i], v[i]);
  }
  rep(i, n) E[i].clear();
  rep(i, q) {
    reader(&r[i]);
    r[i]--;
    b[r[i]] = true;
  }
  ok[0] = true;
  rep(i, m) {
    if (!b[i]) {
      if (d[v[i]] - d[u[i]] == 1) {
        E[u[i]].emplace_back(v[i]);
      }
    }
  }
  bfs(0, 1);
  for (int i = q - 1; i >= 0; i--) {
    ans[i] = n - cnt;
    bool shouldRemoveEdge = d[v[r[i]]] - d[u[r[i]]] == 1; // store the result to avoid redundant computation
    if (shouldRemoveEdge && !ok[v[r[i]]]) {
      E[u[r[i]]].emplace_back(v[r[i]]);
      if (ok[u[r[i]]]) {
        cnt++;
        ok[v[r[i]]] = true;
        bfs(v[r[i]], 1);
      }
    }
  }
  rep(i, q) printf("%d\n", ans[i]);
}
accuracy: 1
time_ms: 30
memory_kb: 13956
final_rank: 3

code_snippet: #include <iostream>
#include <vector>
#include <queue>
#include <cstring>

using namespace std;

void reader(int &x) {
    cin >> x;
}

void bfs(int u, int t, vector<vector<int>> &E, queue<int> &que, vector<int> &d, vector<int> &ok, int &cnt) {
    que.push(u);
    while (!que.empty()) {
        int p = que.front();
        que.pop();
        for (int v : E[p]) {
            if (t) {
                if (d[v] > d[p] && !ok[v]) {
                    ok[v] = 1;
                    cnt++;
                    que.push(v);
                }
            } else if (d[v] == -1) {
                d[v] = d[p] + 1;
                que.push(v);
            }
        }
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int n, m, q;
    reader(n);
    reader(m);
    reader(q);
    vector<int> u(m), v(m), r(q), ans(q), d(n), ok(n);
    vector<vector<int>> E(n);
    queue<int> que;
    int cnt = 1;
    for (int i = 0; i < m; i++) {
        reader(u[i]);
        reader(v[i]);
        u[i]--;
        v[i]--;
        E[u[i]].push_back(v[i]);
        E[v[i]].push_back(u[i]);
    }
    memset(&d[0], -1, sizeof(int) * n);
    d[0] = 0;
    bfs(0, 0, E, que, d, ok, cnt);
    for (int i = 0; i < m; i++) {
        if (d[u[i]] > d[v[i]])
            swap(u[i], v[i]);
    }
    for (int i = 0; i < n; i++) E[i].clear();
    vector<int> b(m);
    ok[0] = true;
    for (int i = 0; i < q; i++) {
        reader(r[i]);
        r[i]--;
        b[r[i]] = true;
    }
    for (int i = 0; i < m; i++) {
        if (!b[i]) {
            if (d[v[i]] - d[u[i]] == 1) {
                E[u[i]].emplace_back(v[i]);
            }
        }
    }
    bfs(0, 1, E, que, d, ok, cnt);
    for (int i = q - 1; i >= 0; i--) {
        ans[i] = n - cnt;
        if (d[v[r[i]]] - d[u[r[i]]] == 1 && !ok[v[r[i]]]) {
            E[u[r[i]]].emplace_back(v[r[i]]);
            if (ok[u[r[i]]]) {
                cnt++;
                ok[v[r[i]]] = true;
                bfs(v[r[i]], 1, E, que, d, ok, cnt);
            }
        }
    }
    for (int i = 0; i < q; i++) cout << ans[i] << '\n';
    return 0;
}
accuracy: 1
time_ms: 60
memory_kb: 14428
final_rank: 6

code_snippet: #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
void reader(int *x) {
  int k = getchar_unlocked();
  *x = k - '0';
  while (1) {
    k = getchar_unlocked();
    if (k < '0' || k > '9')
      break;
    *x = ((*x) << 1) + ((*x) << 3) + k - '0';
  }
}
vector<int> E[100000];
int u[200000], v[200000], r[200000], ans[200000], d[100000], cnt = 1;
bool b[200000], ok[100000], visited[100000];
queue<int> que;
void bfs(int u, int t) {
  memset(visited, 0, sizeof(visited)); // Initialize visited array
  visited[u] = true; // Mark the starting node as visited
  que.push(u);
  while (!que.empty()) {
    int p = que.front();
    que.pop();
    for (int v : E[p]) {
      if (!visited[v]) { // Check if the node has been visited
        if (t) {
          if (d[v] > d[p] && !ok[v]) {
            ok[v] = 1;
            cnt++;
            visited[v] = true; // Mark the node as visited
            que.push(v);
          }
        } else if (!~d[v]) {
          d[v] = d[p] + 1;
          visited[v] = true; // Mark the node as visited
          que.push(v);
        }
      }
    }
  }
}
int main() {
  int n, m, q;
  reader(&n);
  reader(&m);
  reader(&q);
  rep(i, m) {
    reader(&u[i]);
    reader(&v[i]);
    u[i]--;
    v[i]--;
    E[u[i]].push_back(v[i]);
    E[v[i]].push_back(u[i]);
  }
  memset(d, -1, sizeof(d));
  d[0] = 0;
  bfs(0, 0);
  rep(i, m) {
    if (d[u[i]] > d[v[i]])
      swap(u[i], v[i]);
  }
  rep(i, n) E[i].clear();
  rep(i, q) {
    reader(&r[i]);
    r[i]--;
    b[r[i]] = true;
  }
  ok[0] = true;
  rep(i, m) {
    if (!b[i]) {
      if (d[v[i]] - d[u[i]] == 1) {
        E[u[i]].emplace_back(v[i]);
      }
    }
  }
  bfs(0, 1);
  for (int i = q - 1; i >= 0; i--) {
    ans[i] = n - cnt;
    if (d[v[r[i]]] - d[u[r[i]]] == 1 && !ok[v[r[i]]]) {
      E[u[r[i]]].emplace_back(v[r[i]]);
      if (ok[u[r[i]]]) {
        cnt++;
        ok[v[r[i]]] = true;
        bfs(v[r[i]], 1);
      }
    }
  }
  rep(i, q) printf("%d\n", ans[i]);
}
accuracy: 1
time_ms: 160
memory_kb: 14040
final_rank: 7

code_snippet: #include <bits/stdc++.h>
using namespace std;

int main() {
  int n, m, q, a[210000], b[210000], c, dist[110000], T[110000], cnt, U[110000];
  vector<pair<int, int>> x[110000], y[110000];
  bool used[210000];

  scanf("%d%d%d", &n, &m, &q);
  for (int i = 0; i < m; i++) {
    scanf("%d%d", &a[i], &b[i]);
    x[a[i]].push_back(make_pair(b[i], i));
    x[b[i]].push_back(make_pair(a[i], i));
  }
  fill(dist, dist + n + 1, 999999);
  dist[1] = 0;
  queue<int> Q;
  Q.push(1);
  while (!Q.empty()) {
    int a1 = Q.front();
    Q.pop();
    for (pair<int, int> i : x[a1]) {
      if (dist[i.first] > dist[a1] + 1) {
        dist[i.first] = dist[a1] + 1;
        Q.push(i.first);
      }
    }
  }
  for (int i = 1; i <= n; i++) {
    for (pair<int, int> j : x[i]) {
      if (dist[i] < dist[j.first]) {
        y[i].push_back(j);
        T[j.first]++;
      }
    }
  }
  for (int i = 0; i < q; i++) {
    scanf("%d", &c);
    c--;
    queue<pair<int, int>> Q1;
    int ss = -1;
    if (dist[a[c]] < dist[b[c]])
      ss = b[c];
    if (dist[a[c]] > dist[b[c]])
      ss = a[c];
    if (ss >= 1 && U[ss] == 0 && used[c] == false) {
      Q1.push(make_pair(ss, c));
      while (!Q1.empty()) {
        int a1 = Q1.front().first, a2 = Q1.front().second;
        Q1.pop();
        if (U[a1] == 1 || used[a2] == true)
          continue;
        T[a1]--;
        used[a2] = true;
        if (T[a1] != 0)
          continue;
        cnt++;
        U[a1] = 1;
        for (pair<int, int> j : y[a1]) {
          if (U[j.first] == 0)
            Q1.push(j);
        }
      }
    }
    printf("%d\n", cnt);
  }
  return 0;
}
accuracy: 1
time_ms: 80
memory_kb: 20456
final_rank: 11

code_snippet: #include <bits/stdc++.h>
using namespace std;
int n, m, q, a[210000], b[210000], c, dist[110000], T[110000], cnt, U[110000];
list<pair<int, int>> x[110000], y[110000];
unordered_set<int> used;
int main() {
  ios_base::sync_with_stdio(false);
  scanf("%d%d%d", &n, &m, &q);
  for (int i = 0; i < m; i++) {
    scanf("%d%d", &a[i], &b[i]);
    x[a[i]].push_back(make_pair(b[i], i));
    x[b[i]].push_back(make_pair(a[i], i));
  }
  fill(dist, dist + n + 1, 999999);
  dist[1] = 0;
  queue<int> Q;
  Q.push(1);
  while (!Q.empty()) {
    int a1 = Q.front();
    Q.pop();
    for (pair<int, int>& i : x[a1]) {
      if (dist[i.first] > dist[a1] + 1) {
        dist[i.first] = dist[a1] + 1;
        Q.push(i.first);
      }
    }
  }
  for (int i = 1; i <= n; i++) {
    for (pair<int, int>& j : x[i]) {
      if (dist[i] < dist[j.first]) {
        y[i].push_back(j);
        T[j.first]++;
      }
    }
  }
  for (int i = 0; i < q; i++) {
    scanf("%d", &c);
    c--;
    queue<pair<int, int>> Q1;
    int ss = -1;
    if (dist[a[c]] < dist[b[c]])
      ss = b[c];
    if (dist[a[c]] > dist[b[c]])
      ss = a[c];
    if (ss >= 1 && U[ss] == 0 && used.find(c) == used.end()) {
      Q1.push(make_pair(ss, c));
      while (!Q1.empty()) {
        int a1 = Q1.front().first, a2 = Q1.front().second;
        Q1.pop();
        if (U[a1] == 1 || used.find(a2) != used.end())
          continue;
        T[a1]--;
        used.insert(a2);
        if (T[a1] != 0)
          continue;
        cnt++;
        U[a1] = 1;
        for (pair<int, int>& j : y[a1]) {
          if (U[j.first] == 0)
            Q1.push(j);
        }
      }
    }
    printf("%d\n", cnt);
  }
  return 0;
}
accuracy: 1
time_ms: 120
memory_kb: 36080
final_rank: 17

code_snippet: #include <bits/stdc++.h>
using namespace std;
int n, m, q, a[210000], b[210000], c, dist[110000], T[110000], cnt, U[110000];
vector<pair<int, int>> x[110000], y[110000];
bool used[210000];
int main() {
  scanf("%d%d%d", &n, &m, &q);
  for (int i = 0; i < m; i++) {
    scanf("%d%d", &a[i], &b[i]);
    x[a[i]].push_back(make_pair(b[i], i));
    x[b[i]].push_back(make_pair(a[i], i));
  }
  fill(dist, dist + n + 1, 999999);
  dist[1] = 0;
  deque<int> Q;  // Use deque instead of queue
  Q.push_back(1);  // Use push_back instead of push
  while (!Q.empty()) {
    int a1 = Q.front();
    Q.pop_front();  // Use pop_front instead of pop
    for (auto& i : x[a1]) {  // Use range-based for loop
      if (dist[i.first] > dist[a1] + 1) {
        dist[i.first] = dist[a1] + 1;
        Q.push_back(i.first);
      }
    }
  }
  for (int i = 1; i <= n; i++) {
    for (auto& j : x[i]) {  // Use range-based for loop
      if (dist[i] < dist[j.first]) {
        y[i].push_back(j);
        T[j.first]++;
      }
    }
  }
  for (int i = 0; i < q; i++) {
    scanf("%d", &c);
    c--;
    deque<pair<int, int>> Q1;  // Use deque instead of queue
    int ss = -1;
    if (dist[a[c]] < dist[b[c]])
      ss = b[c];
    if (dist[a[c]] > dist[b[c]])
      ss = a[c];
    if (ss >= 1 && U[ss] == 0 && used[c] == false) {
      Q1.push_back(make_pair(ss, c));  // Use push_back instead of push
      while (!Q1.empty()) {
        int a1 = Q1.front().first, a2 = Q1.front().second;
        Q1.pop_front();  // Use pop_front instead of pop
        if (U[a1] == 1 || used[a2] == true)
          continue;
        T[a1]--;
        used[a2] = true;
        if (T[a1] != 0)
          continue;
        cnt++;
        U[a1] = 1;
        for (auto& j : y[a1]) {  // Use range-based for loop
          if (U[j.first] == 0)
            Q1.push_back(j);
        }
      }
    }
    cout << cnt << "\n";
  }
  return 0;
}
accuracy: 1
time_ms: 80
memory_kb: 20472
final_rank: 12

code_snippet: #include <iostream>
#include <vector>
#include <queue>
#include <cstring>
using namespace std;

const int MAX_N = 110000;
const int MAX_M = 210000;

int n, m, q, c, cnt;
int a[MAX_M], b[MAX_M], dist[MAX_N], T[MAX_N], U[MAX_N];
vector<pair<int, int>> x[MAX_N], y[MAX_N];
vector<bool> used(MAX_M, false);

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);

  scanf("%d%d%d", &n, &m, &q);

  for (int i = 0; i < m; i++) {
    scanf("%d%d", &a[i], &b[i]);
    x[a[i]].emplace_back(b[i], i);
    x[b[i]].emplace_back(a[i], i);
  }

  memset(dist, 127, sizeof(dist));
  dist[1] = 0;

  vector<int> Q(1, 1);

  for (int i = 0; i < Q.size(); i++) {
    int a1 = Q[i];
    for (pair<int, int> j : x[a1]) {
      if (dist[j.first] > dist[a1] + 1) {
        dist[j.first] = dist[a1] + 1;
        Q.push_back(j.first);
      }
    }
  }

  for (int i = 1; i <= n; i++) {
    for (pair<int, int> j : x[i]) {
      if (dist[i] < dist[j.first]) {
        y[i].push_back(j);
        T[j.first]++;
      }
    }
  }

  for (int i = 0; i < q; i++) {
    scanf("%d", &c);
    c--;
    vector<pair<int, int>> Q1;
    int ss = -1;
    if (dist[a[c]] < dist[b[c]])
      ss = b[c];
    if (dist[a[c]] > dist[b[c]])
      ss = a[c];
    if (ss >= 1 && U[ss] == 0 && used[c] == false) {
      Q1.emplace_back(ss, c);
      while (!Q1.empty()) {
        int a1 = Q1.back().first, a2 = Q1.back().second;
        Q1.pop_back();
        if (U[a1] == 1 || used[a2] == true)
          continue;
        T[a1]--;
        used[a2] = true;
        if (T[a1] != 0)
          continue;
        cnt++;
        U[a1] = 1;
        for (pair<int, int> j : y[a1]) {
          if (U[j.first] == 0)
            Q1.emplace_back(j);
        }
      }
    }
    printf("%d\n", cnt);
  }

  return 0;
}
accuracy: 1
time_ms: 70
memory_kb: 20436
final_rank: 10

code_snippet: #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;

void reader(int *x) {
  int k = getchar_unlocked();
  *x = k - '0';
  while (1) {
    k = getchar_unlocked();
    if (k < '0' || k > '9')
      break;
    *x = ((*x) << 1) + ((*x) << 3) + k - '0';
  }
}

const int MAX_N = 100000;
const int MAX_M = 200000;
const int MAX_Q = 200000;

vector<int> E[MAX_N];
int u[MAX_M], v[MAX_M], r[MAX_Q], ans[MAX_Q], d[MAX_N], cnt = 1;
bool b[MAX_M], ok[MAX_N];
queue<int> que;

void bfs(int u, int t) {
  que.push(u);
  while (!que.empty()) {
    int p = que.front();
    que.pop();
    for (int v : E[p]) {
      if (t) {
        if (d[v] > d[p] && !ok[v]) {
          ok[v] = 1;
          cnt++;
          que.push(v);
        }
      } else if (!~d[v]) {
        d[v] = d[p] + 1;
        que.push(v);
      }
    }
  }
}

int main() {
  int n, m, q;
  reader(&n);
  reader(&m);
  reader(&q);

  rep(i, m) {
    reader(&u[i]);
    reader(&v[i]);
    u[i]--;
    v[i]--;
    E[u[i]].push_back(v[i]);
    E[v[i]].push_back(u[i]);
  }

  memset(d, -1, sizeof(d));
  d[0] = 0;
  bfs(0, 0);

  rep(i, m) {
    if (d[u[i]] > d[v[i]])
      swap(u[i], v[i]);
  }

  rep(i, n) E[i].clear();

  rep(i, q) {
    reader(&r[i]);
    r[i]--;
    b[r[i]] = true;
  }

  ok[0] = true;

  rep(i, m) {
    if (!b[i]) {
      if (d[v[i]] - d[u[i]] == 1) {
        E[u[i]].emplace_back(v[i]);
      }
    }
  }

  bfs(0, 1);

  for (int i = q - 1; i >= 0; i--) {
    ans[i] = n - cnt;
    if (d[v[r[i]]] - d[u[r[i]]] == 1 && !ok[v[r[i]]]) {
      E[u[r[i]]].emplace_back(v[r[i]]);
      if (ok[u[r[i]]]) {
        cnt++;
        ok[v[r[i]]] = true;
        bfs(v[r[i]], 1);
      }
    }
  }

  rep(i, q) printf("%d\n", ans[i]);
}
accuracy: 1
time_ms: 30
memory_kb: 13924
final_rank: 2

code_snippet: #include <iostream>
#include <vector>
#include <queue>
#include <bitset>
#include <algorithm>

using namespace std;

const int MAX_N = 100000;
const int MAX_M = 200000;

int n, m, q;
vector<int> adj[MAX_N];
int u[MAX_M], v[MAX_M], r[MAX_M], ans[MAX_M], d[MAX_N], cnt = 1;
bitset<MAX_N> b, ok;

void bfs(int u, int t) {
    queue<int> que;
    que.push(u);
    while (!que.empty()) {
        int p = que.front();
        que.pop();
        for (int v : adj[p]) {
            if (t) {
                if (d[v] > d[p] && !ok[v]) {
                    ok[v] = true;
                    cnt++;
                    que.push(v);
                }
            } else if (d[v] == -1) {
                d[v] = d[p] + 1;
                que.push(v);
            }
        }
    }
}

int main() {
    cin >> n >> m >> q;
    for (int i = 0; i < m; i++) {
        cin >> u[i] >> v[i];
        u[i]--;
        v[i]--;
        adj[u[i]].push_back(v[i]);
        adj[v[i]].push_back(u[i]);
    }

    fill(d, d + n, -1);
    d[0] = 0;
    bfs(0, 0);

    for (int i = 0; i < m; i++) {
        if (d[u[i]] > d[v[i]])
            swap(u[i], v[i]);
    }

    for (int i = 0; i < n; i++) {
        adj[i].clear();
    }

    for (int i = 0; i < q; i++) {
        cin >> r[i];
        r[i]--;
        b[r[i]] = true;
    }

    ok[0] = true;
    for (int i = 0; i < m; i++) {
        if (!b[i]) {
            if (d[v[i]] - d[u[i]] == 1) {
                adj[u[i]].push_back(v[i]);
            }
        }
    }

    bfs(0, 1);

    for (int i = q - 1; i >= 0; i--) {
        ans[i] = n - cnt;
        if (d[v[r[i]]] - d[u[r[i]]] == 1 && !ok[v[r[i]]]) {
            adj[u[r[i]]].push_back(v[r[i]]);
            if (ok[u[r[i]]]) {
                cnt++;
                ok[v[r[i]]] = true;
                bfs(v[r[i]], 1);
            }
        }
    }

    for (int i = 0; i < q; i++) {
        cout << ans[i] << endl;
    }

    return 0;
}
accuracy: 0.14814814814814814
time_ms: 80
memory_kb: 11956
final_rank: 19