HDU3440 House Man（差分约束）

题意：有n个高度各不相同的房子排成一条直线，每个房子都占据一个点，相邻两个房子之间的距离可以改变，但是所有房子的相对位置不能变。有一个超人能够在房子之间跳跃，他从最矮的房子开始，依次跳到更高的房顶上。任意两个高度的次序相邻的房子之间的距离不能超过D。求最高的和最矮的房子之间的最大距离。

 

思路：我们将房子按照高度次序编号，最矮的为0，最高的是n-1，设Si为房子i在直线上的坐标，要求的是max()，方便起见我们可以设定S0为0，即坐标源点，于是变成了求max()。

如果最高的房子在S0的右边，则答案就是max(Sn-1)，此时需要跑最短路；否则Sn-1将会是个负数，答案就成了min(Sn-1)，需要跑最长路。为了方便计算，如果Sn-1在S0的左边，我们就将整个数组做一次翻转，这样无论哪种情况，只需要跑最短路求max即可。

(PS:看别人的博客学了个更简便的方法：我们只需要比较最高的楼和最矮的楼的下标，如果矮楼在前面，以它为起点，置dis[0] = 0，求到最高楼的最短路 dis[n - 1] 即可；如果高楼在前面，那么就以高楼为起点，置dis[n - 1]为0，求dis[0]即可)

 

然后就是建立差分约束系统:

设j为每个房子在数组中的原顺序（j = 0,1,2,...,n-1），rk[j]为房子j排序后的序号（rk[j] = 0,1,2,...,n-1），S(x)为房子x在直线省的坐标，则有：

S(rk[j]) >= S(rk[j - 1]) + 1，（j = 1，2，...，n-1）

设i为每个房子按高度升序排列后的序号（i = 0, 1, 2,...,n-1），id[i]为每个房子在原数组中的下标(id[i] = 0,1,2,...,n-1)，

S(rk[j]) <= S(rk[j] - 1) + D，（id[rk[j]] > id[rk[j] - 1]）

S(rk[j] - 1) <= S(rk[j]) + D，（id[rk[j]] < id[rk[j] - 1])，rk[j] = 1,2,...,n-1。

有点绕，但是不是很难想明白。用不等式建图跑最短路即可，spfa判负环。

邻接矩阵数组开小了，T了好几发= =

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <cmath>
#include <list>
#include <cstdlib>
#include <set>
#include <string>

using namespace std;

typedef long long ll;
const int inf = 0x3f3f3f3f;
const int maxn = 1005;
struct edg{
    int v, nxt;
    ll w;
}G[maxn << 2];
int tot, pre[maxn];
int n, times[maxn], mx, mn;
ll dis[maxn], d;
bool vis[maxn];
void add(int u, int v, ll w) {
    G[tot].v = v;
    G[tot].w = w;
    G[tot].nxt = pre[u];
    pre[u] = tot++;
}
struct node {
    int id, h, rk;
}p[maxn];
bool cmp1(struct node &a, struct node &b) {
    return a.h < b.h;
}
bool cmp2(struct node &a, struct node &b) {
    return a.id < b.id;
}
ll spfa(){
    for (int i = 0; i < n; ++i) {
        dis[i] = 0x3f3f3f3f3f3f3f3f;
        times[i] = 0;
        vis[i] =  false;
    }
    queue<int> que;
    que.push(0);
    dis[0] = 0;
    times[0] = 1;
    vis[0] = true;
    while (!que.empty()) {
        int u = que.front();
        que.pop();
        vis[u] = false;
        for (int i = pre[u]; ~i; i = G[i].nxt) {
            int v = G[i].v;
            ll w = G[i].w;
            if (dis[u] + w < dis[v]) {
                dis[v] = dis[u] + w;
                if (!vis[v]) {
                    vis[v] = true;
                    if (++times[v] > n) {
                        return -1;
                    }
                    que.push(v);
                }
            }
        }
    }
    return dis[n - 1];
}
int main() {
    int t, cas = 0;
    scanf("%d", &t);
    while (t--) {
        scanf("%d%lld", &n, &d);
        tot = 0;
        memset(pre, -1, sizeof(pre));
        mx = 0, mn = 0;
        for (int i = 0; i < n; ++i) {
            scanf("%d", &p[i].h);
            p[i].id = i;
            if (p[i].h > p[mx].h) {
                mx = i;
            }
            if (p[i].h < p[mn].h) {
                mn = i;
            }
        }
        if (mx < mn) {
            // 如果最高的楼在最矮的楼左边，就翻转数组。
            for (int i = 0; i < n / 2; ++i) {
                int tmp = p[i].h;
                p[i].h = p[n - i - 1].h;
                p[n - i - 1].h = tmp;
            }
        }
        sort(p, p + n, cmp1);
        for (int i = 0; i < n; ++i) {
            p[i].rk = i;
        }
        for (int i = 1; i < n; ++i) {
            if (p[i].id > p[i - 1].id) {
                add(i - 1, i, d);
            } else {
                add(i, i - 1, d);
            }
        }
        sort(p, p + n, cmp2);
        for (int i = 1; i < n; ++i) {
            add(p[i].rk, p[i - 1].rk, -1);
            //add(p[i - 1].rk, p[i].rk, d);
        }
        printf("Case %d: %lld\n", ++cas, spfa());
    }
    return 0;
}