oj.uz

Submission #398008

# Submission time Handle Problem Language Result Execution time Memory
398008 2021-05-03T14:10:52 Z ACmachine Gondola (IOI14_gondola) C++17
100 / 100
 34 ms 6604 KB 
#include "gondola.h"
#include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;

template<typename T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template<typename T, typename U> using ordered_map = tree<T, U, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

typedef long long ll;
typedef long double ld;

typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

typedef vector<int> vi;
typedef vector<ll> vll;

#define FOR(i,j,k,in) for(int i=(j); i < (k);i+=in)
#define FORD(i,j,k,in) for(int i=(j); i >=(k);i-=in)
#define REP(i,b) FOR(i,0,b,1)
#define REPD(i,b) FORD(i,b,0,1)
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define all(x) begin(x), end(x)
#define MANY_TESTS int tcase; cin >> tcase; while(tcase--)

const double EPS = 1e-9;
const int MOD = 1e9+7;
const ll INFF = 1e18;
const int INF = 1e9;
const ld PI = acos((ld)-1);
const vi dy = {1, 0, -1, 0, -1, 1, 1, -1};
const vi dx = {0, 1, 0, -1, -1, 1, -1, 1};

void DBG(){cout << "]" << endl;}
template<typename T, typename ...U> void DBG(const T& head, const U... args){ cout << head << "; "; DBG(args...); }
#define dbg(...) cout << "Line(" << __LINE__ << ") -> [" << #__VA_ARGS__ << "]: [", DBG(__VA_ARGS__);
#define chk() cout << "Check at line(" << __LINE__ << ") hit." << endl;

template<class T, unsigned int U>
ostream& operator<<(ostream& out, const array<T, U> &v){out << "[";  REP(i, U) out << v[i] << ", ";  out << "]"; return out;}
template <class T, class U>
ostream& operator<<(ostream& out, const pair<T, U> &par) {out << "[" << par.first << ";" << par.second << "]"; return out;}
template <class T>
ostream& operator<<(ostream& out, const set<T> &cont) { out << "{"; for( const auto &x:cont) out << x << ", "; out << "}"; return out; }
template <class T, class U>
ostream& operator<<(ostream& out, const map<T, U> &cont) {out << "{"; for( const auto &x:cont) out << x << ", "; out << "}"; return out; }
template<class T>
ostream& operator<<(ostream& out, const vector<T> &v){ out << "[";  REP(i, v.size()) out << v[i] << ", ";  out << "]"; return out;}

template<class T>
istream& operator>>(istream& in, vector<T> &v){ for(auto &x : v) in >> x; return in; }


const int mx = (int)1e6 + 5;
int valid(int n, int inputSeq[])
{
    vector<int> inp(n);
    REP(i, n)
        inp[i] = inputSeq[i];
    auto rotate_seq = [&](){
        int mini = min_element(all(inp)) - inp.begin();
        rotate(inp.begin(), inp.begin() + mini, inp.end());
    };
    rotate_seq();
    bool can = true;
    int last = -1;
    vector<int> cnt(mx, 0);
    REP(i, inp.size()) cnt[inp[i]]++;
    REP(i, mx){
        if(cnt[i] > 1) can = false;
    }
    REP(i, inp.size()){
        if(inp[i] <= n){
            if(last != -1 && inp[i] != inp[last] + (i - last))
                can = false;
            last = i;
        }
    }
    return (can ? 1 : 0);
}

//----------------------

int replacement(int n, int gondolaSeq[], int replacementSeq[])
{
    vector<int> inp(n);
    REP(i, n)
        inp[i] = gondolaSeq[i];
    auto rotate_seq = [&](){
        int mini = min_element(all(inp)) - inp.begin();
        if(inp[mini] > n) return;
        int rot = mini - inp[mini] + 1;
        if(rot < 0) rot += n;
        rotate(inp.begin(), inp.begin() + rot, inp.end());
        //rotate(inp.begin(), inp.begin() + mini, inp.end());
    };
    rotate_seq();
    vector<int> pos(mx, -1);
    REP(i, n){
        pos[inp[i]] = i;
    }
    set<int> incorrect;
    REP(i, n){
        if(inp[i] != i + 1)
            incorrect.insert(i);
    }
    int l = 0;
    vector<int> narr(n);
    iota(all(narr), 1);
    FOR(i, n + 1, mx, 1){
        if(incorrect.empty()) break;
        if(pos[i] == -1){
            replacementSeq[l] = narr[*incorrect.begin()];
            narr[*incorrect.begin()] = i;
            l++;
        }
        else{
            replacementSeq[l] = narr[pos[i]];
            incorrect.erase(pos[i]);
            narr[pos[i]] = i;
            l++;
        }
    }
    return l;
}

//----------------------
const int mod = (int)1e9 + 9;
struct Mint{
    ll v;
    Mint(){v = 0;}
    Mint(ll _v){
        v = _v;
        v%= mod;
        if(v < 0) v += mod;
    }
    friend Mint operator*(Mint a, Mint b){
        return Mint(a.v * b.v);
    }
    friend Mint binpow(Mint a, ll p){
        Mint res(1);
        while(p > 0){
            if(p&1){
                res = res * a;
            }
            a = a * a;
            p>>=1;
        }
        return res;
    }
};

int countReplacement(int n, int inputSeq[])
{
    vector<int> inp(n);
    REP(i, n)
        inp[i] = inputSeq[i];
    auto check_validity = [](vector<int> inp, int n){
        const int mx = (int)1e6 + 6;
        auto rotate_seq = [&](){
            int mini = min_element(all(inp)) - inp.begin();
            rotate(inp.begin(), inp.begin() + mini, inp.end());
        };
        rotate_seq();
        bool can = true;
        int last = -1;
        vector<int> cnt(mx, 0);
        vector<int> ninp = inp;
        sort(all(ninp));
        FOR(i, 1, ninp.size(), 1){
            if(ninp[i] == ninp[i - 1])
                can = false;
        }
        REP(i, inp.size()){
            if(inp[i] <= n){
                if(last != -1 && inp[i] != inp[last] + (i - last))
                    can = false;
                last = i;
            }
        }
        return (can ? 1 : 0);
    };
    if(!check_validity(inp, n)){
        return 0;
    }
    auto rotate_seq = [&](){
        int mini = min_element(all(inp)) - inp.begin();
        if(inp[mini] > n) return;
        int rot = mini - inp[mini] + 1;
        if(rot < 0) rot += n;
        rotate(inp.begin(), inp.begin() + rot, inp.end());
    };
    rotate_seq();
    vector<int> todo;
    REP(i, n){
        if(inp[i] > n) todo.pb(inp[i]);
    }
    int incorrect = 0;
    REP(i, n){
        if(inp[i] != i + 1)
            incorrect++;
    }
    sort(all(todo));
    Mint ans(1);
    int prev = n + 1;
    for(auto x : todo){
        int d = x - prev;
        ans = ans * binpow(Mint(incorrect), d);
        prev = x + 1; incorrect--;
    }
    int diff = *min_element(all(inp)) - n;
    if(diff > 1) ans = ans * Mint(n);
    return (int)ans.v;
}

Compilation message

gondola.cpp: In function 'int valid(int, int*)':
gondola.cpp:20:40: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   20 | #define FOR(i,j,k,in) for(int i=(j); i < (k);i+=in)
      |                                        ^
gondola.cpp:22:18: note: in expansion of macro 'FOR'
   22 | #define REP(i,b) FOR(i,0,b,1)
      |                  ^~~
gondola.cpp:73:5: note: in expansion of macro 'REP'
   73 |     REP(i, inp.size()) cnt[inp[i]]++;
      |     ^~~
gondola.cpp:20:40: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   20 | #define FOR(i,j,k,in) for(int i=(j); i < (k);i+=in)
      |                                        ^
gondola.cpp:22:18: note: in expansion of macro 'FOR'
   22 | #define REP(i,b) FOR(i,0,b,1)
      |                  ^~~
gondola.cpp:77:5: note: in expansion of macro 'REP'
   77 |     REP(i, inp.size()){
      |     ^~~
gondola.cpp: In lambda function:
gondola.cpp:20:40: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   20 | #define FOR(i,j,k,in) for(int i=(j); i < (k);i+=in)
      |                                        ^
gondola.cpp:175:9: note: in expansion of macro 'FOR'
  175 |         FOR(i, 1, ninp.size(), 1){
      |         ^~~
gondola.cpp:20:40: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   20 | #define FOR(i,j,k,in) for(int i=(j); i < (k);i+=in)
      |                                        ^
gondola.cpp:22:18: note: in expansion of macro 'FOR'
   22 | #define REP(i,b) FOR(i,0,b,1)
      |                  ^~~
gondola.cpp:179:9: note: in expansion of macro 'REP'
  179 |         REP(i, inp.size()){
      |         ^~~

Subtask #1
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 3 ms 4172 KB Output is correct
2 Correct 3 ms 4172 KB Output is correct
3 Correct 3 ms 4172 KB Output is correct
4 Correct 3 ms 4172 KB Output is correct
5 Correct 3 ms 4172 KB Output is correct

Subtask #2
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 3 ms 4172 KB Output is correct
2 Correct 3 ms 4172 KB Output is correct
3 Correct 3 ms 4172 KB Output is correct
4 Correct 3 ms 4172 KB Output is correct
5 Correct 4 ms 4172 KB Output is correct
6 Correct 8 ms 4428 KB Output is correct
7 Correct 15 ms 4828 KB Output is correct
8 Correct 13 ms 4684 KB Output is correct
9 Correct 6 ms 4300 KB Output is correct
10 Correct 14 ms 4812 KB Output is correct

Subtask #3
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 5 ms 4172 KB Output is correct
2 Correct 3 ms 4172 KB Output is correct
3 Correct 3 ms 4172 KB Output is correct
4 Correct 3 ms 4172 KB Output is correct
5 Correct 3 ms 4172 KB Output is correct
6 Correct 8 ms 4428 KB Output is correct
7 Correct 14 ms 4876 KB Output is correct
8 Correct 12 ms 4676 KB Output is correct
9 Correct 7 ms 4300 KB Output is correct
10 Correct 14 ms 4860 KB Output is correct
11 Correct 4 ms 4172 KB Output is correct
12 Correct 3 ms 4172 KB Output is correct
13 Correct 8 ms 4428 KB Output is correct
14 Correct 3 ms 4176 KB Output is correct
15 Correct 15 ms 4808 KB Output is correct

Subtask #4
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 3 ms 4172 KB Output is correct
2 Correct 3 ms 4172 KB Output is correct
3 Correct 3 ms 4204 KB Output is correct
4 Correct 3 ms 4172 KB Output is correct
5 Correct 3 ms 4172 KB Output is correct

Subtask #5
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 3 ms 4172 KB Output is correct
2 Correct 3 ms 4172 KB Output is correct
3 Correct 3 ms 4172 KB Output is correct
4 Correct 3 ms 4172 KB Output is correct
5 Correct 3 ms 4172 KB Output is correct
6 Correct 3 ms 4172 KB Output is correct
7 Correct 3 ms 4172 KB Output is correct
8 Correct 3 ms 4172 KB Output is correct
9 Correct 3 ms 4172 KB Output is correct
10 Correct 3 ms 4172 KB Output is correct

Subtask #6
20.0 / 20.0

# Verdict Execution time Memory Grader output
1 Correct 3 ms 4172 KB Output is correct
2 Correct 3 ms 4172 KB Output is correct
3 Correct 3 ms 4172 KB Output is correct
4 Correct 3 ms 4172 KB Output is correct
5 Correct 3 ms 4172 KB Output is correct
6 Correct 4 ms 4172 KB Output is correct
7 Correct 3 ms 4172 KB Output is correct
8 Correct 3 ms 4172 KB Output is correct
9 Correct 3 ms 4172 KB Output is correct
10 Correct 3 ms 4172 KB Output is correct
11 Correct 13 ms 5068 KB Output is correct
12 Correct 15 ms 5324 KB Output is correct
13 Correct 29 ms 6316 KB Output is correct
14 Correct 13 ms 5068 KB Output is correct
15 Correct 31 ms 5836 KB Output is correct

Subtask #7
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 3 ms 4112 KB Output is correct
2 Correct 4 ms 4172 KB Output is correct
3 Correct 3 ms 4172 KB Output is correct

Subtask #8
15.0 / 15.0

# Verdict Execution time Memory Grader output
1 Correct 3 ms 4172 KB Output is correct
2 Correct 3 ms 4172 KB Output is correct
3 Correct 2 ms 4172 KB Output is correct
4 Correct 3 ms 4172 KB Output is correct
5 Correct 3 ms 4172 KB Output is correct
6 Correct 3 ms 4172 KB Output is correct
7 Correct 3 ms 4172 KB Output is correct
8 Correct 3 ms 4172 KB Output is correct

Subtask #9
15.0 / 15.0

# Verdict Execution time Memory Grader output
1 Correct 3 ms 4172 KB Output is correct
2 Correct 3 ms 4172 KB Output is correct
3 Correct 3 ms 4172 KB Output is correct
4 Correct 3 ms 4172 KB Output is correct
5 Correct 3 ms 4172 KB Output is correct
6 Correct 3 ms 4172 KB Output is correct
7 Correct 4 ms 4172 KB Output is correct
8 Correct 3 ms 4172 KB Output is correct
9 Correct 24 ms 5388 KB Output is correct
10 Correct 20 ms 5072 KB Output is correct
11 Correct 9 ms 4556 KB Output is correct
12 Correct 11 ms 4556 KB Output is correct
13 Correct 5 ms 4300 KB Output is correct

Subtask #10
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 3 ms 4172 KB Output is correct
2 Correct 3 ms 4172 KB Output is correct
3 Correct 3 ms 4172 KB Output is correct
4 Correct 3 ms 4172 KB Output is correct
5 Correct 3 ms 4172 KB Output is correct
6 Correct 3 ms 4172 KB Output is correct
7 Correct 3 ms 4172 KB Output is correct
8 Correct 3 ms 4172 KB Output is correct
9 Correct 24 ms 5324 KB Output is correct
10 Correct 20 ms 5192 KB Output is correct
11 Correct 10 ms 4476 KB Output is correct
12 Correct 11 ms 4660 KB Output is correct
13 Correct 5 ms 4304 KB Output is correct
14 Correct 31 ms 5424 KB Output is correct
15 Correct 34 ms 6604 KB Output is correct
16 Correct 8 ms 4644 KB Output is correct
17 Correct 24 ms 5768 KB Output is correct
18 Correct 14 ms 5068 KB Output is correct