[USACO 13DEC]Vacation Planning(gold)

Description

Air Bovinia operates flights connecting the N farms that the cows live on (1 <= N <= 20,000). As with any airline, K of these farms have been designated as hubs (1 <= K <= 200, K <= N).

Currently, Air Bovinia offers M one-way flights (1 <= M <= 20,000), where flight i travels from farm u_i to farm v_i and costs d_i (1 <= d_i <= 10,000) dollars. As with any other sensible airline, for each of these flights, at least one of u_i and v_i is a hub. There is at most one direct flight between two farms in any given direction, and no flight starts and ends at the same farm.

Bessie is in charge of running the ticketing services for Air Bovinia. Unfortunately, while she was away chewing on delicious hay for a few hours, Q one-way travel requests for the cows‘ holiday vacations were received (1 <= Q <= 50,000), where the ith request is from farm a_i to farm b_i.

As Bessie is overwhelmed with the task of processing these tickets, please help her compute whether each ticket request can be fullfilled, and its minimum cost if it can be done.

To reduce the output size, you should only output the total number of ticket requests that are possible, and the minimum total cost for them. Note that this number might not fit into a 32-bit integer.

是n个点m条有向边,求两两之间的最短路,要求路径上必须经过编号1~k的至少一个点

Input

  • Line 1: The integers N, M, K, and Q.
  • Lines 2..M + 1: Line i+1 contains u_i, v_i, and d_i. (1 <= u_i, v_i <= N, u_i != v_i)
  • Lines M + 2..M + K + 1: Each of these lines contains the ID of a single hub (in the range 1..N).
  • Lines M + K + 2..M + K + Q + 1: Two numbers per line, indicating a request for a ticket from farm a_i to b_i. (1 <= a_i, b_i <= N, a_i != b_i)

Output

  • Line 1: The number of ticket requests that can be fullfilled.
  • Line 2: The minimum total cost of fulling the possible ticket requests

Sample Input

3 3 1 2
1 2 10
2 3 10
2 1 5
2
1 3
3 1 

Sample Output

1
20 

Hint

For the first flight, the only feasible route is 1->2->3, costing 20. There are no flights leaving farm 3, so the poor cows are stranded there.

题解

显然是一道求多源最短路的题,而总的点数远远超过了$floyd$的承受范围。

我们用分治的思想,注意到题中所有边都是与“关键点”即收费站相连的,显然我们可以考虑对于这些点进行$floyd$。

对于非关键点的点,我们可以枚举,并在之前$floyd$处理完的“块”内求一遍单源最短路,注意与枚举的点相连的边是“出边”还是“入边”。

处理答案时,注意点要分是在“块”内还是“块”外。

  1 #include<cmath>
  2 #include<queue>
  3 #include<ctime>
  4 #include<stack>
  5 #include<cstdio>
  6 #include<string>
  7 #include<cstdlib>
  8 #include<cstring>
  9 #include<iostream>
 10 #include<algorithm>
 11 #define LL long long
 12 using namespace std;
 13 const int N=20000;
 14 int INF;
 15
 16 struct tt
 17 {
 18     int to,next,cost;
 19 }edge[N+5];
 20 int path[N+5],top;
 21 int n,m,k,q,u,v,d;
 22 int x[205],num[N+5];
 23 int map[205][205];
 24 int in[N+5][205],out[205][N+5];
 25
 26 void Count_in();
 27 void Count_out();
 28 void Floyd();
 29 void Build();
 30 inline void Add(int x,int y,int c);
 31 inline int my_min(int x,int y);
 32 inline int Read();
 33
 34 int main()
 35 {
 36     n=Read();m=Read();k=Read();q=Read();
 37     for (int i=1;i<=m;i++)
 38     {
 39         u=Read();v=Read();d=Read();
 40         Add(u,v,d);
 41     }
 42     for (int i=1;i<=k;i++)
 43     {
 44         x[i]=Read();
 45         num[x[i]]=i;
 46     }
 47     Floyd();
 48     Count_in();
 49     Count_out();
 50     int cnt=0,sum=0,ans=2*INF,x,y;
 51     for (int i=1;i<=q;i++)
 52     {
 53         x=Read();y=Read();
 54         if (num[x]&&num[y]) {if (map[num[x]][num[y]]<INF) cnt++,sum+=map[num[x]][num[y]];}
 55         else if (num[x]) {if (out[num[x]][y]<INF) cnt++,sum+=out[num[x]][y];}
 56         else if (num[y]) {if (in[x][num[y]]<INF) cnt++,sum+=in[x][num[y]];}
 57         else
 58         {
 59             int ans=2*INF;
 60             for (int j=1;j<=k;j++) if (in[x][j]+out[j][y]<ans) ans=in[x][j]+out[j][y];
 61             if (ans<INF) cnt++,sum+=ans;
 62         }
 63     }
 64     printf("%d\n%d\n",cnt,sum);
 65     return 0;
 66 }
 67
 68 inline void Add(int x,int y,int c)
 69 {
 70     edge[++top].to=y;
 71     edge[top].cost=c;
 72     edge[top].next=path[x];
 73     path[x]=top;
 74 }
 75 void Floyd()
 76 {
 77     memset(map,127/3,sizeof(map));
 78     Build();
 79     for (int p=1;p<=k;p++)
 80         for (int i=1;i<=k;i++)
 81             for (int j=1;j<=k;j++)
 82                 if (map[i][j]>map[i][p]+map[p][j])
 83                     map[i][j]=map[i][p]+map[p][j];
 84 }
 85 void Build()
 86 {
 87     for (int i=1;i<=k;i++)
 88         for (int j=path[x[i]];j;j=edge[j].next)
 89             if (!num[edge[j].to])
 90                 for (int p=path[edge[j].to];p;p=edge[p].next)
 91                     map[i][num[edge[p].to]]=my_min(map[i][num[edge[p].to]],edge[j].cost+edge[p].cost);
 92             else map[i][num[edge[j].to]]=my_min(map[i][num[edge[j].to]],edge[j].cost);
 93 }
 94 void Count_in()
 95 {
 96     memset(in,127/3,sizeof(in));INF=in[0][0];
 97     for (int i=1;i<=n;i++) if (!num[i])
 98     {
 99         for (int j=path[i];j;j=edge[j].next)
100         {
101             if (in[i][num[edge[j].to]]>edge[j].cost)
102                 in[i][num[edge[j].to]]=edge[j].cost;
103             for (int p=1;p<=k;p++) if (in[i][p]>map[num[edge[j].to]][p]+edge[j].cost)
104                 in[i][p]=map[num[edge[j].to]][p]+edge[j].cost;
105         }
106     }
107 }
108 void Count_out()
109 {
110     memset(out,127/3,sizeof(out));
111     for (int i=1;i<=k;i++)
112     {
113         for (int j=path[x[i]];j;j=edge[j].next) if (!num[edge[j].to])
114         {
115             if (out[i][edge[j].to]>edge[j].cost)
116                 out[i][edge[j].to]=edge[j].cost;
117             for (int p=1;p<=k;p++) if (out[p][edge[j].to]>map[p][i]+edge[j].cost)
118                 out[p][edge[j].to]=map[p][i]+edge[j].cost;
119         }
120     }
121 }
122 inline int my_min(int x,int y) {return x<y ? x:y;}
123 inline int Read()
124 {
125     int sum=0;
126     char ch=getchar();
127     while (ch<‘0‘||ch>‘9‘) ch=getchar();
128     while (ch>=‘0‘&&ch<=‘9‘)
129     {
130         sum=sum*10+ch-‘0‘;
131         ch=getchar();
132     }
133     return sum;
134 }
时间: 2024-10-10 04:02:43

[USACO 13DEC]Vacation Planning(gold)的相关文章

bzoj4093: [Usaco2013 Dec]Vacation Planning

bzoj4093: [Usaco2013 Dec]Vacation Planning Time Limit: 10 Sec  Memory Limit: 128 MBSubmit: 81  Solved: 38[Submit][Status][Discuss] Description Bovinia设计了连接N (1 < = N < = 20,000)个农场的航班.对于任何航班,指定了其中的k个农场作为枢纽. (1 < = K <= 200 , K < = N). 目前,共有

bzoj4097 [Usaco2013 dec]Vacation Planning

Description Air Bovinia is planning to connect the N farms (1 <= N <= 200) that the cows live on. As with any airline, K of these farms (1 <= K <= 100, K <= N) have been selected as hubs. The farms are conveniently numbered 1..N, with farms

【Floyd(并非水题orz)】BZOJ4093-[Usaco2013 Dec]Vacation Planning

最近刷水太多标注一下防止它淹没在silver的水题中--我成为了本题,第一个T掉的人QAQ [题目大意] Bovinia设计了连接N (1 < = N < = 20,000)个农场的航班.对于任何航班,指定了其中的k个农场作为枢纽. (1 < = K <= 200 , K < = N). 目前,共有M种单向航班( 1 < = M < = 20,000 ),第i个航班从农场u_i至农场v_i花费d_i ( 1 < = d_i < =10,000 )美元.

洛谷P3094 [USACO13DEC]假期计划Vacation Planning

题目描述 有N(1 <= N <= 200)个农场,用1..N编号.航空公司计划在农场间建立航线.对于任意一条航线,选择农场1..K中的农场作为枢纽(1 <= K <= 100, K <= N). 当前共有M (1 <= M <= 10,000)条单向航线连接这些农场,从农场u_i 到农场 v_i, 将花费 d_i美元.(1 <= d_i <= 1,000,000). 航空公司最近收到Q (1 <= Q <= 10,000)个单向航行请求.

USACO 2015 February Contest Gold T2: Censoring

题目大意 FJ把杂志上所有的文章摘抄了下来并把它变成了一个长度不超过10^5的字符串S.他有一个包含n个单词的列表,列表里的n个单词记为t1...tN.他希望从S中删除这些单词. FJ每次在S中找到最早出现的列表中的单词(最早出现指该单词的开始位置最小),然后从S中删除这个单词.他重复这个操作直到S中没有列表里的单词为止.注意删除一个单词后可能会导致S中出现另一个列表中的单词 FJ注意到列表中的单词不会出现一个单词是另一个单词子串的情况,这意味着每个列表中的单词在S中出现的开始位置是互不相同的

USACO 2016 December Contest Gold T1: Moocast

题目大意 FJ的N头牛(1≤N≤1000)为了在他们之间传播信息, 想要组织一个"哞哞广播"系统. 奶牛们决定去用步话机装备自己而不是在很远的距离之外互相哞哞叫, 所以每一头奶牛都必须有一个步话机. 这些步话机都有一个限制传播半径, 但是奶牛们可以间接地通过中间奶牛传播信息, 所以并不是每头牛都必须直接向其他每一头奶牛连边. 奶牛们需要去决定多少钱花在步话机上, 如果他们花了$X, 那么他们都将会得到sqrt(x)距离的步话机. 所以, 两头牛之间的欧几里得距离平方最多是X. 请帮助奶

USACO 2016 December Contest Gold T3: Lasers and Mirrors

题目大意 出于某种原因,农夫约翰的牛总是在举行激光表演. 对于他们的最新展会,奶牛已经购买了一个大功率的激光器 - 这么大,事实上,他们似乎不能轻易地从它交付的位置移动.他们想以某种方式将激光的光发送到FJ物业另一侧的谷仓.激光器和谷仓都可以被认为位于FJ农场的地图上的2D平面中的点上.牛计划指挥激光器,使得它发出水平或竖直(即,与x或y轴平行)的光束.他们会将这个光束从一些镜子反射回去,直接到谷仓. 在农场上有N个栅栏(1≤N≤100,000),位于不同的二维点(也不同于激光和谷仓),牛可以安

USACO 2017 December Contest Gold T1: A Pie for a Pie

题目大意 Bessie和Elsie各自烤了 N(1≤N≤10^5)个馅饼.Bessie 会这 2N 个馅饼打分,Elsie 也会.二者的打分均为一个 ≤1e9 的非负整数.由于她们口味不同,每个派的两个分数可能不同.她们想互赠礼物.开始时,Bessie 送给 Elsie 一个馅饼.她们收到礼物(对方做的馅饼)后都会回赠对方一个自己做的馅饼.她们选择回礼的方法相同.以 Elsie 为例,Elsie 根据自己的打分来选择回礼.回礼的分数至少要大于她收到的馅饼的分数,但两个馅饼的分数差不能大于 D(0

BZOJ-USACO被虐记

bzoj上的usaco题目还是很好的(我被虐的很惨. 有必要总结整理一下. 3889: [Usaco2015 Jan]Cow Routing 双键值最短路,预处理出代价跑一遍最短路就可以. ★3890: [Usaco2015 Jan]Meeting Time 维护一个小根堆,把边不断地插进去,然后维护一个ans,如果说ans>q.top().t且两个边权都走到n的话,就直接输出答案.否则答案只可能比当前答案还要大. 3891: [Usaco2014 Dec]Piggy Back 做3遍最短路,然