Problem:
Score: 600 points

Problem Statement

How many strings can be obtained by applying the following operation on a string S exactly K times: "choose one lowercase English letter and insert it somewhere"?

The answer can be enormous, so print it modulo (10^9+7).

Constraints

K is an integer between 1 and 10^6 (inclusive).

S is a string of length between 1 and 10^6 (inclusive) consisting of lowercase English letters.

Input

Input is given from Standard Input in the following format:

K
S

Output

Print the number of strings satisfying the condition, modulo (10^9+7).

Sample Input 1

5
oof

Sample Output 1

575111451

For example, we can obtain proofend, moonwolf, and onionpuf, while we cannot obtain oofsix, oofelevennn, voxafolt, or fooooooo.

Sample Input 2

37564
whydidyoudesertme

Sample Output 2

318008117

Solution in Kotlin (1.3.71) (judge verdict: Accepted)

fun main() {
    val k = readLine()!!.toInt()
    val s = readLine()!!
    val n = s.length
    val table = LongArray(k+n+1){1L}
    val facto = LongArray(n+k+1)
    val front = LongArray(k + n + 1){1L}
    val mod = (1e9+7).toLong()

    table[1] = 26L
    val c = n + k

    for(i in 2..c) {
        table[i] = table[i-1] * 26L
        table[i] %= mod
    }

    front[1] = 25L
    for(i in 2..c) {
        front[i] = front[i-1] * 25L
        front[i] %= mod
    }

    facto[0] = 1L
    facto[1] = 1L

    for(i in 2..c) {
        facto[i] = (facto[i-1] * i) % mod
    }

    fun modInv(a:Long, m:Long = mod): Long {
        fun mInv(a:Long, m:Long): Long {
            if(m == 0L) return 1L
            if(m == 1L) return a
            var result = mInv(a, m / 2) % mod
            result = (result * result) % mod
            if(m % 2 != 0L) {
                result = (result * a) % mod
            }
            return result
        }
        return mInv(a, m - 2)
    }

    fun comb(n:Int, r:Int) : Long {
        val a = facto[n]
        val b = (facto[r] * facto[n-r]) % mod
        val ret = (a*modInv(b)) % mod
        return ret
    }





    // a a -> b a a | a a b -> b a a b , b a a b
    // f(i) : i 번 연산을 수행 했을때 나오는 문자열의 갯수. 각 문자열의 길이는 n + i 가 된다. 길이 n + i - 1 일 때 문자를 추가하는 위치의 수는 n + i 개가 된다.
    // 그 중에서 각 문자열은 이미 위치한 문자열과 같은 알파벳을 앞뒤로 넣는 것은 같은 횟수로 간주가 된다.
    // 주어진 문자열에서 알파벳 추가할때, 나오는 경우의 수는 문자열의 길이가 l 이라고 할때, (l+1) * 26 - l 이다. 25l + 26

    // 존재하지 않는 경우 : 전체 갯수 - (1 개만 존재 + 2개만 존재 + .... (k+s) / s 개)
    // s + k - i * s 에서 s 개를 뽑는다. 남은
    // 0 개만 존재하는 경우
    // 전체 경우 - 존재하지않는 경우 => 답
    // 존재하지 않는 경우 : f(n - 1) 에서 존재하지 않는 경우 f(n) 에서 존재하지 않는 경우 ...
    // f(n - 1) * 25 + 26 - f(n - s)

    // f(1) = f
    // f(k - i) =
    // f(k - 1) = f(k) * k * (26 ^ s - 1 )
    // f(k) = nCs * n - s C s * ... s + k C s * 26 ^ k

    // 1. 주어진 s 에서 부터 알파벳을 붙여나가면서 접근하가.
    //   ---> 중복된 케이스를 제거하면서.
    //      중복 패턴 2 가지
    //       (1) abc* , abc?  - 서로 다른 문자의 위치가 같은 경우 => abc*? , abc?* : 두개가 생김.
    //       (2) a*bc , ab?c  - 서로 다른 문자의 위치가 다른 경우 => a*b?c : 한개가 생김.
    //       abc 에서 나올 수 있는 추가 경우의 수 : 4 * 26 - 3 임. 101 개의 두 개의 경우의 수를 뽑는데.
    //       (101_C_2 - 26_C_2 * 4) * 1
    //       ( 26_C_2 * 4) * 2
    // 2. 길이 s + k 인 모든 알파벳 조합에서 s 가 아예없는 것들을 세서 전체 수에서 빼기.
    //   ---> ㅎㅎ
    //   ===> ㄱㄴㄷㄹ ㅁㅂㅅㅇ ㅈㅊㅋㅌ ㅍㅎ
    //   ===>

    fun solve(idx:Int): Long {
        // cc-[idx]
        val remain = n + k - idx
        val cnt = idx - n
        if(cnt < 0) return 0L
        // Combination(idx - 1, n - 1)
        val b = comb(idx - 1, n - 1)
        val before = front[cnt]
        val after = table[remain]
        val ret = (((b * before) % mod ) * after) % mod
        return ret
    }
    var ans = 0L
    for(i in 1..n+k) {
        ans += solve(i)
        ans %= mod
    }
    print(ans)

}