POJ 3133 Manhattan Wiring 解题报告（插头DP）

最新推荐文章于 2018-03-25 16:44:24 发布
最新推荐文章于 2018-03-25 16:44:24 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： ACM 文章标签： DP 插头DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sf____/article/details/15469033
版权
Manhattan Wiring
Time Limit: 5000MS Memory Limit: 65536K
Total Submissions: 1358 Accepted: 795

Description

There is a rectangular area containing n × m cells. Two cells are marked with “2”, and another two with “3”. Some cells are occupied by obstacles. You should connect the two “2”s and also the two “3”s with non-intersecting lines. Lines can run only vertically or horizontally connecting centers of cells without obstacles.

Lines cannot run on a cell with an obstacle. Only one line can run on a cell at most once. Hence, a line cannot intersect with the other line, nor with itself. Under these constraints, the total length of the two lines should be minimized. The length of a line is defined as the number of cell borders it passes. In particular, a line connecting cells sharing their border has length 1.

Fig. 1(a) shows an example setting. Fig. 1(b) shows two lines satisfying the constraints above with minimum total length 18.

Figure 1: An example of setting and its solution

Input

The input consists of multiple datasets, each in the following format.

nm
row1
…
rown

n is the number of rows which satisfies 2 ≤ n ≤ 9. m is the number of columns which satisfies 2 ≤ m ≤ 9. Each rowi is a sequence of m digits separated by a space. The digits mean the following.

0: Empty

1: Occupied by an obstacle

2: Marked with “2”

3: Marked with “3”

The end of the input is indicated with a line containing two zeros separated by a space.

Output

0

Sample Input

5 5
0 0 0 0 0
0 0 0 3 0
2 0 2 0 0
1 0 1 1 1
0 0 0 0 3
2 3
2 2 0
0 3 3
6 5
2 0 0 0 0
0 3 0 0 0
0 0 0 0 0
1 1 1 0 0
0 0 0 0 0
0 0 2 3 0
5 9
0 0 0 0 0 0 0 0 0
0 0 0 0 3 0 0 0 0
0 2 0 0 0 0 0 2 0
0 0 0 0 3 0 0 0 0
0 0 0 0 0 0 0 0 0
9 9
3 0 0 0 0 0 0 0 2
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 3
9 9
0 0 0 1 0 0 0 0 0
0 2 0 1 0 0 0 0 3
0 0 0 1 0 0 0 0 2
0 0 0 1 0 0 0 0 3
0 0 0 1 1 1 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
9 9
0 0 0 0 0 0 0 0 0
0 3 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 2 3 2
0 0

Sample Output

18
2
17
12
0
52
43

    

    解题报告：思考了挺久，第一次敲是这么做的。使用8进制。0表示无插头，1表示线路的左插头，2表示线路的有插头。3表示地图上标记为2的点形成的插头，4表示地图上标记为3的点形成的插头。写了大段的状态转移，最后战战兢兢的提交了，4K代码竟然1A了= =。第一次提交代码如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxn=100013;
int now,pre;
int maze[10][10];
struct Node
{
	int H[maxn];
	int N[maxn];
	int S[maxn];
	int size;
	void init()
	{
		size=0;
		memset(H,-1,sizeof(H));
	}
	void push(int SS,int num)
	{
		int s=SS%maxn;
		while( ~H[s] && S[H[s]]!=SS )
			s=(s+1)%maxn;
		if( ~H[s] )
		{
			N[H[s]]=min(N[H[s]],num);
			return ;
		}
		N[size]=num;
		S[size]=SS;
		H[s]=size++;
	}
	int get(int SS)
	{
		int s=SS%maxn;
		while( ~H[s] && S[H[s]]!=SS )
			s=(s+1)%maxn;
		if( ~H[s] )
			return N[H[s]];
		return 2;
	}
} dp[2];

int get(int S,int p,int l=3)
{
	return (S>>(p*l))&((1<<l)-1);
}

void set(int &S,int p,int v,int l=3)
{
	S^=get(S,p,l)<<(p*l);
	S^=v<<(p*l);
}

int main()
{
	int n,m;
	while( scanf("%d%d",&n,&m),n||m )
	{
		for(int i=0;i<=n;i++) for(int j=0;j<=m;j++)
			maze[i][j]=1;
		for(int i=0;i<n;i++) for(int j=0;j<m;j++)
			scanf("%d",&maze[i][j]);

		now=0;
		pre=1;
		dp[now].init();
		dp[now].push(0,0);

		for(int i=0;i<n;i++)
		{
			for(int j=0;j<m;j++)
			{
				swap(now,pre);
				dp[now].init();

				for(int s=0;s<dp[pre].size;s++)
				{
					int S=dp[pre].S[s];
					int num=dp[pre].N[s];
					int p=get(S,j);
					int q=get(S,j+1);

					if(maze[i][j]==1)
					{
						if(p==0 && q==0)
						{
							dp[now].push(S,num);
						}
						continue;
					}
					if(maze[i][j]>=2)
					{
						int no=maze[i][j]+1;
						if((p==no && q==0)||(q==no && p==0))
						{
							set(S,j,0);
							set(S,j+1,0);
							dp[now].push(S,num+1);
						}
						else if(p==0 && q==0)
						{
							if(maze[i+1][j]!=1)
							{
								set(S,j,no);
								dp[now].push(S,num+1);
							}
							if(maze[i][j+1]!=1)
							{
								set(S,j,0);
								set(S,j+1,no);
								dp[now].push(S,num+1);
							}
						}
						else if((p==0)^(q==0))
						{
							if(max(p,q)==1)
							{
								int find=1;
								for(int k=j+2;k<=m;k++)
								{
									int v=get(S,k);
									if(v==2) find--;
									else if(v==1) find++;

									if(find==0)
									{
										set(S,j,0);
										set(S,j+1,0);
										set(S,k,no);
										dp[now].push(S,num+1);
										break;
									}
								}
							}
							else if(max(p,q)==2)
							{
								int find=1;
								for(int k=j-1;k>=0;k--)
								{
									int v=get(S,k);
									if(v==2) find++;
									else if(v==1) find--;
									if(find==0)
									{
										set(S,j,0);
										set(S,j+1,0);
										set(S,k,no);
										dp[now].push(S,num+1);
										break;
									}
								}
							}
						}
						continue;
					}

					if(p==0 && q==0)
					{
						dp[now].push(S,num);

						if(maze[i][j+1]!=1 && maze[i+1][j]!=1)
						{
							set(S,j,1);
							set(S,j+1,2);
							dp[now].push(S,num+1);
						}
					}
					else if((p>0)^(q>0))
					{
						if(maze[i+(p>0)][j+(q>0)]!=1)
							dp[now].push(S,num+1);
						set(S,j,q);
						set(S,j+1,p);
						if(maze[i+(q>0)][j+(p>0)]!=1)
							dp[now].push(S,num+1);
					}
					else if((p>=3 && p==q)||(p==2 && q==1))
					{
						set(S,j,0);
						set(S,j+1,0);
						dp[now].push(S,num+1);
					}
					else if(p==1 && q==1)
					{
						int find=1;
						for(int k=j+2;k<=m;k++)
						{
							int v=get(S,k);
							if(v==1) find++;
							else if(v==2) find--;
							if(find==0)
							{
								set(S,j,0);
								set(S,j+1,0);
								set(S,k,1);
								dp[now].push(S,num+1);
								break;
							}
						}
					}
					else if(p==2 && q==2)
					{
						int find=1;
						for(int k=j-1;k>=0;k--)
						{
							int v=get(S,k);
							if(v==2) find++;
							else if(v==1) find--;
							if(find==0)
							{
								set(S,j,0);
								set(S,j+1,0);
								set(S,k,2);
								dp[now].push(S,num+1);
								break;
							}
						}
					}
					else if(max(p,q)>=3 && min(p,q)==1)
					{
						int find=1;
						for(int k=j+2;k<=m;k++)
						{
							int v=get(S,k);
							if(v==2) find--;
							else if(v==1) find++;

							if(find==0)
							{
								set(S,j,0);
								set(S,j+1,0);
								set(S,k,max(p,q));
								dp[now].push(S,num+1);
								break;
							}
						}
					}
					else if(max(p,q)>=3 && min(p,q)==2)
					{
						int find=1;
						for(int k=j-1;k>=0;k--)
						{
							int v=get(S,k);
							if(v==1) find--;
							else if(v==2) find++;

							if(find==0)
							{
								set(S,j,0);
								set(S,j+1,0);
								set(S,k,max(p,q));
								dp[now].push(S,num+1);
								break;
							}
						}
					}
					else
					{
					}
				}
			}

			for(int s=0;s<dp[now].size;s++)
				dp[now].S[s]<<=3;
		}

		printf("%d\n",dp[now].get(0)-2);
	}
}
    后来优化了下，将maxn该成29989，直接204MS搞定，排名第7哈哈。没有往下试了，有兴趣的可以继续。

    看了下kuangbin大神的思路，直接用2表示2号插头，3表示3号插头。之前不敢这么做是因为担心产生回路，现在想一下，整个过程都在贪心，肯定不会有回路嘛。改了下代码，如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxn=59999;
int now,pre;
int maze[10][10];
struct Node
{
	int H[maxn];
	int N[maxn];
	int S[maxn];
	int size;
	void init()
	{
		size=0;
		memset(H,-1,sizeof(H));
	}
	void push(int SS,int num)
	{
		int s=SS%maxn;
		while( ~H[s] && S[H[s]]!=SS )
			s=(s+1)%maxn;
		if( ~H[s] )
		{
			N[H[s]]=min(N[H[s]],num);
			return ;
		}
		N[size]=num;
		S[size]=SS;
		H[s]=size++;
	}
	int get(int SS)
	{
		int s=SS%maxn;
		while( ~H[s] && S[H[s]]!=SS )
			s=(s+1)%maxn;
		if( ~H[s] )
			return N[H[s]];
		return 2;
	}
} dp[2];

int L=2;
int get(int S,int p)
{
	return (S>>(p*L))&((1<<L)-1);
}

void set(int &S,int p,int v)
{
	S^=get(S,p)<<(p*L);
	S^=v<<(p*L);
}

int main()
{
	int n,m;
	while( scanf("%d%d",&n,&m),n||m )
	{
		memset(maze,0,sizeof(maze));
		for(int i=0;i<n;i++) for(int j=0;j<m;j++)
		{
			scanf("%d",&maze[i][j]);
			if(maze[i][j]<=1) maze[i][j]^=1;
		}

		now=0;
		pre=1;
		dp[now].init();
		dp[now].push(0,0);

		for(int i=0;i<n;i++)
		{
			for(int j=0;j<m;j++)
			{
				swap(now,pre);
				dp[now].init();

				for(int s=0;s<dp[pre].size;s++)
				{
					int S=dp[pre].S[s];
					int num=dp[pre].N[s];
					int p=get(S,j);
					int q=get(S,j+1);

					if(maze[i][j]==0)
					{
						if(p==0 && q==0)
							dp[now].push(S,num);
						continue;
					}
					
					if(maze[i][j]>=2)
					{
						if((p>0)^(q>0))
						{
							if(max(p,q)==maze[i][j])
							{
								set(S,j,0);
								set(S,j+1,0);
								dp[now].push(S,num+1);
							}
						}
						if(p==0 && q==0)
						{
							if(maze[i+1][j])
							{
								set(S,j,maze[i][j]);
								set(S,j+1,0);
								dp[now].push(S,num+1);
							}
							if(maze[i][j+1])
							{
								set(S,j,0);
								set(S,j+1,maze[i][j]);
								dp[now].push(S,num+1);
							}
						}
						continue;
					}

					if(p==0 && q==0)
					{
						dp[now].push(S,num);
						if(maze[i+1][j] && maze[i][j+1])
						{
							set(S,j,2);
							set(S,j+1,2);
							dp[now].push(S,num+1);
							set(S,j,3);
							set(S,j+1,3);
							dp[now].push(S,num+1);
						}
					}
					else if((p>0) ^ (q>0))
					{
						if(maze[i+(p>0)][j+(q>0)])
							dp[now].push(S,num+1);
						set(S,j,q);
						set(S,j+1,p);
						if(maze[i+(q>0)][j+(p>0)])
							dp[now].push(S,num+1);
					}
					else if(p==q)
					{
						set(S,j,0);
						set(S,j+1,0);
						dp[now].push(S,num+1);
					}
				}
			}

			for(int s=0;s<dp[now].size;s++)
				dp[now].S[s]<<=L;
		}

		printf("%d\n",dp[now].get(0)-2);
	}
}

    这段代码时间挺长，也没有再优化了。

    越是长的代码越是担心。如果真的比赛，应该会选择第二种吧，思路代码都清晰。

    最小表示法：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long LL;

const int maxn=59999;
const int L=2;
int now,pre;
int n,m;
int endx,endy;
int maze[15][15];
int code[15];
struct Node
{
	int h[maxn];
	int n[maxn];
	LL s[maxn];
	int size;
	void init()
	{
		memset(h,-1,sizeof(h));
		size=0;
	}

	void push(LL ss,int num)
	{
		int i=ss%maxn;
		while( ~h[i] && s[h[i]]!=ss )
			i=(i+1)%maxn;
		if( ~h[i] )
		{
			n[h[i]]=min(n[h[i]],num);
		}
		else
		{
			s[size]=ss;
			n[size]=num;
			h[i]=size++;
		}
	}

	int get(LL ss)
	{
		int i=ss%maxn;
		while( ~h[i] && s[h[i]]!=ss )
			i=(i+1)%maxn;
		if( ~h[i] )
			return n[h[i]]-2;
		else
			return 0;
	}
} dp[2];

void decode(LL s)
{
	for(int i=0;i<=m;i++)
		code[i]=s&((1<<L)-1),s>>=L;
}

LL encode()
{
	LL s=0;

	for(int i=m;i>=0;i--)
	{
		s<<=L;
		s|=code[i];
	}
	return s;
}

void shift()
{
	for(int s=0;s<dp[now].size;s++)
		dp[now].s[s]<<=L;
}

void merge(int a,int b)
{
	for(int i=0;i<=m;i++) if(code[i]==a)
		code[i]=b;
}

void doGrid(int i,int j)
{
	for(int s=0;s<dp[pre].size;s++)
	{
		decode(dp[pre].s[s]);
		int num=dp[pre].n[s];
		int left=code[j];
		int up=code[j+1];
		int ma=max(left,up);
		int mi=min(left,up);
		int val=maze[i][j];

		if(val==0)
		{
			if(ma==0)
				dp[now].push(encode(),num);
			continue;
		}
		else if(val>1)
		{
			if(ma==val && mi==0)
			{
				code[j]=0;
				code[j+1]=0;
				dp[now].push(encode(),num+1);
				continue;
			}
			else if(ma==0)
			{
				if(maze[i+1][j]==1 || maze[i+1][j]==val)
				{
					code[j]=val;
					code[j+1]=0;
					dp[now].push(encode(),num+1);
				}
				if(maze[i][j+1]==1 || maze[i][j+1]==val)
				{
					code[j]=0;
					code[j+1]=val;
					dp[now].push(encode(),num+1);
				}
			}
			continue;
		}

		if(ma==0)
		{
			dp[now].push(encode(),num);
			if(maze[i][j+1] && maze[i+1][j])
			{
				code[j]=code[j+1]=2;
				dp[now].push(encode(),num+1);

				code[j]=code[j+1]=3;
				dp[now].push(encode(),num+1);
			}
		}
		else if(mi==0)
		{
			if(maze[i+1][j]==1 || maze[i+1][j]==ma)
			{
				code[j]=ma;
				code[j+1]=0;
				dp[now].push(encode(),num+1);
			}
			if(maze[i][j+1]==1 || maze[i][j+1]==ma)
			{
				code[j]=0;
				code[j+1]=ma;
				dp[now].push(encode(),num+1);
			}
		}
		else if(left==up)
		{
			code[j]=code[j+1]=0;
			dp[now].push(encode(),num+1);
		}
	}
}

void solve()
{
	now=1,pre=0;
	dp[now].init();
	dp[now].push(0,0);

	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m;j++)
		{
			swap(now,pre);
			dp[now].init();
			doGrid(i,j);
		}
		shift();
	}
}

void init()
{
	memset(maze,0,sizeof(maze));
	for(int i=0;i<n;i++) for(int j=0;j<m;j++)
	{
		scanf("%d",&maze[i][j]);
		if(maze[i][j]<=1) maze[i][j]^=1;
	}
}

int main()
{
	int cas=1;
	while(scanf("%d%d",&n,&m),n||m)
	{
		init();
		solve();
		printf("%d\n",dp[now].get(0));
	}
}


SF-_-
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[POJ3133]Manhattan Wiring 插头dp
chbug的博客
07-10 814
[POJ3133]Manhattan Wiring 插头dp 原题POJ3133题意：N*M有障碍矩阵，0可通过,1为障碍，两个2，两个3，求连接两个2和连接两个3的两条不相交路径长度和的最小值(1 <= N, M <= 9).
poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告
10-06
poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题...
poj 3133
志当存高远
06-25 1310
 Manhattan WiringTime Limit: 5000MS Memory Limit: 65536KTotal Submissions: 816 Accepted: 465DescriptionThere is a rectangular area containing n × m cells. Two c
POJ3133
code
03-05 1210
POJ3133 Manhattan Wiring 现在有一个N*M（2 输入：包含多组实例。每个实例第一行为N和M，然后是数字矩阵。输入以0和0结束。 输出：输出最小的短长度，如果不存在这样的两条线，就输出0. 分析：插头DP问题，只要按常规的插头DP问题来处理即可，但是要分别特殊处理2和3格子，然后用f[]记录最小长度即可。插头只有3种，0插头（表示无），2插头和3插头。 会不会出现4
Manhattan Wiring poj3133
霁月难逢 彩云易散
07-15 635
确定起点和终点的俩条简单路径问题，可以规定每个格子只能有2号插头或3号插头或空插头，允许合并相同编号的插头，这样可能会产生冗余的回路，但由于此题求得是最小解，所以这种情况会被筛选掉，当然如果求最长路径的话就不能这样了，只能使用最小表示法编号，然后合并不同编号的插头。 #include #include #include #include #include #include #incl
poj 3133 Manhattan Wiring
我要吃熊猫
03-31 631
插头dp
poj 2564 Edit Step Ladders 解题报告
10-12
讲解 poj 2564做法。 解题思路是DP+字典树，挺好的一题，文件里面包括思路和代码。
POJ 我收集的解题报告（100多道）
08-24
【标题】"POJ 解题报告集合"是一个珍贵的学习资源，包含了编程爱好者在解决POJ（Programming Online Judge）平台上的100多道题目后的详细分析与解答。POJ是著名的在线编程竞赛平台，它提供了丰富的算法题目，帮助...
POJ 部分题解 解题报告
09-17
10. **POJ 2528 线段树.txt**：这是第三个线段树相关的题目，解题报告可能会深入讲解线段树在不同场景下的应用。 通过阅读这些解题报告，你可以学习到各种高级算法的应用，如动态规划、搜索算法、数据结构（如线段...
poj 1440解题报告
05-29
poj 1440解题报告 poj 1440解题报告 poj 1440解题报告 poj 1440解题报告
POJ 3133 Manhattan Wiring 笔记
woniupengpeng的专栏
07-18 215
n*m矩阵，1 代表障碍物，如图，要求连线 2 与连线 3 不能有交点。求两个连线和的最小长度。
poj 3133 Manhattan Wiring (插头dp)
ACM之梦
01-30 559
题意： 一个n*m的地图，有三种类型的格子，1表示障碍物，0表示空，2、3分别表示不同类型的，现在要将2和2,3和3相连（都只有一对），当然不能交叉，求最短的和。 题解： 这是另外一类的插头dp问题，多路径的问题。应为插头类型较多所以考虑用多进制表示，这里有4格子，因此考虑用3进制表示法做，但是由于4进制比较高效，因此用四进制做。题解附了注释，应该很详细了。 #include #inclu
【POJ3133】Manhattan Wiring 插头DP
CRTorlonia的博客
03-25 245
原题走这里 看起来就很难的一道题 本题存在一个小陷阱，它看起来像是单回路模型（毕竟是求路径），然而它其实是多回路模型，或者说可以用多回路模型做。 这道题求的是最短距离，那么这就意味着如果出现了多出来的一个回路，那么它就会因为带来了额外的距离而被舍去。 于是乎，我们就可以用多回路也就是Eat the trees的思路来转移，但是路径分为2和3两种，所以轮廓线上的状态也有0,2,3三种，用四进...
poj 3133 -- Manhattan Wiring 插头dp
Demerzel_IV
09-20 395
颓了几天= =终于解决这道题了。庆祝一下。题解明天再补。
POJ 3133 Manhattan Wiring （插头DP，轮廓线，经典）
weixin_30423977的博客
09-09 102
题意：给一个n*m的矩阵，每个格子中有1个数，可能是0或2或3，出现2的格子数为2个，出现3的格子数为2个，要求将两个2相连，两个3相连，求不交叉的最短路（起终点只算0.5长，其他算1）。 思路： 　　这题与普通插头DP有些区别了，就是要求最短路时，而且还要同时两条不相交的最短路。一开始看还是感觉挺难的，因为每个0格子还得考虑两种线，分别是2线和3线，而且还不能出现回路的，于...
POJ 3133 Manhattan Wiring（限制匹配的插头DP）
yasolx的博客
08-02 444
Manhattan Wiring Time Limit: 5000MS   Memory Limit: 65536K Total Submissions: 1921   Accepted: 1130 Description There is a rectangular area containing n × m cells. Tw
[插头DP] poj3133 Manhattan Wiring
CE玩家
08-10 407
还是一道插头DP 不过我的代码跑的好慢啊啊，要卡卡常才能过#include <cstdio> #include <iostream> #include <algorithm> #include <string> #include <cstring>using namespace std;const int N=20010,inf=1<<30;int n,m; int f[10][10][4][N]
poj 3133 Manhattan Wiring 插头dp
XYM-AC之路
10-08 1494
这题的和上一份报告那题有点像，不过是确定了起点和终点，而且分别有两对，按照小hh的说法就是确定了起点和终点就相当于回路问题，另一边相当于虫洞连接起来，不过他说起点为左括号，终点为右括号，这还是有点问题的，昨晚思考了一下，如果，起点和终点的位置在其他位置，而不是边界，想想楼教男人8题的那题，如果位置在中间该怎么处理，左括号和右括号的设置方法肯定不可行，而是应该像上篇报告那题要独立插头，但是这个独立插
POJ3133 Manhattan Wiring（难题 较为复杂）
qq_36782366的博客
07-28 360
题目链接：poj3133 参考博客：点击打开链接 现在有一个N*M（2 输入：包含多组实例。每个实例第一行为N和M，然后是数字矩阵。输入以0和0结束。 输出：输出最小的短长度，如果不存在这样的两条线，就输出0. 分析：插头DP问题，只要按常规的插头DP问题来处理即可，但是要分别特殊处理2和3格子，然后用f[]记录最小长度即可。插头只有3种，0插头（表示无），2插头和3插头。 会不会
[POJ1088] 滑雪(递归dp)
最新发布
05-17
对于这道题，我们可以使用递归DP来解决，用$f(i,j)$表示以$(i,j)$为起点的路径最大长度，那么最后的答案就是所有$f(i,j)$中的最大值。 状态转移方程如下： $$ f(i,j)=\max f(x,y)+1(x,y)是(i,j)的下一个满足条件的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值