text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int INF32 = 0x3f3f3f3f;
const long long INF64 = 0x3f3f3f3f3f3f3f3f;
const int mod2 = 1e9 + 9;
const int mod = 998244353;
const int N = 1e5 + 5;
int cnt;
vector<int> g[N], a[2];
int vis[N], col[N];
void dfs(int now, int color) {
++cnt;
a[color].emplace_back(now);
col[now] = color;
++vis[now];
for (int i : g[now]) {
if (!vis[i])
dfs(i, 1 - color);
else if (col[i] == color) {
cout << -1 << '\n';
exit(0);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
int u, v;
for (int i = 0; i < m; ++i) {
cin >> u >> v;
g[u].emplace_back(v);
g[v].emplace_back(u);
}
for (int i = 1; i <= n; ++i) {
if (!vis[i] && !g[i].empty()) dfs(i, 1);
}
cout << a[0].size() << '\n';
for (int i : a[0]) cout << i << ' ';
cout << '\n';
cout << a[1].size() << '\n';
for (int i : a[1]) cout << i << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> Neighbs[100000];
short int Clr[100000];
bool bfs(int root) {
queue<int> Q;
Q.push(root);
Clr[root] = 1;
while (Q.size()) {
int front = Q.front();
Q.pop();
short int color = -Clr[front];
for (auto it : Neighbs[front]) {
if (!Clr[it])
Clr[it] = color, Q.push(it);
else if (Clr[it] != color)
return 0 * printf("-1");
}
}
return 1;
}
int main() {
int n, m;
scanf("%i%i", &n, &m);
while (m--) {
int u, v;
scanf("%i%i", &u, &v);
--u, --v;
Neighbs[u].push_back(v);
Neighbs[v].push_back(u);
}
for (int i = 0; i < n; i++)
if (!Clr[i] && !bfs(i)) return 0;
int count = 0;
for (int i = 0; i < n; i++)
if (Clr[i] == -1) count++;
printf("%i\n", count);
for (int i = 0; i < n; i++)
if (Clr[i] == -1) printf("%i ", i + 1);
printf("\n%i\n", n - count);
for (int i = 0; i < n; i++)
if (Clr[i] == 1) printf("%i ", i + 1);
}
|
#include <bits/stdc++.h>
using namespace std;
bool visited[100001] = {0};
int color[100001];
std::vector<long long> v[100001];
long long ar = 0;
long long pa = 0;
bool isBipartite(std::vector<long long> *G, long long src, long long V) {
std::vector<long long>::iterator it;
color[src] = 1;
ar++;
visited[src] = true;
queue<long long> q;
q.push(src);
while (!q.empty()) {
long long u = q.front();
q.pop();
visited[u] = true;
for (it = G[u].begin(); it != G[u].end(); ++it) {
if (!color[*it]) {
if (color[u] == 2)
color[*it] = 1;
else
color[*it] = 2;
if (color[*it] == 2) {
pa++;
} else
ar++;
q.push(*it);
visited[*it] = true;
} else if (color[*it] == color[u])
return false;
}
}
return true;
}
int main() {
long long m, n;
cin >> n >> m;
set<long long> arya;
set<long long> pari;
long long a, b;
set<long long> se;
for (int i = 0; i < m; ++i) {
cin >> a >> b;
se.insert(a - 1);
se.insert(b - 1);
v[a - 1].push_back(b - 1);
v[b - 1].push_back(a - 1);
}
set<long long>::iterator sei;
bool x = 0;
for (sei = se.begin(); sei != se.end(); ++sei) {
if (!visited[*sei]) {
if (!isBipartite(v, *sei, n)) {
x = 1;
break;
}
}
}
if (x) {
cout << -1 << endl;
} else {
cout << ar << endl;
for (long long i = 0; i < n; ++i) {
if (color[i] == 1 && visited[i]) {
cout << i + 1 << " ";
}
}
cout << "\n" << pa << endl;
for (long long i = 0; i < n; ++i) {
if (color[i] == 2 && visited[i]) {
cout << i + 1 << " ";
}
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.141592653589793;
template <template <typename> class Array, typename T>
void outArray(Array<T>& a) {
auto it = a.begin();
for (; it != a.end(); it++) {
cout << (*it) << " ";
}
cout << "\n";
}
template <typename T>
void outVector(vector<T>& a) {
for (int i = 0; i < a.size(); i++) {
cout << a[i] + 1 << " ";
}
cout << "\n";
}
void dfs(int v, int depth, vector<vector<int>>& a, vector<int>& color,
bool& ok) {
color[v] = depth % 2;
for (int i = 0; i < a[v].size(); i++) {
if (color[a[v][i]] == -1) {
dfs(a[v][i], depth + 1, a, color, ok);
} else if (color[a[v][i]] == color[v]) {
ok = false;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
vector<vector<int>> a(n);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--, y--;
a[x].push_back(y);
a[y].push_back(x);
}
vector<int> color(n, -1);
bool ok = true;
for (int i = 0; i < n; i++) {
if (color[i] == -1) {
dfs(i, 0, a, color, ok);
}
}
vector<int> ans1, ans2;
for (int i = 0; i < n; i++) {
if (color[i]) {
ans1.push_back(i);
} else {
ans2.push_back(i);
}
}
if (ok) {
cout << ans1.size() << "\n";
outVector(ans1);
cout << ans2.size() << "\n";
outVector(ans2);
} else {
cout << "-1\n";
}
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = (int)(1e8);
const int inf = (int)(1e9);
using namespace std;
vector<int> e[100100];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
e[u].push_back(v);
e[v].push_back(u);
}
vector<char> part(n, -1);
bool ok = 1;
vector<int> q(n);
for (int st = 0; st < n; st++)
if (part[st] == -1) {
int h = 0, t = 0;
q[t++] = st;
part[st] = 0;
while (h < t) {
int v = q[h++];
for (int i = 0; i < e[v].size(); i++) {
int to = e[v][i];
if (part[to] == -1) {
part[to] = !part[v];
q[t++] = to;
} else
ok &= part[to] != part[v];
}
}
}
if (!ok) {
cout << -1;
return 0;
}
vector<int> p1, p2;
for (int i = 0; i < n; i++) {
if (!part[i])
p1.push_back(i + 1);
else
p2.push_back(i + 1);
}
cout << p1.size() << '\n';
for (int i = 0; i < p1.size(); i++) cout << p1[i] << ' ';
cout << '\n';
cout << p2.size() << '\n';
for (int i = 0; i < p2.size(); i++) cout << p2[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100001];
int n, m;
vector<int> ans1;
vector<int> ans2;
int colour[100001];
bool ok = 1;
vector<int> visited(100001);
void dfs(int v, int p = -1, int col = 0) {
visited[v] = 1;
if (ok == 0) return;
colour[v] = col;
for (auto it : adj[v]) {
if (it == p)
continue;
else if (visited[it]) {
if (colour[v] == colour[it]) ok = 0;
} else {
dfs(it, v, col ^ 1);
}
}
}
void solve() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) dfs(i);
}
if (ok == 0) {
cout << -1 << endl;
return;
}
for (int i = 1; i <= n; i++) {
if (colour[i] == 0)
ans1.push_back(i);
else
ans2.push_back(i);
}
cout << ans1.size() << endl;
for (auto it : ans1) cout << it << " ";
cout << endl;
cout << ans2.size() << endl;
for (auto it : ans2) cout << it << " ";
cout << endl;
}
int main() {
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int black = 0;
const int red = 1;
const int N = 1e5 + 10;
int vis[N];
int color[N];
vector<int> graph[N];
vector<int> ver[2];
bool isTwoColor;
void init() {
memset(vis, 0, sizeof(vis));
memset(color, 0, sizeof(color));
isTwoColor = true;
}
void DFS(int v) {
vis[v] = 1;
ver[color[v]].push_back(v);
for (int i = 0; i < graph[v].size(); i++) {
if (!vis[graph[v][i]]) {
color[graph[v][i]] = color[v] ^ 1;
DFS(graph[v][i]);
} else if (color[graph[v][i]] == color[v]) {
isTwoColor = false;
}
}
}
int main() {
int n, k, a, b;
scanf("%d%d", &n, &k);
init();
for (int i = 0; i < k; i++) {
scanf("%d%d", &a, &b);
graph[a].push_back(b);
graph[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
DFS(i);
}
}
if (isTwoColor) {
int len = ver[0].size();
printf("%d\n", len);
for (int i = 0; i < len - 1; i++) {
printf("%d ", ver[0][i]);
}
printf("%d\n", ver[0][len - 1]);
len = ver[1].size();
printf("%d\n", len);
for (int i = 0; i < len - 1; i++) {
printf("%d ", ver[1][i]);
}
printf("%d\n", ver[1][len - 1]);
} else
printf("-1\n");
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 100000 + 5;
int N, M;
int par[MN];
int rel[MN];
int color[MN];
int find(int n) {
if (par[n] == n) return n;
int p = find(par[n]);
rel[n] ^= rel[par[n]];
return par[n] = p;
}
bool merge(int a, int b) {
int p1 = find(a);
int p2 = find(b);
if (p1 != p2) {
par[p2] = p1;
rel[p2] = rel[a] ^ rel[b] ^ 1;
return false;
} else {
if (rel[a] ^ rel[b] == 0) return true;
return false;
}
}
vector<int> A, B;
int main() {
scanf("%d%d", &N, &M);
for (int i = 0; i < N; i++) par[i] = i;
for (int i = 0; i < M; i++) {
int(a);
scanf("%d", &(a));
int(b);
scanf("%d", &(b));
;
a--, b--;
if (merge(a, b)) {
printf("-1\n");
return 0;
}
}
int cnt = 0;
for (int i = 0; i < N; i++)
if (par[i] == i) {
color[i] = cnt;
cnt ^= 1;
}
for (int i = 0; i < N; i++)
if (par[i] != i) {
int p = find(i);
color[i] = color[p] ^ rel[i];
}
for (int i = 0; i < N; i++) {
if (color[i]) {
A.push_back(i);
} else {
B.push_back(i);
}
}
printf("%d\n", A.size());
for (auto &n : A) printf("%d ", n + 1);
printf("\n%d\n", B.size());
for (auto &n : B) printf("%d ", n + 1);
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, m;
scanf("%d%d", &n, &m);
std::vector<std::vector<int>> graph(n);
for (int i = 0; i < m; ++i) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
graph.at(a).push_back(b);
graph.at(b).push_back(a);
}
std::vector<int> color(n, -1);
bool ok = true;
for (int s = 0; s < n && ok; ++s) {
if (!~color[s]) {
std::vector<int> queue;
queue.push_back(s);
color[s] = 0;
for (int h = 0; h < static_cast<int>(queue.size()); ++h) {
auto u = queue[h];
for (int v : graph.at(u)) {
if (!~color[v]) {
color[v] = color[u] ^ 1;
queue.push_back(v);
}
ok &= color[u] != color[v];
}
}
}
}
if (ok) {
std::vector<std::vector<int>> result(2);
for (int i = 0; i < n; ++i) {
result[color[i]].push_back(i);
}
for (int i = 0; i < 2; ++i) {
printf("%d\n", static_cast<int>(result[i].size()));
for (auto&& v : result[i]) {
printf("%d ", v + 1);
}
puts("");
}
} else {
puts("-1");
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg, typename... Args>
inline void input(Arg& arg, Args&... args) {
cin >> arg;
(void)(int[]){0, (void(cin >> args), 0)...};
}
template <typename Arg, typename... Args>
inline void printErr(Arg&& arg, Args&&... args) {
cerr << arg;
(void)(int[]){0, (void(cerr << " "
<< "\033[1;41m"
<< ","
<< "\033[0m"
<< " " << args),
0)...};
cerr << '\n';
};
template <class T, class... U>
void dbg(const char* sdbg, T h, U... a) {
cerr << "\033[1;31m"
<< "Debug: "
<< "\033[0m";
cerr << sdbg;
cerr << " "
<< "\033[1;41m"
<< "="
<< "\033[0m"
<< " ";
printErr(h, a...);
}
template <class S, class T>
ostream& operator<<(ostream& os, const pair<S, T>& p) {
return os << "pair(" << p.first << "\033[1;31m"
<< ", "
<< "\033[0m" << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& p) {
os << "\033[1;32m"
<< "vector[ "
<< "\033[0m";
for (const auto& it : p)
os << it << "\033[1;31m"
<< ", "
<< "\033[0m";
return os << "\033[1;32m"
<< "]"
<< "\033[0m";
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& p) {
os << "\033[1;32m"
<< "set[ ";
for (auto& it : p)
os << it << "\033[1;31m"
<< ", "
<< "\033[0m";
return os << "\033[1;32m"
<< "]"
<< "\033[0m";
}
template <class S, class T>
ostream& operator<<(ostream& os, const map<S, T>& p) {
os << "\033[1;32m"
<< "map[ "
<< "\033[0m";
for (auto& it : p)
os << it << "\033[1;31m"
<< ", "
<< "\033[0m";
return os << "\033[1;32m"
<< "]"
<< "\033[0m";
}
template <class T>
void dbgIter(const char* sdbg, T a, T b) {
cerr << "\033[1;31m"
<< "Debug: "
<< "\033[0m";
cerr << sdbg;
cerr << "\033[1;31m"
<< " = "
<< "\033[0m";
cerr << "[";
for (T i = a; i != b; ++i) {
if (i != a) cerr << ", ";
cerr << *i;
}
cerr << "]\n";
}
template <typename T>
using min_heap = priority_queue<T, std::vector<T>, std::greater<T>>;
template <typename T>
using max_heap = priority_queue<T>;
template <typename T, typename S>
inline bool contains(map<T, S> map1, S value1) {
return map1.find(value1) != map1.end();
}
template <typename T, typename S>
inline bool contains(T container1, S value1) {
return container1.find(value1) != container1.end();
}
struct DFSData {
vector<bool> visited;
vector<int32_t> parity;
DFSData(int32_t vertices) {
visited.resize(vertices, false);
parity.resize(vertices, -1);
}
};
struct Graph {
struct GraphNode {
int32_t vertex, link;
GraphNode() : vertex{0}, link{0} {}
GraphNode(int32_t v1, int32_t l1) : vertex{v1}, link{l1} {}
};
vector<GraphNode> adj;
vector<int32_t> head;
Graph(int32_t vertices) { head.resize(vertices, -1); }
void add_edge(int32_t v1, int32_t v2) {
adj.emplace_back(v2, head[v1]);
head[v1] = adj.size() - 1;
adj.emplace_back(v1, head[v2]);
head[v2] = adj.size() - 1;
}
bool dfs(int32_t v1, DFSData& d, int32_t parity) {
if (d.visited[v1]) {
if (d.parity[v1] != parity) return false;
return true;
}
d.visited[v1] = true;
d.parity[v1] = parity;
bool success = true;
int32_t j = head[v1];
for (; j != -1; j = adj[j].link) {
success &= dfs(adj[j].vertex, d, !parity);
}
return success;
}
};
void solve() {
int32_t n, m;
cin >> n >> m;
int32_t v1, v2;
Graph gh(n + 1);
for (int64_t(i) = (0); (i) < (m); ++(i)) {
input(v1, v2);
gh.add_edge(v1, v2);
}
DFSData dfs_data(n + 1);
for (int64_t(i) = (1); (i) <= (n); ++(i)) {
if (dfs_data.visited[i]) continue;
if (gh.dfs(i, dfs_data, 0) == false) {
cout << "-1\n";
return;
}
}
vector<int32_t> vertexCover[2];
for (int64_t(i) = (1); (i) <= (n); ++(i)) {
if (gh.head[i] == (-1)) continue;
vertexCover[dfs_data.parity[i]].push_back(i);
}
for (int64_t(i) = (0); (i) < (2); ++(i)) {
cout << vertexCover[i].size() << '\n';
for (const int32_t& j : vertexCover[i]) cout << j << " ";
cout << '\n';
}
}
int32_t main() {
std::ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout.precision(20);
cout << fixed;
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100001];
int color[100001];
vector<int> set1, set2;
int n, m;
bool isBipartite(int i) {
bool answer = true;
for (int j = 0; j < g[i].size(); j++) {
if (color[i] == color[g[i][j]])
return false;
else if (color[g[i][j]] == 0) {
color[g[i][j]] = 3 - color[i];
answer = answer && isBipartite(g[i][j]);
}
}
if (color[i] == 1)
set1.push_back(i);
else if (color[i] == 2)
set2.push_back(i);
return answer;
}
bool bipartiteCheck() {
for (int i = 1; i <= n; i++) {
if (color[i] == 0 && g[i].size() > 0) {
color[i] = 1;
if (!isBipartite(i)) return false;
}
}
return true;
}
int main() {
int u, v;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
if (bipartiteCheck()) {
cout << set1.size() << endl;
for (int i = 0; i < set1.size(); i++) {
cout << set1[i] << " ";
}
cout << endl;
cout << set2.size() << endl;
for (int i = 0; i < set2.size(); i++) {
cout << set2[i] << " ";
}
} else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int bfs(vector<vector<int> > &g, vector<int> &vis, int s) {
queue<int> q;
vis[s] = 1;
q.push(s);
while (!q.empty()) {
int x = q.front();
q.pop();
if (vis[x] == 1) {
for (int i = 0; i < g[x].size(); i++) {
if (vis[g[x][i]] == 0) {
q.push(g[x][i]);
vis[g[x][i]] = 2;
} else if (vis[g[x][i]] == 1)
return -1;
}
} else {
for (int i = 0; i < g[x].size(); i++) {
if (vis[g[x][i]] == 0) {
q.push(g[x][i]);
vis[g[x][i]] = 1;
} else if (vis[g[x][i]] == 2)
return -1;
}
}
}
return 1;
}
int main() {
int n, m, u, v;
cin >> n >> m;
vector<vector<int> > g(n + 1, vector<int>());
for (int i = 0; i < m; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
vector<int> vis(n + 1, 0);
for (int i = 1; i <= n; i++) {
if (g[i].size() > 0 && (vis[i] == 0)) {
int x = bfs(g, vis, i);
if (x == -1) {
cout << "-1" << endl;
return 0;
}
}
}
vector<int> b, G;
for (int i = 1; i <= n; i++) {
if (vis[i] == 1) b.push_back(i);
if (vis[i] == 2) G.push_back(i);
}
cout << b.size() << endl;
for (int i = 0; i < b.size(); i++) cout << b[i] << " ";
cout << endl;
cout << G.size() << endl;
for (int i = 0; i < G.size(); i++) cout << G[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g;
int n, m;
vector<int> col;
bool dfs(int v, int c) {
if (col[v] != -1) {
return c == col[v];
}
col[v] = c;
for (int u : g[v]) {
if (!dfs(u, c ^ 1)) return false;
}
return true;
}
int main() {
cin >> n >> m;
g = vector<vector<int> >(n);
for (int i = 0; i < (int)(m); i++) {
int x, y;
scanf("%d %d", &x, &y);
x--, y--;
g[x].push_back(y);
g[y].push_back(x);
}
col = vector<int>(n, -1);
for (int i = 0; i < (int)(n); i++) {
if (col[i] == -1) {
if (!dfs(i, 0)) {
cout << -1 << endl;
return 0;
}
}
}
vector<vector<int> > ans(2);
for (int i = 0; i < (int)(n); i++) ans[col[i]].push_back(i);
for (int c = 0; c < (int)(2); c++) {
cout << ans[c].size() << endl;
for (int v : ans[c]) {
printf("%d ", v + 1);
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool col[100005], vis[100005];
vector<int> g[100005];
bool bad;
void dfs(int u) {
vis[u] = true;
for (auto v : g[u]) {
if (vis[v]) {
if (col[u] == col[v]) {
bad = true;
}
} else {
col[v] = 1 - col[u];
dfs(v);
}
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d %d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
col[i] = 0;
dfs(i);
}
}
vector<int> A, B;
for (int i = 1; i <= n; ++i) {
if (col[i]) {
A.push_back(i);
} else {
B.push_back(i);
}
}
if (bad) {
printf("-1");
} else {
printf("%d\n", (int)A.size());
for (auto x : A) {
printf("%d ", x);
}
printf("\n");
printf("%d\n", (int)B.size());
for (auto x : B) {
printf("%d ", x);
}
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char ch = getchar();
bool positive = 1;
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') positive = 0;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline char RC() {
char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
return c;
}
inline long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline long long lcm(long long a, long long b, long long MOD) {
return a / gcd(a, b) * b % MOD;
}
inline long long Sub(long long x, long long y, long long mod) {
long long res = x - y;
while (res < 0) res += mod;
return res;
}
inline long long Add(long long x, long long y, long long mod) {
long long res = x + y;
while (res >= mod) res -= mod;
return res;
}
inline long long POW_MOD(long long x, long long y, long long mod) {
long long ret = 1;
while (y > 0) {
if (y & 1) ret = ret * x % mod;
x = x * x % mod;
y >>= 1;
}
return ret;
}
const int N = 100000 + 50;
const int inf = 2100000000;
const long long INF = 1LL << 60;
const double PI = 3.14159265358;
int p[N], deg[N], col[N];
bool vis[N];
vector<int> e[N], A, B;
bool cmp(const int& x, const int& y) { return deg[x] > deg[y]; }
bool dfs(int u) {
bool flag = true;
for (int v : e[u]) {
if (!vis[v]) {
vis[v] = true;
col[v] = !col[u];
flag &= dfs(v);
} else {
if (col[v] == col[u]) {
flag = false;
}
}
}
return flag;
}
int main() {
int n, m;
memset(col, -1, sizeof(col));
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
deg[u]++, deg[v]++;
}
for (int i = 1; i <= n; ++i) p[i] = i;
sort(p + 1, p + n + 1, cmp);
bool flag = true;
for (int i = 1; i <= n && flag; ++i) {
int u = p[i];
if (col[u] == -1) col[u] = 1;
vis[u] = true;
flag &= dfs(u);
}
for (int i = 1; i <= n; ++i) {
if (col[i])
A.push_back(i);
else
B.push_back(i);
}
if (flag) {
cout << A.size() << endl;
for (int v : A) {
cout << v << " ";
}
cout << endl;
cout << B.size() << endl;
for (int v : B) {
cout << v << " ";
}
cout << endl;
} else {
cout << "-1" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct vertex {
int a, b;
};
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<vertex> vec(m);
for (int i = 0; i < m; i++) cin >> vec[i].a >> vec[i].b;
vector<vector<int> > g(n + 1);
vector<int> color(n + 1);
for (int i = 0; i < m; i++) {
g[vec[i].a].push_back(vec[i].b);
g[vec[i].b].push_back(vec[i].a);
}
vector<int> par_color(n + 1);
for (int d = 1; d <= n; d++) {
if (!color[d]) {
if (g[d].empty()) continue;
stack<int> st;
st.push(d);
int col = 1;
color[d] = 1;
vector<int> par(n + 1);
par[d] = -1;
par_color[d] = 1;
while (st.size()) {
int node = st.top();
st.pop();
color[node] = 3 - par_color[node];
int sz = g[node].size();
for (int i = 0; i < sz; i++) {
int to = g[node][i];
if (!color[to]) {
st.push(to);
par[to] = node;
par_color[to] = color[node];
} else if (color[to] == color[node] && par[node] != to) {
cout << -1;
return 0;
}
}
}
}
}
vector<int> red, blue;
for (int i = 1; i <= n; i++) {
if (color[i] == 1)
red.push_back(i);
else if (color[i] == 2)
blue.push_back(i);
}
if (red.size() == 0 || blue.size() == 0) {
cout << -1;
return 0;
}
int sz = red.size();
cout << sz << "\n";
for (int i = 0; i < sz; i++) {
cout << red[i] << " ";
}
sz = blue.size();
cout << "\n" << sz << "\n";
for (int i = 0; i < sz; i++) {
cout << blue[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100000];
vector<int> multitude[2];
int f[100000] = {};
bool dfs(int d, int color = 0) {
multitude[color].push_back(d);
f[d] = 1 + color;
for (auto u : v[d]) {
if (!f[u] && dfs(u, 1 - color)) return 1;
if (f[u] != 1 + 1 - color) return 1;
}
return 0;
}
int main() {
int n, m, i;
cin >> n >> m;
for (i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
v[a].push_back(b);
v[b].push_back(a);
}
for (i = 0; i < n; i++) {
if (!f[i] && dfs(i)) {
cout << "-1";
return 0;
}
}
for (i = 0; i < 2; i++) {
cout << multitude[i].size() << "\n";
for (auto v : multitude[i]) cout << v + 1 << " ";
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
return b ? gcd(b, a % b) : a;
}
long long int lcm(long long int a, long long int b) {
return a * b / gcd(a, b);
}
const int N = 1e5 + 10;
int n, m, col[N];
vector<int> ad[N];
void dfs(int v, int c) {
col[v] = c;
for (auto u : ad[v]) {
if (col[u] == c && col[u] != 0) {
cout << -1 << endl;
exit(0);
}
if (col[u] == 0) dfs(u, 3 - c);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
clock_t z = clock();
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
ad[x].push_back(y);
ad[y].push_back(x);
}
for (int i = 1; i <= n; i++)
if (col[i] == 0) dfs(i, 1);
vector<int> a, b;
for (int i = 1; i <= n; i++)
if (col[i] == 1)
a.push_back(i);
else
b.push_back(i);
cout << (int)a.size() << endl;
for (auto i : a) cout << i << " ";
cout << endl;
cout << (int)b.size() << endl;
for (auto i : b) cout << i << " ";
cout << endl;
fprintf(stderr, "Total Time: %.3f\n", (double)(clock() - z) / CLOCKS_PER_SEC),
fflush(stderr);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int N = 100010;
int col[N];
vector<int> g[N];
bool bfs(int s, int n) {
queue<int> p;
p.push(s);
col[s] = 1;
while (!p.empty()) {
int from = p.front();
p.pop();
for (int i = 0; i < g[from].size(); i++) {
if (col[g[from][i]] == -1) {
p.push(g[from][i]);
col[g[from][i]] = !col[from];
}
if (col[from] == col[g[from][i]]) return false;
}
}
return true;
}
int main() {
int n, m, a, b, i;
memset(col, -1, sizeof(col));
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
bool flag = false;
for (i = 1; i <= n; i++)
if (col[i] == -1 && !bfs(i, n)) {
flag = true;
break;
}
if (flag)
cout << "-1" << endl;
else {
vector<int> v[5];
for (i = 1; i <= n; i++) {
if (col[i] == -1)
continue;
else
v[col[i]].push_back(i);
}
cout << v[0].size() << endl;
for (i = 0; i < v[0].size(); i++) cout << v[0][i] << ' ';
cout << endl;
cout << v[1].size() << endl;
for (i = 0; i < v[1].size(); i++) cout << v[1][i] << ' ';
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100001];
int n, m;
vector<int> ans1;
vector<int> ans2;
int colour[100001];
bool ok = 1;
vector<int> visited(100001);
void dfs(int v, int p = -1, int col = 0) {
visited[v] = 1;
if (ok == 0) return;
colour[v] = col;
for (auto it : adj[v]) {
if (it == p)
continue;
else if (visited[it]) {
if (colour[v] == colour[it]) ok = 0;
} else {
dfs(it, v, col ^ 1);
}
}
}
void solve() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) dfs(i);
}
if (ok == 0) {
cout << -1 << endl;
return;
}
for (int i = 1; i <= n; i++) {
if (colour[i] == 0)
ans1.push_back(i);
else
ans2.push_back(i);
}
cout << ans1.size() << endl;
for (auto it : ans1) cout << it << " ";
cout << endl;
cout << ans2.size() << endl;
for (auto it : ans2) cout << it << " ";
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long INF = 1e18;
const double PI = acos(-1);
const long long tam = 1000100;
const long long MOD = 1e9 + 7;
const long long cmplog = 29;
int hijos[tam];
vector<int> g[tam];
pair<long long, long long> pcen;
int n;
void dfs(int u, int pa) {
hijos[u] = 1;
int maxx = 0;
for (int w : g[u]) {
if (w == pa) continue;
dfs(w, u);
hijos[u] += hijos[w];
maxx = max(maxx, hijos[w]);
}
maxx = max(maxx, n - hijos[u]);
pcen = min(pcen, pair<long long, long long>(maxx, u));
}
vector<pair<long long, long long> > queries[tam];
set<int> sdown[tam];
void dfs2(int u, int pa, int idx) {
hijos[u] = 1;
for (int w : g[u]) {
if (w == pa) continue;
dfs2(w, u, idx);
hijos[u] += hijos[w];
}
int pup = n - hijos[u];
queries[idx].push_back({pup, u});
sdown[idx].insert(hijos[u]);
}
int mejor(multiset<int> &s, int precio) {
auto it = s.upper_bound(precio / 2);
int ans = precio;
if (it != s.end()) {
ans = min(ans, max(precio - *it, *it));
}
if (it != s.begin()) {
it--;
ans = min(ans, max(precio - *it, *it));
}
return ans;
}
bool fans[tam];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
int iz, der;
for (long long i = 0; i < n - 1; i++) {
cin >> iz >> der;
g[iz].push_back(der);
g[der].push_back(iz);
}
pcen = pair<long long, long long>(n, n);
dfs(1, 1);
int ucen = pcen.second;
multiset<int> siz, sder;
for (long long i = 0; i < g[ucen].size(); i++) {
int w = g[ucen][i];
dfs2(w, ucen, i);
}
for (long long idx = 0; idx < g[ucen].size(); idx++) {
for (int xx : sdown[idx]) sder.insert(xx);
}
fans[ucen] = 1;
for (long long idx = 0; idx < g[ucen].size(); idx++) {
for (int xx : sdown[idx]) {
sder.erase(sder.find(xx));
}
for (auto par : queries[idx]) {
int u = par.second;
int pup = par.first;
int bst = min(mejor(siz, pup), mejor(sder, pup));
int otro = n - hijos[g[ucen][idx]];
bst = min(bst, max(pup - otro, otro));
if (bst <= n / 2)
fans[u] = 1;
else
fans[u] = 0;
}
for (int xx : sdown[idx]) {
siz.insert(xx);
}
}
for (long long i = 1; i < n + 1; i++) cout << fans[i] << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4e5 + 5;
int n, size[MAXN], hev[MAXN], down[MAXN], up[MAXN];
int tot, Last[MAXN], Go[MAXN * 2], Next[MAXN * 2];
void link(int u, int v) { Next[++tot] = Last[u], Last[u] = tot, Go[tot] = v; }
void dfs1(int now, int pre) {
size[now] = 1;
for (int p = Last[now]; p; p = Next[p]) {
int v = Go[p];
if (v == pre) continue;
dfs1(v, now);
size[now] += size[v];
down[now] = max(down[now], (size[v] <= n / 2) ? size[v] : down[v]);
hev[now] = max(hev[now], size[v]);
}
}
void dfs2(int now, int pre) {
multiset<int> d;
for (int p = Last[now]; p; p = Next[p]) {
int v = Go[p];
if (v != pre) d.insert((size[v] <= n / 2) ? size[v] : down[v]);
}
for (int p = Last[now]; p; p = Next[p]) {
int v = Go[p];
if (v == pre) continue;
if (n - size[v] <= n / 2)
up[v] = max(up[v], n - size[v]);
else {
up[v] = max(up[v], up[now]);
d.erase(d.find(size[v] <= n / 2 ? size[v] : down[v]));
if (!d.empty()) up[v] = max(up[v], *d.rbegin());
d.insert((size[v] <= n / 2) ? size[v] : down[v]);
}
dfs2(v, now);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
link(u, v), link(v, u);
}
dfs1(1, 0);
dfs2(1, 0);
for (int i = 1; i <= n; i++) {
int ans = 1;
if (n - size[i] > n / 2) ans = (n - size[i] - up[i] <= n / 2);
if (hev[i] > n / 2) ans = (hev[i] - down[i] <= n / 2);
printf("%d ", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class S, class T>
istream& operator>>(istream& is, pair<S, T>& p) {
return is >> p.first >> p.second;
}
const double EPS = 1e-10;
const double PI = acos(-1.0);
const long long MOD = 1e9 + 7;
vector<int> G[400000];
int par[400000];
int sz[400000];
int N;
void init(int u, int p = -1) {
sz[u] = 1;
par[u] = p;
for (int to : G[u]) {
if (to == p) continue;
init(to, u);
sz[u] += sz[to];
}
}
int cent(int u) {
bool ok = true;
for (int to : G[u]) {
if (to == par[u]) continue;
if (sz[to] > N / 2) ok = false;
}
ok = ok && (N - sz[u] <= N / 2);
if (ok) return u;
int res = -1;
for (int to : G[u]) {
if (to == par[u]) continue;
res = cent(to);
if (res != -1) break;
}
return res;
}
int ans[400000];
void dfs(int u, int p, int ix, int c) {
if (ix > 0)
ans[u] = N - sz[u] - sz[G[c][0]] <= N / 2;
else
ans[u] = (N - sz[G[c][0]] <= N / 2) ||
(N - sz[u] - (int((G[c]).size()) > 1 ? sz[G[c][1]] : 0) <= N / 2);
for (int to : G[u]) {
if (to == p) continue;
dfs(to, u, ix, c);
}
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cin >> N;
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);
}
init(0);
int c = cent(0);
init(c);
ans[c] = 1;
sort((G[c]).begin(), (G[c]).end(),
[&](int i, int j) { return sz[i] > sz[j]; });
for (int i = (0); i < (int((G[c]).size())); ++i) {
dfs(G[c][i], c, i, c);
}
for (int i = (0); i < (N); ++i) cout << (i ? " " : "") << ans[i];
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double inff = 1.0 / 0.0;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
long long int x, y, n, i, z, j, k, w, u, q, m, d, t, g;
long long int isCentroid[400010], siz[400010], ans[400010];
long long int centroid, min_til;
vector<pair<long long int, long long int> > subtree;
vector<long long int> adj[400010];
void dfs(long long int src, long long int p) {
siz[src] = 1;
long long int mx = 0;
for (auto a : adj[src]) {
if (a != p) {
dfs(a, src);
siz[src] += siz[a];
mx = max(mx, siz[a]);
}
}
mx = max(n - siz[src], mx);
if (mx < min_til) {
min_til = mx;
centroid = src;
}
}
void dfs1(long long int cap, long long int src, long long int head,
long long int p) {
if (cap <= n / 2) {
ans[src] = 1;
goto hell;
}
for (int i = 0; i < min(2ll, (long long int)subtree.size()); i++) {
if (subtree[i].second != head and
n - siz[subtree[i].second] - siz[src] <= n / 2)
ans[src] = 1;
}
hell:
for (auto a : adj[src]) {
if (a != p) {
dfs1(cap, a, head, src);
}
}
}
void solve() {
cin >> n;
for (i = (long long int)0; i < (long long int)n - 1; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
min_til = 1e18;
dfs(1, -1);
ans[centroid] = true;
dfs(centroid, centroid);
for (auto a : adj[centroid]) {
subtree.push_back({siz[a], a});
}
sort(subtree.begin(), subtree.end());
reverse(subtree.begin(), subtree.end());
for (i = (long long int)0; i < (long long int)(long long int)subtree.size();
i++) {
dfs1(n - subtree[i].first, subtree[i].second, subtree[i].second, centroid);
}
for (i = (long long int)1; i < (long long int)n + 1; i++) {
cout << ans[i] << " ";
}
cout << "\n";
}
int main() {
int TESTS = 1;
ios::sync_with_stdio(false), cout.tie(0), cin.tie(0);
;
while (TESTS--) {
solve();
}
}
|
#include <bits/stdc++.h>
const long long LL_INF = (long long)2e18 + 5;
using namespace std;
const long long N = 400010;
long long n;
vector<long long> adj[N], par(N), child(N), ans(N);
void dfs(long long v, long long par) {
child[v] = 1;
for (auto u : adj[v]) {
if (u == par) continue;
dfs(u, v);
child[v] += child[u];
}
}
long long centroid(long long v, long long p) {
for (auto u : adj[v]) {
if (u == p) continue;
if (child[u] <= n / 2) continue;
return centroid(u, v);
}
return v;
}
void dfs_for_cent(long long v, long long p) {
child[v] = 1;
if (p != -1) {
if (par[p] == -1)
par[v] = v;
else
par[v] = par[p];
}
for (auto u : adj[v]) {
if (u == p) continue;
dfs_for_cent(u, v);
child[v] += child[u];
}
}
void solve() {
cin >> n;
for (long long i = (long long)(0); i < (long long)(n - 1); i++) {
long long u, v;
cin >> u >> v;
u--, v--;
adj[u].push_back(v), adj[v].push_back(u);
}
dfs(0, -1);
long long cent = centroid(0, -1);
par[cent] = -1;
dfs_for_cent(cent, -1);
fill(ans.begin(), ans.end(), 0);
long long mx_1 = -1, mx_2 = -1, mx_ind = -1;
for (long long i = (long long)(0); i < (long long)(n); i++) {
if (par[i] == i) {
if (child[i] >= mx_1) {
if (child[i] == mx_1) {
if (mx_ind == -1)
mx_ind = i;
else
mx_ind = -2;
} else {
mx_ind = i;
}
mx_2 = mx_1, mx_1 = child[i];
} else if (child[i] >= mx_2)
mx_2 = child[i];
}
}
for (long long i = (long long)(0); i < (long long)(n); i++) {
if (i == cent) {
ans[i] = 1;
continue;
}
long long pr = par[i];
long long remain = 0;
if (pr == mx_ind) {
remain = max(child[pr] - child[i], mx_2);
} else
remain = mx_1;
long long sz = n - child[i] - remain;
if (sz <= n / 2)
ans[i] = 1;
else
ans[i] = 0;
}
for (long long i = (long long)(0); i < (long long)(n); i++)
cout << ans[i] << ' ';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
struct arr {
int x, y, next;
} edge[500007 * 2];
int ls[500007], n, tot, siz[500007], dp[500007][2], root;
bool f[500007];
void add(int x, int y) {
edge[++tot].x = x;
edge[tot].y = y;
edge[tot].next = ls[x];
ls[x] = tot;
}
int findroot(int x, int fa) {
int son = 1;
bool f = true;
for (int i = ls[x]; i; i = edge[i].next) {
int y = edge[i].y, z;
if (y == fa) continue;
z = findroot(y, x);
son += z;
if (z > n / 2) f = false;
}
if (n - son > n / 2) f = false;
if (f) root = x;
return son;
}
void refresh(int k, int x) {
if (k > n / 2) return;
if (k > dp[x][0]) {
int p = k;
k = dp[x][0];
dp[x][0] = p;
}
if (k > dp[x][1]) dp[x][1] = k;
}
void dfs1(int x, int fa) {
siz[x]++;
for (int i = ls[x]; i; i = edge[i].next) {
int y = edge[i].y;
if (y == fa) continue;
dfs1(y, x);
siz[x] += siz[y];
refresh(siz[y], x);
}
}
void dfs2(int x, int fa, int cnt) {
int fsiz = n - siz[x];
if (fsiz - cnt <= n / 2) f[x] = true;
if (fsiz <= n / 2) cnt = max(cnt, fsiz);
for (int i = ls[x]; i; i = edge[i].next) {
int y = edge[i].y;
if (y == fa) continue;
if (dp[x][0] == siz[y])
dfs2(y, x, max(cnt, dp[x][1]));
else
dfs2(y, x, max(cnt, dp[x][0]));
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
findroot(1, 0);
dfs1(root, 0);
dfs2(root, 0, 0);
for (int i = 1; i <= n; i++) printf("%d ", f[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
std::vector<int> edge[400005];
int cnt[400005];
int dp[400005];
int yes[400005];
int fa[400005];
int n;
void init(int u, int f) {
cnt[u] = 1;
for (int i = 0; i < edge[u].size(); i++) {
int v = edge[u][i];
if (v == f) continue;
init(v, u);
cnt[u] += cnt[v];
}
}
void dfs(int u, int f) {
int ok = 0;
int nmax = 0;
int p = 0;
for (int i = 0; i < edge[u].size(); i++) {
int v = edge[u][i];
if (v == f) continue;
if (cnt[v] > nmax) nmax = cnt[v], p = v;
if (cnt[v] > n / 2) ok = 1;
}
for (int i = 0; i < edge[u].size(); i++) {
int v = edge[u][i];
if (v == f) continue;
dfs(v, u);
}
if (ok) {
dp[u] = dp[p];
if (nmax - dp[u] > n / 2) yes[u] = 0;
} else {
if (cnt[u] > n / 2) {
dp[u] = nmax;
if (cnt[p] - 1 - dp[u] > n / 2) yes[u] = 0;
}
}
}
void dfs1(int u, int f) {
int ok = 0;
int p;
int nmax1 = 0, nmax2 = 0;
int p1 = 0, p2 = 0;
for (int i = 0; i < edge[u].size(); i++) {
int v = edge[u][i];
if (v == f) continue;
if (cnt[v] > nmax1) {
swap(nmax1, nmax2);
swap(p1, p2);
nmax1 = cnt[v];
p1 = v;
} else if (cnt[v] > nmax2) {
nmax2 = cnt[v];
p2 = v;
}
if (cnt[v] > n / 2) ok = 1, p = v;
}
if (n - cnt[u] > n / 2) ok = 1, p = u;
for (int i = 0; i < edge[u].size(); i++) {
int v = edge[u][i];
if (v == f) continue;
if (ok) {
if (p == u)
fa[v] = fa[u];
else
fa[v] = dp[p];
if (n - cnt[v] - fa[v] > n / 2) yes[v] = 0;
} else {
if (n - cnt[v] > n / 2) {
if (cnt[v] == nmax1) {
fa[v] = max(nmax2, n - cnt[u]);
} else {
fa[v] = max(nmax1, n - cnt[u]);
}
if (n - cnt[v] - fa[v] > n / 2) yes[v] = 0;
}
}
dfs1(v, u);
}
}
int main() {
cin >> n;
memset(dp, 0, sizeof dp);
for (int i = 1; i <= n; i++) yes[i] = 1;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
edge[u].push_back(v);
edge[v].push_back(u);
}
init(1, -1);
dfs(1, -1);
dfs1(1, -1);
for (int i = 1; i <= n; i++) {
cout << yes[i] << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400010;
int n, ans[N], where[N];
long long sz[N];
vector<int> v[N];
bool visit[N];
void init() {
scanf("%d", &n);
int a, b;
for (int i = 0; i < n - 1; ++i) {
scanf("%d %d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
}
void dfs(int now) {
visit[now] = true;
for (int i = 0; i < v[now].size(); ++i)
if (!visit[v[now][i]]) {
dfs(v[now][i]);
sz[now] += sz[v[now][i]];
}
if (sz[now] == 0)
sz[now] = 1;
else
sz[now] += 1;
}
int find_centroid(int now) {
visit[now] = true;
for (int i = 0; i < v[now].size(); ++i) {
if (visit[v[now][i]]) continue;
if (sz[v[now][i]] > n / 2) return find_centroid(v[now][i]);
}
return now;
}
void sv(int now, int value) {
if (visit[now]) return;
visit[now] = true;
where[now] = value;
for (int i = 0; i < v[now].size(); ++i) sv(v[now][i], value);
}
void dfs2(int now) {
visit[now] = true;
for (int i = 0; i < v[now].size(); ++i) sv(v[now][i], i);
}
void solve() {
dfs(1);
for (int i = 1; i <= n; ++i) visit[i] = false;
int centroid = find_centroid(1);
for (int i = 1; i <= n; ++i) visit[i] = false;
dfs2(centroid);
for (int i = 1; i <= n; ++i) {
visit[i] = false;
sz[i] = 0;
}
dfs(centroid);
vector<int> tmp;
for (int i = 0; i < v[centroid].size(); ++i)
tmp.push_back(sz[v[centroid][i]]);
int max1 = -1000000006, idx1, max2 = -1000000006, idx2;
for (int i = 0; i < tmp.size(); ++i)
if (tmp[i] > max1) {
max1 = tmp[i];
idx1 = i;
}
if ((n % 2 == 0) && max1 == n / 2)
max2 = n / 2;
else {
for (int i = 0; i < tmp.size(); ++i)
if (tmp[i] > max2 && i != idx1) {
max2 = tmp[i];
idx2 = i;
}
}
for (int i = 1; i <= n; ++i) {
if (i == centroid)
ans[i] = 1;
else if (where[i] == idx1) {
int tmp = n - sz[i] - max2;
if (tmp <= n / 2)
ans[i] = 1;
else
ans[i] = 0;
} else {
int tmp = n - sz[i] - max1;
if (tmp <= n / 2)
ans[i] = 1;
else
ans[i] = 0;
}
}
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
printf("\n");
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int __ = 1;
while (__--) {
init();
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000001;
struct edge {
int next, to;
} e[N];
int g[N], n, M, cn, c[2], fir, sec, color[N], s[N];
inline void addedge(int x, int y) {
e[++M] = (edge){g[x], y};
g[x] = M;
}
inline void dfs1(int h, int fa) {
bool flag = true;
for (int i = g[h]; i; i = e[i].next) {
if (e[i].to == fa) continue;
dfs1(e[i].to, h);
if (s[e[i].to] > n / 2) flag = false;
}
if (n - s[h] <= n / 2 && flag == true) {
c[cn++] = h;
}
}
inline void dfs2(int h, int fa) {
s[h] = 1;
for (int i = g[h]; i; i = e[i].next) {
if (fa == e[i].to || e[i].to == c[0] || e[i].to == c[1]) continue;
dfs2(e[i].to, h);
s[h] += s[e[i].to];
}
}
inline void dfs3(int h, int fa) {
for (int i = g[h]; i; i = e[i].next) {
if (fa == e[i].to || e[i].to == c[0] || e[i].to == c[1]) continue;
color[e[i].to] = 1;
dfs3(e[i].to, h);
}
}
inline void predo() {
dfs2(1, 0);
dfs1(1, 0);
}
int main() {
scanf("%d", &n);
for (int i = 1, x, y; i < n; i++) {
scanf("%d%d", &x, &y);
addedge(x, y);
addedge(y, x);
}
predo();
if (cn == 2) {
for (int i = 1; i <= n; i++) printf("1 ");
return 0;
}
dfs2(c[0], 0);
for (int i = 0; i < cn; i++) {
for (int j = g[c[i]]; j; j = e[j].next) {
if (e[j].to == c[0] || e[j].to == c[1]) continue;
if (s[e[j].to] > s[fir]) {
sec = fir;
fir = e[j].to;
} else if (s[e[j].to] > s[sec]) {
sec = e[j].to;
}
}
}
color[fir] = 1;
dfs3(fir, 0);
for (int i = 1; i <= n; i++) {
if (i == c[0] || i == c[1]) {
printf("1 ");
continue;
}
if (color[i]) {
if (n - s[sec] - s[i] <= n / 2) {
printf("1 ");
} else
printf("0 ");
} else {
if (n - s[fir] - s[i] <= n / 2) {
printf("1 ");
} else {
printf("0 ");
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
int S[400005], d[400005], maxsub[400005], maxfa[400005];
int N;
vector<int> G[400005];
void dfssize(int x, int fa) {
int v;
S[x] = 1;
for (int i = 0; i < G[x].size(); i++) {
v = G[x][i];
if (v == fa) {
continue;
}
dfssize(v, x);
S[x] += S[v];
}
}
void dfsdis(int x, int fa) {
int v;
for (int i = 0; i < G[x].size(); i++) {
v = G[x][i];
if (v == fa) {
continue;
}
d[v] = d[x] + 1;
dfsdis(v, x);
}
}
void dfssub(int x, int fa) {
int v;
if (S[x] <= (N / 2)) {
maxsub[x] = S[x];
} else {
maxsub[x] = 0;
}
for (int i = 0; i < G[x].size(); i++) {
v = G[x][i];
if (v == fa) {
continue;
}
dfssub(v, x);
if (maxsub[v] <= (N / 2) && (maxsub[x] < maxsub[v])) {
maxsub[x] = maxsub[v];
}
}
}
void dfsfa(int x, int fa) {
int v, maxA = 0, maxB = 0;
if (fa == 0) {
maxfa[x] = 0;
} else {
if (N - S[x] <= (N / 2)) {
maxfa[x] = N - S[x];
} else {
if (maxfa[fa] > maxfa[x]) {
maxfa[x] = maxfa[fa];
}
}
}
for (int i = 0; i < G[x].size(); i++) {
v = G[x][i];
if (v == fa) {
continue;
}
if (maxsub[v] >= maxA) {
maxB = maxA;
maxA = maxsub[v];
} else if (maxsub[v] > maxB) {
maxB = maxsub[v];
}
}
for (int i = 0; i < G[x].size(); i++) {
v = G[x][i];
if (v == fa) {
continue;
}
if (maxsub[v] == maxA) {
maxfa[v] = maxB;
} else {
maxfa[v] = maxA;
}
dfsfa(v, x);
}
}
int main() {
cin >> N;
for (int i = 1; i <= N; i++) {
G[i].clear();
}
int a, b;
for (int i = 1; i < N; i++) {
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
dfssize(1, 0);
d[1] = 0;
dfsdis(1, 0);
dfssub(1, 0);
memset(maxfa, 0, sizeof(maxfa));
dfsfa(1, 0);
bool rep;
int size;
int maxs;
bool core;
int v;
for (int i = 1; i <= N; i++) {
rep = false;
core = true;
for (int j = 0; j < G[i].size(); j++) {
v = G[i][j];
if (d[v] > d[i]) {
size = S[v];
} else {
size = N - S[i];
}
if (size > (N / 2)) {
if (rep) {
core = false;
break;
}
if (d[v] > d[i]) {
maxs = maxsub[v];
} else {
maxs = maxfa[i];
}
if (maxs <= (N / 2) && (size - maxs <= (N / 2))) {
rep = true;
} else {
core = false;
}
}
}
if (core) {
cout << 1;
} else {
cout << 0;
}
cout << ' ';
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void rread(T& num) {
num = 0;
T f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') num = num * 10 + ch - '0', ch = getchar();
num *= f;
}
const int inf = 2e9, mod = 1e9 + 7;
const int maxn = 4e5 + 10;
const long double PI = acos(-1.0);
long long gcd(long long a, long long b) { return (a ? gcd(b % a, a) : b); }
void exgcd(long long a, long long b, long long& d, long long& x, long long& y) {
if (!b) {
d = a;
x = 1;
y = 0;
} else {
exgcd(b, a % b, d, y, x);
y -= x * (a / b);
}
}
long long power(long long a, long long n) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
}
n >>= 1;
a *= a;
}
return p;
}
long long power(long long a, long long n, long long mod) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
p %= mod;
}
n >>= 1;
a *= a;
a %= mod;
}
return p % mod;
}
int n, m;
vector<int> nex[maxn];
int sz[maxn], nel[maxn], a[maxn];
void dfs1(int x, int be) {
int maxx = 0;
sz[x] = 1;
for (int i = 0; i < nex[x].size(); i++)
if (nex[x][i] != be) {
dfs1(nex[x][i], x);
maxx = max(maxx, nel[nex[x][i]]);
sz[x] += sz[nex[x][i]];
}
if (sz[x] <= n / 2)
nel[x] = sz[x];
else
nel[x] = maxx;
}
void dfs2(int x, int be, int fa) {
int maxx = 0;
int id = 0;
int maxx1 = 0, maxx2 = 0, id1 = 0, id2 = 0;
if (n - sz[x] > maxx) maxx = n - sz[x], id = 0;
if (fa > maxx1) maxx1 = fa, id1 = be;
for (int i = 0; i < nex[x].size(); i++)
if (nex[x][i] != be) {
if (sz[nex[x][i]] > maxx) maxx = sz[nex[x][i]], id = nex[x][i];
if (nel[nex[x][i]] > maxx1) {
maxx2 = maxx1;
id2 = id1;
maxx1 = nel[nex[x][i]];
id1 = nex[x][i];
} else if (nel[nex[x][i]] > maxx2)
maxx2 = nel[nex[x][i]], id2 = nex[x][i];
}
if (id == 0) {
if (n - sz[x] - fa <= n / 2)
a[x] = 1;
else
a[x] = 0;
} else {
if (sz[id] - nel[id] <= n / 2)
a[x] = 1;
else
a[x] = 0;
}
for (int i = 0; i < nex[x].size(); i++)
if (nex[x][i] != be) {
int gg = 0;
if (id1 == nex[x][i]) {
if (n - sz[nex[x][i]] <= n / 2)
gg = n - sz[nex[x][i]];
else
gg = maxx2;
} else {
if (n - sz[nex[x][i]] <= n / 2)
gg = n - sz[nex[x][i]];
else
gg = maxx1;
}
dfs2(nex[x][i], x, gg);
}
}
int main() {
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++) nex[i].clear();
memset(nel, 0, sizeof nel);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
nex[u].push_back(v);
nex[v].push_back(u);
}
dfs1(1, 0);
dfs2(1, 0, 0);
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T sqr(T a) {
return a * a;
};
const double pi = acos(-1.0);
const int INF = INT_MAX;
const long long LLINF = LLONG_MAX;
const int MAX_N = 4e5 + 10;
int N, ans[MAX_N], sz[MAX_N], ms[MAX_N][2], mv[MAX_N][2];
vector<int> G[MAX_N];
void dfs(int v, int p) {
sz[v] = 1;
for (auto u : G[v])
if (u != p) {
dfs(u, v);
sz[v] += sz[u];
int t = sz[u] <= N / 2 ? sz[u] : ms[u][0];
if (t > ms[v][0])
mv[v][1] = mv[v][0], mv[v][0] = u, ms[v][1] = ms[v][0], ms[v][0] = t;
else if (t > ms[v][1])
mv[v][1] = u, ms[v][1] = t;
}
}
void dfs1(int v, int p, int lst) {
if (N - sz[v] - lst <= N / 2) ans[v] = 1;
for (auto u : G[v])
if (u != p) {
if (sz[u] - ms[v][0] > N / 2) ans[v] = 0;
dfs1(u, v,
N - sz[u] <= N / 2 ? N - sz[u] : max(lst, ms[v][mv[v][0] == u]));
}
}
int main(int argc, char const *argv[]) {
scanf("%d", &N);
for (int i = 1, u, v; i < N; ++i)
scanf("%d%d", &u, &v), G[u].push_back(v), G[v].push_back(u);
dfs(1, 0), dfs1(1, 0, 0);
for (int i = 1; i < N + 1; ++i) printf("%d ", ans[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline namespace Infinity {
inline namespace Constant {
constexpr const int eof = EOF;
constexpr const int maxint = INT_MAX;
constexpr const long long maxll = LLONG_MAX;
constexpr const double eps = DBL_EPSILON;
} // namespace Constant
inline namespace TypeDefine {
using uint = unsigned int;
using ll = long long int;
using ull = unsigned long long int;
using ld = long double;
template <typename T = int>
using Pair = pair<T, T>;
template <typename T = int>
using PairList = vector<Pair<T>>;
template <typename T = vector<int>>
using Iter = typename T::iterator;
} // namespace TypeDefine
inline namespace IO {
const char LF = '\n';
const char SP = ' ';
int dbl_prec = 10;
int ldbl_prec = 18;
inline void write(const int n) { printf("%d", n); }
inline void write(const unsigned n) { printf("%u", n); }
inline void write(const long long n) { printf("%lld", n); }
inline void write(const unsigned long long n) { printf("%lld", n); }
inline void write(const int64_t n) { printf("%" PRId64, n); }
inline void write(const uint64_t n) { printf("%" PRIu64, n); }
inline void write(const double a) { printf("%.*f", dbl_prec, a); }
inline void write(const long double a) { printf("%.*Lf", ldbl_prec, a); }
inline void write(const char c) { printf("%c", c); }
inline void write(const char s[]) { printf("%s", s); }
inline void write(const string &s) { printf("%s", s.data()); }
template <typename T>
inline void writeSP(const T a) {
write(a);
write(SP);
}
template <typename T, typename U>
inline void write(const pair<T, U> &p) {
writeSP(p.first);
write(p.second);
}
template <class T>
inline void write(const T a) {
for (auto i = a.begin(); i != a.end(); i++) {
if (i != a.begin()) write(SP);
write(*i);
}
}
template <typename T>
inline void write(initializer_list<T> list) {
for (auto i = list.begin(); i != list.end(); i++) {
if (i != list.begin()) write(SP);
write(*i);
}
}
template <typename T>
inline void writer(T begin, T end) {
for (write(*begin++); begin != end; ++begin) write(SP), write(*begin);
}
inline void writeln() { write(LF); }
inline void writeSP() { write(SP); }
template <typename T>
inline void writeln(const T &a) {
write(a);
write(LF);
}
template <typename T>
inline void writeln(initializer_list<T> list) {
for (auto i = list.begin(); i != list.end(); i++) {
if (i != list.begin()) write(SP);
write(*i);
}
write(LF);
}
template <class T>
inline void writelns(const T &a) {
for (auto n : a) writeln(n);
}
template <typename T, typename... types>
inline void write(const T &a, const types &...args) {
write(a);
write(args...);
}
template <typename... types>
inline void writeln(const types &...args) {
write(args...);
write(LF);
}
template <typename... types>
inline void writeSP(const types &...args) {
write(args...);
write(SP);
}
inline void writelnYN(bool b) { writeln(b ? "YES" : "NO"); }
inline void writelnyn(bool b) { writeln(b ? "Yes" : "No"); }
string caseN(int n, bool sharp = true, bool space = true) {
return string("Case ") + (sharp ? "#" : "") + to_string(n) + ":" +
(space ? " " : "");
}
inline int read(int &n) { return scanf("%d", &n); }
inline int read(int64_t &n) { return scanf("%" SCNd64, &n); }
template <typename T, typename... types>
inline int read(T &n, types &...args) {
return read(n) == eof ? eof : read(args...) + 1;
}
inline char getcc() {
char c;
do c = getchar();
while (isspace(c));
return c;
}
inline int getint() {
int n;
read(n);
return n;
}
inline int64_t getll() {
int64_t n;
read(n);
return n;
}
inline double getdbl() {
double n;
scanf("%lf", &n);
return n;
}
inline pair<int, int> getpair() {
pair<int, int> p;
scanf("%d%d", &p.first, &p.second);
return p;
}
inline vector<int> getints(int n) {
vector<int> v(n);
for (int &i : v) i = getint();
return v;
}
inline vector<pair<int, int>> getpairs(int n) {
vector<pair<int, int>> v(n);
for (pair<int, int> &p : v) {
p = getpair();
}
return v;
}
inline void read(string &str, unsigned size) {
char s[++size];
scanf("%s", s);
str.assign(s);
}
inline string getstr(unsigned size = 0x100000) {
string s;
read(s, size);
return s;
}
inline string getln(unsigned size = 0x100000) {
char s[++size];
scanf("%[^\n]", s);
getchar();
return s;
}
} // namespace IO
inline namespace BattleLab {
class Range {
class RangeIterator {
public:
RangeIterator(int current = 0, int step = 1)
: current(current), step(step) {}
bool operator!=(const RangeIterator &iterator) const {
return current < iterator.current;
}
int operator*() const { return current; }
RangeIterator operator++() { return {current += step, step}; }
protected:
int current, step;
};
public:
Range(int to, int from = 0, int step = 1) : from(from), to(to), step(step) {}
RangeIterator begin() const { return {from, step}; }
RangeIterator end() const { return {to, step}; }
protected:
int from, to, step;
};
Range range(int to) { return {to}; }
Range range(int from, int to) { return {to, from}; }
Range range(int from, int to, int step) { return {to, from, step}; }
} // namespace BattleLab
inline namespace Miscelleneous {
inline constexpr int ctoi(const char c) { return c - '0'; }
inline constexpr char itoc(const int n) { return n + '0'; }
inline int dtoi(const double d) { return round(d); }
template <typename T>
inline constexpr bool in(T x, T l, T r) {
return l <= x && x <= r;
}
template <typename T>
inline constexpr T tristate(int val, T nag, T zero, T pos) {
return val > 0 ? pos : val < 0 ? nag : zero;
}
template <class T>
inline int size(const T &a) {
return a.size();
}
template <class T>
inline void sort(T &a) {
sort(a.begin(), a.end());
}
template <class T1, class T2>
inline void sort(T1 &a, T2 comp) {
sort(a.begin(), a.end(), comp);
}
template <class T1, typename T2>
inline int lbound(const T1 &a, const T2 k) {
return lower_bound(a.begin(), a.end(), k) - a.begin();
}
template <class T1, typename T2>
inline int ubound(const T1 &a, const T2 k) {
return upper_bound(a.begin(), a.end(), k) - a.begin();
}
template <class T1, class T2>
inline int count(T1 &a, T2 k) {
return ubound(a, k) - lbound(a, k);
}
template <typename T>
inline void clear(T &a) {
memset(a, 0, sizeof a);
}
template <typename T>
T gcd(T a, T b) {
while (b) {
T t = a % b;
a = b;
b = t;
}
return a;
}
template <typename T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
long long qpow(long long a, long long b, long long c) {
return b ? qpow(a * a % c, b >> 1, c) * (b & 1 ? a : 1) % c : 1;
}
template <typename T>
T exGcd(T a, T b, T &x, T &y) {
T d = a;
if (b) {
d = exGcd(b, a % b, y, x);
y -= a / b * x;
} else {
x = 1;
y = 0;
}
return d;
}
template <typename T>
inline constexpr T mps(T l, T r, T k) {
return ((r - (r % k + k) % k) - (l + (k - l % k) % k)) / k + 1;
}
template <typename T>
inline constexpr T sgn(T a) {
return a ? a > 0 ? 1 : -1 : 0;
}
template <typename T>
inline constexpr T sq(T a) {
return a * a;
}
template <typename T>
inline constexpr bool odd(T a) {
return bool(a % 2);
}
template <typename T>
inline constexpr bool even(T a) {
return !bool(a % 2);
}
template <typename T1, typename T2>
inline constexpr T1 smod(T1 x, T2 m) {
return x > m ? x - m : x + m < m ? x + m : x;
}
vector<int> repetend(vector<int> a) {
vector<int> p(a.size(), -1);
for (unsigned i = 0; i < a.size(); i++)
if (p[i] == -1) {
int c = 1;
for (unsigned j = a[i]; j != i; j = a[j]) ++c;
p[i] = c;
for (unsigned j = a[i]; j != i; j = a[j]) p[j] = c;
}
return p;
}
template <typename T>
inline constexpr T lmiddle(T first, T last) {
return first + (last - first) / 2;
}
template <typename T>
inline constexpr T rmiddle(T first, T last) {
return last - (last - first) / 2;
}
template <typename T, typename F>
T dichotomy(T l, T r, F check, T prec = 1) {
while (r - l > prec) {
T m = lmiddle(l, r);
(check(m) ? l : r) = m;
}
return l;
}
template <typename T, typename F>
T dichotomy2(T l, T r, F check, T prec = 1) {
while (r - l > prec) {
T m = rmiddle(l, r);
(check(m) ? r : l) = m;
}
return r;
}
bool contains(const string &s, const string &t) {
return s.find(t) != string::npos;
}
template <typename T>
bool contains(const T &s, typename T::value_type t) {
for (typename T::value_type c : s)
if (c == t) return true;
return false;
}
template <typename T>
bool contains(const initializer_list<T> s, T t) {
return find(s.begin(), s.end(), t) != s.end();
}
} // namespace Miscelleneous
} // namespace Infinity
class Tree {
public:
Tree(unsigned n) : n(n), adj(n) {}
void addDirected(int u, int v) { adj[u].push_back(v); }
void addUndirected(int u, int v) {
addDirected(u, v);
addDirected(v, u);
}
protected:
int n;
vector<vector<int>> adj;
};
class Centroids : public Tree {
public:
Centroids(unsigned n) : Tree(n), ss(n), sc(n), sp(n) {}
vector<int> solve() {
r.assign(n, 1);
prepare1(0, -1);
prepare2(0, -1);
return r;
}
private:
void update(int &a, int b) {
if (b <= n / 2 && b > a) {
a = b;
}
}
void prepare1(int u, int p) {
ss[u] = 1;
for (int v : adj[u]) {
if (v != p) {
prepare1(v, u);
if (ss[v] - sc[v] > n / 2) {
r[u] = 0;
}
ss[u] += ss[v];
update(sc[u], sc[v]);
update(sc[u], ss[v]);
}
}
update(sc[u], ss[u]);
}
void prepare2(int u, int p) {
update(sp[u], n - ss[u]);
update(sp[u], sp[p]);
if (n - ss[u] - sp[u] > n / 2) {
r[u] = 0;
}
int pm = 0;
for (auto i = adj[u].begin(); i != adj[u].end(); i++) {
int v = *i;
if (v != p) {
update(sp[v], pm);
update(pm, sc[v]);
}
}
pm = 0;
for (auto i = adj[u].rbegin(); i != adj[u].rend(); i++) {
int v = *i;
if (v != p) {
update(sp[v], pm);
update(pm, sc[v]);
prepare2(v, u);
}
}
}
protected:
vector<int> ss, sc, sp, r;
};
int main() {
int n = getint();
Centroids c(n);
for (int i = 0; i < n - 1; i++) {
c.addUndirected(getint() - 1, getint() - 1);
}
writeln(c.solve());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500000;
vector<int> g[N];
int n, x, y, sum[N], ans[N], mx1 = 0, mx2 = 0;
void dfs(int v, int z, int s, int p = 0) {
if (s <= n / 2) z = max(s, z);
if (s - z > (n / 2)) return;
ans[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
if (g[v][i] != p) dfs(g[v][i], z, s + sum[v] - sum[g[v][i]], v);
}
}
void dfs1(int v, int p = 0) {
sum[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
if (g[v][i] != p) dfs1(g[v][i], v), sum[v] += sum[g[v][i]];
}
}
int dfs2(int v, int s = 0, int p = 0) {
int t;
bool is = 1;
for (int i = 0; i < g[v].size(); i++) {
if (g[v][i] == p) continue;
t = dfs2(g[v][i], s + sum[v] - sum[g[v][i]], v);
if (sum[g[v][i]] > (n / 2)) {
is = 0;
}
if (t != 0) return t;
}
if (is && (n - sum[v] <= (n / 2))) return v;
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
dfs1(1);
int centr = dfs2(1);
dfs1(centr);
int id = 0;
for (int i = 0; i < g[centr].size(); i++) {
if (sum[g[centr][i]] >= mx1) {
mx2 = mx1;
id = i;
mx1 = sum[g[centr][i]];
} else if (sum[g[centr][i]] >= mx2) {
mx2 = sum[g[centr][i]];
}
}
ans[centr] = 1;
for (int i = 0; i < g[centr].size(); i++) {
if (i == id)
dfs(g[centr][i], mx2, sum[centr] - sum[g[centr][i]], centr);
else
dfs(g[centr][i], mx1, sum[centr] - sum[g[centr][i]], centr);
}
for (int i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class S, class T>
istream& operator>>(istream& is, pair<S, T>& p) {
return is >> p.first >> p.second;
}
const double EPS = 1e-10;
const double PI = acos(-1.0);
const long long MOD = 1e9 + 7;
vector<int> G[400000];
int par[400000];
int sz[400000];
int N;
void init(int u, int p = -1) {
sz[u] = 1;
par[u] = p;
for (int to : G[u]) {
if (to == p) continue;
init(to, u);
sz[u] += sz[to];
}
}
int cent(int u) {
bool ok = true;
for (int to : G[u]) {
if (to == par[u]) continue;
if (sz[to] > N / 2) ok = false;
}
ok = ok && (N - sz[u] <= N / 2);
if (ok) return u;
int res = -1;
for (int to : G[u]) {
if (to == par[u]) continue;
res = cent(to);
if (res != -1) break;
}
return res;
}
int ans[400000];
void dfs(int u, int p, int ix, int c) {
if (ix > 0)
ans[u] = N - sz[u] - sz[G[c][0]] <= N / 2;
else
ans[u] = (N - sz[G[c][0]] <= N / 2) ||
(N - sz[u] - (int((G[c]).size()) > 1 ? sz[G[c][1]] : 0) <= N / 2);
for (int to : G[u]) {
if (to == p) continue;
dfs(to, u, ix, c);
}
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cin >> N;
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);
}
init(0);
int c = cent(0);
init(c);
ans[c] = 1;
sort((G[c]).begin(), (G[c]).end(),
[&](int i, int j) { return sz[i] > sz[j]; });
for (int i = (0); i < (int((G[c]).size())); ++i) {
dfs(G[c][i], c, i, c);
}
for (int i = (0); i < (N); ++i) cout << (i ? " " : "") << ans[i];
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
return (b != 0 ? gcd(b, a % b) : a);
}
template <typename T>
T lcm(T a, T b) {
return (a / gcd(a, b) * b);
}
template <typename T>
T BigMod(T b, T p, T m) {
if (p == 0) return 1;
if (p % 2 == 0) {
T s = BigMod(b, p / 2, m);
return ((s % m) * (s % m)) % m;
}
return ((b % m) * (BigMod(b, p - 1, m) % m)) % m;
}
template <typename T>
T ModInv(T b, T m) {
return BigMod(b, m - 2, m);
}
template <typename T>
T POW(T B, T P) {
if (P == 0) return 1;
if (P & 1)
return B * POW(B, P - 1);
else
return (POW(B, P / 2) * POW(B, P / 2));
}
template <typename T>
T Swap(T &a, T &b) {
T tmp = a;
a = b;
b = tmp;
}
int Set(int N, int pos) { return N = N | (1 << pos); }
int Reset(int N, int pos) { return N = N & ~(1 << pos); }
bool Check(int N, int pos) { return (bool)(N & (1 << pos)); }
double DEG(double x) { return (180.0 * x) / (2.0 * acos(0.0)); }
double RAD(double x) { return (x * (double)2.0 * acos(0.0)) / (180.0); }
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
template <class T>
inline bool readfast(T &x) {
int c = getchar();
int sgn = 1;
while (~c && c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
int R[] = {1, -1, 0, 0, 1, -1, -1, 1};
int C[] = {0, 0, 1, -1, 1, -1, 1, -1};
int KR[] = {-2, -2, -1, 1, 2, 2, -1, 1};
int KC[] = {1, -1, 2, 2, 1, -1, -2, -2};
struct P {
double x, y;
P(double x = 0.0, double y = 0.0) {
this->x = x;
this->y = y;
}
};
P mkv(P ae, P be) { return P(be.x - ae.x, be.y - ae.y); }
double dtp(P ae, P be) { return (ae.x * be.x + ae.y * be.y); }
double crp(P ae, P be) { return (ae.x * be.y - ae.y * be.x); }
double val(P ae) { return sqrt(dtp(ae, ae)); }
P vresize(P ae, double llen) {
double v = val(ae);
return P(ae.x * llen / v, ae.y * llen / v);
}
double ART(P ae, P be) { return crp(ae, be) / 2.0; }
P rot(P ae, double ang) {
return P(ae.x * cos(ang) - ae.y * sin(ang),
ae.y * cos(ang) + ae.x * sin(ang));
}
vector<int> Edge[400005];
int ans[400005], h, n, child_side[400005], greater_than_h[400005];
int sub_tree[400005], max_id[400005], side_id[400005];
int dfs(int u, int parent) {
int i, v;
sub_tree[u] = 1;
child_side[u] = 0;
int max_sub_tree = -1;
for (i = 0; i < Edge[u].size(); i++) {
v = Edge[u][i];
if (v == parent) continue;
int sub = dfs(v, u);
if (sub > h) {
max_id[u] = v;
max_sub_tree = sub;
greater_than_h[u]++;
}
if (sub <= h) {
if (sub > max_sub_tree) {
max_sub_tree = sub;
max_id[u] = v;
}
if (child_side[u] < sub) {
child_side[u] = sub;
side_id[u] = v;
}
} else {
if (child_side[u] <= child_side[v]) {
child_side[u] = child_side[v];
side_id[u] = v;
}
}
sub_tree[u] += sub;
}
return sub_tree[u];
}
void dfs2(int u, int parent, int parent_side) {
int parent_subtree_size = n - sub_tree[u];
int max_len, tmxl = parent_side;
if (parent_subtree_size <= h) tmxl = max(tmxl, parent_subtree_size);
if (parent_subtree_size > h) {
greater_than_h[u]++;
max_len = parent_subtree_size;
} else {
max_len = sub_tree[max_id[u]];
}
if (greater_than_h[u] == 0)
ans[u] = 1;
else if (greater_than_h[u] > 1)
ans[u] = 0;
else {
if (max_len == parent_subtree_size) {
if (max_len - tmxl <= h)
ans[u] = 1;
else
ans[u] = 0;
} else {
if (max_len - child_side[max_id[u]] <= h)
ans[u] = 1;
else
ans[u] = 0;
}
}
int mxl = tmxl;
for (int i = 0; i < Edge[u].size(); i++) {
int v = Edge[u][i];
if (v == parent) continue;
if (side_id[u] != v) {
if (mxl <= h)
dfs2(v, u, max(mxl, child_side[u]));
else
dfs2(u, v, child_side[u]);
} else {
int bmxl = 0;
if (mxl <= h) bmxl = mxl;
for (int j = 0; j < Edge[u].size(); j++) {
int k = Edge[u][j];
if (k != v && k != parent) {
if (sub_tree[k] <= h)
bmxl = max(bmxl, sub_tree[k]);
else
bmxl = max(bmxl, child_side[k]);
}
}
dfs2(v, u, bmxl);
}
}
}
int main() {
int a, b, c, d, m, p, x, y, i, j, k, l, q, r, t, cnt, sm, tmp, u, v;
scanf("%d", &n);
h = n / 2;
for (i = 0; i < n - 1; i++) {
scanf("%d %d", &u, &v);
Edge[u].push_back(v);
Edge[v].push_back(u);
}
memset(greater_than_h, 0, sizeof(greater_than_h));
memset(max_id, -1, sizeof(max_id));
dfs(1, 0);
dfs2(1, 0, 0);
for (i = 1; i <= n; i++) {
if (i > 1) printf(" ");
printf("%d", ans[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400001;
vector<int> adj[N];
int sz[N];
void dfs(int u, int p = -1) {
sz[u] = 1;
for (auto el : adj[u]) {
if (el != p) {
dfs(el, u);
sz[u] += sz[el];
}
}
}
int n;
int centroid(int u, int p = -1) {
for (auto el : adj[u]) {
if (el != p && sz[el] > n / 2) {
return centroid(el, u);
}
}
return u;
}
void root_at(int u) {
memset(sz, 0, sizeof(sz));
dfs(u);
}
int mxs[3];
int can[N];
void solve(int u, int sub, int p) {
int rem = (sub == mxs[2] ? mxs[1] : mxs[2]);
can[u] = (n - sz[u] - rem <= n / 2 || n - sub <= n / 2);
for (auto el : adj[u]) {
if (el != p) solve(el, sub, u);
}
}
int main(int argc, char** argv) {
cin >> n;
int u, v;
for (int i = 0; i < n - 1; i++) {
scanf("%d %d", &u, &v);
u--, v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(0);
int root = centroid(0);
root_at(root);
can[root] = 1;
for (auto el : adj[root]) {
mxs[0] = sz[el];
sort(mxs, mxs + 3);
}
for (auto el : adj[root]) {
solve(el, sz[el], root);
}
for (int i = 0; i < n; i++) {
printf("%d ", can[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 4E5 + 5;
int color[MAXN]{};
std::vector<int> graph[MAXN]{};
int subtr[MAXN]{};
int upper[MAXN]{};
int N, Nh, R = 0;
int big[2];
void dfs(const int& cur) {
for (auto& nxt : graph[cur])
if (!upper[nxt]) {
upper[nxt] = cur;
dfs(nxt);
subtr[cur] += subtr[nxt];
}
++subtr[cur];
}
void dfsC(const int& cur, int prev) {
int subsm = 0;
bool good = (prev <= Nh);
for (auto& nxt : graph[cur])
if (nxt != upper[cur]) {
if (subtr[nxt] > Nh) good = false;
subsm += subtr[nxt];
}
if (good) R = cur;
for (auto& nxt : graph[cur])
if (nxt != upper[cur]) {
if (good) return;
dfsC(nxt, prev + subsm - subtr[nxt]);
}
}
void dfs2(const int& cur, const int& flag) {
color[cur] = flag;
for (auto& nxt : graph[cur])
if (nxt != upper[cur]) dfs2(nxt, flag);
}
int main() {
scanf("%d", &N);
Nh = N >> 1;
for (int i = 1; i < N; ++i) {
int u, v;
scanf(" %d%d", &u, &v);
graph[u].push_back(v);
graph[v].push_back(u);
}
upper[1] = 1;
dfs(1);
dfsC(1, 0);
for (int i = 1; i <= N; ++i) subtr[i] = upper[i] = 0;
upper[R] = R;
dfs(R);
for (auto& nxt : graph[R]) dfs2(nxt, nxt);
big[0] = big[1] = 0;
for (auto& nxt : graph[R]) {
if (subtr[nxt] >= subtr[big[0]]) {
big[1] = big[0];
big[0] = nxt;
} else if (subtr[nxt] >= subtr[big[1]])
big[1] = nxt;
}
for (int i = 1; i <= N; ++i)
if (i != R) {
int sze = subtr[big[0]];
if (color[i] == big[0]) sze = subtr[big[1]];
if ((N - subtr[i] - sze <= Nh) || (N - subtr[color[i]] <= Nh))
printf("1 ");
else
printf("0 ");
} else
printf("1 ");
putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 4e5 + 5;
vector<long long int> g[N];
vector<bool> dp(N, 0);
vector<long long int> sz(N, 0);
long long int n;
void dfs(long long int v, long long int p) {
sz[v] = 1;
for (auto &it : g[v]) {
if (it != p) {
dfs(it, v);
sz[v] += sz[it];
}
}
return;
}
long long int dfs_cd(long long int v, long long int p) {
for (auto &it : g[v])
if (it != p && sz[it] > n / 2) return dfs_cd(it, v);
return v;
}
void dfs_dp(long long int v, long long int p, long long int c_cnt,
long long int mx_del) {
if (c_cnt - mx_del <= n / 2) dp[v] = 1;
for (auto &it : g[v]) {
if (it != p) dfs_dp(it, v, n - sz[it], mx_del);
}
return;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
srand(time(NULL));
cin >> n;
for (long long int i = 0; i < n - 1; i++) {
long long int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 0);
long long int C = dfs_cd(1, 0);
dp[C] = 1;
for (long long int i = 1; i < n + 1; i++) sz[i] = 0;
dfs(C, 0);
multiset<long long int> ms;
for (auto &it : g[C]) ms.insert(sz[it]);
for (auto &it : g[C]) {
ms.erase(ms.find(sz[it]));
auto high = ms.upper_bound(n / 2);
if (high != ms.begin()) high--;
long long int mx_del = *high;
if (n - sz[it] <= n / 2) mx_del = n / 2;
dfs_dp(it, C, n - sz[it], mx_del);
ms.insert(sz[it]);
}
for (long long int i = 1; i < n + 1; i++) cout << dp[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[400005], cnt(400005), in(400005), out(400005), res(400005, -1);
int n;
void dfs1(int V, int pV) {
cnt[V] = 1;
in[V] = -100;
for (auto v : adj[V]) {
if (v == pV) continue;
dfs1(v, V);
cnt[V] += cnt[v];
if (cnt[v] <= n / 2)
in[V] = max(in[V], cnt[v]);
else
in[V] = max(in[V], in[v]);
}
if (cnt[V] <= n / 2) {
in[V] = cnt[V];
}
}
void dfs2(int V, int pV) {
int mx = -100, sMx = -100;
for (auto v : adj[V]) {
if (v == pV) continue;
if (in[v] >= mx)
sMx = mx, mx = in[v];
else if (in[v] > sMx)
sMx = in[v];
}
for (auto v : adj[V]) {
if (v == pV) {
if ((n - cnt[V]) > n / 2 && (n - cnt[V] - out[V]) > n / 2) res[V] = 0;
continue;
}
if (cnt[v] > n / 2 && (cnt[v] - in[v]) > n / 2) res[V] = 0;
if ((n - cnt[v]) <= n / 2)
out[v] = n - cnt[v];
else if (in[v] == mx)
out[v] = max(out[V], sMx);
else
out[v] = max(out[V], mx);
dfs2(v, V);
}
if (res[V] == -1) res[V] = 1;
}
int main() {
scanf("%d", &n);
int u, v;
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs1(1, 0);
out[1] = -100;
dfs2(1, 0);
for (int i = 1; i <= n; i++) cout << res[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 400005;
int n, u, v, sz[MX], res[MX];
vector<int> adj[MX];
void dfs(int u, int p) {
sz[u] = 1;
for (int v : adj[u])
if (v != p) {
dfs(v, u);
sz[u] += sz[v];
}
}
int findCentroid(int u) {
while (1) {
int ind = -1;
for (int v : adj[u])
if (2 * sz[v] > n) ind = v;
if (ind == -1) break;
sz[u] = n - sz[ind];
u = ind;
}
return u;
}
void obtRes(int u, int p, int mx) {
int temp = sz[u];
if (p == -1 || 2 * sz[p] <= n || 2 * (sz[p] - mx) <= n) res[u] = 1;
vector<int> a;
for (int v : adj[u])
if (2 * sz[v] <= n) a.push_back(sz[v]);
sort(a.begin(), a.end());
for (int v : adj[u])
if (v != p) {
sz[u] = n - sz[v];
obtRes(v, u,
max({mx, 2 * sz[u] <= n ? sz[u] : 0,
a.size() ? (a.back() != sz[v]
? a.back()
: (a.size() > 1 ? a[a.size() - 2] : 0))
: 0}));
}
sz[u] = temp;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
if (n == 2) {
cout << "1 1" << '\n';
return 0;
}
for (int i = 1; i < n; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, 1);
obtRes(findCentroid(1), -1, 0);
for (int i = 1; i <= n; i++) cout << res[i] << " ";
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int MAXN = 5 * 1e5 + 1, MODM = 1e9 + 7;
int n;
vector<int> g[MAXN];
int sz[MAXN];
int pr[MAXN];
int ans[MAXN];
int m1, m2;
int now;
int root = -1;
void dfs(int v, int p = -1) {
sz[v] = 1;
pr[v] = p;
for (auto to : g[v]) {
if (to != p) {
dfs(to, v);
sz[v] += sz[to];
}
}
}
void dfs2(int v, int p = -1) {
int k = m1;
if (sz[now] == m1) k = m2;
ans[v] |= (n - sz[v] - k <= (n / 2));
ans[v] |= (n - sz[now] <= (n / 2));
for (auto it : g[v])
if (it != p) dfs2(it, v);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
dfs(1);
for (int v = 1; v <= n; v++) {
int cnt = 0;
for (auto to : g[v])
if (to != pr[v]) cnt += (sz[to] <= (n / 2));
if (v != 1) cnt += (n - sz[v] <= (n / 2));
ans[v] = (cnt == g[v].size());
if (ans[v]) root = v;
}
if (root == -1) {
for (int i = 0; i < n; i++) cout << 0 << " ";
return 0;
}
fill(sz, sz + MAXN, 0);
dfs(root);
for (auto it : g[root]) {
if (sz[it] > m1) {
m2 = m1;
m1 = sz[it];
} else
m2 = max(m2, sz[it]);
}
for (auto it : g[root]) {
now = it;
dfs2(it, root);
}
for (int i = 0; i < n; i++) cout << ans[i + 1] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000001;
struct edge {
int next, to;
} e[N];
int g[N], n, M, cn, c[2], fir, sec, color[N], s[N];
inline void addedge(int x, int y) {
e[++M] = (edge){g[x], y};
g[x] = M;
}
inline void dfs1(int h, int fa) {
bool flag = true;
for (int i = g[h]; i; i = e[i].next) {
if (e[i].to == fa) continue;
dfs1(e[i].to, h);
if (s[e[i].to] > n / 2) flag = false;
}
if (n - s[h] <= n / 2 && flag == true) {
c[cn++] = h;
}
}
inline void dfs2(int h, int fa) {
s[h] = 1;
for (int i = g[h]; i; i = e[i].next) {
if (fa == e[i].to || e[i].to == c[0]) continue;
dfs2(e[i].to, h);
s[h] += s[e[i].to];
}
}
inline void dfs3(int h, int fa) {
for (int i = g[h]; i; i = e[i].next) {
if (fa == e[i].to || e[i].to == c[0]) continue;
color[e[i].to] = 1;
dfs3(e[i].to, h);
}
}
inline void predo() {
dfs2(1, 0);
dfs1(1, 0);
}
int main() {
scanf("%d", &n);
for (int i = 1, x, y; i < n; i++) {
scanf("%d%d", &x, &y);
addedge(x, y);
addedge(y, x);
}
predo();
if (cn == 2) {
for (int i = 1; i <= n; i++) printf("1 ");
return 0;
}
dfs2(c[0], 0);
for (int j = g[c[0]]; j; j = e[j].next) {
if (e[j].to == c[0] || e[j].to == c[1]) continue;
if (s[e[j].to] > s[fir]) {
sec = fir;
fir = e[j].to;
} else if (s[e[j].to] > s[sec]) {
sec = e[j].to;
}
}
color[fir] = 1;
dfs3(fir, 0);
for (int i = 1; i <= n; i++) {
if (i == c[0]) {
printf("1 ");
continue;
}
if (color[i]) {
if (n - s[sec] - s[i] <= n / 2) {
printf("1 ");
} else
printf("0 ");
} else {
if (n - s[fir] - s[i] <= n / 2) {
printf("1 ");
} else {
printf("0 ");
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 400010;
vector<int> t[MAXN];
int par[MAXN], sz[MAXN], up[MAXN], dw[MAXN], n;
void dfs_sz(int u, int parent) {
par[u] = parent;
sz[u] = 1;
int size = t[u].size();
for (int i = 0; i < size; i++) {
int v = t[u][i];
if (v == parent) continue;
dfs_sz(v, u);
sz[u] += sz[v];
}
}
void dfs_down(int u, int parent) {
dw[u] = (sz[u] <= n / 2 ? sz[u] : 0);
int size = t[u].size();
for (int i = 0; i < size; i++) {
int v = t[u][i];
if (v == parent) continue;
dfs_down(v, u);
dw[u] = max(dw[u], dw[v]);
}
}
void dfs_up(int u, int parent, int val) {
up[u] = max((n - sz[u] <= n / 2 ? n - sz[u] : 0), val);
int size = t[u].size();
int mx0 = 0, mx1 = 0;
for (int i = 0; i < size; i++) {
int v = t[u][i];
if (v == parent) continue;
if (dw[v] >= mx0) {
mx1 = mx0;
mx0 = dw[v];
} else if (dw[v] >= mx1) {
mx1 = dw[v];
}
}
for (int i = 0; i < size; i++) {
int v = t[u][i];
if (v == parent) continue;
dfs_up(v, u, max(up[u], (mx0 == dw[v] ? mx1 : mx0)));
}
}
int main() {
int u, v;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
t[u].push_back(v);
t[v].push_back(u);
}
dfs_sz(1, -1);
dfs_down(1, -1);
dfs_up(1, -1, 0);
for (int i = 1; i <= n; i++) {
int ans = 1;
int size = t[i].size();
for (int k = 0; k < size; k++) {
int u = t[i][k];
if (u == par[i]) {
if (n - sz[i] - up[i] > n / 2) ans = 0;
} else {
if (sz[u] - dw[u] > n / 2) ans = 0;
}
}
printf("%d", ans);
if (i == n)
printf("\n");
else
printf(" ");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 10;
int up[N], down[N], sz[N], fa[N];
int n;
vector<int> g[N];
void dfs_sz(int u, int p = -1) {
sz[u] = 1;
fa[u] = p;
for (int i = 0; i < (int)g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
dfs_sz(v, u);
sz[u] += sz[v];
}
}
void dfs_down(int u, int p = -1) {
if (sz[u] <= n / 2) down[u] = sz[u];
for (int i = 0; i < (int)g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
dfs_down(v, u);
down[u] = max(down[u], down[v]);
}
}
void dfs_up(int u, int p = -1, int pre = 0) {
if (n - sz[u] <= n / 2)
up[u] = n - sz[u];
else
up[u] = pre;
int _max = 0, next_max = 0;
for (int i = 0; i < (int)g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
if (down[v] >= _max) {
next_max = _max;
_max = down[v];
} else if (down[v] >= next_max) {
next_max = down[v];
}
}
for (int i = 0; i < (int)g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
if (down[v] == _max)
dfs_up(v, u, max(up[u], next_max));
else
dfs_up(v, u, max(up[u], _max));
}
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
}
dfs_sz(0);
dfs_down(0);
dfs_up(0);
for (int u = 0; u < n; u++) {
int ok = 1;
for (int i = 0; i < (int)g[u].size(); i++) {
int v = g[u][i];
if (v == fa[u]) {
if (n - sz[u] - up[u] > n / 2) ok = 0;
} else {
if (sz[v] - down[v] > n / 2) ok = 0;
}
}
printf("%d ", ok);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, c, d, x, y, p, q, t, ans[400009], res, mi, T, lca[22][400009],
sub[400009];
vector<int> v[400009];
int ma[2];
void dfs(int id, int par) {
lca[1][id] = par;
lca[0][id] = id;
for (int i = 0; i < v[id].size(); i++) {
int u = v[id][i];
if (u == par) continue;
dfs(u, id);
sub[id] += sub[u];
}
sub[id]++;
}
int centroid(int id, int par) {
int f = 0, s = 0;
for (int i = 0; i < v[id].size(); i++) {
int u = v[id][i];
if (u == par) continue;
if (sub[u] > T)
return centroid(u, id);
else
s += sub[u];
}
if (f == 0 && n - 1 - s <= T) return id;
}
int lim;
void init_lca() {
lim = log(n) / log(2) + 1;
for (int i = 2; i <= lim; i++) {
for (int j = 1; j <= n; j++) {
lca[i][j] = lca[1][lca[i - 1][lca[i - 1][j]]];
}
}
}
void calc(int id, int par, int branch = 0) {
for (int i = 0; i < v[id].size(); i++) {
int u = v[id][i];
if (u == par) continue;
int branch2 = (branch == 0 ? u : branch);
if (branch2 != ma[0]) {
if (n - sub[ma[0]] - sub[u] <= T) ans[u] = 1;
} else {
if (n - sub[ma[1]] - sub[u] <= T) ans[u] = 1;
}
if (n - sub[branch2] <= T) ans[u] = 1;
calc(u, id, branch2);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i < n; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
if (n <= 4) {
for (int i = 1; i <= n; i++) cout << 1 << " ";
return 0;
}
dfs(1, 0);
T = n / 2;
c = centroid(1, 0);
memset(sub, 0, sizeof(sub));
dfs(c, 0);
ans[c] = 1;
for (int i = 0; i < v[c].size(); i++) {
int u = v[c][i];
if (sub[u] >= sub[ma[0]]) {
ma[1] = ma[0];
ma[0] = u;
} else if (sub[u] > sub[ma[1]])
ma[1] = u;
}
calc(c, 0);
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4e5 + 5;
struct Edge {
int v, nxt;
Edge() {}
Edge(int _v, int _nxt) : v(_v), nxt(_nxt) {}
};
Edge E[MAXN * 2];
int head[MAXN], ans[MAXN], sub[MAXN], mxsub[MAXN];
int tot = 0, fuc, n, x, y;
void addedge(int u, int v) {
E[tot] = Edge(v, head[u]);
head[u] = tot++;
}
void dfs1(int now, int fa) {
sub[now] = 1;
mxsub[now] = 1;
int tmp = 1;
for (int i = head[now]; ~i; i = E[i].nxt) {
int v = E[i].v;
if (v != fa) {
dfs1(v, now);
sub[now] += sub[v];
mxsub[now] = max(mxsub[now], mxsub[v]);
tmp += sub[v];
}
}
if (tmp <= fuc) {
mxsub[now] = tmp;
}
}
void dfs2(int now, int fa, int subfa, int mxfa) {
int cnt = subfa > fuc;
int id;
if (cnt) {
id = -1;
}
int tmp = n;
int mx1, mx2;
int id1, id2;
mx1 = mx2 = -1;
for (int i = head[now]; ~i; i = E[i].nxt) {
int v = E[i].v;
if (v != fa) {
if (id1 == -1 || mx1 < mxsub[v]) {
mx2 = mx1;
id2 = id1;
mx1 = mxsub[v];
id1 = v;
} else if (id2 == -1 || mx2 < mxsub[v]) {
mx2 = mxsub[v];
id2 = v;
}
}
}
for (int i = head[now]; ~i; i = E[i].nxt) {
int v = E[i].v;
if (v != fa) {
dfs2(v, now, sub[now] - sub[v] + subfa,
max(tmp - sub[v] <= fuc ? tmp - sub[v] : 0,
max(mxfa, id1 == v ? mx2 : mx1)));
if (sub[v] > fuc) {
cnt++;
id = v;
}
}
}
if (cnt > 1) {
ans[now] = 0;
} else if (cnt == 0) {
ans[now] = 1;
} else if (id != -1) {
ans[now] = (sub[id] - mxsub[id] <= fuc);
} else {
ans[now] = (subfa - mxfa <= fuc);
}
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
addedge(x, y);
addedge(y, x);
}
fuc = n / 2;
dfs1(1, 1);
dfs2(1, 1, 0, 0);
for (int i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int qtd[400001], _max[400001];
vector<int> graph[400001];
bool ok[400001];
int n;
multiset<int> s;
void coloca(int x) {
if (x <= n / 2) s.insert(x);
}
void tira(int x) {
if (x <= n / 2) s.erase(s.find(x));
}
int dfs(int v, int parent) {
qtd[v] = 1;
for (int u : graph[v]) {
if (u == parent) continue;
qtd[v] += dfs(u, v);
if (qtd[u] <= n / 2) _max[v] = max(_max[v], qtd[u]);
_max[v] = max(_max[v], _max[u]);
}
if (qtd[v] <= n / 2) _max[v] = max(_max[v], qtd[v]);
return qtd[v];
}
void dfs2(int v, int parent) {
if (n - qtd[v] - *--s.end() > n / 2) ok[v] = true;
for (int u : graph[v])
if (u != parent) coloca(_max[u]);
for (int u : graph[v]) {
if (u == parent) continue;
if (qtd[u] - _max[u] > n / 2) ok[v] = true;
coloca(n - qtd[u]);
tira(_max[u]);
dfs2(u, v);
coloca(_max[u]);
tira(n - qtd[u]);
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d %d", &a, &b);
graph[a].push_back(b);
graph[b].push_back(a);
}
coloca(0);
dfs(1, 1);
dfs2(1, 1);
for (int i = 1; i <= n; i++) printf("%d ", !ok[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 400 * 1000 + 10;
vector<int> vec[MAXN];
bool mark[MAXN];
bool ok[MAXN];
int sz[MAXN], dwn[MAXN], up[MAXN];
int n, m;
void dfs(int v) {
sz[v] = 1;
mark[v] = true;
for (int i = 0; i < (int)vec[v].size(); i++) {
int u = vec[v][i];
if (!mark[u]) {
dfs(u);
sz[v] += sz[u];
dwn[v] = max(dwn[u], dwn[v]);
if (sz[u] <= n / 2) dwn[v] = max(dwn[v], sz[u]);
if (sz[u] - dwn[u] > n / 2) ok[v] = false;
}
}
}
void dfs2(int v) {
if (n - sz[v] - up[v] > n / 2) ok[v] = false;
if (n - sz[v] <= n / 2) up[v] = n - sz[v];
mark[v] = true;
int k = up[v];
for (int i = 0; i < (int)vec[v].size(); i++) {
int u = vec[v][i];
if (!mark[u]) {
up[u] = max(up[u], k);
k = max(k, dwn[u]);
if (sz[u] <= n / 2) k = max(k, sz[u]);
}
}
k = up[v];
for (int i = (int)vec[v].size() - 1; i >= 0; i--) {
int u = vec[v][i];
if (!mark[u]) {
up[u] = max(up[u], k);
k = max(k, dwn[u]);
if (sz[u] <= n / 2) k = max(k, sz[u]);
dfs2(u);
}
}
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--, b--;
vec[a].push_back(b);
vec[b].push_back(a);
}
memset(ok, true, n);
dfs(0);
memset(mark, false, n);
dfs2(0);
for (int i = 0; i < n; i++) cout << ok[i] << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400005;
int n, sz[N], p[N], cur, centroid;
vector<int> adj[N];
void dfs(int u, int par = -1) {
sz[u] = 1;
for (int &v : adj[u])
if (v != par) p[v] = u, dfs(v, u), sz[u] += sz[v];
}
int find_center(int u, int par = -1) {
for (int &v : adj[u])
if (v != par && sz[v] > n / 2) return find_center(v, u);
return u;
}
void dfs1(int u, int par) {
p[u] = cur;
for (int &v : adj[u]) {
if (v != par && v != centroid) dfs1(v, u);
}
}
int main() {
cin.tie(0)->sync_with_stdio(false);
cin >> n;
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1);
centroid = find_center(1);
memset(sz, 0, sizeof sz);
dfs(centroid);
int max_sz = 0, se_max_sz = 0;
for (auto &v : adj[centroid]) {
cur = v;
dfs1(v, v);
if (sz[v] > max_sz)
se_max_sz = max_sz, max_sz = sz[v];
else
se_max_sz = max(se_max_sz, sz[v]);
}
for (int i = 1; i <= n; ++i) {
if (n - sz[p[i]] <= n / 2)
cout << 1 << ' ';
else if (n - (sz[i] + (sz[p[i]] == max_sz ? se_max_sz : max_sz)) <= n / 2)
cout << 1 << ' ';
else
cout << 0 << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T& num) {
char CH;
bool F = false;
for (CH = getchar(); CH < '0' || CH > '9'; F = CH == '-', CH = getchar())
;
for (num = 0; CH >= '0' && CH <= '9';
num = num * 10 + CH - '0', CH = getchar())
;
F && (num = -num);
}
int stk[70], tp;
template <class T>
inline void print(T p) {
if (!p) {
puts("0");
return;
}
while (p) stk[++tp] = p % 10, p /= 10;
while (tp) putchar(stk[tp--] + '0');
putchar('\n');
}
const long long mod = 1e9 + 7;
const double PI = acos(-1.0);
const int inf = 1e9;
const int N = 4e5 + 10;
const int maxn = 1e3 + 20;
const double eps = 1e-12;
int n, siz[N], ans[N], submax[N], max1[N], max2[N];
vector<int> ve[N];
void dfs(int cur, int fa) {
siz[cur] = 1;
submax[cur] = 0;
int len = ve[cur].size();
for (int i = 0; i < len; i++) {
int x = ve[cur][i];
if (x == fa) continue;
dfs(x, cur);
siz[cur] += siz[x];
if (submax[x] > submax[cur]) {
max2[cur] = max1[cur];
max1[cur] = x;
submax[cur] = submax[x];
} else if (submax[x] > submax[max2[cur]])
max2[cur] = x;
}
if (siz[cur] <= n / 2) submax[cur] = siz[cur];
}
void dfs1(int cur, int fa, int mmax) {
int len = ve[cur].size(), flag = 1;
for (int i = 0; i < len; i++) {
int x = ve[cur][i];
if (x == fa) {
int temp = n - siz[cur];
if (temp > n / 2 && temp - mmax > n / 2) flag = 0;
continue;
}
if (siz[x] > n / 2) {
if (siz[x] - submax[x] > n / 2) flag = 0;
}
}
ans[cur] = flag;
for (int i = 0; i < len; i++) {
int x = ve[cur][i];
if (x == fa) continue;
int temp;
if (n - siz[x] <= n / 2)
temp = n - siz[x];
else {
if (max1[cur] == x)
temp = max(mmax, submax[max2[cur]]);
else
temp = max(mmax, submax[max1[cur]]);
}
dfs1(x, cur, temp);
}
}
int main() {
read(n);
int u, v;
for (int i = 1; i <= n - 1; i++) {
read(u);
read(v);
ve[v].push_back(u);
ve[u].push_back(v);
}
dfs(1, 0);
dfs1(1, 0, 0);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int x = 0;
while (ch < '0' || '9' < ch) ch = getchar();
while ('0' <= ch && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x;
}
const int maxn = 400009;
struct edge {
int v, link;
} e[maxn * 2];
int head[maxn], size[maxn], big[maxn];
int n, u, v, ans[maxn];
inline void addEdge(int k, int u, int v) {
e[k].v = v;
e[k].link = head[u];
head[u] = k;
}
void dfs(int u, int fa) {
size[u] = 1;
for (int k = head[u]; k; k = e[k].link)
if (e[k].v != fa) {
dfs(e[k].v, u);
size[u] += size[e[k].v];
big[u] = max(big[u], big[e[k].v]);
if (size[e[k].v] - big[e[k].v] > n / 2) ans[u] |= 1;
}
if (size[u] <= n / 2) big[u] = max(big[u], size[u]);
}
void dfs(int u, int fa, int best, int tmp) {
int mx1 = 0, mx2 = 0, a;
if (n - size[u] - best > n / 2) ans[u] |= 1;
if (n - size[u] <= n / 2) best = max(best, n - size[u]);
for (int k = head[u]; k; k = e[k].link)
if (e[k].v != fa) {
if (big[e[k].v] >= mx1) {
mx2 = mx1;
mx1 = big[e[k].v];
} else if (big[e[k].v] >= mx2)
mx2 = big[e[k].v];
}
for (int k = head[u]; k; k = e[k].link)
if (e[k].v != fa) {
if (big[e[k].v] == mx1)
a = mx2;
else
a = mx1;
dfs(e[k].v, u, max(best, max(a, tmp)),
(n - size[e[k].v] > n / 2 ? 0 : n - size[e[k].v]));
}
}
int main() {
n = read();
for (int i = 1; i <= n - 1; i++) {
u = read();
v = read();
addEdge(2 * i - 1, u, v);
addEdge(2 * i, v, u);
}
dfs(1, 0);
dfs(1, 0, 0, 0);
for (int i = 1; i <= n; i++) printf("%d ", ans[i] ^ 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, c, d, x, y, p, q, t, ans[400009], res, mi, T, lca[22][400009],
sub[400009];
vector<int> v[400009];
int ma[2];
void dfs(int id, int par) {
lca[1][id] = par;
lca[0][id] = id;
for (int i = 0; i < v[id].size(); i++) {
int u = v[id][i];
if (u == par) continue;
dfs(u, id);
sub[id] += sub[u];
}
sub[id]++;
}
int centroid(int id, int par) {
int f = 0, s = 0;
for (int i = 0; i < v[id].size(); i++) {
int u = v[id][i];
if (u == par) continue;
if (sub[u] > T) {
f = 1;
break;
} else
s += sub[u];
}
if (f == 0 && n - 1 - s <= T) return id;
for (int i = 0; i < v[id].size(); i++) {
int u = v[id][i];
if (u == par) continue;
f = centroid(u, id);
if (f) return f;
}
return 0;
}
int lim;
void init_lca() {
lim = log(n) / log(2) + 1;
for (int i = 2; i <= lim; i++) {
for (int j = 1; j <= n; j++) {
lca[i][j] = lca[1][lca[i - 1][lca[i - 1][j]]];
}
}
}
void calc(int id, int par, int branch = 0) {
for (int i = 0; i < v[id].size(); i++) {
int u = v[id][i];
if (u == par) continue;
int branch2 = (branch == 0 ? u : branch);
if (branch2 != ma[0]) {
if (n - sub[ma[0]] - sub[u] <= T) ans[u] = 1;
} else {
if (n - sub[ma[1]] - sub[u] <= T) ans[u] = 1;
}
if (n - sub[branch2] <= T) ans[u] = 1;
calc(u, id, branch2);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i < n; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
if (n <= 4) {
for (int i = 1; i <= n; i++) cout << 1 << " ";
return 0;
}
dfs(1, 0);
T = n / 2;
c = centroid(1, 0);
memset(sub, 0, sizeof(sub));
dfs(c, 0);
ans[c] = 1;
for (int i = 0; i < v[c].size(); i++) {
int u = v[c][i];
if (sub[u] >= sub[ma[0]]) {
ma[1] = ma[0];
ma[0] = u;
} else if (sub[u] > sub[ma[1]])
ma[1] = u;
}
init_lca();
calc(c, 0);
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[400001], vertex;
int r, n, s[400001], pa[400001], ans[400001], k, t;
void visit(int u) {
s[u] = 1;
bool dd = true;
for (auto v : g[u]) {
if (!pa[v]) {
pa[v] = u;
visit(v);
s[u] += s[v];
if (s[v] > n / 2) dd = false;
}
}
if (n - s[u] > n / 2) dd = false;
if (!r && dd) r = u;
}
void dfs(int u) {
if (k + t - s[u] <= n / 2 || n - t <= n / 2)
ans[u] = 1;
else
return;
for (auto v : g[u]) {
if (pa[v] == u) dfs(v);
}
}
bool cmp(int x, int y) { return (s[x] > s[y]); }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
if (n == 2) {
cout << "1 1";
return 0;
}
pa[1] = 1;
visit(1);
for (int i = 1; i <= n; i++) s[i] = 0, pa[i] = 0;
pa[r] = r;
visit(r);
for (auto v : g[r]) vertex.push_back(v);
sort(vertex.begin(), vertex.end(), cmp);
ans[r] = 1;
for (auto v : g[r]) {
t = s[v];
if (v == vertex[0]) {
k = n - s[vertex[1]] - t;
} else {
k = n - s[vertex[0]] - t;
}
dfs(v);
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
inline bool checkBit(long long n, int i) { return n & (1LL << i); }
inline long long setBit(long long n, int i) {
return n | (1LL << i);
;
}
inline long long resetBit(long long n, int i) { return n & (~(1LL << i)); }
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long &a) {
a %= 1000000007;
(a < 0) && (a += 1000000007);
}
inline long long modMul(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline long long modAdd(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long modSub(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInverse(long long a) { return modPow(a, 1000000007 - 2); }
inline long long modDiv(long long a, long long b) {
return modMul(a, modInverse(b));
}
bool seive[1010000];
vector<long long> prime;
void seiveGen(long long limit) {
limit += 100;
long long sqrtn = sqrt(limit);
for (long long i = 3; i <= sqrtn; i += 2) {
if (!seive[i >> 1]) {
for (long long j = i * i; j < limit; j += i + i) {
seive[j >> 1] = 1;
}
}
}
prime.push_back(2);
for (long long i = 3; i < limit; i += 2) {
if (!seive[i >> 1]) prime.push_back(i);
}
}
inline long long power(long long bs, long long k) {
long long x = 1LL, y = bs;
if (k == 0) return 1LL;
while (k > 0) {
if (k % 2) x *= y;
y *= y;
k /= 2;
}
return x;
}
template <typename F, typename S>
ostream &operator<<(ostream &os, const pair<F, S> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
string to_str(T t) {
stringstream second;
second << t;
return second.str();
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename F, typename S>
ostream &operator<<(ostream &os, const map<F, S> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
clock_t tStart = clock();
void faltu() { cerr << '\n'; }
template <typename T>
void faltu(T a[], int n) {
for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
cerr << '\n';
}
template <typename T, typename... hello>
void faltu(T arg, const hello &...rest) {
cerr << arg << ' ';
faltu(rest...);
}
vector<long long> g[400100];
long long dp[400100], n, ans[400100], cen, mx1, mx2, v1, v2;
bool vis[400100], mx_tr[400100];
long long sb[400100];
void dfs(long long u) {
long long i, j, sz = (long long)g[u].size();
vis[u] = true;
sb[u] = 1;
for (i = 0; i < sz; ++i) {
j = g[u][i];
if (vis[j]) continue;
dfs(j);
sb[u] += sb[j];
}
}
long long get_centroid(long long u) {
long long i, j = -1;
bool cur = true;
vis[u] = true;
for (long long v : g[u]) {
if (vis[v]) continue;
if (sb[v] > (n / 2)) cur = false;
if (j == -1 || sb[v] > sb[j]) j = v;
}
if (cur && n - sb[u] <= (n / 2)) return u;
return get_centroid(j);
}
void dfs2(long long u) {
vis[u] = true;
if (u == cen)
ans[u] = 1;
else {
if (mx_tr[u]) {
if (n - sb[u] - mx2 <= (n / 2))
ans[u] = 1;
else
ans[u] = 0;
} else {
if (n - sb[u] - mx1 <= n / 2)
ans[u] = 1;
else
ans[u] = 0;
}
}
for (long long v : g[u]) {
if (vis[v]) continue;
mx_tr[v] |= mx_tr[u];
dfs2(v);
}
}
int main() {
int i, j = -1, a, b;
cin >> n;
for (i = 1; i < n; ++i) {
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
memset(sb, 0, sizeof(sb));
memset(vis, false, sizeof(vis));
dfs(1);
memset(vis, false, sizeof(vis));
cen = get_centroid(1);
memset(vis, false, sizeof(vis));
dfs(cen);
memset(ans, 0, sizeof(ans));
for (long long v : g[cen]) {
if ((sb[v] * 2) == sb[cen]) {
j = 1;
break;
}
if (sb[v] > mx1) {
mx2 = mx1;
v2 = v1;
mx1 = sb[v];
v1 = v;
} else if (sb[v] > mx2) {
mx2 = sb[v];
v2 = v;
}
}
if (j == 1) {
for (i = 1; i <= n; ++i) cout << 1 << ' ';
return 0;
}
memset(mx_tr, false, sizeof(mx_tr));
mx_tr[v1] = true;
memset(vis, false, sizeof(vis));
dfs2(cen);
for (i = 1; i <= n; ++i) cout << ans[i] << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 4;
vector<int> adj[maxn];
int dp1[maxn], dp2[maxn], C[maxn], ans[maxn];
int n;
void DFS(int u, int par = -1) {
C[u] = 1;
for (int i = 0; i < adj[u].size(); ++i)
if (adj[u][i] != par) {
int v = adj[u][i];
DFS(v, u);
C[u] += C[v];
dp1[u] = max(dp1[u], dp1[v]);
}
if (C[u] <= n / 2) dp1[u] = C[u];
}
void Solve(int u, int par = -1) {
ans[u] = 1;
if (C[u] <= n / 2) {
if (n - C[u] - dp2[u] > n / 2) ans[u] = 0;
} else {
for (int i = 0; i < adj[u].size(); ++i)
if (adj[u][i] != par) {
int v = adj[u][i];
if (C[v] - dp1[v] > n / 2) ans[u] = 0;
}
}
int ma = -1, mav = -1;
for (int i = 0; i < adj[u].size(); ++i)
if (adj[u][i] != par) {
int v = adj[u][i];
if (dp1[v] > ma) ma = dp1[v], mav = v;
}
for (int i = 0; i < adj[u].size(); ++i)
if (adj[u][i] != par) {
int v = adj[u][i];
if (v == mav) {
dp2[v] = dp2[u];
for (int k = 0; k < adj[u].size(); ++k)
if (adj[u][k] != par && adj[u][k] != mav) {
int vv = adj[u][k];
dp2[v] = max(dp2[v], dp1[vv]);
}
} else
dp2[v] = max(dp2[u], ma);
if (n - C[v] <= n / 2) dp2[v] = n - C[v];
Solve(v, u);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
DFS(1);
Solve(1);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long linf = 1e18 + 9;
const int inf = 1e9 + 9;
const long long mod = 1e9 + 7;
const int N = 4e5 + 9;
int n, u, v, ans[N], sub[N], mx[N], centroid;
vector<int> gr[N], c[N];
int dfs(int v, int f) {
sub[v] = 1;
for (int i = 0; i < gr[v].size(); i++) {
if (gr[v][i] == f) continue;
int t = dfs(gr[v][i], v);
sub[v] += t;
mx[v] = max(mx[v], t);
c[v].push_back(t);
}
if ((n - sub[v]) <= n / 2 and mx[v] <= n / 2) {
ans[v] = 1;
centroid = v;
}
return sub[v];
}
void dfs2(int v, int f, int cur, int root) {
if (v != centroid and ans[v] == 0) {
int t = c[centroid].size() - 1;
if (sub[root] == c[centroid][t]) t--;
if (t >= 0 and n - sub[v] - c[centroid][t] <= n / 2)
ans[v] = 1;
else {
if (cur - sub[v] <= n / 2)
ans[v] = 1;
else
ans[v] = 0;
}
}
if (n - sub[v] <= n / 2) cur = sub[v];
for (int i = 0; i < gr[v].size(); i++) {
if (gr[v][i] == f) continue;
if (v == centroid) root = gr[v][i];
dfs2(gr[v][i], v, cur, root);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d %d", &u, &v);
gr[u].push_back(v);
gr[v].push_back(u);
}
dfs(1, 0);
memset(mx, 0, sizeof mx);
for (int i = 1; i <= n; i++) c[i].clear();
dfs(centroid, 0);
for (int i = 1; i <= n; i++) sort(c[i].begin(), c[i].end());
dfs2(centroid, 0, 0, 0);
for (int i = 1; i <= n; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
class biggest {
public:
void put(int max, int source) {
if (max > max2) {
if (max > max1) {
max2 = max1;
max1 = max;
max_source = source;
return;
}
max2 = max;
}
}
int max(int but_not) const {
if (but_not == max_source) return max2;
return max1;
}
int max1, max2, max_source;
};
struct edge_details {
int children, cut;
};
int N, N2;
std::vector<std::map<int, edge_details>> connections;
std::vector<biggest> maxes;
std::vector<bool> is_reparent_used, good;
int dfs(int current, int parent) {
int children = 0;
for (auto &edge : connections[current]) {
if (edge.first != parent) {
int current_children = dfs(edge.first, current);
;
edge.second.children = current_children;
children += current_children;
if (current_children <= N2) {
int bigmax = std::max(current_children, edge.second.cut);
maxes[current].put(bigmax, edge.first);
} else {
maxes[current].put(edge.second.cut, edge.first);
if (is_reparent_used[current]) {
good[current] = false;
} else if (current_children - edge.second.cut > N2) {
good[current] = false;
} else {
is_reparent_used[current] = true;
}
}
}
}
if (parent != current) {
connections[parent][current].cut = maxes[current].max(-2);
connections[current][parent].children = N - children - 1;
}
return children + 1;
}
void dfs2(int current, int parent) {
int max = maxes[parent].max(current);
connections[current][parent].cut = max;
if (connections[current][parent].children > N2) {
if (connections[current][parent].children - max > N2) {
good[current] = false;
} else if (is_reparent_used[current]) {
good[current] = false;
} else {
is_reparent_used[current] = true;
}
connections[current][parent].cut = max;
} else {
connections[current][parent].cut =
std::max(max, connections[current][parent].children);
}
maxes[current].put(connections[current][parent].cut, parent);
for (auto &edge : connections[current]) {
if (edge.first != parent) {
dfs2(edge.first, current);
}
}
}
int main() {
std::cin >> N;
N2 = N / 2;
connections.resize(N);
is_reparent_used.resize(N);
maxes.resize(N);
good.resize(N);
std::fill(good.begin(), good.end(), true);
for (int i = 0; i < N - 1; ++i) {
int u, v;
std::cin >> u >> v;
--u;
--v;
connections[u][v] = {0, 0};
connections[v][u] = {0, 0};
}
dfs(0, 0);
for (auto &edge : connections[0]) {
bool is_reparent_used = false;
dfs2(edge.first, 0);
if (good[0] && edge.second.children > N2) {
if (is_reparent_used) {
good[0] = false;
} else {
is_reparent_used = true;
if (edge.second.children - edge.second.cut > N2) {
good[0] = false;
}
}
}
}
for (int i = 0; i < N; ++i) {
if (i > 0) std::cout << " ";
std::cout << (good[i] ? '1' : '0');
}
std::cout << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
const long long LL_INF = (long long)2e18 + 5;
using namespace std;
const long long N = 4e5 + 1;
vector<long long> adj[N], par(N), child(N);
void dfs(long long v, long long par) {
for (auto u : adj[v]) {
if (u == par) continue;
dfs(u, v);
}
child[v] += 1;
child[par] += child[v];
}
long long centroid(long long v, long long p, long long n) {
for (auto u : adj[v]) {
if (u == p) continue;
if (child[u] <= n / 2) continue;
return centroid(u, v, n);
}
return v;
}
void dfs_for_cent(long long v, long long p) {
child[v] = 1;
if (p != -1) {
if (par[p] == -1)
par[v] = v;
else
par[v] = par[p];
}
for (auto u : adj[v]) {
if (u == p) continue;
dfs_for_cent(u, v);
child[v] += child[u];
}
}
void solve() {
long long n;
cin >> n;
for (long long i = (long long)(0); i < (long long)(n - 1); i++) {
long long u, v;
cin >> u >> v;
adj[u].push_back(v), adj[v].push_back(u);
}
dfs(1, 0);
long long cent = centroid(1, 0, n);
par[cent] = -1;
dfs_for_cent(cent, -1);
vector<long long> ans(n + 1);
long long mx_1 = -1, mx_2 = -1, mx_ind = -1;
for (long long i = (long long)(1); i < (long long)(n + 1); i++) {
if (par[i] == i) {
if (child[i] >= mx_1) {
if (child[i] == mx_1) {
if (mx_ind == -1)
mx_ind = i;
else
mx_ind = -0x3f3f3f3f;
} else {
mx_ind = i;
}
mx_2 = mx_1, mx_1 = child[i];
} else if (child[i] > mx_2)
mx_2 = child[i];
}
}
for (long long i = (long long)(1); i < (long long)(n + 1); i++) {
if (i == cent) {
ans[i]++;
continue;
}
long long pr = par[i];
long long remain = 0;
if (pr == mx_ind) {
remain = max(child[pr] - child[i], mx_2);
} else
remain = mx_1;
ans[i] = n - child[i] - remain <= n / 2;
}
for (long long i = (long long)(1); i < (long long)(n + 1); i++)
cout << ans[i] << ' ';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> E[400000 + 5];
int dp[400000 + 5];
int max1[400000 + 5];
int max2[400000 + 5];
int sz[400000 + 5];
void dfs1(int x, int fa) {
sz[x] = 1;
dp[x] = 0;
for (int y : E[x]) {
if (y != fa) {
dfs1(y, x);
sz[x] += sz[y];
if (dp[y] > dp[x]) {
dp[x] = dp[y];
max2[x] = max1[x];
max1[x] = y;
} else if (dp[y] > dp[max2[x]])
max2[x] = y;
}
}
if (sz[x] <= n / 2) dp[x] = sz[x];
}
int ans[400000 + 5];
void dfs2(int x, int fa, int pre) {
int flag = 1;
for (int y : E[x]) {
if (y == fa) {
if (n - sz[x] > n / 2 && n - sz[x] - pre > n / 2) flag = 0;
} else if (sz[y] > n / 2) {
if (sz[y] - dp[y] > n / 2) flag = 0;
}
}
ans[x] = flag;
for (int y : E[x]) {
if (y != fa) {
int tmp;
if (n - sz[y] <= n / 2)
tmp = n - sz[y];
else {
if (y == max1[x])
tmp = max(pre, dp[max2[x]]);
else
tmp = max(pre, dp[max1[x]]);
}
dfs2(y, x, tmp);
}
}
}
int main() {
int u, v;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d %d", &u, &v);
E[u].push_back(v);
E[v].push_back(u);
}
dfs1(1, 0);
dfs2(1, 0, 0);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> e[400040];
int ans[400040], sz[400040], uz[400040], dz[400040], n;
void dfs(int x, int fa) {
int i, y;
sz[x] = 1;
for (i = 0; i < e[x].size(); i++) {
y = e[x][i];
if (y == fa) continue;
dfs(y, x);
if (sz[y] - dz[y] > n / 2) ans[x] = 0;
sz[x] += sz[y];
dz[x] = max(dz[x], dz[y]);
}
if (sz[x] <= n / 2) dz[x] = sz[x];
}
void dfs1(int x, int fa) {
if (n - sz[x] - uz[x] > n / 2) ans[x] = 0;
if (n - sz[x] <= n / 2) uz[x] = n - sz[x];
int i, y, mx = uz[x], p = -1, m = 0;
for (i = 0; i < e[x].size(); i++) {
y = e[x][i];
if (y == fa) continue;
if (dz[y] > mx) {
p = y;
m = mx;
mx = dz[y];
} else if (dz[y] > m)
m = dz[y];
}
for (i = 0; i < e[x].size(); i++) {
y = e[x][i];
if (y == fa) continue;
if (y == p)
uz[y] = m;
else
uz[y] = mx;
dfs1(y, x);
}
}
void solve() {
int i, x, y;
cin >> n;
for (i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
e[x].push_back(y);
e[y].push_back(x);
}
for (i = 1; i <= n; i++) ans[i] = 1;
dfs(1, 0);
dfs1(1, 0);
for (i = 1; i <= n; i++) printf("%d ", ans[i]);
}
int main(void) {
int T = 1;
while (T--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 400000;
int k[SIZE], cen = -1, ans[SIZE], t, num[SIZE], z;
vector<int> g[SIZE];
vector<int> y;
void dfs1(int v, int pr, int n) {
bool r = true;
if (pr == t) {
y.push_back(v);
z = y.size() - 1;
}
num[v] = z;
for (int u : g[v]) {
if (u == pr) {
continue;
}
dfs1(u, v, n);
if ((k[u] + 1) > n / 2) {
r = false;
}
k[v] += k[u] + 1;
}
if (r && (k[v] + 1) * 2 >= n) {
cen = v;
}
}
int main() {
for (int i = 0; i < SIZE; i++) {
k[i] = 0;
}
int n, a, b, max1 = 0, max2 = 1;
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
g[a - 1].push_back(b - 1);
g[b - 1].push_back(a - 1);
}
dfs1(0, -1, n);
t = cen;
for (int i = 0; i < SIZE; i++) {
k[i] = 0;
}
y.resize(0);
dfs1(cen, -1, n);
if (k[y[0]] > k[y[1]]) {
max1 = 0;
max2 = 1;
} else {
max1 = 1;
max2 = 0;
}
for (int i = 2; i < y.size(); i++) {
int v = y[i];
if (k[v] > k[y[max1]]) {
max2 = max1;
max1 = i;
} else {
if (k[v] > k[y[max2]]) {
max2 = i;
}
}
}
for (int i = 0; i < n; i++) {
if (i == t) {
ans[i] = 1;
continue;
}
if ((k[y[num[i]]] + 1) == n - n / 2) {
ans[i] = 1;
} else {
if (num[i] == max1) {
if ((k[i] + 2 + k[y[max2]]) >= n - (n / 2)) {
ans[i] = 1;
}
} else {
if ((k[i] + 2 + k[y[max1]]) >= n - (n / 2)) {
ans[i] = 1;
}
}
}
}
for (int i = 0; i < n; i++) {
cout << ans[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
const int N = 4e5 + 5;
int n, h;
int sub[N];
int Mx[N][2];
int id[N][2];
int flag[N];
int ans[N];
vector<int> G[N];
int is[N];
void dfs(int u, int p = -1) {
sub[u] = 1;
is[u] = 0;
flag[u] = 1;
Mx[u][0] = Mx[u][1] = -1;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v == p) continue;
dfs(v, u);
sub[u] += sub[v];
if (sub[v] > h) {
if (sub[v] - Mx[v][0] <= h) {
is[u]++;
} else
flag[u] = 0;
}
int o = Mx[v][0];
if (sub[v] <= h) o = max(o, sub[v]);
if (Mx[u][0] < o) {
Mx[u][1] = Mx[u][0];
id[u][1] = id[u][0];
Mx[u][0] = o;
id[u][0] = v;
} else if (Mx[u][1] < o) {
Mx[u][1] = o;
id[u][1] = v;
}
}
}
void dfs2(int u, int p, int PM) {
if (u > 1) {
int o = PM;
int os = n - sub[u];
if (os - o > h) flag[u] = 0;
if (os > h) is[u]++;
}
if (is[u] > 1 || flag[u] == 0) ans[u] = 0;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v == p) continue;
int M = PM;
if (id[u][0] != v) M = max(M, Mx[u][0]);
if (id[u][1] != v) M = max(M, Mx[u][1]);
if (n - sub[u] <= h) M = max(M, n - sub[u]);
dfs2(v, u, M);
}
}
int main() {
int u, v;
cin >> n;
h = n / 2;
for (int i = 0; i < n - 1; i++) {
scanf("%d %d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; i++) ans[i] = 1, flag[i] = 1;
dfs(1, -1);
dfs2(1, -1, 0);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4e5 + 10;
vector<int> g[MAXN];
bool can[MAXN];
int cnt[MAXN], prob[MAXN];
int best[MAXN], n;
void dfs_down(int v, int p = -1) {
prob[v] = -1;
cnt[v] = 1;
for (int u : g[v]) {
if (u == p) continue;
dfs_down(u, v);
cnt[v] += cnt[u];
best[v] = max(best[v], best[u]);
if (cnt[u] <= n / 2)
best[v] = max(best[v], cnt[u]);
else
prob[v] = u;
}
if (prob[v] == -1 and n - cnt[v] <= n / 2)
can[v] = true;
else if (prob[v] != -1) {
int u = prob[v];
int x = best[u];
if (cnt[u] - x <= n / 2) can[v] = true;
}
}
void dfs_up(int v, int pass = 0, int p = -1) {
if (can[v] == false and prob[v] == -1) {
int x = n - cnt[v];
if (x - pass <= n / 2) can[v] = true;
}
set<pair<int, int> > s;
for (int u : g[v])
if (u != p) {
s.insert({best[u], u});
if (cnt[u] <= n / 2) s.insert({cnt[u], u});
}
s.insert({pass, v});
if (n - cnt[v] <= n / 2) s.insert({n - cnt[v], v});
for (int u : g[v]) {
if (u == p) continue;
s.erase({best[u], u});
if (cnt[u] <= n / 2) s.erase({cnt[u], u});
int x = s.rbegin()->first;
dfs_up(u, x, v);
s.insert({best[u], u});
if (cnt[u] <= n / 2) s.insert({cnt[u], u});
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int v, u;
cin >> v >> u;
v--;
u--;
g[v].push_back(u);
g[u].push_back(v);
}
dfs_down(0);
dfs_up(0);
for (int i = 0; i < n; i++) cout << can[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-8;
struct Edge {
int v, next;
} eg[1000000];
int head[500000];
int ans[500000];
int tp, fuc, n;
int sub[500000], submx[500000];
void Add(int u, int v) {
eg[tp].v = v;
eg[tp].next = head[u];
head[u] = tp++;
}
void dfs(int u, int pre) {
sub[u] = 1;
submx[u] = 1;
int v;
int tmp = 1;
for (int i = head[u]; i != -1; i = eg[i].next) {
v = eg[i].v;
if (v == pre) continue;
dfs(v, u);
sub[u] += sub[v];
submx[u] = max(submx[u], submx[v]);
tmp += sub[v];
}
if (tmp <= fuc) submx[u] = tmp;
}
void dfs2(int u, int pre, int subfa, int mxfa) {
int cnt = subfa > fuc;
int id, v;
if (cnt) id = -1;
int tmp = n;
int mx1, mx2;
int id1, id2;
mx1 = mx2 = -1;
for (int i = head[u]; i != -1; i = eg[i].next) {
v = eg[i].v;
if (v == pre) continue;
if (id1 == -1 || mx1 < submx[v]) {
mx2 = mx1;
id2 = id1;
mx1 = submx[v];
id1 = v;
} else if (id2 == -1 || mx2 < submx[v]) {
mx2 = submx[v];
id2 = v;
}
}
for (int i = head[u]; i != -1; i = eg[i].next) {
v = eg[i].v;
if (v == pre) continue;
dfs2(v, u, sub[u] - sub[v] + subfa,
max(tmp - sub[v] <= fuc ? tmp - sub[v] : 0,
max(mxfa, id1 == v ? mx2 : mx1)));
if (sub[v] > fuc) {
cnt++;
id = v;
}
}
if (cnt > 1)
ans[u] = 0;
else if (cnt == 0)
ans[u] = 1;
else if (id != -1)
ans[u] = (sub[id] - submx[id] <= fuc);
else
ans[u] = (subfa - mxfa <= fuc);
}
void solve() {
fuc = n / 2;
dfs(1, 1);
dfs2(1, 1, 0, 0);
}
int main() {
int u, v, i;
scanf("%d", &n);
tp = 0;
memset(head, -1, sizeof(head));
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
Add(u, v);
Add(v, u);
}
solve();
for (i = 1; i <= n; i++) {
if (i != 1) putchar(' ');
printf("%d", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, u, v, C, S1, S2, u1;
vector<vector<int>> G;
vector<bool> V, A;
vector<int> S;
int size(int u) {
V[u] = 1;
for (int v : G[u])
if (!V[v]) S[u] += size(v);
return S[u];
}
void find(int u) {
V[u] = 1;
C = u;
for (int v : G[u])
if (!V[v] && S[v] > N / 2) find(v);
}
void solve(int u, int i) {
V[u] = 1;
if (N - S[i] <= N / 2) A[u] = 1;
if (S[u] + (i != u1 ? S1 : S2) >= N - N / 2) A[u] = 1;
for (int v : G[u])
if (!V[v]) solve(v, i);
}
int main() {
cin >> N;
G.assign(N, {});
for (int i = 0; i < (int)N - 1; i++) {
cin >> u >> v;
u--, v--;
G[u].push_back(v);
G[v].push_back(u);
}
S.assign(N, 1);
V.assign(N, 0);
size(0);
V.assign(N, 0);
find(0);
S.assign(N, 1);
V.assign(N, 0);
size(C);
S1 = S2 = -1;
for (int v : G[C]) {
if (S[v] >= S1)
S2 = S1, S1 = S[v], u1 = v;
else if (S[v] > S2)
S2 = S[v];
}
A.assign(N, 0);
A[C] = 1;
V.assign(N, 0);
V[C] = 1;
for (int v : G[C]) solve(v, v);
for (int i = 0; i < (int)N; i++) cout << A[i] << ' ';
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 100000;
const long long inf = (long long)1e18;
const long long MOD = (long long)1e9 + 7;
const long double eps = 1e-6;
const long long ABC = 26;
const long long P = 239;
vector<vector<int> > g;
vector<int> sz, msz;
vector<int> ans;
int xxx;
int n;
void dfs(int u, int par) {
sz[u] = 1;
msz[u] = 0;
for (int v : g[u])
if (v != par) {
dfs(v, u);
sz[u] += sz[v];
msz[u] = max(msz[u], msz[v]);
}
if (sz[u] <= xxx) msz[u] = max(msz[u], sz[u]);
}
void dfs2(int u, int par, int best) {
int cnt = n - 1;
int bad = 0;
for (int v : g[u])
if (v != par) {
cnt -= sz[v];
if (sz[v] > xxx) {
if (sz[v] - msz[v] <= xxx)
bad++;
else
bad += 2;
}
}
if (cnt > xxx) {
if (cnt - best <= xxx)
bad++;
else
bad += 2;
}
if (bad <= 1)
ans[u] = 1;
else
ans[u] = 0;
cnt = g[u].size();
vector<int> pref(cnt + 1), suff(cnt + 1);
pref[0] = 0;
for (int i = 0; i < cnt; i++)
if (g[u][i] != par)
pref[i + 1] = max(pref[i], msz[g[u][i]]);
else
pref[i + 1] = max(pref[i], best);
suff[cnt] = 0;
for (int i = cnt - 1; i >= 0; i--)
if (g[u][i] != par)
suff[i] = max(suff[i + 1], msz[g[u][i]]);
else
suff[i] = max(suff[i + 1], best);
for (int i = 0; i < cnt; i++)
if (g[u][i] != par) {
int best1 = max(pref[i], suff[i + 1]);
if (n - sz[g[u][i]] <= xxx) best1 = max(best1, n - sz[g[u][i]]);
dfs2(g[u][i], u, best1);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
xxx = n / 2;
g.resize(n);
sz.resize(n);
msz.resize(n);
ans.resize(n);
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
g[a - 1].push_back(b - 1);
g[b - 1].push_back(a - 1);
}
dfs(0, -1);
dfs2(0, -1, 0);
for (int i : ans) cout << i << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int sum = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) {
sum = sum * 10 + (c ^ 48);
c = getchar();
}
return sum;
}
int const maxn = 400005;
int n, cnt, root, fi, se, finum, H[maxn], size[maxn], maxp[maxn];
bool vis[maxn];
struct Edge {
int next, to;
} E[maxn << 1];
inline void add(int a, int b) {
E[++cnt] = (Edge){H[a], b};
H[a] = cnt;
}
void getrt(int x, int fa) {
size[x] = 1, maxp[x] = 0;
for (int i = H[x]; i; i = E[i].next) {
int y = E[i].to;
if (y == fa) continue;
getrt(y, x);
size[x] += size[y];
maxp[x] = max(maxp[x], size[y]);
}
maxp[x] = max(maxp[x], n - size[x]);
if (maxp[x] < maxp[root]) root = x;
}
void dfs(int x, int fa) {
size[x] = 1;
for (int i = H[x]; i; i = E[i].next) {
int y = E[i].to;
if (y == fa) continue;
dfs(y, x);
size[x] += size[y];
if (x == root) {
if (size[y] > fi)
se = fi, fi = size[y], finum = y;
else if (size[y] > se)
se = size[y];
}
}
}
void col(int x, int fa) {
vis[x] = true;
for (int i = H[x]; i; i = E[i].next) {
int y = E[i].to;
if (y == fa) continue;
col(y, x);
}
}
int main() {
n = read();
for (int i = 1; i < n; i++) {
int x = read(), y = read();
add(x, y), add(y, x);
}
maxp[root = 0] = 1e8;
getrt(1, 0);
dfs(root, 0);
col(finum, root);
for (int i = 1; i <= n; i++) {
if (i == root)
printf("1 ");
else if (vis[i]) {
int tot = min(n - fi, max(se, n - se - size[i]));
if (tot > n / 2)
printf("0 ");
else
printf("1 ");
} else {
if (max(fi, n - fi - size[i]) > n / 2)
printf("0 ");
else
printf("1 ");
}
}
putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400400;
void DFS1(int i = 1, int p = 0);
void DFS2(int i = 1, int p = 0, int LastMax = 0);
void max_self(int& x, int y) { x = max(x, y); }
int n;
int W[N];
int Res[N];
int Ans[N];
vector<int> Adj[N];
vector<int> Pref[N];
vector<int> Suff[N];
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
Adj[x].push_back(y);
Adj[y].push_back(x);
}
DFS1();
DFS2();
for (int i = 1; i <= n; i++) printf("%d ", Ans[i]);
}
void DFS1(int i, int p) {
W[i] = 1;
for (auto j : Adj[i])
if (j != p) {
DFS1(j, i);
W[i] += W[j];
max_self(Res[i], Res[j]);
}
if (W[i] <= n / 2) Res[i] = W[i];
Pref[i].resize(Adj[i].size());
Suff[i].resize(Adj[i].size());
for (int j = 0; j < Adj[i].size(); j++) {
if (Adj[i][j] != p) Pref[i][j] = Res[Adj[i][j]];
if (j > 0) max_self(Pref[i][j], Pref[i][j - 1]);
}
for (int j = Adj[i].size() - 1; j >= 0; j--) {
if (Adj[i][j] != p) Suff[i][j] = Res[Adj[i][j]];
if (j + 1 < Adj[i].size()) max_self(Suff[i][j], Suff[i][j + 1]);
}
}
void DFS2(int i, int p, int LastMax) {
int HChild = p;
int MaxSize = n - W[i];
for (auto j : Adj[i])
if (j != p)
if (W[j] > MaxSize) MaxSize = W[j], HChild = j;
if (HChild == p)
Ans[i] = (MaxSize - LastMax <= n / 2);
else
Ans[i] = (MaxSize - Res[HChild] <= n / 2);
for (int j = 0, k; j < Adj[i].size(); j++)
if ((k = Adj[i][j]) != p) {
if (n - W[k] <= n / 2)
DFS2(k, i, n - W[k]);
else
DFS2(k, i,
max(LastMax, max(j > 0 ? Pref[i][j - 1] : 0,
j + 1 < Adj[i].size() ? Suff[i][j + 1] : 0)));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9;
const int MAXN = 1 << 20;
int n;
int b0[MAXN], b1[MAXN];
int p0[MAXN], p1[MAXN];
int size[MAXN];
vector<int> E[MAXN];
void update(int &b0, int &b1, int &p0, int &p1, int b, int p) {
if (b0 <= b) {
b1 = b0;
p1 = p0;
b0 = b;
p0 = p;
} else {
if (b1 < b) {
b1 = b;
p1 = p;
}
}
}
int lszx[MAXN], pszx[MAXN];
int cnt_larger[MAXN];
void calc_up(int x, int dad) {
for (auto child : E[x]) {
if (child == dad) continue;
if (size[child] > n / 2) ++cnt_larger[x];
if (size[child] > lszx[x]) {
lszx[x] = size[child];
pszx[x] = child;
}
}
if (dad != -1) {
int dad_sz = n - size[x];
if (dad_sz > n / 2) ++cnt_larger[x];
if (dad_sz > lszx[x]) {
lszx[x] = dad_sz;
pszx[x] = dad;
}
if (dad_sz <= n / 2) {
update(b0[x], b1[x], p0[x], p1[x], dad_sz, dad);
} else {
if (p0[dad] != x)
update(b0[x], b1[x], p0[x], p1[x], b0[dad], dad);
else
update(b0[x], b1[x], p0[x], p1[x], b1[dad], dad);
}
}
for (auto child : E[x]) {
if (child == dad) continue;
calc_up(child, x);
}
}
void calc_down(int x, int dad) {
int &sz = (size[x] = 1);
for (auto child : E[x]) {
if (child == dad) continue;
calc_down(child, x);
sz += size[child];
if (size[child] <= n / 2) {
update(b0[x], b1[x], p0[x], p1[x], size[child], child);
} else {
update(b0[x], b1[x], p0[x], p1[x], b0[child], child);
}
}
}
int main(void) {
scanf("%d", &n);
memset(p0, -1, sizeof p0);
memset(p1, -1, sizeof p1);
for (int i = 0; i < n - 1; ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u;
--v;
E[u].push_back(v);
E[v].push_back(u);
}
calc_down(0, -1);
calc_up(0, -1);
for (int i = 0; i < n; ++i) {
if (cnt_larger[i] == 0) {
printf("1 ");
continue;
}
if (cnt_larger[i] == 1) {
int p = pszx[i];
if (p0[p] == i) {
if (lszx[i] - b1[p] <= n / 2) {
printf("1 ");
continue;
}
} else {
if (lszx[i] - b0[p] <= n / 2) {
printf("1 ");
continue;
}
}
}
printf("0 ");
}
return 0;
}
|
#include <bits/stdc++.h>
const long long MOD = 1000000007;
using namespace std;
vector<int> tree[(400000 + 10)];
int n;
int sz[(400000 + 10)], fa[(400000 + 10)];
int dw[(400000 + 10)], up[(400000 + 10)];
void dfs_sz(int rt, int f) {
fa[rt] = f;
sz[rt] = 1;
for (int i = 0; i < tree[rt].size(); i++) {
int u = tree[rt][i];
if (u != f) {
dfs_sz(u, rt);
sz[rt] += sz[u];
}
}
}
void dfs_down(int rt, int f) {
dw[rt] = (sz[rt] <= n / 2 ? sz[rt] : 0);
for (int i = 0; i < tree[rt].size(); i++) {
int u = tree[rt][i];
if (u != f) {
dfs_down(u, rt);
dw[rt] = max(dw[rt], dw[u]);
}
}
}
void dfs_up(int rt, int f, int val) {
up[rt] = max((n - sz[rt] <= n / 2 ? n - sz[rt] : 0), val);
int mx0 = 0, mx1 = 0;
for (int i = 0; i < tree[rt].size(); i++) {
int u = tree[rt][i];
if (u != f) {
if (dw[u] >= mx0) {
mx1 = mx0;
mx0 = dw[u];
} else if (dw[u] >= mx1) {
mx1 = dw[u];
}
}
}
for (int i = 0; i < tree[rt].size(); i++) {
int u = tree[rt][i];
if (u != f) {
dfs_up(u, rt, max(up[rt], mx0 == dw[u] ? mx1 : mx0));
}
}
}
int main() {
scanf("%d", &n);
int u, v;
for (int i = 1; i < n; i++) {
scanf("%d %d", &u, &v);
tree[u].push_back(v);
tree[v].push_back(u);
}
dfs_sz(1, 0);
dfs_down(1, 0);
dfs_up(1, 0, 0);
for (v = 1; v <= n; v++) {
int ans = 1;
for (int i = 0; i < tree[v].size(); i++) {
u = tree[v][i];
if (u == fa[v]) {
if (n - sz[v] - up[v] > n / 2) ans = 0;
} else {
if (sz[u] - dw[u] > n / 2) ans = 0;
}
}
printf("%d ", ans);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f7f7f7f;
const int MAXN = 400105;
const double eps = 1e-10;
struct node {
int en, len, next;
node(int en = 0, int len = 0, int next = 0) : en(en), len(len), next(next) {}
};
struct node E[MAXN * 2];
int p[MAXN], num;
void init() {
memset(p, -1, sizeof(p));
num = 0;
}
void add(int st, int en, int len) {
E[num] = node(en, len, p[st]);
p[st] = num++;
}
int max(int x, int y, int z) { return max(x, max(y, z)); }
int du[MAXN], ans[MAXN];
int n, dis1[MAXN], dis2[MAXN], sum[MAXN], id[MAXN];
void dfs(int u, int fa) {
int i;
sum[u]++;
for (i = p[u]; i + 1; i = E[i].next) {
int v = E[i].en;
if (v == fa) continue;
dfs(v, u);
sum[u] += sum[v];
if (sum[v] <= n / 2) {
if (dis1[u] < sum[v]) {
if (id[u] != v) dis2[u] = dis1[u];
dis1[u] = sum[v];
id[u] = v;
} else if (dis1[u] == sum[v]) {
if (id[u] != v) dis2[u] = max(dis2[u], dis1[u]);
} else {
if (id[u] != v) dis2[u] = max(dis2[u], sum[v]);
}
}
if (dis1[u] < dis1[v]) {
if (id[u] != v) dis2[u] = dis1[u];
dis1[u] = dis1[v];
id[u] = v;
} else if (dis1[u] == dis1[v]) {
if (id[u] != v) dis2[u] = max(dis2[u], dis1[u]);
} else {
if (id[u] != v) dis2[u] = max(dis2[u], dis1[v]);
}
}
}
void DFS(int u, int fa, int leng) {
ans[u] = 1;
for (int i = p[u]; i + 1; i = E[i].next) {
int v = E[i].en;
if (v != fa) {
if (sum[v] - dis1[v] > n / 2) {
ans[u] = 0;
break;
}
} else {
if (n - sum[u] - leng > n / 2) {
ans[u] = 0;
break;
}
}
}
for (int i = p[u]; i + 1; i = E[i].next) {
int v = E[i].en;
if (v == fa) continue;
if (id[u] != v) {
DFS(v, u, max(dis1[u], leng, n - sum[u] <= n / 2 ? n - sum[u] : 0));
} else
DFS(v, u, max(dis2[u], leng, n - sum[u] <= n / 2 ? n - sum[u] : 0));
}
}
int main() {
int i;
scanf("%d", &n);
init();
for (i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v, 0);
add(v, u, 0);
}
for (i = 1; i <= n; i++) {
dis1[i] = dis2[i] = 0;
sum[i] = 0;
id[i] = -1;
ans[i] = -1;
}
dfs(1, -1);
DFS(1, -1, 0);
for (i = 1; i <= n; i++) {
if (ans[i] == -1)
while (1)
;
printf("%d", ans[i]);
if (i == n)
puts("");
else
printf(" ");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void readi(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
void readll(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
void readc(char &x) {
char c;
while ((c = getchar()) == ' ')
;
x = c;
}
void writes(string s) { puts(s.c_str()); }
void writeln() { writes(""); }
void writei(int x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
void writell(long long x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
inline long long inc(int &x) { return ++x; }
inline long long inc(long long &x) { return ++x; }
inline long long inc(int &x, long long y) { return x += y; }
inline long long inc(long long &x, long long y) { return x += y; }
inline double inc(double &x, double y) { return x += y; }
inline long long dec(int &x) { return --x; }
inline long long dec(long long &x) { return --x; }
inline long long dec(int &x, long long y) { return x -= y; }
inline long long dec(long long &x, long long y) { return x -= y; }
inline double dec(double &x, double y) { return x -= y; }
inline long long mul(int &x) { return x = ((long long)x) * x; }
inline long long mul(long long &x) { return x = x * x; }
inline long long mul(int &x, long long y) { return x *= y; }
inline long long mul(long long &x, long long y) { return x *= y; }
inline double mul(double &x, double y) { return x *= y; }
inline long long divi(const int &x) {
long long ans, l, r, mid;
ans = 0;
l = 0;
r = 0x3fffffff;
while (l < r) {
mid = (l + r) / 2;
if (mid * mid <= x) {
ans = mid;
l = mid + 1;
} else
r = mid;
}
return ans;
}
inline long long divi(const long long &x) {
long long ans, l, r, mid;
ans = 0;
l = 0;
r = 0x3fffffff;
while (l < r) {
mid = (l + r) / 2;
if (mid * mid <= x) {
ans = mid;
l = mid + 1;
} else
r = mid;
}
return ans;
}
inline long long divi(int &x, long long y) { return x /= y; }
inline long long divi(long long &x, long long y) { return x /= y; }
inline double divi(double &x, double y) { return x /= y; }
inline long long mod(int &x, long long y) { return x %= y; }
inline long long mod(long long &x, long long y) { return x %= y; }
int n, m, i, j, sz[400005], first, second, szfi, szse, ans[400005], rt, rt2, x,
y;
vector<int> e[400005];
void dfs(int x, int fa) {
sz[x] = 1;
bool ok = 1;
for (__typeof((e[x]).begin()) it = (e[x]).begin(); it != (e[x]).end(); it++) {
if (fa == *it) continue;
dfs(*it, x);
sz[x] += sz[*it];
if (sz[*it] > n / 2) ok = 0;
}
if (ok && (n - sz[x]) <= n / 2) rt2 = x;
}
void dfs2(int x, int fa, int b) {
b |= (x == first);
if (b)
sz[x] += szse;
else
sz[x] += szfi;
if (b && szfi * 2 == n) ans[x] = 1;
if ((n - sz[x]) <= n / 2) ans[x] = 1;
for (__typeof((e[x]).begin()) it = (e[x]).begin(); it != (e[x]).end(); it++) {
if (fa == *it) continue;
dfs2(*it, x, b);
}
}
int main() {
readi(n);
if ((1) <= ((n - 1)))
for (((i)) = (1); ((i)) <= ((n - 1)); ((i))++) {
readi(x);
readi(y);
e[x].push_back(y);
e[y].push_back(x);
}
dfs(1, 0);
rt = rt2;
dfs(rt, 0);
for (__typeof((e[rt]).begin()) it = (e[rt]).begin(); it != (e[rt]).end();
it++) {
if (sz[*it] > sz[second]) second = *it;
if (sz[second] > sz[first]) swap(first, second);
}
szfi = sz[first];
szse = sz[second];
dfs2(rt, 0, 0);
if ((1) <= ((n)))
for (((i)) = (1); ((i)) <= ((n)); ((i))++) writei(ans[i]), putchar(' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
void io() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(15);
}
double tick() {
static clock_t oldt;
clock_t newt = clock();
double diff = 1.0 * (newt - oldt) / CLOCKS_PER_SEC;
oldt = newt;
return diff;
}
long long mulmod(long long a, long long b, long long m) {
long long q = (long long)(((long double)a * (long double)b) / (long double)m);
long long r = a * b - q * m;
if (r > m) r %= m;
if (r < 0) r += m;
return r;
}
template <typename T>
T mod(T a, T b) {
while (a < 0) a += b;
return a % b;
}
template <typename T>
T power(T e, T n, T m) {
T x = 1, p = e;
while (n) {
if (n & 1) x = mod(x * p, m);
p = mod(p * p, m);
n >>= 1;
}
return x;
}
template <typename T>
T power(T e, T n) {
T x = 1, p = e;
while (n) {
if (n & 1) x = x * p;
p = p * p;
n >>= 1;
}
return x;
}
template <typename T>
T InverseEuler(T a, T m) {
return (a == 1 ? 1 : power(a, m - 2, m));
}
template <typename T>
inline T gcd(T a, T b) {
T c;
while (b) {
c = b;
b = a % b;
a = c;
}
return a;
}
template <typename T>
T lcm(T a, T b) {
return (a * (b / gcd(a, b)));
}
long long exEuclid(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long x1, y1;
long long g = exEuclid(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return g;
}
const int MAXN = 4e5 + 5;
vector<int> g[MAXN];
int n;
int subsz[MAXN];
void dfs_sz(int u = 1, int p = -1) {
subsz[u] = 1;
for (auto v : g[u]) {
if (v != p) {
dfs_sz(v, u);
subsz[u] += subsz[v];
}
}
}
int find_centroid(int u, int p) {
for (auto v : g[u]) {
if (v != p) {
if (2 * subsz[v] > n) {
return find_centroid(v, u);
}
}
}
return u;
}
int subtree[MAXN];
void dfs(int u, int p) {
if (p != -1) {
if (subtree[p] == -1) {
subtree[u] = u;
} else {
subtree[u] = subtree[p];
}
}
subsz[u] = 1;
for (auto v : g[u]) {
if (v != p) {
dfs(v, u);
subsz[u] += subsz[v];
}
}
}
int ans[MAXN];
int main(int argc, char *argv[]) {
io();
cin >> n;
int x, y;
for (int i = 1; i < n; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs_sz(1, -1);
int centroid = find_centroid(1, -1);
subtree[centroid] = -1;
dfs(centroid, -1);
ans[centroid] = 1;
int heaviest = -1, secondHeaviest = -1, heavyChild = -1;
for (int i = 1; i <= n; i++) {
if (subtree[i] == i) {
if (subsz[i] == heaviest) {
secondHeaviest = heaviest;
heavyChild = -1;
} else if (subsz[i] > heaviest) {
secondHeaviest = heaviest;
heaviest = subsz[i];
heavyChild = i;
} else if (subsz[i] > secondHeaviest) {
secondHeaviest = subsz[i];
}
}
}
for (int i = 1; i <= n; i++) {
if (i != centroid) {
int max_rem = 0;
if (subtree[i] == heavyChild) {
max_rem = max(secondHeaviest, subsz[subtree[i]] - subsz[i]);
} else {
max_rem = heaviest;
}
ans[i] = (2 * (n - (subsz[i] + max_rem)) <= n);
}
}
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
int S[400005], d[400005], maxsub[400005], maxfa[400005];
int N;
vector<int> G[400005];
inline int getint() {
static char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
if (c == '-') {
int res = 0;
while ((c = getchar()) >= '0' && c <= '9') {
res = res * 10 + c - '0';
}
return -res;
} else {
int res = c - '0';
while ((c = getchar()) >= '0' && c <= '9') {
res = res * 10 + c - '0';
}
return res;
}
}
void dfssize(int x, int fa) {
int v;
S[x] = 1;
for (int i = 0; i < G[x].size(); i++) {
v = G[x][i];
if (v == fa) {
continue;
}
dfssize(v, x);
S[x] += S[v];
}
}
void dfsdis(int x, int fa) {
int v;
for (int i = 0; i < G[x].size(); i++) {
v = G[x][i];
if (v == fa) {
continue;
}
d[v] = d[x] + 1;
dfsdis(v, x);
}
}
void dfssub(int x, int fa) {
int v;
if (S[x] <= (N / 2)) {
maxsub[x] = S[x];
} else {
maxsub[x] = 0;
}
for (int i = 0; i < G[x].size(); i++) {
v = G[x][i];
if (v == fa) {
continue;
}
dfssub(v, x);
if (maxsub[v] <= (N / 2) && (maxsub[x] < maxsub[v])) {
maxsub[x] = maxsub[v];
}
}
}
void dfsfa(int x, int fa) {
int v, maxA = 0, maxB = 0;
if (fa == 0) {
maxfa[x] = 0;
} else {
if (N - S[x] <= (N / 2)) {
maxfa[x] = N - S[x];
} else {
if (maxfa[fa] > maxfa[x]) {
maxfa[x] = maxfa[fa];
}
}
}
for (int i = 0; i < G[x].size(); i++) {
v = G[x][i];
if (v == fa) {
continue;
}
if (maxsub[v] >= maxA) {
maxB = maxA;
maxA = maxsub[v];
} else if (maxsub[v] > maxB) {
maxB = maxsub[v];
}
}
for (int i = 0; i < G[x].size(); i++) {
v = G[x][i];
if (v == fa) {
continue;
}
if (maxsub[v] == maxA) {
maxfa[v] = maxB;
} else {
maxfa[v] = maxA;
}
dfsfa(v, x);
}
}
int main() {
N = getint();
for (int i = 1; i <= N; i++) {
G[i].clear();
}
int a, b;
for (int i = 1; i < N; i++) {
a = getint();
b = getint();
G[a].push_back(b);
G[b].push_back(a);
}
dfssize(1, 0);
d[1] = 0;
dfsdis(1, 0);
dfssub(1, 0);
memset(maxfa, 0, sizeof(maxfa));
dfsfa(1, 0);
bool rep;
int size;
int maxs;
bool core;
int v;
for (int i = 1; i <= N; i++) {
rep = false;
core = true;
for (int j = 0; j < G[i].size(); j++) {
v = G[i][j];
if (d[v] > d[i]) {
size = S[v];
} else {
size = N - S[i];
}
if (size > (N / 2)) {
if (rep) {
core = false;
break;
}
if (d[v] > d[i]) {
maxs = maxsub[v];
} else {
maxs = maxfa[i];
}
if (maxs <= (N / 2) && (size - maxs <= (N / 2))) {
rep = true;
} else {
core = false;
}
}
}
if (core) {
cout << 1;
} else {
cout << 0;
}
cout << ' ';
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[400005];
int dp1[400005], dp2[400005], sub[400005], ans[400005], n;
void dfs1(int u, int p) {
sub[u] = 1;
dp1[u] = 0;
for (int j = 0; j < graph[u].size(); j++) {
int v = graph[u][j];
if (v != p) {
dfs1(v, u);
sub[u] += sub[v];
dp1[u] = max(dp1[u], dp1[v]);
if (sub[v] <= (n / 2)) dp1[u] = max(dp1[u], sub[v]);
}
}
}
void dfs2(int u, int p) {
int max1, max2, max3, max4;
max1 = 0, max2 = 0, max3 = max4 = 0;
for (int j = 0; j < graph[u].size(); j++) {
int v = graph[u][j];
if (v != p) {
if (dp1[v] > max1) {
max2 = max1;
max1 = dp1[v];
} else if (dp1[v] <= max1 && dp1[v] > max2) {
max2 = dp1[v];
}
if (sub[v] <= (n / 2)) {
if (sub[v] > max3) {
max4 = max3;
max3 = sub[v];
} else if (sub[v] <= max3 && sub[v] > max4) {
max4 = sub[v];
}
}
}
}
for (int j = 0; j < graph[u].size(); j++) {
int v = graph[u][j];
if (v != p) {
if (dp1[v] == max1)
dp2[v] = max(dp2[v], max2);
else
dp2[v] = max(dp2[v], max1);
if (sub[v] <= (n / 2)) {
if (sub[v] == max3)
dp2[v] = max(dp2[v], max4);
else
dp2[v] = max(dp2[v], max3);
}
if (n - sub[v] <= (n / 2)) dp2[v] = max(n - sub[v], dp2[v]);
dp2[v] = max(dp2[v], dp2[u]);
dfs2(v, u);
}
}
}
void dfs3(int u, int p) {
int f = 0, x;
for (int j = 0; j < graph[u].size(); j++) {
int v = graph[u][j];
if (v != p) {
dfs3(v, u);
if (sub[v] > (n / 2)) {
x = v;
f = 1;
}
}
}
if (!f) {
if (n - sub[u] - dp2[u] <= (n / 2)) ans[u] = 1;
} else {
if (sub[x] - dp1[x] <= (n / 2)) ans[u] = 1;
}
}
int main() {
int i, x, y;
cin >> n;
for (i = 0; i < n - 1; i++) {
cin >> x >> y;
graph[x].push_back(y);
graph[y].push_back(x);
}
dfs1(1, -1);
dp2[1] = 0;
dfs2(1, -1);
dfs3(1, -1);
for (i = 1; i <= n; i++) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 500005;
const int mod = 1e9 + 7;
inline int getint() {
int n;
scanf("%d", &n);
return n;
}
bool ok[MAX];
int sz[MAX], mx[MAX], mxid[MAX], nex[MAX], nexid[MAX];
vector<int> G[MAX];
int n;
void dfs1(int u, int fa) {
sz[u] = 1;
for (auto v : G[u]) {
if (v == fa) continue;
dfs1(v, u);
sz[u] += sz[v];
int num = (sz[v] > n / 2 ? mx[v] : sz[v]);
if (num > nex[u]) {
nex[u] = num;
nexid[u] = v;
if (nex[u] > mx[u]) {
swap(mx[u], nex[u]);
swap(mxid[u], nexid[u]);
}
}
if (sz[v] > n / 2 && sz[v] - mx[v] > n / 2) ok[u] = 0;
}
}
void dfs2(int u, int fa) {
if (n - sz[u] > n / 2) {
if (mxid[fa] == u)
ok[u] = (n - sz[u] - nex[fa] > n / 2 ? 0 : ok[u]);
else
ok[u] = (n - sz[u] - mx[fa] > n / 2 ? 0 : ok[u]);
}
if (mxid[fa] == u) {
int num = n - sz[u] > n / 2 ? nex[fa] : n - sz[u];
if (num > nex[u]) {
nex[u] = num;
nexid[u] = fa;
}
} else {
int num = n - sz[u] > n / 2 ? mx[fa] : n - sz[u];
if (num > nex[u]) {
nex[u] = num;
nexid[u] = fa;
}
}
if (nex[u] > mx[u]) {
swap(nex[u], mx[u]);
swap(nexid[u], mxid[u]);
}
for (auto v : G[u]) {
if (v == fa) continue;
dfs2(v, u);
}
}
int main() {
n = getint();
for (int i = 1; i <= n; i++) ok[i] = 1;
for (int i = 1; i < n; i++) {
int u = getint();
int v = getint();
G[u].push_back(v);
G[v].push_back(u);
}
dfs1(1, 0);
dfs2(1, 0);
for (int i = 1; i <= n; i++) printf("%d ", ok[i] ? 1 : 0);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> G[400005];
int subtree[400005], n, root, maximo;
bool ans[400005];
pair<int, int> max1, max2;
int dfs(int v, int p) {
subtree[v] = 1;
for (int x : G[v])
if (x != p) subtree[v] += dfs(x, v);
return subtree[v];
}
int centroid(int v, int p) {
for (int x : G[v]) {
if (x == p) continue;
if ((long long)subtree[x] * 2 > n) return centroid(x, v);
}
return v;
}
void dfs2(int v, int p) {
if (((long long)n - maximo - subtree[v]) * 2 > n)
ans[v] = 0;
else
ans[v] = 1;
for (int x : G[v]) {
if (x != p) dfs2(x, v);
}
}
void dfs3(int v, int p) {
ans[v] = 1;
for (int x : G[v]) {
if (x != p) dfs3(x, v);
}
}
int main() {
int a, b, i;
scanf("%d", &n);
for (i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
}
dfs(1, -1);
int cent = centroid(1, -1);
ans[cent] = 1;
dfs(cent, -1);
for (int x : G[cent]) {
if (subtree[x] > max1.first) {
max2 = max1;
max1 = make_pair(subtree[x], x);
continue;
}
if (subtree[x] > max2.first) max2 = make_pair(subtree[x], x);
}
for (int x : G[cent]) {
root = x;
if (max1.second == x)
maximo = max2.first;
else
maximo = max1.first;
if (subtree[x] * 2 == n)
dfs3(x, cent);
else
dfs2(x, cent);
}
printf("%d", ans[1]);
for (i = 2; i <= n; i++) printf(" %d", ans[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void print(T *p, T *q, string Gap = " ", bool flag = false) {
int d = p < q ? 1 : -1;
while (p != q) {
if (flag)
cout << Gap[0] << *p << Gap[1];
else
cout << *p;
p += d;
if (p != q && !flag) cout << Gap;
}
cout << endl;
}
template <typename T>
void print(const T &a, string bes = "") {
int len = bes.length();
if (len >= 2)
cout << bes[0] << a << bes[1] << endl;
else
cout << a << endl;
}
template <typename T>
void debug(T *p, T *q, string Gap = " ", bool flag = false) {}
template <typename T>
void debug(const T &a, string bes = "") {}
void IO_Init() { ios::sync_with_stdio(false); }
long long LLabs(const long long a) { return a >= 0 ? a : -a; }
const double PI = 3.1415926535898;
const double eps = 1e-10;
const int MAXM = 1e5 + 5;
const int MAXN = 4e5 + 5;
const int INF = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
int n, x, y;
int Head[MAXN], tot, son[MAXN];
int pson[MAXN], ans[MAXN];
struct o {
int to, cost, nxt;
} E[MAXN << 1];
void init_edge() {
memset(Head, -1, sizeof(Head));
tot = 0;
}
void add_edge(int u, int v, int cost) {
E[tot].to = v;
E[tot].cost = cost;
E[tot].nxt = Head[u];
Head[u] = tot++;
}
void dfs_v(int u, int f) {
ans[u] = 1;
son[u] = 1;
pson[u] = 0;
for (int v = Head[u]; ~v; v = E[v].nxt) {
o &e = E[v];
if (e.to == f) continue;
dfs_v(e.to, u);
son[u] += son[e.to];
pson[u] = max(pson[u], pson[e.to]);
if (son[e.to] - pson[e.to] > n >> 1) {
ans[u] = 0;
}
}
if (son[u] <= n >> 1) pson[u] = max(pson[u], son[u]);
}
void dfs_b(int u, int f, int val) {
vector<pair<int, int> > P;
for (int v = Head[u]; ~v; v = E[v].nxt) {
o &e = E[v];
if (e.to == f) continue;
P.push_back(pair<int, int>(pson[e.to], e.to));
}
sort(P.begin(), P.end(), greater<pair<int, int> >());
for (int v = Head[u]; ~v; v = E[v].nxt) {
o &e = E[v];
if (e.to == f) continue;
int nx_val = val;
if (n - son[e.to] <= n >> 1) nx_val = max(nx_val, n - son[e.to]);
if (e.to == P[0].second) {
if (P.size() > 1) {
nx_val = max(nx_val, P[1].first);
}
} else {
nx_val = max(nx_val, P[0].first);
}
dfs_b(e.to, u, nx_val);
}
if (n - son[u] - val > n >> 1) {
ans[u] = 0;
}
}
int main() {
IO_Init();
while (~scanf("%d", &n)) {
init_edge();
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
add_edge(x, y, 1);
add_edge(y, x, 1);
}
dfs_v(1, 0);
dfs_b(1, 0, 0);
for (int i = 1; i <= n; i++) {
printf("%d%c", ans[i], i == n ? '\n' : ' ');
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<vector<int> > graph(n + 1);
for (int e = 1; e < n; e++) {
int u, v;
cin >> u >> v;
graph[u].emplace_back(v);
graph[v].emplace_back(u);
}
vector<int> subtree_size(n + 1);
function<void(int, int)> dfs1 = [&](int u, int p) {
subtree_size[u] = 1;
for (int v : graph[u]) {
if (v == p) continue;
dfs1(v, u);
subtree_size[u] += subtree_size[v];
}
};
dfs1(1, 0);
function<int(int, int)> get_centroid = [&](int u, int p) {
for (int v : graph[u]) {
if (v == p) continue;
if (subtree_size[v] > n / 2) return get_centroid(v, u);
}
return u;
};
int root = get_centroid(1, 0);
vector<int> sze(n + 1);
function<void(int, int)> dfs2 = [&](int u, int p) {
sze[u] = 1;
for (int v : graph[u]) {
if (v == p) continue;
dfs2(v, u);
sze[u] += sze[v];
}
};
dfs2(root, 0);
multiset<int> ms;
for (int v : graph[root]) ms.emplace(sze[v]);
vector<int> ans(n + 1);
vector<int> path;
function<void(int, int, int)> solve = [&](int u, int p, int st) {
int sz = sze[root] - sze[st];
if (sz <= n / 2) {
ans[u] = 1;
}
if (ms.size()) {
int maxi = *ms.rbegin();
int nsum = sze[root] - sze[u] - maxi;
if (nsum <= n / 2) ans[u] = 1;
}
for (int v : graph[u]) {
if (v == p or v == root) continue;
solve(v, u, st);
}
};
ans[root] = 1;
for (int u : graph[root]) {
ms.erase(ms.find(sze[u]));
solve(u, root, u);
ms.insert(sze[u]);
}
for (int i = 1; i <= n; i++) cout << ans[i] << " \n"[i == n];
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int MAXN = 5 * 1e5 + 1, MODM = 1e9 + 7;
int n;
vector<int> g[MAXN];
int sz[MAXN];
int pr[MAXN];
int ans[MAXN];
int m1, m2;
int now;
int root = -1;
void dfs(int v, int p = -1) {
sz[v] = 1;
pr[v] = p;
for (auto to : g[v]) {
if (to != p) {
dfs(to, v);
sz[v] += sz[to];
}
}
}
void dfs2(int v, int p = -1) {
int k = m1;
if (sz[now] == m1) k = m2;
ans[v] |= (n - sz[v] - k <= (n / 2));
ans[v] |= (n - sz[now] <= (n / 2));
for (auto it : g[v])
if (it != p) dfs2(it, v);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
dfs(1);
for (int v = 1; v <= n; v++) {
int cnt = 0;
for (auto to : g[v])
if (to != pr[v]) cnt += (sz[to] <= (n / 2));
if (v != 1) cnt += (n - sz[v] <= (n / 2));
ans[v] = (cnt >= g[v].size());
if (ans[v]) root = v;
}
if (root == -1) {
for (int i = 0; i < n; i++) cout << 0 << " ";
return 0;
}
fill(sz, sz + MAXN, 0);
dfs(root);
for (auto it : g[root]) {
if (sz[it] > m1) {
m2 = m1;
m1 = sz[it];
} else
m2 = max(m2, sz[it]);
}
for (auto it : g[root]) {
now = it;
dfs2(it, root);
}
for (int i = 0; i < n; i++) cout << ans[i + 1] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5;
vector<int> G[N];
int sz[N], n;
void predfs(int rt, int f) {
sz[rt] = 1;
for (int v : G[rt]) {
if (v != f) predfs(v, rt), sz[rt] += sz[v];
}
}
int son[N], fa[N];
void dfs(int rt, int f) {
if (sz[rt] <= n / 2) son[rt] = sz[rt];
for (int v : G[rt]) {
if (v == f) continue;
dfs(v, rt);
son[rt] = max(son[rt], son[v]);
}
}
void dfs1(int rt, int f, int ss) {
if ((n - sz[rt]) <= n / 2) fa[rt] = n - sz[rt];
fa[rt] = max(fa[rt], ss);
int mx1 = fa[rt], id1 = 0, mx2 = fa[rt], id2 = 0;
for (int v : G[rt]) {
if (v == f) continue;
if (son[v] >= mx1) {
mx2 = mx1, id2 = id1;
mx1 = son[v], id1 = v;
} else if (son[v] >= mx2) {
mx2 = son[v], id2 = v;
}
}
for (int v : G[rt]) {
if (v == f) continue;
if (v != id1) {
dfs1(v, rt, mx1);
} else {
dfs1(v, rt, mx2);
}
}
}
int ans[N];
void solve(int rt, int f) {
if (f && n - sz[rt] - fa[rt] > n / 2) ans[rt] = 0;
for (int v : G[rt]) {
if (v == f) continue;
if (sz[v] - son[v] > n / 2) ans[rt] = 0;
solve(v, rt);
}
}
int main(int argc, const char* argv[]) {
scanf("%d", &n);
for (int u, v, i = 1; i < n; ++i) {
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
predfs(1, 0);
dfs(1, 0);
dfs1(1, 0, 0);
for (int i = 1; i <= n; ++i) ans[i] = 1;
solve(1, 0);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void print(T *p, T *q, string Gap = " ", bool flag = false) {
int d = p < q ? 1 : -1;
while (p != q) {
if (flag)
cout << Gap[0] << *p << Gap[1];
else
cout << *p;
p += d;
if (p != q && !flag) cout << Gap;
}
cout << endl;
}
template <typename T>
void print(const T &a, string bes = "") {
int len = bes.length();
if (len >= 2)
cout << bes[0] << a << bes[1] << endl;
else
cout << a << endl;
}
template <typename T>
void debug(T *p, T *q, string Gap = " ", bool flag = false) {}
template <typename T>
void debug(const T &a, string bes = "") {}
void IO_Init() { ios::sync_with_stdio(false); }
long long LLabs(const long long a) { return a >= 0 ? a : -a; }
const double PI = 3.1415926535898;
const double eps = 1e-10;
const int MAXM = 1e5 + 5;
const int MAXN = 4e5 + 5;
const int INF = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
int n, x, y;
int Head[MAXN], tot, son[MAXN];
int pson[MAXN], ans[MAXN];
struct o {
int to, cost, nxt;
} E[MAXN << 1];
void init_edge() {
memset(Head, -1, sizeof(Head));
tot = 0;
}
void add_edge(int u, int v, int cost) {
E[tot].to = v;
E[tot].cost = cost;
E[tot].nxt = Head[u];
Head[u] = tot++;
}
void dfs_v(int u, int f) {
ans[u] = 1;
son[u] = 1;
pson[u] = 0;
for (int v = Head[u]; ~v; v = E[v].nxt) {
o &e = E[v];
if (e.to == f) continue;
dfs_v(e.to, u);
son[u] += son[e.to];
pson[u] = max(pson[u], pson[e.to]);
}
if (son[u] <= n >> 1) pson[u] = max(pson[u], son[u]);
}
void dfs_b(int u, int f, int val) {
vector<pair<int, int> > P;
for (int v = Head[u]; ~v; v = E[v].nxt) {
o &e = E[v];
if (e.to == f) continue;
P.push_back(pair<int, int>(pson[e.to], e.to));
}
sort(P.begin(), P.end(), greater<pair<int, int> >());
for (int v = Head[u]; ~v; v = E[v].nxt) {
o &e = E[v];
if (e.to == f) continue;
int nx_val = val;
if (n - son[e.to] <= n >> 1) nx_val = max(nx_val, n - son[e.to]);
if (e.to == P[0].second) {
if (P.size() > 1) {
nx_val = max(nx_val, P[1].first);
}
} else {
nx_val = max(nx_val, P[0].first);
}
if (son[e.to] - pson[e.to] > n >> 1) {
ans[u] = 0;
}
dfs_b(e.to, u, nx_val);
}
if (n - son[u] - val > n >> 1) {
ans[u] = 0;
}
}
int main() {
IO_Init();
while (~scanf("%d", &n)) {
init_edge();
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
add_edge(x, y, 1);
add_edge(y, x, 1);
}
dfs_v(1, 0);
dfs_b(1, 0, 0);
for (int i = 1; i <= n; i++) {
printf("%d%c", ans[i], i == n ? '\n' : ' ');
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<vector<int> > graph(n + 1);
for (int e = 1; e < n; e++) {
int u, v;
cin >> u >> v;
graph[u].emplace_back(v);
graph[v].emplace_back(u);
}
vector<int> subtree_size(n + 1);
function<void(int, int)> dfs1 = [&](int u, int p) {
subtree_size[u] = 1;
for (int v : graph[u]) {
if (v == p) continue;
dfs1(v, u);
subtree_size[u] += subtree_size[v];
}
};
dfs1(1, 0);
function<int(int, int)> get_centroid = [&](int u, int p) {
for (int v : graph[u]) {
if (v == p) continue;
if (subtree_size[v] > n / 2) return get_centroid(v, u);
}
return u;
};
int root = get_centroid(1, 0);
vector<int> sze(n + 1);
function<void(int, int)> dfs2 = [&](int u, int p) {
sze[u] = 1;
for (int v : graph[u]) {
if (v == p) continue;
dfs2(v, u);
sze[u] += sze[v];
}
};
dfs2(root, 0);
multiset<int> ms;
for (int v : graph[root]) ms.emplace(sze[v]);
vector<int> ans(n + 1);
vector<int> path;
function<void(int, int, int)> solve = [&](int u, int p, int st) {
int sz = sze[root] - sze[st];
if (sz <= n / 2) {
ans[u] = 1;
}
if (ms.size()) {
int maxi = *ms.rbegin();
int nsum = sze[root] - sze[u] - maxi;
if (nsum <= n / 2) ans[u] = 1;
}
for (int v : graph[u]) {
if (v == p or v == root) continue;
solve(v, u, st);
}
};
ans[root] = 1;
for (int u : graph[root]) {
ms.erase(ms.find(sze[u]));
solve(u, root, u);
ms.insert(sze[u]);
}
for (int i = 1; i <= n; i++) cout << ans[i] << " \n"[i == n];
}
|
#include <bits/stdc++.h>
const int N = 4e5 + 1;
bool vis[N], ans[N];
int i, j, n, RT, p1, p2, siz[N];
int t, fa[N], nxt[N * 2], en[N * 2];
void Find(int u) {
int i = fa[u], v, t = 0;
for (siz[u] = 1; i; i = nxt[i])
if (!siz[v = en[i]])
if (Find(v), siz[u] += siz[v], siz[v] > t) t = siz[v];
if ((t << 1) <= n && (siz[u] << 1) >= n) ans[u] = 1, RT = u;
}
void SIZ(int u) {
siz[u] = 1;
for (int i = fa[u], v; i; i = nxt[i])
if (!siz[v = en[i]]) SIZ(v), siz[u] += siz[v];
}
void Fill(int u, int p) {
vis[u] = 1;
for (int i = fa[u]; i; i = nxt[i])
if (en[i] != p) Fill(en[i], u);
}
int main() {
scanf("%d", &n);
for (RT = 1; RT < n; ++RT) {
scanf("%d%d", &i, &j);
en[++t] = j, nxt[t] = fa[i], fa[i] = t;
en[++t] = i, nxt[t] = fa[j], fa[j] = t;
}
Find(1), memset(siz + 1, 0, 4 * n);
for (SIZ(RT), i = fa[RT]; i; i = nxt[i])
if (siz[j = en[i]] > siz[p1])
p2 = p1, p1 = j;
else if (siz[j] > siz[p2])
p2 = j;
for (Fill(p1, RT), i = 1; i <= n; putchar(32)) {
if (!ans[i]) {
if (vis[i])
t = siz[p2];
else
t = siz[p1];
if ((n - siz[i] - t << 1) <= n) ans[i] = 1;
if (vis[i] && (siz[p1] << 1) == n) ans[i] = 1;
}
putchar(48 + ans[i++]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
bool ckmin(T &a, U b) {
return b < a ? a = b, true : false;
}
template <typename T, typename U>
bool ckmax(T &a, U b) {
return b > a ? a = b, true : false;
}
int n, rt, tot = 0;
multiset<int, greater<int>> st;
vector<int> res, size;
vector<vector<int>> adj;
void dfs1(int v, int p) {
size[v] = 1;
for (auto i : adj[v]) {
if (i == p) continue;
dfs1(i, v);
size[v] += size[i];
}
}
int dfs2(int v, int p) {
for (auto i : adj[v]) {
if (i != p && size[i] > n / 2) {
return dfs2(i, v);
}
}
return v;
}
void dfs3(int v, int p) {
int above = n - 1;
for (auto i : adj[v]) {
if (i != p) above -= size[i];
}
if (above <= n / 2)
res[v] = 1;
else {
auto it = st.lower_bound(n / 2);
if ((it != st.end() && above - *it <= n / 2) ||
(tot <= n / 2 && above - tot <= n / 2)) {
res[v] = 1;
}
}
for (auto i : adj[v]) {
if (v == p) {
st.erase(st.find(size[i]));
tot = n - size[i];
dfs3(i, v);
st.insert(size[i]);
} else {
if (i == p) continue;
dfs3(i, v);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
res.assign(n, 0);
size.assign(n, 0);
adj.assign(n, vector<int>());
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);
}
dfs1(0, 0);
rt = dfs2(0, 0);
dfs1(rt, rt);
for (auto i : adj[rt]) {
st.insert(size[i]);
}
dfs3(rt, rt);
for (auto i : res) {
cout << i << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
bool ans[400000];
int sz[400000], n, maxi[400000], dp[400000];
int dfs(int u, int par, vector<int> g[]) {
sz[u] = 1;
for (int& i : g[u])
if (i != par) {
sz[u] += dfs(i, u, g);
maxi[u] = max(maxi[u], maxi[i]);
}
if (sz[u] <= n / 2) maxi[u] = sz[u];
return sz[u];
}
void dfs2(int u, int par, vector<int> g[]) {
if (n - sz[u] <= n / 2) dp[u] = max(dp[u], n - sz[u]);
int fi = -1, snd = -1;
for (int& i : g[u]) {
if (i == par) continue;
if (maxi[i] > fi) {
snd = fi;
fi = maxi[i];
} else if (maxi[i] > snd) {
snd = maxi[i];
}
}
for (int& i : g[u]) {
if (i == par) continue;
if (maxi[i] == fi)
dp[i] = max(dp[u], snd);
else
dp[i] = max(dp[u], fi);
dfs2(i, u, g);
}
}
void dfs3(int u, int par, vector<int> g[]) {
if (n - sz[u] <= n / 2) {
int flag = -1;
for (int& i : g[u])
if (i != par && sz[i] > n / 2) {
flag = i;
break;
}
if (flag == -1 || maxi[flag] >= sz[flag] - n / 2)
ans[u] = true;
else
ans[u] = false;
} else {
if (dp[u] >= n - sz[u] - n / 2)
ans[u] = true;
else
ans[u] = false;
}
for (int& i : g[u])
if (i != par) dfs3(i, u, g);
}
void solve() {
int u, v;
cin >> n;
vector<int> g[n];
for (int i = 1; i < n; i++) {
cin >> u >> v;
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(0, -1, g);
dfs2(0, -1, g);
dfs3(0, -1, g);
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[400556];
int sub[400556], ans[400556], n, mx1, mx2;
void dfs(int v, int p) {
sub[v] = 1;
for (int i = 0; i < adj[v].size(); i++) {
if (p != adj[v][i]) {
dfs(adj[v][i], v);
sub[v] += sub[adj[v][i]];
}
}
}
int centroid(int v, int p) {
for (int i = 0; i < adj[v].size(); i++) {
if (adj[v][i] == p)
continue;
else if (sub[adj[v][i]] > n / 2)
return centroid(adj[v][i], v);
}
return v;
}
void dfs2(int v, int p, int flg) {
for (int i = 0; i < adj[v].size(); i++) {
if (p == -1) {
if (p != adj[v][i]) dfs2(adj[v][i], v, flg = adj[v][i] == mx1 ? 1 : 0);
} else if (flg == 0) {
int rem = n - sub[v] - sub[mx1];
if (rem <= n / 2) ans[v] = 1;
if (p != adj[v][i]) dfs2(adj[v][i], v, flg);
} else if (flg == 1) {
int rem = n - sub[v] - max(sub[mx2], sub[mx1] - sub[v]);
if (rem <= n / 2) ans[v] = 1;
if (p != adj[v][i]) dfs2(adj[v][i], v, flg);
}
}
}
int main() {
int i, u, v;
cin >> n;
for (i = 0; i < n - 1; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
if (n <= 2) {
for (i = 1; i <= n; i++) cout << "1 ";
return 0;
}
dfs(1, -1);
int cent = centroid(1, -1);
dfs(cent, -1);
mx1 = 400556 - 2;
mx2 = 400556 - 3;
for (i = 0; i < adj[cent].size(); i++) {
if (sub[adj[cent][i]] > sub[mx1]) {
mx2 = mx1;
mx1 = adj[cent][i];
} else if (sub[adj[cent][i]] > sub[mx2]) {
mx2 = adj[cent][i];
}
}
ans[cent] = 1;
dfs2(cent, -1, 0);
for (i = 1; i <= n; i++) cout << ans[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int v;
node *next;
} edge[400000 * 2 + 10], *adj[400000 + 10], *ecnt = &edge[0];
int n, m, ok[400000 + 10], sz[400000 + 10], mx[400000 + 10], sub[400000 + 10];
template <class T>
void Read(T &x) {
char c;
while (c = getchar(), c != EOF)
if (c >= '0' && c <= '9') {
x = c - '0';
while (c = getchar(), c >= '0' && c <= '9') x = x * 10 + c - '0';
ungetc(c, stdin);
return;
}
}
inline void addedge(int u, int v) {
node *p = ++ecnt;
p->v = v;
p->next = adj[u];
adj[u] = p;
}
void read() {
int x, y;
Read(n);
for (int i = 1; i < n; i++) {
Read(x), Read(y);
addedge(x, y), addedge(y, x);
}
}
void dfs(int u, int fa) {
sz[u] = 1, sub[u] = 0;
for (node *p = adj[u]; p; p = p->next)
if (p->v != fa) {
dfs(p->v, u);
sub[u] = max(sub[u], sub[p->v]);
sz[u] += sz[p->v];
if (sz[mx[u]] < sz[p->v]) mx[u] = p->v;
}
if (sz[u] <= n / 2) sub[u] = max(sub[u], sz[u]);
if (sz[mx[u]] < n - sz[u]) mx[u] = u;
if ((mx[u] == u ? n - sz[u] : sz[mx[u]]) <= n / 2) ok[u] = true;
}
void dfs2(int u, int fa, int t) {
if ((mx[u] == u ? n - sz[u] : sz[mx[u]]) > n / 2) {
if (mx[u] == u) {
if (t && n - sz[u] - t <= n / 2) ok[u] = true;
} else {
if (sub[mx[u]] && sz[mx[u]] - sub[mx[u]] <= n / 2) ok[u] = true;
}
}
int c1 = 0, c2 = 0;
for (node *p = adj[u]; p; p = p->next)
if (p->v != fa) {
if (sub[p->v] <= n / 2) {
if (sub[p->v] > sub[c1]) {
c2 = c1;
c1 = p->v;
} else if (sub[p->v] > sub[c2])
c2 = p->v;
}
}
for (node *p = adj[u]; p; p = p->next)
if (p->v != fa) {
int tmp = n - sz[p->v];
if (tmp > n / 2) tmp = 0;
if (c1 == p->v)
dfs2(p->v, u, max(max(t, sub[c2]), tmp));
else
dfs2(p->v, u, max(max(t, sub[c1]), tmp));
}
}
void solve() {
dfs(1, 0);
dfs2(1, 0, 0);
for (int i = 1; i < n; i++) printf("%d ", ok[i]);
printf("%d\n", ok[n]);
}
int main() {
read();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int lcm(int a, int b) { return a * (b / gcd(a, b)); }
int n, t = 0, num;
vector<int> graph[400010], res(400010), euler(400010, -1);
vector<int> subsize(400010), visited(400010, 0), arr(400010), dep(400010),
pa(400010);
set<pair<int, int> > parent;
struct SegmentTreeNode {
int start, end;
int maxi;
void assignLeaf(int value) { maxi = value; }
void merge(SegmentTreeNode& left, SegmentTreeNode& right) {
maxi = max(left.maxi, right.maxi);
}
int getValue() { return maxi; }
};
SegmentTreeNode nodes[4 * 400010];
class SegmentTree {
public:
void build() { buildTree(1, 0, n - 1); }
int getValue(int lo, int hi) {
if (lo > hi) return -1;
SegmentTreeNode result = getValue(1, lo, hi);
return result.getValue();
}
void update(int index, int value) { update(1, index, value); }
private:
void buildTree(int stIndex, int lo, int hi) {
nodes[stIndex].start = lo, nodes[stIndex].end = hi;
if (lo == hi) {
nodes[stIndex].assignLeaf(euler[lo]);
return;
}
int left = 2 * stIndex, right = left + 1, mid = (lo + hi) / 2;
buildTree(left, lo, mid);
buildTree(right, mid + 1, hi);
nodes[stIndex].merge(nodes[left], nodes[right]);
}
SegmentTreeNode getValue(int stIndex, int lo, int hi) {
if (nodes[stIndex].start == lo && nodes[stIndex].end == hi)
return nodes[stIndex];
int mid = (nodes[stIndex].start + nodes[stIndex].end) / 2;
if (lo > mid) return getValue(2 * stIndex + 1, lo, hi);
if (hi <= mid) return getValue(2 * stIndex, lo, hi);
SegmentTreeNode leftResult = getValue(2 * stIndex, lo, mid);
SegmentTreeNode rightResult = getValue(2 * stIndex + 1, mid + 1, hi);
SegmentTreeNode result;
result.merge(leftResult, rightResult);
return result;
}
void update(int stIndex, int index, int value) {
if (nodes[stIndex].start == nodes[stIndex].end) {
nodes[stIndex].assignLeaf(value);
return;
}
int left = 2 * stIndex, right = left + 1,
mid = (nodes[stIndex].start + nodes[stIndex].end) / 2;
if (index <= mid)
update(left, index, value);
else
update(right, index, value);
nodes[stIndex].merge(nodes[left], nodes[right]);
}
};
SegmentTree st;
void dfs(int u) {
visited[u] = 1;
subsize[u] = 1;
arr[u] = t++;
for (int i = 0; i < (int)(graph[u].size()); i++) {
int v = graph[u][i];
if (visited[v] == 0) {
pa[v] = u;
dfs(v);
subsize[u] += subsize[v];
}
}
dep[u] = t - 1;
}
void dfs2(int u) {
visited[u] = 1;
if ((n - subsize[u]) >= num) {
int temp1, temp2, s;
s = n - subsize[u];
temp1 = st.getValue(0, arr[u] - 1);
temp2 = st.getValue(dep[u] + 1, n - 1);
if (temp1 != -1) {
if (s - temp1 < num) res[u] = 1;
}
if (temp2 != -1) {
if (s - temp2 < num) res[u] = 1;
}
set<pair<int, int> >::iterator it1, it2;
it1 = parent.lower_bound(
make_pair(((n % 2 == 0) ? (n / 2) : (n / 2) + 1), -1));
it2 = parent.lower_bound(make_pair((n / 2) + subsize[u], -1));
if (it1 != it2)
res[u] = 1;
else if (it1 != parent.end()) {
if (((it1->first) >= ((n % 2 == 0) ? (n / 2) : (n / 2) + 1)) &&
((it1->first) <= ((n / 2) + subsize[u])))
res[u] = 1;
}
}
parent.insert(make_pair(subsize[u], u));
st.update(arr[u], -1);
for (int i = 0; i < (int)(graph[u].size()); i++) {
int v = graph[u][i];
if (visited[v] == 0) dfs2(v);
}
parent.erase(make_pair(subsize[u], u));
if (subsize[u] < num) st.update(arr[u], subsize[u]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
num = (n / 2) + 1;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
graph[x].push_back(y);
graph[y].push_back(x);
}
pa[1] = -1;
dfs(1);
for (int i = 1; i < n + 1; i++) {
if (subsize[i] < num) euler[arr[i]] = subsize[i];
}
st.build();
for (int i = 1; i < n + 1; i++) {
if ((subsize[i] - 1) >= num) {
int child = -1;
for (int j = 0; j < (int)(graph[i].size()); j++) {
int v = graph[i][j];
if ((v != pa[i]) && (subsize[v] >= num)) child = v;
}
if (child == -1)
res[i] = 1;
else {
int temp1;
temp1 = st.getValue(arr[child] + 1, dep[child]);
if (temp1 != -1) {
if ((subsize[child] - temp1) < num) res[i] = 1;
}
}
} else if ((n - subsize[i]) < num)
res[i] = 1;
}
visited.assign(400010, 0);
dfs2(1);
for (int i = 1; i < n + 1; i++) cout << res[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 400005;
int n;
int ans[MAXN];
vector<int> edges[MAXN];
int sz[MAXN], down[MAXN], up[MAXN];
void dfsdown(int x, int pre) {
sz[x] = 1;
for (int i = 0; i < edges[x].size(); i++) {
int nex = edges[x][i];
if (nex == pre) continue;
dfsdown(nex, x);
sz[x] += sz[nex];
down[x] = max(down[x], down[nex]);
if (sz[nex] - down[nex] > n / 2) ans[x] = 0;
}
if (sz[x] <= n >> 1) down[x] = sz[x];
}
void dfsup(int x, int pre) {
if (n - sz[x] <= n / 2) up[x] = n - sz[x];
int ma = 0;
for (int i = 0; i < edges[x].size(); i++) {
int nex = edges[x][i];
if (nex == pre) continue;
up[nex] = max(up[nex], ma);
up[nex] = max(up[nex], up[x]);
ma = max(ma, down[nex]);
}
ma = 0;
for (int i = edges[x].size() - 1; i >= 0; i--) {
int nex = edges[x][i];
if (nex == pre) continue;
up[nex] = max(up[nex], ma);
ma = max(ma, down[nex]);
if (n - sz[nex] - up[nex] > n / 2) {
ans[nex] = 0;
}
dfsup(nex, x);
}
}
int main() {
cin >> n;
int a, b;
for (int i = 0; i < n - 1; i++) {
scanf("%d %d", &a, &b);
edges[a].push_back(b);
edges[b].push_back(a);
}
memset(ans, -1, sizeof(ans));
dfsdown(1, 1);
dfsup(1, 1);
for (int i = 1; i <= n; i++) {
if (i > 1) cout << ' ';
if (!ans[i])
cout << 0;
else
cout << 1;
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int>>> g;
vector<int> ans;
int n, h;
int dfs(int i, int p) {
int sum = 1;
pair<int, int>* pr;
for (auto& v : g[i]) {
if (v.second == p) {
pr = &v;
continue;
}
v.first = dfs(v.second, i);
sum += v.first;
}
if (p != -1) {
pr->first = n - sum;
}
return sum;
}
void dfs2(int i, int p) {
ans[i] = 1;
for (auto& v : g[i]) {
if (v.second == p) continue;
dfs2(v.second, i);
}
}
void dfs3(int i, int p, int t) {
pair<int, int>* pr;
for (auto& v : g[i]) {
if (v.second == p) {
pr = &v;
continue;
}
dfs3(v.second, i, t);
}
if (pr->first <= h + t) ans[i] = 1;
}
int main() {
int u, v;
scanf("%d", &n);
h = n >> 1;
if (n < 3) {
for (int i = 0; i < n; ++i) printf("1 ");
printf("\n");
return 0;
}
g.assign(n, vector<pair<int, int>>());
ans.assign(n, 0);
for (int i = 1; i < n; ++i) {
scanf("%d %d", &u, &v);
--u, --v;
g[v].push_back(make_pair(0, u));
g[u].push_back(make_pair(0, v));
}
dfs(0, -1);
int mid;
bool ismid;
for (mid = 0; mid < n; ++mid) {
ismid = true;
for (auto& v : g[mid])
if (v.first > h) {
ismid = false;
break;
}
if (ismid) break;
}
ans[mid] = 1;
sort(g[mid].begin(), g[mid].end());
pair<int, int>* elast = &(*(g[mid].end() - 1));
for (auto& e : g[mid]) {
if (n - e.first <= h)
dfs2(e.second, mid);
else {
if (&e == elast) continue;
dfs3(e.second, mid, elast->first);
}
}
dfs3(elast->second, mid, (elast - 1)->first);
for (int i = 0; i < n; ++i) printf("%d ", ans[i]);
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[500001];
void UP(int &x, int y) {
if (y > x) x = y;
}
int size[500001], dn[500001], n, ans[500001], up[500001], x, y;
void dfs1(int x, int fa) {
size[x] = 1;
for (int i = 0; i < g[x].size(); i++) {
int to = g[x][i];
if (to == fa) continue;
dfs1(to, x);
if (size[to] - dn[to] > n / 2) ans[x] = 0;
size[x] += size[to];
UP(dn[x], dn[to]);
}
if (size[x] <= n / 2) dn[x] = size[x];
}
void dfs2(int u, int fa) {
if (n - size[u] - up[u] > n / 2) ans[u] = 0;
if (n - size[u] <= n / 2) up[u] = n - size[u];
int mx = 0;
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i];
if (v == fa) continue;
up[v] = max(up[u], mx);
UP(mx, dn[v]);
}
mx = 0;
for (int i = g[u].size() - 1; i >= 0; --i) {
int v = g[u][i];
if (v == fa) continue;
UP(up[v], mx);
UP(mx, dn[v]);
dfs2(v, u);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= n; i++) ans[i] = 1;
dfs1(1, 0), dfs2(1, 0);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400100;
const int INF = 1000000007;
vector<int> adj[N];
int child[N], n, p[N], bg[N], en[N];
void dfs(int u) {
child[u] = 1;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (p[v] == 0) {
p[v] = u;
dfs(v);
child[u] += child[v];
}
}
}
bool checkCent(int u) {
for (int i = 0; i < adj[u].size(); i++)
if (adj[u][i] != p[u]) {
if (child[adj[u][i]] > n / 2) return false;
}
return (n - child[u] > n / 2) ? false : true;
}
int l[N * 4], h[N * 4], leaf[N], node[N * 4];
void build(int r, int low, int high) {
l[r] = low;
h[r] = high;
if (low == high) {
leaf[low] = r;
return;
}
int mid = (low + high) / 2;
build(r * 2, low, mid);
build(r * 2 + 1, mid + 1, high);
}
void update(int u, int value) {
u = leaf[u];
if (value > n / 2) value = -1;
node[u] = value;
while (u > 1) {
u /= 2;
node[u] = max(node[u * 2], node[u * 2 + 1]);
}
}
int get(int r, int low, int high) {
if (l[r] > high || h[r] < low) return 0;
if (l[r] >= low && h[r] <= high) return node[r];
return max(get(r * 2, low, high), get(r * 2 + 1, low, high));
}
int ans[N];
int cnt = 0;
void dfs2(int u) {
bg[u] = ++cnt;
child[u] = 1;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (p[v] == 0) {
p[v] = u;
dfs2(v);
child[u] += child[v];
}
}
update(bg[u], child[u]);
en[u] = cnt;
}
void dfs3(int u) {
int c = max(get(1, 1, bg[u] - 1), get(1, en[u] + 1, n));
ans[u] = (n - child[u] - c <= n / 2);
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v != p[u]) {
update(bg[v], n - child[v]);
dfs3(v);
update(bg[v], child[v]);
}
}
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
p[1] = -1;
dfs(1);
int root;
for (int i = 1; i <= n; i++)
if (checkCent(i)) root = i;
build(1, 1, n);
memset(child, 0, sizeof(child));
memset(p, 0, sizeof(p));
p[root] = -1;
dfs2(root);
dfs3(root);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
}
|
#include <bits/stdc++.h>
int mod = 1000000007;
using namespace std;
using namespace std;
vector<vector<int> > adj(400005);
int dp[400005];
int parent[400005];
int half;
int cntr = -1;
int n;
int v1 = -1, v2 = -1;
int ans[400005];
void dfs1(int v, int p, int n) {
dp[v] = 1;
bool dcn = true;
vector<int>::iterator it = adj[v].begin();
for (; it != adj[v].end(); it++) {
if (*it == p) continue;
parent[*it] = v;
dfs1(*it, v, n);
dp[v] += dp[*it];
if (dp[*it] > half) dcn = false;
}
if (n - dp[v] > half) {
dcn = false;
}
if (dcn && cntr == -1) {
cntr = v;
}
}
void dfs2(int v, int val, int p, int n) {
dp[v] = 1;
vector<int>::iterator it = adj[v].begin();
for (; it != adj[v].end(); it++) {
if (*it == p) continue;
dfs2(*it, val, v, n);
dp[v] += dp[*it];
}
if (n - val <= half) {
ans[v] = 1;
return;
}
if (val == v1)
val = v2;
else
val = v1;
if (n - dp[v] - val <= half) {
ans[v] = 1;
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
int n;
cin >> n;
half = n / 2;
memset(ans, 0, sizeof(ans));
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
parent[1] = 0;
dfs1(1, 0, n);
vector<int>::iterator it = adj[cntr].begin();
dp[parent[cntr]] = n - dp[cntr];
vector<pair<int, int> > v;
ans[cntr] = 1;
for (; it != adj[cntr].end(); it++) {
v.push_back(make_pair(*it, dp[*it]));
if (dp[*it] >= v1) {
v2 = v1;
v1 = dp[*it];
} else if (dp[*it] > v2) {
v2 = dp[*it];
}
}
vector<pair<int, int> >::iterator itt = v.begin();
for (; itt != v.end(); itt++) {
int u = (*itt).first;
int val = (*itt).second;
dfs2(u, val, cntr, n);
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long maxn = 4e5 + 7;
const long long maxe = 1e6 + 7;
const long long INF = 1e9 + 7;
const double PI = acos(-1);
int dx[4] = {0, 0, 1, -1};
int dy[4] = {-1, 1, 0, 0};
inline void Max(int &a, int b) {
if (b > a) a = b;
}
inline void Min(int &a, int b) {
if (a == -1 || b < a) a = b;
}
int n, k;
vector<int> G[maxn];
pair<pair<int, int>, pair<int, int> > f1[maxn];
int f2[maxn];
int Si[maxn];
bool dp[maxn];
void dfs1(int u, int fa) {
Si[u] = 1;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v == fa) continue;
dfs1(v, u);
Si[u] += Si[v];
}
}
void dfs2(int u, int fa) {
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v == fa) continue;
dfs2(v, u);
f1[u].second = max(make_pair(f1[v].first.first, v), f1[u].second);
if (Si[v] <= k) f1[u].second = max(f1[u].second, make_pair(Si[v], v));
if (f1[u].second > f1[u].first) swap(f1[u].second, f1[u].first);
}
}
void dfs3(int u, int fa) {
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v == fa) continue;
f2[v] = f2[u];
if (v == f1[u].first.second)
f2[v] = max(f2[v], f1[u].second.first);
else
f2[v] = max(f2[v], f1[u].first.first);
if (n - Si[v] <= k) f2[v] = n - Si[v];
dfs3(v, u);
}
}
void dfs4(int u, int fa) {
int cnt = 0;
bool ok = true;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v == fa) continue;
if (Si[v] > k) {
if (Si[v] - f1[v].first.first <= k)
cnt++;
else
ok = false;
}
dfs4(v, u);
}
if (n - Si[u] > k) {
if (n - Si[u] - f2[u] <= k)
cnt++;
else
ok = false;
}
if (cnt > 1) ok = false;
dp[u] = ok;
}
int main() {
cin >> n;
k = n / 2;
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
f2[1] = 0;
dfs1(1, 0);
dfs2(1, 0);
dfs3(1, 0);
dfs4(1, 0);
for (int i = 1; i <= n; i++)
if (dp[i])
cout << "1 ";
else
cout << "0 ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool relax(T &a, const T &b) {
if (b > a) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool tense(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
inline int getint() {
static char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
if (c == '-') {
int res = 0;
while ((c = getchar()) >= '0' && c <= '9') res = res * 10 + c - '0';
return -res;
} else {
int res = c - '0';
while ((c = getchar()) >= '0' && c <= '9') res = res * 10 + c - '0';
return res;
}
}
inline long long gets64() {
static char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
if (c == '-') {
long long res = 0;
while ((c = getchar()) >= '0' && c <= '9') res = res * 10 + c - '0';
return -res;
} else {
long long res = c - '0';
while ((c = getchar()) >= '0' && c <= '9') res = res * 10 + c - '0';
return res;
}
}
const int MaxN = 400005;
int n;
struct halfEdge {
int v;
halfEdge *next;
};
halfEdge adj_pool[MaxN * 2], *adj_tail = adj_pool;
halfEdge *adj[MaxN];
inline void addEdge(const int &u, const int &v) {
adj_tail->v = v, adj_tail->next = adj[u], adj[u] = adj_tail++;
adj_tail->v = u, adj_tail->next = adj[v], adj[v] = adj_tail++;
}
int size[MaxN];
int nC, vC[233];
void dfs1(int u, int v) {
int vW = size[u] = 1;
for (halfEdge *e = adj[u]; e; e = e->next)
if (e->v != v) {
dfs1(e->v, u);
size[u] += size[e->v];
relax(vW, size[e->v]);
}
relax(vW, n - size[u]);
if (vW <= n >> 1) vC[++nC] = u;
}
bool orz[MaxN];
void dfs2(int u, int v) {
orz[u] = true;
for (halfEdge *e = adj[u]; e; e = e->next)
if (e->v != v) dfs2(e->v, u);
}
int main() {
n = getint();
for (int i = 1; i < n; ++i) {
int u = getint(), v = getint();
addEdge(u, v);
}
dfs1(1, 0);
if (nC == 2) {
for (int i = 1; i <= n; ++i) {
putchar('1');
putchar(' ');
}
return 0;
}
int c = vC[1];
dfs1(c, 0);
int gzb = -1, csy = -1;
for (halfEdge *e = adj[c]; e; e = e->next) {
if (gzb == -1 || size[e->v] >= size[gzb])
csy = gzb, gzb = e->v;
else if (csy == -1 || size[e->v] > size[csy])
csy = e->v;
}
dfs2(gzb, c);
for (int i = 1; i <= n; ++i) {
if (i == c)
printf("1 ");
else {
int l = size[orz[i] ? csy : gzb];
if (n - l - size[i] <= n >> 1)
putchar('1');
else
putchar('0');
putchar(' ');
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAXN = 400005;
vector<int> G[MAXN], pre[MAXN], suf[MAXN];
int siz[MAXN], cnt[MAXN], maxson[MAXN], ans[MAXN];
int n;
void dfs1(int u, int fa) {
siz[u] = 1;
cnt[u] = 0;
maxson[u] = 0;
for (int v : G[u]) {
if (v == fa) continue;
dfs1(v, u);
siz[u] += siz[v];
cnt[u] = max(cnt[v], cnt[u]);
if (siz[v] > siz[maxson[u]]) maxson[u] = v;
}
if (siz[u] <= n / 2) cnt[u] = siz[u];
}
void dfs2(int u, int fa) {
int fasiz = n - siz[u];
if (fasiz > siz[maxson[u]]) maxson[u] = fa;
for (int v : G[u]) {
if (v == fa) continue;
dfs2(v, u);
}
}
void dfs3(int u, int fa) {
int child = G[u].size();
pre[u].resize(child);
suf[u].resize(child);
for (int i = 0; i < child; i++) pre[u][i] = suf[u][i] = cnt[G[u][i]];
for (int i = 1; i < child; i++) pre[u][i] = max(pre[u][i - 1], pre[u][i]);
for (int i = child - 2; i >= 0; i--)
suf[u][i] = max(suf[u][i + 1], suf[u][i]);
for (int i = 0; i < child; i++) {
int v = G[u][i];
if (v == fa) continue;
int mmax = 0;
if (i > 0) mmax = max(pre[u][i - 1], mmax);
if (i < child - 1) mmax = max(suf[u][i + 1], mmax);
cnt[u] = (n - siz[v] <= n / 2 ? n - siz[v] : mmax);
int x = maxson[v];
if (x == u) {
ans[v] = (n - siz[v] - cnt[x] <= n / 2 ? 1 : 0);
} else {
ans[v] = (siz[x] - cnt[x] <= n / 2 ? 1 : 0);
}
dfs3(v, u);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
dfs1(1, 0);
dfs2(1, 0);
int x = maxson[1];
ans[1] = (siz[x] - cnt[x] <= n / 2 ? 1 : 0);
dfs3(1, 0);
for (int i = 1; i <= n; i++) printf("%d%c", ans[i], " \n"[i == n]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 4e5 + 5;
int head[N], to[N * 2], nxt[N * 2], tot, n;
int son[N], ans[N], down[N], up[N], tmp[N];
void init() {
for (int i = 1; i <= n; ++i) head[i] = -1;
tot = 0;
}
void add_edge(int u, int v) {
to[tot] = v, nxt[tot] = head[u];
head[u] = tot++;
}
void dfs(int u, int fa) {
son[u] = 1;
up[u] = down[u] = 0;
int a = -1, b = -1;
for (int i = head[u]; ~i; i = nxt[i]) {
int v = to[i];
if (v == fa) continue;
dfs(v, u);
down[u] = max(down[u], down[v]);
tmp[v] = down[v];
if (son[v] <= n / 2) tmp[v] = son[v];
if (son[v] <= n / 2) down[u] = max(down[u], son[v]);
if (a == -1)
a = v;
else if (tmp[v] > tmp[a]) {
swap(a, b);
a = v;
} else if (b == -1 || tmp[v] > tmp[b])
b = v;
son[u] += son[v];
}
for (int i = head[u]; ~i; i = nxt[i]) {
int v = to[i];
if (v == fa) continue;
if (n - son[v] <= n / 2)
up[v] = n - son[v];
else {
if (v != a)
up[v] = tmp[a];
else
up[v] = tmp[b];
if (n - son[u] <= n / 2) up[v] = max(up[v], n - son[u]);
}
}
}
void dfs2(int u, int fa) {
up[u] = max(up[u], up[fa]);
ans[u] = 1;
for (int i = head[u]; ~i; i = nxt[i]) {
int v = to[i];
if (v == fa) continue;
dfs2(v, u);
if (son[v] - down[v] > n / 2) ans[u] = 0;
}
if (n - son[u] - up[u] > n / 2) ans[u] = 0;
}
int main() {
scanf("%d", &n);
init();
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
add_edge(u, v), add_edge(v, u);
}
dfs(1, 1);
dfs2(1, 1);
for (int i = 1; i <= n; ++i) printf("%d%s", ans[i], i == n ? "\n" : " ");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> edge[400010];
int n;
int sum[400010];
int cut[400010];
int prevCut[400010];
int fa[400010];
int first[400010];
int second[400010];
void dfs1(int u, int par) {
fa[u] = par;
sum[u] = 1;
cut[u] = 0;
for (int i = 0; i < edge[u].size(); i++) {
int v = edge[u][i];
if (v == par) continue;
dfs1(v, u);
sum[u] += sum[v];
if (sum[v] <= n / 2)
cut[u] = max(sum[v], cut[u]);
else
cut[u] = max(cut[v], cut[u]);
}
}
void dfs2(int u) {
if (prevCut[u] >= 0) return;
if (fa[u] != -1) dfs2(fa[u]);
if (u == 1) {
prevCut[u] = 0;
} else if (n - sum[u] <= n / 2) {
prevCut[u] = n - sum[u];
} else if (sum[u] != first[fa[u]] && cut[u] != first[fa[u]]) {
prevCut[u] = first[fa[u]];
} else {
prevCut[u] = second[fa[u]];
}
first[u] = second[u] = prevCut[u];
for (int i = 0; i < edge[u].size(); i++) {
int v = edge[u][i];
if (v == fa[u]) continue;
int can = sum[v] <= n / 2 ? sum[v] : cut[v];
if (can >= first[u]) {
second[u] = first[u];
first[u] = can;
} else if (can > second[u]) {
second[u] = can;
}
}
}
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = 1; i <= n; i++) edge[i].clear();
memset(sum, 0, sizeof(sum));
memset(prevCut, -1, sizeof(cut));
memset(first, 0, sizeof(first));
memset(second, 0, sizeof(second));
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
edge[u].push_back(v);
edge[v].push_back(u);
}
dfs1(1, -1);
for (int i = 1; i <= n; i++) {
dfs2(i);
}
for (int u = 1; u <= n; u++) {
int ok = 1;
for (int j = 0; j < edge[u].size(); j++) {
int v = edge[u][j];
if (v != fa[u]) {
if (sum[v] - cut[v] > n / 2) {
ok = 0;
break;
}
} else {
if (n - sum[u] - prevCut[u] > n / 2) {
ok = 0;
break;
}
}
}
if (u == n)
printf("%d\n", ok);
else
printf("%d ", ok);
}
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.