Question

I am trying to solve this problem in Python. Noting that only the first kiss requires the alternation, any kiss that is not a part of the chain due to the first kiss can very well have a hug on the 2nd next person, this is the code I have come up with. This is just a simple mathematical calculation, no looping, no iteration, nothing. But still I am getting a timed-out message. Any means to optimize it?

import psyco
psyco.full()
testcase = int(raw_input())
for i in xrange(0,testcase):
    n = int(raw_input())
    if n%2:
        m = n/2;
        ans = 2 + 4*(2**m-1);
        ans = ans%1000000007;
        print ans
    else:
        m = n/2 - 1
        ans = 2 + 2**(n/2) + 4*(2**m-1);
        ans = ans%1000000007
        print ans

Answer 1

The answer to this is a pretty simple recursion. F(1) = 2 and for F(n) we have two choices:

• n = H, then the number of ways to kiss the remaining guests is simply F(n-1)
• n = K, then the number of ways to kiss the remaining guests is 2 ** k where k is the number of remaining guests that the princess is not forced to kiss. Since she has to kiss every second remaining guest, k = ceil((n - 1) / 2)

Putting them together, we get F(n) = F(n - 1) + 2 ** ceil((n - 1) / 2)

My attempt, including taking everything mod 1000000007:

from math import ceil

def F(n):
    m = 1000000007
    a = 2
    for i in range(2, n+1):
        a = (a + pow(2, int(ceil((i - 1.0) / 2)), m)) % m
    return a

EDIT: Updated (much faster and more unreadable! F(1e9) takes about 3 minutes):

def F(n):
    m = 1000000007
    a = 2
    z = 1

    for i in xrange(2, n, 2):
        z = (z * 2) % m
        a = (a + z + z) % m

    if (n & 1 == 0):
        z = (z * 2) % m
        a = (a + z) % m

    return a

EDIT 2: After further thought, I realised the above is actually just:

F(n) = (1 + 1) + (2 + 2) + (4 + 4) + ... + (2 ** n/2 + 2 ** n/2)
     = 2 * (1 + 2 + 4 + ... + 2 ** n/2)
     = 2 * (2 ** (n/2 + 1) - 1)
     = 2 ** (n/2 + 2) - 2

But if n is even, the last 2 ** n/2 only occurs once, so we have:

def F(n):
    m = 1000000007
    z = pow(2, n/2, m)

    if (n % 2 == 0):
        return (z * 3 - 2) % m
    else:
        return (z * 4 - 2) % m

Which runs much faster! (Limited by the speed of pow(x, y, z), which I think is O(lg n)?)

And just because, here is the one-liner:

def F(n):
    return (pow(2, n/2, 1000000007) * (3 + n % 2) - 2) % 1000000007

Results:

1   => 2
2   => 4
3   => 6
4   => 10
5   => 14
6   => 22
7   => 30
8   => 46
9   => 62
10  => 94
1e6 => 902893650
1e7 => 502879941
1e8 => 251151906
1e9 => 375000001