1975: [Sdoi2010]魔法猪学院

1975: [Sdoi2010]魔法猪学院

Time Limit: 10 Sec   Memory Limit: 64 MB
Submit: 1855   Solved: 567
[ Submit][ Status][ Discuss]

Description

iPig在假期来到了传说中的魔法猪学院，开始为期两个月的魔法猪训练。经过了一周理论知识和一周基本魔法的学习之后，iPig对猪世界的世界本原有了很多的了解：众所周知，世界是由元素构成的；元素与元素之间可以互相转换；能量守恒……。 能量守恒……iPig 今天就在进行一个麻烦的测验。iPig 在之前的学习中已经知道了很多种元素，并学会了可以转化这些元素的魔法，每种魔法需要消耗 iPig 一定的能量。作为 PKU 的顶尖学猪，让 iPig 用最少的能量完成从一种元素转换到另一种元素……等等，iPig 的魔法导猪可没这么笨！这一次，他给 iPig 带来了很多 1 号元素的样本，要求 iPig 使用学习过的魔法将它们一个个转化为 N 号元素，为了增加难度，要求每份样本的转换过程都不相同。这个看似困难的任务实际上对 iPig 并没有挑战性，因为，他有坚实的后盾……现在的你呀！ 注意，两个元素之间的转化可能有多种魔法，转化是单向的。转化的过程中，可以转化到一个元素（包括开始元素）多次，但是一但转化到目标元素，则一份样本的转化过程结束。iPig 的总能量是有限的，所以最多能够转换的样本数一定是一个有限数。具体请参看样例。

Input

第一行三个数 N、M、E 表示iPig知道的元素个数（元素从 1 到 N 编号）、iPig已经学会的魔法个数和iPig的总能量。 后跟 M 行每行三个数 si、ti、ei 表示 iPig 知道一种魔法，消耗 ei 的能量将元素 si 变换到元素 ti 。

Output

一行一个数，表示最多可以完成的方式数。输入数据保证至少可以完成一种方式。

Sample Input

4 6 14.9
1 2 1.5
2 1 1.5
1 3 3
2 3 1.5
3 4 1.5
1 4 1.5

Sample Output

3

HINT

样例解释
有意义的转换方式共4种：
1->4，消耗能量 1.5
1->2->1->4，消耗能量 4.5
1->3->4，消耗能量 4.5
1->2->3->4，消耗能量 4.5
显然最多只能完成其中的3种转换方式（选第一种方式，后三种方式仍选两个），即最多可以转换3份样本。
如果将 E=14.9 改为 E=15，则可以完成以上全部方式，答案变为 4。

数据规模
占总分不小于 10% 的数据满足 N <= 6，M<=15。
占总分不小于 20% 的数据满足 N <= 100，M<=300，E<=100且E和所有的ei均为整数（可以直接作为整型数字读入）。
所有数据满足 2 <= N <= 5000，1 <= M <= 200000，1<=E<=107，1<=ei<=E，E和所有的ei为实数。

Source

Sdoi2010 Contest2 Day2

[ Submit][ Status][ Discuss]
一个很直接的想法，，每次选取当前最短路计入答案，下次选取次短路...不断做下去，把能量用完就行 那么问题在于，如何求解当前最短路？？ 有朴素的A*算法，，不过时间和空间效率太低难以接受，参考论文 论文介绍了用可持久化堆的做法。。原文已经很详细了 不过自己理解的时候花了不少时间，，嗯，，就自己说一些自己的见解吧 将原图中的边反向，然后构建出最短路树，， 以节点n为根，那么树上从n到某一点的路径就能对应原图中从n到该节点的某条最短路 除了树边，原图还会有一些其它的边，当采用它们，就能得到一些较劣的路径 假设一开始从节点1，最短路是从1到n的树上路径，把它加入答案 接下来，从1开始，可以选择找一条原图中从1连出去，但不是树边的边，或是先从1走树边走几步，再找这样的边 无论怎么找，，我们的目的是找一条附加代价最小的边，这样才能构成次短路 很显然能用堆维护 但是说了，一个节点可以的选择，除了它自己本身连出去的边，还有先往父亲走，再从父亲出发的边 也就是说，一个节点的各个祖宗的所有选择，对于该节点都是可行的 难道要把每一种选择都扔进堆里吗？？？所以，，用一个可持久化的堆 为了搞这个东西，，特意学了下左偏树--(原来都用C++自带的priority_queue) 联系到线段树的可持久化，，也叫主席树 它是通过新建一个与父辈信息相同成分很多的节点代替插入父辈的信息，那么这里也一样 对于i节点的边集的堆，要把父亲的堆整个扔进去？ 新建一个和父亲的堆的节点信息相同的点，合并这两个堆，，总之，通过建立新节点实现可持久化


最后求解的时候，，，每次拿出当前最短路，要更新以后的信息，只要做两件事 首先，，把当前节点的左右儿子扔进去(代替删除来弹出堆顶) 然后沿着当前选取的非树边走一步，把找到的新点的那个堆扔进去

#include<iostream>
#include<cstdio>
#include<queue>
#include<vector>
#include<bitset>
#include<algorithm>
#include<cstring>
#include<map>
#include<stack>
#include<set>
#include<cmath>
#include<ext/pb_ds/priority_queue.hpp>
using namespace std;

const int maxn = 5E3 + 50;
const int maxm = 2E5 + 20;
const int T = 10;
typedef double DB;

struct E{
	int to; DB w;
	E(){}
	E(int to,DB w): to(to),w(w){}
}edgs[maxm],e2[maxm];

struct data{
	DB va; int num;
	data(){}
	data(DB va,int num): va(va),num(num){}
	bool operator < (const data &b) const {return va > b.va;}
};

DB k,dis[maxn],s[maxm],key[maxm*T];
int n,m,cnt1,fa[maxn],from[maxn],ch[maxm*T][2]
	,dist[maxm*T],nex[maxm*T],root[maxn],ne[maxm];
bool inq[maxn],intre[maxm];

vector <int> v[maxn];
queue <int> Q;
vector <int> v2[maxn];
vector <int> v3[maxn];
priority_queue <data> Q2;

void SPFA()
{
	memset(dis,127,sizeof(dis));
	dis[n] = 0;
	Q.push(n);
	inq[n] = 1;
	while (!Q.empty()) {
		int t = Q.front(); Q.pop();
		inq[t] = 0;
		for (int i = 0; i < v[t].size(); i++) {
			E e = edgs[v[t][i]];
			if (dis[e.to] > dis[t] + e.w) {
				dis[e.to] = dis[t] + e.w;
				fa[e.to] = t;
				from[e.to] = v[t][i];
				if (!inq[e.to]) {
					inq[e.to] = 1;
					Q.push(e.to);
				}
			}
		}
	}
	for (int i = 1; i < n; i++) {
		v2[fa[i]].push_back(from[i]);
		intre[from[i]] = 1;
	}
}

int New(DB Key,int Nex)
{
	int ret = ++cnt1;
	key[cnt1] = Key;
	nex[cnt1] = Nex;
	return ret;
}

int merge(int p,int q)
{
	if (!p) return q;
	if (!q) return p;
	if (key[p] > key[q]) swap(p,q);
	ch[p][1] = merge(ch[p][1],q);
	if (dist[ch[p][1]] > dist[ch[p][0]])
		swap(ch[p][0],ch[p][1]);
	dist[p] = dist[ch[p][1]] + 1;
	return p; 
}

int Build(int tot)
{
	for (int i = 1; i <= tot; i++) 
		Q.push(New(s[i],ne[i]));
	for (;;) {
		int t1 = Q.front(); Q.pop();
		if (Q.empty()) return t1;
		int t2 = Q.front(); Q.pop();
		Q.push(merge(t1,t2));
	}
}

int val(int x,int y)
{
	ch[x][0] = ch[y][0];
	ch[x][1] = ch[y][1];
	key[x] = key[y];
	nex[x] = nex[y];
	dist[x] = dist[y];
	return x;
}

int Merge(int p,int q)
{
	int ret = ++cnt1;
	if (!p) return val(ret,q);
	if (!q) return val(ret,p);
	if (key[p] > key[q]) swap(p,q);
	val(ret,p);
	ch[ret][1] = Merge(ch[p][1],q);
	if (dist[ch[ret][1]] > dist[ch[ret][0]])
		swap(ch[ret][0],ch[ret][1]);
	dist[ret] = dist[ch[ret][1]] + 1;
	return ret; 
}

void Dfs(int x)
{
	if (x != n) {
		int tot = 0;
		for (int i = 0; i < v3[x].size(); i++) {
			if (intre[v3[x][i]]) continue;
			E e = e2[v3[x][i]];
			s[++tot] = e.w - dis[x] + dis[e.to];
			ne[tot] = e.to;
		}
		if (tot) root[x] = Build(tot);
		if (fa[x] != n && root[fa[x]]) {
			if (tot) root[x] = Merge(root[x],root[fa[x]]);
			else root[x] = val(++cnt1,root[fa[x]]);
		}
	}
	for (int i = 0; i < v2[x].size(); i++) {
		E e = edgs[v2[x][i]];
		Dfs(e.to);
	}
}

int main()
{
	#ifdef DMC
		freopen("DMC.txt","r",stdin);
		freopen("test2.txt","w",stdout);
	#endif
	
	cin >> n >> m >> k;
	dist[0] = -1;
	for (int i = 1; i <= m; i++) {
		int x,y; DB w;
		scanf("%d%d%lf",&x,&y,&w);
		edgs[i] = E(x,w);
		v[y].push_back(i);
		e2[i] = E(y,w);
		v3[x].push_back(i);
	}
	SPFA();
	Dfs(n);
	Q2.push(data(key[root[1]],root[1]));
	int ans = 1;
	k -= dis[1];
	for (int I = 0; ; I++) {
		data t = Q2.top(); Q2.pop();
		k -= (t.va + dis[1]);
		if (k < 0.00) {cout << ans; break;}
		++ans;
		int son = nex[t.num];
		if (root[son])
			Q2.push(data(key[root[son]] + t.va,root[son]));
		for (int i = 0; i < 2; i++)
			if (ch[t.num][i])
				Q2.push(data(key[ch[t.num][i]] + t.va - key[t.num],ch[t.num][i]));
	}
	int z = 233;
	return 0;
}