HDU3440(差分约束)

House Man

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 2889    Accepted Submission(s): 1212

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

 

题意：给我们n座房子，房子的高度各不相同， 从最低的房子开始， 每次跳到更高的房子， 跳n-1次最能跳到最高的房子了，但是每次跳跃的距离不能超过d

　　   将这些房子在一维的方向上重新摆放（但是保持输入时的相对位置不变） ， 使得最矮的房子和最高的房子水平距离最大

差分约束系统建图。

 //2017-08-29
 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #include <queue>
 #include <stack>

 using namespace std;

 const int N = ;
 const int M = ;
 const int INF = 0x3f3f3f3f;

 int head[N], tot;
 struct Edge{
     int to, next, w;
 }edge[M];

 void init(){
     tot = ;
     memset(head, -, sizeof(head));
 }

 void add_edge(int u, int v, int w){
     edge[tot].w = w;
     edge[tot].to = v;
     edge[tot].next = head[u];
     head[u] = tot++;
 }

 int n, m, c;
 bool vis[N];
 int dis[N], cnt[N];

 bool spfa(int s, int n){
     memset(vis, , sizeof(vis));
     memset(dis, INF, sizeof(dis));
     memset(cnt, , sizeof(cnt));
     vis[s] = ;
     dis[s] = ;
     cnt[s] = ;
     deque<int> dq;
     dq.push_back(s);
     int sum = , len = ;
     while(!dq.empty()){
         // LLL 优化
         while(dis[dq.front()]*len > sum){
             dq.push_back(dq.front());
             dq.pop_front();
         }
         int u = dq.front();
         sum -= dis[u];
         len--;
         dq.pop_front();
         vis[u] = ;
         for(int i = head[u]; i != -; i = edge[i].next){
             int v = edge[i].to;
             if(dis[v] > dis[u] + edge[i].w){
                 dis[v] = dis[u] + edge[i].w;
                 if(!vis[v]){
                     vis[v] = ;
                     // SLF 优化
                     if(!dq.empty() && dis[v] < dis[dq.front()])
                       dq.push_front(v);
                     else dq.push_back(v);
                     sum += dis[v];
                     len++;
                     if(++cnt[v] > n)return false;
                 }
             }
         }
     }
     return true;
 }

 struct Node{
     int id, height;
     bool operator<(const Node a) const{
         return height < a.height;
     }
 }house[N];

 int main()
 {
     std::ios::sync_with_stdio(false);
     //freopen("input.txt", "r", stdin);
     int T, n, d, kase = ;
     cin>>T;
     while(T--){
         init();
         cin>>n>>d;
         for(int i = ; i < n; i++){
               cin>>house[i].height;
             house[i].id = i;
         }
         sort(house, house+n);
         //令d[i]表示i到最左边点的距离。
         for(int i = ; i < n-; i++){
             // d[i+1] - d[i] >= 1 约束1
             // d[i] - d[i+1] <= -1
             // i+1 -> i : -1
             add_edge(i+, i, -);
             // d[v] - d[u] <= d | v > u 约束2
             if(house[i+].id < house[i].id)
                 add_edge(house[i+].id, house[i].id, d);
             else
                   add_edge(house[i].id, house[i+].id, d);
         }
         int s, t;
         //有向边都是 标号小的点  --->  标号大的点（除开边权为-1的边），所以找最短路的时候也要约定从标号小的点到标号大的点
         if(house[].id < house[n-].id){
             s = house[].id;
             t = house[n-].id;
         }else{
             s = house[n-].id;
             t = house[].id;
         }
         cout<<"Case "<<++kase<<": ";
         if(spfa(s, n))
             cout<<dis[t]<<endl;
         else cout<<-<<endl;
     }

     return ;
 }