hdoj--3440--House Man（差分约束）

最新推荐文章于 2025-09-05 16:34:31 发布

转载最新推荐文章于 2025-09-05 16:34:31 发布 · 93 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/playboy307/p/5273545.html

文章标签：

#java

本文描述了一个有趣的算法问题，一位无法飞行却擅长跳跃的超级英雄需要在多个不同高度的房子间跳跃，每次跳跃都必须从较矮的房子跳到较高的房子。挑战在于如何在保持跳跃距离限制的同时，最大化起始和终点房子之间的距离。

House Man

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)

Total Submission(s): 2306 Accepted Submission(s): 931

Problem Description

In Fuzhou, there is a crazy super man. He can’t fly, but he could jump from housetop to housetop. Today he plans to use N houses to hone his house hopping skills. He will start at the shortest house and make N-1 jumps, with each jump taking him to a taller house than the one he is jumping from. When finished, he will have been on every house exactly once, traversing them in increasing order of height, and ending up on the tallest house.
The man can travel for at most a certain horizontal distance D in a single jump. To make this as much fun as possible, the crazy man want to maximize the distance between the positions of the shortest house and the tallest house.
The crazy super man have an ability—move houses. So he is going to move the houses subject to the following constraints:
1. All houses are to be moved along a one-dimensional path.
2. Houses must be moved at integer locations along the path, with no two houses at the same location.
3. Houses must be arranged so their moved ordering from left to right is the same as their ordering in the input. They must NOT be sorted by height, or reordered in any way. They must be kept in their stated order.
4. The super man can only jump so far, so every house must be moved close enough to the next taller house. Specifically, they must be no further than D apart on the ground (the difference in their heights doesn't matter).
Given N houses, in a specified order, each with a distinct integer height, help the super man figure out the maximum possible distance they can put between the shortest house and the tallest house, and be able to use the houses for training.

Input

In the first line there is an integer T, indicates the number of test cases.(T<=500)
Each test case begins with a line containing two integers N (1 ≤ N ≤ 1000) and D (1 ≤ D ≤1000000). The next line contains N integer, giving the heights of the N houses, in the order that they should be moved. Within a test case, all heights will be unique.

Output

For each test case , output “Case %d: “first where d is the case number counted from one, then output a single integer representing the maximum distance between the shortest and tallest house, subject to the constraints above, or -1 if it is impossible to lay out the houses. Do not print any blank lines between answers.

Sample Input

   3 4 4 20 30 10 40 5 6 20 34 54 10 15 4 2 10 20 16 13 
  

Sample Output

   Case 1: 3 Case 2: 3 Case 3: -1
  

Author

jyd

Source

2010 ACM-ICPC Multi-University Training Contest（1）——Host by FZU

Recommend

We have carefully selected several similar problems for you: 3439 3433 3442 3438 3437

题意：一个男人在n个房子之间跳，他只可以从低的房子跳到高的房子上，
现在给出房子的个数n，男人跳的有多远，每一个房子的高度，男人不能
改变房子的位置，只能按照房子的输入顺序，问男人能否跳n-1次经过所有的
房子到达最高的房子上，如果可以的话输出最大的距离值，否则输出-1 
#include<stdio.h>
#include<string.h>
#include<queue>
#include<stack>
#include<iostream>
#include<algorithm>
using namespace std;
#define INF 0x3f3f3f
#define MAXN 1010
#define MAXM 20000
int head[MAXN],vis[MAXN],dis[MAXN],used[MAXN];
int Instack[MAXN];
int D,n,s,e,cnt;
struct node
{
	int u,v;
	int val,next;
}edge[MAXM];
struct house
{
	int height,pos;
}h[MAXN];
void init()
{
	memset(head,-1,sizeof(head));
	cnt=0;
}
void add(int u,int v,int val)
{
	node E={u,v,val,head[u]};
	edge[cnt]=E;
	head[u]=cnt++;
}
int cmp(house s1,house s2)
{
	return s1.height<s2.height;
}
void getmap()
{
	for(int i=1;i<=n;i++)
	cin>>h[i].height,h[i].pos=i;
	sort(h+1,h+n+1,cmp);
	s=min(h[1].pos,h[n].pos);
	e=max(h[1].pos,h[n].pos);
	for(int i=1;i<=n-1;i++)
	{
		if(h[i].pos>h[i+1].pos)
		add(h[i+1].pos,h[i].pos,D);
		else
		add(h[i].pos,h[i+1].pos,D);
		add(i+1,i,-1);
	}
}
void SPFA()
{
	memset(vis,0,sizeof(vis));
	memset(used,0,sizeof(used));
	memset(dis,INF,sizeof(dis));
	memset(Instack,0,sizeof(Instack));
	used[s]++;
	vis[s]=1;
	dis[s]=0;
	int top=0;
	Instack[top++]=s;
	while(top)
	{
		int u=Instack[--top];
		vis[u]=0;
		for(int i=head[u];i!=-1;i=edge[i].next)
		{
			node E=edge[i];
			if(dis[E.v]>dis[u]+E.val)
			{
				dis[E.v]=dis[E.u]+E.val;
				if(!vis[E.v])
				{
					vis[E.v]=1;
					used[E.v]++;
					if(used[E.v]>n)
					{
						cout<<-1<<endl;
						return ;
					}
					Instack[top++]=E.v;
				}
			}
		}
	}
	cout<<dis[e]<<endl;
}
int main()
{
	int t;
	int k=1;
//	std::cout.sync_with_stdio(false);
	cin>>t;
	while(t--)
	{
		cin>>n>>D;
		init();
		getmap();
		cout<<"Case "<<k++<<": ";
		SPFA();
	}
	return 0;
}

转载于:https://www.cnblogs.com/playboy307/p/5273545.html