oj.uz

답안 #1083280

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
1083280 2024-09-02T20:30:42 Z Joshua_Andersson Necklace (Subtask 1-3) (BOI19_necklace1) C++14
37 / 85
 1257 ms 71016 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;

        if (rand()%2)
        {
            while (aa < sz(a) && ba < sz(b) && a[aa] == b[ba])
            {
                aa++;
                ba++;
            }
        }
        else if (rand()%2)
        {
            while (ab > 0 && bb > 0 && a[ab] == b[bb])
            {
                ab--;
                bb--;
            }
        }

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

        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

# 결과 실행 시간 메모리 Grader output
1 Correct 1199 ms 512 KB Output is correct
2 Correct 1200 ms 524 KB Output is correct
3 Correct 1200 ms 500 KB Output is correct
4 Correct 1195 ms 348 KB Output is correct
5 Correct 1193 ms 348 KB Output is correct

Subtask #2
4.0 / 20.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1199 ms 512 KB Output is correct
2 Correct 1200 ms 524 KB Output is correct
3 Correct 1200 ms 500 KB Output is correct
4 Correct 1195 ms 348 KB Output is correct
5 Correct 1193 ms 348 KB Output is correct
6 Correct 1194 ms 1624 KB Output is correct
7 Partially correct 1192 ms 1724 KB Output is partially correct
8 Correct 1200 ms 1444 KB Output is correct
9 Correct 1199 ms 1624 KB Output is correct
10 Correct 1198 ms 1712 KB Output is correct
11 Correct 1187 ms 1856 KB Output is correct
12 Correct 1193 ms 1632 KB Output is correct

Subtask #3
8.0 / 40.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1199 ms 512 KB Output is correct
2 Correct 1200 ms 524 KB Output is correct
3 Correct 1200 ms 500 KB Output is correct
4 Correct 1195 ms 348 KB Output is correct
5 Correct 1193 ms 348 KB Output is correct
6 Correct 1194 ms 1624 KB Output is correct
7 Partially correct 1192 ms 1724 KB Output is partially correct
8 Correct 1200 ms 1444 KB Output is correct
9 Correct 1199 ms 1624 KB Output is correct
10 Correct 1198 ms 1712 KB Output is correct
11 Correct 1187 ms 1856 KB Output is correct
12 Correct 1193 ms 1632 KB Output is correct
13 Partially correct 1243 ms 71016 KB Output is partially correct
14 Partially correct 1251 ms 71012 KB Output is partially correct
15 Partially correct 1256 ms 67056 KB Output is partially correct
16 Partially correct 1248 ms 70084 KB Output is partially correct
17 Partially correct 1250 ms 68700 KB Output is partially correct
18 Partially correct 1246 ms 70684 KB Output is partially correct
19 Partially correct 1257 ms 70552 KB Output is partially correct
20 Partially correct 1248 ms 68600 KB Output is partially correct
21 Partially correct 1241 ms 69344 KB Output is partially correct