text stringlengths 49 983k |
|---|
#include<bits/stdc++.h>
using namespace std;
struct bian{
int x,to,next;
}edge[400001];
int head[100005],tot=0;
void add(int x,int y,int z){
edge[++tot].next=head[x];edge[tot].to=y;edge[tot].x=z;head[x]=tot;
}
int n,m,vis[100005],dis[100005];
void dfs(int x,int fa){
vis[x]=1;
for(int i=head[x];i;i=edge[i].next)if(fa!=edge[i].to){
if(dis[edge[i].to]!=0x7f7f7f7f){
if(edge[i].x!=dis[edge[i].to]-dis[x]){
puts("No");exit(0);
}
}else{
dis[edge[i].to]=dis[x]+edge[i].x;
dfs(edge[i].to,x);
}
}
}
int main(){
scanf("%d%d",&n,&m);
for(int i=1,x,y,z;i<=m;++i){
scanf("%d%d%d",&x,&y,&z);
add(x,y,z);
add(y,x,-z);
}
memset(dis,0x7f,sizeof dis);
for(int i=1;i<=n;++i)if(!vis[i])dfs(i,i);
puts("Yes");
return 0;
} |
#include <iostream>
#include <vector>
using namespace std;
vector<vector<int>> G;
int d[200010], l[200010], r[200010], x[200010];
bool det[200010];
bool dfs(int key){
det[key]=true;
bool res=true;
for(int i=0; i<G[key].size(); ++i){
int antic=x[key], nx=l[G[key][i]]+r[G[key][i]]-key;
if(l[G[key][i]]==key) antic += d[G[key][i]];
else antic -= d[G[key][i]];
if(det[nx]){
res=res&&(x[nx]==antic);
}else{
x[nx]=antic;
res=res&&dfs(nx);
}
}
return res;
}
int main() {
int N, M;
cin >> N >> M;
G.resize(N+1);
for(int i=0; i<M; ++i){
cin >> l[i] >> r[i] >> d[i];
G[l[i]].emplace_back(i);
G[r[i]].emplace_back(i);
}
bool flag=true;
for(int i=1; i<=N; ++i){
if(!det[i]){
x[i]=0;
flag=flag&&dfs(i);
}
}
cout << (flag ? "Yes" : "No") << endl;
return 0;
} |
#include<cstdio>
#include<algorithm>
#define MAX 200005
using namespace std;
struct A{ int par; int dis; };
A a[MAX];
void getp(int x){
if(a[x].par != x){
getp(a[x].par);
a[x].dis += a[a[x].par].dis;
a[x].par = a[a[x].par].par;
}
}
int main(){
int n, m, l, r, d, i;
bool flag = true;
scanf("%d%d", &n, &m);
for(i = 1; i <= n; i++){
a[i].par = i;
a[i].dis = 0;
}
for(i = 0; i < m; i++){
scanf("%d%d%d", &l, &r, &d);
getp(l);
getp(r);
if(a[l].par == a[r].par){
if(a[r].dis - a[l].dis != d) flag = false;
}else{
a[a[r].par].dis = -a[r].dis + d + a[l].dis;
a[a[r].par].par = a[l].par;
}
}
if(flag) printf("Yes\n");
else printf("No\n");
} |
#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<algorithm>
using namespace std;
const int N=100005;
int n,m;
int fa[N],dis[N];
int find(int x)
{
if (x==fa[x]) return x;
int t=find(fa[x]);
dis[x]+=dis[fa[x]];
return fa[x]=t;
}
int main()
{
scanf("%d%d",&n,&m);
for (int i=1;i<=n;i++) fa[i]=i;
int x,y,d,fx,fy;
bool o=true;
while (m--)
{
scanf("%d%d%d",&y,&x,&d);
if (!o) continue;
fx=find(x),fy=find(y);
if (fx==fy)
{
if (dis[x]-dis[y]!=d) o=false;
}
else
{
fa[fx]=fy;
dis[fx]=-dis[x]+dis[y]+d;
}
}
if (o) puts("Yes");else puts("No");
return 0;
} |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 2e5 + 10;
int f[N];
ll dis[N];
void fail() {
puts("No");
exit(0);
}
int find(int k) {
if(f[k] == k) return k;
else {
int fa = find(f[k]);
dis[k] += dis[f[k]];
return f[k] = fa;
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for(int i = 1; i <= n; ++i) f[i] = i;
for(int i = 1, x, y, z; i <= m; ++i) {
scanf("%d%d%d", &x, &y, &z);
int fx = find(x), fy = find(y);
if(fx == fy) {
if(dis[y] - dis[x] != z) fail();
} else {
f[fy] = fx;
dis[fy] = dis[x] - dis[y] + z;
}
}
puts("Yes");
return 0;
} |
#include<cstdio>
#include<algorithm>
#include<cstring>
#define rep(i, s, t) for(i = s; i <= t; ++i)
#define dep(i, s, t) for(i = s; i >= t; --i)
using namespace std;
const int N = 1e5 + 10;
int n, m; bool ans = 1;
int pos[N];
struct edge{int ed, v, ne;} e[N<<1]; int he[N], in[N], en;
void ins(int a, int b, int c) {
e[++en].ed = b; e[en].v = c; e[en].ne = he[a]; he[a] = en; ++in[b];
}
void dfs(int u) {
for(int i = he[u], v; i; i = e[i].ne) {
v = e[i].ed;
if(!pos[v]) {
pos[v] = pos[u] + e[i].v;
dfs(v);
} else
if(pos[u] + e[i].v != pos[v]) ans = 0;
}
}
int main() {
int i, x, y, z;
scanf("%d%d", &n, &m);
rep(i, 1, m) {scanf("%d%d%d", &x, &y, &z); ins(x, y, z);}
rep(i, 1, n) if(!in[i]) {pos[i] = 1; dfs(i);}
rep(i, 1, n) if(!pos[i]) ans = 0;
if(ans) puts("Yes"); else puts("No");
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010, INF = (int) 1e9 + 10;
vector< pair<int,int> > edge[N];
int d[N];
bool DFS(int v, int dis) {
if ( d[v] != -INF && d[v] != dis ) return 0;
else if ( d[v] != -INF && d[v] == dis ) return 1;
d[v] = dis;
bool ok = 1;
for ( auto u:edge[v] ) {
ok &= DFS(u.first,dis+u.second);
}
return ok;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
edge[u].push_back( make_pair(v,w) );
edge[v].push_back( make_pair(u,-w) );
}
fill( d+1, d+n+1, -INF);
bool ok = 1;
for (int i = 1; i <= n; i++) {
if ( d[i] == -INF ) {
ok &= DFS(i,0);
}
}
puts( ok ? "Yes" : "No");
return 0;
}
|
#include<cstdio>
#include<vector>
#include<tuple>
using namespace std;
vector<pair<int, int>> map[100001];
int ind[100001];
int l[100001];
int v[100001];
bool dfs(int x) {
int t, w;
v[x] = 1;
for (auto e : map[x]) {
tie(t, w) = e;
if (v[t] == 0) {
l[t] = l[x] + w;
if (!dfs(t)) return false;
}
else {
if (l[t] != l[x] + w) return false;
}
}
return true;
}
int main() {
int n, m, a, b, c;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &a, &b, &c);
map[a].emplace_back(b, c);
map[b].emplace_back(a, -c);
}
for (int i = 1; i <= n; i++) {
if (v[i] == 0) {
if (!dfs(i)) {
printf("No\n");
return 0;
}
}
}
printf("Yes\n");
return 0;
} |
#include<cstdio>
int n,m,fa[100005],dis[100005];
bool ok=1;
int find(int x){
if(fa[x]!=x){
int nf=fa[x];
fa[x]=find(fa[x]);
dis[x]+=dis[nf];
}
return fa[x];
}
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
fa[i]=i;
for(int i=1;i<=m;i++){
int l,r,d;
scanf("%d%d%d",&l,&r,&d);
int rl=find(l),rr=find(r);
if(rl==rr&&dis[l]-dis[r]!=d)
ok=0;
if(rl!=rr){
fa[rl]=rr;
dis[rl]=d+dis[r]-dis[l];
}
}
if(ok)printf("Yes");
else printf("No");
return 0;
} |
#include <cstdio>
#include <iostream>
using namespace std;
const int N = 1e5 + 5;
int fa[N], val[N];
inline int getf(int x) {
if (x == fa[x]) return x;
else {
getf(fa[x]);
val[x] += val[fa[x]];
fa[x] = fa[fa[x]];
return fa[x];
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i ++) fa[i] = i;
for (int a, b, l, r, d; m; m --) {
scanf("%d%d%d", &l, &r, &d);
a = getf(l); b = getf(r);
if (a == b) {
if (val[r] - val[l] != d) return puts("No"), 0;
}
else {
d += val[l] - val[r];
fa[b] = a;
val[b] += d;
}
}
puts("Yes");
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
struct node{
int f,dis;
};
node f[100001];
int findx(int x){
if(f[x].f==x&&f[x].dis==0)return x;
int k=findx(f[x].f);
f[x].dis=f[f[x].f].dis+f[x].dis;
f[x].f=k;
return k;
}
int main(){
int n,m;
cin>>n>>m;
for(int i=1;i<=n;i++){
f[i].f=i;
f[i].dis=0;
}
for(int i=1;i<=m;i++){
int a,b,d;
cin>>a>>b>>d;
int k1=findx(a),k2=findx(b);
if(k1!=k2){
/*if(a>b){
swap(a,b);
d=-d;
}*/
if(k1>k2){
f[k1].f=k2;
f[k1].dis=-(f[a].dis-f[b].dis+d);
}
else{
f[k2].f=k1;
f[k2].dis=f[a].dis-f[b].dis+d;
}
}
else{
if(f[b].dis-f[a].dis!=d){
cout<<"No";
return 0;
}
}
}
cout<<"Yes";
} |
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN = 200000+9;
int fa[MAXN];
int val[MAXN];
int n,m;
int Find(int x){
if(fa[x]==x)return x;
int tmp=fa[x];
fa[x]=Find(fa[x]);
val[x]=val[tmp]+val[x];
return fa[x];
}
void Union(int x,int y,int det){
int xx=Find(x);int yy=Find(y);
val[yy]=det;
fa[yy]=xx;
}
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++){
fa[i]=i;
}
for(int i=1;i<=m;i++){
int a,b,c;
scanf("%d%d%d",&a,&b,&c);
int aa=Find(a);
int bb=Find(b);
if(aa==bb){
if(c!=val[b]-val[a]){
puts("No");
return 0;
}
}
else
Union(a,b,c+val[a]-val[b]);
}
puts("Yes");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i=0;i<(n);i++)
#define Rep(i,a,b) for (int i=(a);i<=(b);i++)
#define rrep(i,n) for (int i=(n)-1;i>=0;i--)
#define rRep(i,a,b) for (int i=(a);i>=b;i--)
const int Maxn=100005;
int n,m;
vector <pair <int,int> > v[Maxn];
bool used[Maxn];
int a[Maxn];
bool dfs(int cur,int col)
{
if (used[cur])
{
return a[cur]==col;
}
used[cur]=true;
a[cur]=col;
for (auto &u:v[cur])
{
if (!dfs(u.first,a[cur]+u.second))
{
return false;
}
}
return true;
}
int main()
{
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));
}
for (int i=1;i<=n;i++)
{
if (!used[i])
{
if (!dfs(i,0))
{
cout<<"No";
return 0;
}
}
}
cout<<"Yes";
return false;
} |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
ll n, m;
vector<pair<ll, ll>> v[100000];
bool used[100000];
ll koko[100000];
bool dfs(ll now){
bool ret = 1;
for(pair<ll, ll> next : v[now]){
if(used[next.first]){
if(koko[next.first] != koko[now] + next.second) return false;
}else{
used[next.first] = 1;
koko[next.first] = koko[now] + next.second;
ret &= dfs(next.first);
}
}
return ret;
}
int main(){
ios_base::sync_with_stdio(false);
cin >> n >> m;
for(ll i = 0; i < m; i++){
ll l, r, d; cin >> l >> r >> d;
v[--l].push_back(pair<ll, ll>(--r, d));
v[r].push_back(pair<ll, ll>(l, -d));
}
bool ans = 1;
for(ll i = 0; i < n; i++){
if(!used[i]){
used[i] = 1;
}
ans &= dfs(i);
}
cout << (ans ? "Yes\n" : "No\n");
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define int long long
typedef pair <int, int> ii;
const int N = 1e5 + 5;
int n, m, d[N], tin[N], dfsTime;
vector <ii> adj[N];
bool mark[N];
void dfs(int u) {
tin[u] = ++dfsTime;
mark[u] = 1;
for (ii p : adj[u]) {
int v = p.first, w = p.second;
if (!mark[v]) {
d[v] = d[u] + w;
dfs(v);
} else if (tin[v] > tin[u]) {
if (d[v] - d[u] != w) {
cout << "No";
exit(0);
}
}
}
}
signed main() {
ios_base::sync_with_stdio(0); cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int l, r, x;
cin >> l >> r >> x;
adj[r].push_back({l, x});
adj[l].push_back({r, -x});
}
for (int i = 1; i <= n; ++i) if (!mark[i])
dfs(i);
cout << "Yes";
return 0;
} |
#include <iostream>
#include <cstdio>
#include <vector>
#include <cstdlib>
using namespace std;
//const int SP = 2100000000;
int n, m;
int l, r, d;
int a[100005];
int b[100005];
bool ans = true;
vector<int> vx[100005], wt[100005];
void dfs(int p, int q)
{
if(b[p])
{
if(a[p] != q) printf("No"), exit(0);
return;
}
b[p] = true;
a[p] = q;
for(int i = 0; i < vx[p].size(); i++)
{
dfs(vx[p][i], wt[p][i] + q);
}
}
int main()
{
scanf("%d%d", &n, &m);
for(int i = 0; i < m; i++)
{
scanf("%d%d%d", &l, &r, &d);
vx[l].push_back(r);
vx[r].push_back(l);
wt[l].push_back(d);
wt[r].push_back(-d);
}
for(int i = 1; i <= n; i++)
{
if(!b[i]) dfs(i, 0);
}
printf("Yes");
return 0;
}
|
#include<cstdio>
#include<algorithm>
using namespace std;
const int N = 100005;
int gi()
{
int x=0,w=1;char ch=getchar();
while ((ch<'0'||ch>'9')&&ch!='-') ch=getchar();
if (ch=='-') w=0,ch=getchar();
while (ch>='0'&&ch<='9') x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
return w?x:-x;
}
int n,m,fa[N],dis[N];
int find(int x)
{
int ff=fa[x];
if (x==fa[x]) return x;
fa[x]=find(fa[x]);
dis[x]+=dis[ff];
return fa[x];
}
int abs(int x){return x>0?x:-x;}
int main()
{
n=gi();m=gi();
for (int i=1;i<=n;i++) fa[i]=i;
while (m--)
{
int l=gi(),r=gi(),d=gi();
if (find(l)^find(r))
{
int fl=find(l),fr=find(r);
int dd=dis[r]-dis[l]-d;
if (dd>0) swap(fl,fr);
fa[fr]=fl,dis[fr]=abs(dd);
}
else
{
if (dis[r]-dis[l]!=d)
return puts("No"),0;
}
}
return puts("Yes"),0;
} |
#include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
using namespace std;
const int N = 200050;
int vis[N], a[N], L[N], R[N], D[N];
int n, m;
vector<pair<int, int> > g[N];
void dfs(int u){
for(auto p : g[u]){
if (vis[p.first]) continue;
vis[p.first] = 1;
a[p.first] = a[u] + p.second;
dfs(p.first);
}
}
int main(){
// freopen("input.inp", "r", stdin);
scanf("%d%d", &n, &m);
for(int i = 1; i <= m; ++i){
scanf("%d%d%d", &L[i], &R[i], &D[i]);
g[L[i]].pb(mp(R[i], D[i]));
g[R[i]].pb(mp(L[i], -D[i]));
}
for(int i = 1; i <= n; ++i) if (!vis[i]){
vis[i] = 1;
dfs(i);
}
for(int i = 1; i <= m; ++i) if (a[L[i]] + D[i] != a[R[i]]){
puts("No");
return 0;
}
puts("Yes");
return 0;
} |
#prag\
ma GCC optimize("O3")
#include<bits/stdc++.h>
using namespace std;
#define f first
#define s second
pair<int,int> fa[100001];
int find(int x){
if(fa[x].f==x&&fa[x].s==0) return x;
int t=find(fa[x].f);
fa[x]=make_pair(t,fa[fa[x].f].s+fa[x].s);
fa[x].f=t;
return t;
}
int main()
{
ios::sync_with_stdio(false);
int n,m;
cin>>n>>m;
for(int i=1;i<=n;++i) fa[i]=make_pair(i,0);
for(int i=1;i<=m;++i){
int l,r,d;
cin>>l>>r>>d;
int x=find(l),y=find(r);
if(x!=y){
if(x>y) fa[x]=make_pair(y,-(fa[l].s-fa[r].s+d));
else fa[y]=make_pair(x,fa[l].s-fa[r].s+d);
}
else{
if(fa[r].s-fa[l].s!=d){
cout<<"No";
return 0;
}
}
}
cout<<"Yes";
} |
/*input
3 3
1 2 1
2 3 1
1 3 5
*/
#include <iostream>
#include <vector>
typedef std::pair<int, int> ii;
const int ms = 100100;
std::vector<ii> edges[ms];
int pos[ms];
bool visit[ms];
bool dfs(int on, int cur = 0) {
if(visit[on]) {
return cur == pos[on];
}
pos[on] = cur;
visit[on] = true;
for(auto a : edges[on]) {
if(!dfs(a.first, cur + a.second)) {
return false;
}
}
return true;
}
int main() {
int n;
int m;
std::cin >> n >> m;
for(int i = 0; i < m; i++) {
int u, v, d;
std::cin >> u >> v >> d;
edges[u].push_back(ii(v, d));
edges[v].push_back(ii(u, -d));
}
bool ans = true;
for(int i = 1; i <= n; i++) {
if(!visit[i]) {
ans = ans && dfs(i);
}
}
std::cout << (ans ? "Yes" : "No") << '\n';
} |
#include<cstdio>
#include<vector>
#include<algorithm>
#define MAXN 100006
using namespace std;
int fa[MAXN],re[MAXN],n,b,a,d,m;
int root(int x)
{
if(fa[x]==x) return x;
int lastfa=fa[x];
int haha=root(fa[x]);
re[x]=re[x]+re[lastfa];
fa[x]=haha;
return haha;
}
bool work()
{
for(int i=1;i<=n;i++)
fa[i]=i;
for(int i=1;i<=m;i++)
{
scanf("%d%d%d",&a,&b,&d);
int roota=root(a);
int rootb=root(b);
if(roota==rootb)
{
if(re[a]!=re[b]+d) return 0;
}
else
{
fa[roota]=rootb;
re[roota]=d+re[b]-re[a];
}
}
return 1;
}
int main()
{
scanf("%d%d",&n,&m);
if(work()) printf("Yes");
else printf("No");
} |
#include<bits/stdc++.h>
using namespace std;
struct bian{
int x,to,next;
}edge[400001];
int cnt,head[100001],dis[100001];
bool vis[100001],f;
inline void add(int u,int v,int x){
edge[++cnt].x=x,edge[cnt].to=v,edge[cnt].next=head[u],head[u]=cnt;
}
inline void dfs(int x,int fa){
vis[x]=1;
for(int i=head[x];i;i=edge[i].next)
if(fa!=edge[i].to){
if(dis[edge[i].to]!=0x7f7f7f7f){
if(edge[i].x!=dis[edge[i].to]-dis[x]){
puts("No");exit(0);
}
}else{
dis[edge[i].to]=dis[x]+edge[i].x;
dfs(edge[i].to,x);
}
}
}
int main()
{
ios::sync_with_stdio(false);
int n,m;
cin>>n>>m;
for(int i=1;i<=m;i++){
int l,r,d;
cin>>l>>r>>d;
add(l,r,d),add(r,l,-d);
}
memset(dis,0x7f,sizeof dis);
for(int i=1;i<=n;i++)
if(!vis[i]) dfs(i,i);
cout<<"Yes";
} |
#include<iostream>
using namespace std;
const int maxn = 100005;
int f[maxn], sum[maxn];
int find(int a)
{
if (f[a] != a)
{
int pre = f[a];
f[a] = find(f[a]);
sum[a] = sum[a] + sum[pre];
}
return f[a];
}
void Union(int u, int v, int rootu, int rootv, int val)
{
f[rootu] = rootv;
sum[rootu] = -sum[u] + val + sum[v];
}
int main()
{
int N, M;
scanf("%d %d", &N, &M);
for (int i = 1;i <= N;i++)f[i] = i,sum[i]=0;
int u, v, rootu, rootv, dist;
bool flag = true;
for (int i = 1;i <= M;i++)
{
scanf("%d %d %d", &u, &v, &dist);
rootu = find(u);
rootv = find(v);
if (rootu != rootv)
{
Union(u, v, rootu, rootv, dist);
}
else
{
if (sum[u] - sum[v] != dist)
flag = false;
}
}
if (flag)puts("Yes");
else puts("No");
return 0;
} |
#include<bits/stdc++.h>
#define maxn 100100
using namespace std;
int fa[maxn];
long long a[maxn];
int ff(int x)
{
vector<long long>t,u;
while(x!=fa[x])
{
t.push_back(x);
u.push_back(a[x]);
x=fa[x];
}
long long s=0;
for(int i=(int)t.size()-1;i>=0;i--)
{
s+=u[i];
a[t[i]]=s;
fa[t[i]]=x;
}
return x;
}
int main()
{
cin.tie(0);ios_base::sync_with_stdio(false);
int n,m,l,r,d;
cin>>n>>m;
for(int i=1;i<=n;i++)fa[i]=i;
while(m--)
{
cin>>l>>r>>d;
ff(l);
ff(r);
if(fa[l]==fa[r])
{
if(a[r]-a[l]==d)continue;
else {cout<<"No"<<endl;exit(0);}
}
a[fa[r]]=a[l]-a[r]+d;
fa[fa[r]]=fa[l];
}
cout<<"Yes"<<endl;
return 0;
}
|
#include <cstdio>
#include <vector>
using namespace std;
vector<pair<int, int> > g[100001];
int v[100001];
int d[100001];
int f(int x, int y) {
if (v[x]) return d[x] != y;
v[x] = 1;
d[x] = y;
for (auto t : g[x]) if (f(t.first, y + t.second)) return 1;
return 0;
}
int main() {
int i, j, k, n, m;
scanf("%d%d", &n, &m);
while (m--) {
scanf("%d%d%d", &i, &j, &k);
g[i].emplace_back(j, k);
g[j].emplace_back(i, -k);
}
for (i = 1; i <= n; i++) if (!v[i] && f(i, 0)) {
puts("No");
return 0;
}
puts("Yes");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[100010],d[100010];
int findd(int x)
{
if(f[x]==x) return x;
int a=f[x];
int b=findd(f[x]);
d[x]+=d[a];
f[x]=b;
return b;
}
bool unit(int x,int y,int c)
{
int fx=findd(x);
int fy=findd(y);
if(fx==fy)
{
if(d[y]-d[x]==c) return 1;
else return 0;
}
f[fy]=fx;
d[fy]=d[x]+c-d[y];
return 1;
}
int main()
{
int n,m;
while(~scanf("%d%d",&n,&m))
{
int flag=0;
int l,r,d;
for(int i=1;i<=n;i++)f[i]=i;
for(int i=0;i<m;i++)
{
scanf("%d%d%d",&l,&r,&d);
if(!unit(l,r,d))
{
flag=1;
}
}
if(flag) cout<<"No"<<endl;
else cout<<"Yes"<<endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
int n,m,fa[100005],vv[100005];
int find(int x){
if(x==fa[x])return x;
int k=find(fa[x]);
vv[x]+=vv[fa[x]];
fa[x]=k;
return k;
}
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)fa[i]=i;
while(m--){
int u,v,val;
scanf("%d%d%d",&u,&v,&val);
int fu=find(u),fv=find(v);
if(fu!=fv){
fa[fu]=fv;
vv[fu]=vv[v]+val-vv[u];
}
else{
if(vv[u]-vv[v]!=val){
puts("No");
return 0;
}
}
}
puts("Yes");
} |
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int n,m;
vector<pair<int,int> > e[100010];
long long pos[100010];
bool vis[100010];
inline void dfs(int x)
{
vis[x]=1;
for(int i=0;i<e[x].size();i++)
{
pair<int,int> cur=e[x][i];
if(vis[cur.first])
{
if(pos[cur.first]-pos[x]!=cur.second) {cout<<"No";exit(0);}
}
else
{
pos[cur.first]=pos[x]+cur.second;
dfs(cur.first);
}
}
}
int main()
{
cin>>n>>m;
for(int i=0;i<m;i++)
{
int l,r,d;
cin>>l>>r>>d;
e[l].push_back({r,d});
e[r].push_back({l,-d});
}
for(int i=0;i<n;i++) if(!vis[i]) dfs(i);
cout<<"Yes";
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long int LL;
const int MAXN = 100005;
int n, m, fa[MAXN]; LL val[MAXN];
int find(int x){
if(fa[x] < 0) return x;
int ret = find(fa[x]);
val[x] += val[fa[x]];
return fa[x] = ret;
}
int main(){
int i, a, b, c, tmp;
memset(fa, -1, sizeof(fa));
scanf("%d%d", &n, &m);
for(i = 1; i <= m; ++ i){
scanf("%d%d%d", &a, &b, &c);
if(find(a) != find(b)){
val[tmp = find(a)] = val[b] - c - val[a];
fa[tmp] = find(b);
}else if(val[b] - val[a] != c){
printf("No\n");
return 0;
}
} printf("Yes\n");
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
multiset<pair<int,int>> edge[100005];
int memo[100005],f=1;
void dfs(int now)
{
for (auto v:edge[now])
{
if (memo[v.first]==1000000007)
{
memo[v.first]=memo[now]+v.second;
dfs(v.first);
}
else if (memo[now]+v.second!=memo[v.first])
{
f=0;
}
}
}
int main(int argc, char const *argv[])
{
int n,m;
cin>>n>>m;
int l,r,d;
for (int i = 0; i < m; ++i)
{
cin>>l>>r>>d;--l;--r;
edge[l].insert({r,d});
edge[r].insert({l,-d});
}
for (int i = 0; i < n; ++i)
{
memo[i]=1000000007;
}
for (int i = 0; i < n; ++i)
{
if (memo[i]==1000000007)
{
memo[i]=0;
dfs(i);
}
}
if (f)
{
cout<<"Yes\n";
}
else
{
cout<<"No\n";
}
return 0;
}
|
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#define MAXN 100005
using namespace std;
typedef long long ll;
int w,n,m;
int s,t,v;
int f[MAXN];
int val[MAXN];
bool flag = 0;
int find(int x)
{
if (f[x]==x) return x;
int F=find(f[x]);val[x]+=val[f[x]];return f[x]=F;
}
void Union(int x,int y,int w)
{
int a=find(x),b=find(y);
if (a!=b) f[a]=b,val[a]=val[y]-val[x]-w;
else
if (val[y]-val[x]!=w) flag=1;
}
int main()
{
scanf("%d%d",&n,&m);flag=0;
for (int i=0;i<=n;i++) f[i]=i,val[i]=0;
for (int i=1;i<=m;i++)
{
scanf("%d%d%d",&s,&t,&v);
Union(s,t,v);
}
printf(flag?"No\n":"Yes\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n, m;
vector<pair<int, int>> e[100005];
ll x[1000005];
bool vis[1000005];
bool ok = true;
void solve(int v) {
vis[v] = true;
for (auto p : e[v]) {
int y = p.first;
int d = p.second;
if (vis[y]) {
if (x[v] + d != x[y]) {
ok = false;
}
} else {
x[y] = x[v] + d;
solve(y);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
cin >> n >> m;
for (int i=1; i<=m; i++) {
int l, r, d;
cin >> l >> r >> d;
e[l].push_back({r, d});
e[r].push_back({l, -d});
}
for (int i=1; i<=n; i++) {
if (!vis[i]) {
solve(i);
}
}
cout << (ok ? "Yes" : "No") << '\n';
} |
#include <cstdio>
#include <algorithm>
const int MAXN = 100004;
int N;
int uf[MAXN];
long long xx[MAXN];
int findp(int);
int main() {
int N, q;
scanf("%d%d", &N, &q);
std::fill(uf, uf + N, -1);
for (int i = 0; i < q; ++i) {
int l, r, d;
scanf("%d%d%d", &l, &r, &d);
int ll = findp(l), rr = findp(r);
if (ll == rr) {
if (xx[r] - xx[l] != d) goto fail;
continue;
}
uf[rr] = ll;
xx[rr] = (d + (long long)xx[l]) - xx[r];
}
puts("Yes");
return 0;
fail:
puts("No");
return 0;
}
int Q[MAXN];
int qr;
int findp(int t) {
Q[0] = t;
qr = 1;
int pt = uf[t];
while (pt != -1) {
t = Q[qr++] = pt;
pt = uf[t];
}
int sum = 0;
for (int i = qr - 2; i >= 0; --i) {
sum += xx[Q[i]];
xx[Q[i]] = sum;
uf[Q[i]] = t;
}
return t;
}
|
#include <bits/stdc++.h>
using namespace std;const int maxn = 2e6;int n ,p[maxn] ,w[maxn] ,m;
int dfs(int x){
if(p[x]==x)return x;int q = p[x]; p[x] = dfs(q) , w[x]+= w[q];return p[x];
}
int main(){ios::sync_with_stdio(0) ,cin.tie(0) ,cout.tie(0);
cin >> n >> m; for(int i=1;i<=n;i++)p[i]=i;
while(m--){int l ,r ,d; cin >> l >> r >> d;int x=dfs(l) ,y=dfs(r);if(x==y&&w[r]-w[l]!=d)return cout<<"No", 0;else p[y] = x ,w[y] = w[l]+d-w[r];}
cout << "Yes";}
|
#include<iostream>
#include<cstdio>
#include<vector>
using namespace std;
int n,m,dis[200001];
bool vis[200001];
vector<pair<int,int> > g[200001];
bool dfs(int x){
int i,y,d;
vis[x]=true;
for(i=0;i<g[x].size();i++){
y=g[x][i].first,d=g[x][i].second;
if(!vis[y]){
dis[y]=dis[x]+d;
if(!dfs(y))return false;
}
else
if(dis[x]+d!=dis[y])return false;
}
return true;
}
int main(){
int i,u,v,w;
cin >> n >> m;
for(i=1;i<=m;i++){
cin >> u >> v >> w;
g[u].push_back(make_pair(v,w));
g[v].push_back(make_pair(u,-w));
}
for(i=1;i<=n;i++)
if(!vis[i])
if(!dfs(i)){
cout << "No" << endl;
return 0;
}
cout << "Yes";
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int n, m, d[100005], p[100005];
vector<int> c[100005];
int Find (int X) {
if(p[X] == X) return X;
return p[X] = Find(p[X]);
}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++) {
p[i] = i;
c[i].push_back(i);
}
while(m--) {
int L, R, C;
scanf("%d%d%d",&L,&R,&C);
int LL = Find(L), RR = Find(R);
if(LL == RR) {
if(d[R] - d[L] != C) {
puts("No");
return 0;
}
continue;
}
if(c[LL].size() < c[RR].size()) {
swap(LL, RR);
swap(L, R);
C *= -1;
}
int D = d[L] + C - d[R];
for(auto &T : c[RR]) {
c[LL].push_back(T);
d[T] += D;
}
p[RR] = LL;
c[RR].clear();
}
puts("Yes");
}
|
#include<bits/stdc++.h>
using namespace std;
int N,M;
struct edge{ int from,to,cost; };
vector< edge > G[100000];
map<int,bool> visited;
map<int,int> d;
bool dfs(int pos,int sum){
if(visited[pos]){
if( d[pos] == sum )return true;
else return false;
}
visited[pos]=true;
d[pos]=sum;
for(int i=0;i<(int)G[pos].size();i++){
edge e=G[pos][i];
if( !dfs(e.to, sum+e.cost) )return false;
}
return true;
}
int main(){
cin>>N>>M;
for(int i=0;i<M;i++){
int L,R,D;
cin>>L>>R>>D;
L--,R--;
G[L].push_back( (edge){L,R, D} );
G[R].push_back( (edge){R,L,-D} );
}
bool ans=true;
for(int i=0;i<N;i++){
if(visited[i])continue;
if( !dfs(i,0) ){
ans=false;
break;
}
}
cout<< (ans?"Yes":"No") <<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 2e5 + 10, inf = 1e9 + 1;
int dis[N], mark[N], n, m, mn, mx;
vector<pair<int, int> > gr[N];
void dfs(int v) {
mark[v] = 1;
for (auto p : gr[v]) {
int u = p.first, w = p.second;
if (mark[u]) {
if (dis[u] != dis[v] + w) {
cout << "No";
exit(0);
}
}
else {
dis[u] = dis[v] + w;
dfs(u);
}
}
return;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y, w;
cin >> x >> y >> w;
gr[x].push_back({y, w});
gr[y].push_back({x, -w});
}
for (int i = 0; i < n; i++) {
if (!mark[i]) {
mn = mx = 0;
dfs(i);
if (mx - mx > inf) {
cout << "No";
return 0;
}
}
}
cout << "Yes";
return 0;
}
|
#include<cstdio>
#include<algorithm>
#include<vector>
using namespace std;
long long D[101000];
int ck[101000], n, m;
vector<int>E[101000], L[101000];
void DFS(int a, long long d) {
int i;
ck[a] = 1;
D[a] = d;
for (i = 0; i < E[a].size(); i++) {
if (!ck[E[a][i]])DFS(E[a][i], D[a] + L[a][i]);
}
}
int main() {
int i, a, b, c;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &a, &b, &c);
E[a].push_back(b);
L[a].push_back(c);
E[b].push_back(a);
L[b].push_back(-c);
}
for (i = 1; i <= n; i++) {
if (!ck[i]) {
DFS(i, 0);
}
}
for (i = 1; i <= n; i++)for (int j = 0; j < E[i].size(); j++) {
if (D[E[i][j]] != D[i] + L[i][j]) {
printf("No\n");
return 0;
}
}
printf("Yes\n");
} |
#include<bits/stdc++.h>
using namespace std;
int n,m,l,r,d,fl,fr,bo=1,fa[100010],dis[100010];
int find(int x)
{
if(fa[x]!=x)
{
int t=fa[x];
fa[x]=find(fa[x]);
dis[x]+=dis[t];
}
return fa[x];
}
int main()
{
cin>>n>>m;
for(int i=1;i<=n;i++)
{
fa[i]=i;
}
for(int i=1;i<=m;i++)
{
scanf("%d%d%d",&l,&r,&d);
fl=find(l);
fr=find(r);
if(fl==fr&&dis[l]-dis[r]!=d)
{
bo=0;
}
if(fl!=fr)
{
fa[fl]=fr;
dis[fl]=d+dis[r]-dis[l];
}
}
if(bo)
{
cout<<"Yes";
}
else
{
cout<<"No";
}
return 0;
} |
#include<bits/stdc++.h>
#define rep(i,a,b) for (int i=(a); i<=int(b); i++)
#define pb push_back
#define mp make_pair
#define v first
#define w second
using namespace std;
typedef pair<int,int> pii;
const int maxn = 200009, INF = 2e9;
int d[maxn], q[maxn], l, r, a, b, c, n, m, u;
vector<pii> e[maxn];
void bfs(int s) {
l = r = 0; q[r++] = s; d[s] = 0;
while (l < r) {
u = q[l++];
for (auto k : e[u])
if (d[k.v] >= INF) {
d[k.v] = d[u] + k.w;
q[r++] = k.v;
}
else if (d[u] + k.w != d[k.v]) {
puts("No"); exit(0);
}
}
}
int main() {
scanf("%d%d", &n, &m);
rep (i, 1, m) {
scanf("%d%d%d", &a, &b, &c);
e[a].pb(mp(b, c)); e[b].pb(mp(a, -c));
}
memset(d, 0x7f, sizeof d);
rep (i, 1, n)
if (d[i] >= INF) bfs(i);
puts("Yes");
return 0;
} |
#include <bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define INFL 0x3f3f3f3f3f3f3f3f
#define EPS (1e-10)
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
vector<P>E[100000];
bool used[100000];
int a[100000];
void dfs(int v){
used[v]=true;
for(auto p:E[v]){
if(used[p.second]){
if(a[v]+p.first!=a[p.second]){
puts("No");exit(0);
}
}
else{
a[p.second]=a[v]+p.first;
dfs(p.second);
}
}
}
signed main(){
int n,m;scanf("%d%d",&n,&m);
rep(i,m){
int l,r,d;scanf("%d%d%d",&l,&r,&d);l--;r--;
E[l].push_back(P(d,r));
E[r].push_back(P(-d,l));
}
rep(i,n){
if(!used[i]){
dfs(i);
}
}
puts("Yes");
} |
#prag\
ma GCC optimize("Ofast")
#include <bits/stdc++.h>
typedef long long ll;
#define N 200005
using namespace std;
int n,m,dis[N];
bool visited[N];
vector <pair<int,int > > V[N];
bool dfs(int x)
{
visited[x]=true;
for(int i=0;i<V[x].size();++i)
{
int y=V[x][i].first,d=V[x][i].second;
if(!visited[y])
{
dis[y]=dis[x]+d;
if(!dfs(y)) return false;
}
else if(dis[x]+d!=dis[y]) return false;
}
return true;
}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=m;++i)
{
int u,v,w; scanf("%d%d%d",&u,&v,&w);
V[u].push_back(make_pair(v,w));
V[v].push_back(make_pair(u,-w));
}
for(int i=1;i<=n;++i)
if(!visited[i])
if(!dfs(i))
{
printf("No\n");
return 0;
}
printf("Yes\n");
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
void dfs(vector<vector<vector<int>>> &g,vector<int> &p,bool &f,vector<bool> &c,int x){
if(!f)
return;
c.at(x)=1;
for(auto v:g.at(x)){
int y=v.at(0);
int d=v.at(1);
if(c.at(y)){
if(p.at(y)!=p.at(x)+d)
f=0;
continue;
}
p.at(y)=p.at(x)+d;
dfs(g,p,f,c,y);
}
return;
}
int main(){
int n,m;
cin>>n>>m;
vector<vector<vector<int>>> g(n);
for(int i=0;i<m;i++){
int l,r,d;
cin>>l>>r>>d;
l--;
r--;
g.at(l).push_back({r,d});
g.at(r).push_back({l,-d});
}
vector<int> p(n,0);
bool f=1;
vector<bool> c(n,0);
for(int i=0;i<n;i++){
if(c.at(i))
continue;
dfs(g,p,f,c,i);
}
cout<<(f?"Yes":"No")<<endl;
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define SIZE(a) ((int)(a).size())
const int N = 100005;
int n, m;
vector<pair<int,int>> g[N];
int was[N];
int dist[N];
void die() {
cout << "No\n";
exit(0);
}
void dfs(int v, int d = 0) {
was[v] = 1;
dist[v] = d;
for (auto& item : g[v]) {
int to = item.first;
int c = item.second;
if (!was[to]) {
dfs(to, d + c);
} else {
if (dist[to] != d + c) {
die();
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
REP(i, m) {
int x, y, c;
cin >> x >> y >> c;
--x; --y;
g[x].emplace_back(y, c);
g[y].emplace_back(x, -c);
}
REP(i, n) if (!was[i]) dfs(i);
cout << "Yes\n";
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int M = 200005;
int n, m;
vector< pair<int,int> > G[N];
bool vis[N];
int dep[N];
int deg[N];
void dfs(int u) {
vis[u] = 1;
for (auto e : G[u]) {
if (!vis[e.second]) {
dep[e.second] = dep[u] + e.first;
dfs(e.second);
} else {
if (dep[e.second] != dep[u] + e.first) {
cout << "No\n"; exit(0);
}
}
}
}
int main() {
ios_base::sync_with_stdio(false); cin.tie(0);
cin >> n >> m;
while(m--) {
int l, r, d; cin >> l >> r >> d;
G[l].push_back(make_pair(d, r));
G[r].push_back(make_pair(-d, l));
deg[r]++;
}
for (int i = 1; i <= n; ++i) if (!deg[i]) {
dfs(i);
}
for (int i = 1; i <= n; ++i) if (!vis[i]) {
cout << "No\n"; return 0;
}
cout << "Yes\n";
} |
#include <stdio.h>
int N,M,P[100100],D[100100];
int find(int x)
{
if (x != P[x]){
int r = P[x];
P[x] = find(P[x]);
D[x] += D[r];
}
return P[x];
}
int main()
{
scanf ("%d %d",&N,&M);
for (int i=1;i<=N;i++) P[i] = i;
for (int i=0;i<M;i++){
int l,r,d; scanf ("%d %d %d",&l,&r,&d);
int L = find(l);
int R = find(r);
if (L != R){
P[R] = L;
D[R] = d + D[l] - D[r];
}
else{
if (D[r] - D[l] != d){
puts("No");
return 0;
}
}
}
puts("Yes");
return 0;
} |
#include<cstdio>
#include<algorithm>
using namespace std;
int n,m,P[100100],D[100100];
int find(int x)
{
if (x != P[x]) {
int r = P[x];
P[x] = find(P[x]);
D[x] += D[r];
}
return P[x];
}
int main()
{
scanf("%d %d", &n, &m);
for (int i=1; i<=n; i++) P[i] = i;
for (int i=0; i<m; i++) {
int l,r,d; scanf("%d %d %d",&l,&r,&d);
int L = find(l);
int R = find(r);
if (L != R) {
P[R] = L;
D[R] = d + D[l] - D[r];
} else {
if (D[r] - D[l] != d) {
puts("No");
return 0;
}
}
}
puts("Yes");
return 0;
}
|
//#define _GLIBCXX_DEBUG
#include<bits/stdc++.h>
using namespace std;
#define pb push_back//also for STRING
#define MAX_N 100000
struct edge{
int to,cost;
};
int d[MAX_N];
vector<edge> g[MAX_N];
bool f[MAX_N];
bool dfs(int v){
f[v]=true;
for(int j=0;j<g[v].size();++j){
int w=g[v][j].to;
if(f[w]){
if(d[w]!=d[v]+g[v][j].cost) return false;
continue;
}
d[w]=d[v]+g[v][j].cost;
if(!dfs(w)) return false;
}
return true;
}
int main(){
int n,m;
scanf("%d %d",&n,&m);
while(m-- > 0){
int l,r,d;
scanf("%d %d %d",&l,&r,&d);
g[--l].pb((edge){--r,d});
g[r].pb((edge){l,-d});
}
fill(f,f+n,false);
for(int v=0;v<n;++v){
if(!dfs(v)){
printf("No\n");
return 0;
}
}
printf("Yes\n");
return 0;
} |
//ΔARC090B
#include<iostream>
#include<cstdio>
#include<fstream>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<cmath>
#include<cstring>
#include<cstdlib>
using namespace std;
typedef long long LL;
typedef double DB;
const int N = 111111;
int n,m,a[N],vis[N];
vector<int> v[N],p[N];
void dfs(int u){
int i,x,z;
vis[u]=1;
i=v[u].size();
while(i--){
x=v[u][i];
z=p[u][i];
if(vis[x]){
if(a[x]!=a[u]+z){
printf("No");
exit(0);
}
}
else{
a[x]=a[u]+z;
dfs(x);
}
}
}
int main()
{
int i,x,y,z;
scanf("%d%d",&n,&m);
while(m--){
scanf("%d%d%d",&x,&y,&z);
v[x].push_back(y);
p[x].push_back(z);
v[y].push_back(x);
p[y].push_back(-z);
}
for(i=1;i<=n;i=i+1)
if(!vis[i])
dfs(i);
printf("Yes");
return 0;
} |
#include <cstdlib>
#include <cstdio>
#include <algorithm>
#define maxn 100005
#define rep(i, l, r) for (register int i = l; i <= r; i++)
#define per(i, r, l) for (register int i = r; i >= l; i--)
using namespace std;
int ufs[maxn];
int val[maxn];
int get(int x){
int t = (x == ufs[x]) ? x : get(ufs[x]);
val[x] += val[ufs[x]];
return ufs[x] = t;
}
int main(){
int n, m;
int x, y, d;
scanf("%d%d", &n, &m);
rep(i, 1, n) ufs[i] = i;
rep(i, 1, m){
scanf("%d%d%d", &x, &y, &d);
int _x = get(x), _y = get(y);
if (_x == _y) {
if (val[x] - val[y] != d) {
printf("No");
return 0;
}
}
else val[_x] = d + val[y] - val[x], ufs[_x] = _y;
}
printf("Yes");
return 0;
} |
#include<cstdio>
const int maxn=100000;
int n,m,fa[maxn+10],dfa[maxn+10];
int getfa(int x){
int u=x,d=0;
for(;fa[u]!=u;u=fa[u]) d+=dfa[u];
for(int i=x,p;fa[i]!=i;i=p){
p=fa[i]; fa[i]=u; d-=dfa[i]; dfa[i]+=d;
}
return u;
}
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;++i) fa[i]=i;
for(int i=1;i<=m;++i){
int l,r,d; scanf("%d%d%d",&l,&r,&d);
int ll=getfa(l),rr=getfa(r);
if(ll!=rr){
fa[ll]=rr; dfa[ll]=dfa[r]-dfa[l]-d;
}else if(dfa[r]-dfa[l]-d){
printf("No"); return 0;
}
}
printf("Yes");
} |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int chk[100001];
struct edg {
int idx, dst;
};
vector<edg> gph[100001];
int dst[100001];
void go(int now, int cnt) {
dst[now] = cnt;
chk[now] = 1;
for (edg nxt : gph[now]) {
if (!chk[nxt.idx]) {
go(nxt.idx, cnt+nxt.dst);
}
else {
if (dst[nxt.idx] != cnt+nxt.dst) {
puts("No");
exit(0);
}
}
}
}
int main() {
scanf("%d %d", &n, &m);
while (m--) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
gph[u].push_back({ v,w });
gph[v].push_back({ u,-w });
}
for (int i = 1; i <= n; i++) {
if (!chk[i]) {
go(i, 0);
}
}
puts("Yes");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int>>> graph;
vector<bool> vis;
vector<int> value;
bool dfs(int u, int val) {
vis[u] = true;
value[u] = val;
for (auto &ed: graph[u]) {
int v, w;
tie(v, w) = ed;
if (vis[v]) {
if (value[v] != value[u] + w) {
return false;
}
} else {
if (!dfs(v, value[u] + w)) {
return false;
}
}
}
return true;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
graph.assign(n, {});
vis.resize(n);
value.resize(n);
for (int i = 0; i < m; i++) {
int l, r, d;
scanf("%d %d %d", &l, &r, &d);
l--, r--;
graph[l].push_back({r, d});
graph[r].push_back({l, -d});
}
bool ans = true;
for (int i = 0; i < n; i++) {
if (!vis[i] and !dfs(i, 0)) {
ans = false;
}
}
printf("%s\n", ans ? "Yes" : "No");
return 0;
} |
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#define lol(i,n) for(int i=0;i<n;i++)
#define mod 1000000007
typedef long long ll;
using namespace std;
int n,m;
int x[100010];
queue<pair<int,int> >Q[100010];
queue<int> T;
int main(){
cin>>n>>m;
lol(i,m){
int a,b,c;cin>>a>>b>>c;
a--,b--;
Q[a].push(make_pair(b,c));
Q[b].push(make_pair(a,-c));
}
lol(i,n)x[i]=-mod;
bool ans=true;
lol(i,n){
if(x[i]==-mod)T.push(i);
else continue;
x[i]=0;
while(!T.empty()){
int a=T.front();
T.pop();
while(!Q[a].empty()){
int to=Q[a].front().first;
int cost=Q[a].front().second;
Q[a].pop();
if(x[to]==-mod){
x[to]=x[a]+cost;
T.push(to);
}
else{
if(x[to]!=x[a]+cost)ans=false;
}
}
}
}
cout<<(ans?"Yes":"No")<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, p[100010], d[100010];
int getf(int x){
if(p[x] == x)return x;
getf(p[x]);
int parent = p[x];
p[x] = p[parent];
d[x] = d[x] + d[parent];
return p[x];
}
int main(){
int n, m;
scanf("%d%d" , &n , &m);
for(int i = 1 ; i <= n ; i++)
p[i] = i, d[i] = 0;
bool invalid = false;
for(int i = 1 ; i <= m ; i++){
int l, r, dd;
scanf("%d%d%d" , &l , &r , &dd);
if(l == r){
if(dd == 0)continue;
else{
invalid = true;
continue;
}
}
int pl = getf(l), pr = getf(r);
if(pl == pr){
if(d[r] - d[l] == dd){
continue;
}
else{
invalid = true;
}
}
else{
p[pr] = pl;
d[pr] = dd - d[r] + d[l];
}
}
if(invalid){
puts("No");
return 0;
}
puts("Yes");
return 0;
} |
#include <cstdio>
#include <algorithm>
using namespace std;
typedef long long ll;
int N, M;
int p[100005];
ll dist[100005];
int find(int a){
if(a==p[a]) return a;
int pa=p[a];
p[a]=find(pa);
dist[a]+=dist[pa];
return p[a];
}
bool merge(int a,int b,int d){
int pa=find(a), pb=find(b);
if(pa==pb){
return dist[a]==dist[b]+d;
}
else{
p[pa]=pb;
dist[pa]=d-dist[a]+dist[b];
return 1;
}
}
int main(){
scanf("%d %d",&N,&M);
for(int i=1;i<=N;i++)
p[i]=i;
while(M--){
int L,R,D; scanf("%d %d %d",&L,&R,&D);
if(!merge(L,R,D)) return !printf("No");
}
puts("Yes");
} |
#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
int main(){
int n,m;
cin>>n>>m;
vector<P> v[111111];
for(int i=0;i<m;i++){
int l,r,d;
cin>>l>>r>>d;
v[l].push_back(P(r,d));
v[r].push_back(P(l,-d));
}
int cos[111111],ans=1;
fill(cos,cos+n+1,INT_MAX);
for(int i=1;i<=n;i++){
if(cos[i]==INT_MAX){
queue<P> q;
q.push(P(i,0));
while(!q.empty()){
int to=q.front().first;
int cost=q.front().second;
q.pop();
if(cos[to]==INT_MAX){
cos[to]=cost;
for(int j=0;j<v[to].size();j++){
P p=v[to][j];
p.second+=cost;
q.push(p);
}
}else if(cos[to]!=cost)ans=0;
}
}
}
if(ans)cout<<"Yes"<<endl;
else cout<<"No"<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n,m;
int f[100004],h[100004];
int F(int x){
if(f[x]==x)return x;
int pa=F(f[x]);
h[x]+=h[f[x]],f[x]=pa;
return f[x];
}
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)f[i]=i;
for(int i=1;i<=m;i++){
int L,R,D;scanf("%d%d%d",&L,&R,&D);
int l=F(L),r=F(R);
if(l==r){
if(h[R]-h[L]!=D){
puts("No");
return 0;
}
}else{
f[r]=l;
h[r]=D+h[L]-h[R];
}
}
puts("Yes");
} |
#include <iostream>
#include <string>
#include <cstdio>
#include <cmath>
#include<cstring>
using namespace std;
const int maxn=100001;
int f[maxn];
int d[maxn];
int find(int x)
{
if(f[x]==x)
return x;
int r=find(f[x]);
d[x]=d[f[x]]+d[x];
return f[x]=r;
}
int fix(int x,int y,int z)
{
int fx=find(x);
int fy=find(y);
if(fx==fy)
return z==d[y]-d[x];
f[fy]=fx;
d[fy]=d[x]+z-d[y];
return 1;
}
int main()
{
int n,m;
int flag=1;
cin>>n>>m;
for(int i=1;i<=n;i++)
f[i]=i;
for(int i=1;i<=m;i++)
{
int x,y,z;
cin>>x>>y>>z;
if(flag)
flag=fix(x,y,z);
}
if(flag)
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<vector>
#include<iomanip>
#define sqr(x) (x)*(x)
using namespace std;
long long n,m,i,j,dis[100005],x,y,z;
vector<pair<long long,long long>/**/> e[100005];
void dfs(long long x,long long dist)
{
if (dis[x])
{
if (dis[x]!=dist)
{
cout<<"No";
exit(0);
}
return;
}
dis[x]=dist;
int i;
for (i=0;i<e[x].size();i++)
{
dfs(e[x][i].first,dist+e[x][i].second);
}
}
int main()
{
cin>>n>>m;
while (m--)
{
cin>>x>>y>>z;
e[x].push_back(make_pair(y,z));
e[y].push_back(make_pair(x,-z));
}
for (i=1;i<=n;i++)
{
if (dis[i]) continue;
dfs(i,1e15);
}
cout<<"Yes";
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
struct ques {
int l,r,d;
}q[200100];
int n,m;
int fa[100100],dep[100100];
bool flag=1;
int find(int x)
{
if (x==fa[x]) return x; else
{
int k=fa[x];
fa[x]=find(fa[x]);
dep[x]+=dep[k];
return fa[x];
}
}
int main()
{
scanf("%d%d",&n,&m);
for (int i=1;i<=n;i++) fa[i]=i;
for (int i=1;i<=m;i++)
scanf("%d%d%d",&q[i].l,&q[i].r,&q[i].d);
for (int i=1;i<=m;i++)
{
int x=q[i].l,y=q[i].r,z=q[i].d;
int fx=find(x),fy=find(y);
if (fx!=fy) {
fa[fx]=fy;
dep[fx]=z-dep[x]+dep[y];
} else
if (dep[x]-dep[y]!=z) {
puts("No");
flag=0;
break;
}
}
if (flag) puts("Yes");
return 0;
} |
#include <bits/stdc++.h>
typedef long long ll;
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,a) FOR(i,0,a)
using namespace std;
const int MAX_N=1e5;
int N,M;
typedef pair<int,int> P;
int v2g[MAX_N];
map<int,int> g2v[MAX_N];
int main(){
cin>>N>>M;
REP(i,N){
v2g[i]=i;
g2v[i].insert(P(i,0));
}
bool ans=true;
REP(i,M){
int L,R,D;
cin>>L>>R>>D;
L--;
R--;
if (v2g[L]==v2g[R]){
int g=v2g[L];
if (g2v[g][R]-g2v[g][L]!=D){
ans=false;
}
}else{
int f,t,d;
if (g2v[v2g[L]].size()<g2v[v2g[R]].size()){
f=v2g[L];
t=v2g[R];
d=-D-g2v[f][L]+g2v[t][R];
}else{
f=v2g[R];
t=v2g[L];
d=D-g2v[f][R]+g2v[t][L];
}
for(auto i:g2v[f]){
g2v[t][i.first]=i.second+d;
v2g[i.first]=t;
}
}
}
cout<<(ans ? "Yes" : "No")<<endl;
return 0;
} |
#include<cstdio>
#include<iostream>
using namespace std;
struct node{
int p,num;
}a[100007];
int find(int x)
{
if(a[x].p==x&&a[x].num==0){
return x;
}
else
{
int t=find(a[x].p);
a[x].num=a[a[x].p].num+a[x].num;
a[x].p=t;
return t;
}
}
int main()
{
int n,m,i;
cin>>n>>m;
for(i=1;i<=n;i++){
a[i].p=i;a[i].num=0;
}
for(i=1;i<=m;i++)
{
int l,r,x;
scanf("%d%d%d",&l,&r,&x);
int pl=find(l),pr=find(r);
if(pl!=pr)
{
if(pl>pr)
{
a[pl].p=pr;
a[pl].num=-(a[l].num-a[r].num+x);
}
else
{
a[pr].p=pl;
a[pr].num=a[l].num-a[r].num+x;
}
}
else{
if(a[r].num-a[l].num!=x)
{
cout<<"No"<<endl;
return 0;
}
}
}
cout<<"Yes"<<endl;
return 0;
} |
#include<bits/stdc++.h>
#define MAX_N 100005
#define pb push_back
using namespace std;
struct node{
int y,cost;
bool operator < (node d) const{
return cost<d.cost;
}
}drg[MAX_N];
int n,m,dst[MAX_N];
bool ans;
vector<node> net[MAX_N];
void dfs(int x){
int sz=net[x].size();
node y;
while(sz--){
y=net[x][sz];
if(dst[y.y]){
if(dst[x]+y.cost!=dst[y.y]) ans=true;
continue;
}
dst[y.y]=dst[x]+y.cost;
dfs(y.y);
}
}
int main(){
int i,x;
node p;
scanf("%d %d",&n,&m);
for(i=1;i<=n;i++) drg[i].y=i;
for(i=0;i<m;i++){
scanf("%d %d %d",&x,&p.y,&p.cost);
net[x].pb(p);
drg[p.y].cost++;
}
sort(drg+1,drg+n+1);
for(i=1;i<=n;i++){
if(dst[drg[i].y]) continue;
dst[drg[i].y]=1;
dfs(drg[i].y);
}
printf("%s\n",(ans)?"No":"Yes");
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N=1e5+5;
vector< pair<ll,ll> > adj[N];
ll vis[N],dist[N],n,m;
void dfs(ll u,ll d)
{
if(vis[u]==1)
{
if(dist[u]!=d)
{
cout<<"No";
exit(0);
}
return;
}
vis[u]=1;
dist[u]=d;
for(auto node:adj[u])
dfs(node.first,d+node.second);
}
int main()
{
ios_base:: sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
cin>>n>>m;
for(ll i=0;i<m;i++)
{
ll x,y,d;
cin>>x>>y>>d;
adj[x].push_back({y,d});
adj[y].push_back({x,-d});
}
for(ll i=1;i<=n;i++)
if(!vis[i])
dfs(i,0);
cout<<"Yes";
} |
#include<cstdio>
inline int read()
{
int x;char c;
while((c=getchar())<'0'||c>'9');
for(x=c-'0';(c=getchar())>='0'&&c<='9';)x=x*10+c-'0';
return x;
}
#define MN 100000
#define MM 200000
struct edge{int nx,t,w;}e[MM*2+5];
int h[MN+5],en,u[MN+5],z[MN+5],O;
inline void ins(int x,int y,int w)
{
e[++en]=(edge){h[x],y,w};h[x]=en;
e[++en]=(edge){h[y],x,-w};h[y]=en;
}
void dfs(int x)
{
u[x]=1;
for(int i=h[x];i;i=e[i].nx)
if(!u[e[i].t])z[e[i].t]=z[x]+e[i].w,dfs(e[i].t);
else O|=z[e[i].t]!=z[x]+e[i].w;
}
int main()
{
int n,m,x,y,i;
n=read();m=read();
while(m--)x=read(),y=read(),ins(x,y,read());
for(i=1;i<=n;++i)if(!u[i])dfs(i);
puts(O?"No":"Yes");
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e5+5;
using pii = pair<int, int>;
int p[N],vis[N],n,m;
vector<pii> G[N];
bool dfs(int x, int v){
if(vis[x]) return p[x] == v;
vis[x] = 1;
p[x] = v;
for(auto &n : G[x]){
if(!dfs(n.first, v+n.second)) return false;
}
return true;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m;
for(int i=0;i<m;++i){
int a,b,d;
cin >> a >> b >> d;
G[a].push_back({b, d});
G[b].push_back({a, -d});
}
for(int i=1;i<=n;++i){
if(!vis[i]){
if(!dfs(i, 0)){
puts("No");
return 0;
}
}
}
puts("Yes");
return 0;
}
|
#include <cstdio>
using namespace std;
const int MAX_N = 1000005;
int fa[MAX_N], dis[MAX_N];
int find(int x) {
if (fa[x] == x) return x;
int par = find(fa[x]);
dis[x] += dis[fa[x]];
return fa[x] = par;
}
bool add(int L, int R, int D) {
if (find(L) == find(R)) {
if (dis[L] - dis[R] != -D) {
puts("No");
return 0;
}
return 1;
}
int faR = fa[R], faL = fa[L];
fa[faR] = fa[faL];
dis[faR] = dis[L] + D - dis[R];
return 1;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) fa[i] = i;
for (int i = 1; i <= m; ++i) {
int L, R, D;
scanf("%d%d%d", &L, &R, &D);
if (!add(L, R, D)) {
return 0;
}
}
puts("Yes");
return 0;
}
|
#include <bits/stdc++.h>
#define REP(i, a, n) for(ll i = ((ll) a); i < ((ll) n); i++)
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
ll N, M;
vector< vector<pll> > E;
vector<bool> used;
vector<ll> X;
bool dfs(ll v, ll x) {
if(used[v]) return X[v] == x;
used[v] = true;
X[v] = x;
bool ret = true;
for(pll p : E[v]) {
ll u = p.first, d = p.second;
ret = ret && dfs(u, x + d);
}
return ret;
}
int main(void) {
cin >> N >> M;
E.resize(N);
REP(i, 0, M) {
ll L, R, D;
cin >> L >> R >> D;
L--;
R--;
E[L].push_back(pll(R, +D));
E[R].push_back(pll(L, -D));
}
bool ans = true;
used.resize(N, false);
X.resize(N);
REP(i, 0, N) if(!used[i]) ans = ans && dfs(i, 0);
cout << (ans ? "Yes" : "No") << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ran 101111
int n;
vector<pair<int,int> > e[ran];
bool vis[ran];
int pos[ran];
bool dfs(int x){
vis[x] = true;
for(auto p : e[x]){
int y = p.first;
int dif = p.second;
if(!vis[y]){
pos[y] = pos[x] + dif;
if(!dfs(y))return false;
}else{
if(pos[y] != pos[x] + dif)return false;
}
}
return true;
}
int main(){
int m;
scanf("%d%d",&n,&m);
while(m--){
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
e[x].push_back({y, z});
e[y].push_back({x, -z});
}
for(int i=1; i<=n; i++)
if(!vis[i]){
pos[i] = 0;
if(!dfs(i)){
puts("No");
return 0;
}
}
puts("Yes");
return 0;
}
|
#include<stdio.h>
#include<vector>
#include<algorithm>
using namespace std;
typedef pair<int, int>pii;
vector<pii>pat[100000];
bool flag[100000];
int d[100000];
void dfs(int node, int t)
{
if (flag[node])
{
if (d[node] != t)
{
printf("No\n");
exit(0);
}
return;
}
flag[node] = true;
d[node] = t;
for (int i = 0; i < pat[node].size(); i++)dfs(pat[node][i].first, t + pat[node][i].second);
}
int main()
{
int num, way;
scanf("%d%d", &num, &way);
for (int i = 0; i < way; i++)
{
int za, zb, zc;
scanf("%d%d%d", &za, &zb, &zc);
za--, zb--;
pat[za].push_back(make_pair(zb, zc));
pat[zb].push_back(make_pair(za, -zc));
}
for (int i = 0; i < num; i++)
{
if (!flag[i])dfs(i, 0);
}
printf("Yes\n");
} |
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <cmath>
using namespace std;
const int N=100005;
int n,m,fa[N],d[N];
int getf(int k){
if (fa[k]==k)
return k;
int f=fa[k];
fa[k]=getf(fa[k]);
d[k]+=d[f];
return fa[k];
}
int main(){
scanf("%d%d",&n,&m);
for (int i=1;i<=n;i++)
fa[i]=i;
memset(d,0,sizeof d);
for (int i=1;i<=m;i++){
int L,R,D;
scanf("%d%d%d",&L,&R,&D);
if (getf(L)==getf(R)){
if (d[L]-d[R]!=D){
puts("No");
return 0;
}
}
else {
int A=getf(L),B=getf(R);
fa[B]=A,d[B]=d[L]-D-d[R];
}
}
puts("Yes");
return 0;
} |
#include<iostream>
#include<vector>
#include<stack>
using namespace std;
int main() {
int n, m; cin >> n >> m;
vector<int>x(n, 0); stack<int>s;
vector < vector<pair<int, int>>>l(n), r(n);
for (int i = 0, L, R, d; i < m; i++) {
cin >> L >> R >> d; L--; R--;
l[R].push_back({ L,d }); r[L].push_back({ R,d });
}
for (int i = 0; i < n; i++) {
if (l[i].size() == 0) { x[i] = 1; s.push(i); }
}
bool ok = true;
while (!s.empty()) {
int node = s.top(); s.pop();
for (int i = 0; i < r[node].size(); i++) {
int next = r[node][i].first, xd = x[node] + r[node][i].second;
if (x[next] == 0) { x[next] = xd; s.push(next); }
else if (x[next] != xd) { ok = false; break; }
}
}
for (int i = 0; i < n; i++) if (x[i] == 0)ok = false;
cout << (ok ? "Yes" : "No") << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int p[N], rec[N];
int find(int x){
if (p[x] == x) return x;
int fa = find(p[x]);
rec[x] += rec[p[x]];
return p[x] = fa;
}
bool same(int x, int y){
return find(x) == find(y);
}
void unite(int x, int y, int val){
int fx = find(x), fy = find(y);
p[fx] = fy;
rec[fx] = rec[y] - rec[x] + val;
}
int main(){
int n, m, x, y, d;
scanf("%d %d",&n,&m);
for (int i = 1; i <= n; i++){
p[i] = i;
rec[i] = 0;
}
for (int i = 1; i <= m; i++){
scanf("%d %d %d",&x,&y,&d);
if (same(x, y)){
if (rec[x] - rec[y] != d){
printf("No\n");
return 0;
}
}
else unite(x, y, d);
}
printf("Yes\n");
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define N 600000
#define INF 0x3f3f3f3f
int n,m,x,y,z,tot,f[N],head[N];
struct edge{int v,l,nxt;}e[N];
void add(int x,int y,int z){e[++tot].v=y; e[tot].l=z; e[tot].nxt=head[x]; head[x]=tot;}
void dfs(int u){
for (int i=head[u],v;i;i=e[i].nxt)
if (f[v=e[i].v]==INF){
f[v]=f[u]+e[i].l;
dfs(v);
}
else
if (f[v]!=f[u]+e[i].l){puts("No"); exit(0);}
}
int main(){
scanf("%d%d",&n,&m);
memset(f,0x3f,sizeof f);
while (m--){
scanf("%d%d%d",&x,&y,&z);
add(x,y,z); add(y,x,-z);
}
for (int i=1;i<=n;++i)
if (f[i]==INF){f[i]=0; dfs(i);}
puts("Yes");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pi;
int n, m, l, r, d, dist[100001], vis[100001];
vector<pi> adj[100001];
void dfs(int node){
vis[node] = 1;
for(auto it:adj[node]){
if(vis[it.first] != -1){
if(dist[it.first] != dist[node]+it.second){ cout << "No"; exit(0); }
continue;
}
vis[it.first] = 1;
dist[it.first] = dist[node]+it.second;
dfs(it.first);
}
}
int main(){
memset(vis, -1, sizeof(vis));
cin >> n >> m;
for(int i = 0; i < m; i++){
cin >> l >> r >> d;
adj[l].push_back(pi(r, d));
adj[r].push_back(pi(l, -d));
}
for(int i = 1; i <= n; i++){
if(vis[i] == -1) dfs(i);
}
cout << "Yes";
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
int N,M;
int fa[200010],d[200010];
int find(int x)
{
if (x == fa[x]) return x;
int tmp = find(fa[x]);
d[x] += d[fa[x]];
fa[x] = tmp;
return tmp;
}
int main()
{
scanf("%d%d",&N,&M);
for (int i=1;i<=N;i++)fa[i] = i, d[i] = 0;
bool ok = true;
for (int i=1;i<=M;i++)
{
int L,R,D;
scanf("%d%d%d",&L,&R,&D);
if (find(L) == find(R))
{
if (d[L] - d[R] != D) ok = false;
}
else
{
int fl = find(L), fr = find(R);
d[fl] = D + d[R] - d[L];
fa[fl] = fr;
}
}
if (ok)
puts("Yes");
else
puts("No");
} |
#include <iostream>
#include <cstdio>
#include <vector>
#include <cstdlib>
#define N 100005
using namespace std;
int n, m, l[N * 2], r, d, a[N];
bool v[N];
vector<int> ve[N], vd[N];
void f(int p) {
int i;
for (i = 0; i < ve[p].size(); i++) {
if (!v[ve[p][i]]) v[ve[p][i]] = 1, a[ve[p][i]] = a[p] + vd[p][i], f(ve[p][i]);
else if (a[p] + vd[p][i] != a[ve[p][i]]) {cout << "No"; exit(0);}
}
}
int main()
{
int i;
cin >> n >> m;
for (i = 0; i < m; i++) {
scanf("%d %d %d", &l[i], &r, &d);
ve[l[i]].push_back(r); vd[l[i]].push_back(d);
ve[r].push_back(l[i]); vd[r].push_back(-d);
}
for (i = 0; i < m; i++) if (!v[l[i]]) v[l[i]] = 1, f(l[i]);
cout << "Yes" << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000, unknown = 1e9 + 100;
vector<pair<int,int>> g[MAXN];
int cur[MAXN];
bool dfs(int v) {
bool ok = 1;
for (auto P : g[v]) {
int u = P.first, d = P.second;
if (cur[u] == unknown) cur[u] = cur[v] + d, ok &= dfs(u);
else {
if (cur[u] != cur[v] + d) ok = 0;
}
}
return ok;
}
int main() {
int N, M, u, v, d; scanf("%d%d", &N, &M);
for (int i = 0; i < M; ++i) scanf("%d%d%d", &u, &v, &d), --u, --v, g[u].push_back({v, d}), g[v].push_back({u, -d});
fill(cur, cur + N, unknown);
bool ok = 1;
for (int i = 0; i < N; ++i)
if (cur[i] == unknown)
cur[i] = 0, ok &= dfs(i);
puts(ok? "Yes": "No");
}
|
#include <bits/stdc++.h>
using namespace std;
int n,ans[100005],m;
vector <pair<int,int> > v[100005];
bool yes=true;
void dfs (int x,int cur,bool s)
{
if (ans[x]&&!s)
{
if (ans[x]!=cur)
yes=false;
return;
}
ans[x]=cur;
for (int i=0;i<v[x].size();i++)
dfs(v[x][i].first,cur+v[x][i].second,0);
}
int main()
{
cin >>n>>m;
for (int i=0;i<m;i++)
{
int l,r,d;
cin >>l>>r>>d;
v[l].push_back({r,d});
v[r].push_back({l,-d});
}
for (int i=1;i<=n;i++)
{
if (!ans[i])
{
ans[i]=1e9+1;
dfs(i,1e9+1,1);
}
}
yes?cout<<"Yes":cout<<"No";
return 0;
}
|
#include<stdio.h>
int f[100010],v[100010];
int fa(int a)
{
if(f[a]==a)
return a;
int t=f[a];
f[a]=fa(f[a]);
v[a]+=v[t];
return f[a];
}
bool connect(int x,int y,int d)
{
int fx=fa(x);
int fy=fa(y);
if(fx!=fy)
{
f[fy]=fx;
v[fy]=v[x]-v[y]+d;
}
else if(v[y]-v[x]!=d)
return 1;
return 0;
}
int main()
{
int n,m,h=0,l,r,d;
scanf("%d%d",&n,&m);
for(int j=1;j<=n;j++)
f[j]=j;
for(int i=1;i<=m;i++)
{
scanf("%d%d%d",&l,&r,&d);
h+=connect(l,r,d);//true失败
}
if(!h)
printf("Yes\n");
else
printf("No\n");
return 0;
}
|
#include<cstdio>
#include<algorithm>
using namespace std;
const int inf=100005;
int i,j,k,l,n,m,fx,fy;
int tmp[4],fa[inf],dis[inf];
bool f;
int find(int x)
{
if (fa[x]!=x)
{
int org=fa[x];
fa[x]=find(fa[x]);
dis[x]+=dis[org];
return fa[x];
}
else return x;
}
void unite(int x,int y,int z)
{
fx=find(x);
fy=find(y);
if (fx==fy)
{
if (dis[y]-dis[x]!=z)
f=0;
}
else
{
dis[fy]=z+dis[x]-dis[y];
fa[fy]=fx;
}
}
int main()
{
f=1;
scanf("%d%d",&n,&m);
for (i=1;i<=n;i++)
fa[i]=i;
for (i=1;i<=m;i++)
{
scanf("%d%d%d",&tmp[1],&tmp[2],&tmp[3]);
unite(tmp[1],tmp[2],tmp[3]);
if (!f)
break;
}
if (f)
printf("Yes");
else printf("No");
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
const int N=100009;
const int M=200009;
int n,m,l,r,d;
int x[N],fa[N];
int dis[N];
inline int findfa(int x)
{
if(fa[x]==x)return x;
int f=findfa(fa[x]);
dis[x]=dis[x]+dis[fa[x]];
fa[x]=f;
return f;
}
int main()
{
if(fopen("vj.in","r"))
{
freopen("vj.in","r",stdin);
freopen("vj.out","w",stdout);
}
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
fa[i]=i,dis[i]=0;
for(int i=1;i<=m;i++)
{
scanf("%d%d%d",&l,&r,&d);
if(findfa(l)==findfa(r))
{
if(dis[l]+d!=dis[r])
{
puts("No");
return 0;
}
}
else
{
int x=findfa(l),y=findfa(r);
fa[y]=x;dis[y]=dis[l]+d-dis[r];
}
}
puts("Yes");
return 0;
}
|
#include <cstdio>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
using namespace std;
const int N=200010;
typedef long long ll;
int T[N];
ll v[N];
int findr(int x){
if(T[x]==-1) return x;
int p=findr(T[x]);
v[x]+=v[T[x]];
return T[x]=p;
}
int main(){
int n,m,i,x,y,z,p,q;
scanf("%d %d",&n,&m);
memset(T,-1,sizeof(T));
for(i=1;i<=m;i++){
scanf("%d %d %d",&x,&y,&z);
p=findr(x);q=findr(y);
if(p==q){
if(v[y]!=v[x]+z){puts("No");return 0;}
}
else T[q]=p,v[q]=v[x]-v[y]+z;
}
printf("Yes");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int>>> g;
vector<bool> used;
vector<int> pt;
void dfs(int u, int nw)
{
if (used[u])
{
if (nw != pt[u])
{
cout << "No" << endl;
exit(0);
}
return;
}
used[u] = true;
pt[u] = nw;
for (auto p : g[u])
dfs(p.first, pt[u] + p.second);
}
int main()
{
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
g.resize(n);
pt.resize(n);
used.resize(n);
while (m--)
{
int a, b, d;
cin >> a >> b >> d;
--a, --b;
g[a].emplace_back(b, d);
g[b].emplace_back(a, -d);
}
for (int i = 0; i < n; ++i)
if (!used[i])
dfs(i, 0);
cout << "Yes" << endl;
}
|
#include<cstdio>
#include<algorithm>
using namespace std;
int n,m,cnt,tot;
int fns[100010],wz[100010],b[100010],roadl[400010],roadto[400010],road[400010];
void dfs(int num,int st)
{
if(b[num])
{
if(st!=fns[num]) cnt=1;
return;
}
b[num]=1,fns[num]=st;
int t=wz[num];
while(t)
{
dfs(road[t],st+roadl[t]);
t=roadto[t];
}
}
int main()
{
int i,j,x,y,z;
scanf("%d%d",&n,&m);
for(i=1;i<=m;i++)
{
scanf("%d%d%d",&x,&y,&z);
roadto[++tot]=wz[x],road[tot]=y,wz[x]=tot,roadl[tot]=z;
roadto[++tot]=wz[y],road[tot]=x,wz[y]=tot,roadl[tot]=-z;
}
for(i=1;i<=n;i++)
{
if(!b[i]) dfs(i,0);
}
if(cnt) printf("No\n");
else printf("Yes\n");
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
LL dst[100010]={0};
LL fat[100010];
LL n,m,l,r,d;
int getfat(int x){
if(x==fat[x])return x;
LL i=getfat(fat[x]);
dst[x]+=dst[fat[x]];
fat[x]=i;
return i;
}
int main(){
LL i,j,k;
for(i=0;i<100010;i++)fat[i]=i;
cin>>n>>m;
for(i=0;i<m;i++){
cin>>l>>r>>d;
j=getfat(l);
k=getfat(r);
if(j==k&&d!=dst[l]-dst[r]){
cout<<"No"<<endl;
return 0;
}
if(j==k&&d==dst[l]-dst[r]) continue;
if(j!=k){
if(d>dst[l]){
fat[j]=k;
dst[j]=dst[r]+d-dst[l];
}
else if(d+dst[r]>dst[l]){
fat[j]=k;
dst[j]=dst[r]+d-dst[l];
}
else if(d+dst[r]<dst[l]){
fat[k]=j;
dst[k]=dst[l]-d-dst[r];
}
}
}
cout<<"Yes"<<endl;
return 0;
} |
#include <iostream>
#include <vector>
#include <cstdio>
using namespace std;
typedef pair<int, int> pii;
const int MAXN = 1e5 + 5;
int N, M;
vector<pii> neigh[MAXN];
bool tk[MAXN];
int val[MAXN];
bool Fill(int v, int col) {
if (tk[v]) return val[v] == col;
tk[v] = true;
val[v] = col;
for (int i = 0; i < neigh[v].size(); i++) {
pii u = neigh[v][i];
if (!Fill(u.first, val[v] + u.second)) return false;
}
return true;
}
int main() {
scanf("%d %d", &N, &M);
for (int i = 0; i < M; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
neigh[a].push_back(pii(b, c));
neigh[b].push_back(pii(a, -c));
}
for (int i = 1; i <= N; i++) {
if (!tk[i]) {
if (!Fill(i, 0)) {
printf("No\n");
return 0;
}
}
}
printf("Yes\n");
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int n,m,x,y,z,f[100005],w[100005];
void find(int x){
if (f[x]==x) return;
find(f[x]); w[x]+=w[f[x]]; f[x]=f[f[x]];
}
int main(){
scanf("%d%d",&n,&m);
for (int i=1;i<=n;++i) f[i]=i;
for (int i=1;i<=m;++i){
scanf("%d%d%d",&x,&y,&z);
find(x); find(y);
if (f[x]==f[y]){
if (w[x]+z!=w[y]){
puts("No"); return 0;
}
}else{
w[f[y]]=w[x]+z-w[y];
f[f[y]]=f[x];
}
}
puts("Yes");
return 0;
} |
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int MAX=1e6;
int father[MAX],v[MAX],flag,t;
int find(int x)
{
if(father[x]==x)return x;
t=find(father[x]);
v[x]+=v[father[x]];
father[x]=t;
return father[x];
}
void work(int x,int y,int w)
{
int p=find(x),q=find(y);
if(p!=q)
{
father[p]=q;
v[p]=v[y]-v[x]-w;
}
else if(v[y]-v[x]!=w)flag=1;
}
int main()
{
int w,n,m;
memset(v,0,sizeof(v));
flag=0;
scanf("%d%d",&n,&m);
for(int i=0; i<=n; i++)father[i]=i;
for(int i=1; i<=m; i++)
{
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
work(x,y,z);
}
if(flag)printf("No\n");
else printf("Yes\n");
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
//#define int long long
#define mp make_pair
#define pb push_back
#define pii pair<int,int>
#define F first
#define S second
int const M=2e5+10,inf=1e9+10,mod=1e9+7,M2=1e6+10,M3=3e3+10;
int l[M],r[M],q[M],d[M];
vector<int>adj[M],edg[M],adj2[M],edg2[M];
bool mark[M];
int cur[M];
void dfs(int v)
{
mark[v]=1;
for(int i=0;i<adj[v].size();i++)
{
int u=adj[v][i];
if(mark[u] && cur[u]!=edg[v][i]+cur[v])
{
cout<<"No";
exit(0);
}
if(!mark[u])cur[u]=cur[v]+edg[v][i],dfs(u);
}
}
int main()
{
int n,m;
cin>>n>>m;
for(int i=1;i<=m;i++)scanf("%d%d%d",&l[i],&r[i],&d[i]),adj[l[i]].pb(r[i]),adj[r[i]].pb(l[i]),edg[l[i]].pb(d[i]),edg[r[i]].pb(-d[i]);
int tail=0,head=0;
int cnt=0;
for(int i=1;i<=n;i++)
{
if(!mark[i])dfs(i);
}
cout<<"Yes";
} |
#include <bits/stdc++.h>
using namespace std;
using pint = pair<int, int>;
#define x first
#define y second
int n, m, v[100004], w[100004];
vector<pint> g[100004];
bool dfs(int k, int x) {
if (v[k]) return w[k] == x;
v[k] = true; w[k] = x;
bool ret = true;
for (pint i : g[k]) ret &= dfs(i.x, x + i.y);
return ret;
}
int main() {
cin >> n >> m;
for (int i=0; i<m; i++) {
int x, y, k;
cin >> x >> y >> k;
g[x].emplace_back(y, k);
g[y].emplace_back(x, -k);
}
bool ans = true;
for (int i=1; i<=n; i++) if (!v[i]) ans &= dfs(i, 0);
cout << (ans ? "Yes" : "No");
} |
#include<bits/stdc++.h>
#define N 200005
using namespace std;
int n,m;
int f[N],d[N];
int find(int x)
{
if(x==f[x])return x;
int nf=find(f[x]);
d[x]+=d[f[x]];
return f[x]=nf;
}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)f[i]=i;
int t1,t2,t3;
for(int i=1;i<=m;i++)
{
scanf("%d%d%d",&t1,&t2,&t3);
int aa=find(t1),bb=find(t2);
if(aa!=bb)
{
f[aa]=bb;
d[aa]=d[t2]-d[t1]-t3;
}
else
{
if(d[t2]-d[t1]!=t3)return puts("No"),0;
}
}
puts("Yes");
return 0;
} |
#include "bits/stdc++.h"
using namespace std;
#define INF 1145141919810364364
int N, M;
static vector<pair<int, long long> > V[100000];
static long long Num[100000];
bool check = true;
void DFS(int p) {
for (pair<int, long long> x : V[p]) {
if (Num[x.first] == INF) {
Num[x.first] = Num[p] + x.second;
DFS(x.first);
}
else {
if (Num[x.first] != Num[p] + x.second) check = false;
}
}
}
int main() {
cin >> N >> M;
for (int i = 0; i < M; i++) {
int L, R, D;
cin >> L >> R >> D;
L--, R--;
V[L].push_back({ R, D });
V[R].push_back({ L, -D });
}
for (int i = 0; i < N; i++) {
Num[i] = INF;
}
for (int i = 0; i < N; i++) {
if (Num[i] == INF) {
Num[i] = 0;
DFS(i);
}
}
if (check) cout << "Yes";
else cout << "No";
} |
#include <bits/stdc++.h>
using namespace std;
int n, m, l, r, d1;
vector<pair<int,int>> e[100004];
bool visited[100004];
long long d[100004];
bool ok;
void dfs(int here){
visited[here] = true;
for(auto i : e[here]){
int there = i.first;
int dist = i.second;
if(!visited[there]){
d[there] = d[here] + dist;
dfs(there);
}
else
if(d[here]+dist != d[there])
ok = false;
}
return;
}
int main() {
cin>>n>>m;
while(m--){
cin>>l>>r>>d1;
e[l].push_back({r,d1});
e[r].push_back({l,-d1});
}
ok = true;
memset(visited,false,sizeof(visited));
memset(d,0,sizeof(d));
for(int i = 1; i<=n;i++){
if(visited[i]) continue;
d[i] = 0;
dfs(i);
}
cout<<(ok? "Yes" : "No");
return 0;
} |
#include<bits/stdc++.h>
#define N 500005
using namespace std;
int head[N],d[N]; bool vis[N],flag=false;
int n,m,x,y,z,kk=0;
struct Edge{int nxt,to,step;}e[N];
void link(int x,int y,int z){e[++kk].nxt=head[x];e[kk].to=y;e[kk].step=z;head[x]=kk;}
void dfs(int u)
{
if (flag) return; vis[u]=true;
for (int i=head[u];i;i=e[i].nxt){
int v=e[i].to; if (flag) return;
if (d[u]+e[i].step<d[v]){
d[v]=d[u]+e[i].step;
if (vis[v]){flag=true;return;}
else dfs(v);
}
} vis[u]=false;
}
int main()
{
scanf("%d%d",&n,&m);
for (int i=1;i<=m;i++){
scanf("%d%d%d",&x,&y,&z);
link(x,y,z);link(y,x,-z);
} flag=false;
for (int i=1;i<=n;i++){
dfs(i); if (flag) break;
} if (flag) puts("No"); else puts("Yes");
return 0;
} |
#include<iostream>
#include<cstring>
#include<cstdio>
#define N 100010
using namespace std;
int fa[N],d[N];
inline int findf(int x)
{
int fx=x,y,sav,s=0;
while(fx^fa[fx]) s+=d[fx],fx=fa[fx];
while(x^fx) sav=d[x],d[x]=s,s-=sav,
y=fa[x],fa[x]=fx,x=y;
return fx;
}
int main()
{
int n,m,f=1;scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++) fa[i]=i,d[i]=0;
while(m--)
{
int x,y,z;scanf("%d%d%d",&x,&y,&z);
int fx=findf(x),fy=findf(y);
if(fx^fy) fa[fx]=fy,d[fx]=z+d[y]-d[x];
else if(d[x]-d[y]==z) continue;
else { f=0;break; }
}
if(f) printf("Yes\n");
else printf("No\n");
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
struct bian{
int x,to,next;
}edge[400001];
int cnt,head[100001],dis[100001];
bool vis[100001],f;
inline void add(int u,int v,int x){
edge[++cnt].x=x,edge[cnt].to=v,edge[cnt].next=head[u],head[u]=cnt;
}
inline void dfs(int x){
for(int i=head[x];i;i=edge[i].next){
if(!vis[edge[i].to]){
vis[edge[i].to]=1;
dis[edge[i].to]=dis[x]+edge[i].x;
dfs(edge[i].to);
}
else if(dis[edge[i].to]!=dis[x]+edge[i].x){
f=0;
return;
}
}
}
int main()
{
ios::sync_with_stdio(false);
int n,m;
cin>>n>>m;
for(int i=1;i<=m;i++){
int l,r,d;
cin>>l>>r>>d;
add(l,r,-d),add(r,l,d);
}
for(int i=1;i<=n;i++){
if(!vis[i]){
vis[i]=1;
f=1;
dfs(i);
if(!f||dis[i]!=0){
cout<<"No";
return 0;
}
}
}
cout<<"Yes";
} |
#include<bits/stdc++.h>
using namespace std;
int N, M, ap[100009];
long long h[100009];
vector < pair < int, int > > v[100009];
void dfs (int nod)
{
ap[nod] = 1;
for (auto it : v[nod])
if (ap[it.first] == 0)
h[it.first] = h[nod] + it.second, dfs (it.first);
}
int main ()
{
//freopen ("input", "r", stdin);
//freopen ("output", "w", stdout);
scanf ("%d %d", &N, &M);
while (M --)
{
int x, y, d;
scanf ("%d %d %d", &x, &y, &d);
v[x].push_back ({y, d});
v[y].push_back ({x, -d});
}
for (int i=1; i<=N; i++)
if (ap[i] == 0)
h[i] = 0, dfs (i);
for (int i=1; i<=N; i++)
for (auto it : v[i])
if (h[it.first] != h[i] + it.second)
{
printf ("No\n");
return 0;
}
printf ("Yes\n");
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.