HDU 5496 Beauty of Sequence

题目链接：

http://acm.hdu.edu.cn/showproblem.php?pid=5496

Beauty of Sequence

Problem Description

Sequence is beautiful and the beauty of an integer sequence is defined as follows: removes all but the first element from every consecutive group of equivalent elements of the sequence (i.e. unique function in C++ STL) and the summation of rest integers is the beauty of the sequence.

Now you are given a sequence A of n integers {a1,a2,...,an}. You need find the summation of the beauty of all the sub-sequence of A. As the answer may be very large, print it modulo 109+7.

Note: In mathematics, a sub-sequence is a sequence that can be derived from another sequence by deleting some elements without changing the order of the remaining elements. For example {1,3,2} is a sub-sequence of {1,4,3,5,2,1}.

 

Input

There are multiple test cases. The first line of input contains an integer T, indicating the number of test cases. For each test case:

The first line contains an integer n (1≤n≤105), indicating the size of the sequence. The following line contains n integers a1,a2,...,an, denoting the sequence(1≤ai≤109).

The sum of values n for all the test cases does not exceed 2000000.

 

Output

For each test case, print the answer modulo 109+7 in a single line.

 

Sample Input

3
5
1 2 3 4 5
4
1 2 1 3
5
3 3 2 1 2

 

Sample Output

240
54
144

 

题意分析：

　　题目 是让我们求所有子序和的总和，并且在一个子序列中相邻且相等的数不重复累加（相当于当成一个数）。

题解：

　　当你一个问题想不通的时候，可以换一个角度来思考。

　　一开始直接想统计结果，但是明显统计量是天文数字，于是觉得是不是有什么规律，也没想出来，于是就想从反面思考这个问题，既然不能直接求和，那么能不能转而去求每个点对最后的ans的贡献呢。小试了一下，发现可行。

　　另外一个问题，在一个子序列中相邻相同点只考虑一次。可以选择在这样的子序列中只计算第一个点的贡献值。也就是，考虑一个点的贡献值，只要考虑那些包含它且在它前面没有与它相等的点的所有子序列，我们可以换个角度去求这样的子序列个数，统计所有包含改节点的子序列，然后减去不符合条件的子序列（具体看代码注释）

ac代码：

 #include<iostream>
 #include<cstdio>
 #include<map>
 using namespace std;
 typedef long long LL;

 const int maxn = 1e5 + ;
 const int mod = 1e9 + ;

 int a[maxn];
 int n;

 int bin[maxn];
 map<int, int> mymap;

 void table() {
     bin[] = ;
     for (int i = ; i < maxn; i++) bin[i] = bin[i - ] *  % mod;
 }

 void init() {
     mymap.clear();
 }

 int main() {
     int tc;
     table();
     scanf("%d", &tc);
     while (tc--) {
         init();
         scanf("%d", &n);
         LL ans = ;
         for (int i = ; i <= n; i++) {
             scanf("%d", a + i);
             //mymap[a[i]]表示在i之前,所有以a[i]结尾的子序列的数目
             //bin[n-1]表示所有包含i的子序列，而mymap[a[i]]*bin[n-i]代表的就是不符合条件的子序列了。
             LL tmp = ((bin[n - ] - (LL)bin[n - i] * mymap[a[i]])%mod +mod) % mod;
             ans = (ans + a[i] * tmp) % mod;
             mymap[a[i]] += bin[i - ];
             mymap[a[i]] %= mod;
         }
         printf("%lld\n", ans);
     }
     return ;
 }