Hello2020（前四题题解）

Hello2020（前四题题解）

Hello，2020！新的一年从快乐的掉分开始……

我在m3.codeforces.com这个镜像网站中一开始还打不开D题，我……

还有话说今天这场为什么那么多二分。

比赛传送门：https://codeforces.com/contest/1284。

A. New Year and Naming

题目大意：这题就是一个干支纪年法。每年的名字分两段，第一段在n个字符串中取，第二段在m个字符串中取，每过一年就各取下一个，如果取到n（m）就去取第一个。

纯模拟，加上一点点字符串操作。

又丑又长的代码：

 #include <iostream>
 #include <cstdio>
 #include <algorithm>
 #include <cstring>
 #include <vector>
 #define rep(x, l, r) for(int x = l; x <= r; x++)
 #define repd(x, r, l) for(int x = r; x >= l; x--)
 #define clr(x, y) memset(x, y, sizeof(x))
 #define all(x) x.begin(), x.end()
 #define pb push_back
 #define mp make_pair
 #define MAXN 2005
 #define fi first
 #define se second
 #define SZ(x) ((int)x.size())
 using namespace std;
 typedef long long ll;
 typedef vector<int> vi;
 typedef pair<int, int> pii;
 const int INF =  << ;
 const int p = ;
 int lowbit(int x){ return x & (-x);}
 int fast_power(int a, int b){ int x; for(x = ; b; b >>= ){ if(b & ) x = 1ll * x * a % p; a = 1ll * a * a % p;} return x % p;}

 char st1[MAXN][], st2[MAXN][];

 int main(){
     int n, m;
     scanf("%d%d", &n, &m);
     rep(i, , n) scanf("%s", st1[i]);
     rep(i, , m) scanf("%s", st2[i]);
     int q;
     scanf("%d", &q);
     rep(i, , q){
         int x;
         scanf("%d", &x);
         int len = strlen(st1[(x - ) % n + ]);
         rep(j, , len - ) putchar(st1[(x - ) % n + ][j]);
         puts(st2[(x - ) % m + ]);
     }
     return ;
 }

-A

B.New Year and Ascent Sequence

题目大意：给你n个序列，每次取任意两个序列（可以取同一个，并且交换前后顺序算不同种）接起来（比如说‘11’和‘22’就是‘1122’）。问这n²个接成序列中共有多少个序列中存在顺序对。

不难看出，如果一个序列中本身存在顺序对，接成的序列也肯定存在顺序对。

判断方法

if(x > minx) flag = 1;

将它们找出来后直接统计入答案，套上一个小学学的容斥原理

ans = 1ll * 2 * cnt1 * n - 1ll * cnt1 * cnt1;

然后主要问题就是这些剩下的没有顺序对的序列。

很显然凡是最大值比这个序列最小值大的，就可以和这个序列接起来。

将最大值排序后二分一下最小的最大值就好。

代码如下

 #include <iostream>
 #include <cstdio>
 #include <algorithm>
 #include <cstring>
 #include <vector>
 #define rep(x, l, r) for(int x = l; x <= r; x++)
 #define repd(x, r, l) for(int x = r; x >= l; x--)
 #define clr(x, y) memset(x, y, sizeof(x))
 #define all(x) x.begin(), x.end()
 #define pb push_back
 #define mp make_pair
 #define MAXN 100005
 #define fi first
 #define se second
 #define SZ(x) ((int)x.size())
 using namespace std;
 typedef long long ll;
 typedef vector<int> vi;
 typedef pair<int, int> pii;
 const int INF =  << ;
 const int p = ;
 int lowbit(int x){ return x & (-x);}
 int fast_power(int a, int b){ int x; for(x = ; b; b >>= ){ if(b & ) x = 1ll * x * a % p; a = 1ll * a * a % p;} return x % p;}

 vi a, b;

 int main(){
     int n;
     scanf("%d", &n);
     int cnt1 = , cnt2 = ;
     rep(i, , n){
         int k;
         scanf("%d", &k);
         int minx = INF, maxx = -INF;
         bool flag = ;
         rep(j, , k){
             int x;
             scanf("%d", &x);
             if(x > minx) flag = ;
             minx = min(minx, x);
             maxx = max(maxx, x);
         }
         if(flag) cnt1++;
         else{
             cnt2++;
             a.pb(minx);
             b.pb(maxx);
         }
     }
     sort(all(b));
     ll ans = 1ll *  * cnt1 * n - 1ll * cnt1 * cnt1;
     rep(i, , SZ(b) - ){
         ans += cnt2 - (upper_bound(all(b), a[i]) - b.begin());
     }
     printf("%I64d\n", ans);
     return ;
 }

-B

C.New Year and Permutation

题目大意：在所有由[1，n]组成的排列中，有多少对数(l，r)满足max{p_l，p_l+1，…，p_r} - min{p_l，p_l+1，…，p_r} = r - l。

似乎解释的不是很清楚，再来个样例解释一下。

当n = 3时，所有的排列为[1，2，3]，[1，3，2]，[2，1，3]，[2，3，1]，[3，1，2]，[3，2，1]。

对于[1，2，3]：(1，1)中max = 1， min = 1， r - l = 0，成立；(1，3)中max = 3， min = 1， r - l = 2，成立。

对于[1，3，2]：(1，2)中max = 3， min = 1， r - l = 1，不成立。

别的懒得说了，原题样例说明有。

这道题一开始看的时候有点慌，浪费了好多时间。

后来一想，不就分别统计长度为i的子段满足条件。

我们可以很轻松的求出不同子段出现次数，所有该长度的子段出现次数为:

排列个数×每个排列中出现的次数 = n！×（n - i +1）

然后该长度不同子段的个数为n！/ (n - i)！，稍微证明一下或者列举几个便可以得出。

然后求所有符合条件的字段个数，(1，2，…，i ) 到（n - i + 1，n - i + 2，…， n ）一共有n - i + 1种，然后每种的排列有i！个。

所有长度为i的字段对答案的贡献 = 不同子段的出现个数 × 符合的长度为i子段的个数

= n！× (n - i + 1) / ( n！/ ( n - i )！) × ( n - i + 1 ) × i！

= ( n - i )！ × ( n - i + 1) × ( n - i +1 ) × i！

这个式子看上去挺好看的，然后求个总和就好。

代码特别短：

 #include <iostream>
 #include <cstdio>
 #include <algorithm>
 #include <cstring>
 #include <vector>
 #define rep(x, l, r) for(int x = l; x <= r; x++)
 #define repd(x, r, l) for(int x = r; x >= l; x--)
 #define clr(x, y) memset(x, y, sizeof(x))
 #define all(x) x.begin(), x.end()
 #define pb push_back
 #define mp make_pair
 #define MAXN 250005
 #define fi first
 #define se second
 #define SZ(x) ((int)x.size())
 using namespace std;
 typedef long long ll;
 typedef vector<int> vi;
 typedef pair<int, int> pii;
 const int INF =  << ;
 int p;
 int lowbit(int x){ return x & (-x);}
 int fast_power(int a, int b){ int x; for(x = ; b; b >>= ){ if(b & ) x = 1ll * x * a % p; a = 1ll * a * a % p;} return x % p;}

 int pow[MAXN];

 int main(){
     int n;
     scanf("%d%d", &n, &p);
     pow[] = ;
     rep(i, , n){
         pow[i] = 1ll * pow[i - ] * i % p;
     }
     int ans = ;
     rep(i, , n){
         int s = 1ll * pow[n - i] * (n - i + ) % p * (n - i + ) % p * pow[i] % p;
         ans = (ans + s) % p;
     }
     printf("%d\n", ans);
     return ;
 }

-C

D.New Year and Conference

题目大意：有n个人，每个人在a会场讲话开始时间为sa_i，结束时间为ea_i，在b会场开始时间为sb_i，结束时间为eb_i。是否存在一个集合中的人在a市场没有时间重叠在b市场有重叠或在b市场没有重叠在a市场有有重叠。设两个人开始结束时间分别为(u，v)和(x，y)，当max(x，u) <= min(y，v)时两人重叠。存在重叠时输出“NO”，否则输出“YES”（似乎有什么不对的地方）。

提前申明一下，这道题我自己代码一直过不了，但是群里有人按照我的解法过了……代码也差不多……

只WA了第10个点（加了个特判过了），现在对拍跑了2个半小时还没跑出一组错误数据……

我的解法甚是奇怪……

首先判断a会场不重叠b会场重叠的情况，发现我们对于每个人a会场只要判断左边不重叠的情况，右边的到时候会枚举到的。

对于i这个人，要是ea_j < sa_i，那么这两个人就不会重叠。

所以我们以sa_i为关键字进行排序，二分查找可以找出所有与i不重叠的人。

但是对每个人找他左边的人的区间肯定要超时，因为左边的人一定是从1开始的一个区间，我们记录下对于每个人i所有的以i为最右边的不重叠的人p_i,j。（即不存在一个人k使得ea_i < ea_k < sa_pi,j）

然后只需要判断b会场是否有重叠，也就是说对第i个人，所有他左边的不重叠人j的[sb_j，eb_j]这个区间是否和[sb_i，eb_i]有重合，变成了一个区间覆盖问题。

用线段树进行维护，将区间[sb_i，eb_i]更改为已覆盖，判断p_i中是否有点的讲话区间中有已覆盖的点。

对于另一种情况b会场不重叠a会场重叠情况和这个相同。

放上我的WA掉的代码（仅供参考，对着打出锅了别怪我）：

 #include <iostream>
 #include <cstdio>
 #include <algorithm>
 #include <cstring>
 #include <vector>
 #define rep(x, l, r) for(int x = l; x <= r; x++)
 #define repd(x, r, l) for(int x = r; x >= l; x--)
 #define clr(x, y) memset(x, y, sizeof(x))
 #define all(x) x.begin(), x.end()
 #define pb push_back
 #define mp make_pair
 #define MAXN 500005
 #define MAXM 2000005
 #define fi first
 #define se second
 #define SZ(x) ((int)x.size())
 using namespace std;
 typedef long long ll;
 typedef vector<int> vi;
 typedef pair<int, int> pii;
 const int INF =  << ;
 const int p = ;
 int lowbit(int x){ return x & (-x);}
 int fast_power(int a, int b){ int x; for(x = ; b; b >>= ){ if(b & ) x = 1ll * x * a % p; a = 1ll * a * a % p;} return x % p;}

 struct node1{
     int l1, r1, l2, r2;
 }a[MAXN];
 struct node2{
     int l, r;
     bool flag, tag;
 }tree[MAXM];
 bool ans;
 int num[MAXM];
 vi ve1[MAXN], ve2[MAXN];

 void pushup(int q){
     tree[q].flag = tree[q << ].flag || tree[q <<  | ].flag;
 }

 void pushdown(int q){
     if(!tree[q].tag) return;
     tree[q << ].flag = tree[q << ].tag = ;
     tree[q <<  | ].flag = tree[q <<  | ].tag = ;
     tree[q].tag = ;
 }

 void build(int q, int l, int r){
     tree[q].l = l;
     tree[q].r = r;
     tree[q].tag = ;
     tree[q].flag = ;
     if(l == r) return;
     int mid = (l + r) >> ;
     build(q << , l, mid);
     build(q <<  | , mid + , r);
     pushup(q);
 }

 void update(int q, int l, int r){
     if(tree[q].l > r || tree[q].r < l) return;
     if(tree[q].l >= l && tree[q].r <= r){
         tree[q].flag = ;
         tree[q].tag = ;
         return;
     }
     pushdown(q);
     update(q << , l, r);
     update(q <<  | , l, r);
     pushup(q);
 }

 void query(int q, int l, int r){
     if(tree[q].l > r || tree[q].r < l) return;
     if(tree[q].l >= l && tree[q].r <= r){
         ans = ans || tree[q].flag;
         return;
     }
     pushdown(q);
     query(q << , l, r);
     query(q <<  | , l, r);
     pushup(q);
 }

 bool cmp1(node1 a, node1 b){
     return a.r1 < b.r1;
 }

 bool cmp2(node1 a, node1 b){
     return a.r2 < b.r2;
 }

 int main(){
     int n, m = ;
     scanf("%d", &n);
     rep(i, , n){
         scanf("%d%d%d%d", &a[i].l1, &a[i].r1, &a[i].l2, &a[i].r2);
         num[++m] = a[i].l1;
         num[++m] = a[i].r1;
         num[++m] = a[i].l2;
         num[++m] = a[i].r2;
     }
     sort(num + , num + m + );
     rep(i, , n){
         a[i].l1 = lower_bound(num + , num + m + , a[i].l1) - num;
         a[i].r1 = lower_bound(num + , num + m + , a[i].r1) - num;
         a[i].l2 = lower_bound(num + , num + m + , a[i].l2) - num;
         a[i].r2 = lower_bound(num + , num + m + , a[i].r2) - num;
     }
     sort(a + , a + n + , cmp1);
     rep(i, , n){
         int l = , r = n, ans = ;
         while(l <= r){
             int mid = (l + r) >> ;
             if(a[mid].r1 < a[i].l1){
                 ans = mid;
                 l = mid + ;
             }
             else r = mid - ;
         }
         ve1[ans].pb(i);
     }
     build(, , m);
     rep(i, , n){
         update(, a[i].l2, a[i].r2);
         rep(j, , SZ(ve1[i]) - ){
             int x = ve1[i][j];
             ans = ;
             query(, a[x].l2, a[x].r2);
             if(ans){
                 puts("NO");
                 return ;
             }
         }
     }
     sort(a + , a + n + , cmp2);
     rep(i, , n){
         int l = , r = n, ans = ;
         while(l <= r){
             int mid = (l + r) >> ;
             if(a[mid].r2 < a[i].l2){
                 ans = mid;
                 l = mid + ;
             }
             r = mid - ;
         }
         ve2[ans].pb(i);
     }
     build(, , m);
     rep(i, , n){
         update(, a[i].l1, a[i].r1);
         rep(j, , SZ(ve2[i]) - ){
             int x = ve2[i][j];
             ans = ;
             query(, a[x].l1, a[x].r1);
             if(ans){
                 puts("NO");
                 return ;
             }
         }
     }
     puts("YES");
     return ;
 }

-D