HDU3440 House Man(差分约束)

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

 

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

如果最高的房子在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;
}

 

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值