2019.03.27【APIO2013】【洛谷P3638】【BZOJ3205】机器人（区间DP）（斯坦纳树）

洛谷传送门

BZOJ传送门

---

解析：

首先我们可以为每一个位置标号，记$f[l][r][pos]$表示在$pos$位置中停留一个编号为$l,r$的复合机器人的最小推动次数。

显然在同一个位置的转移可以用区间DP来实现。

从一个位置转移到另外一个位置，发现转移是带后效性的，而且就是斯坦纳树的后效性形式。

用记忆化搜索预处理出每一个位置向四个方向推动会停留的最终位置，注意可能会因为转向器出现环路的情况，要特判。暴力建图，注意这里建立的是有向图。

然后把斯坦纳树的状压DP变成区间DP，这道题就做完了……才怪！

由于数据略为毒瘤，我们需要对SPFA的转移进行优化（不要想Dijkstra了）。

显然所有边的边权全部为$1$，那么对于原始队列里面的东西我们来一个基数排序，把小的放在队列前面。

还没完，这个队列除了初始的构造是拒绝之后的插入队尾的。

我们另外开一个队列来保存在SPFA中更新的节点，每次在两个队首重贪心选择较小的那一个取出来松弛。

优化至此已经可以通过本题。

---

代码：

#include<bits/stdc++.h>
#define ll long long
#define re register
#define cs const

using std::cout;
using std::cerr;
using std::swap;

cs int N=502;
int n,w,h,tot;
std::vector<int> e[N*N];
inline void addedge(int u,int v){
	e[u].push_back(v);
}

char mp[N][N];
int to[N][N][4],id[N][N];
bool insta[N][N][4];

cs int dx[4]={-1,0,1,0};
cs int dy[4]={0,1,0,-1};

int dfs(int x,int y,int dir){
	if(insta[x][y][dir])return 0;
	if(~to[x][y][dir])return to[x][y][dir];
	insta[x][y][dir]=true;
	int nx=x+dx[dir],ny=y+dy[dir];
	switch(mp[nx][ny]){
		case 'x':to[x][y][dir]=id[x][y];break;
		case 'A':to[x][y][dir]=dfs(nx,ny,(dir+3)&3);break;
		case 'C':to[x][y][dir]=dfs(nx,ny,(dir+1)&3);break;
		default:to[x][y][dir]=dfs(nx,ny,dir);
	}
	insta[x][y][dir]=false;
	return to[x][y][dir];
}

int f[10][10][N*N];
cs int INF=0x3f3f3f3f;

int q1[N*N],h1,t1;
std::queue<int,std::list<int> > q2;
bool in[N*N];

inline void radix_sort(int *a,int *b,int cnt){
	static int bin[N*N],c[N*N];
	int mx=0;
	for(int re i=1;i<=cnt;++i)mx=std::max(mx,a[b[i]]);
	memset(bin,0,sizeof(int)*(mx+1));
	for(int re i=1;i<=cnt;++i)++bin[a[b[i]]];
	for(int re i=1;i<=mx;++i)bin[i]+=bin[i-1];
	for(int re i=1;i<=cnt;++i)c[bin[a[b[i]]]--]=b[i];
	memcpy(b+1,c+1,sizeof(int)*cnt);
}

inline void SPFA(int *dist){
	h1=1;t1=0;
	for(int re i=1;i<=tot;++i)if(dist[i]<INF)q1[++t1]=i,in[i]=true;
	radix_sort(dist,q1,t1);
	while(h1<=t1||!q2.empty()){
		int u;
		if(h1<=t1&&(q2.empty()||dist[q1[h1]]<dist[q2.front()]))u=q1[h1++];
		else u=q2.front(),q2.pop();
		in[u]=false;
		for(std::vector<int>::iterator v=e[u].begin();v!=e[u].end();++v)
		if(dist[*v]>dist[u]+1){
			dist[*v]=dist[u]+1;
			if(!in[*v])q2.push(*v),in[*v]=true;
		} 
	}
}

signed main(){
	memset(f,0x3f,sizeof f);
	std::ios::sync_with_stdio(false);
	scanf("%d%d%d",&n,&w,&h);
	for(int re i=1;i<=h;++i)scanf("%s",mp[i]+1);
	for(int re i=0;i<=h+1;++i)mp[i][0]=mp[i][w+1]='x';
	for(int re i=0;i<=w+1;++i)mp[0][i]=mp[h+1][i]='x';
	for(int re i=1;i<=h;++i)
	for(int re j=1;j<=w;++j){
		if(mp[i][j]!='x')id[i][j]=++tot;
		for(int re k=0;k<4;++k)to[i][j][k]=-1;
	}
	for(int re i=1;i<=h;++i)
	for(int re j=1;j<=w;++j)if(id[i][j])
	for(int re k=0;k<4;++k){
		dfs(i,j,k);
		if(to[i][j][k]&&to[i][j][k]!=id[i][j])addedge(id[i][j],to[i][j][k]);
	}
	for(int re i=1;i<=h;++i)
	for(int re j=1;j<=w;++j)if(isdigit(mp[i][j])){
		f[mp[i][j]^48][mp[i][j]^48][id[i][j]]=0;
	}
	for(int re len=1;len<=n;++len)
	for(int re l=1,r=l+len-1;r<=n;++l,++r){
		for(int re k=l;k<r;++k)
		for(int re i=1;i<=tot;++i)f[l][r][i]=std::min(f[l][r][i],f[l][k][i]+f[k+1][r][i]);
		SPFA(f[l][r]);
	}
	int ans=INF;
	for(int re i=1;i<=tot;++i)ans=std::min(ans,f[1][n][i]);
	cout<<(ans<INF?ans:-1);
	return 0;
}