spoj，gss系列

Spoj 1034 gss 1

给出n个数，然后q组询问，每组询问x，y，表示求区间[x, y]内的最大连续和是多少

解：线段树，写得很挫，复杂度高死了，有空收集一些高效程序来研究

//spoj gss 1 ...
const
        maxn=50011;
        inf='1.txt';
type
        type_node=record
          sonl, sonr, l, r, mid, max, sul, sur, sum: longint;
        end;
var
        tree: array[0..maxn*4]of type_node;
        a: array[0..maxn]of longint;
        n, q, x, y: longint;
procedure build(k, xx, yy: longint);
begin
  with tree[k] do begin
    l := xx; r := yy;
    mid := (l+r)>>1;
    if l=r then begin
      sum := a[l]; max := a[l]; sul := a[l]; sur := a[l];
      sonl := 0; sonr := 0;
      exit;
    end;
    sonl := k << 1; sonr := sonl + 1;
    build(sonl, xx, mid);
    build(sonr, mid+1, yy);
    sum := tree[sonl].sum + tree[sonr].sum;
    if ((tree[sonl].sul)>(tree[sonl].sum+tree[sonr].sul)) then sul := tree[sonl].sul
      else sul := tree[sonl].sum+tree[sonr].sul;
    if ((tree[sonr].sur)>(tree[sonr].sum+tree[sonl].sur)) then sur := tree[sonr].sur
      else sur := tree[sonr].sum+tree[sonl].sur;
    if (tree[sonl].max>tree[sonr].max) then max := tree[sonl].max
      else max := tree[sonr].max;
    if (max<tree[sonl].sur+tree[sonr].sul) then max := tree[sonl].sur+tree[sonr].sul;
  end;
end;

function askr(k, xx, yy: longint): longint;
var
        tmp: longint;
begin
  while (xx>tree[k].mid)and(tree[k].sonl<>0) do k := tree[k].sonr;
  with tree[k] do begin
    if (xx=l)and(r=yy) then exit(sur);
    askr := tree[sonr].sur;
    tmp :=  tree[sonr].sum + {tree[sonl].sur}askr(sonl, xx, mid);
    if tmp>askr then askr := tmp;              {1 wa}
  end;
end;

function askl(k, xx, yy: longint): longint;
var
        tmp: longint;
begin
  while (yy<=tree[k].mid)and(tree[k].sonl<>0) do k := tree[k].sonl;
  with tree[k] do begin
    if (l=xx)and(r=yy) then exit(sul);
    askl := tree[sonl].sul;
    tmp := tree[sonl].sum + {tree[sonr].sul}askl(sonr, mid+1, yy);
    if tmp>askl then askl := tmp;
  end;
end;

function query(k, xx, yy: longint): longint;
var
        tmp: longint;
begin
  query := -maxlongint;
  with tree[k] do begin
    if (xx<=l)and(r<=yy) then exit(max);
    if yy<=mid then query := query(sonl, xx, yy)
      else if xx>mid then query := query(sonr, xx, yy)
        else begin
          tmp := query(sonl, xx, mid);
          if query<tmp then query := tmp;
          tmp := query(sonr, mid+1, yy);
          if query<tmp then query := tmp;
          tmp := askr(sonl, xx, mid) + askl(sonr, mid+1, yy);
          if query<tmp then query := tmp;
        end;
  end;
end;

procedure init;
var
        i: longint;
begin
  readln(n);
  for i := 1 to n do read(a[i]); readln;
  fillchar(tree, sizeof(tree[0]), 0);
  build(1, 1, n);
end;

procedure main;
var
        i: longint;
begin
  readln(q);
  for i := 1 to q do begin
    readln(x, y);
    writeln(query(1, x, y));
  end;
end;

begin
  //assign(input,inf); reset(input);
  init;
  main;
end.

Spoj 1716 gss3

题意同gss1，只是增加了修改数的操作

解：同gss1，+个修改数的操作，另外自己以后写程序注意把跳出语句放在前面（放在更新语句后），202调起来很蛋疼，fp老是开开关关的..

//orzorzorz
const
        maxn=50011;
        inf='1.txt';
type
        type_node=record
          l, r, mid, sonl, sonr, max, sum, sul, sur: longint;
        end;
var
        tree: array[0..maxn*4]of type_node;
        a: array[0..maxn]of longint;
        x, y, n, m: longint;

procedure build(k, ll, rr: longint);
var
        tmp: longint;
begin
  with tree[k] do begin
    l := ll; r := rr; mid := (l+r)>>1;
    if ll=rr then begin
      sum := a[l]; max := a[l]; sul := a[l]; sur := a[l];
      sonl := 0; sonr := 0;
      exit;
    end;
    sonl := k << 1; sonr := sonl + 1;
    build(sonl, ll, mid); build(sonr, mid+1, rr);
    sum := tree[sonl].sum + tree[sonr].sum;
    if ((tree[sonr].sur)>(tree[sonl].sur+tree[sonr].sum)) then sur := tree[sonr].sur
      else sur := tree[sonl].sur+tree[sonr].sum;
    if ((tree[sonl].sul)>(tree[sonl].sum+tree[sonr].sul)) then sul := tree[sonl].sul
      else sul := tree[sonl].sum+tree[sonr].sul;
    if ((tree[sonl].max)>(tree[sonr].max)) then max := tree[sonl].max
      else max := tree[sonr].max;
    if ((tree[sonl].sur+tree[sonr].sul)>(max)) then max := tree[sonl].sur+tree[sonr].sul;
  end;
end;

procedure init;
var
        i: longint;
begin
  readln(n);
  for i := 1 to n do read(a[i]); readln;
  fillchar(tree, sizeof(tree[0]), 0);
  build(1, 1, n);
end;

procedure change(k, xx, num: longint);
var
        tmp: longint;
begin
  with tree[k] do begin
    if (l=r) then begin
      max := num; sum := num; sur := num; sul := num;
      exit;
    end
     else if xx<=mid then change(sonl, xx, num)
      else if xx>mid then change(sonr, xx, num);
    sum := tree[sonl].sum + tree[sonr].sum;
    if ((tree[sonr].sur)>(tree[sonl].sur+tree[sonr].sum)) then sur := tree[sonr].sur
      else sur := tree[sonl].sur+tree[sonr].sum;
    if ((tree[sonl].sul)>(tree[sonl].sum+tree[sonr].sul)) then sul := tree[sonl].sul
      else sul := tree[sonl].sum+tree[sonr].sul;
    if ((tree[sonl].max)>(tree[sonr].max)) then max := tree[sonl].max
      else max := tree[sonr].max;
    if ((tree[sonl].sur+tree[sonr].sul)>(max)) then max := tree[sonl].sur+tree[sonr].sul;
  end;
end;

function askr(k, xx, yy: longint): longint;
var
        tmp: longint;
begin
  while (xx>tree[k].mid)and(tree[k].sonr<>0) do k := tree[k].sonr;
  with tree[k] do begin
    if (l=xx)and(r=yy) then exit(sur);
    tmp := tree[sonr].sur;
    askr := tree[sonr].sum + askr(sonl, xx, mid);
    if tmp>askr then askr := tmp;
  end;
end;

function askl(k, xx, yy: longint): longint;
var
        tmp: longint;
begin
  while (yy<=tree[k].mid)and(tree[k].sonl<>0) do k := tree[k].sonl;
  with tree[k] do begin
    if (l=xx)and(r=yy) then exit(sul);
    tmp := tree[sonl].sul;
    askl := tree[sonl].sum + askl(sonr, mid+1, yy);
    if tmp>askl then askl := tmp;
  end;
end;

function query(k, xx, yy: longint): longint;
var
        tmp: longint;
begin
  //query := -maxlongint;
  with tree[k] do begin
    if (xx<=l)and(r<=yy) then exit(max);
    if yy<=mid then query := query(sonl, xx, yy)
      else if xx>mid then query := query(sonr, xx, yy)
        else begin
          query := query(sonl, xx, mid);
          tmp := query(sonr, mid+1, yy);
          if tmp>query then query := tmp;
          tmp := askr(sonl, xx, mid) + askl(sonr, mid+1, yy);
          if tmp>query then query := tmp;
        end;
  end;
end;

procedure main;
var
        i, key: longint;
begin
  readln(m);
  for i := 1 to m do begin
    readln(key, x, y);
    if key=0 then change(1, x, y)
      else writeln(query(1, x, y));
  end;
end;

begin
  assign(input,inf); reset(input);
  init;
  main;
end.

Spoj 2713 gss4

题意：给出n个数，有两个操作，0 x y ，表示[x,y]中每个数开放向下去整，1 x y，表示求区间[x, y]的和

解：写了两种线段树，都tle了，蛋疼死，上网看了一下其他做法，有一个是暴力更新区间，不过用并差集维护，线段树组求和。我自己也跟风写了这个，疼~~~

const
        maxn=100011;
        inf='1.txt';
var
        a, tree: array[0..maxn]of qword;
        fath: array[0..maxn]of longint;
        n, m: longint;

procedure add(x: longint; num: int64);
begin
  while x<=n do begin
    tree[x] := tree[x] + num;
    x := x + (x and (-x));
  end;
end;

function query(x: longint): qword;
begin
  query := 0;
  while x>0 do begin
    query := query + tree[x];
    x := x - (x and (-x));
  end;
end;

function getfather(x: longint): longint;
begin
  if fath[x]=x then exit(x);
  fath[x] := getfather(fath[x]);
  exit(fath[x]);
end;

procedure change(x, y: longint);
var
        i: longint;
begin
  i := getfather(x);
  while (i<=y)and(i<>0) do begin
    if a[i]<>1 then begin
      add(i, -a[i]);
      a[i] := trunc(sqrt(a[i]));
      add(i, a[i]);
      if a[i]=1 then fath[i] := fath[i+1];
    end;
    i := getfather(i+1);
  end;
end;

procedure init;
var
        i: longint;
begin
  readln(n);
  fillchar(tree, sizeof(tree), 0);
  for i := 1 to n do begin
    read(a[i]); add(i, a[i]);
    fath[i] := i;
  end;
  readln;
end;

procedure main;
var
        i, x, y, key, tmp: longint;
begin
  readln(m);
  for i := 1 to m do begin
    readln(key, x, y);
    if x>y then begin
      tmp := x; x := y; y := tmp;
    end;
    if key=0 then change(x, y)
      else writeln(query(y)-query(x-1));
  end;
end;

var test: longint;

begin
  assign(input,inf); reset(input);
  test := 0;
  while not seekeof do begin
    inc(test);
    writeln('Case #',test,':');
    init;
    main;
    writeln;
  end;
end.

Spoj 2916 gss5

呼~~，说点闲话，我又回来了，闭关了一个星期后（其实一点收获也没有吧喂！），我终于又回来切题了，我重接着上次的思路去做gss5（居然还接得上），这次的格式我就乱一点了，这次是给出n个数，给出区间左右端点的取值范围，然后求最大值区间，本质是恶心到死的分类讨论，我真是弱死了，切了一个中午，其实我本来的区间划分没什么大问题的，但是最大的问题就是考虑一个区间的值是否为0的时候取舍问题，我写的函数是至少取一个的，那么写的就超级麻烦了，所以最后写了一大堆if，然后子程序也写了4个，超丑，希望日后有空回来写下，对比下，看看自己的进步好了。

const
        maxn=100111;
        inf='1.txt';
type
        type_node=record
          sonl, sonr, l, r, mid, sul, sur, sum, max: longint;
        end;
var
        tree: array[0..maxn]of type_node;
        a: array[0..maxn]of longint;
        i, test, n, m: longint;
        tmpl, tmpr, tmpm: longint;

procedure build(k, ll, rr: longint);
begin
  with tree[k] do begin
    l := ll; r := rr; mid := (l+r)>>1;
    if l=r then begin
      sul := a[l]; sur := a[l]; sum := a[l]; max := a[l];
      sonl := 0; sonr := 0;
      exit;
    end;
    sonl := k << 1; sonr := sonl + 1;
    build(sonl, ll, mid); build(sonr, mid+1, rr);
    sum := tree[sonl].sum + tree[sonr].sum;
    if ((tree[sonl].sul)>(tree[sonl].sum+tree[sonr].sul)) then sul := tree[sonl].sul
      else sul := tree[sonl].sum+tree[sonr].sul;
    if ((tree[sonr].sur)>(tree[sonr].sum+tree[sonl].sur)) then sur := tree[sonr].sur
      else sur := tree[sonr].sum+tree[sonl].sur;
    max := sul;
    if sur>max then max := sur;
    if tree[sonl].max > max then max := tree[sonl].max;
    if tree[sonr].max > max then max := tree[sonr].max;
    if (tree[sonl].sur+tree[sonr].sul>max) then max := tree[sonl].sur+tree[sonr].sul;
  end;
end;

function query(k, ll, rr: longint): longint;
begin
  if ll>rr then exit(0);
  with tree[k] do begin
    if (ll<=l)and(r<=rr) then exit(sum);
    if ll>mid then query := query(sonr, ll, rr)
      else if rr<=mid then query := query(sonl, ll, rr)
        else query := query(sonl, ll, mid) + query(sonr, mid+1, rr);
  end;
end;

function askl(k, ll, rr: longint): longint;
var
        tmp: longint;
begin
  if ll>rr then exit(0);
  with tree[k] do begin
    if (ll<=l)and(r<=rr) then exit(sul);
    if ll>mid then askl := askl(sonr, ll, rr)
      else if rr<=mid then askl := askl(sonl, ll, rr)
        else begin
          askl := askl(sonl, ll, mid);
          tmp := query(sonl, ll, mid) + askl(sonr, mid+1, rr);
          if tmp>askl then askl := tmp;
        end;
  end;
end;

function askr(k, ll, rr: longint): longint;
var
        tmp: longint;
begin
  if ll>rr then exit(0);
  with tree[k] do begin
    if (ll<=l)and(r<=rr) then exit(sur);
    if ll>mid then askr := askr(sonr, ll, rr)
      else if rr<=mid then askr := askr(sonl, ll, rr)
        else begin
          askr := askr(sonr, mid+1, rr);
          tmp := askr(sonl, ll, mid) + query(sonr, mid+1, rr);
          if tmp>askr then askr := tmp;
        end;
  end;
end;

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

function _max(k, ll, rr: longint): longint;
begin
  if ll>rr then exit(0);
  with tree[k] do begin
    if (ll<=l)and(r<=rr) then exit(max);
    if mid<ll then _max := _max(sonr, ll, rr)
      else if mid>=rr then _max := _max(sonl, ll, rr)
        else begin
          _max := _max(sonl, ll, mid);
          tmpm := _max(sonr, mid+1, rr);
          if tmpm>_max then _max := tmpm;
          tmpm := askr(sonl, ll, mid) + askl(sonr, mid+1, rr);
          if tmpm>_max then _max := tmpm;
        end;
  end;
end;

procedure init;
var
        i: longint;
begin
  read(n); for i := 1 to n do read(a[i]); readln;
  build(1, 1, n);
end;

procedure main;
var
        i, x1, x2, y1, y2, ans, tmp, ttt: longint;
begin
  readln(m);
  for i := 1 to m do begin
    readln(x1, y1, x2, y2);
    if y1<=x2 then begin
      ans := query(1, y1, x2);
      tmp := askr(1, x1, y1-1); if tmp>0 then ans := ans + tmp;
      tmp := askl(1, x2+1, y2); if tmp>0 then ans := ans + tmp;
    end
      else begin
        ans := _max(1, x2, y1);
        if x1<x2 then begin
          tmp := askr(1, x1, x2);
          ttt := askl(1, x2+1, y1); if ttt>0 then tmp := ttt + tmp;
          if tmp>ans then ans := tmp;
        end;
        if y1<y2 then begin
          tmp := askl(1, y1, y2);
          ttt := askr(1, x2, y1-1); if ttt>0 then tmp := ttt + tmp;
          if tmp>ans then ans := tmp;
        end;
        if (x1<x2)and(y1<y2) then begin
          tmp := query(1, x2, y1);
          ttt := askr(1, x1, x2-1); if ttt>0 then tmp := ttt + tmp;
          ttt := askl(1, y1+1, y2); if ttt>0 then tmp := ttt + tmp;
          if tmp>ans then ans := tmp;
        end;
      end;
    writeln(ans);
  end;
end;

begin
  assign(input,inf);reset(input);
  fillchar(tree, sizeof(tree[0]), 0);
  readln(test);
  for i := 1 to test do begin
    init;
    main;
  end;
end.

Spoj 4487

Splay裸题，splay比线段树强大在插入删除，静态指针不能释放内存很纠结，而且多次调用函数也让我胆颤心惊，不过还是过了。

const
        oo=maxlongint >> 2;
        maxn=200011;
        null=-1;
        inf='1.txt';
type
        node=record
          size, left, right, num, father: longint;
          maxl, maxr, sum, opt: longint;
        end;
var
        tree: array[-1..maxn]of node;
        root, n, q, tot: longint;
function max(a, b: longint): longint;
begin if a>b then exit(a) else exit(b); end;
procedure updata(x: longint);
var
        tmp, tt: longint;
begin
  with tree[x] do begin
    sum := tree[left].sum + num + tree[right].sum;
    size := tree[left].size + 1 + tree[right].size;
    //maxl
    //tmp := tree[left].maxl; if tmp>maxl then maxl := tmp;
    maxl := tree[left].maxl;
    tmp := tree[right].maxl; if tmp<0 then tmp := 0;
    tmp := tree[left].sum + num + tmp;
    if tmp>maxl then maxl := tmp;
    //maxr
    //tmp := tree[right].maxr; if tmp>maxr then maxr := tmp;
    maxr := tree[right].maxr;
    tmp := tree[left].maxr; if tmp<0 then tmp := 0;
    tmp := tmp + num + tree[right].sum;
    if tmp>maxr then maxr := tmp;
    //opt
    //if maxl > opt then opt := maxl;
    opt := maxl;
    if maxr > opt then opt := maxr;
    if tree[left].opt>opt then opt := tree[left].opt;
    if tree[right].opt>opt then opt := tree[right].opt;
    //tmp := tree[left].maxr + num + tree[right].maxl;!!
    tt := tree[left].maxr; if tt<0 then tt := 0;
    tmp := num + tt;
    tt := tree[right].maxl; if tt<0 then tt := 0;
    tmp := tmp + tt;
    if tmp>opt then opt := tmp;
    {maxl:=max(tree[left].maxl,tree[left].sum+num+max(0,tree[right].maxl));
    maxr:=max(tree[right].maxr,tree[right].sum+num+max(0,tree[left].maxr));
    opt:=max(maxl,maxr);
    opt:=max(opt,max(tree[left].opt,tree[right].opt));
    opt:=max(opt,max(0,tree[left].maxr)+num+max(0,tree[right].maxl));}
  end;
end;

procedure zig(x: longint);
var
        y, p: longint;
begin
  with tree[x] do begin
    y := father; if y=root then root := x;
    tree[y].left := right;
    if right<>null then tree[right].father := y;
    p := tree[y].father;
    father := p;
    if p<>null then begin
      if tree[p].left=y then tree[p].left := x
        else tree[p].right := x;
    end;
    right := y;
    tree[y].father := x;
  end;
  updata(y);
  //updata(x); yihouhuigengxin
end;

procedure zag(x: longint);
var
        y, z: longint;
begin
  with tree[x] do begin
    y := father; if y=root then root := x;
    tree[y].right := left;
    if left<>null then tree[left].father := y;
    z := tree[y].father;
    father := z;
    if z<>null then begin
      if tree[z].left=y then tree[z].left := x
        else tree[z].right := x;
    end;
    left := y;
    tree[y].father := x;
  end;
  updata(y);
end;


function build(l, r: longint): longint;
var
        x: longint;
begin
  x := (l+r)>>1; build := x;
  with tree[x] do begin
    if l<x then begin
      left := build(l, x-1);
      tree[left].father := x;
    end else left := null;
    if x<r then begin
      right := build(x+1, r);
      tree[right].father := x;
    end else right := null;
  end;
  updata(x);
end;

function find(x: longint): longint;
var
        i: longint;
begin
  i := root;
  while true do with tree[i] do begin
    if tree[left].size+1=x then exit(i);
    if tree[left].size+1>x then i := left
      else begin
        x := x-tree[left].size-1;
        i := right;
      end;
  end;
end;

procedure splay(x, goal: longint);
var
        y, z, u, v: longint;
begin
  while tree[x].father<>goal do with tree[x] do begin
    y := father; if tree[y].left=x then u := 0 else u := 1;
    z := tree[y].father;
    if z=goal then begin
      if u=0 then zig(x) else zag(x);
      continue;
    end;
    if tree[z].left=y then v := 0 else v := 1;
    if (u xor v = 0) then begin
      if u=0 then begin
        zig(y); zig(x);
      end
      else begin
        zag(y); zag(x);
      end;
    end
    else begin
      if u=0 then zig(x) else zag(x);
      if v=0 then zig(x) else zag(x);
    end;
  end;
  updata(x);
end;

procedure ins(x, number: longint);
var
        l, r, y: longint;
begin
  l := find(x-1); splay(l, null);
  r := find(x); splay(r, root);
  r := tree[root].right;
  inc(tot);
  with tree[tot] do begin
    num := number;
    left := null; right := null;
    updata(tot);
    //new(tot);
  end;
  tree[r].left := tot;
  tree[tot].father := r;
  updata(r);
  updata(root);
end;

procedure del(x: longint);
var
        l, r, y: longint;
begin
  l := find(x-1); splay(l, null);
  r := find(x+1); splay(r, root);
  r := tree[root].right;

  tree[r].left := null;
  updata(r);
  updata(root);
end;

procedure cha(x, number: longint);
var
        p, l, r, y: longint;
begin
  l := find(x-1); splay(l, null);
  r := find(x+1); splay(r, root);
  r := tree[root].right;

  p := tree[r].left;
  tree[p].num := number; //new(p);
  updata(p);
  updata(r);
  updata(root);
end;

function query(x, y: longint): longint;
var
        l, r, p: longint;
begin
  l := find(x-1);
  splay(l, null);
  r := find(y+1); splay(r, root);
  r := tree[root].right;
  p := tree[r].left;
  query := tree[p].opt;
end;

procedure init;
var
        i: longint;
begin
  readln(n);
  tot := n+1;
  with tree[0] do begin
    opt := -oo; maxl := -oo; maxr := -oo;
  end;
  with tree[tot] do begin
    opt := -oo; maxl := -oo; maxr := -oo;
  end;
  with tree[null] do begin
    opt := -oo; maxl := -oo; maxr := -oo; sum := 0;
  end;
  for i := 1 to n do with tree[i] do read(num); readln;
  readln(q);
  root := build(0, tot);
  tree[root].father := null;
end;

procedure print(x: longint);
var
        head, tail, i, time, s: longint;
        q: array[1..100]of longint;
begin
  head := 0; tail := 1;
  q[tail] := x;
  i := 32;
  s := 1; time := 0;
  while head<>tail do begin
    inc(head);
    inc(time);
    with tree[q[head]] do begin
      write(q[head]: i);
      if left<>null then begin
        inc(tail);
        q[tail] := left;
      end;
      if right<>null then begin
        inc(tail);
        q[tail] := right;
      end;
    end;
    if time=s then begin
      writeln; s := s << 1; i := i >> 1;
    end;
  end;
end;

procedure main;
var
        i, x, y, number: longint;
        c: char;
begin
  for i := 1 to q do begin
    read(c);
    case c of
      'I': begin
        readln(x, number); inc(x);
        ins(x, number);
      end;
      'D': begin
        readln(x); inc(x);
        del(x);
      end;
      'R': begin
        readln(x, number); inc(x);
        cha(x, number);
      end;
      'Q': begin
        readln(x, y); inc(x); inc(y);
        writeln(query(x, y));
      end;
    end;
    //print(root);
  end;
end;

begin
  assign(input,inf); reset(input);
  init;
  main;
end.

Spoj 6779

说点其他，gss到这里也就差不多了，不知道为什么，gss2特别不想切，所以还是等到暑假吧。为了爆掉95什么的，虽然这样说，可是好颓废，嗯，努力吧。

这题神牛表示是树链剖分裸体，于是去了解了一下，之前在黄天神牛的blog里看过，表示眼睛闪闪ym啊， 现在自己也去了解做了一下，具体做法是把一棵树的边分为轻重边，由于性质，一条路径上的轻边重边的数量不会超过logn（具体见国家队2009论文）。然后把连续的重边add进线段树，其他单独add，然后询问路径opt，改值做成线段树询问就行了，不用求lca，慢慢抬上去直到两个端点位于同一条重链上。具体的还是见代码吧，回来再补充。

const
        maxn=101111;
        def=maxlongint;
        inf='1.txt';
type
        type_tree=record
          flag, sum, opt, maxl, maxr, size,
          sonl, sonr, l, r, mid: longint;
        end;
        type_edge=record
          dest, next: longint;
        end;
var
        tree: array[0..maxn*4]of type_tree;
        edge: array[0..maxn*2]of type_edge;
        size, w, fa, dep, maxson, a, num, top, vect: array[0..maxn]of longint;
        n, q, tot, len: longint;

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

procedure updata(var c, a, b: type_tree);
var
        tmp: longint;
        k: type_tree;
begin
  k := c;
  with k do begin
    sum := a.sum + b.sum;
    size := a.size + b.size;
    maxl := a.maxl; tmp := a.sum + b.maxl; if tmp<0 then tmp := 0;
    if tmp>maxl then maxl := tmp;
    maxr := b.maxr; tmp := b.sum + a.maxr; if tmp<0 then tmp := 0;
    if tmp>maxr then maxr := tmp;
    opt := a.opt; if maxl>maxr then tmp := maxl else tmp:= maxr;
    if tmp>opt then opt := tmp;
    if b.opt > opt then opt := b.opt;
    if (a.maxr + b.maxl > opt ) then opt := a.maxr + b.maxl;
  end;
  c := k;
end;

procedure dfs_1(x: longint);
var
        i: longint;
        tmp: longint;
begin
  i := vect[x];
  tmp := 0;
  while i<>0 do
    with edge[i] do begin
      if dest <> fa[x] then begin
        fa[dest] := x;
        dfs_1(dest);
        inc(size[x], size[dest]);
        if size[dest] > size[tmp] then tmp := dest;
      end;
      i := next;
    end;
  if size[x] = 0 then size[x] := 1;
  if tmp <> 0 then maxson[x] := tmp;
end;

procedure dfs_2(x, head, depth: longint);
var
        i: longint;
begin
  top[x] := head; dep[x] := depth;
  inc(len); a[len] := w[x]; num[x] := len;
  if maxson[x] <> 0 then dfs_2(maxson[x], head, depth + 1);
  i := vect[x];
  while i<>0 do
    with edge[i] do begin
      if (dest <> fa[x])and(dest<>maxson[x]) then begin
        dfs_2(dest, dest, depth + 1);
      end;
      i := next;
    end;
end;

procedure build(k, left, right: longint);
begin
  with tree[k] do begin
    flag := def;
    l := left; r := right; mid := (l+r)>>1;
    if (l=r) then begin
      size := 1; opt := a[l]; sum := a[l]; maxl := a[l]; maxr := a[l];
      exit;
    end;
    sonl := k << 1; sonr := sonl + 1;
    build(sonl, left, mid); build(sonr, mid + 1, right);
    updata(tree[k], tree[sonl], tree[sonr]);
  end;
end;

procedure init;
var
        i, x, y: longint;
begin
  readln(n);
  for i := 1 to n do read(w[i]); readln;
  fillchar(vect, sizeof(vect), 0); tot := 0;
  for i := 1 to n-1 do begin
    readln(x, y);
    inc(tot);
    with edge[tot] do begin
      dest := y;
      next := vect[x];
      vect[x] := tot;
    end;
    inc(tot);
    with edge[tot] do begin
      dest := x;
      next := vect[y];
      vect[y] := tot;
    end;
  end;
  fillchar(fa, sizeof(fa), 0);
  fillchar(size, sizeof(size), 0);
  fillchar(maxson, sizeof(maxson), 0);
  dfs_1(1);
  len := 0;
  dfs_2(1, 1, 1);
  //len := 0;
  build(1, 1, n);
end;

procedure renew(k, cnum: longint);
begin
  with tree[k] do begin
    sum := size*cnum;
    if cnum>0 then opt := cnum*size else opt := cnum;
    maxl := opt; maxr := opt;
    flag := cnum;
  end;
end;

procedure clear(k: longint);
begin
  with tree[k] do begin
    if (l<>r)and(flag<>def) then begin
      renew(sonl, flag);
      renew(sonr, flag);
      flag := def;
    end;
  end;
end;

procedure cover(k, left, right, cnum: longint);
begin
  with tree[k] do begin
    if (left<=l)and(r<=right) then begin
      renew(k, cnum);
      exit;
    end;
    clear(k);
    if right<=mid then cover(sonl, left, right, cnum)
      else if left>mid then cover(sonr, left, right, cnum)
        else begin
          cover(sonl, left, mid, cnum);
          cover(sonr, mid+1, right, cnum);
        end;
    updata(tree[k], tree[sonl], tree[sonr]);
  end;
end;

procedure change(x, y, cnum: longint);
var
        k: longint;
        f1, f2: longint;
begin
  f1 := top[x]; f2 := top[y];
  while f1<>f2 do begin
    if dep[f1] >= dep[f2] then begin
      cover(1, num[f1], num[x], cnum);
      x := fa[f1]; f1 := top[x];
    end;
    if f1=f2 then break;
    if dep[f2] >= dep[f1] then begin
      cover(1, num[f2], num[y], cnum);
      y := fa[f2]; f2 := top[y];
    end;
  end;
  if dep[x] > dep[y] then begin
    k := x; x := y; y := k;
  end;
  cover(1, num[x], num[y], cnum);
end;

function ask(k, left, right: longint): type_tree;
var
        u, v: type_tree;
begin
  with tree[k] do begin
    if (left <= l)and(r <= right) then exit(tree[k]);
    clear(k);
    if right <= mid then ask := ask(sonl, left, right)
      else if left > mid then ask := ask(sonr, left, right)
        else begin
          u := ask(sonl, left, mid);
          v := ask(sonr, mid+1, right);
          updata(ask, u, v);
        end;
  end;
end;

function query(x, y: longint): type_tree;
var
        ans1, ans2, tmp: type_tree;
        f1, f2: longint;
begin
  fillchar(ans1, sizeof(ans1), 0);
  fillchar(ans2, sizeof(ans2), 0);
  f1 := top[x]; f2 := top[y];
  while f1<>f2 do begin
    if dep[f1] >= dep[f2] then begin
      tmp := ask(1, num[f1], num[x]);
      updata(ans1, tmp, ans1);
      x := fa[f1]; f1 := top[x];
    end;
    if f1=f2 then break;
    if dep[f2] >= dep[f1] then begin
      tmp := ask(1, num[f2], num[y]);
      updata(ans2, tmp, ans2);
      y := fa[f2]; f2 := top[y];
    end;
  end;
  if dep[x]>dep[y] then begin
    tmp := ask(1, num[y], num[x]);
    updata(ans1, tmp, ans1);
  end
  else begin
    tmp := ask(1, num[x], num[y]);
    updata(ans2, tmp, ans2);
  end;
  f1 := ans1.maxl; ans1.maxl := ans1.maxr; ans1.maxr := f1;
  updata(query, ans1, ans2);
end;

procedure main;
var
        i, x, y, z, c: longint;
        tmp: type_tree;
begin
  readln(q);
  for i := 1 to q do begin
    read(c);
    if c = 1 then begin
      readln(x, y);
      writeln(query(x, y).opt);
    end
    else begin
      readln(x, y, z);
      change(x, y, z);
    end;
  end;
end;

begin
  assign(input, inf); reset(input);
  init;
  main;
end.

f