2017-2018 ACM-ICPC Southeastern European Regional Programming Contest (SEERC 2017) Solution

最新推荐文章于 2021-08-01 10:09:17 发布
最新推荐文章于 2021-08-01 10:09:17 发布
阅读量350 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/Dup4/p/9497946.html
版权

A：Concerts

题意：给出一个串T， 一个串S，求串S中有多少个串T，可以重复，但是两个字符间的距离要满足给出的数据要求

思路：先顺序统计第一个T中的字符在S中有多少个，然后对于第二位的以及后面的，我们从后面往前推，前缀和搞一搞，注意间距

 1 #include<bits/stdc++.h>
 2 
 3 using namespace std;
 4 
 5 #define N 100010
 6 
 7 typedef long long ll;
 8 
 9 const int MOD = 1e9 + 7;
10 
11 ll sum[N];
12 
13 char strN[N], strK[N];
14 
15 int n,k;
16 int pos[100];
17 
18 int main()
19 {
20     while(~scanf("%d %d",&k,&n))
21     {
22         memset(sum, 0, sizeof sum);
23         for(int i = 0; i < 26; ++i)
24         {
25             scanf("%d",&pos[i]);
26         }
27         scanf("%s",strK + 1);
28         scanf("%s",strN + 1);
29         for(int i = 1;i <= n; ++i)
30         {
31             sum[i] = (strN[i] == strK[1]) + sum[i - 1];
32             sum[i] %= MOD;
33         }
34         for(int i = 2; i <= k; ++i)
35         {
36             for(int j = n; j >= 1; --j)
37             {
38                 if(strN[j] == strK[i])
39                 {
40                     int idx = strK[i - 1] - 'A';
41                     idx = pos[idx];
42                     if(j - idx - 1 < 1) sum[j] = 0;
43                     else sum[j] = sum[j - idx - 1];
44                 }
45                 else sum[j] = 0;
46             }
47             for(int j = 1;j <= n; ++j)
48             {
49                 sum[j] += sum[j - 1];
50                 sum[j] %= MOD;
51             }
52         }
53         printf("%lld\n",sum[n]);
54     }
55     return 0;
56 }
View Code

 

B：Bricks

留坑。

 

C：Christmas Tree

留坑。

 

D：Harry Potter and The Vector Spell

题意：给出n个向量，每个向量有m维，n个向量中有且只有两维上是一，然后重载了加号运算符和乘号运算符，求最多的非线性相关的向量个数

思路：因为每个向量中有且只有两个1，那么可以想象答案最大肯定是m - 1 因为分布肯定是这样的

 

那么我们考虑将每个向量的两个1连一条边，那么每个连通块对答案的贡献就是 连通块里面的点数减1

 1 #pragma comment(linker, "/STACK:1024000000,1024000000") 
 2 
 3 #include <bits/stdc++.h>
 4 using namespace std;
 5 
 6 #define INF 0x3f3f3f3f
 7 #define INFLL 0x3f3f3f3f3f3f3f3f
 8 #define ll long long 
 9 #define N 100100
10 
11 int m, n;
12 int pre[N];
13 int arr[N];
14 
15 inline int find(int x)
16 {
17     if (x != pre[x])
18         pre[x] = find(pre[x]);
19     return pre[x];
20 }
21 
22 inline void join(int x, int y)
23 {
24     int fx = find(x), fy = find(y);
25     if (fx != fy)
26         pre[fx] = fy;
27 }
28 
29 inline void Run()
30 {
31     while (scanf("%d%d", &m, &n) != EOF)
32     {
33         memset(arr, 0, sizeof arr);
34         for (int i = 1; i <= m; ++i)
35             pre[i] = i;
36         for (int i = 1, tot, x; i <= m; ++i)
37         {
38             scanf("%d", &tot);
39             while (tot--)
40             {
41                 scanf("%d", &x);
42                 if (arr[x])
43                     join(arr[x], i);
44                 else
45                     arr[x] = i;
46             }
47         }
48         int cnt = 0;
49         for (int i = 1; i <= m; ++i)
50             if (pre[i] == i) ++cnt;
51         printf("%d\n", m - cnt);
52     }
53 }
54 
55 int main()
56 {
57     #ifdef LOCAL
58         freopen("Test.in", "r", stdin);
59     #endif
60 
61     Run();
62     
63     return 0;
64 }
View Code

 

 

E：Looping Playlist

留坑。

 

F：Binary Transformations

题意：给出两个01串，每位有一个权值，然后要从a串变成b串，每换一次的花费是变之后a串中里面每一位是1的对应的权值和，求最小花费

思路：贪心的想法

先把1变成0，按权值大小从大到小变，把0变成1，按权值从小到大变

存在一个问题，如果本来a对应的那位以及b对应的那位都是1，但是那位权值特别特别大，可以将它先变成0，最后再变回来，可能会使得花费更少

容易知道，如果将a里面所有为1位的权值从大到小排序，那么如果存在这样的方案使得花费减少，那么肯定是一段连续的，枚举长度，

时间复杂度O(n ^ 2)

注意随手剪枝

 

  1 #include<bits/stdc++.h>
  2 
  3 using namespace std;
  4 
  5 typedef long long ll;
  6 #define N 5010
  7 const ll INFLL = 0x3f3f3f3f3f3f3f3f;
  8 struct node{
  9     int pos;
 10     int cost;
 11     inline node(){}
 12     inline node(int pos,int cost) :pos(pos), cost(cost){}
 13     inline bool operator < (const node &b) const
 14     {
 15         return cost > b.cost;
 16     }
 17 };
 18 
 19 inline bool cmp1(node a, node b)
 20 {
 21     return a.cost > b.cost;
 22 }
 23 
 24 inline bool cmp2(node a, node b)
 25 {
 26     return a.cost < b.cost;
 27 }
 28 
 29 int n;
 30 ll sum;
 31 int cost[N];
 32 char s1[N];
 33 char s2[N];
 34 
 35 int main()
 36 {
 37     while(~scanf("%d",&n))
 38     {
 39         for(int i = 1; i <= n; ++i)
 40         {
 41             scanf("%d", &cost[i]);
 42         }
 43         sum = 0;
 44         scanf("%s", s1 + 1);
 45         scanf("%s", s2 + 1);
 46         vector<node>ONE, ZERO_ONE;
 47         for(int i = 1; i <= n; ++i)
 48         {
 49             if(s1[i] == '1')
 50             {
 51                 ONE.push_back(node(i, cost[i]));
 52                 sum += cost[i];
 53             }
 54             else if(s1[i] == '0' && s2[i] == '1')
 55             {
 56                 ZERO_ONE.push_back(node(i, cost[i]));
 57             }
 58         }
 59         sort(ONE.begin(), ONE.end(), cmp1);
 60         int len = ONE.size();
 61         ll Begin = sum;
 62         ll ans = INFLL;
 63         for(int sz = -1; sz < len; ++sz)
 64         {
 65             ll tmp = 0;
 66             sum = Begin;
 67             for(int i = 0; i <= sz; ++i)
 68             {
 69                 sum -= ONE[i].cost;
 70                 tmp += sum;
 71                 if(tmp >= ans) break;
 72             }
 73             if(tmp >= ans) continue;
 74             for(int i = sz + 1; i < len; ++i)
 75             {
 76                 int p = ONE[i].pos;
 77                 if(s2[p] == '0')
 78                 {
 79                     sum -= ONE[i].cost;
 80                     tmp += sum;
 81                     if(tmp >= ans) break;
 82                 }
 83             }
 84             if(tmp >= ans) continue;
 85             vector<node>CHANGE = ZERO_ONE;
 86             for(int i = 0; i <= sz; ++i)
 87             {
 88                 int p = ONE[i].pos;
 89                 if(s1[p] == '1' && s2[p] == '1')
 90                 {
 91                     CHANGE.push_back(node(p, cost[p]));
 92                 }
 93             }
 94             sort(CHANGE.begin(), CHANGE.end(), cmp2);
 95             for(int i = 0, lenn = CHANGE.size(); i < lenn; ++i)
 96             {
 97                 sum += CHANGE[i].cost;
 98                 tmp += sum;
 99                 if(tmp >= ans) break;
100             }
101             ans = min(ans, tmp);
102         }
103         printf("%lld\n",ans);
104     }
105     return 0;
106 }
View Code

 

G：Robots

题意：给出n组数据，每组数据包含一个加速度和时间，求按顺序得到的距离，以及按最优顺序得到距离的不同

思路：先遍历一遍算一下，然后贪心按加速度排一下，算一下，算差距

 1 #include <bits/stdc++.h>
 2 
 3 using namespace std;
 4 
 5 #define N 10010
 6 
 7 struct node
 8 {
 9     double a, s;
10     inline void scan()
11     {
12         scanf("%lf%lf", &a, &s);
13     }
14     inline bool operator < (const node &r) const
15     {
16         return a  > r.a;
17     }
18 }arr[N];
19 
20 int n;
21 
22 inline double work()
23 {
24     double res = 0;
25     double v = 0;
26     for (int i = 1; i <= n; ++i)
27     {
28         double t = arr[i].s;
29         res += v * t + arr[i].a * t * t / 2;
30         v += arr[i].a * t;
31     }
32     return res;
33 }
34 
35 int main()
36 {
37     while (scanf("%d", &n) != EOF)
38     {
39         for (int i = 1; i <= n; ++i) arr[i].scan();
40         double sum1 = work();
41         sort(arr + 1, arr + 1 + n);
42         double sum2 = work();
43 //        printf("%lf %lf\n", sum1, sum2);
44         printf("%.1f\n", sum2 - sum1);
45     }
46     return 0;
47 }
View Code

 

H:Cat and Mouse

留坑。

 

I:Tetris

留坑。

 

J：Cunning Friends

题意：有n堆石头，第i堆有ai个，A先取，每次从一堆中取的数量不等于0，然后B 和 C取 谁不能取了谁就输了，B 和 C 想让A输，假设每个人的决策都是最佳的，求A是必败还是必输

思路：可以考虑一下几种情况

1° 全是1的情况  那么用n%3 看一下余数，如果余数是0 那么A是必输的

2°只有一个不是1的情况，那么A是必胜的，因为假如堆数%3 == 0 那么 我将不是1的那堆取成1，这样就相当于变成了堆数%3==1 变成必胜态

3°有两个不是1的情况

首先我们可以知道，假如只有两堆，并且这两堆都不是1，那么A是必输的

那转化成加了若干堆1，那么这若干堆1当中如果%3 == 0 那么A是必输的

如果不是，并且存在至少一堆是2，A是赢的

4° 其他情况都是必输的

 1 #pragma comment(linker, "/STACK:1024000000,1024000000") 
 2 
 3 #include <cstdio>
 4 #include <cmath>
 5 #include <algorithm>
 6 #include <iostream>
 7 
 8 using namespace std;
 9 
10 #define INF 0x3f3f3f3f
11 #define INFLL 0x3f3f3f3f3f3f3f3f
12 #define ll long long 
13 #define N 100100
14 
15 int n;
16 
17 int ONE, TWO;
18 
19 inline bool work()
20 {
21     if (ONE == n - 1) return true;
22     else if (ONE == n)
23         return n % 3;
24     if (ONE == n - 2)
25     {
26         if (n % 3 == 2) return false;
27         if (TWO) return true;
28         return false;
29     }
30     return false;
31 }
32 
33 inline void Run()
34 {
35     while (scanf("%d", &n) != EOF)
36     {
37         ONE = 0, TWO = 0;
38         for (int i = 1, num; i <= n; ++i)
39         {
40             scanf("%d", &num);
41             if (num == 1) ++ONE;
42             if (num == 2) ++TWO;
43         }
44         puts(work() ? "Win" : "Lose");
45     }
46 }
47 
48 int main()
49 {
50     #ifdef LOCAL
51         freopen("Test.in", "r", stdin);
52     #endif
53 
54     Run();
55     
56     return 0;
57 }
View Code

 

 

 

k：Escape Room

题意：有一个长度为n的序列，里面的数是1 - n 然后给出每一位以当前位为队头的最长上升子序列长度，还原原序列，多个答案输出字典序最小的那个

思路：

比如说 1 2 2 1

我们可以考虑先放长度为1 的

肯定是从后面取两个数 放 4 和 3

然后 长度就变成

0 1 1 0

然后又取两个 2 1 放下去

 1 #include <bits/stdc++.h>
 2 
 3 using namespace std;
 4 
 5 #define N 10010
 6 
 7 struct node
 8 {
 9     double a, s;
10     inline void scan()
11     {
12         scanf("%lf%lf", &a, &s);
13     }
14     inline bool operator < (const node &r) const
15     {
16         return a  > r.a;
17     }
18 }arr[N];
19 
20 int n;
21 
22 inline double work()
23 {
24     double res = 0;
25     double v = 0;
26     for (int i = 1; i <= n; ++i)
27     {
28         double t = arr[i].s;
29         res += v * t + arr[i].a * t * t / 2;
30         v += arr[i].a * t;
31     }
32     return res;
33 }
34 
35 int main()
36 {
37     while (scanf("%d", &n) != EOF)
38     {
39         for (int i = 1; i <= n; ++i) arr[i].scan();
40         double sum1 = work();
41         sort(arr + 1, arr + 1 + n);
42         double sum2 = work();
43 //        printf("%lf %lf\n", sum1, sum2);
44         printf("%.1f\n", sum2 - sum1);
45     }
46     return 0;
47 }
View Code

 

L：Divide and Conquer

留坑。

 

转载于:https://www.cnblogs.com/Dup4/p/9497946.html

banshen0201
关注
2017-2018 ACM-ICPC Southeastern European Regional Programming Contest (SEERC 2017)
wang_viscaria的博客
10-23 570
Rank Solved A B C D E F G H I J K L ?/? 7/12 O . . O . O O . . O O O O: 当场通过 Ø: 赛后通过 .: 尚未通过 A Concerts solved by chelly chelly’s solution B Bricks unsolved C Christmas Tree unsolved D Ha...
2017-2018 ACM-ICPC, NEERC, Southern Subregional Contest G. Orientation of Edges
mMingfunnyTree的博客
10-21 746
G. Orientation of Edges time limit per test3 seconds memory limit per test256 megabytes inputstandard input outputstandard output Vasya has a graph containing both directed (oriented) and undirect
ACM Southwestern European Regional Programming Contest (SWERC) 2017 A map+暴力
老铁,干了这碗algorithms的博客
01-27 470
//暴力+map的应用 #include #include #include #include using namespace std; typedef long long LL; const int maxn=2000+5; mapstr; int main() {     int n,m;     scanf("%d",&n);     scanf("%d",&m)
ACM Southwestern European Regional Programming Contest (SWERC) 2017 J 智商题(模m同余)
老铁,干了这碗algorithms的博客
01-28 488
点击打开链接 //模3同余即为同种颜色 //((a%c)+(b%c))%c==(a+b)%c #include #include #include using namespace std; typedef long long LL; const int maxn=1e5+5; LL a[3],b[3],c[3]; int main() { int n; while(scanf(
2017-2018 ACM-ICPC Southeastern European(SEERC 2017) A concerts
喵 喵 喵~
08-26 696
题目大意：字符串只由A~Z组成，给定s字符串长度k(k&amp;lt;=300)，p字符串长度是n(&amp;lt;=1e5)，再给定字母A~Z匹配成功后需要间隔的次数a[27]，再给出字符串s, p。求s匹配p的方案数 dp[i][j]:匹配到i位置时已经匹配了j个的方案数。 (1) s[j]==p[i]：dp[i][j] = dp[i-1][j] + dp[i-a[id]-1][j-1]; (2) s[...
2015-2016 ACM-ICPC Northeastern European Regional Contest 标程
08-23
2016 ACM-ICPC Northeastern European Regional Contest 标程" 提供的是一个编程竞赛的参考资料，这是一场由ACM（Association for Computing Machinery）主办的国际大学生程序设计竞赛（International Collegiate ...
Southeastern European Regional Programming Contest Bucharest, Romania – Vinnytsya, Ukraine Porblem J
weixin_43818893的博客
10-05 587
题目链接：https://codeforces.com/group/xrTA2IaQje/contest/255050 这是一个无效链接，当然如果咱们在一个学校那当咱没说，这是咱学校Group里的。 博弈论的题目，训练赛的时候我最后一个小时吭吃瘪肚的推了半天wa在test5上，无聊的分享一下手稿 题意：三人尼姆博弈，后俩人想置第一人于死地，而第一个人置之死地而后生。 题解：我先统计一下非1的数c...
Southeastern European Regional Programming Contest 2007 测试数据
10-13
【标题】"Southeastern European Regional Programming Contest 2007 测试数据"是指一场编程竞赛的测试数据集，这是2007年东南欧区域编程比赛的一部分。在这场比赛中，参赛者需要解决一系列的算法问题，而这些测试...
2008 SouthEastern European
02-17
2008 SouthEastern European
2017-2018 ACM-ICPC Southeast Regional Contest (Div. 1)
weixin_34387468的博客
11-18 249
A. Ducks in a Row 当$n\times k&gt;|S|$时，显然无解。 否则最优解中翻转的区间一定两两不相交，设$f[i][j][x][y]$表示考虑前$i$个位置，第$i$个位置翻转情况为$j$，当前连续段长度为$x$，已有$y$个长度至少为$n$的$D$连续段的最少翻转次数，然后转移即可。 时间复杂度$O(|S|^2)$。 #include&lt;cstdio&g...
题解：2017-2018 ACM-ICPC Southeastern European Regional Programming Contest (SEERC 2017)
wu-kan
10-21 950
Concerts 辣鸡数据范围。滚动DP。 #include&lt;bits/stdc++.h&gt; using namespace std; const int N=1e7+9,M=1e9+7; char a[N],b[N]; int n,k,f[2][N],h[127]; int main() { scanf("%d%d",&amp;k,&amp;n); for(char c='A'; ...
2018-2019 ACM-ICPC Southeastern European Regional Programming Contest (SEERC 2018) Solution
banshen0201的博客
12-02 413
A. Numbers Unsolved. B. Broken Watch Solved. 题意： 一个圆盘上，有等分的n块区域，有三根指针，当三根指针分别位于两块区域的交界处时 指针的三点相连会形成一个三角形，求有多少个三角包含三指针的起点（即交汇处） 思路： 1 #include<bits/stdc++.h> 2 3 using n...
2020-2021 ICPC Southeastern European Regional Programming Contest (SEERC 2020)
m0_46062697的博客
06-26 1477
B - Reverse Game Gym - 103102B、 博弈 #include<bits/stdc++.h> using namespace std; typedef unsigned long long ull; typedef long long LL; typedef pair<int,int> PII; const int mod=998244353; const int inf=0x3f3f3f3f; const double PI = acos...
(SWERC 2017)
海边拾贝，沧海一粟
11-20 681
文章目录2017-2018 ACM-ICPC Southwestern European Regional Programming Contest (SWERC 2017)训练 1AE Ingredients题意分析F Shattered Cake 2017-2018 ACM-ICPC Southwestern European Regional Programming Contest (S...
2018-2019 ACM-ICPC Southeastern European Regional (SEERC 2018) G - Matrix Queries (level 3)(线段树)
咸鱼有梦想
04-12 651
题目链接 题意: 给你一个(2^n)*(2^n)的矩阵，矩阵元素只有0，1两种颜色。 定义一个元素的价值是 1.如果一个矩阵都是一种颜色，那么他的价值为1 2.如果一个矩阵不纯色，那么他的价值是把他分成4个(2^(k-1))*(2^(k-1)) (假设原来的大小是(2^k)*(2^k))的矩阵的价值之和+1 然后有q个操作，一开始矩阵都是0颜色， 每一次操作，你需要把t=0,把第x...
Codeforces Round #698 (Div. 2)E. Nezzar and Binary String(线段树+离线+异或)
weixin_45722843的博客
06-18 138
Codeforces Round #698 (Div. 2)E. Nezzar and Binary String(线段树+离线+异或) 题意 给你两个01字符串，要求从第一个字符串转换成第二个字符串，并满足以下要求 每次给定一个检查区间，要求这个区间内必须是单一的0或1 你可以在检查之后偷偷修改严格小于区间一半的字符数 如果可以转换成功输出YES，否则输出NO 思路： 将检查区间，从后往前遍历，则，对于当前检查的区间，之前一定是全0或者全1，所以将当前检查区间和*2与区间长度作比较，若相等则输出NO，若小
2018-2019 ICPC Southwestern European Regional Programming Contest (SWERC 2018)(Gym102465)
micaudience的博客
05-08 1075
2018-2019 ICPC Southwestern European Regional Programming Contest (SWERC 2018)(Gym102465) C 题意：给两组字符串，填一个不大于4X4的网格，要求每一行（列）均选自对应组的字符串。 题解：将数量较多的一组字符串建Trie树，dfs较少的一组，并再Trie树上匹配。 #include<iostream&gt...
Day 19 B. Flip the Bits
Jackey_tao的博客
08-01 218
Problem: There is a binary string a of length n. In one operation, you can select any prefix of a with an equal number of 0 and 1 symbols. Then all symbols in the prefix are inverted: each 0 becomes 1 and each 1 becomes 0. For example, suppose a=0111010000
上海交大ACM-ICPC标准代码库：算法与数据结构
"上海交大ACM-ICPC模板是由上海交通大学计算机科学与工程系的Hao Yuan在2003年10月23日编写的，它包含了一个标准的代码库，专为参加ACM国际大学生程序设计竞赛（ACM-ICPC）的团队准备。这个模板涵盖了算法和数据结构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值