Submission #1131695

#	Time	Username	Problem	Language	Result	Execution time	Memory
1131695		steveonalex	Crossing (JOI21_crossing)	C++20	0 / 100	44 ms	4168 KiB

Main

#include <bits/stdc++.h>
 
using namespace std;
 
typedef long long ll;
typedef unsigned long long ull;
 
#define MASK(i) (1ULL << (i))
#define GETBIT(mask, i) (((mask) >> (i)) & 1)
#define ALL(v) (v).begin(), (v).end()
 
ll max(ll a, ll b){return (a > b) ? a : b;}
ll min(ll a, ll b){return (a < b) ? a : b;}
ll gcd(ll a, ll b){return __gcd(a, b);}
ll lcm(ll a, ll b){return a / gcd(a, b) * b;}
 
ll LASTBIT(ll mask){return (mask) & (-mask);}
int pop_cnt(ull mask){return __builtin_popcountll(mask);}
int ctz(ull mask){return __builtin_ctzll(mask);}
int logOf(ull mask){return 63 - __builtin_clzll(mask);}
 
mt19937_64 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
ll rngesus(ll l, ll r){return l + (ull) rng() % (r - l + 1);}
double rngesus_d(double l, double r){
    double cur = rngesus(0, MASK(60) - 1);
    cur /= MASK(60) - 1;
    return l + cur * (r - l);
}
 
template <class T1, class T2>
    bool maximize(T1 &a, T2 b){
        if (a < b) {a = b; return true;}
        return false;
    }
 
template <class T1, class T2>
    bool minimize(T1 &a, T2 b){
        if (a > b) {a = b; return true;}
        return false;
    }
 
template <class T>
    void printArr(T container, string separator = " ", string finish = "\n", ostream &out = cout){
        for(auto item: container) out << item << separator;
        out << finish;
    }
 
template <class T>
    void remove_dup(vector<T> &a){
        sort(ALL(a));
        a.resize(unique(ALL(a)) - a.begin());
    }

const ll MOD = ((ll)(1e9 + 7)) * ((ll)(1e9 + 9));
const int N = 2e5 + 69;
ll po[N], pref_po[N];

string f(string a, string b){
    int n = a.size();
    string ans(n, '0');
    for(int i = 0; i < n; ++i){
        int digit1 = a[i] - '0', digit2 = b[i] - '0';
        ans[i] += (6 - digit1 - digit2) % 3;
    }
    return ans;
}

vector<string> get_string_template(){
    string x, y, z; 
    for(int i = 0; i < 3; ++i) for(int j = 0; j < 3; ++j) for(int k = 0; k < 3; ++k){
        x.push_back('0' + i);
        y.push_back('0' + j);
        z.push_back('0' + k);
    }

    set<string> S;
    vector<string> pending;
    S.insert(x); S.insert(y); S.insert(z);
    for(string i: S) for(string j: S) pending.push_back(f(i, j));
    while(pending.size()){
        string cur = pending.back(); pending.pop_back();
        if (S.insert(cur).second){
            for(string i: S) if (cur != i){
                pending.push_back(f(cur, i));
            }
        }
    }
    return vector<string>(ALL(S));
}

int convert(char c){
    switch(c){
        case 'J': 
            return 0;
        case 'O':
            return 1;
        default:
            return 2;
    }
}

struct SegmentTree{
    struct Node{
        ll sum, lazy;
        Node(){
            sum = 0; lazy = -1;
        }
    };
    int n;
    vector<Node> a;

    SegmentTree(int n): n(n){
        a.resize(n*4+4);
    }

    void apply(int id, int val, int l, int r){
        a[id].lazy = val;
        a[id].sum = (pref_po[r] - pref_po[l-1]) * val % MOD;
        if (a[id].sum < 0) a[id].sum += MOD;
    }

    void push(int id, int l, int r){
        if (a[id].lazy != -1){
            int mid = (l + r) >> 1;
            apply(id * 2, a[id].lazy, l, mid);
            apply(id * 2 + 1, a[id].lazy, mid + 1, r);
            a[id].lazy = -1;
        }
    }

    Node combine(Node a, Node b){
        Node c;
        c.sum = (a.sum + b.sum) % MOD;
        return c;
    }

    void update(int u, int v, int val, int l, int r, int id){
        if (u <= l && r <= v){
            apply(id, val, l, r);
            return;
        }
        push(id, l, r);
        int mid = (l + r) >> 1;
        if (u <= mid) update(u, v, val, l, mid, id * 2);
        if (v > mid) update(u, v, val, mid + 1, r, id * 2 + 1);
        a[id] = combine(a[id * 2], a[id * 2 + 1]);
    }

    void update(int u, int v, int val){
        update(u, v, val, 1, n, 1);
    }

    ll get(){
        return a[1].sum;
    }
};

void solve(){
    vector<string> string_template = get_string_template();

    int n; cin >> n;
    string x, y, z; cin >> x >> y >> z;
    for(char &c: x) c = '0' + convert(c);
    for(char &c: y) c = '0' + convert(c);
    for(char &c: z) c = '0' + convert(c);

    vector<string> attainable;
    for(string s: string_template){
        string cur = "";
        for(int i = 0; i < n; ++i){
            int digit0 = x[i] - '0', digit1 = y[i] - '0', digit2 = z[i] - '0';
            int digit = digit0 * 9 + digit1 * 3 + digit2 * 1;
            cur.push_back(s[digit]);
        }
        attainable.push_back(cur);
    }
    remove_dup(attainable);

    vector<ll> hash_attainable;
    for(string s: attainable){
        ll ans = 0;
        for(int i = 0; i < n; ++i){
            int digit = s[i] - '0';
            ans += po[i+1] * digit;
            ans %= MOD;
        }
        hash_attainable.push_back(ans);
    }
    remove_dup(hash_attainable);

    int q; cin >> q;
    string t; cin >> t;

    SegmentTree st(n);
    for(int i = 0; i < n; ++i) st.update(i+1, i+1, convert(t[i]));
    if (binary_search(ALL(hash_attainable), st.get())) cout << "Yes\n";
    else cout << "No\n";
    while(q--){
        int l, r; char c; cin >> l >> r >> c;
        st.update(l, r, c);

        if (binary_search(ALL(hash_attainable), st.get())) cout << "Yes\n";
        else cout << "No\n";
    }
}   

void prepare(){
    po[0] = pref_po[0] = 1;
    for(int i = 1; i < N; ++i){
        po[i] = po[i-1] * 3 % MOD;
        pref_po[i] = (pref_po[i-1] + po[i]) % MOD;
    }
}

int main(void){
    ios::sync_with_stdio(0);cin.tie(0); cout.tie(0);

    clock_t start = clock();

    prepare();
    solve();

    cerr << "Time elapsed: " << clock() - start << " ms\n";
    return 0;
}

• Subtask 1: 0 / 3
• Subtask 2: 0 / 23
• Subtask 3: 0 / 23
• Subtask 4: 0 / 51