LuoguP5897 [IOI2013]wombats

LuoguP5897 [IOI2013]wombats

题目描述

简要题意：有一个$R\ast C$的网格图，边有边权，支持修改，多次询问$V_1,V_2$，求点$(0,V_1)$到$(R-1,V_2)$的最短路（只能往左右和往下走）。

Solution

记$f[i][j]$表示从$(0,i)$到$(0,j)$的最短路，可以通过一行一行$DP$在$O(R\ast C^2)$的时间内求得，而每次修改需要重新求答案，所以时间复杂度为$O(R\ast C^2\ast Q)$。

但我们发现这题的$R$很大，而$C$很小，所以我们考虑把$R$这一位扔到线段树上，线段树的一个区间记录了一个$C\ast C$的矩阵。线段$[l,r]$中矩阵的一个点$D_{i,j}$记录从$(l,i)$到$(r,j)$的距离，这样每次修改就只需要修改$lo{g}^n$。

接下来考虑两个线段怎么合并，如果暴力枚举的话时间复杂度为$O(n^3)$（类似$floyd$的方法，枚举$i,j$和中间点$k$），但我们发现这里有决策单调性，我们固定一个点$i$，枚举$j$，假设$j$的最优决策点为$k$，那么对于任意的$j^{\prime }>j$，$j^{\prime }$的最优决策点$k^{\prime }>k$，这样就可以通过分治做到$O(n^{2}lgn)$或直接记录决策点位置做到$O(n^2)$。

这样优化之后时间复杂度就$OK$了。然而空间还是太大了，于是有一个神奇的套路：在线段树中，若线段的长度小于一个阈值$t$，则通过之前说的$O(n^3)$暴力求解$D$矩阵。

我的程序当阈值设为20的时候能过。
所以时空复杂度就是$O(能过)$了（懒得算QAQ）

#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <cassert>
#include <string.h>
//#include <unordered_set>
//#include <unordered_map>
//#include <bits/stdc++.h>

#define MP(A,B) make_pair(A,B)
#define PB(A) push_back(A)
#define SIZE(A) ((int)A.size())
#define LEN(A) ((int)A.length())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define fi first
#define se second

using namespace std;

template<typename T>inline bool upmin(T &x,T y) { return y<x?x=y,1:0; }
template<typename T>inline bool upmax(T &x,T y) { return x<y?x=y,1:0; }

typedef long long ll;
typedef unsigned long long ull;
typedef long double lod;
typedef pair<int,int> PR;
typedef vector<int> VI;

const lod eps=1e-11;
const lod pi=acos(-1);
const int oo=1<<30;
const ll loo=1ll<<62;
const int mods=998244353;
const int MAXN=5005;
const int INF=0x3f3f3f3f;//1061109567
/*--------------------------------------------------------------------*/
inline int read()
{
	int f=1,x=0; char c=getchar();
	while (c<'0'||c>'9') { if (c=='-') f=-1; c=getchar(); }
	while (c>='0'&&c<='9') { x=(x<<3)+(x<<1)+(c^48); c=getchar(); }
	return x*f;
}
int n,m,d1[MAXN][205],d2[MAXN][205],s[MAXN][205],tmp[205][205];
struct Matrix
{
	int A[205][205],l,r;
	void clear(int L,int R) 
	{
		l=L,r=R;
		for (int i=1;i<=m;i++) 
			for (int j=1;j<=m;j++) A[i][j]=INF;
	}
	Matrix(int L=0,int R=0) { clear(L,R); }
	void rebuild(int L,int R)
	{
		l=L,r=R;
		for (int i=1;i<=m;i++) 
			for (int j=1;j<=m;j++) A[i][j]=abs(s[l][i]-s[l][j]);
		for (int k=l+1;k<=r;k++)
		{
			for (int i=1;i<=m;i++)
				for (int j=1;j<=m;j++) A[i][j]+=d2[k][j],tmp[i][j]=A[i][j];
			for (int i=1,smin;i<=m;i++)
			{
				smin=tmp[i][1];
				for (int j=2;j<=m;j++) smin+=d1[k][j],upmin(smin,tmp[i][j]),upmin(A[i][j],smin);
				smin=tmp[i][m];
				for (int j=m-1;j>=1;j--) smin+=d1[k][j+1],upmin(smin,tmp[i][j]),upmin(A[i][j],smin);
			}
		}
	}
	void print()
	{
		cout<<l<<" "<<r<<endl;
		for (int i=1;i<=m;i++)
		{
			for (int j=1;j<=m;j++) cout<<A[i][j]<<" ";
			cout<<endl;
		}
		cout<<endl;
	}
} ans;
struct Segment_Tree
{
	Matrix tree[1005];
	void Solve(Matrix &x,Matrix &y,int t,int l,int r,int L,int R)
	{	
		int mid=(l+r)>>1,k=L;
		for (int i=L+1;i<=R;i++)
			if (x.A[t][i]+d2[y.l][i]+y.A[i][mid]<x.A[t][k]+d2[y.l][k]+y.A[k][mid]) k=i;
		ans.A[t][mid]=x.A[t][k]+d2[y.l][k]+y.A[k][mid];
		
		if (l==r) return;
		Solve(x,y,t,l,mid,L,k);
		Solve(x,y,t,mid+1,r,k,R);
	}
	Matrix Merge(Matrix &x,Matrix &y)
	{	
		ans.clear(x.l,y.r);
		for (int i=1;i<=m;i++) Solve(x,y,i,1,m,1,m);
		return ans;
	}
	
	void up(int x) { tree[x]=Merge(tree[x<<1],tree[x<<1|1]); }
	void build(int x,int l,int r)
	{
		if (r-l<=20) { tree[x].rebuild(l,r); return; }
		int mid=(l+r)>>1;
		build(x<<1,l,mid);
		build(x<<1|1,mid+1,r);
		up(x);
	}
	void change(int x,int l,int r,int y)
	{
		if (r-l<=20) { tree[x].rebuild(l,r); return; }
		int mid=(l+r)>>1;
		if (y<=mid) change(x<<1,l,mid,y);
		else change(x<<1|1,mid+1,r,y);
		up(x);
	}
} segment;

int main()
{
	n=read(),m=read();
	for (int i=1;i<=n;i++)
		for (int j=2;j<=m;j++) d1[i][j]=read(),s[i][j]=s[i][j-1]+d1[i][j];
	for (int i=2;i<=n;i++)
		for (int j=1;j<=m;j++) d2[i][j]=read();
	segment.build(1,1,n);
	int Case=read();
	while (Case--)
	{
		int opt=read();
		if (opt==1) 
		{ 
			int x=read()+1,y=read()+2;
			d1[x][y]=read();  
			for (;y<=m;y++) s[x][y]=s[x][y-1]+d1[x][y];
			segment.change(1,1,n,x);
		}
		else if (opt==2) 
		{
			int x=read()+2,y=read()+1;
			d2[x][y]=read(),segment.change(1,1,n,x);
		}
		else printf("%d\n",segment.tree[1].A[read()+1][read()+1]);
	}
	return 0;
}