Educational Codeforces Round 45 (Rated for Div. 2)题解（a－e）

Berland Football Cup starts really soon! Commentators from all over the world come to the event.

Organizers have already built $n$ commentary boxes. $m$ regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.

If $n$ is not divisible by $m$ , it is impossible to distribute the boxes to the delegations at the moment.

Organizers can build a new commentary box paying $a$ burles and demolish a commentary box paying $b$ burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.

What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by $m$ )?

Input

The only line contains four integer numbers $n$ , $m$ , $a$ and $b$ ( $1 \leq n, m \leq 10^{12}$ , $1 \leq a, b \leq 100$ ), where $n$ is the initial number of the commentary boxes, $m$ is the number of delegations to come, $a$ is the fee to build a box and $b$ is the fee to demolish a box.

Output

Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by $m$ ). It is allowed that the final number of the boxes is equal to $0$ .

    Examples 
  
      input 
     
       Copy 
     
9 7 3 8

      output 
     
       Copy 
     
15

      input 
     
       Copy 
     
2 7 3 7

      output 
     
       Copy 
     
14

      input 
     
       Copy 
     
30 6 17 19

      output 
     
       Copy 
     
0

Note

In the first example organizers can build $5$ boxes to make the total of $14$ paying $3$ burles for the each of them.

In the second example organizers can demolish $2$ boxes to make the total of $0$ paying $7$ burles for the each of them.

In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get $5$ boxes.

#include <iostream>
#define ll long long
using namespace std;
int main()
{
    ll n,m,a,b;
    cin>>n>>m>>a>>b;//a -> +
    if(n<m)
    {
        ll s1=(m-n)*a;
        ll s2=n*b;
        cout<<min(s1,s2)<<endl;
    }
    else if(n%m==0)
    {
        cout<<0<<endl;
    }
    else
    {
        ll s1,s2;
        ll k=n/m;
        ll dif1=n-k*m;
        s1=dif1*b;
        ll dif2=(k+1)*m-n;
        s2=dif2*a;
        cout<<min(s1,s2)<<endl;

    }

    return 0;
}

模拟，注意n<m时注意有可以将n砍到0强行平均的方法，n> m的时候往两边两种做法比较一下就ok

You have a Petri dish with bacteria and you are preparing to dive into the harsh micro-world. But, unfortunately, you don't have any microscope nearby, so you can't watch them.

You know that you have $n$ bacteria in the Petri dish and size of the $i$ -th bacteria is $a_{i}$ . Also you know intergalactic positive integer constant $K$ .

The $i$ -th bacteria can swallow the $j$ -th bacteria if and only if $a_{i} > a_{j}$ and $a_{i} \leq a_{j} + K$ . The $j$ -th bacteria disappear, but the $i$ -th bacteria doesn't change its size. The bacteria can perform multiple swallows. On each swallow operation any bacteria $i$ can swallow any bacteria $j$ if $a_{i} > a_{j}$ and $a_{i} \leq a_{j} + K$ . The swallow operations go one after another.

For example, the sequence of bacteria sizes $a = [101, 53, 42, 102, 101, 55, 54]$ and $K = 1$ . The one of possible sequences of swallows is: $[101, 53, 42, 102, 101 - -- -, 55, 54]$ $\to$ $[101, 53 - - -, 42, 102, 55, 54]$ $\to$ $[101 - -- -, 42, 102, 55, 54]$ $\to$ $[42, 102, 55, 54 - - -]$ $\to$ $[42, 102, 55]$ . In total there are $3$ bacteria remained in the Petri dish.

Since you don't have a microscope, you can only guess, what the minimal possible number of bacteria can remain in your Petri dish when you finally will find any microscope.

Input

The first line contains two space separated positive integers $n$ and $K$ ( $1 \leq n \leq 2 \cdot 10^{5}$ , $1 \leq K \leq 10^{6}$ ) — number of bacteria and intergalactic constant $K$ .

The second line contains $n$ space separated integers $a_{1}, a_{2}, \dots, a_{n}$ ( $1 \leq a_{i} \leq 10^{6}$ ) — sizes of bacteria you have.

Output

Print the only integer — minimal possible number of bacteria can remain.

     Examples 
   
       input 
      
        Copy 
      
7 1
101 53 42 102 101 55 54

       output 
      
        Copy 
      
3

       input 
      
        Copy 
      
6 5
20 15 10 15 20 25

       output 
      
        Copy 
      
1

       input 
      
        Copy 
      
7 1000000
1 1 1 1 1 1 1

       output 
      
        Copy 
      
7

Note

The first example is clarified in the problem statement.

In the second example an optimal possible sequence of swallows is: $[20, 15, 10, 15, 20 - - -, 25]$ $\to$ $[20, 15, 10, 15 - - -, 25]$ $\to$ $[20, 15, 10 - - -, 25]$ $\to$ $[20, 15 - - -, 25]$ $\to$ $[20 - - -, 25]$ $\to$ $[25]$ .

In the third example no bacteria can swallow any other bacteria.

模拟 stl乱搞这里用map当作一个计数set用，second变量统计first出现了几次。

根据题意推一下aj的范围是 [ai-k,ai) lower_ bound找一下，用erase的第三种用法，删除这个区间的数据即可
最后算结果的时候要乘上first出现的次数，就是second

stl真好用（笑）

#include <iostream>
#include <set>
#include <map>
using namespace std;
#define ll long long
map<int,int>s;
map<int,int>::iterator iter;
map<int,int>::iterator iter1;
//set<int>::iterator left;
//set<int>::iterator right;
//int a[200005];
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	int n,k;
	int t;
	cin>>n>>k;
	for(int i=1;i<=n;i++)
	{
		cin>>t;
		s[t]++;
	}
	map<int,int>::iterator left;
	map<int,int>::iterator right;
	for(iter=s.begin();iter!=s.end();iter++)
	{
		left=s.lower_bound(iter->first-k);//第一个大于等于的
		//cout<<left->first<<' ';
		right=iter;
		//cout<<right<<' ';
		s.erase(left,right);//erase的第三种用法：传入两个iterator参数，删除这两个迭代器左闭右开区间内的数据
	}
	int sum=0;
	for(iter=s.begin();iter!=s.end();iter++)
	{
		sum+=(iter->second);
	}

	cout<<sum<<endl;

	return 0;
}

A bracket sequence is a string containing only characters "(" and ")".

A regular bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()()", "(())" are regular (the resulting expressions are: "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.

You are given $n$ bracket sequences $s_{1}, s_{2}, \dots, s_{n}$ . Calculate the number of pairs $i, j (1 \leq i, j \leq n)$ such that the bracket sequence $s_{i} + s_{j}$ is a regular bracket sequence. Operation $+$ means concatenation i.e. "()(" + ")()" = "()()()".

If $s_{i} + s_{j}$ and $s_{j} + s_{i}$ are regular bracket sequences and $i \neq j$ , then both pairs $(i, j)$ and $(j, i)$ must be counted in the answer. Also, if $s_{i} + s_{i}$ is a regular bracket sequence, the pair $(i, i)$ must be counted in the answer.

Input

The first line contains one integer $n (1 \leq n \leq 3 \cdot 10^{5})$ — the number of bracket sequences. The following $n$ lines contain bracket sequences — non-empty strings consisting only of characters "(" and ")". The sum of lengths of all bracket sequences does not exceed $3 \cdot 10^{5}$ .

Output

In the single line print a single integer — the number of pairs $i, j (1 \leq i, j \leq n)$ such that the bracket sequence $s_{i} + s_{j}$ is a regular bracket sequence.

    Examples 
  
      input 
     
       Copy 
     
3
)
()
(

      output 
     
       Copy 
     
2

      input 
     
       Copy 
     
2
()
()

      output 
     
       Copy 
     
4

Note

In the first example, suitable pairs are $(3, 1)$ and $(2, 2)$ .

In the second example, any pair is suitable, namely $(1, 1), (1, 2), (2, 1), (2, 2)$ .

#include<cstdio>
#include<iostream>
#define maxn 300005
using namespace std;
int fl[maxn],fr[maxn];
int l[maxn],r[maxn];
long long ans = 0;
int main()
{
	ios::sync_with_stdio(false);
	int n;
	cin>>n;
	string s;
	for(int i=1;i<=n;i++)
	{
		cin>>s;
		int x = 0,y = 0;//x记录左括号的数量，y记录右括号的数量
		for(int j=0;j<s.size();j++)
		{
			if(s[j]=='(')	x++;
			if(s[j]==')')	if(x!=0)	x--;else y++;//判断是否抵消
		}//模拟删除操作
		//getchar();
		l[i] = y , r[i] = x;
	}

	for(int i=1;i<=n;i++)
	{
		int nowl = l[i],nowr = r[i];
		if(nowl&&nowr)	
		{
			continue;//非法
		}
		if(nowl==0)
		{
			ans+=fl[nowr];
			fr[nowr]++;
		}
		if(nowr==0)		
		{
			ans+=fr[nowl];
			fl[nowl]++;
		}
	}
	cout<<ans<<endl;
	
	return 0;
}

这题当时有点钻牛角尖了，stl乱搞失败，当时的想法是先找（），不断用erase的第二种用法删除（），最后计数之后放进两个map里，复杂度大概O(nlog(n)) tle gg

后来的想法直接数组模拟了，前面的操作差不多，记数模拟删除，后面的操作O(n)解决。

我们用fl和fr数组来存储当前出现的经过处理后的字符串的数量记录当前字符串的情况，比如剩下((，那就fl[2]++ 。

假如当前这个字符串处理后剩下 )))，那么和它配对的就是(((，那么最终结果就要加上 (1*fl[3])，并且把fr[3]++;

ps：这种做法可以不用考虑括号平衡的情况，含在里面了。

Given three numbers $n, a, b$ . You need to find an adjacency matrix of such an undirected graph that the number of components in it is equal to $a$ , and the number of components in its complement is $b$ . The matrix must be symmetric, and all digits on the main diagonal must be zeroes.

In an undirected graph loops (edges from a vertex to itself) are not allowed. It can be at most one edge between a pair of vertices.

The adjacency matrix of an undirected graph is a square matrix of size $n$ consisting only of "0" and "1", where $n$ is the number of vertices of the graph and the $i$ -th row and the $i$ -th column correspond to the $i$ -th vertex of the graph. The cell $(i, j)$ of the adjacency matrix contains $1$ if and only if the $i$ -th and $j$ -th vertices in the graph are connected by an edge.

A connected component is a set of vertices $X$ such that for every two vertices from this set there exists at least one path in the graph connecting this pair of vertices, but adding any other vertex to $X$ violates this rule.

The complement or inverse of a graph $G$ is a graph $H$ on the same vertices such that two distinct vertices of $H$ are adjacent if and only if they are not adjacent in $G$ .

Input

In a single line, three numbers are given $n, a, b (1 \leq n \leq 1000, 1 \leq a, b \leq n)$ : is the number of vertexes of the graph, the required number of connectivity components in it, and the required amount of the connectivity component in it's complement.

Output

If there is no graph that satisfies these constraints on a single line, print "NO" (without quotes).

Otherwise, on the first line, print "YES"(without quotes). In each of the next $n$ lines, output $n$ digits such that $j$ -th digit of $i$ -th line must be $1$ if and only if there is an edge between vertices $i$ and $j$ in $G$ (and $0$ otherwise). Note that the matrix must be symmetric, and all digits on the main diagonal must be zeroes.

If there are several matrices that satisfy the conditions — output any of them.

    Examples 
  
      input 
     
       Copy 
     
3 1 2

      output 
     
       Copy 
     
YES
001
001
110

      input 
     
       Copy 
     
3 3 3

      output 
     
       Copy 
     
NO

简单构造题，失策了，应该跳过c做d的。

题意：给你n,a,b n代表有n个顶点的图，原图中有a个连通块，它的补图中有b个连通块。（离散真好用）

画图推了个结论：除了n＝1以外，其他的原图和补图间肯定存在一个必定全连通，因为完全图的威力是很大的。

继续往细里推：1<=n<=3的时候，a和b不可能全为1，其他情况可能出现全为1的情况

接下来就是构造了，假如a!=1 ,就需要构造a个连通块的图的邻接矩阵，最容易想到的情况是有(a-1)个孤立顶点，剩下的n-(a-1)个顶点连通，直接一条线连过去就ok，注意无向图邻接矩阵对称。

如果b!=1，我们就构造这个图的补图，方法同上，输出的时候用！输出其反，特判主对角线为0

#include <algorithm>
#include<cstdio>
#include <cstring>
#include <iostream>
#define ll long long
#define maxn 300005
using namespace std;
int main()
{
	ios::sync_with_stdio(false);
	cout.tie(0);
	cin.tie(0);
	int n,a,b;
	cin>>n>>a>>b;
	bool map[n+1][n+1];
	memset(map,0,sizeof(map));
	if(a!=1&&b!=1)
	{
		cout<<"NO"<<endl;
		return 0;
	}
	if(a!=1)//构造一个联通量为a的邻接矩阵 总共a－1个孤立顶点，剩下n-(a-1)个顶点连通
	{
		cout<<"YES"<<endl;
		for(int i=1;i<n-(a-1);i++)
		{
			map[i][i+1]=1;
			map[i+1][i]=1;//直接构造成线型的
		}
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=n;j++)
			{
				cout<<map[i][j];
			}
			cout<<endl;
		}
	}
	else if(b!=1)//构造一个联通量b的邻接矩阵 总共b－1个孤立顶点，剩下n-(a-1)个顶点连通
	{
		cout<<"YES"<<endl;
		for(int i=1;i<n-(b-1);i++)
		{
			map[i][i+1]=1;
			map[i+1][i]=1;//直接构造成线型的
		}
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=n;j++)
			{
				if(i!=j)cout<<!map[i][j];
				else cout<<0;
			}
			cout<<endl;
		}
	}
	else if(a==1&&b==1)
	{
		if(n==1)
		{
			cout<<"YES"<<endl;
			cout<<0<<endl;
		}
		else if(n<=3) cout<<"NO"<<endl;
		else//构造一个联通图
		{
			cout<<"YES"<<endl;
			for(int i=1;i<n;i++)
			{
				map[i][i+1]=1;
				map[i+1][i]=1;
			}
			for(int i=1;i<=n;i++)
			{
				for(int j=1;j<=n;j++)
				{
					cout<<map[i][j];
				}
				cout<<endl;
			}
		}
	}
	return 0;
}

Adilbek's house is located on a street which can be represented as the OX axis. This street is really dark, so Adilbek wants to install some post lamps to illuminate it. Street has $n$ positions to install lamps, they correspond to the integer numbers from $0$ to $n - 1$ on the OX axis. However, some positions are blocked and no post lamp can be placed there.

There are post lamps of different types which differ only by their power. When placed in position $x$ , post lamp of power $l$ illuminates the segment $[x; x + l]$ . The power of each post lamp is always a positive integer number.

The post lamp shop provides an infinite amount of lamps of each type from power $1$ to power $k$ . Though each customer is only allowed to order post lamps of exactly one type. Post lamps of power $l$ cost $a_{l}$ each.

What is the minimal total cost of the post lamps of exactly one type Adilbek can buy to illuminate the entire segment $[0; n]$ of the street? If some lamps illuminate any other segment of the street, Adilbek does not care, so, for example, he may place a lamp of power $3$ in position $n - 1$ (even though its illumination zone doesn't completely belong to segment $[0; n]$ ).

Input

The first line contains three integer numbers $n$ , $m$ and $k$ ( $1 \leq k \leq n \leq 10^{6}$ , $0 \leq m \leq n$ ) — the length of the segment of the street Adilbek wants to illuminate, the number of the blocked positions and the maximum power of the post lamp available.

The second line contains $m$ integer numbers $s_{1}, s_{2}, \dots, s_{m}$ ( $0 \leq s_{1} < s_{2} < \dots s_{m} < n$ ) — the blocked positions.

The third line contains $k$ integer numbers $a_{1}, a_{2}, \dots, a_{k}$ ( $1 \leq a_{i} \leq 10^{6}$ ) — the costs of the post lamps.

Output

Print the minimal total cost of the post lamps of exactly one type Adilbek can buy to illuminate the entire segment $[0; n]$ of the street.

If illumintaing the entire segment $[0; n]$ is impossible, print -1.

题意：一条街道[0,n]，第i个灯可以照亮[m,m+i] 这片区域（m任取），费用为ai，block点不能放灯。

贪心题，从0开始放，然后跳到下一个放灯点，如果这个点block了，就退到最近的没有被block的点，如果相隔大于等于i就gg

#include <algorithm>
#include<cstdio>
#include <cstring>
#include <iostream>
#define ll long long
const ll inf=(ll)1e18+7;
using namespace std;
int a[1000005];
int near[1000005];
int main()
{
	ios::sync_with_stdio(false);
	cout.tie(0);cin.tie(0);
	int n,m,k;
	cin>>n>>m>>k;
	bool block[n];
	memset(block,0,sizeof(block));
	int t;
	for(int i=1;i<=m;i++)
	{
		cin>>t;
		block[t]=1;
	}
	if(block[0])
	{
		cout<<-1<<endl;
		return 0;
	}
	for(int i=1;i<n;i++)//递推找出当前点向前推最近的点（如果这个点是block点的话）
	{
		if(!block[i]) near[i]=i;
		else near[i]=near[i-1];
	}
	ll res=inf;
	for(int i=1;i<=k;i++)
	{
		cin>>a[i];
	}
	for(int i=1;i<=k;i++)
	{
		bool flag=0;
		int now=0;
		int cnt=0;//统计循环次数
		while(1)
		{
			cnt++;
			if(now+i>=n)
			{
				break;
			}
			else if(near[now+i]==near[now])//无法全部照亮 gg
			{
				flag=1;
				break;
			}
			now=near[now+i];
		}
		if(flag==0)
		{
			res=min(res,1ll*cnt*1ll*a[i]);
		}
	}

	if(res>=1e18)
	{
		cout<<-1<<endl;
	}
	else
	{
		cout<<res<<endl;
	}

	return 0;
}

Educational Codeforces Round 45 (Rated for Div. 2)题解（a－e）

猜你喜欢