bzoj3669

不难想到从小到大穷举a，判断在携带不超过a个B型精灵的情况下最少携带多少个B型精灵
这是一个经典的问题，显然要求出最小生成树，树上1到N路径上最大的边即是答案
所以我们要动态维护一个最小生成树可以用link cut tree维护
根据最小生成树的回路性质，我们加入一条边(u,v)，保留树上u-v路径上最大边和新边中小的那个
由于这里维护的是边权，我们可以把每条边当做一个点p(u,v)，连接(u,v)时，即是连接(u,p)和（v,p)
然后记录下路径上最大点权的编号即可

var son:array[0..150010,1..2] of longint;
    q,f,w,fa,v:array[0..150010] of longint;
    rev:array[0..150010] of boolean;
    s,e,a,b:array[0..150010] of longint;
    ans,i,n,m:longint;

function min(a,b:longint):longint;
  begin
    if a>b then exit(b) else exit(a);
  end;

function getf(x:longint):longint;
  begin
    if f[x]<>x then f[x]:=getf(f[x]);
    exit(f[x]);
  end;

procedure swap(var a,b:longint);
  var c:longint;
  begin
    c:=a;
    a:=b;
    b:=c;
  end;

function root(x:longint):boolean;
  begin
    exit((son[fa[x],1]<>x) and (son[fa[x],2]<>x));
  end;

procedure update(x:longint);
  begin
    w[x]:=x;
    if v[w[son[x,1]]]>v[w[x]] then w[x]:=w[son[x,1]];
    if v[w[son[x,2]]]>v[w[x]] then w[x]:=w[son[x,2]];
  end;

procedure push(x:longint);
  begin
    if rev[x] then
    begin
      rev[son[x,1]]:=not rev[son[x,1]];
      rev[son[x,2]]:=not rev[son[x,2]];
      swap(son[x,1],son[x,2]);
      rev[x]:=false;
    end;
  end;

procedure rotate(x,w:longint);
  var y:longint;
  begin
    y:=fa[x];
    if not root(y) then
    begin
      if son[fa[y],1]=y then son[fa[y],1]:=x
      else son[fa[y],2]:=x;
    end;
    fa[x]:=fa[y];
    son[y,3-w]:=son[x,w];
    if son[x,w]<>0 then fa[son[x,w]]:=y;
    son[x,w]:=y;
    fa[y]:=x;
    update(y);
  end;

procedure splay(x:longint);
  var y,t,i:longint;
  begin
    t:=0;
    i:=x;
    while not root(i) do
    begin
      inc(t);
      q[t]:=i;
      i:=fa[i];
    end;
    inc(t);
    q[t]:=i;
    for i:=t downto 1 do
      push(q[i]);
    while not root(x) do
    begin
      y:=fa[x];
      if root(y) then
      begin
        if son[y,1]=x then rotate(x,2)
        else rotate(x,1);
      end
      else begin
        if son[fa[y],1]=y then
        begin
          if son[y,1]=x then rotate(y,2)
          else rotate(x,1);
          rotate(x,2);
        end
        else begin
          if son[y,1]=x then rotate(x,2)
          else rotate(y,1);
          rotate(x,1);
        end;
      end;
    end;
    update(x);
  end;

procedure access(x:longint);
  var y:longint;
  begin
    y:=0;
    repeat
      splay(x);
      son[x,2]:=y;
      update(x);
      y:=x;
      x:=fa[x];
    until x=0;
  end;

procedure sort(l,r: longint);
  var i,j,x,y: longint;
  begin
    i:=l;
    j:=r;
    x:=a[(l+r) div 2];
    repeat
      while a[i]<x do inc(i);
      while x<a[j] do dec(j);
      if not(i>j) then
      begin
        swap(s[i],s[j]);
        swap(e[i],e[j]);
        swap(a[i],a[j]);
        swap(b[i],b[j]);
        inc(i);
        j:=j-1;
      end;
    until i>j;
    if l<j then sort(l,j);
    if i<r then sort(i,r);
  end;

procedure makeroot(x:longint);
  begin
    access(x);
    splay(x);
    rev[x]:=not rev[x];
  end;

procedure path(x,y:longint);
  begin
    makeroot(x);
    access(y);
    splay(y);
  end;

procedure link(x,y:longint);
  begin
    makeroot(x);
    fa[x]:=y;
  end;

procedure cut(x,y:longint);
  begin
    makeroot(x);
    access(y);
    splay(y);
    son[y,1]:=0;
    fa[x]:=0;
  end;

procedure deal(i:longint);
  var x,y,z:longint;
  begin
    x:=getf(s[i]);
    y:=getf(e[i]);
    if x<>y then
    begin
      f[x]:=y;
      link(s[i],n+i);
      link(e[i],n+i);
    end
    else begin
      x:=s[i];
      y:=e[i];
      path(x,y);
      z:=w[y];
      if v[z]>b[i] then
      begin
        cut(s[z-n],z);
        cut(e[z-n],z);
        link(s[i],n+i);
        link(e[i],n+i);
      end;
    end;
  end;

begin
  readln(n,m);
  for i:=1 to m do
    readln(s[i],e[i],a[i],b[i]);
  for i:=1 to n do
    f[i]:=i;
  sort(1,m);
  for i:=1 to m do
  begin
    v[n+i]:=b[i];
    w[n+i]:=n+i;
  end;
  ans:=2147483647;
  i:=0;
  while i<m do
  begin
    inc(i);
    deal(i);
    while a[i]=a[i+1] do
    begin
      inc(i);
      deal(i);
    end;
    if getf(1)=getf(n) then
    begin
      path(1,n);
      ans:=min(ans,a[i]+v[w[n]]);
    end;
  end;
  if ans=2147483647 then writeln(-1)
  else writeln(ans);
end.