HDU 3440 查分约束

点击打开链接

题意：给个n个不同的高度，一个人从最低点跳跃，每次可以跳到第一个比它高的位置，最后跳到最高点，然后每次最多可以跳的距离为D，而且在跳跃时可以在不改变给定顺序的情况下移动这些高度，使得最后起始点和终点的位置最远，

思路：自己想了一会，想的方向错了，我自己想的方法是将最小高度记为0，最大高度记为n-1，然后写查分约束方程，这了一会发现条件不足，没想法了，看了大牛们的解法发现原来以给定的顺序直接进行条件就可以了，而且好简单，因为我们不能调整给定的顺序，那么对于给定的顺序就可以有pos(i+1)>=pos(i)+1，那么可以写出一个条件就是i+1-->i连一条权值为-1的边，还有一个条件是相邻两个要跳跃的距离不可以大于D，可以写出另一个方程，而现在条件全部是基于给定的序列，那么剩下的条件也要在这个基础进行，右面的点一定是在左边的点的后面，那么式子也就很好列出来了，图建完了，查询距离就用SPFA判环并输出就行了，对于起点和终点也要在原序列完成，那么找到位置并处理一下前后即可，因为位置相对的是绝对值，且边是从前向后建的，那么起点和终点为什么换位置就理解了#include <stack>
#include <vector>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int inf=0x3f3f3f3f;
const ll INF=0x3f3f3f3f3f3f3f3fll;
const int maxn=1010;
int dis[maxn],cnt[maxn],head[maxn],n,m,k;
bool vis[maxn];
struct edge{
int to,w,next;
}E[maxn*200];
void add_edge(int u,int v,int w){
E[k].to=v;E[k].w=w;E[k].next=head[u];head[u]=k++;
}
int spfa(int st,int en){
stack<int>que;
memset(dis,inf,sizeof(dis));
memset(cnt,0,sizeof(cnt));
memset(vis,0,sizeof(vis));
que.push(st);dis[st]=0;
while(!que.empty()){
int t=que.top();que.pop();
vis[t]=0;
for(int i=head[t];i!=-1;i=E[i].next){
if(dis[t]+E[i].w<dis[E[i].to]){
dis[E[i].to]=dis[t]+E[i].w;
if(!vis[E[i].to]){
vis[E[i].to]=1;
que.push(E[i].to);
if(++cnt[E[i].to]>n) return -1;
}
}
}
}
if(dis[en]==inf) return -1;
return dis[en];
}
struct edge1{
int pos,val;
}A[maxn];
bool cmp(const edge1 &a,const edge1 &b){
return a.val<b.val;
}
int main(){
int T,cas=1;
scanf("%d",&T);
while(T--){
scanf("%d%d",&n,&m);
k=0;
memset(head,-1,sizeof(head));
for(int i=0;i<n;i++){
scanf("%d",&A[i].val);
A[i].pos=i;
}
for(int i=1;i<n;i++) add_edge(i,i-1,-1);
sort(A,A+n,cmp);
for(int i=1;i<n;i++){
int u=A[i-1].pos;
int v=A[i].pos;
if(u>v) add_edge(v,u,m);
else add_edge(u,v,m);
}
int st=A[0].pos,en=A[n-1].pos;
if(st>en) swap(st,en);
int ans=spfa(st,en);
printf("Case %d: %d\n",cas++,ans);
}
return 0;
}