#include "simurgh.h"
#include <bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define pb push_back
#define N 505
vector<int> inq, tree, ACpls, adj[N], cyc, fin, onn, off, vall, imsad;
vector<pair<int, int> > edge;
int n, m, par[N], dep[N], p[N], t;
bool ans[150000], ch[150000], in[N];
int get(int v, int i){
return edge[i].ff + edge[i].ss - v;
}
void reset(){
for(int i = 0; i < n; i++)
p[i] = i;
}
int find(int v){
return v == p[v] ? v : p[v] = find(p[v]);
}
bool merge(int v, int u){
v = find(v);
u = find(u);
if(v == u) return 0;
p[v] = u;
return 1;
}
int ask(){
reset();
for(int& x : inq)
merge(edge[x].ff, edge[x].ss);
t = 0;
for(int& x : tree){
if(merge(edge[x].ff, edge[x].ss)){
inq.pb(x);
t += ans[x];
}
}
return count_common_roads(inq);
}
void dfs(int v){
for(int& x : adj[v]){
int u = get(v, x);
if(dep[u]) continue;
par[u] = x;
dep[u] = dep[v] + 1;
tree.pb(x);
dfs(u);
}
}
int fillexc(int x){
inq = cyc;
for(int& a : inq){
if(a == x){
swap(a, inq.back());
inq.pop_back();
break;
}
}
return ask();
}
void solvecycle(){
if(fin.empty()) return;
if(onn.empty() && off.empty()){
int lo = -1;
vall.clear();
for(int& x : cyc)
vall.pb(fillexc(x));
for(int& x : vall)
lo = max(lo, x);
for(int i = cyc.size() - 1; i >= 0; i--){
ch[cyc[i]] = 1;
ans[cyc[i]] = (lo - vall[i]);
}
} else {
int lo;
if(off.empty())
lo = fillexc(onn[0]);
else
lo = fillexc(off[0]) - 1;
for(int& x : fin){
ch[x] = 1;
ans[x] = (fillexc(x) == lo);
}
}
}
void solvetree(){
for(int i = 0; i < m; i++){
if(dep[edge[i].ff] < dep[edge[i].ss]) swap(edge[i].ff, edge[i].ss);
if(dep[edge[i].ff] - dep[edge[i].ss] == 1) continue;
cyc.clear(); fin.clear(); off.clear(); onn.clear();
cyc.pb(i);
int s = edge[i].ff;
while(s != edge[i].ss){
cyc.pb(par[s]);
if(ch[par[s]] == 0) fin.pb(par[s]);
else if(ans[par[s]] == 1) onn.pb(par[s]);
else off.pb(par[s]);
s = get(s, par[s]);
}
solvecycle();
}
for(int& x : tree){
if(ch[x] == 0){
ch[x] = ans[x] = 1;
}
}
}
void dfs2(int v){
in[v] = 1;
for(int i = adj[v].size() - 1; i >= 0; i--){
if(ch[adj[v][i]]){
swap(adj[v][i], adj[v].back());
adj[v].pop_back();
continue;
}
int u = get(v, adj[v][i]);
if(in[u]) continue;
imsad.pb(adj[v][i]);
dfs2(u);
}
}
void solvethisshit(){
if(imsad.empty()) return;
inq = imsad;
if(ask() == t){
for(int& x : imsad){
ch[x] = 1;
ans[x] = 0;
}
return;
}
int l = 0, r = imsad.size() - 1;
while(l != r){
int m = (l + r) >> 1;
inq.clear();
for(int i = 0; i <= m; i++)
inq.pb(imsad[i]);
if(ask() == t) l = m + 1;
else r = m;
}
for(int i = 0; i < r; i++){
ch[imsad[i]] = 1;
ans[imsad[i]] = 0;
}
ch[imsad[r]] = ans[imsad[r]] = 1;
}
vector<int> find_roads(int n, vector<int> u, vector<int> v) {
::n = n;
m = u.size();
for(int i = 0; i < m; i++){
adj[v[i]].pb(i);
adj[u[i]].pb(i);
edge.pb({v[i], u[i]});
}
dep[0] = 1;
dfs(0);
if(m == n - 1){
return tree;
}
solvetree();
do{
memset(in, 0, sizeof in);
imsad.clear();
for(int i = 0; i < n; i++){
if(in[i]) continue;
dfs2(i);
}
solvethisshit();
} while(!imsad.empty());
return ACpls;
}
| # |
Verdict |
Execution time |
Memory |
Grader output |
| 1 |
Incorrect |
2 ms |
376 KB |
WA in grader: NO |
| 2 |
Halted |
0 ms |
0 KB |
- |
| # |
Verdict |
Execution time |
Memory |
Grader output |
| 1 |
Incorrect |
2 ms |
376 KB |
WA in grader: NO |
| 2 |
Halted |
0 ms |
0 KB |
- |
| # |
Verdict |
Execution time |
Memory |
Grader output |
| 1 |
Incorrect |
2 ms |
376 KB |
WA in grader: NO |
| 2 |
Halted |
0 ms |
0 KB |
- |
| # |
Verdict |
Execution time |
Memory |
Grader output |
| 1 |
Correct |
2 ms |
376 KB |
correct |
| 2 |
Incorrect |
2 ms |
376 KB |
WA in grader: NO |
| 3 |
Halted |
0 ms |
0 KB |
- |
| # |
Verdict |
Execution time |
Memory |
Grader output |
| 1 |
Incorrect |
2 ms |
376 KB |
WA in grader: NO |
| 2 |
Halted |
0 ms |
0 KB |
- |
