text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
const ll mod = 998244353;
ll fa[300010];
ll power(ll x, ll y) {
ll res = 1;
while (y) {
if (y % 2) {
res *= x;
res %= mod;
}
y /= 2;
x *= x;
x %= mod;
}
return res;
}
ll inv(ll x) { return power(x, mod - 2); }
ll t(ll f, ll s) { return (fa[f] * inv((fa[s] * fa[f - s]) % mod)) % mod; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
fa[0] = 1;
for (int i = 1; i < 300005; i++) {
fa[i] = i * fa[i - 1];
fa[i] %= mod;
}
int mx = -1;
int n, k;
cin >> n >> k;
vector<pair<int, int>> v;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
v.push_back({x, 0});
v.push_back({y, 1});
}
sort(v.begin(), v.end());
ll ans = 0, cnt = 0;
for (auto [f, s] : v) {
if (s == 0) {
cnt++;
if (cnt >= k) ans += t(cnt - 1, k - 1);
} else {
cnt--;
}
}
cout << (ans + mod) % mod;
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 1e6 + 7;
const long long p = 998244353;
using namespace std;
struct node {
int l, r;
} q[maxn];
bool cmp(node x, node y) {
if (x.l != y.l) return x.l < y.l;
return x.r < y.r;
}
long long jc[maxn], inv[maxn], inj[maxn];
priority_queue<int, vector<int>, greater<int> > q1;
long long C(long long n, long long m) {
long long sum = jc[n];
sum = (1LL * sum * inj[m]) % p;
sum = (1LL * sum * inj[n - m]) % p;
return sum;
}
long long dd(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % p;
a = a * a % p;
b = b >> 1;
}
return ans;
}
int main() {
int n, k, x, y;
scanf("%d%d", &n, &k);
jc[0] = inv[0] = inv[1] = inj[0] = inj[1] = 1;
for (int i = 1; i <= n; i++) jc[i] = (1LL * i * jc[i - 1]) % p;
for (int i = 2; i <= n + k; i++) inv[i] = ((p - p / i) * inv[p % i]) % p;
for (int i = n + k; i >= 1; i--) inj[i] = dd(jc[i], p - 2);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
q[i].l = x;
q[i].r = y;
}
sort(q + 1, q + 1 + n, cmp);
long long maxs = 0, ans = 0;
for (int i = 1; i <= n; i++) {
while (q1.size() && q1.top() < q[i].l) {
q1.pop();
maxs--;
}
q1.push(q[i].r);
maxs++;
if (maxs >= k) {
if (maxs == k) {
ans = (ans + 1) % p;
continue;
} else {
long long sum = C(maxs - 1, k);
long long kk = 1LL * k * inv[maxs - k] % p;
sum = (sum * kk) % p;
ans = (ans + sum) % p;
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int mod = 998244353;
struct M {
unsigned v;
M(long long a = 0) : v((a %= mod) < 0 ? a + mod : a) {}
M& operator+=(M r) {
if ((v += r.v) >= mod) v -= mod;
return *this;
}
M& operator-=(M r) {
if ((v += mod - r.v) >= mod) v -= mod;
return *this;
}
M& operator*=(M r) {
v = (uint64_t)v * r.v % mod;
return *this;
}
};
uint32_t add(M a, M b) { return (a += b).v; }
uint32_t mul(M a, M b) { return (a *= b).v; }
uint32_t sub(M a, M b) { return (a -= b).v; }
constexpr int mm = 3e5 + 3;
int fact[mm], invFact[mm];
void pre() {
fact[0] = invFact[0] = invFact[1] = 1;
for (int i = 1; i < mm; i++) {
fact[i] = mul(fact[i - 1], i);
}
for (int i = 2; i < mm; i++) {
invFact[i] = mul((mod - mod / i), invFact[mod % i]);
}
for (int i = 1; i < mm; i++) {
invFact[i] = mul(invFact[i - 1], invFact[i]);
}
}
int ncr(int n, int r) {
assert(n >= 0 and r >= 0);
if (n < r) return 0;
return mul(mul(fact[n], invFact[r]), invFact[n - r]);
}
void solve() {
int n, k;
cin >> n >> k;
vector<pair<int, int>> v(n);
for (auto& [x, y] : v) {
cin >> x >> y;
}
sort(v.begin(), v.end(), [&](pair<int, int> a, pair<int, int> b) {
return make_pair(a.second, a.first) < make_pair(b.second, b.first);
});
int ans = 0;
multiset<int> st;
for (int i = n - 1; i >= 0; --i) {
int x = v[i].second;
while (!st.empty() && *st.rbegin() > x) {
st.erase(*st.rbegin());
}
int cnt = st.size();
if (cnt >= k - 1) ans = add(ans, ncr(cnt, k - 1));
st.insert(v[i].first);
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
pre();
for (int i = 1; i <= t; ++i) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
std::cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const long long MOD = 998244353;
const long long INFLL = 0x3f3f3f3f3f3f3f3f;
const int INF = 0x3f3f3f3f;
const long long MAXN = 1e+5 + 7;
const int m = 998244353;
const int nax = 1e6;
long long fatorial[nax + 1];
long long binary_pow(long long a, long long b) {
a = a % m;
long long ans = 1;
while (b > 0) {
if (b & 1) {
ans = (ans * a) % m;
}
a = (a * a) % m;
b = b >> 1;
}
return ans;
}
long long modular_inverse(long long a) { return binary_pow(a, m - 2); }
void calcula_fatorial() {
fatorial[0] = 1;
for (int i = 1; i <= nax; i++) {
fatorial[i] = (fatorial[i - 1] * i) % m;
}
}
long long binomial_coefficient(int n, int k) {
return fatorial[n] * modular_inverse(fatorial[k]) % m *
modular_inverse(fatorial[n - k]) % m;
}
void solve() {
long long n, k;
cin >> n >> k;
set<long long> evento;
unordered_map<long long, long long> entrada, saida;
for (int i = 0; i < n; ++i) {
long long a, b;
cin >> a >> b;
evento.insert(a);
evento.insert(b);
entrada[a]++;
saida[b]++;
}
long long ans = 0, sz = 0;
for (auto e : evento) {
sz += entrada[e];
for (int i = 0; i < saida[e]; ++i) {
if (sz - 1 < k - 1) {
sz--;
continue;
}
ans += binomial_coefficient(sz - 1, k - 1);
ans %= m;
sz--;
}
}
cout << ans << '\n';
}
int main() {
calcula_fatorial();
ios_base::sync_with_stdio(0);
cin.tie(0);
long long i, j, n;
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
using ull = uint64_t;
using uint = uint32_t;
using VI = vector<int>;
using VL = vector<ll>;
using VVI = vector<vector<int>>;
using VVL = vector<vector<ll>>;
using PII = pair<int, int>;
using PLL = pair<ll, ll>;
const double PI = acos(-1.0);
namespace Backlight {
const int __BUFFER_SIZE__ = 1 << 20;
bool NEOF = 1;
int __top;
char __buf[__BUFFER_SIZE__], *__p1 = __buf, *__p2 = __buf, __stk[996];
template <typename T>
T MIN(T a, T b) {
return min(a, b);
}
template <typename First, typename... Rest>
First MIN(First f, Rest... r) {
return min(f, MIN(r...));
}
template <typename T>
T MAX(T a, T b) {
return max(a, b);
}
template <typename First, typename... Rest>
First MAX(First f, Rest... r) {
return max(f, MAX(r...));
}
template <typename T>
void updMin(T& a, T b) {
if (a > b) a = b;
}
template <typename T>
void updMax(T& a, T b) {
if (a < b) a = b;
}
inline char nc() {
return __p1 == __p2 && NEOF &&
(__p2 =
(__p1 = __buf) + fread(__buf, 1, __BUFFER_SIZE__, stdin),
__p1 == __p2)
? (NEOF = 0, EOF)
: *__p1++;
}
template <typename T>
inline bool read(T& x) {
char c = nc();
bool f = 0;
x = 0;
while (!isdigit(c)) c == '-' && (f = 1), c = nc();
while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = nc();
if (f) x = -x;
return NEOF;
}
inline bool need(char c) { return (c != '\n') && (c != ' '); }
inline bool read(char& a) {
while ((a = nc()) && need(a) && NEOF)
;
return NEOF;
}
inline bool read(char* a) {
while ((*a = nc()) && need(*a) && NEOF) ++a;
*a = '\0';
return NEOF;
}
inline bool read(double& x) {
bool f = 0;
char c = nc();
x = 0;
while (!isdigit(c)) {
f |= (c == '-');
c = nc();
}
while (isdigit(c)) {
x = x * 10.0 + (c ^ 48);
c = nc();
}
if (c == '.') {
double temp = 1;
c = nc();
while (isdigit(c)) {
temp = temp / 10.0;
x = x + temp * (c ^ 48);
c = nc();
}
}
if (f) x = -x;
return NEOF;
}
template <typename First, typename... Rest>
inline bool read(First& f, Rest&... r) {
read(f);
return read(r...);
}
template <typename T>
inline void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x == 0) {
putchar('0');
return;
}
__top = 0;
while (x) {
__stk[++__top] = x % 10 + '0';
x /= 10;
}
while (__top) {
putchar(__stk[__top]);
--__top;
}
}
template <typename First, typename... Rest>
inline void print(First f, Rest... r) {
print(f);
putchar(' ');
print(r...);
}
template <typename T>
inline void println(T x) {
print(x);
putchar('\n');
}
template <typename First, typename... Rest>
inline void println(First f, Rest... r) {
print(f);
putchar(' ');
println(r...);
}
template <typename T>
inline void _dbg(const char* format, T value) {
cerr << format << '=' << value << endl;
}
template <typename First, typename... Rest>
inline void _dbg(const char* format, First f, Rest... r) {
while (*format != ',') cerr << *format++;
cerr << '=' << f << ", ";
_dbg(format + 1, r...);
}
template <typename T>
ostream& operator<<(ostream& os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << ",";
return os << " ]";
}
template <typename T>
ostream& operator<<(ostream& os, set<T> V) {
os << "[ ";
for (auto v : V) os << v << ",";
return os << " ]";
}
template <typename T>
ostream& operator<<(ostream& os, multiset<T> V) {
os << "[ ";
for (auto v : V) os << v << ",";
return os << " ]";
}
template <typename T1, typename T2>
ostream& operator<<(ostream& os, map<T1, T2> V) {
os << "[ ";
for (auto v : V) os << v << ",";
return os << " ]";
}
template <typename L, typename R>
ostream& operator<<(ostream& os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
} // namespace Backlight
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int l, int r) { return l + rng() % (r - l + 1); }
using namespace Backlight;
const int N = 3e5 + 5;
const int M = 3e6 + 5;
const int K = 1e7 + 5;
const int MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const ll LLINF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-8;
template <typename T>
T inverse(T a, T m) {
T u = 0, v = 1;
while (a != 0) {
T t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T>
class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template <typename U>
Modular(const U& x) {
value = normalize(x);
}
template <typename U>
static Type normalize(const U& x) {
Type v;
if (-mod() <= x && x < mod())
v = static_cast<Type>(x);
else
v = static_cast<Type>(x % mod());
if (v < 0) v += mod();
return v;
}
const Type& operator()() const { return value; }
template <typename U>
explicit operator U() const {
return static_cast<U>(value);
}
constexpr static Type mod() { return T::value; }
Modular& operator+=(const Modular& other) {
if ((value += other.value) >= mod()) value -= mod();
return *this;
}
Modular& operator-=(const Modular& other) {
if ((value -= other.value) < 0) value += mod();
return *this;
}
template <typename U>
Modular& operator+=(const U& other) {
return *this += Modular(other);
}
template <typename U>
Modular& operator-=(const U& other) {
return *this -= Modular(other);
}
Modular& operator++() { return *this += 1; }
Modular& operator--() { return *this -= 1; }
Modular operator++(int) {
Modular result(*this);
*this += 1;
return result;
}
Modular operator--(int) {
Modular result(*this);
*this -= 1;
return result;
}
Modular operator-() const { return Modular(-value); }
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int>::value,
Modular>::type&
operator*=(const Modular& rhs) {
value = normalize(static_cast<int64_t>(value) *
static_cast<int64_t>(rhs.value));
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, long long>::value,
Modular>::type&
operator*=(const Modular& rhs) {
long long q = static_cast<long long>(static_cast<long double>(value) *
rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template <typename U = T>
typename enable_if<!is_integral<typename Modular<U>::Type>::value,
Modular>::type&
operator*=(const Modular& rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular& operator/=(const Modular& other) {
return *this *= Modular(inverse(other.value, mod()));
}
friend const Type& abs(const Modular& x) { return x.value; }
template <typename U>
friend bool operator==(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename V, typename U>
friend V& operator>>(V& stream, Modular<U>& number);
private:
Type value;
};
template <typename T>
bool operator==(const Modular<T>& lhs, const Modular<T>& rhs) {
return lhs.value == rhs.value;
}
template <typename T, typename U>
bool operator==(const Modular<T>& lhs, U rhs) {
return lhs == Modular<T>(rhs);
}
template <typename T, typename U>
bool operator==(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) == rhs;
}
template <typename T>
bool operator!=(const Modular<T>& lhs, const Modular<T>& rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(const Modular<T>& lhs, U rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(U lhs, const Modular<T>& rhs) {
return !(lhs == rhs);
}
template <typename T>
bool operator<(const Modular<T>& lhs, const Modular<T>& rhs) {
return lhs.value < rhs.value;
}
template <typename T>
Modular<T> operator+(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T>
Modular<T> operator-(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T>
Modular<T> operator*(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T>
Modular<T> operator/(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> power(const Modular<T>& a, const U& b) {
assert(b >= 0);
Modular<T> x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1) res *= x;
x *= x;
p >>= 1;
}
return res;
}
template <typename T>
bool IsZero(const Modular<T>& number) {
return number() == 0;
}
template <typename T>
string to_string(const Modular<T>& number) {
return to_string(number());
}
template <typename U, typename T>
U& operator<<(U& stream, const Modular<T>& number) {
return stream << number();
}
template <typename U, typename T>
U& operator>>(U& stream, Modular<T>& number) {
typename common_type<typename Modular<T>::Type, long long>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
const int md = 998244353;
using Mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>;
vector<Mint> fact(1, 1);
vector<Mint> inv_fact(1, 1);
Mint nCk(int n, int k) {
if (k < 0 || k > n) {
return 0;
}
while ((int)fact.size() < n + 1) {
fact.push_back(fact.back() * (int)fact.size());
inv_fact.push_back(1 / fact.back());
}
return fact[n] * inv_fact[k] * inv_fact[n - k];
}
int n, k, L[N], R[N], m, t[N << 1];
void solve(int Case) {
read(n, k);
m = 0;
for (int i = (1); i <= (n); ++i) {
read(L[i], R[i]);
t[++m] = L[i];
t[++m] = R[i];
}
sort(t + 1, t + 1 + m);
m = unique(t + 1, t + 1 + m) - t - 1;
vector<PII> op;
for (int i = (1); i <= (n); ++i) {
L[i] = lower_bound(t + 1, t + 1 + m, L[i]) - t;
R[i] = lower_bound(t + 1, t + 1 + m, R[i]) - t;
op.emplace_back(L[i], 1);
op.emplace_back(R[i] + 1, -1);
}
sort((op).begin(), (op).end());
Mint ans(0);
int cnt = 0;
for (PII p : op) {
if (p.second == -1 && cnt >= k) ans += nCk(cnt - 1, k - 1);
cnt += p.second;
;
}
cout << ans << endl;
}
int main() {
int T = 1;
for (int _ = 1; _ <= T; _++) solve(_);
return 0;
}
|
#include <bits/stdc++.h>
const int MM = 998244353, B = 1 << 21;
using namespace std;
long long tree[B * 2];
long long fac[300005], res;
map<long long, long long> M;
long long inv(long long x) {
long long y = MM - 2;
long long res = 1;
long long pot = x;
while (y) {
if (y & 1) res = res * pot % MM;
pot = pot * pot % MM;
y >>= 1;
}
return res;
}
long long ncr(long long a, long long b) {
if (a < 0 || b < 0 || a - b < 0) return 0;
return fac[a] * inv(fac[b] * fac[a - b] % MM) % MM;
}
pair<long long, long long> t[300005];
long long n, k;
int32_t main() {
srand(chrono::steady_clock::now().time_since_epoch().count());
cin >> n >> k;
fac[0] = 1;
for (long long i = 1; i <= n; i++) {
cin >> t[i].first >> t[i].second;
}
for (long long i = 1; i <= 2 * n; i++) {
fac[i] = (fac[i - 1] * i) % MM;
}
long long X = 0;
sort(t + 1, t + n + 1);
set<pair<long long, long long> > s;
for (long long i = 1; i <= n; i++) {
while (!s.empty() && (*s.begin()).first < t[i].first) s.erase(s.begin());
res += ncr(s.size(), k - 1);
s.insert({t[i].second, i});
if (res >= MM) res -= MM;
}
cout << res << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
long long l[300030];
long long r[300030];
long long sil[300020];
struct wyd {
long long czas;
long long war;
};
wyd t[600020];
bool cmp(const wyd& a, const wyd& b) {
if (a.czas != b.czas) return a.czas < b.czas;
return a.war > b.war;
}
long long spot(long long co, long long doco) {
if (doco == 0) return 1;
if (doco == 1) return co % mod;
if (doco % 2 == 1) {
long long pom = spot(co, doco / 2);
pom *= pom;
pom %= mod;
pom *= co;
return pom % mod;
}
if (doco % 2 == 0) {
long long pom = spot(co, doco / 2);
pom *= pom;
return pom % mod;
}
}
long long dziel(long long co, long long przezco) {
return co * spot(przezco, mod - 2) % mod;
}
void sili() {
sil[0] = 1;
sil[1] = 1;
for (long long i = 2; i < 300001; i++) {
sil[i] = sil[i - 1] * i;
sil[i] %= mod;
}
}
long long dwu(long long g, long long d) {
long long wyn = sil[g];
wyn = dziel(wyn, sil[d]);
wyn = dziel(wyn, sil[g - d]);
return wyn;
}
int main() {
sili();
cin.tie(0);
ios_base::sync_with_stdio(0);
long long n, k;
long long sum = 0;
cin >> n >> k;
long long kk = 0;
for (long long i = 0; i < n; i++) {
long long l, r;
cin >> l >> r;
wyd pom;
pom.war = 1;
pom.czas = l;
t[kk] = pom;
pom.war = -1;
pom.czas = r;
t[kk + 1] = pom;
kk += 2;
}
sort(t, t + kk, cmp);
long long licz = 0;
for (long long i = 0; i < kk; i++) {
if (t[i].war == 1)
licz++;
else {
if (licz >= k) {
sum += dwu(licz - 1, k - 1);
sum %= mod;
}
licz--;
}
}
cout << sum;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int KINF = 0x3f3f3f3f;
const double eps = 1e-7;
const int N = 3e5 + 10;
long long inv[N], fac[N];
int l[N], r[N], sum1[N << 1], sum2[N << 1], d[N << 1];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = (int)0; i < (int)n + 1; ++i)
fac[i] = i ? fac[i - 1] * i % mod : 1;
for (int i = (int)1; i < (int)n + 1; ++i)
inv[i] = i == 1 ? 1 : (mod - mod / i) * inv[mod % i] % mod;
for (int i = (int)0; i < (int)n + 1; ++i)
inv[i] = i ? inv[i - 1] * inv[i] % mod : 1;
int tot = 0;
for (int i = (int)0; i < (int)n; ++i) {
cin >> l[i] >> r[i];
d[tot++] = l[i];
d[tot++] = r[i] + 1;
}
sort(d, d + tot);
tot = unique(d, d + tot) - d;
for (int i = (int)0; i < (int)n; ++i) {
int L = lower_bound(d, d + tot, l[i]) - d;
int R = lower_bound(d, d + tot, r[i] + 1) - d;
sum1[L] += 1;
sum1[R] -= 1;
sum2[L + 1] += 1;
sum2[R] -= 1;
}
for (int i = (int)1; i < (int)tot; ++i) {
sum1[i] += sum1[i - 1];
sum2[i] += sum2[i - 1];
}
long long ans = 0;
for (int i = (int)0; i < (int)tot - 1; ++i) {
if (sum1[i] >= k)
ans += fac[sum1[i]] * inv[k] % mod * inv[sum1[i] - k] % mod;
if (sum2[i] >= k)
ans -= fac[sum2[i]] * inv[k] % mod * inv[sum2[i] - k] % mod;
}
cout << (ans % mod + mod) % mod << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = (int)3e5 + 5;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (res * x) % 998244353;
y = y >> 1;
x = (x * x) % 998244353;
}
return res;
}
long long fac[MAXN];
long long ncr(long long n, long long r) {
if (n < r) return 0;
return (fac[n] * power((fac[r] * fac[n - r]) % 998244353, 998244353 - 2)) %
998244353;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
map<long long, pair<long long, long long> > m;
fac[0] = 1;
for (long long int i = (long long int)1; i < (long long int)n + 1; i++) {
fac[i] = i * fac[i - 1];
fac[i] %= 998244353;
}
for (long long int i = (long long int)0; i < (long long int)n; i++) {
long long l, r;
cin >> l >> r;
m[l].first++;
m[l].second++;
m[r + 1].first--;
}
long long on = 0, ans = 0;
for (auto i : m) {
on += i.second.first;
if (on >= k && i.second.second > 0) {
ans +=
(ncr(on, k) - ncr(on - i.second.second, k) + 998244353) % 998244353;
ans %= 998244353;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
if (0) return;
cout << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
if (0) return;
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const long long N = 3e6 + 7, M = 998244353, inf = INT_MAX;
const long long INF = LLONG_MAX;
inline long long mul(long long a, long long b) { return (1ll * a * b) % M; };
inline long long add(long long a, long long b) {
if (a + b < 0) return a + b + M;
if (a + b >= M) return a + b - M;
return a + b;
}
long long pwrmod(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (1ll * res * a) % M;
a = (1ll * a * a) % M;
b >>= 1;
}
return res;
}
long long fact[N + 2], ifact[N + 2];
void allfact() {
fact[0] = 1;
for (long long i = 1; i <= N; i++) fact[i] = mul(i, fact[i - 1]);
ifact[N] = pwrmod(fact[N], M - 2);
for (long long i = N - 1; i >= 0; i--) ifact[i] = mul(ifact[i + 1], i + 1);
}
long long ncr(long long n1, long long r1) {
if (n1 < r1) return 0;
return mul(mul(fact[n1], ifact[r1]), ifact[n1 - r1]);
}
void compress(vector<pair<long long, long long> >& arr) {
long long n = arr.size();
map<long long, long long> mp;
set<long long> st;
for (long long i = 0; i < (long long)n; i++)
st.insert(arr[i].first), st.insert(arr[i].second);
long long cnt = 0;
for (auto& it : st) mp[it] = cnt++;
for (long long i = 0; i < (long long)n; i++)
arr[i].first = mp[arr[i].first], arr[i].second = mp[arr[i].second];
}
long long arr[N], brr[N];
void solve() {
long long n, k;
cin >> n >> k;
vector<pair<long long, long long> > vec(n);
for (long long i = 0; i < (long long)n; i++)
cin >> vec[i].first >> vec[i].second;
compress(vec);
for (auto& i : vec) arr[i.first]++, brr[i.second + 1]++;
long long ans = 0, cnt = 0;
for (long long i = 0; i < (long long)2 * n + 1; i++) {
if (arr[i] + brr[i] == 0) continue;
if (brr[i]) cnt -= brr[i];
for (long long k1 = 0; k1 < (long long)arr[i]; k1++) {
ans = add(ans, ncr(cnt, k - 1));
cnt++;
}
}
cout << ans << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
allfact();
long long test = 1;
while (test--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 RNG(chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
T ceil(T a, T b) {
return (a + b - 1) / b;
}
template <typename T>
T binpow(T a, T b, T m) {
a %= m;
T res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
const long long MAX_N = 1e6 + 1;
const long long MOD = 998244353;
long long fact[MAX_N], invf[MAX_N];
void precompute() {
fact[0] = invf[0] = 1;
for (long long i = 1; i < MAX_N; i++) {
fact[i] = fact[i - 1] * i % MOD;
invf[i] = binpow(fact[i], MOD - 2, MOD);
}
}
long long nCr(long long n, long long k) {
if (k < 0 || k > n) return 0;
return fact[n] * invf[k] % MOD * invf[n - k] % MOD;
}
void solve() {
long long n, k;
cin >> n >> k;
if (k == 1) {
cout << n << "\n";
return;
}
precompute();
vector<pair<long long, long long>> p;
for (long long i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
p.push_back({a, b});
}
sort((p).begin(), (p).end());
priority_queue<long long, vector<long long>, greater<long long>> pq;
long long res = 0;
for (long long i = 0; i < n; i++) {
if (!pq.empty()) {
while (!pq.empty() and pq.top() < p[i].first) {
pq.pop();
}
long long s = pq.size();
(res += nCr(s, k - 1)) %= MOD;
}
pq.push(p[i].second);
}
cout << res;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t = 1;
for (long long i = 1; i < t + 1; i++) {
solve();
}
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
|
#include <bits/stdc++.h>
const double PI = 3.141592653589793238460;
using namespace std;
long long pows(long long a, long long n, long long m) {
long long res = 1;
while (n) {
if (n % 2 != 0) {
res = (res * a) % m;
n--;
} else {
a = (a * a) % m;
n = n / 2;
}
}
return res % m;
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % 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;
}
bool istrue(string s) {
int i = 0;
int j = s.size() - 1;
while (i < j) {
if (s[i] == s[j]) {
i++;
j--;
} else {
return false;
}
}
return true;
}
long long m = 998244353;
long long fact[300001];
void compute() {
fact[0] = 1;
for (long long i = 1; i <= 300000; i++) {
fact[i] = (fact[i - 1] * i) % m;
}
}
long long cor(long long n, long long k) {
long long r = fact[n];
r = (r * pows(fact[k], m - 2, m) % m) % m;
r = (r * pows(fact[n - k], m - 2, m) % m) % m;
return r;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
compute();
long long n, k;
cin >> n >> k;
vector<pair<long long, long long>> vi;
long long l, r;
for (long long i = 0; i < n; i++) {
cin >> l >> r;
vi.push_back({l, 0});
vi.push_back({r, 1});
}
sort(vi.begin(), vi.end());
long long on = 0;
long long ans = 0;
for (long long i = 0; i < vi.size(); i++) {
if (vi[i].second == 0) {
if (on >= k - 1) {
ans = ans + cor(on, k - 1) % m;
ans = ans % m;
}
on++;
} else {
on--;
}
}
cout << ans % m << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long mod = 998244353;
const int maxm = 1e6 + 5;
const int maxn = 3e5 + 5;
struct node {
int t, val;
bool operator<(const node &_) const { return t < _.t; }
} q[maxm];
vector<int> v;
long long fac[maxn];
long long inv[maxn];
int l[maxn];
int r[maxn];
long long ans;
int n, K;
long long C(int n, int m) {
if (m > n) return 0;
return fac[n] * inv[m] % mod * inv[n - m] % mod;
}
long long fpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
void init() {
ans = 0;
fac[0] = 1;
for (long long i = 1; i < maxn; ++i) fac[i] = fac[i - 1] * i % mod;
inv[maxn - 1] = fpow(fac[maxn - 1], mod - 2);
for (long long i = maxn - 2; i >= 0; --i) inv[i] = (i + 1) * inv[i + 1] % mod;
}
int main() {
init();
v.clear();
scanf("%d%d", &n, &K);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &l[i], &r[i]);
v.push_back(l[i]);
v.push_back(r[i] + 1);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
int k = 0;
for (int i = 1; i <= n; ++i) {
q[++k] = node{l[i], 1};
q[++k] = node{r[i] + 1, -1};
}
sort(q + 1, q + 1 + k);
int id = 1, cnt = 0;
for (auto i : v) {
int pre = cnt, add = 0, sub = 0;
while (id <= k && q[id].t <= i) {
if (q[id].val == 1)
add += 1;
else
sub += 1;
id++;
}
ans = (ans + C(cnt + add - sub, K) - C(cnt - sub, K) + mod) % mod;
cnt += add - sub;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
const int P = 998244353;
int n, k;
struct Node {
int l, r;
bool operator<(const Node& rhs) const {
return l < rhs.l || (l == rhs.l && r < rhs.r);
}
} p[maxn];
int fac[maxn];
int Pow(int a, int b) {
long long sum = 1, z = a;
for (; b; b >>= 1) {
if (b & 1) sum = sum * z % P;
if (b) z = z * z % P;
}
return (int)sum;
}
int inv(int x) { return Pow(x, P - 2); }
int c(int a, int b) {
if (a < b) return 0;
return 1LL * fac[a] * inv(fac[b]) % P * inv(fac[a - b]) % P;
}
multiset<int> s;
int main() {
fac[0] = 1;
for (int i = 1; i < maxn; ++i) fac[i] = 1LL * i * fac[i - 1] % P;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d%d", &p[i].l, &p[i].r);
if (k == 1) {
printf("%d\n", n);
return 0;
}
sort(p + 1, p + n + 1);
s.insert(p[1].r);
long long ans = 0;
for (int i = 2; i <= n; ++i) {
while (!s.empty() && *s.begin() < p[i].l) s.erase(s.begin());
int len = s.size();
ans = (ans + c(len, k - 1)) % P;
s.insert(p[i].r);
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > tim;
long long fac[300005] = {}, ans = 0;
long long power(long long x, long long y) {
long long res = 1;
x = x % 998244353;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % 998244353;
y = y >> 1;
x = (x * x) % 998244353;
}
return res;
}
void calfac(long long n, long long k) {
long long i, j;
fac[k] = 1;
for (i = k + 1; i <= n; i++) {
fac[i] = (fac[i - 1] * i) % 998244353;
fac[i] = (fac[i] * (power(i - k, 998244353 - 2) % 998244353)) % 998244353;
}
}
bool cmp(const pair<long long, long long>& x,
const pair<long long, long long>& y) {
if (x.first != y.first) return x.first < y.first;
return x.second > y.second;
}
int main() {
long long n, k, i, j, x, y, cnt = 0, m;
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> x >> y;
tim.push_back(make_pair(x, i));
tim.push_back(make_pair(y, -i));
}
sort(tim.begin(), tim.end(), cmp);
calfac(n, k - 1);
m = tim.size();
for (i = 0; i < m; i++) {
if (tim[i].second < 0)
cnt--;
else {
cnt++;
if (cnt >= k) ans = (ans + fac[cnt - 1]) % 998244353;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
const long long MOD = 998244353;
const long long INF = 1e18;
const long long MX = 2e5 + 10;
const long long nx[4] = {0, 0, 1, -1}, ny[4] = {1, -1, 0, 0};
template <class T>
using V = vector<T>;
template <class T>
bool ckmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
long long cdiv(long long a, long long b) {
return a / b + ((a ^ b) > 0 && a % b);
}
constexpr long long log2(long long x) { return 31 - __builtin_clz(x); }
void IO() {}
long long modpow(long long x, long long p) {
if (p == 0) return 1;
long long v = modpow(x, p / 2);
v *= v;
v %= MOD;
if (p % 2 == 1) v *= x;
v %= MOD;
return v;
}
long long modinv(long long x) { return modpow(x, MOD - 2); }
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
IO();
long long N, K;
cin >> N >> K;
vector<pair<long long, long long> > vec;
for (long long i = (0); i < (N); ++i) {
long long l, r;
cin >> l >> r;
vec.push_back({l, 1});
vec.push_back({r, 2});
}
sort(begin(vec), end(vec));
long long M = K - 1;
long long C[N + 1];
C[M] = 1;
for (long long i = (M + 1); i < (N + 1); ++i) {
C[i] = C[i - 1] * i;
C[i] %= MOD;
C[i] *= modinv(i - M);
C[i] %= MOD;
}
long long cnt = 0;
long long ans = 0;
for (long long i = (0); i < ((long long)vec.size()); ++i) {
if (vec[i].second == 2) {
cnt--;
continue;
}
cnt++;
if (cnt < K) continue;
ans += C[cnt - 1];
ans %= MOD;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
long long int fact[N], inv[N];
map<long long int, pair<long long int, long long int> > all;
long long int modularExponentiation(long long int x, long long int n) {
long long int result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % 998244353;
x = (x * x) % 998244353;
n = n / 2;
}
return result;
}
long long int nck(long long int n, long long int k) {
if (n < k) return 0;
long long int ans = (fact[n] * inv[k]) % 998244353;
ans = (ans * inv[n - k]) % 998244353;
return ans;
}
void solve() {
long long int n, k;
cin >> n >> k;
for (long long int i = 0, x, y; i < n; i++) {
cin >> x >> y;
all[x].first++;
all[y].second++;
}
long long int ans = 0, crt = 0;
for (auto X : all) {
long long int temp = nck(crt + all[X.first].first, k);
ans = (ans + temp) % 998244353;
temp = nck(crt, k);
ans = (ans - temp + 998244353) % 998244353;
crt += all[X.first].first;
crt -= all[X.first].second;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
srand(time(NULL));
;
int t = 1;
fact[0] = inv[0] = 1;
for (long long int i = 1; i < N; i++) {
fact[i] = (fact[i - 1] * i) % 998244353;
inv[i] = modularExponentiation(fact[i], 998244353 - 2);
}
for (int i = 1; i <= t; i++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 300001, MOD = 998244353;
long long i, n, k, x1, x2, total_cases, fact[MAXN] = {1, 1}, inv[MAXN] = {1, 1};
vector<pair<long long, long long>> lines(MAXN);
multiset<long long> ms;
void precompute() {
for (i = 2; i < MAXN; ++i) {
fact[i] = fact[i - 1] * i % MOD;
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
}
for (i = 2; i < MAXN; ++i) inv[i] = inv[i - 1] * inv[i] % MOD;
}
long long nCk(long long n, long long k) {
if (k < 0 || k > n) return 0;
return fact[n] * inv[n - k] % MOD * inv[k] % MOD;
}
long long intersections() {
sort(lines.begin(), lines.begin() + n);
for (i = 0; i < n; ++i) {
while (!ms.empty() && *ms.begin() < lines[i].first) ms.erase(ms.begin());
total_cases = (total_cases + nCk(ms.size(), k - 1)) % MOD;
ms.insert(lines[i].second);
}
return total_cases;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
precompute();
cin >> n >> k;
for (i = 0; i < n; ++i) {
cin >> x1 >> x2;
lines[i] = {x1, x2};
}
cout << intersections() << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 6e5 + 100;
const long long mod = 998244353;
long long fac[N], inv[N];
int l[N], r[N], tot;
pair<int, int> has[N];
long long qpow(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = (ret * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ret;
}
long long C(int n, int m) {
if (n < m) return 0;
return ((fac[n] * inv[m]) % mod * inv[n - m]) % mod;
}
int main() {
fac[0] = inv[0] = 1;
for (int i = 1; i < N; i++) fac[i] = 1ll * i * fac[i - 1] % mod;
inv[N - 1] = qpow(fac[N - 1], mod - 2);
for (int i = N - 2; i >= 1; i--) inv[i] = inv[i + 1] * 1ll * (i + 1) % mod;
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &l[i], &r[i]);
has[++tot] = make_pair(l[i], 1);
has[++tot] = make_pair(r[i] + 1, -1);
}
sort(has + 1, has + 1 + tot);
long long cnt = 0, ans = 0;
for (int i = 1; i <= tot; i++) {
if (has[i].second == 1) {
ans = (ans + C(cnt, k - 1)) % mod;
}
cnt += has[i].second;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long nax = 3 * 1e5 + 5;
vector<long long int> fac(nax + 1, 0), inv(nax + 1, 0);
long long binpow(long long a, long long b) {
a %= 998244353;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % 998244353;
a = a * a % 998244353;
b >>= 1;
}
return res;
}
long long ncr(long long n, long long r) {
if (n < r) return 0;
return ((fac[n] * inv[r] % 998244353) * inv[n - r]) % 998244353;
}
bool mc(pair<long long int, long long int> p1,
pair<long long int, long long int> p2) {
if (p1.first == p2.first) return p1.second > p2.second;
return p1.first < p2.first;
}
void solve() {
long long n, k;
cin >> n >> k;
vector<pair<long long int, long long int> > a;
for (long long i = 0; i < n; i++) {
long long l, r;
cin >> l >> r;
a.push_back({l, 1});
a.push_back({r + 1, 2});
}
sort(a.begin(), a.end(), mc);
long long cnt = 0, ans = 0;
for (auto it : a) {
if (it.second == 1) {
ans = (ans + ncr(cnt, k - 1)) % 998244353;
cnt++;
} else
cnt--;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(20);
fac[0] = 1;
for (long long i = 1; i <= nax; i++) fac[i] = (fac[i - 1] * i) % 998244353;
inv[nax] = binpow(fac[nax], 998244353 - 2);
for (long long i = nax - 1; i >= 0; i--)
inv[i] = (inv[i + 1] * (i + 1)) % 998244353;
long long t = 1;
while (t--) {
solve();
cout << "\n";
}
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
std::cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const long long MOD = 998244353;
const long long INFLL = 0x3f3f3f3f3f3f3f3f;
const int INF = 0x3f3f3f3f;
const long long MAXN = 1e+5 + 7;
const int m = 998244353;
const int nax = 1e6;
long long fatorial[nax + 1];
long long binary_pow(long long a, long long b) {
a = a % m;
long long ans = 1;
while (b > 0) {
if (b & 1) {
ans = (ans * a) % m;
}
a = (a * a) % m;
b = b >> 1;
}
return ans;
}
long long modular_inverse(long long a) { return binary_pow(a, m - 2); }
void calcula_fatorial() {
fatorial[0] = 1;
for (int i = 1; i <= nax; i++) {
fatorial[i] = (fatorial[i - 1] * i) % m;
}
}
long long binomial_coefficient(int n, int k) {
return fatorial[n] * modular_inverse(fatorial[k]) % m *
modular_inverse(fatorial[n - k]) % m;
}
void solve() {
long long n, k;
cin >> n >> k;
set<long long> evento;
map<long long, long long> entrada, saida;
for (int i = 0; i < n; ++i) {
long long a, b;
cin >> a >> b;
evento.insert(a);
evento.insert(b);
entrada[a]++;
saida[b]++;
}
long long ans = 0, sz = 0;
for (auto e : evento) {
sz += entrada[e];
for (int i = 0; i < saida[e]; ++i) {
if (sz - 1 < k - 1) {
sz--;
continue;
}
ans += binomial_coefficient(sz - 1, k - 1);
ans %= m;
sz--;
}
}
cout << ans << '\n';
}
int main() {
calcula_fatorial();
ios_base::sync_with_stdio(0);
cin.tie(0);
long long i, j, n;
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 998244353;
long long fastpower(long long x, long long n, long long M) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return fastpower((x * x) % M, n / 2, M);
else
return (x * fastpower((x * x) % M, (n - 1) / 2, M)) % M;
}
long long GCD(long long A, long long B) {
if (B == 0)
return A;
else
return GCD(B, A % B);
}
bool vowl(char c) {
return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
}
long long mod(long long A, long long M) { return fastpower(A, M - 2, M); }
void sieve(long long N) {
bool isPrime[N + 1];
for (long long i = 0; i <= N; ++i) {
isPrime[i] = true;
}
isPrime[0] = false;
isPrime[1] = false;
for (long long i = 2; i * i <= N; ++i) {
if (isPrime[i] == true) {
for (long long j = i * i; j <= N; j += i) isPrime[j] = false;
}
}
}
vector<long long> factorize(long long n) {
vector<long long> res;
for (long long i = 2; i * i <= n; ++i) {
while (n % i == 0) {
res.push_back(i);
n /= i;
}
}
if (n != 1) {
res.push_back(n);
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long fact[300005];
fact[0] = 1;
fact[1] = 1;
for (long long i = 2; i <= 300000; i++) {
fact[i] = (fact[i - 1] * i) % M;
}
long long n, k;
cin >> n >> k;
map<long long, long long> m;
map<long long, long long> p;
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
m[x]++;
p[x]++;
m[y + 1]--;
}
long long cont = 0;
for (auto &it : m) {
cont += it.second;
it.second = cont;
}
long long ans = 0;
for (auto u : p) {
auto it = m.find(u.first);
if (it->second >= k) {
ans += (fact[it->second] *
(mod(fact[k], M) * mod(fact[it->second - k], M) % M) % M) %
M;
ans = (ans) % M;
}
long long p = it->second - u.second;
if (p >= k) {
ans -= (fact[p] * (mod(fact[k], M) * mod(fact[p - k], M) % M) % M) % M;
ans = (ans + M) % M;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const long long mod = 998244353;
const long long MaxN = 6e5 + 10;
std::vector<long long> v;
std::pair<long long, long long> a[MaxN];
long long n, m, k, ans, c[MaxN], fac[MaxN], inv[MaxN];
long long lowbit(long long x) { return x & (-x); }
long long C(long long n, long long m) {
if (n > m) return 0;
return ((fac[m] * inv[n]) % mod) * inv[m - n] % mod;
}
void add(long long pos, long long val) {
while (pos <= m) c[pos] += val, pos += lowbit(pos);
}
long long query(long long pos) {
long long ret = 0;
while (pos) ret += c[pos], pos -= lowbit(pos);
return ret;
}
long long read() {
long long x = 0;
char ch = getchar();
while (ch > '9' || ch < '0') ch = getchar();
while (ch <= '9' && ch >= '0')
x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return x;
}
long long fast_pow(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = (ret * a) % mod;
a = (a * a) % mod, b >>= 1;
}
return ret;
}
void prework() {
for (int i = 1; i <= n; i++)
v.push_back(a[i].first), v.push_back(a[i].second);
std::sort(v.begin(), v.end()),
v.erase(std::unique(v.begin(), v.end()), v.end());
for (int i = 1; i <= n; i++) {
a[i].first =
std::lower_bound(v.begin(), v.end(), a[i].first) - v.begin() + 1;
a[i].second =
std::lower_bound(v.begin(), v.end(), a[i].second) - v.begin() + 1;
m = std::max(a[i].first, m), m = std::max(a[i].second, m);
}
inv[0] = fac[0] = 1;
for (int i = 1; i <= 300000; i++) fac[i] = fac[i - 1] * i % mod;
inv[300000] = fast_pow(fac[300000], mod - 2);
for (int i = 299999; ~i; i--) inv[i] = inv[i + 1] * (i + 1) % mod;
}
int main() {
n = read(), k = read();
if (k == 1) return 0 * printf("%lld\n", n);
for (int i = 1; i <= n; i++) a[i].first = read(), a[i].second = read();
std::sort(a + 1, a + n + 1), prework();
for (int i = 1; i <= n; i++) {
long long x = i - 1 - query(a[i].first - 1);
ans = (((ans) + (C(k - 1, x))) % mod), add(a[i].second, 1);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
ll mod = 998244353;
vector<ll> fact;
ll power(ll a, ll b) {
ll result = 1;
while (b > 0) {
if (b % 2) result = (result * a) % mod;
a = (a * a) % mod;
b /= 2;
}
return result;
}
ll combi(ll n, ll r) {
if (n < r) return 0;
ll p = (fact[n - r] * fact[r]) % mod;
ll ans = fact[n];
ans = (ans * power(p, mod - 2)) % mod;
return ans;
}
int main() {
fact.resize(1e6);
fact[0] = 1;
fact[1] = 1;
for (int i = 2; i < 1e6; i++) {
fact[i] = (fact[i - 1] * i) % mod;
}
ll n, k;
cin >> n >> k;
ll ans = 0;
map<ll, ll> m1;
map<ll, ll> m2;
map<ll, ll> m3;
for (ll i = 0; i < n; i++) {
ll x, y;
scanf("%lld %lld", &x, &y);
m2[x]++;
m1[x]++;
m1[y]--;
m3[y]++;
}
ll ct = 0;
ll curr = 0;
ll prev = 0;
for (auto it : m1) {
ct += m2[it.first];
prev = ct - m3[it.first];
if (ct >= k) {
(ans += combi(ct, k)) %= mod;
(ans -= combi(prev, k)) %= mod;
}
ct -= m3[it.first];
}
cout << (ans + mod) % mod << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9 + 7, maxn = 3e5 + 100, mod = 998244353;
long long f[maxn], d[maxn], c[maxn];
long long mood(long long x) {
x %= mod;
x = (x + mod) % mod;
return x;
}
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
return (a.first < b.first);
}
long long binpow(long long a, long long b) {
if (b <= 0) return 1;
long long t = binpow(a, b / 2);
t *= t;
t = mood(t);
if (b % 2) t *= a;
t = mood(t);
return t;
}
void solve() {
long long n, k;
cin >> n >> k;
c[k] = 1;
for (long long i = k + 1; i <= n; ++i) {
c[i] = f[i] * d[i - k];
c[i] = mood(c[i]);
c[i] *= d[k];
c[i] = mood(c[i]);
}
map<long long, long long> a, b;
set<long long> st;
for (long long i = 0; i < n; ++i) {
long long x, y;
cin >> x >> y;
a[x] += 1;
b[y + 1] -= 1;
st.insert(x);
st.insert(y + 1);
}
long long sum = 0, ans = 0;
for (auto i : st) {
sum += b[i];
if (a[i]) {
sum += a[i];
if (sum >= k) {
ans += c[sum];
if (sum >= a[i] + k) ans -= c[sum - a[i]];
ans = mood(ans);
}
}
}
cout << ans;
}
signed main() {
f[0] = 1, d[0] = 1, d[1] = 1;
for (long long i = 1; i <= maxn; ++i) {
f[i] = i * f[i - 1];
f[i] = mood(f[i]);
d[i] = binpow(f[i], mod - 2);
d[i] = mood(d[i]);
}
ios_base::sync_with_stdio(false);
cin.tie(0);
srand(100);
cout << fixed << setprecision(8);
long long t = 1;
while (t--) {
solve();
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long p = 998244353;
long long trans(long long x) {
long long y = p - 2;
long long ans = 1;
for (long long i = 0; y >> i; i++) {
if ((y >> i) & 1) {
ans *= x;
ans %= p;
}
x *= x;
x %= p;
}
return ans;
}
long long f[300111];
struct box {
long long pos;
char flag;
};
vector<box> o;
int main(void) {
long long n, k;
scanf("%lld %lld", &n, &k);
for (long long i = 0; i <= n; i++) {
if (i < k - 1)
f[i] = 0;
else if (i == k - 1)
f[i] = 1;
else {
f[i] = f[i - 1] * (i) % p;
f[i] = f[i] * trans(i - k + 1) % p;
}
}
for (long long i = 0; i < n; i++) {
long long l, r;
scanf("%lld %lld", &l, &r);
o.push_back({l, 'L'});
o.push_back({r, 'R'});
}
sort(o.begin(), o.end(), [](box a, box b) {
if (a.pos == b.pos) return a.flag < b.flag;
return a.pos < b.pos;
});
long long cnt = 0, ans = 0;
for (long long i = 0; i < o.size(); i++) {
if (o[i].flag == 'R')
cnt--;
else {
ans += f[cnt];
ans %= p;
cnt++;
}
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
vector<long long> fact(N);
template <typename T1, typename T2>
void add_self(T1& a, T2 b) {
a += b;
if (a >= 998244353) {
a -= 998244353;
}
}
long long pow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) {
res = (res * a) % 998244353;
}
b >>= 1;
a = (a * a) % 998244353;
}
return res;
}
long long modInverse(long long a) { return pow(a, (long long)998244353 - 2); }
long long nCr(long long n, long long r) {
if (r > n) {
return 0;
}
if (n < r) {
swap(n, r);
}
long long ways = 0;
ways = (modInverse(fact[r]) * modInverse(fact[n - r])) % 998244353;
ways = (ways * fact[n]) % 998244353;
return ways;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed;
cout.precision(10);
fact[0] = 1;
for (int i = 1; i < N; i++) {
fact[i] = (fact[i - 1] * i) % 998244353;
}
int n, k;
cin >> n >> k;
vector<int> l(n);
vector<int> r(n);
for (int i = 0; i < n; i++) {
cin >> l[i] >> r[i];
}
vector<int> order(n);
iota(order.begin(), order.end(), 0);
sort(order.begin(), order.end(), [&](int i, int j) { return l[i] < l[j]; });
long long sol = 0;
multiset<int> s;
for (int i : order) {
while (!s.empty() and *s.begin() < l[i]) {
s.erase(s.begin());
}
int len = (int)s.size();
add_self(sol, nCr(len, k - 1));
s.insert(r[i]);
}
cout << sol;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long fact[1000005];
long long p(long long n, long long k) {
if (k == 0) return 1;
if (k == 1) return n;
long long x = p(n, k / 2) % 998244353;
if (k & 1) return (((x * x) % 998244353) * n) % 998244353;
return (x * x) % 998244353;
}
long long nck(long long n, long long k) {
long long ans = fact[n];
ans = (ans * p(fact[k], 998244353 - 2)) % 998244353;
ans = (ans * p(fact[n - k], 998244353 - 2)) % 998244353;
return ans;
}
void solve() {
cin >> n >> k;
map<long long, long long> add, rem;
pair<long long, long long> a[n];
vector<pair<long long, long long>> ops;
for (long long i = 0; i < n; ++i) {
long long l, r;
cin >> l >> r;
a[i].first = l, a[i].second = r;
add[l]++;
rem[r]++;
ops.push_back({l, 0});
ops.push_back({r, 1});
}
sort(a, a + n);
sort(ops.begin(), ops.end());
long long c = 0;
long long ans = 0;
for (long long i = 0; i < ops.size(); ++i) {
if (ops[i].second == 0) {
c++;
if (c >= k) {
ans = (ans + nck(c - 1, k - 1)) % 998244353;
}
} else
c--;
}
cout << ans << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long T = 1;
fact[0] = 1;
for (long long i = 1; i < 1000005; ++i) {
fact[i] = (i * fact[i - 1]) % 998244353;
}
for (long long i = 1; i <= T; ++i) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int64_t st[300005], ed[300005];
vector<int64_t> rec;
vector<int64_t> mn;
int64_t fact[300005];
int64_t revmod[300005];
int64_t N;
int64_t power(int64_t a, int64_t M) {
if (M == 0) return 1;
int64_t tmp = power(a, M / 2);
tmp = (tmp * tmp) % 998244353;
if (M % 2 == 0) {
return tmp;
} else {
return (tmp * a) % 998244353;
}
}
void calc() {
fact[0] = 1;
revmod[0] = 1;
for (int i = 1; i <= N; i++) fact[i] = (fact[i - 1] * i) % 998244353;
for (int i = 1; i <= N; i++) {
revmod[i] = power(fact[i], 998244353 - 2);
}
}
int64_t C(int64_t k, int64_t n) {
if (k == 0) return 1;
if (k > n || k < 0) return 0;
return (((fact[n] * revmod[n - k]) % 998244353) * revmod[k]) % 998244353;
}
int main() {
int64_t cur = 0;
int64_t k;
cin >> N >> k;
int64_t sum = 0;
for (int i = 0; i < N; i++) {
cin >> st[i] >> ed[i];
rec.push_back(st[i]);
rec.push_back(ed[i]);
if (st[i] > ed[i]) cur++;
}
sort(rec.begin(), rec.end());
sort(st, st + N);
sort(ed, ed + N);
calc();
int s = 0, t = 0;
for (int i = 0; i < rec.size(); i++) {
if (s < N && rec[i] == st[s]) {
sum = (sum + C(k - 1, cur)) % 998244353;
cur++;
s++;
continue;
}
if (t < N && rec[i] == ed[t]) {
cur--;
t++;
}
}
cout << sum;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
const int mod = 998244353;
pair<int, int> a[N];
int fact[N];
int invf[N];
void solve() {
int n, k;
scanf("%d%d", &n, &k);
vector<pair<int, int> > e;
for (int i = 0; i < n; ++i) {
scanf("%d%d", &a[i].first, &a[i].second);
e.push_back(pair<int, int>(a[i].first, 0));
e.push_back(pair<int, int>(a[i].second, 1));
}
fact[0] = fact[1] = 1;
for (int i = 2; i <= n; ++i) fact[i] = fact[i - 1] * 1ll * i % mod;
invf[0] = invf[1] = 1;
for (int i = 2; i <= n; ++i) {
invf[i] = (mod - invf[mod % i] * 1ll * (mod / i) % mod) % mod;
}
for (int i = 2; i <= n; ++i) {
invf[i] = invf[i - 1] * 1ll * invf[i] % mod;
}
sort(e.begin(), e.end());
int ans = 0;
int curcnt = 0;
for (int i = 0; i < e.size(); ++i) {
if (e[i].second == 0) {
if (curcnt >= k - 1) {
ans = (ans + fact[curcnt] * 1ll * invf[k - 1] % mod *
invf[curcnt - (k - 1)]) %
mod;
}
curcnt++;
}
if (e[i].second == 1) {
curcnt--;
}
}
printf("%d\n", ans);
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int Mod = 998244353;
int fact[300005];
int mult(long long a, long long b) {
a *= b;
a %= Mod;
return a;
}
int n, k;
vector<pair<int, int> > pts;
unsigned long long power(unsigned long long x, int y, int p) {
unsigned long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
unsigned long long modInverse(unsigned long long n, int p) {
return power(n, p - 2, p);
}
unsigned long long ncr(unsigned long long n, int r, int p) {
if (r == 0) return 1;
return (fact[n] * modInverse(fact[r], p) % p * modInverse(fact[n - r], p) %
p) %
p;
}
int solve() {
int on = 0;
long long ans = 0;
for (int i = 0; i < pts.size(); i++) {
if (pts[i].second == 0) {
if (on >= k - 1) {
ans += ncr(on, k - 1, Mod);
ans %= Mod;
}
on++;
} else {
on--;
}
}
return ans;
}
int main() {
cin >> n >> k;
fact[0] = fact[1] = 1;
for (int i = 1; i < 300001; i++) {
fact[i] = mult(i, fact[i - 1]);
}
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
pts.push_back({a, 0});
pts.push_back({b, 1});
}
sort(pts.begin(), pts.end());
cout << solve() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 RNG(chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
T ceil(T a, T b) {
return (a + b - 1) / b;
}
template <typename T>
T binpow(T a, T b, T m) {
a %= m;
T res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
const long long MAX_N = 1e6 + 1;
const long long MOD = 998244353;
long long fact[MAX_N], invf[MAX_N];
void precompute() {
fact[0] = invf[0] = 1;
for (long long i = 1; i < MAX_N; i++) {
fact[i] = fact[i - 1] * i % MOD;
invf[i] = binpow(fact[i], MOD - 2, MOD);
}
}
long long nCr(long long n, long long k) {
if (k < 0 || k > n) return 0;
return fact[n] * invf[k] % MOD * invf[n - k] % MOD;
}
void solve() {
long long n, k;
cin >> n >> k;
if (k == 1) {
cout << n << "\n";
return;
}
precompute();
vector<pair<long long, long long>> p;
for (long long i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
p.push_back({a, b});
}
sort((p).begin(), (p).end());
multiset<long long> ms;
long long res = 0;
for (long long i = 0; i < n; i++) {
if (!ms.empty()) {
while (!ms.empty() and *ms.begin() < p[i].first) {
auto it = ms.begin();
ms.erase(it);
}
long long s = ms.size();
(res += nCr(s, k - 1)) %= MOD;
}
ms.insert(p[i].second);
}
cout << res;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t = 1;
for (long long i = 1; i < t + 1; i++) {
solve();
}
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("-O3")
#pragma GCC optmize("sse, sse2, sse3, sse4, avx, abx, avx2, sse4.1")
#pragma GCC optmize("fast-math")
#pragma GCC optimize("unroll-loops")
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first != b.first) return a.first < b.first;
return a.second < b.second;
}
const long long mod = 998244353;
vector<long long> fact;
long long n;
long long pow(long long x, long long y) {
if (y == 0) return 1;
if (y == 1) return x;
if (y % 2 == 0) {
long long z = pow(x, y / 2);
return (z * z) % mod;
} else
return (x * pow(x, y - 1)) % mod;
}
long long inv(long long x) { return pow(x, mod - 2); }
void prec() {
fact[0] = 1;
for (long long i = 1; i <= n; ++i) fact[i] = fact[i - 1] * i % mod;
}
long long c(long long x, long long k) {
if (k > x) return 0;
if (k == x) return 1;
return ((fact[x] * inv(fact[k])) % mod * inv(fact[x - k])) % mod;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
;
long long k;
cin >> n >> k;
fact.resize(n + 1);
prec();
vector<pair<long long, long long>> ev;
ev.resize(2 * n);
for (long long i = 0; i < n; ++i) {
long long l, r;
cin >> l >> r;
ev[i] = {l, -1};
ev[i + n] = {r, 1};
}
sort(ev.begin(), ev.end(), comp);
long long ans = 0;
long long cnt = 0;
for (auto s : ev) {
if (s.second == 1) {
ans += c(cnt - 1, k - 1);
ans %= mod;
}
cnt -= s.second;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const int32_t mod = 998244353;
const long long N = 3e5 + 50;
long long fact[N], invfact[N];
long long powerM(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
b /= 2;
a = (a * a) % mod;
}
return ans;
}
long long invM(long long num) { return powerM(num, mod - 2); }
void precompute() {
fact[0] = fact[1] = 1;
for (long long i = 2; i < N; i++) {
fact[i] = fact[i - 1] * i;
fact[i] %= mod;
}
invfact[N - 1] = invM(fact[N - 1]);
for (long long i = N - 2; i >= 0; i--) {
invfact[i] = invfact[i + 1] * (i + 1);
invfact[i] %= mod;
}
}
long long nCr(long long x, long long y) {
if (y > x) return 0;
long long num = fact[x];
num *= invfact[y];
num %= mod;
num *= invfact[x - y];
num %= mod;
return num;
}
long long n, k;
long long solve() {
precompute();
cin >> n >> k;
map<long long, vector<long long>> mp;
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
mp[x].push_back(1);
mp[y + 1].push_back(-1);
}
long long cur = 0;
long long las = (*mp.begin()).first;
long long ans = 0;
for (auto& i : mp) {
long long sum = 0;
for (auto& j : i.second) {
if (j == -1)
cur--;
else
sum++;
}
for (long long ii = 1; ii <= min(sum, k); ii++) {
if (k - ii > cur) continue;
ans += nCr(sum, ii) * nCr(cur, k - ii) % mod;
ans %= mod;
}
cur += sum;
}
cout << ans << '\n';
return 0;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(20);
long long tests = 1;
for (long long i = 1; i <= tests; i++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6;
const int MAXN = 3e5 + 10;
const long long mod = 998244353;
long long jc[maxn];
long long inv[maxn];
long long num;
long long _dec[maxn];
long long add[maxn];
long long qpow(long long x, long long y) {
long long ret = 1;
while (y) {
if (y & 1) ret = ret * x % mod;
x = x * x % mod;
y >>= 1;
}
return ret;
}
inline void init() {
jc[0] = jc[1] = 1;
inv[0] = qpow(jc[0], mod - 2);
inv[1] = qpow(jc[1], mod - 2);
for (int i = 2; i < maxn; i++) {
jc[i] = jc[i - 1] * i % mod;
inv[i] = qpow(jc[i], mod - 2);
}
}
vector<long long> v;
vector<pair<long long, long long> > point;
long long Find(int x) {
return lower_bound(v.begin(), v.end(), x) - v.begin() + 1;
}
long long C(long long num, long long k) {
return jc[num] * inv[k] % mod * inv[num - k] % mod;
}
int main() {
init();
long long n, k;
cin >> n >> k;
long long a, b;
for (int i = 0; i < n; i++) {
cin >> a >> b;
point.push_back(make_pair(a, b));
v.push_back(a);
v.push_back(b + 1);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
for (int i = 0; i < n; i++) {
long long left = point[i].first;
long long right = point[i].second;
left = Find(left), right = Find(right + 1);
add[left]++;
_dec[right]++;
}
long long num = 0, now = 0;
long long ans = 0;
for (int i = 1; i <= v.size(); i++) {
now = add[i];
num -= _dec[i];
while (now) {
if (num >= k - 1) {
ans += C(num, k - 1) % mod;
}
ans %= mod;
now--;
num++;
}
}
cout << ans % mod << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll inf = 1000000001, INF = (ll)1e18 + 1;
const int maxn = 3e5 + 10;
ll fact[maxn], fact_inv[maxn];
ll power(ll a, ll b) {
ll result = 1;
while (b) {
if (b % 2) result = (result * a) % 998244353;
a = (a * a) % 998244353;
b /= 2;
}
return result;
}
ll divide(ll a, ll b) { return (a * power(b, 998244353 - 2)) % 998244353; }
void init() {
fact[0] = 1;
for (int i = 1; i < maxn; i++) {
fact[i] = (fact[i - 1] * i) % 998244353;
}
fact_inv[maxn - 1] = divide(1, fact[maxn - 1]);
for (int i = maxn - 2; i >= 0; i--)
fact_inv[i] = (fact_inv[i + 1] * (i + 1)) % 998244353;
}
ll C(ll n, ll k) {
return (((fact[n] * fact_inv[n - k]) % 998244353) * fact_inv[k]) % 998244353;
}
void solve() {
int n, k;
cin >> n >> k;
vector<int> l(n), r(n);
for (int i = 0; i < n; i++) cin >> l[i] >> r[i];
vector<pair<int, int> > event(2 * n);
for (int i = 0; i < n; i++) {
event[i * 2] = {l[i], 0};
event[i * 2 + 1] = {r[i], 1};
}
ll ans = 0;
int cnt = 0;
sort((event).begin(), (event).end());
for (int i = 0; i < 2 * n; i++) {
if (event[i].second) {
cnt--;
if (cnt >= k - 1) ans = (ans + C(cnt, k - 1)) % 998244353;
} else
cnt++;
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int64_t N = 3e5 + 5, mod = 998244353;
int64_t fa[N], ifa[N];
int64_t modpow(int64_t u, int64_t v) {
int64_t ans = 1;
while (v) {
if (v & 1) ans = (ans * u) % mod;
v >>= 1;
u = (u * u) % mod;
}
return ans;
}
void prec() {
fa[0] = fa[1] = 1;
for (int64_t i = 2; i < N; i++) {
fa[i] = (fa[i - 1] * i) % mod;
}
ifa[N - 1] = modpow(fa[N - 1], mod - 2);
for (int64_t i = N - 2; i >= 0; i--) {
ifa[i] = (ifa[i + 1] * (i + 1)) % mod;
}
}
int64_t Ans(int64_t n, int64_t m) {
if (n - m < 0) {
return 0;
}
return ((((fa[n] * ifa[n - m]) % mod) * (ifa[m])) % mod);
}
void solve() {
int64_t n, k;
cin >> n >> k;
vector<pair<int64_t, int64_t>> z;
for (int64_t i = 0, x, y; i < n; i++) {
cin >> x >> y;
z.push_back({x, 0});
z.push_back({y, 1});
}
sort(z.begin(), z.end());
int64_t ans = 0, b = 0;
for (auto &it : z) {
if (it.second) {
b--;
} else {
b++;
ans += Ans(b - 1, k - 1);
ans %= mod;
}
}
cout << ans;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
prec();
int64_t tq = 1;
for (; tq; tq--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long pow2(long long a, long long b, long long m) {
long long ans = 1;
while (b > 0) {
if (b & 1) {
ans = (ans * a) % m;
}
a = (a * a) % m;
b >>= 1;
}
return ans;
}
void solve() {
long long *fact = new long long[300010];
fact[0] = fact[1] = 1;
for (long long i = 2; i < 300001; i++)
fact[i] = (fact[i - 1] * i) % 998244353;
long long n, k;
cin >> n >> k;
vector<pair<long long, long long> > v;
for (long long i = 0; i < n; i++) {
long long l, r;
cin >> l >> r;
v.push_back({l, 0});
v.push_back({r, 1});
}
sort(v.begin(), v.end());
long long cnt = 0, ans = 0;
for (long long i = 0; i < v.size(); i++) {
if (cnt >= k - 1 && !v[i].second) {
long long temp = fact[cnt];
temp = (temp * pow2(fact[k - 1], 998244353 - 2, 998244353)) % 998244353;
temp = (temp * pow2(fact[cnt - k + 1], 998244353 - 2, 998244353)) %
998244353;
ans = (ans + temp) % 998244353;
}
if (!v[i].second)
cnt++;
else
cnt--;
}
cout << ans;
}
int32_t main() {
std::ios::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
long long t = 1;
for (long long j = 1; j <= t; j++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 5, inf = 1e18 + 100;
const long long mod = 998244353;
pair<long long, long long> a[N];
long long f[N], rf[N], s[N], w[N];
long long binpow(long long a, long long n) {
long long res = 1;
while (n > 0) {
if (n & 1) res *= a;
a *= a;
res %= mod;
a %= mod;
n >>= 1;
}
return res;
}
long long cnk(long long n, long long k) {
if (k < 0 || n < k) return 0;
return f[n] * rf[k] % mod * rf[n - k] % mod;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
f[0] = 1;
for (long long i = 1; i <= N; ++i) f[i] = (f[i - 1] * i) % mod;
rf[N] = binpow(f[N], mod - 2);
for (long long i = N; i >= 1; --i) rf[i - 1] = (rf[i] * i) % mod;
long long n, k;
cin >> n >> k;
vector<pair<long long, long long> > v;
for (long long i = 1; i <= n; ++i) {
long long l, r;
cin >> l >> r;
v.push_back({l, 1});
v.push_back({r + 1, -1});
}
sort(v.begin(), v.end());
long long cnt = 0, p = 0;
for (auto i : v) {
if (i.second == 1) cnt += cnk(p, k - 1), cnt %= mod;
p += i.second;
}
cout << cnt;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353, N = 3e5 + 10;
long long fac[N], inv[N], facinv[N];
long long qpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % MOD;
b /= 2;
a = a * a % MOD;
}
return res;
}
void init() {
fac[0] = 1;
inv[1] = 1;
facinv[1] = 1;
for (int i = 1; i < N; ++i) {
fac[i] = fac[i - 1] * i % MOD;
}
}
long long C(int n, int m) {
if (n < 0 || n < m) return 0;
return fac[n] * qpow(fac[m], MOD - 2) % MOD * qpow(fac[n - m], MOD - 2) % MOD;
}
int n, k;
int a[2 * N], d[2 * N], x[2 * N];
int l[N], r[N], val[2 * N], cnt;
int main() {
init();
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &l[i], &r[i]);
val[++cnt] = l[i];
val[++cnt] = r[i];
}
sort(val + 1, val + 1 + cnt);
int all = unique(val + 1, val + 1 + cnt) - val - 1;
for (int i = 1; i <= n; ++i) {
l[i] = lower_bound(val + 1, val + 1 + all, l[i]) - val;
r[i] = lower_bound(val + 1, val + 1 + all, r[i]) - val;
}
for (int i = 1; i <= n; ++i) {
x[l[i]]++;
d[l[i]]++;
d[r[i] + 1]--;
}
for (int i = 1; i <= all; ++i) {
a[i] = a[i - 1] + d[i];
}
long long ans = 0;
for (int i = 1; i <= all; ++i) {
if (a[i] < k) continue;
ans = (ans + C(a[i], k) - C(a[i] - x[i], k) + MOD) % MOD;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma optimize("SEX_ON_THE_BEACH")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("fast-math")
using ll = long long int;
using ull = long long int;
using dd = double;
using ldd = long double;
namespace someUsefull {
template <typename T1, typename T2>
inline void checkMin(T1& a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
inline void checkMax(T1& a, T2 b) {
if (a < b) a = b;
}
const int _popcount_size_ = 16;
char _bits_count_[1 << _popcount_size_];
inline void _build_bits_count_() {
for (int i = 1, j = 0; i < (1 << _popcount_size_); ++i) {
if (i & (1 << (j + 1))) ++j;
_bits_count_[i] = _bits_count_[i ^ (1 << j)] + 1;
}
}
template <typename T1 = int, typename T2 = int>
inline T1 popcnt(T2 x) {
T1 ans = 0;
while (x) {
ans += _bits_count_[x & (1 << _popcount_size_) - 1];
x >>= _popcount_size_;
}
return ans;
}
} // namespace someUsefull
using namespace std;
using namespace someUsefull;
vector<ll> fact;
ll mod = 998244353;
ll bp(ll a, ll n) {
ll ans = 1;
while (n) {
if (n & 1) ans = ans * a % mod;
a = a * a % mod;
n >>= 1;
}
return ans;
}
ll c(int n, int k) {
return fact[n] * bp(fact[k] * fact[n - k] % mod, mod - 2) % mod;
}
void solve(int test) {
int n, k;
cin >> n >> k;
fact.resize(n + 100);
fact[0] = 1;
for (int i = 1; i < fact.size(); ++i) fact[i] = fact[i - 1] * i % mod;
vector<pair<int, int>> ob;
for (int i = 0; i < n; ++i) {
int l, r;
cin >> l >> r;
ob.push_back({l, 0});
ob.push_back({r, 1});
}
sort((ob).begin(), (ob).end());
ll ans = 0;
int cnt = 0;
for (int i = 0; i < ob.size(); ++i) {
if (ob[i].second == 0)
++cnt;
else {
if (cnt >= k) {
ans += c(cnt - 1, k - 1);
}
--cnt;
}
}
cout << ans % mod;
}
signed main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
_build_bits_count_();
int t = 1;
for (int i = 0; i < t; ++i) {
solve(i + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > a;
const int MAXN = 1e6 + 7;
const long long MOD = 998244353;
long long fac[MAXN], inv[MAXN];
long long ksm(long long a, long long b) {
long long res = 1;
for (; b; b >>= 1) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
}
return res;
}
void init(int n) {
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % MOD;
inv[n] = ksm(fac[n], MOD - 2);
for (int i = n - 1; i >= 0; i--) inv[i] = inv[i + 1] * (i + 1) % MOD;
}
long long C(long long a, long long b) {
if (a < b) return 0;
return fac[a] * inv[b] % MOD * inv[a - b] % MOD;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.precision(6);
cout << fixed;
int n, k;
cin >> n >> k;
a.resize(n);
init(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
sort(a.begin(), a.end());
long long ans = 0;
priority_queue<int, vector<int>, greater<int> > q;
for (int i = 0; i < n; i++) {
while (!q.empty() && q.top() < a[i].first) q.pop();
ans += C(q.size(), k - 1);
ans %= MOD;
q.push(a[i].second);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Max = 2e6 + 10;
const int Mod = 998244353;
const long long int Inf = 1LL << 62;
int l[Max];
int r[Max];
long long int f[Max], inv[Max];
long long int BigMod(long long int a, int e) {
if (e == -1) {
e = Mod - 2;
}
long long int r = 1;
while (e) {
if (e & 1) {
r *= a, r %= Mod;
}
a *= a, a %= Mod, e >>= 1;
}
return r;
}
long long int nCr(int x, int y) {
if (x < 0 or y < 0 or x < y) {
return 0;
}
return f[x] * (inv[y] * inv[x - y] % Mod) % Mod;
}
void init() {
f[0] = 1;
for (int i = 1; i < Max; ++i) {
f[i] = i * 1LL * f[i - 1] % Mod;
}
inv[Max - 1] = BigMod(f[Max - 1], -1);
for (int i = Max - 1; i; --i) {
inv[i - 1] = i * 1LL * inv[i] % Mod;
}
}
int main() {
init();
int n, k;
scanf("%d %d", &n, &k);
set<int> st;
map<int, vector<int>> add, rmv;
for (int i = 1; i <= n; i++) {
scanf("%d %d", &l[i], &r[i]);
st.insert(l[i]);
st.insert(r[i]);
add[l[i]].push_back(i);
rmv[r[i]].push_back(i);
}
long long int cnt = 0, ans = 0;
for (int x : st) {
for (int y : add[x]) {
ans += nCr(cnt, k - 1);
ans %= Mod;
cnt++;
}
for (int y : rmv[x]) {
cnt--;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
const long long N = 6e5 + 10;
vector<long long> fact(N), inv(N), uniq(N), ct(N);
long long binpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
long long invv(long long x) { return binpow(x, MOD - 2, MOD); }
void test_case() {
long long n, k;
cin >> n >> k;
vector<pair<long long, long long>> v;
map<long long, long long> m;
long long ind = 1, curr = 0;
for (int i = 0; i < n; i++) {
long long lf, rt;
cin >> lf >> rt;
v.push_back({lf, rt});
m[lf] = m[rt] = 1;
}
for (auto &u : m) u.second = ind++;
for (int i = 0; i < n; i++) {
v[i] = {m[v[i].first], m[v[i].second]};
ct[v[i].first]++;
uniq[v[i].first]++;
uniq[v[i].second + 1]--;
}
for (long long i = 0; i < ind; i++) {
curr += uniq[i];
uniq[i] = curr;
}
long long ans = 0;
fact[0] = inv[0] = 1;
for (int i = 1; i < N; i++) {
fact[i] = fact[i - 1] * i % MOD;
inv[i] = invv(fact[i]);
}
for (long long i = 1; i < ind; i++) {
if (ct[i] && uniq[i] >= k) {
long long res = fact[uniq[i]] * inv[k] % MOD * inv[uniq[i] - k] % MOD;
long long nn = uniq[i] - ct[i], res1 = 0;
if (nn >= k && k >= 0 && nn >= 0)
res1 = fact[uniq[i] - ct[i]] * inv[k] % MOD * inv[uniq[i] - ct[i] - k] %
MOD;
ans = (ans + res - res1 + MOD) % MOD;
}
}
cout << ans << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long tc = 1;
while (tc--) test_case();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
struct Lamp {
int x, se;
bool operator<(const Lamp &o) const {
if (x != o.x) return x < o.x;
return se < o.se;
}
} lamp[600002];
long long inv_mod(long long a) {
long long res = 1, d = a;
long long k = MOD - 2;
while (k) {
if (k & 1) res = (res * d) % MOD;
d = (d * d) % MOD;
k >>= 1;
}
return res;
}
int N, K;
long long comcnt[300002];
int main() {
scanf("%d %d", &N, &K);
int il, ir;
for (int i = 0; i < N; ++i) {
scanf("%d %d", &il, &ir);
lamp[i + i] = {il, 0};
lamp[i + i + 1] = {ir, 1};
}
sort(lamp, lamp + N + N);
long long cnt = 0;
for (int i = 0; i < N + N; ++i) {
if (lamp[i].se == 0) {
++cnt;
if (cnt >= K) ++comcnt[cnt - K];
} else
--cnt;
}
long long res = 0, combi = 1;
for (long long i = 0; i <= N; ++i) {
res = (res + combi * comcnt[i]) % MOD;
combi = (combi * (K + i)) % MOD;
combi = (combi * inv_mod(i + 1)) % MOD;
}
printf("%lld\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD2 = 1000 * 1000 * 1000 + 7;
const long long INF = 1ll * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 + 7;
const long long MOD = 998244353;
const long long N = 1000 * 100 + 10;
const long long N2 = 70;
const long double PI = 3.141592653589793;
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
long long power(long long x, long long y, long long p = LLONG_MAX) {
long long res = 1;
x %= p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long inv(long long val, long long MODx = MOD) {
return power(val, MODx - 2, MODx);
}
vector<long long> fac, ifac;
void preFac(long long sz) {
fac.resize(sz + 1), ifac.resize(sz + 1);
fac[0] = 1;
for (long long i = 1; i <= sz; i++) {
fac[i] = (i * fac[i - 1]) % MOD;
}
ifac[sz] = inv(fac[sz]);
for (long long i = sz - 1; i >= 0; i--) {
ifac[i] = ((i + 1) * ifac[i + 1]) % MOD;
}
}
long long nCr(long long N, long long R) {
if (R <= N && R >= 0) {
return ((fac[N] * ifac[R]) % MOD * ifac[N - R]) % MOD;
}
return 0;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
std::vector<pair<long long, long long> > v(n);
for (long long i = 0; i < n; ++i) {
cin >> v[i].first >> v[i].second;
}
sort(v.begin(), v.end());
preFac(n + 10);
long long ans = 0;
multiset<long long> store;
for (long long i = 0; i < n; ++i) {
while (!store.empty() && (*store.begin() < v[i].first)) {
store.erase(store.begin());
}
ans += (nCr((long long)store.size(), k - 1));
ans += MOD;
ans %= MOD;
store.insert(v[i].second);
}
cout << ans << "\n";
cerr << "Time : " << 1000 * (long double)clock() / (long double)CLOCKS_PER_SEC
<< "ms\n";
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int gcdExtended(long long int a, long long int b, long long int *x,
long long int *y);
long long int modInverse(long long int b, long long int m) {
long long int x, y;
long long int g = gcdExtended(b, m, &x, &y);
if (g != 1) return -1;
return (x % m + m) % m;
}
long long int modDivide(long long int a, long long int b, long long int m) {
a = a % m;
long long int inv = modInverse(b, m);
return (inv * a) % m;
}
long long int gcdExtended(long long int a, long long int b, long long int *x,
long long int *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
long long int x1, y1;
long long int gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
signed main(void) {
long long int t = 1;
std::ios::sync_with_stdio(false);
cin.tie(NULL);
while (t--) {
long long int n, k;
cin >> n >> k;
vector<pair<long long int, long long int> > v;
for (long long int i = 0; i < n; i++) {
long long int l, r;
cin >> l >> r;
v.push_back({l, -1});
v.push_back({r, 1});
}
vector<long long int> ncr(n + 1);
ncr[k - 1] = 1;
long long int x = k - 1;
long long int y = 0;
long long int temp = 1;
for (long long int i = k; i <= n; i++) {
x++;
y++;
temp = (temp * x) % 998244353;
temp = modDivide(temp, y, 998244353);
ncr[i] = temp;
}
sort(v.begin(), v.end());
long long int ans = 0;
long long int cnt = 0;
for (long long int i = 0; i < 2 * n; i++) {
cnt += -v[i].second;
if (v[i].second == -1 && cnt >= k) ans = (ans + ncr[cnt - 1]) % 998244353;
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr long long mod = 998244353;
struct M {
unsigned v;
M(long long a = 0) : v((a %= mod) < 0 ? a + mod : a) {}
M& operator+=(M r) {
if ((v += r.v) >= mod) v -= mod;
return *this;
}
M& operator-=(M r) {
if ((v += mod - r.v) >= mod) v -= mod;
return *this;
}
M& operator*=(M r) {
v = (uint64_t)v * r.v % mod;
return *this;
}
};
uint32_t add(M a, M b) { return (a += b).v; }
uint32_t mul(M a, M b) { return (a *= b).v; }
uint32_t sub(M a, M b) { return (a -= b).v; }
constexpr long long mm = 3e5 + 3;
long long fact[mm], invFact[mm];
void pre() {
fact[0] = invFact[0] = invFact[1] = 1;
for (long long i = 1; i < mm; i++) {
fact[i] = mul(fact[i - 1], i);
}
for (long long i = 2; i < mm; i++) {
invFact[i] = mul((mod - mod / i), invFact[mod % i]);
}
for (long long i = 1; i < mm; i++) {
invFact[i] = mul(invFact[i - 1], invFact[i]);
}
}
long long ncr(long long n, long long r) {
assert(n >= 0 and r >= 0);
if (n < r) return 0;
return mul(mul(fact[n], invFact[r]), invFact[n - r]);
}
vector<pair<long long, long long>> v;
const long long N = 3e5 + 5;
vector<int32_t> tree[N << 2];
struct merge_sort_tree {
public:
void build(long long l, long long r, long long node) {
if (l == r) {
tree[node].push_back(v[l].second);
return;
}
long long mid = l + r >> 1, lc = node + node, rc = 1 + lc;
build(l, mid, lc);
build(mid + 1, r, rc);
merge(tree[lc].begin(), tree[lc].end(), tree[rc].begin(), tree[rc].end(),
back_inserter(tree[node]));
}
long long query(long long l, long long r, long long ql, long long qr,
long long val, long long node) {
if (ql > qr) return 0;
if (qr < l || r < ql) return 0;
if (ql <= l and r <= qr) {
long long L = lower_bound(tree[node].begin(), tree[node].end(), val) -
tree[node].begin();
return L;
}
long long mid = l + r >> 1, lc = node + node, rc = 1 + lc;
return (query(l, mid, ql, qr, val, lc) +
query(mid + 1, r, ql, qr, val, rc));
}
};
void solve() {
long long n, k;
cin >> n >> k;
v.resize(n);
for (auto& [x, y] : v) {
cin >> x >> y;
}
sort(v.begin(), v.end());
long long ans = 0;
merge_sort_tree ins;
v.insert(v.begin(), make_pair(0, 0));
ins.build(1, n, 1);
;
for (long long i = 1; i <= n; ++i) {
long long cnt = i - 1 - ins.query(1, n, 1, i - 1, v[i].first, 1);
if (cnt >= k - 1) ans = add(ans, ncr(cnt, k - 1));
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
pre();
for (long long i = 1; i <= t; ++i) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
const int P = 998244353;
int n, k;
int fac[N], inv[N], ifac[N];
pair<int, int> a[N];
pair<int, int> b[N << 1];
int c[N << 1];
int num, cnt;
void Init() {
fac[0] = 1;
for (int i = 1; i < N; i++) fac[i] = 1ll * fac[i - 1] * i % P;
inv[0] = inv[1] = 1;
for (int i = 2; i < N; i++) inv[i] = 1ll * (P - P / i) * inv[P % i] % P;
ifac[0] = ifac[1] = 1;
for (int i = 2; i < N; i++) ifac[i] = 1ll * ifac[i - 1] * inv[i] % P;
}
int C(int n, int m) {
if (n < m) return 0;
return ((1ll * fac[n] * ifac[m]) % P) * ifac[n - m] % P;
}
bool Cmp(pair<int, int> a, pair<int, int> b) { return a.first < b.first; }
void Update(int x, int y) {
for (; x <= cnt; x += x & -x) c[x] += y;
}
int Query(int x) {
int Ans = 0;
for (; x; x -= x & -x) Ans += c[x];
return Ans;
}
int main() {
Init();
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].first, &a[i].second);
b[++num] = pair<int, int>(a[i].first, i);
b[++num] = pair<int, int>(a[i].second, i + n);
}
sort(b + 1, b + num + 1);
for (int i = 1; i <= num; i++) {
if (b[i].first != b[i - 1].first) cnt++;
if (b[i].second <= n)
a[b[i].second].first = cnt;
else
a[b[i].second - n].second = cnt;
}
int Ans = 0;
for (int i = 1; i <= n; i++)
Update(a[i].first, 1), Update(a[i].second + 1, -1);
for (int i = 1; i <= cnt; i++) Ans = (Ans + C(Query(i), k)) % P;
sort(a + 1, a + n + 1, Cmp);
memset(c, 0, sizeof(c));
int p = 0;
for (int i = 1; i <= cnt; i++) {
while (p < n && a[p + 1].first <= i) Update(cnt - a[++p].second + 1, 1);
Ans = (Ans - C(Query(cnt - i), k)) % P;
}
printf("%d\n", (Ans + P) % P);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
const long long MOD = 998244353;
long long fact[1000000];
long long binpow(long long a, long long p) {
if (p == 0) return 1;
long long res = binpow(a, p / 2);
res *= res;
res %= MOD;
if (p % 2) res *= a;
res %= MOD;
return res;
}
long long C(long long n, long long k) {
long long c = fact[n];
c *= binpow(fact[k], MOD - 2);
c %= MOD;
c *= binpow(fact[n - k], MOD - 2);
c %= MOD;
return c;
}
void solve() {
long long n, k;
cin >> n >> k;
vector<pair<long long, long long>> points;
for (long long i = 0; i < n; i++) {
long long l, r;
cin >> l >> r;
points.push_back({l, 1});
points.push_back({r + 1, -1});
}
sort(points.begin(), points.end());
long long bal = 0;
long long res = 0;
for (long long i = 0; i < points.size(); i++) {
if (points[i].second == 1) {
if (bal > k - 1) {
res -= C(bal, k);
res %= MOD;
if (res < 0) res += MOD;
}
bal++;
if (bal >= k) res += C(bal, k);
res %= MOD;
if (res < 0) res += MOD;
} else
bal--;
}
cout << res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
srand(time(0));
fact[0] = 1;
for (long long i = 1; i < 1000000; i++)
fact[i] = ((fact[i - 1] % MOD) * (i % MOD)) % MOD;
long long t = 1;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
const long long int N = 5e5 + 7, mod = 998244353;
long long int POW(long long int a, long long int b, long long int mod) {
a %= mod;
long long int r = 1;
for (long long int i = b; i > 0; i >>= 1) {
if (i & 1) r = (r * a) % mod;
a = (a * a) % mod;
}
return r;
}
long long int f[N];
long long int nCr(long long int n, long long int r) {
if (n < r) return 0;
return f[n] * POW(f[n - r] * f[r], mod - 2, mod) % mod;
}
long long int nPr(long long int n, long long int r) {
return nCr(n, r) * f[r] % mod;
}
int main() {
f[0] = 1;
for (long long int i = 1; i < N; i++) {
f[i] = (f[i - 1] * i) % mod;
}
long long int n, k;
cin >> n >> k;
set<long long int> x;
map<long long int, long long int> mp;
vector<long long int> a, b;
for (long long int i = 0; i < n; i++) {
long long int l, r;
cin >> l >> r;
a.push_back(l);
b.push_back(r);
mp[l]++;
x.insert(l);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
long long int ans = 0;
for (long long int j : x) {
long long int p, s;
p = n;
long long int z = lower_bound(b.begin(), b.end(), j) - b.begin();
long long int z1 = upper_bound(a.begin(), a.end(), j) - a.begin();
z1 = n - z1;
p -= z1 + z;
s = mp[j];
ans = (ans + nCr(p, k));
long long int tem = nCr((p - s), k);
ans = (ans + mod - tem) % mod;
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
const long long MOD = 998244353;
const double PI = acos(-1.0);
using namespace std;
const long long N = 3e5 + 20;
long long fact[N], invFac[N];
long long modpow(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
long long ncr(long long n, long long r) {
return fact[n] * (invFac[r] * invFac[n - r] % MOD) % MOD;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
fact[0] = 1;
for (long long i = 1; i <= n + 1; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
}
invFac[n + 1] = modpow(fact[n + 1], MOD - 2, MOD);
for (long long i = n; i >= 0; i--) {
invFac[i] = invFac[i + 1] * (i + 1) % MOD;
}
long long l[n], r[n];
map<long long, long long> on, off;
set<long long> s;
for (long long i = 0; i < n; i++) {
cin >> l[i] >> r[i];
on[l[i]]++;
off[r[i]]++;
s.insert(l[i]);
s.insert(r[i]);
}
long long c = 0;
long long ans = 0;
for (auto x : s) {
if (c + on[x] >= k) {
long long r = ncr(c + on[x], k);
if (c >= k) {
r -= ncr(c, k);
}
r %= MOD;
if (r < 0) {
r += MOD;
}
ans += r;
ans %= MOD;
}
c += on[x];
c -= off[x];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long l, r;
} a[1505050];
bool cmp(node a, node b) {
if (a.l == b.l) {
return a.r > b.r;
}
return a.l < b.l;
}
multiset<long long> s;
long long num[1505050];
long long fpow(long long a, long long k) {
long long res = 1;
while (k) {
if (k & 1) res = (res * a) % 998244353;
k >>= 1;
a = a * a % 998244353;
}
return res;
}
long long f[1505050], invf[1505050];
void init(int n) {
f[0] = 1;
for (int i = 1; i <= n; ++i) {
f[i] = f[i - 1] * i % 998244353;
}
invf[n] = fpow(f[n], 998244353 - 2);
for (int i = n - 1; i >= 0; --i) {
invf[i] = invf[i + 1] * (i + 1) % 998244353;
}
}
long long C(long long n, long long k) {
if (k < 0 || k > n) return 0;
return f[n] * invf[k] % 998244353 * invf[n - k] % 998244353;
}
int main() {
long long n, k;
scanf("%lld %lld", &n, &k);
init(1505050 - 100);
for (int i = 1; i <= n; i++) {
scanf("%lld %lld", &a[i].l, &a[i].r);
}
sort(a + 1, a + 1 + n, cmp);
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long l = a[i].l, r = a[i].r;
while ((!s.empty()) && (*s.begin() < l)) s.erase(s.begin());
long long w = s.size();
if (w >= k - 1) {
ans += C(w, k - 1);
ans %= 998244353;
}
s.insert(r);
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
using namespace std;
const int N = 300003, mod = 998244353;
const long long inf = (1e18 + 11);
long long fact[N];
multiset<int> ls;
map<int, int> rs;
long long power(long long b, int p) {
long long r = 1;
b %= mod;
while (p) {
if (p & 1) r *= b, r %= mod;
b *= b, b %= mod;
p >>= 1;
}
return r;
}
long long modinv(long long x) { return power(x, mod - 2); }
long long C(int n, int r) {
if (n < r) return 0;
return ((fact[n] * modinv(fact[r] * fact[n - r])) % mod);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
int i, j, l, r;
fact[0] = 1;
for (i = 1; i <= n; ++i) fact[i] = (fact[i - 1] * i) % mod;
ls.clear(), rs.clear();
for (i = 1; i <= n; ++i) cin >> l >> r, ls.insert(l), rs[r + 1]++;
int prev = 0;
for (auto it : rs) rs[it.first] += prev, prev = rs[it.first];
int cnt = 0, ans = 0;
for (auto it : ls) {
++cnt;
auto it1 = rs.upper_bound(it);
if (it1 == rs.begin()) {
if (cnt >= k) {
ans += C(cnt - 1, k - 1);
if (ans >= mod) ans -= mod;
}
} else {
auto it2 = it1;
--it2;
cnt -= it2->second;
if (cnt >= k) {
ans += C(cnt - 1, k - 1);
if (ans >= mod) ans -= mod;
}
cnt += it2->second;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
const int maxn = 3e5 + 5;
const long long mod = 998244353;
const double eps = 1e-6L;
struct node {
int l, r;
bool operator<(const node& k) const {
if (l == k.l) return r > k.r;
return l < k.l;
}
} a[maxn];
long long fac[maxn], f[maxn], inv[maxn];
void init() {
fac[1] = 1;
f[1] = 1;
inv[1] = 1;
for (long long i = 2; i <= maxn; i++) {
fac[i] = fac[i - 1] * i % mod;
f[i] = (mod - mod / i) * f[mod % i] % mod;
inv[i] = inv[i - 1] * f[i] % mod;
}
}
long long C(long long m, long long n) {
if (m < n) return 0;
if (n == 0 || m == n) return 1;
return fac[m] * inv[n] % mod * inv[m - n] % mod;
}
int b[maxn];
int main() {
int T = 1;
init();
while (T--) {
int n, k, m = 1;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d %d", &a[i].l, &a[i].r);
b[i] = a[i].r;
}
sort(a, a + n);
sort(b, b + n);
int left = a[0].l, right = a[0].r;
long long ans = 0;
bool flag = true;
for (int i = n - 1; i >= 0; i--) {
int num = i + 1 - (lower_bound(b, b + n, a[i].l) - b);
ans = (ans + C(num - 1, k - 1)) % mod;
}
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10, mod = 998244353;
long long n, m, sum[2 * N];
long long f[N], unf[N];
struct Good {
int l, r;
} good[N];
vector<int> arr;
int find(int x) { return lower_bound(arr.begin(), arr.end(), x) - arr.begin(); }
int qmi(int a, int b) {
int res = 1;
while (b > 0) {
if (b & 1) res = (long long)res * a % mod;
b >>= 1;
a = (long long)a * a % mod;
}
return res;
}
void ini() {
unf[0] = 1, f[0] = 1;
for (int i = 1; i <= n; i++) {
f[i] = (long long)f[i - 1] * i % mod;
unf[i] = (long long)unf[i - 1] * qmi(i, mod - 2) % mod;
}
}
long long C(long long a, long long b) {
if (a < b) return 0;
return (long long)f[a] * unf[a - b] % mod * unf[b] % mod;
}
int main() {
scanf("%lld%lld", &n, &m);
ini();
for (int i = 1; i <= n; i++) {
scanf("%d%d", &good[i].l, &good[i].r);
arr.push_back(good[i].l);
arr.push_back(good[i].r + 1);
}
sort(arr.begin(), arr.end());
arr.erase(unique(arr.begin(), arr.end()), arr.end());
static int t[2 * N];
memset(t, 0, sizeof t);
for (int i = 1; i <= n; i++) {
int start = find(good[i].l), end = find(good[i].r + 1);
t[start]++;
sum[start]++, sum[end]--;
}
for (int i = 1; i < arr.size(); i++) sum[i] += sum[i - 1];
long long res = 0;
for (int i = 0; i < arr.size(); i++) {
if (sum[i] < m) continue;
res = ((res + C(sum[i], m) - C(sum[i] - t[i], m)) % mod + mod) % mod;
}
printf("%lld", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 3 * (int)1e5 + 100;
const long long mod = 998244353;
long long n, k, l, r;
long long fac[N], inv[N];
long long pow_mod(long long a, long long n) {
long long ret = 1;
while (n) {
if (n & 1) ret = ret * a % mod;
a = a * a % mod;
n >>= 1;
}
return ret;
}
void init() {
fac[0] = 1;
for (long long i = 1; i < N; i++) {
fac[i] = fac[i - 1] * i % mod;
}
}
long long CC(long long x, long long y) {
if (y < 0 || y > x) return 0;
return fac[x] * pow_mod(fac[y] * fac[x - y] % mod, mod - 2) % mod;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(10);
cout << fixed;
init();
cin >> n >> k;
vector<pair<int, int> > rev;
for (int i = 0; i < n; ++i) {
cin >> l >> r;
rev.emplace_back(make_pair(l, -1));
rev.emplace_back(make_pair(r, 1));
}
sort(rev.begin(), rev.end());
long long now = 0, ans = 0;
for (pair<int, int> pii : rev) {
if (pii.second == -1) {
ans += CC(now, k - 1);
ans %= mod;
++now;
} else
--now;
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
inline int Add(int a, int b) {
return (a + b >= MOD) ? (a + b - MOD) : (a + b);
}
inline int Mul(int a, int b) { return (long long)a * b % MOD; }
int Pow(int a, int b) {
int c = 1;
for (; b; a = Mul(a, a), b >>= 1)
if (b & 1) c = Mul(c, a);
return c;
}
const int N = 300005;
int n, k, m;
map<int, int> hs;
pair<int, int> a[N];
int c[N * 2];
void Modify(int x, int k) {
for (; x <= m; x += x & -x) c[x] += k;
return;
}
int Sum(int x) {
int sum = 0;
for (; x; x -= x & -x) sum += c[x];
return sum;
}
int fac[N], fac_inv[N];
void Init() {
fac[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = Mul(fac[i - 1], i);
fac_inv[n] = Pow(fac[n], MOD - 2);
for (int i = n; i; --i) fac_inv[i - 1] = Mul(fac_inv[i], i);
return;
}
inline int C(int a, int b) {
if (a < b) return 0;
return Mul(fac[a], Mul(fac_inv[b], fac_inv[a - b]));
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
int l, r;
scanf("%d%d", &l, &r);
a[i] = make_pair(r, l);
hs[l] = hs[r] = 0;
}
m = 0;
for (auto &x : hs) {
x.second = ++m;
}
for (int i = 1; i <= n; ++i) {
a[i].first = hs[a[i].first];
a[i].second = hs[a[i].second];
}
sort(a + 1, a + n + 1);
Init();
int ans = 0;
for (int i = n; i; --i) {
ans = Add(ans, C(Sum(a[i].first), k - 1));
Modify(a[i].second, 1);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
vector<long long int> fact(1e6);
void PreCompute() {
fact[0] = 1;
for (long long int i = 1; i < 1e6; i++) {
fact[i] = ((fact[i - 1] % mod) * i) % mod;
}
}
long long int modexp(long long int x, long long int n, long long int m) {
if (n == 0)
return 1ll;
else if (n & 1ll) {
return (x * modexp(x, n - 1, m)) % m;
} else {
long long int y = modexp(x, n / 2, m);
return (y * y) % m;
}
}
long long int flt(long long int a, long long int p) {
return modexp(a, p - 2, p);
}
long long int nchooser(long long int n, long long int r) {
if (r > n)
return 0;
else if (r == n)
return 1;
else {
long long int num = fact[n];
long long int denom = ((fact[r] * fact[n - r])) % mod;
long long int invdenom = flt(denom, mod);
return (num * invdenom) % mod;
}
}
void Compute(long long int n, long long int k) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
vector<pair<long long int, long long int> > events(n);
vector<pair<long long int, long long int> > vec;
for (long long int i = 0; i < n; i++) {
cin >> events[i].first >> events[i].second;
vec.emplace_back(make_pair(events[i].first, 0ll));
vec.emplace_back(make_pair(events[i].second, 1ll));
}
sort(vec.begin(), vec.end());
long long int cnt = 0;
long long int active_events = 1;
if (k == 1) cnt++;
for (long long int i = 1; i < vec.size(); i++) {
if (vec[i].second == 0) {
cnt += nchooser(active_events, k - 1);
cnt %= mod;
active_events++;
} else if (vec[i].second == 1) {
active_events--;
}
}
cout << cnt << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
PreCompute();
long long int n, k;
cin >> n >> k;
Compute(n, k);
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.141592653;
const long long infi = 1000000001;
const long long mod = 998244353;
const string no = "NO\n", yes = "YES\n";
long long bexpo(long long a, long long p) {
long long x = 1;
while (p) {
if (p & 1) {
x = (x * a) % mod;
}
a = (a * a) % mod;
p >>= 1;
}
return x;
}
int main() {
int t = 1;
long long n, m, i, length, d, bank, k, j, x, y, ans, q;
while (t--) {
ans = 0;
cin >> n >> k;
vector<pair<long long, long long> > vp;
for (i = 0; i < n; i++) {
cin >> x >> y;
vp.emplace_back(make_pair(x, y));
}
long long fact[n + 1], inv[n + 1];
fact[0] = 1;
for (i = 1; i < n + 1; i++) {
fact[i] = (fact[i - 1] * i) % mod;
}
inv[n] = bexpo(fact[n], mod - 2);
for (i = n - 1; i >= 0; i--) {
inv[i] = ((i + 1) * inv[i + 1]) % mod;
}
priority_queue<long long, vector<long long>, greater<long long> > pq;
sort(vp.begin(), vp.end());
x = 0;
for (i = 0; i < n; i++) {
pq.push(vp[i].second);
y = vp[i].first;
while (pq.top() < y && !pq.empty()) {
pq.pop();
}
x = pq.size();
y = 0;
if (x >= k) {
y = (((fact[x - 1] * inv[k - 1]) % mod) * inv[x - k]) % mod;
ans += (((fact[x - 1] * inv[k - 1]) % mod) * inv[x - k]) % mod;
ans %= mod;
}
}
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
const long long int mod = 998244353ll;
const long double eps = 1e-8;
long long int gcd(long long int a, long long int b, long long int& x,
long long int& y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long int x1, y1;
long long int d = gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
long long int rev(long long int a, long long int m) {
long long int x, y;
long long int g = gcd(a, m, x, y);
if (g != 1) {
throw g;
}
return (x % m + m) % m;
}
long long int n, k;
vector<pair<long long int, long long int>> a;
vector<long long int> f;
void fillf() {
f = vector<long long int>(n + 1);
f[0] = 1;
for (long long int i = 1; i <= n; i++) {
f[i] = f[i - 1] * i;
f[i] %= mod;
}
}
long long int cnk(long long int n, long long int k) {
long long int fn = f[n];
long long int fk = f[k];
long long int fnk = f[n - k];
long long int R = fn;
R *= rev(fk, mod);
R %= mod;
R *= rev(fnk, mod);
R %= mod;
return R;
}
int main(int argc, char* argv[]) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(15);
cout.setf(ios::fixed);
cin >> n >> k;
a = vector<pair<long long int, long long int>>(n + 1);
for (long long int i = 1; i <= n; i++) {
cin >> a[i].first >> a[i].second;
}
fillf();
map<long long int, vector<long long int>> q;
for (long long int i = 1; i <= n; i++) {
q[a[i].first].push_back(i);
q[a[i].second + 1].push_back(i);
}
long long int R = 0;
set<long long int> z;
for (auto t : q) {
long long int nc = 0;
for (auto u : t.second) {
if (!z.count(u)) {
z.insert(u);
nc += 1;
} else {
z.erase(u);
}
}
long long int n = z.size();
long long int old = n - nc;
if (n >= k) {
long long int t = cnk(n, k);
long long int m = old >= k ? cnk(old, k) : 0;
t = (t - m + mod) % mod;
R += t;
R %= mod;
}
}
cout << R << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using matr = vector<vector<ll>>;
using dbl = long double;
using ui = unsigned int;
mt19937 rnd;
ll random(ll limit) {
uniform_int_distribution<ll> uniform_dist(0, limit);
return uniform_dist(rnd);
}
ll solve(vector<ll> x, ll k) {
ll n = x.size();
if (k == 0) return n * (n - 1) / 2;
vector<ll> y;
ll num = 0;
for (int i = 0; i < n; i++) {
if (x[i] < k)
y.push_back(x[i]);
else
num++;
}
return num * (num - 1) / 2 + solve(y, k / 2);
}
ll mod = 998244353;
ll bpow(ll a, ll b) {
ll res = 1;
while (b > 0) {
if (b % 2) res *= a;
a *= a;
b /= 2;
a %= mod;
res %= mod;
}
return res;
}
ll inv(ll a) { return (bpow(a, mod - 2)); }
int N = 3E5;
vector<ll> fac(2 * N + 1);
ll bin(ll n, ll k) {
if (k > n) return 0;
ll res = fac[n];
res *= inv(fac[k]);
res %= mod;
res *= inv(fac[n - k]);
res %= mod;
return res;
}
int main() {
rnd = mt19937(956231);
ios::sync_with_stdio(false);
cin.tie(0);
fac[0] = 1;
for (int i = 0; i < 2 * N; i++) {
fac[i + 1] = fac[i] * (i + 1);
fac[i + 1] %= mod;
}
ll n, k;
cin >> n >> k;
vector<vector<ll>> kek;
for (int i = 0; i < n; i++) {
ll l, r;
cin >> l >> r;
kek.push_back({l, 1});
kek.push_back({r, 2});
}
sort(kek.begin(), kek.end());
ll ans = 0;
int num = 0;
for (auto v : kek) {
if (v[1] == 1) {
num++;
ans += bin(num, k) - bin(num - 1, k);
ans %= mod;
ans += mod;
ans %= mod;
} else
num--;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using pi = pair<int, int>;
const int mod = 998244353;
const ll inf = ll(1e18);
const double PI = acos(-1), eps = 1e-9;
ll fast_pow(int a, int p) {
ll res = 1;
while (p) {
if (p % 2 == 0) {
a = a * 1ll * a % mod;
p /= 2;
} else {
res = res * 1ll * a % mod;
p--;
}
}
return res;
}
ll fact[300005] = {1};
ll c(int n, int k) {
return fact[n] * 1ll * fast_pow(fact[k], mod - 2) % mod * 1ll *
fast_pow(fact[n - k], mod - 2) % mod;
}
const int mxa = 2e5;
const int mxn = 2e5, mxk = 5e2 + 5;
int n, k;
void solve() {
cin >> n >> k;
map<int, pi> make_pair;
for (int i = 0; i < n; ++i) {
int l, r;
cin >> l >> r;
++make_pair[l].first;
++make_pair[r + 1].second;
}
for (int i = 1; i <= n; ++i) fact[i] = (fact[i - 1] * i) % mod;
ll ans = 0;
int cnt = 0;
for (const auto &p : make_pair) {
cnt += (p.second.first - p.second.second);
if (cnt >= k) {
ans = (ans + c(cnt, k)) % mod;
if (cnt - p.second.first >= k)
ans = ((ans - c(cnt - p.second.first, k)) % mod + mod) % mod;
}
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int tt;
tt = 1;
while (tt-- > 0) solve();
}
|
#include <bits/stdc++.h>
const int32_t MAX_N = 300010;
const int32_t mod = 998244353;
int32_t fact[MAX_N];
int32_t power(int32_t base, int32_t n) {
int32_t res = 1;
for (; n != 0; n /= 2) {
if (n & 1) res = 1ll * res * base % mod;
base = 1ll * base * base % mod;
}
return res;
}
inline int32_t c(int32_t n, int32_t m) {
if (n < 0 || m < 0 || n - m < 0) return 0;
return 1ll * fact[n] * power(fact[m], mod - 2) % mod *
power(fact[n - m], mod - 2) % mod;
}
int32_t main() {
fact[0] = 1;
for (int32_t i = 1; i < MAX_N; i++) fact[i] = 1ll * i * fact[i - 1] % mod;
int32_t n, k;
scanf("%d%d", &n, &k);
std::vector<int32_t> s;
s.reserve(n + n);
std::vector<std::pair<int32_t, int32_t>> a(n);
for (int32_t i = 0; i < n; i++) {
scanf("%d%d", &a[i].first, &a[i].second);
s.push_back(a[i].first);
s.push_back(a[i].second);
}
std::sort(s.begin(), s.end());
s.erase(std::unique(s.begin(), s.end()), s.end());
std::vector<int32_t> in(s.size()), out(s.size() + 1);
for (int32_t i = 0; i < n; i++) {
in[std::lower_bound(s.begin(), s.end(), a[i].first) - s.begin()]++;
out[std::upper_bound(s.begin(), s.end(), a[i].second) - s.begin()]++;
}
int32_t ans = 0, sum = 0;
for (int32_t i = 0; i < s.size(); i++) {
sum -= out[i];
ans += c(sum + in[i], k);
if (mod <= ans) ans -= mod;
ans -= c(sum, k);
if (ans < 0) ans += mod;
sum += in[i];
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long oo = 2e9;
long long M = 1e9 + 7;
multiset<long long> st;
pair<int, int> p[202020];
map<long long, long long> mp;
bool vis[202020];
vector<int> G[202020];
long long q, t, n, m, k, z, x, y, d, sum, mn, mx, ans;
string s;
long long a[2020202], b[2020202];
long long mxl[2020202], mxr[2020202], r[2020202], l[2020202];
const long long N = 300500;
const long long mod = 998244353;
vector<long long> v;
long long fact[N];
long long invFact[N];
long long fast_pow(long long a, long long p) {
long long res = 1;
while (p) {
if (p % 2 == 0) {
a = (a * a) % mod;
p /= 2;
} else {
res = (res * a) % mod;
p--;
}
}
return res;
}
long long C(long long n, long long k) {
if (k > n) {
return 0;
}
return fact[n] * invFact[k] % mod * invFact[n - k] % mod;
}
struct item {
int val;
bool end;
};
bool cmp(item a, item b) {
if (a.val != b.val)
return a.val < b.val;
else
return a.end < b.end;
}
std::vector<item> events;
int main() {
ios::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL);
fact[0] = invFact[0] = 1;
for (long long i = 1; i < N; i++) {
fact[i] = (fact[i - 1] * i) % mod;
invFact[i] = fast_pow(fact[i], mod - 2);
}
cin >> n >> k;
int x, y;
for (int i = 0; i < n; ++i) {
cin >> x >> y;
events.push_back({x, 0});
events.push_back({y, 1});
}
sort(events.begin(), events.end(), cmp);
int cnt = 0;
for (int i = 0; i < events.size(); ++i) {
if (events[i].end) {
cnt--;
ans = (ans + C(cnt, k - 1)) % mod;
} else
cnt++;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int powerFunction(long long int x, long long int y) {
long long int res = 1;
long long int p = 998244353;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
bool prime[10000001];
long long int P = 998244353 - 2;
long long int fact[10000001] = {0};
void sieveFunction(long long int maxLimit) {
memset(prime, true, sizeof(prime));
prime[0] = prime[1] = false;
for (long long int i = 2; maxLimit >= i; i++) {
if (prime[i]) {
for (long long int j = 2 * i; maxLimit >= j; j += i) prime[j] = false;
}
}
}
void factorialFunction(long long int maxLimit) {
fact[0] = 1;
for (long long int i = 1; i <= maxLimit; i++)
fact[i] = (fact[i - 1] * i) % 998244353;
return;
}
long long int nCr(long long int n, long long int r) {
long long int a = fact[n];
long long int b = powerFunction(fact[n - r], 998244353 - 2);
long long int c = powerFunction(fact[r], 998244353 - 2);
return (a * (b % 998244353 * c % 998244353) % 998244353) % 998244353;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, k;
cin >> n >> k;
map<long long int, long long int> m, s, st;
factorialFunction(n + 1);
for (long long int i = 0; i < n; i++) {
long long int l, r;
cin >> l >> r;
m[l]++;
m[r + 1]--;
st[l]++;
}
long long int pre = INT_MIN;
for (auto it : m) {
s[it.first] = it.second;
if (pre == INT_MIN) {
pre = it.second;
continue;
}
s[it.first] += pre;
pre = s[it.first];
}
pre = INT_MIN;
long long int ans = 0;
for (auto it : st) {
if (s[it.first] < k) continue;
ans += nCr(s[it.first], k);
ans %= 998244353;
if (s[it.first] - it.second >= k) ans -= nCr(s[it.first] - it.second, k);
ans += 998244353;
ans %= 998244353;
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 998244353;
const long long int N = 3e5 + 5;
long long int pow(long long int x, long long int y, long long int m) {
long long int res = 1;
x = x % m;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) {
res *= x;
res %= m;
}
y = y / 2;
x = (x * x) % m;
}
return res;
}
long long int fact[N], fact1[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int i, j, tc;
tc = 1;
fact[0] = 1;
for (i = 1; i < N; i++) {
fact[i] = i * fact[i - 1];
fact[i] %= mod;
}
while (tc--) {
long long int n, k;
cin >> n >> k;
vector<pair<long long int, long long int> > v;
vector<long long int> st;
for (i = 0; i < n; i++) {
long long int a, b;
cin >> a >> b;
v.push_back({a, 1});
v.push_back({b + 1, -1});
}
sort(v.begin(), v.end());
for (i = 0; i < N; i++) {
if (i >= (k - 1)) {
long long int num = fact[i];
long long int denom = pow(fact[k - 1], mod - 2, mod);
long long int denom1 = pow(fact[i - k + 1], mod - 2, mod);
num *= denom;
num %= mod;
num *= denom1;
num %= mod;
fact1[i] = num;
}
}
if (k == 1) {
cout << n << "\n";
return 0;
}
long long int ans = 0;
long long int cnt = 0;
for (i = 0; i < v.size(); i++) {
long long int sec = v[i].second;
if (sec == -1)
cnt--;
else
cnt++;
if (cnt == k && sec == 1) {
ans += 1;
ans %= mod;
} else if (cnt > k && sec == 1) {
ans += (fact1[cnt - 1]);
ans %= mod;
}
}
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 11;
const long long mod = 998244353;
const long long inf = 1e9 + 1;
long long fact[N];
long long ifact[N];
long long powmod(long long base, long long exp) {
long long res = 1;
while (exp) {
if (exp & 1) res = (res * base) % mod;
base = (base * base) % mod;
exp >>= 1;
}
return res;
}
void compute() {
fact[0] = 1;
ifact[0] = 1;
for (long long i = 1; i < N; ++i) {
fact[i] = (fact[i - 1] * i) % mod;
ifact[i] = powmod(fact[i], mod - 2);
}
}
long long ncr(long long n, long long r) {
if (n < r) return 0;
long long ans = (fact[n] * ifact[n - r]) % mod;
ans = (ans * ifact[r]) % mod;
return ans;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
compute();
long long n, k;
cin >> n >> k;
vector<pair<long long, long long>> arr;
for (long long i = 0; i < n; ++i) {
long long l, r;
cin >> l >> r;
arr.push_back({l, 0});
arr.push_back({r, 1});
}
if (k == 1) {
cout << n << endl;
return 0;
}
sort(arr.begin(), arr.end());
long long ans = 0;
long long cnt = 0;
for (auto x : arr) {
if (x.second == 1) {
cnt--;
ans = (ans + ncr(cnt, k - 1)) % mod;
} else
cnt++;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 998244353;
const int maxn = 1e5 + 10;
void pvec(vector<int> v) {
for (auto x : v) {
cout << x << " ";
}
cout << endl;
}
long long int gcd(long long int x, long long int y) {
if (y == 0) {
return x;
} else {
return gcd(y, x % y);
}
}
long long int binpow(long long int a, long long int b) {
if (b == 0) {
return 1;
}
long long int res = 1;
long long int tmp = binpow(a, b / 2);
res = (tmp * tmp) % mod;
if (b % 2 == 1) {
res = (res * a) % mod;
}
return res;
}
struct node {
int pos;
int l;
int r;
int val;
};
bool comp(node a, node b) {
if (a.val == b.val) return a.l > b.l;
return a.val > b.val;
}
void update(int* BIT, int n, int idx) {
while (idx <= n) {
BIT[idx]++;
idx += idx & (-idx);
}
}
int query(int* BIT, int idx) {
int ans = 0;
while (idx) {
ans += BIT[idx];
idx -= idx & (-idx);
}
return ans;
}
vector<int> solveQuery(int arr[], int n, int QueryL[], int QueryR[],
int QueryK[], int q) {
node a[n + q + 1];
for (int i = 1; i <= n; ++i) {
a[i].val = arr[i - 1];
a[i].pos = 0;
a[i].l = 0;
a[i].r = i;
}
for (int i = n + 1; i <= n + q; ++i) {
a[i].pos = i - n;
a[i].val = QueryK[i - n - 1];
a[i].l = QueryL[i - n - 1];
a[i].r = QueryR[i - n - 1];
}
sort(a + 1, a + n + q + 1, comp);
int BIT[n + 1];
memset(BIT, 0, sizeof(BIT));
int ans[q + 1];
for (int i = 1; i <= n + q; ++i) {
if (a[i].pos != 0) {
int cnt = query(BIT, a[i].r) - query(BIT, a[i].l - 1);
ans[a[i].pos] = cnt;
} else {
update(BIT, n, a[i].r);
}
}
vector<int> ai;
for (int i = 1; i <= q; ++i) {
ai.push_back(ans[i]);
}
return ai;
}
void solve() {
int n, k;
cin >> n >> k;
vector<long long int> nck(n + 1, 0);
long long int kf = 1, kfi;
for (long long int i = 1; i <= k - 1; i++) {
kf = (kf * i) % mod;
}
kfi = binpow(kf, mod - 2);
nck[k - 1] = 1;
for (int i = k; i <= n; i++) {
nck[i] = (nck[i - 1] * i) % mod;
nck[i] = (nck[i] * binpow(i - k + 1, mod - 2)) % mod;
}
vector<pair<int, int> > v(n);
for (int i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
}
sort(v.begin(), v.end());
int r[n];
for (int i = 0; i < n; i++) {
r[i] = v[i].second;
}
int q = n - k + 1;
int ql[q], qr[q], qk[q];
for (int i = k - 1; i < n; i++) {
ql[i - k + 1] = 1;
qr[i - k + 1] = i;
qk[i - k + 1] = v[i].first - 1;
}
vector<int> ai = solveQuery(r, n, ql, qr, qk, q);
long long int ans = 0;
for (int u : ai) {
ans = (ans + nck[u]) % mod;
}
cout << ans << "\n";
}
int main() {
int t = 1;
int cnt = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 998244353;
const long long int inf = 2e9 + 5;
double PI = 3.14159265358979323846;
const int N = 3e5 + 7;
long long int modexp(long long int x, long long int n) {
long long int ans = 1;
while (n) {
if (n & 1) ans = ans * x % mod;
x = x * x % mod;
n /= 2;
}
return ans;
}
long long int modinv(long long int x) { return modexp(x, mod - 2); }
long long int fact[N];
void pre() {
fact[0] = 1;
for (int i = 1; i < N; i++) fact[i] = i * fact[i - 1] % mod;
}
long long int C(int n, int k) {
if (k < 0 || k > n) return 0;
long long int num = fact[n];
long long int dem = fact[k] * fact[n - k] % mod;
return num * modinv(dem) % mod;
}
template <long long int M>
struct ModInt {
int val;
ModInt(long long int x = 0) : val((x % M + M) % M) {}
ModInt pow(long long int n) const {
ModInt ans = 1, x = val;
while (n) {
if (n & 1) ans *= x;
x *= x;
n /= 2;
}
return ans;
}
ModInt inverse() const { return pow(M - 2); }
ModInt operator+(const ModInt& m) {
return val + m.val < M ? val + m.val : val + m.val - M;
}
ModInt operator-(const ModInt& m) {
return val - m.val >= 0 ? val - m.val : val - m.val + M;
}
ModInt operator*(const ModInt& m) { return val * (long long int)m.val % M; }
ModInt operator/(const ModInt& m) { return *this * m.inverse(); }
ModInt operator+=(const ModInt& m) { return *this = *this + m; }
ModInt operator-=(const ModInt& m) { return *this = *this - m; }
ModInt operator*=(const ModInt& m) { return *this = *this * m; }
ModInt operator/=(const ModInt& m) { return *this = *this / m; }
friend ostream& operator<<(ostream& os, const ModInt& m) {
os << m.val;
return os;
}
friend istream& operator>>(istream& is, ModInt& m) {
is >> m.val;
return is;
}
};
using mint = ModInt<mod>;
void solve() {
long long int n, k;
cin >> n >> k;
vector<long long int> l(n), r(n);
for (int i = 0; i < n; i++) {
cin >> l[i] >> r[i];
}
vector<long long int> order(n);
iota((order).begin(), (order).end(), 0);
sort((order).begin(), (order).end(),
[&](long long int i, long long int j) { return l[i] < l[j]; });
pre();
mint ans = 0;
multiset<long long int> s;
for (long long int i : order) {
while (!s.empty() and (*s.begin()) < l[i]) {
s.erase(s.begin());
}
long long int cnt = (long long int)s.size();
ans += C(cnt, k - 1);
s.insert(r[i]);
}
cout << ans << "\n";
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
const long long mod = 998244353;
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long ksm(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a % mod;
a = a * a % mod;
b >>= 1;
}
return ret;
}
const int N = 3e5 + 5;
long long n, k;
int a[2 * N], l[N], r[N], c[2 * N];
struct node {
int l;
int r;
} b[N];
const int maxn = 1e6 + 5;
long long inv[maxn];
long long fac[maxn];
long long Com(int n, int m) { return fac[n] * inv[m] % mod * inv[n - m] % mod; }
void init() {
inv[0] = fac[0] = 1;
inv[1] = 1;
for (int i = 1; i < maxn; i++) {
fac[i] = fac[i - 1] * i % mod;
}
inv[1] = 1;
for (int i = 2; i < maxn; i++) {
inv[i] = (long long)(mod - mod / i) * inv[mod % i] % mod;
}
inv[0] = 1;
for (int i = 1; i < maxn; i++) {
inv[i] = inv[i - 1] * inv[i] % mod;
}
}
bool cmp(node x, node y) {
if (x.l == y.l) return x.r < y.r;
return x.l < y.l;
}
int lowbit(int x) { return x & (-x); }
void add(int x, int k) {
while (x <= 2 * n) {
c[x] = c[x] + k;
x = x + lowbit(x);
}
}
int getsum(int x) {
int ans = 0;
while (x) {
ans += c[x];
x -= lowbit(x);
}
return ans;
}
long long solve(int a, int b) {
long long x = (long long)a, y = (long long)b;
return Com(a, b);
}
int main() {
init();
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> l[i] >> r[i];
if (k == 1) {
cout << n << "\n";
return 0;
}
for (int i = 1; i <= n; i++) a[i] = l[i];
for (int i = n + 1; i <= 2 * n; i++) a[i] = r[i - n];
sort(a + 1, a + 1 + 2 * n);
int len = unique(a + 1, a + 1 + 2 * n) - a - 1;
for (int i = 1; i <= n; i++) l[i] = lower_bound(a + 1, a + 1 + len, l[i]) - a;
for (int i = 1; i <= n; i++) r[i] = lower_bound(a + 1, a + 1 + len, r[i]) - a;
for (int i = 1; i <= n; i++) b[i].l = l[i], b[i].r = r[i];
sort(b + 1, b + 1 + n, cmp);
long long ans = 0;
for (int i = 1; i <= n; i++) {
int p = b[i].l;
int tp = getsum(2 * n);
int q = getsum(p - 1);
tp -= q;
if (tp >= k - 1) {
ans += solve(tp, k - 1);
ans %= mod;
}
add(b[i].r, 1);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod_inv(long long n) {
long long p = 998244353 - 2;
long long ans = 1;
long long x = n;
while (p > 0) {
if (p & 1) ans = (ans * x) % 998244353;
x = (x * x) % 998244353;
p = p / 2;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
long long n, k;
cin >> n >> k;
vector<pair<long long, long long>> v1, v2;
map<long long, long long> m1;
for (long long i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
m1[a]++;
m1[b]++;
v1.push_back(make_pair(a, i));
v2.push_back(make_pair(b, i));
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
long long ans = 0;
long long ar[n + 1];
memset(ar, 0, sizeof(ar));
ar[k] = 1;
for (long long i = k + 1; i <= n; i++) {
long long x = (ar[i - 1] * i) % 998244353;
long long y = mod_inv(i - k);
ar[i] = (x * y) % 998244353;
}
long long c = 0;
long long i = 0, j = 0;
for (auto it = m1.begin(); it != m1.end(); it++) {
long long p = c;
while (i < n and v1[i].first == (it->first)) {
c++;
i++;
}
ans = (ans + ar[c]) % 998244353;
ans = (ans - ar[p] + 998244353) % 998244353;
while (j < n and v2[j].first == (it->first)) {
c--;
j++;
}
}
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MOD = 998244353, MAX = 3e5 + 5;
const long long INF = 1e18 + 5;
long long powN(long long a, long long p) {
if (p == 0) return 1;
long long z = powN(a, p / 2);
z = (z * z) % MOD;
if (p % 2) z = (z * a) % MOD;
return z;
}
struct PnC {
int n;
vector<long long> F, I;
void init(int n) {
F.resize(n + 1);
I.resize(n + 1);
F[0] = I[0] = 1;
for (int i = 1; i <= n; i++) {
F[i] = (F[i - 1] * i) % MOD;
I[i] = powN(F[i], MOD - 2);
}
}
long long nCr(int n, int r) {
if (r > n) return 0;
return (((F[n] * I[r]) % MOD) * I[n - r]) % MOD;
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
PnC P;
P.init(MAX);
int n, k;
cin >> n >> k;
int curr = 0;
multiset<pair<int, int> > S;
for (int i = 0; i < n; i++) {
int l, r;
cin >> l >> r;
S.insert({l, -1});
S.insert({r, 0});
}
long long ans = 0;
for (auto s : S) {
if (s.second == 0) {
curr--;
} else {
curr++;
if (curr >= k) {
ans += P.nCr(curr - 1, k - 1);
}
ans %= MOD;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 998244353;
ll fact[300100];
ll invf[300100];
ll stp(ll x, int s) {
if (s == 0) return 1;
if (s & 1) {
ll r = stp(x, s >> 1);
return (((r * r) % MOD) * x) % MOD;
} else {
ll r = stp(x, s >> 1);
return (r * r) % MOD;
}
}
int n, k;
pair<int, int> mas[300100];
pair<int, bool> evnt[600100];
ll cmb(ll x) {
if (k > x) return 0;
return (((fact[x] * invf[k]) % MOD) * invf[x - k]) % MOD;
}
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
fact[0] = 1;
invf[0] = 1;
for (int i = 1; i < 300100; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
invf[i] = stp(fact[i], MOD - 2);
}
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> mas[i].first >> mas[i].second;
for (int i = 0; i < n; i++) {
evnt[i << 1].first = mas[i].first;
evnt[i << 1].second = false;
evnt[(i << 1) + 1].first = mas[i].second;
evnt[(i << 1) + 1].second = true;
}
sort(evnt, evnt + n * 2);
ll ans = 0;
ll open = 0;
for (int r = 0; r < (n << 1);) {
int l = r;
while (r < (n << 1) && evnt[l] == evnt[r]) r++;
int cnt = r - l;
if (!evnt[l].second) {
ans += cmb(open + cnt);
if (ans >= MOD) ans -= MOD;
ans += MOD - cmb(open);
if (ans >= MOD) ans -= MOD;
open += cnt;
} else {
open -= cnt;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
const int N = 6e5 + 10, mod = 998244353;
int n, t, m;
long long fact[N];
struct node {
int p, id;
bool operator<(const node &a) const { return p == a.p ? id < a.id : p < a.p; }
};
vector<node> v;
void init() {
fact[0] = 1;
for (int i = 1; i < N; i++) {
fact[i] = (fact[i - 1] * i) % mod;
}
}
long long ksm(long long a, long long b) {
long long res = 1 % mod;
while (b) {
if (b & 1) res = (res * a) % mod;
b >>= 1;
a = (a * a) % mod;
}
return res % mod;
}
long long cc(long long n, long long m) {
if (m > n)
return 0;
else if (m == 0 || m == n)
return 1;
else {
return fact[n] * ksm(fact[m], mod - 2) % mod * ksm(fact[n - m], mod - 2) %
mod;
}
}
void solve() {
scanf("%d%d", &n, &m);
v.clear();
for (int i = 1, x, y; i <= n; i++) {
scanf("%d%d", &x, &y);
v.push_back({x, 1});
v.push_back({y + 1, -1});
}
sort(v.begin(), v.end());
long long ans = 0, cnt = 0;
for (auto i : v) {
if (i.id == 1) {
ans = (ans + cc(cnt, m - 1) % mod) % mod;
}
cnt += i.id;
}
printf("%lld\n", ans);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long int inv[300001], fac[300001];
long long int mi(long long int a, long long int b) {
long long int ans = 1;
while (b) {
if (b & 1) ans *= a;
a *= a;
a %= mod;
b >>= 1;
ans %= mod;
}
return ans % mod;
}
long long Inv(long long n) { return mi(n, mod - 2); }
inline long long int c(long long int k, long long int n) {
if (n < 0 || k < 0 || k > n) return 0;
return (fac[n]) * inv[k] % mod * inv[n - k] % mod;
}
void init() {
fac[0] = 1;
for (int i = 1; i < 300001; i++) {
fac[i] = (fac[i - 1]) * i % mod;
}
inv[0] = 1;
inv[300000] = Inv(fac[300000]);
for (int i = 299999; i >= 1; i--) inv[i] = inv[i + 1] * (i + 1) % mod;
}
struct p {
int x, p;
} e;
int cmp(p i, p j) {
if (i.x == j.x) return i.p < j.p;
return i.x < j.x;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
int n, k, u = 0;
init();
cin >> n >> k;
long long ans = 0;
vector<p> v;
for (int i = 0; i < n; i++)
cin >> e.x, e.p = 0, v.push_back(e), cin >> e.x, e.p = 1, v.push_back(e);
sort(v.begin(), v.end(), cmp);
for (int i = 0; i < 2 * n; i++)
if (v[i].p)
u--;
else
u++, ans += c(k - 1, u - 1);
cout << ans % mod;
}
|
#include <bits/stdc++.h>
using namespace std;
class NT {
public:
~NT();
static long long toN(long long x, long long n, long long mod);
};
class Solution {
public:
long long MOD = 998244353;
vector<long long> F;
long long C(long long n, long long k) {
long long up = F[n];
long long btm = (F[k] * F[n - k]) % MOD;
return (up * NT::toN(btm, MOD - 2, MOD)) % MOD;
}
void solve(int num, std::istream& in, std::ostream& out) {
int n, k;
in >> n >> k;
vector<pair<int, int>> arr;
F.resize(4 * 1e5);
F[0] = F[1] = 1;
for (int i = 2; i < F.size(); i++) {
F[i] = (F[i - 1] * i) % MOD;
}
for (int i = 0; i < n; i++) {
int from, to;
in >> from >> to;
arr.push_back({from, -1});
arr.push_back({to, 1});
}
sort(arr.begin(), arr.end());
long long count = 0;
int curr = 0;
for (auto p : arr) {
int x = p.first;
int id = p.second;
if (id == 1) {
curr--;
} else {
if (curr + 1 == k)
count++;
else if (curr >= k) {
count += C(curr, k - 1);
}
curr++;
}
}
out << count % MOD;
}
};
void solve(std::istream& in, std::ostream& out) {
out << std::setprecision(12);
Solution solution;
solution.solve(0, in, out);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
istream& in = cin;
ostream& out = cout;
solve(in, out);
return 0;
}
NT::~NT() {}
long long NT::toN(long long x, long long n, long long mod) {
long long rez = 1;
long long tmp = x;
while (n) {
if (n & 1) rez = (rez * tmp) % mod;
tmp = (tmp * tmp) % mod;
n >>= 1;
}
return rez;
}
|
#include <bits/stdc++.h>
using namespace std;
bool comp(long long a, long long b) { return a > b; }
std::vector<long long> fac(500000);
void pre() {
fac[0] = 1;
for (int i = 1; i < 500000; i++) {
fac[i] = i * fac[i - 1];
fac[i] %= 998244353;
}
}
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long modInverse(long long n, long long p) { return power(n, p - 2, p); }
long long nCrModPFermat(long long n, long long r) {
if (n <= 0 || n < r) return 0;
if (r == 0) return 1;
long long a = (fac[n] * modInverse(fac[r], 998244353) % 998244353 *
modInverse(fac[n - r], 998244353) % 998244353) %
998244353;
return a;
}
void solve() {
long long k, x, y, n;
cin >> n >> k;
std::vector<pair<long long, long long>> ar;
long long ans = 0;
for (int i = 0; i < n; i++) {
long long l, r;
cin >> l >> r;
ar.push_back(make_pair(l, r));
}
if (k == 1) {
cout << n << "\n";
return;
}
sort(ar.begin(), ar.end());
multiset<long long> q;
long long cnt;
for (int i = 0; i < n; i++) {
while (!q.empty() && *q.begin() < ar[i].first) {
q.erase(q.begin());
}
cnt = q.size();
ans += (nCrModPFermat(cnt, k - 1));
ans %= 998244353;
q.insert(ar[i].second);
}
cout << ans << "\n";
}
int main() {
pre();
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353, maxn = 6e5 + 5;
vector<pair<int, int>> v;
long long f[300005];
long long inv(long long e, long long p) {
long long r = 1;
for (; p; p >>= 1) {
if (p & 1) r = r * e % MOD;
e = e * e % MOD;
}
return r;
}
long long C(long long n, long long m) {
if (n < m) return 0;
return f[n] * inv(f[m], MOD - 2) % MOD * inv(f[n - m], MOD - 2) % MOD;
}
bool cmp(pair<int, int> a, pair<int, int> b) {
return a.first < b.first || a.first == b.first && a.second > b.second;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
long long n, k, res = 0, cnt = 0;
cin >> n >> k;
f[0] = 1;
for (int i = 1, l, r; i <= n; i++) {
cin >> l >> r;
v.push_back({l, 1});
v.push_back({r, -1});
f[i] = f[i - 1] * i % MOD;
;
}
sort(v.begin(), v.end(), cmp);
for (int i = 0; i < v.size(); i++) {
if (v[i].second == 1) res = (res + C(cnt, k - 1)) % MOD;
cnt += v[i].second;
}
cout << res << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename... T>
inline void inp(T &...args) {
((cin >> args), ...);
}
template <typename T>
inline istream &operator>>(istream &in, vector<T> &a) {
for (auto &x : a) in >> x;
return in;
}
template <typename T, typename U>
inline istream &operator>>(istream &in, pair<T, U> &a) {
in >> a.first >> a.second;
return in;
}
const long long int MX = 1e6 + 10;
const long long int Mod = 998244353;
inline long long int md(long long int x, long long int M = Mod) {
x %= M;
return ((x < 0) ? (x + M) : x);
}
vector<long long int> fact(MX), invfact(MX), inv(MX);
void init_fact(long long int m = Mod) {
inv[0] = 0;
inv[1] = fact[0] = fact[1] = invfact[0] = invfact[1] = 1;
for (long long int i = 2; i < MX; i++) {
fact[i] = md(fact[i - 1] * i, m);
inv[i] = m - (m / i) * inv[m % i] % m;
invfact[i] = md(inv[i] * invfact[i - 1], m);
}
}
long long int NPR(long long int n, long long int r) {
if (0 <= r and r <= n) {
return md(fact[n] * invfact[n - r]);
}
return 0;
}
long long int NCR(long long int n, long long int r) {
if (0 <= r and r <= n) {
return md(fact[n] * md(invfact[r] * invfact[n - r]));
}
return 0;
}
void solve(int &T) {
long long int n, k;
cin >> n >> k;
vector<pair<long long int, long long int>> a;
for (long long int i = (0); ((1) > 0 ? i < (n) : i > (n)); i += (1)) {
long long int x, y;
cin >> x >> y;
a.push_back({x, 1});
a.push_back({y + 1, -1});
}
sort((a).begin(), (a).end());
long long int cnt = 0, ans = 0;
for (long long int i = (0); ((1) > 0 ? i < (2 * n) : i > (2 * n)); i += (1)) {
if (a[i].second == 1) {
if (cnt >= k - 1) {
ans = md(ans + NCR(cnt, k - 1));
}
cnt++;
} else {
cnt--;
}
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
init_fact();
int t = 1;
for (int i = 1; i <= t; i++) {
if (0) cerr << "Case #" << i << "\n";
solve(i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 998244353;
const long long inf = 4e18;
const long long N = 3e5;
long long fac[N + 1];
long long power(long long x, long long y) {
if (y < 0) return power(x, M - 2) * power(x, y + 1) % M;
y %= (M - 1);
long long res = 1;
while (y > 0) {
if (y & 1) res = res * x % M;
y = y >> 1;
x = x * x % M;
}
return res;
}
void factorial() {
fac[0] = 1;
for (long long i = 1; i <= N; i++) fac[i] = fac[i - 1] * i % M;
}
long long nCr(long long n, long long r) {
if (r > n || r < 0) return 0;
if (r == 0) return 1;
return (fac[n] * power(fac[r], M - 2) % M * power(fac[n - r], M - 2) % M) % M;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
factorial();
long long n, k;
cin >> n >> k;
vector<pair<long long, long long> > v;
vector<long long> right;
for (long long i = 0; i < n; i++) {
long long l, r;
cin >> l >> r;
v.emplace_back(l, r);
right.emplace_back(r);
}
sort(v.begin(), v.end());
sort(right.begin(), right.end());
long long o = 0;
for (long long i = 0; i < n; i++) {
long long j =
upper_bound(v.begin(), v.end(), make_pair(right[i], inf)) - v.begin();
o = (o + nCr(j - i - 1, k - 1)) % M;
}
cout << o << '\n';
}
|
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
const int M = 998244353;
const int N = 3e5 + 5;
int dp[N];
int n, k;
int fast_exp(int a, int b) {
if (b == 0) {
return 1;
} else if (b & 1) {
ll x = fast_exp(a, (b - 1) / 2);
return (a * ((x * x) % M)) % M;
} else {
ll x = fast_exp(a, b / 2);
return (x * x) % M;
}
}
ll modfac(int a) {
if (a == 0) {
return 1;
} else if (dp[a] != -1) {
return dp[a];
} else {
ll ans = (a * modfac(a - 1)) % M;
dp[a] = ans;
return ans;
}
}
int nck(int a, int b) {
if (a < b) {
return 0;
}
ll x = modfac(a);
ll y = modfac(b);
ll z = modfac(a - b);
ll l = (y * z) % M;
ll inv = fast_exp(l, M - 2);
return (x * inv) % M;
}
int main() {
cin >> n >> k;
vector<array<int, 4>> sweep{};
for (int i = 0; i < n; ++i) {
dp[i] = -1;
int l, r;
cin >> l >> r;
sweep.push_back({l, 0, r, 1});
sweep.push_back({r, 1, l, -1});
}
dp[n] = -1;
sort(sweep.begin(), sweep.end());
int size = 0;
ll ans = 0;
for (int i = 0; i < (int)sweep.size(); ++i) {
int action = sweep[i][3];
if (action == 1) {
int curr = nck(size, k - 1);
ans = (ans + curr) % M;
size += 1;
} else if (action == -1) {
size -= 1;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 998244353;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
long long fac[300003]{1};
long long f(long long n, int k) {
long long ret = 1;
while (k) {
if (k & 1) ret = ret * n % P;
n = n * n % P;
k >>= 1;
}
return ret;
}
long long C(long long n, long long r) {
if (n < r) return 0;
return fac[n] * f(fac[r] * fac[n - r] % P, P - 2) % P;
}
int main() {
int n, m, i, j, k, mx = 0;
pair<int, int> a[600003];
scanf("%d%d", &n, &k);
for (i = 0; i < n; ++i) {
int l, r;
scanf("%d%d", &l, &r);
a[i * 2] = {l, 1};
a[i * 2 + 1] = {r + 1, -1};
mx = max(mx, l);
}
for (i = 1; i <= n; ++i) fac[i] = fac[i - 1] * i % P;
sort(a, a + 2 * n);
int cnt = 0, tmp1 = 1, tmp2 = 0;
long long ans = 0;
for (i = 1; i < 2 * n; ++i) {
while (i < 2 * n && a[i].first == a[i - 1].first) {
if (a[i].second > 0)
tmp1++;
else
tmp2--;
i++;
}
if (tmp1 > 0)
ans = (ans + C(cnt + tmp1 + tmp2, k) - C(cnt + tmp2, k) + P) % P;
cnt += tmp1 + tmp2;
if (a[i].second > 0)
tmp1 = 1, tmp2 = 0;
else
tmp1 = 0, tmp2 = -1;
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
using vc = vector<T>;
template <class T>
using vvc = vc<vc<T>>;
template <class T>
void mkuni(vector<T> &v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
long long rand_int(long long l, long long r) {
static mt19937_64 gen(chrono::steady_clock::now().time_since_epoch().count());
return uniform_int_distribution<long long>(l, r)(gen);
}
template <class T>
void print(T x, int suc = 1) {
cout << x;
if (suc == 1)
cout << '\n';
else
cout << ' ';
}
template <class T>
void print(const vector<T> &v, int suc = 1) {
for (int i = 0; i < v.size(); i++)
print(v[i], i == (int)(v.size()) - 1 ? suc : 2);
}
const int N = 3e5 + 10;
struct Tree {
long long l, r, lazy, sum, mi, ma;
} tree[N << 2];
void push_up(int rt) {
tree[rt].sum = tree[rt << 1].sum + tree[rt << 1 | 1].sum;
tree[rt].ma = tree[rt << 1].ma;
tree[rt].mi = tree[rt << 1 | 1].mi;
}
void build(int l, int r, int rt, vector<int> &a) {
tree[rt].l = l, tree[rt].r = r, tree[rt].lazy = 0;
if (l == r) {
tree[rt].sum = tree[rt].mi = tree[rt].ma = a[l];
return;
}
int mid = l + r >> 1;
build(l, mid, rt << 1, a);
build(mid + 1, r, rt << 1 | 1, a);
push_up(rt);
}
void push_down(int rt) {
if (tree[rt].lazy) {
int x = tree[rt].lazy, l = tree[rt].l, r = tree[rt].r;
tree[rt].lazy = 0;
tree[rt << 1].sum = 1ll * (tree[rt << 1].r - tree[rt << 1].l + 1) * x;
tree[rt << 1].mi = tree[rt << 1].ma = x;
tree[rt << 1].lazy = x;
tree[rt << 1 | 1].sum =
1ll * (tree[rt << 1 | 1].r - tree[rt << 1 | 1].l + 1) * x;
tree[rt << 1 | 1].mi = tree[rt << 1 | 1].ma = x;
tree[rt << 1 | 1].lazy = x;
}
}
void update_range(int L, int R, long long Y, int rt) {
int l = tree[rt].l, r = tree[rt].r;
if (tree[rt].mi >= Y || l > R) return;
if (tree[rt].ma <= Y && r <= R) {
tree[rt].sum = 1ll * (r - l + 1) * Y;
tree[rt].mi = tree[rt].ma = Y;
tree[rt].lazy = Y;
return;
}
push_down(rt);
update_range(L, R, Y, rt << 1);
update_range(L, R, Y, rt << 1 | 1);
push_up(rt);
}
int query_range(int L, int R, int rt, long long &Y) {
int l = tree[rt].l, r = tree[rt].r;
if (tree[rt].mi > Y || r < L) return 0;
if (tree[rt].sum <= Y && l >= L) {
Y -= tree[rt].sum;
return r - l + 1;
}
push_down(rt);
long long res = 0;
res += query_range(L, R, rt << 1, Y);
res += query_range(L, R, rt << 1 | 1, Y);
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, q;
cin >> n >> q;
vector<int> a(n + 1);
for (int i = 1; i <= n; ++i) cin >> a[i];
build(1, n, 1, a);
while (q--) {
long long x, y, op;
cin >> op >> x >> y;
if (op == 1) {
update_range(1, x, y, 1);
} else
cout << query_range(x, n, 1, y) << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 10;
long long n, q;
long long a[MAXN];
struct SegmentTreeNode {
long long minima;
long long maxima;
long long count;
long long lazy;
long long sum;
} segtree[MAXN << 2];
void combineChildrenResuts(long long id) {
long long left = id << 1;
long long right = left + 1;
segtree[id].minima = min(segtree[left].minima, segtree[right].minima);
segtree[id].maxima = max(segtree[left].maxima, segtree[right].maxima);
segtree[id].sum = segtree[left].sum + segtree[right].sum;
}
void buildSegmentTree(long long id, long long seg_low, long long seg_high) {
segtree[id].count = seg_high - seg_low + 1;
if (seg_low == seg_high) {
segtree[id].minima = segtree[id].maxima = segtree[id].sum = a[seg_low];
segtree[id].lazy = 0;
return;
}
long long seg_mid = seg_low + ((seg_high - seg_low) >> 1);
buildSegmentTree(id << 1, seg_low, seg_mid);
buildSegmentTree((id << 1) + 1, seg_mid + 1, seg_high);
combineChildrenResuts(id);
}
void applyChanges(long long id, long long y) {
segtree[id].lazy = segtree[id].minima = segtree[id].maxima = y;
segtree[id].sum = segtree[id].count * y;
}
void pushLaziness(long long id, long long sl, long long sr) {
if (sl != sr && segtree[id].lazy != 0) {
long long y = segtree[id].lazy;
applyChanges(id << 1, y);
applyChanges((id << 1) + 1, y);
}
segtree[id].lazy = 0;
}
void performMaxQuery(long long id, long long sgl, long long sgr, long long ql,
long long qr, long long y) {
if (sgr < ql || sgl > qr || segtree[id].minima >= y) {
return;
}
if (sgl >= ql && sgr <= qr && segtree[id].maxima < y) {
applyChanges(id, y);
return;
}
pushLaziness(id, sgl, sgr);
long long sgm = sgl + ((sgr - sgl) >> 1);
performMaxQuery(id << 1, sgl, sgm, ql, qr, y);
performMaxQuery((id << 1) + 1, sgm + 1, sgr, ql, qr, y);
combineChildrenResuts(id);
}
long long moveAndBuyMaxNumberQuery(long long id, long long sl, long long sr,
long long ql, long long qr, long long &y) {
if (sl > sr || sl > qr || sr < ql) {
return 0;
}
pushLaziness(id, sl, sr);
long long ans = 0, sm = sl + ((sr - sl) >> 1);
if (sl == ql && sr == qr) {
if (y >= segtree[id].sum) {
y -= segtree[id].sum;
ans += segtree[id].count;
return ans;
}
if (y < segtree[id].minima) {
return 0;
}
ans += moveAndBuyMaxNumberQuery(id << 1, sl, sm, ql, sm, y);
ans += moveAndBuyMaxNumberQuery((id << 1) + 1, sm + 1, sr, sm + 1, qr, y);
return ans;
}
if (qr <= sm) {
ans += moveAndBuyMaxNumberQuery(id << 1, sl, sm, ql, qr, y);
} else if (ql > sm) {
ans += moveAndBuyMaxNumberQuery((id << 1) + 1, sm + 1, sr, ql, qr, y);
} else {
ans += moveAndBuyMaxNumberQuery(id << 1, sl, sm, ql, sm, y);
ans += moveAndBuyMaxNumberQuery((id << 1) + 1, sm + 1, sr, sm + 1, qr, y);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> q;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
buildSegmentTree(1, 1, n);
while (q--) {
long long tp, x, y;
cin >> tp >> x >> y;
if (tp == 1) {
performMaxQuery(1, 1, n, 1, x, y);
} else {
cout << moveAndBuyMaxNumberQuery(1, 1, n, x, n, y) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int inf = 1e9;
long long sum[maxn << 2];
int mn[maxn << 2], mx[maxn << 2], lazy[maxn << 2], a[maxn];
inline void pushup(int rt) {
int r1 = (rt << 1), r2 = (rt << 1 | 1);
mn[rt] = min(mn[r1], mn[r2]);
mx[rt] = max(mx[r1], mx[r2]);
sum[rt] = sum[r1] + sum[r2];
}
inline void pushdown(int l, int r, int rt) {
if (lazy[rt]) {
int r1 = (rt << 1), r2 = (rt << 1 | 1), mid = (l + r) >> 1;
sum[r1] = (mid - l + 1LL) * lazy[rt];
sum[r2] = (long long)(r - mid) * lazy[rt];
mx[r1] = mx[r2] = lazy[rt];
mn[r1] = mn[r2] = lazy[rt];
lazy[r1] = lazy[r2] = lazy[rt];
lazy[rt] = 0;
}
}
inline void build(int l, int r, int rt) {
if (l == r)
sum[rt] = mx[rt] = mn[rt] = a[l];
else {
int mid = (l + r) >> 1;
build(l, mid, (rt << 1));
build(mid + 1, r, (rt << 1 | 1));
pushup(rt);
}
}
inline void update(int l, int r, int x, int y, int rt) {
if (r <= x && mx[rt] < y) {
mx[rt] = mn[rt] = lazy[rt] = y;
sum[rt] = (r - l + 1LL) * y;
return;
}
pushdown(l, r, rt);
int mid = (l + r) >> 1;
if (mn[(rt << 1)] < y) update(l, mid, x, y, (rt << 1));
if (x > mid && mn[(rt << 1 | 1)] < y) update(mid + 1, r, x, y, (rt << 1 | 1));
pushup(rt);
}
inline int query(int l, int r, int L, int R, int k, int rt) {
if (l == r) return mn[rt] <= k ? l : -1;
pushdown(l, r, rt);
int mid = (l + r) >> 1, ans = -1;
if (L <= mid && mn[(rt << 1)] <= k)
ans = query(l, mid, L, R, k, (rt << 1));
else if (R > mid && mn[(rt << 1 | 1)] <= k)
ans = query(mid + 1, r, L, R, k, (rt << 1 | 1));
pushup(rt);
return ans;
}
inline int getsum(int l, int r, int L, int R, int &y, int rt) {
if (L <= l && r <= R && sum[rt] <= y) {
y -= sum[rt];
return r - l + 1;
}
if (l == r || !y) return 0;
pushdown(l, r, rt);
int mid = (l + r) >> 1, ans = 0;
if (L <= mid && mn[(rt << 1)] <= y) ans += getsum(l, mid, L, R, y, (rt << 1));
if (R > mid) ans += getsum(mid + 1, r, L, R, y, (rt << 1 | 1));
pushup(rt);
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n, q, t, x, y;
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> a[i];
build(1, n, 1);
while (q--) {
cin >> t >> x >> y;
if (t == 1) {
update(1, n, x, y, 1);
} else {
int s = query(1, n, x, n, y, 1);
if (~s)
cout << getsum(1, n, s, n, y, 1) << '\n';
else
cout << 0 << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct Fenwick {
vector<long long int> bit;
long long int size;
void modify(long long int j, long long int v) {
j++;
for (; j < size; j += j & -j) bit[j] += v;
}
long long int query(long long int j) {
j++;
long long int v = 0;
for (; j > 0; j -= j & -j) v += bit[j];
return v;
}
long long int rangequery(long long int a, long long int b) {
return query(b) - query(a - 1);
}
void rangeupdate(long long int a, long long int b, long long int v) {
modify(a, v);
modify(b + 1, -v);
}
Fenwick(long long int s) {
s += 3;
size = s;
bit = vector<long long int>(s, 0);
}
} data(200005);
map<long long int, long long int> st;
long long int prefix(long long int i) {
if (i == 0) return 0;
auto nxt = st.upper_bound(i);
auto prv = prev(nxt);
return data.query(prv->first) - prv->second * (nxt->first - i - 1);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, q;
cin >> n >> q;
st[n + 1] = 1e10;
st[0] = 0;
auto add = [&](long long int x, long long int v) {
auto nxt = st.lower_bound(x);
auto prv = prev(nxt);
data.modify(prv->first, -prv->second * (nxt->first - x));
data.modify(x, v * (nxt->first - x));
st[x] = v;
};
auto erase = [&](long long int x) {
st.erase(x);
data.modify(x, -data.rangequery(x, x));
auto nxt = st.lower_bound(x);
auto prv = prev(nxt);
data.modify(prv->first, prv->second * (nxt->first - x));
};
auto add_stack = [&](long long int i, long long int x) {
auto itr = st.lower_bound(i);
if (itr->first == i) {
if (itr->second < x) {
erase(i);
add(i, x);
} else
return;
} else if (prev(itr)->second < x) {
add(i, x);
}
itr = st.find(i);
while (x >= next(itr)->second) erase(next(itr)->first);
};
vector<long long int> arr(n + 1);
for (long long int i = n; i >= 1; i--) {
cin >> arr[i];
add_stack(i, arr[i]);
}
while (q--) {
long long int k, x, y;
cin >> k >> x >> y;
x = n - x + 1;
if (k == 1) {
add_stack(x, y);
} else {
long long int cnt = 0;
while (x && y >= (++st.begin())->second) {
long long int l = 0, r = 0;
for (long long int w = (1 << 20); w >= 1; w >>= 1) {
long long int p = r + w;
if (x < p) continue;
if ((--st.upper_bound(p))->second <= y) {
r = p;
}
}
l = r;
for (long long int w = (1 << 20); w >= 1; w >>= 1) {
long long int p = l - w;
if (p <= 0) continue;
if (prefix(r) - prefix(p - 1) <= y) l = p;
}
y -= prefix(r) - prefix(l - 1);
cnt += r - l + 1;
x = l - 1;
}
cout << cnt << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T, size_t N>
inline ostream &operator<<(ostream &os, const array<T, N> &a) {
os << "[";
int cnt = 0;
for (auto &val : a) {
if (cnt++) os << ", ";
os << val;
}
os << "]";
return os;
}
template <typename T>
inline ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[";
int cnt = 0;
for (auto &val : v) {
if (cnt++) os << ", ";
os << val;
}
return os << "]";
}
template <typename T>
inline ostream &operator<<(ostream &os, const set<T> &v) {
os << "{";
int cnt = 0;
for (auto &val : v) {
if (cnt++) os << ", ";
os << val;
}
return os << "}";
}
template <typename T>
inline ostream &operator<<(ostream &os, const multiset<T> &v) {
os << "{";
int cnt = 0;
for (auto &val : v) {
if (cnt++) os << ", ";
os << val;
}
return os << "}";
}
template <typename T1, typename T2>
inline ostream &operator<<(ostream &os, const map<T1, T2> &v) {
os << "[";
int cnt = 0;
for (auto &val : v) {
if (cnt++) os << ", ";
os << val;
}
return os << "]";
}
template <typename Arg1>
void __f(const char *name, Arg1 &&arg1) {
cerr << name << ": " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << ": " << arg1 << " |";
__f(comma + 1, args...);
}
using ll = long long;
using ull = unsigned long long;
using vi = vector<int>;
using vll = vector<long long>;
using vvi = vector<vector<int>>;
using vs = vector<string>;
using vb = vector<bool>;
using vvb = vector<vector<bool>>;
using vc = vector<char>;
using si = set<int>;
using mpii = map<int, int>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const int dx[] = {-1, 1, 0, 0};
const int dy[] = {0, 0, 1, -1};
template <class T>
inline bool umin(T &a, const T b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
inline bool umax(T &a, const T b) {
return a < b ? a = b, 1 : 0;
}
struct SegmentTree {
struct data {
int mi, ma;
ll sum;
data() {}
data(int _mi, int _ma, ll _sum) : mi(_mi), ma(_ma), sum(_sum) {}
};
struct node {
int l, r;
int lazy;
data val;
node() {}
} t[200004 << 2];
SegmentTree() {}
void build(int id, int l, int r, vi &a) {
t[id].l = l;
t[id].r = r;
t[id].lazy = 0;
if (l == r) {
t[id].val = data(a[l], a[l], a[l]);
} else {
int mid = (l + r) >> 1;
build((id << 1), l, mid, a);
build(((id << 1) | 1), mid + 1, r, a);
t[id].val = merge(t[(id << 1)].val, t[((id << 1) | 1)].val);
}
}
void apply(int id, int ma) {
t[id].lazy = ma;
ll len = t[id].r - t[id].l + 1;
t[id].val = data(ma, ma, len * ma);
}
void pushDown(int id) {
assert(t[id].l != t[id].r);
if (t[id].lazy > 0) {
apply((id << 1), t[id].lazy);
apply(((id << 1) | 1), t[id].lazy);
}
t[id].lazy = 0;
}
data merge(const data &ld, const data &rd) {
assert(ld.ma >= ld.mi);
assert(rd.ma >= rd.mi);
assert(ld.mi >= rd.ma);
return data(min(ld.mi, rd.mi), max(ld.ma, rd.ma), ld.sum + rd.sum);
}
void updateMax(int id, int l, int r, int ma) {
if (t[id].l == t[id].r) {
assert(t[id].val.mi == t[id].val.ma);
assert(t[id].val.mi == t[id].val.sum);
int newVal = max(t[id].val.ma, ma);
t[id].val = data(newVal, newVal, 1LL * newVal);
return;
}
if (t[id].l == l && t[id].r == r) {
if (ma >= t[id].val.ma) {
apply(id, ma);
} else if (ma >= t[id].val.mi) {
pushDown(id);
int mid = (t[id].l + t[id].r) >> 1;
updateMax((id << 1), l, mid, ma);
updateMax(((id << 1) | 1), mid + 1, r, ma);
t[id].val = merge(t[(id << 1)].val, t[((id << 1) | 1)].val);
}
return;
}
pushDown(id);
int mid = (t[id].l + t[id].r) >> 1;
if (r <= mid)
updateMax((id << 1), l, r, ma);
else if (l > mid)
updateMax(((id << 1) | 1), l, r, ma);
else {
updateMax((id << 1), l, mid, ma);
updateMax(((id << 1) | 1), mid + 1, r, ma);
}
t[id].val = merge(t[(id << 1)].val, t[((id << 1) | 1)].val);
}
void query(int id, int l, int r, ll &had, int &got) {
if (t[id].l == t[id].r) {
assert(t[id].val.mi == t[id].val.ma);
assert(t[id].val.mi == t[id].val.sum);
if (had >= t[id].val.sum) {
had -= t[id].val.sum;
got += t[id].r - t[id].l + 1;
}
return;
}
if (t[id].l == l && t[id].r == r) {
if (had >= t[id].val.sum) {
had -= t[id].val.sum;
got += t[id].r - t[id].l + 1;
} else if (had >= t[id].val.mi) {
pushDown(id);
int mid = (t[id].l + t[id].r) >> 1;
query((id << 1), l, mid, had, got);
query(((id << 1) | 1), mid + 1, r, had, got);
}
return;
}
pushDown(id);
int mid = (t[id].l + t[id].r) >> 1;
if (r <= mid)
query((id << 1), l, r, had, got);
else if (l > mid)
query(((id << 1) | 1), l, r, had, got);
else {
query((id << 1), l, mid, had, got);
query(((id << 1) | 1), mid + 1, r, had, got);
}
}
int query2(int id, int pos) {
if (t[id].l == t[id].r) {
assert(t[id].val.mi == t[id].val.ma);
assert(t[id].val.mi == t[id].val.sum);
return t[id].val.mi;
}
pushDown(id);
int mid = (t[id].l + t[id].r) >> 1;
if (pos <= mid)
return query2((id << 1), pos);
else
return query2(((id << 1) | 1), pos);
}
} st;
int n, m;
void solve() {
vi a(n + 1, 0);
for (int i = 1; i <= n; i++) cin >> a[i];
st.build(1, 1, n, a);
while (m--) {
int op, pos, val;
cin >> op >> pos >> val;
if (op == 1) {
st.updateMax(1, 1, pos, val);
} else if (op == 2) {
ll had = val;
int got = 0;
st.query(1, pos, n, had, got);
cout << got << endl;
}
}
}
void solve(int _cas) { solve(); }
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL), cout.precision(12);
while (cin >> n >> m) solve(1);
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using db = double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<db, db>;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<db>;
using vs = vector<str>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
template <class T>
using V = vector<T>;
template <class T, size_t SZ>
using AR = array<T, SZ>;
template <class T>
using PR = pair<T, T>;
const int MOD = 1e9 + 7;
const int mxN = 2e5 + 5;
const ll INF = 1e18;
const ld PI = acos((ld)-1);
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;
constexpr int pct(int x) { return __builtin_popcount(x); }
constexpr int bits(int x) { return 31 - __builtin_clz(x); }
ll cdiv(ll a, ll b) { return a / b + ((a ^ b) > 0 && a % b); }
ll fdiv(ll a, ll b) { return a / b - ((a ^ b) < 0 && a % b); }
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
template <class T, class U>
T fstTrue(T lo, T hi, U first) {
hi++;
assert(lo <= hi);
while (lo < hi) {
T mid = lo + (hi - lo) / 2;
first(mid) ? hi = mid : lo = mid + 1;
}
return lo;
}
template <class T, class U>
T lstTrue(T lo, T hi, U first) {
lo--;
assert(lo <= hi);
while (lo < hi) {
T mid = lo + (hi - lo + 1) / 2;
first(mid) ? lo = mid : hi = mid - 1;
}
return lo;
}
template <class T>
void remDup(vector<T>& v) {
sort(begin(v), end(v));
v.erase(unique(begin(v), end(v)), end(v));
}
template <class T, class U>
void erase(T& t, const U& u) {
auto it = t.find(u);
assert(it != end(t));
t.erase(u);
}
template <class T>
void re(complex<T>& c);
template <class T, class U>
void re(pair<T, U>& p);
template <class T>
void re(vector<T>& v);
template <class T, size_t SZ>
void re(AR<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(db& d) {
str t;
re(t);
d = stod(t);
}
void re(ld& d) {
str t;
re(t);
d = stold(t);
}
template <class T, class... U>
void re(T& t, U&... u) {
re(t);
re(u...);
}
template <class T>
void re(complex<T>& c) {
T a, b;
re(a, b);
c = {a, b};
}
template <class T, class U>
void re(pair<T, U>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& x) {
for (auto& a : x) re(a);
}
template <class T, size_t SZ>
void re(AR<T, SZ>& x) {
for (auto& a : x) re(a);
}
template <class T>
void rv(int& n, vector<T>& x) {
re(n);
x.resize(n);
for (auto& a : x) re(a);
}
str to_string(char c) { return str(1, c); }
str to_string(const char* second) { return (str)second; }
str to_string(str second) { return second; }
str to_string(bool b) { return to_string((int)b); }
template <class T>
str to_string(complex<T> c) {
stringstream ss;
ss << c;
return ss.str();
}
str to_string(vector<bool> v) {
str res = "{";
for (int i = (0); i < ((int)(v).size()); ++i) res += char('0' + v[i]);
res += "}";
return res;
}
template <size_t SZ>
str to_string(bitset<SZ> b) {
str res = "";
for (int i = (0); i < (SZ); ++i) res += char('0' + b[i]);
return res;
}
template <class T, class U>
str to_string(pair<T, U> p);
template <class T>
str to_string(T v) {
bool fst = 1;
str res = "";
for (const auto& x : v) {
if (!fst) res += " ";
fst = 0;
res += to_string(x);
}
return res;
}
template <class T, class U>
str to_string(pair<T, U> p) {
return to_string(p.first) + " " + to_string(p.second);
}
template <class T>
void pr(T x) {
cout << to_string(x);
}
template <class T, class... U>
void pr(const T& t, const U&... u) {
pr(t);
pr(u...);
}
void ps() { pr("\n"); }
template <class T, class... U>
void ps(const T& t, const U&... u) {
pr(t);
if (sizeof...(u)) pr(" ");
ps(u...);
}
void DBG() { cerr << "]" << endl; }
template <class T, class... U>
void DBG(const T& t, const U&... u) {
cerr << to_string(t);
if (sizeof...(u)) cerr << ", ";
DBG(u...);
}
void setIn(str second) { freopen(second.c_str(), "r", stdin); }
void setOut(str second) { freopen(second.c_str(), "w", stdout); }
void unsyncIO() { cin.tie(0)->sync_with_stdio(0); }
void setIO(str second = "") {
unsyncIO();
if ((int)(second).size()) {
setIn(second + ".in"), setOut(second + ".out");
}
}
int n, m;
struct segm_tree {
ll tree[mxN << 2], lazy[mxN << 2], mn[mxN << 2];
segm_tree() {
for (int i = 0; i < mxN * 2; i++) {
tree[i] = lazy[i] = 0;
}
}
void push(int k, int l, int r) {
if (lazy[k]) {
tree[k] = lazy[k] * (r - l + 1);
mn[k] = lazy[k];
if (l != r) {
lazy[k << 1] = lazy[k << 1 | 1] = lazy[k];
}
lazy[k] = 0;
}
}
void update(int k, int l, int r, int i, int j, ll val) {
push(k, l, r);
if (r < i || l > j || l > r) return;
if (r <= j && l >= i) {
tree[k] = (r - l + 1) * val;
mn[k] = val;
if (l != r) {
lazy[k << 1] = lazy[k << 1 | 1] = val;
}
return;
}
int middle = (l + r) >> 1;
update(k << 1, l, middle, i, j, val);
update(k << 1 | 1, middle + 1, r, i, j, val);
tree[k] = tree[k << 1] + tree[k << 1 | 1];
mn[k] = min(mn[k << 1], mn[k << 1 | 1]);
}
ll query(int k, int l, int r, int i, int j) {
if (r < i || l > j || l > r) return 0;
push(k, l, r);
if (r <= j && l >= i) {
return tree[k];
}
int middle = (l + r) >> 1;
return query(k << 1, l, middle, i, j) +
query(k << 1 | 1, middle + 1, r, i, j);
}
ll query(int k, int l, int r, int i, int j, ll& y) {
if (r < i || l > j || l > r) return 0;
push(k, l, r);
if (r <= j && l >= i && tree[k] <= y) {
y -= tree[k];
return (r - l + 1);
}
if (mn[k] > y) {
return 0;
}
int middle = (l + r) >> 1;
return query(k << 1, l, middle, i, j, y) +
query(k << 1 | 1, middle + 1, r, i, j, y);
}
void update(ll val, int ind) {
int l = 1, r = n;
int ans = n + 1;
while (l <= r) {
int middle = (l + r) >> 1;
if (query(1, 1, n, middle, middle) < val) {
ans = middle;
r = middle - 1;
} else {
l = middle + 1;
}
}
update(1, 1, n, ans, ind, val);
}
} m_tree;
int main() {
setIO();
re(n, m);
ll c;
for (int i = 1; i <= n; i++) {
re(c);
m_tree.update(1, 1, n, i, i, c);
}
ll t, x, y;
for (int i = 0; i < m; i++) {
re(t, x, y);
if (t == 1) {
m_tree.update(y, x);
} else {
ps(m_tree.query(1, 1, n, x, n, y));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long rd() {
long long X = 0;
bool flag = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') flag = 0;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
X = (X << 1) + (X << 3) + ch - '0';
ch = getchar();
}
if (flag) return X;
return ~(X - 1);
}
const int N = 5e5 + 5, SZ = N << 2, INF = 0x7fffffff;
int n, m;
int a[N];
struct data {
int mx, mx2, mn, mn2, cmx, cmn, tmx, tmn, tad;
long long sum;
};
data t[SZ];
void pushup(int u) {
const int lu = u << 1, ru = u << 1 | 1;
t[u].sum = t[lu].sum + t[ru].sum;
if (t[lu].mx == t[ru].mx) {
t[u].mx = t[lu].mx, t[u].cmx = t[lu].cmx + t[ru].cmx;
t[u].mx2 = max(t[lu].mx2, t[ru].mx2);
} else if (t[lu].mx > t[ru].mx) {
t[u].mx = t[lu].mx, t[u].cmx = t[lu].cmx;
t[u].mx2 = max(t[lu].mx2, t[ru].mx);
} else {
t[u].mx = t[ru].mx, t[u].cmx = t[ru].cmx;
t[u].mx2 = max(t[lu].mx, t[ru].mx2);
}
if (t[lu].mn == t[ru].mn) {
t[u].mn = t[lu].mn, t[u].cmn = t[lu].cmn + t[ru].cmn;
t[u].mn2 = min(t[lu].mn2, t[ru].mn2);
} else if (t[lu].mn < t[ru].mn) {
t[u].mn = t[lu].mn, t[u].cmn = t[lu].cmn;
t[u].mn2 = min(t[lu].mn2, t[ru].mn);
} else {
t[u].mn = t[ru].mn, t[u].cmn = t[ru].cmn;
t[u].mn2 = min(t[lu].mn, t[ru].mn2);
}
}
void push_add(int u, int l, int r, int v) {
t[u].sum += (r - l + 1ll) * v;
t[u].mx += v, t[u].mn += v;
if (t[u].mx2 != -INF) t[u].mx2 += v;
if (t[u].mn2 != INF) t[u].mn2 += v;
if (t[u].tmx != -INF) t[u].tmx += v;
if (t[u].tmn != INF) t[u].tmn += v;
t[u].tad += v;
}
void push_min(int u, int tg) {
if (t[u].mx <= tg) return;
t[u].sum += (tg * 1ll - t[u].mx) * t[u].cmx;
if (t[u].mn2 == t[u].mx) t[u].mn2 = tg;
if (t[u].mn == t[u].mx) t[u].mn = tg;
if (t[u].tmx > tg) t[u].tmx = tg;
t[u].mx = tg, t[u].tmn = tg;
}
void push_max(int u, int tg) {
if (t[u].mn > tg) return;
t[u].sum += (tg * 1ll - t[u].mn) * t[u].cmn;
if (t[u].mx2 == t[u].mn) t[u].mx2 = tg;
if (t[u].mx == t[u].mn) t[u].mx = tg;
if (t[u].tmn < tg) t[u].tmn = tg;
t[u].mn = tg, t[u].tmx = tg;
}
void pushdown(int u, int l, int r) {
const int lu = u << 1, ru = u << 1 | 1, mid = (l + r) >> 1;
if (t[u].tad)
push_add(lu, l, mid, t[u].tad), push_add(ru, mid + 1, r, t[u].tad);
if (t[u].tmx != -INF) push_max(lu, t[u].tmx), push_max(ru, t[u].tmx);
if (t[u].tmn != INF) push_min(lu, t[u].tmn), push_min(ru, t[u].tmn);
t[u].tad = 0, t[u].tmx = -INF, t[u].tmn = INF;
}
void build(int u = 1, int l = 1, int r = n) {
t[u].tmn = INF, t[u].tmx = -INF;
if (l == r) {
t[u].sum = t[u].mx = t[u].mn = a[l];
t[u].mx2 = -INF, t[u].mn2 = INF;
t[u].cmx = t[u].cmn = 1;
return;
}
int mid = (l + r) >> 1;
build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
pushup(u);
}
void add(int L, int R, int v, int u = 1, int l = 1, int r = n) {
if (R < l || r < L) return;
if (L <= l && r <= R) return push_add(u, l, r, v);
int mid = (l + r) >> 1;
pushdown(u, l, r);
add(L, R, v, u << 1, l, mid), add(L, R, v, u << 1 | 1, mid + 1, r);
pushup(u);
}
void tomax(int L, int R, int v, int u = 1, int l = 1, int r = n) {
if (R < l || r < L || t[u].mn >= v) return;
if (L <= l && r <= R && t[u].mn2 > v) return push_max(u, v);
int mid = (l + r) >> 1;
pushdown(u, l, r);
tomax(L, R, v, u << 1, l, mid), tomax(L, R, v, u << 1 | 1, mid + 1, r);
pushup(u);
}
long long qmin(int L, int R, int u = 1, int l = 1, int r = n) {
if (R < l || r < L) return INF;
if (L <= l && r <= R) return t[u].mn;
int mid = (l + r) >> 1;
pushdown(u, l, r);
return min(qmin(L, R, u << 1, l, mid), qmin(L, R, u << 1 | 1, mid + 1, r));
}
int y;
int bns(int l, int r) {
int res = -1;
while (l <= r) {
int md = l + r >> 1;
if (qmin(md, md) <= y)
res = md, r = md - 1;
else
l = md + 1;
}
return res;
}
long long qsum(int L, int R, int u = 1, int l = 1, int r = n) {
if (R < l || r < L) return 0;
int mid = (l + r) >> 1;
if (L <= l && r <= R) {
if (t[u].sum <= y && y > 0) {
y -= t[u].sum;
return r - l + 1;
} else {
pushdown(u, l, r);
if (t[u].mn > y) return 0;
return qsum(L, R, u << 1, l, mid) + qsum(L, R, u << 1 | 1, mid + 1, r);
}
}
pushdown(u, l, r);
return qsum(L, R, u << 1, l, mid) + qsum(L, R, u << 1 | 1, mid + 1, r);
}
int main() {
n = rd();
m = rd();
for (int i = 1; i <= n; i++) a[i] = rd();
build();
for (int i = 1; i <= m; i++) {
int op, l, x;
op = rd(), l = rd(), y = rd();
if (op == 1)
tomax(1, l, y);
else
printf("%lld\n", qsum(l, n));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, q;
long long tag, x, y;
long long a[N];
struct node {
long long sum;
int lazy;
} t[N << 2];
inline void push_up(int root) {
t[root].sum = t[root << 1].sum + t[root << 1 | 1].sum;
}
inline void push_down(int root, int l, int r) {
t[root].sum = 1ll * (r - l + 1) * t[root].lazy;
a[l] = a[r] = t[root].lazy;
if (l < r) {
t[root << 1].lazy = t[root << 1 | 1].lazy = t[root].lazy;
}
t[root].lazy = 0;
}
inline void build(int l, int r, int root) {
if (l == r) {
t[root].sum = a[l];
t[root].lazy = 0;
return;
}
int mid = (l + r) >> 1;
build(l, mid, root << 1);
build(mid + 1, r, root << 1 | 1);
push_up(root);
}
inline void upd(int l, int r, int root, long long x, long long y) {
if (t[root].lazy) {
push_down(root, l, r);
}
if (l > x || a[r] >= y) return;
if (a[l] <= y && r <= x) {
t[root].lazy = y;
push_down(root, l, r);
return;
}
int mid = (l + r) >> 1;
upd(l, mid, root << 1, x, y);
upd(mid + 1, r, root << 1 | 1, x, y);
push_up(root);
}
long long now;
inline long long query(int l, int r, int root, long long x) {
if (t[root].lazy) {
push_down(root, l, r);
}
if (r < x || a[r] > now) return 0;
if (now >= t[root].sum && l >= x) {
now -= t[root].sum;
return r - l + 1ll;
}
if (l == r) return 0;
int mid = (l + r) >> 1;
long long res = query(l, mid, root << 1, x);
res += query(mid + 1, r, root << 1 | 1, x);
return res;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
build(1, n, 1);
for (int i = 1; i <= q; i++) {
scanf("%lld%lld%lld", &tag, &x, &y);
if (tag == 1) {
upd(1, n, 1, x, y);
} else {
now = y;
printf("%lld\n", query(1, n, 1, x));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, m, q;
long long w[N];
struct node {
int l, r;
long long sum, maxx, minn, tag;
} tr[N * 4];
void pushup(int u) {
tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
tr[u].minn = min(tr[u << 1].minn, tr[u << 1 | 1].minn);
tr[u].maxx = max(tr[u << 1].maxx, tr[u << 1 | 1].maxx);
}
void pushdown(int u) {
auto &root = tr[u], &lson = tr[u << 1], &rson = tr[u << 1 | 1];
if (root.tag) {
lson.tag = rson.tag = root.tag;
lson.maxx = lson.minn = root.tag;
rson.maxx = rson.minn = root.tag;
lson.sum = root.tag * (lson.r - lson.l + 1);
rson.sum = root.tag * (rson.r - rson.l + 1);
root.tag = 0;
}
}
void build(int u, int l, int r) {
tr[u].l = l, tr[u].r = r;
if (l == r) {
tr[u].sum = tr[u].maxx = tr[u].minn = w[l];
tr[u].tag = 0;
return;
}
int mid = l + r >> 1;
build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
pushup(u);
}
void update(int u, int l, int r, long long k) {
if (tr[u].minn >= k) return;
if (tr[u].l >= l && tr[u].r <= r && tr[u].maxx <= k) {
tr[u].sum = k * (tr[u].r - tr[u].l + 1);
tr[u].minn = tr[u].maxx = tr[u].tag = k;
return;
}
pushdown(u);
int mid = tr[u].l + tr[u].r >> 1;
if (l <= mid) update(u << 1, l, r, k);
if (r > mid) update(u << 1 | 1, l, r, k);
pushup(u);
}
long long query(int u, int l, int r, long long &k) {
if (tr[u].minn > k) return 0ll;
if (tr[u].l >= l && tr[u].r <= r && tr[u].sum <= k) {
k -= tr[u].sum;
return 1ll * (tr[u].r - tr[u].l + 1);
}
pushdown(u);
long long res = 0;
int mid = tr[u].l + tr[u].r >> 1;
if (l <= mid) res += query(u << 1, l, r, k);
if (r > mid) res += query(u << 1 | 1, l, r, k);
return res;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%lld", &w[i]);
build(1, 1, n);
int op, x;
long long y;
while (q--) {
scanf("%d%d%lld", &op, &x, &y);
if (op == 1)
update(1, 1, x, y);
else
printf("%lld\n", query(1, x, n, y));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 23;
int t, n, m, q;
int a[N];
int mx[N << 2], se[N << 2], cn[N << 2], tag[N << 2];
long long sum[N << 2];
inline void pushup(int u) {
const int ls = u << 1, rs = u << 1 | 1;
sum[u] = sum[ls] + sum[rs];
if (mx[ls] == mx[rs]) {
mx[u] = mx[rs];
se[u] = max(se[ls], se[rs]);
cn[u] = cn[ls] + cn[rs];
} else if (mx[ls] > mx[rs]) {
mx[u] = mx[ls];
se[u] = max(se[ls], mx[rs]);
cn[u] = cn[ls];
} else {
mx[u] = mx[rs];
se[u] = max(mx[ls], se[rs]);
cn[u] = cn[rs];
}
}
inline void pushtag(int u, int tg) {
if (mx[u] <= tg) return;
sum[u] += (1ll * tg - mx[u]) * cn[u];
mx[u] = tag[u] = tg;
}
inline void pushdown(int u) {
if (tag[u] == -1) return;
pushtag(u << 1, tag[u]), pushtag(u << 1 | 1, tag[u]);
tag[u] = -1;
}
void build(int u = 1, int l = 1, int r = n) {
tag[u] = -1;
if (l == r) {
sum[u] = mx[u] = a[l], se[u] = -1e9 - 10, cn[u] = 1;
return;
}
int mid = (l + r) >> 1;
build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
pushup(u);
}
void modify_min(int L, int R, int v, int u = 1, int l = 1, int r = n) {
if (mx[u] <= v) return;
if (L <= l && r <= R && se[u] < v) return pushtag(u, v);
int mid = (l + r) >> 1;
pushdown(u);
if (L <= mid) modify_min(L, R, v, u << 1, l, mid);
if (mid < R) modify_min(L, R, v, u << 1 | 1, mid + 1, r);
pushup(u);
}
int query_max(int L, int R, int u = 1, int l = 1, int r = n) {
if (L <= l && r <= R) return mx[u];
int mid = (l + r) >> 1, r1 = -1e9, r2 = -1e9;
pushdown(u);
if (L <= mid) r1 = query_max(L, R, u << 1, l, mid);
if (mid < R) r2 = query_max(L, R, u << 1 | 1, mid + 1, r);
return max(r1, r2);
}
long long query_sum(int L, int R, int u = 1, int l = 1, int r = n) {
if (L <= l && r <= R) return sum[u];
int mid = (l + r) >> 1;
long long res = 0;
pushdown(u);
if (L <= mid) res += query_sum(L, R, u << 1, l, mid);
if (mid < R) res += query_sum(L, R, u << 1 | 1, mid + 1, r);
return res;
}
int _query_sum(long long v, int u = 1, int l = 1, int r = n) {
if (l == r) {
return l;
}
int mid = (l + r) >> 1;
pushdown(u);
if (-sum[u << 1] > v)
return _query_sum(v, u << 1, l, mid);
else
return _query_sum(v + sum[u << 1], u << 1 | 1, mid + 1, r);
}
int _query_max(int v, int L, int R, int u = 1, int l = 1, int r = n) {
if (l == r) return l;
if (L <= l && r <= R) {
int mid = (l + r) >> 1;
if (mx[u << 1] >= v)
return _query_max(v, L, R, u << 1, l, mid);
else
return _query_max(v, L, R, u << 1 | 1, mid + 1, r);
}
int mid = (l + r) >> 1, mn = 1e9;
pushdown(u);
if (L <= mid && mx[u << 1] >= v)
mn = min(mn, _query_max(v, L, R, u << 1, l, mid));
if (mid < R && mx[u << 1 | 1] >= v)
mn = min(mn, _query_max(v, L, R, u << 1 | 1, mid + 1, r));
return mn;
}
int main() {
cin >> n >> q;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), a[i] = -a[i];
build();
while (q--) {
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
if (t == 1) {
modify_min(1, x, -y);
} else {
int ans = 0;
int l = x, r = n;
while (l <= n) {
int cur = -query_max(l, l);
if (cur > y) {
int L = l, R = n;
int res = _query_max(-y, L, R);
if (res > n) break;
l = res;
}
int st = l;
long long _sum = st > 1 ? query_sum(1, st - 1) : 0;
if (-query_sum(st, n) <= y) {
ans += n - st + 1;
break;
}
int res = _query_sum(-_sum + y) - 1;
ans += res - st + 1;
l = res + 1;
y += query_sum(st, res);
}
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int N, Q;
int A[200005];
namespace SEGTREE {
int ts, st;
struct NODE {
long long sum;
int max, min, lazy;
};
vector<NODE> tree;
NODE combine(const NODE &l, const NODE &r) {
return {l.sum + r.sum, max(l.max, r.max), min(l.min, r.min), 0};
}
void build() {
for (ts = 1; ts < N; ts <<= 1)
;
ts <<= 1;
st = (ts >> 1) - 1;
tree.resize(ts);
for (int i = 1; i <= N; i++) tree[st + i] = {A[i], A[i], A[i], 0};
for (int i = st; i; i--) tree[i] = combine(tree[i << 1], tree[i << 1 | 1]);
}
void apply(int n, int v) {
tree[n] = {((long long)1 << __builtin_clz(n) - __builtin_clz(ts) - 1) * v, v,
v, v};
}
void propagate(int n) {
if (!tree[n].lazy) return;
apply(n << 1, tree[n].lazy);
apply(n << 1 | 1, tree[n].lazy);
tree[n].lazy = 0;
}
void lazy_up(int n) {
for (n >>= 1; n; n >>= 1)
if (!tree[n].lazy) tree[n] = combine(tree[n << 1], tree[n << 1 | 1]);
}
void lazy_down(int n) {
if (!n) return;
lazy_down(n >> 1);
if (!tree[n].lazy || n > st) return;
propagate(n);
}
void query(int r, int v) {
if (tree[1].min >= v) return;
int l = 1;
r += st;
while (l <= st) {
propagate(l);
if (tree[l << 1].min < v)
l <<= 1;
else
l = l << 1 | 1;
}
int l0 = l, r0 = r;
lazy_down(l0);
lazy_down(r0);
for (; l <= r; l >>= 1, r >>= 1) {
if (l & 1) apply(l++, v);
if (r & 1 ^ 1) apply(r--, v);
}
lazy_up(l0);
lazy_up(r0);
}
tuple<int, long long> find(int l, int v) {
if (l > N || tree[1].min > v) return {N + 1, 0};
int n = 1, s = 1, e = ts - st - 1;
long long sum = 0;
while (n <= st) {
propagate(n);
int m = s + e >> 1;
if (m >= l && tree[n << 1].min <= v)
n <<= 1, e = m;
else {
sum += tree[n << 1].sum;
n = n << 1 | 1;
s = m + 1;
}
}
return {n - st, sum};
}
tuple<int, long long> get_range(long long val) {
if (tree[1].sum <= val) return {N + 1, 0};
int n = 1;
long long val0 = val;
while (n <= st) {
propagate(n);
if (tree[n << 1].sum <= val)
val -= tree[n << 1].sum, n = n << 1 | 1;
else
n <<= 1;
}
return {n - st, val0 - val};
}
}; // namespace SEGTREE
int main() {
scanf("%d%d", &N, &Q);
for (int i = 1; i <= N; i++) scanf("%d", A + i);
SEGTREE::build();
while (Q--) {
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
if (t == 1)
SEGTREE::query(x, y);
else {
int ans = 0;
while (x <= N) {
auto [t, v] = SEGTREE::find(x, y);
if (t > N) break;
v += y;
auto [nxt, s] = SEGTREE::get_range(v);
ans += nxt - t;
y = v - s;
x = nxt;
}
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool check(long long n, long long pos) { return n & (1LL << pos); }
long long Set(long long n, long long pos) { return n = n | (1LL << pos); }
struct segTreemin {
long long n;
vector<long long> tree, lazy;
segTreemin(long long n) : n(n), tree(4 * n, 0), lazy(4 * n, -1) {}
void propagate(long long node, long long l, long long r) {
if (lazy[node] != -1) {
tree[node] = lazy[node];
if (l != r) lazy[2 * node] = lazy[node], lazy[2 * node + 1] = lazy[node];
}
lazy[node] = -1;
}
void treeUpdate(long long node, long long l, long long r, long long u,
long long v, long long val) {
long long mid = (l + r) >> 1;
propagate(node, l, r);
if (l > v || r < u) return;
if (l >= u && r <= v) {
lazy[node] = val;
propagate(node, l, r);
return;
}
treeUpdate(2 * node, l, mid, u, v, val);
treeUpdate(2 * node + 1, mid + 1, r, u, v, val);
tree[node] = min(tree[2 * node], tree[2 * node + 1]);
}
void update(long long l, long long r, long long val) {
treeUpdate(1, 1, n, l, r, val);
}
long long treeQuery(long long node, long long l, long long r, long long val) {
if (tree[node] > val) return n + 1;
long long mid = (l + r) >> 1;
propagate(node, l, r);
if (l == r) return l;
if (tree[2 * node] <= val) return treeQuery(2 * node, l, mid, val);
return treeQuery(2 * node + 1, mid + 1, r, val);
}
long long query(long long val) { return treeQuery(1, 1, n, val); }
};
struct segTreesum {
long long n;
vector<long long> tree, lazy;
segTreesum(long long n) : n(n), tree(4 * n, 0), lazy(4 * n, -1) {}
void propagate(long long node, long long l, long long r) {
if (lazy[node] != -1) {
tree[node] = lazy[node] * (r - l + 1);
if (l != r) lazy[2 * node] = lazy[node], lazy[2 * node + 1] = lazy[node];
}
lazy[node] = -1;
}
void treeUpdate(long long node, long long l, long long r, long long u,
long long v, long long val) {
long long mid = (l + r) >> 1;
propagate(node, l, r);
if (l > v || r < u) return;
if (l >= u && r <= v) {
lazy[node] = val;
propagate(node, l, r);
return;
}
treeUpdate(2 * node, l, mid, u, v, val);
treeUpdate(2 * node + 1, mid + 1, r, u, v, val);
tree[node] = (tree[2 * node] + tree[2 * node + 1]);
}
void update(long long l, long long r, long long val) {
treeUpdate(1, 1, n, l, r, val);
}
long long treeQuery(long long node, long long l, long long r, long long u,
long long v) {
long long mid = (l + r) >> 1;
propagate(node, l, r);
if (l > v || r < u) return 0;
if (l >= u && r <= v) return tree[node];
return (treeQuery(2 * node, l, mid, u, v) +
treeQuery(2 * node + 1, mid + 1, r, u, v));
}
long long query(long long l, long long r) { return treeQuery(1, 1, n, l, r); }
long long treeQuery2(long long node, long long l, long long r,
long long val) {
long long mid = (l + r) >> 1;
propagate(node, l, r);
if (l == r) {
if (tree[node] <= val) return l;
return l - 1;
}
propagate(2 * node, l, mid);
if (tree[2 * node] >= val) return treeQuery2(2 * node, l, mid, val);
propagate(2 * node + 1, mid + 1, r);
return treeQuery2(2 * node + 1, mid + 1, r, val - tree[2 * node]);
}
long long query2(long long val) { return treeQuery2(1, 1, n, val); }
};
long long arr[200005];
int main() {
long long i, j, k, l, m, n, o, r, q;
long long testcase;
long long input, flag, tag, ans;
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
while (cin >> n >> m) {
segTreemin seg1(n);
segTreesum seg2(n);
for (long long i = 1; i <= n; i++) {
cin >> arr[i];
seg1.update(i, i, arr[i]);
seg2.update(i, i, arr[i]);
}
for (long long i = 1; i <= m; i++) {
long long t, x, y;
cin >> t >> x >> y;
if (t == 1) {
long long pos = seg1.query(y);
if (pos <= x) {
seg1.update(pos, x, y);
seg2.update(pos, x, y);
}
} else {
ans = 0;
while (y) {
long long pos = seg1.query(y);
pos = max(pos, x);
if (pos > n) break;
long long tot = y;
if (pos > 1) tot += seg2.query(1, pos - 1);
long long ret = seg2.query2(tot);
ans += ret - pos + 1;
y -= seg2.query(pos, ret);
x = ret + 1;
assert(y >= 0);
}
cout << ans << "\n";
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, mod = 1e9 + 7;
int seg[4 * N], mx[4 * N], mn[4 * N];
long long sum[4 * N];
void relax(int ind, int s, int e, int mid) {
int x = seg[ind];
seg[ind] = 0;
if (!x) {
return;
}
seg[2 * ind] = mx[2 * ind] = seg[2 * ind + 1] = mx[2 * ind + 1] =
mn[2 * ind] = mn[2 * ind + 1] = x;
sum[2 * ind] = 1ll * (mid - s) * x;
sum[2 * ind + 1] = 1ll * (e - mid) * x;
}
void add(int s, int e, int ind, int l, int r, int val) {
if (s >= r || e <= l || mn[ind] >= val) return;
if (s >= l && e <= r && mx[ind] <= val) {
seg[ind] = mx[ind] = mn[ind] = val;
sum[ind] = 1ll * (e - s) * val;
return;
}
int mid = (s + e) / 2;
relax(ind, s, e, mid);
add(s, mid, 2 * ind, l, r, val);
add(mid, e, 2 * ind + 1, l, r, val);
mx[ind] = mx[2 * ind];
mn[ind] = mn[2 * ind + 1];
sum[ind] = sum[2 * ind] + sum[2 * ind + 1];
}
pair<int, int> get(int s, int e, int ind, int l, int r, int val) {
if (s >= r || e <= l || val < mn[ind]) return {0, 0};
if (s >= l && e <= r && sum[ind] <= val) {
return {e - s, sum[ind]};
}
int mid = (s + e) / 2;
relax(ind, s, e, mid);
pair<int, int> g = get(s, mid, 2 * ind, l, r, val);
pair<int, int> g2 = get(mid, e, 2 * ind + 1, l, r, val - g.second);
return {g.first + g2.first, g.second + g2.second};
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, q;
cin >> n >> q;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
add(0, n, 1, i, i + 1, x);
}
for (int i = 0; i < q; i++) {
int t, x, y;
cin >> t >> x >> y;
if (t == 1) {
add(0, n, 1, 0, x, y);
} else {
cout << get(0, n, 1, x - 1, n, y).first << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("omit-frame-pointer")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int MAXN = 2e5 + 7;
int mi[MAXN << 2], lazy[MAXN << 2], n, q;
long long sum[MAXN << 2];
void lazy_prop(int id, int l, int r) {
int t = lazy[id];
if (!t) return;
lazy[id] = 0;
sum[id] = 1LL * t * (r - l + 1);
mi[id] = t;
if (l != r) {
int g = id << 1;
lazy[g] = t;
lazy[g | 1] = t;
}
}
void update(int id, int l, int r, int i, int j, int v) {
lazy_prop(id, l, r);
if (i > r || j < l) return;
int mid = (l + r) >> 1, g = id << 1;
if (i <= l && j >= r) {
sum[id] = 1LL * (r - l + 1) * v;
mi[id] = v;
if (l != r) lazy[g] = v, lazy[g | 1] = v;
return;
}
update(g, l, mid, i, j, v);
update(g | 1, mid + 1, r, i, j, v);
sum[id] = sum[g] + sum[g | 1];
mi[id] = min(mi[g], mi[g | 1]);
}
long long getSum(int id, int l, int r, int i, int j) {
lazy_prop(id, l, r);
if (i > r || j < l) return 0;
if (i <= l && j >= r) return sum[id];
int mid = (l + r) >> 1, g = id << 1;
return getSum(g, l, mid, i, j) + getSum(g | 1, mid + 1, r, i, j);
}
int getMin(int id, int l, int r, int i, int j) {
lazy_prop(id, l, r);
if (i > r || j < l) return INT_MAX;
if (i <= l && j >= r) return mi[id];
int mid = (l + r) >> 1, g = id << 1;
return min(getMin(g, l, mid, i, j), getMin(g | 1, mid + 1, r, i, j));
}
int pos1(int id, int l, int r, int y) {
lazy_prop(id, l, r);
int mid = (l + r) >> 1, g = id << 1;
if (l != r) {
lazy_prop(g, l, mid);
lazy_prop(g | 1, mid + 1, r);
}
if (l == r) return mi[id] <= y ? l : n + 1;
if (mi[g] <= y) return pos1(g, l, mid, y);
return pos1(g | 1, mid + 1, r, y);
}
int pos2(int id, int l, int r, long long rest) {
lazy_prop(id, l, r);
int mid = (l + r) >> 1, g = id << 1;
if (l != r) {
lazy_prop(g, l, mid);
lazy_prop(g | 1, mid + 1, r);
}
if (l == r) return sum[id] <= rest ? l : l - 1;
if (sum[g] >= rest) return pos2(g, l, mid, rest);
return pos2(g | 1, mid + 1, r, rest - sum[g]);
}
int main() {
if (fopen("tst.inp", "r")) {
freopen("tst.inp", "r", stdin);
freopen("tst.out", "w", stdout);
}
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n >> q;
for (int i = 1, x; i <= n; ++i) {
cin >> x;
update(1, 1, n, i, i, x);
}
while (q--) {
int t, x, y;
cin >> t >> x >> y;
if (t == 1) {
int l = 1, r = x, p = 0;
while (l <= r) {
int mid = (l + r) >> 1;
if (getMin(1, 1, n, 1, mid) >= y)
p = mid, l = mid + 1;
else
r = mid - 1;
}
update(1, 1, n, p + 1, x, y);
} else {
int ll = x, ans = 0;
while (ll <= n && y) {
if (getMin(1, 1, n, ll, ll) > y) ll = pos1(1, 1, n, y);
if (ll > n) break;
int p = pos2(1, 1, n, 1LL * y + getSum(1, 1, n, 1, ll - 1));
y -= getSum(1, 1, n, ll, p);
ans += p - ll + 1;
ll = p + 1;
}
cout << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gi() {
char cc = getchar();
long long cn = 0, flus = 1;
while (cc < '0' || cc > '9') {
if (cc == '-') flus = -flus;
cc = getchar();
}
while (cc >= '0' && cc <= '9') cn = cn * 10 + cc - '0', cc = getchar();
return cn * flus;
}
const long long N = 2e5 + 5;
long long n, q, a[N];
struct Tr {
long long mx, mi, w, tag;
} tr[N << 2];
void pushup(long long x) {
tr[x].mi = min(tr[(x << 1)].mi, tr[(x << 1 | 1)].mi);
tr[x].mx = max(tr[(x << 1)].mx, tr[(x << 1 | 1)].mx);
tr[x].w = tr[(x << 1)].w + tr[(x << 1 | 1)].w;
}
void pushmark(long long x, long long l, long long r) {
long long u = tr[x].tag, mid = (l + r) >> 1;
if (!u) return;
tr[(x << 1)].tag = u, tr[(x << 1 | 1)].tag = u;
tr[(x << 1)].mx = u, tr[(x << 1)].w = (mid - l + 1) * u,
tr[(x << 1 | 1)].mx = u, tr[(x << 1 | 1)].w = (r - mid) * u;
tr[(x << 1)].mi = u, tr[(x << 1 | 1)].mi = u;
tr[x].tag = 0;
}
long long query(long long x, long long l, long long r, long long k) {
if (r <= k) return tr[x].w;
long long mid = (l + r) >> 1;
pushmark(x, l, r);
if (mid < k)
return tr[(x << 1)].w + query((x << 1 | 1), mid + 1, r, k);
else
return query((x << 1), l, mid, k);
}
void update(long long x, long long l, long long r, long long ql, long long qr,
long long k) {
if (ql <= l && r <= qr) {
tr[x].mx = tr[x].mi = tr[x].tag = k, tr[x].w = (r - l + 1) * k;
return;
}
if (l > qr || r < ql) return;
long long mid = (l + r) >> 1;
pushmark(x, l, r);
update((x << 1), l, mid, ql, qr, k),
update((x << 1 | 1), mid + 1, r, ql, qr, k);
pushup(x);
}
long long Get1(long long x, long long l, long long r, long long S) {
if (l == r) return (tr[x].mx <= S) ? l : n + 1;
long long mid = (l + r) >> 1;
pushmark(x, l, r);
if (tr[(x << 1)].mi <= S)
return Get1((x << 1), l, mid, S);
else
return Get1((x << 1 | 1), mid + 1, r, S);
}
long long Get2(long long x, long long l, long long r, long long S) {
if (l == r) return (tr[x].w <= S) ? l : l - 1;
long long mid = (l + r) >> 1;
pushmark(x, l, r);
if (tr[(x << 1)].w > S)
return Get2((x << 1), l, mid, S);
else
return Get2((x << 1 | 1), mid + 1, r, S - tr[(x << 1)].w);
}
void build(long long x, long long l, long long r) {
if (l == r) return tr[x].w = tr[x].mi = tr[x].mx = a[l], void();
long long mid = (l + r) >> 1;
build((x << 1), l, mid), build((x << 1 | 1), mid + 1, r), pushup(x);
}
signed main() {
n = gi(), q = gi();
for (register long long i = (1); i <= (n); ++i) a[i] = gi();
build(1, 1, n);
long long type, x, k;
for (register long long i = (1); i <= (q); ++i) {
type = gi(), x = gi(), k = gi();
if (type == 1) {
long long l = Get1(1, 1, n, k);
if (l > x) continue;
update(1, 1, n, l, x, k);
} else {
long long ans = 0;
while (233) {
long long bg = Get1(1, 1, n, k);
bg = max(bg, x);
if (bg == n + 1) break;
long long st = ((bg == 1) ? 0 : query(1, 1, n, bg - 1));
long long go = Get2(1, 1, n, st + k);
ans += (go - bg + 1);
k -= (query(1, 1, n, go) - st), x = go + 1;
}
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ul = unsigned long long;
using ld = long double;
const int N = 1 << 18;
ll ts[N * 2], tmn[N * 2], mod[N * 2];
void rel(int v) {
ts[v] = ts[v * 2] + ts[v * 2 + 1];
tmn[v] = min(tmn[v * 2], tmn[v * 2 + 1]);
}
void push(ll v, ll l, ll r) {
if (!mod[v]) return;
ts[v] = mod[v] * (r - l);
tmn[v] = mod[v];
if (v < N) {
mod[v * 2] = mod[v];
mod[v * 2 + 1] = mod[v];
}
mod[v] = 0;
}
int getf(ll x, int v = 1, int l = 0, int r = N) {
push(v, l, r);
if (tmn[v] > x) return -1;
if (r - l == 1) return l;
int res = getf(x, v * 2, l, (l + r) / 2);
if (res != -1) return res;
return getf(x, v * 2 + 1, (l + r) / 2, r);
}
void tset(ll cl, ll cr, ll x, int v = 1, int l = 0, int r = N) {
if (cr <= l || r <= cl) {
push(v, l, r);
return;
}
if (cl <= l && r <= cr) {
mod[v] = x;
push(v, l, r);
return;
}
push(v, l, r);
tset(cl, cr, x, v * 2, l, (l + r) / 2);
tset(cl, cr, x, v * 2 + 1, (l + r) / 2, r);
rel(v);
}
pair<ll, ll> gs(ll cl, ll x, ll v = 1, ll l = 0, ll r = N) {
push(v, l, r);
if (r <= cl || tmn[v] > x) {
return {x, 0};
}
if (cl <= l && ts[v] <= x) {
return {x - ts[v], r - l};
}
auto p1 = gs(cl, x, v * 2, l, (l + r) / 2);
auto p2 = gs(cl, p1.first, v * 2 + 1, (l + r) / 2, r);
p2.second += p1.second;
return p2;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
ll n, q, t, x, y;
cin >> n >> q;
for (int i = 0; i < (n); i++) {
cin >> ts[N + i];
tmn[N + i] = ts[N + i];
}
for (int i = N - 1; i > 0; i--) rel(i);
for (int i = 0; i < (q); i++) {
cin >> t >> x >> y;
if (t == 1) {
ll pos = getf(y);
tset(pos, x, y);
} else {
cout << gs(x - 1, y).second - (N - n) << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
int n, q;
int a[MAXN];
int MAX[MAXN << 2];
int laz[MAXN << 2];
long long sum[MAXN << 2];
void update(int o) {
MAX[o] = MAX[o << 1];
sum[o] = sum[o << 1] + sum[o << 1 | 1];
}
void buildtree(int o, int l, int r) {
if (l == r) {
MAX[o] = a[l];
sum[o] = a[l];
return;
}
int mid = l + r >> 1;
buildtree(o << 1, l, mid);
buildtree(o << 1 | 1, mid + 1, r);
update(o);
}
void setv(int o, int l, int r, int v) {
MAX[o] = v;
sum[o] = (long long)(r - l + 1) * v;
laz[o] = v;
}
void pushdown(int o, int l, int r) {
if (!laz[o]) return;
int mid = l + r >> 1;
setv(o << 1, l, mid, laz[o]);
setv(o << 1 | 1, mid + 1, r, laz[o]);
laz[o] = 0;
}
void modify(int o, int l, int r, int x, int y, int v) {
if (l >= x && r <= y) {
setv(o, l, r, v);
return;
}
pushdown(o, l, r);
int mid = l + r >> 1;
if (mid >= x) modify(o << 1, l, mid, x, y, v);
if (mid + 1 <= y) modify(o << 1 | 1, mid + 1, r, x, y, v);
update(o);
}
int query1(int o, int l, int r, int p) {
if (l == r) return MAX[o] <= p ? l : l + 1;
pushdown(o, l, r);
int mid = l + r >> 1;
if (MAX[o << 1 | 1] <= p) return query1(o << 1, l, mid, p);
return query1(o << 1 | 1, mid + 1, r, p);
}
long long query2(int o, int l, int r, int p) {
if (r <= p) return sum[o];
pushdown(o, l, r);
int mid = l + r >> 1;
if (mid + 1 > p) return query2(o << 1, l, mid, p);
return query2(o << 1, l, mid, p) + query2(o << 1 | 1, mid + 1, r, p);
}
int query3(int o, int l, int r, long long t) {
if (l == r) return sum[o] <= t ? l : l - 1;
pushdown(o, l, r);
int mid = l + r >> 1;
if (sum[o << 1] <= t) return query3(o << 1 | 1, mid + 1, r, t - sum[o << 1]);
return query3(o << 1, l, mid, t);
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
buildtree(1, 1, n);
while (q--) {
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
if (t == 1) {
int l = query1(1, 1, n, y);
if (l <= x) modify(1, 1, n, l, x, y);
} else {
int cnt = 0;
x = max(x, query1(1, 1, n, y));
while (y && x <= n) {
long long tar = (x == 1 ? 0 : query2(1, 1, n, x - 1));
int r = query3(1, 1, n, tar + y);
y -= query2(1, 1, n, r) - tar;
cnt += r - x + 1;
x = max(r + 2, query1(1, 1, n, y));
}
printf("%d\n", cnt);
}
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.