POJ 2437 Muddy roads

Muddy roads

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 2917		Accepted: 1364

Description

Farmer John has a problem: the dirt road from his farm to town has suffered in the recent rainstorms and now contains (1 <= N <= 10,000) mud pools. 

Farmer John has a collection of wooden planks of length L that he can use to bridge these mud pools. He can overlap planks and the ends do not need to be anchored on the ground. However, he must cover each pool completely. 

Given the mud pools, help FJ figure out the minimum number of planks he needs in order to completely cover all the mud pools.

Input

* Line 1: Two space-separated integers: N and L 

* Lines 2..N+1: Line i+1 contains two space-separated integers: s_i and e_i (0 <= s_i < e_i <= 1,000,000,000) that specify the start and end points of a mud pool along the road. The mud pools will not overlap. These numbers specify points, so a mud pool from 35 to 39 can be covered by a single board of length 4. Mud pools at (3,6) and (6,9) are not considered to overlap. 

Output

* Line 1: The miminum number of planks FJ needs to use.

Sample Input

3 3
1 6
13 17
8 12

Sample Output

5

Hint

INPUT DETAILS: 

FJ needs to use planks of length 3 to cover 3 mud pools. The mud pools cover regions 1 to 6, 8 to 12, and 13 to 17. 

OUTPUT DETAILS: 

FJ can cover the mud pools with five planks of length 3 in the following way: 

                   111222..333444555....

                   .MMMMM..MMMM.MMMM....

                   012345678901234567890

题意：有n个泥水沟，要你用L的板子把所有沟覆盖。

分析：贪心。每次把当前的沟覆盖，若之前的木板已把当前的沟覆盖则忽略，否则覆盖部分或完全没覆盖，需要考虑的是剩下沟的长度如何覆盖完全。

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
using namespace std;
const int maxn = 10000 + 10;

struct P
{
    int s, e;
}p[maxn];

int n, l;

int cmp(P a, P b)
{
    return a.s < b.s;
}

int main()
{
    while (scanf("%d%d", &n, &l) != EOF){
        for (int i = 0; i < n; i++){
            scanf("%d%d", &p[i].s, &p[i].e);
        }
        sort(p, p + n, cmp);
        int ans = 0, pos = -1, num;
        for (int i = 0; i < n; i++){
            if (pos >= p[i].e)    //如果现在标记的木棒覆盖点已经可以覆盖现在这个区间，则不需要再添加木棒。  
                continue;
            if (pos > p[i].s){    //如果只覆盖了一部分 
                num = ceil((p[i].e - pos) * 1.0 / l);    //记得向上取整，而且注意向上取整的函数ceil运用于浮点型，要强制转换成浮点型才对。
                pos += num * l;     //能覆盖点更新  
                ans += num;    //答案更新 
            }
            else{
                num = ceil((p[i].e - p[i].s) * 1.0 / l);
                pos = p[i].s + num * l;
                ans += num;
            }
        }
        printf("%d\n", ans);
    }
    return 0;
}