NOIP模拟 17.9.28

Posted 2020-10-08 嘒彼小星

公交车
【问题描述】
市内有??个路口和??条双向道路，每条道路都有过路费，第??条道路的过路费
为??%元。市内还有??条公交线路，公交车只在路口停靠，而且一路公交车只会沿
着固定的线路往返行驶。上第??路公交车需要??%元的费用，但费用是一次性的，
即你可以在公交线路上的任意停靠路口下车。但是一旦下车了，如果要再次上车，
则还需要再次付费。
现在你在路口??，你想知道从??出发到其它每个路口的最小费用是多少。
【输入格式】
输入的第一行包含四个整数??、??、??和??，分别代表路口数、道路数、公交
线路数和你所处的路口编号。
接下来的??行，每行包含三个整数??%、??%和??%，代表第??条道路连接??%路口和
??%路口，并且通过这条道路需要缴纳??%元的过路费。
接下来的??行，每行首先是两个整数??%和??%，代表第??路公交车的上车费用为??%
元，而且公交线路共有??%个停靠路口。接下来同一行内有??%个整数，按顺序给出
了这路公交车的各个停靠路口。
【输出格式】
输出一行，包含??个整数，为从路口??到每个路口的最小费用。
【样例】
transprt.in transprt.out
5 4 1 1
1 2 1
2 3 1
3 4 1
4 5 1
2 4 2 3 4 5
0 1 2 3 3
【样例解释】
到路口5 时需要先走到路口2 然后搭公交车，费用为1 + 2 = 3。
其他情况均不需要搭公交车。
【数据规模和约定】
对于30%的数据，?? ≤ 100，?? = 1。
对于另外30%的数据，?? = 0。
对于100%的数据，1 ≤ ?? ≤ 100000，1 ≤ ?? ≤ 200000，1 ≤ ?? ≤ 50000，
Σ??% ≤ 200000, 1 ≤ ??%, ??% ≤ 107。

 

【题解】

水最短路

公交车虚一个点，从经过的点往虚的点连有边权，虚的点往经过的点连边权0即可

  1 #include <iostream>
  2 #include <cstdio>
  3 #include <cstdlib>
  4 #include <cstring>
  5 #include <algorithm>
  6 #include <queue>
  7 #include <vector> 
  8 
  9 inline void read(long long &x)
 10 {
 11     x = 0;char ch = getchar(), c = ch;
 12     while(ch < ‘0‘ || ch > ‘9‘) c = ch, ch = getchar();
 13     while(ch <= ‘9‘ && ch >= ‘0‘) x = x * 10 + ch - ‘0‘, ch = getchar();
 14     if(c == ‘-‘)x = -x;
 15 }
 16 
 17 const long long INF = 0x3f3f3f3f;
 18 const long long MAXN = 300000 + 1000;
 19 const long long MAXM = 400000 + 1000;
 20 const long long MAXK = 70000 + 1000;
 21 const long long MAXT = 400000 + 1000;
 22 
 23 //开longlong
 24 
 25 long long n,m,k,s;
 26 
 27 struct Edge
 28 {
 29     long long u,v,w,next;
 30     Edge(long long _u, long long _v, long long _w, long long _next){u = _u;v =_v;w = _w;next = _next;}
 31     Edge(){}
 32 } edge[MAXM * 2 + MAXT * 2];
 33 long long head[MAXN + MAXK], cnt;
 34 
 35 inline void insert(long long a, long long b, long long c)
 36 {
 37     edge[++cnt] = Edge(a,b,c,head[a]);
 38     head[a] = cnt;
 39 }
 40 
 41 struct Node
 42 {
 43     long long v,w;
 44     Node(long long _v, long long _w){v = _v;w = _w;}
 45     Node(){}
 46 };
 47 struct cmp
 48 {
 49     bool operator()(Node a, Node b)
 50     {
 51         return a.w > b.w;
 52     }
 53 };
 54 long long d[MAXN + MAXK], b[MAXN + MAXK];
 55 std::priority_queue<Node, std::vector<Node>, cmp> q;
 56 
 57 void dijkstra()
 58 {
 59     memset(d, 0x3f, sizeof(d));
 60     d[s] = 0;
 61     q.push(Node(s, 0));
 62     Node now;long long v, u;
 63     while(q.size())
 64     {
 65         now = q.top(), q.pop();
 66         if(b[now.v])continue;
 67         u = now.v;
 68         b[u] = 1;
 69         for(register long long pos = head[u];pos;pos = edge[pos].next)
 70         {
 71             v = edge[pos].v;
 72             if(d[v] > d[u] + edge[pos].w)
 73             {
 74                 d[v] = d[u] + edge[pos].w;
 75                 q.push(Node(v, d[v]));
 76             }
 77         }
 78     }
 79 }
 80 
 81 int main()
 82 {
 83     read(n), read(m), read(k), read(s);
 84     long long tmp1, tmp2, tmp3;
 85     for(register long long i = 1;i <= m;++ i)
 86     {
 87         read(tmp1), read(tmp2), read(tmp3); 
 88         insert(tmp1, tmp2, tmp3);
 89         insert(tmp2, tmp1, tmp3);
 90     }
 91     for(register long long i = 1;i <= k;++ i)
 92     {
 93         read(tmp3);read(tmp1);
 94         for(register long long j = 1;j <= tmp1;++ j)
 95         {
 96             read(tmp2);
 97             insert(n + i, tmp2, 0);
 98             insert(tmp2, n + i, tmp3);
 99         }
100     }
101     dijkstra();
102     for(register long long i = 1;i <= n;++ i)
103         printf("%lld ", d[i]);
104     return 0;
105 }

T1

 

灌溉
【问题描述】
Farmer John 有??个牧场，他希望灌溉他的所有牧场。牧场编号为1 ∼ ??，要
灌溉一个牧场有两种方式，一个是直接在这个牧场建设一个小型水库，另一个是
从别的牧场向这个牧场引水。在第??个牧场建立小型水库需要??%美元，而从第?? 个
牧场向第??个牧场引水需要??%,<美元。即便牧场??没有建设小型水库，只要有别的有
水的水库向它引水，那它自己也有水，而且可以向别的水库引水。请告诉FJ 灌
溉所有牧场所需的最小代价。
【输入格式】
输入数据的第一行包含一个整数??，代表牧场的数目。
接下来??行，每行包含一个整数??%，代表建立小型水库的代价。
接下来??行，每行包含??个整数。第??行的第??个数为??%,<。
【输出格式】
输出一行，包含一个整数，即为答案。
【样例】
irrigate.in irrigate.out
4
5
4
4
3
0 2 2 2
2 0 3 3
2 3 0 4
2 3 4 0
9
【样例解释】
FJ 应该在第4 块牧场上建立小型水库，然后从这块牧场向其他所有牧场引
水。总费用为3 + 2 + 2 + 2 = 9美元。
【数据规模和约定】
对于20%的数据，?? ≤ 10。
对于40%的数据，?? ≤ 50。
对于60%的数据，?? ≤ 100。
对于100%的数据，1 ≤ ?? ≤ 300，1 ≤ ??%,<,??% ≤ 10>，??%,< = ??<,%，??%,% = 0。

【题解】

水MST

空间开小了，爆掉80

 

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <algorithm>
 6 
 7 const long long INF = 0x3f3f3f3f;
 8 const long long MAXN = 300000 + 10;
 9 const long long MAXM = 1000000 + 1000;
10 
11 inline void read(long long &x)
12 {
13     x = 0;char ch = getchar(), c = ch;
14     while(ch < ‘0‘ || ch > ‘9‘) c = ch, ch = getchar();
15     while(ch <= ‘9‘ && ch >= ‘0‘) x = x * 10 + ch - ‘0‘, ch = getchar();
16     if(c == ‘-‘)x = -x; 
17 }
18 
19 long long n, ans, rank[MAXN + MAXN], w[MAXM + MAXM], u[MAXM + MAXM], v[MAXM + MAXM], fa[MAXN + MAXN], cnt;
20 
21 long long cmp(long long a, long long b)
22 {
23     return w[a] < w[b];
24 }
25 
26 long long find(long long x)
27 {
28     return x == fa[x] ? x : fa[x] = find(fa[x]);
29 }
30 
31 int main()
32 {
33     read(n);
34     for(register long long i = n * 10;i >= 1;-- i)fa[i] = i; 
35     for(register long long i = 1;i <= n;++ i)
36         ++ cnt, u[cnt] = n + 1, v[cnt] = i, read(w[cnt]), rank[cnt] = cnt; 
37     
38     long long tmp,f1,f2;
39     for(register long long i = 1;i <= n;++ i)
40         for(register long long j = 1;j <= n;++ j)
41         {
42             read(tmp); 
43             if(i >= j)continue;
44             ++cnt, u[cnt] = i, v[cnt] = j, w[cnt] = tmp;
45             rank[cnt] = cnt; 
46         } 
47     std::sort(rank + 1, rank + 1 + cnt, cmp);
48     for(register long long k = 1;k <= cnt;++ k)
49     {
50         f1 = find(u[rank[k]]), f2 = find(v[rank[k]]);
51         if(f1 == f2)continue;
52         fa[f1] = f2;
53         ans += w[rank[k]];
54     }
55     printf("%lld", ans);
56     return 0;
57 }

T2

 

 

 

对决
【问题描述】
有两个人在玩一个公平组合游戏。现在我们要分析这两个人谁能获胜。给定
这个游戏的所有局面和局面间的转移，显然它会构成一个DAG。
如果一个局面不能转移到其它局面，那么称这个局面为终止局面；如果一个
局面不能由其它局面转移而来，那么称这个局面为起始局面。
已知这个游戏有??个局面和??条转移（即DAG 有??个点和??条边），有唯一的
起始局面，但可能有多个终止局面。同时，每一个局面都可以由初始局面到达。
现在告诉你所有终止局面是哪方获胜，你能否求出每个局面是先手必胜态还是先
手必败态？
【输入格式】
输入数据的第一行包含两个正整数??和??，分别代表游戏的局面数和转移数。
接下来??行，每行两个整数??%和??%，代表第??条转移是由局面??%转移到局面??%。
接下来一行，有若干个整数，依次代表所有终止局面的获胜方，按照其节点
编号从小到大给出。如果数字为1，那么在该终止局面的先手获胜；如果数字为
0，则后手获胜。
【输出格式】
输出??行，每行包含一个字符串，第??行的字符串代表编号为??的局面的状态。
如果局面为先手必胜态，则输出“First”，否则输出“Last”（均不含引号）。
【样例】
duel.in duel.out
5 5
1 2
1 3
2 4
4 3
4 5
0 1
First
Last
Last
First
First
【样例解释】
局面3 和5 是终止局面，其中3 为后手胜，5 为先手胜。
根据博弈论的有关知识，不难得出答案。
【数据规模和约定】
对于30%的数据，1 ≤ ??,?? ≤ 10。
对于另外30%的数据，?? = ?? − 1。
对于100%的数据，1 ≤ ?? ≤ 100000，1 ≤ ?? ≤ 200000。
【提示】
对于没有接触过博弈论的同学，这里普及一点小常识。如果你之前了解博弈
论相关理论，可以忽略这一段文字。
我们用“局面”代指博弈论中游戏的一个状态。所谓“公平组合游戏”即不
存在随机性、双方信息相同、双方在面临同一局面时的选择也相同的游戏。
比如在本题的游戏中，游戏不存在随机性（游戏进程仅受双方的选择所影响），
双方了解游戏的所有信息（整个游戏的局面和转移），双方在面临同一局面时的
选择也相同（都只能选择从当前局面转移到的其他局面，这些局面被称为后继局
面）。
在一个公平组合游戏中，所有局面都可以分为“先手必胜”和“先手必败”
两种。其含义为，如果双方都以最优策略行动，那么面临这一局面的一方（即先
手） 将必胜或必败。
对于终止局面（即不存在后继局面，当一方到达这一局面时，游戏结束），
其为先手必胜还是先手必败是游戏定义的。在本题中，即为输入给定的。
而对于非终止局面，其为先手必胜还是先手必败是由其后继局面决定的：
• 如果存在一个后继局面为先手必败态，那么当前局面为先手必胜态。
因为先手可以从所有后继局面中任意选择，他当然会选择先手必败的
后继局面——面临这一后继局面的将是后手。
• 否则，即如果所有后继局面都是先手必胜态，那么当前局面为先手必
败态。
根据以上两条规则，可以判定游戏中所有局面的状态。

 

【题解】

水dfs。题解是top排序，但是容易被卡成有一定常数的kn^q，k < 1，可能会爆掉

我这个算法是稳稳地O(n)，(n), Ω(n)

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <algorithm>
 6 
 7 inline void read(int &x)
 8 {
 9     x = 0;char ch = getchar(), c = ch;
10     while(ch < ‘0‘ || ch > ‘9‘) c = ch, ch = getchar();
11     while(ch <= ‘9‘ && ch >= ‘0‘) x = x * 10 + ch - ‘0‘, ch = getchar();
12     if(c == ‘-‘)x = -x;
13 }
14 
15 const int INF = 0x3f3f3f3f;
16 const int MAXN = 1000000 + 10;
17 const int MAXM = 2000000 + 10;
18 
19 struct Edge
20 {
21     int u,v,next;
22     Edge(int _u, int _v, int _next){u = _u;v = _v;next = _next;}
23     Edge(){}
24 }edge[MAXM];
25 
26 int chudu[MAXN], head[MAXN], rudu[MAXN], zhuangtai[MAXN], cnt, n, m, b[MAXN];
27 
28 inline void insert(int a, int b)
29 {
30     edge[++cnt] = Edge(a,b,head[a]);
31     head[a] = cnt;
32 }
33 
34 //1为必败态，2为必胜态 
35 
36 void dfs(int u)
37 {
38     int flag = 1;
39     for(register int pos = head[u];pos;pos = edge[pos].next)
40     {
41         int v = edge[pos].v;
42         if(b[v])
43         {
44             if(zhuangtai[v] == 1)
45                 flag = 2;
46         }
47         else 
48         {
49             dfs(v);
50             if(zhuangtai[v] == 1)
51                 flag = 2;
52         }
53     }
54     zhuangtai[u] = flag;
55     b[u] = 1;
56 }
57 
58 int main()
59 {
60     read(n), read(m);
61     int tmp1, tmp2;
62     for(register int i = 1;i <= m;++ i)
63     {
64         read(tmp1), read(tmp2);
65         insert(tmp1, tmp2);
66         ++ chudu[tmp1];
67         ++ rudu[tmp2];
68     }
69     for(register int i = 1;i <= n;++ i)
70         if(!chudu[i])
71             read(zhuangtai[i]), ++ zhuangtai[i], b[i] = 1;
72     for(register int i = 1;i <= n;++ i)
73         if(rudu[i] == 0 && !b[i])
74             dfs(i); 
75     for(register int i = 1;i <= n;++i)
76     {
77         if(zhuangtai[i] == 2)
78             printf("First\n");
79         else
80             printf("Last\n");
81     }
82     return 0;
83 }

T3