text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 6;
const long long inf = 1e9 + 7;
const long long Log2 = 19;
vector<long long> g[N];
long long n, k, dis, cnt[N], i, x, y, police, d[N], par[N];
queue<long long> q;
vector<long long> ans;
pair<long long, long long> a[N];
void BFS() {
while (!q.empty()) {
long long u = q.front();
q.pop();
for (auto i : g[u]) {
if (d[i] > d[u] + 1) {
d[i] = d[u] + 1;
par[i] = par[u];
q.push(i);
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
if (fopen("tst"
".inp",
"r")) {
freopen(
"tst"
".inp",
"r", stdin);
}
cin >> n >> k >> dis;
fill(d, d + n + 1, inf);
for (i = 1; i <= k; i++) {
cin >> x;
cnt[x]++;
d[x] = 0;
q.push(x);
par[x] = x;
if (cnt[x] == 1) police++;
}
cout << police - 1 << "\n";
for (i = 1; i < n; i++) {
cin >> a[i].first >> a[i].second;
x = a[i].first;
y = a[i].second;
g[x].push_back(y);
g[y].push_back(x);
}
BFS();
for (i = 1; i < n; i++) {
x = a[i].first, y = a[i].second;
if (par[x] != par[y]) ans.push_back(i);
}
for (auto i : ans) cout << i << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
int n, k, d;
bool visited[maxn];
int par[maxn];
map<pair<int, int>, int> edge;
map<pair<int, int>, bool> mark;
vector<int> G[maxn];
vector<int> ans;
queue<int> Q;
void bfs() {
while (!Q.empty()) {
int v = Q.front();
Q.pop();
for (int u : G[v]) {
if (!visited[u]) {
par[u] = v;
visited[u] = true;
Q.push(u);
} else if (u != par[v]) {
if (!mark[{v, u}]) {
mark[{v, u}] = mark[{u, v}] = true;
ans.push_back(edge[{v, u}]);
}
}
}
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> k >> d;
for (int i = 0; i < k; i++) {
int p;
cin >> p;
p--;
if (!visited[p]) {
Q.push(p);
par[p] = -1;
}
visited[p] = true;
}
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--, v--;
G[u].push_back(v);
G[v].push_back(u);
edge[{u, v}] = edge[{v, u}] = i + 1;
}
bfs();
cout << ans.size() << '\n';
for (int u : ans) {
cout << u << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const int maxN = 1e6 + 7;
long long n, m, d;
bool used[maxN], stat[maxN];
int dist[maxN], ans, parent[maxN];
vector<int> graph[maxN], wek;
queue<int> Q;
map<pair<int, int>, int> edges;
void BFS() {
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (auto v : graph[u]) {
if (dist[v] == inf) {
dist[v] = dist[u] + 1;
parent[v] = u;
Q.push(v);
} else {
if (v != parent[u]) {
if (edges[pair<int, int>(min(u, v), max(u, v))] != 0) {
ans++;
wek.push_back(edges[pair<int, int>(min(u, v), max(u, v))]);
edges[pair<int, int>(min(u, v), max(u, v))] = 0;
}
}
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> d;
for (int i = (1); i <= ((n)); ++i) dist[i] = inf;
for (int i = (1); i <= ((m)); ++i) {
int a;
cin >> a;
if (stat[a] != true) {
stat[a] = true;
Q.push(a);
dist[a] = 0;
}
}
for (int i = (0); i <= ((n - 1) - 1); ++i) {
int a, b;
cin >> a >> b;
if (a > b) swap(a, b);
graph[a].push_back(b);
graph[b].push_back(a);
edges[(pair<int, int>(a, b))] = i + 1;
}
BFS();
cout << ans << endl;
for (int i = (0); i <= ((ans)-1); ++i) cout << wek[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long n, k, d;
long long lvl[300005], vis[300005];
vector<long long> adj[300005];
long long par[300005];
vector<long long> v;
vector<pair<long long, long long>> sh;
long long root(long long x) {
if (par[x] == x) return x;
return par[x] = root(par[x]);
}
void join(long long x, long long y) { par[root(x)] = y; }
void bfs(set<long long> st) {
queue<long long> q;
for (auto &cv : st) q.push(cv), vis[cv] = 1;
while (!q.empty()) {
long long cur = q.front();
q.pop();
for (auto &cv : adj[cur]) {
if (vis[cv]) continue;
vis[cv] = 1;
join(cur, cv);
q.push(cv);
}
}
}
void solve() {
long long i, j, l, r, m, a, b, c, x, y, z, t;
cin >> n >> k >> d;
set<long long> st;
for (i = 1; i <= k; i++) {
cin >> x;
vis[x] = 1;
st.insert(x);
}
for (i = 1; i <= n; i++) par[i] = i;
for (i = 1; i < n; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
sh.push_back({x, y});
}
bfs(st);
vector<long long> ans;
for (i = 0; i < sh.size(); i++) {
if (root(sh[i].first) == root(sh[i].second)) continue;
ans.push_back(i + 1);
}
cout << ans.size() << endl;
for (i = 0; i < ans.size(); i++) {
cout << ans[i] << ' ';
}
cout << endl;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
const int inf = (int)2e9;
int n, k, d, vis[N * 2], bl[N], a[N];
int dis[N];
int first[N], nxt[N * 2], point[N * 2], id[N * 2], e = 0;
void add_edge(int x, int y, int z) {
point[++e] = y;
nxt[e] = first[x];
first[x] = e;
id[e] = z;
}
queue<int> q;
void bfs() {
while (!q.empty()) {
int now = q.front();
q.pop();
for (int i = first[now]; i != -1; i = nxt[i]) {
int v = point[i];
if (bl[v]) continue;
dis[v] = dis[now] + 1;
q.push(v);
vis[id[i]] = 1;
bl[v] = 1;
}
}
}
int main() {
memset(vis, 0, sizeof(vis));
memset(first, -1, sizeof(first));
memset(nxt, -1, sizeof(nxt));
for (int i = 1; i <= n; i++) dis[i] = inf;
scanf("%d%d%d", &n, &k, &d);
for (int i = 1; i <= k; i++) {
scanf("%d", &a[i]);
bl[a[i]] = 1;
dis[a[i]] = 0;
q.push(a[i]);
}
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
add_edge(x, y, i);
add_edge(y, x, i);
}
bfs();
int ans = 0;
for (int i = 1; i < n; i++) ans += (!vis[i]);
cout << ans << endl;
for (int i = 1; i < n; i++)
if (!vis[i]) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)3e5 + 5;
const int K = (int)3e5 + 5;
vector<pair<int, int>> adj[N];
queue<pair<int, int>> q;
bool visited[N];
int res[300005];
int n;
int k;
int d;
int main() {
scanf("%d%d%d", &n, &k, &d);
for (int i = 0; i < k; i++) {
int place;
scanf("%d", &place);
q.push({place, 0});
}
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back({v, i + 1});
adj[v].push_back({u, i + 1});
}
while (!q.empty()) {
int pos = q.front().first;
int from = q.front().second;
q.pop();
if (visited[pos]) continue;
visited[pos] = 1;
for (pair<int, int> u : adj[pos]) {
if (u.first != from) {
if (visited[u.first])
res[u.second] = 1;
else
q.push({u.first, pos});
}
}
}
int rescnt = 0;
for (int i = 1; i <= n - 1; i++)
if (res[i]) rescnt++;
cout << rescnt << endl;
for (int x = 1; x <= n - 1; x++)
if (res[x]) cout << x << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, p;
int d[300020];
int x[300020];
int y[300020];
vector<int> a[300020];
queue<int> q;
int main() {
scanf("%d%d%*d", &n, &k);
for (int i = 0; i < k; i++) {
scanf("%d", &p);
if (d[p] > 0) {
i--;
k--;
continue;
}
d[p] = p;
q.push(p);
}
for (int i = 1; i < n; i++) {
scanf("%d%d", &x[i], &y[i]);
a[x[i]].push_back(y[i]);
a[y[i]].push_back(x[i]);
}
while (q.size()) {
int u = q.front();
q.pop();
for (int i : a[u]) {
if (d[i] == 0) {
d[i] = d[u];
q.push(i);
}
}
}
printf("%d\n", k - 1);
for (int i = 1; i < n; i++)
if (d[x[i]] != d[y[i]]) printf("%d ", i);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
const int INF = 2147483647;
using namespace std;
class Node {
public:
int pred, dist;
bool visited, isStation;
Node() : pred(0), dist(0), visited(false), isStation(false) {}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k, d;
cin >> n >> k >> d;
vector<set<int>> tree(n + 1);
vector<Node> nodes(n + 1);
map<pair<int, int>, int> roads;
vector<int> stations;
for (int i = 0; i < k; i++) {
int num;
cin >> num;
stations.push_back(num);
}
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
tree[x].insert(y);
tree[y].insert(x);
roads.insert(make_pair(make_pair(x, y), i));
roads.insert(make_pair(make_pair(y, x), i));
}
for (int i : stations) {
nodes[i].isStation = true;
nodes[i].visited = true;
nodes[i].pred = i;
}
sort(stations.begin(), stations.end());
auto it = unique(stations.begin(), stations.end());
stations.resize(it - stations.begin());
k = stations.size();
bool done = false;
vector<int> ans;
queue<int> q;
for (int i : stations) {
q.push(i);
nodes[i].visited = true;
}
while (!q.empty()) {
int cur = q.front();
q.pop();
vector<int> toKill;
for (int i : tree[cur]) {
if (!nodes[i].visited) {
nodes[i].visited = true;
nodes[i].pred = nodes[cur].pred;
q.push(i);
} else if (nodes[i].pred != nodes[cur].pred) {
toKill.push_back(i);
}
}
for (int i : toKill) {
tree[i].erase(cur);
tree[cur].erase(i);
ans.push_back(roads.find(make_pair(cur, i))->second);
}
}
cout << ans.size() << endl;
for (int i : ans) {
cout << i << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cout << *it << " = " << a << "\n";
err(++it, args...);
}
const long long N = 3e5 + 5, M = 1e9 + 7, inf = 1e6;
vector<int> g[N], p(N), d(N, inf), pre(N), vis(N);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n, k, dt;
cin >> n >> k >> dt;
queue<int> q;
set<int> ans;
map<pair<int, int>, int> m;
for (int i = 0; i < k; i++) {
int x;
cin >> x;
if (p[x] != 1) {
q.push(x);
p[x] = 1;
d[x] = 0;
vis[x] = 1;
}
}
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
m[{x, y}] = m[{y, x}] = i + 1;
g[x].push_back(y);
g[y].push_back(x);
}
while (not q.empty()) {
int u = q.front();
q.pop();
for (int v : g[u]) {
if (vis[v] and v != pre[u]) {
ans.insert(m[{u, v}]);
} else if (not vis[v]) {
d[v] = d[u] + 1;
pre[v] = u;
q.push(v);
vis[v] = 1;
}
}
}
cout << ans.size() << "\n";
for (auto x : ans) {
cout << x << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300050;
const int inf = 1 << 30;
const long long INF = 1ll << 61;
const double eps = 1e-9;
int n, m, d, h, dis[maxn];
int u[maxn], v[maxn];
bool vis[maxn], us[maxn];
vector<pair<int, int> > nex[maxn];
queue<int> q;
vector<int> ans;
int main() {
scanf("%d%d%d", &n, &m, &d);
memset(dis, 0x3f, sizeof(dis));
for (int i = 1; i <= m; ++i) {
int x;
scanf("%d", &x);
dis[x] = 0;
q.push(x);
}
for (int i = 1; i <= n - 1; ++i) {
scanf("%d%d", &u[i], &v[i]);
nex[u[i]].push_back(make_pair(v[i], i));
nex[v[i]].push_back(make_pair(u[i], i));
}
while (!q.empty()) {
h = q.front();
q.pop();
for (auto p : nex[h])
if (dis[p.first] == 0x3f3f3f3f) {
dis[p.first] = dis[h] + 1;
us[p.second] = true;
q.push(p.first);
}
}
for (int i = 1; i <= n - 1; ++i)
if (!us[i]) ans.push_back(i);
printf("%d\n", ans.size());
for (auto p : ans) printf("%d ", p);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
int n, k, d, p[N], dis[N];
vector<int> adj[N], ind[N], ans;
queue<int> que;
void bfs() {
while (!que.empty()) {
int v = que.front();
que.pop();
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i];
if (dis[u] == -1) {
dis[u] = dis[v] + 1;
que.push(u);
} else
ans.push_back(ind[v][i]);
}
}
return;
}
int main() {
cin >> n >> k >> d;
for (int i = 0; i < k; i++) {
cin >> p[i];
p[i]--;
}
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
ind[u].push_back(i);
ind[v].push_back(i);
}
fill(dis, dis + N, -1);
for (int i = 0; i < k; i++) {
if (dis[p[i]] == -1) {
que.push(p[i]);
dis[p[i]] = 0;
}
}
bfs();
sort(ans.begin(), ans.end());
vector<int> sol;
for (int i = 1; i < ans.size(); i++) {
if (ans[i - 1] == ans[i]) sol.push_back(ans[i]);
}
cout << sol.size() << '\n';
for (int i = 0; i < sol.size(); i++) cout << sol[i] + 1 << " ";
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, d, pred[400000];
vector<pair<int, int> > a[400000];
vector<int> ans;
bool b[400000], rebr[400000];
queue<int> q;
int main() {
int i, x, y;
cin >> n >> k >> d;
for (i = 1; i <= n; i++) {
b[i] = false;
rebr[i] = false;
}
for (i = 1; i <= k; i++) {
cin >> x;
if (!b[x]) {
b[x] = true;
q.push(x);
}
}
for (i = 1; i < n; i++) {
cin >> x >> y;
a[x].push_back(make_pair(y, i));
a[y].push_back(make_pair(x, i));
}
while (!q.empty()) {
int v = q.front();
q.pop();
for (i = 0; i < a[v].size(); i++) {
int to = a[v][i].first;
if (b[to]) {
if (to != pred[v] && !rebr[a[v][i].second]) {
ans.push_back(a[v][i].second);
rebr[a[v][i].second] = true;
}
} else {
q.push(to);
pred[to] = v;
b[to] = true;
}
}
}
cout << ans.size() << endl;
for (i = 0; i < ans.size(); i++) cout << ans[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 7;
vector<pair<int, int> > mp[maxn];
int n, k, d;
queue<pair<int, int> > q;
int po[maxn];
int vis[maxn];
bool ans[maxn];
int BFS() {
int cnt = 0;
while (!q.empty()) {
int u = q.front().first, st = q.front().second;
q.pop();
if (vis[u]) continue;
vis[u] = 1;
for (int i = 0; i < mp[u].size(); i++) {
int v = mp[u][i].first, num = mp[u][i].second;
if (v != st) {
if (vis[v] == 0) {
q.push(make_pair(v, u));
} else {
ans[num] = 1;
cnt++;
}
}
}
}
printf("%d\n", cnt);
for (int i = 1; i < n; i++) {
if (ans[i] == 1) {
printf("%d ", i);
}
}
printf("\n");
return cnt;
}
int main() {
scanf("%d%d%d", &n, &k, &d);
for (int i = 0; i < k; i++) {
scanf("%d", &po[i]);
q.push(make_pair(po[i], 0));
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
mp[u].push_back(make_pair(v, i));
mp[v].push_back(make_pair(u, i));
}
BFS();
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300010;
bool isp[maxn];
vector<int> son[maxn];
int u[maxn], v[maxn];
int dis[maxn];
int co[maxn];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
;
int n, k, d;
cin >> n >> k >> d;
memset(dis, -1, sizeof dis);
for (int j = 1; j <= k; ++j) {
int x;
cin >> x;
isp[x] = 1;
}
for (int j = 1; j < n; ++j) {
cin >> u[j] >> v[j];
son[u[j]].push_back(v[j]);
son[v[j]].push_back(u[j]);
}
int tot = 0;
int ans = 0;
queue<int> que;
for (int j = 1; j <= n; ++j) {
if (isp[j]) {
que.push(j);
dis[j] = 0;
++ans;
co[j] = ++tot;
}
}
--ans;
cout << ans << endl;
while (!que.empty()) {
int tis = que.front();
que.pop();
if (dis[tis] == d) continue;
for (int j = 0; j < son[tis].size(); ++j) {
int nx = son[tis][j];
if (dis[nx] == -1) {
dis[nx] = dis[tis] + 1;
co[nx] = co[tis];
que.push(nx);
}
}
}
for (int j = 1; j < n; ++j) {
if (co[u[j]] != co[v[j]]) cout << j << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
std::vector<std::vector<std::array<int, 2>>> v;
std::vector<bool> is_p;
std::vector<bool> visited;
std::set<int> to_remove;
int d;
void solve(std::istream& in, std::ostream& out) {
int n, k;
in >> n >> k >> d;
is_p.resize(n);
v.resize(n);
visited.resize(n);
queue<std::array<int, 2>> q;
for (int i = 0; i < k; ++i) {
int p;
in >> p;
--p;
if (!is_p[p]) {
is_p[p] = true;
q.push({p, 0});
visited[p] = true;
}
}
for (int i = 0; i < n - 1; ++i) {
int a, b;
in >> a >> b;
--a;
--b;
v[a].push_back({b, i});
v[b].push_back({a, i});
to_remove.insert(i);
}
while (!q.empty()) {
auto cur = q.front();
for (auto next : v[cur[0]]) {
if (visited[next[0]]) continue;
q.push({next[0], cur[1]});
to_remove.erase(next[1]);
visited[next[0]] = true;
}
q.pop();
}
out << to_remove.size() << '\n';
for (auto r : to_remove) out << r + 1 << ' ';
out << '\n';
}
};
void solve(std::istream& in, std::ostream& out) {
out << std::setprecision(12);
Solution solution;
solution.solve(in, out);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
istream& in = cin;
ostream& out = cout;
solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
int a[N + 2], b[N + 2], ds[N + 2], tg[N + 2];
vector<int> adj[N + 2];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k, d;
cin >> n >> k >> d;
for (int i = 1; i <= n; i++) ds[i] = 1e9;
queue<int> q;
for (int i = 1; i <= k; i++) {
int x;
cin >> x;
if (ds[x]) ds[x] = 0, tg[x] = x, q.push(x);
}
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
a[i] = u, b[i] = v;
}
while (q.size()) {
int u = q.front();
q.pop();
for (auto x : adj[u]) {
if (ds[u] + 1 < ds[x]) {
ds[x] = ds[u] + 1;
q.push(x);
tg[x] = tg[u];
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++)
if (tg[a[i]] != tg[b[i]]) ans++;
cout << ans << endl;
for (int i = 1; i < n; i++)
if (tg[a[i]] != tg[b[i]]) cout << i << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long visit[300001];
vector<long long> p;
vector<pair<long long, long long> > vec[300001];
map<long long, long long> m, m1;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long i, j, n, k, d;
cin >> n >> k >> d;
for (i = 1; i <= k; i++) {
long long x;
cin >> x;
p.push_back(x);
}
for (i = 1; i < n; i++) {
long long x, y;
cin >> x >> y;
vec[x].push_back({y, i});
vec[y].push_back({x, i});
}
queue<long long> q;
for (i = 0; i < k; i++) {
long long x = p[i];
q.push(x);
visit[x] = 1;
}
while (!q.empty()) {
long long u = q.front();
q.pop();
long long si = vec[u].size();
for (long long i = 0; i < si; i++) {
long long v = vec[u][i].first;
long long a = vec[u][i].second;
if (!visit[v]) {
q.push(v);
m[a]++;
visit[v] = 1;
}
}
}
long long c = 0;
for (i = 1; i < n; i++) {
if (!m[i]) c++;
}
cout << c << endl;
for (i = 1; i < n; i++) {
if (!m[i]) cout << i << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pi = pair<int, int>;
using pll = pair<ll, ll>;
constexpr int INF = 0x3f3f3f3f;
constexpr ll LLINF = 0x3f3f3f3f3f3f3f3f;
template <class RIt>
void dbarr(RIt frs, RIt lst) {
cerr << "arr: ";
for (int i = 0; i < (int)(lst - frs); i++)
cerr << frs[i] << " \n"[i == (int)(lst - frs) - 1];
}
const int MM = 3e5 + 5;
int n, k, d;
bool pol[MM], vis[MM];
vector<pi> adj[MM];
int main() {
cin.exceptions(cin.failbit);
cin.tie(0)->sync_with_stdio(0);
cin >> n >> k >> d;
queue<pi> q;
for (int i = 0; i < k; i++) {
int x;
cin >> x;
pol[x] = 1;
q.push({x, 0});
}
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
adj[a].emplace_back(b, i);
adj[b].emplace_back(a, i);
}
set<int> res;
while (q.size()) {
auto [u, p] = q.front();
q.pop();
if (vis[u]) continue;
vis[u] = 1;
for (auto [v, i] : adj[u]) {
if (v == p) continue;
if (vis[v])
res.insert(i);
else
q.push({v, u});
}
}
cout << res.size() << "\n";
for (int x : res) cout << x + 1 << " ";
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 7;
const long double E = 1e-5;
unsigned char ccc;
bool _minus = false;
template <typename T>
inline T sqr(T t) {
return (t * t);
}
inline void read(long long &n) {
n = 0;
_minus = false;
while (true) {
ccc = getchar();
if (ccc == ' ' || ccc == '\n') break;
if (ccc == '-') {
_minus = true;
continue;
}
n = n * 10 + ccc - '0';
}
if (_minus) n *= -1;
}
inline void read(int &n) {
n = 0;
_minus = false;
while (true) {
ccc = getchar();
if (ccc == ' ' || ccc == '\n') break;
if (ccc == '-') {
_minus = true;
continue;
}
n = n * 10 + ccc - '0';
}
if (_minus) n *= -1;
}
char wwww[19];
int kkkk;
inline void write(long long y) {
long long x = y;
kkkk = 0;
if (!x)
++kkkk, wwww[kkkk] = '0';
else
while (x) {
++kkkk;
wwww[kkkk] = char(x % 10 + '0');
x /= 10;
}
for (int i = kkkk; i >= 1; --i) putchar(wwww[i]);
putchar(' ');
}
const int INF = 1e9;
const int MAX = 3e5 + 10;
vector<pair<int, int> > vec[MAX];
bool used[MAX];
vector<int> ans;
int d;
int dist[MAX];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
srand(time(NULL));
cout.precision(3);
cout << fixed;
int n, k;
cin >> n >> k >> d;
for (int i = 1; i <= n; i++) {
dist[i] = INF;
}
queue<int> q;
int pos;
for (int i = 0; i < k; i++) {
cin >> pos;
dist[pos] = 0;
q.push(pos);
}
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
vec[a].push_back(make_pair(b, i));
vec[b].push_back(make_pair(a, i));
}
while (!q.empty()) {
int pos = q.front();
q.pop();
for (pair<int, int> a : vec[pos]) {
if (dist[a.first] == INF) {
dist[a.first] = dist[pos] + 1;
q.push(a.first);
used[a.second] = true;
}
}
}
for (int i = 1; i < n; i++) {
if (!used[i]) {
ans.push_back(i);
}
}
cout << ans.size() << "\n";
for (int a : ans) {
cout << a << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, d;
cin >> n >> k >> d;
auto has_police = vector<bool>(n);
for (auto i = 0; i < k; i++) {
int v;
cin >> v;
v--;
has_police[v] = true;
}
struct Edge {
int id, source, target;
};
auto adjacency_list = vector<vector<Edge>>(n);
for (auto i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
adjacency_list[u].push_back({i, u, v});
adjacency_list[v].push_back({i, v, u});
}
auto seen = vector<bool>(n);
auto queue = std::queue<int>();
for (auto v = 0; v < n; v++)
if (has_police[v]) {
seen[v] = true;
queue.push(v);
}
auto subgraph = vector<bool>(n - 1);
while (!queue.empty()) {
auto v = queue.front();
queue.pop();
for (const auto e : adjacency_list[v])
if (!seen[e.target]) {
seen[e.target] = true;
subgraph[e.id] = true;
queue.push(e.target);
}
}
const auto n_closed = count(begin(subgraph), end(subgraph), false);
assert(n_closed == count(begin(has_police), end(has_police), true) - 1);
cout << n_closed << endl;
for (auto e = 0; e < n - 1; e++)
if (!subgraph[e]) cout << e + 1 << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, u, v, d, x, dis[300001], vis[300001];
map<pair<int, int>, int> mp;
vector<int> G[300001];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> d;
memset(dis, -1, sizeof(dis));
queue<int> q;
for (int i = 1; i <= k; ++i) {
cin >> x;
dis[x] = 0;
q.push(x);
}
for (int i = 1; i < n; ++i) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
mp[{u, v}] = mp[{v, u}] = i;
}
while (!q.empty()) {
int temp = q.front();
q.pop();
for (int j : G[temp]) {
if (dis[j] == -1) {
dis[j] = dis[temp] + 1;
vis[mp[{j, temp}]] = 1;
q.push(j);
}
}
}
int cnt = 0;
for (int i = 1; i < n; ++i)
if (!vis[i]) ++cnt;
cout << cnt << '\n';
for (int i = 1; i < n; ++i)
if (!vis[i]) cout << i << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
int n, k, d, x, y;
vector<vector<int> > v(N);
bool visited[N];
map<pair<int, int>, int> mp;
set<int> del;
set<pair<int, pair<int, int> > > se;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> k >> d;
for (int i = 0; i < k; i++) cin >> x, se.insert({0, {x, -1}});
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
mp[{x, y}] = mp[{y, x}] = i + 1;
}
while (!se.empty()) {
int cost = se.begin()->first;
int node = se.begin()->second.first;
int p = se.begin()->second.second;
se.erase(se.begin());
if (visited[node] || cost > d) continue;
visited[node] = 1;
for (auto i : v[node]) {
if (i != p) {
if (!visited[i])
se.insert({cost + 1, {i, node}});
else
del.insert(mp[{i, node}]);
}
}
}
cout << del.size() << endl;
for (auto i : del) cout << i << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void swap(long long int &a, long long int &b) {
long long int u = min(a, b);
long long int v = max(a, b);
a = u;
b = v;
}
int main() {
long long int n, k, d;
cin >> n >> k >> d;
set<long long int> police;
map<pair<long long int, long long int>, long long int> mymap;
vector<vector<long long int> > edge(n + 1);
vector<bool> visited(n + 1, false);
vector<bool> pp(n + 1, false);
long long int tmp;
for (int i = 1; i <= k; i++) {
cin >> tmp;
police.insert(tmp);
pp[tmp] = true;
}
long long int u, v;
for (int i = 1; i <= n - 1; i++) {
cin >> u >> v;
swap(u, v);
mymap[{u, v}] = i;
edge[u].push_back(v);
edge[v].push_back(u);
}
queue<pair<long long int, long long int> > q;
pair<long long int, long long int> temp;
for (auto it : police) q.push(make_pair(it, 1));
while (!q.empty()) {
temp = q.front();
q.pop();
visited[temp.first] = true;
for (auto it2 : edge[temp.first]) {
if (!visited[it2] && temp.second <= d && !pp[it2]) {
q.push(make_pair(it2, temp.second + 1));
visited[it2] = true;
mymap[{min(temp.first, it2), max(temp.first, it2)}] = 0;
}
}
}
long long int ct = 0;
for (auto it : mymap) {
if (it.second != 0) {
ct++;
}
}
cout << ct << "\n";
for (auto it : mymap)
if (it.second != 0) cout << it.second << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, dd, num[300005], nn, ans[300005], an;
vector<int> eg[300005], egid[300005];
bool vis[300005] = {0}, vis2[300005] = {0}, vis3[300005] = {0},
vis4[300005] = {0};
struct node {
int u, d, pr;
};
queue<struct node> q;
void bfs() {
while (!q.empty()) {
struct node u = q.front();
q.pop();
if (u.d > dd) {
if (!vis2[u.pr]) vis2[u.pr] = 1, ans[++an] = u.pr;
continue;
}
for (int i = 0; i < eg[u.u].size(); i++) {
int v = eg[u.u][i];
int id = egid[u.u][i];
if (vis4[id]) continue;
vis4[id] = 1;
int d = u.d + 1;
if (!vis3[v]) {
vis3[v] = 1;
struct node tmp;
tmp.u = v;
tmp.pr = id;
tmp.d = d;
q.push(tmp);
} else {
if (!vis2[id]) vis2[id] = 1, ans[++an] = id;
}
}
}
}
int main() {
an = 0;
nn = 0;
scanf("%d%d%d", &n, &k, &dd);
for (int i = 1, a; i <= k; i++) {
scanf("%d", &a);
vis[a] = 1;
num[++nn] = a;
}
for (int i = 1, a, b; i < n; i++) {
scanf("%d%d", &a, &b);
eg[a].push_back(b);
egid[a].push_back(i);
eg[b].push_back(a);
egid[b].push_back(i);
}
for (int i = 1; i <= nn; i++) {
struct node tmp;
tmp.u = num[i];
tmp.d = 0;
tmp.pr = -1;
vis3[num[i]] = 1;
q.push(tmp);
}
bfs();
sort(ans + 1, ans + 1 + an);
printf("%d\n", an);
for (int i = 1; i <= an; i++) printf("%d ", ans[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v[300005];
vector<int> del;
bool vis[300005], b[300005];
queue<int> q;
int main() {
int n, k, d;
scanf("%d%d%d", &n, &k, &d);
for (int i = 0; i < k; i++) {
int a;
scanf("%d", &a);
q.push(a);
vis[a] = 1;
}
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
v[a].push_back({b, i});
v[b].push_back({a, i});
}
while (!q.empty()) {
int node = q.front();
q.pop();
for (auto u : v[node]) {
if (!vis[u.first]) {
q.push(u.first);
vis[u.first] = 1;
b[u.second] = 1;
}
}
}
for (int i = 1; i < n; i++) {
if (!b[i]) del.push_back(i);
}
printf("%d\n", del.size());
for (int i : del) printf("%d ", i);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
bool vis[N] = {false};
bool vs[N] = {false};
vector<int> g[N];
vector<int> edge[N];
vector<int> ans;
int n, k, d, a, u, v;
queue<int> q;
void bfs() {
int now;
int nxt;
while (!q.empty()) {
now = q.front();
q.pop();
for (int i = 0; i < g[now].size(); i++) {
if (!vis[g[now][i]])
vis[g[now][i]] = true, vs[edge[now][i]] = true, q.push(g[now][i]);
else if (!vs[edge[now][i]])
ans.push_back(edge[now][i]);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k >> d;
for (int i = 0; i < k; i++) cin >> a, vis[a] = true;
for (int i = 0; i < n - 1; i++)
cin >> u >> v, g[u].push_back(v), g[v].push_back(u),
edge[v].push_back(i + 1), edge[u].push_back(i + 1);
for (int i = 1; i <= n; i++)
if (vis[i]) q.push(i);
bfs();
sort(ans.begin(), ans.end());
ans.erase(unique(ans.begin(), ans.end()), ans.end());
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); i++) cout << ans[i] << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > a[3 * int(1e5) + 5];
queue<pair<int, int> > q;
int n, k, d;
bool tv[3 * int(1e5) + 5], rs[3 * int(1e5) + 5];
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> k >> d;
int u, v;
for (int i = 1; i <= k; i++) {
cin >> u;
q.push(pair<int, int>(u, 0));
}
for (int i = 1; i <= n - 1; i++) {
cin >> u >> v;
a[u].push_back(pair<int, int>(v, i));
a[v].push_back(pair<int, int>(u, i));
}
while (q.size() != 0) {
u = q.front().first;
v = q.front().second;
q.pop();
if (tv[u]) continue;
tv[u] = true;
for (int i = 0; i <= a[u].size() - 1; i++)
if (a[u][i].first != v)
if (tv[a[u][i].first])
rs[a[u][i].second] = true;
else
q.push(pair<int, int>(a[u][i].first, u));
}
int d = 0;
for (int i = 1; i <= n - 1; i++)
if (rs[i]) d++;
cout << d << ' ';
for (int i = 1; i <= n - 1; i++)
if (rs[i]) cout << i << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
bitset<N> vis;
vector<pair<int, int>> tre[N];
int ans[N], sz;
int main(int argc, char const *argv[]) {
int n, k, d;
cin >> n >> k >> d;
queue<pair<int, int>> qqq;
for (int i = 0; i < k; i++) {
int v;
cin >> v;
qqq.push({v, -1});
}
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
tre[a].push_back({b, i});
tre[b].push_back({a, i});
}
while (!qqq.empty()) {
int a = qqq.front().first, b = qqq.front().second;
qqq.pop();
if (vis[a]) {
continue;
}
vis[a] = 1;
for (auto i : tre[a]) {
if (i.first == b) {
continue;
}
if (vis[i.first]) {
ans[sz++] = i.second;
} else {
qqq.push({i.first, a});
}
}
}
cout << sz << endl;
for (int i = 0; i < sz; i++) {
if (i) {
cout << " ";
}
cout << ans[i];
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {0, 1, -1, 0, 1, -1, -1, 1};
const int dy[] = {-1, 0, 0, 1, 1, 1, -1, -1};
const long long int MOD = 0;
const long long int N = 0;
int p[300010];
int d[300010];
char vv[300010];
vector<int> g[300010];
vector<pair<int, pair<int, int> > > e;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k, u, v, x, ad;
cin >> n >> k >> ad;
queue<pair<int, int> > q;
memset(p, -1, sizeof p);
memset(vv, 0, sizeof vv);
for (int i = 0; i < n; i++) {
d[i] = 1e9;
}
for (int i = 0; i < k; i++) {
cin >> x;
x--;
q.push(make_pair(x, 0));
p[x] = x;
d[x] = 0;
}
for (int i = 0; i < n - 1; i++) {
cin >> u >> v;
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
e.push_back(make_pair(i + 1, make_pair(u, v)));
}
int dd;
while (!q.empty()) {
u = q.front().first;
dd = q.front().second;
q.pop();
if (vv[u]) continue;
vv[u] = 1;
for (int i = 0; i < g[u].size(); i++) {
v = g[u][i];
if (d[u] + 1 < d[v]) {
d[v] = d[u] + 1;
p[v] = p[u];
q.push(make_pair(v, dd + 1));
}
}
}
int cnt = 0;
for (int i = 0; i < e.size(); i++) {
if (p[e[i].second.first] != p[e[i].second.second]) cnt++;
}
cout << cnt << "\n";
for (int i = 0; i < e.size(); i++) {
if (p[e[i].second.first] != p[e[i].second.second]) {
cout << e[i].first << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> p;
vector<int> v[300005];
bool vis[300005];
int par[300005];
map<pair<int, int>, int> mp;
void bfs() {
queue<int> q;
for (auto i : p) {
q.push(i);
vis[i] = 1;
par[i] = i;
}
while (!q.empty()) {
int cn = q.front();
q.pop();
for (auto x : v[cn]) {
if (!vis[x]) {
q.push(x);
vis[x] = 1;
par[x] = par[cn];
} else if (par[x] != par[cn] && mp[{x, cn}] > 0) {
cout << mp[{x, cn}] << " ";
mp[{x, cn}] = 0;
mp[{cn, x}] = 0;
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
int n, k, d;
cin >> n >> k >> d;
for (long long i = 0; i < k; i++) {
int x;
cin >> x;
p.insert(x);
}
for (long long i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
mp[{a, b}] = i;
mp[{b, a}] = i;
}
cout << p.size() - 1 << "\n";
bfs();
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K, D, st[300005], dr[300005], city[300005], ans;
vector<pair<int, int> > L[300005];
bool used[300005];
queue<int> q;
inline void Read() {
int i, x, y;
cin >> N >> K >> D;
for (i = 1; i <= K; i++) {
cin >> x;
if (!used[x]) {
ans++;
q.push(x);
used[x] = 1;
city[x] = x;
}
}
for (i = 1; i < N; i++) {
cin >> x >> y;
st[i] = x;
dr[i] = y;
L[x].push_back({y, i});
L[y].push_back({x, i});
}
}
inline void Solve() {
int nod;
while (!q.empty()) {
nod = q.front();
q.pop();
for (auto it : L[nod]) {
if (!used[it.first]) {
used[it.first] = 1;
q.push(it.first);
city[it.first] = city[nod];
}
}
}
}
inline void Write() {
int i;
cout << ans - 1 << "\n";
for (i = 1; i <= N; i++) {
if (city[st[i]] != city[dr[i]]) {
cout << i << " ";
}
}
}
int main() {
Read();
Solve();
Write();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, d;
int par[300005];
vector<int> plcs;
vector<int> adj[300005];
inline void bfs() {
queue<int> q;
for (auto x : plcs) {
par[x] = -1;
q.push(x);
}
while (!q.empty()) {
int v = q.front();
q.pop();
for (auto x : adj[v]) {
if (par[x]) {
continue;
}
par[x] = v;
q.push(x);
}
}
}
int main() {
scanf("%d%d%d", &n, &k, &d);
set<pair<int, int>> keep;
vector<pair<int, int>> edgs;
for (int i = 1; i <= k; i++) {
int a;
scanf("%d", &a);
plcs.push_back(a);
}
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
edgs.push_back(make_pair(min(a, b), max(a, b)));
}
bfs();
for (int i = 1; i <= n; i++) {
auto curr = make_pair(min(i, par[i]), max(i, par[i]));
while (!keep.count(curr) && curr.first > 0) {
keep.insert(curr);
int v = curr.second;
int u = par[v];
if (u == curr.first) {
v = par[u];
}
curr = make_pair(min(v, u), max(v, u));
}
}
vector<int> ans;
for (int i = 0; i < (n - 1); i++) {
if (!keep.count(edgs[i])) {
ans.push_back(i + 1);
}
}
printf("%d\n", ans.size());
for (auto x : ans) {
printf("%d ", x);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int N = 3e5 + 5;
int nowtime, n, k, d, memo[N];
bool visited[N];
vector<int> v[N], ans, police;
map<pair<int, int>, int> kode;
set<pair<int, int> > sett;
int par[N];
void bfs() {
queue<int> q;
for (auto x : police) {
q.push(x);
par[x] = x;
visited[x] = true;
}
while (q.empty() == false) {
int skg = q.front();
q.pop();
for (auto isi : v[skg]) {
if (visited[isi] == false) {
visited[isi] = true;
par[isi] = skg;
q.push(isi);
} else if (par[skg] != isi && par[isi] != skg) {
if (sett.count({skg, isi}) == 0 && sett.count({isi, skg}) == 0) {
sett.insert({skg, isi});
ans.push_back(kode[{skg, isi}]);
}
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k >> d;
for (int i = 1; i <= k; i++) {
int p;
cin >> p;
police.push_back(p);
}
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
kode[{a, b}] = i;
kode[{b, a}] = i;
v[a].push_back(b);
v[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
memo[i] = INF;
}
bfs();
cout << ans.size() << endl;
for (auto isi : ans) {
cout << isi << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k, d;
cin >> n >> k >> d;
queue<pair<int, int> > q;
bool vis[n];
for (int i = 0; i < n; i++) vis[i] = false;
bool used[n - 1];
for (int i = 0; i < n - 1; i++) used[i] = false;
for (int i = 0; i < k; i++) {
int p;
cin >> p;
p--;
q.push(make_pair(p, 0));
vis[p] = true;
}
vector<pair<int, int> > adj[n];
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(make_pair(v, i));
adj[v].push_back(make_pair(u, i));
}
while (!q.empty()) {
pair<int, int> p = q.front();
q.pop();
if (p.second > d) continue;
for (int i = 0; i < adj[p.first].size(); i++) {
if (!vis[adj[p.first][i].first]) {
q.push(make_pair(adj[p.first][i].first, p.second + 1));
vis[adj[p.first][i].first] = true;
used[adj[p.first][i].second] = true;
}
}
}
int ans = 0;
for (int i = 0; i < n - 1; i++)
if (!used[i]) ans++;
cout << ans << endl;
for (int i = 0; i < n - 1; i++)
if (!used[i]) cout << i + 1 << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
os << '{';
for (int i = (0), __i = (((int)(vec).size())); i < __i; i++) {
os << vec[i];
if (i + 1 != ((int)(vec).size())) os << ',';
}
os << '}';
return os;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &par) {
os << '(' << par.first << ',' << par.second << ')';
return os;
}
int gcd(int x, int y) { return y ? gcd(y, x % y) : abs(x); }
template <class T>
T sqr(T x) {
return x * x;
}
bool pairCompare(const std::pair<int, int> &firstElem,
const std::pair<double, int> &secondElem) {
if (firstElem.first > secondElem.first)
return true;
else if (firstElem.first == secondElem.first &&
firstElem.second < secondElem.second)
return true;
else
return false;
}
vector<long long> a;
vector<vector<int> > w;
int main() {
ios::sync_with_stdio(false);
FILE *f;
int n, d, k;
cin >> n >> k >> d;
queue<int> v;
vector<bool> visited;
vector<int> from;
vector<vector<pair<int, int> > > w;
visited.resize(n, false);
w.resize(n);
from.resize(n, -1);
set<int> s;
for (int i = 0; i < k; i++) {
int x;
cin >> x;
if (s.find(x - 1) == s.end()) {
v.push(x - 1);
visited[x - 1] = true;
s.insert(x - 1);
}
}
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
w[a].push_back(make_pair(b, i + 1));
w[b].push_back(make_pair(a, i + 1));
}
vector<int> ans;
vector<bool> deletedE(n - 1, false);
while (!v.empty()) {
int cur = v.front();
visited[cur] = true;
for (int i = 0; i < w[cur].size(); i++)
if (!visited[w[cur][i].first]) {
v.push(w[cur][i].first);
visited[w[cur][i].first] = true;
from[w[cur][i].first] = cur;
} else if (from[cur] != w[cur][i].first &&
!deletedE[w[cur][i].second - 1]) {
ans.push_back(w[cur][i].second);
deletedE[w[cur][i].second - 1] = true;
}
v.pop();
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, d, x, y, ans;
vector<pair<int, int> > e[1000555];
queue<pair<int, int> > q;
bool visit[1000555], res[1000555];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> d;
for (int i = 1; i <= k; i++) {
cin >> x;
q.push({x, 0});
}
for (int i = 1; i < n; i++) {
cin >> x >> y;
e[x].push_back({y, i});
e[y].push_back({x, i});
}
while (!q.empty()) {
int pos = q.front().first;
int par = q.front().second;
q.pop();
if (visit[pos]) continue;
visit[pos] = 1;
for (auto u : e[pos]) {
if (u.first == par) continue;
if (visit[u.first])
res[u.second] = 1;
else
q.push({u.first, pos});
}
}
for (int i = 1; i <= n; i++) ans += res[i];
cout << ans << endl;
for (int i = 1; i <= n; i++) {
if (res[i]) cout << i << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 7;
vector<pair<int, int>> adj[N];
queue<pair<int, int>> q;
bool vis[N], res[N];
int main() {
ios_base::sync_with_stdio(0);
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, k, d;
scanf("%d%d%d", &n, &k, &d);
for (int i = 0; i < k; ++i) {
int x;
scanf("%d", &x);
q.push({x, 0});
}
for (int i = 0; i < n - 1; ++i) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back({v, i + 1});
adj[v].push_back({u, i + 1});
}
while (!q.empty()) {
int CurrentNode = q.front().first;
int From = q.front().second;
q.pop();
if (vis[CurrentNode]) continue;
vis[CurrentNode] = true;
for (int i = 0; i < adj[CurrentNode].size(); ++i) {
if (adj[CurrentNode][i].first != From) {
if (vis[adj[CurrentNode][i].first])
res[adj[CurrentNode][i].second] = 1;
else
q.push({adj[CurrentNode][i].first, CurrentNode});
}
}
}
int ans = 0;
for (int i = 1; i <= n - 1; ++i)
if (res[i]) ++ans;
printf("%d\n", ans);
for (int i = 1; i <= n - 1; ++i)
if (res[i]) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n, k, d;
cin >> n >> k >> d;
auto has_police = vector<bool>(n);
for (auto i = 0; i < k; i++) {
int v;
cin >> v;
v--;
has_police[v] = true;
}
struct Edge {
int id, source, target;
};
auto adjacency_list = vector<vector<Edge>>(n);
for (auto i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
adjacency_list[u].push_back({i, u, v});
adjacency_list[v].push_back({i, v, u});
}
auto seen = vector<bool>(n);
auto queue = std::queue<int>();
for (auto v = 0; v < n; v++)
if (has_police[v]) {
seen[v] = true;
queue.push(v);
}
auto subgraph = vector<bool>(n - 1);
while (!queue.empty()) {
auto v = queue.front();
queue.pop();
for (const auto e : adjacency_list[v])
if (!seen[e.target]) {
seen[e.target] = true;
subgraph[e.id] = true;
queue.push(e.target);
}
}
const auto n_closed = count(begin(subgraph), end(subgraph), false);
assert(n_closed == count(begin(has_police), end(has_police), true) - 1);
cout << n_closed << endl;
for (auto e = 0; e < n - 1; e++)
if (!subgraph[e]) cout << e + 1 << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, d, fix[300005], a, b, ans, p[300005], mp1[300005];
queue<int> q;
vector<pair<int, int> > v[300005];
set<int> s[300005];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> k >> d;
for (int i = 1; i <= k; i++) {
cin >> a;
if (!fix[a]) {
q.push(a);
ans++;
}
fix[a] = 1;
}
cout << ans - 1 << endl;
for (int i = 1; i <= n - 1; i++) {
cin >> a >> b;
v[a].push_back({b, i});
v[b].push_back({a, i});
}
while (q.size()) {
a = q.front();
q.pop();
for (int i = 0; i < v[a].size(); i++) {
if (v[a][i].first == p[a]) continue;
if (fix[v[a][i].first] == 1) {
mp1[v[a][i].second] = 1;
} else {
p[v[a][i].first] = a;
q.push(v[a][i].first);
fix[v[a][i].first] = 1;
}
}
}
for (int i = 1; i <= n - 1; i++)
if (mp1[i]) cout << i << " ";
cout << endl;
;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 6;
int ans[N];
vector<pair<int, int> > G[N];
int k;
int d;
set<pair<int, int> > q;
int yes[N];
int par[N];
int vis[N];
int dist[N];
int main() {
int n;
cin >> n >> k >> d;
for (int i = 0; i < k; i++) {
int x;
cin >> x;
if (yes[x]) continue;
yes[x] = 1;
vis[x] = 1;
q.insert(make_pair(0, x));
}
for (int i = 2; i <= n; ++i) {
int x, y;
cin >> x >> y;
G[x].push_back(make_pair(i - 1, y));
G[y].push_back(make_pair(i - 1, x));
}
while (!q.empty()) {
auto cur = *(q.begin());
q.erase(q.begin());
for (auto z : G[cur.second]) {
if (vis[z.second]) {
if (par[z.second] == cur.second or par[cur.second] == z.second)
continue;
ans[z.first] = 1;
} else {
vis[z.second] = 1;
par[z.second] = cur.second;
q.insert(make_pair(cur.first + 1, z.second));
}
}
}
int cnt = 0;
for (int i = 1; i < n; i++)
if (ans[i]) cnt++;
cout << cnt << endl;
for (int i = 1; i < n; i++) {
if (ans[i]) cout << i << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct A {
int id, key;
} node[600000];
int n, m, p, k, minn, sum;
int flow[600000];
bool mark[600000], book[600000], inque[600000];
vector<int> way[600000], id[600000], ans;
queue<int> que;
bool cmp(A x, A y) { return x.key < y.key; }
int main() {
int a, b;
cin >> n >> m >> p;
for (int i = 1; i <= m; i++) {
cin >> a;
way[0].push_back(a);
}
for (int i = 1; i < n; i++) {
cin >> a >> b;
way[a].push_back(b);
id[a].push_back(i);
way[b].push_back(a);
id[b].push_back(i);
}
que.push(0);
book[0] = true;
flow[0] = p + 1;
while (!que.empty()) {
k = que.front();
que.pop();
for (int i = 0; i < way[k].size(); i++) {
if (!book[way[k][i]]) {
flow[way[k][i]] = flow[k] - 1;
book[way[k][i]] = true;
que.push(way[k][i]);
}
}
}
minn = p + 1;
for (int i = 1; i <= n; i++) {
node[i].id = i;
node[i].key = flow[i];
}
sort(1 + node, 1 + n + node, cmp);
for (int i = 1; i <= n; i++) que.push(node[i].id);
while (!que.empty()) {
k = que.front();
que.pop();
mark[k] = true;
sum = 0;
for (int i = 0; i < way[k].size(); i++) {
if (!mark[way[k][i]]) {
if (flow[way[k][i]] == flow[k]) {
ans.push_back(id[k][i]);
} else if (flow[way[k][i]] == flow[k] + 1) {
sum++;
}
}
}
for (int i = 0; i < way[k].size(); i++) {
if (flow[way[k][i]] == flow[k] + 1 && sum != 1) {
sum--;
ans.push_back(id[k][i]);
}
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
int mod = 1000000007;
using namespace std;
using namespace std;
int n, k, d;
vector<vector<int> > adj(300005);
map<pair<int, int>, int> m;
bool isP[300005];
int dp[300005], id[300005];
vector<int> ans;
void dfs1(int v, int p) {
vector<int>::iterator it = adj[v].begin();
if (isP[v]) {
dp[v] = 0;
id[v] = v;
}
for (; it != adj[v].end(); it++) {
if (*it == p) continue;
dfs1(*it, v);
if (dp[*it] + 1 < dp[v]) {
dp[v] = dp[*it] + 1;
id[v] = id[*it];
}
}
}
void dfs2(int v, int p) {
vector<int>::iterator it = adj[v].begin();
for (; it != adj[v].end(); it++) {
if (*it == p) continue;
if (dp[v] + 1 < dp[*it]) {
dp[*it] = dp[v] + 1;
id[*it] = id[v];
}
dfs2(*it, v);
}
}
void dfs3(int v, int p) {
vector<int>::iterator it = adj[v].begin();
for (; it != adj[v].end(); it++) {
if (*it == p) continue;
if (id[v] != id[*it]) ans.push_back(m[make_pair(v, *it)]);
dfs3(*it, v);
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
cin >> n >> k >> d;
memset(isP, 0, sizeof(isP));
for (int i = 0; i <= n; i++) dp[i] = 30000000;
for (int i = 0; i < k; i++) {
int x;
cin >> x;
isP[x] = true;
}
for (int i = 1; i <= n - 1; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
m[make_pair(x, y)] = i;
m[make_pair(y, x)] = i;
}
dfs1(1, 0);
dfs2(1, 0);
dfs3(1, 0);
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
}
|
#include <bits/stdc++.h>
bool police[300000];
bool removeedge[300000];
int minpolicedst[300000];
int minpolice[300000];
int parent[300000];
struct edge {
int id;
int to;
};
std::vector<struct edge> g[300000];
void remove_edges(int x) {
for (auto& e : g[x]) {
if (e.to != parent[x]) {
parent[e.to] = x;
remove_edges(e.to);
}
if (minpolice[x] != minpolice[e.to]) removeedge[e.id] = true;
}
}
int main() {
int n, k, d;
std::queue<int> q;
int uniqpolice = 0;
std::cin >> n >> k >> d;
for (int i = 0; i < n; i++) minpolicedst[i] = 300000 + 1;
for (int i = 0; i < k; i++) {
int x;
std::cin >> x;
if (!police[x - 1]) q.push(x - 1);
police[x - 1] = true;
minpolicedst[x - 1] = 0;
minpolice[x - 1] = x - 1;
}
uniqpolice = q.size();
for (int i = 0; i < n - 1; i++) {
int x, y;
std::cin >> x >> y;
g[x - 1].push_back({i, y - 1});
g[y - 1].push_back({i, x - 1});
}
while (!q.empty()) {
int x = q.front();
q.pop();
for (auto& e : g[x]) {
if (minpolicedst[e.to] > minpolicedst[x] + 1) {
minpolicedst[e.to] = minpolicedst[x] + 1;
minpolice[e.to] = minpolice[x];
q.push(e.to);
}
}
}
parent[0] = -1;
remove_edges(0);
std::cout << (uniqpolice - 1) << std::endl;
for (int i = 0; i < n - 1; i++) {
if (removeedge[i]) std::cout << i + 1 << ' ';
}
std::cout << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MaxN = 300005;
long long n, k, d, head[MaxN], cntEdge, cntColour, c[MaxN], ans[MaxN],
cntAnswer;
long long fr[MaxN], to[MaxN];
struct Edge {
long long destiantion, nextEdge;
} edge[MaxN * 2];
struct City {
long long serial, colour;
};
queue<City> q;
inline long long Read() {
long long num = 0, op = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') op = -1;
ch = getchar();
}
while (isdigit(ch)) {
num = num * 10 + ch - '0';
ch = getchar();
}
return num * op;
}
inline void AddEdge(long long u, long long v) {
cntEdge++;
edge[cntEdge].destiantion = v;
edge[cntEdge].nextEdge = head[u];
head[u] = cntEdge;
return;
}
inline void BFS() {
while (q.size()) {
City x = q.front();
q.pop();
for (long long i = head[x.serial]; i; i = edge[i].nextEdge) {
long long y = edge[i].destiantion;
if (!c[y]) {
c[y] = x.colour;
q.push((City){y, x.colour});
}
}
}
return;
}
signed main() {
n = Read(), k = Read(), d = Read();
for (long long i = 1; i <= k; i++) {
long long x = Read();
if (!c[x]) {
c[x] = ++cntColour;
q.push((City){x, cntColour});
}
}
for (long long i = 1; i < n; i++) {
fr[i] = Read(), to[i] = Read();
AddEdge(fr[i], to[i]), AddEdge(to[i], fr[i]);
}
BFS();
for (long long i = 1; i < n; i++) {
if (c[fr[i]] != c[to[i]]) ans[++cntAnswer] = i;
}
printf("%lld\n", cntAnswer);
for (long long i = 1; i <= cntAnswer; i++) printf("%lld ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double g = 10.0, eps = 1e-7;
const int N = 300000 + 10, maxn = 60 + 10, inf = 0x3f3f3f;
inline void debug() { cout << "fuck" << endl; }
vector<int> v[N];
map<int, int> m[N];
bool vis[N];
bool used[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k, d;
cin >> n >> k >> d;
queue<int> q;
for (int i = 0; i < k; i++) {
int a;
cin >> a;
vis[a] = 1;
q.push(a);
}
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
m[a][b] = m[b][a] = i;
}
vector<int> ans;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = 0; i < v[x].size(); i++) {
if (!vis[v[x][i]]) {
vis[v[x][i]] = 1;
used[m[x][v[x][i]]] = 1;
q.push(v[x][i]);
} else if (!used[m[x][v[x][i]]]) {
ans.push_back(m[x][v[x][i]]);
}
}
}
sort(ans.begin(), ans.end());
ans.erase(unique(ans.begin(), ans.end()), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long po(long long a, long long b) {
long long x = 1, y = a;
while (b > 0) {
if (b % 2) {
x = x * y;
x %= 1000000007;
}
y = y * y;
y %= 1000000007;
b /= 2;
}
return x;
}
static vector<int> adj[500005];
int main() {
if (0) {
freopen("C:/Users/gold/Desktop/sublime IO/input.txt", "r", stdin);
freopen("C:/Users/gold/Desktop/sublime IO/output.txt", "w", stdout);
}
int T = 1;
while (T--) {
int n, k, d;
scanf("%d %d %d", &n, &k, &d);
static bool v[500005];
queue<pair<int, pair<int, int> > > q;
for (int i = 0; i < k; i++) {
int x;
scanf("%d", &x);
q.push(make_pair(x, make_pair(0, -1)));
v[x] = true;
}
vector<pair<int, int> > e;
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
e.push_back(make_pair(u, v));
}
map<pair<int, int>, bool> dp;
while (!q.empty()) {
pair<int, pair<int, int> > tmp = q.front();
q.pop();
dp[make_pair(tmp.first, tmp.second.second)] =
dp[make_pair(tmp.second.second, tmp.first)] = true;
if (tmp.second.first == d) {
continue;
}
int cur = tmp.first;
for (int i = 0; i < adj[cur].size(); i++) {
if (v[adj[cur][i]] == 0) {
q.push(make_pair(adj[cur][i], make_pair(tmp.second.first + 1, cur)));
v[adj[cur][i]] = true;
}
}
}
vector<int> ans;
for (int i = 0; i < e.size(); i++) {
if (dp[e[i]]) {
continue;
} else
ans.push_back(i + 1);
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) {
printf("%d ", ans[i]);
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > adj[300005];
bool vis[300005];
set<int> s;
queue<int> q;
void bfs() {
while (q.size()) {
int v = q.front();
q.pop();
for (auto u : adj[v]) {
if (!vis[u.first]) {
vis[u.first] = true;
s.erase(u.second);
q.push(u.first);
}
}
}
}
int main() {
int n, k, d;
cin >> n >> k >> d;
for (int i = 1; i <= k; i++) {
int a;
cin >> a;
q.push(a);
vis[a] = true;
}
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back({b, i});
adj[b].push_back({a, i});
s.insert(i);
}
bfs();
cout << s.size() << endl;
for (auto u : s) cout << u << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300007;
int p[N];
bool visited[N];
bool roads[N];
vector<int> ans;
int n, k, d;
vector<pair<int, int> > v[N];
queue<int> Q;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
memset(visited, 0, sizeof(visited));
memset(roads, 0, sizeof(roads));
cin >> n >> k >> d;
int use, c1, c2;
for (int i = 1; i <= k; i++) {
cin >> use;
visited[use] = 1;
p[use] = use;
Q.push(use);
}
for (int i = 1; i <= n - 1; i++) {
cin >> c1 >> c2;
v[c1].push_back({c2, i});
v[c2].push_back({c1, i});
}
while (!Q.empty()) {
int c = Q.front();
Q.pop();
for (int i = 0; i < v[c].size(); i++) {
if (!visited[v[c][i].first]) {
visited[v[c][i].first] = 1;
p[v[c][i].first] = p[c];
Q.push(v[c][i].first);
} else if (p[v[c][i].first] != p[c] && !roads[v[c][i].second]) {
roads[v[c][i].second] = 1;
ans.push_back(v[c][i].second);
}
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
}
|
#include <bits/stdc++.h>
const int MX = 300005;
using namespace std;
int n, k, d;
vector<pair<int, int> > v[MX];
int police[MX];
vector<int> ans;
int visit[MX];
int used[MX];
void bfs() {
deque<pair<int, int> > q;
for (int i = 1; i <= n; i++) {
if (police[i] == 1) {
q.push_back(make_pair(i, -1));
visit[i] = 1;
}
}
while (!q.empty()) {
pair<int, int> nod = q.front();
q.pop_front();
for (int i = 0; i < (int)(v[nod.first].size()); i++) {
int id = v[nod.first][i].first;
int nn = v[nod.first][i].second;
if (nod.second == nn) continue;
if (!visit[nn]) {
used[id] = 1;
visit[nn] = 1;
q.push_back(make_pair(nn, nod.first));
}
}
}
}
int main() {
cin >> n >> k >> d;
for (int i = 0; i < k; i++) {
int x;
cin >> x;
police[x] = 1;
}
for (int i = 1; i <= n - 1; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(make_pair(i, y));
v[y].push_back(make_pair(i, x));
}
bfs();
for (int i = 1; i <= n - 1; i++) {
if (used[i] == 0) {
ans.push_back(i);
}
}
cout << ans.size() << endl;
for (int i = 0; i < (int)(ans.size()); i++) {
cout << ans[i] << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:225450978")
#pragma GCC optimize("Ofast")
using namespace std;
const long long Mod = 1000000007LL, INF = 1e9, LINF = 1e18;
const long double Pi = 3.141592653589793116, EPS = 1e-9,
Gold = ((1 + sqrt(5)) / 2);
long long keymod[] = {1000000007LL, 1000000009LL, 1000000021LL, 1000000033LL};
long long keyCount = sizeof(keymod) / sizeof(long long);
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcountll(s);
}
auto TimeStart = chrono::steady_clock::now();
auto TimeEnd = chrono::steady_clock::now();
void ControlIO(int argc, char* argv[]);
void TimerStart();
void TimerStop();
void Exit();
string cppstr_infile = "FILE.IN";
string cppstr_outfile = "FILE.OUT";
long long n, k, d, p, u, v;
set<long long> P;
vector<vector<long long> > adj;
map<pair<long long, long long>, long long> id;
void Input() {
cin >> n >> k >> d;
adj.resize(n);
while (k--) {
cin >> p;
p--;
P.insert(p);
}
for (long long i = 1; i < n; i++) {
cin >> u >> v;
u--;
v--;
id[make_pair(u, v)] = i;
id[make_pair(v, u)] = i;
adj[u].push_back(v);
adj[v].push_back(u);
}
}
void Solve() {
queue<long long> Q;
vector<bool> vis(n, false), used(n, false);
long long deleted = n - 1;
for (auto it = P.begin(); it != P.end(); it++) {
p = *it;
vis[p] = true;
Q.push(p);
}
while (!Q.empty()) {
long long z = Q.front();
Q.pop();
for (auto t : adj[z]) {
if (vis[t]) continue;
deleted = deleted - 1;
used[id[make_pair(z, t)]] = true;
Q.push(t);
vis[t] = true;
}
}
cout << deleted << '\n';
for (long long i = 1; i < n; i++) {
if (!used[i]) cout << i << " ";
}
cout << '\n';
}
int main(int argc, char* argv[]) {
ControlIO(argc, argv);
ios_base::sync_with_stdio(0);
cin.tie(NULL);
Input();
TimerStart();
Solve();
TimerStop();
return 0;
}
void ControlIO(int argc, char* argv[]) {
char* infile = new char[cppstr_infile.size() + 1];
char* outfile = new char[cppstr_outfile.size() + 1];
strcpy(infile, cppstr_infile.c_str());
strcpy(outfile, cppstr_outfile.c_str());
}
void TimerStart() {}
void TimerStop() {}
void Exit() {
TimerStop();
exit(0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 5e5 + 10;
vector<pair<int, int>> v[N];
int vis[N], vv[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, d;
cin >> n >> m >> d;
queue<int> qu;
for (int i = 0; i < m; i++) {
int a;
cin >> a;
vis[a] = 1;
qu.push(a);
}
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
v[a].push_back({b, i + 1});
v[b].push_back({a, i + 1});
}
set<int> ans;
while (!qu.empty()) {
int x = qu.front();
qu.pop();
for (auto it : v[x]) {
if (vv[it.second]) continue;
vv[it.second] = 1;
if (vis[it.first]) {
ans.insert(it.second);
continue;
}
vis[it.first] = 1;
qu.push(it.first);
}
}
cout << ans.size() << "\n";
for (auto it : ans) cout << it << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int to, val, id;
};
vector<node> g[300100];
vector<int> ans;
queue<int> q;
bool vis[300100], way[300100];
void bfs() {
while (!q.empty()) {
int u = q.front();
q.pop();
int sz = g[u].size();
for (int i = 0; i < sz; i++) {
int v = g[u][i].to;
if (!vis[v]) {
vis[v] = 1;
way[g[u][i].id] = 1;
q.push(v);
}
}
}
}
int main() {
int n, k, d;
while (~scanf("%d%d%d", &n, &k, &d)) {
for (int i = 1; i <= n; i++) {
g[i].clear();
way[i] = vis[i] = 0;
}
ans.clear();
for (int i = 0; i < k; i++) {
int x;
scanf("%d", &x);
q.push(x);
vis[x] = 1;
}
for (int i = 1; i <= n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back({v, 1, i});
g[v].push_back({u, 1, i});
}
bfs();
for (int i = 1; i <= n - 1; i++) {
if (!way[i]) ans.push_back(i);
}
int sz = ans.size();
printf("%d\n", sz);
for (int i = 0; i < sz; i++) {
if (i == 0)
printf("%d", ans[i]);
else
printf(" %d", ans[i]);
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e5 + 5;
int n, k, d, cnt = 0;
bool vis[maxn];
bool edgevis[maxn];
vector<int> added;
struct edge {
int to;
int id;
};
vector<edge> ee[maxn];
struct node {
int p;
int step;
};
queue<node> q;
void bfs() {
while (!q.empty()) {
node st = q.front();
int np = st.p, nstep = st.step;
q.pop();
if (nstep > d) continue;
for (int i = 0; i < (int)ee[np].size(); ++i) {
edge tt = ee[np][i];
int nto = tt.to, nid = tt.id;
if (!vis[nto]) {
vis[nto] = true;
edgevis[nid] = true;
++cnt;
q.push(node{nto, nstep + 1});
}
}
}
}
int main() {
scanf("%d%d%d", &n, &k, &d);
memset(vis, false, sizeof(vis));
memset(edgevis, false, sizeof(edgevis));
int tmp;
for (int i = 1; i <= k; ++i) {
scanf("%d", &tmp);
q.push(node{tmp, 0});
vis[tmp] = true;
}
int x, y;
for (int i = 1; i <= n - 1; ++i) {
scanf("%d%d", &x, &y);
ee[x].push_back(edge{y, i});
ee[y].push_back(edge{x, i});
}
bfs();
cout << n - 1 - cnt << endl;
for (int i = 1; i <= n - 1; ++i) {
if (edgevis[i] == false) {
cout << i << ' ';
}
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2010;
const long long INF = 1e18;
long long modularExponentiation(long long x, long long n, long long M) {
long long result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % M;
x = (x * x) % M;
n = n / 2;
}
return result;
}
long long modInverse(long long A, long long M) {
return modularExponentiation(A, M - 2, M);
}
long long comb(long long x) {
return ((x) * (x - (long long)1) * (x - (long long)2)) / (long long)6;
}
stack<long long> mys;
long long a[maxn];
map<int, int> mp;
void init(long long n, int i) {
mp.clear();
while (!mys.empty()) {
mys.pop();
}
for (int j = 0; j < 2 * n; j++) {
if ((j < 2 * n - 1) and (j != i)) mys.push(a[j]);
mp[a[j]]++;
}
}
int main() {
int n, k, d;
cin >> n >> k >> d;
set<int> p;
for (int i = 0; i < k; i++) {
int x;
cin >> x;
p.insert(x);
}
set<int>::iterator it;
vector<int> adj[n + 1];
map<pair<int, int>, int> mp;
int c = 1;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
mp[{u, v}] = c;
mp[{v, u}] = c;
c++;
adj[u].push_back(v);
adj[v].push_back(u);
}
queue<pair<int, int> > q;
int inf = 1e7 + 50;
vector<bool> v;
for (int i = 0; i < n + 1; i++) {
v.push_back(false);
}
for (it = p.begin(); it != p.end(); it++) {
q.push({*it, 0});
}
int numberof = 0;
vector<int> roads;
while (!q.empty()) {
pair<int, int> popo = q.front();
q.pop();
if (v[popo.first]) {
continue;
}
v[popo.first] = true;
for (int i = 0; i < adj[popo.first].size(); i++) {
if (adj[popo.first][i] != popo.second) {
if (!v[adj[popo.first][i]]) {
q.push({adj[popo.first][i], popo.first});
} else {
numberof++;
roads.push_back(mp[{popo.first, adj[popo.first][i]}]);
}
}
}
}
cout << numberof << endl;
for (int i = 0; i < numberof; i++) {
cout << roads[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxN = 3 * 100 * 1000 + 5;
vector<int> g[mxN];
int vis[mxN];
void solve() {
int n, k, d;
cin >> n >> k >> d;
queue<int> q;
for (int i = 0; i < k; i++) {
int p;
cin >> p;
p--;
if (!vis[p]) {
vis[p] = 1;
q.push(p);
}
}
map<pair<int, int>, int> mp;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
mp[{min(u, v), max(u, v)}] = i;
g[u].push_back(v);
g[v].push_back(u);
}
set<int> ans;
vector<int> par(n);
while ((int)q.size()) {
int sz = q.size();
while (sz--) {
int cur;
cur = q.front();
q.pop();
for (auto to : g[cur]) {
if (vis[to]) {
if (to != par[cur]) ans.insert(mp[{min(cur, to), max(cur, to)}]);
} else {
par[to] = cur;
vis[to] = 1;
q.push({to});
}
}
}
}
cout << (int)ans.size() << endl;
for (auto edge : ans) {
cout << edge << " ";
}
cout << endl;
}
int query = 0;
int main() {
int q = 1;
if (query) cin >> q;
while (q--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
vector<int> E[MAXN];
map<pair<int, int>, bool> iskey;
queue<int> q;
int N, K, D, dis[MAXN], ans = 0;
pair<int, int> e[MAXN];
int main() {
scanf("%d%d%d", &N, &K, &D);
memset(dis, 0x3f, sizeof(dis));
for (int i = 1; i <= K; i++) {
int p;
scanf("%d", &p);
dis[p] = 0;
q.push(p);
}
for (int i = 1; i <= N - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
E[x].push_back(y);
E[y].push_back(x);
if (x > y) swap(x, y);
e[i] = make_pair(x, y);
}
while (!q.empty()) {
int node = q.front();
q.pop();
for (int i = 0; i <= (int)E[node].size() - 1; i++) {
if (dis[E[node][i]] > D) {
dis[E[node][i]] = dis[node] + 1;
q.push(E[node][i]);
iskey[make_pair(min(node, E[node][i]), max(node, E[node][i]))] = 1;
}
}
}
for (int i = 1; i <= N - 1; i++)
if (!iskey[e[i]]) ans++;
cout << ans << endl;
for (int i = 1; i <= N - 1; i++)
if (!iskey[e[i]]) {
printf("%d ", i);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long i, j, cnt = 1;
int ar[300050];
vector<int> vt[300050];
int vi[300050];
pair<int, int> pth[300050];
int pos[300050];
int tv[300050];
bool cmp(int a, int b) { return pth[a] < pth[b]; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k, d, b;
queue<pair<int, int> > q;
cin >> n >> k >> d;
for (i = 0; i < k; i++) {
cin >> b;
if (!vi[b]) q.push({b, 0}), vi[b] = 1;
}
for (i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
vt[u].push_back(v), vt[v].push_back(u);
pth[cnt++] = {min(u, v), max(u, v)};
}
for (i = 1; i < n; i++) pos[i] = i;
sort(pos + 1, pos + n, cmp);
sort(pth + 1, pth + n);
while (!q.empty()) {
pair<int, int> tip = q.front();
q.pop();
if (tip.second < d) {
for (auto it : vt[tip.first]) {
if (!vi[it]) {
q.push({it, tip.second + 1}), vi[it] = 1;
int tpos = lower_bound(pth + 1, pth + n,
(pair<int, int>){min(it, tip.first),
max(it, tip.first)}) -
pth;
tv[tpos] = 1;
}
}
}
}
cnt = 0;
for (i = 1; i < n; i++)
if (!tv[i]) cnt++;
cout << cnt << '\n';
for (i = 1; i < n; i++) {
if (!tv[i]) {
cout << pos[i] << (cnt - 1 ? ' ' : '\n');
}
}
return ~~(0 ^ 0 ^ 0);
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int N = 3e5 + 5;
vector<pair<int, int>> g[N];
int d[N], u[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, h;
cin >> n >> m >> h;
vector<int> q;
fill(d, d + N, 1e9);
for (int i = 0; i < m; ++i) {
int v;
cin >> v;
if (!u[v]) q.push_back(v);
u[v] = 1;
d[v] = 0;
}
for (int k = 1; k < n; ++k) {
int i, j;
cin >> i >> j;
g[i].push_back({j, k});
g[j].push_back({i, k});
}
set<int> ok;
for (int k = 0; k < q.size(); ++k) {
int v = q[k];
for (auto p : g[v]) {
int i = p.first;
if (d[i] > d[v] + 1) {
d[i] = d[v] + 1;
u[i] = 1;
q.push_back(i);
ok.insert(p.second);
}
}
}
cout << n - 1 - ok.size() << endl;
for (int i = 1; i < n; ++i)
if (!ok.count(i)) cout << i << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> edges;
vector<int> g[300001];
int police[300001];
int nearest[300001];
int stat[300001];
void dfs1(int beta, int baap) {
int mini = (police[beta] ? 0 : (int)1e9), minpos = (police[beta] ? beta : -1);
for (int i = 0; i < g[beta].size(); i++) {
int pota = g[beta][i];
if (pota == baap) continue;
dfs1(pota, beta);
if (mini > 1 + nearest[pota]) {
mini = 1 + nearest[pota];
minpos = stat[pota];
}
}
nearest[beta] = mini;
stat[beta] = minpos;
}
void dfs2(int beta, int baap) {
int up = (baap == -1 ? (int)1e9 : 1 + nearest[baap]);
if (up < nearest[beta]) {
nearest[beta] = up;
stat[beta] = stat[baap];
}
for (int i = 0; i < g[beta].size(); i++) {
int pota = g[beta][i];
if (pota == baap) continue;
dfs2(pota, beta);
}
}
int main() {
int n, k, d;
scanf("%d %d %d", &n, &k, &d);
for (int i = 0; i < k; i++) {
int x;
scanf("%d", &x);
police[x] = 1;
}
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d %d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
edges.push_back(make_pair(x, y));
}
dfs1(1, -1);
dfs2(1, -1);
vector<int> ans;
for (int i = 0; i < n - 1; i++) {
int u = edges[i].first, v = edges[i].second;
if (stat[u] != stat[v]) ans.push_back(i + 1);
}
printf("%d\n", (int)ans.size());
for (int i = 0; i < ans.size(); i++) {
printf("%d ", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int MAXN = 3e5 + 100;
int v[MAXN], res[MAXN];
queue<pair<int, int> > q;
vector<pair<int, int> > g[MAXN];
void solve() {
int n, k, d;
cin >> n >> k >> d;
for (int i = 0; i < k; i++) {
int ok;
cin >> ok;
q.push({ok, 0});
}
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
g[u].push_back({v, i + 1});
g[v].push_back({u, i + 1});
}
while (!q.empty()) {
int l, r;
l = q.front().first;
r = q.front().second;
q.pop();
if (v[l]) continue;
v[l] = 1;
for (int i = 0; i < (int)g[l].size(); i++)
if (g[l][i].first != r) {
if (v[g[l][i].first])
res[g[l][i].second] = 1;
else
q.push({g[l][i].first, l});
}
}
int ans = 0;
for (int i = 1; i < n; i++)
if (res[i]) ans++;
cout << ans << endl;
for (int i = 1; i < n; i++)
if (res[i]) cout << i << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t = 1;
while (t--) {
solve();
}
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
vector<int> G[300050];
queue<pair<int, int>> q;
int vis[300050], color, ans[300050], anscnt, u[300050], v[300050];
int main() {
int n = read(), k = read(), d = read();
for (int i = 1; i <= k; i++) {
int p = read();
if (!vis[p]) {
q.push({p, ++color});
vis[p] = color;
}
}
for (int i = 1; i < n; i++) {
u[i] = read(), v[i] = read();
G[u[i]].push_back(v[i]);
G[v[i]].push_back(u[i]);
}
while (!q.empty()) {
auto u = q.front();
q.pop();
for (int i = 0; i < G[u.first].size(); i++) {
int v = G[u.first][i];
if (!vis[v]) {
vis[v] = u.second;
q.push({v, vis[v]});
}
}
}
for (int i = 1; i < n; i++) {
if (vis[u[i]] != vis[v[i]]) ans[++anscnt] = i;
}
cout << anscnt << endl;
for (int i = 1; i <= anscnt; i++) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 6e+5 + 50;
vector<pair<int, int> > g[MAXN];
int vis[MAXN];
int n, k, d;
queue<pair<int, int> > q;
int ans;
int mk[MAXN];
void bfs() {
while (!q.empty()) {
int pos = q.front().first, from = q.front().second;
q.pop();
if (vis[pos]) continue;
vis[pos] = 1;
for (int i = 0; i < g[pos].size(); i++) {
int temp = g[pos][i].first, id = g[pos][i].second;
if (temp != from) {
if (vis[temp]) {
mk[id] = 1;
ans++;
} else {
q.push(make_pair(temp, pos));
}
}
}
}
}
int main(int argc, char *argv[]) {
while (cin >> n >> k >> d) {
for (int i = 0; i <= n; i++) {
g[i].clear();
}
while (!q.empty()) {
q.pop();
}
memset(vis, 0, sizeof(vis));
memset(mk, 0, sizeof(mk));
ans = 0;
int pos;
for (int i = 1; i <= k; i++) {
scanf("%d", &pos);
q.push(make_pair(pos, 0));
}
int from, to;
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d", &from, &to);
g[from].push_back(make_pair(to, i));
g[to].push_back(make_pair(from, i));
}
bfs();
cout << ans << endl;
for (int i = 1; i <= n - 1; i++)
if (mk[i]) cout << i << ' ';
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
int zf = 1;
char ch = ' ';
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') zf = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * zf;
}
struct Edge {
int to, next;
} edges[600005];
int head[300005], edge_num = 0;
void addEdge(int from, int to) {
edges[++edge_num] = (Edge){to, head[from]};
head[from] = edge_num;
}
struct Node {
int id;
int clr;
};
queue<Node> que;
int vis[300005];
int ans[300005], ans_num = 0;
void BFS() {
Node u;
while (!que.empty()) {
u = que.front(), que.pop();
for (int c_e = head[u.id]; c_e; c_e = edges[c_e].next) {
int v = edges[c_e].to;
if (!vis[v]) {
vis[v] = u.clr;
que.push((Node){v, u.clr});
}
}
}
}
int u[300005], v[300005];
int main() {
int n = read(), k = read(), d = read();
int clr = 0, kk = 0;
for (int i = 1; i <= k; ++i) {
int pol = read();
if (!vis[pol]) {
++kk;
que.push((Node){pol, ++clr});
vis[pol] = clr;
}
}
for (int i = 1; i < n; ++i) {
u[i] = read(), v[i] = read();
addEdge(u[i], v[i]), addEdge(v[i], u[i]);
}
BFS();
for (int i = 1; i < n; ++i)
if (vis[u[i]] != vis[v[i]]) ans[++ans_num] = i;
printf("%d\n", ans_num);
for (int i = 1; i <= ans_num; ++i) {
if (i != 1) printf(" ");
printf("%d", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 10;
vector<int> G[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k, d;
cin >> n >> k >> d;
set<int> S;
pair<int, int> E[n];
for (int i = 0; i < k; i++) {
int p;
cin >> p;
S.insert(p);
}
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
E[i] = {u, v};
}
queue<int> Q;
int V[n + 1];
memset(V, 0, sizeof(V));
for (auto u : S) {
Q.push(u);
V[u] = u;
}
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int v : G[u]) {
if (!V[v]) {
V[v] = V[u];
Q.push(v);
}
}
}
vector<int> A;
for (int i = 0; i < n - 1; i++) {
int a = E[i].first;
int b = E[i].second;
if (V[a] != V[b]) {
A.push_back(i + 1);
}
}
if (A.size() != S.size() - 1) {
cout << "Sad:(\n";
}
cout << A.size() << "\n";
for (auto u : A) {
cout << u << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e6 + 7;
int n, k, d, u, v, x, y, p[N], protection[N];
vector<int> graph[N], ans;
pair<int, int> edges[N];
queue<int> q;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k >> d;
for (int i = 1; i <= (int)k; i++) {
cin >> x;
if (p[x]) continue;
p[x] = 1;
protection[x] = x;
q.push(x);
}
for (int i = 1; i <= (int)n - 1; i++) {
cin >> u >> v;
graph[u].push_back(v);
graph[v].push_back(u);
edges[i] = {u, v};
}
while (!q.empty()) {
x = q.front();
q.pop();
for (auto y : graph[x]) {
if (!protection[y]) {
protection[y] = protection[x];
q.push(y);
}
}
}
for (int i = 1; i <= (int)n - 1; i++) {
if (protection[edges[i].first] != protection[edges[i].second]) {
ans.push_back(i);
}
}
cout << ans.size() << endl;
for (auto x : ans) {
cout << x << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct canh {
int v, id;
};
int n, m, d;
int p[300001];
vector<canh> a[300001];
int k[300001];
bool f[300001];
void nhap() {
scanf("%d%d%d", &n, &m, &d);
canh tam;
for (int i = 1; i <= m; i++) scanf("%d", &p[i]);
for (int i = 1; i <= n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
tam.v = v;
tam.id = i;
a[u].push_back(tam);
swap(tam.v, u);
a[u].push_back(tam);
}
}
void bfs() {
queue<int> q;
for (int i = 1; i <= n; i++) k[i] = -1;
for (int i = 1; i <= m; i++) {
q.push(p[i]);
k[p[i]] = 0;
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (vector<canh>::iterator i = a[u].begin(); i != a[u].end(); i++) {
canh v = *i;
if (k[v.v] == -1 && k[u] + 1 <= d) {
k[v.v] = k[u] + 1;
q.push(v.v);
f[v.id] = true;
}
}
}
vector<int> t;
int dem = 0;
for (int i = 1; i < n; i++) {
if (!f[i]) {
dem++;
t.push_back(i);
}
}
cout << dem << "\n";
for (int i = 0; i < t.size(); i++) {
cout << t[i] << " ";
}
}
int main() {
nhap();
bfs();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long int LINF = 0x3f3f3f3f3f3f3f3fll;
const long double pi = acos(-1);
const int MOD = 1e9 + 9;
const int N = 3e5 + 10;
int n, k, d, qual[N];
vector<int> g[N];
vector<int> pol;
vector<pair<int, int> > ed;
void process() {
queue<pair<int, int> > q;
for (int x : pol) {
q.push(make_pair(x, x)), qual[x] = x;
}
while (!q.empty()) {
pair<int, int> y = q.front();
q.pop();
for (int v : g[y.first]) {
if (!qual[v]) {
qual[v] = y.second;
q.push(make_pair(v, qual[v]));
}
}
}
}
int main() {
scanf("%d%d%d", &n, &k, &d);
for (int i = 0; i < k; i++) {
int x;
scanf("%d", &x);
pol.push_back(x);
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
ed.push_back(make_pair(u, v));
}
process();
vector<int> resp;
for (int i = 0; i < ed.size(); i++) {
int u = ed[i].first;
int v = ed[i].second;
if (qual[u] != qual[v]) resp.push_back(i + 1);
}
cout << resp.size() << endl;
for (int x : resp) printf("%d ", x);
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
queue<pair<int, int>> q;
vector<pair<int, int>> way[300005];
int v[300005];
int res[300005];
int main() {
int n, k, d;
scanf("%d%d%d", &n, &k, &d);
for (int i = 0; i < k; i++) {
int p;
scanf("%d", &p);
q.push({p, 0});
}
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
way[u].push_back({v, i + 1});
way[v].push_back({u, i + 1});
}
while (!q.empty()) {
int pos = q.front().first;
int from = q.front().second;
q.pop();
if (v[pos]) continue;
v[pos] = 1;
for (int i = 0; i < way[pos].size(); i++)
if (way[pos][i].first != from) {
if (v[way[pos][i].first])
res[way[pos][i].second] = 1;
else
q.push({way[pos][i].first, pos});
}
}
int rescnt = 0;
for (int i = 1; i <= n - 1; i++)
if (res[i]) rescnt++;
printf("%d\n", rescnt);
for (int i = 1; i <= n - 1; i++)
if (res[i]) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
const int N = (int)3e5 + 228;
using namespace std;
int n, k, l, d[N], p[N], pr[N];
bool was[N];
vector<pair<int, int> > g[N];
set<int> st;
queue<int> q;
int main() {
scanf("%d%d%d", &n, &k, &l);
for (int i = 1; i <= n; i++) {
d[i] = -1;
}
for (int i = 1; i <= k; i++) {
int v;
scanf("%d", &v);
if (!was[v]) q.push(v);
d[v] = 0;
was[v] = true;
}
for (int i = 1; i < n; i++) {
int v, u;
scanf("%d%d", &v, &u);
g[v].push_back({u, i});
g[u].push_back({v, i});
}
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 0; i < (int)g[v].size(); i++) {
int to = g[v][i].first;
if (d[to] == -1) {
d[to] = d[v] + 1;
pr[to] = v;
q.push(to);
} else {
if (pr[v] != to) {
st.insert(g[v][i].second);
}
}
}
}
printf("%d\n", (int)st.size());
for (auto to : st) {
printf("%d ", to);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
int power(long long int n, long long int y) {
long long int res = 1;
n = n % mod;
if (n == 0) {
return 0;
}
while (y > 0) {
if (y & 1) res = (res * n) % mod;
y = y >> 1;
n = (n * n) % mod;
}
return res;
}
void solve() {
long long int n, k, d;
cin >> n >> k >> d;
vector<vector<vector<long long int>>> v(n + 1);
vector<int> dis(n + 1, 1e9);
vector<int> vis(n + 1, 0);
vector<int> colour(n, -1);
queue<int> q;
for (int i = 1; i <= k; i++) {
int x;
cin >> x;
q.push(x);
vis[x] = 1;
dis[x] = 0;
}
for (int i = 1; i <= n - 1; i++) {
int a, b;
cin >> a >> b;
v[a].push_back({b, i});
v[b].push_back({a, i});
}
while (!q.empty()) {
int temp = q.front();
q.pop();
for (auto it : v[temp]) {
int r = it[0], idx = it[1];
if (!vis[r]) {
vis[r] = 1;
colour[idx] = 1;
q.push(r);
}
}
}
vector<int> ans;
for (int i = 1; i <= n - 1; i++) {
if (colour[i] == -1) {
ans.push_back(i);
}
}
cout << ans.size() << endl;
for (auto it : ans) {
cout << it << " ";
}
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, d, u, res;
int vis[300007];
queue<int> Q;
int a[300007];
int b[300007];
vector<int> G[300007];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> k >> d;
for (int i = 1; i <= k; ++i) {
cin >> u;
if (!vis[u]) {
vis[u] = u;
Q.push(u);
}
}
for (int i = 1; i < n; ++i) {
cin >> a[i] >> b[i];
G[a[i]].push_back(b[i]);
G[b[i]].push_back(a[i]);
}
while (!Q.empty()) {
int v = Q.front();
Q.pop();
for (auto it : G[v]) {
if (!vis[it]) {
vis[it] = vis[v];
Q.push(it);
}
}
}
for (int i = 1; i < n; ++i) {
if (vis[a[i]] != vis[b[i]]) ++res;
}
cout << res << '\n';
for (int i = 1; i < n; ++i) {
if (vis[a[i]] != vis[b[i]]) cout << i << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int from, to;
} E[600010 * 2];
int que[600010], dis[600010], ans, vis[600010 * 2];
int police[600010], edge_cnt, anss[600010];
int n, m, k, ne[600010 * 2], last[600010];
void add(int x, int y) {
E[++edge_cnt].from = x;
E[edge_cnt].to = y;
ne[edge_cnt] = last[x];
last[x] = edge_cnt;
}
void Insert() {
int x, y;
scanf("%d %d", &x, &y);
add(x, y);
add(y, x);
}
void bfs() {
int head = 1, tail = 0;
int u, v;
memset(dis, 0x7f, sizeof(dis));
for (int i = 1; i <= m; i++) {
que[++tail] = police[i];
dis[police[i]] = 0;
}
while (head <= tail) {
u = que[head];
for (int j = last[u]; j; j = ne[j]) {
int v = E[j].to;
if (vis[(j + 1) / 2]) continue;
if (dis[v] > dis[u] + 1) {
vis[(j + 1) / 2] = 1;
dis[v] = dis[u] + 1;
que[++tail] = v;
}
if (dis[v] <= dis[u]) {
vis[(j + 1) / 2] = 1;
anss[++ans] = (j + 1) / 2;
}
}
head++;
}
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) scanf("%d", &police[i]);
for (int i = 1; i <= n - 1; i++) Insert();
bfs();
cout << ans << endl;
for (int i = 1; i <= ans; i++) printf("%d ", anss[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = ~(1 << 31);
const double pi = acos(-1);
vector<int> edg[300020];
set<int> us[300020];
int main() {
cin.sync_with_stdio(false);
int n, k, d;
cin >> n >> k >> d;
int vis[300020];
memset(vis, 0, sizeof(vis));
queue<int> q;
for (int i = (0); i < (k); i++) {
int hold;
cin >> hold;
hold--;
q.push(hold);
vis[hold] = true;
}
vector<pair<int, int> > con;
for (int i = (0); i < (n - 1); i++) {
int a, b;
cin >> a >> b;
a--;
b--;
edg[a].push_back(b);
edg[b].push_back(a);
us[a].insert(b);
us[b].insert(a);
con.push_back(pair<int, int>(a, b));
}
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int i = (0); i < (edg[cur].size()); i++) {
int ne = edg[cur][i];
if (!vis[ne]) {
us[cur].erase(ne);
vis[ne] = true;
q.push(ne);
}
}
}
vector<int> ind;
int cur = -1;
int count = 0;
for (int i = (0); i < (con.size()); i++) {
int a = con[i].first, b = con[i].second;
if (us[a].find(b) != us[a].end() && us[b].find(a) != us[b].end())
ind.push_back(i + 1);
}
cout << ind.size() << endl;
for (int i = (0); i < (ind.size()); i++) cout << ind[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, d, done[300005] = {0};
vector<int> graph[300005];
map<pair<int, int>, int> edge;
set<int> p;
void go() {
queue<pair<int, int> > q;
for (auto it : p) q.push({it, 0});
while (!q.empty()) {
int x = q.front().first, P = q.front().second;
q.pop();
if (done[x]) continue;
done[x] = 1;
for (auto it : graph[x]) {
if (done[it] && it != P)
printf("%d ", edge[{min(x, it), max(x, it)}]);
else if (it != P)
q.push({it, x});
}
}
}
int main() {
scanf("%d", &n);
scanf("%d", &k);
scanf("%d", &d);
for (__typeof(k) i = 0 - (0 > k); i != k - (0 > k); i += 1 - 2 * (0 > k)) {
int x;
scanf("%d", &x);
p.insert(x);
}
for (__typeof(n - 1) i = 0 - (0 > n - 1); i != n - 1 - (0 > n - 1);
i += 1 - 2 * (0 > n - 1)) {
int u, v;
scanf("%d", &u);
scanf("%d", &v);
graph[u].push_back(v);
graph[v].push_back(u);
edge[{min(u, v), max(u, v)}] = i + 1;
}
printf("%d\n", (int)p.size() - 1);
go();
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, map<int, int> > id;
vector<int> p, g[300005];
int vis[300005], flag[300005], pre[300005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k, d;
cin >> n >> k >> d;
for (int i = 1; i <= k; i++) {
int x;
cin >> x;
if (flag[x] == 0) {
p.push_back(x);
flag[x] = 1;
}
}
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
id[x][y] = id[y][x] = i;
g[x].push_back(y);
g[y].push_back(x);
}
set<int> ans;
queue<int> q;
for (int i = 0; i < p.size(); i++) {
q.push(p[i]);
vis[p[i]] = 1;
}
while (!q.empty()) {
int x = q.front();
q.pop();
for (int j = 0; j < g[x].size(); j++) {
int t = g[x][j];
if (vis[t] != 0 && pre[x] != t) {
ans.insert(id[x][t]);
continue;
}
if (vis[t]) continue;
pre[t] = x;
vis[t] = 1;
q.push(t);
}
}
cout << ans.size() << '\n';
set<int>::iterator it;
for (it = ans.begin(); it != ans.end(); it++) {
cout << *it;
if (it == --ans.end())
cout << '\n';
else
cout << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5;
vector<int> adj[N + 1];
vector<pair<int, int> > edges;
int D, color[N + 1], d[N + 1];
bool f[N + 1];
queue<int> Q;
void bfs() {
while (!Q.empty()) {
int u = Q.front();
Q.pop();
if (d[u] == D) continue;
for (int i = (0), i_end = (adj[u].size()); i < i_end; ++i) {
int v = adj[u][i];
if (!color[v]) {
d[v] = d[u] + 1;
color[v] = color[u];
Q.push(v);
}
}
}
}
int main() {
int n, k;
scanf("%d%d%d", &n, &k, &D);
for (int i = (0), i_end = (k); i < i_end; ++i) {
int p;
scanf("%d", &p);
f[p] = true;
}
for (int i = (0), i_end = (n - 1); i < i_end; ++i) {
int u, v;
scanf("%d%d", &u, &v);
edges.push_back(make_pair(u, v));
adj[u].push_back(v);
adj[v].push_back(u);
}
int cnt = 0;
for (int i = (1), i_end = (n + 1); i < i_end; ++i)
if (f[i]) {
Q.push(i);
color[i] = i;
++cnt;
}
bfs();
printf("%d\n", cnt - 1);
int now = 0;
for (int i = (0), i_end = (n - 1); i < i_end; ++i) {
if (color[edges[i].first] != color[edges[i].second]) {
++now;
printf("%d%c", i + 1, " \n"[now == cnt - 1]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
int n, k, d, dist[300000], par[300000], from[300000], to[300000];
set<pair<int, int> > st;
queue<int> q;
vector<int> adjlist[300000];
int main() {
memset((par), (-1), sizeof(par));
for (int(i) = 0; (i) < (300000); (i)++) dist[i] = INF;
scanf("%d %d %d", &n, &k, &d);
for (int(i) = 0; (i) < (k); (i)++) {
int police;
scanf("%d", &police);
police--;
q.push(police);
dist[police] = 0;
}
for (int(i) = 0; (i) < (n - 1); (i)++) {
scanf("%d %d", &from[i], &to[i]);
from[i]--;
to[i]--;
adjlist[from[i]].push_back(to[i]);
adjlist[to[i]].push_back(from[i]);
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto v : adjlist[u]) {
if (dist[v] == INF) {
dist[v] = dist[u] + 1;
par[v] = u;
q.push(v);
}
}
}
for (int(i) = 0; (i) < (n); (i)++) {
if (par[i] != -1) {
st.insert({par[i], i});
}
}
int cnt = 0;
for (int(i) = 0; (i) < (n - 1); (i)++) {
int u = from[i], v = to[i];
if (st.find({u, v}) == st.end() && st.find({v, u}) == st.end()) cnt++;
}
printf("%d\n", cnt);
for (int(i) = 0; (i) < (n - 1); (i)++) {
int u = from[i], v = to[i];
if (st.find({u, v}) == st.end() && st.find({v, u}) == st.end())
printf("%d ", i + 1);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, d, pred[400000];
vector<pair<int, int> > a[400000];
vector<int> ans;
bool b[400000], rebr[400000];
queue<int> q;
int main() {
ios_base::sync_with_stdio(false);
int i, x, y;
cin >> n >> k >> d;
for (i = 1; i <= n; i++) {
b[i] = false;
rebr[i] = false;
}
for (i = 1; i <= k; i++) {
cin >> x;
if (!b[x]) {
b[x] = true;
q.push(x);
}
}
for (i = 1; i < n; i++) {
cin >> x >> y;
a[x].push_back(make_pair(y, i));
a[y].push_back(make_pair(x, i));
}
while (!q.empty()) {
int v = q.front();
q.pop();
for (i = 0; i < a[v].size(); i++) {
int to = a[v][i].first;
if (b[to]) {
if (to != pred[v] && !rebr[a[v][i].second]) {
ans.push_back(a[v][i].second);
rebr[a[v][i].second] = true;
}
} else {
q.push(to);
pred[to] = v;
b[to] = true;
}
}
}
cout << ans.size() << endl;
for (i = 0; i < ans.size(); i++) cout << ans[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int to, next, v;
} e[600010];
struct Node {
int num, d;
};
int n, k, d, cnt = 1, ans = 0, x, y, head[300010], vis[300010], flg[300010],
res[300010];
queue<Node> q;
void add() {
e[++cnt] = {y, head[x], 0}, head[x] = cnt, e[++cnt] = {x, head[y], 0},
head[y] = cnt;
}
void bfs() {
while (!q.empty()) {
Node u = q.front();
q.pop();
flg[u.num] = 0;
if (u.d > d) continue;
for (int i = head[u.num]; i; i = e[i].next) {
if (e[i].v) continue;
e[i].v = e[i ^ 1].v = 1;
if (vis[e[i].to]) {
res[++ans] = i / 2;
} else if (!flg[e[i].to])
q.push({e[i].to, u.d + 1}), flg[e[i].to] = vis[e[i].to] = 1;
}
}
}
int main() {
scanf("%d%d%d", &n, &k, &d);
for (int i = 1; i <= k; i++) scanf("%d", &x), q.push({x, 0}), vis[x] = 1;
for (int i = 1; i < n; i++) scanf("%d%d", &x, &y), add();
bfs(), printf("%d\n", ans);
for (int i = 1; i <= ans; i++) printf("%d ", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace H_ {
const int N = 300002;
const int M = N * 2;
struct E_ {
int eid, to;
E_ *next;
} arre[M], *arrto[N];
int euse = 0;
int cut[N];
void adde_(int eid, int a, int b) {
arre[euse] = (E_){eid, b, arrto[a]};
arrto[a] = arre + euse++;
}
int dis[N];
int q[N], *l = q, *r = q;
void bfs_() {
while (l != r) {
int c = *l++;
for (E_ *p = arrto[c]; p; p = p->next)
if (dis[p->to] != -1)
++cut[p->eid];
else
dis[ *r++ = p->to] = dis[c] + 1;
}
}
} // namespace H_
int main() {
using namespace H_;
ios::sync_with_stdio(false);
memset(dis, 0xFF, sizeof dis);
int n, k, mxd;
cin >> n >> k >> mxd;
while (k--) {
int c;
cin >> c;
--c;
if (dis[c] == -1) dis[ *r++ = c] = 0;
}
for (int i = 1; i < n; ++i) {
int a, b;
cin >> a >> b;
--a, --b;
adde_(i, a, b);
adde_(i, b, a);
}
bfs_();
int cntcut = 0;
for (int i = 1; i < n; ++i)
if (cut[i] == 2) ++cntcut;
cout << cntcut << '\n';
for (int i = 1; i < n; ++i)
if (cut[i] == 2) cout << i << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 1e18;
const long long int mod = 1e9 + 7;
const long long int MOD = 998244353;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c *x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug &operator<<(const c &) {
return *this;
}
};
vector<char *> tokenizer(const char *args) {
char *token = new char[111];
strcpy(token, args);
token = strtok(token, ", ");
vector<char *> v({token});
while ((token = strtok(NULL, ", "))) v.push_back(token);
return reverse(v.begin(), v.end()), v;
}
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
void debugg(vector<char *> args) { cerr << "\b\b "; }
#pragma clang diagnostic pop
template <typename Head, typename... Tail>
void debugg(vector<char *> args, Head H, Tail... T) {
debug() << " [" << args.back() << ": " << H << "] ";
args.pop_back();
debugg(args, T...);
}
template <typename T>
T power(T a, T b) {
if (b == 0) return 1;
if (b == 1)
return a;
else {
T res = (power(a, b / 2));
if (b % 2) {
return (res * 1LL * res * 1LL * a);
} else {
return res * 1LL * res;
}
}
}
template <typename T>
long long power(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
template <typename T>
T gcd(T a, T b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
inline long long int ceil(long long int a, long long int b) {
return a / b + (a % b == 0 ? 0 : 1);
}
inline bool is_square(long long int x) {
long long int p = sqrt(x);
return p * 1LL * p == x;
}
void factorial(vector<long long int> &fact, long long int n) {
fact.resize(n + 1, 1);
fact[0] = 1;
fact[1] = 1;
for (int i = 2; i <= n; ++i) {
fact[i] = ((fact[i - 1] % mod) * (i % mod)) % mod;
}
}
long long int mod_inv(long long int a) {
return (power<long long int>(a, mod - 2, mod)) % mod;
}
long long int ncr(long long int n, long long int r,
vector<long long int> &fact) {
if (r > n or n < 0 or r < 0) return 0LL;
return (((fact[n] % mod) * (mod_inv(fact[n - r]) % mod)) % mod *
(mod_inv(fact[r]) % mod)) %
mod;
}
long long int NCR(long long int n, long long int r, vector<long long int> &fact,
vector<long long int> &inv) {
if (r > n or n < 0 or r < 0) return 0LL;
return (((fact[n] % mod) * (inv[n - r]))) % mod * (inv[r]) % mod;
}
void modI(vector<long long int> &inv, long long int n,
vector<long long int> &fact) {
inv.resize(n + 1, 1);
inv[n] = mod_inv(fact[n]);
for (int i = n - 1; i >= 0; --i) {
inv[i] = ((inv[i + 1]) % mod * ((i + 1) % mod)) % mod;
}
}
template <typename T>
class Segtree {
public:
int n;
vector<T> seg;
T ID;
Segtree(int _n, T _id) {
n = _n;
ID = _id;
seg.assign(2 * n, ID);
}
T comb(T a, T b) { return min(a, b); }
void pull(int p) { seg[p] = comb(seg[2 * p], seg[2 * p + 1]); }
void update(int idx, T val) {
seg[idx += n] = val;
for (idx /= 2; idx; idx /= 2) pull(idx);
}
T query(int l, int r) {
T lnode = ID, rnode = ID;
for (l += n, r += n + 1; l < r; l /= 2, r /= 2) {
if (l & 1) lnode = comb(lnode, seg[l++]);
if (r & 1) rnode = comb(rnode, seg[--r]);
}
return comb(lnode, rnode);
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, k, d;
cin >> n >> k >> d;
vector<long long int> p(k - 1 + 1);
for (auto i = 0; i <= k - 1; i++) {
cin >> p[i];
};
vector<vector<pair<long long int, long long int>>> g(n + 1);
for (int i = 1; i <= n - 1; ++i) {
long long int u, v;
cin >> u >> v;
g[u].emplace_back(pair<long long int, long long int>{v, i});
g[v].emplace_back(pair<long long int, long long int>{u, i});
}
vector<long long int> cnt(n);
queue<pair<long long int, long long int>> q;
bitset<300009> vis;
for (auto &i : p) {
q.push(pair<long long int, long long int>{i, 0});
vis[i] = 1;
{};
}
while (!q.empty()) {
long long int t = q.front().first;
long long int f = q.front().second;
q.pop();
for (auto &[a, b] : g[t]) {
if (!vis[a]) {
vis[a] = 1;
q.push(pair<long long int, long long int>{a, b});
cnt[b]++;
}
}
}
long long int ans = 0;
{};
for (int i = 1; i <= n - 1; ++i) {
if (!cnt[i]) ans++;
}
cout << ((ans)) << "\n";
;
for (int i = 1; i <= n - 1; ++i) {
if (!cnt[i]) cout << i << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
int n, k, d;
int dist[N];
int color[N];
vector<int> adj[N];
map<pair<int, int>, int> id;
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(dist, -1, sizeof(dist));
cin >> n >> k >> d;
queue<int> Q;
while (k--) {
int p;
cin >> p;
dist[p] = 0;
Q.push(p);
}
for (int i = 1; i <= n; i++) color[i] = i;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
id[make_pair(min(x, y), max(x, y))] = i + 1;
}
while (!Q.empty()) {
int x = Q.front();
Q.pop();
if (1 + dist[x] > d) continue;
for (int i = 0; i < (int)adj[x].size(); i++) {
int y = adj[x][i];
if (dist[y] == -1) {
dist[y] = 1 + dist[x];
Q.push(y);
color[y] = color[x];
}
}
}
set<int> edges;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (int)adj[i].size(); j++) {
if (color[i] != color[adj[i][j]]) {
edges.insert(id[make_pair(min(i, adj[i][j]), max(i, adj[i][j]))]);
}
}
}
cout << (int)edges.size() << endl;
for (auto e : edges) cout << e << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { cin >> x; }
void _R(int64_t &x) { cin >> x; }
void _R(double &x) { cin >> x; }
void _R(long double &x) { cin >> x; }
void _R(char &x) { cin >> x; }
void _R(char *x) { cin >> x; }
void _R(string &x) { cin >> x; }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { cout << x; }
void _W(const int64_t &x) { cout << x; }
void _W(const double &x) { cout << fixed << setprecision(8) << x; }
void _W(const long double &x) { cout << fixed << setprecision(16) << x; }
void _W(const char &x) { cout << x; }
void _W(const char *x) { cout << x; }
void _W(const string &x) { cout << x; }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.first);
cout << ' ';
_W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) cout << ' ';
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
cout << (sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
void solve() {
int n, k, d;
R(n, k, d);
vector<pair<int, int> > g[n + 1];
vector<bool> used(n, false);
vector<int> dist(n + 1);
vector<bool> vis(n + 1, false);
for (int i = (0); i < (k); i++) {
int ps;
R(ps);
vis[ps] = true;
dist[ps] = 0;
}
for (int i = (1); i < (n); i++) {
int u, v;
R(u, v);
g[u].push_back({v, i});
g[v].push_back({u, i});
}
queue<int> q;
for (int i = (1); i < (n + 1); i++) {
if (vis[i]) q.push(i);
}
while (!q.empty()) {
int u = q.front();
q.pop();
if (dist[u] >= d) {
continue;
}
for (auto to : g[u]) {
if (!vis[to.first]) {
dist[to.first] = dist[u] + 1;
vis[to.first] = true;
q.push(to.first);
used[to.second] = true;
}
}
}
int cnt = 0;
for (int i = (1); i < (n); i++) {
if (!used[i]) cnt++;
}
W(cnt);
for (int i = (1); i < (n); i++) {
if (!used[i]) {
cout << i << ' ';
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
for (int testcase = 1; testcase <= t; testcase++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double Pi = 3.14159265359;
const long long MOD = 1000 * 1000 * 1000 + 7;
const long long N = 3e5 + 10;
const long long INF = 1e18;
long long n, v, u, k, d;
set<long long> st;
long long dis[N];
vector<pair<long long, long long> > g[N];
long long ans[N];
void BFS() {
queue<long long> q;
for (auto u : st) q.push(u);
while (q.size()) {
long long fr = q.front();
q.pop();
for (auto u : g[fr]) {
if (dis[u.first] > dis[fr] + 1) {
dis[u.first] = dis[fr] + 1;
ans[u.second] = 1;
q.push(u.first);
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> d;
memset(dis, 63, sizeof dis);
for (int i = 0; i < k; i++) {
cin >> v;
st.insert(v);
dis[v] = 0;
}
for (int i = 0; i < n - 1; i++) {
cin >> v >> u;
g[v].push_back({u, i + 1}), g[u].push_back({v, i + 1});
}
BFS();
long long Cnt = 0;
vector<long long> ann;
for (int i = 1; i <= n - 1; i++) {
if (ans[i] == 0) {
Cnt++;
ann.push_back(i);
}
}
cout << Cnt << '\n';
for (auto u : ann) cout << u << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char CRTBUFF[30000];
struct debugger {
static void call(string::iterator it, string::iterator ed) {}
template <typename T, typename... aT>
static void call(string::iterator it, string::iterator ed, T a, aT... rest) {
string b;
for (; *it != ','; ++it)
if (*it != ' ') b += *it;
cout << b << "=" << a << " ";
call(++it, ed, rest...);
}
};
int n, k, d;
vector<int> G[500000 + 10];
int A[500000 + 100];
int BL[500000 + 100];
void bfs() {
memset(BL, -1, sizeof(BL));
queue<int> que;
for (int i = (0); i < (k); i += (1)) {
BL[A[i]] = A[i];
que.push(A[i]);
}
while (!que.empty()) {
int u = que.front();
que.pop();
for (auto v : G[u]) {
if (BL[v] == -1) {
BL[v] = BL[u];
que.push(v);
}
}
}
}
int main() {
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
};
while (cin >> n >> k >> d) {
memset(G, 0, sizeof(G));
for (int i = (0); i < (k); i += (1)) cin >> A[i];
vector<pair<int, int> > vec;
for (int i = (0); i < (n - 1); i += (1)) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
vec.push_back({u, v});
}
bfs();
vector<int> out;
for (int i = (0); i < (n - 1); i += (1)) {
int u = vec[i].first, v = vec[i].second;
if (BL[u] != BL[v]) {
out.push_back(i + 1);
}
}
cout << out.size() << "\n";
for (auto idx : out) {
cout << idx << " ";
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, len, ans = 0;
cin >> n >> k >> len;
vector<char> ch(n);
vector<pair<int, int>> r(n - 1);
vector<list<int>> g(n);
set<pair<int, int>> deleted;
queue<int> q;
int t1, t2, v;
for (int i = 0; i < k; i++) {
cin >> t1;
t1--;
if (ch[t1]) continue;
q.push(t1);
ch[t1] = 1;
}
for (int i = 0; i < n - 1; i++) {
cin >> t1 >> t2;
t1--;
t2--;
g[t1].push_back(t2);
g[t2].push_back(t1);
r[i] = make_pair(t1, t2);
}
while (!q.empty()) {
v = q.front();
q.pop();
ch[v] = 2;
for (int to : g[v]) {
if (ch[to] == 1) {
deleted.insert(make_pair(v, to));
ans++;
} else if (ch[to] == 0) {
ch[to] = 1;
q.push(to);
}
}
}
cout << ans << endl;
for (int i = 0; i < n - 1; i++)
if (deleted.find(r[i]) != deleted.end() ||
deleted.find(make_pair(r[i].second, r[i].first)) != deleted.end()) {
cout << i + 1 << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k, d;
cin >> n >> k >> d;
queue<pair<int, int> > q;
vector<long long> D(n, -1);
for (int i = 0; i < k; ++i) {
int a;
cin >> a;
a--;
q.push(pair<int, int>(a, a));
D[a] = 0;
}
vector<vector<long long> > adj(n, vector<long long>());
map<pair<int, int>, int> M;
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
M[pair<int, int>(u, v)] = i;
M[pair<int, int>(v, u)] = i;
}
vector<bool> B(n - 1);
int ans = n - 1;
while (!q.empty()) {
pair<int, int> p = q.front();
q.pop();
int a = p.first;
int b = p.second;
if (M.count(pair<int, int>(a, b))) {
B[M[{a, b}]] = true;
ans--;
}
if (D[a] == d) continue;
for (auto u : adj[a]) {
if (D[u] == -1) {
D[u] = D[a] + 1;
q.push({u, a});
}
}
}
cout << ans << '\n';
for (int i = 0; i < n - 1; ++i)
if (!B[i]) cout << i + 1 << " ";
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, d;
const int MAXN = 300005;
bool vis[MAXN];
vector<pair<int, int> > adj[MAXN];
queue<int> curr;
set<int> ans;
int main() {
ios::sync_with_stdio(0);
cin >> n >> k >> d;
for (int i = 0; i < k; i++) {
int x;
cin >> x;
vis[x] = true;
curr.push(x);
}
for (int i = 1; i <= n - 1; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(make_pair(y, i));
adj[y].push_back(make_pair(x, i));
ans.insert(i);
}
while (!curr.empty()) {
int x = curr.front();
curr.pop();
for (int i = 0; i < adj[x].size(); i++) {
int c = adj[x][i].first;
if (!vis[c]) {
curr.push(c);
vis[c] = true;
ans.erase(adj[x][i].second);
}
}
}
cout << ans.size() << "\n";
for (set<int>::iterator it = ans.begin(); it != ans.end(); it++)
cout << *it << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int a, pos;
};
int level[300007], path[300007];
bool vis[300007];
int main() {
int n, k, d, u, v;
scanf("%d%d%d", &n, &k, &d);
int arr[k];
vector<node> adj[n + 1];
queue<int> q;
for (int i = 0; i < k; i++) {
scanf("%d", &arr[i]);
q.push(arr[i]);
level[arr[i]] = 1;
}
d++;
node te;
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
te.a = v;
te.pos = i;
adj[u].push_back(te);
te.a = u;
adj[v].push_back(te);
}
while (!q.empty()) {
u = q.front();
q.pop();
if (level[u] == d) continue;
for (int j = 0; j < adj[u].size(); j++) {
v = adj[u][j].a;
if (level[v]) {
continue;
}
vis[adj[u][j].pos] = 1;
level[v] = level[u] + 1;
q.push(v);
}
}
k = 0;
for (int i = 1; i < n; i++) {
if (!vis[i]) level[k++] = i;
}
printf("%d\n", k);
for (int i = 0; i < k; i++) printf("%d ", level[i]);
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[300005];
int vc[500000];
vector<int> v1;
map<pair<int, int>, int> m;
queue<pair<int, int>> q;
set<pair<int, int>> s;
int visited[300005];
int c = 0, r1, r2;
void bfs(int x) {
int i;
for (i = 0; i < 300005; i++) {
if (vc[i]) {
q.push({i, -1});
visited[i] = 0;
}
}
while (!q.empty()) {
auto n = q.front();
q.pop();
for (auto i : v[n.first]) {
if (visited[i] == -1) {
q.push({i, n.first});
visited[i] = visited[n.first] + 1;
} else if (i != n.second) {
s.insert({min(n.first, i), max(n.first, i)});
}
}
}
c = 1;
}
int main() {
int x, y, z, p, q, i, r;
for (i = 0; i < 300003; i++) {
visited[i] = -1;
}
cin >> x >> y >> z;
for (i = 0; i < y; i++) {
cin >> p;
vc[p] = 1;
}
for (i = 1; i < x; i++) {
cin >> p >> q;
m[{min(p, q), max(p, q)}] = i;
v[p].push_back(q);
v[q].push_back(p);
}
bfs(z);
cout << s.size() << endl;
for (auto it : s) {
v1.push_back(m[{it.first, it.second}]);
}
sort(v1.begin(), v1.end());
for (i = 0; i < v1.size(); i++) cout << v1[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int in[300005];
int res[300005];
vector<pair<int, int> > v[300005];
queue<pair<int, int> > Q;
int dist[300005], vis[300005], d;
set<int> my;
void bfs() {
while (!Q.empty()) {
pair<int, int> cur = Q.front();
int len = cur.second, node = cur.first;
Q.pop();
for (auto u : v[node])
if (!vis[u.first] && len < d) {
Q.push({u.first, len + 1});
vis[u.first] = 1;
res[u.second] = 1;
}
}
}
int main() {
int n, k;
cin >> n >> k >> d;
for (int i = 1; i <= k; i++) {
scanf("%d", &in[i]);
vis[in[i]] = 1;
Q.push({in[i], 0});
}
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
v[x].push_back({y, i});
v[y].push_back({x, i});
}
bfs();
for (int i = 0; i < n - 1; i++)
if (!res[i]) my.insert(i);
cout << my.size() << endl;
set<int>::iterator it;
for (it = my.begin(); it != my.end(); it++) cout << *it + 1 << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> arr[400000];
pair<int, int> ae[400000];
vector<int> ans;
int n, d;
int pr[400000];
vector<int> prv;
vector<int> dis;
void dijkstra(int s, vector<int>& d, vector<int>& p) {
d.assign(n + 1, 1000000);
p.assign(n + 1, -1);
d[s] = 0;
using pii = pair<int, int>;
priority_queue<pii, vector<pii>, greater<pii>> q;
q.push({0, s});
while (!q.empty()) {
int v = q.top().second;
int d_v = q.top().first;
q.pop();
if (d_v != d[v]) continue;
for (auto edge : arr[v]) {
int to = edge.first;
int len = edge.second;
if (d[v] + len < d[to]) {
d[to] = d[v] + len;
p[to] = v;
if (pr[v] != -1) pr[to] = pr[v];
q.push({d[to], to});
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int k;
cin >> n >> k >> d;
int j;
pr[0] = -1;
for (int x = 0; x < k; x++) {
cin >> j;
pr[j] = j;
arr[0].push_back(make_pair(j, 1));
}
int w, e;
for (int x = 0; x < n - 1; x++) {
cin >> w >> e;
arr[w].push_back(make_pair(e, 1));
arr[e].push_back(make_pair(w, 1));
ae[x] = make_pair(e, w);
}
dijkstra(0, dis, prv);
for (int x = 0; x < n - 1; x++) {
if (pr[ae[x].first] != pr[ae[x].second]) {
ans.push_back(x);
}
}
cout << ans.size() << endl;
for (auto it = ans.begin(); it != ans.end(); ++it) cout << *it + 1 << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxN = 3 * 100 * 1000 + 5;
vector<pair<int, int>> g[mxN];
int vis[mxN];
void solve() {
int n, k, d;
cin >> n >> k >> d;
queue<int> q;
for (int i = 0; i < k; i++) {
int p;
cin >> p;
p--;
if (!vis[p]) {
vis[p] = 1;
q.push(p);
}
}
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].push_back({v, i});
g[v].push_back({u, i});
}
set<int> ans;
vector<int> par(n);
while ((int)q.size()) {
int sz = q.size();
while (sz--) {
int cur;
cur = q.front();
q.pop();
for (auto to : g[cur]) {
if (vis[to.first]) {
if (to.first != par[cur]) ans.insert(to.second);
} else {
par[to.first] = cur;
vis[to.first] = 1;
q.push(to.first);
}
}
}
}
cout << (int)ans.size() << endl;
for (auto edge : ans) {
cout << edge << " ";
}
cout << endl;
}
int query = 0;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q = 1;
if (query) cin >> q;
while (q--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxN = 3 * 100 * 1000 + 5;
vector<pair<int, int>> g[mxN];
int vis[mxN];
void solve() {
int n, k, d;
cin >> n >> k >> d;
queue<int> q;
for (int i = 0; i < k; i++) {
int p;
cin >> p;
p--;
if (!vis[p]) {
vis[p] = 1;
q.push(p);
}
}
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].push_back({v, i});
g[v].push_back({u, i});
}
set<int> ans;
vector<int> par(n);
while ((int)q.size()) {
int sz = q.size();
while (sz--) {
int cur;
cur = q.front();
q.pop();
for (auto to : g[cur]) {
if (vis[to.first]) {
if (to.first != par[cur]) ans.insert(to.second);
} else {
par[to.first] = cur;
vis[to.first] = 1;
q.push(to.first);
}
}
}
}
cout << (int)ans.size() << endl;
for (auto edge : ans) {
cout << edge << " ";
}
cout << endl;
}
int query = 0;
int main() {
int q = 1;
if (query) cin >> q;
while (q--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
Node() : vis(0) {}
int vis;
vector<pair<int, int>> adj;
};
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int64_t n, k, d;
cin >> n >> k >> d;
queue<pair<int, int>> q;
for (int i = 0; i < k; i++) {
int v;
cin >> v;
v--;
q.push({v, i + 1});
}
vector<Node> a(n);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
a[u].adj.push_back({v, i + 1});
a[v].adj.push_back({u, i + 1});
}
while (!q.empty()) {
int u = q.front().first;
int c = q.front().second;
q.pop();
if (a[u].vis != 0) continue;
a[u].vis = c;
for (auto pv : a[u].adj) {
if (a[pv.first].vis == 0) {
q.push({pv.first, c});
}
}
}
vector<int> res;
for (int u = 0; u < n; u++) {
for (auto pv : a[u].adj) {
if (a[pv.first].vis != a[u].vis) res.push_back(pv.second);
}
}
sort(res.begin(), res.end());
res.erase(unique(res.begin(), res.end()), res.end());
cout << res.size() << endl;
for (auto e : res) {
cout << e << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int vis[500005];
queue<int> q;
vector<int> g[500005];
map<pair<int, int>, int> mp;
int road[500005];
int main() {
int n, k, d;
cin >> n >> k >> d;
memset(vis, 0, sizeof(vis));
memset(road, 0, sizeof(road));
for (int i = 0; i < k; i++) {
int x;
cin >> x;
q.push(x);
vis[x] = 1;
}
for (int i = 1; i <= n - 1; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
mp[make_pair(x, y)] = i;
mp[make_pair(y, x)] = i;
}
int ans = 0;
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 0; i < g[v].size(); i++) {
int u = g[v][i];
if (!vis[u]) {
q.push(u);
ans++;
road[mp[make_pair(v, u)]] = 1;
vis[u] = 1;
}
}
}
cout << n - 1 - ans << endl;
for (int i = 1; i <= n - 1; i++) {
if (!road[i]) cout << i << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k, d;
cin >> n >> k >> d;
long long dis[n + 1], vis[n + 1];
for (long long i = 1; i <= n; i++) dis[i] = 1e18, vis[i] = 0;
queue<long long> bfs;
set<long long> b;
vector<pair<long long, long long> > e[n + 1];
for (long long i = 0; i < k; i++) {
long long u;
cin >> u;
b.insert(u);
dis[u] = 0;
vis[u] = u;
}
for (auto u : b) bfs.push(u);
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
e[u].push_back(make_pair(v, i));
e[v].push_back(make_pair(u, i));
}
set<long long> ans;
while (!bfs.empty()) {
long long u = bfs.front();
bfs.pop();
for (auto v : e[u]) {
if (vis[v.first] > 0 && vis[v.first] != vis[u])
ans.insert(v.second + 1);
else if (dis[u] < d && vis[v.first] == 0) {
dis[v.first] = dis[u] + 1;
vis[v.first] = vis[u];
bfs.push(v.first);
}
}
}
cout << ans.size() << endl;
for (auto i : ans) cout << i << " ";
cout << endl;
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int q = 1;
for (int i = 1; i <= q; i++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int d1[300001];
int d2[300001];
int u[300001];
int used[300001];
int asd[300001];
int ans[300001];
;
int mx[300001];
vector<int> g[300001];
map<pair<int, int>, int> ma;
void dfs(int v) {
u[v] = 1;
d1[v] = 1000000007;
d2[v] = d1[v];
if (used[v]) d1[v] = 0;
for (int i = 0; i < g[v].size(); i++) {
if (!u[g[v][i]]) {
dfs(g[v][i]);
if (d1[g[v][i]] == d1[v]) asd[v]++;
if (d1[g[v][i]] + 1 <= d1[v]) {
mx[v] = g[v][i];
d2[v] = d1[v];
d1[v] = d1[g[v][i]] + 1;
} else if (d1[g[v][i]] + 1 < d2[v]) {
d2[v] = d1[g[v][i]] + 1;
}
}
}
}
void dfs1(int v, int pr, int fup) {
u[v] = 1;
if (used[v]) {
} else if (d1[v] >= fup) {
ans[ma[make_pair(v, pr)]] = 1;
} else {
ans[ma[make_pair(mx[v], v)]] = 1;
}
for (int i = 0; i < g[v].size(); i++) {
if (g[v][i] == pr) continue;
int to = g[v][i];
int len = d1[v];
if (mx[v] == to && asd[v] < 2) len = d2[v];
int fdown = min(fup, len);
if (fdown != 1000000007) fdown++;
dfs1(to, v, fdown);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
int x;
cin >> x;
used[x] = 1;
}
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
ma[make_pair(x, y)] = i;
ma[make_pair(y, x)] = i;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1);
memset(u, 0, sizeof u);
dfs1(1, 0, 1000000007);
int almas = 0;
for (int i = 1; i < n; i++) {
if (!ans[i]) almas++;
}
cout << almas << endl;
for (int i = 1; i < n; i++) {
if (!ans[i]) cout << i << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int to, next, v;
} e[600010];
struct Node {
int num, d;
};
int n, k, d, cnt = 1, ans = 0, x, y, head[300010], vis[300010], flg[300010],
res[300010];
queue<Node> q;
void add() {
e[++cnt] = {y, head[x], 0}, head[x] = cnt, e[++cnt] = {x, head[y], 0},
head[y] = cnt;
}
void bfs() {
while (!q.empty()) {
Node u = q.front();
q.pop();
if (u.d > d) continue;
for (int i = head[u.num]; i; i = e[i].next) {
if (e[i].v) continue;
e[i].v = e[i ^ 1].v = 1;
if (vis[e[i].to]) {
res[++ans] = i / 2;
} else
q.push({e[i].to, u.d + 1}), flg[e[i].to] = vis[e[i].to] = 1;
}
}
}
int main() {
scanf("%d%d%d", &n, &k, &d);
for (int i = 1; i <= k; i++) scanf("%d", &x), q.push({x, 0}), vis[x] = 1;
for (int i = 1; i < n; i++) scanf("%d%d", &x, &y), add();
bfs(), printf("%d\n", ans);
for (int i = 1; i <= ans; i++) printf("%d ", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const INF = 1e9 + 7;
long long const LLINF = 1e18 + 7;
long double const eps = 1e-8;
long double const PI = acos(-1);
long long const p_hash = 257;
long long const mod = 1e9 + 9;
bool operator==(pair<int, int> a, pair<int, int> b) {
return (a.first == b.first && a.second == b.second);
}
pair<int, int> operator+(pair<int, int> a, pair<int, int> b) {
return {a.first + b.first, a.second + b.second};
}
pair<int, int> operator-(pair<int, int> a, pair<int, int> b) {
return {a.first - b.first, a.second - b.second};
}
bool operator<(pair<int, int> const& a, pair<int, int> const& b) {
return a.first < b.first || (a.first == b.first && a.second < b.second);
}
istream& operator>>(istream& in, pair<int, int>& a) {
return (in >> a.first >> a.second);
}
ostream& operator<<(ostream& ou, pair<int, int> a) {
return (ou << a.first << " " << a.second << endl);
}
namespace std {
template <>
struct hash<pair<int, int> > {
std::size_t operator()(const pair<int, int>& a) const {
using std::hash;
using std::size_t;
return (1LL * hash<int>()(a.first) * p_hash + 1LL * hash<int>()(a.second)) %
mod;
}
};
} // namespace std
bool eq(long double const& a, long double const& b) {
return (a - b < eps && a - b > -eps);
}
bool less(long double const& a, long double const& b) { return (a - b < -eps); }
struct st {
int v, pr, path;
st(int v, int pr, int path) : v(v), pr(pr), path(path) {}
};
bool w[300100];
vector<pair<int, int> > g[300100];
int main() {
ios::sync_with_stdio(false);
int n, k, d;
cin >> n >> k >> d;
queue<st> q;
for (int i = 0; i < k; i++) {
int id;
cin >> id;
if (!w[id]) {
w[id] = true;
q.push(st(id, 0, 0));
}
}
for (int i = 1; i <= n - 1; i++) {
int v, u;
cin >> v >> u;
g[v].push_back({u, i});
g[u].push_back({v, i});
}
vector<int> ans;
while (!q.empty()) {
st cur = q.front();
int v = cur.v, pr = cur.pr;
q.pop();
for (pair<int, int> to : g[v])
if (to.first != pr) {
if (!w[to.first] && cur.path < d) {
w[to.first] = true;
q.push(st(to.first, v, cur.path + 1));
} else
ans.push_back(to.second);
}
}
sort(ans.begin(), ans.end());
int sz = unique(ans.begin(), ans.end()) - ans.begin();
ans.resize(sz);
cout << ans.size() << endl;
for (int i : ans) cout << i << " ";
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.