[JXOI2017]颜色 线段树求点对贡献

[JXOI2017]颜色

题目链接

https://www.luogu.org/problemnew/show/P4065

题目描述

可怜有一个长度为 n 的正整数序列 Ai，其中相同的正整数代表着相同的颜色。

现在可怜觉得这个序列太长了，于是她决定选择一些颜色把这些颜色的所有位置都删去。

删除颜色 i 可以定义为把所有满足 Aj = i 的位置 j 都从序列中删去。

然而有些时候删去之后，整个序列变成了好几段，可怜不喜欢这样，于是她想要知道有多少种删去颜色的方案使得最后剩下来的序列非空且连续。

例如颜色序列 {1, 2, 3, 4, 5}，删除颜色 3 后序列变成了 {1, 2} 和 {4, 5} 两段，不满足条件。而删除颜色 1 后序列变成了 {2, 3, 4, 5}，满足条件。

两个方案不同当且仅当至少存在一个颜色 i 只在其中一个方案中被删去。

输入输出格式

输入格式：

第一行输入一个整数 T 表示数据组数。每组数据第一行输入一个整数 n 表示数列长度。第二行输入 n 个整数描述颜色序列。

输出格式：

对于每组数据输出一个整数表示答案。

输入输出样例

输入样例#1：
复制

1
5
1 3 2 4 3

输出样例#1： 复制

6

说明

满足条件的删颜色方案有 {1}, {1, 3}, {1, 2, 3}, {1, 3, 4}, {2, 3, 4}, ∅.

对于 20% 的数据，保证 1 ≤∑n ≤ 20。

对于 40% 的数据，保证 1 ≤∑n ≤ 500。

对于 60% 的数据，保证 1 ≤∑n ≤ 10^4。

对于 100% 的数据，保证 1 ≤ T,∑n ≤ 3 × 10^5, 1 ≤ Ai ≤ n。

题解

每段合法区间都是连续的，自然而然会想到枚举一个端点，然后求另一个端点的合法个数。

感觉这个套路比较常见，但是我依然不会。

我们可以先枚举右端点，然后怎么确定左端点的个数呢，感觉很麻烦是不是，正难则反嘛。

定义a[i]为i点的值，head[a[i]]为a[i]最左端点的位置，tail[i]为其最右端的位置。

枚举右端点，当右端点为第i位，令R=i，假设存在一个L，使得区间（Ｌ，Ｒ）为合法区间，

对于j(L<=j<=R),满足:

１．tail[a[j]]<=R

２．head[a[j]]>=L

到这一步接下来就有点难想到了。

对于每个点i，如果i=tail[a[i]]，那么对于任何区间，head[a[i]]+1~tail[a[i]]不可能是左端点，我们将这段区间赋值成一。

再找到最靠近i的k满足，tail[k]>i,则（１，ｋ）之间不可能存在左端点。

i为右端点的贡献等于，i-k-sum[k+1,i](sum[k+1,i]为k+1到i的被标记了的总和，蓝字部分）.

至于怎么找k,可以用单调栈来维护，因为弹出栈的话，就不会再用到了。

代码

 #include<bits/stdc++.h>
 using namespace std;
 #define ll long long
 #define N 500050

 int n,top,a[N],sk[N];
 int head[N],tail[N],last[N],nex[N];
 struct Tree {int l,r,lazy,sum;}tr[N<<];
 template<typename T>void read(T&x)
 {
   ll k=; char c=getchar();
   x=;
   while(!isdigit(c)&&c!=EOF)k^=c=='-',c=getchar();
   if (c==EOF)exit();
   while(isdigit(c))x=x*+c-'',c=getchar();
   x=k?-x:x;
 }
 void read_char(char &c)
 {while(!isalpha(c=getchar())&&c!=EOF);}
 void push_up(int x)
 {
   int len=tr[x].r-tr[x].l+;
   if (len>)tr[x].sum=tr[x<<].sum+tr[x<<|].sum;
   else tr[x].sum=;
   if (tr[x].lazy!=-)
     tr[x].sum=tr[x].lazy*len;
 }
 void push_down(int x)
 {
   if (tr[x].lazy==-)return;
   tr[x<<].lazy=tr[x].lazy;
   tr[x<<|].lazy=tr[x].lazy;
   push_up(x<<);
   push_up(x<<|);
   tr[x].lazy=-;
 }
 void bt(int x,int l,int r)
 {
   tr[x]=Tree{l,r,-,};
   if (l==r) return ;
   int mid=(l+r)>>;
   bt(x<<,l,mid);
   bt(x<<|,mid+,r);
 }
 void update(int x,int l,int r)
 {
   if (l>r)return;
   if (l<=tr[x].l&&tr[x].r<=r)
     {
       tr[x].lazy=;
       push_up(x);
       return ;
     }
   int mid=(tr[x].l+tr[x].r)>>;
   push_down(x);
   if (l<=mid)update(x<<,l,r);
   if (mid<r)update(x<<|,l,r);
   push_up(x);
 }
 int query(int x,int l,int r)
 {
   if (l<=tr[x].l&&tr[x].r<=r)
     return tr[x].sum;
   int mid=(tr[x].l+tr[x].r)>>,ans=;
   push_down(x);
   if (l<=mid)ans=query(x<<,l,r);
   if (mid<r)ans+=query(x<<|,l,r);
   push_up(x);
   return ans;
 }
 void work()
 {
   read(n);
   for(int i=;i<=n;i++) read(a[i]);
   for(int i=;i<=n;i++)
     {
       if (head[a[i]]==)head[a[i]]=i;
       nex[tail[a[i]]]=i;
       last[i]=tail[a[i]];
       tail[a[i]]=i;
     }
   bt(,,n);
   sk[top=]=;
   tail[]=n+;
   ll ans=;
   for(int i=;i<=n;i++)
     {
       sk[++top]=i;
       while(top&&tail[a[sk[top]]]<=i)top--;
       int j=sk[top];
       if (tail[a[i]]==i)
     {
       update(,head[a[i]]+,tail[a[i]]);
       ans+=i-j-query(,j+,i);
     }
     }
   printf("%lld\n",ans);
 }
 void clear()
 {
   memset(head,,sizeof(head));
   memset(tail,,sizeof(tail));
 }
 int main()
 {
 #ifndef ONLINE_JUDGE
   freopen("aa.in","r",stdin);
 #endif
   int q;
   read(q);
   while(q--)
     {
       clear();
       work();
     }
 }