oj.uz

Submission #1083314

# Submission time Handle Problem Language Result Execution time Memory
1083314 2024-09-02T22:37:05 Z Joshua_Andersson Necklace (Subtask 1-3) (BOI19_necklace1) C++14
53 / 85
 1261 ms 71256 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]) % mod;
        }

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

    ull gethash(int l, int r) // hash s[l, r]
    {
        ull rv = (suf[r + 1] * b[r - l + 1]) % mod;
        return suf[l] + mod * (suf[l] < rv) - 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);
    vvi lcp(sz(a), vi(sz(b)));
    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;
    bool pront = false;
    auto start = chrono::high_resolution_clock::now();

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


        while (aa < sz(a) && ba < sz(b) && a[aa] == b[ba])
        {
            aa++;
            ba++;
        }

        while (ab > 0 && bb > 0 && a[ab-1] == b[bb-1])
        {
            ab--;
            bb--;
        }
        

        //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 (pront)
            {
                repp(k, i, i + llen) cout << a[k];
                cout << "\n";
                repp(k, j, j + llen) cout << b[k];
                cout << "\n\n";
            }
            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 1201 ms 520 KB Output is correct
2 Correct 1196 ms 348 KB Output is correct
3 Correct 1194 ms 344 KB Output is correct
4 Correct 1196 ms 508 KB Output is correct
5 Correct 1201 ms 344 KB Output is correct

Subtask #2
20.0 / 20.0

# Verdict Execution time Memory Grader output
1 Correct 1201 ms 520 KB Output is correct
2 Correct 1196 ms 348 KB Output is correct
3 Correct 1194 ms 344 KB Output is correct
4 Correct 1196 ms 508 KB Output is correct
5 Correct 1201 ms 344 KB Output is correct
6 Correct 1194 ms 1628 KB Output is correct
7 Correct 1194 ms 1628 KB Output is correct
8 Correct 1200 ms 1440 KB Output is correct
9 Correct 1200 ms 1628 KB Output is correct
10 Correct 1200 ms 1880 KB Output is correct
11 Correct 1197 ms 1696 KB Output is correct
12 Correct 1196 ms 1624 KB Output is correct

Subtask #3
8.0 / 40.0

# Verdict Execution time Memory Grader output
1 Correct 1201 ms 520 KB Output is correct
2 Correct 1196 ms 348 KB Output is correct
3 Correct 1194 ms 344 KB Output is correct
4 Correct 1196 ms 508 KB Output is correct
5 Correct 1201 ms 344 KB Output is correct
6 Correct 1194 ms 1628 KB Output is correct
7 Correct 1194 ms 1628 KB Output is correct
8 Correct 1200 ms 1440 KB Output is correct
9 Correct 1200 ms 1628 KB Output is correct
10 Correct 1200 ms 1880 KB Output is correct
11 Correct 1197 ms 1696 KB Output is correct
12 Correct 1196 ms 1624 KB Output is correct
13 Correct 1261 ms 71204 KB Output is correct
14 Correct 1255 ms 71256 KB Output is correct
15 Correct 1254 ms 66976 KB Output is correct
16 Correct 1256 ms 70080 KB Output is correct
17 Partially correct 1251 ms 68508 KB Output is partially correct
18 Partially correct 1251 ms 70548 KB Output is partially correct
19 Correct 1258 ms 70548 KB Output is correct
20 Partially correct 1253 ms 68508 KB Output is partially correct
21 Partially correct 1257 ms 69308 KB Output is partially correct