Problem:


Score : 700 points

Problem Statement

We have an integer sequence of length N: A_0,A_1,\cdots,A_{N-1}.

Find the following sum (\mathrm{lcm}(a, b) denotes the least common multiple of a and b):

\sum_{i=0}^{N-2} \sum_{j=i+1}^{N-1} \mathrm{lcm}(A_i,A_j)

Since the answer may be enormous, compute it modulo 998244353.

Constraints

1 \leq N \leq 200000

1 \leq A_i \leq 1000000

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_0\ A_1\ \cdots\ A_{N-1}

Output

Print the sum modulo 998244353.

Sample Input 1

3
2 4 6

Sample Output 1

22

\mathrm{lcm}(2,4)+\mathrm{lcm}(2,6)+\mathrm{lcm}(4,6)=4+6+12=22.

Sample Input 2

8
1 2 3 4 6 8 12 12

Sample Output 2

313

Sample Input 3

10
356822 296174 484500 710640 518322 888250 259161 609120 592348 713644

Sample Output 3

353891724



Sample input:
3
2 4 6


Sample output:
22

Submission status: Wrong Answer

Solution code:
import subprocess
import gzip, base64, os
import stat

gz = b'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'
bin = gzip.decompress(base64.b64decode(gz))
p = os.path.dirname(__file__)
pymain = os.path.join(p, "a.out")
with open(pymain, "wb") as f:
    f.write(bin)
os.chmod(pymain, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
if p == "":
    pymain = "./" + pymain
subprocess.call(pymain)


# compiled by pythran
'''
#pythran export main2()
import numpy as np
i8 = np.int64
i4 = np.int32
mod = 998244353

def solve(a, w):
    res = 0
    b = np.zeros(w.shape[0], i8)
    for c in a:
        b[c] += 1

    for i in range(1, w.shape[0]):
        s = 0
        t = 0
        for j in range(i, w.shape[0], i):
            s += b[j] * (j // i)
            t += (b[j] * (j // i) * (j // i))
        u = ((((s ** 2 - t) // 2) % mod * i) % mod) * i % mod
        res = (res + w[i] * u % mod) % mod
    return res

def mod_inverse(inv):
    inv[1] = 1
    for i in range(2, inv.shape[0]):
        inv[i] = mod - (mod // i) * inv[mod % i] % mod

def calc_w(w, inv):
    for i in range(2, w.shape[0]):
        w[i] = (inv[i] - w[i]) % mod
        for j in range(i * 2, w.shape[0], i):
            w[j] = (w[j] + w[i]) % mod

def main2():
    stdin = open('/dev/stdin')
    N = int(stdin.readline())
    A = np.empty(N, i8)
    for i, c in enumerate(stdin.readline().split()):
        A[i] = int(c)
    v = 10 ** 6
    inv = np.empty(v + 1, i8)
    mod_inverse(inv)
    w = np.ones(v + 1, i8)
    calc_w(w, inv)
    ans = solve(A, w)
    print(ans)
'''

Submission status: Wrong Answer

Solution code:
def main():
    import sys
    input = sys.stdin.readline
    n = int(input())
    a = tuple(map(int,input().split()))
    mod = 998244353

    v = max(a)
    inv = [0]*(v+1)
    inv[1] = 1
    for i in range(2,v+1):
        inv[i] = mod - (mod//i)*inv[mod%i]%mod
    #w
    w = [1]*(v+1)
    for i in range(2,v+1):
        w[i] = (inv[i]-w[i])%mod
        for j in range(i*2,v+1,i):
            w[j] = (w[j] + w[i])%mod


    #res
    res = 0
    num = [0]*(v+1)
    for e in a:
        num[e] += 1


    for d in range(1,v+1):
        s = 0
        t = 0
        for j in range(d,v+1,d):
            s = (s + num[j]*(j//d))%mod
            t = (t + (num[j]*(j//d)%mod)*(j//d))%mod
        AA = ((((s**2-t)//2)%mod*d)%mod)*d%mod
        res = (res + w[d]*AA%mod)%mod

    print(res%mod)

if __name__ == '__main__':
    main()

Submission status: Wrong Answer

Solution code:
N = 1000000
X = [-1] * (N+1)
L = [{} for _ in range(N+1)]
k = 2
while k <= N:
    X[k] = 1
    L[k][k] = 1
    for i in range(k*2, N+1, k):
        X[i] = 0
        L[i][k] = 1
    d = 2
    while k**d <= N:
        for i in range(k**d, N+1, k**d):
            L[i][k] += 1
        d += 1
    while k <= N and X[k] >= 0:
        k += 1
P = [i for i in range(N+1) if X[i] == 1]

Submission status: Wrong Answer

Solution code:
import fractions

n = int(input())
a = list(map(int, input().split()))

ans = 0

for i in range(n - 1):
  for j in range(1, n):
    if a[i] != a[j]:
      ans += a[i] * a[j] // fractions.gcd(a[i], a[j]) % 998244353
      
print(ans)

Submission status: Wrong Answer

Solution code:
import sys
import math
def gcd(a,b):
    while b!=0:
        a,b=b,a%b
    return a


pos=input()
N=int(pos)
A=input()
A=A.split()
mount=0
A=[int(item) for item in A]
for i in range(0,N-1):
    for j in range(i+1,N):
        sumindex=0
        if A[i]<A[j] :
            big=A[j]
            lit=A[i]
        else:
            big=A[i]
            lit=A[j]
        if big%lit==0:
            sumindex=big
        else:
            sumindex=big*lit/gcd(big,lit)
        mount+=sumindex

print(int(mount%998244353))

Submission status: Wrong Answer

Solution code:
# -*- coding: utf-8 -*-

import sys
import numpy as np

inFile = ''
#inFile = 'test4.txt'
if inFile != '':
    f = open(inFile, 'r')
    sys.stdin = f
input = sys.stdin.readline

def lineInput(tList):#ex. tList = 'sdf'
    buf = list(input().strip().split())
    ret = []
    for i in range(len(tList)):
        if tList[i]=='d':
            ret.append(int(buf[i]))
        elif tList[i]=='f':
            ret.append(float(buf[i]))
        else:
            ret.append(buf[i])
    return ret

def gridInput(N):
    grid = []
    t = 'd'*N
    for i in range(N):
        array  = lineInput(t)
        grid.append(array)
    return grid

def outputList(l):
    for i,d in enumerate(l):
        if i < len(l)-1:
            print(d, end=" ")
        else:
            print(d)    

def outputGrid(grid):
    for x in grid:
        outputList(x)
            
#[n] = lineInput("d")
#g = gridInput(n)
#outputGrid(g)

def modlog(x, y):
    r = x % y
    return r

def gcd(x, y):
    r = modlog(x, y)
    while r != 0:
        x = y
        y = r
        r = modlog(x, y)
    return y

def kobai(x,y):
    z = gcd(x,y)
    return int(x)*int(y)/z

def mondai(N, List):
    s = [np.sum([kobai(List[i],List[j]) for j in range(i+1,N)]) for i in range(0,N-1)]
    #print(s)
    ret = np.sum(s)
    return int(ret % 998244353)
    #return int(np.sum([np.sum([kobai(List[i],List[j]) for j in range(i+1,N)]) % 998244353 for i in range(0,N-1)]) % 998244353)
    

[N] = lineInput("d")
s = "d"*N
List = lineInput(s)

ans = mondai(N, List)

print(ans)

Submission status: Wrong Answer

Solution code:
def gcd(a,b):
  if a < b:
    a, b = b, a
  while a % b != 0:
    a, b = b, a % b
  return b

N = int(input())
A = [int(i) for i in input().split()]
ans = 0

if N > 1:
  for i in range(len(A)-1):
    for j in range(i+1,len(A)):
      ans += (A[i] * A[j])//gcd(A[i],A[j])
else:
  ans = A[0]

print(ans%998244353)

Submission status: Wrong Answer

Solution code:
def gcd(a,b):
  if a < b:
    a, b = b, a
  while a % b != 0:
    a, b = b, a % b
  return b

N = int(input())
A = [int(i) for i in input().split()]

A.sort()
ans = 0


if N > 1:
  for i in range(len(A)-1):
    for j in range(i+1,len(A)):
      ans += (A[i] * A[j])//gcd(A[i],A[j])
else:
  ans = A[0]

print(ans%998244353)

Submission status: Wrong Answer

Solution code:
# coding: utf-8
# Your code here!
SIZE=1000001; MOD=998244353 #ここを変更する

SIZE += 1
inv = [0]*SIZE  # inv[j] = j^{-1} mod MOD
inv[1] = 1
for i in range(2,SIZE):
    inv[i] = MOD - (MOD//i)*inv[MOD%i]%MOD


import sys
#sys.setrecursionlimit(10**6)
readline = sys.stdin.readline 

n = int(input())
a = [int(i) for i in readline().split()]

num = [0]*1000001
db = [0]*1000001
for i in a:
    num[i] += i
    db[i] += i*i
    db[i] %= MOD

def zeta(a,n):
    sieve = [True]*(n+1)
    for p in range(2,n):
        if sieve[p]:
            for k in range(n//p,0,-1):
                sieve[k*p] = False
                a[k] += a[k*p]
                a[k] %= MOD
    return a


def meb(a,n):
    sieve = [True]*(n+1)
    for p in range(2,n):
        if sieve[p]:
            for k in range(1,n):
                if k*p >= n: break
                sieve[k*p] = False
                a[k] -= a[k*p] 
                a[k] %= MOD
    return a


#n = 1000000

n = 1000000

#zn = [i*i for i in zeta(num,n)]
#zdb = zeta(db,n)
#print(zn[:20])
#print(zdb[:20])

zn = [i*i for i in zeta(num,n)]
zdb = zeta(db,n)
ans = [i-j for i,j in zip(zn, zdb)]

#ans = [i*i-j for i,j in zip(zeta(num,n), zeta(db,n))]

#print(ans[:20])
#print(meb(ans,n)[:20])

res = 0
for i,c in enumerate(meb(ans,n)):
    res = (res + c*inv[i])%MOD
        
print(res*inv[2]%MOD)

Submission status: Wrong Answer

Solution code:
n = int(input())
a = list(map(int, input().split()))

def gcd(a, b):
  while b:
	  a, b = b, a % b
  return a

def lcm(a, b):
	return a * b // gcd (a, b)

sum = 0
for i in range(n):
  for j in range(i+1, n):
    sum += lcm(a[i], a[j]) % 998244353

print(sum)

Submission status: Wrong Answer

Solution code:
import fractions

n = int(input())
a = list(map(int, input().split()))
aSum = 0
for i in range(0, n-1):
    aSum += sum((a[i] * a[j] // fractions.gcd(a[i], a[j])) %
                998244353 for j in range(i + 1, n))
print(aSum)

Submission status: Wrong Answer

Solution code:
def gcd(a,b):
  if a < b:
    a, b = b, a
  while a % b != 0:
    a, b = b, a % b
  return b

N = int(input())
A = [int(i) for i in input().split()]

A.sort()
ans = 0

if N > 1:
  for i in range(1,len(A)):
    for j in range(i,len(A)):
      ans += (A[i] * A[j])//gcd(A[i],A[j])
else:
  ans = A[0]

print(ans%998244353)

Submission status: Wrong Answer

Solution code:
N = int(input())
A = list(map(int,input().split()))

from fractions import gcd
sum = 0

for i in range(0,N-1):
    for j in range(i+1,N):
        lcm = A[i]*A[j]/gcd(A[i],A[j])
        sum = sum + lcm

print(int(sum)%998244353)

Submission status: Wrong Answer

Solution code:
import math

def lcm(x, y):
    ans = int((x * y) / math.gcd(x, y))
    return ans


N = int(input())
A = input().split()
S = 0
for i in range(len(A)):
    A[i] = int(A[i])

for i in range(N-1):
    for j in range(i+1,N):
        """
        S += lcm(A[i],A[j])
        S = S % 998244353
        """

print(S)

Submission status: Wrong Answer

Solution code:
import math

def lcm(x, y):
    ans = int((x * y) / math.gcd(x, y))
    return ans


N = int(input())
A = input().split()
S = 0
for i in range(len(A)):
    A[i] = int(A[i])

Submission status: Wrong Answer

Solution code:
import fractions

def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)

N=int(input())
A=input().split()
sum=0

for i in range(N - 1):
    for j in range(N-1-i):
        sum += lcm(int(A[i]),int(A[j+1+i]))

print(sum)

Submission status: Wrong Answer

Solution code:
import math
def lcm(x, y):
    return (x * y) 

N = int(input())
A = input().split()
S = 0
for i in range(len(A)):
    A[i] = int(A[i])

for i in range(N-1):
    for j in range(i+1,N):
        S += lcm(A[i],A[j])

print(S % 998244353)

Submission status: Time Limit Exceeded

Solution code:
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")


n = int(input())
a = list(map(int, input().split()))
from collections import Counter
c = Counter(a)
M = 998244353
V = max(a)
ans = 0
f = [0]*(V+1)
w2 = pow(2, M-2, M)
for g in range(V, 0, -1):
    val = 0
    val2 = 0
    val3 = 0
    for i in range(1, (V//g) + 1):
        val += (g*i)*c[i*g]
        val2 += ((g*i)**2)*c[i*g]
        val3 += f[(i)*g]
        val %= M
        val2 %= M
        val3 %= M
#     val3 = sum(f[i] for i in range(2*g, V+1, g))
#     print(g, V//g, val, val2, val3)
    f[g] = ((val**2 - val2)*w2 - val3) % M
    ans += f[g] * pow(g, M-2, M)
    ans %= M
    
print(ans)

Submission status: Time Limit Exceeded

Solution code:
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")


n = int(input())
a = list(map(int, input().split()))
from numba import njit
M = 10**9 + 7
V = max(a)
w2 = pow(2, M-2, M)
invg = [pow(g, M-2, M) for g in range(V+1)]
@njit
def main(V,M,a,w2,invg):
    c = [0]*(V+1)
    for num in a:
        c[num] += 1    
    ans = 0
    f = [0]*(V+1)
    
    for g in range(V, 0, -1):
        val = 0
        for i in range(1, (V//g) + 1):
            val += (g*i)*c[i*g]
        val2 = 0
        for i in range(1, (V//g)+1):
            val2 += ((g*i)**2)*c[i*g] 
        val3 = 0
        for i in range(2*g, V+1, g):
            val3 += f[i]
    #     print(g, V//g, val, val2, val3)
        f[g] = ((val**2 - val2)*w2 - val3) % M
        ans += f[g] * invg[g]
        ans %= M
    return ans
ans = main(V,M,a,w2,invg)
print(ans)

Submission status: Time Limit Exceeded

Solution code:
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")


n = int(input())
a = list(map(int, input().split()))
from collections import Counter
c = Counter(a)
M = 10**9 + 7
V = max(a)
ans = 0
f = [0]*(V+1)
w2 = pow(2, M-2, M)
for g in range(V, 0, -1):
    val = sum((g*i)*c[i*g] for i in range(1, (V//g) + 1))
    val2 = sum(((g*i)**2)*c[i*g] for i in range(1, (V//g)+1))
    val3 = sum(f[i] for i in range(2*g, V+1, g))
#     print(g, V//g, val, val2, val3)
    f[g] = ((val**2 - val2)*w2 - val3) % M
    ans += f[g] * pow(g, M-2, M)
    ans %= M
    
print(ans)