HDU-3440-House Man（线性约束）

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3440

题目大意：一个人在高楼之间来回跳，他要从最低的楼跳到最高的楼上，每次他最多跳d远（这个远是水平的，不算高度），然后给你这一些楼的高度。楼是不能动的（相对位置固定，高度固定）。问从最低的楼顶跳到最高的楼顶，最远能跳多远？存在解输出，不存在输出-1

思路，还是简单的线性约束，因为题目保证存在解的话必定可行。因此只用考虑如何跳就行了。因为只能向高处跳，我们先按高度排一下序，然后前后两个楼之间就可以建立约束关系了，这里的楼因为不能重叠，因此存在一个隐含条件即：d[i]-d[i-1]>=1，取-1，得：d[i-1]-d[i]<=-1，即存在w=（i~i-1）=-1的边。做n-1次跳跃。其实高度现在已经没什么用了，我们用相对位置建立一个图即可。

首先是相对位置-1的：用样例2举例子： HDU-3440-House Man（线性约束）

然后对于前面的，连接后面的大的。 HDU-3440-House Man（线性约束）然后跑最短路即可。

对于样例三，很明显有一个负环，所以不存在固定位置。跑最短路的时候，如果楼高的在前面，反向跑，楼高的在后面，正常跑。

AC：

//#pragma comment(linker, "/STACK:1024000000,1024000000")
  
#include<stdio.h>
#include<string.h> 
#include<math.h> 
   
#include<map>  
//#include<set>
#include<deque> 
#include<queue> 
#include<stack> 
#include<bitset>
#include<string> 
#include<fstream>
#include<iostream> 
#include<algorithm> 
using namespace std; 
  
#define ll long long 
#define Pair pair<int,int>
//#define max(a,b) (a)>(b)?(a):(b)
//#define min(a,b) (a)<(b)?(a):(b)
#define clean(a,b) memset(a,b,sizeof(a))// 水印
//std::ios::sync_with_stdio(false);
//  register
const int MAXN=1e3+10;
const int INF32=0x3f3f3f3f;
const ll INF64=0x3f3f3f3f3f3f3f3f;
const ll mod=1e9+7;
const double PI=acos(-1.0);

struct node{
	int v,val,nxt;
	node(int _v=0,int _val=0,int _nxt=0){
		v=_v;val=_val;nxt=_nxt;
	}
}edge[MAXN*MAXN];
int head[MAXN],ecnt;
int st[MAXN],tot;
int dis[MAXN],vis[MAXN],sum[MAXN];
Pair high[MAXN];
int n,d,flag;

void intt(){
	clean(head,-1);
	ecnt=0;tot=0;
}
void add(int u,int v,int val){
	edge[ecnt]=node(v,val,head[u]);
	head[u]=ecnt++;
}
int cmp(Pair a,Pair b){
	return a.first<b.first;
}
void dfs_spfa(int str){
	clean(dis,INF32);dis[str]=0;
	clean(vis,0);vis[str]=1;
	clean(sum,0);sum[str]++;
	st[tot++]=str;
	while(tot){
		int u=st[--tot];vis[u]=0;
		for(int i=head[u];i+1;i=edge[i].nxt){
			int v=edge[i].v;
			if(dis[v]>dis[u]+edge[i].val){
				dis[v]=dis[u]+edge[i].val;
				if(vis[v]==0){
					vis[v]=1;
					st[tot++]=v;
					sum[v]++;
					if(sum[v]>n){
						flag=1;return ;
					}
				}
			}
		}
	} 
}
int main(){
	int T,Case=1;
	scanf("%d",&T);
	while(T--){
		intt();
		scanf("%d%d",&n,&d);
		int h,hi,li;
		for(int i=1;i<=n;++i){
			scanf("%d",&h);
			high[i]={h,i};
		}sort(high+1,high+1+n,cmp);//按高度排序 
		hi=high[n].second;li=high[1].second;
		//从最低的开始向高处走 
		for(int i=2;i<=n;++i){
			add(i,i-1,-1);
			if(high[i].second>high[i-1].second)//后面的 在后面 
				add(high[i-1].second,high[i].second,d);
			else	add(high[i].second,high[i-1].second,d);
		}flag=0;
		dfs_spfa(min(li,hi));
//		for(int i=1;i<=n;++i){
//			printf("%d ",dis[i]);
//		}printf("\n");
		if(flag)	printf("Case %d: -1\n",Case++);
		else		printf("Case %d: %d\n",Case++,dis[max(li,hi)]);
	}
}
/*

*/

HDU-3440-House Man（线性约束）

相关推荐