Educational Codeforces Round 46 题解(前三题)

最新推荐文章于 2021-01-02 17:42:57 发布

onlysky_yy

最新推荐文章于 2021-01-02 17:42:57 发布

阅读量579

点赞数 1

分类专栏：做题笔记 codeforce codeforce 文章标签： coderforce edu round 46

本文链接：https://blog.csdn.net/qq_31964727/article/details/80837110

版权

做题笔记同时被 3 个专栏收录

13 篇文章 0 订阅

订阅专栏

codeforce

4 篇文章 0 订阅

订阅专栏

codeforce

3 篇文章 1 订阅

订阅专栏

Codehorses has just hosted the second Codehorses Cup. This year, the same as the previous one, organizers are giving T-shirts for the winners.

The valid sizes of T-shirts are either "M" or from $0$ to $3$ "X" followed by "S" or "L". For example, sizes "M", "XXS", "L", "XXXL"are valid and "XM", "Z", "XXXXL" are not.

There are $n$ winners to the cup for both the previous year and the current year. Ksenia has a list with the T-shirt sizes printed for the last year cup and is yet to send the new list to the printing office.

Organizers want to distribute the prizes as soon as possible, so now Ksenia is required not to write the whole list from the scratch but just make some changes to the list of the previous year. In one second she can choose arbitrary position in any word and replace its character with some uppercase Latin letter. Ksenia can't remove or add letters in any of the words.

What is the minimal number of seconds Ksenia is required to spend to change the last year list to the current one?

The lists are unordered. That means, two lists are considered equal if and only if the number of occurrences of any string is the same in both lists.

Input

The first line contains one integer $n$ ( $1 \leq n \leq 100$ ) — the number of T-shirts.

The $i$ -th of the next $n$ lines contains $a_{i}$ — the size of the $i$ -th T-shirt of the list for the previous year.

The $i$ -th of the next $n$ lines contains $b_{i}$ — the size of the $i$ -th T-shirt of the list for the current year.

It is guaranteed that all the sizes in the input are valid. It is also guaranteed that Ksenia can produce list $b$ from the list $a$ .

Output

Print the minimal number of seconds Ksenia is required to spend to change the last year list to the current one. If the lists are already equal, print 0.

   Examples 
 

     input 
    
      Copy 
    
3
XS
XS
M
XL
S
XS

     output 
    
      Copy 
    
2

     input 
    
      Copy 
    
2
XXXL
XXL
XXL
XXXS

     output 
    
      Copy 
    
1

     input 
    
      Copy 
    
2
M
XS
XS
M

     output 
    
      Copy 
    
0

Note

In the first example Ksenia can replace "M" with "S" and "S" in one of the occurrences of "XS" with "L".

In the second example Ksenia should replace "L" in "XXXL" with "S".

In the third example lists are equal.

题目分析:

第一眼看到多字符串,就想到字典树,故而套入字典树模版.

考虑数据量小故而改原本的标志末端的bool型end为int型num,表示当前剩余经过此结点的字符串数目

故而添加字符串时对经过的每个结点num++,

查询时就是返回目标串在字典树中的最大匹配长度,关键在于边查询边将经过的点num--,因此判断空时以为空或者num==0做判断.字符串需要change的字符个数就是字符串长度减去最大匹配长度.

这么做的优点在于利用字典树的同前缀特性利用贪心思想的同时不用去考虑该修改具体的前n个字符串中的哪个字符串.缺点是字典树26个分叉有点浪费.

ac代码:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
const int maxn=26; //这里假设字符串中只出现26个小写字母 
const int maxm=100000;
struct treenode{
	int num; 
	treenode* next[maxn]; 
}head;
 
treenode memory[maxm];
int mallocp=0;
 
void init(){
	head.num=1;
	for(int i=0;i<maxn;i++) head.next[i]=NULL;
}
 
treenode* createnew(){
	treenode* newnode;
	newnode=&memory[mallocp++];
	newnode->num=0;
	for(int i=0;i<maxn;i++) newnode->next[i]=NULL;
	return newnode;
}
 
void update(char* s){
	int k=0,temp;
	treenode* t=&head;
	while(s[k]){
		temp=s[k]-'A';
		if(!t->next[temp]) t->next[temp]=createnew(); 
		t=t->next[temp];
		t->num++;
		k++;
	}
}
 
int search(char* s){
	int k=0;
	treenode* t=&head;
	while(s[k]){
		int temp=s[k]-'A';
		if(NULL==t->next[temp]||0==t->next[temp]->num) return k;
		t=t->next[temp];
		t->num--;
		k++;
	}
	return k; 
}
 
int main(){
	init();
	char x[1000];
	int n;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%s",&x);
		update(x);
	}
	int ans=0;
	for(int i=0;i<n;i++){
		scanf("%s",&x);
		ans+=strlen(x);
		ans-=search(x);
	}
	printf("%d\n",ans);
	return 0;
}

Recently, you bought a brand new smart lamp with programming features. At first, you set up a schedule to the lamp. Every day it will turn power on at moment $0$ and turn power off at moment $M$ . Moreover, the lamp allows you to set a program of switching its state (states are "lights on" and "lights off"). Unfortunately, some program is already installed into the lamp.

The lamp allows only good programs. Good program can be represented as a non-empty array $a$ , where $0 < a_{1} < a_{2} < \dots < a_{| a |} < M$ . All $a_{i}$ must be integers. Of course, preinstalled program is a good program.

The lamp follows program $a$ in next manner: at moment $0$ turns power and light on. Then at moment $a_{i}$ the lamp flips its state to opposite (if it was lit, it turns off, and vice versa). The state of the lamp flips instantly: for example, if you turn the light off at moment $1$ and then do nothing, the total time when the lamp is lit will be $1$ . Finally, at moment $M$ the lamp is turning its power off regardless of its state.

Since you are not among those people who read instructions, and you don't understand the language it's written in, you realize (after some testing) the only possible way to alter the preinstalled program. You can insert at most one element into the program $a$ , so it still should be a good program after alteration. Insertion can be done between any pair of consecutive elements of $a$ , or even at the begining or at the end of $a$ .

Find such a way to alter the program that the total time when the lamp is lit is maximum possible. Maybe you should leave program untouched. If the lamp is lit from $x$ till moment $y$ , then its lit for $y - x$ units of time. Segments of time when the lamp is lit are summed up.

Input

First line contains two space separated integers $n$ and $M$ ( $1 \leq n \leq 10^{5}$ , $2 \leq M \leq 10^{9}$ ) — the length of program $a$ and the moment when power turns off.

Second line contains $n$ space separated integers $a_{1}, a_{2}, \dots, a_{n}$ ( $0 < a_{1} < a_{2} < \dots < a_{n} < M$ ) — initially installed program $a$ .

Output

Print the only integer — maximum possible total time when the lamp is lit.

   Examples 
 
     input 
    
      Copy 
    
3 10
4 6 7

     output 
    
      Copy 
    
8

     input 
    
      Copy 
    
2 12
1 10

     output 
    
      Copy 
    
9

     input 
    
      Copy 
    
2 7
3 4

     output 
    
      Copy 
    
6

Note

In the first example, one of possible optimal solutions is to insert value $x = 3$ before $a_{1}$ , so program will be $[3, 4, 6, 7]$ and time of lamp being lit equals $(3 - 0) + (6 - 4) + (10 - 7) = 8$ . Other possible solution is to insert $x = 5$ in appropriate place.

In the second example, there is only one optimal solution: to insert $x = 2$ between $a_{1}$ and $a_{2}$ . Program will become $[1, 2, 10]$ , and answer will be $(1 - 0) + (10 - 2) = 9$ .

In the third example, optimal answer is to leave program untouched, so answer will be $(3 - 0) + (7 - 4) = 6$ .

题目分析:

我们需要先将输入的n个数据转化为

a1-0,a2-a1,a3-a2,a4-a3...... m-an 这么n+1个数

然后我们要做的其实就是将这n+1个数其中某个大于1的数分解为两个大于等于1的数,或者选择不分解

而具体分解哪个要看哪种分解最终灯亮的时间最长,而灯亮时间其实就是下标为偶数的数的和,然而某个数分解为两个数会导致这个数后面部分原来是偶数的变成奇数,故而答案会截然不同,我们要克服的就是这个问题.

我选择的是先转化好n+1个数存进a数组,建立all数组,b数组,然后叠加法求出第i个下标位置时a0到ai的总和,以及i位置和它之前的灯亮时间总和

为了考虑到不做变化的情况,maxans初值为n+1个数的灯亮时间总和,然后就开始线性递推,寻找最大的答案

maxans=std::max(maxans,b[i]-1+all[n]-all[i]-b[n]+b[i]);

我解释一下这个公式,其实被分解的数无论是下标是奇数还是偶数,奇数分解为1,x-1,偶数分解为x-1,1就好了,故而前i个数包括第i个本身的灯亮时间为b[i]-1,而all[n]-all[i]-b[n]+b[i]实际为all[n]-all[i]-(b[n]-b[i]),其实就是求出了后半段中原来下标为奇数的和,现在前面因为分解多了一个数,故而他们下标都加1,成为了被点亮的偶数下标,

ac代码:

#include <iostream>
#include <stdio.h>
#include <algorithm>

using namespace std;
typedef long long ll;
const int maxn=100005;

ll a[maxn],b[maxn],all[maxn];
void solve(){
	int n,m;
	scanf("%d%d",&n,&m);
	ll t1=0,t2;
	for(int i=0;i<n;i++){
		scanf("%lld",&t2);
		a[i]=t2-t1;
		t1=t2;
	}
	a[n]=m-t2;
	ll sum=0;
	for(int i=0;i<=n;i++){
		if(i%2==0) sum+=a[i];
		all[i]=all[i-1]+a[i];
		b[i]=sum; 
	}
	ll maxans=sum;
	for(int i=0;i<=n;i++){
		maxans=std::max(maxans,b[i]-1+all[n]-all[i]-b[n]+b[i]);
	}
	printf("%lld",maxans);
}


int main(){
	solve();
	return 0;
}

C. Covered Points Count

You are given $n$ segments on a coordinate line; each endpoint of every segment has integer coordinates. Some segments can degenerate to points. Segments can intersect with each other, be nested in each other or even coincide.

Your task is the following: for every $k \in [1.. n]$ , calculate the number of points with integer coordinates such that the number of segments that cover these points equals $k$ . A segment with endpoints $l_{i}$ and $r_{i}$ covers point $x$ if and only if $l_{i} \leq x \leq r_{i}$ .

Input

The first line of the input contains one integer $n$ ( $1 \leq n \leq 2 \cdot 10^{5}$ ) — the number of segments.

The next $n$ lines contain segments. The $i$ -th line contains a pair of integers $l_{i}, r_{i}$ ( $0 \leq l_{i} \leq r_{i} \leq 10^{18}$ ) — the endpoints of the $i$ -th segment.

Output

Print $n$ space separated integers $c n t_{1}, c n t_{2}, \dots, c n t_{n}$ , where $c n t_{i}$ is equal to the number of points such that the number of segments that cover these points equals to $i$ .

Note

The picture describing the first example:

$\text{[math]}$

Points with coordinates $[0, 4, 5, 6, 7, 8]$ are covered by one segment, points $[1, 2]$ are covered by two segments and point $[3]$ is covered by three segments.

The picture describing the second example:

$\text{[math]}$

Points $[1, 4, 5, 6, 7]$ are covered by one segment, points $[2, 3]$ are covered by two segments and there are no points covered by three segments.

题目分析:

这道题就是给我们n条数轴上的线段让我们回答只被1条线覆盖的端点有多少,被2条线覆盖的端点有多少...只被n条线覆盖的有多少.

我们发现实际上我们不用逐个点去判断,所有的点被这n条线段的2*n个端点切割成了许多段,而每一段内的经过的线的条数在这个小段内是相同的,故而我们可以将所有线段的端点排序,排序后相邻两端点之间的一段线段a上面的所有点被覆盖的线段条数当然就是相同的了,然后将这线段a上点的数目加到对应的答案里.

核心思维就是上面这样子,排序用sort复杂度n*logn,求答案复杂度只为n,完全可以接受.

最关键的难点其实在于每个端点的处理,因为多线段端点可能重复,而线段又是闭区间,故而经过某端点的线段条数只有等到新端点开始计算时再计算老端点是最稳妥的,因为此时重复点都已经处理了.

ac代码:

#include <iostream>
#include <stdio.h>
#include <algorithm>

using namespace std;
typedef long long ll;
typedef pair<ll,int> pali;

const int maxn=100005;

pali a[4*maxn];
ll num[4*maxn];
void solve(){
	int n;
	scanf("%d",&n);
	ll t1,t2;
	for(int i=0;i<n;i++){
		scanf("%lld%lld",&t1,&t2);
		a[2*i]=make_pair(t1,0); //second为0表示为线段起点,1表示终点 
		a[2*i+1]=make_pair(t2,1);
	} 
	sort(a,a+2*n);
	
	ll now=0,lastpos=-1,temp=0;
	//now表示当前经过此端点的线段条数
	//lastpos表示上一个端点的位置
	//temp表示上一个端点上被删除的线段终点数目 
	//可以看出,我们把端点与线段中央是分开算的 
	for(int i=0;i<2*n;i++) num[i]=0;
	for(int i=0;i<2*n;i++){
		if(a[i].first>lastpos){ //以新点的接入做触发,将之前的答案统计一下 
			num[now+temp]++,temp=0;  		//前一个端点 
			num[now]+=a[i].first-lastpos-1; //此端点到前一个端点间线段上的点 
			lastpos=a[i].first;
		}
		if(a[i].second){
			temp++;
			now--; 
		}
		else now++;  
	}
	num[now+temp]++; //最后一个端点的收尾
	printf("%lld",num[1]);
	for(int i=2;i<=n;i++) printf(" %lld",num[i]); 
}


int main(){
	solve();
	return 0;
}

onlysky_yy

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Educational Codeforces Round 46 题解(前三题)

A. Codehorses T-shirtstime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputCodehorses has just hosted the second Codehorses Cup. This year, the same as...
复制链接

扫一扫