Submission #928550

#	Submission time	Handle	Problem	Language	Result	Execution time	Memory
928550	2024-02-16T16:06:23 Z	boris_mihov	Salesman (IOI09_salesman)	C++17	Compilation error	0 ms	0 KB

salesman

#include <algorithm>
#include <iostream>
#include <numeric>
#include <cassert>
#include <vector>
#include <queue>
#include <set>

typedef long long llong;
const int MAXN = 500000 + 10;
const llong INF = 4e18;

int n;
llong d, u;
struct Event
{
    int pos;
    int time;
    llong cost;

    friend bool operator < (const Event &a, const Event &b)
    {
        return a.time < b.time;
    }
};

struct SegmentTree
{
    llong tree[4*MAXN];
    void build(int l, int r, int node)
    {
        if (l == r)
        {
            tree[node] = -INF;
            return;
        }   

        int mid = (l + r) / 2;
        build(l, mid, 2*node);
        build(mid + 1, r, 2*node + 1);
        tree[node] = std::max(tree[2*node], tree[2*node + 1]);
    }

    void update(int l, int r, int node, int queryPos, int queryVal)
    {
        if (l == r)
        {
            tree[node] = std::max(tree[node], queryVal);
            return;
        }

        int mid = (l + r) / 2;
        if (queryPos <= mid) update(l, mid, 2*node, queryPos, queryVal);
        else update(mid + 1, r, 2*node + 1, queryPos, queryVal);
        tree[node] = std::max(tree[2*node], tree[2*node + 1]);
    }

    llong query(int l, int r, int node, int queryL, int queryR)
    {
        if (queryL <= l && r <= queryR)
        {
            return tree[node];
        }

        int res = -INF;
        int mid = (l + r) / 2;
        if (queryL <= mid) res = query(l, mid, 2*node, queryL, queryR);
        if (mid + 1 <= queryR) res = std::max(res, query(mid + 1, r, 2*node + 1, queryL, queryR));
        return res;
    }

    void build()
    {
        build(1, MAXN - 1, 1);
    }

    void update(int pos, int val)
    {
        update(1, MAXN - 1, 1, pos, val);
    }

    int query(int l, int r)
    {
        return query(1, MAXN - 1, 1, l, r);
    }
};

SegmentTree treeU;
SegmentTree treeD;
Event event[MAXN];
llong dp[MAXN];

void solve()
{
    treeU.build();
    treeD.build();
    std::sort(event + 1, event + 1 + n);
    for (int i = n ; i >= 0 ; --i)
    {
        if (event[i].pos <= event[0].pos) dp[i] = -(event[0].pos - event[i].pos) * d;
        else dp[i] = -(event[i].pos - event[0].pos) * u;

        dp[i] = std::max(dp[i], treeU.query(1, event[i].pos) - event[i].pos * u);
        dp[i] = std::max(dp[i], treeD.query(event[i].pos, MAXN - 1) + event[i].pos * d);
        treeU.update(event[i].pos, dp[i] + event[i].cost + event[i].pos * u);
        treeD.update(event[i].pos, dp[i] + event[i].cost - event[i].pos * d);
    }

    std::cout << dp[0] << '\n';
}

void input()
{
    std::cin >> n >> u >> d >> event[0].pos;
    for (int i = 1 ; i <= n ; ++i)
    {
        std::cin >> event[i].time >> event[i].pos >> event[i].cost;
    }
}

void fastIOI()
{
    std::ios_base :: sync_with_stdio(0);
    std::cout.tie(nullptr);
    std::cin.tie(nullptr);
}

int main()
{
    fastIOI();
    input();
    solve();

    return 0;
}

Compilation message

salesman.cpp: In member function 'void SegmentTree::update(int, int, int, int, int)':
salesman.cpp:48:55: error: no matching function for call to 'max(llong&, int&)'
   48 |             tree[node] = std::max(tree[node], queryVal);
      |                                                       ^
In file included from /usr/include/c++/10/algorithm:61,
                 from salesman.cpp:1:
/usr/include/c++/10/bits/stl_algobase.h:254:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  254 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/10/bits/stl_algobase.h:254:5: note:   template argument deduction/substitution failed:
salesman.cpp:48:55: note:   deduced conflicting types for parameter 'const _Tp' ('long long int' and 'int')
   48 |             tree[node] = std::max(tree[node], queryVal);
      |                                                       ^
In file included from /usr/include/c++/10/algorithm:61,
                 from salesman.cpp:1:
/usr/include/c++/10/bits/stl_algobase.h:300:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  300 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/10/bits/stl_algobase.h:300:5: note:   template argument deduction/substitution failed:
salesman.cpp:48:55: note:   deduced conflicting types for parameter 'const _Tp' ('long long int' and 'int')
   48 |             tree[node] = std::max(tree[node], queryVal);
      |                                                       ^
In file included from /usr/include/c++/10/algorithm:62,
                 from salesman.cpp:1:
/usr/include/c++/10/bits/stl_algo.h:3480:5: note: candidate: 'template<class _Tp> constexpr _Tp std::max(std::initializer_list<_Tp>)'
 3480 |     max(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/10/bits/stl_algo.h:3480:5: note:   template argument deduction/substitution failed:
salesman.cpp:48:55: note:   mismatched types 'std::initializer_list<_Tp>' and 'long long int'
   48 |             tree[node] = std::max(tree[node], queryVal);
      |                                                       ^
In file included from /usr/include/c++/10/algorithm:62,
                 from salesman.cpp:1:
/usr/include/c++/10/bits/stl_algo.h:3486:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::max(std::initializer_list<_Tp>, _Compare)'
 3486 |     max(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/10/bits/stl_algo.h:3486:5: note:   template argument deduction/substitution failed:
salesman.cpp:48:55: note:   mismatched types 'std::initializer_list<_Tp>' and 'long long int'
   48 |             tree[node] = std::max(tree[node], queryVal);
      |                                                       ^
salesman.cpp: In member function 'llong SegmentTree::query(int, int, int, int, int)':
salesman.cpp:65:19: warning: overflow in conversion from 'long long int' to 'int' changes value from '-4000000000000000000' to '1651507200' [-Woverflow]
   65 |         int res = -INF;
      |                   ^~~~
salesman.cpp:68:97: error: no matching function for call to 'max(int&, llong)'
   68 |         if (mid + 1 <= queryR) res = std::max(res, query(mid + 1, r, 2*node + 1, queryL, queryR));
      |                                                                                                 ^
In file included from /usr/include/c++/10/algorithm:61,
                 from salesman.cpp:1:
/usr/include/c++/10/bits/stl_algobase.h:254:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  254 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/10/bits/stl_algobase.h:254:5: note:   template argument deduction/substitution failed:
salesman.cpp:68:97: note:   deduced conflicting types for parameter 'const _Tp' ('int' and 'llong' {aka 'long long int'})
   68 |         if (mid + 1 <= queryR) res = std::max(res, query(mid + 1, r, 2*node + 1, queryL, queryR));
      |                                                                                                 ^
In file included from /usr/include/c++/10/algorithm:61,
                 from salesman.cpp:1:
/usr/include/c++/10/bits/stl_algobase.h:300:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  300 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/10/bits/stl_algobase.h:300:5: note:   template argument deduction/substitution failed:
salesman.cpp:68:97: note:   deduced conflicting types for parameter 'const _Tp' ('int' and 'llong' {aka 'long long int'})
   68 |         if (mid + 1 <= queryR) res = std::max(res, query(mid + 1, r, 2*node + 1, queryL, queryR));
      |                                                                                                 ^
In file included from /usr/include/c++/10/algorithm:62,
                 from salesman.cpp:1:
/usr/include/c++/10/bits/stl_algo.h:3480:5: note: candidate: 'template<class _Tp> constexpr _Tp std::max(std::initializer_list<_Tp>)'
 3480 |     max(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/10/bits/stl_algo.h:3480:5: note:   template argument deduction/substitution failed:
salesman.cpp:68:97: note:   mismatched types 'std::initializer_list<_Tp>' and 'int'
   68 |         if (mid + 1 <= queryR) res = std::max(res, query(mid + 1, r, 2*node + 1, queryL, queryR));
      |                                                                                                 ^
In file included from /usr/include/c++/10/algorithm:62,
                 from salesman.cpp:1:
/usr/include/c++/10/bits/stl_algo.h:3486:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::max(std::initializer_list<_Tp>, _Compare)'
 3486 |     max(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/10/bits/stl_algo.h:3486:5: note:   template argument deduction/substitution failed:
salesman.cpp:68:97: note:   mismatched types 'std::initializer_list<_Tp>' and 'int'
   68 |         if (mid + 1 <= queryR) res = std::max(res, query(mid + 1, r, 2*node + 1, queryL, queryR));
      |                                                                                                 ^