text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9;
long long int fun() {
long long int n, i, j, x, h;
cin >> n;
long long int a[n], b[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
long long int p = a[0];
long long int cnt = 1;
for (long long int i = 1; i < n; i++) {
if (a[i] - p > b[i]) {
p = a[i];
cnt++;
} else if (a[i + 1] - a[i] > b[i]) {
p = a[i] + b[i];
cnt++;
} else {
p = a[i];
}
}
cout << cnt;
return 0;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t = 1;
while (t > 0) {
fun();
t--;
cout << "\n";
}
}
|
#include <bits/stdc++.h>
int main() {
int n;
std::vector<std::pair<int, int> > v;
std::cin >> n;
v.resize(n);
for (int i = 0; i < n; ++i) std::cin >> v[i].first >> v[i].second;
int ans = 2;
for (int i = 1; i < n - 1; ++i) {
if (v[i].first - v[i].second > v[i - 1].first)
++ans;
else if (v[i].first + v[i].second < v[i + 1].first) {
++ans;
v[i].first += v[i].second;
}
}
std::cout << (n == 1 ? 1 : ans) << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
const int N = 1e5 + 5;
long long n, x[N], h[N], cnt;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x[i] >> h[i];
}
cnt++;
for (int i = 2; i < n; i++) {
if (x[i] - h[i] > x[i - 1]) {
cnt++;
} else if (x[i] + h[i] < x[i + 1]) {
cnt++;
x[i] = x[i] + h[i];
}
}
if (n != 1) cnt++;
cout << cnt;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long x[100005], h[100005];
int dp[100005][4];
int main() {
memset(dp, -1, sizeof dp);
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%lld %lld", &x[i], &h[i]);
}
x[n + 1] = 1000000000000;
dp[1][1] = 1;
dp[1][2] = 1;
dp[1][3] = 1;
for (int i = 2; i <= n; ++i) {
if (x[i] + h[i] < x[i + 1]) {
dp[i][3] = max(dp[i - 1][1], max(dp[i - 1][2], dp[i - 1][3])) + 1;
} else
dp[i][3] = max(dp[i - 1][1], max(dp[i - 1][2], dp[i - 1][3]));
if (x[i] - h[i] > x[i - 1]) {
dp[i][1] = max(dp[i - 1][2] + 1, dp[i - 1][1] + 1);
if (x[i] - h[i] > x[i - 1] + h[i - 1])
dp[i][1] = max(dp[i - 1][3] + 1, dp[i][1]);
} else
dp[i][1] = max(dp[i - 1][1], max(dp[i - 1][2], dp[i - 1][3]));
dp[i][2] = max(dp[i - 1][1], max(dp[i - 1][2], dp[i - 1][3]));
}
printf("%d\n", dp[n][3]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
void solve() {
int n;
cin >> n;
vector<int> v(n), h(n);
for (int i = 0; i < n; i++) {
cin >> v[i] >> h[i];
}
int ans = 0;
for (int i = 1; i < n - 1; i++) {
if (v[i] - v[i - 1] > h[i]) {
ans++;
} else if (v[i + 1] - v[i] > h[i]) {
v[i] += h[i];
ans++;
}
}
cout << (n > 2 ? ans + 2 : ans + n) << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int x[100005], h[100005];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> x[i] >> h[i];
int s = min(2, n);
for (int i = 1; i < n - 1; i++) {
if (x[i] - h[i] > x[i - 1])
s++;
else if (x[i] + h[i] < x[i + 1])
s++, x[i] = x[i] + h[i];
}
cout << s;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10e5;
int fl[maxn], fr[maxn], s[maxn], pos[maxn], h[maxn];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> pos[i] >> h[i];
fl[0] = 1;
if (n == 1 || pos[0] + h[0] < pos[1]) fr[0] = 1;
s[0] = 0;
for (int i = 1; i < n; i++) {
int pmax = max(max(fl[i - 1], fr[i - 1]), s[i - 1]);
s[i] = pmax;
if (i + 1 < n && pos[i] + h[i] < pos[i + 1]) fr[i] = pmax + 1;
if (i == n - 1) {
fr[i] = pmax + 1;
}
if (pos[i] - h[i] > pos[i - 1] &&
!(pos[i] - h[i] > pos[i - 1] + h[i - 1])) {
fl[i] = max(fl[i - 1], s[i - 1]) + 1;
}
if (pos[i] - h[i] > pos[i - 1] + h[i - 1]) {
fl[i] = pmax + 1;
}
}
cout << max(max(fr[n - 1], fl[n - 1]), s[n - 1]);
return 0;
}
|
#include <bits/stdc++.h>
int x[111111];
int y[111111];
int main() {
int i, n, rr = 0, tt = -1e9;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d%d", &x[i], &y[i]);
x[n + 1] = 2e9 + 222;
for (i = 1; i <= n; i++) {
if (x[i] - y[i] > tt) {
tt = x[i];
rr++;
continue;
}
tt = x[i];
if (x[i] + y[i] < x[i + 1]) {
rr++;
tt = x[i] + y[i];
}
}
printf("%d", rr);
}
|
#include <bits/stdc++.h>
using namespace std;
int x[100005], h[100005];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x[i] >> h[i];
}
int ans = 0;
int last = -1e9 - 5;
for (int i = 0; i < n - 1; i++) {
if (x[i] - h[i] > last) {
ans++;
last = x[i];
} else if (x[i] + h[i] < x[i + 1]) {
ans++;
last = x[i] + h[i];
} else
last = x[i];
}
if (x[n - 1] > last) ans++;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, j;
cin >> n;
long long int a[n][2], ans[n][3][2];
for (i = 0; i < n; i++) {
cin >> a[i][0] >> a[i][1];
for (j = 0; j < 6; j++) ans[i][j / 2][j % 2] = 0;
}
ans[0][0][0] = 1;
ans[0][0][1] = a[0][0];
for (i = 1; i < n; i++) {
for (j = 0; j < 3; j++) {
if (a[i][0] - a[i][1] > ans[i - 1][j][1]) {
if (ans[i - 1][j][0] + 1 > ans[i][0][0]) {
ans[i][0][0] = ans[i - 1][j][0] + 1;
ans[i][0][1] = a[i][0];
}
} else {
if (ans[i - 1][j][0] > ans[i][0][0]) {
ans[i][0][0] = ans[i - 1][j][0];
ans[i][0][1] = a[i][0];
}
}
ans[i][1][0] = max(ans[i - 1][j][0], ans[i][1][0]);
ans[i][1][1] = a[i][0];
if (a[i][0] > ans[i - 1][j][1] &&
((i < n - 1 && a[i][0] + a[i][1] < a[i + 1][0]) || i == n - 1)) {
if (ans[i - 1][j][0] + 1 > ans[i][2][0]) {
ans[i][2][0] = ans[i - 1][j][0] + 1;
ans[i][2][1] = a[i][0] + a[i][1];
}
} else {
if (ans[i - 1][j][0] > ans[i][2][0]) {
ans[i][2][0] = ans[i - 1][j][0];
ans[i][2][1] = a[i][0];
}
}
}
}
cout << max(ans[n - 1][0][0], max(ans[n - 1][1][0], ans[n - 1][2][0]));
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
template <typename T>
void showvector(vector<T> v) {
for (T x : v) cout << x << " ";
cout << "\n";
}
template <typename T>
void showvector1(vector<T> v) {
long long int n = v.size();
for (long long int i = 1; i <= n - 1; i++) cout << v[i] << "\n";
}
template <typename T>
void showset(set<T> s) {
for (T x : s) cout << x << " ";
cout << "\n";
}
template <class T>
void showvectorpair(vector<T> v) {
for (auto it = v.begin(); it != v.end(); it++)
cout << it->first << " " << it->second << "\n";
cout << "\n";
}
template <typename T, typename P>
void showmap(map<T, P> m) {
for (auto it = m.begin(); it != m.end(); it++)
cout << it->first << " " << it->second << "\n";
cout << "\n";
}
template <typename T>
bool comp(T a, T b) {
return (a > b);
}
template <class T>
bool comppair(T a, T b) {
if (a.first == b.first) return (a.second > b.second);
return (a.first > b.first);
}
bool sameparity(long long int a, long long int b) { return (a % 2 == b % 2); }
bool difparity(long long int a, long long int b) { return !(a % 2 == b % 2); }
bool isprime(long long int x) {
if (x <= 1) return false;
for (long long int i = 2; i <= sqrt(x); i++) {
if (x % i == 0) return false;
}
return true;
}
bool iseven(long long int x) { return !(x % 2); }
bool isodd(long long int x) { return (x % 2); }
char add(char a, char b) {
if (a == '1' && b == '1')
return '2';
else if (a == '1' || b == '1')
return '1';
else
return '0';
}
map<long long int, long long int> m;
long long int n;
long long int fun(long long int xcord) {
auto it = m.lower_bound(xcord);
if (it == m.begin()) {
if (it->first == xcord)
return 1;
else
return 0;
}
if (it->first == xcord) {
auto pt = it;
advance(pt, -1);
return max(1 + fun(it->first - it->second), fun(pt->first));
} else {
advance(it, -1);
auto pt = it;
advance(pt, -1);
return max(1 + fun(it->first - it->second), fun(pt->first));
}
}
vector<long long int> x(100005), h(100005), lt(100005), rt(100005),
stay(100005);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int test = 1;
while (test--) {
long long int n;
cin >> n;
for (long long int i = 1; i <= n; i++) {
cin >> x[i] >> h[i];
}
x[0] = LLONG_MIN;
x[n + 1] = LLONG_MAX;
stay[0] = lt[0] = rt[0] = 0;
for (long long int i = 1; i <= n; i++) {
stay[i] = max(stay[i - 1], lt[i - 1]);
if (x[i - 1] + h[i - 1] < x[i]) {
stay[i] = max(stay[i], rt[i - 1]);
}
if (x[i] - h[i] > x[i - 1]) {
lt[i] = 1 + max(lt[i - 1], stay[i - 1]);
if (x[i] - h[i] > x[i - 1] + h[i - 1]) {
lt[i] = max(lt[i], rt[i - 1] + 1);
}
}
if (x[i] + h[i] < x[i + 1]) {
rt[i] = max({lt[i - 1], rt[i - 1], stay[i - 1]}) + 1;
}
}
cout << max({lt[n], rt[n], stay[n]});
}
}
|
#include <bits/stdc++.h>
long long mpow(long long a, long long n, long long mod) {
long long ret = 1;
long long b = a;
while (n) {
if (n & 1) ret = (ret * b) % mod;
b = (b * b) % mod;
n >>= 1;
}
return (long long)ret;
}
using namespace std;
int dp[100005][3];
vector<pair<int, int> > v;
int main() {
int n, i, j;
cin >> n;
for (j = 0; j < n; j++) {
int x, h;
cin >> x >> h;
v.push_back(make_pair(x, h));
}
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
dp[0][1] = 1;
dp[0][2] = 0;
for (j = 1; j < n - 1; j++) {
if (v[j].first - v[j].second > v[j - 1].first) {
if (v[j - 1].first + v[j - 1].second < v[j].first - v[j].second) {
dp[j][0] = max(dp[j - 1][0], dp[j - 1][1]);
dp[j][0] = max(dp[j][0], dp[j - 1][2]) + 1;
} else
dp[j][0] = max(dp[j - 1][0], dp[j - 1][2]) + 1;
}
if (j + 1 < n && (v[j].first + v[j].second) < v[j + 1].first) {
dp[j][1] = max(dp[j - 1][0], dp[j - 1][1]);
dp[j][1] = max(dp[j][1], dp[j - 1][2]) + 1;
}
dp[j][2] = max(dp[j - 1][0], dp[j - 1][1]);
dp[j][2] = max(dp[j - 1][2], dp[j][2]);
}
int k = max(dp[n - 2][0], dp[n - 2][1]);
k = max(dp[n - 2][2], k);
cout << k + 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<int, int> > trees(n);
for (int i = 0; i < n; i++) {
cin >> trees[i].first >> trees[i].second;
}
if (n == 1) {
cout << "1\n";
return 0;
}
int count = 2;
int reference = trees[0].first;
for (int i = 1; i < n - 1; i++) {
if (trees[i].first - trees[i].second > reference) {
reference = trees[i].first;
count++;
} else if (trees[i].first + trees[i].second < trees[i + 1].first) {
count++;
reference = trees[i].first + trees[i].second;
} else {
reference = trees[i].first;
}
}
cout << count << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long int n, x, h, ans = 0;
long int dp[3][100005];
cin >> n;
if (n <= 2) {
ans = (n == 2) ? 2 : 1;
} else {
ans += 2;
for (int i = 0; i < n; i++) {
cin >> x >> h;
dp[0][i] = x - h;
dp[1][i] = x;
dp[2][i] = x + h;
}
long int pivot = dp[1][0];
for (int i = 1; i < n - 1; i++) {
if (pivot < dp[0][i] && dp[1][i - 1] < dp[0][i]) {
pivot = dp[1][i];
ans++;
} else if (dp[2][i] < dp[1][i + 1]) {
pivot = dp[2][i];
ans++;
}
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dx4[4] = {0, 1, 0, -1};
long long dy4[4] = {1, 0, -1, 0};
long long dy8[8] = {1, 1, 1, 0, -1, -1, -1, 0};
long long dx8[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
long long l, r;
long long ans = 0;
long long xarr[n], harr[n];
for (long long i = 0; i < n; i++) {
cin >> xarr[i] >> harr[i];
}
for (long long i = 0; i < n; i++) {
long long x = xarr[i], h = harr[i];
if (i == 0) {
ans++;
l = x - h;
r = x;
} else if (i == n - 1) {
if (x > r) ans++;
} else if (x - h > r) {
r = x;
ans++;
} else if (x > r && xarr[i + 1] > x + h) {
r = x + h;
ans++;
} else {
r = x;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Point {
int x, y;
Point(int x0, int y0) : x(x0), y(y0) {}
Point() : x(0), y(0) {}
};
int t;
int dx[] = {-1, 0, 1, 0, -1, -1, 1, 1};
int dy[] = {0, -1, 0, 1, -1, 1, -1, 1};
int n, m;
long long maxx;
int d[100005][4];
int a[100005], h[100005];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> h[i];
}
memset(d, 0, sizeof(d));
d[0][0] = 1;
d[0][1] = 0;
if (a[1] - a[0] > h[1])
d[0][2] = 1;
else
d[0][2] = 0;
int res = 1;
for (int i = 1; i < n; i++) {
int dis = a[i] - a[i - 1];
if (h[i] < dis) d[i][0] = max(d[i - 1][0] + 1, d[i - 1][1] + 1);
if (h[i] + h[i - 1] < dis) d[i][0] = max(d[i][0], d[i - 1][2] + 1);
d[i][1] = max(d[i - 1][0], d[i - 1][1]);
if (h[i - 1] < dis) d[i][1] = max(d[i][1], d[i - 1][2]);
if (h[i] < a[i + 1] - a[i] || i == n - 1)
d[i][2] = max(d[i - 1][0] + 1, d[i - 1][1] + 1);
if (h[i - 1] < dis) d[i][2] = max(d[i][2], d[i - 1][2] + 1);
res = max(res, max(d[i][0], max(d[i][1], d[i][2])));
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
struct tree {
int x, h;
};
const int INF = 0x3f3f3f3f;
const long long LLINF = 1e18;
const int maxN = 1e5 + 5;
tree arr[maxN];
int l[maxN], r[maxN], u[maxN];
int main() {
int n;
scanf("%d", &n);
;
for (int i = 0; i < n; ++i) {
scanf("%d %d", &arr[i].x, &arr[i].h);
;
}
if (n == 1) {
printf("1\n");
return 0;
}
l[0] = 1;
r[0] = arr[0].x + arr[0].h < arr[1].x ? 1 : 0;
u[0] = 0;
for (int i = 1; i < n; ++i) {
if (arr[i - 1].x + arr[i - 1].h < arr[i].x - arr[i].h) {
l[i] = max(l[i - 1], max(u[i - 1], r[i - 1])) + 1;
} else if (arr[i - 1].x < arr[i].x - arr[i].h) {
l[i] = max(l[i - 1], u[i - 1]) + 1;
} else {
l[i] = max(l[i - 1], max(u[i - 1], r[i - 1]));
}
if (i < n - 1 && arr[i].x + arr[i].h < arr[i + 1].x) {
r[i] = max(l[i - 1], max(u[i - 1], r[i - 1])) + 1;
} else if (i == n - 1) {
r[i] = max(l[i - 1], max(u[i - 1], r[i - 1])) + 1;
} else {
r[i] = max(l[i - 1], max(u[i - 1], r[i - 1]));
}
u[i] = max(l[i - 1], max(u[i - 1], r[i - 1]));
}
printf("%d\n", max(l[n - 1], max(u[n - 1], r[n - 1])));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<pair<long long, long long>> a(n);
for (long long i = 0; i < n; i++) {
long long t1, t2;
cin >> t1 >> t2;
a[i] = make_pair(t1, t2);
}
a.push_back(make_pair(LLONG_MAX, -1));
sort(a.begin(), a.end());
long long res = 1;
for (long long i = 1; i < n; i++) {
if (a[i].first - a[i].second > a[i - 1].first) {
res += 1;
} else if (a[i].first + a[i].second < a[i + 1].first) {
res += 1;
a[i].first = a[i].first + a[i].second;
}
}
cout << res << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int x[100009], h[100009];
int n, sum;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x[i], &h[i]);
}
sum = 1;
for (int i = 2; i <= n - 1; i++) {
if (x[i] - x[i - 1] > h[i])
sum++;
else if (x[i + 1] - x[i] > h[i]) {
sum++;
x[i] = x[i] + h[i];
}
}
if (n >= 2)
printf("%d", sum + 1);
else
printf("1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int x[n], h[n];
for (int i = 0; i < n; i++) cin >> x[i] >> h[i];
vector<pair<unsigned long long int, unsigned long long int>> range(n);
range[0].first = INT_MAX;
range[n - 1].second = INT_MAX;
for (int i = 0; i < n - 1; i++) {
range[i].second = x[i + 1] - x[i];
range[i + 1].first = range[i].second;
}
int ans = min(2, n);
for (int i = 1; i < n - 1; i++) {
if (range[i].first > h[i]) {
++ans;
} else if (range[i].second > h[i]) {
range[i].second -= h[i];
range[i + 1].first = range[i].second;
++ans;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using lld = long long int;
int main() {
lld n;
cin >> n;
vector<pair<lld, lld> > V(n);
for (int i = 0; i < n; i++) {
lld x, y;
cin >> x >> y;
V[i] = {x, y};
}
if (n == 1) {
cout << 1 << endl;
return 0;
}
lld ans = 2;
for (int i = 1; i < n - 1; i++) {
if (V[i].first - V[i].second > V[i - 1].first) {
ans++;
} else if (V[i + 1].first > V[i].first + V[i].second) {
ans++;
V[i].first = V[i].first + V[i].second;
} else {
continue;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265358979323846;
const long long int NO = 1000001;
bool compare(pair<long long int, long long int> A,
pair<long long int, long long int> B) {
return A.first < B.first;
}
long long int solve() {
long long int n;
cin >> n;
pair<long long int, long long int> arr[n];
for (long long int i = 0; i < n; i++) {
long long int x, h;
cin >> x >> h;
arr[i].first = x;
arr[i].second = h;
}
if (n < 3) return n;
sort(arr, arr + n, compare);
long long int dp[3][n];
dp[0][0] = 0;
dp[1][0] = 1;
dp[2][0] = 0;
if (arr[1].first >= arr[0].first + arr[0].second) {
dp[2][0] = 1;
}
for (long long int i = 1; i < n - 1; i++) {
dp[0][i] = max(dp[0][i - 1], max(dp[1][i - 1], dp[2][i - 1]));
dp[1][i] = dp[0][i];
dp[2][i] = dp[0][i];
if (arr[i].first - arr[i].second > arr[i - 1].first) {
dp[1][i] = max(dp[1][i], dp[1][i - 1] + 1);
if (arr[i].first - arr[i].second >
(arr[i - 1].first + arr[i - 1].second)) {
dp[1][i] = max(dp[1][i], dp[2][i - 1] + 1);
}
}
if (arr[i].first + arr[i].second < arr[i + 1].first) {
dp[2][i] = max(dp[2][i], max(dp[1][i - 1], dp[2][i - 1]) + 1);
}
}
return max(dp[0][n - 2], max(dp[1][n - 2], dp[2][n - 2])) + 1;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t = 1;
for (long long int w = 1; w <= t; w++) {
long long int num = solve();
cout << num << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> x(n);
vector<int> h(n);
if (n == 1) {
cout << 1 << endl;
} else {
cin >> x[0] >> h[0];
int answer = 1;
int at = 1;
int left = x[0];
cin >> x[1] >> h[1];
for (int i = 1; i < n - 1; i++) {
cin >> x[i + 1] >> h[i + 1];
if (x[i] - h[i] > left) {
left = x[i];
answer++;
} else if (x[i] + h[i] < x[i + 1]) {
left = x[i] + h[i];
answer++;
} else {
left = x[i];
}
}
answer++;
cout << answer << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
int pos[maxn], dis[maxn];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &pos[i], &dis[i]);
}
if (n == 1) {
printf("1\n");
return 0;
}
int ans = 2;
for (int i = 2; i < n; i++) {
if (dis[i] < pos[i] - pos[i - 1]) {
ans++;
continue;
}
if (dis[i] < pos[i + 1] - pos[i]) {
ans++;
pos[i] += dis[i];
continue;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.);
const double eps = 1e-15;
const int MOD = 1e9 + 7;
long long power(long long x, long long y) {
if (y == 0) return 1;
long long s = power(x, y / 2);
s %= MOD;
if (y & 1) s *= x;
return s;
}
long long Ceil(long long x, long long y) { return (x + y - 1) / y; }
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool isprime(int n) {
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return 0;
return 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<pair<int, int> > a(n);
for (int i = 0; i < n; i++) {
int x, h;
cin >> x >> h;
a[i] = {x, h};
}
int res = min(2, n);
int occupied = 0;
for (int i = 1; i < n - 1; i++) {
int x = a[i].first, h = a[i].second;
int diff = x - a[i - 1].first;
if (h < diff - occupied)
res++, occupied = 0;
else if (h < a[i + 1].first - x)
res++, occupied = h;
else
occupied = 0;
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int A[n];
int H[n];
int count;
if (n >= 2) {
count = 2;
} else
count = 1;
for (int i = 0; i < n; i++) {
cin >> A[i] >> H[i];
}
long long s = 0;
int index = -2;
for (int i = 1; i < n - 1; i++) {
int d1 = A[i] - A[i - 1];
int d2 = A[i + 1] - A[i];
if (index + 1 != i) {
s = 0;
}
if (H[i] < d1 - s) {
count++;
} else if (H[i] >= d1 - s && H[i] < d2) {
count++;
s = H[i];
index = i;
} else {
continue;
}
}
cout << count;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
vector<pair<long long int, long long int>> v;
for (long long int i = 0; i < n; i++) {
long long int x, y;
cin >> x >> y;
v.push_back(make_pair(x, y));
}
if (n >= 3) {
long long int ans = 2;
long long int var = 0;
for (long long int i = n - 2; i > 0; i--) {
long long int lr = v[i + 1].first - v[i].first - 1 - var;
long long int ur = v[i].first - v[i - 1].first - 1;
if (lr >= v[i].second) {
ans++;
var = 0;
} else if (ur >= v[i].second) {
ans++;
var = v[i].second;
} else
var = 0;
}
cout << ans << "\n";
} else
cout << n << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[100002], b[100002], ret = 2;
int main() {
cin >> n;
cin >> a[0] >> b[0];
for (int i = 1; i < n; i++) cin >> a[i] >> b[i];
for (int i = 1; i < n - 1; i++) {
if (a[i] - b[i] > a[i - 1])
ret++;
else {
if (a[i] + b[i] < a[i + 1]) {
ret++;
a[i] = a[i] + b[i];
}
}
}
if (n == 1) ret--;
cout << ret;
}
|
#include <bits/stdc++.h>
using namespace std;
struct tree {
int x, h;
};
int main() {
int n;
cin >> n;
vector<tree> t(n);
for (int i = 0; i < n; i++) {
cin >> t[i].x >> t[i].h;
}
if (n == 1) {
cout << 1;
return 0;
}
int now = t[0].x;
int a = 1;
for (int i = 1; i < n - 1; i++) {
if (t[i].x - t[i].h > now) {
now = t[i].x;
a++;
} else if (t[i].x + t[i].h < t[i + 1].x) {
now = t[i].x + t[i].h;
a++;
} else {
now = t[i].x;
}
}
cout << a + 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 0;
int n, k, x, t;
string s;
vector<pair<int, int>> v;
int main() {
scanf("%d", &n);
for (int i = 0, a, b; i < n; i++) {
scanf("%d%d", &a, &b);
v.push_back({a, b});
}
int prevL = v[0].first;
int stay[100005], left[100005], right[100005];
memset(stay, 0, sizeof stay);
memset(left, 0, sizeof left);
memset(right, 0, sizeof right);
for (int i = 1; i < n - 1; i++) {
stay[i] = right[i] = max(left[i - 1], max(stay[i - 1], right[i - 1]));
if (v[i].first - v[i].second <= v[i - 1].first) {
left[i] = stay[i];
} else {
if (v[i].first - v[i].second > v[i - 1].first + v[i - 1].second)
left[i] = stay[i] + 1;
else
left[i] = max(left[i - 1], stay[i - 1]) + 1;
}
if (v[i].first + v[i].second < v[i + 1].first) {
right[i]++;
}
}
if (n == 1) {
printf("1\n");
} else
printf("%d\n", max(left[n - 2], max(right[n - 2], stay[n - 2])) + 2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x[n], h[n];
for (int i = 0; i < n; i++) {
cin >> x[i] >> h[i];
}
int ans = (n == 1) ? 1 : 2;
for (int i = 1; i < n - 1; i++) {
if (x[i] - h[i] > x[i - 1]) {
ans++;
} else if (x[i] + h[i] < x[i + 1]) {
ans++;
x[i] += h[i];
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(vector<long long int> a, vector<long long int> b) {
return a[0] > b[0];
}
bool sortfirst(pair<long long int, char> a, pair<long long int, char> b) {
return a.first > b.first;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return (a / gcd(a, b)) * b;
}
bool isPowerOfTwo(long long int n) {
if (n == 0) return false;
return (ceil(log2(n)) == floor(log2(n)));
}
double sumOfGP(double a, double r, long long int n) {
double sum = 0;
for (long long int i = 0; i < n; i++) {
sum = sum + a;
a = a * r;
}
return sum;
}
bool check(string s) {
stack<char> st;
for (long long int i = 0; i < s.length(); i++) {
if (s[i] == '(')
st.push('(');
else {
if (st.empty()) {
return false;
} else
st.pop();
}
}
if (st.empty())
return true;
else
return false;
}
long long int mod = 1e9 + 7;
bool iszero(string a) {
for (long long int i = 0; i < a.length(); i++) {
if (a[i] == '1') return false;
}
return true;
}
long long int fac(long long int n) {
if (n <= 0) return 1;
return (n * fac(n - 1)) % mod;
}
long long int calSumGP(long long int a, long long int r, long long int n) {
long long int sum = 0, temp = a % mod;
for (long long int i = 1; i < n; i++) {
sum = sum + temp;
temp = (temp * r) % mod;
}
return sum % mod;
}
bool checksort(long long int a[], long long int n) {
for (long long int i = 1; i < n; i++) {
if (a[i] < a[i - 1]) return false;
}
return true;
}
long long int mxN = 1e6 + 5;
bool checksq(long long int n) {
long long int t = sqrt(n);
if (t * t == n) return true;
return false;
}
long long int rec(long long int a[], long long int n, long long int i,
long long int sum) {
long long int mx = 0;
sum += a[i];
if (i + 1 < n && sum >= 0) {
for (long long int k = i + 1; k < n; k++) {
if (k < n && sum + a[k] >= 0) mx = max(mx, (1 + rec(a, n, k, sum)));
}
}
return mx;
}
bool checkPrime(long long int n) {
for (long long int i = 2; i <= sqrt(n); i++)
if (n % i == 0) return false;
return true;
}
long long int countDigit(long long int n) { return floor(log10(n) + 1); }
const long long int size = 4e5 + 7;
vector<long long int> adj[size];
bool vis[size];
void dfs(int node) {
vis[node] = true;
for (auto it : adj[node]) {
if (!vis[it]) dfs(it);
}
}
void solve() {
long long int n;
cin >> n;
vector<pair<long long int, long long int>> vp;
while (n--) {
long long int x, y;
cin >> x >> y;
vp.push_back({x, y});
}
if (vp.size() == 1) {
cout << 1;
return;
}
long long int cnt = 0;
for (long long int i = 1; i + 1 < vp.size(); i++) {
if ((vp[i].first - vp[i].second) > vp[i - 1].first) {
cnt++;
} else if ((vp[i].first + vp[i].second) < vp[i + 1].first) {
cnt++;
vp[i].first += vp[i].second;
}
}
if (vp.size() >= 2) cnt += 2;
cout << cnt;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
t = 1;
while (t--) {
long long int n;
cin >> n;
pair<long long int, long long int> a[n];
for (int i = 0; i < n; i++) {
long long int x, y;
cin >> x >> y;
a[i] = {x, y};
}
if (n == 1 || n == 2) {
cout << n << endl;
return 0;
}
long long int ans = 2;
for (int i = 1; i < n - 1; i++) {
if ((a[i].first - a[i].second) > a[i - 1].first) {
ans++;
} else if ((a[i].first + a[i].second) < a[i + 1].first) {
ans++;
a[i].first = a[i].first + a[i].second;
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000007;
const int N = 2e5 + 10;
const double eps = 1e-6;
int dp[N][3];
long long x[N];
long long h[N];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> x[i] >> h[i];
memset((dp), (0), sizeof(dp));
dp[0][1] = 1;
dp[0][2] = 1;
for (int i = 1; i < n; i++) {
if (x[i - 1] + h[i - 1] >= x[i]) {
dp[i][2] = dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]);
dp[i][2]++;
} else {
dp[i][2] = dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][1], dp[i - 1][2]));
dp[i][2]++;
}
if (x[i - 1] + h[i] < x[i]) {
dp[i][1] = max(dp[i - 1][0], dp[i - 1][1]);
if (x[i - 1] + h[i - 1] + h[i] < x[i])
dp[i][1] = max(dp[i][1], dp[i - 1][2]);
dp[i][1]++;
}
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2])) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, i, x[100005], h[100005], ans;
int main() {
cin >> n;
for (i = 0; i < n; i++) cin >> x[i] >> h[i];
if (n == 1) {
cout << "1" << endl;
return 0;
}
ans = 2;
for (i = 1; i < n - 1; i++) {
if ((x[i] - h[i]) > x[i - 1])
ans++;
else if ((x[i] + h[i]) < x[i + 1]) {
ans++;
x[i] = x[i] + h[i];
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[200100];
pair<int, int> a[200100];
int main(void) {
int n;
dp[1] = 1;
dp[2] = 1;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i].first >> a[i].second;
for (int i = 3; i < 2 * n; i += 2) {
int ptr = (i + 1) / 2;
if (((long long)a[ptr].first - a[ptr].second) >
((long long)a[ptr - 1].first + a[ptr - 1].second))
dp[i] = dp[i - 1] + 1;
else if (((long long)a[ptr].first - a[ptr].second) >
(long long)a[ptr - 1].first)
dp[i] = max(dp[i - 1], dp[i - 2] + 1);
else if ((long long)a[ptr].first >
((long long)a[ptr - 1].first + a[ptr - 1].second))
dp[i] = dp[i - 1];
else
dp[i] = dp[i - 2];
if ((long long)a[ptr].first >
((long long)a[ptr - 1].first + a[ptr - 1].second))
dp[i + 1] = max(dp[i - 1] + 1, dp[i - 2] + 1);
else
dp[i + 1] = dp[i - 2] + 1;
}
cout << dp[2 * n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<pair<int, int> > v(n);
for (int i = 0; i < n; i++) cin >> v[i].first >> v[i].second;
long long int ans = 1;
int prev = 0;
for (int i = 1; i < n - 1; i++) {
if (abs(v[i].first - v[i - 1].first - prev) > v[i].second) {
ans++;
prev = 0;
} else if (abs(v[i + 1].first - v[i].first) > v[i].second) {
ans++;
prev = v[i].second;
} else
prev = 0;
}
if (n > 1) ans++;
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<int, int>> v;
int x, y;
int i, j;
for (i = 0; i < n; i++) {
cin >> x >> y;
v.push_back(make_pair(x, y));
}
sort(v.begin(), v.end());
int ans = 1;
for (i = 1; i < n - 1; i++) {
if (v[i].first - v[i].second > v[i - 1].first)
ans++;
else if (v[i].first + v[i].second < v[i + 1].first) {
ans++;
v[i].first = v[i].first + v[i].second;
}
}
if (n > 1) ans++;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<pair<int, int>> coor(n + 10);
for (int i = 1; i <= n; ++i) {
cin >> coor[i].first >> coor[i].second;
}
sort(coor.begin() + 1, coor.begin() + 1 + n);
coor[0] = {-2e9 + 10, 0};
coor[n + 1] = {2e9 + 10, 0};
int answer = 0;
for (int i = 1; i <= n; ++i) {
if (coor[i].first - coor[i].second > coor[i - 1].first) {
++answer;
} else if (coor[i].first + coor[i].second < coor[i + 1].first) {
++answer;
coor[i].first += coor[i].second;
}
}
cout << answer;
}
|
#include <bits/stdc++.h>
using namespace std;
int Set(int mask, int pos) { return mask = mask | (1 << pos); }
bool check(int mask, int pos) { return (bool)(mask & (1 << pos)); }
int dp[200005][2];
int h[200005], x[200005];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x[i] >> h[i];
}
dp[0][0] = 1, dp[0][1] = 0;
for (int i = 1; i < n; i++) {
dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]);
if (x[i] - h[i] > x[i - 1]) dp[i][0] = dp[i - 1][0] + 1;
if (x[i] - h[i] > x[i - 1] + h[i - 1])
dp[i][0] = max(dp[i][0], dp[i - 1][1] + 1);
if (i == n - 1 || x[i] + h[i] < x[i + 1]) {
dp[i][1] = max(dp[i - 1][0] + 1, dp[i - 1][1] + 1);
}
}
cout << max(dp[n - 1][0], dp[n - 1][1]) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<pair<int, int>> v;
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
v.push_back({x, y});
}
int ans = min(2, n);
int temp = v[0].first;
for (int i = 1; i < n - 1; i++) {
if (v[i].first - v[i].second > temp) {
temp = v[i].first;
ans++;
} else if (v[i].first + v[i].second < v[i + 1].first) {
temp = v[i].first + v[i].second;
ans++;
} else {
temp = v[i].first;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
int main() {
cin >> N;
vector<pair<long long, long long> > tree;
for (int i = 0; i < N; i++) {
long long x, h;
cin >> x >> h;
tree.push_back(make_pair(x, h));
}
int ans = min(2, N);
for (int i = 1; i < N - 1; i++) {
if (tree[i - 1].first + tree[i].second < tree[i].first) {
ans++;
} else if (tree[i].first + tree[i].second < tree[i + 1].first) {
ans++;
tree[i].first += tree[i].second;
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long arr[100002][2];
for (int i = 0; i < n; i++) {
cin >> arr[i][0] >> arr[i][1];
}
long long ans = 2;
if (n == 1)
ans = 1;
else if (n == 2)
ans = 2;
else {
long long left_most = arr[0][0], right_most;
for (int i = 1; i < n - 1; i++) {
right_most = arr[i + 1][0];
if (arr[i][0] - arr[i][1] > left_most) {
ans++;
left_most = arr[i][0];
} else if (arr[i][0] + arr[i][1] < arr[i + 1][0]) {
ans++;
left_most = arr[i][0] + arr[i][1];
} else {
left_most = arr[i][0];
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long arr[n], arr1[n], height[n];
cin >> arr[0] >> height[0];
arr1[0] = arr[0];
for (int i = 1; i < n; i++) {
cin >> arr[i] >> height[i];
arr1[i] = arr[i] - arr[i - 1];
}
if (n == 1)
cout << 1 << endl;
else {
int sum = 0;
for (int i = 1; i < n - 1; i++) {
if (height[i] < arr1[i]) {
arr1[i] = arr1[i] - height[i];
sum++;
} else if (height[i] < arr1[i + 1]) {
arr1[i + 1] = arr1[i + 1] - height[i];
sum++;
} else
continue;
}
cout << sum + 2 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100010], b[100010];
int ans;
int main() {
cin >> n;
if (n == 1) {
cout << 1;
return 0;
}
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
}
for (int i = 2; i < n; i++) {
if (a[i] - b[i] > a[i - 1]) {
ans++;
} else if (a[i] + b[i] < a[i + 1]) {
ans++;
a[i] = a[i] + b[i];
}
}
cout << ans + 2;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long b, long long e) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b, e / 2);
return power(b * b, e / 2);
}
long long power(long long b, long long e, long long m) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b % m, e / 2, m) % m;
return power(b * b % m, e / 2, m);
}
bool sortinrev(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.first);
}
long long modinv(long long a, long long m) { return power(a, m - 2, m); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
for (long long int g = 0; g < t; g++) {
long long int n, x, y, ans = 2;
cin >> n;
vector<pair<long long int, long long int>> v;
for (long long int i = 0; i < n; i++) {
cin >> x >> y;
v.push_back(make_pair(x, y));
}
if (n == 1) {
cout << 1;
return 0;
}
for (long long int i = 1; i < (int)v.size() - 1; i++) {
if (v[i].first - v[i].second > v[i - 1].first)
ans++;
else if (v[i].first + v[i].second < v[i + 1].first) {
ans++;
v[i].first = v[i].first + v[i].second;
}
}
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<pair<int, int>> vec(n);
for (auto& p : vec) cin >> p.first >> p.second;
vector<bool> fell(n, false);
fell[0] = true;
int ans = 1;
for (int i = 1; i < n; i++) {
if (fell[i - 1] == true) {
if (vec[i].first - vec[i].second > vec[i - 1].first) {
ans++;
fell[i] = true;
} else if ((i == n - 1) ||
vec[i + 1].first > vec[i].first + vec[i].second)
ans++;
else
fell[i] = true;
} else {
if (vec[i].first - vec[i].second > vec[i - 1].first + vec[i - 1].second) {
ans++;
fell[i] = true;
} else if ((i == n - 1) ||
vec[i + 1].first > vec[i].first + vec[i].second)
ans++;
else
fell[i] = true;
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool vowel(char che) {
if (che == 'A' || che == 'E' || che == 'I' || che == 'O' || che == 'U' ||
che == 'Y') {
return true;
} else {
return false;
}
}
const long long mod = 1e9 + 7;
long long pw(long long a, long long b) {
long long ans = 1;
while (b) {
if (b % 2 == 1) {
ans *= a;
ans %= mod;
}
b /= 2;
a *= a;
a %= mod;
}
return ans;
}
const int N = 1e6 + 5;
pair<long long, long long> p[N];
stack<int> sk;
string s, s1;
char o;
bool mark[N], h;
vector<long long> vt[N], vm, vs;
set<long long> st;
long long a[N], b[N], c[N], d[N], dp[N][3], dis, ps[N], tree, v[N];
void dfs(long long v, long long k) {}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t, n, m, k = 0, f = 0, sum = 0, ans = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
dp[0][2] = 0;
dp[0][0] = 1;
if ((a[1] - a[0]) > b[0]) dp[0][1] = 1;
long long mx = 1, mx1 = 1;
a[n] = 1e17;
for (int i = 1; i < n; i++) {
dp[i][2] = mx;
if ((a[i + 1] - a[i]) > b[i]) dp[i][1] = mx + 1;
if ((a[i] - a[i - 1]) > (b[i] + b[i - 1]))
dp[i][0] = mx + 1;
else if ((a[i] - a[i - 1]) > b[i])
dp[i][0] = mx1 + 1;
mx = max(mx, max(dp[i][0], max(dp[i][1], dp[i][2])));
mx1 = max(mx1, max(dp[i][0], max(dp[i - 1][1], dp[i][2])));
}
cout << mx << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
const int INF = 0x3f3f3f3f;
int main() {
int n;
scanf("%d", &n);
int preCur = -INF, preH = 0, cur, h, ans = 0;
bool isLeft = 1;
while (n--) {
scanf("%d %d", &cur, &h);
if (!isLeft && preCur + preH < cur) ++ans, preCur += preH;
isLeft = 0;
if (cur - h > preCur) ++ans, ++isLeft;
preCur = cur, preH = h;
}
if (!isLeft) ++ans;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> x(n);
vector<long long> h(n);
for (long long i = 0; i < n; i++) {
cin >> x[i] >> h[i];
}
vector<long long> f_back(n, 0);
vector<long long> f_not(n, 0);
vector<long long> f_front(n, 0);
f_back[0] = 1;
f_not[0] = 0;
if (n == 1 || (n > 1 && x[1] - x[0] - 1 >= h[0])) {
f_front[0] = 1;
}
for (long long i = 1; i < n; i++) {
f_not[i] = max(max(f_not[i - 1], f_front[i - 1]), f_back[i - 1]);
if (x[i] - x[i - 1] - 1 >= h[i])
f_back[i] = max(f_back[i], max(f_not[i - 1], f_back[i - 1])) + 1;
if (x[i] - x[i - 1] - 1 >= h[i] + h[i - 1])
f_back[i] = max(f_back[i], f_front[i - 1] + 1);
if (i == n - 1 || (i < n - 1 && x[i + 1] - x[i] - 1 >= h[i]))
f_front[i] = max(f_back[i - 1], max(f_front[i - 1], f_not[i - 1])) + 1;
}
cout << max(max(f_front[n - 1], f_back[n - 1]), f_not[n - 1]);
cin >> n;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, x[100000], h[100000], count = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &x[i], &h[i]);
}
int position = -1000000000;
for (int i = 0; i < n; i++) {
if (x[i] - h[i] > position) {
position = x[i];
count++;
} else {
if (i < n - 1 && x[i] + h[i] < x[i + 1] || i == n - 1) {
position = x[i] + h[i];
count++;
} else
position = x[i];
}
}
printf("%d", count);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[100100];
int i, n, ans, d;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d%d", &a[i].first, &a[i].second);
sort(a + 1, a + 1 + n);
d = -9999999999;
ans = 0;
for (i = 1; i <= n; i++) {
if (a[i].first - a[i].second > d) {
ans++;
d = a[i].first;
} else if (i == n || a[i].first + a[i].second < a[i + 1].first) {
ans++;
d = a[i].first + a[i].second;
} else
d = a[i].first;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, INF = 0x3f3f3f3f;
int first[N], h[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &first[i], &h[i]);
if (n == 1) {
puts("1");
return 0;
}
int ans = 2, now = 0;
for (int i = 2; i < n; i++) {
now = max(now, first[i - 1]);
if (first[i] - h[i] > now)
ans++;
else if (first[i] + h[i] < first[i + 1]) {
now = first[i] + h[i];
ans++;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void sf(int &x) { scanf("%d", &x); }
void sf(long long &x) { scanf("%lld", &x); }
void sf(long long &x, long long &y) { scanf("%lld%lld", &x, &y); }
void sf(float &x) { scanf("%f", &x); }
void sf(double &x) { scanf("%lf", &x); }
void sf(int &x, int &y) { scanf("%d%d", &x, &y); }
void sf(float &x, float &y) { scanf("%f%f", &x, &y); }
void sf(double &x, double &y) { scanf("%lf%lf", &x, &y); }
void sf(double &x, double &y, double &z) { scanf("%lf%lf%lf", &x, &y, &z); }
void sf(int &x, int &y, int &z) { scanf("%d%d%d", &x, &y, &z); }
void sf(long long &x, long long &y, long long &z) {
scanf("%lld%lld%lld", &x, &y, &z);
}
void sf(float &x, float &y, float &z) { scanf("%u%u%u", &x, &y, &z); }
void sf(char &x) { x = getchar(); }
void sf(char *s) { scanf("%s", s); }
void sf(string &s) { cin >> s; }
void pf(int x) { printf("%d\n", x); }
void pf(int x, int y) { printf("%d %d\n", x, y); }
void pf(int x, int y, int z) { printf("%d %d %d\n", x, y, z); }
void pf(long long x) { printf("%lld\n", x); }
void pf(long long x, long long y) { printf("%lld %lld\n", x, y); }
void pf(long long x, long long y, long long z) {
printf("%lld %lld %lld\n", x, y, z);
}
void pf(float x) { printf("%u\n", x); }
void pf(double x) { printf("%.6lf\n", x); }
void pf(double x, double y) { printf("%.5lf %.5lf\n", x, y); }
void pf(char x) { printf("%c\n", x); }
void pf(char *x) { printf("%s\n", x); }
void pf(string x) {
cout << x;
puts("");
}
long long STN(string s) {
long long sm;
stringstream ss(s);
ss >> sm;
return sm;
}
template <class T>
T bigmod(T b, T p, T m) {
if (p == 0) return 1 % m;
T x = b;
T ans = 1;
while (p) {
if (p & 1) ans = (ans * x) % m;
p >>= 1;
x = (x * x) % m;
}
return ans;
}
template <class T>
T gcd(T x, T y) {
if (y == 0) return x;
return gcd(y, x % y);
}
template <typename T>
T POW(T b, T p) {
if (p == 0) return 1;
if (p == 1) return b;
if (p % 2 == 0) {
T s = POW(b, p / 2);
return s * s;
}
return b * POW(b, p - 1);
}
template <typename T>
T modinv(T num, T m) {
return bigmod(num, m - 2, m);
}
template <class T>
string NTS(T Number) {
stringstream ss;
ss << Number;
return ss.str();
}
long long n, a[100009], b[100009];
int main() {
sf(n);
for (int i = 0; i < n; i++) {
sf(a[i], b[i]);
}
if (n <= 2) {
pf(n);
return 0;
}
long long c = a[0], an = 0;
for (int i = 1; i < n - 1; i++) {
if (c < a[i] - b[i]) {
c = a[i];
an++;
} else if (a[i + 1] > a[i] + b[i]) {
c = a[i] + b[i];
an++;
} else {
c = a[i];
}
}
pf(an + 2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct nd {
long long x, h;
} a[123456];
int main() {
long long i, m, n, p, pr, j, l, ck, cnt = 1, stor, r;
scanf("%lld", &pr);
if (pr >= 2) {
cnt = 2;
}
for (i = 0; i < pr; i++) {
scanf("%lld%lld", &a[i].x, &a[i].h);
}
ck = a[0].x;
for (i = 1; i < pr - 1; i++) {
m = a[i].x - a[i].h;
n = a[i].x + a[i].h;
r = a[i + 1].x;
if (ck < m || r > n) {
cnt++;
}
if (ck >= m && r > n) {
ck = n;
} else {
ck = a[i].x;
}
}
printf("%lld\n", cnt);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int x[100010], h[100010];
int main() {
while (cin >> n) {
int ans = 0;
int pre = 0;
for (int i = 0; i < n; ++i) {
cin >> x[i] >> h[i];
}
for (int i = 0; i < n; ++i) {
if (i == 0)
ans++;
else {
if (pre) {
if (h[i] + h[i - 1] + 1 <= x[i] - x[i - 1]) {
ans++;
pre = 0;
} else {
if (i == n - 1 || h[i] + 1 <= x[i + 1] - x[i]) {
ans++;
pre = 1;
} else {
pre = 0;
}
}
} else {
if (h[i] + 1 <= x[i] - x[i - 1]) {
ans++;
} else {
if (i == n - 1 || h[i] + 1 <= x[i + 1] - x[i]) {
ans++;
pre = 1;
} else {
pre = 0;
}
}
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k, n, m, p, t;
cin >> n;
long long int x[100001];
long long int h[100001];
for (i = 0; i < n; i++) {
cin >> x[i] >> h[i];
}
if (n < 3) {
cout << n << endl;
return 0;
}
p = 2;
for (i = 1; i < (n - 1); i++) {
if ((x[i] - h[i]) > x[i - 1]) {
p++;
} else if ((x[i] + h[i]) < x[i + 1]) {
p++;
x[i] = x[i] + h[i];
}
}
cout << p << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int trees;
cin >> trees;
int ans = 0;
int x, y;
vector<int> height;
vector<int> location;
for (int i = 0; i < trees; i++) {
cin >> x >> y;
location.push_back(x);
height.push_back(y);
}
int it = 0;
for (int i = 0; i < trees; i++) {
if (i == 0) {
it = location[i];
ans++;
} else if (i == trees - 1) {
ans++;
} else if (location[i] - it > height[i]) {
it = location[i];
ans++;
} else if (location[i + 1] - location[i] > height[i]) {
it = location[i] + height[i];
ans++;
} else {
it = location[i];
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
string itosm(long long x) {
if (x == 0) return "0";
string ans = "";
while (x > 0) {
ans += ((x % 10) + '0');
x /= 10;
}
reverse(ans.begin(), ans.end());
return ans;
}
long long stoim(string str) {
long long ans = 0;
long long k = 1;
for (int i = str.length() - 1; i >= 0; i--) {
ans += (str[i] - '0') * k;
k *= 10;
}
return ans;
}
const long long infll = 1e18 + 3;
const int inf = 1009000999;
const double eps = 1e-6;
const int maxn = 2e5 + 7777;
const int baseint = 1000200013;
const long long basell = 1e18 + 3;
const long double PI = acos(-1.0);
const int mod = 1e9 + 7;
pair<int, int> a[maxn];
int dp[maxn][2];
int main() {
srand(228228);
ios_base::sync_with_stdio(0);
;
int n;
cin >> n;
for (int i = (0); i < (n); i++) cin >> a[i].first >> a[i].second;
a[n].first = 2e9 + 1;
dp[0][0] = 1;
if (a[0].first + a[0].second < a[1].first) dp[0][1] = 1;
for (int i = (1); i < (n); i++) {
if (a[i].first - a[i].second > a[i - 1].first) dp[i][0] = dp[i - 1][0] + 1;
if (a[i].first - a[i].second - a[i - 1].second > a[i - 1].first)
dp[i][0] = max(dp[i][0], dp[i - 1][1] + 1);
if (a[i].first + a[i].second < a[i + 1].first)
dp[i][1] = max(dp[i - 1][0], dp[i - 1][1]) + 1;
dp[i][0] = max(dp[i][0], dp[i - 1][0]);
if (a[i].first - a[i - 1].second > a[i - 1].first)
dp[i][0] = max(dp[i][0], dp[i - 1][1]);
}
cout << max(dp[n - 1][0], dp[n - 1][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1e6 + 9;
pair<int, int> sweep[Maxn];
int x[Maxn], h[Maxn];
int main(void) {
int n;
cin >> n;
int last = -1e9 - 10;
int ans = 0, ed = 0;
for (int i = 0; i < n; i++) {
cin >> x[i] >> h[i];
}
for (int i = 0; i < n; i++) {
if (i == n - 1 || x[i + 1] > x[i] + h[i]) {
sweep[ed++] = make_pair(x[i] + h[i], x[i]);
}
if (!i || x[i - 1] < x[i] - h[i])
sweep[ed++] = make_pair(x[i], x[i] - h[i]);
}
sort(sweep, sweep + ed);
for (int i = 0; i < ed; i++) {
int r = sweep[i].first, l = sweep[i].second;
if (l > last) {
ans++;
last = r;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Tree {
long long x, height;
bool operator<(const Tree& b) const { return x < b.x; }
} q[105005];
const long long INF = 0x3f3f3f3f3f3f3f3f;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld%lld", &q[i].x, &q[i].height);
}
sort(q + 1, q + 1 + n);
q[0].x = -INF;
q[n + 1].x = INF;
int res = 0;
for (int i = 1; i <= n; i++) {
if (q[i].x - q[i].height > q[i - 1].x) {
res++;
continue;
}
if (q[i].x + q[i].height < q[i + 1].x) {
q[i].x += q[i].height;
res++;
}
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, x, h, i, c = 2, p = 0, q;
cin >> n;
vector<pair<int, int> > vec;
for (i = 0; i < n; i++) {
cin >> x >> h;
vec.push_back(make_pair(x, h));
}
for (i = 1; i < n - 1; i++) {
if ((vec[i].first - vec[i].second) > vec[i - 1].first &&
(vec[i].first - vec[i].second) > p) {
c++;
} else if ((vec[i].first + vec[i].second) < vec[i + 1].first) {
c++;
p = (vec[i].first + vec[i].second);
}
}
if (n == 1)
cout << "1" << endl;
else
cout << c << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 1;
cin >> n;
pair<long long, long long> t[n];
for (int i = 0; i < n; i++) cin >> t[i].first >> t[i].second;
for (int i = 1; i < n - 1; i++) {
if (t[i].first - t[i].second > t[i - 1].first)
ans++;
else if (t[i].first + t[i].second < t[i + 1].first)
t[i].first += t[i].second, ans++;
}
if (n != 1) ans++;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int _I() {
int x;
scanf("%d", &x);
return x;
}
struct node {
int a, b;
node(){};
node(int a, int b) {
this->a = a;
this->b = b;
}
bool operator<(const node &R) const { return b > R.b; }
};
vector<pair<int, int> > arr;
int n;
int dp[100005];
int goo(int idx, int last) {
if (idx == n) return 0;
if (dp[idx] != -1) return dp[idx];
int ans = 0;
if (arr[idx].first - arr[idx].second > last) {
ans = max(ans, goo(idx + 1, arr[idx].first) + 1);
}
if (arr[idx].first > last &&
arr[idx].first + arr[idx].second < arr[idx + 1].first) {
ans = max(ans, goo(idx + 1, arr[idx].first + arr[idx].second) + 1);
}
ans = max(ans, goo(idx + 1, max(last, arr[idx].first)));
return dp[idx] = ans;
}
void solve() {
n = _I();
for (int i = 0; i < n; i++) {
int a = _I();
int b = _I();
arr.push_back({a, b});
}
arr.push_back({INT_MAX, INT_MAX});
sort(arr.begin(), arr.end());
memset(dp, -1, sizeof(dp));
printf("%d\n", goo(0, INT_MIN));
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int mod = 1e9 + 7;
ll pwr(ll a, ll b);
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> x(n), h(n);
for (int i = 0; i < n; i++) cin >> x[i] >> h[i];
if (n <= 2) {
cout << n << "\n";
return 0;
}
int dp[3][n + 5];
memset(dp, 0, sizeof dp);
for (int i = 1; i < n - 1; i++) {
if (x[i - 1] + h[i - 1] < x[i] - h[i])
dp[0][i] = 1 + max(dp[0][i - 1], max(dp[1][i - 1], dp[2][i - 1]));
else if (x[i - 1] < x[i] - h[i])
dp[0][i] = 1 + max(dp[0][i - 1], dp[1][i - 1]);
dp[1][i] = max(dp[0][i - 1], max(dp[1][i - 1], dp[2][i - 1]));
if (x[i] + h[i] < x[i + 1]) {
dp[2][i] = dp[1][i] + 1;
}
}
cout << 2 + max(dp[0][n - 2], max(dp[1][n - 2], dp[2][n - 2])) << "\n";
}
ll pwr(ll a, ll b) {
a %= mod;
ll res = 1;
while (b > 0) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
long long x[123456] = {0}, h[123456] = {0}, dp[123456][3] = {0};
long long n, ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x[i] >> h[i];
}
x[0] = x[1] - h[1] - 1;
x[n + 1] = x[n] + h[n] + 1;
for (int i = 1; i <= n; i++) {
dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][1], dp[i - 1][2]));
dp[i][1] = dp[i][2] = -1;
if (x[i] - h[i] > x[i - 1]) dp[i][1] = max(dp[i - 1][0], dp[i - 1][1]) + 1;
if (x[i] - h[i] > x[i - 1] + h[i - 1])
dp[i][1] = max(dp[i][1], dp[i - 1][2] + 1);
if (x[i] + h[i] < x[i + 1]) {
dp[i][2] = max(dp[i - 1][0], dp[i - 1][1]) + 1;
if (x[i - 1] + h[i - 1] < x[i])
dp[i][2] = max(dp[i][2], dp[i - 1][2] + 1);
}
ans = max(ans, max(dp[i][0], max(dp[i][1], dp[i][2])));
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x[n], h[n], i;
for (i = 0; i < n; i++) cin >> x[i] >> h[i];
int cnt = 1;
int l = x[0];
for (i = 1; i < n - 1; i++) {
if (x[i] - h[i] > l) {
l = x[i];
cnt++;
} else if (x[i] + h[i] < x[i + 1]) {
cnt++;
l = x[i] + h[i];
} else {
l = x[i];
}
}
if (n > 1) cnt++;
cout << cnt;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, count = 1;
cin >> n;
int coord[n];
long long ht[n];
for (int i = 0; i < n; i++) {
cin >> coord[i] >> ht[i];
}
for (int i = 1; i < n - 1; i++) {
if (coord[i] - ht[i] > coord[i - 1])
count++;
else if (coord[i] + ht[i] < coord[i + 1]) {
count++;
coord[i] = coord[i] + ht[i];
}
}
if (n > 1) count++;
cout << count;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int x[n], h[n];
for (int i = 0; i < n; i++) scanf("%d %d", &x[i], &h[i]);
if (n < 2) {
printf("%d", n);
return 0;
}
int ans = 2;
for (int i = 1; i < n - 1; i++) {
if (x[i] - h[i] > x[i - 1])
ans++;
else if (x[i] + h[i] < x[i + 1]) {
x[i] = x[i] + h[i];
ans++;
}
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> a) {
out << a.first << " " << a.second;
return out;
}
template <typename T, typename T1>
T amax(T& a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T& a, T1 b) {
if (b < a) a = b;
return a;
}
const long long INF = 1e18;
const int32_t M = 1e9 + 7;
const int32_t MM = 998244353;
long long int pw(long long int a, long long int p = M - 2,
long long int MOD = M) {
long long int result = 1;
while (p > 0) {
if (p & 1) result = a * result % MOD;
a = a * a % MOD;
p >>= 1;
}
return result;
}
const long long int N = 100005;
long long int x[N], h[N];
long long int dp[N][2];
void richierich() {
long long int n;
cin >> n;
for (long long int i = 1; i < n + 1; i++) {
cin >> x[i] >> h[i];
}
dp[1][0] = 1;
dp[1][1] = (x[1] + h[1]) < x[2] ? 1 : 0;
for (long long int i = 2; i < n + 1; i++) {
dp[i][0] = max(dp[i - 1][0] + ((x[i] - h[i]) > x[i - 1]),
dp[i - 1][1] + ((x[i] - h[i]) > (x[i - 1] + h[i - 1])));
if (i == n) continue;
dp[i][1] = max(dp[i - 1][0] + ((x[i] + h[i]) < (x[i + 1])),
dp[i - 1][1] + ((x[i] + h[i]) < (x[i + 1])));
}
dp[n][1] = max(dp[n - 1][0] + 1, dp[n - 1][1] + 1);
cout << max(dp[n][0], dp[n][1]) << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
while (t--) richierich();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int mod = 1e9 + 7;
bool comparator(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first == b.first)
return a.second < b.second;
else
return a.first < b.first;
}
long long exp(long long a, long long b) {
long long ans = 1;
while (b != 0) {
if (b % 2) ans = ans * a;
a = a * a;
b /= 2;
}
return ans;
}
long long x[MAXN];
long long h[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
for (long long i = (long long)0; i < (long long)n; i++) {
cin >> x[i] >> h[i];
}
long long ans = 0;
if (n == 1)
ans++;
else
ans += 2;
long long pre = x[0];
for (long long i = (long long)1; i < (long long)n - 1; i++) {
if (x[i] - pre - 1 >= h[i]) {
pre = x[i];
ans++;
} else if (x[i + 1] - x[i] - 1 >= h[i]) {
ans++;
pre = x[i] + h[i];
} else {
pre = x[i];
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long c, i, j, k, l, n, x1, x2, y;
vector<long long> v;
unordered_map<long long, long long> m;
cin >> n;
i = 0;
while (i < n) {
cin >> k;
v.push_back(k);
cin >> k;
m[v[i]] = k;
i++;
}
i = 1;
c = 1;
while (i < n - 1) {
x1 = v[i] - v[i - 1];
x2 = v[i + 1] - v[i];
y = m[v[i]];
if (x1 > y) {
c++;
} else {
if (x2 > y) {
c++;
v[i] = v[i] + m[v[i]];
}
}
i++;
}
if (n > 1) {
c++;
}
cout << c;
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int x[n];
int h[n];
int o[n];
int trees = 1;
if (n == 1) {
printf("1\n");
return 0;
}
for (int i = 0; i < (n); i++) {
scanf("%d %d", &(x[i]), &(h[i]));
o[i] = 0;
}
o[0] = -1;
for (int i = 1; i < n - 1; i++) {
if (x[i] - h[i] > x[i - 1] + o[i - 1] * h[i - 1] &&
x[i] - h[i] > x[i - 1]) {
trees++;
o[i] = -1;
} else {
if (x[i] + h[i] < x[i + 1]) {
o[i] = 1;
trees++;
} else {
if (x[i] - h[i] > x[i - 1]) {
o[i] = -1;
}
}
}
}
trees++;
printf("%d\n", trees);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int a, x[100001], h[100001], i, j, dp[100001][3];
int main() {
scanf("%d", &a);
for (i = 1; i <= a; i++) {
scanf("%d%d", &x[i], &h[i]);
}
dp[1][1] = 1;
x[a + 1] = 9999999999999999ll;
x[0] = -99999999999999999ll;
if (x[1] + h[1] < x[2]) dp[1][2] = 1;
for (i = 2; i <= a; i++) {
if (x[i] - h[i] > x[i - 1])
dp[i][1] = dp[i - 1][1] + 1;
else
dp[i][1] = dp[i - 1][1];
if (x[i] - h[i] > x[i - 1] + h[i - 1])
dp[i][1] = max(dp[i][1], dp[i - 1][2] + 1);
else
dp[i][1] = max(dp[i][1], dp[i - 1][2]);
if (x[i] + h[i] < x[i + 1])
dp[i][2] = max(dp[i - 1][1], dp[i - 1][2]) + 1;
else
dp[i][2] = max(dp[i - 1][1], dp[i - 1][2]);
}
cout << max(dp[a][1], dp[a][2]);
}
|
#include <bits/stdc++.h>
using namespace std;
int maxFellTrees(const vector<long long int> &t,
const vector<long long int> &h) {
long long int maxNum = 0;
int size = t.size();
vector<long long int> fellTree(size);
for (size_t i = 0; i < size; i++) {
if (i == 0) {
maxNum++;
fellTree[i] = t[i];
continue;
}
if (i == size - 1) {
maxNum++;
continue;
}
if (t[i] - h[i] > max(fellTree[i - 1], t[i - 1])) {
fellTree[i] = t[i] - h[i];
maxNum++;
} else if (t[i] + h[i] < t[i + 1]) {
fellTree[i] = t[i] + h[i];
maxNum++;
}
}
return maxNum;
}
int main(int argc, char const *argv[]) {
int n;
cin >> n;
vector<long long int> trees(n);
vector<long long int> heights(n);
for (int i = 0; i < n; i++) {
cin >> trees[i];
cin >> heights[i];
}
cout << maxFellTrees(trees, heights) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long bigmod(long long a, long long b, long long m) {
if (b == 0) return 1 % m;
long long first = bigmod(a, b / 2, m);
first = (first * first) % m;
if (b % 2 == 1) first = (first * a) % m;
return first;
}
int fx[] = {0, 0, -1, 1, -1, 1, -1, 1};
int fy[] = {1, -1, 0, 0, 1, 1, -1, -1};
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
long long a[n + 1][2];
int i;
for (i = 0; i < n; i++) {
cin >> a[i][0] >> a[i][1];
}
a[n][0] = LONG_LONG_MAX;
int temp = a[0][0], ans = 1;
for (i = 1; i < n; i++) {
if (a[i][0] - a[i][1] > temp)
ans++, temp = a[i][0];
else if (a[i][0] + a[i][1] < a[i + 1][0])
ans++, temp = a[i][0] + a[i][1];
else
temp = a[i][0];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long x[(int)1e5 + 1], h[(int)1e5 + 1], n;
long long mem[(int)1e5 + 1];
long long cut(int i, long long left, long long right) {
if (i >= n) return 0;
if (mem[i] != -1) return mem[i];
int ans1 = 0, ans2 = 0, ans3 = 0;
if (x[i] - h[i] > right) ans1 = 1 + cut(i + 1, x[i] - h[i], x[i]);
if (i + 1 < n) {
if (x[i] + h[i] < x[i + 1]) ans2 = 1 + cut(i + 1, x[i], x[i] + h[i]);
}
ans3 = cut(i + 1, x[i], x[i]);
if (i == n - 1) return 1;
return mem[i] = max({ans1, ans2, ans3});
}
int main() {
memset(mem, -1, sizeof(mem));
cin >> n;
for (int i = 0; i < n; i++) cin >> x[i] >> h[i];
cout << cut(1, x[0], x[0]) + 1 << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 1e9 + 100;
const long long int maxn = 1e5 + 100;
vector<pair<long long int, long long int> > v;
long long int n;
long long int dp[maxn];
long long int ans(long long int x, long long int T) {
if (x == n - 1) return 1;
if (x > (n - 1)) return 0;
if (x == 0) {
return (ans(x + 1, v[x].first) + 1);
}
if (v[x].first - v[x].second > T) return (ans(x + 1, v[x].first) + 1);
if (dp[x]) {
return dp[x];
}
long long int P = ans(x + 1, v[x].first);
if (v[x].first + v[x].second < v[x + 1].first) {
long long int Q = (ans(x + 1, v[x].first + v[x].second) + 1);
dp[x] = max(P, Q);
return max(P, Q);
} else {
dp[x] = P;
return P;
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
long long int x, h;
cin >> x >> h;
v.push_back(make_pair(x, h));
}
cout << ans(0, -10000);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
pair<int, int> arr[MAXN];
int dp[MAXN][2];
int dpL(int i) {
int x1 = arr[i - 1].first, x = arr[i].first, h1 = arr[i - 1].second,
h = arr[i].second;
if (x - x1 <= h) {
return max(dp[i - 1][0], dp[i - 1][1]);
}
if (x - x1 > h + h1) {
return max(dp[i - 1][0] + 1, dp[i - 1][1] + 1);
} else {
return max(dp[i - 1][0] + 1, dp[i - 1][1]);
}
}
int dpR(int i) {
if (arr[i + 1].first - arr[i].first > arr[i].second)
return max(dp[i - 1][0], dp[i - 1][1]) + 1;
return dp[i][0];
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i].first >> arr[i].second;
}
if (n == 1) {
cout << 1 << endl;
return 0;
}
sort(arr, arr + n);
dp[0][0] = 1;
dp[0][1] = (arr[1].first - arr[0].first > arr[0].second);
for (int i = 1; i < n - 1; i++) {
dp[i][0] = dpL(i);
dp[i][1] = dpR(i);
}
cout << max(dp[n - 2][0], dp[n - 2][1]) + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x[100005], h[100005];
cin >> n;
for (int i = 0; i < n; ++i) cin >> x[i] >> h[i];
int count = 1;
int newarr[100005];
newarr[1] = x[0] - h[0];
for (int i = 1; i < n - 1; ++i) {
if ((x[i] - h[i] > x[i - 1]) && (x[i] - h[i] > newarr[count])) {
count++;
newarr[count] = x[i] - h[i];
} else if (x[i] + h[i] < x[i + 1]) {
count++;
newarr[count] = x[i] + h[i];
} else
continue;
}
if (n == 1)
puts("1");
else
cout << count + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 7;
const int MOD = 1e6 + 9;
void solve() {
long long n;
cin >> n;
long long x[n + 100], h[n + 100];
for (int i = 0; i < n; i++) cin >> x[i] >> h[i];
if (n == 1) {
cout << 1 << endl;
return;
}
long long ans = 2;
for (int i = 1; i < n - 1; i++) {
if (x[i] - h[i] > x[i - 1]) {
ans++;
} else if (x[i] + h[i] < x[i + 1]) {
ans++;
x[i] += h[i];
}
}
cout << ans << endl;
}
int main() {
long long t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long binpow(long long base, long long exp) {
long long mod = 1000000007LL;
long long res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base) % mod;
exp = exp >> 1;
base = (base * base) % mod;
}
return res;
}
long long mod(long long x) {
return ((x % 1000000007LL + 1000000007LL) % 1000000007LL);
}
long long add(long long a, long long b) { return mod(mod(a) + mod(b)); }
long long mul(long long a, long long b) { return mod(mod(a) * mod(b)); }
bool isPrime(long long n) {
if (n <= 1) return false;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
const long long N = (long long)1e6;
void sieve(long long N) {
bool prime[N + 1];
memset(prime, true, sizeof(prime));
for (long long p = 2; p * p <= N; p++) {
if (prime[p] == true) {
for (long long i = p * p; i <= N; i += p) prime[i] = false;
}
}
}
long long fact(long long n) {
long long res = 1;
for (long long i = 1; i <= n; i++) {
res = res * 1ll * i % 1000000007LL;
}
return res;
}
long long C(long long n, long long k) {
return fact(n) * 1ll * binpow(fact(k), 1000000007LL - 2) % 1000000007LL *
1ll * binpow(fact(n - k), 1000000007LL - 2) % 1000000007LL;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, i, c = 1, prev = INT_MIN;
cin >> n;
vector<pair<long long, long long> > v(n);
for (i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
}
for (i = 0; i < n - 1; i++) {
if (v[i].second < abs(prev - v[i].first)) {
c++;
prev = v[i].first;
} else if (v[i].first + v[i].second < v[i + 1].first) {
c++;
prev = v[i].first + v[i].second;
} else {
prev = v[i].first;
}
}
cout << c << "\n";
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, c = 0;
std::cin >> n;
for (int x1 = -(1 << 30), h1 = 0, x, h; std::cin >> x >> h;
++c, x1 = x, h1 = h) {
if (x1 + h1 >= x) --c, h1 = 0;
if (x - h > x1 + h1) h = 0;
}
std::cout << c << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<pair<int, int> > v;
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
v.push_back(make_pair(x, y));
}
int prev = v[0].first;
int fell = 2;
for (int i = 1; i < n - 1; i++) {
if (prev < v[i].first - v[i].second) {
fell++;
prev = v[i].first;
} else if (v[i + 1].first > v[i].first + v[i].second) {
fell++;
prev = v[i].first + v[i].second;
} else {
prev = v[i].first;
}
}
if (n == 1)
cout << "1";
else
cout << fell << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 2;
cin >> n;
int x[n + 10], h[n + 10];
for (int i = 0; i < n; i++) {
cin >> x[i] >> h[i];
}
for (int i = 1; i < n - 1; i++) {
if (x[i] - x[i - 1] > h[i]) {
ans++;
} else if (x[i + 1] - x[i] > h[i]) {
ans++;
x[i] += h[i];
}
}
cout << (n == 1 ? 1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")
inline void RI(int &x) {
char c;
while ((c = getchar()) < '0' || c > '9')
;
x = c - '0';
while ((c = getchar()) >= '0' && c <= '9') x = (x << 3) + (x << 1) + c - '0';
}
inline void Out(int a) {
if (a > 9) Out(a / 10);
putchar(a % 10 + '0');
}
const int inf = 0x3f3f3f3f;
const double pi = acos(-1.0);
const double dnf = 1e18;
const double eps = 1e-12;
const long long mod = 1000000007;
const int maxn = 200010;
const int maxk = 110;
int n;
int x[maxn], h[maxn], dp[maxn][3];
int main() {
while (cin >> n) {
for (int i = 1; i <= n; i++) scanf("%d%d", &x[i], &h[i]);
memset(dp, -inf, sizeof(dp));
dp[1][0] = dp[1][1] = dp[1][2] = 1;
for (int i = 2; i <= n; i++) {
if (x[i] - h[i] > x[i - 1] + h[i - 1])
dp[i][0] = max(dp[i][0], dp[i - 1][2] + 1);
if (x[i] - h[i] > x[i - 1]) {
dp[i][0] = max(dp[i][0], dp[i - 1][0] + 1);
dp[i][0] = max(dp[i][0], dp[i - 1][1] + 1);
}
if (x[i] > x[i - 1] + h[i - 1]) dp[i][1] = max(dp[i][1], dp[i - 1][2]);
dp[i][1] = max(dp[i][1], dp[i - 1][0]);
dp[i][1] = max(dp[i][1], dp[i - 1][1]);
if (x[i] > x[i - 1] + h[i - 1])
dp[i][2] = max(dp[i][2], dp[i - 1][2] + 1);
dp[i][2] = max(dp[i][2], dp[i - 1][0] + 1);
dp[i][2] = max(dp[i][2], dp[i - 1][1] + 1);
}
int ans = 0;
for (int i = 0; i < 3; i++) ans = max(ans, dp[n][i]);
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s = 1;
cin >> n;
long long x[n], h[n];
for (int i = 0; i < n; i++) cin >> x[i] >> h[i];
for (int i = 1; i < n; i++) {
if (x[i] - x[i - 1] > h[i])
s++;
else if (x[i + 1] - x[i] > h[i]) {
s++;
x[i] = x[i] + h[i];
}
}
cout << s;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int x, h, prevx, prevh;
cin >> n;
vector<long long> dpl(n, 0);
vector<long long> dpn(n, 0);
vector<long long> dpr(n, 0);
for (int i = 0; i < n; ++i) {
cin >> x >> h;
if (i == 0) {
dpl[0] = dpr[0] = 1;
dpn[0] = 0;
} else {
if (x - prevx > h)
dpl[i] = max(dpl[i - 1], dpn[i - 1]) + 1;
else {
dpl[i] = 0;
if (x - prevx <= prevh) dpr[i - 1] = 0;
}
if (x - prevx > h + prevh) dpl[i] = max(dpr[i - 1] + 1, dpl[i]);
dpr[i] = max(dpl[i - 1], dpn[i - 1]) + 1;
if (x - prevx > prevh) {
dpn[i] = max(max(dpr[i - 1], dpn[i - 1]), dpl[i - 1]);
dpr[i] = max(dpr[i], dpr[i - 1] + 1);
} else {
dpn[i] = max(dpn[i - 1], dpl[i - 1]);
}
}
prevx = x;
prevh = h;
}
cout << max(max(dpl[n - 1], dpn[n - 1]), dpr[n - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> xi;
vector<long long int> hi;
int main() {
long long int n, x, h, ans = 1, temp, temp1, curr, i;
scanf("%lld", &n);
for (i = 0; i < n; i++) {
scanf("%lld %lld", &x, &h);
xi.push_back(x);
hi.push_back(h);
}
curr = xi[0];
for (i = 1; i < n; i++) {
temp = xi[i] - hi[i];
temp1 = xi[i] + hi[i];
if (temp > curr) {
ans++;
curr = xi[i];
} else {
if (i + 1 < n && temp1 < xi[i + 1]) {
ans++;
curr = temp1;
} else {
if (i + 1 == n) ans++;
curr = xi[i];
}
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mx = 1e5 + 5;
pair<long long, long long> a[mx];
long long n, s = 1;
bool c[mx];
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
memset(c, 0, sizeof(c));
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].first >> a[i].second;
}
a[n + 1].first = 1e15;
sort(a + 1, a + n + 1);
for (int i = 2; i <= n; i++) {
if (c[i - 1]) {
if (a[i - 1].first + a[i - 1].second < a[i].first - a[i].second)
s++;
else if (a[i].first + a[i].second < a[i + 1].first) {
c[i] = true;
s++;
}
} else {
if (a[i].first - a[i].second > a[i - 1].first)
s++;
else if (a[i].first + a[i].second < a[i + 1].first) {
c[i] = true;
s++;
}
}
}
cout << s;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, count1, l_b, count2;
cin >> n;
long long p[n], h[n];
for (i = 0; i < n; i++) {
cin >> p[i] >> h[i];
}
count1 = 1;
l_b = p[0];
for (i = 1; i < n - 1; i++) {
if (l_b < p[i] - h[i]) {
count1++;
l_b = p[i];
} else if (p[i + 1] > p[i] + h[i]) {
count1++;
l_b = p[i] + h[i];
} else {
l_b = p[i];
}
}
count2 = 1;
l_b = p[n - 1];
for (i = n - 2; i > 0; i--) {
if (l_b > p[i] + h[i]) {
count2++;
l_b = p[i];
} else if (p[i - 1] < p[i] - h[i]) {
count2++;
l_b = p[i] - h[i];
} else {
l_b = p[i];
}
}
if (n > 2) {
cout << max(count1 + 1, count2 + 1);
} else {
cout << n;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int x[100005], h[100005];
int main() {
ifstream fin("date.in");
ofstream fout("date.out");
int n, i, last, sol = 0;
cin >> n;
for (i = 1; i <= n; ++i) cin >> x[i] >> h[i];
last = -2000000010;
x[n + 1] = 2000000010;
for (i = 1; i <= n; ++i)
if (x[i] - h[i] > last) {
last = x[i];
++sol;
} else if (x[i] + h[i] < x[i + 1]) {
++sol;
last = x[i] + h[i];
} else {
last = x[i];
}
cout << sol;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, dp[100001][2], x[100001], h[100001];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> x[i] >> h[i];
dp[1][0] = 1;
if (x[1] + h[1] < x[2]) dp[1][1] = 1;
x[n + 1] = 1000000000000009;
for (int i = 2; i <= n; i++) {
dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]);
dp[i][1] = max(dp[i - 1][0], dp[i - 1][1]);
if (x[i] - h[i] > x[i - 1]) dp[i][0] = max(dp[i][0], dp[i - 1][0] + 1);
if (x[i] - h[i] > x[i - 1] + h[i - 1])
dp[i][0] = max(dp[i][0], dp[i - 1][1] + 1);
if (x[i] + h[i] < x[i + 1]) dp[i][1] = max(dp[i][1], dp[i - 1][0] + 1);
if (x[i - 1] + h[i - 1] < x[i] && x[i] + h[i] < x[i + 1])
dp[i][1] = max(dp[i][1], dp[i - 1][1] + 1);
}
cout << max(dp[n][0], dp[n][1]) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, count;
long long l, u;
scanf("%d", &n);
long long int a[n];
long long int h[n];
for (i = 0; i < n; ++i) {
cin >> a[i] >> h[i];
}
l = a[0];
h[n - 1] = 0;
h[0] = 0;
u = a[n - 1];
if (n > 1) {
count = 2;
for (i = 1; i < n - 1; ++i) {
if (a[i] - h[i] > l) {
count++;
l = a[i];
} else {
if (a[i] + h[i] < a[i + 1]) {
l = a[i] + h[i];
count++;
} else
l = a[i];
}
}
} else
count = 1;
printf("%d\n", count);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int OO = (int)1e12;
const int MAX = (int)1e6;
long long n;
int height[MAX + 1];
int xDistance[MAX + 1];
int mem[MAX + 1][4];
int maxCut(int i, int which_fell, int previous_distance, int previous_height) {
if (i == n) return 0;
int &ret = mem[i][which_fell];
if (ret != -1) return ret;
ret = 0;
if (which_fell == 0 || (i == 0)) {
int distanceLeft = xDistance[i] - height[i];
int distanceRight = xDistance[i] + height[i];
if (distanceLeft > previous_distance) {
ret = max(ret, 1 + maxCut(i + 1, 1, xDistance[i], height[i]));
}
if (distanceRight < xDistance[i + 1] || (i == 0)) {
ret = max(ret, 1 + maxCut(i + 1, 2, xDistance[i], height[i]));
}
ret = max(ret, maxCut(i + 1, 0, xDistance[i], height[i]));
}
if (which_fell == 1 || i == n - 1) {
int distanceLeft = xDistance[i] - height[i];
int distanceRight = xDistance[i] + height[i];
if (distanceLeft > previous_distance || i == 0) {
ret = max(ret, 1 + maxCut(i + 1, 1, xDistance[i], height[i]));
}
if (distanceRight < xDistance[i + 1] || i == n - 1) {
ret = max(ret, 1 + maxCut(i + 1, 2, xDistance[i], height[i]));
}
ret = max(ret, maxCut(i + 1, 0, xDistance[i], height[i]));
}
if (which_fell == 2) {
int distanceLeft = xDistance[i] - height[i];
int distanceRight = xDistance[i] + height[i];
int previous_distance_new = previous_distance + previous_height;
if (distanceLeft > previous_distance_new) {
ret = max(ret, 1 + maxCut(i + 1, 1, xDistance[i], height[i]));
}
if (distanceRight < xDistance[i + 1]) {
ret = max(ret, 1 + maxCut(i + 1, 2, xDistance[i], height[i]));
}
ret = max(ret, maxCut(i + 1, 0, xDistance[i], height[i]));
}
return ret;
}
int main() {
cin >> n;
height[n] = 0;
xDistance[n] = OO;
for (int i = 0; i < n; i++) {
cin >> xDistance[i] >> height[i];
}
memset(mem, -1, sizeof(mem[0][0]) * (MAX + 1) * 4);
cout << maxCut(0, 3, -OO, 0) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long double EPS = 1e-11;
template <class T>
T &chmin(T &a, const T &b) {
return a = min(a, b);
}
template <class T>
T &chmax(T &a, const T &b) {
return a = max(a, b);
}
const int64_t INFLL = 1e18;
int n;
const int MAX_N = 100010;
int64_t x[MAX_N], h[MAX_N];
int ans[2][2];
int main() {
cin >> n;
x[0] = -INFLL;
h[0] = 0;
for (int i = (1); i < (int)(n + 1); ++i) cin >> x[i] >> h[i];
x[n + 1] = INFLL;
h[n + 1] = 0;
for (int i = (1); i < (int)(n + 1); ++i) {
int64_t pl = x[i - 1];
int64_t pr = x[i - 1] + h[i - 1];
int64_t l = x[i] - h[i];
int64_t r = x[i] + h[i];
ans[i & 1][0] = ans[i & 1][1] =
max(ans[(i + 1) & 1][0], ans[(i + 1) & 1][1]);
if (pl < l) chmax(ans[i & 1][0], ans[(i + 1) & 1][0] + 1);
if (pr < l) chmax(ans[i & 1][0], ans[(i + 1) & 1][1] + 1);
if (r < x[i + 1]) ans[i & 1][1]++;
}
cout << max(ans[n & 1][0], ans[n & 1][1]) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
template <typename T>
T gcd(T a, T b) {
return b != 0 ? gcd(b, a % b) : a;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
long long n;
cin >> n;
map<long long, long long> m;
long long a[n];
long long t;
for (int i = 0; i < n; i++) {
cin >> a[i] >> t;
m[a[i]] = t;
}
if (n == 1) {
cout << 1;
return 0;
}
if (n == 2) {
cout << 2;
return 0;
}
long long last = a[0];
long long count = 2;
for (int i = 1; i < n - 1; i++) {
int flag = 0, flag1 = 0;
if (a[i] - last > m[a[i]]) {
last = a[i];
count++;
flag = 1;
}
if (flag == 0) {
if (a[i] + m[a[i]] < a[i + 1]) {
last = a[i] + m[a[i]];
count++;
flag1 = 1;
}
if (flag == 0 && flag1 == 0) {
last = a[i];
}
}
}
cout << count << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, k;
int main() {
int n;
cin >> n;
pair<int, int> a[n], seg[n];
for (i = 0; i < n; ++i) cin >> a[i].first >> a[i].second;
int z = 2;
seg[0] = make_pair(a[0].first - a[0].second, a[0].first);
seg[n - 1] = make_pair(a[n - 1].first, a[n - 1].second + a[n - 1].first);
for (i = 1; i < n - 1; ++i) {
int l = a[i].first - a[i].second, r = a[i].second + a[i].first;
if (l > seg[i - 1].second)
seg[i] = make_pair(l, a[i].first), ++z;
else if (r < a[i + 1].first)
seg[i] = make_pair(a[i].second, r), ++z;
else
seg[i] = make_pair(a[i].first, a[i].first);
}
if (n == 1) z = 1;
cout << z << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<long long, long long>> coll(n);
for (int i = 0; i < n; i++) cin >> coll[i].first >> coll[i].second;
long long ans = 0;
for (int i = 0; i < n; i++) {
if (i == 0)
ans++;
else if (i == n - 1)
ans++;
else if (coll[i].first - coll[i].second > coll[i - 1].first)
ans++;
else if (coll[i].first + coll[i].second < coll[i + 1].first) {
ans++;
coll[i].first += coll[i].second;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, f;
cin >> n;
long long x[n], h[n];
for (i = 0; i < n; i++) cin >> x[i] >> h[i];
if (n == 1)
f = 1;
else if (n == 2)
f = 2;
else {
f = 2;
for (i = 1; i < n - 1; i++) {
if ((x[i] - h[i]) > x[i - 1])
f++;
else if ((x[i] + h[i]) < x[i + 1]) {
f++;
x[i] = x[i] + h[i];
} else
continue;
}
}
cout << f;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.