Educational Codeforces Round 46 (Rated for Div. 2) C - Covered Points Count

C. Covered Points Count
time limit per test
3 seconds
memory limit per test
256 megabytes
input
standard input
output
standard output

You are given nn 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[1..n]k∈[1..n], calculate the number of points with integer coordinates such that the number of segments that cover these points equals kk. A segment with endpoints lili and riri covers point xx if and only if lixrili≤x≤ri.

Input

The first line of the input contains one integer nn (1n21051≤n≤2⋅105) — the number of segments.

The next nn lines contain segments. The ii-th line contains a pair of integers li,rili,ri (0liri10180≤li≤ri≤1018) — the endpoints of the ii-th segment.

Output

Print nn space separated integers cnt1,cnt2,,cntncnt1,cnt2,…,cntn, where cnticnti is equal to the number of points such that the number of segments that cover these points equals to ii.

Examples
input
Copy
3
0 3
1 3
3 8
output
Copy
6 2 1 
input
Copy
3
1 3
2 4
5 7
output
Copy
5 2 0 
Note

The picture describing the first example:

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

The picture describing the second example:

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

#include<bits/stdc++.h>

using namespace std;

const int MAXN = 200000 + 10;
struct f
{
	long long head;
	int shu;
}a[2 * MAXN];
long long mark[MAXN];

int com(const f &u , const f &v)
{
	if(u.head == v.head)
		return u.shu > v.shu;
	return u.head < v.head;
}

int main()
{
	int n;
	cin >> n;
	int num = 0;
	for(int i = 1; i <= n * 2; i ++)
	{
		cin >> a[i].head;
		if(i & 1)
			a[i].shu = 1;
		else
			a[i].shu = 0;
	}
	//a[n + 1].head = a[n + 1].tail = 1e18 + 1;
	//cout << endl;
	sort( a + 1, a + 2 * n + 1, com);
	//for(int i = 1 ; i <= 2 * n ; i ++)
	//	cout << a[i].head << " " << a[i].shu << endl;
	//cout << endl;
	int  temp ;
	long long  f = 0;
	for(int i = 1 ; i <= n * 2; i ++)
	{
		//mark[num] += a[i].head - a[i - 1].head;
		if(a[i].shu == 1)
		{
			if(a[i].head - f - 1 >=0)
				mark[num] += a[i].head - f - 1;
			f = a[i].head;
			temp = i;
			int t = num;
			//cout << "!" << " " << t << endl;
			while(a[temp].head == a[temp + 1].head && temp + 1 <= n * 2)
			{
				//cout << a[temp + 1].shu << endl;


				//t ++;
				if(a[temp + 1].shu > 0)
				{
					num ++;
					t ++;
					//cout << "!" << endl;
				}
					//num ++;
				else
					num --;
				temp ++;
			}
			//cout << t << endl;
			num ++;
			t ++;
			//cout << num << " " << t << endl;
			mark[t] ++;
			i += (temp - i);
			//for(int j = 1; j <= 3 ; j ++)
			//	cout << mark[j] << " ";
			//cout << endl;
		}
		else
		{
			if(a[i].head - f - 1 >= 0)
				mark[num] += a[i].head - f - 1;
			f = a[i].head;
			int t = num ;
			temp = i;
			while(a[temp].head == a[temp + 1].head && temp + 1 <= n * 2)
			{
				if(a[temp + 1].shu > 0)
				{
					num ++;
					t ++;
				}
				//	num ++;
				else
					num --;
				temp ++;
			}
			//cout << num << " " << t << endl;
			mark[t] ++ ;
			num --;

			//for(int j = 1 ; j <= 3; j ++)
			//	cout << mark[j] << " ";
			//cout << endl;
			i += (temp - i) ;
		}
	}
	cout << mark[1];
	for(int i = 2; i <= n ; i ++)
		cout << " " << mark[i];
	return 0;
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于LSTM的财务因子预测选股模型LSTM (Long Short-Term Memory) 是一种特殊的循环神经网络(RNN)架构,用于处理具有长期依赖关系的序列数据。传统的RNN在处理长序列时往往会遇到梯度消失或梯度爆炸的问题,导致无法有效地捕捉长期依赖。LSTM通过引入门控机制(Gating Mechanism)和记忆单元(Memory Cell)来克服这些问题。 以下是LSTM的基本结构和主要组件: 记忆单元(Memory Cell):记忆单元是LSTM的核心,用于存储长期信息。它像一个传送带一样,在整个链上运行,只有一些小的线性交互。信息很容易地在其上保持不变。 输入门(Input Gate):输入门决定了哪些新的信息会被加入到记忆单元中。它由当前时刻的输入和上一时刻的隐藏状态共同决定。 遗忘门(Forget Gate):遗忘门决定了哪些信息会从记忆单元中被丢弃或遗忘。它也由当前时刻的输入和上一时刻的隐藏状态共同决定。 输出门(Output Gate):输出门决定了哪些信息会从记忆单元中输出到当前时刻的隐藏状态中。同样地,它也由当前时刻的输入和上一时刻的隐藏状态共同决定。 LSTM的计算过程可以大致描述为: 通过遗忘门决定从记忆单元中丢弃哪些信息。 通过输入门决定哪些新的信息会被加入到记忆单元中。 更新记忆单元的状态。 通过输出门决定哪些信息会从记忆单元中输出到当前时刻的隐藏状态中。 由于LSTM能够有效地处理长期依赖关系,它在许多序列建模任务中都取得了很好的效果,如语音识别、文本生成、机器翻译、时序预测等。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值