Submission #545695

#	Submission time	Handle	Problem	Language	Result	Execution time	Memory
545695	2022-04-05T08:05:37 Z	balbit	Shuffle (NOI19_shuffle)	C++14	14 / 100	25 ms	38120 KB

shuffle

#include "shuffle.h"
#include <bits/stdc++.h>
//#define int ll
using namespace std;

#define ll long long
#define f first
#define s second
#define pii pair<int, int>

#define MX(a,b) a=max(a,b)
#define MN(a,b) a=min(a,b)
#define SZ(x) (int)(x).size()
#define ALL(x) (x).begin(), (x).end()

#define REP(i,n) for (int i = 0; i<n; ++i)
#define REP1(i,n) for (int i = 1; i<=n; ++i)
#define pb push_back

#ifdef BALBIT
#define bug(...) cerr<<"#"<<__LINE__<<": "<<#__VA_ARGS__<<"- ", _do(__VA_ARGS__)
template<typename T> void _do( T && x) {cerr<<x<<endl;}
template<typename T, typename ...S> void _do( T && x, S && ...y) {cerr<<x<<", "; _do(y...);}
#else
#define bug(...)
#define endl '\n'
#endif // BALBIT

const int maxn = 3e5+5;

#define VI vector<int>

#ifdef BALBIT

vector<int> per = {1,2,3,4,5,6};

std::vector< std::vector<int> > shuffle(std::vector< std::vector<int> > x){
    REP(i, SZ(x)) {
        for (int &y:x[i]) {
            y = per[y-1];
        }
        random_shuffle(ALL(x[i]));
    }
    random_shuffle(ALL(x));
    return x;
//    REP(i, SZ(x)) {
//        for (int y : x[i]) cout<<y<<' ';
//        cout<<endl;
//    }
//    cout<<endl;
//    bug("enter!");
//    vector<vector<int> > re(SZ(x), vector<int> (SZ(x[0])));
//    REP(i, SZ(x)) REP(j, SZ(x[0])) cin>>x[i][j];
//    return re;
}
#endif // BALBIT

vector<vector<int> > myshuffle(vector<vector<int> > b) {
    for (auto &y : b) for (int &x : y) ++x;
    vector<vector<int> > gt = shuffle(b);
    for (auto &y : gt) {
        for(int &x : y) --x;
        sort(ALL(y));
    }

    return gt;
}

vector<int> g1[maxn], g2[maxn];

bool seen[maxn];
vector<int> ord;
void dfs(int v, bool one) {
    ord.pb(v); seen[v] = 1;
    for (int u : (one?g1:g2)[v]) {
        if (!seen[u]) {
            dfs(u, one^1);
        }
    }
}
#define vvi vector<vector<int> >
vector<int> chg(vvi a, vvi b) {
    vector<int> GP(SZ(a) * SZ(a[0]));
    REP(i, SZ(a)) {
        for (int x : a[i]) {
            GP[x] = i;
        }
    }
    vector<int> re;
    REP(i, SZ(b)) {
        for (int x : b[i]) {
            if (i != GP[x]) {
                re.pb(x);
            }
        }
    }
    return re;
}

void ASS(bool t) {
    if (!t) {
        while(1);
    }
}

vector<int> solve(int N, int B, int K, int Q, int ST) {

    auto F = [&](int &at) {int oat = at; at = (at+1)%B; return oat; };

    if (ST == 3 || ST == 1) {
        // shuffle solving for the case where the buckets AREN't shuffled
        vector<pair<VI, VI> > v;
        vector<int> strt;
        REP(i,N) strt.pb(i);
        v.pb({strt, strt});
        // groups of {index, p[i]}
        while (1) {
            vector<vector<int> > ask (B);
            vector<int> whichbucket(N); // which bucket is this index tossed into?
            vector<int> group(N); // which group is this result from?
            bool need = 0;
            int AT = 0;
            int grp = 0;
            vector<vector<pair<VI, VI> > > yeah(SZ(v));

            for (auto &e : v) {
                yeah[grp].resize(B);
                if (SZ(e.f) > 1) need = 1;
                REP(i, SZ(e.f)) {
                    whichbucket[e.f[i]] = AT;
                    yeah[grp][AT].f.pb(e.f[i]);
                    ask[AT].pb(e.f[i]);
                    F(AT);
                }
                for (int x : e.s) {
                    group[x]=grp;
                }
                ++grp;
            }
            if (need == 0) break;

            vector<vector<int> > get = myshuffle(ask);

            vector<pair<VI, VI> > nv;


            REP(i, B) {
                REP(j, K) {
                    yeah[group[get[i][j]]][i].s.pb(
                                                 get[i][j]);
                }
            }

            for (auto & e : yeah) {
                REP(i,B) {
                    if (SZ(e[i].f)) {
                        nv.pb(e[i]);
                    }
                }
            }

            v.swap(nv);
        }

        vector<int> re(N);
        bug(SZ(v));
        assert(SZ(v) == N);
        REP(i, SZ(v)) {
            re[v[i].f[0]] = v[i].s[0] + 1;
        }
        return re;
    }
    else if (ST == 4 || ST == 2) {
        assert(K == 2);
        vector<vector<int> > ask1, ask2;
        REP(i,N) {
            if (i % 2 == 0) {
                ask1.pb({i, i+1});
            }else{
                ask2.pb({i, (i+1)%N});
            }
        }
        vector<vector<int> > gt1 = myshuffle(ask1), gt2 = myshuffle(ask2);
        sort(ALL(gt1)); sort(ALL(gt2));

        // build graphs
        REP(i,SZ(gt1)) {
            g1[gt1[i][0]].pb(gt1[i][1]);
            g1[gt1[i][1]].pb(gt1[i][0]);
            g2[gt2[i][0]].pb(gt2[i][1]);
            g2[gt2[i][1]].pb(gt2[i][0]);
        }

        swap(ask1[0][0], ask1[1][0]); // swapping 0 and 2 (1 and 3 in 1-based)
        vector<vector<int> > c1 = myshuffle(ask1);
        swap(ask1[0][0], ask1[1][0]);

        // now look for the pair that doesn't appear in either ask1 or ask2: that is the sus pair

        vector<int> d1;
        for (vector<int> t : c1) {
            if (!binary_search(ALL(ask1), t) && !binary_search(ALL(ask2), t)) {
                assert(SZ(d1) == 0);
                d1 = t;
            }
        }

        swap(ask1[0][0], ask1[2][0]);
        vector<vector<int> > c2 = myshuffle(ask1);
        swap(ask1[0][0], ask1[2][0]);

        vector<int> d2;

        for (vector<int> t : c2) {
            if (!binary_search(ALL(ask1), t) && !binary_search(ALL(ask2), t)) {
//                assert(SZ(d2) == 0);
//                d2 = t;
                for (int y : t) d2.pb(y);
            }
        }

        bug(SZ(d1), SZ(d2));


        ASS(SZ(d1) == 2); // ASS(SZ(d2) == 2);
        int one = -1;
        for (int x : d1) for (int y : d2) if (x == y) one = x;
        ASS(one != -1);

        dfs(one, 1);

        for (int &x : ord) ++x;
        return ord;
    }
}


#ifdef BALBIT
signed main(){
    ios::sync_with_stdio(0), cin.tie(0);
    bug(1,2);
    vector<int> gt = solve(6,3,2,-1,4);
    for(int x : gt) cout<<x<<' ';
    cout<<endl;
}

#endif

Compilation message

shuffle.cpp: In function 'std::vector<int> solve(int, int, int, int, int)':
shuffle.cpp:235:1: warning: control reaches end of non-void function [-Wreturn-type]
  235 | }
      | ^

Subtask #1
2.0 / 2.0

#	Verdict	Execution time	Memory	Grader output
1	Correct	8 ms	14292 KB	Output is correct
2	Correct	8 ms	14360 KB	Output is correct
3	Correct	8 ms	14408 KB	Output is correct
4	Correct	8 ms	14404 KB	Output is correct
5	Correct	8 ms	14292 KB	Output is correct

Subtask #2
0.0 / 3.0

#	Verdict	Execution time	Memory	Grader output
1	Runtime error	18 ms	29044 KB	Execution killed with signal 6
2	Halted	0 ms	0 KB	-

Subtask #3
12.0 / 12.0

#	Verdict	Execution time	Memory	Grader output
1	Correct	9 ms	14804 KB	Output is correct
2	Correct	16 ms	27180 KB	Output is correct
3	Correct	11 ms	18372 KB	Output is correct
4	Correct	10 ms	14548 KB	Output is correct
5	Correct	25 ms	38120 KB	Output is correct