Hello 2020——B. New Year and Ascent Sequence

Hello 2020——B. New Year and Ascent Sequence

A sequence a=[a1,a2,…,al] of length l has an ascent if there exists a pair of indices (i,j) such that 1≤i<j≤l and ai<aj. For example, the sequence [0,2,0,2,0] has an ascent because of the pair (1,4), but the sequence [4,3,3,3,1] doesn’t have an ascent.

Let’s call a concatenation of sequences p and q the sequence that is obtained by writing down sequences p and q one right after another without changing the order. For example, the concatenation of the [0,2,0,2,0] and [4,3,3,3,1] is the sequence [0,2,0,2,0,4,3,3,3,1]. The concatenation of sequences p and q is denoted as p+q.

Gyeonggeun thinks that sequences with ascents bring luck. Therefore, he wants to make many such sequences for the new year. Gyeonggeun has n sequences s1,s2,…,sn which may have different lengths.

Gyeonggeun will consider all n2 pairs of sequences sx and sy (1≤x,y≤n), and will check if its concatenation sx+sy has an ascent. Note that he may select the same sequence twice, and the order of selection matters.

Please count the number of pairs (x,y) of sequences s1,s2,…,sn whose concatenation sx+sy contains an ascent.

Input
The first line contains the number n (1≤n≤100000) denoting the number of sequences.

The next n lines contain the number li (1≤li) denoting the length of si, followed by li integers si,1,si,2,…,si,li (0≤si,j≤106) denoting the sequence si.

It is guaranteed that the sum of all li does not exceed 100000.

Output
Print a single integer, the number of pairs of sequences whose concatenation has an ascent.

Examples
inputCopy
5
1 1
1 1
1 2
1 4
1 3
outputCopy
9
inputCopy
3
4 2 0 2 0
6 9 9 8 8 7 7
1 6
outputCopy
7
inputCopy
10
3 62 24 39
1 17
1 99
1 60
1 64
1 30
2 79 29
2 20 73
2 85 37
1 100
outputCopy
72
Note
For the first example, the following 9 arrays have an ascent: [1,2],[1,2],[1,3],[1,3],[1,4],[1,4],[2,3],[2,4],[3,4]. Arrays with the same contents are counted as their occurences.

题意： 给你n个数列，取其中两个（有循序）合并，一共有n^2种取法，问合并后的数列是否存在上升子对，就是i<j&&a[i]<a[j]，如果存在ans++，问最后ans是多少。

思路： 我们找到每个数列的最大和最小值，把最大值放入一个桶种排序，然后求前缀和，然后对于每个数列来说，它在前面的组合成功的数量就是最大值比它的最小值大的数列的数量，ans+=pre[maxn]-pre[a[i].minn]，我们只要把整个前缀和的最大值减去他的最小值，就可以知道有多少数列的最大值大于它的最小值，也就是成功的数量。
还有一种特殊数列要要另算，就是本身就已经是成功的数列，它跟任意数列组合都是成功的，它的存在的数量就是（2n-1），对于有特殊数列，就要把他们独立计算，ans+=cnt((t-cnt)2)+cntcnt;（t是一共有的数列组数，cnt是特殊数列的数量）

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
struct node{
	int minn;
	int maxx;
}a[1000007];
int da[1000007];
int xiao[1000007];
int pre[1000007];
int e[1000007];
int vis[1000007];
int main(){
	int t;
	ll ans=0,cnt=0;
	scanf("%d",&t);
	for(int j=1;j<=t;j++)
	{
		int n;
		scanf("%d",&n);
		int flag=0;
		for(int i=1;i<=n;i++){
			scanf("%d",&e[i]);
			if(i==1){
				a[j].maxx=e[i];
				a[j].minn=e[i];
			}else{
				if(e[i]>e[i-1])flag=1;
				if(a[j].maxx<e[i])a[j].maxx=e[i];
				if(a[j].minn>e[i])a[j].minn=e[i];
			}
		}
		if(flag==0){
			da[a[j].maxx]++;
			xiao[a[j].minn]++;
		}else{
			vis[j]=1;
			cnt++;
		}	
	}
	ans+=cnt*((t-cnt)*2)+cnt*cnt;
	int maxn=0;
	for(int i=0;i<=1000000;i++)
	{
		if(i==0)pre[i]=da[i];
		else
		pre[i]=pre[i-1]+da[i];
		if(da[i]!=0&&i>maxn)maxn=i;
	}
	for(int i=1;i<=t;i++)
	{
		if(vis[i]==0)
		ans+=pre[maxn]-pre[a[i].minn];
	}
	printf("%lld\n",ans);
	return 0;
}