結果
| 問題 | No.2950 Max Min Product |
| ユーザー |
 wsrtrt
|
| 提出日時 | 2024-10-25 22:55:38 |
| 言語 | C++23 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
AC
|
| 実行時間 | 1,242 ms / 3,000 ms |
| コード長 | 17,284 bytes |
| コンパイル時間 | 5,769 ms |
| コンパイル使用メモリ | 325,224 KB |
| 実行使用メモリ | 37,752 KB |
| 最終ジャッジ日時 | 2024-10-25 23:31:31 |
| 合計ジャッジ時間 | 39,813 ms |
|
ジャッジサーバーID （参考情報） |
judge5 / judge2 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 2 ms
6,816 KB |
| testcase_01 | AC | 2 ms
6,816 KB |
| testcase_02 | AC | 2 ms
6,944 KB |
| testcase_03 | AC | 808 ms
37,132 KB |
| testcase_04 | AC | 903 ms
37,172 KB |
| testcase_05 | AC | 840 ms
37,112 KB |
| testcase_06 | AC | 1,235 ms
37,576 KB |
| testcase_07 | AC | 1,235 ms
37,644 KB |
| testcase_08 | AC | 1,228 ms
37,656 KB |
| testcase_09 | AC | 558 ms
20,484 KB |
| testcase_10 | AC | 1,056 ms
37,372 KB |
| testcase_11 | AC | 891 ms
37,144 KB |
| testcase_12 | AC | 1,227 ms
37,612 KB |
| testcase_13 | AC | 1,226 ms
37,512 KB |
| testcase_14 | AC | 1,236 ms
37,688 KB |
| testcase_15 | AC | 1,017 ms
37,448 KB |
| testcase_16 | AC | 709 ms
37,076 KB |
| testcase_17 | AC | 790 ms
37,120 KB |
| testcase_18 | AC | 1,095 ms
37,576 KB |
| testcase_19 | AC | 1,090 ms
37,552 KB |
| testcase_20 | AC | 1,091 ms
37,604 KB |
| testcase_21 | AC | 662 ms
20,588 KB |
| testcase_22 | AC | 893 ms
37,168 KB |
| testcase_23 | AC | 579 ms
20,504 KB |
| testcase_24 | AC | 1,232 ms
37,608 KB |
| testcase_25 | AC | 1,234 ms
37,552 KB |
| testcase_26 | AC | 1,242 ms
37,608 KB |
| testcase_27 | AC | 636 ms
37,164 KB |
| testcase_28 | AC | 967 ms
37,600 KB |
| testcase_29 | AC | 680 ms
37,176 KB |
| testcase_30 | AC | 937 ms
37,736 KB |
| testcase_31 | AC | 1,044 ms
37,576 KB |
| testcase_32 | AC | 935 ms
37,752 KB |
| testcase_33 | AC | 472 ms
37,216 KB |
| testcase_34 | AC | 296 ms
20,436 KB |
| testcase_35 | AC | 458 ms
37,132 KB |
| testcase_36 | AC | 657 ms
37,548 KB |
| testcase_37 | AC | 656 ms
37,724 KB |
| testcase_38 | AC | 653 ms
37,708 KB |
| testcase_39 | AC | 2 ms
6,940 KB |
ソースコード
#include <bits/stdc++.h>
#include <atcoder/all>
using namespace std;
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#define INT(...) \
int __VA_ARGS__; \
IN(__VA_ARGS__)
#define LL(...) \
ll __VA_ARGS__; \
IN(__VA_ARGS__)
#define STR(...) \
string __VA_ARGS__; \
IN(__VA_ARGS__)
#define CHR(...) \
char __VA_ARGS__; \
IN(__VA_ARGS__)
#define DBL(...) \
double __VA_ARGS__; \
IN(__VA_ARGS__)
#define ll long long
#define cout std::cout
#define yes cout<<"Yes"<<"\n"
#define no cout<<"No"<<"\n"
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto &i:a)
#define all(x) (x).begin(),(x).end()
#define allr(x) (x).rbegin(),(x).rend()
#define SUM(v) accumulate(all(v), 0LL)
#define MIN(v) *min_element(all(v))
#define MAX(v) *max_element(all(v))
#define lb(c, x) distance((c).begin(), lower_bound(all(c), (x)))
#define ub(c, x) distance((c).begin(), upper_bound(all(c), (x)))
#define pii pair<int, int>
#define pll pair<long long,long long>
#define pb push_back
#define eb emplace_back
#define ff first
#define ss second
#define vi vector<int>
#define vll vector<long long>
#define vc vector<char>
#define vvi vector<vector<int>>
#define vec(type, name, ...) vector<type> name(__VA_ARGS__)
#define VEC(type, name, size) \
vector<type> name(size); \
IN(name)
int scan() { return getchar(); }
void scan(int &a) { cin >> a; }
void scan(long long &a) { cin >> a; }
void scan(char &a) { cin >> a; }
void scan(double &a) { cin >> a; }
void scan(string &a) { cin >> a; }
template <class T, class S> void scan(pair<T, S> &p) { scan(p.first), scan(p.second); }
template <class T> void scan(vector<T> &);
template <class T> void scan(vector<T> &a) {
for(auto &i : a) scan(i);
}
template <class T> void scan(T &a) { cin >> a; }
void IN() {}
template <class Head, class... Tail> void IN(Head &head, Tail &...tail) {
scan(head);
IN(tail...);
}
template <class T> void print(const T &a) { cout << a; }
void OUT() { cout << endl; }
template <class Head, class... Tail> void OUT(const Head &head, const Tail &...tail) {
print(head);
if(sizeof...(tail)) cout << ' ';
OUT(tail...);
}
#define vv(type, name, h, ...) vector<vector<type>> name(h, vector<type>(__VA_ARGS__))
#define VV(type, name, h, w) \
vector<vector<type>> name(h, vector<type>(w)); \
IN(name)
#define vvv(type, name, h, w, ...) vector<vector<vector<type>>> name(h, vector<vector<type>>(w, vector<type>(__VA_ARGS__)))
#define vvvv(type, name, a, b, c, ...) \
vector<vector<vector<vector<type>>>> name(a, vector<vector<vector<type>>>(b, vector<vector<type>>(c, vector<type>(__VA_ARGS__))))
template<typename T> using min_priority_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T> pair<T, T> operator-(const pair<T, T> &x, const pair<T, T> &y) { return pair<T, T>(x.ff - y.ff, x.ss - y.ss); }
template <class T> pair<T, T> operator+(const pair<T, T> &x, const pair<T, T> &y) { return pair<T, T>(x.ff + y.ff, x.ss + y.ss); }
template <class T> pair<T, T> operator&(const pair<T, T> &l, const pair<T, T> &r) { return pair<T, T>(max(l.ff, r.ff), min(l.ss, r.ss)); }
template <class T> vector<T> &operator--(vector<T> &v) {
fore(e, v) e--;
return v;
}
template <class T> vector<T> operator--(vector<T> &v, int) {
auto res = v;
fore(e, v) e--;
return res;
}
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
#define UNIQUE(x) sort(all(x)), x.erase(unique(all(x)), x.end())
//座標圧縮
template <typename T> void zip(vector<T> &x) {
vector<T> y = x;
UNIQUE(y);
for(int i = 0; i < x.size(); ++i) { x[i] = lb(y, x[i]); }
}
template <class T> T ceil(T x, T y) {
assert(y >= 1);
return (x > 0 ? (x + y - 1) / y : x / y);
}
template <class T> T floor(T x, T y) {
assert(y >= 1);
return (x > 0 ? x / y : (x + y - 1) / y);
}
long long POW(long long x, int n) {
long long res = 1LL;
for(; n; n >>= 1, x *= x)
if(n & 1) res *= x;
return res;
}
//0^n=0
long long modpow(long long a, long long n, long long mod) {
a%=mod;
assert(a!=0||n!=0);
if(a==0)return 0;
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
//return 0<=a&&a<h&&0<=b&&b<w;
inline bool ingrid(int a,int b,int h,int w){return 0<=a&&a<h&&0<=b&&b<w;}
//return 0<=a&&a<n;
inline bool inl(int a,int n){return 0<=a&&a<n;}
// bit 演算系
ll pow2(int i) { return 1LL << i; }
int topbit(signed t) { return t == 0 ? -1 : 31 - __builtin_clz(t); }
int topbit(ll t) { return t == 0 ? -1 : 63 - __builtin_clzll(t); }
int lowbit(signed a) { return a == 0 ? 32 : __builtin_ctz(a); }
int lowbit(ll a) { return a == 0 ? 64 : __builtin_ctzll(a); }
// int allbit(int n) { return (1 << n) - 1; }
ll allbit(ll n) { return (1LL << n) - 1; }
int popcount(signed t) { return __builtin_popcount(t); }
int popcount(ll t) { return __builtin_popcountll(t); }
bool ispow2(int i) { return i && (i & -i) == i; }
int in() {
int x;
cin >> x;
return x;
}
ll lin() {
unsigned long long x;
cin >> x;
return x;
}
long long sqrtll(long long x) {
assert(x >= 0);
long long rev = sqrt(x);
while(rev * rev > x) --rev;
while((rev+1) * (rev+1)<=x) ++rev;
return rev;
}
int logN(long long n){
int ret=1;
while((1LL<<ret)<n)ret++;
return ret;
}
const double PI=3.1415926535897932384626433832795028841971;
const ll MOD = 998244353;
const int INFI = numeric_limits<int>::max() / 2; const long long INFL = numeric_limits<long long>::max() / 2;
#define inf INFINITY
template<class T>
void debug(vector<T> a){
rep(i,0,(int)a.size()){
cout<<a[i]<<' ';
}
cout<<endl;
return;
}
bool palindrome(const string& s){
return equal(all(s),s.rbegin());
}
template <std::uint_fast64_t Modulus> class modint {
using u64 = std::uint_fast64_t;
public:
u64 a;
constexpr modint(const u64 x = 0) noexcept : a(x % Modulus) {}
constexpr u64 &val() noexcept { return a; }
constexpr const u64 &val() const noexcept { return a; }
constexpr modint operator+(const modint rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint operator-(const modint rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint operator*(const modint rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint operator/(const modint rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint &operator+=(const modint rhs) noexcept {
a += rhs.a;
if (a >= Modulus) {
a -= Modulus;
}
return *this;
}
constexpr modint &operator-=(const modint rhs) noexcept {
if (a < rhs.a) {
a += Modulus;
}
a -= rhs.a;
return *this;
}
constexpr modint &operator*=(const modint rhs) noexcept {
a = a * rhs.a % Modulus;
return *this;
}
constexpr modint &operator/=(modint rhs) noexcept {
u64 exp = Modulus - 2;
while (exp) {
if (exp % 2) {
*this *= rhs;
}
rhs *= rhs;
exp /= 2;
}
return *this;
}
friend bool operator==(const modint& a,const modint& b) { return a.val()==b.val(); }
friend bool operator!=(const modint& a,const modint& b) { return a.val()!=b.val(); }
};
using mint9=modint<998244353>;
using mint1=modint<1000000007>;
//基本的にcostを指定しないと重みなし辺になります
struct Edge{
int from,to;
ll cost;
Edge()=default;
Edge(int from,int to,ll cost=1):from(from),to(to),cost(cost){}
operator int() const {return to;}
};
constexpr pii dx4[4] = {pii{-1, 0},pii{0, -1}, pii{0, 1}, pii{1, 0} };
constexpr pii dx8[8] = {{1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1}, {0, -1}, {1, -1}};
constexpr pii dx[2][8] = { {{-1,-1},{-1,0},{0,-1},{0,1},{1,-1},{1,0}},{{-1,0},{0,-1},{1,0},{-1,1},{0,1},{1,1}}};
#define el "\n"
#define endl "\n"
#define fastio std::cin.sync_with_stdio(false);std::cin.tie(nullptr),cout<<fixed<<setprecision(16);
template< typename T, typename E, typename F, typename G, typename H >
struct LazySegmentTree {
private:
int n{}, sz{}, height{};
vector< T > data;
vector< E > lazy;
const F f;
const G g;
const H h;
const T ti;
const E ei;
inline void update(int k) {
data[k] = f(data[2 * k + 0], data[2 * k + 1]);
}
inline void all_apply(int k, const E &x) {
data[k] = g(data[k], x);
if(k < sz) lazy[k] = h(lazy[k], x);
}
inline void propagate(int k) {
if(lazy[k] != ei) {
all_apply(2 * k + 0, lazy[k]);
all_apply(2 * k + 1, lazy[k]);
lazy[k] = ei;
}
}
public:
LazySegmentTree() = default;
explicit LazySegmentTree(int n, const F f, const G g, const H h,const T &ti, const E &ei)
: n(n), f(f), g(g), h(h), ti(ti), ei(ei) {
sz = 1;
height = 0;
while(sz < n) sz <<= 1, height++;
data.assign(2 * sz, ti);
lazy.assign(2 * sz, ei);
}
explicit LazySegmentTree(const vector< T > &v, const F f, const G g, const H h,const T &ti, const E &ei)
: LazySegmentTree(v.size(), f, g, h, ti, ei) {
build(v);
}
void build(const vector< T > &v) {
assert(n == (int) v.size());
for(int k = 0; k < n; k++) data[k + sz] = v[k];
for(int k = sz - 1; k > 0; k--) update(k);
}
void set(int k, const T &x) {
k += sz;
for(int i = height; i > 0; i--) propagate(k >> i);
data[k] = x;
for(int i = 1; i <= height; i++) update(k >> i);
}
T get(int k) {
k += sz;
for(int i = height; i > 0; i--) propagate(k >> i);
return data[k];
}
T operator[](int k) {
return get(k);
}
T prod(int l, int r) {
if(l >= r) return ti;
l += sz;
r += sz;
for(int i = height; i > 0; i--) {
if(((l >> i) << i) != l) propagate(l >> i);
if(((r >> i) << i) != r) propagate((r - 1) >> i);
}
T L = ti, R = ti;
for(; l < r; l >>= 1, r >>= 1) {
if(l & 1) L = f(L, data[l++]);
if(r & 1) R = f(data[--r], R);
}
return f(L, R);
}
T all_prod() const {
return data[1];
}
void apply(int k, const E &x) {
k += sz;
for(int i = height; i > 0; i--) propagate(k >> i);
data[k] = g(data[k], x);
for(int i = 1; i <= height; i++) update(k >> i);
}
void apply(int l, int r, const E &x) {
if(l >= r) return;
l += sz;
r += sz;
for(int i = height; i > 0; i--) {
if(((l >> i) << i) != l) propagate(l >> i);
if(((r >> i) << i) != r) propagate((r - 1) >> i);
}
{
int l2 = l, r2 = r;
for(; l < r; l >>= 1, r >>= 1) {
if(l & 1) all_apply(l++, x);
if(r & 1) all_apply(--r, x);
}
l = l2, r = r2;
}
for(int i = 1; i <= height; i++) {
if(((l >> i) << i) != l) update(l >> i);
if(((r >> i) << i) != r) update((r - 1) >> i);
}
}
template< typename C >
int find_first(int l, const C &check) {
if(l >= n) return n;
l += sz;
for(int i = height; i > 0; i--) propagate(l >> i);
T sum = ti;
do {
while((l & 1) == 0) l >>= 1;
if(check(f(sum, data[l]))) {
while(l < sz) {
propagate(l);
l <<= 1;
auto nxt = f(sum, data[l]);
if(not check(nxt)) {
sum = nxt;
l++;
}
}
return l + 1 - sz;
}
sum = f(sum, data[l++]);
} while((l & -l) != l);
return n;
}
template< typename C >
int find_last(int r, const C &check) {
if(r <= 0) return -1;
r += sz;
for(int i = height; i > 0; i--) propagate((r - 1) >> i);
T sum = ti;
do {
r--;
while(r > 1 and (r & 1)) r >>= 1;
if(check(f(data[r], sum))) {
while(r < sz) {
propagate(r);
r = (r << 1) + 1;
auto nxt = f(data[r], sum);
if(not check(nxt)) {
sum = nxt;
r--;
}
}
return r - sz;
}
sum = f(data[r], sum);
} while((r & -r) != r);
return -1;
}
};
template< typename T, typename E, typename F, typename G, typename H >
LazySegmentTree< T, E, F, G, H > get_lazy_segment_tree(int N, const F &f, const G &g, const H &h, const T &ti, const E &ei) {
return LazySegmentTree<T,E,F,G,H>{N, f, g, h, ti, ei};
}
template< typename T, typename E, typename F, typename G, typename H >
LazySegmentTree< T, E, F, G, H > get_lazy_segment_tree(const vector< T > &v, const F &f, const G &g, const H &h, const T &ti, const E &ei) {
return LazySegmentTree<T,E,F,G,H>{v, f, g, h, ti, ei};
}
int main(){
fastio
INT(n);
VEC(ll,a,n);
struct node{
mint9 len;
ll mini,maxi;
mint9 min_sum,max_sum;
mint9 val;
};
auto f=[](node a,node b){
a.len+=b.len;
chmin(a.mini,b.mini);
chmax(a.maxi,b.maxi);
a.min_sum+=b.min_sum;
a.max_sum+=b.max_sum;
a.val+=b.val;
return a;
};
auto g=[](node a,pll t){
//順に処理していく
if(t.ff!=-INFL){
a.mini=t.ff;
a.min_sum=(mint9)t.ff*a.len;
a.val=(mint9)t.ff*a.max_sum;
}
if(t.ss!=-INFL){
a.maxi=t.ss;
a.max_sum=(mint9)t.ss*a.len;
a.val=(mint9)t.ss*a.min_sum;
}
return a;
};
auto h=[](pll a,pll b){
if(b.ff!=-INFL){
a.ff=b.ff;
}
if(b.ss!=-INFL){
a.ss=b.ss;
}
return a;
};
auto seg=get_lazy_segment_tree(n,f,g,h,node{0,INFL,-INFL,0,0,0},pll(-INFL,-INFL));
mint9 ans=0;
rep(i,0,n){
seg.set(i,node{1,a[i],a[i],a[i],a[i],a[i]*a[i]});
{
int ok=i,ng=-1;
while(abs(ok-ng)>1){
int mid=(ok+ng)>>1;
if(seg[mid].mini>=a[i])ok=mid;
else ng=mid;
}
seg.apply(ok,i+1,pll(a[i],-INFL));
}
{
int ok=i,ng=-1;
while(abs(ok-ng)>1){
int mid=(ok+ng)>>1;
if(seg[mid].maxi<=a[i])ok=mid;
else ng=mid;
}
seg.apply(ok,i+1,pll(-INFL,a[i]));
}
ans+=seg.prod(0,n).val;
}
OUT(ans.val());
return 0;
}
/*
区間更新みたいな感じ
一番下のノード以外miniとmaxiはあんま重要ではない
*/