zoukankan      html  css  js  c++  java
  • @bzoj


    @description@

    皮卡丘被火箭队用邪恶的计谋抢走了!这三个坏家伙还给小智留下了赤果果的挑衅!为了皮卡丘,也为了正义,小智和他的朋友们义不容辞的踏上了营救皮卡丘的道路。
    火箭队一共有N个据点,据点之间存在M条双向道路。据点分别从1到N标号。小智一行K人从真新镇出发,营救被困在N号据点的皮卡丘。为了方便起见,我们将真新镇视为0号据点,一开始K个人都在0号点。
    由于火箭队的重重布防,要想摧毁K号据点,必须按照顺序先摧毁1到K-1号据点,并且,如果K-1号据点没有被摧毁,由于防御的连锁性,小智一行任何一个人进入据点K,都会被发现,并产生严重后果。因此,在K-1号据点被摧毁之前,任何人是不能够经过K号据点的。
    为了简化问题,我们忽略战斗环节,小智一行任何一个人经过K号据点即认为K号据点被摧毁。被摧毁的据点依然是可以被经过的。
    K个人是可以分头行动的,只要有任何一个人在K-1号据点被摧毁之后,经过K号据点,K号据点就被摧毁了。显然的,只要N号据点被摧毁,皮卡丘就得救了。
    野外的道路是不安全的,因此小智一行希望在摧毁N号据点救出皮卡丘的同时,使得K个人所经过的道路的长度总和最少。
    请你帮助小智设计一个最佳的营救方案吧!

    Input
    第一行包含三个正整数N,M,K。表示一共有N+1个据点,分别从0到N编号,以及M条无向边。一开始小智一行共K个人均位于0号点。
    接下来M行,每行三个非负整数,第i行的整数为Ai,Bi,Li。表示存在一条从Ai号据点到Bi号据点的长度为Li的道路。

    Output
    仅包含一个整数S,为营救皮卡丘所需要经过的最小的道路总和。

    Sample Input
    3 4 2
    0 1 1
    1 2 1
    2 3 100
    0 3 1
    Sample Output
    3

    【样例说明】
    小智和小霞一起前去营救皮卡丘。在最优方案中,小智先从真新镇前往1号点,接着前往2号据点。当小智成功摧毁2号据点之后,小霞从真新镇出发直接前往3号据点,救出皮卡丘。

    HINT
    对于100%的数据满足N ≤ 150, M ≤ 20 000, 1 ≤ K ≤ 10, Li ≤ 10 000, 保证小智一行一定能够救出皮卡丘。
    至于为什么K ≤ 10,你可以认为最终在小智的号召下,小智,小霞,小刚,小建,小遥,小胜,小光,艾莉丝,天桐,还有去日本旅游的黑猫警长,一同前去大战火箭队。

    @solution@

    考虑如果 j 还没有被到达过且 j 之前的都曾被到达过,此时某个人如果想从 i 走到 j,那么必然只会经过编号比 j 小的点。

    先考虑我们是否可以预处理出 A[i][j] 表示 i 出发经过编号 ≤ j 的点到达点 j 的最短路径。
    可以发现这个 Floyd 的过程非常相似。我们做 Floyd 时最外层循环的含义是“仅经过编号 ≤ k 的点时的最短路”。
    于是就可以直接在 Floyd 的时候顺便求出 A[i][j]。

    那么在我们求出 A[i][j] 过后,其实就可以只考虑我们第一次经过某个点(因为不是第一次经过肯定就是在第一次经过另外一个点的路上,于是会被算入上面的最短路 A[i][j])。
    相当于我们是选择 K 条从 0 号点出发的路径,使得这 K 条路径覆盖完所有点,且 K 条路径长度总和最小(这里的长度就是 A[i][j])。
    覆盖完所有点,可以考虑使用拆点 + 上下界网络流。
    除了 0 号点的所有点向 0 号点连 inf 边,就可以跑上下界的最小费用无源汇流,此时流出来的费用就是答案。

    @accepted code@

    #include<cstdio>
    #include<algorithm>
    using namespace std;
    const int MAXN = 150;
    const int MAXV = 350;
    const int MAXE = 50000;
    const int INF = int(1E9);
    struct FlowGraph{
    	struct edge{
    		int to, flow, cap, cost;
    		edge *rev, *nxt;
    	}edges[MAXE + 5], *adj[MAXV + 5], *cur[MAXV + 5], *ecnt;
    	FlowGraph() {ecnt = &edges[0];}
    	void addedge(int u, int v, int c, int w) {
    		edge *p = (++ecnt), *q = (++ecnt);
    		p->to = v, p->cap = c, p->flow = 0, p->cost = w;
    		p->nxt = adj[u], adj[u] = p;
    		q->to = u, q->cap = 0, q->flow = 0, q->cost = -w;
    		q->nxt = adj[v], adj[v] = q;
    		p->rev = q, q->rev = p;
    //		printf("! %d %d %d %d
    ", u, v, c, w);
    	}
    	int hp[MAXV + 5], f[MAXV + 5];
    	int d[MAXV + 5], h[MAXV + 5], s, t;
    	void update(int x, int k) {
    		f[x] = k;
    		while( x ) {
    			hp[x] = x;
    			if( (x<<1) <= t && f[hp[x<<1]] < f[hp[x]] )
    				hp[x] = hp[x<<1];
    			if( (x<<1|1) <= t && f[hp[x<<1|1]] < f[hp[x]] )
    				hp[x] = hp[x<<1|1];
    			x >>= 1;
    		}
    	}
    	void maintain() {
    		for(int i=1;i<=t;i++)
    			h[i] += d[i];
    	}
    	bool relabel() {
    		maintain();
    		for(int i=1;i<=t;i++)
    			hp[i] = i, d[i] = f[i] = INF, cur[i] = adj[i];
    		d[s] = 0; update(s, 0);
    		while( f[hp[1]] != INF ) {
    			int x = hp[1]; update(x, INF);
    			for(edge *p=adj[x];p;p=p->nxt) {
    				int w = p->cost + h[x] - h[p->to];
    				if( p->cap > p->flow && d[x] + w < d[p->to] ) {
    					d[p->to] = d[x] + w;
    					update(p->to, d[p->to]);
    				}
    			}
    		}
    		return !(d[t] == INF);
    	}
    	bool vis[MAXV + 5];
    	int aug(int x, int tot) {
    		if( x == t ) return tot;
    		int sum = 0; vis[x] = true;
    		for(edge *&p=cur[x];p;p=p->nxt) {
    			int w = p->cost + h[x] - h[p->to];
    			if( !vis[p->to] && p->cap > p->flow && d[x] + w == d[p->to] ) {
    				int del = aug(p->to, min(tot - sum, p->cap - p->flow));
    				p->flow += del, p->rev->flow -= del, sum += del;
    				if( sum == tot ) break;
    			}
    		}
    		vis[x] = false;
    		return sum;
    	}
    	int min_cost_max_flow(int _s, int _t) {
    		s = _s, t = _t; int cost = 0;
    		while( relabel() ) {
    			int del = aug(s, INF);
    			cost += del*(d[t] + h[t]);
    		}
    		return cost;
    	}
    }G;
    int N, M, K;
    int A[MAXN + 5][MAXN + 5];
    int main() {
    	scanf("%d%d%d", &N, &M, &K), N++;
    	int s = 2*N + 1, t = 2*N + 2;
    	for(int i=1;i<=N;i++)
    		for(int j=1;j<=N;j++)
    			A[i][j] = (i == j ? 0 : INF);
    	for(int i=2;i<=N;i++) {
    		G.addedge(i, t, 1, 0);
    		G.addedge(i, i + N, 1, 0);
    		G.addedge(s, i + N, 1, 0);
    		G.addedge(i + N, 1, INF, 0);
    	}
    	G.addedge(1, 1 + N, K, 0);
    	for(int i=1;i<=M;i++) {
    		int u, v, w; scanf("%d%d%d", &u, &v, &w), u++, v++;
    		A[u][v] = min(A[u][v], w), A[v][u] = min(A[v][u], w);
    	}
    	for(int k=1;k<=N;k++) {
    		for(int i=1;i<=N;i++)
    			for(int j=1;j<=N;j++)
    				A[i][j] = min(A[i][j], A[i][k] + A[k][j]);
    		for(int i=1;i<k;i++)
    			G.addedge(i + N, k, INF, A[i][k]);
    	}
    	printf("%d
    ", G.min_cost_max_flow(s, t));
    }
    

    @details@

    代码中为了更严谨,我将拆点后的中间的边不仅下界设为 1,上界也设为 1(即保证每个点最多只能被一个人“第一次经过”)。

    但其实。。。好像也没有这个必要。因为假如路径相交,一定可以将它拆成路径不相交的情况。

  • 相关阅读:
    一文说清 InnoDB 的事务机制
    MySQL 索引结构
    Mysql索引(一篇就够le)
    对Elasticsearch生命周期的思考
    elasticsearch备份和还原(基于hdfs)
    想写一篇jvm的工具入门
    elasticsearch跨集群数据迁移
    [论文阅读]阿里DIN深度兴趣网络之总体解读
    [源码阅读] 阿里SOFA服务注册中心MetaServer(3)
    [源码阅读] 阿里SOFA服务注册中心MetaServer(2)
  • 原文地址:https://www.cnblogs.com/Tiw-Air-OAO/p/11396666.html
Copyright © 2011-2022 走看看