计蒜客NOIP模拟赛(3)D1T3 任性的国王

X 国的地图可以被看作一个两行 nn 列的网格状图。现在 X 国需要修建铁路，然而该国的国王非常小气，他只想保证位于某两列之间的所有城市互相可以到达就行了，在此基础上，他希望所花费的代价最小。

铁路可以建在任何两个相邻的点之间，使他们可以互相到达。可以作为工作人员，你已经整理出了为每一对相邻城市架设铁路所需要的花费。你需要准备好回答国王如下形式的问题。

对于 (i,j)(i,j)：当前情况下，使第 ii 列到第 jj 列之间的所有城市连通的最小代价是多少（列下标从 11 开始）？注意不能用其他列的城市。

然而你还有更大的困难，随着时间变化，使用某些边作为铁路的代价会发生改变，你必须有效率地处理这些变化。

输入格式

第一行两个正整数 n,m，表示该国有 2 行 n 列以及 m个询问或者操作。

第二行 3n-2个数，前 n-1个数依次表示在第一行的 n-1 条边上修建铁路的代价。

接下来 n-1 个数，依次表示在第二行的 n-1 条边上修建铁路的代价。

最后 n 个数，依次表示在第 1列到第 n列的边上修建铁路的代价。

接下来 m 行的输入具有如下形式，K,S,T其中

若 K=1，则表示询问当前状态下，使所有第 S 列到第 T 列之间的城市连通需要的最小代价。

若 K=2，则表示位于第 1 行第 S 列的点到第 1 行第 S+1 列的点之间的边上修建铁路的代价变为 T。

若 K=3，则表示位于第 2 行第 S 列的点和第 2 行第 S+1 列的点之间的边上修建铁路的代价变为 T。

若 K=4，则表示第 S 列的边上修建铁路的代价变为 T。

输出格式

依次对每个询问，用一行输出相应的答案。

数据范围与约定

对于 30% 的数据：n,m≤2000。

另有 30% 的数据：所有竖边的代价为 0 且永不改变。

对于全部数据：n,m<10^5

所有输入和输出数据保证合法，且不超过 2^{31}-1

样例输入

4 14
2 3 4 3 1 1 1 5 4 7
1 1 2
1 2 3
1 1 3
1 2 4
2 1 5
1 1 4
4 2 1
1 1 3
1 2 3
1 2 4
3 3 100
1 3 4
1 2 4
1 1 4
样例输出

6
8
10
13
17
9
5
10
15
16
20

暴力显然可以每一次查询做一次最小生成树

一开始贪心，每一列选两个最小的边，用线段树维护，然后选一个最小的未选边

但这样显然不能保证图连通和最优

我们要想办法用数据结构来优化查询和修改，这里用线段树

w[rt][0/1][0/1]表示rt区间左，右是否有竖边的最小值

这样就可以通过左右区间合并来维护和查询

注意当区间只有一个元素时

w[rt][0][1]=a[l]+b[l]+c[l+1]

每一个节点都要算上下一个点的竖边，合并时要减去重复的竖边

详情见代码，这样是可以保证图连通的

s=t时要特判

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 typedef long long lol;
 struct XXX
 {
  lol a[][];
 };
 lol w[][][],a[],b[],c[];
 int n,m;
 void pushup(int rt,int mid)
 {int i,j;
     for (i=;i<=;i++)
         for (j=;j<=;j++)
         {
             w[rt][i][j]=1e9;
           lol cost=w[rt*][i][]+w[rt*+][][j]-c[mid+];
             w[rt][i][j]=min(w[rt][i][j],cost);
             cost=w[rt*][i][]+w[rt*+][][j]-c[mid+];
             w[rt][i][j]=min(w[rt][i][j],cost);
             cost=w[rt*][i][]+w[rt*+][][j]-c[mid+];
             w[rt][i][j]=min(w[rt][i][j],cost);
         }
 }
 void build(int rt,int l,int r)
 {
  if (l>r) return;
     if (l==r)
     {
         lol tot=a[l]+b[l]+c[l]+c[l+];
         w[rt][][]=tot-c[l+];
         w[rt][][]=tot-(a[l]+b[l]+abs(b[l]-a[l]))/;
         w[rt][][]=1e9;
         w[rt][][]=tot-c[l];
         return;
     }
     int mid=(l+r)/;
     build(rt*,l,mid);
     build(rt*+,mid+,r);
 pushup(rt,mid);
 }
 void ask(int rt,int l,int r,int L,int R,XXX &p)
 {int i,j;
  if (l>r) return;
     if (l>=L&&r<=R)
     {
         for (i=;i<=;i++)
             for (j=;j<=;j++)
             p.a[i][j]=w[rt][i][j];
         return;
     }
     XXX p1,p2;
     if (l==r) return;
  int mid=(l+r)/;
  if (L>=mid+)
  {
      ask(rt*+,mid+,r,L,R,p2);
      for (i=;i<=;i++)
          for (j=;j<=;j++)
              p.a[i][j]=p2.a[i][j];
      return;
  }
  if (R<=mid)
  {
      ask(rt*,l,mid,L,R,p1);
      for (i=;i<=;i++)
          for (j=;j<=;j++)
              p.a[i][j]=p1.a[i][j];
      return;
  }
     ask(rt*,l,mid,L,R,p1);
     ask(rt*+,mid+,r,L,R,p2);
   for (i=;i<=;i++)
       for (j=;j<=;j++)
       {
           p.a[i][j]=1e9;
            lol cost=p1.a[i][]+p2.a[][j]-c[mid+];
             p.a[i][j]=min(p.a[i][j],cost);
             cost=p1.a[i][]+p2.a[][j]-c[mid+];
             p.a[i][j]=min(p.a[i][j],cost);
             cost=p1.a[i][]+p2.a[][j]-c[mid+];
             p.a[i][j]=min(p.a[i][j],cost);
       }
 }
 void update(int rt,int l,int r,lol k,lol x,lol d)
 {
  if (l>r) return;
     if (l==r)
     {
         if (k==) a[x]=d;
         if (k==) b[x]=d;
         if (k==) c[x]=d;
          lol tot=a[l]+b[l]+c[l]+c[l+];
         w[rt][][]=tot-c[l+];
         w[rt][][]=tot-(a[l]+b[l]+abs(b[l]-a[l]))/;
         w[rt][][]=1e9;
         w[rt][][]=tot-c[l];
         return;
     }
     int mid=(l+r)/;
     if (k==)
     {
          if (x<=mid+) update(rt*,l,mid,k,x,d);
          if (x>=mid+) update(rt*+,mid+,r,k,x,d);
     }
     else
     {
     if (x<=mid) update(rt*,l,mid,k,x,d);
     else update(rt*+,mid+,r,k,x,d);
     }
 pushup(rt,mid);
 }
 int main()
 {int i;
 lol k,s,t;
  XXX p;
     cin>>n>>m;
     for (i=;i<=n-;i++)
         scanf("%lld",&a[i]);
     for (i=;i<=n-;i++)
         scanf("%lld",&b[i]);
     for (i=;i<=n;i++)
         scanf("%lld",&c[i]);
     build(,,n-);
     while (m--)
     {lol ans=2e9;
         scanf("%lld%lld%lld",&k,&s,&t);
         if (k==)
         {
             if (s==t)
             {printf("%lld\n",c[s]);continue;}
             ask(,,n-,s,t-,p);
             ans=min(min(p.a[][],p.a[][]),min(p.a[][],p.a[][]));
             printf("%lld\n",ans);
         }
         else
         {
             update(,,n-,k,s,t);
         }
     }
 }

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 typedef long long lol;
 struct XXX
 {
  lol a[][];
 };
 lol w[][][],a[],b[],c[];
 int n,m;
 void pushup(int rt,int mid)
 {int i,j;
     for (i=;i<=;i++)
         for (j=;j<=;j++)
         {
             w[rt][i][j]=1e9;
           lol cost=w[rt*][i][]+w[rt*+][][j]-c[mid+];
             w[rt][i][j]=min(w[rt][i][j],cost);
             cost=w[rt*][i][]+w[rt*+][][j]-c[mid+];
             w[rt][i][j]=min(w[rt][i][j],cost);
             cost=w[rt*][i][]+w[rt*+][][j]-c[mid+];
             w[rt][i][j]=min(w[rt][i][j],cost);
         }
 }
 void build(int rt,int l,int r)
 {
  if (l>r) return;
     if (l==r)
     {
         lol tot=a[l]+b[l]+c[l]+c[l+];
         w[rt][][]=tot-c[l+];
         w[rt][][]=tot-(a[l]+b[l]+abs(b[l]-a[l]))/;
         w[rt][][]=1e9;
         w[rt][][]=tot-c[l];
         return;
     }
     int mid=(l+r)/;
     build(rt*,l,mid);
     build(rt*+,mid+,r);
 pushup(rt,mid);
 }
 void ask(int rt,int l,int r,int L,int R,XXX &p)
 {int i,j;
  if (l>r) return;
     if (l>=L&&r<=R)
     {
         for (i=;i<=;i++)
             for (j=;j<=;j++)
             p.a[i][j]=w[rt][i][j];
         return;
     }
     XXX p1,p2;
     if (l==r) return;
  int mid=(l+r)/;
  if (L>=mid+)
  {
      ask(rt*+,mid+,r,L,R,p2);
      for (i=;i<=;i++)
          for (j=;j<=;j++)
              p.a[i][j]=p2.a[i][j];
      return;
  }
  if (R<=mid)
  {
      ask(rt*,l,mid,L,R,p1);
      for (i=;i<=;i++)
          for (j=;j<=;j++)
              p.a[i][j]=p1.a[i][j];
      return;
  }
     ask(rt*,l,mid,L,R,p1);
     ask(rt*+,mid+,r,L,R,p2);
   for (i=;i<=;i++)
       for (j=;j<=;j++)
       {
           p.a[i][j]=1e9;
            lol cost=p1.a[i][]+p2.a[][j]-c[mid+];
             p.a[i][j]=min(p.a[i][j],cost);
             cost=p1.a[i][]+p2.a[][j]-c[mid+];
             p.a[i][j]=min(p.a[i][j],cost);
             cost=p1.a[i][]+p2.a[][j]-c[mid+];
             p.a[i][j]=min(p.a[i][j],cost);
       }
 }
 void update(int rt,int l,int r,lol k,lol x,lol d)
 {
  if (l>r) return;
     if (l==r)
     {
         if (k==) a[x]=d;
         if (k==) b[x]=d;
         if (k==) c[x]=d;
          lol tot=a[l]+b[l]+c[l]+c[l+];
         w[rt][][]=tot-c[l+];
         w[rt][][]=tot-(a[l]+b[l]+abs(b[l]-a[l]))/;
         w[rt][][]=1e9;
         w[rt][][]=tot-c[l];
         return;
     }
     int mid=(l+r)/;
     if (k==)
     {
          if (x<=mid+) update(rt*,l,mid,k,x,d);
          if (x>=mid+) update(rt*+,mid+,r,k,x,d);
     }
     else
     {
     if (x<=mid) update(rt*,l,mid,k,x,d);
     else update(rt*+,mid+,r,k,x,d);
     }
 pushup(rt,mid);
 }
 int main()
 {int i;
 lol k,s,t;
  XXX p;
     cin>>n>>m;
     for (i=;i<=n-;i++)
         scanf("%lld",&a[i]);
     for (i=;i<=n-;i++)
         scanf("%lld",&b[i]);
     for (i=;i<=n;i++)
         scanf("%lld",&c[i]);
     build(,,n-);
     while (m--)
     {lol ans=2e9;
         scanf("%lld%lld%lld",&k,&s,&t);
         if (k==)
         {
             if (s==t)
             {printf("%lld\n",c[s]);continue;}
             ask(,,n-,s,t-,p);
             ans=min(min(p.a[][],p.a[][]),min(p.a[][],p.a[][]));
             printf("%lld\n",ans);
         }
         else
         {
             update(,,n-,k,s,t);
         }
     }
 }