埃氏筛法+快速幂+dp SRM 660 Div 2 Hard: Powerit

本文介绍了一个算法问题,涉及计算一个特定序列的求和,并对结果进行模运算。首先,理解给定的整数n、k和m的含义;接着,解释如何计算从1到n的每个整数i的i^(2^k-1),最后将所有这些计算的结果相加,并对m取模得到最终答案。文章提供了具体的实例和解析过程,包括使用指数运算和模运算的技巧,以及如何利用分治策略和动态规划来优化计算效率。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

Powerit


Problem Statement

You are given three ints: nk, and m.

For each i between 1 and n, inclusive, Fox Ciel calculated the number i^(2^k - 1). ("^" denotes exponentiation.)

Return the sum of all numbers Fox Ciel calculated, modulo m.

Definition

  • ClassPowerit
  • Methodcalc
  • Parametersint , int , int
  • Returnsint
  • Method signatureint calc(int n, int k, int m)
(be sure your method is public)

Limits

  • Time limit (s)2.000
  • Memory limit (MB)256

Constraints

  • n will be between 1 and 1,000,000, inclusive.
  • k will be between 1 and 400, inclusive.
  • m will be between 2 and 1,000,000,000, inclusive.

Test cases

    • n4
    • k1
    • m107
    Returns 10
    • n4
    • k2
    • m107
    Returns 100
    We have  k=2 and therefore (2^ k - 1) = (2^2 - 1) = 3. Fox Ciel calculated the numbers 1^3, 2^3, 3^3, and 4^3. Their sum is 100, and 100 modulo 107 is 100.
    • n3
    • k3
    • m107
    Returns 69
    The actual sum of Ciel's numbers is 2316, and 2316 modulo 107 is 69.
    • n1
    • k400
    • m107
    Returns 1
    • n10
    • k2
    • m10
    Returns 5

题解

Problems that ask you to return the result modulo 1,000,000,007 (or in this case an argument  m ) usually do so to allow us to solve problems that have large results without actually using those large numbers in calculations. We can handle these numbers with modular arithmetic. Read  this recipe for more info.

This problem has two parts. First we need to know that each element of the sum can be calculated in  O(k)  time. We have a power of the form  i2k1 . If we use exponentiation by squaring, we can calculate a power in  O(log(x))  time where  x  is the exponent. This time the exponent is  O(2k)  , the base 2 logarithm of  2k  is  k . This means that if we use exponentiation by squaring we will need  O(k)  time. Because the specific exponent is a power of 2 minus 1, there are also other methods we can use. For example:  2k1=20+21+22+...2k1 . So we have:  i20+21+22+...2k1=(i20)(i21)(i22)...(i2k1) . Each  i2k  can be found by squaring  i2k1 . Ultimately, it doesn't matter if we use this method that is specific to this problem because it is still  O(k)

The second part of the problem is to realize that even with such an algorithm, we will need  O(nk)  time to find all  n  elements of the sum and add them together. For the constraints and the time limit that is too high, specially because of all the modulo operations we will need to do for each step.

If we want a faster solution we should try to look for a way to reuse the work spent in calculating the result for an  i  so that it can make the calculation for other elements easier. A nice way is to notice this: Imagine a number  a=bc a  is the product of two integers. The exponentiation for  a  is :  f(a)=a2k1 . Try this:

f(a)=a2k1  
f(a)=(bc)2k1  
f(a)=(b2k1)(c2k1)
f(a)=f(b)f(c)

Exponentiation is distributive between products. Since we have to calculate  f(i)  for all the numbers in a range, it is likely that when we are about to calculate  f(a)  we already know the values of  f(b)  and  f(c)  , so we can just reuse those results and avoid an  O(k)  calculation.

We just need to materialize that idea into a solution. For each  i  in the range we need to find two factors  pq  such that  i=pq . We should tell right away that there will be many numbers for which this is impossible: Prime numbers. If  i  is prime, we need to use the past method of calculating  f(i)  in  O(k)  time. There are 78498 prime numbers among the first 1000000 natural numbers. So in the worst case we will do the  O(k)  algorithm 78498 times. It is still much better than doing it 1000000 times.

Finally, in case  i  is composite, we need to quickly find two factors  pq=i . We can just do all of this as we test if  i  is prime, just use the successive divisions, if we don't find a divisor  p  (and therefore  q=ip  is also a divisor so we have our pair of factors), then the number is prime. We can do better and use a Sieve of Eratosthenes, just with a small modification, when you find a prime number  p  , don't just strike down its multiples as composite numbers, also save  p  as a "first factor" of each of the composite numbers. Then we can use the look up for the first factor to find a divisor.

long get_ith_element(int i, int k, int m)
{
    // calculate i ^ (2^k - 1) in O(k) time:
    long p = i;
    long q = p;
    for (int j = 1; j < k; j++) {
        q = (q * q) % m;
        p = (p * q) % m;
    }
    return p;
}
 
int calc(int n, int k, int m)
{
    // modified Sieve of Erathostenes, when the number is composite, 
    // first_factor[i] will return a prime number that divides it.
    vector<int> first_factor(n + 1, 1);
    for (int i = 2; i <= n; i++) {
        if (first_factor[i] == 1) {
            // prime
            first_factor[i] = i;
            for (int j = i+i; j <= n; j += i) {
                first_factor[j] = i;
            }
        }
    }
     
    // f(p*q) = f(p) * f(q) , because f(i) = i ^ (something)
    vector<long> dp(n + 1, 1LL );
    long sum = 0;
    for (int i = 1; i <= n; i++) {
        if (first_factor[i] == i) {
            dp[i] = get_ith_element(i,k,m);
        } else {
            dp[i] = (dp[first_factor[i]] * dp[i / first_factor[i]]) % m;
        }
        sum += dp[i];
    }
    return (int)(sum % m);
}


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值