solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
n,m = [int(x) for x in input().split()]
edge = {}
for i in range (1,n+1):
edge[i] = {}
for j in range (1,m+1):
edge[i][j] = []
for i in range (m):
a,b,c = [int(x) for x in input().split()]
edge[a][c].append(b)
edge[b][c].append(a)
q = int(input())
for i in range (q):
u,v = [int(x) for x in input().split()]
count = 0
for key in edge[u]:
level = {u:0}
frontier = [u]
found = False
while frontier and not found:
next = []
for uu in frontier:
for vv in edge[uu][key]:
if not(vv in level):
if vv == v:
found = True
level[vv] = 0
next.append(vv)
frontier = next
if(found):
count += 1
print (count) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100003;
int n, m;
vector<unordered_set<int> > colores;
vector<unordered_map<int, int> > cual;
map<pair<int, int>, int> queries;
int rep(int v, int col) {
if (cual[col][v] != v) cual[col][v] = rep(cual[col][v], col);
return cual[col][v];
}
void unir(int u, int v, int col) { cual[col][rep(u, col)] = rep(v, col); }
int query(int u, int v) {
if (queries.find({u, v}) != queries.end()) return queries[{u, v}];
int ans = 0;
for (int col : colores[u])
if (colores[v].find(col) != colores[v].end() and
cual[col][u] == cual[col][v])
++ans;
return queries[{u, v}] = ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
colores = vector<unordered_set<int> >(n, unordered_set<int>());
cual = vector<unordered_map<int, int> >(MAXN, unordered_map<int, int>());
vector<pair<int, int> > que;
que.reserve(2 * n);
for (int i = 0; i < m; ++i) {
int u, v, c;
cin >> u >> v >> c;
--u, --v;
que.push_back({u, c});
que.push_back({v, c});
colores[u].insert(c), colores[v].insert(c);
if (cual[c].find(u) == cual[c].end()) cual[c][u] = u;
if (cual[c].find(v) == cual[c].end()) cual[c][v] = v;
unir(u, v, c);
}
for (auto q : que) rep(q.first, q.second);
int q;
cin >> q;
while (q--) {
int u, v;
cin >> u >> v;
--u, --v;
if (colores[u].size() > colores[v].size()) swap(u, v);
cout << query(u, v) << "\n";
}
}
| 8 | CPP |
import sys
from collections import defaultdict
from functools import lru_cache
from collections import Counter
def mi(s):
return map(int, s.strip().split())
def lmi(s):
return list(mi(s))
def mf(f, s):
return map(f, s)
def lmf(f, s):
return list(mf(f, s))
def path(graph, u, v, color, visited):
if u == v:
return True
elif u in visited:
return False
visited.add(u)
for child, c in graph[u]:
if color == c and path(graph, child, v, color, visited):
return True
return False
def main(graph, queries, colors):
ans = []
for u, v in queries:
c = 0
for color in colors:
if path(graph, u, v, color, set()):
c += 1
ans.append(c)
for n in ans:
print(n)
if __name__ == "__main__":
queries = []
colors = set()
for e, line in enumerate(sys.stdin.readlines()):
if e == 0:
n, ed = mi(line)
graph = defaultdict(list)
for i in range(1, n + 1):
graph[i]
k = 0
elif ed > 0:
a, b, c = mi(line)
# Undirected graph.
graph[a].append((b, c))
graph[b].append((a, c))
colors.add(c)
ed -= 1
elif ed == 0:
ed -= 1
continue
else:
queries.append(lmi(line))
main(graph, queries, colors)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int ans;
int n, m, q;
int a, b, c;
struct st {
int P[110];
int sz[110];
void init() {
for (int i = 1; i <= n; i++) P[i] = i, sz[i] = 1;
}
int ata(int x) {
if (x == P[x]) return x;
return P[x] = ata(P[x]);
}
void uni(int x, int y) {
x = ata(x);
y = ata(y);
if (x == y) return;
if (sz[x] < sz[y]) swap(x, y);
sz[x] += sz[y], sz[y] = 0, P[y] = x;
}
} T[110];
int main() {
cin >> n >> m;
for (int i = 1; i <= 100; i++) T[i].init();
for (int i = 1; i <= m; i++) {
cin >> a >> b >> c;
T[c].uni(a, b);
}
cin >> q;
while (q--) {
cin >> a >> b;
int ans = 0;
for (int i = 1; i <= 100; i++) ans += (T[i].ata(a) == T[i].ata(b));
cout << ans << "\n";
}
}
| 8 | CPP |
from collections import defaultdict
def DFS(d,a,visited):
visited[a] = 1
if a in d:
for i in d[a]:
if visited[i] == 1:
continue
else:
DFS(d,i,visited)
n,m = map(int,input().split())
l = [defaultdict(list) for i in range(m+1)]
for i in range(m):
a,b,c = map(int,input().split())
l[c][a].append(b)
l[c][b].append(a)
q = int(input())
for i in range(q):
a,b = map(int,input().split())
r = 0
for j in l:
visited = [0 for i in range(n+1)]
DFS(j,a,visited)
if visited[a] == 1 and visited[b] == 1:
r = r + 1
print(r)
| 8 | PYTHON3 |
def solve():
def dfs(c):
if c == v:
return True
r = False
for i in range(1, n+1):
if g[w][c][i] and i not in p:
p[i] = c
r |= dfs(i)
return r
n, m = map(int, input().split())
g = [[[False for j in range(n+1)] for i in range(n+1)] for _ in range(m+1)]
for _ in range(m):
u, v, w = map(int, input().split())
g[w][u][v] = True
g[w][v][u] = True
for _ in range(int(input())):
u, v = map(int, input().split())
res = 0
for w in range(1, m+1):
p = dict()
p[u] = -1
res += dfs(u)
print(res)
solve()
| 8 | PYTHON3 |
from collections import defaultdict, deque
def bfs(g,s,c):
visited = set()
q = deque([s])
while len(q) > 0:
v = q.pop()
visited.add(v)
for adj,adj_c in g[v]:
if adj_c == c and adj not in visited and adj not in q:
q.append(adj)
return visited
def con_components(g,c):
visited = set()
components = []
for s in g.keys():
if s not in visited:
nodes = bfs(g,s,c)
components.append(nodes)
visited |= nodes
return components
def main():
n,m = map(int, input().split())
g = defaultdict(list)
colors = set()
for _ in range(m):
a,b,c = map(int, input().split())
g[a].append((b,c))
g[b].append((a,c))
colors.add(c)
components = {c:con_components(g,c) for c in colors}
q = int(input())
for _ in range(q):
u,v = map(int, input().split())
ct = 0
for c in colors:
for comp in components[c]:
if u in comp and v in comp:
ct += 1
print(ct)
if __name__ == '__main__':
main() | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int c1, n, m;
bool check[int(10e5)];
vector<pair<long long int, long long int>> v[int(10e5)];
int ans;
void flush() {
ans = 0;
for (int i = 0; i < 101; i++) check[i] = 0;
}
void dfs(long long int start, long long int end, long long int c) {
check[start] = 1;
if (start == end) {
ans = 1;
}
for (auto i : v[start]) {
if (!check[i.first] && c == i.second) dfs(i.first, end, c);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long int a, b, c;
cin >> a >> b >> c;
v[a].push_back({b, c});
v[b].push_back({a, c});
}
long long int q;
cin >> q;
while (q--) {
int x, y, count1 = 0;
cin >> x >> y;
for (int i = 1; i <= m; i++) {
dfs(x, y, i);
if (ans) {
count1++;
}
flush();
}
cout << count1 << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int i, j, k;
void A();
void B();
void C();
void D();
void E();
int main() {
B();
return 0;
}
struct edge {
int to, w;
edge(int to, int w) : to(to), w(w) {}
};
vector<edge> graph[101];
int vst[101];
bool dfs(int node, int dest, int col) {
if (node == dest) return true;
vst[node] = 1;
for (int i = 0; i < (int)graph[node].size(); i++) {
edge to = graph[node][i];
if (!vst[to.to] && col == to.w) {
if (dfs(to.to, dest, col)) return true;
}
}
return false;
}
void B() {
int n, m;
scanf("%d %d", &n, &m);
int a, b, c;
for (i = 0; i <= m - 1; i++) {
scanf("%d %d", &a, &b);
scanf("%d", &c);
graph[a].push_back(edge(b, c));
graph[b].push_back(edge(a, c));
}
int color[m + 1];
int dp[n + 1][n + 1];
memset(dp, -1, sizeof dp);
int q;
scanf("%d", &q);
for (i = 0; i <= q - 1; i++) {
scanf("%d %d", &a, &b);
if (dp[a][b] == -1) {
for (j = 0; j <= m; j++) color[j] = 0;
int ans = 0;
for (j = 0; j <= (int)graph[a].size() - 1; j++) {
if (color[graph[a][j].w] == 0) {
for (k = 0; k <= n; k++) vst[k] = 0;
if (dfs(graph[a][j].to, b, graph[a][j].w)) {
color[graph[a][j].w] = 1;
ans++;
}
}
}
printf("%d\n", ans);
dp[a][b] = dp[b][a] = ans;
} else
printf("%d\n", dp[a][b]);
}
}
| 8 | CPP |
n, m = map(int, input().split())
graphs = [[[] for _ in range(n)] for _ in range(m)]
for _ in range(m):
a, b, c = map(int, input().split())
graphs[c - 1][a - 1].append(b - 1)
graphs[c - 1][b - 1].append(a - 1)
used = None
def dfs(vertex, color):
used[vertex] = True
for nei in graphs[color][vertex]:
if not used[nei]:
dfs(nei, color)
q = int(input())
for _ in range(q):
u, v = map(int, input().split())
c = 0
for _color in range(m):
used = [False] * n
dfs(u - 1, _color)
if used[v - 1]:
c += 1
print(c)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) int idx,
__attribute__((unused)) int LINE_NUM) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int lcm(int a, int b) { return (a * b) / gcd(a, b); }
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, 1, -1, 0, 0, -1, 1};
int dx4[] = {0, 0, 1, -1};
int dy4[] = {1, -1, 0, 0};
const long long MOD = 1000000007;
double sq(double x) { return x * x; }
template <typename T>
inline T Bigmod(T base, T power, T MOD) {
T ret = 1;
while (power) {
if (power & 1) ret = (ret * base) % MOD;
base = (base * base) % MOD;
power >>= 1;
}
return ret;
}
inline void normal(long long &a) {
a %= MOD;
(a < 0) && (a += MOD);
}
inline long long modMul(long long a, long long b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a * b) % MOD;
}
inline long long modAdd(long long a, long long b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a + b) % MOD;
}
inline long long modSub(long long a, long long b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInverse(long long a) { return modPow(a, MOD - 2); }
inline long long modDiv(long long a, long long b) {
return modMul(a, modInverse(b));
}
bool sortinrev(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.first);
}
const int maxn = 104;
vector<int> edj[maxn][maxn];
void solution() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
edj[a][c].push_back(b);
edj[b][c].push_back(a);
}
int q;
cin >> q;
while (q--) {
int a, b;
cin >> a >> b;
int ans = 0;
for (int i = 1; i <= m; i++) {
queue<int> q;
q.push(a);
int vis[maxn];
memset(vis, 0, sizeof(vis));
vis[a] = 1;
bool got = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int j = 0; j < (int)edj[u][i].size(); j++) {
int v = edj[u][i][j];
if (vis[v] == 0) {
if (v == b) {
got = 1;
break;
}
q.push(v);
vis[v] = 1;
}
}
if (got) {
break;
}
}
if (got) ans++;
}
cout << ans << endl;
}
}
signed main() {
ios::sync_with_stdio(false);
int t;
t = 1;
while (t--) {
solution();
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const long long MAX = 101;
const double PI = 3.1415926;
class Disjoint_Sets {
public:
long long* parent;
long long* size;
long long n;
void Initialise() {
parent = new long long[n];
size = new long long[n];
for (int i = 0; i < n; i++) parent[i] = i;
for (int i = 0; i < n; i++) size[i] = 1;
}
void merge(long long a, long long b) {
long long parent_a = find(a);
long long parent_b = find(b);
if (parent_a == parent_b) return;
if (size[parent_a] < size[parent_b]) {
parent[parent_a] = parent_b;
size[parent_b] += size[parent_a];
size[parent_a] = 0;
} else {
parent[parent_b] = parent_a;
size[parent_a] += size[parent_b];
size[parent_b] = 0;
}
}
long long find(long long a) {
if (parent[a] == a) {
return a;
}
parent[a] = find(parent[a]);
return parent[a];
}
};
Disjoint_Sets allColor[MAX];
int N, m;
vector<pair<long long, long long> > adj[MAX];
bool visited[MAX];
void dfs(long long s) {
visited[s] = 1;
for (pair<long long, long long> x : adj[s]) {
allColor[x.second].merge(s, x.first);
if (!visited[x.first]) dfs(x.first);
}
}
void dfsPre() {
for (int i = 0; i < N; ++i)
if (!visited[i]) dfs(i);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> N >> m;
memset(visited, 0, sizeof(visited));
for (int i = 0; i < MAX; ++i) {
allColor[i].n = N;
allColor[i].Initialise();
}
for (int i = 0; i < m; ++i) {
int x, y, c;
cin >> x >> y >> c;
x--;
y--;
c--;
adj[x].push_back(make_pair(y, c));
adj[y].push_back(make_pair(x, c));
}
dfsPre();
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
int x, y;
cin >> x >> y;
x--;
y--;
int counter = 0;
for (int j = 0; j < MAX; ++j)
if (allColor[j].find(x) == allColor[j].find(y)) counter++;
cout << counter << endl;
}
return 0;
}
| 8 | CPP |
from collections import defaultdict
def connectedComponents(root, visited, graph, c, comp):
visited[root] = 1
comp[root] = c
for i in graph[root]:
if visited[i] == 0:
connectedComponents(i, visited, graph, c, comp)
return
n, m = map(int, input().split())
graphs = [defaultdict(list) for i in range(m + 1)]
vert = defaultdict(set)
for _ in range(m):
u, v, c = map(int, input().split())
graphs[c][u].append(v)
graphs[c][v].append(u)
vert[c].add(v)
vert[c].add(u)
components = [[0 for i in range(n + 1)]for i in range(m + 1)]
for i in range(1, m + 1):
c = 0
visited = [0 for i in range(n + 1)]
for r in graphs[i].keys():
if visited[r] == 0:
c += 1
connectedComponents(r, visited, graphs[i], c, components[i])
# for i in components:
# print(i)
q = int(input())
for i in range(q):
u, v = map(int, input().split())
ans = 0
for j in range(1, m + 1):
if components[j][u] == components[j][v] and components[j][u] != 0:
ans += 1
print(ans) | 8 | PYTHON3 |
v, e = map(int, input().split())
graphs = [ [set([i]) for i in range(1, v + 1)] for _ in range(101) ]
def getSet(sets, vertex):
for s in sets:
if vertex in s: return s
for _ in range(e):
a, b, c = map(int, input().split())
sa = getSet(graphs[c], a)
sb = getSet(graphs[c], b)
if sa.isdisjoint(sb):
sa |= sb
graphs[c].remove(sb)
q = int(input())
for _ in range(q):
a, b = map(int, input().split())
c = 0
for graph in graphs:
sa = getSet(graph, a)
sb = getSet(graph, b)
if not sa.isdisjoint(sb): c += 1
print(c) | 8 | PYTHON3 |
f = lambda: map(int, input().split())
n, m = f()
p = [list(range(n + 1)) for x in range(m + 1)]
def g(c, x):
if x != p[c][x]: p[c][x] = g(c, p[c][x])
return p[c][x]
for i in range(m):
a, b, c = f()
p[c][g(c, a)] = g(c, b)
for j in range(int(input())):
a, b = f()
print(sum(g(i, a) == g(i, b) for i in range(m + 1))) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long M = 1e9 + 7;
const long long N = 1e3 + 10;
const long long IM = 1e15 + 37;
const long long PI = 3.14159265;
void PV(vector<long long> v) {
for (long long i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << "\n";
}
void PA(long long v[], long long n, long long x = 0) {
for (long long i = x; i < n + x; i++) cout << v[i] << " ";
cout << "\n";
}
void IN(long long a[], long long n, long long x = 0) {
for (long long i = x; i < n + x; i++) cin >> a[i];
}
inline void PP(long long n) { cout << n; }
inline void PP(long long n, long long m) { cout << n << " " << m << "\n"; }
inline void PP(long long n, long long m, long long q) {
cout << n << " " << m << " " << q << "\n";
}
inline void PP(long long n, long long m, long long q, long long u) {
cout << n << " " << m << " " << q << " " << u << "\n";
}
inline void op() {}
long long n, k;
vector<pair<long long, long long> > v[N];
map<pair<long long, long long>, long long> m;
map<long long, long long> z;
long long ans = 0;
void dfs(long long x, long long y, long long col = -1) {
m[{x, col}]++;
if (x == y && z[col] == 0) {
ans++;
z[col]++;
return;
}
for (auto i : v[x]) {
long long f = i.first;
long long s = i.second;
if (col == -1) {
m[{x, s}]++;
dfs(f, y, s);
} else {
if (col == s && !m[{f, s}]) {
dfs(f, y, s);
}
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
op();
long long i, j, x, y, u, l;
{
i = j = x = y = u = l = 0;
cin >> n >> k;
for (long long i = 0; i < k; i++) {
cin >> x >> y >> u;
v[x].push_back({y, u});
v[y].push_back({x, u});
}
cin >> l;
while (l--) {
m.clear();
ans = 0;
z.clear();
cin >> x >> y;
dfs(x, y);
cout << (ans) << "\n";
}
}
return 0;
}
| 8 | CPP |
import sys
import math
from collections import defaultdict
import itertools
MAXNUM = math.inf
MINNUM = -1 * math.inf
def getInt():
return int(sys.stdin.readline().rstrip())
def getInts():
return map(int, sys.stdin.readline().rstrip().split(" "))
def getString():
return sys.stdin.readline().rstrip()
def printOutput(ans):
sys.stdout.write()
pass
def dfs(a, b, edgeList):
total = 0
cLook = set()
for nxt, col in edgeList[a]:
if col not in cLook:
explored = dict()
explored[a] = True
explored[nxt] = True
if dfs_helper(nxt, b, edgeList, col, explored) == 1:
cLook.add(col)
total += 1
return total
def dfs_helper(cur, goal, edgeList, color, explored):
if cur == goal:
return 1
for nxt, col in edgeList[cur]:
if col == color and nxt not in explored:
explored[nxt] = True
if dfs_helper(nxt, goal, edgeList, color, explored) == 1:
return 1
del explored[nxt]
return 0
def solve(n, m, edgeList, queries):
for a, b in queries:
print(dfs(a, b, edgeList))
def readinput():
n, m = getInts()
edgeList = defaultdict(list)
for _ in range(m):
a, b, c = getInts()
edgeList[a].append((b, c))
edgeList[b].append((a, c))
queries = []
q = getInt()
for _ in range(q):
queries.append(tuple(getInts()))
(solve(n, m, edgeList, queries))
readinput()
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long vis[101] = {0};
long long d[212345] = {0};
vector<vector<vector<long long> > > v(101, vector<vector<long long> >(101));
void dfs(long long c, long long k) {
vis[k] = 1;
for (int i = 0; i < v[c][k].size(); i++)
if (!vis[v[c][k][i]]) dfs(c, v[c][k][i]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
long long a, b, c1;
for (int i = 0; i < m; i++) {
cin >> a >> b >> c1;
v[c1][a].push_back(b);
v[c1][b].push_back(a);
}
long long q;
cin >> q;
while (q--) {
cin >> a >> b;
long long cnt = 0;
for (int i = 1; i < m + 1; i++) {
memset(vis, 0, sizeof vis);
;
dfs(i, a);
if (vis[b]) cnt++;
}
cout << cnt << "\n";
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v[102];
bool mark[102], dp[102];
int ans[102];
void dfs(int x, int c) {
mark[x] = 1;
for (int i = 0; i < v[x].size(); i++) {
int child = v[x][i].first;
int col = v[x][i].second;
if (!mark[child] && col == c) {
dp[child] = 1;
dfs(child, c);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int fi, se, c;
cin >> fi >> se >> c;
v[se].push_back(make_pair(fi, c));
v[fi].push_back(make_pair(se, c));
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int fi, se;
cin >> fi >> se;
for (int j = 1; j <= m; j++) {
dfs(fi, j);
if (dp[se]) ans[i]++;
memset(mark, 0, sizeof mark);
memset(dp, 0, sizeof dp);
}
}
for (int i = 0; i < q; i++) cout << ans[i] << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 102;
vector<pair<int, int> > adj[max_n];
bool vis[max_n];
bool dfs(int st, int des, int c) {
if (vis[st]) return 0;
if (st == des) return 1;
vis[st] = 1;
for (pair<int, int> it : adj[st]) {
if (it.second == c) {
if (dfs(it.first, des, c)) return 1;
}
}
return 0;
}
int main() {
int i, j, k, n, m, x, y, z;
cin >> n >> m;
int c;
for (i = 0; i < m; i++) {
cin >> x >> y >> c;
x--;
y--;
adj[x].push_back(make_pair(y, c));
adj[y].push_back(make_pair(x, c));
}
int q;
cin >> q;
for (j = 1; j <= q; j++) {
cin >> x >> y;
x--;
y--;
k = 0;
for (i = 1; i <= m; i++) {
memset(vis, 0, sizeof(vis));
if (dfs(x, y, i)) k++;
}
cout << k << '\n';
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
vector<pair<int, int>> ar[100001];
void insert(int a, int b, int c) {
ar[a].push_back(make_pair(b, c));
ar[b].push_back(make_pair(a, c));
}
int vis[100001];
int dfs(int a, int b, int c) {
vis[a] = 1;
if (a == b) return 1;
int x = (int)(ar[a].size());
for (int i = 0; i < x; i++)
if (vis[ar[a][i].first] != 1 && ar[a][i].second == c)
if (dfs(ar[a][i].first, b, c) == 1) return 1;
return 0;
}
int main() {
int a, b, c;
scanf("%d", &n);
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d", &a);
scanf("%d", &b);
scanf("%d", &c);
insert(a, b, c);
}
scanf("%d", &q);
for (int t = 0; t < q; t++) {
scanf("%d", &a);
scanf("%d", &b);
int ans = 0;
for (int i = 1; i < m + 1; i++) {
for (int j = 0; j < n + 1; j++) vis[j] = 0;
ans += dfs(a, b, i);
}
printf("%d\n", ans);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool mat[100][100][100];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a, b, c;
cin >> a >> b >> c;
--a, --b, --c;
mat[a][b][c] = 1;
mat[b][a][c] = 1;
}
for (int col = 0; col < m; ++col) {
for (int k = 0; k < n; ++k) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if ((mat[i][k][col] && mat[k][j][col])) {
mat[i][j][col] = 1;
}
}
}
}
}
int q;
cin >> q;
while (q--) {
int a, b;
cin >> a >> b;
--a, --b;
cout << accumulate(mat[a][b], mat[a][b] + m, 0) << '\n';
}
return 0;
}
| 8 | CPP |
def get_connected_matrix(adjacency_matrix):
n = len(adjacency_matrix)
non_visited_vertices = set(i for i in range(n))
cluster_numbers = [0] * n
cluster_number = 1
def traverse(u):
non_visited_vertices.remove(u)
cluster_numbers[u] = cluster_number
for v in range(n):
if v in non_visited_vertices:
if adjacency_matrix[u][v]:
traverse(v)
while non_visited_vertices:
vertex = non_visited_vertices.pop()
non_visited_vertices.add(vertex)
traverse(vertex)
cluster_number += 1
connected_matrix = [[False] * n for _ in range(n)]
for u in range(n):
for v in range(n):
if u == v:
continue
connected_matrix[u][v] = connected_matrix[v][u] = (cluster_numbers[u] == cluster_numbers[v])
return connected_matrix
def main():
n, m = [int(t) for t in input().split()]
matrices = [[[False] * n for _ in range(n)] for _ in range(m)]
for _ in range(m):
a, b, c = [int(t) - 1 for t in input().split()]
matrices[c][a][b] = True
matrices[c][b][a] = True
connected_matrices = [get_connected_matrix(matrix) for matrix in matrices]
q = int(input())
for _ in range(q):
u, v = [int(t) - 1 for t in input().split()]
total_connection = sum(1 for connected_matrix in connected_matrices if connected_matrix[u][v])
print(total_connection)
if __name__ == '__main__':
main()
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int>>> v;
int visited[100];
void dfs(int i, int final, int color) {
if (i == final) {
visited[final] = 1;
return;
}
visited[i] = 1;
for (auto j : v[i]) {
if (visited[j.first] == 0 && j.second == color) {
dfs(j.first, final, color);
}
}
}
int solve(int x, int y, int c) {
memset(visited, 0, sizeof(visited));
dfs(x, y, c);
if (visited[y] == 1) {
return 1;
} else {
return 0;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
int n, m;
cin >> n >> m;
v.resize(n);
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
v[b - 1].push_back({a - 1, c - 1});
v[a - 1].push_back({b - 1, c - 1});
}
int q;
cin >> q;
while (q--) {
int x, y;
cin >> x >> y;
int ans = 0;
for (int i = 0; i < m; i++) {
ans = ans + solve(x - 1, y - 1, i);
}
cout << ans << '\n';
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<long long> graph[1001][1001];
long long n, m;
bool found = false;
vector<bool> visited(1001);
void dfs(long long src, long long des, long long color) {
if (found) {
return;
}
if (src == des) {
found = true;
return;
}
visited[src] = true;
for (vector<long long>::iterator it = graph[color][src].begin();
it != graph[color][src].end(); it++) {
if (visited[*it] == false) {
dfs(*it, des, color);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
for (long long i = 0; i <= 101; i++) {
for (long long j = 0; j <= 101; j++) {
graph[i][j].clear();
}
}
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
long long a, b, c;
cin >> a >> b >> c;
graph[c][a].push_back(b);
graph[c][b].push_back(a);
}
long long q;
cin >> q;
while (q--) {
long long a, b;
cin >> a >> b;
long long ans = 0;
for (long long color = 0; color <= 100; color++) {
for (long long i = 0; i <= n; i++) {
visited[i] = false;
}
found = false;
dfs(a, b, color);
if (found) ans++;
}
cout << ans << "\n";
}
}
| 8 | CPP |
# http://codeforces.com/contest/505/problem/B
class Node:
def __init__(self, n):
self.n = n
self.neighs = {}
def dfs_color(self, f, t, nodes, visited):
# if self.n in visited:
# return visited[self.n]
visited.add(self.n)
connected = set()
for neigh, colors_to_neigh in self.neighs.items():
if neigh == f or neigh in visited:
continue
colors = colors_to_neigh if neigh == t else nodes[neigh].dfs_color(self.n,t,nodes, visited)
connected.update(colors.intersection(colors_to_neigh))
# visited[self.n] = connected
visited.remove(self.n)
return connected
def dfs_colored_path(self, cc, nodes, visited):
visited.add(self.n)
for neigh, colors_to_neigh in self.neighs.items():
if neigh in visited or cc not in colors_to_neigh:
continue
nodes[neigh].dfs_colored_path(cc, nodes, visited)
return visited
def search_with_color(self, t, nodes):
colors_to_explore = set()
colors = set()
for neigh, colors_to_neigh in self.neighs.items():
colors_to_explore.update(colors_to_neigh)
for color in colors_to_explore:
cities = self.dfs_colored_path(color, nodes, set())
if t in cities:
colors.add(color)
return len(colors)
n, m = [int(n) for n in input().split()]
# edges = [int(n) for _ in range(m) for input().split()]
edges = []
while m:
edge = [int(n) for n in input().split()]
edges.append(edge)
m-=1
nodes = [Node(i) for i in range(n+1)]
for f, t, c in edges:
if t not in nodes[f].neighs:
nodes[f].neighs[t] = set()
nodes[f].neighs[t].add(c)
f,t = t,f
if t not in nodes[f].neighs:
nodes[f].neighs[t] = set()
nodes[f].neighs[t].add(c)
qs = int(input())
for q in range(qs):
# visited = set()
f, t = [int(n) for n in input().split()]
# print(len(nodes[f].dfs_color(f, t, nodes, visited)))
print(nodes[f].search_with_color(t, nodes))
| 8 | PYTHON3 |
from collections import defaultdict
n, m = map(int, input().split())
d = [defaultdict(list) for i in range(1+m)]
for i in range(m):
a, b, c = map(int, input().split())
d[c][a].append(b)
d[c][b].append(a)
q = int(input())
for _ in range(q):
u, v = map(int, input().split())
ct = 0
for adj in d:
vst = [0]*(n+1)
q = [u]
while q:
e = q.pop()
if e == v:
ct += 1
break
else:
vst[e] = 1
for j in adj[e]:
if not vst[j]:
q.append(j)
print(ct)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int used[101];
vector<pair<int, int>> g[101];
int s[101];
int n, cnt = 0, m, j, ind = 0;
void dfs(int x, int y, int p) {
cnt = 0;
used[x] = 1;
if (x == y) {
cnt++;
ind = 1;
return;
}
for (int k = 0; k < g[x].size(); k++) {
if (used[g[x][k].first] == 0) {
if (g[x][k].second == p && ind != 1) {
dfs(g[x][k].first, y, p);
}
}
}
}
int main() {
cin >> n >> m;
for (int u, v, r, i = 0; i < m; i++) {
cin >> u >> v >> r;
g[u].push_back({v, r});
g[v].push_back({u, r});
}
cin >> j;
for (int h, f, b = 1; b <= j; b++) {
cin >> h >> f;
cnt = 0;
for (int i = 1; i <= m; i++) {
memset(used, 0, sizeof(used));
ind = 0;
dfs(h, f, i);
s[b] = s[b] + cnt;
}
}
for (int i = 1; i <= j; i++) cout << s[i] << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
void dfs(vector<pair<int, int> > adj[], vector<bool>& visited, int u, int c) {
visited[u] = true;
vector<pair<int, int> >::iterator it1;
for (it1 = adj[u].begin(); it1 != adj[u].end(); it1++) {
if (!visited[(*it1).first] && (*it1).second == c) {
dfs(adj, visited, (*it1).first, c);
}
}
}
signed main() {
int n, m;
cin >> n >> m;
vector<pair<int, int> > adj[101];
while (m--) {
int a, b, c;
cin >> a >> b >> c;
adj[a].push_back(make_pair(b, c));
adj[b].push_back(make_pair(a, c));
}
int q;
cin >> q;
while (q--) {
int x, y;
cin >> x >> y;
int ans = 0;
for (int i = 1; i <= 100; i++) {
vector<bool> visited(101, false);
dfs(adj, visited, x, i);
if (visited[y]) ans++;
}
cout << ans << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, k;
map<long long int, long long int> m2;
map<int, int> m3;
long long int vis[101];
vector<int> v2;
long long int x, y, c;
int co = 0;
vector<pair<long long int, long long int> > v[101];
bool a[101];
void dfs(int x1, int ci) {
if (x1 == y) {
co = 1;
return;
}
vis[x1] = 1;
for (int j = 0; j < v[x1].size(); j++) {
if (!vis[v[x1][j].first] && v[x1][j].second == ci) {
dfs(v[x1][j].first, ci);
}
}
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y >> c;
a[c] = 1;
v[x].push_back(make_pair(y, c));
v[y].push_back(make_pair(x, c));
}
int q;
cin >> q;
int c2;
for (int i = 1; i <= q; i++) {
cin >> x >> y;
c2 = 0;
for (int j = 1; j <= 100; j++) {
if (a[j] == 1) {
memset(vis, 0, sizeof(vis));
co = 0;
dfs(x, j);
if (co == 1) c2 += 1;
}
}
cout << c2 << endl;
}
}
| 8 | CPP |
class DisjointSet: #only support query, NO construction supported
def __init__(self, n):
self.num_sets = n #--@union
self.parents = list(range(n))
self.ranks = [0] * n
self.sizes = [1] * n #used@union: size of set@root! 0 if NOT repsentive
def __str__(self):
return '%s'%self.parents
def __repr__(self):
return '%s'%self.parents
def find(self,j): #no compress
while self.parents[j]!=j:
j = self.parents[j]
return j
def union(self,i,j):
i = self.find(i)
j = self.find(j)
if i == j:
return False
rd = self.ranks[i] - self.ranks[j]
if rd == 0: # Increment repr0's rank if both nodes have same rank
self.ranks[i] += 1
elif rd < 0: # Swap to ensure that repr0's rank >= repr1's rank
i, j = j, i
self.parents[j] = i #merge
self.sizes[i] += self.sizes[j]
self.sizes[j] = 0
self.num_sets -= 1
return True
def main():
n,m = list(map(int,input().split())) #100,100
el = [list(map(int,input().split())) for _ in range(m)]
q = int(input())
vl = [list(map(int,input().split())) for _ in range(q)]
dl = [DisjointSet(n) for _ in range(m)]
for a,b,c in el:
dl[c-1].union(a-1,b-1)
[print(sum([d.find(u-1)==d.find(v-1) for d in dl])) for u,v in vl]
main()
'''
import cProfile
cProfile.run("main()")
'''
| 8 | PYTHON3 |
def iterative_bfs(graph, start, path=[]):
'''iterative breadth first search from start'''
q=[start]
while q:
v=q.pop(0)
if not v in path:
path=path+[v]
q=q+graph[v]
return path
dx = {}
nodes, edges = map(int, input().split(' '))
for c in range(edges+1):
graph = {}
for i in range(nodes):
graph[i] = []
dx[c] = graph
for i in range(edges):
a, b, c = map(int, input().split(' '))
dx[c][a-1].append(b-1)
dx[c][b-1].append(a-1)
for _ in range(int(input())):
a, b = map(int, input().split(' '))
t = 0
for i in dx:
graph = dx[i]
if b-1 in iterative_bfs(graph, a-1):
t += 1
print(t) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<pair<int, int>> adj[4004];
int vis[4004];
bool dfs(int u, int col, int v) {
vis[u] = 1;
if (u == v) return true;
for (pair<int, int> p : adj[u]) {
if (vis[p.first] or p.second != col) {
continue;
}
if (dfs(p.first, col, v)) {
return true;
}
}
return false;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
adj[a].push_back({b, c});
adj[b].push_back({a, c});
}
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
int ans = 0;
for (int i = 1; i <= m; i++) {
memset(vis, 0, sizeof(vis));
ans += dfs(l, i, r);
}
cout << ans << '\n';
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 105;
struct Dsu {
int arr[maxn];
void init(int n) {
for (int i = 0; i <= n; i++) {
arr[i] = i;
}
}
int fnd(int x) { return arr[x] == x ? x : arr[x] = fnd(arr[x]); }
void join(int x, int y) {
x = fnd(x);
y = fnd(y);
if (x != y) arr[x] = y;
}
bool check(int x, int y) { return fnd(x) == fnd(y); }
} dsu[maxn];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) dsu[i].init(n);
int u, v, c;
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &u, &v, &c);
dsu[c].join(u, v);
}
int q;
scanf("%d", &q);
while (q--) {
scanf("%d %d", &u, &v);
int ans = 0;
for (int i = 1; i <= m; i++) {
ans += dsu[i].check(u, v);
}
printf("%d\n", ans);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
int siz[105][105];
pair<int, int> par[105][105];
void make_set(int i, int x) {
par[i][x].first = i, par[i][x].second = x;
siz[i][x] = 1;
}
pair<int, int> find_set(pair<int, int> p) {
if (par[p.first][p.second].first == p.first &&
par[p.first][p.second].second == p.second) {
return p;
}
return par[p.first][p.second] = find_set(par[p.first][p.second]);
}
void union_set(int c, int a, int b) {
pair<int, int> x, y;
x.first = c;
x.second = find_set({c, a}).second;
y.first = c;
y.second = find_set({c, b}).second;
if (x != y) {
if (siz[c][x.second] < siz[c][y.second]) {
swap(x, y);
}
siz[c][x.second] += siz[c][y.second];
par[c][y.second] = par[c][x.second];
}
}
void tcase(int Tcase) {
int n, m, a, b, c, q;
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
make_set(i, j);
}
}
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &a, &b, &c);
union_set(c, a, b);
}
scanf("%d", &q);
while (q--) {
int cnt = 0;
scanf("%d %d", &a, &b);
for (int i = 1; i <= m; i++) {
if (find_set({i, a}) == find_set({i, b})) {
cnt++;
}
}
printf("%d\n", cnt);
}
}
int main() {
int T = 1;
for (int Tcase = 1; Tcase <= T; Tcase++) {
tcase(Tcase);
}
}
| 8 | CPP |
def build_graph():
line1 = input().strip().split()
n = int(line1[0])
m = int(line1[1])
graph = {}
for _ in range(m):
line = input().strip().split()
u = int(line[0])
v = int(line[1])
c = int(line[2])
if c not in graph:
graph[c] = {j: [] for j in range(1, n+1)}
graph[c][u].append(v)
graph[c][v].append(u)
return graph
parent_history = {}
def no_of_paths(u, v, graph):
x = 0
for c in graph:
if c in parent_history:
if v in parent_history[c]:
parent = parent_history[c]
if u in parent:
x += 1
elif u in parent_history[c]:
parent = parent_history[c]
if v in parent:
x += 1
else:
parent = {}
parent = dfs_visit(v, graph[c], parent)
if len(parent_history[c]) < len(parent):
parent_history[c] = parent
if u in parent:
x += 1
else:
parent = {}
parent = dfs_visit(v, graph[c], parent)
parent_history[c] = parent
if u in parent:
x += 1
return x
def dfs_visit(i, adj_list, parent):
for j in adj_list[i]:
if j not in parent:
parent[j] = i
dfs_visit(j, adj_list, parent)
return parent
if __name__ == "__main__":
graph = build_graph()
for _ in range(int(input())):
line = input().strip().split()
print(no_of_paths(int(line[0]), int(line[1]), graph))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<pair<int, int>> g[105];
int vis[105];
bool dfs(int str, int col, int dst) {
vis[str] = 1;
if (str == dst) return 1;
for (int i = 0; i < g[str].size(); i++) {
if (g[str][i].second == col && !vis[g[str][i].first]) {
if (dfs(g[str][i].first, col, dst)) return true;
}
}
return false;
}
int main() {
cin >> n >> m;
int a, b, c;
for (int i = 1; i <= m; i++) {
cin >> a >> b >> c;
g[a].push_back(make_pair(b, c));
g[b].push_back(make_pair(a, c));
}
int q;
cin >> q;
for (int t = 1; t <= q; t++) {
int u, v;
cin >> u >> v;
int ans = 0;
for (int i = 1; i <= 100; i++) {
memset(vis, 0, sizeof(vis));
if (dfs(u, i, v)) ans++;
}
cout << ans << "\n";
}
}
| 8 | CPP |
#include <bits/stdc++.h>
struct node {
int x;
struct node* next;
};
struct node* adj[105][105];
int v[105][105];
int cc;
void DFS(int u, int w) {
v[w][u] = cc;
struct node* temp = adj[w][u];
while (temp) {
if (v[w][temp->x] == 0) {
DFS(temp->x, w);
}
temp = temp->next;
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < 105; i++) {
for (int j = 0; j < 105; j++) {
adj[i][j] = NULL;
v[i][j] = 0;
}
}
int v1, v2, w;
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &v1, &v2, &w);
v1--;
v2--;
w--;
struct node* temp = (struct node*)malloc(sizeof(struct node));
temp->x = v2;
temp->next = adj[w][v1];
adj[w][v1] = temp;
struct node* tmp = (struct node*)malloc(sizeof(struct node));
tmp->x = v1;
tmp->next = adj[w][v2];
adj[w][v2] = tmp;
}
for (int i = 0; i < m; i++) {
cc = 0;
for (int j = 0; j < n; j++) {
if (v[i][j] == 0) {
cc++;
DFS(j, i);
}
}
}
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d%d", &v1, &v2);
v1--;
v2--;
int ans = 0;
for (int i = 0; i < m; i++) {
if (v[i][v1] == v[i][v2] && v[i][v1] != 0 && v[i][v2] != 0) {
ans++;
}
}
printf("%d\n", ans);
}
return 0;
}
| 8 | CPP |
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
#from fractions import *
from bisect import *
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
#vsInput()
def bfs(adj,s,k):
#print(adj)
vis={i:False for i in adj}
vis[s]=True
qu=[s]
while(len(qu)!=0):
e=qu.pop(0)
if(e==k):return True
for i in adj[e]:
if(vis[i]!=True):
qu.append(i)
vis[i]=True
return False
n,m=value()
adj={i:defaultdict(list) for i in range(1,m+1)}
for i in range(m):
s,d,c=value()
adj[c][s].append(d)
adj[c][d].append(s)
#print(adj[1].keys())
for i in range(Int()):
s,d=value()
ans=0
for i in range(1,m+1):
if(s in adj[i].keys() and bfs(adj[i],s,d)):
ans+=1
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> adj[101];
set<pair<long long int, long long int>> color[101];
long long int visited[101];
long long int x;
void dfs(long long int a, long long int b, long long int c) {
visited[a] = 1;
if (a == b) {
x = 1;
}
for (long long int i = 0; i < adj[a].size(); i++) {
if (visited[adj[a][i]] == 0 &&
color[c].find({a, adj[a][i]}) != color[c].end()) {
dfs(adj[a][i], b, c);
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int i, j, k, l, m, n, p, t, a, b, c, q;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> a >> b >> c;
adj[a].push_back(b);
adj[b].push_back(a);
color[c].insert({a, b});
color[c].insert({b, a});
}
cin >> q;
for (i = 0; i < q; i++) {
cin >> a >> b;
p = 0;
for (j = 1; j <= m; j++) {
x = 0;
dfs(a, b, j);
p += x;
memset(visited, 0, sizeof(visited));
}
cout << p << "\n";
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> v;
vector<vector<pair<int, int>>> g;
vector<int> used;
int N, M;
void dfs(int i, int j, int I, int m) {
if (i == j) v[I][j]++;
used[i] = 1;
for (auto u : g[i]) {
if (!used[u.second] && m == u.first) dfs(u.second, j, I, m);
}
}
int main() {
cin >> N >> M;
g.resize(N + 1);
used.resize(N + 1);
v.resize(N + 1, vector<int>(N + 1));
for (int i = 0; i < M; i++) {
int a, b, c;
cin >> a >> b >> c;
g[a].push_back({c, b});
g[b].push_back({c, a});
}
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
if (i == j) continue;
for (int f = 1; f <= M; f++) {
used.assign(N + 1, 0);
dfs(i, j, i, f);
}
}
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
cout << v[a][b] << '\n';
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long fac[2000005] = {0};
void factorial() {
fac[0] = 1;
fac[1] = 1;
for (long long i = 2; i < 200005; i++)
fac[i] = ((i % 1000000007) * (fac[i - 1] % 1000000007)) % 1000000007;
}
long long power(long long n, long long m) {
long long p = 1;
if (m == 0) return 1;
p = (power(n, m / 2) % 1000000007);
p = (p % 1000000007 * p % 1000000007) % 1000000007;
return (m & 1 ? ((p % 1000000007 * n % 1000000007) % 1000000007)
: (p % 1000000007));
}
long long ncr(long long n, long long r) {
return ((fac[n] * power(fac[r], 1000000007 - 2)) % 1000000007 *
power(fac[n - r], 1000000007 - 2)) %
1000000007;
}
vector<pair<long long, long long> > graph[102];
long long n, m;
long long cnt = 0;
long long used[101] = {0};
void dfs(long long x, long long y, long long col) {
used[x] = 1;
if (x == y) {
++cnt;
return;
}
for (long long i = 0; i < graph[x].size(); i++) {
pair<long long, long long> p = graph[x][i];
if (p.second == col && !used[p.first]) {
dfs(p.first, y, col);
}
}
return;
}
void ram5564() {
cin >> n >> m;
while (m--) {
long long a, b, c;
cin >> a >> b >> c;
graph[a].push_back(make_pair(b, c));
graph[b].push_back(make_pair(a, c));
}
long long q;
cin >> q;
while (q--) {
long long x, y;
cin >> x >> y;
cnt = 0;
for (long long i = 1; i < 101; i++) {
memset(used, 0, sizeof(used));
dfs(x, y, i);
}
cout << cnt << "\n";
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) ram5564();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const long long int inf64 = 1e18 + 5;
const int MAX = 105;
bool vis[MAX];
vector<int> adj[MAX][MAX];
void dfs(int x, int col) {
vis[x] = true;
for (auto v : adj[col][x]) {
if (!vis[v]) dfs(v, col);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, q, i, j, a, b, c;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> a >> b >> c;
adj[c][a].push_back(b);
adj[c][b].push_back(a);
}
cin >> q;
while (q--) {
cin >> a >> b;
int ans = 0;
for (i = 1; i <= m; i++) {
memset(vis, false, sizeof vis);
dfs(a, i);
ans += vis[b];
}
cout << ans << '\n';
}
}
| 8 | CPP |
def gerarGrafo(cor):
adjancencias = {}
for aresta in arestas:
if aresta[2] == cor:
if adjancencias.get(aresta[0]) == None:
adjancencias[aresta[0]] = []
if adjancencias.get(aresta[1]) == None:
adjancencias[aresta[1]] = []
adjancencias[aresta[0]].append(aresta[1])
adjancencias[aresta[1]].append(aresta[0])
return adjancencias
def dfs(u, w, adjacencias):
pilha = [u]
visitados = {u: 1}
existeCaminhoUV = False
if adjacencias.get(u) == None or adjacencias.get(w) == None:
return existeCaminhoUV
while len(pilha) > 0:
vertice = pilha.pop()
for v in adjacencias[vertice]:
if visitados.get(v) == None:
visitados[v] = 1
pilha.append(v)
if visitados.get(w) != None:
existeCaminhoUV = True
return existeCaminhoUV
entrada = input().split()
n = int(entrada[0])
m = int(entrada[1])
cores = set()
arestas = []
i = 0
while i < m:
aresta = input().split()
cores.add(aresta[2])
arestas.append(aresta)
i += 1
q = int(input())
paresVertices = []
i = 0
while i < q:
paresVertices.append(input().split())
i += 1
res = [0] * q
for cor in cores:
grafo = gerarGrafo(cor)
i = 0
for par in paresVertices:
if dfs(par[0], par[1], grafo):
res[i] += 1
i += 1
for e in res:
print(e) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
vector<pair<int, int> > v[N];
int vis[N], a[N];
void dfs(int x, int y, int c) {
if (vis[x]) return;
vis[x] = 1;
if (x == y) a[c] = 1;
for (auto i : v[x]) {
if ((!vis[i.first]) && i.second == c) dfs(i.first, y, c);
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a, b, c;
cin >> a >> b >> c;
v[a].push_back({b, c});
v[b].push_back({a, c});
}
int q;
cin >> q;
for (int i = 1; i <= q; ++i) {
int l, r, f = 0;
cin >> l >> r;
for (auto j : v[l]) {
dfs(l, r, j.second);
memset(vis, 0, sizeof(vis));
}
for (int i = 1; i <= m; ++i) f += a[i];
cout << f;
cout << "\n";
memset(a, 0, sizeof(a));
}
return 0;
}
| 8 | CPP |
n,m=map(int,input().split())
INF=10**18
d=[[[INF]*n for j in range(n)] for i in range(m)]
edges=[[[] for i in range(n)] for i in range(m)]
for _ in range(m):
a,b,c=map(int,input().split())
a-=1
b-=1
c-=1
edges[c][a].append(b)
edges[c][b].append(a)
d[c][a][b]=d[c][b][a]=1
for color in range(m):
for s in range(n):
q=[s]
visited=[False]*n
visited[s]=True
while q:
node=q.pop(0)
visited[node]=True
for to in edges[color][node]:
if visited[to]:
continue
d[color][s][to]=d[color][to][s]=1
q.append(to)
Q=int(input())
for _ in range(Q):
u,v=map(int,input().split())
u-=1
v-=1
ans=0
for color in range(m):
if d[color][u][v]<INF:
ans+=1
print(ans) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct uf {
static const int MAXN = 105;
int par[MAXN];
int size[MAXN];
void init() {
memset(par, -1, sizeof(par));
for (int i = 0; i < (MAXN); ++i) size[i] = 1;
}
int root(int a) {
if (par[a] == -1) return a;
return par[a] = root(par[a]);
}
void unite(int a, int b) {
a = root(a);
b = root(b);
if (a == b) return;
if (size[a] < size[b]) swap(a, b);
par[b] = a;
size[a] += size[b];
}
bool same(int a, int b) { return root(a) == root(b); }
};
uf u_[105];
int n, m;
int main() {
for (int i = 0; i < (100); ++i) u_[i].init();
cin >> n >> m;
for (int i = 0; i < (m); ++i) {
int a, b, c;
cin >> a >> b >> c;
--a;
--b;
--c;
u_[c].unite(a, b);
}
int q;
cin >> q;
while (q--) {
int res = 0;
int u, v;
cin >> u >> v;
--u;
--v;
for (int i = 0; i < (100); ++i)
if (u_[i].same(u, v)) ++res;
cout << res << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, a, b, c, s, t;
bool v[105];
vector<int> adj[105][105];
int dp[105][105][105];
int dfs(int par, int cur, int t, int cg) {
v[cur] = true;
if (cur == t) return 1;
for (int x : adj[cur][cg]) {
if (!v[x])
if (dfs(cur, x, t, cg)) return 1;
}
return 0;
}
int main() {
memset(dp, 0, sizeof dp);
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &a, &b, &c);
adj[a][c].push_back(b);
adj[b][c].push_back(a);
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &s, &t);
int ans = 0;
for (int j = 1; j <= m; j++) {
memset(v, 0, sizeof v);
ans += dfs(0, s, t, j);
}
printf("%d\n", ans);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int>>> v(505);
int vis[1000];
bool ch;
void dfs(int s, int c, int la) {
vis[s] = 1;
for (auto i : v[s]) {
if (!vis[i.first] && i.second == c) {
if (i.first == la) ch = 1;
dfs(i.first, c, la);
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
v[a].push_back(make_pair(b, c));
v[b].push_back(make_pair(a, c));
}
int ans = 0;
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int a, b;
cin >> a >> b;
for (int j = 1; j <= 500; j++) {
dfs(a, j, b);
if (ch == 1) ans++;
ch = 0;
memset(vis, 0, sizeof vis);
}
cout << ans << endl;
ans = 0;
}
return 0;
}
| 8 | CPP |
n,m = map(int, input().split())
l = []
for i in range(m):
a,b,c = map(int, input().split())
if len(l) <= c-1:
for i in range(c-len(l)):
l.append([])
p = l[c-1]
m = []
for i in range(len(p)):
if a in p[i] or b in p[i]:
m.append(i)
new = [a,b]
for i in range(len(m)):
new = new + p[m[i]]
for i in range(len(m)):
p.pop(m[i]-i)
p.append(new)
l[c-1] = p
q = int(input())
for i in range(q):
counter = 0
u,v = map(int, input().split())
for j in range(len(l)):
yes = 0
for k in range(len(l[j])):
if yes == 0 and u in l[j][k] and v in l[j][k]:
yes = 1
counter += 1
print(counter)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> conn[105];
int mark[105];
void dfs(int u, int c) {
mark[u] = true;
int sz = conn[u].size();
for (int i = 0; i < sz; i += 2) {
int v = conn[u][i], x = conn[u][i + 1];
if (!mark[v] and x == c) dfs(v, c);
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; ++i) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
conn[a].push_back(b);
conn[a].push_back(c);
conn[b].push_back(a);
conn[b].push_back(c);
}
int q;
scanf("%d", &q);
while (q--) {
int u, v;
scanf("%d %d", &u, &v);
int res = 0;
for (int i = 1; i <= m; ++i) {
memset(mark, 0, sizeof mark);
dfs(u, i);
if (mark[v]) res++;
}
printf("%d\n", res);
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool c[101][101][101];
bool bfs(int u, int v, int p) {
queue<int> q;
bool visit[101] = {false};
q.push(u);
visit[u] = true;
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int i = 1; i <= n; i++)
if (c[p][cur][i]) {
if (!visit[i]) {
visit[i] = true;
q.push(i);
}
}
}
return visit[v];
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b, t;
scanf("%d %d %d", &a, &b, &t);
c[t][a][b] = c[t][b][a] = true;
}
int q;
scanf("%d", &q);
while (q--) {
int s, e;
int cnt = 0;
scanf("%d %d", &s, &e);
for (int i = 1; i <= m; i++) {
if (bfs(s, e, i)) cnt++;
}
printf("%d\n", cnt);
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000;
vector<pair<int, int> > vec[maxn];
vector<int> v;
bool check[maxn];
bool ans = 0;
void dfs(int s, int e, int c) {
check[s] = 1;
if (ans == 1) return;
if (s == e) {
ans = 1;
return;
}
for (int i = 0; i < vec[s].size(); i++) {
if (vec[s][i].second == c && !check[vec[s][i].first]) {
dfs(vec[s][i].first, e, c);
}
}
return;
}
int main() {
int n, m, d, f, g, maxe_c = 0;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> f >> g >> d;
vec[f].push_back(make_pair(g, d));
vec[g].push_back(make_pair(f, d));
maxe_c = max(maxe_c, d);
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> f >> g;
int col = 0;
for (int j = 0; j <= maxe_c; j++) {
ans = false;
for (int s = 1; s <= n; s++) check[s] = 0;
dfs(f, g, j);
if (ans) col++;
}
v.push_back(col);
}
for (int i = 0; i < v.size(); i++) cout << v[i] << endl;
}
| 8 | CPP |
import sys, os.path
from collections import*
from copy import*
import math
mod=10**9+7
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
def dfs(x,y,z):
vis[x]=1
if(x==y):
return
for v in adj[x]:
if(vis[v[0]]):
continue
if(v[1]==z):
dfs(v[0],y,z)
adj=defaultdict(list)
n,m=map(int,input().split())
s=set()
for i in range(m):
a,b,c=map(int,input().split())
adj[a].append((b,c))
adj[b].append((a,c))
s.add(c)
q=int(input())
for i in range(q):
x,y=map(int,input().split())
count=0
for j in s:
vis=[0 for i in range(n+1)]
dfs(x,y,j)
if(vis[y]):
count+=1
print(count) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int>>> adjlist;
int vertices, edges, ans;
vector<int> visited;
vector<int> colorchk;
vector<vector<int>> storedans;
void print() {
int count = 0;
for (auto &i : adjlist) {
cout << "For vertex " << count << endl;
count++;
for (auto &j : i) {
cout << j.first << " " << j.second << endl;
}
cout << endl;
}
}
void dfs(int current, int destination, int color) {
if (colorchk[color]) return;
if (current == destination) {
ans++;
colorchk[color] = 1;
return;
}
visited[current] = 1;
for (auto &i : adjlist[current]) {
if (i.second == color && !visited[i.first]) {
dfs(i.first, destination, color);
}
}
}
int main() {
int vtx1, vtx2, color;
cin >> vertices >> edges;
adjlist.assign(vertices + 1, vector<pair<int, int>>());
for (int i = 0; i < edges; i++) {
cin >> vtx1 >> vtx2 >> color;
adjlist[vtx1].push_back({vtx2, color});
adjlist[vtx2].push_back({vtx1, color});
}
storedans.assign(vertices + 1, vector<int>());
for (auto &i : storedans) {
i.assign(vertices + 1, -1);
}
int query;
cin >> query;
while (query--) {
cin >> vtx1 >> vtx2;
if (storedans[vtx1][vtx2] != -1) {
cout << storedans[vtx1][vtx2] << endl;
} else {
ans = 0;
colorchk.assign(edges + 1, 0);
for (auto &i : adjlist[vtx1]) {
if (!colorchk[i.second]) {
visited.assign(vertices + 1, 0);
dfs(vtx1, vtx2, i.second);
}
}
storedans[vtx1][vtx2] = ans;
storedans[vtx2][vtx1] = ans;
cout << storedans[vtx1][vtx2] << endl;
}
}
return 0;
}
| 8 | CPP |
n, m = map(int, input().split())
mx = [[0x00] * n for i in range(n)]
used = None
def dfs(cur, trg, color):
if cur == trg:
return True
if not used[cur]:
used[cur] = True
for i in range(n):
if mx[cur][i] & color:
if dfs(i, trg, color):
return True
return False
for i in range(m):
a, b, c = map(lambda s: int(s) - 1, input().split())
mx[a][b] |= 1 << c
mx[b][a] |= 1 << c
q = int(input())
for i in range(q):
u, v = map(lambda s: int(s) - 1, input().split())
result = 0
for j in range(m):
used = [False] * n
if dfs(u, v, 1 << j):
result += 1
print(result)
| 8 | PYTHON3 |
n,m=map(int,input().split())
g=[[] for _ in range(n)]
for _ in range(m):
a,b,c=map(int,input().split())
g[a-1].append((b-1,c-1))
g[b-1].append((a-1,c-1))
def dfs(x,c,t):
if x==t:return True
v[x]=1
for j in g[x]:
if j[1]==c and v[j[0]]==0:
if dfs(j[0],c,t):return True
return False
q=int(input())
o=[0]*q
v=[]
for i in range(q):
f,y=map(int,input().split())
for c in range(100):
v=[0]*n
if dfs(f-1,c,y-1):o[i]+=1
print('\n'.join(list(map(str,o))))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int c[110][110];
int root(int k, int i) {
return (c[k][i] < 0 ? i : c[k][i] = root(k, c[k][i]));
}
void un(int k, int i, int j) {
i = root(k, i);
j = root(k, j);
if (i == j) return;
if (c[k][i] > c[k][j]) swap(i, j);
c[k][i] += c[k][j];
c[k][j] = i;
}
int same(int k, int i, int j) {
if (root(k, i) == root(k, j)) return 1;
return 0;
}
int main() {
memset(c, -1, sizeof(c));
int n, m;
cin >> n >> m;
int i, j, a, b;
while (m--) {
cin >> i >> j >> a;
un(a, i, j);
}
cin >> m;
while (m--) {
cin >> i >> j;
int t = 0;
for (int k = 1; k < 101; ++k) {
if (same(k, i, j)) ++t;
}
cout << t << '\n';
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
inline bool checkBit(long long n, int i) { return n & (1LL << i); }
inline long long setBit(long long n, int i) {
return n | (1LL << i);
;
}
inline long long resetBit(long long n, int i) { return n & (~(1LL << i)); }
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long &a) {
a %= 1000000007;
(a < 0) && (a += 1000000007);
}
inline long long modMul(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline long long modAdd(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long modSub(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInverse(long long a) { return modPow(a, 1000000007 - 2); }
inline long long modDiv(long long a, long long b) {
return modMul(a, modInverse(b));
}
vector<pair<int, int> > adjlist[110];
bool vis[110];
int c;
int t;
int yes = 0;
void dfs(int u) {
vis[u] = 1;
if (u == t) {
yes = 1;
return;
}
int l = adjlist[u].size();
for (int j = 0; j < l; ++j) {
pair<int, int> v = adjlist[u][j];
if (yes == 1) return;
if (!vis[v.first] && v.second == c) dfs(v.first);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
for (int i = 0, x, y, z; i < m; ++i) {
cin >> x >> y >> z;
adjlist[x].emplace_back(make_pair(y, z));
adjlist[y].emplace_back(make_pair(x, z));
}
int q;
cin >> q;
for (int i = 0, x, y; i < q; ++i) {
int ans = 0;
memset(vis, 0, sizeof(vis));
cin >> x >> y;
for (int j = 1; j <= 100; ++j) {
c = j;
t = y;
memset(vis, 0, sizeof(vis));
dfs(x);
ans += yes;
yes = 0;
}
cout << ans << '\n';
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
using pr = pair<int, int>;
using vp = vector<pr>;
using vvp = vector<vp>;
using vi = vector<int>;
int N;
void dfs(vvp& g, vi& vis, int& fl, int fin, int col, int nd) {
if (nd == fin) {
fl = 1;
return;
}
if (fl) return;
vis[nd] = 1;
for (auto& pr : g[nd]) {
if (pr.second == col)
if (!vis[pr.first]) dfs(g, vis, fl, fin, col, pr.first);
}
}
int get_num_colors(vvp& g, int u, int v) {
int ans = 0;
set<int> c;
for (auto& pr : g[u]) c.insert(pr.second);
for (auto x : c) {
vi vis(N + 1);
int fl = 0;
dfs(g, vis, fl, v, x, u);
ans += fl;
}
return ans;
}
int main() {
int n, m;
cin >> n >> m;
N = n;
vvp g(n + 1);
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
g[a].push_back({b, c});
g[b].push_back({a, c});
}
int q;
cin >> q;
map<pr, int> mp;
for (int i = 0; i < q; i++) {
int u, v;
cin >> u >> v;
if (mp.count({u, v})) {
int ans = mp[{u, v}];
cout << ans << endl;
} else {
int ans = get_num_colors(g, u, v);
mp[{u, v}] = ans;
mp[{v, u}] = ans;
cout << ans << endl;
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[109][109];
vector<int> w;
bool mark[1000];
void dfs(int v, int c) {
mark[v] = true;
for (int i = 0; i < adj[c][v].size(); i++) {
int u = adj[c][v][i];
if (!mark[u]) dfs(u, c);
}
}
int main() {
int n, m;
int v, u, c;
int i, j;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> v >> u >> c;
v--, u--, c--;
if (!mark[c]) {
mark[c] = true;
w.push_back(c);
}
adj[c][v].push_back(u);
adj[c][u].push_back(v);
}
int t, q;
vector<int> tt;
cin >> q;
for (i = 0; i < q; i++) {
t = 0;
cin >> v >> u;
v--, u--;
for (j = 0; j < w.size(); j++) {
fill(mark, mark + n, false);
dfs(v, w[j]);
if (mark[u]) t++;
}
tt.push_back(t);
}
for (int i = 0; i < q; i++) cout << tt[i] << endl;
return 0;
}
| 8 | CPP |
n, m = list(map(int,input().split()))
p = [ [ i for i in range(n) ] for j in range(m)]
def f(ci,xi):
if xi==p[ci][xi]: return xi
p[ci][xi] = f(ci,p[ci][xi])
return p[ci][xi]
def uni(ci,xi,yi):
p[ci][f(ci,xi)]=f(ci,yi)
for i in range(m):
a, b, c = list(map(int,input().split()))
uni(c-1,a-1,b-1)
for i in range(int(input())):
a, b = list(map(int,input().split()))
print(sum(1 if f(i,a-1) == f(i,b-1) else 0 for i in range(m)))
# Made By Mostafa_Khaled | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const long long LINF = 2e18;
void inv(bool e);
bool brute;
int cnt_tests = 1;
int n, m;
const int N = 200;
vector<pair<int, int> > graph[N];
vector<pair<int, int> > qs;
void inp() {
cin >> n >> m;
int v, u, c;
for (int i = 0; i < m; i++) {
cin >> v >> u >> c;
graph[v].push_back({u, c});
graph[u].push_back({v, c});
}
int t;
cin >> t;
qs.resize(t);
for (int i = 0; i < t; i++) {
cin >> v >> u;
qs[i] = {v, u};
}
}
bool used[N];
void dfs(int v, int c) {
used[v] = true;
for (auto e : graph[v]) {
if (!used[e.first] && e.second == c) dfs(e.first, c);
}
}
inline void clear_used() {
for (int i = 0; i < N; i++) used[i] = false;
}
int calc(int v, int u) {
int ans = 0;
for (int i = 1; i <= m; i++) {
clear_used();
dfs(v, i);
if (used[u]) ans++;
}
return ans;
}
void solve() {
for (auto x : qs) {
printf("%d\n", calc(x.first, x.second));
}
}
void stress() {}
void run();
int main() {
if (0) {
freopen("stack.in", "r", stdin);
freopen("stack.out", "w", stdout);
}
brute = false;
for (int i = 0; (i < cnt_tests); i++) {
run();
}
cerr << '\n' << "Time: " << clock() / 1000.0 << " ms";
return 0;
}
void run() {
if (!brute) {
inp();
} else {
stress();
}
solve();
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long int>> v, v1;
long long int fsfs(long long int a, long long int c) {
if (v[c][a] == a) {
return a;
}
v[c][a] = fsfs(v[c][a], c);
return v[c][a];
}
void alwani(long long int a, long long int b, long long int c) {
long long int x = fsfs(a, c);
long long int y = fsfs(b, c);
if (x != y) {
if (v1[c][x] < v1[c][y]) {
swap(x, y);
} else {
v1[c][x]++;
}
v[c][y] = v[c][x];
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, m, a, b, c;
cin >> n >> m;
v.resize(m + 1);
v1.resize(m + 1);
for (long long i = (1); i < (m + 1); i++) {
v[i].resize(n + 1);
v1[i].resize(n + 1, 1);
iota(v[i].begin(), v[i].end(), 0ll);
}
for (long long i = (0); i < (m); i++) {
cin >> a >> b >> c;
alwani(a, b, c);
}
long long int q;
cin >> q;
for (long long i = (0); i < (q); i++) {
cin >> a >> b;
long long int sum = 0;
for (long long j = (1); j < (m + 1); j++) {
if (fsfs(a, j) == fsfs(b, j)) {
sum++;
}
}
cout << sum << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
class step {
public:
int s;
int d;
int c;
bool isused;
bool consists(int a);
int getopposite(int a);
~step() { isused = false; }
};
int step::getopposite(int a) { return (a == s) ? d : s; }
bool step::consists(int a) {
if (isused) return false;
return ((a == s) || (a == d));
}
bool isthereway(int source, int dest, step* step_array, int array_size) {
for (int i = 0; i < array_size; i++) {
if (step_array[i].consists(source)) {
if (step_array[i].getopposite(source) == dest) return true;
step_array[i].isused = true;
if (isthereway(step_array[i].getopposite(source), dest, step_array,
array_size))
return true;
}
}
return false;
}
int main() {
int n, m, res, reqs, s, d, c, color_num = 0;
cin >> n >> m;
step routes[m];
for (int i = 0; i < m; i++) {
cin >> s >> d >> c;
if (c > color_num) color_num = c;
routes[i].s = s;
routes[i].d = d;
routes[i].c = c;
routes[i].isused = false;
}
cin >> reqs;
step requests[reqs];
for (int i = 0; i < reqs; i++) {
cin >> s >> d;
requests[i].s = s;
requests[i].d = d;
}
int sizes[color_num];
step* arr;
for (int r = 0; r < reqs; r++) {
res = 0;
for (int i = 1; i <= color_num; i++) {
sizes[i] = 0;
int k = 0;
for (int j = 0; j < m; j++) {
if (routes[j].c == i) sizes[i]++;
}
arr = new step[sizes[i]];
for (int j = 0; j < m; j++) {
if (routes[j].c == i) arr[k++] = routes[j];
}
if (isthereway(requests[r].s, requests[r].d, arr, sizes[i])) res++;
}
cout << res << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
int ans;
using namespace std;
const int maxn = 1e3;
vector<int> v[maxn][maxn];
vector<int> color[maxn];
bool b[maxn], col[maxn];
int n, m;
void empt() {
for (int i = 1; i <= n; i++) b[i] = 0;
}
void empT() {
for (int i = 1; i <= n; i++) col[i] = 0;
}
void dfs(int c, int x) {
for (int i = 0; i < v[c][x].size(); i++) {
if (!b[v[c][x][i]]) {
b[v[c][x][i]] = 1;
dfs(c, v[c][x][i]);
}
}
}
int main() {
cin >> n >> m;
int a, s, d;
for (int i = 1; i <= m; i++) {
cin >> a >> s >> d;
v[d][s].push_back(a);
v[d][a].push_back(s);
color[a].push_back(d);
color[s].push_back(d);
}
int q;
cin >> q;
for (int i = 1; i <= q; i++) {
ans = 0;
cin >> a >> s;
empT();
for (int j = 0; j < color[a].size(); j++) {
if (!col[color[a][j]]) {
empt();
b[a] = 1;
dfs(color[a][j], a);
if (b[s]) ans++;
col[color[a][j]] = 1;
}
}
cout << ans << endl;
}
return 0;
}
| 8 | CPP |
def dfs(place,target):
vis[place]=True
if target==place:total[0]+=1;return()
anyAdj=0
for i in j[place]:
if not vis[i]:anyAdj=1;dfs(i,target)
if anyAdj==0:return()
v,e=map(int,input().split())
edges=[]
for i in range(e):edges.append(list(map(int,input().split())))
colors=[]
for i in edges:colors.append(i[2])
colors=list(set(colors))
colorAdjs=[]
for i in colors:
colorAdjs.append([[] for w in range(v)])
for j in edges:
if j[2]==i:
colorAdjs[-1][j[0]-1].append(j[1]-1)
colorAdjs[-1][j[1]-1].append(j[0]-1)
q=int(input())
for i in range(q):
total=[0]
a,b=map(int,input().split())
a-=1;b-=1
for j in colorAdjs:
vis=[False]*v
dfs(a,b)
print(total[0])
| 8 | PYTHON3 |
class CodeforcesTask505BSolution:
def __init__(self):
self.result = ''
self.n_m = []
self.edges = []
self.q = 0
self.queries = []
def read_input(self):
self.n_m = [int(x) for x in input().split(" ")]
for x in range(self.n_m[1]):
self.edges.append([int(y) for y in input().split(" ")])
self.q = int(input())
for x in range(self.q):
self.queries.append([int(y) for y in input().split(" ")])
def process_task(self):
graphs = [[[] for x in range(self.n_m[0])] for c in range(self.n_m[1])]
for edge in self.edges:
graphs[edge[2] - 1][edge[0] - 1].append(edge[1])
graphs[edge[2] - 1][edge[1] - 1].append(edge[0])
results = []
for query in self.queries:
to_visit = [(query[0], c) for c in range(self.n_m[1])]
used = set()
visited = [[False] * self.n_m[0] for x in range(self.n_m[1])]
while to_visit:
visiting = to_visit.pop(-1)
if visiting[1] not in used and not visited[visiting[1]][visiting[0] - 1]:
visited[visiting[1]][visiting[0] - 1] = True
if visiting[0] == query[1]:
used.add(visiting[1])
else:
to_visit.extend([(x, visiting[1]) for x in graphs[visiting[1]][visiting[0] - 1]])
colors = len(used)
results.append(colors)
self.result = "\n".join([str(x) for x in results])
def get_result(self):
return self.result
if __name__ == "__main__":
Solution = CodeforcesTask505BSolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())
| 8 | PYTHON3 |
n, m = map(int, input().split())
e, g = {}, {x: set() for x in range(1, n + 1)}
for i in range(m):
a, b, c = map(int, input().split())
e[(a, b)] = e[(b, a)] = e.get((a, b), set()) | {c}
g[a].add(b)
g[b].add(a)
for _ in range(int(input())):
a, b = map(int, input().split())
ans = 0
for color in range(1, m + 1):
vis = [0] * (n + 1)
q = [a]
while q:
v = q.pop()
if v == b:
ans += 1
break
vis[v] = 1
for i in g[v]:
if not vis[i] and color in e[(v, i)]:
q.append(i)
print(ans) | 8 | PYTHON3 |
#include <bits/stdc++.h>
int fx[] = {0, 0, +1, -1};
int fy[] = {+1, -1, 0, 0};
using namespace std;
const int maX = 1e3 + 1;
vector<long long> Graph[maX], cost[maX];
long long visit[maX];
long long color[maX];
long long cc = 0;
void dfs(long long x, long long y, long long z) {
visit[x] = 1;
if (x == z) return;
for (long long i = 0; i < Graph[x].size(); i++) {
long long u = Graph[x][i];
if (visit[u] == 0 && cost[x][i] == y) {
cc++;
dfs(u, y, z);
}
}
}
int main() {
long long n, m, i, j, k = 0;
cin >> n >> m;
for (i = 1; i <= m; i++) {
long long x, y, z;
cin >> x >> y >> z;
Graph[x].push_back(y);
Graph[y].push_back(x);
cost[x].push_back(z);
cost[y].push_back(z);
color[z] = 1;
}
long long q;
cin >> q;
while (q--) {
k = 0;
long long x, y;
cin >> x >> y;
for (i = 1; i <= m; i++) {
memset(visit, 0, sizeof(visit));
if (color[i]) {
dfs(x, i, y);
if (visit[y]) {
k += 1;
}
}
}
cout << k << endl;
}
}
| 8 | CPP |
import sys
# sys.stdin = open('in')
class Dsu:
def __init__(self):
self.__sz = {}
self.__parent = {}
def parent(self, a):
if (a not in self.__parent) or (a == self.__parent[a]):
return a
else:
self.__parent[a] = self.parent(self.__parent[a])
return self.__parent[a]
def connect(self, a, b):
p1 = self.parent(a)
p2 = self.parent(b)
if p2 != p1:
if p1 not in self.__sz:
self.__sz[p1] = 1
if p2 not in self.__sz:
self.__sz[p2] = 1
sz1 = self.__sz[p1]
sz2 = self.__sz[p2]
if sz1 >= sz2:
self.__parent[p2] = p1
self.__sz[p1] += self.__sz[p2]
else:
self.__parent[p1] = p2
self.__sz[p2] += self.__sz[p1]
def connected(self, a, b):
return self.parent(a) == self.parent(b)
# reading input
n, m = [int(i) for i in input().split(' ')]
g = {}
choice = {}
for j in range(m):
a, b, c = [int(i) for i in input().split(' ')]
if c not in g:
g[c] = Dsu()
g[c].connect(a, b)
if a not in choice:
choice[a] = []
if b not in choice:
choice[b] = []
choice[a].append(c)
choice[b].append(c)
# compute output
q = int(input())
mem = {}
for j in range(q):
a, b = [int(i) for i in input().split(' ')]
if a not in choice or b not in choice:
print('0')
continue
if a in mem and type(mem[a]) == dict and b in mem[a]:
s = mem[a][b]
else:
options = set.intersection(set(choice[a]), set(choice[b]))
s = 0
for c in options:
s += int(g[c].connected(a, b))
if a not in mem:
mem[a] = {}
if b not in mem:
mem[b] = {}
mem[a][b] = mem[b][a] = s
print(s) | 8 | PYTHON3 |
n, m = map(int, input().split())
d = {}
adj = [[] for i in range(1 + n)]
d = [[[-1 for k in range(101)] for j in range(1 + n)] for i in range(n + 1)]
for i in range(m):
a, b, c = map(int, input().split())
adj[a].append(b)
adj[b].append(a)
d[a][b][c] = 1
d[b][a][c] = 1
# d[(a, b)] = d.get((a, b), []) + [c]
# d[(b, a)] = d.get((b, a), []) + [c]
visited = [0] * (n + 1)
def dfs(u, target, c):
if u == target:
return True
visited[u] = 1
for v in adj[u]:
if visited[v] == 0 and d[u][v][c] == 1:
if dfs(v, target, c):
return True
return False
for _ in range(int(input())):
u, v = map(int, input().split())
res = 0
for i in range(1, 101):
visited = [0] * (n + 1)
if dfs(u, v, i):
res += 1
print(res) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> nei[105][105];
bool mark[105];
bool DFS(int root, int color, int dest) {
bool res = (root == dest);
mark[root] = true;
for (int i = 0; i < nei[root][color].size(); i++)
if (!mark[nei[root][color][i]])
res |= DFS(nei[root][color][i], color, dest);
return res;
}
int main() {
int n, m;
cin >> n >> m;
int C = 0;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
nei[a][c].push_back(b);
nei[b][c].push_back(a);
C = max(C, c);
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
int count = 0;
for (int col = 1; col <= C; col++) {
memset(mark, 0, sizeof(mark));
if (DFS(a, col, b)) count++;
}
cout << count << endl;
}
return 0;
}
| 8 | CPP |
n, m = list(map(int,input().split()))
p = [ [ i for i in range(n) ] for j in range(m)]
def f(ci,xi):
if xi==p[ci][xi]: return xi
p[ci][xi] = f(ci,p[ci][xi])
return p[ci][xi]
def uni(ci,xi,yi):
p[ci][f(ci,xi)]=f(ci,yi)
for i in range(m):
a, b, c = list(map(int,input().split()))
uni(c-1,a-1,b-1)
for i in range(int(input())):
a, b = list(map(int,input().split()))
print(sum(1 if f(i,a-1) == f(i,b-1) else 0 for i in range(m)))
| 8 | PYTHON3 |
from collections import defaultdict
def dfs(i,col):
bool[i-1] = True
for j in hash1[i]:
if j[1] == col:
if bool[j[0]-1] == False:
dfs(j[0],col)
n,m = map(int,input().split())
hash1 = defaultdict(list)
hash2 = defaultdict(set)
for i in range(m):
a,b,c = map(int,input().split())
hash1[a].append([b,c])
hash2[a].add(c)
hash1[b].append([a,c])
hash2[b].add(c)
q = int(input())
ans = []
for i in range(q):
a,b = map(int,input().split())
count = 0
for j in hash2[a]:
bool = [False]*n
dfs(a,j)
if bool[b-1] == True:
count+=1
ans.append(count)
print(*ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long>> adj[101];
long long vis[101];
long long sum;
void dfs(long long n, long long des, long long c) {
vis[n] = 1;
if (n == des) {
sum++;
return;
}
for (auto x : adj[n]) {
long long ch = x.first;
long long col = x.second;
if (vis[ch] == 0 && col == c) {
dfs(ch, des, c);
}
}
}
void icchhipadey() {
long long n, m;
cin >> n >> m;
long long a, b, c;
long long q;
for (int i = 1; i <= n; i++) vis[i] = 0;
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
adj[a].push_back({b, c});
adj[b].push_back({a, c});
}
cin >> q;
long long ans = 0;
for (int i = 0; i < q; i++) {
cin >> a >> b;
ans = 0;
for (long long col = 1; col <= 100; col++) {
sum = 0;
for (int j = 1; j <= n; j++) {
vis[j] = 0;
}
dfs(a, b, col);
ans += sum;
}
cout << ans << endl;
}
}
int main() { icchhipadey(); }
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
vector<pair<int, int> > adj[n + 1];
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
adj[a].push_back(make_pair(b, c));
adj[b].push_back(make_pair(a, c));
}
int q;
cin >> q;
while (q--) {
int st, en;
cin >> st >> en;
bool visited[n + 1][m + 1];
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++) visited[i][j] = false;
bool color[m + 1];
for (int i = 0; i <= m; i++) color[i] = true;
int cnt = 0;
for (int i = 0; i < adj[st].size(); i++) {
pair<int, int> f = adj[st][i];
int col = f.second;
int star = f.first;
if ((!visited[star][col]) && (color[col])) {
visited[star][col] = true;
queue<int> q;
q.push(star);
while (!q.empty()) {
int u = q.front();
if (u == en) {
cnt++;
color[col] = false;
break;
}
q.pop();
for (int j = 0; j < adj[u].size(); j++) {
pair<int, int> ins = adj[u][j];
if ((!visited[ins.first][ins.second]) && (ins.second == col)) {
visited[ins.first][ins.second] = true;
q.push(ins.first);
}
}
}
}
}
cout << cnt << endl;
}
}
| 8 | CPP |
from collections import deque ,defaultdict
def dfs(node , c):
for i in g[node]:
if not visited[i[0]] and i[1] == c :
visited[i[0]] = True
dfs(i[0] , i[1])
n , m = map(int,input().split())
g = defaultdict(list)
cols = deque()
#g = [[] for i in range(n + 1)]
for i in range(m):
u , v , c = map(int,input().split())
g[u].append([v , c])
g[v].append([u , c])
cols.append(c)
q = int(input())
ans = deque()
for i in range(q):
x , y = map(int,input().split())
cnt = 0
for j in range(1 , m + 1 ):
visited = [False]*(n + 1)
dfs(x , j)
if visited[y] == True:
cnt +=1
ans.append(cnt)
for i in ans:
print(i)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int find(long long int par[], long long int i) {
if (par[i] == i) {
return i;
}
long long int x = find(par, par[i]);
par[i] = x;
return par[i];
}
void un(long long int par[], long long int i, long long int j) {
long long int si = find(par, i);
long long int sj = find(par, j);
if (si == sj) {
return;
}
par[si] = sj;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, m;
cin >> n >> m;
vector<vector<pair<int, int>>> ed(101);
long long int a, b, c;
while (m-- != 0) {
cin >> a >> b >> c;
a--;
b--;
ed[c].push_back(make_pair(a, b));
}
long long int par[n][101];
for (long long int i = 0; i < 101; i++) {
long long int tpar[n];
for (long long int j = 0; j < n; j++) {
tpar[j] = j;
}
for (auto z : ed[i]) {
un(tpar, z.first, z.second);
}
for (long long int j = 0; j < n; j++) {
find(tpar, j);
}
for (long long int j = 0; j < n; j++) {
par[j][i] = tpar[j];
}
}
long long int q;
cin >> q;
long long int u, v, ans;
while (q-- != 0) {
ans = 0;
cin >> u >> v;
u--;
v--;
for (long long int i = 0; i < 101; i++) {
if (par[u][i] == par[v][i]) {
ans++;
}
}
cout << ans << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
const int mod = 1e9 + 7;
vector<pair<long long, long long> > v[N];
bool visit[N];
bool dfs(int a, int b, int color) {
if (a == b) return true;
visit[a] = true;
bool ans = false;
for (auto it : v[a]) {
if (it.second == color and !visit[it.first]) {
ans |= dfs(it.first, b, color);
}
}
return ans;
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m, q;
cin >> n >> m;
for (int i = int(1); i <= int(m); i++) {
int a, b, c;
cin >> a >> b >> c;
v[a].push_back({b, c});
v[b].push_back({a, c});
}
cin >> q;
while (q--) {
int a, b;
cin >> a >> b;
int ans = 0;
for (int i = int(1); i <= int(m); i++) {
memset(visit, false, sizeof visit);
if (dfs(a, b, i)) ans++;
}
cout << ans << '\n';
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > x[105];
int n, m;
int vis[105];
void dfs(int s, int c) {
if (vis[s]) return;
vis[s] = true;
for (int i = 0; i < x[s].size(); i++)
if (x[s][i].second == c) dfs(x[s][i].first, c);
return;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b, c;
cin >> a >> b >> c;
x[a].push_back(make_pair(b, c));
x[b].push_back(make_pair(a, c));
}
cin >> n;
for (int i = 1; i <= n; i++) {
int a, b;
cin >> a >> b;
int cnt = 0;
for (int i = 1; i <= m; i++) {
memset(vis, 0, sizeof(vis));
dfs(a, i);
cnt += vis[b];
}
cout << cnt << endl;
}
}
| 8 | CPP |
def main():
n, m = map(int, input().split())
edges = {_: {} for _ in range(1, m + 1)}
for _ in range(m):
a, b, c = map(int, input().split())
d = edges[c]
l = d.get(a)
if l:
l.append(b)
else:
d[a] = [b]
l = d.get(b)
if l:
l.append(a)
else:
d[b] = [a]
def dfs(t):
unused[t] = False
for y in dcolor.get(t, ()):
if unused[y]:
dfs(y)
res = []
n += 1
unused = [True] * n
for _ in range(int(input())):
a, b = map(int, input().split())
x = 0
for dcolor in edges.values():
for j in range(n):
unused[j] = True
dfs(a)
if not unused[b]:
x += 1
res.append(str(x))
print('\n'.join(res))
if __name__ == '__main__':
main()
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long binomialCoeff(long long n, long long k) {
long long res = 1;
if (k > n - k) k = n - k;
for (long long i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
struct MyComp {
bool operator()(const pair<int, int>& x, const pair<int, int>& y) const {
return x.second > y.second || (x.second == y.second && x.first > y.first);
}
};
long long M = 1e9 + 7;
long long mods(long long a, long long b) {
a = a % M;
b = b % M;
return (a + b) % M;
}
long long modp(long long a, long long b) {
a = a % M;
b = b % M;
return (a * b) % M;
}
vector<pair<int, int> > adj[105];
vector<int> visited(105);
bool dfs(int s, int t, int c) {
visited[s] = 1;
if (s == t) return true;
for (auto u : adj[s]) {
if (visited[u.first] == 0 && u.second == c) {
if (dfs(u.first, t, c)) return true;
}
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y, c;
cin >> x >> y >> c;
adj[x].push_back({y, c});
adj[y].push_back({x, c});
}
int q;
cin >> q;
while (q--) {
for (int i = 1; i <= n; i++) visited[i] = 0;
int a, b;
cin >> a >> b;
int count = 0;
for (int i = 1; i <= m; i++) {
for (int i = 1; i <= n; i++) visited[i] = 0;
if (dfs(a, b, i)) count++;
}
cout << count << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200;
int n, m, u, v, c, q, cnt, mark[maxn];
vector<int> g[maxn][maxn];
void dfs(int w, int col) {
mark[w] = 1;
if (w == v) cnt++;
for (int i = 0; i < g[w][col].size(); i++) {
if (!mark[g[w][col][i]]) {
dfs(g[w][col][i], col);
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v >> c;
g[v][c].push_back(u);
g[u][c].push_back(v);
}
cin >> q;
for (int i = 0; i < q; i++) {
cin >> u >> v;
cnt = 0;
for (int j = 0; j < maxn; j++) {
memset(mark, 0, sizeof mark);
dfs(u, j);
}
cout << cnt << endl;
}
}
| 8 | CPP |
class Solution:
def __init__(self, n, m, edges):
self.n = n
self.m = m
self.edges = [[[] for _ in range(m+1)] for _ in range(n+1)]
for _from, _to, _color in edges:
self.edges[_from][_color].append(_to)
self.edges[_to][_color].append(_from)
self.id = 0
def initialize(self):
self.discovered = [[0]*(self.n+1) for i in range(self.m+1)]
def bfs(self, x0, color):
self.id += 1
stack = [x0]
while stack:
n = stack.pop()
if not self.discovered[color][n]:
self.discovered[color][n] = self.id
for neigh in self.edges[n][color]:
stack.append(neigh)
def solve(graph, colors, u, v):
counter = 0
for color in colors:
if not graph.discovered[color][u] and not graph.discovered[color][v]:
graph.bfs(u, color)
if graph.discovered[color][u] == graph.discovered[color][v]:
counter += 1
return counter
def main():
n, m = map(int, input().split())
edges = []
colors = set()
for _ in range(m):
a, b, c = map(int, input().split())
colors.add(c)
edges.append((a, b, c))
graph = Solution(n, m, edges)
graph.initialize()
q = int(input())
for _ in range(q):
u, v = map(int, input().split())
print(solve(graph, colors, u, v))
if __name__ == '__main__':
main()
| 8 | PYTHON3 |
def build_graph():
line1 = input().strip().split()
n = int(line1[0])
m = int(line1[1])
graph = {}
for _ in range(m):
line = input().strip().split()
u = int(line[0])
v = int(line[1])
c = int(line[2])
if c not in graph:
graph[c] = {j: [] for j in range(1, n+1)}
graph[c][u].append(v)
graph[c][v].append(u)
return graph
parent_history = {}
def no_of_paths(u, v, graph):
x = 0
for c in graph:
if c in parent_history:
if v in parent_history[c]:
parent = parent_history[c]
else:
parent = {}
parent = dfs_visit(v, graph[c], parent)
if len(parent_history[c]) < len(parent):
parent_history[c] = parent
else:
parent = {}
parent = dfs_visit(v, graph[c], parent)
parent_history[c] = parent
if u in parent:
x += 1
return x
def dfs_visit(i, adj_list, parent):
for j in adj_list[i]:
if j not in parent:
parent[j] = i
dfs_visit(j, adj_list, parent)
return parent
if __name__ == "__main__":
graph = build_graph()
for _ in range(int(input())):
line = input().strip().split()
print(no_of_paths(int(line[0]), int(line[1]), graph)) | 8 | PYTHON3 |
#code by aanchaltiwari__
def dfs(x, y, color):
visited = [False for i in range(n + 1)]
visited[x] = True
stack = [x]
while stack:
node = stack.pop()
for child, childcolor in g[node]:
if visited[child] == False and childcolor == color:
visited[child] = True
stack.append(child)
if visited[y] == True:
return True
return False
n, m = map(int, input().split())
g = {i: [] for i in range(1, n + 1)}
s = set()
for i in range(m):
u, v, c = map(int, input().split())
s.add(c)
g[u].append([v, c])
g[v].append([u, c])
s = list(s)
# print(g)
# print(s)
ans = [[0 for i in range(n+1)]for j in range(n+1)]
for i in range(1, n + 1):
for j in range(1, n + 1):
for c in s:
if i != j:
if dfs(i, j, c):
ans[i][j] += 1
# print(ans)
q = int(input())
for i in range(q):
u, v = map(int, input().split())
print(ans[u][v])
| 8 | PYTHON3 |
def DFS(start, color):
global isUsed
isUsed[start] = True
for i in graph[start]:
if not isUsed[i[0]] and i[1] == color:
DFS(i[0], color)
n, m = tuple(map(int, input().split()))
graph = [[] for i in range(n)]
for i in range(m):
a, b, c = tuple(map(int, input().split()))
graph[a - 1].append((b - 1, c))
graph[b - 1].append((a - 1, c))
q = int(input())
answers = [0] * q
for i in range(q):
u, v = tuple(map(int, input().split()))
for j in range(1, m + 1):
isUsed = [False] * n
DFS(u - 1, j)
if isUsed[v - 1]:
answers[i] += 1
print("\n".join(map(str, answers)))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2000000000;
const double pi = acos(-1.0);
int G[105][105][105], cc[105][105], vis[105];
int n, m;
void DFS(int c, int u, int ctr) {
vis[u] = 1;
cc[c][u] = ctr;
for (int i = 1; i < n + 1; i++) {
if (!vis[i] && (G[c][u][i] == 1)) {
DFS(c, i, ctr);
}
}
}
int main() {
ios_base ::sync_with_stdio(false);
while (cin >> n >> m) {
memset(G, 0, sizeof(G));
memset(cc, 0, sizeof(cc));
int a, b, c;
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
G[c][a][b] = 1;
G[c][b][a] = 1;
}
for (int i = 1; i < m + 1; i++) {
memset(vis, 0, sizeof(vis));
int ct = 1;
for (int j = 1; j < n + 1; j++) {
if (!vis[j]) {
DFS(i, j, ct);
ct++;
}
}
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
cin >> a >> b;
int ans = 0;
for (int j = 1; j < m + 1; j++)
if ((cc[j][a] == cc[j][b]) && (cc[j][a] >= 1)) ans++;
cout << ans << endl;
}
}
return 0;
}
| 8 | CPP |
def find(num, color):
while dsu[color][num] != num:
num = dsu[color][num]
return num
inp = lambda : map(int, input().split())
n, m = inp()
dsu = [[i for i in range(n + 1)] for _ in range(101)]
for i in range(m):
x, y, z = inp()
x1 = find(x, z)
y1 = find(y, z)
if x1 != y1:
dsu[z][x1] = y1
q = int(input())
for i in range(q):
x, y = inp()
ans = 0
for j in range(101):
if find(x, j) == find(y, j):
ans += 1
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 120 + 7;
const long long INF = 1e9;
const long long mod = 1e9 + 7;
int n;
int m;
int k;
int used[N];
vector<pair<int, int> > g[N];
void dfs(int v, int c) {
used[v] = 1;
for (auto to : g[v]) {
if (!used[to.first] && to.second == c) {
dfs(to.first, c);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y, z;
cin >> x >> y >> z;
g[x].push_back({y, z});
g[y].push_back({x, z});
}
cin >> k;
while (k--) {
int x, y;
cin >> x >> y;
map<int, int> T;
for (auto to : g[x]) {
dfs(x, to.second);
if (used[y]) {
T[to.second]++;
}
for (int i = 1; i <= n; i++) {
used[i] = 0;
}
}
cout << T.size() << endl;
T.clear();
}
}
| 8 | CPP |
n,m = input().split(' ')
l = []
for x in range(int(m)):
l.append(list(range(int(n))))
for x in range(int(m)):
p = input().split(' ')
newl = l[int(p[2])-1]
a,i = max(newl[int(p[0])-1],newl[int(p[1])-1]),min(newl[int(p[0])-1],newl[int(p[1])-1])
for y in range(len(newl)):
if newl[y] == a:
newl[y] = i
l[int(p[2])-1] = newl
q = int(input())
put = []
for x in range(q):
out = 0
a,b = input().split(' ')
for n in l:
if n[int(a)-1] == n[int(b)-1]:
out += 1
put.append(out)
for x in put:
print(x)
| 8 | PYTHON3 |
import queue
n, m = map(int, input().strip().split())
adj = [[] for i in range(n + 1)]
def doable(s, t, c):
global adj, n, m
q = queue.Queue()
visited = [False for i in range(n + 1)]
q.put(s)
visited[s] = True
while not q.empty():
u = q.get()
for v in adj[u]:
if v[1] == c and not visited[v[0]]:
q.put(v[0])
visited[v[0]] = True
return visited[t]
maxc = 0
for _ in range(m):
u, v, c = map(int, input().strip().split())
adj[u].append((v, c))
adj[v].append((u, c))
maxc = max(maxc, c)
q = int(input())
for _ in range(q):
u, v = map(int, input().strip().split())
ans = 0
for color in range(1, maxc + 1):
if (doable(u, v, color)):
ans += 1
print(ans)
| 8 | PYTHON3 |
from sys import stdin, stdout
def find(node, color):
x = []
while colors[color][node] > 0:
x.append(node)
node = colors[color][node]
for i in x:
colors[color][i] = node
return node
def union(node1, node2, color):
if node1 != node2:
if colors[color][node1] > colors[color][node2]:
node1, node2 = node2, node1
colors[color][node1] += colors[color][node2]
colors[color][node2] = node1
n, m = map(int, stdin.readline().strip().split())
colors = [[-1 for i in range(n+1)] for j in range(m+1)]
for __ in range(m):
a, b, c = map(int, stdin.readline().strip().split())
union(find(b, c), find(a, c), c)
q = int(stdin.readline().strip())
outputs = []
for __ in range(q):
count = 0
a, b = map(int, stdin.readline().strip().split())
for i in range(1, m+1):
if find(a, i) == find(b, i):
count += 1
outputs.append(count)
for output in outputs:
stdout.write(f'{output}\n')
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool uax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
bool uin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &p) {
in >> p.first >> p.second;
return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, pair<T1, T2> &p) {
out << p.first << ' ' << p.second;
return out;
}
const int B = 300;
int n, m, q;
map<pair<int, int>, pair<int, int>> k;
vector<vector<pair<int, int>>> g;
map<pair<int, int>, int> ans;
int fp(int x, int z) {
if (k.find(make_pair(x, z)) == k.end()) {
k[make_pair(x, z)] = make_pair(x, 1);
return x;
}
if (k[make_pair(x, z)].first == x) {
return x;
} else {
return k[make_pair(x, z)].first = fp(k[make_pair(x, z)].first, z);
}
}
void un(int x, int y, int z) {
x = fp(x, z);
y = fp(y, z);
if (x != y) {
pair<int, int> kx = k[make_pair(x, z)], ky = k[make_pair(y, z)];
if (kx.second < ky.second) {
swap(x, y);
swap(kx, ky);
}
k[make_pair(y, z)].first = x;
if (ky.second == kx.second) {
k[make_pair(x, z)].second++;
}
}
}
bool cmp(pair<int, int> a, pair<int, int> b) {
a = make_pair(a.second, a.first);
b = make_pair(b.second, b.first);
return a < b;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
g.resize(n);
int x, y, z;
for (int i = 0; i < m; i++) {
cin >> x >> y >> z;
x--;
y--;
z--;
g[x].push_back(make_pair(y, z));
g[y].push_back(make_pair(x, z));
un(x, y, z);
}
for (int i = 0; i < n; i++) {
sort(g[i].begin(), g[i].end(), cmp);
}
cin >> q;
for (int i = 0; i < q; i++) {
cin >> x >> y;
x--;
y--;
if (g[x].size() > g[y].size()) {
swap(x, y);
}
if (ans.find(make_pair(x, y)) != ans.end()) {
cout << ans[make_pair(x, y)] << "\n";
continue;
}
int ret = 0;
if (g[x].size() == 0) {
cout << ret << "\n";
ans[make_pair(x, y)] = ret;
continue;
}
if (fp(x, g[x][0].second) == fp(y, g[x][0].second)) {
ret++;
}
for (int j = 1; j < g[x].size(); j++) {
if (g[x][j].second == g[x][j - 1].second) {
continue;
}
if (fp(x, g[x][j].second) == fp(y, g[x][j].second)) {
ret++;
}
}
cout << ret << "\n";
ans[make_pair(x, y)] = ret;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXX = 1e2 + 10;
int T, n, m, ans;
vector<pair<int, int> > adj[MAXX];
bool vis[MAXX];
void dfs(int v, int c) {
vis[v] = 1;
for (auto x : adj[v])
if (x.second == c && !vis[x.first]) dfs(x.first, x.second);
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v, c;
cin >> u >> v >> c, --v, --u;
adj[v].push_back({u, c}), adj[u].push_back({v, c});
}
cin >> T;
while (T--) {
int v, u;
cin >> v >> u;
v--, u--, ans = 0;
for (int i = 1; i <= 100; i++) {
fill(vis, vis + MAXX, 0);
dfs(v, i);
ans += vis[u];
}
cout << ans << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > adj[102];
set<int> s;
bool vis[102];
int des;
void dfs(int u, int path) {
if (u == des) {
s.insert(path);
return;
}
if (vis[u]) {
return;
}
vis[u] = true;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i].first, c = adj[u][i].second;
if (c == path && !vis[v]) {
dfs(v, path);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
adj[a].push_back(make_pair(b, c));
adj[b].push_back(make_pair(a, c));
}
int q;
cin >> q;
while (q--) {
int u, v;
cin >> u >> v;
s.clear();
des = v;
for (int i = 1; i <= m; i++) {
memset(vis, false, sizeof(vis));
dfs(u, i);
}
cout << s.size() << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> adj[101];
set<pair<long long int, long long int>> color[101];
long long int visited[101];
long long int x;
void bfs(long long int a, long long int b, long long int c) {
queue<long long int> q;
q.push(a);
while (!q.empty()) {
long long int p = q.front();
q.pop();
if (p == b) {
x = 1;
visited[p] = 1;
}
if (visited[p]) continue;
visited[p] = 1;
for (long long int i = 0; i < adj[p].size(); i++) {
if (color[c].find({p, adj[p][i]}) != color[c].end()) {
q.push(adj[p][i]);
}
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int i, j, k, l, m, n, p, t, a, b, c, q;
cin >> n >> m;
set<pair<long long int, long long int>> s;
for (i = 0; i < m; i++) {
cin >> a >> b >> c;
if (s.find({a, b}) == s.end()) {
s.insert({a, b});
adj[a].push_back(b);
adj[b].push_back(a);
}
color[c].insert({a, b});
color[c].insert({b, a});
}
cin >> q;
for (i = 0; i < q; i++) {
cin >> a >> b;
p = 0;
for (j = 1; j <= m; j++) {
x = 0;
bfs(a, b, j);
p += x;
memset(visited, 0, sizeof(visited));
}
cout << p << "\n";
}
}
| 8 | CPP |
n,m = list(map(int,input().split(" ")))
Meow =[]
for i in range(101):
Meow.append([])
for j in range(n+1):
Meow[i].append(j)
def root(N,C):
while(Meow[C][N]!=N):
Meow[C][N] = Meow[C][Meow[C][N]];
N=Meow[C][N]
return N
def union(A,B,C):
p = root(A,C)
q = root(B,C)
Meow[C][p]=q
for i in range(m):
a,b,c = list(map(int,input().split(" ")))
union(a,b,c)
q = int(input())
for i in range(q):
a,b = list(map(int,input().split(" ")))
cnt=0;
for i in range(1,101):
if(root(a,i)==root(b,i)):
cnt+=1
print(cnt)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
class Node {
public:
int v;
vector<int> neighbours, colors;
Node(int v) { v = v; }
};
bool dfs(Node **arr, int color, bool *visited, int cur, int dest) {
if (cur == dest) return true;
visited[cur] = true;
bool found = false;
for (int i = 0; i < arr[cur]->neighbours.size(); i++) {
if (arr[cur]->colors[i] == color && !visited[arr[cur]->neighbours[i]]) {
found = dfs(arr, color, visited, arr[cur]->neighbours[i], dest);
}
if (found) {
visited[cur] = false;
return true;
}
}
visited[cur] = false;
return false;
}
int main() {
int n, m;
cin >> n >> m;
Node *arr[n + 1];
for (int i = 0; i <= n; i++) arr[i] = new Node(i);
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
arr[a]->neighbours.push_back(b);
arr[a]->colors.push_back(c);
arr[b]->neighbours.push_back(a);
arr[b]->colors.push_back(c);
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int u, v;
cin >> u >> v;
bool visited[n + 1];
memset(visited, 0, (n + 1) * sizeof(bool));
int colors[m + 1];
memset(colors, 0, (m + 1) * sizeof(int));
int num = 0;
for (int i = 0; i < arr[u]->neighbours.size(); i++) {
if (!colors[arr[u]->colors[i]]) {
if (dfs(arr, arr[u]->colors[i], visited, arr[u]->neighbours[i], v))
num++;
colors[arr[u]->colors[i]] = 1;
}
}
cout << num << endl;
}
return 0;
}
| 8 | CPP |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.