BZOJ3205/UOJ107 [Apio2013]机器人

最新推荐文章于 2019-04-02 16:15:16 发布
最新推荐文章于 2019-04-02 16:15:16 发布
阅读量128 收藏
点赞数
文章标签： ux
原文链接：http://www.cnblogs.com/ljh2000-jump/p/6421523.html
版权

本文版权归ljh2000和博客园共有，欢迎转载，但须保留此声明，并给出原文链接，谢谢合作。

 

 

本文作者：ljh2000
作者博客：http://www.cnblogs.com/ljh2000-jump/
转载请注明出处，侵权必究，保留最终解释权！

 

Description

VRI（Voltron机器人学会）的工程师建造了 n个机器人。任意两个兼容的机器人站在同一个格子时可以合并为一个复合机器人。我们把机器人用 1至 n编号（n ≤ 9）。如果两个机器人的编号是连续的，那么它们是兼容的，可以合并成一个复合机器人。最初这   n   个机器人各自都只有唯一的编号。而一个由两个或以上的机器人合并构成的复合机器人拥有两个编号，分别是构成它的所有机器人中最小和最大的编号。例如， 2号机器人只可以与 1号或 3号机器人合并。若 2号机器人与 3号机器人合并，可构成编号为 2-3的复合机器人。如果编号为 2-3的复合机器人与编号为 4-6的复合机器人合并，可构成编号为 2-6的复合机器人。当所有机器人合并以后则构成 1-n复合机器人。工程师把这 n个机器人放在了一个封闭的房间中，房间四周均是墙。该房间被划分成 w     h    个方格。有些方格有障碍物，机器人不可经过或停留；其余方格允许多个机器人停留，同时允许机器人经过。任何时候一个机器人只占用一个方格。初始时刻，所有机器人均在不同的方格中。这些原始的机器人不会自发地移动。它们只有被工程师沿   x轴或 y轴推动后，才会沿推动的方向不断向前直线移动，直至碰到障碍物或墙停止移动。停止移动后，它会扫描当前的格子是否存在可以与它合并的机器人，如果有，则合并并继续检查，直至不能再合并为止。工程师只能沿水平向左、水平向右、竖直向上、竖直向下四个方向推动机器人，并且，在机器人尚未停止移动时，不允许推动其它机器人，因此任何时刻，房间中都只能有一个机器人移动,为了帮助机器人转向，工程师在一些格子中放置了转向器。具体地说，转向器分为顺时针转向器（右转器）和逆时针转向器（左转器），顺时针转向器可以使到达该格子的机器人沿顺时针方向转向   90_；逆时针转向器可以使到达该格子的机器人沿逆时针方向转向 90_。现在，我们将告诉你初始时刻房间内的信息。请你计算工程师最少共计需要推动机器人多少次，才能把所有的 n个机器人全部合并（如果可能的话）。

Input

你的程序必须从标准输入读入。输入的第 1行包含 3个整数 n、w和 h，用空格隔开。输入文件中接下来的 h行描述初始时刻房间内的信息，每行包含w个字符。这w* h 字符中每一个表示房间中的一个格子，意义如下：
 
‘ 1’至‘9’：表示该方格中有一个机器人，编号为这个数字；
‘ x’：表示该方格有障碍物；
 
‘ A’：表示该方格中有一个逆时针转向器；
 
‘ C’：表示该方格中有一个顺时针转向器；
‘ .’：表示该方格为空地。

Output

你的程序必须输出到标准输出。输出仅一个整数，表示最少需要推动的次数。
若不能使所有机器人全部合并，输出-1。

 

Sample Input

4 10 5
1.........
AA...x4...
..A..x....
2....x....
..C.3.A...



Sample Output

5

HINT

 



第一步：向右推动 3 号机器人，当它碰到转向器后会向上继续移动，直至碰到墙壁停止移动。第二步：向上推动 4 号机器人，当它碰到墙壁后停止移动，与3 号机器人合并，构成  3-4 号机器人 第三步：向上推动 2 号机器人，当它碰到转向器后会向左移动，由于左侧为墙壁，故停留在原地。第四步：向右推动  2 号机器人，由于它在一个转向器上，故它会向上移动，直至碰到墙壁停止移动，与  1 号机器人合并，构成 1-2 号机器人。第五步：向左推动  3-4 号机器人，当它碰到墙壁后停止移动，与 1-2 号机器人合并，构成  1-4 号机器人。 

n ≤ 9，w ≤ 500 且   h ≤ 500

 

正解：斯坦纳树

解题报告：

　　我已经醉了…这道题调了我半个晚上，一大堆傻逼错误，我已经被自己最近的低效状态感动了…

　　看到这个题，很快可以想到斯坦纳树，不过这个题没必要把状态记录下来，因为一定是连续的区间。

　　考虑用$f[l][r][i][j]$表示$l$到$r$的机器人在$(i,j)$这个地方合并的最小代价。

　　然后转移的话就很简单了：

　　$f[l][r][i][j]=min(f[l][r][p][q]+1,f[l][o][i][j]+f[o+1][r][i][j]) $,

　　其中$(p,q)$可以一步走到$(i,j)$,$l<=o<r$。

　　跟斯坦纳树的常规套路一样，$SPFA$转移即可。

 

　　结果，这道题最臭不要脸的是卡！空！间！还卡！常！数！

　　我把标号改为从$0$开始，并且把队列滚动，再把一系列空间开到下界，空间过了。

　　然后我发现我在OJ上超时了...

　　被BZOJ的评测机速度感动了...

 

　　.............

 

　　接下来就是各种预处理+常数优化，本机已经很快了，OJ上就是跑不过。

 

　　.............

 

　　最后怒写基数排序，终于跑过去了...基数排序大法好啊...

　　代码已经看不得了...

 

 BZOJ：

//It is made by ljh2000
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <ctime>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <string>
#include <complex>
using namespace std;
typedef long long LL;
#define RG register
const int MAXN = 501;
const int MOD = 200000;
int n,m,k,f[10][10][MAXN][MAXN],to[4][MAXN][MAXN],inf,cnt,ans,pos[12][2];
char ch[MAXN+12][MAXN+12];
bool vis[4][MAXN][MAXN],use[MAXN][MAXN];
int head,tail,L,R,nex[MOD+12],val[10000],sum[10000];
int dx[4]={-1,0,1,0};
int dy[4]={0,-1,0,1};
//0:up 1:left 2:down 3:right 
//顺时针:id+3  逆时针:id+1
struct node{ int x,y,dis; }tmp,a[MAXN*MAXN],dui[MOD+12],dui2[MOD+12],b[MAXN*MAXN];
inline bool cmp(node q,node qq){ return q.dis<qq.dis; }
inline int get(int x,int y){ return (x-1)*m+y; }
inline int getint(){
    int w=0,q=0; char c=getchar(); while((c<'0'||c>'9') && c!='-') c=getchar();
    if(c=='-') q=1,c=getchar(); while (c>='0'&&c<='9') w=w*10+c-'0',c=getchar(); return q?-w:w;
}

inline int dfs(int l,int x,int y){//dfs预处理每个点沿着当前前进方向到达的地方，记忆化搜索
	if(vis[l][x][y]) return to[l][x][y]=-1;
	if(to[l][x][y]!=0) return to[l][x][y];
	vis[l][x][y]=1;

	int savl=l;
	if(ch[x][y]=='A') l++,l%=4;//逆时针
	if(ch[x][y]=='C') l+=3,l%=4;//顺时针
	int nowx=x+dx[l],nowy=y+dy[l];
	if(nowx<=0 || nowy<=0 || nowx>n || nowy>m || ch[nowx][nowy]=='x') to[savl][x][y]=get(x,y);
	else to[savl][x][y]=dfs(l,nowx,nowy);
	vis[savl][x][y]=0;
	return to[savl][x][y];//中间l发生了改变！必须另外保存！
}

inline void SPFA(RG int l,RG int r){//带特技的SPFA，跟BFS有何区别呢...
	memset(sum,0,sizeof(sum));
	int mn,mx; mn=mx=a[1].dis; 
	for(int i=1;i<=cnt;i++) {
		mn=min(mn,a[i].dis); mx=max(mx,a[i].dis);
		sum[a[i].dis]++;
	}
	for(int i=mn+1;i<=mx;i++) sum[i]+=sum[i-1];
	for(int i=1;i<=cnt;i++) b[sum[a[i].dis]--]=a[i];
	for(int i=1;i<=cnt;i++) a[i]=b[i];

	//sort(a+1,a+cnt+1,cmp);
	head=tail=L=R=0;
	for(int i=1;i<=cnt/*!!!*/;i++) tail=nex[tail],dui[tail]=a[i];
	RG int ux,uy,nowx,nowy; RG node t1,t2;
	while(head!=tail || L!=R) {
		if(head==tail) L=nex[L],ux=dui2[L].x,uy=dui2[L].y;
		else if(L==R) head=nex[head],ux=dui[head].x,uy=dui[head].y;
		else {
			t1=dui[nex[head]]; t2=dui2[nex[L]];//不能直接比较！需要用f比较！因为期间有可能被更新...
			if(f[l][r][t1.x][t1.y]<f[l][r][t2.x][t2.y]) ux=t1.x,uy=t1.y,head=nex[head];
			else ux=t2.x,uy=t2.y,L=nex[L];
		}
		for(RG int i=0;i<4;i++) {
			if(to[i][ux][uy]<=0) continue;
			nowx=(to[i][ux][uy]-1)/m+1; nowy=(to[i][ux][uy]-1)%m+1;
			if(f[l][r][nowx][nowy]>f[l][r][ux][uy]+1) {
				f[l][r][nowx][nowy]=f[l][r][ux][uy]+1;
				if(!use[nowx][nowy]) {
					use[nowx][nowy]=1; tmp.x=nowx; tmp.y=nowy; tmp.dis=f[l][r][nowx][nowy]/*!!!*/;
					R=nex[R];
					dui2[R]=tmp; 
				}
			}
		}
		use[ux][uy]=0;
	}
}

inline void work(){
	k=getint(); m=getint(); n=getint();
	memset(f,0x3f,sizeof(f)); inf=f[0][0][0][0];
	for(int i=1;i<=n;i++) {	scanf("%s",ch[i]+1); for(int j=1;j<=m;j++) if(ch[i][j]<='9' && ch[i][j]>='1') f[ch[i][j]-'1'][ch[i][j]-'1'][i][j]=0; }
	for(int i=1;i<=n;i++) 
		for(int j=1;j<=m;j++)
			if(ch[i][j]!='x') {
				for(int l=0;l<4;l++) 
					to[l][i][j]=dfs(l,i,j);
				if(ch[i][j]<='9' && ch[i][j]>='1') pos[ch[i][j]-'1'][0]=i,pos[ch[i][j]-'1'][1]=j;
			}

	for(int i=0;i<MOD;i++) nex[i]=(i+1)%MOD;

	for(int i=0;i<k;i++) {//一开始做一遍!
		use[pos[i][0]][pos[i][1]]=0; cnt=0;
		tmp.x=pos[i][0]; tmp.y=pos[i][1]; tmp.dis=0;
		a[++cnt]=tmp;
		SPFA(i,i);
	}

	for(int l=k-2;l>=0;l--)
		for(int r=l+1;r<k;r++) {
			for(RG int ll=l;ll<r;ll++)
				for(RG int i=1;i<=n;i++)
					for(RG int j=1;j<=m;j++)
						f[l][r][i][j]=min(f[l][r][i][j],f[l][ll][i][j]+f[ll+1][r][i][j]);
			cnt=0;
			for(int i=1;i<=n;i++) 
				for(int j=1;j<=m;j++)
					if(f[l][r][i][j]!=inf) {
						use[i][j]=1; a[++cnt].x=i; a[cnt].y=j;
						a[cnt/*!!!*/].dis=f[l][r][i][j];//记得加距离啊...
					}
			SPFA(l,r);
		}
	ans=inf;
	for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) if(f[0][k-1][i][j]<ans) ans=f[0][k-1][i][j];
	if(ans==inf) printf("-1"); else printf("%d",ans);
	//cout<<endl<<clock()<<endl;
}

int main()
{
    work();
    return 0;
}

　　

UOJ：

//It is made by ljh2000
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <ctime>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <string>
#include <complex>
using namespace std;
typedef long long LL;
#define RG register
const int MAXN = 501;
const int MOD = 300000;
int n,m,k,f[10][10][MAXN][MAXN],to[4][MAXN][MAXN],inf,cnt,ans,pos[12][2];
char ch[MAXN+12][MAXN+12];
bool vis[4][MAXN][MAXN],use[MAXN][MAXN];
int head,tail,L,R,nex[MOD+12],sum[700000];
int dx[4]={-1,0,1,0};
int dy[4]={0,-1,0,1};
//0:up 1:left 2:down 3:right 
//顺时针:id+3  逆时针:id+1
struct node{ int x,y,dis; }tmp,a[MAXN*MAXN],dui[MOD+12],dui2[MOD+12],b[MAXN*MAXN];
inline bool cmp(node q,node qq){ return q.dis<qq.dis; }
inline int get(int x,int y){ return (x-1)*m+y; }
inline int getint(){
    int w=0,q=0; char c=getchar(); while((c<'0'||c>'9') && c!='-') c=getchar();
    if(c=='-') q=1,c=getchar(); while (c>='0'&&c<='9') w=w*10+c-'0',c=getchar(); return q?-w:w;
}

inline int dfs(int l,int x,int y){//dfs预处理每个点沿着当前前进方向到达的地方，记忆化搜索
	if(vis[l][x][y]) return to[l][x][y]=-1;
	if(to[l][x][y]!=0) return to[l][x][y];
	vis[l][x][y]=1;

	int savl=l;
	if(ch[x][y]=='A') l++,l%=4;//逆时针
	if(ch[x][y]=='C') l+=3,l%=4;//顺时针
	int nowx=x+dx[l],nowy=y+dy[l];
	if(nowx<=0 || nowy<=0 || nowx>n || nowy>m || ch[nowx][nowy]=='x') to[savl][x][y]=get(x,y);
	else to[savl][x][y]=dfs(l,nowx,nowy);
	vis[savl][x][y]=0;
	return to[savl][x][y];//中间l发生了改变！必须另外保存！
}

inline void SPFA(RG int l,RG int r){//带特技的SPFA，跟BFS有何区别呢...
	memset(sum,0,sizeof(sum));
	int mn,mx; mn=mx=a[1].dis; 
	for(int i=1;i<=cnt;i++) {
		mn=min(mn,a[i].dis); mx=max(mx,a[i].dis);
		sum[a[i].dis]++;
	}
	for(int i=mn+1;i<=mx;i++) sum[i]+=sum[i-1];
	for(int i=1;i<=cnt;i++) b[sum[a[i].dis]--]=a[i];
	for(int i=1;i<=cnt;i++) a[i]=b[i];

	//sort(a+1,a+cnt+1,cmp);
	head=tail=L=R=0;
	for(int i=1;i<=cnt/*!!!*/;i++) tail=nex[tail],dui[tail]=a[i];
	RG int ux,uy,nowx,nowy; RG node t1,t2;
	while(head!=tail || L!=R) {
		if(head==tail) L=nex[L],ux=dui2[L].x,uy=dui2[L].y;
		else if(L==R) head=nex[head],ux=dui[head].x,uy=dui[head].y;
		else {
			t1=dui[nex[head]]; t2=dui2[nex[L]];//不能直接比较！需要用f比较！因为期间有可能被更新...
			if(f[l][r][t1.x][t1.y]<f[l][r][t2.x][t2.y]) ux=t1.x,uy=t1.y,head=nex[head];
			else ux=t2.x,uy=t2.y,L=nex[L];
		}
		for(RG int i=0;i<4;i++) {
			if(to[i][ux][uy]<=0) continue;
			nowx=(to[i][ux][uy]-1)/m+1; nowy=(to[i][ux][uy]-1)%m+1;
			if(f[l][r][nowx][nowy]>f[l][r][ux][uy]+1) {
				f[l][r][nowx][nowy]=f[l][r][ux][uy]+1;
				if(!use[nowx][nowy]) {
					use[nowx][nowy]=1; tmp.x=nowx; tmp.y=nowy; tmp.dis=f[l][r][nowx][nowy]/*!!!*/;
					R=nex[R];
					dui2[R]=tmp; 
				}
			}
		}
		use[ux][uy]=0;
	}
}

inline void work(){
	k=getint(); m=getint(); n=getint();
	memset(f,0x3f,sizeof(f)); inf=f[0][0][0][0];
	for(int i=1;i<=n;i++) {	scanf("%s",ch[i]+1); for(int j=1;j<=m;j++) if(ch[i][j]<='9' && ch[i][j]>='1') f[ch[i][j]-'1'][ch[i][j]-'1'][i][j]=0; }
	for(int i=1;i<=n;i++) 
		for(int j=1;j<=m;j++)
			if(ch[i][j]!='x') {
				for(int l=0;l<4;l++) 
					to[l][i][j]=dfs(l,i,j);
				if(ch[i][j]<='9' && ch[i][j]>='1') pos[ch[i][j]-'1'][0]=i,pos[ch[i][j]-'1'][1]=j;
			}

	for(int i=0;i<MOD;i++) nex[i]=(i+1)%MOD;

	for(int i=0;i<k;i++) {//一开始做一遍!
		use[pos[i][0]][pos[i][1]]=0; cnt=0;
		tmp.x=pos[i][0]; tmp.y=pos[i][1]; tmp.dis=0;
		a[++cnt]=tmp;
		SPFA(i,i);
	}

	for(int l=k-2;l>=0;l--)
		for(int r=l+1;r<k;r++) {
			for(RG int ll=l;ll<r;ll++)
				for(RG int i=1;i<=n;i++)
					for(RG int j=1;j<=m;j++)
						f[l][r][i][j]=min(f[l][r][i][j],f[l][ll][i][j]+f[ll+1][r][i][j]);
			cnt=0;
			for(int i=1;i<=n;i++) 
				for(int j=1;j<=m;j++)
					if(f[l][r][i][j]!=inf) {
						use[i][j]=1; a[++cnt].x=i; a[cnt].y=j;
						a[cnt/*!!!*/].dis=f[l][r][i][j];//记得加距离啊...
					}
			SPFA(l,r);
		}
	ans=inf;
	for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) if(f[0][k-1][i][j]<ans) ans=f[0][k-1][i][j];
	if(ans==inf) printf("-1"); else printf("%d",ans);
	//cout<<endl<<clock()<<endl;
}

int main()
{
    work();
    return 0;
}

　　

 

转载于:https://www.cnblogs.com/ljh2000-jump/p/6421523.html

dgoh41514
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【BZOJ3205】【UOJ107】【APIO2013】机器人
cz_xuyixuan的博客
04-18 1206
【题目链接】BZOJUOJ【思路要点】补档博客，无题解。【代码】#include&lt;bits/stdc++.h&gt; using namespace std; #define MAXN 505 #define MAXC 10 #define MAXV 1000005 #define MAXQ 300005 #define INF 1e9 //0 - up; 1 - right; 2 - do...
3205: [Apio2013]机器人
CRZbulabula的博客
08-28 8835
3205: [Apio2013]机器人 Time Limit: 15 Sec  Memory Limit: 128 MB Submit: 525  Solved: 131 [Submit][Status][Discuss] Description VRI（Voltron机器人学会）的工程师建造了 n个机器人。任意两个兼容的机器人站在同一个格子时可以合并为一个复合机器人。我们把机器人用
bzoj3205: [Apio2013]机器人
weixin_30846599的博客
05-08 161
传送门：http://www.lydsy.com/JudgeOnline/problem.php?id=3205 思路：类似斯坦纳树的想法 但是因为这里的合并必须连号 所以子集枚举就变成了区间合并 说说做法好了 首先记搜搜出每个点向四个方向走一步会到哪里 注意：转向器可能导致机器人一直在里面转出不来，要特判掉 然后设f[l][r][x][y]表示当前合并的机器人是[l...
bzoj3205 [Apio2013]机器人
aklm45097的博客
05-04 498
传送门：http://www.lydsy.com/JudgeOnline/problem.php?id=3205 http://uoj.ac/problem/107 【题解】 我们发现这就是一棵斯坦纳树啊。。 令f[l,r,a,b]表示合并了(l,r)，当前在(a,b)的最小推的次数。 预处理出来每个点朝每个方向推一下到哪里。（dfs，注意处理循环情况） 然后我们就可以套斯坦...
BZOJ 3205 [Apio2013]机器人 ——斯坦纳树
weixin_33695082的博客
04-01 511
腊鸡题目，实在卡不过去。 （改了一下午） 就是裸的斯坦纳树的题目，一方面合并子集，另一方面SPFA迭代求解。 优化了许多地方，甚至基数排序都写了。 还是T到死，不打算改了，就这样吧 #include <map> #include <cmath> #include <queue> #include <cstdio> #includ...
BZOJ全代码
02-05
BZOJ平台全部代码，解压到一个文件夹在打开使用。BZOJ平台全部代码，解压到一个文件夹在打开使用。
BZOJ第一部分
11-03
BZOJ原题-BZOJP1000-P2000的题目，下载后可以离线做题。
BZOJ3230相似子串测试数据
08-19
BZOJ3230相似子串的测试数据，希望能够帮到大家。
数论题解：「BZOJ1053」反素数/「Violet5」樱花
01-22
「BZOJ1053」反素数/「Violet5」樱花 详细题解
BZOJ上面的题目以及数据
10-13
BZOJ题目以及数据
BZOJ 3205: [Apio2013]机器人(类斯坦纳树DP)
Freopen的博客
04-02 5546
题目 to(x,y,k)\rm to(x,y,k)to(x,y,k)代表在(x,y)(x,y)(x,y)按kkk方向推可以到达哪里（如果会循环的话就不存在） dp(i,j,x,y)\rm {dp(i,j,x,y)}dp(i,j,x,y)代表在(x,y)(x,y)(x,y)处得到i,i+1...ji ,i+1... ji,i+1...j等机器人的合体的代价。 那么可以有： dp(i,j,x,y)=m...
bzoj 3205: [Apio2013]机器人 （斯坦纳树）
clover_hxy的博客
04-16 4158
题目描述传送门题解这道题改spfa的姿势+卡常+记忆化，搞了一下午。。。。 f[i][j][x][y]f[i][j][x][y] 表示把i-j机器人合并到点(x,y)(x,y)的最小代价。 考虑怎么转移？ (1)f[i][j][x][y]=min{f[i][k][x][y]+f[k+1][j][x][y]}f[i][j][x][y]=min\{f[i][k][x][y]+f[k+1][j][x
bzoj 3205: [Apio2013]机器人 斯坦纳树
lych的博客
03-28 2073
这道题目应该是比较明显的斯坦纳树吧。        令f[l][r][x][y]表示将编号l~r的机器人合并到(x,y)的最小代价，那么就有转移：       1. f[l][r][x][y]=min{f[l][k][x][y]+f[k+1][r][x][y]}       2. f[l][r][x1][y1]=min{f[l][r][x][y]+1}，满足将(x,y)往某一个方向推之后会到
BZOJ 3205 [Apio2013]机器人 斯坦纳树
YihAN_Z
06-29 1314
题目大意：
【BZOJ】【3205】【APIO2013】机器人robot
weixin_30498807的博客
04-30 1449
斯坦纳树 　　好神啊……Orzzyf &&PoPoQQQ 　　为啥跟斯坦纳树扯上关系了？我想是因为每个点（robot）都沿着树边汇到根的时候就全部合起来了吧= =这个好像和裸的斯坦纳树不太一样，那个是无向最小生成树，这个是有向图…… 　　引用题解： 令f[l][r][i][j]表示在点(i,j)将编号在[l,r]区间内的机器人全部合并的最小推动次数 则有动规方...
BZOJ 3205 Apio2013 机器人 斯坦纳树
世界
01-08 3625
题目大意：给定一张地图，一些地方有障碍物，有k 令f[l][r][i][j]表示在点(i,j)将编号在[l,r]区间内的机器人全部合并的最小推动次数 则有动规方程组： f[l][r][i][j]=min{f[l][r][_i][_j]+1} ( (_i,_j)->(i,j) ) f[l][r][i][j]=min(f[l][temp][i][j]+f[temp+1][r][i][j]) (
bzoj 3205: [Apio2013]机器人【dfs+斯坦纳树+spfa】
weixin_30817749的博客
04-16 268
第一次听说斯坦纳树这种东西 先dfs预处理出来dis[i][j][k]表示格子(i,j)向k方向转移能到哪，记忆话搜索预处理，注意如果有环的话特判一下 设f[i][j][x][y]表示复合机器人i-j在(x,y)生成需要推得步数，用spfa转移，因为时间比较紧所以优化spfa，把能转移的放进一个队列（准确的来讲是栈）按f排序，spfa转移到的放到另一个，每次取队首小的更新答案 #include&l...
2019.03.27【APIO2013】【洛谷P3638】【BZOJ3205】机器人（区间DP）（斯坦纳树）
zxyoi_dreamer的博客（不定期诈尸）
03-27 419
洛谷传送门 BZOJ传送门 解析： 首先我们可以为每一个位置标号，记f[l][r][pos]f[l][r][pos]f[l][r][pos]表示在pospospos位置中停留一个编号为l,rl,rl,r的复合机器人的最小推动次数。 显然在同一个位置的转移可以用区间DP来实现。 从一个位置转移到另外一个位置，发现转移是带后效性的，而且就是斯坦纳树的后效性形式。 用记忆化搜索预处理出每一个位置向四个...
【BZOJ3205_洛谷3638】[APIO2013]机器人（动态规划）
weixin_30852367的博客
01-11 205
题目： 洛谷3638 分析： 卡了一天的神题……（OrzJumpmelon） 首先预处理出从点\(p\)向\(d\)方向出发最终能到达的点\(nxt[p][d]\)。这个可以直接记忆化搜索解决。如果出现环说明不能向这个方向出发，设为\(-1\)。 struct point { int x, y; point(const int _x = 0, const int _y = 0) ...
bzoj2908数据下载
最新发布
10-14
BZOJ 2908 题目是一个数据下载任务。这个任务要求下载指定的数据文件，并统计文件中小于等于给定整数的数字个数。 为了完成这个任务，首先需要选择一个合适的网址来下载文件。我们可以使用一个网络爬虫库，如Python...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值