답안 #336854

#	제출 시각	아이디	문제	언어	결과	실행 시간	메모리
336854	2020-12-17T03:50:47 Z	12tqian	Election (BOI18_election)	C++17	100 / 100	631 ms	23168 KB

election

#pragma GCC optimize ("O3")
#pragma GCC target ("sse4")

#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <iostream>
#include <iomanip>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>

using namespace std;
using namespace __gnu_pbds;
template <class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;

typedef long long ll;
typedef long double ld;
typedef double db;
typedef string str;

typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef pair<db, db> pd;

typedef vector<int> vi;
typedef vector<bool> vb;
typedef vector<ll> vl;
typedef vector<db> vd;
typedef vector<str> vs;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<pd> vpd;

#define mp make_pair
#define f first
#define s second
#define sz(x) (int) (x).size()
#define all(x) begin(x), end(x)
#define rall(x) (x).rbegin(), (x).rend()
#define sor(x) sort(all(x))
#define rsz resize
#define resz resize
#define ins insert
#define ft front()
#define bk back()
#define pf push_front
#define pb push_back
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound

#define f1r(i, a, b) for (int i = (a); i < (b); ++i)
#define f0r(i, a) f1r(i, 0, a)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define F0R(i, a) FOR(i,0,a)
#define ROF(i, a, b) for (int i = (b) - 1; i >= (a); --i)
#define R0F(i, a) ROF(i, 0, a)
#define trav(a, x) for (auto& a : x)

mt19937 rng((uint32_t) chrono::steady_clock::now().time_since_epoch().count());

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> using V = vector<T>;

#ifdef LOCAL
#define dbg(...) debug(#__VA_ARGS__, __VA_ARGS__);
#else
#define dbg(...) 17;
#endif

template<typename T, typename S> ostream& operator << (ostream &os, const pair<T, S> &p) { return os << "(" << p.first << ", " << p.second << ")"; }
template<typename C, typename T = decay<decltype(*begin(declval<C>()))>, typename enable_if<!is_same<C, string>::value>::type* = nullptr>
ostream& operator << (ostream &os, const C &c) { bool f = true; os << "{"; for (const auto &x : c) { if (!f) os << ", "; f = false; os << x; } return os << "}"; }
template<typename T> void debug(string s, T x) { cerr << s << " = " << x << "\n"; }
template<typename T, typename... Args> void debug(string s, T x, Args... args) { cerr << s.substr(0, s.find(',')) << " = " << x << " | "; debug(s.substr(s.find(',') + 2), args...); }

constexpr int pct(int x) { return __builtin_popcount(x); }
constexpr int bits(int x) { return 31 - __builtin_clz(x); } // floor(log2(x))

namespace input {
    template<class T> void re(complex<T>& x);
    template<class T1, class T2> void re(pair<T1, T2>& p);
    template<class T> void re(vector<T>& a);
    template<class T, int SZ> void re(array<T, SZ>& a);
    template<class T> void re(T& x) { cin >> x; }
    void re(double& x) { string t; re(t); x = stod(t); }
    void re(ld& x) { string t; re(t); x = stold(t); }
    template<class T, class... Ts> void re(T& t, Ts&... ts) {
        re(t); re(ts...); }
    template<class T> void re(complex<T>& x) { T a, b; re(a, b); x = cd(a, b); }
    template<class T1, class T2> void re(pair<T1, T2>& p) { re(p.f, p.s); }
    template<class T> void re(vector<T>& a) { F0R(i, sz(a)) re(a[i]); }
    template<class T, int SZ> void re(array<T, SZ>& a) { F0R(i, SZ) re(a[i]); }
}

using namespace input;

namespace output {
    void pr(int x) { cout << x; }
    void pr(long x) { cout << x; }
    void pr(ll x) { cout << x; }
    void pr(unsigned x) { cout << x; }
    void pr(unsigned long x) { cout << x; }
    void pr(unsigned long long x) { cout << x; }
    void pr(float x) { cout << x; }
    void pr(double x) { cout << x; }
    void pr(ld x) { cout << x; }
    void pr(char x) { cout << x; }
    void pr(const char* x) { cout << x; }
    void pr(const string& x) { cout << x; }
    void pr(bool x) { pr(x ? "true" : "false"); }
    template<class T> void pr(const complex<T>& x) { cout << x; }
    template<class T1, class T2> void pr(const pair<T1, T2>& x);
    template<class T> void pr(const T& x);
    template<class T, class... Ts> void pr(const T& t, const Ts&... ts) {
        pr(t); pr(ts...); }
    template<class T1, class T2> void pr(const pair<T1,T2>& x) {
        pr("{", x.f, ", ", x.s, "}"); }
    template<class T> void pr(const T& x) {
        pr("{"); // const iterator needed for vector<bool>
        bool fst = 1; for (const auto& a: x) pr(!fst ? ", " : "", a), fst = 0;
        pr("}"); }
    void ps() { pr("\n"); } // print w/ spaces
    template<class T, class... Ts> void ps(const T& t, const Ts&... ts) {
        pr(t); if (sizeof...(ts)) pr(" "); ps(ts...); }
    void pc() { pr("]\n"); } // debug w/ commas
    template<class T, class... Ts> void pc(const T& t, const Ts&... ts) {
        pr(t); if (sizeof...(ts)) pr(", "); pc(ts...); }
}

using namespace output;

namespace io {
    void setIn(string s) { freopen(s.c_str(), "r", stdin); }
    void setOut(string s) { freopen(s.c_str(), "w", stdout); }
    void setIO(string s = "") {
        cin.sync_with_stdio(0); cin.tie(0);
        if (sz(s)) { setIn(s + ".in"), setOut(s + ".out"); }
    }
}

using namespace io;

const int MOD = 1e9 + 7; // 998244353;
const ld PI = acos((ld) -1);

typedef std::decay <decltype(MOD)>::type mod_t;
struct mi {
    mod_t val;
    explicit operator mod_t() const { return val; }
    mi() { val = 0; }
    mi(const long long& v) {
        val = (-MOD <= v && v <= MOD) ? v : v % MOD;
        if (val < 0) val += MOD; }
    friend std::istream& operator >> (std::istream& in, mi& a) { 
        long long x; std::cin >> x; a = mi(x); return in; }
    friend std::ostream& operator << (std::ostream& os, const mi& a) { return os << a.val; }
    friend void pr(const mi& a) { pr(a.val); }
    friend void re(mi& a) { long long x; cin >> x; a = mi(x); }
    friend bool operator == (const mi& a, const mi& b) { return a.val == b.val; }
    friend bool operator != (const mi& a, const mi& b) { return !(a == b); }    
    friend bool operator < (const mi& a, const mi& b) { return a.val < b.val; }
    friend bool operator > (const mi& a, const mi& b) { return a.val > b.val; }
    friend bool operator <= (const mi& a, const mi& b) { return a.val <= b.val; }
    friend bool operator >= (const mi& a, const mi& b) { return a.val >= b.val; }
    mi operator - () const { return mi(-val); }
    mi& operator += (const mi& m) {
        if ((val += m.val) >= MOD) val -= MOD;
        return *this; }
    mi& operator -= (const mi& m) {
        if ((val -= m.val) < 0) val += MOD;
        return *this; }
    mi& operator *= (const mi& m) { val = (long long) val * m.val % MOD;
        return *this; }
    friend mi pow(mi a, long long p) {
        mi ans = 1; assert(p >= 0);
        for (; p; p /= 2, a *= a) if (p & 1) ans *= a;
        return ans; }
    friend mi inv(const mi& a) { assert(a != 0); return pow(a, MOD - 2); }
    mi& operator /= (const mi& m) { return (*this) *= inv(m); }
    friend mi operator + (mi a, const mi& b) { return a += b; }
    friend mi operator - (mi a, const mi& b) { return a -= b; }
    friend mi operator * (mi a, const mi& b) { return a *= b; }
    friend mi operator / (mi a, const mi& b) { return a /= b; }
};
typedef pair<mi, mi> pmi;
typedef vector<mi> vmi;
typedef vector<pmi> vpmi;
const int INF = 1e9;
const int L = 19;
const int SZ = (1<<L);
struct Node {
    int pre, suf, sum, ans;
    Node() { pre = suf = sum = INF; }
    Node(char c) {
        if (c == 'T') {
            pre = suf = sum = ans = 1;
        } else {
            pre = suf = ans = 0;
            sum = -1;
        }
    }
};
Node comb(Node a, Node b) {
    if (a.pre == INF) return b;
    if (b.pre == INF) return a;
    Node res;
    res.sum = a.sum + b.sum;
    res.pre = max(a.pre, a.sum + b.pre);
    res.suf = max(b.suf, b.sum + a.suf);
    res.ans = max({a.ans + b.sum, b.ans + a.sum, a.pre + b.suf});
    return res;
}
Node st[2*SZ];
void build() {
    for (int i = SZ-1; i >= 1; i--) 
        st[i] = comb(st[2*i], st[2*i+1]);
}
Node query(int lo, int hi, int ind = 1, int l = 0, int r = SZ-1) {
    if (hi<l || r<lo) return Node();
    if (lo <= l && r <= hi) return st[ind];
    int m = (l+r)/2;
    Node lc = query(lo, hi, 2*ind, l, m);
    Node rc = query(lo, hi, 2*ind+1, m+1, r);
    return comb(lc, rc);
}
int main() {
    setIO("");
    int n; re(n);
    string s; re(s);
    int q; re(q);
    f0r(i, n) st[i+SZ] = Node(s[i]);
    build();
    while (q--) {
        int l, r; re(l, r);
        l--, r--;
        Node res = query(l, r);
        ps(res.ans);
    }
    return 0;
}

Compilation message

election.cpp: In function 'void io::setIn(std::string)':
election.cpp:153:35: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)', declared with attribute warn_unused_result [-Wunused-result]
  153 |     void setIn(string s) { freopen(s.c_str(), "r", stdin); }
      |                            ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~
election.cpp: In function 'void io::setOut(std::string)':
election.cpp:154:36: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)', declared with attribute warn_unused_result [-Wunused-result]
  154 |     void setOut(string s) { freopen(s.c_str(), "w", stdout); }
      |                             ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~

Subtask #1
28.0 / 28.0

#	결과	실행 시간	메모리	Grader output
1	Correct	16 ms	16748 KB	Output is correct
2	Correct	14 ms	16768 KB	Output is correct
3	Correct	14 ms	16748 KB	Output is correct
4	Correct	17 ms	16748 KB	Output is correct
5	Correct	14 ms	16748 KB	Output is correct

Subtask #2
54.0 / 54.0

#	결과	실행 시간	메모리	Grader output
1	Correct	16 ms	16748 KB	Output is correct
2	Correct	14 ms	16768 KB	Output is correct
3	Correct	14 ms	16748 KB	Output is correct
4	Correct	17 ms	16748 KB	Output is correct
5	Correct	14 ms	16748 KB	Output is correct
6	Correct	74 ms	18220 KB	Output is correct
7	Correct	71 ms	18176 KB	Output is correct
8	Correct	79 ms	18136 KB	Output is correct
9	Correct	68 ms	18028 KB	Output is correct
10	Correct	75 ms	18028 KB	Output is correct
11	Correct	75 ms	18284 KB	Output is correct
12	Correct	76 ms	18284 KB	Output is correct
13	Correct	75 ms	18284 KB	Output is correct
14	Correct	74 ms	18220 KB	Output is correct
15	Correct	91 ms	18284 KB	Output is correct

Subtask #3
18.0 / 18.0

#	결과	실행 시간	메모리	Grader output
1	Correct	16 ms	16748 KB	Output is correct
2	Correct	14 ms	16768 KB	Output is correct
3	Correct	14 ms	16748 KB	Output is correct
4	Correct	17 ms	16748 KB	Output is correct
5	Correct	14 ms	16748 KB	Output is correct
6	Correct	74 ms	18220 KB	Output is correct
7	Correct	71 ms	18176 KB	Output is correct
8	Correct	79 ms	18136 KB	Output is correct
9	Correct	68 ms	18028 KB	Output is correct
10	Correct	75 ms	18028 KB	Output is correct
11	Correct	75 ms	18284 KB	Output is correct
12	Correct	76 ms	18284 KB	Output is correct
13	Correct	75 ms	18284 KB	Output is correct
14	Correct	74 ms	18220 KB	Output is correct
15	Correct	91 ms	18284 KB	Output is correct
16	Correct	631 ms	22016 KB	Output is correct
17	Correct	553 ms	22016 KB	Output is correct
18	Correct	590 ms	22144 KB	Output is correct
19	Correct	482 ms	21504 KB	Output is correct
20	Correct	596 ms	21120 KB	Output is correct
21	Correct	614 ms	23168 KB	Output is correct
22	Correct	606 ms	22796 KB	Output is correct
23	Correct	607 ms	23040 KB	Output is correct
24	Correct	611 ms	22656 KB	Output is correct
25	Correct	608 ms	22016 KB	Output is correct

답안 #336854

Compilation message

Subtask #1 28.0 / 28.0

Subtask #2 54.0 / 54.0

Subtask #3 18.0 / 18.0

Subtask #1
28.0 / 28.0

Subtask #2
54.0 / 54.0

Subtask #3
18.0 / 18.0