Submission #428614

#	Time	Username	Problem	Language	Result	Execution time	Memory
428614		markthitrin	Gondola (IOI14_gondola)	C++14	75 / 100	53 ms	4668 KiB

gondola

#include "gondola.h"
#include <map>
#include <queue>
#include <algorithm>
#include <iostream>
class name {
public:
    int value;
    int base;
    bool operator<(const name& b) const{
        return value > b.value;
    }
    void operator=(const name& b){
        value = b.value;
        base = b.base;
    }
}put_in;
long long mod = 1000000009;
int valid(int n, int inputSeq[])
{
    std::map<int,bool> g;
    int max = 0;
    int find_min = 2000000000;
    int min_pos = 0;
    for(int q = 0 ;q<n;q++){
        if(g[inputSeq[q]])
            return 0;
        g[inputSeq[q]] = true;
        if(find_min > inputSeq[q]){
            find_min = inputSeq[q];
            min_pos = q;
        }
    }
    if(find_min > n)
        return 1;
    int last_pos = min_pos - find_min;
    for(int q = min_pos;q < min_pos + n;q++){
        if(max < inputSeq[q % n] && inputSeq[q % n] <= n){
            if(inputSeq[q % n] - max != q - last_pos)
                return 0;
            max = inputSeq[q % n];
            inputSeq[q % n] = 2000000000;
            last_pos = q;
        }
    }
    for(int q = 0 ;q<n;q++){
        if(inputSeq[q] <= n)
        return 0;
    }
    return 1;
}

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

int replacement(int n, int gondolaSeq[], int replacementSeq[])
{
    std::priority_queue<name> g;
    int max = 0;
    for(int q = 0 ;q<n;q++){
        max = std::max(max,gondolaSeq[q]);
    }
    int find_min = 2000000000;
    int min_pos;
    for(int q = 0 ;q<n;q++){
        if(find_min > gondolaSeq[q]){
            find_min = gondolaSeq[q];
            min_pos = q;
        }
    }
    if(find_min > n)
        min_pos = 0;
    else {
        min_pos -= find_min - 1;
        if(min_pos < 0) min_pos += n;
    }
    for(int q = min_pos;q<min_pos + n;q++){
        put_in.value = gondolaSeq[q % n];
        put_in.base = q + 1 - min_pos;
        g.push(put_in);
    }
    int cnt = 0;
    int last_value = n;
    while(!g.empty()){
        put_in = g.top();
        g.pop();
        if(put_in.value <= n)
            continue;
        replacementSeq[cnt++] = put_in.base;
        for(int q = last_value + 1;q<put_in.value;q++){
            replacementSeq[cnt++] = q;
        }
        last_value = put_in.value;
    }
    return cnt;
}

//----------------------
bool valid_g(std::vector<int> inputSeq){
    int n = inputSeq.size();
    std::map<int,bool> g;
    int max = 0;
    int find_min = 2000000000;
    int min_pos = 0;
    for(int q = 0 ;q<n;q++){
        if(g[inputSeq[q]])
            return false;
        g[inputSeq[q]] = true;
        if(find_min > inputSeq[q]){
            find_min = inputSeq[q];
            min_pos = q;
        }
    }
    if(find_min > n)
        return false;
    int last_pos = min_pos - find_min;
    for(int q = min_pos;q < min_pos + n;q++){
        if(max < inputSeq[q % n] && inputSeq[q % n] <= n){
            if(inputSeq[q % n] - max != q - last_pos)
                return false;
            max = inputSeq[q % n];
            inputSeq[q % n] = 2000000000;
            last_pos = q;
        }
    }
    for(int q = 0 ;q<n;q++){
        if(inputSeq[q] <= n)
        return false;
    }
    return true;
}
long long power(long long a,int number){
    if(number == 0)
        return 1;
    if(number == 1)
        return a;
    long long ans = 1;
    if(number% 2)
        ans *= a;
    ans %= mod;
    ans *= power(a,number/2);
    ans%= mod;
    ans*= power(a,number/2);
    ans%=mod;
    return ans;
}
int countReplacement(int n, int inputSeq[])
{
    std::vector<int> copy;
    for(int q = 0 ;q<n;q++){
        copy.push_back(inputSeq[q]);
    }
    if(!valid_g(copy))
        return 0;
    long long ans = 1;
    std::vector<int> h;
    for(int q = 0 ;q<n;q++){
        if(inputSeq[q] > n)
        h.push_back(inputSeq[q]);
    }
    if(h.size() == 0)
        return 1;
    std::sort(h.begin(),h.end());
    int last_value = n;
    int cnt =0;
    while(h.size() != cnt) {
        ans *= power(h.size() - cnt,h[cnt] - last_value - 1);
        ans %= mod;
        last_value = h[cnt];
        cnt++;
    }
    ans %= mod;
    return int(ans);
}

Compilation message (stderr)

gondola.cpp: In function 'int countReplacement(int, int*)':
gondola.cpp:165:20: warning: comparison of integer expressions of different signedness: 'std::vector<int>::size_type' {aka 'long unsigned int'} and 'int' [-Wsign-compare]
  165 |     while(h.size() != cnt) {
      |           ~~~~~~~~~^~~~~~
gondola.cpp: In function 'int replacement(int, int*, int*)':
gondola.cpp:73:17: warning: 'min_pos' may be used uninitialized in this function [-Wmaybe-uninitialized]
   73 |         min_pos -= find_min - 1;
      |         ~~~~~~~~^~~~~~~~~~~~~~~

• Subtask 1: 5 / 5
• Subtask 2: 5 / 5
• Subtask 3: 10 / 10
• Subtask 4: 5 / 5
• Subtask 5: 10 / 10
• Subtask 6: 20 / 20
• Subtask 7: 5 / 5
• Subtask 8: 15 / 15
• Subtask 9: 0 / 15
• Subtask 10: 0 / 10