洛谷 p1993 小K的农场（差分约束系统）

题目描述

小 K 在 Minecraft 里面建立很多很多的农场，总共 n 个，以至于他自己都忘记了每个

农场中种植作物的具体数量了，他只记得一些含糊的信息（共 m 个），以下列三种形式描

述：

农场 a 比农场 b 至少多种植了 c 个单位的作物。

农场 a 比农场 b 至多多种植了 c 个单位的作物。

农场 a 与农场 b 种植的作物数一样多。
但是，由于小 K 的记忆有些偏差，所以他想要知道存不存在一种情况，使得农场的种

植作物数量与他记忆中的所有信息吻合。

输入输出格式

输入格式：
从 farm.in 中输入数据

第一行包括两个整数 n 和 m，分别表示农场数目和小 K 记忆中的信息数目。

接下来 m 行：

如果每行的第一个数是 1，接下来有 3 个整数 a,b,c，表示农场 a 比农场 b 至少多种植

了 c 个单位的作物。

如果每行的第一个数是 2，接下来有 3 个整数 a,b,c，表示农场 a 比农场 b 至多多种植

了 c 个单位的作物。如果每行的第一个数是 3，家下来有 2 个整数 a,b，表示农场 a 终止的

数量和 b 一样多。

输出格式：
输出到 farm.out 中

如果存在某种情况与小 K 的记忆吻合，输出“Yes”，否则输出“No”。

输入输出样例

输入样例#1：
3 3
3 1 2
1 1 3 1
2 2 3 2
输出样例#1：
Yes
说明

对于 100% 的数据保证：1 ≤ n，m，a，b，c ≤ 10000。

分析：
一看就是差分约束系统，跑最短路即可，判断是否有负环。
第一种：ai-bi>=ci
所以bi-ai<=-ci，于是bi与ai连一条-ci的边。
第二种：ai-bi<=ci
于是ai与bi连一条ci的边。
第三种：ai=bi，也就是说同时满足ai-bi>=0 and ai-bi<=0，于是ai-bi连一条0的双向边。
图不一定连通，我们可以从0向每个点连一条边。
一定要用dfs打法，即用一个栈去存储即可。

代码：

const
  MaxE=500001;
  MaxV=150001;

type
  rec=record
   x,y,w,next:longint;
  end;
var
  n,m,c,qx,i,x,y,w,o,q:longint;
  g:array [0..Maxv] of rec;
  ls:array [0..Maxe] of longint;
  v,d,list,sum:array [0..maxe] of longint;

procedure spfa(first:longint);
var
  head,tail,t,i,qe:longint;
begin
  tail:=1;
  list[1]:=first;
  for i:=1 to n do
  d[i]:=maxlongint;
  d[first]:=0;
  v[first]:=1;
  while tail<>0 do
    begin
      t:=ls[list[tail]];
      qe:=list[tail];
      tail:=tail-1;
      while t>0 do
        with g[t] do
          begin
            if d[x]+w<d[y] then
              begin
                d[y]:=d[x]+w;
                if v[y]=0 then
                  begin
                    v[y]:=1;
                    tail:=tail+1;
                    list[tail]:=y;
                    inc(sum[y]);
                    if (sum[y]>=n) then
                     begin
                      writeln('No');
                      halt;
                     end;
                  end;
              end;
            t:=next;
          end;
      v[qe]:=0;
    end;
end;

procedure add(x,y,w:longint);
 begin
  inc(o);
  g[o].x:=x;
  g[o].y:=y;
  g[o].w:=w;
  g[o].next:=ls[x];
  ls[x]:=o;
 end;

begin
   read(n,m);
  for i:=1 to m do
   begin
    read(qx);
    case qx of
    1:begin read(x,y,w); add(y,x,-w); end;
    2:begin read(x,y,w); add(x,y,w); end;
    3:begin read(x,y); add(x,y,0); add(y,x,0); end;
    end;
   end;
  for i:=1 to n do
   add(0,i,0);
  spfa(0);
  writeln('Yes');
end.