oj.uz

Submission #1083460

# Submission time Handle Problem Language Result Execution time Memory
1083460 2024-09-03T08:45:28 Z Joshua_Andersson Necklace (Subtask 1-3) (BOI19_necklace1) C++14
45 / 85
 1399 ms 648 KB 
#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
#define int ll
const int inf = int(1e18);

typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> p2;

#define rep(i, high) for (int i = 0; i < high; i++)
#define repp(i, low, high) for (int i = low; i < high; i++)
#define repe(i, container) for (auto& i : container)
#define sz(container) ((int)container.size())
#define all(x) begin(x),end(x)

inline void fast() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); }

#if _LOCAL
#define assert(x) if (!(x)) __debugbreak()
#endif

typedef unsigned long long ull;

struct RollingHash
{
    vector<ull> suf, b;
    int mod;
    RollingHash(string& s, ull base = 131, ull mod = 1e9 + 7) : mod(mod), suf(s.size() + 1), b(s.size() + 1)
    {
        b[0] = 1;
        b[1] = base;

        for (int i = sz(s) - 1; i >= 0; i--)
        {
            suf[i] = (suf[i + 1] * base + s[i]);
        }

        repp(i, 2, s.size() + 1)
        {
            b[i] = b[i - 1] * b[1];
        }
    }

    ull gethash(int l, int r) // hash s[l, r]
    {
        ull rv = (suf[r + 1] * b[r - l + 1]);
        return suf[l] - rv;
    }
};

struct DoubleHash
{
    RollingHash h1;
    RollingHash h2;
    DoubleHash(string& s, ull mod = 1e9 + 7) : h1(s, 157, mod), h2(s, 131, mod) {}
    ull gethash(int l, int r)
    {
        return (h1.gethash(l, r) << 32) + h2.gethash(l, r);
    }
};

pair<int, p2> best(string a, string b, bool rev)
{
    int ret = -1;
    p2 r = p2(-1, -1);
    DoubleHash h1(a);
    DoubleHash h2(b);
    mt19937 rng;
    uniform_int_distribution<int> da(0, sz(a) - 1);
    uniform_int_distribution<int> db(0, sz(b) - 1);
    int l = 10;
    auto start = chrono::high_resolution_clock::now();

    while (chrono::duration_cast<chrono::milliseconds>(chrono::high_resolution_clock::now() - start).count() < 700)
    {
        int aa = da(rng);
        int ab = aa;
        int ba = db(rng);
        int bb = ba;


        int lo = -1;
        int hi = 4001;
        while (lo + 1 < hi)
        {
            int mid = (lo + hi) / 2;
            if (aa + mid >= sz(a) || ba + mid >= sz(b) || h1.gethash(aa, aa + mid) != h2.gethash(ba, ba + mid))
            {
                hi = mid;
            }
            else lo = mid;
        }
        aa += hi;
        ba += hi;

        lo = -1;
        hi = 4001;
        while (lo + 1 < hi)
        {
            int mid = (lo + hi) / 2;
            if (ab - 1 - mid < 0 || bb - 1 - mid < 0 || h1.gethash(ab - 1 - mid, ab - 1) != h2.gethash(bb - 1 - mid, bb - 1))
            {
                hi = mid;
            }
            else lo = mid;
        }
        ab -= hi;
        bb -= hi;


        //startb = sb;
        //startb = sb;
        //assert(starta != 1830);
        int starta = aa;
        int startb = bb;
        if (rand() % 2)
        {
            starta = ab;
            startb = ba;
        }

        int rp = 0;
        repp(rlen, 1, l * 2 + 1)
        {
            int i = starta - rlen;
            int j = startb;
            if (i < 0 || j + rlen - 1 >= sz(b)) break;
            bool good = h1.gethash(i, i + rlen - 1) == h2.gethash(j, j + rlen - 1);
            if (good) rp = rlen;
        }
        int lp = 0;
        repp(llen, 1, l * 2 + 1)
        {
            int i = starta;
            int j = startb - llen;
            if (j < 0 || i + llen - 1 >= sz(a)) break;
            bool good = h1.gethash(i, i + llen - 1) == h2.gethash(j, j + llen - 1);
            if (good) lp = llen;
        }

        if (rp + lp > ret)
        {
            //assert(rp + lp != 84);
            r = { starta - rp,startb - lp };
            if (rev) r.second = sz(b) - r.second - rp - lp;
            //assert(r != p2(18, 54));
            ret = rp + lp;
            l = max(l, ret);
        }
    }


    return { ret, r };
}

signed main()
{
    fast();

    string a, b;
    cin >> a >> b;
    pair<int, p2> ans = { -1000,p2(0,0) };
    ans = max(ans, best(a, b, 0));
    /*repp(i, 18, 18 + 32)
    {
        cout << a[i];
    }
    cout << "\n";
    repp(i, 54, 54 + 32)
    {
        cout << b[i];
    }*/
    reverse(all(b));
    ans = max(ans, best(a, b, 1));
    cout << ans.first << "\n" << ans.second.first << " " << ans.second.second;

    return 0;
}

Compilation message

necklace.cpp: In constructor 'RollingHash::RollingHash(std::string&, ull, ull)':
necklace.cpp:29:9: warning: 'RollingHash::mod' will be initialized after [-Wreorder]
   29 |     int mod;
      |         ^~~
necklace.cpp:28:17: warning:   'std::vector<long long unsigned int> RollingHash::suf' [-Wreorder]
   28 |     vector<ull> suf, b;
      |                 ^~~
necklace.cpp:30:5: warning:   when initialized here [-Wreorder]
   30 |     RollingHash(string& s, ull base = 131, ull mod = 1e9 + 7) : mod(mod), suf(s.size() + 1), b(s.size() + 1)
      |     ^~~~~~~~~~~
necklace.cpp:13:48: warning: comparison of integer expressions of different signedness: 'll' {aka 'long long int'} and 'std::__cxx11::basic_string<char>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   13 | #define repp(i, low, high) for (int i = low; i < high; i++)
......
   40 |         repp(i, 2, s.size() + 1)
      |              ~~~~~~~~~~~~~~~~~~                 
necklace.cpp:40:9: note: in expansion of macro 'repp'
   40 |         repp(i, 2, s.size() + 1)
      |         ^~~~

Subtask #1
25.0 / 25.0

# Verdict Execution time Memory Grader output
1 Correct 1396 ms 432 KB Output is correct
2 Correct 1389 ms 448 KB Output is correct
3 Correct 1397 ms 436 KB Output is correct
4 Correct 1396 ms 348 KB Output is correct
5 Correct 1391 ms 604 KB Output is correct

Subtask #2
20.0 / 20.0

# Verdict Execution time Memory Grader output
1 Correct 1396 ms 432 KB Output is correct
2 Correct 1389 ms 448 KB Output is correct
3 Correct 1397 ms 436 KB Output is correct
4 Correct 1396 ms 348 KB Output is correct
5 Correct 1391 ms 604 KB Output is correct
6 Correct 1392 ms 468 KB Output is correct
7 Correct 1398 ms 460 KB Output is correct
8 Correct 1399 ms 348 KB Output is correct
9 Correct 1391 ms 464 KB Output is correct
10 Correct 1394 ms 480 KB Output is correct
11 Correct 1399 ms 344 KB Output is correct
12 Correct 1393 ms 348 KB Output is correct

Subtask #3
0.0 / 40.0

# Verdict Execution time Memory Grader output
1 Correct 1396 ms 432 KB Output is correct
2 Correct 1389 ms 448 KB Output is correct
3 Correct 1397 ms 436 KB Output is correct
4 Correct 1396 ms 348 KB Output is correct
5 Correct 1391 ms 604 KB Output is correct
6 Correct 1392 ms 468 KB Output is correct
7 Correct 1398 ms 460 KB Output is correct
8 Correct 1399 ms 348 KB Output is correct
9 Correct 1391 ms 464 KB Output is correct
10 Correct 1394 ms 480 KB Output is correct
11 Correct 1399 ms 344 KB Output is correct
12 Correct 1393 ms 348 KB Output is correct
13 Correct 1390 ms 648 KB Output is correct
14 Correct 1396 ms 600 KB Output is correct
15 Correct 1397 ms 640 KB Output is correct
16 Correct 1396 ms 604 KB Output is correct
17 Correct 1399 ms 636 KB Output is correct
18 Correct 1392 ms 640 KB Output is correct
19 Incorrect 1397 ms 604 KB Output isn't correct
20 Halted 0 ms 0 KB -