/**
* Solution to IOI 2009 problem "salesman"
*
* We use a C++ set to store the list of currently "active" fairs,
* where an active fair is one that has a better profit than by
* visiting the fair than reaching the same location from some
* other fair. We then process the fairs in order of the time at
* which they occur, using our active set to find the best fair
* to come from in order to visit each new successive fair, and
* updating the active set with the new fair afterwards.
*
* For fairs on the same day, we note that the most efficient
* way of visiting these is to pick one as a starting point and
* then visit fairs in a single direction. We test both the
* upstream and downstream directions, and for each fair decide
* whether it is better to go directly to this fair or to come
* from the previous fair opposite to the direction in which
* we are travelling.
*
* Carl Hultquist, chultquist@gmail.com
*/
#include <iostream>
#include <cassert>
#include <set>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <vector>
using namespace std;
#define MAX_N 500000
#define MAX_D_U 10
#define MAX_S 500001
#define MAX_T 500000
#define MAX_L 500001
#define MAX_M 4000
int n, d, u, s;
// Class for storing all the things we want to associate with a fair
typedef struct fair
{
int t, l, m;
int best;
// Used for traversing upstream and downstream when fairs occur
// on the same day.
int baseBest;
int curBest;
// Order fairs first according to time, and secondly according
// to their location (which makes the upstream and downstream
// traversals much easier).
bool operator <(const fair &f) const
{
if (t < f.t)
return true;
else if (t == f.t && l < f.l)
return true;
else
return false;
}
} fair;
// For our set, we want to order fairs by location only, so have
// a special comparator for this.
struct location_less
{
bool operator ()(const fair &x, const fair &y)
{
return x.l < y.l;
}
};
vector<fair> fairs;
set<fair, location_less> activeFairs;
/**
* Computes the cost of travelling between two points on the river.
*/
double travelCost(double from, double to)
{
if (from < to)
return (to - from) * d;
else
return (from - to) * u;
}
/**
* Queries for the best profit that we can expect to earn when
* visiting fair i directly from some fair that occurred on a
* previous day.
*
* We find the active fairs that occur to the left and right of
* this one along the river -- it is fairly easy to show that our
* optimal predecessor must be one of these fairs. Then we pick
* the one which gives us a greater profit.
*/
int query(int i)
{
set<fair, location_less>::iterator low = activeFairs.lower_bound(fairs[i]);
set<fair, location_less>::iterator high = low;
if (low != activeFairs.begin())
low--;
if (high == activeFairs.end())
high--;
return max(low->best - travelCost(low->l, fairs[i].l),
high->best - travelCost(high->l, fairs[i].l)) + fairs[i].m;
}
/**
* Updates our active fairs set with the given fair. Care must be
* taken to ensure that this fair is actually active (if all fairs
* are on distinct days then it will be, but if there are several on
* the same day then there may be a better path to this location on
* the river via some other fair).
*/
void update(int i)
{
// Insert by default, we will remove it later if we need to.
activeFairs.insert(fairs[i]);
set<fair, location_less>::iterator thisFair = activeFairs.lower_bound(fairs[i]);
set<fair, location_less>::iterator cur = thisFair;
// Check upstream fairs
while (cur != activeFairs.begin())
{
cur--;
// Check if the fair we have just added is covered by the
// previous fair in the set.
if (cur->best - travelCost(cur->l, thisFair->l) >= thisFair->best)
{
// Yes, so remove and return
activeFairs.erase(thisFair);
return;
}
// Check if the fair we have just added covers the previous
// fair in the set.
if (thisFair->best - travelCost(thisFair->l, cur->l) < cur->best)
// No, so stop removing non-active fairs
break;
// Remove the fair that is covered by our recently added one,
// and which is thus no longer active.
activeFairs.erase(cur);
cur = thisFair;
}
// Check downstream fairs
cur = thisFair;
cur++;
while (cur != activeFairs.end())
{
// Check if the fair we have just added is covered by the
// next fair in the set.
if (cur->best - travelCost(cur->l, thisFair->l) >= thisFair->best)
{
// Yes, so remove and return
activeFairs.erase(thisFair);
return;
}
// Check if the fair we have just added covers the next
// fair in the set.
if (thisFair->best - travelCost(thisFair->l, cur->l) < cur->best)
break;
// Remove the fair that is covered by our recently added one,
// and which is thus no longer active.
activeFairs.erase(cur);
cur = thisFair;
cur++;
}
}
int main()
{
scanf("%d %d %d %d", &n, &u, &d, &s);
assert(1 <= n && n <= MAX_N);
assert(1 <= d && d <= MAX_D_U);
assert(1 <= u && u <= MAX_D_U);
assert(1 <= s && s <= MAX_S);
fairs.resize(n + 2);
int maxT = 0;
for (int i = 1; i <= n; i++)
{
scanf("%d %d %d", &fairs[i].t, &fairs[i].l, &fairs[i].m);
assert(1 <= fairs[i].t && fairs[i].t <= MAX_T);
assert(1 <= fairs[i].l && fairs[i].l <= MAX_L);
assert(1 <= fairs[i].m && fairs[i].m <= MAX_M);
maxT = max(maxT, fairs[i].t);
}
// Create a dummy fairs for the salesman's home at the beginning,
// and also one at the end
fairs[0].l = s;
fairs[0].best = 0;
fairs[0].t = -1;
fairs[n + 1].l = s;
fairs[n + 1].m = 0;
fairs[n + 1].t = maxT + 1;
sort(fairs.begin(), fairs.end());
// At the beginning, only fair 0 (the salesman's home) is active
activeFairs.insert(fairs[0]);
for (int i = 1; i <= n; i++)
{
// Check to see if we have multiple fairs on the same day
if (i == n || fairs[i].t != fairs[i + 1].t)
{
// No, so just do the simple approach of querying for
// the best fair to come from in order to reach this
// one, and update our data structure.
fairs[i].best = query(i);
update(i);
}
else
{
// Yes, there are multiple fairs happening on this day. We need
// to choose the best way of picking which of these fairs to
// visit.
int first = i;
while (i <= n && fairs[i].t == fairs[first].t)
i++;
i--;
int last = i;
// First, find the cheapest way of reaching each fair on this
// day if we visit no other fairs on the same day.
for (int j = first; j <= last; j++)
{
fairs[j].baseBest = query(j);
fairs[j].best = fairs[j].baseBest;
}
// Now visit each of the fairs in both an upstream and
// downstream direction, in each case seeing if it was
// better to come via the previous fair.
fairs[first].curBest = fairs[first].baseBest;
for (int j = first + 1; j <= last; j++)
{
// See if it is better to come from the previous
// fair.
int profit = fairs[j - 1].curBest - travelCost(fairs[j - 1].l, fairs[j].l) + fairs[j].m;
if (profit > fairs[j].baseBest)
fairs[j].curBest = profit;
else
fairs[j].curBest = fairs[j].baseBest;
if (fairs[j].curBest > fairs[j].best)
fairs[j].best = fairs[j].curBest;
}
// And upstream. Don't forget to start off with the base
// value of visiting this fair directly (otherwise we will
// use values fro the downstream pass, which will be
// confusing).
fairs[last].curBest = fairs[last].baseBest;
for (int j = last - 1; j >= first; j--)
{
// See if it is better to come from the previous
// fair.
int profit = fairs[j + 1].curBest - travelCost(fairs[j + 1].l, fairs[j].l) + fairs[j].m;
if (profit > fairs[j].baseBest)
fairs[j].curBest = profit;
else
fairs[j].curBest = fairs[j].baseBest;
if (fairs[j].curBest > fairs[j].best)
fairs[j].best = fairs[j].curBest;
}
// Update our query structure for all of these fairs, and
// see if there is a better way home from any of them.
for (int j = first; j <= last; j++)
update(j);
}
}
int best = query(n + 1);
// Check that our profit is positive; if not then output 0
// (indicating that the salesman simply stays at home for the
// year).
cout << (best < 0 ? 0 : best) << endl;
return 0;
}
