Cleaning Shifts

Farmer John‘s cows, pampered since birth, have reached new heights of fastidiousness. They now require their barn to be immaculate. Farmer John, the most obliging of farmers, has no choice but hire some of the cows to clean the barn.

Farmer John has N (1 <= N <= 10,000) cows who are willing to do some cleaning. Because dust falls continuously, the cows require that the farm be continuously cleaned during the workday, which runs from second number M to second number E during the day (0 <= M <= E <= 86,399). Note that the total number of seconds during which cleaning is to take place is E-M+1. During any given second M..E, at least one cow must be cleaning.

Each cow has submitted a job application indicating her willingness to work during a certain interval T1..T2 (where M <= T1 <= T2 <= E) for a certain salary of S (where 0 <= S <= 500,000). Note that a cow who indicated the interval 10..20 would work for 11 seconds, not 10. Farmer John must either accept or reject each individual application; he may NOT ask a cow to work only a fraction of the time it indicated and receive a corresponding fraction of the salary.

Find a schedule in which every second of the workday is covered by at least one cow and which minimizes the total salary that goes to the cows.

Line 1: Three space-separated integers: N, M, and E.

Lines 2..N+1: Line i+1 describes cow i‘s schedule with three space-separated integers: T1, T2, and S.

Line 1: a single integer that is either the minimum total salary to get the barn cleaned or else -1 if it is impossible to clean the barn.

3 0 4
0 2 3
3 4 2
0 0 1

5

Explanation of the sample:

FJ has three cows, and the barn needs to be cleaned from second 0 to second 4. The first cow is willing to work during seconds 0, 1, and 2 for a total salary of 3, etc.

Farmer John can hire the first two cows.

USACO 2005 December Silver

搞了好久啊，不知道哪里搞错了一直WA，后来干脆推翻重来
首先每一条线段的最优值都可以集中在最右端，所以我们可以只考虑右端的取值

dp[seg[i].r] = min(dp[x] + seg[i].c)

#include <map>
#include <set>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010;
const long long inf = 0x7fffffff;

struct node
{
	int l, r;
	long long val;
}tree[N << 2], seg[N];
long long dp[N];

int cmp(node a, node b)
{
	return a.r < b.r;
}

void build(int p, int l, int r)
{
	tree[p].l = l;
	tree[p].r = r;
	tree[p].val = inf;
	if (l == r)
	{
		return;
	}
	int mid = (l + r) >> 1;
	build(p << 1, l, mid);
	build(p << 1 | 1, mid + 1, r);
}

void update(int p, int pos, long long val)
{
	if (tree[p].l == tree[p].r)
	{
		tree[p].val = min(tree[p].val, val);
		return;
	}
	int mid = (tree[p].l + tree[p].r) >> 1;
	if (pos <= mid)
	{
		update(p << 1, pos, val);
	}
	else
	{
		update(p << 1 | 1, pos, val);
	}
	tree[p].val = min(tree[p << 1].val, tree[p << 1 | 1].val);
}

long long query(int p, int l, int r)
{
	if (l <= tree[p].l && tree[p].r <= r)
	{
		return tree[p].val;
	}
	int mid = (tree[p].l + tree[p].r) >> 1;
	if (r <= mid)
	{
		return query(p << 1, l, r);
	}
	else if (l > mid)
	{
		return query(p << 1 | 1, l, r);
	}
	else
	{
		return min(query(p << 1, l, mid), query(p << 1 | 1, mid + 1, r));
	}
}

int main()
{
	int l, r, n;
	while (~scanf("%d%d%d", &n, &l, &r))
	{
		for (int i = 0; i < n; ++i)
		{
			scanf("%d%d%lld", &seg[i].l, &seg[i].r, &seg[i].val);
		}
		sort (seg, seg + n, cmp);
		build(1, 1, r + 1);
		for (int i = 0; i <= 90000; ++i)
		{
			dp[i] = inf;
		}
		for (int i = 0; i < n; ++i)
		{
			if (seg[i].r < l)
			{
				continue;
			}
			if (seg[i].l <= l)
			{
				dp[seg[i].r] = min(dp[seg[i].r], seg[i].val);
			}
			else 
			{
				dp[seg[i].r] = min(dp[seg[i].r], query(1, seg[i].l, seg[i].r) + seg[i].val);
			}
			update(1, seg[i].r + 1, dp[seg[i].r]);
		}
		long long ans = inf;
		for (int i = r; i <= seg[n - 1].r; ++i)
		{
			ans = min(ans, dp[i]);
		}
		if (ans >= inf)
		{
			printf("-1\n");
		}
		else
		{
			printf("%lld\n", ans);
		}
	}
	return 0;
}