import
java.io.*;
import
java.util.*;
class
DSU {
Map<Integer, Integer> parent =
new
HashMap<>();
Map<Integer, Integer> rank =
new
HashMap<>();
int
find(
int
x)
{
if
(!parent.containsKey(x)) {
rank.put(x,
1
);
parent.put(x, x);
}
if
(parent.get(x) != x) {
parent.put(x, find(parent.get(x)));
}
return
parent.get(x);
}
boolean
unite(
int
u,
int
v)
{
int
p1 = find(u), p2 = find(v);
if
(p1 != p2) {
if
(rank.get(p1) < rank.get(p2)) {
parent.put(p1, p2);
}
else
if
(rank.get(p1) > rank.get(p2)) {
parent.put(p2, p1);
}
else
{
parent.put(p2, p1);
rank.put(p1, rank.get(p1) +
1
);
}
return
true
;
}
else
{
return
false
;
}
}
}
class
Solution {
int
kruskal(
boolean
include, List<List<Integer> > edges,
int
a,
int
b)
{
DSU obj =
new
DSU();
int
total =
0
;
if
(include) {
for
(List<Integer> edge : edges) {
int
u = edge.get(
0
), v = edge.get(
1
),
wt = edge.get(
2
);
if
((u == a && v == b)
|| (u == b && v == a)) {
boolean
val = obj.unite(a, b);
total += wt;
break
;
}
}
}
for
(List<Integer> edge : edges) {
int
u = edge.get(
0
), v = edge.get(
1
),
wt = edge.get(
2
);
if
(obj.unite(u, v)) {
total += wt;
}
}
return
total;
}
boolean
solve(List<List<Integer> > edges,
int
a,
int
b)
{
Collections.sort(
edges,
new
Comparator<List<Integer> >() {
@Override
public
int
compare(List<Integer> a,
List<Integer> b)
{
return
a.get(
2
) - b.get(
2
);
}
});
int
overall = kruskal(
false
, edges, a, b);
int
inc = kruskal(
true
, edges, a, b);
return
inc == overall;
}
}
class
GFG {
public
static
void
main(String[] args)
{
Solution obj =
new
Solution();
List<List<Integer> > graph = Arrays.asList(
Arrays.asList(
0
,
1
,
20
), Arrays.asList(
0
,
2
,
5
),
Arrays.asList(
0
,
3
,
10
),
Arrays.asList(
2
,
3
,
10
));
int
A =
2
, B =
3
;
boolean
val = obj.solve(graph, A, B);
if
(val) {
System.out.println(
"True"
);
}
else
{
System.out.println(
"False"
);
}
}
}