結果
| 問題 | No.2677 Minmax Independent Set |
| ユーザー |
👑  tute7627
|
| 提出日時 | 2024-03-15 21:47:54 |
| 言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
WA
|
| 実行時間 | - |
| コード長 | 19,214 bytes |
| コンパイル時間 | 3,435 ms |
| コンパイル使用メモリ | 241,524 KB |
| 実行使用メモリ | 74,660 KB |
| 最終ジャッジ日時 | 2024-09-30 00:45:56 |
| 合計ジャッジ時間 | 16,931 ms |
|
ジャッジサーバーID （参考情報） |
judge3 / judge5 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 2 ms
5,248 KB |
| testcase_01 | AC | 2 ms
5,248 KB |
| testcase_02 | AC | 2 ms
5,248 KB |
| testcase_03 | WA | - |
| testcase_04 | AC | 2 ms
5,248 KB |
| testcase_05 | AC | 414 ms
70,516 KB |
| testcase_06 | AC | 407 ms
70,328 KB |
| testcase_07 | AC | 453 ms
70,928 KB |
| testcase_08 | AC | 418 ms
70,560 KB |
| testcase_09 | AC | 448 ms
70,800 KB |
| testcase_10 | WA | - |
| testcase_11 | WA | - |
| testcase_12 | AC | 281 ms
68,500 KB |
| testcase_13 | AC | 392 ms
68,228 KB |
| testcase_14 | AC | 321 ms
68,348 KB |
| testcase_15 | AC | 460 ms
70,348 KB |
| testcase_16 | WA | - |
| testcase_17 | WA | - |
| testcase_18 | WA | - |
| testcase_19 | WA | - |
| testcase_20 | WA | - |
| testcase_21 | WA | - |
| testcase_22 | WA | - |
| testcase_23 | WA | - |
| testcase_24 | WA | - |
| testcase_25 | WA | - |
| testcase_26 | WA | - |
| testcase_27 | WA | - |
| testcase_28 | AC | 241 ms
66,540 KB |
| testcase_29 | AC | 508 ms
74,660 KB |
| testcase_30 | AC | 2 ms
6,816 KB |
| testcase_31 | AC | 2 ms
6,816 KB |
| testcase_32 | AC | 2 ms
6,820 KB |
| testcase_33 | WA | - |
| testcase_34 | WA | - |
| testcase_35 | WA | - |
| testcase_36 | WA | - |
| testcase_37 | WA | - |
| testcase_38 | WA | - |
| testcase_39 | WA | - |
| testcase_40 | WA | - |
| testcase_41 | WA | - |
| testcase_42 | WA | - |
| testcase_43 | WA | - |
| testcase_44 | WA | - |
| testcase_45 | WA | - |
| testcase_46 | WA | - |
| testcase_47 | WA | - |
| testcase_48 | WA | - |
| testcase_49 | WA | - |
| testcase_50 | AC | 66 ms
27,096 KB |
| testcase_51 | AC | 6 ms
6,816 KB |
| testcase_52 | AC | 147 ms
55,712 KB |
| testcase_53 | AC | 135 ms
52,060 KB |
| testcase_54 | AC | 6 ms
6,816 KB |
| testcase_55 | WA | - |
| testcase_56 | WA | - |
| testcase_57 | WA | - |
| testcase_58 | WA | - |
| testcase_59 | WA | - |
| testcase_60 | AC | 200 ms
70,688 KB |
| testcase_61 | WA | - |
| testcase_62 | AC | 206 ms
69,712 KB |
| testcase_63 | WA | - |
ソースコード
//#define _GLIBCXX_DEBUG
#include<bits/stdc++.h>
using namespace std;
#define endl '\n'
#define lfs cout<<fixed<<setprecision(10)
#define ALL(a) (a).begin(),(a).end()
#define ALLR(a) (a).rbegin(),(a).rend()
#define UNIQUE(a) (a).erase(unique((a).begin(),(a).end()),(a).end())
#define spa << " " <<
#define fi first
#define se second
#define MP make_pair
#define MT make_tuple
#define PB push_back
#define EB emplace_back
#define rep(i,n,m) for(ll i = (n); i < (ll)(m); i++)
#define rrep(i,n,m) for(ll i = (ll)(m) - 1; i >= (ll)(n); i--)
using ll = long long;
using ld = long double;
const ll MOD1 = 1e9+7;
const ll MOD9 = 998244353;
const ll INF = 1e18;
using P = pair<ll, ll>;
template<typename T> using PQ = priority_queue<T>;
template<typename T> using QP = priority_queue<T,vector<T>,greater<T>>;
template<typename T1, typename T2>bool chmin(T1 &a,T2 b){if(a>b){a=b;return true;}else return false;}
template<typename T1, typename T2>bool chmax(T1 &a,T2 b){if(a<b){a=b;return true;}else return false;}
ll median(ll a,ll b, ll c){return a+b+c-max({a,b,c})-min({a,b,c});}
void ans1(bool x){if(x) cout<<"Yes"<<endl;else cout<<"No"<<endl;}
void ans2(bool x){if(x) cout<<"YES"<<endl;else cout<<"NO"<<endl;}
void ans3(bool x){if(x) cout<<"Yay!"<<endl;else cout<<":("<<endl;}
template<typename T1,typename T2>void ans(bool x,T1 y,T2 z){if(x)cout<<y<<endl;else cout<<z<<endl;}
template<typename T1,typename T2,typename T3>void anss(T1 x,T2 y,T3 z){ans(x!=y,x,z);};
template<typename T>void debug(const T &v,ll h,ll w,string sv=" "){for(ll i=0;i<h;i++){cout<<v[i][0];for(ll j=1;j<w;j++)cout<<sv<<v[i][j];cout<<endl;}};
template<typename T>void debug(const T &v,ll n,string sv=" "){if(n!=0)cout<<v[0];for(ll i=1;i<n;i++)cout<<sv<<v[i];cout<<endl;};
template<typename T>void debug(const vector<T>&v){debug(v,v.size());}
template<typename T>void debug(const vector<vector<T>>&v){for(auto &vv:v)debug(vv,vv.size());}
template<typename T>void debug(stack<T> st){while(!st.empty()){cout<<st.top()<<" ";st.pop();}cout<<endl;}
template<typename T>void debug(queue<T> st){while(!st.empty()){cout<<st.front()<<" ";st.pop();}cout<<endl;}
template<typename T>void debug(deque<T> st){while(!st.empty()){cout<<st.front()<<" ";st.pop_front();}cout<<endl;}
template<typename T>void debug(PQ<T> st){while(!st.empty()){cout<<st.top()<<" ";st.pop();}cout<<endl;}
template<typename T>void debug(QP<T> st){while(!st.empty()){cout<<st.top()<<" ";st.pop();}cout<<endl;}
template<typename T>void debug(const set<T>&v){for(auto z:v)cout<<z<<" ";cout<<endl;}
template<typename T>void debug(const multiset<T>&v){for(auto z:v)cout<<z<<" ";cout<<endl;}
template<typename T,size_t size>void debug(const array<T, size> &a){for(auto z:a)cout<<z<<" ";cout<<endl;}
template<typename T,typename V>void debug(const map<T,V>&v){for(auto z:v)cout<<"["<<z.first<<"]="<<z.second<<",";cout<<endl;}
template<typename T>vector<vector<T>>vec(ll x, ll y, T w){vector<vector<T>>v(x,vector<T>(y,w));return v;}
ll gcd(ll x,ll y){ll r;while(y!=0&&(r=x%y)!=0){x=y;y=r;}return y==0?x:y;}
vector<ll>dx={1,-1,0,0,1,1,-1,-1};vector<ll>dy={0,0,1,-1,1,-1,1,-1};
template<typename T>vector<T> make_v(size_t a,T b){return vector<T>(a,b);}
template<typename... Ts>auto make_v(size_t a,Ts... ts){return vector<decltype(make_v(ts...))>(a,make_v(ts...));}
template<typename T1, typename T2>ostream &operator<<(ostream &os, const pair<T1, T2>&p){return os << p.first << " " << p.second;}
template<typename T>ostream &operator<<(ostream &os, const vector<T> &v){for(auto &z:v)os << z << " ";cout<<"|"; return os;}
template<typename T>void rearrange(vector<int>&ord, vector<T>&v){
auto tmp = v;
for(int i=0;i<tmp.size();i++)v[i] = tmp[ord[i]];
}
template<typename Head, typename... Tail>void rearrange(vector<int>&ord,Head&& head, Tail&&... tail){
rearrange(ord, head);
rearrange(ord, tail...);
}
template<typename T> vector<int> ascend(const vector<T>&v){
vector<int>ord(v.size());iota(ord.begin(),ord.end(),0);
sort(ord.begin(),ord.end(),[&](int i,int j){return make_pair(v[i],i)<make_pair(v[j],j);});
return ord;
}
template<typename T> vector<int> descend(const vector<T>&v){
vector<int>ord(v.size());iota(ord.begin(),ord.end(),0);
sort(ord.begin(),ord.end(),[&](int i,int j){return make_pair(v[i],-i)>make_pair(v[j],-j);});
return ord;
}
template<typename T> vector<T> inv_perm(const vector<T>&ord){
vector<T>inv(ord.size());
for(int i=0;i<ord.size();i++)inv[ord[i]] = i;
return inv;
}
ll FLOOR(ll n,ll div){assert(div>0);return n>=0?n/div:(n-div+1)/div;}
ll CEIL(ll n,ll div){assert(div>0);return n>=0?(n+div-1)/div:n/div;}
ll digitsum(ll n){ll ret=0;while(n){ret+=n%10;n/=10;}return ret;}
ll modulo(ll n,ll d){return (n%d+d)%d;};
template<typename T>T min(const vector<T>&v){return *min_element(v.begin(),v.end());}
template<typename T>T max(const vector<T>&v){return *max_element(v.begin(),v.end());}
template<typename T>T acc(const vector<T>&v){return accumulate(v.begin(),v.end(),T(0));};
template<typename T>T reverse(const T &v){return T(v.rbegin(),v.rend());};
//mt19937 mt(chrono::steady_clock::now().time_since_epoch().count());
int popcount(ll x){return __builtin_popcountll(x);};
int poplow(ll x){return __builtin_ctzll(x);};
int pophigh(ll x){return 63 - __builtin_clzll(x);};
template<typename T>T poll(queue<T> &q){auto ret=q.front();q.pop();return ret;};
template<typename T>T poll(priority_queue<T> &q){auto ret=q.top();q.pop();return ret;};
template<typename T>T poll(QP<T> &q){auto ret=q.top();q.pop();return ret;};
template<typename T>T poll(stack<T> &s){auto ret=s.top();s.pop();return ret;};
ll MULT(ll x,ll y){if(LLONG_MAX/x<=y)return LLONG_MAX;return x*y;}
ll POW2(ll x, ll k){ll ret=1,mul=x;while(k){if(mul==LLONG_MAX)return LLONG_MAX;if(k&1)ret=MULT(ret,mul);mul=MULT(mul,mul);k>>=1;}return ret;}
ll POW(ll x, ll k){ll ret=1;for(int i=0;i<k;i++){if(LLONG_MAX/x<=ret)return LLONG_MAX;ret*=x;}return ret;}
template< typename T = int >
struct edge {
int to;
T cost;
int id;
edge():id(-1){};
edge(int to, T cost = 1, int id = -1):to(to), cost(cost), id(id){}
operator int() const { return to; }
};
template<typename T>
using Graph = vector<vector<edge<T>>>;
template<typename T>
Graph<T>revgraph(const Graph<T> &g){
Graph<T>ret(g.size());
for(int i=0;i<g.size();i++){
for(auto e:g[i]){
int to = e.to;
e.to = i;
ret[to].push_back(e);
}
}
return ret;
}
template<typename T>
Graph<T> readGraph(int n,int m,int indexed=1,bool directed=false,bool weighted=false){
Graph<T> ret(n);
for(int es = 0; es < m; es++){
int u,v;
T w=1;
cin>>u>>v;u-=indexed,v-=indexed;
if(weighted)cin>>w;
ret[u].emplace_back(v,w,es);
if(!directed)ret[v].emplace_back(u,w,es);
}
return ret;
}
template<typename T>
Graph<T> readParent(int n,int indexed=1,bool directed=true){
Graph<T>ret(n);
for(int i=1;i<n;i++){
int p;cin>>p;
p-=indexed;
ret[p].emplace_back(i);
if(!directed)ret[i].emplace_back(p);
}
return ret;
}
#line 2 "graph/bipartite_matching.hpp"
#include <cassert>
#include <iostream>
#include <vector>
// Bipartite matching of undirected bipartite graph (Hopcroft-Karp)
// https://ei1333.github.io/luzhiled/snippets/graph/hopcroft-karp.html
// Comprexity: O((V + E)sqrtV)
// int solve(): enumerate maximum number of matching / return -1 (if graph is not bipartite)
struct BipartiteMatching {
int V;
std::vector<std::vector<int>> to; // Adjacency list
std::vector<int> dist; // dist[i] = (Distance from i'th node)
std::vector<int> match; // match[i] = (Partner of i'th node) or -1 (No parter)
std::vector<int> used, vv;
std::vector<int> color; // color of each node(checking bipartition): 0/1/-1(not determined)
BipartiteMatching() = default;
BipartiteMatching(int V_) : V(V_), to(V_), match(V_, -1), used(V_), color(V_, -1) {}
void add_edge(int u, int v) {
assert(u >= 0 and u < V and v >= 0 and v < V and u != v);
to[u].push_back(v);
to[v].push_back(u);
}
void _bfs() {
dist.assign(V, -1);
std::vector<int> q;
int lq = 0;
for (int i = 0; i < V; i++) {
if (!color[i] and !used[i]) q.push_back(i), dist[i] = 0;
}
while (lq < int(q.size())) {
int now = q[lq++];
for (auto nxt : to[now]) {
int c = match[nxt];
if (c >= 0 and dist[c] == -1) q.push_back(c), dist[c] = dist[now] + 1;
}
}
}
bool _dfs(int now) {
vv[now] = true;
for (auto nxt : to[now]) {
int c = match[nxt];
if (c < 0 or (!vv[c] and dist[c] == dist[now] + 1 and _dfs(c))) {
match[nxt] = now, match[now] = nxt;
used[now] = true;
return true;
}
}
return false;
}
bool _color_bfs(int root) {
color[root] = 0;
std::vector<int> q{root};
int lq = 0;
while (lq < int(q.size())) {
int now = q[lq++], c = color[now];
for (auto nxt : to[now]) {
if (color[nxt] == -1) {
color[nxt] = !c, q.push_back(nxt);
} else if (color[nxt] == c) {
return false;
}
}
}
return true;
}
int solve() {
for (int i = 0; i < V; i++) {
if (color[i] == -1 and !_color_bfs(i)) return -1;
}
int ret = 0;
while (true) {
_bfs();
vv.assign(V, false);
int flow = 0;
for (int i = 0; i < V; i++) {
if (!color[i] and !used[i] and _dfs(i)) flow++;
}
if (!flow) break;
ret += flow;
}
return ret;
}
template <class OStream> friend OStream &operator<<(OStream &os, const BipartiteMatching &bm) {
os << "{N=" << bm.V << ':';
for (int i = 0; i < bm.V; i++) {
if (bm.match[i] > i) os << '(' << i << '-' << bm.match[i] << "),";
}
return os << '}';
}
};
#line 2 "graph/strongly_connected_components.hpp"
#include <algorithm>
#line 5 "graph/strongly_connected_components.hpp"
// CUT begin
// Directed graph library to find strongly connected components （強連結成分分解）
// 0-indexed directed graph
// Complexity: O(V + E)
struct DirectedGraphSCC {
int V; // # of Vertices
std::vector<std::vector<int>> to, from;
std::vector<int> used; // Only true/false
std::vector<int> vs;
std::vector<int> cmp;
int scc_num = -1;
DirectedGraphSCC(int V = 0) : V(V), to(V), from(V), cmp(V) {}
void _dfs(int v) {
used[v] = true;
for (auto t : to[v])
if (!used[t]) _dfs(t);
vs.push_back(v);
}
void _rdfs(int v, int k) {
used[v] = true;
cmp[v] = k;
for (auto t : from[v])
if (!used[t]) _rdfs(t, k);
}
void add_edge(int from_, int to_) {
assert(from_ >= 0 and from_ < V and to_ >= 0 and to_ < V);
to[from_].push_back(to_);
from[to_].push_back(from_);
}
// Detect strongly connected components and return # of them.
// Also, assign each vertex `v` the scc id `cmp[v]` (0-indexed)
int FindStronglyConnectedComponents() {
used.assign(V, false);
vs.clear();
for (int v = 0; v < V; v++)
if (!used[v]) _dfs(v);
used.assign(V, false);
scc_num = 0;
for (int i = (int)vs.size() - 1; i >= 0; i--)
if (!used[vs[i]]) _rdfs(vs[i], scc_num++);
return scc_num;
}
// Find and output the vertices that form a closed cycle.
// output: {v_1, ..., v_C}, where C is the length of cycle,
// {} if there's NO cycle (graph is DAG)
int _c, _init;
std::vector<int> _ret_cycle;
bool _dfs_detectcycle(int now, bool b0) {
if (now == _init and b0) return true;
for (auto nxt : to[now])
if (cmp[nxt] == _c and !used[nxt]) {
_ret_cycle.emplace_back(nxt), used[nxt] = 1;
if (_dfs_detectcycle(nxt, true)) return true;
_ret_cycle.pop_back();
}
return false;
}
std::vector<int> DetectCycle() {
int ns = FindStronglyConnectedComponents();
if (ns == V) return {};
std::vector<int> cnt(ns);
for (auto x : cmp) cnt[x]++;
_c = std::find_if(cnt.begin(), cnt.end(), [](int x) { return x > 1; }) - cnt.begin();
_init = std::find(cmp.begin(), cmp.end(), _c) - cmp.begin();
used.assign(V, false);
_ret_cycle.clear();
_dfs_detectcycle(_init, false);
return _ret_cycle;
}
// After calling `FindStronglyConnectedComponents()`, generate a new graph by uniting all
// vertices belonging to the same component(The resultant graph is DAG).
DirectedGraphSCC GenerateTopologicalGraph() {
DirectedGraphSCC newgraph(scc_num);
for (int s = 0; s < V; s++)
for (auto t : to[s]) {
if (cmp[s] != cmp[t]) newgraph.add_edge(cmp[s], cmp[t]);
}
return newgraph;
}
};
// 2-SAT solver: Find a solution for `(Ai v Aj) ^ (Ak v Al) ^ ... = true`
// - `nb_sat_vars`: Number of variables
// - Considering a graph with `2 * nb_sat_vars` vertices
// - Vertices [0, nb_sat_vars) means `Ai`
// - vertices [nb_sat_vars, 2 * nb_sat_vars) means `not Ai`
struct SATSolver : DirectedGraphSCC {
int nb_sat_vars;
std::vector<int> solution;
SATSolver(int nb_variables = 0)
: DirectedGraphSCC(nb_variables * 2), nb_sat_vars(nb_variables), solution(nb_sat_vars) {}
void add_x_or_y_constraint(bool is_x_true, int x, bool is_y_true, int y) {
assert(x >= 0 and x < nb_sat_vars);
assert(y >= 0 and y < nb_sat_vars);
if (!is_x_true) x += nb_sat_vars;
if (!is_y_true) y += nb_sat_vars;
add_edge((x + nb_sat_vars) % (nb_sat_vars * 2), y);
add_edge((y + nb_sat_vars) % (nb_sat_vars * 2), x);
}
// Solve the 2-SAT problem. If no solution exists, return `false`.
// Otherwise, dump one solution to `solution` and return `true`.
bool run() {
FindStronglyConnectedComponents();
for (int i = 0; i < nb_sat_vars; i++) {
if (cmp[i] == cmp[i + nb_sat_vars]) return false;
solution[i] = cmp[i] > cmp[i + nb_sat_vars];
}
return true;
}
};
#line 5 "graph/dulmage_mendelsohn_decomposition.hpp"
#include <utility>
#line 7 "graph/dulmage_mendelsohn_decomposition.hpp"
// Dulmage–Mendelsohn (DM) decomposition （DM 分解）
// return: [(W+0, W-0), (W+1,W-1),...,(W+(k+1), W-(k+1))]
// : sequence of pair (left vetrices, right vertices)
// - |W+0| < |W-0| or both empty
// - |W+i| = |W-i| (i = 1, ..., k)
// - |W+(k+1)| > |W-(k+1)| or both empty
// - W is topologically sorted
// Example:
// (2, 2, [(0,0), (0,1), (1,0)]) => [([],[]),([0,],[1,]),([1,],[0,]),([],[]),]
// Complexity: O(N + (N + M) sqrt(N))
// Verified: https://yukicoder.me/problems/no/1615
std::vector<std::pair<std::vector<int>, std::vector<int>>>
dulmage_mendelsohn(int L, int R, const std::vector<std::pair<int, int>> &edges) {
for (auto p : edges) {
assert(0 <= p.first and p.first < L);
assert(0 <= p.second and p.second < R);
}
BipartiteMatching bm(L + R);
for (auto p : edges) bm.add_edge(p.first, L + p.second);
bm.solve();
DirectedGraphSCC scc(L + R);
for (auto p : edges) scc.add_edge(p.first, L + p.second);
for (int l = 0; l < L; ++l) {
if (bm.match[l] >= L) scc.add_edge(bm.match[l], l);
}
int nscc = scc.FindStronglyConnectedComponents();
std::vector<int> cmp_map(nscc, -2);
std::vector<int> vis(L + R);
std::vector<int> st;
for (int c = 0; c < 2; ++c) {
std::vector<std::vector<int>> to(L + R);
auto color = [&L](int x) { return x >= L; };
for (auto p : edges) {
int u = p.first, v = L + p.second;
if (color(u) != c) std::swap(u, v);
to[u].push_back(v);
if (bm.match[u] == v) to[v].push_back(u);
}
for (int i = 0; i < L + R; ++i) {
if (bm.match[i] >= 0 or color(i) != c or vis[i]) continue;
vis[i] = 1, st = {i};
while (!st.empty()) {
int now = st.back();
cmp_map[scc.cmp[now]] = c - 1;
st.pop_back();
for (int nxt : to[now]) {
if (!vis[nxt]) vis[nxt] = 1, st.push_back(nxt);
}
}
}
}
int nset = 1;
for (int n = 0; n < nscc; ++n) {
if (cmp_map[n] == -2) cmp_map[n] = nset++;
}
for (auto &x : cmp_map) {
if (x == -1) x = nset;
}
nset++;
std::vector<std::pair<std::vector<int>, std::vector<int>>> groups(nset);
for (int l = 0; l < L; ++l) {
if (bm.match[l] < 0) continue;
int c = cmp_map[scc.cmp[l]];
groups[c].first.push_back(l);
groups[c].second.push_back(bm.match[l] - L);
}
for (int l = 0; l < L; ++l) {
if (bm.match[l] >= 0) continue;
int c = cmp_map[scc.cmp[l]];
groups[c].first.push_back(l);
}
for (int r = 0; r < R; ++r) {
if (bm.match[L + r] >= 0) continue;
int c = cmp_map[scc.cmp[L + r]];
groups[c].second.push_back(r);
}
return groups;
}
template<typename T>
vector<int>nibu_graph(const Graph<T>&g){
int n=g.size();
vector<int>t(n,-1);
queue<int>que;
for(ll i=0;i<n;i++){
if(t[i]!=-1)continue;
que.push(i);
t[i]=0;
while(!que.empty()){
auto p=que.front();que.pop();
for(auto e:g[p]){
if(t[e.to]==-1){
que.push(e.to);
t[e.to]=t[p]^e.cost;
}
else if(t[p]!=t[e.to]^e.cost)return vector<int>();
}
}
}
return t;
}
template<typename T>
vector<pair<bool,vector<vector<int>>>>nibu_graph_con(const Graph<T>&g){
int n=g.size();
vector<pair<bool,vector<vector<int>>>>v;
vector<int>t(n,-1);
queue<int>que;
for(ll i=0;i<n;i++){
if(t[i]!=-1)continue;
que.emplace(i);
v.emplace_back(true,vector<vector<int>>(2));
t[i]=0;
while(!que.empty()){
auto p=que.front();que.pop();
v.back().second[t[p]].push_back(p);
for(auto e:g[p]){
if(t[e.to]==-1){
que.push(e.to);
t[e.to]=t[p]^e.cost;
}
else if(t[p]!=t[e.to]^e.cost)v.back().first=false;
}
}
}
return v;
}
int main(){
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
ll res=0,buf=0;
bool judge = true;
ll n;cin>>n;
auto g=readGraph<int>(n,n-1);
auto t=nibu_graph(g);
int L=0,R=0;
vector<int>idx(n);
vector<pair<int,int>>edges;
rep(i,0,n){
if(t[i]==0)idx[i]=L++;
else idx[i]=R++;
}
rep(i,0,n){
for(auto to:g[i]){
if(t[i]==0){
edges.EB(idx[i],idx[to]);
}
}
}
auto dm=dulmage_mendelsohn(L,R,edges);
ll ret=n;
for(auto z:dm)ret-=min(z.fi.size(),z.se.size());
ll mx=0;
for(auto z:dm)chmax(mx,abs((ll)z.fi.size()-(ll)z.se.size()));
cout<<ret-mx<<endl;
return 0;
}