Submission #967185

# Submission time Handle Problem Language Result Execution time Memory
967185 2024-04-21T12:55:47 Z Requiem Vrtić (COCI18_vrtic) C++17
128 / 160
2000 ms 52960 KB
#include<bits/stdc++.h>
//#define int long long
#define pb push_back
#define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
#define MOD 100000007
#define INF 1e18
#define fi first
#define se second
#define FOR(i,a,b) for(int i=a;i<=b;i++)
#define FORD(i,a,b) for(int i=a;i>=b;i--)
#define sz(a) ((int)(a).size())
#define endl '\n'
#define pi 3.14159265359
#define TASKNAME "vrtic"
template<typename T> bool maximize(T &res, const T &val) { if (res < val){ res = val; return true; }; return false; }
template<typename T> bool minimize(T &res, const T &val) { if (res > val){ res = val; return true; }; return false; }
using namespace std;
typedef pair<int,int> ii;
typedef pair<int,ii> iii;
typedef vector<int> vi;
const int MAXN = 153;
int n;
int best_friend[MAXN], bag_of_candy[MAXN];

namespace subtask1{
    bool checkSubtask1(){
         for(int i = 1; i <= n; i++){
             if (best_friend[i] != i % n + 1) return false;
         }
         return true;
    }

    int arr[MAXN];

    void solveSubtask1(){
        int res = 0, splitting_point = 0;
        sort(bag_of_candy + 1, bag_of_candy + 1 + n);
        int cur = 0;

        for(int i = 3; i <= n; i++){
            maximize(res, abs(bag_of_candy[i] - bag_of_candy[i - 2]));
        }

        cout << res << endl;
        for(int i = 1; i <= n; i += 2){
            cout << bag_of_candy[i] << ' ';
        }
        for(int i = n - (n & 1); i > 0; i -= 2){
            cout << bag_of_candy[i] << ' ';
        }
        cout << endl;
    }

}
namespace subtask2{ //not usable yet
    bool checkSubtask2(){
        return n <= 20;
    }

    int MinDistriRange[MAXN][MAXN], ok[MAXN], answer[MAXN];
    vector<vector<int>> Listcycle;
    vector<ii> Nxtmask;
    int dp[21][(1 << 20)], trace[21][(1 << 20)];
    void prep(){
        sort(bag_of_candy + 1, bag_of_candy + 1 + n);
        for(int i = 1; i <= n; i++){
            for(int j = i; j <= n; j++){
                int length = j - i + 1;
                if (length == 1) MinDistriRange[i][j] = 0;
                else if (length == 2) MinDistriRange[i][j] = abs(bag_of_candy[j] - bag_of_candy[i]);
                else {
                     for(int k = i + 2; k <= j; k++){
                         maximize(MinDistriRange[i][j], abs(bag_of_candy[k] - bag_of_candy[k - 2]) );
                     }
                }
            }
        }
    }

    void AssignPermutation(int pos, int msk){
         if (pos == 0) return;
         int taken = trace[pos][msk];

         int numbit = __builtin_popcount(taken);
         vector<int> arr;
         vector<int> ans;
         for(int i = 0; i < n; i++){
             if (taken & (1 << i)) arr.pb(bag_of_candy[i + 1]);
         }

         for(int i = 0; i < numbit; i += 2){
             ans.pb(arr[i]);
         }
         for(int i = numbit - 1 - !((numbit - 1)&1); i >= 0; i -= 2){
             ans.pb(arr[i]);
         }

         for(int i = 0; i < Listcycle[pos - 1].size(); i++){
             answer[Listcycle[pos - 1][i]] = ans[i];
         }

         AssignPermutation(pos - 1, msk ^ taken);
    }
    void solveSubtask2(){
        prep();
        memset(ok, 0, sizeof(ok));
        int numcycle = 0;
        for(int i = 1; i <= n; i++){
            if (ok[i]) continue;
            vector<int> oneCycle;
            numcycle++;
            for(int j = i; !ok[j] ; j = best_friend[j]){
                oneCycle.pb(j);
                ok[j] = 1;
            }
            Listcycle.pb(oneCycle);
        }
        memset(dp, 0x3f, sizeof(dp));
        sort(Listcycle.begin(), Listcycle.end(), [&](const vector<int> &a, const vector<int> &b){
             return a.size() > b.size();
        });
        queue<array<int, 3>> q;
        q.push({0, 0, 0});
        dp[0][0] = 0;
        int sz = 0;
        while(!q.empty()){
            int du = q.front()[0];
            int pos = q.front()[1];
            int msk = q.front()[2];
            int testmsk = 0;
            q.pop();
            if (du > dp[pos][msk] or pos == (int) Listcycle.size()) continue;

            int sz = Listcycle[pos].size();
            for(int i = 0; i < sz; i++){
                testmsk <<= 1;
                testmsk++;
            }

//            cout << sz << ' ' << testmsk << endl;
            for(int j = 0; j < n + 1 - sz; j++){
                if (((testmsk << j) & msk) == 0) {
                    if (minimize(dp[pos + 1][msk ^ (testmsk << j)], max(du, MinDistriRange[j + 1][j + sz]))){
                        q.push({dp[pos + 1][msk ^ (testmsk << j)], pos + 1, msk ^ (testmsk << j) });
                        trace[pos + 1][msk ^ (testmsk << j)] = (testmsk << j);
                    }
                }
            }
        }
        cout << dp[Listcycle.size()][(1 << n) - 1] << endl;
        AssignPermutation(Listcycle.size(), (1 << n) - 1);
        for(int i = 1; i <= n; i++){
            cout << answer[i] << ' ';
        }
        cout << endl;
    }
}
namespace subtask3{
    int MinDistriRange[MAXN][MAXN], ok[MAXN], answer[MAXN], startState, destState;
    ii trace[MAXN];
    vector<int> range[MAXN][MAXN];
    vector<vector<int>> Listcycle;
    vector<vector<int>> cycle[MAXN];

    map<int, int> dp;
    map<int, bitset<MAXN>> transfer;
    bitset<MAXN> prepmask[MAXN][MAXN];

    const int base = 113;

    int hashState(bitset<MAXN> &mask){
        int res = 0;
        for(int i = 0; i < MAXN; i++){
            res = 1LL * (1LL * res * base + (mask[i] + 1) * 1LL) % MOD;
        }
        if (transfer.find(res) == transfer.end()) transfer[res] = mask;
        return res;
    }
    void prep(){
        sort(bag_of_candy + 1, bag_of_candy + 1 + n);
        for(int i = 1; i <= n; i++){
            for(int j = i; j <= n; j++){
                int length = j - i + 1;
                if (length == 1) MinDistriRange[i][j] = 0;
                else if (length == 2) MinDistriRange[i][j] = abs(bag_of_candy[j] - bag_of_candy[i]);
                else {
                     for(int k = i + 2; k <= j; k++){
                         maximize(MinDistriRange[i][j], abs(bag_of_candy[k] - bag_of_candy[k - 2]) );
                     }
                }
//                cout << MinDistriRange[i][j] << ' ';

                vector<int> arr;
                vector<int> ans;
                for(int k = i; k <= j; k++){
                    arr.pb(bag_of_candy[k]);
                }

                for(int k = 0; k < length; k += 2){
                    ans.pb(arr[k]);
                }
                for(int k = length - 1 - ((length - 1) % 2 == 0); k >= 0; k -= 2){
                    ans.pb(arr[k]);
                }
                range[i][j] = ans;
            }
//            cout << endl;
        }
    }

    bitset<MAXN> BitsetMask;

    bool found = false;

    void Assign(){
        for(int i = 0; i < Listcycle.size(); i++){
//            cout << trace[i].fi << ' ' << trace[i].se << endl;
            for(int j = 0; j < Listcycle[i].size(); j++){
                answer[Listcycle[i][j]] = range[trace[i].fi][trace[i].se][j];
            }
        }
    }
    void dfs(int pos, int msk, int mid, bool traceback){
        if (!found and pos == Listcycle.size()) {
            found = true;
            if (traceback) Assign();
            return;
        }
        int sz = Listcycle[pos].size();
//        if (pos == 5) cout << pos << ' ' << msk << ' ' << mid << ' ' << sz << endl;
        BitsetMask = transfer[msk];
        for(int i = 0; i < n - sz + 1; i++){
            if (!found and (BitsetMask & prepmask[sz - 1][i]).count() == 0 and MinDistriRange[i + 1][i + sz] <= mid){
                BitsetMask ^= prepmask[sz - 1][i];
                int nxtState = hashState(BitsetMask);
                if (!found and dp.find(nxtState) == dp.end()){
                    dp[nxtState] = 1;
                    if (traceback) trace[pos] = ii(i + 1, i + sz);
                    dfs(pos + 1, nxtState, mid, traceback);
                }
                BitsetMask ^= prepmask[sz - 1][i];
            }
        }
    }
    bool check(int mid){
        dp.clear();
        found = false;
        dfs(0, startState, mid, 0);
        return found;
    }
    void solveSubtask3(){
        prep();
        memset(ok, 0, sizeof(ok));
//        cout << MinDistriRange[13][14] << endl;
        int numcycle = 0;
        for(int i = 1; i <= n; i++){
            if (ok[i]) continue;
            vector<int> oneCycle;
            numcycle++;
            for(int j = i; !ok[j] ; j = best_friend[j]){
                oneCycle.pb(j);
                ok[j] = 1;
            }
            cycle[oneCycle.size()].pb(oneCycle);
            Listcycle.pb(oneCycle);
        }
        sort(Listcycle.begin(), Listcycle.end(), [&](const vector<int> &a, const vector<int> &b){
             return a.size() > b.size();
        });
        prepmask[0][0][0] = 1;
        for(int i = 1; i <= n; i++){
            prepmask[0][i] = prepmask[0][i - 1] << 1;
        }
        for(int i = 1; i <= n; i++){
            prepmask[i][0] = prepmask[i - 1][0] << 1;
            prepmask[i][0][0] = 1;
            for(int j = 1; j <= n; j++){
                prepmask[i][j] = prepmask[i][j - 1] << 1;
            }
        }
//        cout << Listcycle.size() << endl;
        int l = 0, r = 1e9, res = 0;
        startState = hashState(BitsetMask);
        for(int i = 0; i < n; i++){
            BitsetMask[i] = 1;
        }
        destState = hashState(BitsetMask);

        while(l <= r){
            int mid = (l + r) >> 1;
            if (check(mid)){
                res = mid;
                r = mid - 1;
            }
            else {
                l = mid + 1;
            }
        }
        dp.clear();
        found = false;
        dfs(0, startState, res, 1);
        cout << res << endl;
        for(int i = 1; i <= n; i++){
            cout << answer[i] << ' ';
        }
        cout << endl;
//          if (check(22328)){
//              cout << "YES" << endl;
//          }
//          else{
//              cout << "NO" << endl;
//          }
    }
}
main()
{
    fast;
    if (fopen(TASKNAME".inp","r")){
        freopen(TASKNAME".inp","r",stdin);
        freopen(TASKNAME".out","w",stdout);
    }
    cin >> n;
    for(int i = 1; i <= n; i++){
        cin >> best_friend[i];
    }

    for(int i = 1; i <= n; i++){
        cin >> bag_of_candy[i];
    }

//    if (subtask1::checkSubtask1()) return subtask1::solveSubtask1(), 0;
//    if (subtask2::checkSubtask2()) return subtask2::solveSubtask2(), 0;
    return subtask3::solveSubtask3(), 0;

}
/**
Warning:
- MLE / TLE?
- Gioi han mang?
- Gia tri max phai luon gan cho -INF
- long long co can thiet khong?
- tran mang.
- code can than hon
- Nho sinh test de tranh RTE / TLE
--> Coi lai truoc khi nop
**/

Compilation message

vrtic.cpp: In function 'void subtask1::solveSubtask1()':
vrtic.cpp:36:22: warning: unused variable 'splitting_point' [-Wunused-variable]
   36 |         int res = 0, splitting_point = 0;
      |                      ^~~~~~~~~~~~~~~
vrtic.cpp:38:13: warning: unused variable 'cur' [-Wunused-variable]
   38 |         int cur = 0;
      |             ^~~
vrtic.cpp: In function 'void subtask2::AssignPermutation(int, int)':
vrtic.cpp:98:27: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   98 |          for(int i = 0; i < Listcycle[pos - 1].size(); i++){
      |                         ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~
vrtic.cpp: In function 'void subtask2::solveSubtask2()':
vrtic.cpp:125:13: warning: unused variable 'sz' [-Wunused-variable]
  125 |         int sz = 0;
      |             ^~
vrtic.cpp: In function 'void subtask3::Assign()':
vrtic.cpp:216:26: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<std::vector<int> >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  216 |         for(int i = 0; i < Listcycle.size(); i++){
      |                        ~~^~~~~~~~~~~~~~~~~~
vrtic.cpp:218:30: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  218 |             for(int j = 0; j < Listcycle[i].size(); j++){
      |                            ~~^~~~~~~~~~~~~~~~~~~~~
vrtic.cpp: In function 'void subtask3::dfs(int, int, int, bool)':
vrtic.cpp:224:28: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<std::vector<int> >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  224 |         if (!found and pos == Listcycle.size()) {
      |                        ~~~~^~~~~~~~~~~~~~~~~~~
vrtic.cpp: At global scope:
vrtic.cpp:315:1: warning: ISO C++ forbids declaration of 'main' with no type [-Wreturn-type]
  315 | main()
      | ^~~~
vrtic.cpp: In function 'int main()':
vrtic.cpp:319:16: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  319 |         freopen(TASKNAME".inp","r",stdin);
      |         ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~
vrtic.cpp:320:16: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  320 |         freopen(TASKNAME".out","w",stdout);
      |         ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~
# Verdict Execution time Memory Grader output
1 Correct 1 ms 2648 KB Output is correct
# Verdict Execution time Memory Grader output
1 Correct 7 ms 4956 KB Output is correct
# Verdict Execution time Memory Grader output
1 Correct 1 ms 2396 KB Output is correct
# Verdict Execution time Memory Grader output
1 Correct 1 ms 2396 KB Output is correct
# Verdict Execution time Memory Grader output
1 Correct 1 ms 2396 KB Output is correct
# Verdict Execution time Memory Grader output
1 Execution timed out 2015 ms 22356 KB Time limit exceeded
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Incorrect 1523 ms 52960 KB no bag with given amount of candy
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Correct 8 ms 4188 KB Output is correct
2 Correct 8 ms 4188 KB Output is correct
# Verdict Execution time Memory Grader output
1 Correct 14 ms 4956 KB Output is correct
2 Correct 91 ms 6300 KB Output is correct
# Verdict Execution time Memory Grader output
1 Correct 41 ms 5356 KB Output is correct
2 Correct 12 ms 4952 KB Output is correct