【BZOJ2459】 [BeiJing2011]神秘好人

Description

有一个神秘好人跟Bdcxq玩一个游戏，如果Bdcxq成功完成了这个游戏，那么他将会得到一件礼物。

这个游戏是这样的：

有一个梯子形的图如下，每条边都有一个权值。

神秘好人一开始会告诉Bdcxq每条边的权值。

然后神秘好人会做这样的事情：

1．神秘好人会修改某条边的权值；

2．神秘老人会问你从一个点走到另一个点所需经过边权和最小的权值和。

如果Bdcxq一直能答对问题，那么他就完成了游戏，也能得到礼物。

现在他请你编一个程序来帮他完成游戏。

Input

输入文件的第一行包含一个整数N，表示梯子总共含有2N个点，第一行从左至右分别标号为1，3，……，2N-1，第二行从左至右分别标号为2，4，……，2N。

接下来有三行。

第一行有N-1个整数，依次表示上层相邻两点间的初始权值。

第二行有N个整数，依次表示两层之间的边的初始权值。

第三行有N-1个整数，依次表示下层相邻两点间的初始权值。

接下来一行包含一个整数M，表示神秘好人在游戏开始后的操作。

接下来M行：

每行第一个整数若是0，表示这是一个修改操作，接下来会有3个整数A_i，B_i，C_i，A_i为0，1，2分别代表这条边属于上层边，中间边和下层边，B_i表示这条边是这一层从左向右数的第B_i条边，C_i表示要修改成的边权。

每行第一个整数若是1，表示这是一个询问操作，接下来会有2个整数A_i，B_i，询问A_i到B_i的经过边的最小权值和。

Output

对于每次询问操作你需要输出一行包含一个整数，为最小的边权值和。

Sample Input

4
1 2 7
1 3 4 8
4 5 6
5
1 1 2
1 2 6
1 1 8
0 1 3 1
1 1 8

Sample Output

1
8
13
10

HINT

100%的数据满足N，M≤ 100000。

Solution

用线段树维护仅在这个区间内走时四个角的最短路的邻接矩阵，然后修改询问就强行维护一波就好啦。这题细节比较多，要注意一下。。。

Code

 #include <cstdio>
 #include <cstring>
 #include <algorithm>

 #define R register
 #define maxn 100010
 #define cmin(_a, _b) (_a > (_b) ? _a = (_b) : 0)
 #define dmin(_a, _b) ((_a) < (_b) ? (_a) : (_b))
 typedef long long ll;
 struct Data {
     ll d[][];
     inline void init()
     {
         memset(d, , sizeof (d));
         for (R int i = ; i < ; ++i) d[i][i] = ;
     }
     inline void floyd()
     {
         for (R int k = ; k < ; ++k)
             for (R int i = ; i < ; ++i)
                 for (R int j = ; j < ; ++j)
                     cmin(d[i][j], d[i][k] + d[k][j]);
     }
     inline Data operator + (const Data &that) const
     {
         R Data ret; ret.init();
         ret.d[][] = ret.d[][] = dmin(d[][], d[][] + that.d[][] + d[][]);
         ret.d[][] = ret.d[][] = dmin(that.d[][], that.d[][] + d[][] + that.d[][]);

         ret.d[][] = ret.d[][] = dmin(d[][] + that.d[][], d[][] + that.d[][]);
         ret.d[][] = ret.d[][] = dmin(d[][] + that.d[][], d[][] + that.d[][]);
         ret.d[][] = ret.d[][] = dmin(d[][] + that.d[][], d[][] + that.d[][]);
         ret.d[][] = ret.d[][] = dmin(d[][] + that.d[][], d[][] + that.d[][]);
 //        ret.floyd();
         return ret;
     }
 } ;
 int u[maxn], m[maxn], d[maxn];
 Data tr[maxn << ];
 void update(R int o)
 {
     tr[o] = tr[o << ] + tr[o <<  | ];
 }
 void build(R int o, R int l, R int r)
 {
     if (l == r)
     {
         tr[o].init();
         tr[o].d[][] = tr[o].d[][] = m[l];
         tr[o].d[][] = tr[o].d[][] = u[l];
         tr[o].d[][] = tr[o].d[][] = d[l];
         tr[o].d[][] = tr[o].d[][] = m[l + ];
         tr[o].floyd();
         return ;
     }
     R int mid = l + r >> ;
     build(o << , l, mid);
     build(o <<  | , mid + , r);
     update(o);
 }
 int ql, qr;
 void modify(R int o, R int l, R int r)
 {
     if (l == r)
     {
         tr[o].init();
         tr[o].d[][] = tr[o].d[][] = m[l];
         tr[o].d[][] = tr[o].d[][] = u[l];
         tr[o].d[][] = tr[o].d[][] = d[l];
         tr[o].d[][] = tr[o].d[][] = m[l + ];
         tr[o].floyd();
         return ;
     }
     R int mid = l + r >> ;
     if (ql <= mid) modify(o << , l, mid);
     else modify(o <<  | , mid + , r);
     update(o);
 }
 Data query(R int o, R int l, R int r)
 {
     if (ql <= l && r <= qr) return tr[o];
     R Data ret;
     R int mid = l + r >> ;
     if (ql <= mid && qr <= mid) return query(o << , l, mid);
     if (mid < ql && mid < qr) return query(o <<  | , mid + , r);
     return query(o << , l, mid) + query(o <<  | , mid + , r);
 }
 int main()
 {
     R int n; scanf("%d", &n);
     for (R int i = ; i < n; ++i) scanf("%d", u + i);
     for (R int i = ; i <= n; ++i) scanf("%d", m + i);
     for (R int i = ; i < n; ++i) scanf("%d", d + i);
     build(, , n - );
     R int q; scanf("%d", &q);
     for (; q; --q)
     {
         R int opt, a, b, c; scanf("%d%d%d", &opt, &a, &b);
         if (!opt)
         {
             scanf("%d", &c);
             if (a == ) u[b] = c;
             else if (a == ) m[b] = c;
             else d[b] = c;

             if (a !=  || b != n) ql = b, modify(, , n - );
             if (a ==  && b != ) ql = b - , modify(, , n - );
         }
         else
         {
             R int l = (a + ) >> , lt = (a + ) & , r = (b + ) >> , rt = (b + ) & ;
             l > r ? std::swap(l, r), std::swap(lt, rt),  : ;

             R Data v1, v2, v3; v1.init(); v2.init(); v3.init();
             ql = , qr = l - ;
             if (ql <= qr) v1 = query(, , n - );
             ql = l; qr = r - ;
             if (ql <= qr) v2 = query(, , n - );
             ql = r; qr = n - ;
             if (ql <= qr) v3 = query(, , n - );

             R ll ans = ;
             if (l == r)
             {
                 ans = dmin(v1.d[ + lt][ + rt], v3.d[lt][rt]);
             }
             else
             {
 //                for (R int i = 0; i < 4; ++i, puts("")) for (R int j = 0; j < 4; ++j) printf("%d ", v1.d[i][j]);
 //                for (R int i = 0; i < 4; ++i, puts("")) for (R int j = 0; j < 4; ++j) printf("%d ", v2.d[i][j]);
 //                for (R int i = 0; i < 4; ++i, puts("")) for (R int j = 0; j < 4; ++j) printf("%d ", v3.d[i][j]);
                 ans = v2.d[lt][ + rt];
                 cmin(ans, v1.d[][] + v2.d[lt ^ ][ + rt]);
                 cmin(ans, v2.d[lt][ + (rt ^ )] + v3.d[][]);
                 cmin(ans, v1.d[][] + v2.d[lt ^ ][ + (rt ^ )] + v3.d[][]);
 /*                cmin(v2.d[0][1], v1.d[2][3]);
                 cmin(v2.d[2][3], v3.d[0][1]);
                 v2.floyd();
                 ans = v2.d[lt][2 + rt];*/
             }
             printf("%lld\n", ans);
         }
     }
     return ;
 }
 /*
 4
 1 2 7
 1 3 4 8
 4 5 6
 5
 1 1 2
 1 2 6
 1 1 8
 0 1 3 1
 1 1 8
 */