text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1010;
const int MAXN = 1e4 + 10;
const int MOD = 1e9 + 7;
const int inf = 1e9;
const double pi = acos(-1.0);
const double eps = 1e-6;
int f[MAX];
vector<pair<int, int> > a;
int findSet(int u) { return f[u] = (u == f[u] ? f[u] : findSet(f[u])); }
int Union(int u, int v) {
u = findSet(u);
v = findSet(v);
if (u != v) {
f[v] = u;
return 1;
}
return 0;
}
int main() {
ios::sync_with_stdio(false);
int n, u, v;
cin >> n;
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i < n; i++) {
cin >> u >> v;
if (!Union(u, v)) a.push_back(make_pair(u, v));
}
cout << a.size() << endl;
u = 1;
while (u <= n && f[u] != u) u++;
v = u + 1;
for (int i = 0; i < a.size(); i++) {
while (v <= n && f[v] != v) v++;
cout << a[i].first << " " << a[i].second << " " << u << " " << v++ << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int nodes_size;
long long int edge_size;
class edge {
public:
long long int node;
long long int cost;
edge(long long int i, long long int j) {
node = i;
cost = j;
}
};
class graph {
public:
long long int node;
vector<edge> edges;
long long int parent;
long long int cost;
vector<long long int> children;
} nodes[1005];
long long int visited[1005];
class point {
public:
long long int x;
long long int y;
point() {}
point(long long int i, long long int j) {
x = i;
y = j;
}
};
void fill_array(long long int ar[], long long int value, long long int size) {
for (long long int i = 0; i < size; i++) ar[i] = value;
}
void print_ll_vector(vector<long long int> v) {
for (long long int i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << endl;
}
void input_graph(bool is_undirected, bool is_cost) {
cin >> nodes_size;
edge_size = nodes_size - 1;
for (long long int i = 0; i < edge_size; i++) {
long long int a, b, c;
cin >> a >> b;
if (is_cost) {
cin >> c;
nodes[a].edges.push_back(edge(b, c));
if (is_undirected) nodes[b].edges.push_back(edge(a, c));
} else {
nodes[a].edges.push_back(edge(b, 1));
if (is_undirected) nodes[b].edges.push_back(edge(a, 1));
}
}
}
vector<pair<long long int, long long int> > destroyed_edges;
long long int ctr = 0, c;
vector<long long int> ans;
void dfs(long long int node, long long int parent) {
visited[node] = 1;
for (long long int i = 0; i < nodes[node].edges.size(); i++) {
if (nodes[node].edges[i].node != parent) {
if (visited[nodes[node].edges[i].node]) {
if (node > nodes[node].edges[i].node) {
if (c > 0 || ctr == 1) {
destroyed_edges.push_back(
make_pair(node, nodes[node].edges[i].node));
c++;
} else {
c++;
ans.push_back(node);
ans.push_back(nodes[node].edges[i].node);
}
}
} else
dfs(nodes[node].edges[i].node, node);
}
}
}
vector<long long int> new_edges;
int main() {
input_graph(true, false);
fill_array(visited, 0, nodes_size + 1);
for (long long int i = 1; i <= nodes_size; i++) {
if (!visited[i]) {
c = 0;
ctr++;
dfs(i, -1);
if (c == 0 && i != 1) new_edges.push_back(i);
}
}
cout << (ans.size() / 2) + new_edges.size() << endl;
for (long long int i = 0; i < ans.size();) {
cout << ans[i] << " " << ans[i + 1] << " " << ans[i] << " " << 1 << endl;
i = i + 2;
}
for (long long int i = 0; i < new_edges.size(); i++)
cout << destroyed_edges[i].first << " " << destroyed_edges[i].second << " "
<< destroyed_edges[i].first << " " << new_edges[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void init(vector<int> &parent, int n) {
for (int i = 1; i <= n; i++) parent[i] = i;
}
int root(vector<int> &parent, int x) {
while (parent[x] != x) x = parent[parent[x]];
return x;
}
bool find(vector<int> &parent, int x, int y) {
if (root(parent, x) == root(parent, y)) return true;
return false;
}
void dsu_union(vector<int> &parent, vector<int> &size, int x, int y) {
int rx = root(parent, x), ry = root(parent, y);
if (size[ry] < size[ry]) swap(rx, ry);
size[rx] += size[ry];
parent[ry] = parent[rx];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, x, y, days = 0;
cin >> n;
vector<int> parent(n + 1), size(n + 1, 1);
queue<pair<int, int>> unused;
init(parent, n);
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
if (find(parent, x, y))
unused.push({x, y});
else
dsu_union(parent, size, x, y);
}
int beg = 1;
while (parent[beg] != beg) beg++;
vector<pair<int, int>> roads;
for (int i = beg + 1; i <= n; i++) {
if (parent[i] != i) continue;
days++;
roads.push_back(unused.front());
roads.push_back({beg, i});
unused.pop();
}
cout << days << "\n";
for (int i = 0; i < roads.size(); i += 2)
cout << roads[i].first << " " << roads[i].second << " "
<< roads[i + 1].first << " " << roads[i + 1].second << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[1005];
int ff(int x) { return p[x] == x ? p[x] : p[x] = ff(p[x]); }
void uni(int u, int v) { p[ff(u)] = p[ff(v)]; }
int main() {
int n, i, a, b;
cin >> n;
for (i = 1; i <= n; ++i) p[i] = i;
vector<pair<int, int> > arr;
vector<int> q;
for (i = 1; i < n; ++i) {
cin >> a >> b;
if (ff(a) == ff(b))
arr.push_back(make_pair(a, b));
else
uni(a, b);
}
for (i = 1; i <= n; ++i)
if (ff(i) == i) q.push_back(i);
cout << q.size() - 1 << endl;
for (i = 1; i < (int)q.size(); ++i)
printf("%d %d %d %d ", arr[i - 1].first, arr[i - 1].second, q[i - 1], q[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g;
vector<pair<pair<int, int>, pair<int, int> > > res;
int was[1010], was1[1010];
int k = -1;
int comp[1010];
int d[1010][1010];
int n;
void dfs(int v) {
if (was[v] != -1) return;
was[v] = k;
for (int i = (0); i < (g[v].size()); ++i) dfs(g[v][i]);
}
void dfs1(int v1, int v2) {
if (was1[v1] == 0) {
if ((d[v2][v1] == 1) && (d[v1][v2] == 1))
return;
else {
res.push_back(make_pair(make_pair(v2, v1), make_pair(0, 0)));
return;
}
}
if (was1[v1] == 1) return;
was1[v1] = 0;
for (int i = (0); i < (g[v1].size()); ++i) {
d[v1][g[v1][i]] = 1;
dfs1(g[v1][i], v1);
}
was1[v1] = 1;
}
int main() {
scanf("%d", &n);
g.resize(n);
memset(was, -1, sizeof(was));
memset(comp, -1, sizeof(comp));
memset(d, 0, sizeof(d));
for (int i = (0); i < (n - 1); ++i) {
int a1, b1;
scanf("%d%d", &a1, &b1);
g[a1 - 1].push_back(b1 - 1);
g[b1 - 1].push_back(a1 - 1);
}
for (int i = (0); i < (n); ++i) {
if (was[i] == -1) {
k++;
comp[k] = i;
dfs(i);
}
}
memset(was1, -1, sizeof(was1));
for (int i = (0); i < (n); ++i)
if (was1[i] == -1) dfs1(i, -1);
for (int i = (0); i < (res.size()); ++i) {
res[i].second.first = comp[i];
res[i].second.second = comp[i + 1];
}
printf("%d\n", res.size());
for (int i = (0); i < (res.size()); ++i)
printf("%d %d %d %d\n", res[i].first.first + 1, res[i].first.second + 1,
res[i].second.first + 1, res[i].second.second + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 + 5;
int n, u[MAXN], v[MAXN], parent[MAXN];
void init() {
for (int i = 1; i <= n; ++i) {
parent[i] = i;
}
}
int find(int x) {
if (x == parent[x]) {
return x;
}
return parent[x] = find(parent[x]);
}
void combine(int x, int y) { parent[find(x)] = find(y); }
int main() {
scanf("%d", &n);
init();
vector<int> rm;
for (int i = 1; i < n; ++i) {
scanf("%d%d", &u[i], &v[i]);
if (find(u[i]) != find(v[i])) {
combine(u[i], v[i]);
} else {
rm.push_back(i);
}
}
vector<pair<pair<int, int>, pair<int, int>>> ans;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (find(i) != find(j)) {
int idx = *rm.rbegin();
rm.pop_back();
ans.push_back({{u[idx], v[idx]}, {i, j}});
combine(i, j);
}
}
}
printf("%d\n", (int)ans.size());
for (auto& a : ans) {
printf("%d %d %d %d\n", a.first.first, a.first.second, a.second.first,
a.second.second);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
struct Edge {
unsigned long a, b, x, y;
Edge() {}
Edge(const unsigned long _a, const unsigned long _b, const unsigned long _x,
const unsigned long _y)
: a(_a), b(_b), x(_x), y(_y) {}
};
bool FindNonZero(const std::vector<unsigned long>& be, unsigned long& idx) {
bool bUnvisitedFound = false;
idx = 0;
for (unsigned long i = 0; i < be.size() && !bUnvisitedFound; i++) {
if (!be[i]) {
idx = i;
bUnvisitedFound = true;
}
}
return bUnvisitedFound;
}
bool FindLoop(std::vector<std::set<unsigned long> >& links,
std::vector<unsigned long>& be, const unsigned long idx,
unsigned long& loopA, unsigned long& loopB) {
const std::set<unsigned long>& link = links[idx];
be[idx] = true;
loopA = idx;
while (!link.empty()) {
for (std::set<unsigned long>::const_iterator p = link.begin();
p != link.end(); ++p) {
const unsigned long next = *p;
if (be[next]) {
loopA = idx;
loopB = next;
return true;
} else {
links[idx].erase(next);
links[next].erase(idx);
if (FindLoop(links, be, next, loopA, loopB)) {
return true;
} else {
break;
}
}
}
}
return false;
}
void MarkComp(const std::vector<std::set<unsigned long> >& links,
std::vector<unsigned long>& be, const unsigned long idx) {
const std::set<unsigned long>& link = links[idx];
be[idx] = true;
for (std::set<unsigned long>::const_iterator p = link.begin();
p != link.end(); p++) {
const unsigned long next = *p;
if (!be[next]) {
MarkComp(links, be, next);
}
}
}
int main() {
size_t n;
std::cin >> n;
std::vector<std::set<unsigned long> > links(n);
for (size_t i = 0; i < n - 1; i++) {
unsigned long a, b;
std::cin >> a >> b;
a--;
b--;
links[a].insert(b);
links[b].insert(a);
}
std::vector<Edge> ans;
bool bFinished = false;
while (!bFinished) {
std::vector<unsigned long> be(n);
unsigned long loopA = 0, loopB = 0;
std::vector<std::set<unsigned long> > links_tmp(links);
unsigned long startIdx;
bool bLoopFound = false;
{
std::vector<unsigned long> be_local(n);
while (FindNonZero(be_local, startIdx) && !bLoopFound) {
if (FindLoop(links_tmp, be_local, startIdx, loopA, loopB)) {
bLoopFound = true;
}
}
}
if (bLoopFound) {
MarkComp(links, be, loopA);
unsigned long nonzeroIdx = 0;
if (FindNonZero(be, nonzeroIdx)) {
MarkComp(links, be, nonzeroIdx);
links[loopA].erase(loopB);
links[loopB].erase(loopA);
links[loopA].insert(nonzeroIdx);
links[nonzeroIdx].insert(loopA);
ans.push_back(Edge(loopA, loopB, nonzeroIdx, loopA));
}
} else {
bFinished = true;
}
}
std::cout << ans.size() << std::endl;
for (size_t i = 0; i < ans.size(); i++) {
const Edge& edge = ans[i];
std::cout << (edge.a + 1) << ' ';
std::cout << (edge.b + 1) << ' ';
std::cout << (edge.x + 1) << ' ';
std::cout << (edge.y + 1) << std::endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
void dsu_make(int node, vector<int> &pt, vector<int> &ht) {
pt[node] = node;
ht[node] = 0;
}
int dsu_find(int node, vector<int> &pt) {
if (node == pt[node]) return node;
pt[node] = dsu_find(pt[node], pt);
return pt[node];
}
void dsu_union(int n1, int n2, vector<int> &pt, vector<int> &ht) {
n1 = dsu_find(n1, pt);
n2 = dsu_find(n2, pt);
if (ht[n1] > ht[n2])
pt[n2] = n1;
else
pt[n1] = n2;
if (ht[n1] == ht[n2]) ht[n2]++;
}
int main() {
int n, t1, t2;
cin >> n;
vector<int> pt(n, 0), ht(n, 0);
for (int i = 0; i < n; i++) dsu_make(i, pt, ht);
vector<pair<int, int>> edge, edge2;
for (int i = 1; i < n; i++) {
cin >> t1 >> t2;
t1--;
t2--;
if (dsu_find(t1, pt) == dsu_find(t2, pt))
edge.push_back(make_pair(t1, t2));
else
dsu_union(t1, t2, pt, ht);
}
for (int i = 0; i < n; i++) t1 = dsu_find(i, pt);
set<int> s;
for (int i = 0; i < n; i++) {
s.insert(pt[i]);
}
while (s.size() > 1) {
t1 = *(s.begin());
s.erase(t1);
t2 = *(s.begin());
edge2.push_back(make_pair(t1, t2));
}
cout << edge.size() << "\n";
for (int i = 0; i < edge.size(); i++)
cout << edge[i].first + 1 << " " << edge[i].second + 1 << " "
<< edge2[i].first + 1 << " " << edge2[i].second + 1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void make_set(int v, int parent[], int r[]) {
parent[v] = v;
r[v] = 0;
}
int find_set(int v, int parent[]) {
if (parent[v] == v) {
return v;
}
return parent[v] = find_set(parent[v], parent);
}
void make_pair(int a, int b, int parent[], int r[]) {
int pa = find_set(a, parent);
int pb = find_set(b, parent);
if (r[pa] < r[pb]) {
swap(pa, pb);
}
parent[pb] = pa;
r[pa] = r[pa] + r[pb];
}
int main() {
int t;
cin >> t;
int parent[t];
int r[t];
int k = t;
for (int i = 0; i < t; i++) {
make_set(i, parent, r);
}
int y[t], z[t];
int counter = 0;
t--;
while (t--) {
int a, b;
cin >> a >> b;
if (find_set(a - 1, parent) != find_set(b - 1, parent)) {
make_pair(a - 1, b - 1, parent, r);
} else {
y[counter] = a;
z[counter] = b;
counter++;
}
}
counter--;
if (counter == -1) {
cout << 0;
return 0;
}
cout << counter + 1 << endl;
for (int i = 1; i < k; i++) {
if (find_set(i, parent) != find_set(0, parent)) {
cout << y[counter] << " " << z[counter] << " " << i + 1 << " " << 1
<< endl;
counter--;
make_pair(i, 0, parent, r);
}
}
return 0;
}
|
#include <bits/stdc++.h>
int dx[] = {0, -1, 0, 1, -1, 1, -1, 1};
int dy[] = {-1, 0, 1, 0, 1, -1, -1, 1};
const int N = 3e5 + 5, oo = 1e9, mod = 1e9 + 7;
const double pi = acos(-1);
using namespace std;
vector<int> g[N];
set<pair<int, int>> edges;
map<int, int> comp;
map<int, vector<int>> mp;
int scc;
bool vis[N];
void dfs(int node, int par) {
vis[node] = true;
comp[node] = scc;
mp[scc].push_back(node);
for (auto child : g[node]) {
if (!vis[child])
dfs(child, node);
else if (child != par) {
if (node > child)
edges.insert({child, node});
else
edges.insert({node, child});
}
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
scc++;
dfs(i, 0);
}
}
cout << (int)(edges).size() << '\n';
set<int> st, used;
for (int i = 1; i <= scc; i++) st.insert(i);
for (auto it : edges) {
cout << it.first << ' ' << it.second << ' ';
if (st.find(comp[it.first]) != st.end()) st.erase(comp[it.first]);
if (used.find(comp[it.first]) != used.end() || used.empty()) {
auto i = st.begin();
cout << it.first << ' ' << mp[*i].back() << '\n';
st.erase(i);
used.insert(*i);
used.insert(comp[it.first]);
} else {
auto i = used.begin();
cout << it.first << ' ' << mp[*i].back() << '\n';
used.insert(comp[it.first]);
st.erase(comp[it.first]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int pa[30010];
void init(int n) {
for (int i = 1; i <= n; i++) {
pa[i] = i;
}
}
int finds(int x) {
if (x == pa[x])
return x;
else
return pa[x] = finds(pa[x]);
}
void unions(int x, int y) {
int u = finds(x), v = finds(y);
pa[u] = v;
}
bool issameset(int i, int j) {
int u = finds(i), v = finds(j);
return u == v;
}
int main() {
int n;
cin >> n;
init(n);
vector<pair<int, int> > par;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
if (issameset(u, v)) {
par.push_back(pair<int, int>(u, v));
} else {
unions(u, v);
}
}
for (int i = 1; i <= n; i++) {
int r = finds(i);
}
int ant = -1, j = 0;
;
cout << par.size() << endl;
for (int i = 1; i <= n; i++) {
if (i == pa[i]) {
if (ant == -1)
ant = i;
else {
cout << par[j].first << " " << par[j].second << " " << ant << " " << i
<< endl;
j++;
ant = i;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
const int N = 100001;
int sz[N], p[N];
vector<int> cycles;
void initialize() {
iota(p, p + N, 0);
fill(sz, sz + N, 1);
}
int FindParent(int u) { return p[u] = (p[u] == u ? u : FindParent(p[u])); }
void Union(int u, int v) {
u = FindParent(u);
v = FindParent(v);
if (u == v) return;
if (sz[v] < sz[u]) swap(u, v);
p[u] = v;
sz[v] += sz[u];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
initialize();
int n;
cin >> n;
int t = 0;
for (int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b;
if (FindParent(a) != FindParent(b))
Union(a, b);
else
cycles.push_back(a), cycles.push_back(b);
}
set<int> a;
for (int i = 1; i <= n; ++i) {
a.insert(FindParent(i));
}
cout << a.size() - 1 << '\n';
int z = 0;
vector<int> b;
for (auto l : a) b.push_back(l);
for (int i = 0; i < b.size() - 1; ++i) {
cout << cycles[z] << " " << cycles[z + 1] << " " << FindParent(b[i]) << " "
<< FindParent(b[i + 1]) << '\n';
z += 2;
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > e;
set<pair<int, int> > s;
vector<int> v;
void DFS(int x) {
v[x] = 1;
for (int i = 0; i < e[x].size(); i++)
if (!v[e[x][i]]) {
s.insert({x, e[x][i]});
DFS(e[x][i]);
}
}
int main() {
ios_base::sync_with_stdio(0);
int n;
vector<int> pr;
vector<pair<int, int> > un;
cin >> n;
e.resize(n);
v.resize(n);
vector<pair<int, int> > lst(n - 1);
for (int i = 0; i < n - 1; i++) {
cin >> lst[i].first >> lst[i].second;
lst[i].first--;
lst[i].second--;
e[lst[i].first].push_back(lst[i].second);
e[lst[i].second].push_back(lst[i].first);
}
for (int i = 0; i < n; i++)
if (!v[i]) {
DFS(i);
pr.push_back(i);
}
for (auto paar : lst)
if (s.find(paar) == s.end() && s.find({paar.second, paar.first}) == s.end())
un.push_back(paar);
cout << pr.size() - 1 << endl;
for (int i = 0; i < pr.size() - 1; i++)
cout << un[i].first + 1 << " " << un[i].second + 1 << " " << pr[i] + 1
<< " " << pr[i + 1] + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, bad[999], w[1000], p[1000], cnt;
vector<int> c;
vector<pair<int, int>> d[1000], br, bu;
void dfs(int v, int p) {
w[v] = 1;
for (int i = 0; i < d[v].size(); ++i) {
if (d[v][i].second == p) continue;
if (w[d[v][i].second]) {
if (!bad[d[v][i].first] &&
!bad[d[v][i].first + (d[v][i].first & 1 ? -1 : 1)]) {
bad[d[v][i].first] = 1;
br.push_back(make_pair((d[v][i].first & 1 ? d[v][i].second : v),
(d[v][i].first & 1 ? v : d[v][i].second)));
}
} else
dfs(d[v][i].second, v);
}
}
void dfs2(int v) {
w[v] = 1;
for (int i = 0; i < d[v].size(); ++i) {
if (!w[d[v][i].second]) dfs2(d[v][i].second);
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
int f, t;
scanf("%d%d", &f, &t);
--f;
--t;
d[f].push_back(make_pair(2 * i, t));
d[t].push_back(make_pair(2 * i + 1, f));
}
for (int i = 0; i < n; ++i)
if (!w[i]) dfs(i, -1);
for (int i = 0; i < n; ++i) w[i] = 0;
for (int i = 0; i < n; ++i) {
if (!w[i]) {
c.push_back(i);
dfs2(i);
}
}
for (int i = 1; i < c.size(); ++i) bu.push_back(make_pair(c[i], c[i - 1]));
printf("%d\n", bu.size());
for (int i = 0; i < bu.size(); ++i)
printf("%d %d %d %d\n", br[i].first + 1, br[i].second + 1, bu[i].first + 1,
bu[i].second + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
vector<long long int> parent(1005), rnk(1005);
void init() {
for (long long int i = 0; i < 1005; i++) {
parent[i] = i;
rnk[i] = 0;
}
}
long long int find_dsu(long long int node) {
if (node != parent[node]) parent[node] = find_dsu(parent[node]);
return parent[node];
}
void union_dsu(long long int u, long long int v) {
long long int a = find_dsu(u);
long long int b = find_dsu(v);
if (a == b) return;
if (rnk[a] < rnk[b]) swap(a, b);
parent[b] = a;
if (rnk[a] == rnk[b]) rnk[a]++;
}
int main() {
fast();
init();
long long int n;
cin >> n;
vector<pair<long long int, long long int> > extra, build;
for (long long int i = 0; i < n - 1; i++) {
long long int u, v;
cin >> u >> v;
u--;
v--;
if (find_dsu(u) != find_dsu(v))
union_dsu(u, v);
else
extra.push_back(make_pair(u, v));
}
for (long long int i = 1; i < n; i++) {
if (find_dsu(i) != find_dsu(0)) {
union_dsu(i, 0);
build.push_back(make_pair(0, i));
}
}
cout << extra.size() << endl;
for (long long int i = 0; i < extra.size(); i++)
cout << extra[i].first + 1 << " " << extra[i].second + 1 << " "
<< build[i].first + 1 << " " << build[i].second + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, bool> is_visited;
int par[100100];
vector<pair<int, int>> globe;
map<pair<int, int>, bool> in_globe;
void addEdge(vector<int> adj[], int u, int v) {
adj[u].push_back(v);
adj[v].push_back(u);
}
void dfs(vector<int> adj[], int u) {
is_visited[u] = true;
for (auto v : adj[u]) {
if (is_visited[v] and par[u] != v and !in_globe[make_pair(u, v)]) {
globe.push_back(make_pair(u, v));
in_globe[make_pair(u, v)] = true;
in_globe[make_pair(v, u)] = true;
}
if (!is_visited[v]) {
par[v] = u;
dfs(adj, v);
}
}
}
int main() {
int n;
cin >> n;
vector<int> adj[n + 2];
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
addEdge(adj, u, v);
}
vector<int> vec;
for (int i = 1; i <= n; i++) {
if (!is_visited[i]) {
vec.push_back(i);
dfs(adj, i);
}
}
cout << globe.size() << endl;
for (int i = 0; i < globe.size(); i++) {
cout << globe[i].first << " " << globe[i].second << " " << vec[i] << " "
<< vec[i + 1] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void make_set(int v, int parent[], int r[]) {
parent[v] = v;
r[v] = 0;
}
int find_set(int v, int parent[]) {
if (parent[v] == v) {
return v;
}
return parent[v] = find_set(parent[v], parent);
}
void make_pair(int a, int b, int parent[], int r[]) {
int pa = find_set(a, parent);
int pb = find_set(b, parent);
if (r[pa] < r[pb]) {
swap(pa, pb);
}
parent[pb] = pa;
r[pa] = r[pa] + r[pb];
}
int main() {
int t;
cin >> t;
int parent[1000];
int r[1000];
int k = t;
for (int i = 0; i < t; i++) {
make_set(i, parent, r);
}
vector<int> y, z;
t--;
while (t--) {
int a, b;
cin >> a >> b;
if (find_set(a - 1, parent) != find_set(b - 1, parent)) {
make_pair(a - 1, b - 1, parent, r);
} else {
y.push_back(a);
z.push_back(b);
}
}
if (y.size() == 0) {
cout << 0;
return 0;
}
int counter = 0;
cout << y.size() << endl;
for (int i = 1; i < k; i++) {
if (find_set(i, parent) != find_set(0, parent)) {
cout << y[counter] << " " << z[counter] << " " << i + 1 << " " << 1
<< endl;
counter++;
make_pair(i, 0, parent, r);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long powerr(long long base, long long exp) {
base %= 1000000007;
long long result = 1;
while (exp > 0) {
if (exp & 1) result = (result * base) % 1000000007;
base = (base * base) % 1000000007;
exp >>= 1;
}
return result;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
const int N = 1010;
set<int> seet;
int parent[N];
vector<pair<int, int> > red;
void init() {
for (int i = 1; i < N; ++i) parent[i] = i;
}
int getparent(int u) {
return (u == parent[u]) ? u : parent[u] = getparent(parent[u]);
}
void link(int u, int v) {
int a = getparent(u);
int b = getparent(v);
if (a == b) {
red.push_back({u, v});
return;
}
parent[b] = a;
}
int main() {
init();
int n, u, v;
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
scanf("%d", &u);
scanf("%d", &v);
link(u, v);
}
for (int i = 1; i <= n; ++i) seet.insert(getparent(i));
printf("%d\n", red.size());
for (int i = 0; i < red.size(); ++i) {
auto it = seet.begin();
auto it2 = it;
int temp = *(it);
++it;
int temp2 = *(it);
printf("%d %d %d %d\n", red[i].first, red[i].second, temp, temp2);
seet.erase(it2);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 1e3 + 5;
const int mod = 1e9 + 7;
const int mod1 = 998244353;
vector<int> par(mxn);
int find_set(int a) {
if (a == par[a]) return a;
return par[a] = find_set(par[a]);
}
bool union_set(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a == b) return 0;
par[b] = a;
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
int n, a, b, i;
cin >> n;
for (i = 1; i <= n; i++) par[i] = i;
vector<pair<int, int> > x;
vector<int> r;
for (i = 1; i < n; i++) {
cin >> a >> b;
if (!union_set(a, b)) x.push_back(make_pair(a, b));
}
for (i = 1; i <= n; i++)
if (par[i] == i) r.push_back(i);
cout << (int)x.size() << endl;
for (i = 1; i < (int)r.size(); i++) {
cout << x[i - 1].first << " " << x[i - 1].second << " " << r[i - 1] << " "
<< r[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> v[1005];
int visited[1005] = {0};
int cycle[1005][1005] = {0};
queue<pair<int, int> > q, p;
void dfs(int node, int par) {
visited[node] = 1;
for (int i = 0; i < v[node].size(); i++) {
if (visited[v[node][i]] == 0) {
dfs(v[node][i], node);
} else {
if (v[node][i] != par && cycle[v[node][i]][node] == 0) {
q.push(make_pair(v[node][i], node));
cycle[v[node][i]][node] = 1;
cycle[node][v[node][i]] = 1;
}
}
}
}
int main() {
cin >> n;
int a, b;
for (int i = 1; i <= n - 1; i++) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
dfs(1, -1);
int days = 0;
for (int i = 2; i <= n; i++) {
if (!visited[i]) {
dfs(i, -1);
days++;
p.push(make_pair(i - 1, i));
}
}
cout << days << endl;
while (!p.empty()) {
cout << q.front().first << " " << q.front().second << " " << p.front().first
<< " " << p.front().second << endl;
p.pop();
q.pop();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct subset {
int parent;
int rank;
};
int find(struct subset subsets[], int i) {
if (subsets[i].parent != i)
subsets[i].parent = find(subsets, subsets[i].parent);
return subsets[i].parent;
}
void Union(struct subset subsets[], int x, int y) {
int xroot = find(subsets, x);
int yroot = find(subsets, y);
if (subsets[xroot].rank < subsets[yroot].rank)
subsets[xroot].parent = yroot;
else if (subsets[xroot].rank > subsets[yroot].rank)
subsets[yroot].parent = xroot;
else {
subsets[yroot].parent = xroot;
subsets[xroot].rank++;
}
}
int main() {
int n, b, a;
cin >> n;
int us[1001] = {0};
vector<pair<int, int> > v, rs;
for (int i = 0; i < n - 1; i++) {
scanf("%d%d", &a, &b);
if (a > b) swap(a, b);
v.push_back(make_pair(a, b));
}
struct subset p[n + 1];
for (int i = 1; i <= n; i++) {
p[i].parent = i;
p[i].rank = 0;
}
int val = 0;
for (int i = 0; i < n - 1; i++) {
int l = v[i].first;
int r = v[i].second;
if (find(p, l) != find(p, r)) {
Union(p, l, r);
val++;
} else {
rs.push_back(make_pair(l, r));
}
}
vector<int> ps;
if (val == n - 1) {
cout << "0" << endl;
return 0;
}
val = 0;
for (int i = 1; i <= n; i++) {
if (p[i].parent == i) {
val++;
ps.push_back(i);
}
}
cout << val - 1 << endl;
for (int i = 0; i < val - 1; i++) {
cout << rs[i].first << " " << rs[i].second << " " << ps[i] << " "
<< ps[i + 1] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int parent[50005], r[50005], sz[50005];
void make_set(int v) {
parent[v] = v;
r[v] = 0;
sz[v] = 1;
}
int find_set(int v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
bool union_sets(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (r[a] < r[b]) swap(a, b);
parent[b] = a;
sz[a] += sz[b];
if (r[a] == r[b]) ++r[a];
return 1;
}
return 0;
}
int main() {
int n, x, y;
cin >> n;
for (int i = 1; i <= n; i++) make_set(i);
vector<pair<int, int> > v;
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
if (!union_sets(x, y)) v.push_back(make_pair(x, y));
}
int a[n + 1], k = 0;
for (int i = 1; i <= n; i++) {
a[i] = find_set(i);
}
cout << v.size() << endl;
for (int i = 2; i <= n; i++) {
if (a[i] != a[1]) {
cout << v[k].first << " " << v[k].second << " " << a[1] << " " << a[i]
<< endl;
union_sets(a[1], a[i]);
a[1] = find_set(1);
for (int j = i; j <= n; j++) {
a[j] = find_set(j);
}
k++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int n, parent[N], sz[N];
vector<pair<int, int>> del;
set<int> st;
void init() {
iota(parent, parent + n + 1, 0);
fill(sz, sz + n + 1, 1);
}
int findpar(int u) {
return u == parent[u] ? u : parent[u] = findpar(parent[u]);
}
bool join(int u, int v) {
u = findpar(u);
v = findpar(v);
if (u == v) return 0;
if (sz[u] > sz[v]) swap(u, v);
parent[u] = v;
sz[v] += sz[u];
return 1;
}
int main() {
int u, v;
scanf("%d", &n);
init();
for (int i = 1; i < n; i++) {
scanf("%d %d", &u, &v);
if (!join(u, v)) {
del.push_back({u, v});
}
}
for (int i = 1; i <= n; i++) {
st.insert(findpar(i));
}
printf("%d\n", del.size());
auto it1 = st.begin(), it2 = it1;
it2++;
int i = 0;
for (; it1 != st.end() && it2 != st.end() && i < del.size();
it1++, it2++, i++) {
printf("%d %d %d %d\n", del[i].first, del[i].second, *it1, *it2);
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct dsu {
long long n;
vector<long long> p;
dsu(long long n) : n(n) {}
void init() {
p.resize(n);
for (long long i = 0; i < n; ++i) p[i] = i;
}
long long find(long long x) {
if (x == p[x])
return x;
else
return (p[x] = find(p[x]));
}
void unite(long long x, long long y) {
x = find(x);
y = find(y);
p[x] = y;
}
};
signed main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
;
long long n;
cin >> n;
vector<pair<long long, long long> > bad;
dsu d(n);
d.init();
for (long long i = 0; i < n - 1; ++i) {
long long x, y;
cin >> x >> y;
--x;
--y;
if (d.find(x) == d.find(y)) bad.push_back({x, y});
d.unite(x, y);
}
set<long long> comps;
vector<long long> cps;
for (long long i = 0; i < n; ++i) {
comps.insert(d.find(i));
}
for (long long x : comps) cps.push_back(x);
vector<pair<long long, long long> > gd;
for (long long i = 1; i < cps.size(); ++i) {
gd.push_back({cps[i], cps[i - 1]});
}
if (gd.size() != bad.size()) cout << "FAK";
cout << gd.size() << endl;
for (long long i = 0; i < gd.size(); ++i) {
cout << bad[i].first + 1 << " " << bad[i].second + 1 << " "
<< gd[i].first + 1 << " " << gd[i].second + 1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int parent[10000];
long long int ranc[10000];
vector<pair<long long int, long long int> > v;
long long int makeset(long long int v) {
parent[v] = v;
ranc[v] = 0;
}
long long int findset(long long int v) {
if (parent[v] == v) {
return parent[v];
} else
return findset(parent[v]);
}
long long int unionset(long long int a, long long int b) {
a = findset(a);
b = findset(b);
if (a != b) {
if (ranc[b] > ranc[a]) swap(a, b);
}
parent[b] = a;
ranc[a] += ranc[b];
}
int main() {
long long int n;
cin >> n;
for (long long int i = 0; i < n; i++) {
parent[i] = i;
}
for (long long int i = 0; i < n - 1; ++i) {
long long int x;
long long int y;
cin >> x >> y;
if (findset(x) == findset(y)) {
v.push_back(make_pair(x, y));
} else
unionset(x, y);
}
cout << v.size() << "\n";
if (v.size() > 0) {
for (long long int i = 1; i <= n; ++i) {
for (long long int j = 1; j <= n; ++j) {
if (i != j) {
if (findset(i) != findset(j)) {
cout << v.back().first << " " << v.back().second << " " << i << " "
<< j << "\n";
v.pop_back();
unionset(i, j);
}
}
}
}
}
clock_t clk = clock();
clk = clock() - clk;
cerr << "Time Elapsed: " << fixed << setprecision(10)
<< ((long double)clk) / CLOCKS_PER_SEC << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1009;
int n, s[N];
int f[N];
pair<int, int> d[N];
void Init() {
for (int i = 1; i <= n; i++) s[i] = i;
}
int Find(int x) {
if (x != s[x]) s[x] = Find(s[x]);
return s[x];
}
void Union(int x, int y) {
x = Find(x);
y = Find(y);
s[x] = s[y];
}
int main() {
scanf("%d", &n);
Init();
int cnt = 0;
int tot = 0;
for (int i = 1; i <= n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (Find(x) != Find(y))
Union(x, y);
else
d[++cnt] = make_pair(x, y);
}
printf("%d\n", cnt);
for (int i = 1; i <= n; i++)
if (s[i] == i) f[++tot] = i;
int now = 1;
for (int i = 1; i <= cnt; i++) {
printf("%d %d %d %d\n", d[i].first, d[i].second, f[tot], f[now]);
now++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e+3 + 10;
int p[MAXN], r[MAXN];
vector<pair<int, int>> t;
void make_set(int v) {
p[v] = v;
r[v] = 0;
}
int dsu_get(int v) { return (v == p[v]) ? v : (p[v] = dsu_get(p[v])); }
void unite(int a, int b) {
a = dsu_get(a);
b = dsu_get(b);
if (a != b) {
if (r[a] < r[b]) {
swap(a, b);
}
p[b] = a;
if (r[a] == r[b]) {
r[a]++;
}
}
}
set<int> s;
void solve() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
make_set(i);
}
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
if (dsu_get(u) == dsu_get(v)) {
t.push_back(make_pair(u, v));
} else {
unite(u, v);
}
}
for (int i = 1; i <= n; i++) {
s.insert(dsu_get(i));
}
int res = (int)s.size() - 1;
cout << res << "\n";
int from = *s.begin();
s.erase(s.begin());
int i = 0;
while (!s.empty()) {
int to = *s.begin();
s.erase(s.begin());
cout << t[i].first << " " << t[i].second << " " << from << " " << to
<< "\n";
from = to;
i++;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int A[1005];
int m;
int visited[1005];
vector<int> adj[1005];
vector<pair<int, int>> unused;
vector<int> plans;
map<pair<int, int>, int> used;
void initialize(int Arr[], int N) {
for (int i = 0; i < N; i++) Arr[i] = i;
}
bool Find(int Arr[], int A, int B) {
if (Arr[A] == Arr[B])
return true;
else
return false;
}
void Union(int Arr[], int N, int A, int B) {
int TEMP = Arr[A];
for (int i = 0; i < N; i++) {
if (Arr[i] == TEMP) Arr[i] = Arr[B];
}
}
void dfs(int index, int parent) {
visited[index] = 1;
for (int i = 0; i < adj[index].size(); i++) {
if (visited[adj[index][i]]) {
if (adj[index][i] != parent)
unused.push_back(make_pair(index, adj[index][i]));
} else
dfs(adj[index][i], index);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
n++;
initialize(A, n);
for (int i = 0; i < n - 2; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
Union(A, n, x, y);
}
for (int i = 1; i < n; i++)
if (!visited[i]) dfs(i, i);
int counter = -1;
for (int i = 1; i < n; i++)
if (A[i] == i) counter++;
cout << counter << endl;
int flag = 0, root;
for (int i = 1; i < n; i++)
if (A[i] == i && !flag++)
root = i;
else if (A[i] == i)
plans.push_back(i);
while (counter--) {
pair<int, int> temp;
flag = 0;
while (!flag) {
pair<int, int> temp2;
temp = unused.back();
temp2.second = temp.first;
temp2.first = temp.second;
if (!used[temp] && !used[temp2]) flag = 1;
used[temp] = 1;
used[temp2] = 1;
unused.pop_back();
}
int to = plans.back();
plans.pop_back();
cout << temp.first << " " << temp.second << " " << root << " " << to
<< endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct Edge {
int u, v, t;
bool operator<(const Edge other) const { return t > other.t; }
};
int n, p[1005], mark[1005][1005];
int find_par(int u) {
if (p[u] == u) return u;
return p[u] = find_par(p[u]);
}
void union_set(int u, int v) {
u = find_par(u);
v = find_par(v);
p[u] = v;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
p[i] = i;
}
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
mark[u][v] = 1;
mark[v][u] = 1;
}
vector<Edge> edges;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
edges.push_back({i, j, mark[i][j]});
}
}
sort(edges.begin(), edges.end());
vector<pair<Edge, Edge>> ans;
queue<Edge> q;
for (auto e : edges) {
if (find_par(e.u) != find_par(e.v)) {
union_set(e.u, e.v);
if (e.t) continue;
ans.push_back({q.front(), e});
q.pop();
} else {
if (e.t) q.push(e);
}
}
cout << ans.size() << "\n";
for (auto a : ans) {
cout << a.first.u << " " << a.first.v << " " << a.second.u << " "
<< a.second.v << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 1001;
int pa[maxn];
struct Node {
int u, v;
} cut[maxn];
int finding(int x) {
if (x != pa[x]) {
pa[x] = finding(pa[x]);
}
return pa[x];
}
void unio(int a, int b) {
int x = finding(a);
int y = finding(b);
pa[x] = y;
}
int main() {
int n, ans = 0;
scanf("%d", &n);
for (int i = 0; i <= n; i++) {
pa[i] = i;
}
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d %d", &a, &b);
if (finding(a) == finding(b)) {
cut[ans].u = a;
cut[ans].v = b;
ans++;
} else {
unio(a, b);
}
}
printf("%d\n", ans);
int num = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (finding(i) != finding(j)) {
printf("%d %d %d %d\n", cut[num].u, cut[num].v, i, j);
unio(i, j);
num++;
if (num == ans) break;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[1005];
int n, c, comp[1005], par[1005], sz[1005], from[1005], to[1005], e;
bool visited[1005];
int getpar(int v) {
if (par[v] == v)
return v;
else {
par[v] = getpar(par[v]);
return par[v];
}
}
void u(int a, int b) {
int x, y;
x = getpar(a);
y = getpar(b);
if (x == y) {
from[e] = a;
to[e] = b;
e++;
} else {
if (sz[x] > sz[y]) {
par[y] = x;
sz[x] += sz[y];
} else {
par[x] = y;
sz[y] += sz[x];
}
}
}
int main() {
cin >> n;
int a, b;
for (int i = 1; i <= n; i++) par[i] = i;
for (int i = 1; i <= n - 1; i++) {
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
u(a, b);
}
int x;
for (int i = 1; i <= n; i++) {
x = getpar(i);
if (visited[x] == false) {
visited[x] = true;
comp[c] = x;
c++;
}
}
cout << e << "\n";
for (int i = 0; i < e; i++) {
cout << from[i] << " " << to[i] << " " << comp[i] << " " << comp[i + 1]
<< "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const double eps = 1e-9;
const int maxn = 3e5 + 5;
int fa[maxn];
int findfa(int x) {
int y = x;
while (fa[x] != x) x = fa[x];
while (fa[y] != x) {
int z = fa[y];
fa[y] = x;
y = z;
}
return x;
}
vector<int> a, b, c, d;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i < n + 1; i++) fa[i] = i;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
int fu = findfa(u), fv = findfa(v);
if (fu == fv) {
a.push_back(u);
b.push_back(v);
} else {
int f = min(fu, fv);
fa[fu] = f, fa[fv] = f;
}
}
int cnt = 0;
for (int i = 1; i < n + 1; i++) {
int first = findfa(i);
if (first == 1) continue;
c.push_back(1), d.push_back(i);
fa[first] = 1;
++cnt;
}
printf("%d\n", (cnt));
for (int i = 0; i < cnt; i++) printf("%d %d %d %d\n", a[i], b[i], c[i], d[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int parent(int a, int p[]) {
if (p[a] == a) {
return a;
}
return parent(p[a], p);
}
int main() {
int n;
cin >> n;
int p[n + 1];
for (int i = 0; i < n + 1; i++) {
p[i] = i;
}
vector<pair<int, int> > bre, par;
int count = 0;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
if (a > b) {
swap(a, b);
}
if (parent(b, p) == parent(a, p)) {
count++;
bre.push_back(make_pair(a, b));
} else {
p[parent(b, p)] = parent(a, p);
}
}
for (int j = 2; j < n + 1; j++) {
if (parent(j, p) != parent(1, p)) {
par.push_back(make_pair(parent(1, p), parent(j, p)));
p[parent(1, p)] = parent(j, p);
}
}
cout << count << endl;
for (auto i = bre.begin(), j = par.begin(); i != bre.end(); i++, j++) {
cout << i->first << " " << i->second << " " << j->first << " " << j->second
<< " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
int fx[] = {-1, 1, 0, 0, -1, -1, 1, 1};
int fy[] = {0, 0, -1, 1, -1, 1, -1, 1};
int kx[] = {1, 1, 2, 2, -1, -1, -2, -2};
int ky[] = {2, -2, 1, -1, 2, -2, 1, -1};
int parent[1005];
int Find(int u) {
if (u == parent[u]) return u;
return parent[u] = Find(parent[u]);
}
void Union(int u, int v) {
int p = Find(u);
int q = Find(v);
if (p != q) parent[q] = p;
}
int main() {
for (int i = 1; i < 1005; i++) parent[i] = i;
int n;
scanf("%d", &n);
queue<pair<int, int> > Q;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
if (Find(u) != Find(v))
Union(u, v);
else
Q.push({u, v});
}
printf("%d\n", Q.size());
for (int i = 2; i <= n; i++) {
if (Find(1) != Find(i)) {
printf("%d %d %d %d\n", Q.front().first, Q.front().second, 1, i);
Q.pop();
Union(1, i);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1005;
int n, l, x, y, C[MAX], P[MAX], T[MAX];
struct par {
int a, b;
} In[MAX], Out[MAX];
int findst(int x) {
if (x == P[x]) return x;
return P[x] = findst(P[x]);
}
void joinst(int a, int b) {
if (T[b] > T[a]) swap(a, b);
T[a] += T[b];
P[b] = a;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) P[i] = i, T[i] = 1;
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
int x = findst(a);
int y = findst(b);
if (x == y) {
Out[++l].a = a;
Out[l].b = b;
continue;
}
joinst(x, y);
}
for (int i = 1; i <= n; i++)
if (findst(i) == i) C[++x] = i;
for (int i = 1; i < x; i++) {
In[++y].a = C[i];
In[y].b = C[i + 1];
}
if (l == 0) {
printf("0\n");
return 0;
}
printf("%d\n", l);
for (int i = 1; i < l; i++)
printf("%d %d %d %d ", Out[i].a, Out[i].b, In[i].a, In[i].b);
printf("%d %d %d %d\n", Out[l].a, Out[l].b, In[l].a, In[l].b);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
const char nl = '\n';
const long long mod = 1e9 + 7;
const long long N = 1e5 + 5;
vector<long long> parent(N), size1(N);
long long find_set(long long v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void make_set(long long v) {
parent[v] = v;
size1[v] = 1;
}
void union_sets(long long a, long long b) {
if (a != b) {
if (size1[a] < size1[b]) swap(a, b);
parent[b] = a;
size1[a] += size1[b];
}
}
void accio_ac(void) {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
make_set(i);
}
vector<pair<long long, long long> > extra, not_there;
for (long long i = 1; i < n; i++) {
long long u, v, x, y;
cin >> u >> v;
x = u;
y = v;
u = find_set(u);
v = find_set(v);
if (u == v) {
extra.emplace_back(make_pair(x, y));
} else {
union_sets(u, v);
}
}
for (long long i = 1; i <= n; i++) {
for (long long j = i + 1; j <= n; j++) {
long long a = find_set(i);
long long b = find_set(j);
if (a != b) {
not_there.emplace_back(make_pair(i, j));
union_sets(a, b);
}
}
}
long long k = not_there.size();
cout << k << '\n';
for (long long i = 0; i < k; i++) {
cout << extra[i].first << ' ' << extra[i].second << ' '
<< not_there[i].first << ' ' << not_there[i].second << nl;
}
}
int32_t main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
long long __ = 1;
while (__--) {
accio_ac();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int par[1005];
void init(int n) {
for (int i = 1; i <= n; i++) par[i] = i;
}
int find(int x) {
if (par[x] == x)
return x;
else
return par[x] = find(par[x]);
}
void unite(int x, int y) { par[find(x)] = find(y); }
int main() {
vector<int> p;
vector<pair<int, int> > q;
scanf("%d", &n);
int a, b;
init(n);
for (int i = 1; i < n; i++) {
scanf("%d %d", &a, &b);
if (find(a) == find(b))
q.push_back(make_pair(a, b));
else
unite(a, b);
}
for (int i = 1; i <= n; i++) {
if (find(i) == i) p.push_back(i);
}
printf("%d\n", p.size() - 1);
for (int i = 1; i < p.size(); i++) {
printf("%d %d %d %d\n", q[i - 1].first, q[i - 1].second, p[i - 1], p[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int parent[1005], size[1005];
vector<pair<int, int> > circle;
vector<int> lead;
void make_set(int n) {
for (int i = 1; i <= n; ++i) {
parent[i] = i;
size[i] = 1;
}
}
int find_root(int n) {
if (parent[n] == n) return n;
return parent[n] = find_root(parent[n]);
}
void merge(int a, int b) {
if (size[a] < size[b]) swap(a, b);
parent[b] = a;
size[a] += size[b];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
make_set(n);
for (int i = 1; i < n; ++i) {
int a, b;
cin >> a >> b;
int root_a = find_root(a);
int root_b = find_root(b);
if (root_a == root_b)
circle.push_back(make_pair(a, b));
else
merge(root_a, root_b);
}
int res = 0;
for (int i = 1; i <= n; ++i) {
if (parent[i] == i) {
res++;
lead.push_back(i);
}
}
cout << res - 1 << '\n';
for (int i = 1; i < res; ++i) {
cout << circle.back().first << ' ' << circle.back().second << ' '
<< lead.back() << ' ';
circle.pop_back();
lead.pop_back();
cout << lead.back() << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct UnionFind {
vector<int> f, setSize;
int cantSets;
void init(int n) {
f.clear();
setSize.clear();
cantSets = n;
f.resize(n, -1);
setSize.resize(n, 1);
}
int comp(int x) { return (f[x] == -1 ? x : f[x] = comp(f[x])); }
bool join(int i, int j) {
int a = comp(i), b = comp(j);
if (a != b) {
cantSets--;
if (setSize[a] > setSize[b]) swap(a, b);
setSize[b] += setSize[a];
f[a] = b;
}
return a == b;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
vector<pair<int, int> > badEdges;
UnionFind dsu;
cin >> n;
dsu.init(n);
for (int i = (0); i < (n - 1); i++) {
int a, b;
cin >> a >> b;
a--;
b--;
if (dsu.join(a, b)) badEdges.push_back(make_pair(a + 1, b + 1));
}
set<int> representantes;
for (int i = (0); i < (n); i++) representantes.insert(dsu.comp(i));
int sum = 0;
for (auto it = representantes.begin(); it != representantes.end(); it++)
sum += dsu.setSize[*it];
assert(sum == n);
assert(dsu.cantSets == representantes.size());
assert(badEdges.size() == representantes.size() - 1);
cout << badEdges.size() << '\n';
set<int>::iterator ite = representantes.begin();
for (auto it = badEdges.begin(); it != badEdges.end(); it++) {
cout << it->first << ' ' << it->second << ' ' << *ite + 1 << ' '
<< *next(ite) + 1 << '\n';
ite++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, u, v, cyclecnt, grno, group[(int)1e3 + 5], vertofgr[(int)1e3 + 5];
bool visited[(int)1e3 + 5];
vector<int> adjlist[(int)1e3 + 5];
pair<int, int> cycles[(int)1e3 + 5];
class UnionFind {
private:
int id[(int)1e3 + 5], sz[(int)1e3 + 5];
int root(int x) {
while (id[x] != x) {
id[x] = id[id[x]];
x = id[x];
}
return x;
}
public:
UnionFind() {
for (int i = 0; i < (int)1e3 + 5; i++) {
sz[i] = 1;
id[i] = i;
}
}
bool same(int m, int n) { return root(m) == root(n); }
void unite(int m, int n) {
int rtm = root(m), rtn = root(n);
if (sz[rtm] > sz[rtn]) {
id[rtn] = id[rtm];
sz[rtm] += sz[rtn];
} else {
id[rtm] = id[rtn];
sz[rtn] += sz[rtm];
}
}
};
inline int fio() {
int val = 0;
char ch = getchar();
while (ch == ' ' || ch == '\n') ch = getchar();
while (ch >= '0' && ch <= '9') {
val = val * 10 + ch - '0';
ch = getchar();
}
return val;
}
inline void io() {
n = fio();
UnionFind uf;
for (int i = 0; i < n - 1; i++) {
u = fio(), v = fio();
adjlist[u].push_back(v);
adjlist[v].push_back(u);
if (!uf.same(u, v))
uf.unite(u, v);
else
cycles[cyclecnt++] = make_pair(u, v);
}
}
void dfs(int s) {
visited[s] = true;
group[s] = grno;
for (int i = 0; i < adjlist[s].size(); i++) {
int current = adjlist[s][i];
if (!visited[current]) {
dfs(current);
}
}
}
inline void mkgroups() {
for (int i = 1; i <= n; i++)
if (!visited[i]) {
grno++;
vertofgr[grno] = i;
dfs(i);
}
}
int main() {
io();
mkgroups();
printf("%d\n", cyclecnt);
for (int i = 0; i < cyclecnt; i++) {
printf("%d %d %d %d\n", cycles[i].first, cycles[i].second, vertofgr[1],
vertofgr[i + 2]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mxN = 1005;
long long int parent[mxN], n;
long long int Rank[mxN];
vector<pair<long long int, long long int> > removed;
vector<pair<long long int, long long int> > joined;
unordered_set<long long int> uniq_parent;
void make_set() {
for (long long int v = 0; v <= n + 1; v++) {
parent[v] = v;
Rank[v] = 0;
}
}
long long int find_set(long long int v) {
if (v == parent[v]) {
return v;
}
return parent[v] = find_set(parent[v]);
}
void union_set(long long int A, long long int B) {
long long int a = find_set(A);
long long int b = find_set(B);
if (a == b) {
removed.push_back(make_pair(A, B));
return;
}
if (Rank[a] < Rank[b]) {
swap(a, b);
}
parent[b] = a;
if (Rank[a] == Rank[b]) {
Rank[a]++;
}
}
void solve() {
cin >> n;
make_set();
long long int x, y;
for (long long int i = 0; i < n - 1; i++) {
cin >> x >> y;
union_set(x, y);
}
for (long long int v = 1; v <= n; v++) {
uniq_parent.insert(find_set(v));
}
vector<long long int> uniq;
for (auto x : uniq_parent) {
uniq.push_back(x);
}
for (long long int i = 0; i < uniq.size() - 1; i++) {
joined.push_back({uniq[i], uniq[i + 1]});
}
cout << removed.size() << endl;
for (long long int i = 0; i < removed.size(); i++) {
cout << removed[i].first << " " << removed[i].second << " "
<< joined[i].first << " " << joined[i].second << endl;
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
const int mxN = 1000;
int prnt[mxN];
int rnk[mxN];
vector<int> adj[mxN];
vector<pair<int, int>> ans;
int vis[mxN];
int find(int i) {
if (prnt[i] != i) prnt[i] = find(prnt[i]);
return prnt[i];
}
void join(int x, int y) {
int xroot = find(x);
int yroot = find(y);
if (rnk[xroot] < rnk[yroot])
prnt[xroot] = yroot;
else if (rnk[xroot] > rnk[yroot])
prnt[yroot] = xroot;
else {
prnt[yroot] = xroot;
rnk[xroot]++;
}
}
void dfs(int u, int e) {
for (auto ad = adj[u].begin(); ad != adj[u].end(); ad++) {
if (*ad == e || vis[*ad]) continue;
int adprnt = find(*ad);
int uprnt = find(u);
if (adprnt == uprnt) {
ans.push_back(make_pair(u, *ad));
continue;
}
join(*ad, u);
dfs(*ad, u);
}
vis[u] = 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 0; i < n; i++) {
prnt[i] = i;
}
for (int i = 0; i < n; i++) {
if (!vis[i]) {
dfs(i, -1);
}
}
cout << ans.size() << endl;
int id = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
int x = find(i);
int y = find(j);
if (x != y) {
cout << ans[id].first + 1 << " " << ans[id].second + 1 << " " << i + 1
<< " " << j + 1 << endl;
id++;
join(i, j);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct UnionFind {
int n;
vector<int> dad, size;
UnionFind(int N) : n(N), dad(N), size(N, 1) {
while (N--) dad[N] = N;
}
int find(int u) {
if (dad[u] == u) return u;
return dad[u] = find(dad[u]);
}
void join(int u, int v) {
int Ru = find(u), Rv = find(v);
if (Ru == Rv) return;
if (size[Ru] > size[Rv]) swap(Ru, Rv);
--n, dad[Ru] = Rv;
size[Rv] += size[Ru];
}
bool same(int u, int v) { return find(u) == find(v); }
int get_size(int u) { return size[find(u)]; }
int number_of_sets() { return n; }
};
const int MAXN = 1e3 + 5;
int n;
bool valid[MAXN];
int vis[MAXN];
vector<pair<int, int>> adj[MAXN];
bool dfs(int u, int p, tuple<int, int, int>& edge) {
vis[u] = 1;
for (auto e : adj[u]) {
if (!valid[e.second] || e.first == p) continue;
if (vis[e.first] == 1) {
edge = make_tuple(u, e.first, e.second);
return true;
} else if (vis[e.first] == 2)
continue;
else if (dfs(e.first, u, edge))
return true;
}
vis[u] = 2;
return false;
}
int solve(UnionFind& UF, vector<pair<pair<int, int>, pair<int, int>>>& answer) {
fill(valid, valid + n, true);
int ans = UF.number_of_sets();
while (UF.number_of_sets() > 1) {
fill(vis, vis + n, 0);
tuple<int, int, int> edge;
for (int i = 0; i < n; i++) {
if (vis[i]) continue;
if (dfs(i, -1, edge)) break;
}
int u = UF.find(0);
int v = u;
for (int i = 0; i < n; i++) {
v = UF.find(i);
if (v != u) break;
}
UF.join(u, v);
valid[get<2>(edge)] = false;
answer.emplace_back(make_pair(get<0>(edge), get<1>(edge)), make_pair(u, v));
}
return ans - 1;
}
int main() {
;
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
UnionFind UF(n);
int _id = 0;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
UF.join(u, v);
adj[u].emplace_back(v, _id);
adj[v].emplace_back(u, _id);
_id++;
}
vector<pair<pair<int, int>, pair<int, int>>> v;
cout << solve(UF, v) << '\n';
for (auto i : v)
cout << i.first.first + 1 << ' ' << i.first.second + 1 << ' '
<< i.second.first + 1 << ' ' << i.second.second + 1 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long OO = (long long)1e9;
vector<vector<int>> x;
set<pair<int, int>> nw, od;
int v[1005];
void dfs(int in, int p) {
v[in] = 1;
for (int i = 0; i < x[in].size(); i++)
if (!v[x[in][i]])
dfs(x[in][i], in);
else if (x[in][i] != p)
od.insert(make_pair(min(in, x[in][i]), max(in, x[in][i])));
}
int main() {
ios::sync_with_stdio(false);
memset(v, 0, sizeof v);
int n, a, b;
cin >> n;
x = vector<vector<int>>(n + 1);
for (int i = 1; i < n; i++) {
cin >> a >> b;
x[a].push_back(b);
x[b].push_back(a);
}
dfs(1, 0);
for (int i = 2; i <= n; i++)
if (!v[i]) {
dfs(i, 0);
nw.insert(make_pair(1, i));
}
cout << nw.size() << endl;
for (set<pair<int, int>>::iterator it2 = nw.begin(), it = od.begin();
it2 != nw.end(); it++, it2++)
cout << (*it).first << " " << (*it).second << " " << (*it2).first << " "
<< (*it2).second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void mxi(T& a, const T& b) {
a = max(a, b);
}
template <class T>
void mni(T& a, const T& b) {
a = min(a, b);
}
long double EPS = 1e-9;
long long par[1100];
long long findr(long long x) {
if (x == par[x]) return x;
return par[x] = findr(par[x]);
}
void merge(long long a, long long b) {
long long ra = findr(a), rb = findr(b);
if (ra != rb) {
par[rb] = ra;
}
}
void solve() {
long long n;
cin >> n;
for (long long i = 0; i < (n + 10); i++) par[i] = i;
vector<pair<long long, long long> > v;
vector<pair<long long, long long> > useless;
long long change = 0;
for (long long i = 0; i < (n - 1); i++) {
long long a, b;
cin >> a >> b;
v.push_back({a, b});
if (findr(a) == findr(b)) {
useless.push_back({a, b});
change++;
}
merge(a, b);
}
long long root = findr(1);
cout << change << '\n';
vector<pair<long long, long long> > ans;
for (long long i = 1; i <= n; i++) {
if (findr(i) != root) {
ans.push_back({i, root});
merge(root, i);
}
}
assert(ans.size() == useless.size());
for (long long i = 0; i < ans.size(); i++) {
cout << useless[i].first << ' ' << useless[i].second << ' ' << ans[i].first
<< ' ' << ans[i].second << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t, tab;
t = 1;
tab = t;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int pr[1005], sz[1005], ans = 0;
vector<pair<int, int> > vec;
int find_set(int u) {
if (u == pr[u]) return u;
return pr[u] = find_set(pr[u]);
}
void union_set(int u, int v) {
int a = find_set(u);
int b = find_set(v);
if (a == b) {
vec.push_back({u, v});
ans++;
return;
}
if (sz[a] < sz[b]) swap(a, b);
sz[a] += sz[b];
pr[b] = a;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
pr[i] = i;
sz[i] = 1;
}
for (int i = 0; i < n - 1; i++) {
int n1, n2;
cin >> n1 >> n2;
union_set(n1, n2);
}
set<int> s;
for (int i = 1; i <= n; i++) {
int u = find_set(i);
s.insert(u);
}
cout << ans << endl;
auto it = s.begin();
for (int i = 0; i < ans; i++) {
cout << vec[i].first << " " << vec[i].second << " " << *it << " ";
it++;
cout << *it << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void dfs(int i, vector<vector<pair<int, bool> > >& edg, vector<bool>& vis,
vector<int>& par) {
vis[i] = true;
for (int j = 0; j < edg[i].size(); j++) {
if (!vis[edg[i][j].first]) {
par[edg[i][j].first] = par[i];
edg[i][j].second = true;
for (int k = 0; k < edg[edg[i][j].first].size(); k++) {
if (edg[edg[i][j].first][k].first == i) {
edg[edg[i][j].first][k].second = true;
break;
}
}
dfs(edg[i][j].first, edg, vis, par);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
;
int n;
cin >> n;
vector<vector<pair<int, bool> > > edg(n + 1);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
edg[u].push_back(make_pair(v, false));
edg[v].push_back(make_pair(u, false));
}
vector<bool> vis(n + 1, false);
vector<int> par(n + 1, -1);
for (int i = 1; i < n + 1; i++) {
if (!vis[i]) {
par[i] = i;
dfs(i, edg, vis, par);
}
}
int count = 0;
for (int i = 1; i < n + 1; i++) {
if (par[i] == 1) {
count++;
}
}
if (count == n) {
cout << 0 << endl;
} else {
set<int> x;
for (int i = 1; i < n + 1; i++) {
if (par[i] != 1) {
x.insert(par[i]);
}
}
vector<pair<int, int> > unusedEdges;
for (int i = 1; i < n + 1; i++) {
for (int j = 0; j < edg[i].size(); j++) {
if (!edg[i][j].second) {
unusedEdges.push_back(make_pair(i, edg[i][j].first));
edg[i][j].second = true;
for (int k = 0; k < edg[edg[i][j].first].size(); k++) {
if (edg[edg[i][j].first][k].first == i) {
edg[edg[i][j].first][k].second = true;
break;
}
}
}
}
}
set<int>::iterator it;
int z = 0;
cout << x.size() << endl;
for (it = x.begin(); it != x.end(); it++) {
cout << unusedEdges[z].first << " " << unusedEdges[z].second << " ";
cout << 1 << " " << *it << endl;
z++;
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, par[2000];
vector<pair<int, int> > edge;
vector<pair<pair<int, int>, pair<int, int> > > ans;
set<pair<int, int> > rem;
int find_father(int v) {
if (par[v] == v) return v;
return par[v] = find_father(par[v]);
}
bool ism(int u, int v) { return find_father(u) == find_father(v); }
void mrg(int u, int v) { par[find_father(u)] = find_father(v); }
int main() {
cin >> n;
pair<int, int> a;
for (int i = 0; i < n - 1; i++) cin >> a.first >> a.second, edge.push_back(a);
for (int i = 1; i <= n; i++) par[i] = i;
for (int i = 0; i < n - 1; i++) {
if (!ism(edge[i].first, edge[i].second))
mrg(edge[i].first, edge[i].second);
else
rem.insert(edge[i]);
}
for (int i = 2; i <= n; i++) {
if (!ism(1, i)) {
pair<int, int> b = *rem.begin();
rem.erase(b);
ans.push_back(make_pair(b, make_pair(1, i)));
mrg(1, i);
}
}
cout << (int)ans.size() << endl;
for (int i = 0; i < (int)ans.size(); i++) {
cout << ans[i].first.first << " " << ans[i].first.second << " "
<< ans[i].second.first << " " << ans[i].second.second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int v[1000];
int parent[1000];
int r[1000];
void make_set(int v) {
parent[v] = v;
r[v] = 0;
}
int find_set(int v) {
if (parent[v] == v) {
return v;
}
return parent[v] = find_set(parent[v]);
}
void make_pair(int a, int b) {
int pa = find_set(a);
int pb = find_set(b);
if (r[pa] < r[pb]) {
swap(pa, pb);
}
parent[pb] = pa;
r[pa] = r[pa] + r[pb];
}
int main() {
int t;
cin >> t;
int k = t;
for (int i = 0; i < t; i++) {
make_set(i);
}
int y[t], z[t];
int counter = 0;
t--;
while (t--) {
int a, b;
cin >> a >> b;
if (find_set(a - 1) != find_set(b - 1)) {
make_pair(a - 1, b - 1);
} else {
y[counter] = a;
z[counter] = b;
counter++;
}
}
counter--;
if (counter == -1) {
cout << 0;
return 0;
}
cout << counter + 1 << endl;
for (int i = 1; i < k; i++) {
if (find_set(i) != find_set(0)) {
cout << y[counter] << " " << z[counter] << " " << i + 1 << " " << 1
<< endl;
counter--;
make_pair(i, 0);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:227420978")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long Mod = 1000000007LL, INF = 1e9, LINF = 1e18;
const long double PI = 3.141592653589793116, EPS = 1e-9,
GOLD = ((1 + sqrt(5)) / 2);
long long keymod[] = {1000000007LL, 1000000009LL, 1000000021LL, 1000000033LL};
long long keyCount = sizeof(keymod) / sizeof(long long);
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcount(s);
}
auto TimeStart = chrono::steady_clock::now();
auto TimeEnd = chrono::steady_clock::now();
void ControlIO(int argc, char* argv[]);
void TimerStart();
void TimerStop();
void Exit();
long long n, a, b;
vector<set<long long>> adj(1007);
vector<bool> vis(1007, false);
vector<pair<long long, long long>> R, A;
long long Root = -1;
long long edgecnt = 0, vertexcnt = 0;
map<pair<long long, long long>, long long> Map;
void ccfind(long long z) {
vis[z] = true;
vertexcnt++;
edgecnt += adj[z].size();
for (auto it = adj[z].begin(); it != adj[z].end(); it++) {
long long t = *it;
if (!vis[t]) ccfind(t);
}
}
void DFS(long long z, long long last) {
vis[z] = true;
for (auto it = adj[z].begin(); it != adj[z].end(); it++) {
long long t = *it;
if (t == last) continue;
if (vis[t]) {
if (Map[make_pair(z, t)] || Map[make_pair(t, z)]) continue;
Map[make_pair(z, t)]++;
Map[make_pair(t, z)]++;
R.push_back(make_pair(z, t));
continue;
}
DFS(t, z);
}
}
void Input() {
cin >> n;
for (long long i = 1; i < n; i++) {
cin >> a >> b;
adj[a].insert(b);
adj[b].insert(a);
}
}
void Solve() {
for (long long i = 1; i <= n; i++) {
vertexcnt = 0;
edgecnt = 0;
if (vis[i]) continue;
ccfind(i);
if ((vertexcnt - 1) * 2 == edgecnt) {
Root = i;
break;
}
}
for (long long i = 0; i < 1007; i++) vis[i] = false;
ccfind(Root);
for (long long i = 1; i <= n; i++) {
if (vis[i]) continue;
DFS(i, -1);
A.push_back(make_pair(Root, i));
}
cout << R.size() << '\n';
for (long long i = 0; i < R.size(); i++) {
pair<long long, long long> x = R[i], y = A[i];
cout << x.first << " " << x.second << " ";
cout << y.first << " " << y.second << '\n';
}
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
ControlIO(argc, argv);
Input();
TimerStart();
Solve();
TimerStop();
return 0;
}
void ControlIO(int argc, char* argv[]) {}
void TimerStart() {}
void TimerStop() {}
void Exit() {
TimerStop();
exit(0);
}
|
#include <bits/stdc++.h>
using namespace std;
int parent[10000];
int size[10000];
void make_set(int i) {
parent[i] = i;
size[i] = 1;
}
int find_set(int i) {
if (parent[i] == i) return i;
return parent[i] = find_set(parent[i]);
}
void union_sets(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (size[b] > size[a]) {
int temp;
temp = a;
a = b;
b = temp;
}
parent[b] = a;
size[a] += size[b];
}
}
int main() {
set<int> set1;
vector<int> vector1, vector2;
vector<int>::iterator it1, it3;
set<int>::iterator it2, it4;
int test, a, b, number[10000], k = 0, size = 0;
cin >> test;
test = test - 1;
int firstCity[test], secondCity[test];
for (int i = 1; i <= test + 1; i++) {
make_set(i);
}
for (int i = 0; i < test; i++) {
cin >> firstCity[i] >> secondCity[i];
make_set(firstCity[i]);
make_set(secondCity[i]);
}
for (int i = 0; i < test; i++) {
a = find_set(secondCity[i]);
b = find_set(firstCity[i]);
if (a != b) {
union_sets(firstCity[i], secondCity[i]);
} else {
size++;
vector1.push_back(firstCity[i]);
vector2.push_back(secondCity[i]);
}
}
for (int i = 1; i <= test + 1; i++) {
int l = find_set(i);
set1.insert(l);
}
cout << size << endl;
if (size > 0) {
auto it4 = set1.begin();
it4++;
for (it2 = set1.begin(), it1 = vector1.begin(), it3 = vector2.begin();
it1 != vector1.end(); it2++, it1++, it3++, it4++) {
cout << *it1 << " " << *it3 << " " << *it2 << " " << *it4 << " " << endl;
}
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, compLeader[1002], compAmount, vis[1002], myComp[1002];
vector<int> graph[1002];
void visit(int node, int leader) {
myComp[node] = compAmount;
for (int son : graph[node]) {
if (!myComp[son]) visit(son, leader);
}
}
void CountLeaders() {
int t = -1;
for (int i = 1; i <= n; i++) {
if (!myComp[i]) {
compLeader[++compAmount] = i, visit(i, i), t++;
}
}
cout << t << "\n";
}
bool StillConnected(int node, int a, int b, int color) {
vis[node] = color;
if (node == b) return true;
bool ans = false;
for (int son : graph[node]) {
if (son && (node != a || son != b) && vis[son] != color &&
(node != b || son != a)) {
ans |= StillConnected(son, a, b, color);
}
}
return ans;
}
void Disconnect(int a, int b) {
for (int i = 0; i < graph[a].size(); i++)
if (graph[a][i] == b) graph[a][i] = 0;
}
int parent[1002], sz[1002];
void initialize() {
for (int i = 1; i <= n; i++) parent[i] = i, sz[i] = 1;
}
int find(int x) {
while (parent[x] != x) x = parent[x] = parent[parent[x]];
return x;
}
bool joined(int a, int b) { return find(a) == find(b); }
void join(int a, int b) {
int aRoot = find(a), bRoot = find(b);
if (sz[aRoot] > sz[bRoot]) swap(aRoot, bRoot);
sz[bRoot] += sz[aRoot];
parent[aRoot] = bRoot;
}
void PrintNewRoads() {
int color = 1;
for (int i = 1; i <= n; i++) {
for (int son : graph[i]) {
int chosenComp = 1;
while (joined(chosenComp, myComp[i])) chosenComp++;
if (chosenComp <= compAmount && StillConnected(i, i, son, color++)) {
join(chosenComp, myComp[i]);
cout << i << " " << son << " " << i << " " << compLeader[chosenComp]
<< "\n";
Disconnect(i, son), Disconnect(son, i);
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
initialize();
for (int i = 1; i < n; i++)
cin >> a >> b, graph[a].push_back(b), graph[b].push_back(a);
CountLeaders();
PrintNewRoads();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class DisjointSetUnion {
int n;
int *p, *r;
public:
DisjointSetUnion(int x) {
n = x;
p = new int[n + 1];
r = new int[n + 1];
for (int i = 1; i <= n; i++) p[i] = i;
memset(r, 0, sizeof(r));
}
void Union(int x, int y) {
int a = p[x];
int b = p[y];
if (r[a] > r[b]) {
p[b] = a;
r[a] = max(r[a], r[b] + 1);
} else {
p[a] = b;
r[b] = max(r[b], r[a] + 1);
}
}
int Find(int a) {
if (p[a] == a) return a;
return p[a] = Find(p[a]);
}
};
int main() {
int i, j, k;
int n, m;
int u, v;
scanf("%d", &n);
DisjointSetUnion dsu(n);
vector<pair<int, int> > close;
for (i = 1; i <= n - 1; i++) {
scanf("%d%d", &u, &v);
if (dsu.Find(u) != dsu.Find(v))
dsu.Union(u, v);
else
close.push_back({u, v});
}
set<int> s;
for (i = 1; i <= n; i++) s.insert(dsu.Find(i));
vector<pair<int, int> > open;
set<int>::iterator p = s.begin();
while (p != s.end()) {
u = *p;
p++;
if (p == s.end()) break;
v = *p;
open.push_back({u, v});
}
printf("%d\n", close.size());
for (i = 0; i < close.size(); i++)
printf("%d %d %d %d\n", close[i].first, close[i].second, open[i].first,
open[i].second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[10000 + 1];
bool vis[10000 + 5];
vector<pair<int, int>> dups;
int dcou = 0;
struct obj {
vector<pair<int, int>> dup;
int dco = 0;
};
map<pair<int, int>, bool> check;
void dfs(int a, int ls) {
vis[a] = 1;
for (auto& a1 : adj[a]) {
if (a1 != a && a1 != ls) {
if (vis[a1]) {
if (check[{a1, a}] || check[{a, a1}]) continue;
dcou++;
dups.push_back({a, a1});
check[{a, a1}] = 1;
} else {
dfs(a1, a);
}
}
}
}
int main() {
memset(vis, 0, sizeof(vis));
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
map<int, obj> info;
vector<int> tre;
vector<int> grp;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
dcou = 0;
dups.clear();
check.clear();
dfs(i, 0);
obj o1;
o1.dco = dcou;
o1.dup = dups;
info[i] = o1;
if (dcou == 0) {
tre.push_back(i);
} else {
grp.push_back(i);
}
}
}
int ans = 0;
vector<pair<int, pair<int, pair<int, int>>>> an1;
while (!grp.empty()) {
int in1 = grp.back();
int in2 = tre.back();
grp.pop_back();
tre.pop_back();
ans++;
pair<int, int> tmp = info[in1].dup.back();
info[in1].dup.pop_back();
int de = --info[in1].dco;
an1.push_back({tmp.first, {tmp.second, {in1, in2}}});
if (de == 0) {
tre.push_back(in2);
} else {
grp.push_back(in1);
}
}
cout << ans << "\n";
for (auto& a1 : an1) {
cout << a1.first << " " << a1.second.first << " "
<< " " << a1.second.second.first << " " << a1.second.second.second
<< "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef struct _edge {
int root;
int source;
int destination;
} edge;
void dfs(vector<int> *edges, vector<edge> &edge_to_cut, vector<edge> &blocked,
vector<int> &visit, int cur, int pre, bool &is_cycle, int root) {
if (visit[cur] == 0) {
visit[cur] = 1;
for (int next : edges[cur]) {
if (visit[next] == 0) {
dfs(edges, edge_to_cut, blocked, visit, next, cur, is_cycle, root);
} else if (next != pre) {
bool is_blocked = false;
for (edge b : blocked) {
if (b.source == cur && b.destination == next) {
is_blocked = true;
}
}
if (!is_blocked) {
edge e = {root, cur, next};
edge_to_cut.push_back(e);
is_cycle = true;
edge blocking = {root, next, cur};
blocked.push_back(blocking);
}
}
}
}
}
int main(void) {
int n;
cin >> n;
vector<int> *edges = new vector<int>[n];
for (int i = 0; i < n - 1; i++) {
int s, d;
cin >> s >> d;
edges[s - 1].push_back(d - 1);
edges[d - 1].push_back(s - 1);
}
vector<int> visit(n, 0);
vector<int> dest;
vector<edge> edges_to_cut;
vector<edge> blocked;
for (int i = 0; i < n; i++) {
if (visit[i] == 0) {
bool is_cycle = false;
dfs(edges, edges_to_cut, blocked, visit, i, -1, is_cycle, i);
dest.push_back(i);
}
}
if (edges_to_cut.size() == 0) {
cout << 0 << endl;
return 0;
}
int days = edges_to_cut.size();
cout << days << endl;
for (int i = 0; i < days; i++) {
edge e = edges_to_cut[i];
cout << e.source + 1 << ' ' << e.destination + 1 << ' ' << dest[i] + 1
<< ' ' << dest[i + 1] + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5, inf = 1e18;
long long Q1, Q2, n, tmp1, tmp2, par[N], V, c;
bool mark[N], tmp;
vector<long long> vec, adj[N];
pair<long long, long long> P[N];
long long get_par(long long v) {
return (par[v] == -1 ? v : (par[v] = get_par(par[v])));
}
bool marge(long long v, long long u) {
v = get_par(v);
u = get_par(u);
if (u == v) return true;
par[u] = v;
return false;
}
void DFS(long long v, long long p) {
mark[v] = true;
for (auto u : adj[v]) {
if (u == p) continue;
if (mark[u] != true)
DFS(u, v);
else
tmp = false;
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
fill(par, par + n + 1, -1);
for (long long i = 1; i < n; i++) {
cin >> tmp1 >> tmp2;
adj[tmp1].push_back(tmp2);
adj[tmp2].push_back(tmp1);
if (marge(tmp1, tmp2)) {
P[c].first = tmp1;
P[c].second = tmp2;
Q1 = tmp1, Q2 = tmp2;
c++;
}
}
for (long long i = 1; i <= n; i++) {
if (mark[i] != true) {
vec.push_back(i);
tmp = true;
DFS(i, 0);
if (tmp) V = i;
}
}
long long t = 0;
cout << vec.size() - 1 << endl;
for (long long i = 0; i < vec.size(); i++) {
long long X = vec[i];
if (X == V) continue;
cout << P[t].first << " " << P[t].second << " " << V << " " << X << endl;
t++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void optimise() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
long long int mod = (long long int)1e9 + 7;
void normalize(long long int &a) { a = (a + mod) % mod; }
long long int modmul(long long int a, long long int b) {
a = a % mod;
b = b % mod;
normalize(a);
normalize(b);
return (a * b) % mod;
}
long long int modadd(long long int a, long long int b) {
a = a % mod;
b = b % mod;
normalize(a);
normalize(b);
return (a + b) % mod;
}
long long int modsub(long long int a, long long int b) {
a = a % mod;
b = b % mod;
normalize(a);
normalize(b);
return (a - b + mod) % mod;
}
long long int me(long long int x, long long int n) {
x %= mod;
if (n == 0) return 1;
long long int u = me(x, n / 2) % mod;
u = (u * u) % mod;
if (n % 2) u = (u * x) % mod;
return u;
}
long long int me1(long long int x, long long int n) {
if (n == 0) return 1;
long long int u = me1(x, n / 2);
u = u * u;
if (n % 2) u = u * x;
return u;
}
inline long long int modInv(long long int a) { return me(a, mod - 2); }
inline long long int modDiv(long long int a, long long int b) {
return modmul(a, modInv(b));
}
float power(float x, long long int y) {
float temp;
if (y == 0) return 1;
temp = power(x, y / 2);
if (y % 2 == 0)
return temp * temp;
else {
if (y > 0)
return x * temp * temp;
else
return (temp * temp) / x;
}
}
long long int __gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return __gcd(b, a % b);
}
pair<long long int, long long int> operator+(
pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return {a.first + b.first, a.second + b.second};
}
pair<long long int, long long int> operator-(
pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return {a.first - b.first, a.second - b.second};
}
pair<long long int, long long int> operator*(
pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return {a.first * b.first, a.second * b.second};
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
for (auto it : v) os << it << " ";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (long long int i = 0; i < v.size(); ++i) os << v[i] << " ";
return os;
}
const long long int N = 1e3 + 1;
vector<long long int> vis(N);
vector<long long int> G[N];
vector<long long int> parent(N);
map<pair<long long int, long long int>, long long int> s;
long long int g;
void dfs(long long int v, long long int p) {
vis[v] = 1;
for (auto y : G[v]) {
if (vis[y] and p != y and s.find({v, y}) == s.end() and
s.find({y, v}) == s.end()) {
s[{v, y}] = g;
} else if (vis[y] == 0) {
dfs(y, v);
}
}
}
void solve() {
long long int n;
cin >> n;
vector<long long int> size1(n + 1);
for (long long int i = 0; i < n - 1; i++) {
long long int x, y;
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
set<long long int> ans;
for (long long int i = 1; i <= n; i++) {
if (vis[i] == 0) {
g = i;
dfs(i, -1);
if (i != 1) ans.insert(i);
}
}
vector<pair<pair<long long int, long long int>,
pair<long long int, long long int> > >
p1;
while (!ans.empty()) {
auto k1 = *s.begin();
auto k2 = *ans.begin();
p1.push_back({{k1.first}, {k2, 1}});
s.erase(s.begin());
ans.erase(k2);
}
cout << p1.size() << "\n";
for (long long int i = 0; i < p1.size(); i++) {
cout << p1[i].first.first << " " << p1[i].first.second << " "
<< p1[i].second.first << " " << p1[i].second.second << "\n";
}
}
signed main() {
optimise();
long long int t;
t = 1;
cout << fixed << setprecision(3);
while (t--) {
solve();
cout << "\n";
}
cerr << "\n"
<< "Time Elasped : " << 1.0 * clock() / CLOCKS_PER_SEC << "\n";
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
;
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a > b)
return b;
else
return a;
}
long long gcd(long long a, long long b) { return (b == 0) ? a : gcd(b, a % b); }
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long normalize(long long x, long long mod) {
x %= mod;
if (x < 0) x += mod;
return x;
}
long long dx[4] = {0, 0, 1, -1};
long long dy[4] = {1, -1, 0, 0};
const long long mod = 1000 * 1000 * 1000 + 7;
const long long inf = 1e18 + 5;
long long powm(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
const long long N = 1e5 + 5;
long long n;
long long parent[1005], rank1[1005];
vector<pair<long long, long long> > rem;
void make_set(long long v) {
parent[v] = v;
rank1[v] = 0;
}
long long find_set(long long v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(long long a, long long b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (rank1[a] < rank1[b]) swap(a, b);
parent[b] = a;
if (rank1[a] == rank1[b]) rank1[a]++;
}
}
void solve() {
cin >> n;
for (long long i = (1); i < (n + 1); ++i) make_set(i);
for (long long i = (1); i < (n); ++i) {
long long u, v;
cin >> u >> v;
if (find_set(u) == find_set(v))
rem.push_back({u, v});
else
union_sets(u, v);
}
vector<long long> tmp;
for (long long i = (1); i < (n + 1); ++i) {
if (find_set(i) == i) tmp.push_back(i);
}
cout << ((long long)tmp.size()) - 1 << "\n";
for (long long i = (0); i < (((long long)tmp.size()) - 1); ++i)
cout << rem[i].first << " " << rem[i].second << " " << tmp[i] << " "
<< tmp[i + 1] << "\n";
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int par[1100];
vector<pair<pair<int, int>, pair<int, int> > > ans;
int findParent(int x) { return par[x] == x ? x : par[x] = findParent(par[x]); }
vector<int> vec;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) par[i] = i;
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
int a = findParent(x);
int b = findParent(y);
if (a == b)
ans.push_back({{-1, -1}, {x, y}});
else
par[b] = a;
}
for (int i = 1; i <= n; i++) {
if (par[i] == i) vec.push_back(i);
}
for (int i = 0; i < ans.size(); i++) {
ans[i].first = {vec[i], vec[i + 1]};
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++)
printf("%d %d %d %d\n", ans[i].second.first, ans[i].second.second,
ans[i].first.first, ans[i].first.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void make_set(int v, int parent[], int sz[]) {
parent[v] = v;
sz[v] = 1;
}
int find_set(int v, int parent[]) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v], parent);
}
void union_set(int a, int b, int parent[], int sz[]) {
a = find_set(a, parent);
b = find_set(b, parent);
if (a != b) {
if (sz[a] < sz[b]) {
a = a + b;
b = a - b;
a = a - b;
}
parent[b] = a;
sz[a] += sz[b];
}
}
int main() {
int n;
cin >> n;
int parent[n + 1], sz[n + 1];
for (int i = 1; i <= n; i++) make_set(i, parent, sz);
vector<pair<int, int> > edge;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
union_set(u, v, parent, sz);
edge.push_back(make_pair(u, v));
}
set<int> s;
for (int i = 1; i <= n; i++) s.insert(find_set(i, parent));
int cnt = s.size();
if (cnt == 1) {
cout << 0;
return 0;
}
cout << cnt - 1 << endl;
vector<pair<int, int> > form;
for (int i = 2; i <= n; i++) {
int u = find_set(i, parent), v = find_set(i - 1, parent);
if (u != v) {
edge.push_back(make_pair(u, v));
form.push_back(make_pair(u, v));
union_set(i, i - 1, parent, sz);
}
}
for (int i = 1; i <= n; i++) make_set(i, parent, sz);
int k = 0;
for (int i = 0; i < edge.size(); i++) {
int u = edge[i].first, v = edge[i].second;
if (find_set(u, parent) != find_set(v, parent))
union_set(u, v, parent, sz);
else {
cout << u << " " << v << " " << form[k].first << " " << form[k].second
<< endl;
k++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long md = 1000000007;
long long bexp(long long a, long long b) {
if (b == 0) return 1;
if (b == 1) return a;
long long r = bexp(a, b / 2);
r = r * r;
if (b % 2 == 0)
return r;
else
return r * a;
}
long long n, e, m;
vector<long long> ed[2005];
long long par[10005];
long long fd(long long x) {
if (par[x] < 0) return x;
return par[x] = fd(par[x]);
}
void un(long long a, long long b) {
if (abs(par[a]) >= abs(par[b])) {
par[a] += par[b];
par[b] = a;
} else {
par[b] += par[a];
par[a] = b;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int test_case = 1;
while (test_case--) {
long long i, j, ans = 0, k = 0;
memset(par, -1, sizeof(par));
long long l = 0, r = 0, x = 0, y = 0;
cin >> n;
vector<pair<long long, long long>> v1;
for (i = 1; i < n; i++) {
cin >> l >> r;
ed[l].push_back(r);
ed[r].push_back(l);
x = fd(l);
y = fd(r);
if (x != y) {
un(x, y);
} else {
v1.push_back({l, r});
}
}
vector<long long> v;
long long cnt = 0;
for (i = 1; i <= n; i++) {
if (par[i] < 0) {
v.push_back(i);
cnt++;
}
}
cout << cnt - 1 << "\n";
i = 0;
for (j = i + 1; j < cnt; j++) {
cout << v1[j - 1].first << " " << v1[j - 1].second << " " << v[i] << " "
<< v[j] << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[1005], par[1005];
vector<pair<int, int> > v;
vector<int> v1;
void init() {
for (int i = 0; i <= n; ++i) par[i] = i;
}
int parent(int x) {
if (par[x] == x) return x;
return par[x] = parent(par[x]);
}
bool join(int x, int y) {
x = parent(x);
y = parent(y);
if (x == y) return 0;
par[x] = y;
return 1;
}
int main() {
cin >> n;
init();
for (int i = 0; i < n - 1; ++i) {
int x, y;
scanf("%d%d", &x, &y);
if (!join(x, y)) {
v.push_back({x, y});
}
}
for (int i = 1; i <= n; ++i) {
if (par[i] == i) {
v1.push_back(i);
}
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); ++i) {
printf("%d %d %d %d\n", v[i].first, v[i].second, v1[i], v1[i + 1]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int tree[N], y[N];
int Find(int k) {
int k1 = k, k2;
while (k != tree[k]) k = tree[k];
while (k1 != k) {
k2 = tree[k1];
tree[k1] = k;
k1 = k2;
}
return k;
}
struct node {
int x, y;
} x[N];
int main() {
int n, i, a, b, A, B, o = 0, w = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) tree[i] = i;
for (i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
A = Find(a);
B = Find(b);
if (A != B)
tree[A] = B;
else {
x[++o].x = a;
x[o].y = b;
}
}
for (i = 1; i <= n; i++)
if (tree[i] == i) y[++w] = i;
printf("%d\n", w - 1);
for (i = 2; i <= w; i++)
printf("%d %d %d %d\n", x[i - 1].x, x[i - 1].y, y[1], y[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int par[100005], rank_[100005], size_[100005];
int find_set(int a) {
if (par[a] == a) return a;
par[a] = find_set(par[a]);
return par[a];
}
void make_set(int n) {
par[n] = n;
size_[n] = 1;
}
void union_set(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (size_[a] < size_[b]) {
swap(a, b);
}
par[b] = a;
size_[a] += size_[b];
}
}
int main() {
int tc;
int n, t1, t2;
map<int, vector<int>> mp;
cin >> n;
for (int i = 1; i <= n; i++) {
make_set(i);
}
vector<pair<int, int>> vec;
for (int i = 0; i < n - 1; i++) {
cin >> t1 >> t2;
if (find_set(t1) == find_set(t2))
vec.push_back({t1, t2});
else {
union_set(t1, t2);
}
}
for (int i = 1; i <= n; i++) {
mp[find_set(i)].push_back(i);
}
vector<int> rep;
for (auto it : mp) {
rep.push_back(it.first);
}
cout << vec.size() << endl;
for (int i = 0; i < vec.size(); i++) {
cout << vec[i].first << " " << vec[i].second << " " << rep[i] << " "
<< rep[i + 1] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int p[N];
bool f[N];
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
void init() {
for (int i = 0; i < N; i++) p[i] = i;
}
vector<int> v;
vector<pair<int, int> > s;
int main(void) {
int n;
cin >> n;
init();
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
if (find(a) == find(b))
s.push_back({a, b});
else
p[find(a)] = find(b);
}
for (int i = 1; i <= n; i++) {
if (f[find(i)] == 0) {
f[find(i)] = 1;
v.push_back(find(i));
}
}
cout << s.size() << endl;
for (int i = 0; i < s.size(); i++) {
cout << s[i].first << " " << s[i].second << " " << v[i] << " " << v[i + 1]
<< endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void chkmin(T& x, T y) {
if (y < x) x = y;
}
template <class T>
inline void chkmax(T& x, T y) {
if (x < y) x = y;
}
bool vis[1010], c[1010];
int b[1010];
vector<int> adj[1010], id[1010];
pair<int, int> e[1010];
void dfs(int u) {
int i, v;
vis[u] = 1;
for (i = 0; i < adj[u].size(); i++) {
v = adj[u][i];
if (vis[v]) continue;
c[id[u][i]] = 1;
dfs(v);
}
}
int main() {
int n, i, u, v, m = 0;
scanf("%d", &n);
for (i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
id[u].push_back(i);
id[v].push_back(i);
e[i] = pair<int, int>(u, v);
}
for (i = 1; i <= n; i++)
if (vis[i] == 0) {
b[m++] = i;
dfs(i);
}
printf("%d\n", m - 1);
for (i = 1, m = 0; i < n; i++)
if (c[i] == 0)
printf("%d %d %d %d\n", e[i].first, e[i].second, b[m], b[m++]);
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int &a) {
a = 0;
char c = getchar();
while (c < '0' || c > '9') {
c = getchar();
}
while (c >= '0' && c <= '9') {
a = (a << 1) + (a << 3) + c - '0';
c = getchar();
}
}
int Set(int n, int pos) { return n = n | (1LL << pos); }
int reset(int n, int pos) { return n = n & ~(1LL << pos); }
bool check(int n, int pos) { return (bool)(n & (1LL << pos)); }
int mul(int a, int b) {
int c;
c = (a % 1000000007 * b % 1000000007) % 1000000007;
return c;
}
int add(int a, int b) {
int c;
c = (a % 1000000007 + b % 1000000007) % 1000000007;
return c;
}
int sub(int a, int b) {
int c;
c = ((a % 1000000007 - b % 1000000007) % 1000000007 + 1000000007) %
1000000007;
return c;
}
int power(int x, int y) {
int res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long exgcd(long long x, long long y, long long &a, long long &b) {
int flag = 0;
long long t, la = 1, lb = 0, ra = 0, rb = 1;
while (x % y) {
if (flag == 0)
la -= x / y * ra, lb -= x / y * rb;
else
ra -= x / y * la, rb -= x / y * lb;
t = x, x = y, y = t % y;
flag = 1 - flag;
}
if (flag == 0)
a = ra, b = rb;
else
a = la, b = lb;
return y;
}
int n;
vector<pair<int, int> > edges;
int par[1100];
int find_par(int u) {
if (par[u] == u)
return u;
else
return par[u] = find_par(par[u]);
}
vector<int> pare;
int main() {
read(n);
for (int i = 1; i <= n; i++) par[i] = i;
for (int i = 1; i < n; i++) {
int u, v;
read(u);
read(v);
int first = find_par(u);
int second = find_par(v);
if (first == second)
edges.push_back(pair<int, int>(u, v));
else
par[first] = second;
}
for (int i = 1; i <= n; i++) {
if (par[i] == i) pare.push_back(i);
}
if (pare.size() == 1)
printf("0\n");
else {
printf("%d\n", edges.size());
for (int i = 0, j = 1; i < edges.size() && j < pare.size(); i++, j++) {
printf("%d %d %d %d\n", edges[i].first, edges[i].second, pare[0],
pare[j]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int v[1000];
int parent[1000];
int r[1000];
void make_set(int v) {
parent[v] = v;
r[v] = 0;
}
int find_set(int v) {
if (parent[v] == v) {
return v;
}
return parent[v] = find_set(parent[v]);
}
void make_pair(int a, int b) {
int pa = find_set(a);
int pb = find_set(b);
if (r[pa] < r[pb]) {
swap(pa, pb);
}
parent[pb] = pa;
r[pa] = r[pa] + r[pb];
}
int main() {
int t;
cin >> t;
int k = t;
for (int i = 0; i < t; i++) {
make_set(i);
}
int y[t], z[t];
int counter = 0;
t--;
while (t--) {
int a, b;
cin >> a >> b;
if (find_set(a - 1) != find_set(b - 1)) {
make_pair(a - 1, b - 1);
} else {
y[counter] = a;
z[counter] = b;
counter++;
}
}
counter--;
if (counter == -1) {
cout << 0;
return 0;
}
cout << counter + 1 << endl;
for (int i = 1; i < k; i++) {
if (find_set(i) != find_set(0)) {
cout << y[counter] << " " << z[counter] << " " << i + 1 << " " << 1
<< endl;
counter--;
make_pair(i, 0);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int b[1003];
int a[1004], size[1003];
int root(long i) {
while (a[i] != i) i = a[a[i]];
return i;
}
void join(long i, long j) {
i = root(i);
j = root(j);
if (size[i] > size[j]) {
a[j] = i;
size[i] += size[j];
} else {
a[i] = j;
size[j] += size[i];
}
}
int v[1003];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long n;
cin >> n;
long x, y;
queue<pair<long, long> > q;
for (int i = 1; i <= n; i++) {
a[i] = i;
size[i] = 1;
}
for (long i = 1; i < n; i++) {
cin >> x >> y;
if (root(x) != root(y)) {
join(x, y);
} else
q.push(make_pair(x, y));
}
int w = 0;
for (int i = 1; i <= n; i++) {
int h = root(i);
if (v[h] == 0) {
v[h] = 1;
w++;
b[w] = h;
}
}
cout << q.size() << endl;
int i = 1;
while (!q.empty()) {
long h = q.front().first;
long p = q.front().second;
q.pop();
cout << h << " " << p << " " << b[i] << " " << b[i + 1] << endl;
i++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> removed;
vector<pair<int, int>> added;
vector<int> parent;
vector<int> sizes;
int find_set(int a) {
while (a != parent[a]) {
a = parent[a];
}
return a;
}
void union_set(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a == b) {
return;
}
if (sizes[a] > sizes[b]) {
parent[b] = a;
sizes[a] += sizes[b];
} else {
parent[a] = b;
sizes[b] += sizes[a];
}
}
int main() {
int n, i, j, a, b;
cin >> n;
sizes.resize(n + 1);
parent.resize(n + 1);
for (i = 1; i <= n; i++) {
parent[i] = i;
sizes[i] = 1;
}
for (i = 0; i < n - 1; i++) {
cin >> a >> b;
if (find_set(a) == find_set(b)) {
removed.push_back(make_pair(a, b));
} else {
union_set(a, b);
}
}
for (i = 2; i <= n; i++) {
if (find_set(i) != find_set(1)) {
union_set(1, i);
added.push_back(make_pair(i, 1));
}
}
cout << added.size() << endl;
for (i = 0; i < added.size(); i++) {
cout << removed[i].first << " " << removed[i].second << " "
<< added[i].first << " " << added[i].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int par[1001];
int n;
int find(int v) {
if (par[v] == v) return v;
return par[v] = find(par[v]);
}
int main() {
int p1, p2, a, b;
cin >> n;
for (int i = 1; i <= n; i++) par[i] = i;
vector<pair<int, int> > rem;
for (int i = 1; i <= n - 1; i++) {
cin >> a >> b;
p1 = find(a);
p2 = find(b);
if (p1 != p2)
par[p2] = p1;
else
rem.push_back(make_pair(a, b));
}
int prev = -1, k = 0;
cout << rem.size() << "\n";
for (int i = 1; i <= n; i++) {
if (par[i] == i) {
if (prev != -1) {
cout << rem[k].first << " " << rem[k].second << " " << prev << " " << i
<< "\n";
k++;
}
prev = i;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream fin("roads.in");
ofstream fout("roads.out");
typedef struct muchie {
int a;
int b;
} muchie;
int parent[10009];
int rankS[10009];
int findS(int a) {
if (parent[a] == a) {
return a;
}
parent[a] = findS(parent[a]);
return parent[a];
}
void unionS(int a, int b) {
int n1 = findS(a);
int n2 = findS(b);
if (n1 == n2) {
return;
}
rankS[n1] > rankS[n2] ? parent[n2] = n1 : parent[n1] = n2;
if (rankS[n1] == rankS[n2]) {
rankS[n2]++;
}
}
void solve(int n, vector<muchie> muchii) {
vector<muchie> toClose;
vector<muchie> toOpen;
for (int i = 1; i <= n; i++) {
parent[i] = i;
}
for (auto muchie : muchii) {
if (findS(muchie.a) != findS(muchie.b)) {
unionS(muchie.a, muchie.b);
} else {
toClose.push_back(muchie);
}
}
for (int i = 2; i <= n; i++) {
if (findS(1) != findS(i)) {
unionS(1, i);
toOpen.push_back(muchie{1, i});
}
}
cout << toClose.size() << "\n";
for (int i = 0; i < toClose.size(); i++) {
cout << toClose[i].a << " " << toClose[i].b << " " << toOpen[i].a << " "
<< toOpen[i].b << "\n";
}
}
int main() {
int n, a, b;
cin >> n;
vector<muchie> muchii;
for (int i = 1; i < n; i++) {
cin >> a >> b;
muchii.push_back(muchie{a, b});
}
solve(n, muchii);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[1000 + 3], b[1000 + 3];
vector<pair<int, int> > answer1, answer2;
int parent[1000 + 3];
int findSet(int u) {
return (u == parent[u] ? u : parent[u] = findSet(parent[u]));
}
bool isSameSet(int u, int v) { return findSet(u) == findSet(v); }
void joinSet(int u, int v) { parent[findSet(u)] = findSet(v); }
int main() {
cin >> n;
for (int i = 1; i < n; i++) cin >> a[i] >> b[i];
while (true) {
for (int i = 1; i <= n; i++) parent[i] = i;
int edgeIdxToReplace = -1;
for (int i = 1; i < n; i++) {
if (isSameSet(a[i], b[i]))
edgeIdxToReplace = i;
else
joinSet(a[i], b[i]);
}
if (edgeIdxToReplace == -1) break;
for (int i = 1; i <= n; i++) {
if (!isSameSet(1, i)) {
int u = findSet(1);
int v = findSet(i);
answer1.push_back({a[edgeIdxToReplace], b[edgeIdxToReplace]});
answer2.push_back({u, v});
a[edgeIdxToReplace] = u;
b[edgeIdxToReplace] = v;
break;
}
}
}
cout << (int)answer1.size() << endl;
for (int i = 0; i < (int)answer1.size(); i++) {
cout << answer1[i].first << " " << answer1[i].second << " "
<< answer2[i].first << " " << answer2[i].second << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int M = 1000000007;
long long int min(long long int a, long long int b, long long int c,
long long int d) {
long long int arr[4] = {a, b, c, d};
sort(arr, arr + 4);
return arr[0];
}
long long int max(long long int a, long long int b, long long int c,
long long int d) {
long long int arr[4] = {a, b, c, d};
sort(arr, arr + 4);
return arr[3];
}
long long int gcd(long long int a, long long int b) {
if (b < a) {
int temp = a;
a = b;
b = temp;
}
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
long long int lcm(long long int a, long long int b) {
return (a * b / gcd(a, b));
}
vector<long long int> getprimes() {
vector<long long int> pl(101, 1);
for (int i = 2; i <= 100; i++) {
if (pl[i] == 1) {
for (int j = 2 * i; j <= 100; j += i) {
pl[j] = 0;
}
}
}
return pl;
}
double distsqrd(double x1, double y1, double x2, double y2) {
return (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
}
long long int fact(long long int first) {
long long int ans = 1;
if (first == 0) {
return 1;
}
while (first > 0) {
ans = (ans * first) % 1000000007;
first--;
}
return ans % 1000000007;
}
long long int power(long long int a, long long int b) {
long long int ans = 1;
while (b > 0) {
if (b % 2 == 1) {
ans *= a;
ans = ans;
}
b /= 2;
a *= a;
a = a;
}
return ans;
}
vector<int> getbinary(int first) {
vector<int> bin(16, 0);
int iter = 0;
while (first > 0) {
if (first % 2 == 1) {
bin[iter] = 1;
} else {
bin[iter] = 0;
}
iter++;
first /= 2;
}
return bin;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
map<int, vector<int> > g;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
vector<int> col(n + 1, 0);
int parent[n + 1];
vector<int> scc;
vector<pair<int, int> > nreq;
stack<int> s;
map<pair<int, int>, int> m1;
for (int i = 1; i <= n; i++) {
if (col[i] == 0) {
parent[i] = -1;
col[i] = 1;
scc.push_back(i);
s.push(i);
while (!s.empty()) {
int u = s.top();
s.pop();
for (auto v : g[u]) {
if (col[v] == 1) {
if (v != parent[u] && u != parent[v] && m1[make_pair(u, v)] == 0) {
nreq.push_back(make_pair(u, v));
m1[make_pair(u, v)] = 1;
m1[make_pair(v, u)] = 1;
}
} else {
parent[v] = u;
col[v] = 1;
s.push(v);
}
}
}
}
}
n = scc.size();
cout << n - 1 << endl;
for (int i = 0; i < n - 1; i++) {
cout << nreq[i].first << " " << nreq[i].second << " " << scc[i] << " "
<< scc[i + 1] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[2000];
int vis[2000];
vector<pair<int, int> > cyc;
void dfs(int x, int scc) {
if (vis[x] > 0) {
return;
}
vis[x] = 1;
int j;
for (int i = 0; i < g[x].size(); i++) {
for (j = 0; j < g[g[x][i]].size(); j++) {
if (g[g[x][i]][j] == x) {
g[g[x][i]].erase(g[g[x][i]].begin() + j);
}
}
if (vis[g[x][i]] > 0) {
cyc.push_back(make_pair(x, g[x][i]));
}
dfs(g[x][i], scc);
}
return;
}
int main() {
int n, i, j, x, y, t, u;
cin >> n;
for (i = 0; i < n - 1; i++) {
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
memset(vis, 0, sizeof(vis));
int scc = 0, days = 0;
cyc.clear();
vector<int> store;
store.clear();
for (i = 0; i < n; i++) {
if (vis[i] == 0) {
scc++;
store.push_back(i);
dfs(i, scc);
}
}
if (scc == 1) {
cout << "0\n";
return 0;
}
j = 1;
vector<pair<pair<int, int>, pair<int, int> > > v;
v.clear();
for (i = 0; i < cyc.size(); i++) {
v.push_back(make_pair(make_pair(cyc[i].first + 1, cyc[i].second + 1),
make_pair(store[j - 1] + 1, store[j] + 1)));
j++;
}
cout << v.size() << "\n";
for (i = 0; i < v.size(); i++) {
cout << v[i].first.first << " " << v[i].first.second << " "
<< v[i].second.first << " " << v[i].second.second << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void make_set(int v, int parent[], int r[]) {
parent[v] = v;
r[v] = 0;
}
int find_set(int v, int parent[]) {
if (parent[v] == v) {
return v;
}
return parent[v] = find_set(parent[v], parent);
}
void make_pair(int a, int b, int parent[], int r[]) {
int pa = find_set(a, parent);
int pb = find_set(b, parent);
if (r[pa] < r[pb]) {
swap(pa, pb);
}
parent[pb] = pa;
r[pa] = r[pa] + r[pb];
}
int main() {
int t;
cin >> t;
int parent[t];
int r[t];
int k = t;
for (int i = 0; i < t; i++) {
make_set(i, parent, r);
}
vector<int> y, z;
t--;
while (t--) {
int a, b;
cin >> a >> b;
if (find_set(a - 1, parent) != find_set(b - 1, parent)) {
make_pair(a - 1, b - 1, parent, r);
} else {
y.push_back(a);
z.push_back(b);
}
}
if (y.size() == 0) {
cout << 0;
return 0;
}
int counter = 0;
cout << y.size() << endl;
for (int i = 1; i < k; i++) {
if (find_set(i, parent) != find_set(0, parent)) {
cout << y[counter] << " " << z[counter] << " " << i + 1 << " " << 1
<< endl;
counter++;
make_pair(i, 0, parent, r);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> id;
vector<long long> used;
vector<pair<long long, pair<long long, long long> > > v;
vector<pair<long long, long long> > removed;
vector<pair<long long, long long> > added;
void initialize(long long n) {
id.resize(n + 1);
for (long long i = 0; i <= n; ++i) id[i] = i;
}
long long root(long long x) {
if (x == id[x]) {
return x;
}
return (id[x] = root(id[x]));
}
void union1(long long x, long long y) { id[root(x)] = id[root(y)]; }
long long kruskal() {
long long x, y;
long long edges = v.size();
long long cost, minimumCost = 0;
for (long long i = 0; i < edges; ++i) {
x = v[i].second.first;
y = v[i].second.second;
cost = v[i].first;
if (root(x) != root(y)) {
if (cost) added.push_back(make_pair(x, y));
union1(x, y);
} else {
if (!cost) removed.push_back(make_pair(x, y)), minimumCost++;
}
}
return minimumCost;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
long long n, m, t, k, r, i, j, temp, temp1, temp2, temp3, x, x1, x2, x3, y,
weight;
string str;
cin >> n;
initialize(n);
for (i = 1; i < n; i++) {
cin >> x1 >> x2;
v.push_back(make_pair(0, make_pair(x1, x2)));
}
for (i = 1; i <= n; i++) {
for (j = i + 1; j <= n; j++) {
v.push_back(make_pair(1, make_pair(i, j)));
}
}
sort(v.begin(), v.end());
cout << kruskal() << endl;
for (i = 0; i < removed.size(); i++) {
cout << removed[i].first << " " << removed[i].second << " "
<< added[i].first << " " << added[i].second << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
vector<int> graph[N], p;
vector<pair<int, int> > not_tree_edge;
int n;
bool was[N], fordel[N][N];
void dfs(int v) {
was[v] = 1;
for (int i = 0; i < (int)(graph[v]).size(); i++) {
int to = graph[v][i];
if (!was[to]) {
fordel[v][to] = fordel[to][v] = false;
dfs(to);
}
}
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
graph[u].push_back(v);
graph[v].push_back(u);
fordel[u][v] = fordel[v][u] = true;
}
for (int i = 1; i <= n; i++) {
if (!was[i]) {
p.push_back(i);
dfs(i);
}
}
for (int i = 1; i <= n; i++)
for (int j = 0; j < (int)(graph[i]).size(); j++) {
int to = graph[i][j];
if (i < to)
if (fordel[i][to]) not_tree_edge.push_back(make_pair(i, to));
}
cout << (int)(p).size() - 1 << endl;
for (int i = 1; i < (int)(p).size(); i++)
cout << not_tree_edge[i - 1].first << " " << not_tree_edge[i - 1].second
<< " " << p[0] << " " << p[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int visit[1001];
int setnum(int n) {
if (visit[n] == n or visit[n] == -1) return visit[n];
visit[n] = setnum(visit[n]);
return visit[n];
}
void join(int u, int v) {
int t1 = setnum(u), t2 = setnum(v);
if (t2 != -1)
visit[t2] = t1;
else {
visit[v] = t1;
}
}
int same(int u, int v) {
int t1 = setnum(u), t2 = setnum(v);
return (t1 == t2);
}
int main() {
ios::sync_with_stdio(false);
int n, u, v, ans = 0;
vector<pair<int, int> > graph;
vector<int> not_required;
vector<pair<int, int> > changes;
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> u >> v;
graph.push_back(make_pair(u, v));
}
for (int i = 0; i <= n; i++) visit[i] = -1;
for (int i = 0; i < graph.size(); i++) {
u = graph[i].first, v = graph[i].second;
if (setnum(u) == setnum(v) and setnum(u) != -1) {
not_required.push_back(i);
join(u, v);
} else if (visit[u] != -1) {
join(u, v);
} else if (visit[v] != -1) {
join(v, u);
} else {
visit[u] = visit[v] = u;
}
}
ans = not_required.size();
for (int j = 0; j < not_required.size(); j++) {
int t1 = graph[not_required[j]].first;
for (int i = 1; i <= n; i++) {
if (visit[i] == -1 or !same(t1, i)) {
join(t1, i);
changes.push_back(make_pair(t1, i));
break;
}
}
}
cout << ans << "\n";
for (int i = 0; i < ans; i++) {
cout << graph[not_required[i]].first << " " << graph[not_required[i]].second
<< " " << changes[i].first << " " << changes[i].second << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
int f[N];
struct node {
int s, e;
} a[N], c[N];
void init() {
for (int i = 0; i < N; i++) f[i] = i;
}
int findd(int x) {
if (x != f[x]) f[x] = findd(f[x]);
return f[x];
}
int h[N];
int main() {
int n;
int x, y, z, b;
int l, r;
while (cin >> n) {
init();
l = r = 0;
for (int i = 0; i < n - 1; i++) {
cin >> a[i].s >> a[i].e;
x = findd(a[i].s);
y = findd(a[i].e);
if (x == y) {
c[l].s = a[i].s;
c[l++].e = a[i].e;
} else
f[x] = y;
}
for (int i = 1; i <= n; i++)
if (i == f[i]) h[r++] = i;
cout << r - 1 << endl;
if (r > 1)
for (int i = 0; i < r - 1; i++)
cout << c[i].s << " " << c[i].e << " " << h[r - 1] << " " << h[i]
<< endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[1005];
vector<int> comp[1005];
vector<pair<int, int>> destroy;
bool visited[1005];
bool visited2[1005];
int parent[1005];
bool a[1005][1005];
void dfs(int v) {
visited2[v] = true;
for (int i = 0; i < g[v].size(); i++) {
int temp = g[v][i];
if (parent[v] != temp) {
if (!visited2[temp] && a[v][temp]) {
parent[temp] = v;
dfs(temp);
} else {
if (a[v][temp]) {
destroy.push_back(make_pair(v, temp));
a[v][temp] = false;
a[temp][v] = false;
}
}
}
}
}
int main() {
int n;
scanf("%d", &n);
int u, v;
int cnt = 0;
for (int i = 0; i < n - 1; i++) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
a[v][u] = true;
a[u][v] = true;
}
queue<int> q;
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
visited[i] = true;
q.push(i);
comp[cnt].push_back(i);
while (!q.empty()) {
v = q.front();
q.pop();
for (int j = 0; j < g[v].size(); j++) {
int temp = g[v][j];
if (!visited[temp]) {
visited[temp] = true;
q.push(temp);
comp[cnt].push_back(temp);
}
}
}
cnt++;
}
}
int ans = cnt - 1;
bool good = true;
int num = ans;
for (int i = 1; i <= n; i++) {
if (!visited2[i]) {
dfs(i);
}
}
printf("%d\n", ans);
for (int i = 0; i < ans; i++) {
printf("%d %d ", destroy[i].first, destroy[i].second);
printf("%d %d\n", comp[i][0], comp[i + 1][0]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int road[1010], pairs[1010][2];
int main() {
int N, x, y, keep = 0;
cin >> N;
for (int i = 1; i <= N; i++) road[i] = i;
for (int i = 1; i < N; i++) {
cin >> x >> y;
if (road[x] == road[y]) {
pairs[keep][0] = x;
pairs[keep][1] = y;
keep++;
} else {
int temp = road[y];
for (int j = 1; j <= N; j++) {
if (road[j] == temp) road[j] = road[x];
}
}
}
cout << keep << "\n";
for (int i = 0; i < keep; i++) {
int temp = 0;
cout << pairs[i][0] << " " << pairs[i][1] << " " << road[1] << " ";
for (int j = 1; j <= N; j++) {
if (road[j] != road[1]) {
cout << road[j] << "\n";
temp = road[j];
break;
}
}
for (int j = 1; j <= N; j++) {
if (road[j] == temp) road[j] = road[1];
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
vector<pair<int, int>> rem;
vector<int> vis(1005), comp(1005);
void dfs(int s, int p, vector<int> adj[]) {
vis[s] = 1;
for (int i = 0; i < adj[s].size(); i++) {
if (adj[s][i] != p) {
if (vis[adj[s][i]] == 0) {
dfs(adj[s][i], s, adj);
} else if (vis[adj[s][i]] == 1) {
rem.push_back({s, adj[s][i]});
}
}
}
vis[s] = 2;
}
int main() {
int n;
cin >> n;
vector<int> adj[n + 1];
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
int num = 0;
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
comp[num++] = i;
dfs(i, 0, adj);
}
}
cout << num - 1 << endl;
for (int i = 0; i < num - 1; i++) {
cout << rem[i].first << " " << rem[i].second << " " << comp[i] << " "
<< comp[i + 1] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int parent[3001];
int ranke[3001];
int cycle[3001];
vector<int> lol;
vector<pair<int, int> > bad;
vector<vector<int> > spisok;
set<int> komponents;
void make_new(int v) {
parent[v] = v;
ranke[v] = 0;
}
int find_set(int v) {
if (parent[v] == v)
return v;
else {
return parent[v] = find_set(parent[v]);
}
}
void set_union(int a, int b) {
pair<int, int> c = make_pair(a, b);
a = find_set(a);
b = find_set(b);
if (a == b) bad.push_back(c);
if (a != b) {
if (ranke[a] < ranke[b]) swap(a, b);
parent[a] = b;
komponents.erase(a);
if (ranke[a] == ranke[b]) ranke[b]++;
}
}
int main() {
memset(cycle, 0, sizeof(cycle));
int n, i, j;
cin >> n;
spisok.resize(n + 1, lol);
for (i = 0; i < n; i++) {
komponents.insert(i + 1);
make_new(i + 1);
}
for (i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
set_union(a, b);
spisok[a].push_back(b);
spisok[b].push_back(a);
}
int tre;
set<int>::iterator it, it2;
it = komponents.begin();
it2 = it;
j = 0;
cout << komponents.size() - 1 << endl;
for (i = 0; i < komponents.size() - 1; i++) {
it2++;
cout << bad[j].first << " " << bad[j].second << " " << *it << " " << *it2;
cout << endl;
j++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
const int N = 500001;
int sz[N], p[N];
vector<int> cycles;
void initialize() {
iota(p, p + N, 0);
fill(sz, sz + N, 1);
}
int FindParent(int u) { return p[u] = (p[u] == u ? u : FindParent(p[u])); }
void Union(int u, int v) {
u = FindParent(u);
v = FindParent(v);
if (u == v) return;
if (sz[v] < sz[u]) swap(u, v);
p[u] = v;
sz[v] += sz[u];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
initialize();
int n;
cin >> n;
int t = 0;
for (int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b;
if (FindParent(a) != FindParent(b))
Union(a, b);
else
cycles.push_back(a), cycles.push_back(b);
}
set<int> a;
for (int i = 1; i <= n; ++i) {
a.insert(FindParent(i));
}
cout << a.size() - 1 << '\n';
int z = 0;
vector<int> b;
for (auto l : a) b.push_back(l);
for (int i = 0; i < b.size() - 1; ++i) {
cout << cycles[z] << " " << cycles[z + 1] << " " << b[i] << " " << b[i + 1]
<< '\n';
z += 2;
}
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int maxn = 1005, inf = 0x3f3f3f3f;
int f[maxn], n, m, vis[maxn], ans;
vector<int> e[maxn];
set<pair<int, int>> st;
struct w {
int a, b, c, d;
} q[maxn];
int find(int x) {
if (f[x] == x)
return x;
else
return f[x] = find(f[x]);
}
inline void hb(int x, int y) {
int fx = find(x);
int fy = find(y);
f[fx] = fy;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
f[i] = i;
}
for (int i = 1; i <= n - 1; i++) {
int u, v;
cin >> u >> v;
if (find(u) != find(v))
hb(u, v);
else
st.insert({u, v});
}
for (auto x : st) {
int fa = find(x.first);
for (int i = 1; i <= n; i++) {
if (find(i) == fa) continue;
q[++ans] = ((w){x.first, x.second, x.first, i});
hb(x.first, i);
break;
}
}
cout << ans << endl;
for (int i = 1; i <= ans; i++) {
printf("%d %d %d %d\n", q[i].a, q[i].b, q[i].c, q[i].d);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int par[N];
bool mark[N], mark2[N];
vector<int> u[N];
vector<pair<int, int> > v[N], ans, ans2;
pair<int, int> yal[N];
void dfs(int y, int r) {
mark[y] = true;
par[y] = r;
for (int i = 0; i < v[y].size(); i++) {
if (!mark[v[y][i].first]) {
u[y].push_back(v[y][i].first);
u[v[y][i].first].push_back(y);
mark2[v[y][i].second] = true;
dfs(v[y][i].first, r);
}
}
}
int root(int u) { return (par[u] == u) ? u : par[u] = root(par[u]); }
void mrg(int x, int y) {
int dx = root(x), dy = root(y);
if (dx == dy) return;
par[dx] = dy;
}
int main() {
int n, m;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
v[a].push_back({b, i});
v[b].push_back({a, i});
yal[i] = {a, b};
}
for (int i = 0; i < n; i++) {
if (mark[i] == false) {
dfs(i, i);
}
}
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
if (root(i) != root(j)) {
u[i].push_back(j);
u[j].push_back(i);
ans.push_back({i, j});
mrg(i, j);
}
}
}
for (int i = 0; i < n; i++) {
if (mark2[i] == false) ans2.push_back(yal[i]);
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans2[i].first + 1 << " " << ans2[i].second + 1 << " ";
cout << ans[i].first + 1 << " " << ans[i].second + 1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, parent[1009], x, y, kkomp;
vector<pair<int, int> > forDel;
set<int> komp;
int find_set(int v) {
if (parent[v] == v) return v;
return parent[v] = find_set(parent[v]);
}
void union_set(int v, int u) {
u = find_set(u);
v = find_set(v);
if (rand() % 2 == 0)
parent[v] = u;
else
parent[u] = v;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) parent[i] = i;
for (int i = 1; i < n; i++) {
cin >> x >> y;
if (find_set(x) == find_set(y))
forDel.push_back(make_pair(x, y));
else
union_set(x, y);
}
for (int i = 1; i <= n; i++) komp.insert(find_set(i));
cout << komp.size() - 1 << endl;
kkomp = komp.size();
if (komp.size() == 1) return 0;
for (int i = 0; i < forDel.size(); i++) {
if (komp.size() == 0) break;
cout << forDel[i].first << ' ' << forDel[i].second << ' ' << *komp.begin()
<< ' ';
komp.erase(*komp.begin());
cout << *komp.begin() << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string alpha = "abcdefghijklmnopqrstuvwxyz";
const long long mod = 1e9 + 7;
const long long inf = 2e18 + 5;
const long long nax = 1010;
vector<unordered_set<long long>> g;
stack<long long> C;
stack<long long> UC;
vector<bool> visited(nax);
void dfs(long long u) {
visited[u] = true;
for (auto v : g[u]) {
if (!visited[v]) {
dfs(v);
}
}
}
bool has_cycle(long long u) {
unordered_set<long long> visited;
visited.insert(u);
unordered_map<long long, long long> parent;
parent[u] = u;
vector<long long> frt = {u};
vector<long long> nxt;
while (!frt.empty()) {
nxt.clear();
for (auto u : frt) {
for (auto v : g[u]) {
if (!visited.count(v)) {
parent[v] = u;
visited.insert(v);
nxt.push_back(v);
} else if (parent[u] == v) {
continue;
} else {
return true;
}
}
}
frt = nxt;
}
return false;
}
pair<long long, long long> get_edge(long long u) {
unordered_set<long long> visited;
visited.insert(u);
unordered_map<long long, long long> parent;
parent[u] = u;
vector<long long> frt = {u};
vector<long long> nxt;
while (!frt.empty()) {
nxt.clear();
for (auto u : frt) {
for (auto v : g[u]) {
if (!visited.count(v)) {
parent[v] = u;
visited.insert(v);
nxt.push_back(v);
} else if (parent[u] == v) {
continue;
} else {
return {v, u};
}
}
}
frt = nxt;
}
assert(false);
return {0, 0};
}
long long cnt;
string res = "";
void unite(long long u, long long v) {
cnt++;
auto p = get_edge(u);
long long a = p.first;
long long b = p.second;
g[b].erase(a);
g[a].erase(b);
g[b].insert(v);
g[v].insert(b);
res += to_string(a) + " " + to_string(b) + " " + to_string(b) + " " +
to_string(v) + '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
g = vector<unordered_set<long long>>(n + 1);
for (long long i = (0); i < (n - 1); i++) {
long long u, v;
cin >> u >> v;
g[u].insert(v);
g[v].insert(u);
}
vector<long long> roots;
for (long long i = (1); i < (n + 1); i++) {
if (!visited[i]) {
roots.push_back(i);
dfs(i);
}
}
for (auto r : roots) {
if (has_cycle(r)) {
C.push(r);
} else {
UC.push(r);
}
}
while (!C.empty()) {
long long u, v;
u = C.top();
C.pop();
v = UC.top();
UC.pop();
unite(u, v);
if (has_cycle(u)) {
C.push(u);
} else {
UC.push(u);
}
}
cout << cnt << '\n';
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
const int INF = 0x3f3f3f3f;
int n;
long long a[N], g[2][N];
int dp[2][N];
inline long long read() {
long long f = 1, x = 0;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return f * x;
}
inline void upd(int& x, int y) { x = min(x, y); }
inline long long f(long long x) {
if (x % 2 == 0) return x / 2;
return x;
}
int main() {
n = read(), a[0] = 1;
for (int i = (n), iend = (1); i >= iend; i--) a[i] = read();
dp[0][0] = 0, g[0][0] = 1;
for (int i = (1), iend = (n); i <= iend; i++) {
for (int j = (0), jend = (i); j <= jend; j++) dp[i & 1][j] = INF;
for (int j = (0), jend = (i - 1); j <= jend; j++) {
int t = i & 1;
if ((2 * a[i]) % g[t ^ 1][j] == 0 &&
(2 * a[i] / g[t ^ 1][j]) % 2 != g[t ^ 1][j] % 2)
upd(dp[t][i], dp[t ^ 1][j]), g[t][i] = a[i];
upd(dp[t][j], dp[t ^ 1][j] + 1), g[t][j] = f(g[t ^ 1][j]);
}
}
int ans = INF;
for (int i = (0), iend = (n); i <= iend; i++) upd(ans, dp[n & 1][i]);
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long rdtsc() {
long long tmp;
asm("rdtsc" : "=A"(tmp));
return tmp;
}
const int maxn = 5000;
long long a[maxn], d[maxn];
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int cntTwo[maxn];
long long without[maxn];
bool ok(int i, int j) {
if (without[i] % without[j]) return 0;
return (cntTwo[i] - cntTwo[j] == i - j) || (cntTwo[j] < (j - i));
}
int main() {
srand(rdtsc());
int n;
while (scanf("%d", &n) >= 1) {
for (int i = 0; i < n; i++) scanf("%lld", &a[i]);
for (int i = 0; i < n; i++) {
int &cnt = cntTwo[i];
cnt = 0;
for (long long x = a[i]; x && !(x & 1); x >>= 1) cnt++;
without[i] = (a[i] >> cnt);
}
d[0] = 0;
long long ans = n - 1;
for (int i = 1; i < n; i++) {
d[i] = i;
for (int j = 0; j < i; j++) {
if (ok(j, i)) d[i] = min(d[i], d[j] + i - j - 1);
}
ans = min(ans, n - i - 1 + d[i]);
}
printf(
"%lld"
"\n",
ans);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
long long p[5005], a[5005], dp[5005];
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
while (a[i] % 2 == 0) {
p[i]++;
a[i] /= 2;
}
}
long long ans = 0;
for (long long i = 1; i <= n; i++) {
dp[i] = 1;
for (long long j = 1; j < i; j++) {
if (a[j] % a[i] == 0 && (p[i] - p[j] == i - j || p[i] < i - j))
dp[i] = max(dp[i], dp[j] + 1);
}
ans = max(ans, dp[i]);
}
cout << n - ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[5005][5005], precal[5005];
long long ara[5005];
int solve(int now, int prv) {
if (now < 0) return 0;
int &ret = dp[now][prv];
if (ret != -1) return ret;
long long prvval = (ara[prv] >> min(prv - now - 1, precal[prv]));
ret = 1 + solve(now - 1, prv);
if (prvval & 1) {
if (ara[now] % prvval == 0) ret = min(ret, solve(now - 1, now));
} else if (ara[now] % prvval == (prvval >> 1))
ret = min(ret, solve(now - 1, now));
return ret;
}
int main() {
int i, n;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%I64d", &ara[i]);
precal[i] = __builtin_ctzll(ara[i]);
}
ara[n] = 1;
precal[n] = 0;
memset(dp, -1, sizeof(dp));
cout << solve(n - 1, n) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[100000];
long long a[100000], n;
int c[100000];
long long z[100000];
long long ci(long long i) {
int u = 0;
while (i % 2 == 0) {
i /= 2;
u++;
}
return u;
}
long long zhi(long long i) {
while (i % 2 == 0) i /= 2;
return i;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
c[i] = ci(a[i]);
z[i] = zhi(a[i]);
}
int ans = 1000000;
for (int i = n - 1; i >= 0; i--) {
dp[i] = n - i - 1;
for (int j = i + 1; j < n; j++)
if (z[i] % z[j] == 0) {
if (c[j] < j - i)
dp[i] = min(dp[j] + (j - i - 1), dp[i]);
else if (c[j] - c[i] == j - i)
dp[i] = min(dp[j] + (j - i - 1), dp[i]);
}
ans = min(dp[i] + i, ans);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<long long> a;
vector<int> cnt(5005);
void Input() {
cin >> n;
a.resize(n + 5);
for (int i = 1; i <= n; i++) {
cin >> a[i];
while (a[i] % 2 == 0) {
a[i] /= 2, cnt[i]++;
}
}
a[n + 1] = 1;
}
bool check(long long a, long long b, int j, int i) {
return a % b == 0 && (cnt[j] + i - j == cnt[i] || cnt[i] <= i - j - 1);
}
void Solve() {
vector<int> dp(n + 5);
dp[1] = 0;
for (int i = 2; i <= n + 1; i++) {
dp[i] = i - 1;
for (int j = i - 1; j >= 1; j--) {
if (check(a[j], a[i], j, i)) dp[i] = min(dp[i], dp[j] + i - j - 1);
}
}
cout << min(dp[n + 1], n - 1);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t = 1;
for (int i = 1; i <= t; i++) {
Input();
Solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long str[5010];
int B[5010], dp[5010];
int n;
bool ok(int j, int i) {
if (str[j] % str[i] != 0) return false;
if (B[i] == 0)
return true;
else {
if (i - j == B[i] - B[j]) return true;
if (B[i] < i - j) return true;
}
return false;
}
int main() {
scanf("%d", &n);
memset(B, 0, sizeof(B));
for (int i = 0; i < n; i++) {
scanf("%I64d", &str[i]);
while (str[i] % 2 == 0) {
B[i]++;
str[i] /= 2;
}
}
str[n] = 1;
dp[0] = 0;
for (int i = 1; i <= n; i++) {
dp[i] = i;
for (int j = 0; j < i; j++)
if (ok(j, i)) dp[i] = min(dp[i], dp[j] + i - j - 1);
}
printf("%d\n", dp[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int n, f[N];
long long a[N], b[N], c[N];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%I64d", a + i);
a[n + 1] = 1;
long long t = a[i];
while (t % 2 == 0) t /= 2, b[i]++;
c[i] = t;
}
for (int i = 1; i <= n + 1; i++) {
f[i] = i - 1;
for (int j = 0; j <= i - 1; j++) {
if (a[j] != 0 && a[i] % a[j] == 0 && i - j <= 50) {
if (a[i] / a[j] == 1LL << (i - j)) {
f[i] = min(f[i], f[j] + i - j - 1);
}
}
if (a[i] % 2 == 0) {
long long l = c[j], r = c[i];
int cl = b[j], cr = b[i];
if (l % r != 0) continue;
if (cr > cl && cr - cl == i - j) {
f[i] = min(f[j] + i - j - 1, f[i]);
}
if (cr - 1 + (cl > 0) <= i - j - 1) {
f[i] = min(f[j] + i - j - 1, f[i]);
}
}
if (a[i] % 2 == 1)
if (a[j] % a[i] == 0) {
f[i] = min(f[j] + i - j - 1, f[i]);
continue;
}
}
}
cout << f[n + 1];
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[5111], y, yy;
int lmax[5111], cnt[5111], llmax;
int N, i, j, k;
int main() {
scanf("%d", &N);
for (i = 1; i <= N; i++) scanf("%I64d", &a[i]);
for (llmax = 0, i = 1; i <= N; i++) {
lmax[i] = 0;
cnt[i] = 0;
y = a[i];
while ((y & 1) == 0) {
y >>= 1;
cnt[i]++;
}
for (j = i - 1; j >= 1; j--) {
k = i - j;
if (k > cnt[i]) {
if (a[j] % y == 0 && lmax[j] > lmax[i]) lmax[i] = lmax[j];
} else {
yy = y << (cnt[i] - k);
if (a[j] % yy == 0 && ((a[j] / yy) & 1 == 1) && lmax[j] > lmax[i])
lmax[i] = lmax[j];
}
}
lmax[i]++;
if (lmax[i] > llmax) llmax = lmax[i];
}
printf("%d\n", N - llmax);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, dp[10001], v[10001];
long long f[10001];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> f[i];
while (f[i] % 2 == 0) f[i] /= 2, v[i]++;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
dp[i] = 1;
for (int j = 1; j < i; j++)
if (f[j] % f[i] == 0 && (v[i] - i == v[j] - j || v[i] <= i - j - 1))
dp[i] = max(dp[i], dp[j] + 1);
ans = max(ans, dp[i]);
}
cout << n - ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5000 + 100;
long long n;
bool mat[maxn][maxn];
long long a[maxn];
int dp[maxn];
bool check(long long x, long long y, long long k) {
long long xp = (x & (-x));
long long yp = (y & (-y));
long long kp = (1ll << min(k, 60ll));
if (yp / kp > 1 && yp / kp != xp * 2) return false;
return (x / xp) % (y / yp) == 0;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j) mat[i][j] = check(a[i], a[j], j - i - 1);
for (int i = 0; i < n; ++i) mat[i][n] = true;
for (int i = 0; i < n - 1; ++i) dp[i] = maxn;
for (int i = n - 2; i >= 0; --i)
for (int j = i + 1; j < n + 1; ++j)
if (mat[i][j]) dp[i] = min(dp[i], dp[j] + j - i - 1);
int ans = maxn;
for (int i = 0; i < n; ++i) ans = min(ans, dp[i] + i);
cout << ans << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.