codeforces 545c

最新推荐文章于 2025-09-06 22:33:46 发布

转载最新推荐文章于 2025-09-06 22:33:46 发布 · 89 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/chenruijiang/p/8366359.html

文章标签：

#数据结构与算法

本文介绍了一个关于树木砍伐的问题，通过贪心算法和动态规划两种方法进行解答，旨在找到能够被砍伐的最大树木数量。

Little Susie listens to fairy tales before bed every day. Today's fairy tale was about wood cutters and the little girl immediately started imagining the choppers cutting wood. She imagined the situation that is described below.

There are n trees located along the road at points with coordinates x1, x2, ..., xn. Each tree has its height hi. Woodcutters can cut down a tree and fell it to the left or to the right. After that it occupies one of the segments [xi - hi, xi] or [xi;xi + hi]. The tree that is not cut down occupies a single point with coordinate xi. Woodcutters can fell a tree if the segment to be occupied by the fallen tree doesn't contain any occupied point. The woodcutters want to process as many trees as possible, so Susie wonders, what is the maximum number of trees to fell.

Input

The first line contains integer n (1 ≤ n ≤ 105) — the number of trees.

Next n lines contain pairs of integers xi, hi (1 ≤ xi, hi ≤ 109) — the coordinate and the height of the і-th tree.

The pairs are given in the order of ascending xi. No two trees are located at the point with the same coordinate.

Output

Print a single number — the maximum number of trees that you can cut down by the given rules.

Examples

input

output

input

output

Note

In the first sample you can fell the trees like that:

fell the 1-st tree to the left — now it occupies segment [ - 1;1]
fell the 2-nd tree to the right — now it occupies segment [2;3]
leave the 3-rd tree — it occupies point 5
leave the 4-th tree — it occupies point 10
fell the 5-th tree to the right — now it occupies segment [19;20]

In the second sample you can also fell 4-th tree to the right, after that it will occupy segment [10;19]

这道题目的意思为：输入树的总数n，然后分别输入树的位置position和树高height，树可以左倒或者右倒，但树顶不能到达旁边树的根部，计算可以砍倒的树的数目最大是多少。

1.用贪心的思想：

优先向左倒，向右倒的时候更新两棵树的距离。

#include<iostream>
#define MAXN 100005
using namespace std;
typedef long long ll;
ll root[MAXN];
ll height[MAXN];
ll dist[MAXN];
int main()
{
    int n;
    while (cin >> n)
    {
        int sum = 2;
        if (n == 1)
        {
            cout << '1' << endl;
            return 0;
        }
        for (int i = 0;i < n;i++)
            cin >> root[i] >> height[i];
        for (int i = 1;i < n;i++)
            dist[i] = root[i] - root[i-1];
        dist[0] = 0;
        for (int i = 1;i < n - 1;i++)
        {
            if (height[i] < dist[i])
                sum++;
            else if (height[i] >= dist[i] && height[i] < dist[i + 1])
            {
                sum++;
                dist[i + 1]-=height[i];
            }
        }
        cout << sum << endl;
    }
    return 0;
}

2：动态规划

dp[i][0]表示不砍倒，

dp[i][1]表示向左倒，

dp[i][2]表示向右倒，

dp[i][0] = max(dp[i - 1][0], dp[i - 1][1], dp[i - 1][2])

左倒的时候分两种：前一棵树加现在这棵树的高度小于两棵树的距离和前一棵树加现在这棵树的高度大于两棵树的距离。

小于：dp[i][1] = max(dp[i - 1][0], dp[i - 1][1], dp[i - 1][2])+1

大于：dp[i][1] = max(dp[i - 1][0], dp[i - 1][1])+1

dp[i][2] = max(dp[i - 1][0], dp[i - 1][1], dp[i - 1][2]) + 1

#include<iostream>
#include<algorithm>
#define MAXN 100005
typedef long long ll;
using namespace std;
ll position[MAXN];
ll height[MAXN];
int dp[MAXN][3];
int main()
{
    int n;
    while (cin >> n)
    {
        for (int i = 0;i < n;i++)
            cin >> position[i] >> height[i];
        if (n == 1)
        {
            cout << '1' << endl;
            return 0;
        }
        dp[0][0] = 0;
        dp[0][1] = 1;
        if (position[1] - position[0] > height[0])
            dp[0][2] = 1;
        else
            dp[0][2] = 0;
        for (int i = 1;i < n-1;i++)
        {
            dp[i][0] = max(max(dp[i - 1][0], dp[i - 1][1]), dp[i - 1][2]);
            if (height[i] < position[i] - position[i - 1])
                dp[i][1] = max(dp[i - 1][0], dp[i - 1][1]) + 1;
            if (height[i] + height[i - 1] < position[i] - position[i - 1])
                dp[i][1] = max(dp[i][1] - 1, dp[i - 1][2]) + 1;
            if (height[i] < position[i + 1] - position[i])
                dp[i][2] = max(max(dp[i - 1][0], dp[i - 1][1]), dp[i - 1][2]) + 1;
        }
        cout << max(max(dp[n - 2][0], dp[n - 2][1]), dp[n - 2][2]) + 1 << endl;
    }
    return 0;
}