codeforces 141D Take-off Ramps

题意：

有一条起点为0，长度为L的跑道，有n个跳板，对于第i个跳板，在xi处开始起跳，但是必须在xi-pi ~ xi进行缓冲时间为pi，然后在ti的时间到达xi+di处，人可以往回走，但是跳板的方向是固定的，然后求出到达L的最短时间，并且按照起跳顺序的先后输出用了的跳板的编号。

题解：

首先需要明白的是，给出的xi这个点是无用的，那么有用的点只有xi - pi 和 xi + di。

并且转移情况复杂，包括往回走的情况，包括选跳板的情况，不选跳板的情况，走路的情况，当时一时想不出好的解决方法，但是最后发现这不是最短路么？

考虑选择跳板的情况，将跳板的左右端点连一条单向边，权值为pi + ti

考虑不选跳板的情况，将一个点与其他所有点连一条双向边，权值为距离之差，但是发现有很多边都是无用，所以只需要将左右相邻的点相连就好了。

P.S. 数据太大需要离散QAQ，还有SPFA要被卡，会T在第50组，SXBK!

代码：

#include <bits/stdc++.h>
using namespace std;

#define ll long long
const ll inf = 1e15 + 7;
const int N = 1e6 + 7;
struct edge {int u, v, nxt, w, id;}e[N<<2];
struct node {int s, t, w;} rd[N];

int inq[N], disc[N<<1], dis[N], dcnt, head[N], ecnt, n, L, ans[N], cnt, pre[N];

typedef pair <int, int> pii;
#define MK(a,b) make_pair(a, b)

priority_queue <pii, vector <pii>, greater<pii> > q;

void adde (int u, int v, int w, int id) {
	e[ecnt].u = u;
	e[ecnt].v = v;
	e[ecnt].w = w;
	e[ecnt].id = id;
	e[ecnt].nxt = head[u];
	head[u] = ecnt++;
}

void Dijkstra () {
	memset (dis, 127, sizeof dis);
	pre[1] = -1;
	dis[1] = 0;
	q.push(MK(0, 1));
	while (!q.empty()) {
		int u = q.top().second;
		q.pop(); inq[u] = 0;
		for (int it = head[u]; it != -1; it = e[it].nxt) {
			int v = e[it].v;
			if (dis[v] > dis[u] + e[it].w) {
				dis[v] = dis[u] + e[it].w;
				pre[v] = it;
				q.push(MK(dis[v], v));
			}
		}
	}
	for (int it = pre[dcnt]; it != -1; it = pre[e[it].u])
		if (e[it].id != -1) ans[++cnt] = e[it].id;
}

int main () {
	scanf ("%d%d", &n, &L);
	memset (head, -1, sizeof head);
	disc[++dcnt] = 0;
	disc[++dcnt] = L;
	for (int i = 1; i <= n ; ++i) {
		int x, d, t, p;
		scanf ("%d%d%d%d", &x, &d, &t, &p);
		rd[i].s = x - p;
		rd[i].t = x + d;
		rd[i].w = t + p;
		if (x - p < 0 || x + d > L) continue;
		disc[++dcnt] = x - p;
		disc[++dcnt] = x + d;
	}
	sort (disc + 1, disc + 1 + dcnt);
	dcnt = unique (disc + 1, disc + 1 + dcnt) - disc - 1;
	for (int i = 1; i <= n; ++i) {
		if (rd[i].t > L || rd[i].s < 0) continue;
		int s = lower_bound (disc + 1, disc + 1 + dcnt, rd[i].s) - disc;
		int t = lower_bound (disc + 1, disc + 1 + dcnt, rd[i].t) - disc;
		adde (s, t, rd[i].w, i);
	}
	for (int i = 2; i <= dcnt; ++i) {
		int s = i - 1, t = i, w = disc[t] - disc[s];
		adde (s, t, w, -1);
		adde (t, s, w, -1);
	}
	Dijkstra();
	cout << dis[dcnt] << endl << cnt << endl;
	for (int i = cnt; i >= 1; --i) printf ("%d ", ans[i]);
	return 0;
}

总结：

复杂的转移关系，简单的限制条件，就可以考虑图论QAQ