답안 #545687

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
545687 2022-04-05T07:49:52 Z balbit Shuffle (NOI19_shuffle) C++14
컴파일 오류
0 ms 0 KB
#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 = {6,4,3,2,1,5};

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]));
    }
    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;
    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;
}

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) {
        // 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;
    }
    if (ST == 4) {
        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);

        // 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]);
        vector<vector<int> > c1 = myshuffle(ask1);
        swap(ask1[0][0], ask1[1][0]);
        swap(ask1[0][0], ask1[2][0]);
        vector<vector<int> > c2 = myshuffle(ask1);

        vector<int> d1 = chg(c1, gt1);
        vector<int> d2 = chg(c2, gt1);

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

        dfs(one, 1);

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



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;
}

Compilation message

shuffle.cpp: In function 'std::vector<int> solve(int, int, int, int, int)':
shuffle.cpp:201:1: warning: control reaches end of non-void function [-Wreturn-type]
  201 | }
      | ^
/usr/bin/ld: /tmp/ccKAMbN5.o: in function `main':
grader.cpp:(.text.startup+0x0): multiple definition of `main'; /tmp/cc44SBj7.o:shuffle.cpp:(.text.startup+0x0): first defined here
collect2: error: ld returned 1 exit status