Hdu 5439 Aggregated Counting (2015长春网络赛 ACM/ICPC Asia Regional Changchun Online 找规律)

题目链接：

　　Hdu 5439 Aggregated Counting

题目描述：

　　刚开始给一个1，序列a是由a[i]个i组成，最后1就变成了1,2,2,3,3,4,4,4,5,5,5.......，最后问a[i]出现n次(i最大)时候，i最后一次出现的下标是多少？

解题思路：

　　问题可以转化为求a[i] == n (i最大)，数列前i项的和为多少。

　　index：　　1　　2　　3　　4　　5　　6　　7　　8　　9　　10

　　a:      　　  1　　2　　2　　3　　3　　4　　4　　4　　5　　5

　　可以观察出：ans[1] = 1,　　ans[i] = ans[i-1] + a[i]*i;

　　但是n<=1e9,打不了这个庞大的表。进一步观察，可以发现a数组里面有很多的重复元素，辣么就可以对a数组里面的元素进行压缩存进b数组里面(出现次数为i的最后一个元素为b[i])：

　　index：　　1　　2　　3　　4　　5　　 6　　7　　8　　9　　10

　　a:      　　  1　　2　　2　　3　　3　　 4　　4　　4　　5　　5

　　b:      　　  1　　3　　5　　8　　11　 15　 19　 23　  28　 33

　　ans:　　     1　　11　 38    122  272  596  1086　　

　　1到出现次数为i的最后一个元素的区间和为ans[i]，由a[]可以看出ans[i] = ans[i-1] + (b[i] + b[i-1] + 1) * (b[i] - b[i-1]) / 2 * i;

　　每次查询的时候如果n不在b[i]里面，可以找到一个最接近n并且小于n的b[i]，然后再套用一次等差数列求和即可。

　　还有就是等差数列求和的时候，除以2要用到逆元处理一下。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

typedef __int64 LL;
const int INF = 0x3f3f3f3f;
const int maxn = 450000;
const int mod = 1000000007;
LL a[maxn], b[maxn], ans[maxn], num;

LL quick_mod(LL x, LL n)
{
    LL res = 1;

    while (n)
    {
        if (n % 2)
            res = (res * x) % mod;

        x = (x * x) % mod;
        n /= 2;
    }
    return res % mod;
}
void init ()
{
    LL res = 1, j = 1, nu;

    a[0] = b[0] = 0;
    a[1] = b[1] = 1;
    a[2] = num = 2;
    b[2] = 3;

    while (b[num] <= 1e9)
    {
        if (res <= num)
        {
            j ++;
            res += a[j];
        }

        while (res > num)
        {
            num ++;
            a[num] = j;
            b[num] = b[num-1] + a[num];
        }

    }

    //printf ("%I64d %I64d\n", num, b[num]);

    ans[0] = 0;
    ans[1] = 1;

    for (int i=2; i<=num; i++)
         ans [i] = (ans[i-1] + (b[i] + b[i-1] + 1) % mod * a[i] % mod * i % mod * quick_mod(2, mod-2) % mod) % mod;

}

int main ()
{
    LL t, n;
    init ();
    scanf ("%I64d", &t);

    while (t --)
    {
        scanf ("%I64d", &n);
        LL pos = lower_bound (b, b+num, n) - b;

        if (b[pos] == n)
        {
            printf ("%I64d\n", ans[pos]);
            continue;
        }

        LL res = (ans[pos-1] + (b[pos-1] + n + 1) % mod * (n - b[pos-1]) % mod * pos % mod * quick_mod(2, mod-2) % mod) % mod;

        printf ("%I64d\n", res);
    }
    return 0;
}