QOJ.ac

QOJ

ID	题目	提交者	结果	用时	内存	语言	文件大小	提交时间	测评时间
#727706	#4580. Bicycle Tour	MeatInTheMiddle^#	WA	243ms	21600kb	C++17	9.3kb	2024-11-09 13:36:42	2024-11-09 13:36:43

Judging History

你现在查看的是最新测评结果

[2024-11-09 13:36:43]
评测

测评结果：WA
用时：243ms
内存：21600kb

查看

[2024-11-09 13:36:42]
提交

answer

#include <bits/stdc++.h>
using namespace std;
#define fastio (ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL))
typedef long long ll;
typedef long double lld;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
const int MAXSIZE = 100010;
const long long INF = 2e9 + 5;
const double EPSILON = 1e-14;
const ll DIV = 2000003;
const long double pi = 3.14159265358979323846264338327950288419716939937510L;

struct MaxSeg
{
    struct node
    {
        ll v, lz;
    };
    vector<node> tr;
    vector<ll> a;
    int n;
    void rst(int sz) { n = sz, tr.resize(sz << 2, {0, 0}), a.resize(sz + 1, 0); }
    ll init(int nd, int s, int e)
    {
        if (s == e)
            return tr[nd].v = 0;
        int m = (s + e) >> 1;
        return tr[nd].v = max(init(nd << 1, s, m), init(nd << 1 | 1, m + 1, e));
    }

    void prp(int nd, int s, int e)
    {
        if (tr[nd].lz != 0)
        {
            tr[nd].v = max(tr[nd].v, tr[nd].lz);
            if (s != e)
            {
                tr[nd << 1].lz = max(tr[nd << 1].lz, tr[nd].lz);
                tr[nd << 1 | 1].lz = max(tr[nd << 1 | 1].lz, tr[nd].lz);
            }
            tr[nd].lz = 0;
        }
    }
    void upd(int nd, int s, int e, int l, int r, ll d)
    {
        prp(nd, s, e);
        if (r < s || e < l)
            return;
        if (l <= s && e <= r)
        {
            tr[nd].lz = max(tr[nd].lz, d);
            prp(nd, s, e);
            return;
        }
        int m = (s + e) >> 1;
        upd(nd << 1, s, m, l, r, d);
        upd(nd << 1 | 1, m + 1, e, l, r, d);
        tr[nd].v = max(tr[nd << 1].v, tr[nd << 1 | 1].v);
    }
    void upd(int l, int r, ll d)
    {
        upd(1, 1, n, l, r, d);
    }
    ll qry(int nd, int s, int e, int l, int r)
    {
        prp(nd, s, e);
        if (r < s || e < l)
            return 0;
        if (l <= s && e <= r)
        {
            return tr[nd].v;
        }
        int m = (s + e) >> 1;
        return max(qry(nd << 1, s, m, l, r),
                   qry(nd << 1 | 1, m + 1, e, l, r));
    }
    ll qry(int l, int r)
    {
        return qry(1, 1, n, l, r);
    }
};
struct MinSeg
{
    struct node
    {
        ll v, lz;
    };
    vector<node> tr;
    vector<ll> a;
    int n;
    void rst(int sz) { n = sz, tr.resize(sz << 2, {INF, INF}), a.resize(sz + 1, 0); }
    ll init(int nd, int s, int e)
    {
        if (s == e)
            return tr[nd].v = INF;
        int m = (s + e) >> 1;
        return tr[nd].v = min(init(nd << 1, s, m), init(nd << 1 | 1, m + 1, e));
    }

    void prp(int nd, int s, int e)
    {
        if (tr[nd].lz != INF)
        {
            tr[nd].v = min(tr[nd].v, tr[nd].lz);
            if (s != e)
            {
                tr[nd << 1].lz = min(tr[nd << 1].lz, tr[nd].lz);
                tr[nd << 1 | 1].lz = min(tr[nd << 1 | 1].lz, tr[nd].lz);
            }
            tr[nd].lz = INF;
        }
    }
    void upd(int nd, int s, int e, int l, int r, ll d)
    {
        prp(nd, s, e);
        if (r < s || e < l)
            return;
        if (l <= s && e <= r)
        {
            tr[nd].lz = min(tr[nd].lz, d);
            prp(nd, s, e);
            return;
        }
        int m = (s + e) >> 1;
        upd(nd << 1, s, m, l, r, d);
        upd(nd << 1 | 1, m + 1, e, l, r, d);
        tr[nd].v = min(tr[nd << 1].v, tr[nd << 1 | 1].v);
    }
    void upd(int l, int r, ll d)
    {
        upd(1, 1, n, l, r, d);
    }
    ll qry(int nd, int s, int e, int l, int r)
    {
        prp(nd, s, e);
        if (r < s || e < l)
            return INF;
        if (l <= s && e <= r)
        {
            return tr[nd].v;
        }
        int m = (s + e) >> 1;
        return min(qry(nd << 1, s, m, l, r),
                   qry(nd << 1 | 1, m + 1, e, l, r));
    }
    ll qry(int l, int r)
    {
        return qry(1, 1, n, l, r);
    }
};

class HLD1
{
public:
    int sz[MAXSIZE] = {0}, dep[MAXSIZE] = {0}, par[MAXSIZE] = {0}, top[MAXSIZE] = {0}, in[MAXSIZE] = {0}, out[MAXSIZE] = {0};
    vector<int> g[MAXSIZE];
    vector<int> inp[MAXSIZE];

    MaxSeg seg;
    int chk[MAXSIZE] = {0};
    void dfs(int v = 1)
    {
        chk[v] = 1;
        for (auto i : inp[v])
        {
            if (chk[i])
                continue;
            chk[i] = 1;
            g[v].push_back(i);
            dfs(i);
        }
    }
    void dfs1(int v = 1)
    {
        sz[v] = 1;
        for (auto &i : g[v])
        {
            dep[i] = dep[v] + 1;
            par[i] = v;
            dfs1(i);
            sz[v] += sz[i];
            if (sz[i] > sz[g[v][0]])
                swap(i, g[v][0]);
        }
    }
    int pv;
    void dfs2(int v = 1)
    {
        in[v] = ++pv;
        for (auto i : g[v])
        {
            top[i] = i == g[v][0] ? top[v] : i;
            dfs2(i);
        }
        out[v] = pv;
    }
    void update(int a, int b, int w)
    {
        while (top[a] ^ top[b])
        {
            if (dep[top[a]] < dep[top[b]])
                swap(a, b);
            int st = top[a];
            seg.upd(in[st], in[a], w);
            a = par[st];
        }
        if (dep[a] > dep[b])
            swap(a, b);
        seg.upd(in[a] + 1, in[b], w);
    }
    ll query(int a, int b)
    {
        ll ret = 0;
        while (top[a] ^ top[b])
        {
            if (dep[top[a]] < dep[top[b]])
                swap(a, b);
            int st = top[a];
            ret = max(ret, seg.qry(in[st], in[a]));
            a = par[st];
        }
        if (dep[a] > dep[b])
            swap(a, b);
        ret = max(ret, seg.qry(in[a] + 1, in[b]));
        return ret;
    }
};

class HLD2
{
public:
    int sz[MAXSIZE] = {0}, dep[MAXSIZE] = {0}, par[MAXSIZE] = {0}, top[MAXSIZE] = {0}, in[MAXSIZE] = {0}, out[MAXSIZE] = {0};
    vector<int> g[MAXSIZE];
    vector<int> inp[MAXSIZE];

    MinSeg seg;
    int chk[MAXSIZE] = {0};
    void dfs(int v = 1)
    {
        chk[v] = 1;
        for (auto i : inp[v])
        {
            if (chk[i])
                continue;
            chk[i] = 1;
            g[v].push_back(i);
            dfs(i);
        }
    }
    void dfs1(int v = 1)
    {
        sz[v] = 1;
        for (auto &i : g[v])
        {
            dep[i] = dep[v] + 1;
            par[i] = v;
            dfs1(i);
            sz[v] += sz[i];
            if (sz[i] > sz[g[v][0]])
                swap(i, g[v][0]);
        }
    }
    int pv;
    void dfs2(int v = 1)
    {
        in[v] = ++pv;
        for (auto i : g[v])
        {
            top[i] = i == g[v][0] ? top[v] : i;
            dfs2(i);
        }
        out[v] = pv;
    }

    void update(int a, int b, int w)
    {
        while (top[a] ^ top[b])
        {
            if (dep[top[a]] < dep[top[b]])
                swap(a, b);
            int st = top[a];
            seg.upd(in[st], in[a], w);
            a = par[st];
        }
        if (dep[a] > dep[b])
            swap(a, b);

        seg.upd(in[a], in[b], w);
    }
    ll query(int a, int b)
    {
        ll ret = INF;
        while (top[a] ^ top[b])
        {
            if (dep[top[a]] < dep[top[b]])
                swap(a, b);
            int st = top[a];
            ret = min(ret, seg.qry(in[st], in[a]));
            a = par[st];
        }
        if (dep[a] > dep[b])
            swap(a, b);
        ret = min(ret, seg.qry(in[a], in[b]));
        return ret;
    }
};

int n, m;
int arr[101010];
vector<array<int, 3>> edg;
HLD1 hld1;
HLD2 hld2;

int us[101010];
int prt[101001];

int find(int x)
{
    if (prt[x] == 0 || prt[x] == x)
        return prt[x] = x;
    return prt[x] = find(prt[x]);
}

void mrg(int a, int b)
{
    prt[find(a)] = find(b);
}

int main()
{
    fastio;
    cin >> n >> m;
    for (int i = 0; i < n; i++)
    {
        cin >> arr[i + 1];
    }
    for (int i = 0; i < m; i++)
    {
        int a, b;
        cin >> a >> b;
        edg.push_back({abs(arr[a] - arr[b]), a, b});
    }

    sort(edg.begin(), edg.end());
    hld2.seg.rst(n + 5); // ans
    hld1.seg.rst(n + 5); //

    for (int i = 0; i < m; i++)
    {
        int d = edg[i][0], a = edg[i][1], b = edg[i][2];
        if (find(a) == find(b))
            continue;

        mrg(a, b);

        us[i] = 1;
        hld1.inp[a].push_back(b);
        hld1.inp[b].push_back(a);

        hld2.inp[a].push_back(b);
        hld2.inp[b].push_back(a);
    }
    hld1.dfs();
    hld1.dfs1();
    hld1.dfs2();

    hld2.dfs();
    hld2.dfs1();
    hld2.dfs2();
    for (int i = 0; i < m; i++)
    {
        if (us[i])
        {
            int d = edg[i][0], a = edg[i][1], b = edg[i][2];
            hld1.update(a, b, d);
        }
    }

    for (int i = 0; i < m; i++)
    {
        if (!us[i])
        {
            int d = edg[i][0], a = edg[i][1], b = edg[i][2];
            int mx = hld1.query(a, b);
            hld2.update(a, b, max(d, mx));
        }
    }
    vector<int> ans;
    for (int i = 1; i <= n; i++)
    {
        int t = hld2.query(i, i);
        if (t >= INF)
            ans.push_back(-1);
        else
            ans.push_back(t);
    }
    for (int i : ans)
    {
        cout << i << " ";
    }

    return 0;
}

源文件, 语言: C++17

详细

Test #1:

score: 100

Accepted

time: 0ms

memory: 18656kb

input:

8 11
5 2 7 0 10 6 6 6
1 2
1 3
2 3
2 4
2 5
2 7
3 5
1 6
6 7
6 8
7 8

output:

4 4 5 -1 8 0 0 0

result:

ok single line: '4 4 5 -1 8 0 0 0 '

Test #2:

score: 0

Accepted

time: 0ms

memory: 18532kb

input:

4 5
10 20 30 40
1 2
1 3
1 4
2 3
3 4

output:

20 20 20 30

result:

ok single line: '20 20 20 30 '

Test #3:

score: 0

Accepted

time: 4ms

memory: 18496kb

input:

5 4
72 35 22 49 108
1 2
2 3
3 4
4 5

output:

-1 -1 -1 -1 -1

result:

ok single line: '-1 -1 -1 -1 -1 '

Test #4:

score: 0

Accepted

time: 0ms

memory: 18728kb

input:

2 1
10 20
1 2

output:

-1 -1

result:

ok single line: '-1 -1 '

Test #5:

score: 0

Accepted

time: 14ms

memory: 18836kb

input:

252 31626
825 5234 3578 4723 2145 4362 1861 2413 7203 1939 3210 7153 2155 4559 4403 1466 887 3786 6529 719 4272 3287 5703 6708 2390 4987 4214 770 3487 6230 3498 6255 4963 1093 3065 2961 1663 4857 3224 4284 4228 106 1614 1010 145 1557 4510 1032 4632 155 5570 154 884 1204 2876 6163 5023 4593 7261 3729...

output:

55 33 46 34 10 33 34 30 22 33 33 46 10 34 26 100 14 62 17 9 13 35 81 45 23 29 23 20 11 32 11 32 29 38 18 13 14 0 28 13 11 42 35 22 9 57 22 22 35 7 52 7 14 45 72 92 14 8 15 62 10 20 21 34 66 9 20 24 29 6 30 16 26 9 6 27 8 40 85 17 12 26 29 17 10 61 35 9 39 15 14 14 31 22 63 66 110 24 16 7 30 22 15 18...

result:

ok single line: '55 33 46 34 10 33 34 30 22 33 ...5 15 71 10 52 18 16 30 10 34 4 '

Test #6:

score: 0

Accepted

time: 0ms

memory: 18744kb

input:

30 435
268435456 1024 67108864 16777216 134217728 131072 524288 512 256 8 32 64 33554432 2097152 128 2048 16384 8192 4096 8388608 65536 536870912 4 2 16 1048576 32768 1 262144 4194304
24 28
23 28
10 28
25 28
11 28
12 28
15 28
9 28
8 28
2 28
16 28
19 28
18 28
17 28
27 28
21 28
6 28
28 29
7 28
26 28
1...

output:

201326592 768 50331648 12582912 100663296 98304 393216 384 192 6 24 48 25165824 1572864 96 1536 12288 6144 3072 6291456 49152 402653184 3 3 12 786432 24576 3 196608 3145728

result:

ok single line: '201326592 768 50331648 1258291... 786432 24576 3 196608 3145728 '

Test #7:

score: 0

Accepted

time: 53ms

memory: 19676kb

input:

430 92235
268435456 64 536870912 256 128 134217728 2 64 33554432 524288 1048576 268435456 1048576 512 32 32 8192 8192 8192 268435456 256 1024 16384 8 2097152 1 4 65536 268435456 32768 2048 512 128 32768 268435456 8192 4194304 16384 1024 4194304 128 33554432 67108864 1 512 16 128 16384 536870912 4 16...

output:

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...

result:

ok single line: '0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ... 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 '

Test #8:

score: -100

Wrong Answer

time: 243ms

memory: 21600kb

input:

4815 185773
999998072 999997632 999995973 999998063 999999530 999999125 999999430 999998145 999999596 999997846 999999214 999998642 999997013 999995796 999999311 999996273 999996607 999996332 999995768 999996225 999996086 999996362 999997090 999997081 999998960 999996645 999996842 999998514 99999527...

output:

1662 1649 1661 1661 1661 1660 1661 1662 1661 1662 1661 1662 1662 1658 1660 1661 1661 1661 1661 1661 1660 1657 1661 1662 1661 1661 1662 1659 1661 1627 1661 1662 1661 1661 1661 1661 1661 1660 1661 1662 1661 1661 1657 1661 1661 1661 1660 1662 1661 1661 1659 1661 1661 1661 1661 1661 1661 1658 1661 1661 ...

result:

wrong answer 1st lines differ - expected: '66 57 91 47 76 25 193 80 42 12... 173 79 85 50 80 71 47 22 56 49', found: '1662 1649 1661 1661 1661 1660 ... 1661 1659 1658 1658 1661 1661 '