結果
| 問題 | No.694 square1001 and Permutation 3 |
| ユーザー |
 vwxyz
|
| 提出日時 | 2023-12-01 20:47:29 |
| 言語 | PyPy3 (7.3.15) |
| 結果 |
MLE
|
| 実行時間 | - |
| コード長 | 14,898 bytes |
| コンパイル時間 | 409 ms |
| コンパイル使用メモリ | 82,432 KB |
| 実行使用メモリ | 264,208 KB |
| 最終ジャッジ日時 | 2024-09-26 15:49:48 |
| 合計ジャッジ時間 | 8,011 ms |
|
ジャッジサーバーID （参考情報） |
judge4 / judge3 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 49 ms
57,472 KB |
| testcase_01 | AC | 49 ms
57,088 KB |
| testcase_02 | AC | 48 ms
56,832 KB |
| testcase_03 | AC | 61 ms
66,304 KB |
| testcase_04 | AC | 68 ms
68,736 KB |
| testcase_05 | AC | 72 ms
70,784 KB |
| testcase_06 | AC | 75 ms
70,656 KB |
| testcase_07 | AC | 331 ms
88,896 KB |
| testcase_08 | AC | 662 ms
157,696 KB |
| testcase_09 | MLE | - |
| testcase_10 | AC | 354 ms
89,344 KB |
| testcase_11 | MLE | - |
| testcase_12 | MLE | - |
| testcase_13 | AC | 43 ms
57,472 KB |
ソースコード
import sys
readline=sys.stdin.readline
from collections import defaultdict,Counter
class UnionFind:
def __init__(self,N,label=None,f=None,weighted=False,rollback=False):
self.N=N
self.parents=[None]*self.N
self.size=[1]*self.N
self.roots={i for i in range(self.N)}
self.label=label
if self.label!=None:
self.label=[x for x in label]
self.f=f
self.weighted=weighted
if self.weighted:
self.weight=[0]*self.N
self.rollback=rollback
if self.rollback:
self.operate_list=[]
self.operate_set=[]
def Find(self,x):
stack=[]
while self.parents[x]!=None:
stack.append(x)
x=self.parents[x]
if not self.rollback:
if self.weighted:
w=0
for y in stack[::-1]:
self.parents[y]=x
w+=self.weight[y]
self.weight[y]=w
else:
for y in stack[::-1]:
self.parents[y]=x
return x
def Union(self,x,y,w=None):
root_x=self.Find(x)
root_y=self.Find(y)
if self.rollback:
self.operate_list.append([])
self.operate_set.append([])
if root_x==root_y:
if self.weighted:
if self.weight[y]-self.weight[x]==w:
return True
else:
return False
else:
if self.size[root_x]<self.size[root_y]:
x,y=y,x
root_x,root_y=root_y,root_x
if self.weighted:
w=-w
if self.rollback:
self.operate_list[-1].append((self.parents,root_y,self.parents[root_y]))
self.operate_list[-1].append((self.size,root_x,self.size[root_x]))
self.operate_set[-1].append(root_y)
if self.label!=None:
self.operate_list[-1]((self.label,root_x,self.label[root_x]))
if self.weighted:
self.operate_list[-1].append((self.weight,root_y,self.weight[root_y]))
self.parents[root_y]=root_x
self.size[root_x]+=self.size[root_y]
self.roots.remove(root_y)
if self.label!=None:
self.label[root_x]=self.f(self.label[root_x],self.label[root_y])
if self.weighted:
self.weight[root_y]=w+self.weight[x]-self.weight[y]
def Size(self,x):
return self.size[self.Find(x)]
def Same(self,x,y):
return self.Find(x)==self.Find(y)
def Label(self,x):
return self.label[self.Find(x)]
def Weight(self,x,y):
root_x=self.Find(x)
root_y=self.Find(y)
if root_x!=root_y:
return None
return self.weight[y]-self.weight[x]
def Roots(self):
return list(self.roots)
def Linked_Components_Count(self):
return len(self.roots)
def Linked_Components(self):
linked_components=defaultdict(list)
for x in range(self.N):
linked_components[self.Find(x)].append(x)
return linked_components
def Rollback(self):
assert self.rollback
if self.operate_list:
for lst,x,v in self.operate_list.pop():
lst[x]=v
for x in self.operate_set.pop():
self.roots.add(x)
return True
else:
return False
def __str__(self):
linked_components=defaultdict(list)
for x in range(self.N):
linked_components[self.Find(x)].append(x)
return "\n".join(f"{r}: {linked_components[r]}" for r in sorted(list(linked_components.keys())))
class Graph:
def __init__(self,V,edges=None,graph=None,directed=False,weighted=False,inf=float("inf")):
self.V=V
self.directed=directed
self.weighted=weighted
self.inf=inf
if graph!=None:
self.graph=graph
"""
self.edges=[]
for i in range(self.V):
if self.weighted:
for j,d in self.graph[i]:
if self.directed or not self.directed and i<=j:
self.edges.append((i,j,d))
else:
for j in self.graph[i]:
if self.directed or not self.directed and i<=j:
self.edges.append((i,j))
"""
else:
self.edges=edges
self.graph=[[] for i in range(self.V)]
if weighted:
for i,j,d in self.edges:
self.graph[i].append((j,d))
if not self.directed:
self.graph[j].append((i,d))
else:
for i,j in self.edges:
self.graph[i].append(j)
if not self.directed:
self.graph[j].append(i)
def Warshall_Floyd(self,route_restoration=False):
dist=[[self.inf]*self.V for i in range(self.V)]
for i in range(self.V):
dist[i][i]=0
if route_restoration:
parents=[[j for j in range(self.V)] for i in range(self.V)]
for i,j,d in self.edges:
if i==j:
continue
if dist[i][j]>d:
dist[i][j]=d
if route_restoration:
parents[i][j]=i
if not self.directed and dist[j][i]>d:
dist[j][i]=d
if route_restoration:
parents[j][i]=j
for k in range(self.V):
for i in range(self.V):
for j in range(self.V):
if dist[i][j]>dist[i][k]+dist[k][j]:
dist[i][j]=dist[i][k]+dist[k][j]
if route_restoration:
parents[i][j]=parents[k][j]
for i in range(self.V):
if dist[i][i]<0:
for j in range(self.V):
if dist[i][j]!=self.inf:
dist[i][j]=-self.inf
if route_restoration:
for i in range(self.V):
if dist[i][i]==0:
parents[i][i]=None
return dist,parents
else:
return dist
def Kruskal(self,maximize=False,spanning_tree=False):
UF=UnionFind(self.V)
sorted_edges=sorted(self.edges if self.weighted else [(x,y,1) for x,y in self.edges],key=lambda tpl:tpl[2],reverse=maximize)
if spanning_tree:
st=[]
else:
cost=0
for x,y,d in sorted_edges:
if not UF.Same(x,y):
UF.Union(x,y)
if spanning_tree:
st.append((x,y,d))
else:
cost+=d
return st if spanning_tree else cost
def Inversion_Number(lst,weight=False,weakly=False):
compress,decompress=Compress(lst)
compressed_lst=[compress[x] for x in lst]
N=len(compress)
if not weight:
weight=[1]*len(lst)
ST=Segment_Tree(N,lambda x,y:x+y,0)
inversion_number=0
for c,x in zip(weight,compressed_lst):
inversion_number+=ST.Fold(x if weakly else x+1,N)*c
ST[x]+=c
return inversion_number
def Compress(lst):
decomp=sorted(list(set(lst)))
comp={x:i for i,x in enumerate(decomp)}
return comp,decomp
class Segment_Tree:
def __init__(self,N,f,e,lst=None,dynamic=False):
self.f=f
self.e=e
self.N=N
if dynamic:
self.segment_tree=defaultdict(lambda:self.e)
else:
if lst==None:
self.segment_tree=[self.e]*2*self.N
else:
assert len(lst)<=self.N
self.segment_tree=[self.e]*self.N+[x for x in lst]+[self.e]*(N-len(lst))
for i in range(self.N-1,0,-1):
self.segment_tree[i]=self.f(self.segment_tree[i<<1],self.segment_tree[i<<1|1])
def __getitem__(self,i):
if type(i)==int:
if -self.N<=i<0:
return self.segment_tree[i+self.N*2]
elif 0<=i<self.N:
return self.segment_tree[i+self.N]
else:
raise IndexError("list index out of range")
else:
a,b,c=i.start,i.stop,i.step
if a==None:
a=self.N
else:
a+=self.N
if b==None:
b=self.N*2
else:
b+=self.N
return self.segment_tree[slice(a,b,c)]
def __setitem__(self,i,x):
if -self.N<=i<0:
i+=self.N*2
elif 0<=i<self.N:
i+=self.N
else:
raise IndexError("list index out of range")
self.segment_tree[i]=x
while i>1:
i>>= 1
self.segment_tree[i]=self.f(self.segment_tree[i<<1],self.segment_tree[i<<1|1])
def Build(self,lst):
for i,x in enumerate(lst,self.N):
self.segment_tree[i]=x
for i in range(self.N-1,0,-1):
self.segment_tree[i]=self.f(self.segment_tree[i<<1],self.segment_tree[i<<1|1])
def Fold(self,L=None,R=None):
if L==None:
L=self.N
else:
L+=self.N
if R==None:
R=self.N*2
else:
R+=self.N
vL=self.e
vR=self.e
while L<R:
if L&1:
vL=self.f(vL,self.segment_tree[L])
L+=1
if R&1:
R-=1
vR=self.f(self.segment_tree[R],vR)
L>>=1
R>>=1
return self.f(vL,vR)
def Fold_Index(self,L=None,R=None):
if L==None:
L=self.N
else:
L+=self.N
if R==None:
R=self.N*2
else:
R+=self.N
if L==R:
return None
x=self.Fold(L-self.N,R-self.N)
while L<R:
if L&1:
if self.segment_tree[L]==x:
i=L
break
L+=1
if R&1:
R-=1
if self.segment_tree[R]==x:
i=R
break
L>>=1
R>>=1
while i<self.N:
if self.segment_tree[i]==self.segment_tree[i<<1]:
i<<=1
else:
i<<=1
i|=1
i-=self.N
return i
def Bisect_Right(self,L=None,f=None):
if L==self.N:
return self.N
if L==None:
L=0
L+=self.N
vl=self.e
vr=self.e
l,r=L,self.N*2
while l<r:
if l&1:
vl=self.f(vl,self.segment_tree[l])
l+=1
if r&1:
r-=1
vr=self.f(self.segment_tree[r],vr)
l>>=1
r>>=1
if f(self.f(vl,vr)):
return self.N
v=self.e
while True:
while L%2==0:
L>>=1
vv=self.f(v,self.segment_tree[L])
if f(vv):
v=vv
L+=1
else:
while L<self.N:
L<<=1
vv=self.f(v,self.segment_tree[L])
if f(vv):
v=vv
L+=1
return L-self.N
def Bisect_Left(self,R=None,f=None):
if R==0:
return 0
if R==None:
R=self.N
R+=self.N
vl=self.e
vr=self.e
l,r=self.N,R
while l<r:
if l&1:
vl=self.f(vl,self.segment_tree[l])
l+=1
if r&1:
r-=1
vr=self.f(self.segment_tree[r],vr)
l>>=1
r>>=1
if f(self.f(vl,vr)):
return 0
v=self.e
while True:
R-=1
while R>1 and R%2:
R>>=1
vv=self.f(self.segment_tree[R],v)
if f(vv):
v=vv
else:
while R<self.N:
R=2*R+1
vv=self.f(self.segment_tree[R],v)
if f(vv):
v=vv
R-=1
return R+1-self.N
def __str__(self):
return "["+", ".join(map(str,self.segment_tree[self.N:]))+"]"
class Cumsum:
def __init__(self,lst,mod=0):
self.N=len(lst)
self.mod=mod
self.cumsum=[0]*(self.N+1)
self.cumsum[0]=0
for i in range(1,self.N+1):
self.cumsum[i]=self.cumsum[i-1]+lst[i-1]
if self.mod:
self.cumsum[i]%=self.mod
def __getitem__(self,i):
if type(i)==int:
if 0<=i<self.N:
a,b=i,i+1
elif -self.N<=i<0:
a,b=i+self.N,i+self.N+1
else:
raise IndexError('list index out of range')
else:
a,b=i.start,i.stop
if a==None or a<-self.N:
a=0
elif self.N<=a:
a=self.N
elif a<0:
a+=self.N
if b==None or self.N<=b:
b=self.N
elif b<-self.N:
b=0
elif b<0:
b+=self.N
s=self.cumsum[b]-self.cumsum[a]
if self.mod:
s%=self.mod
return s
def __setitem__(self,i,x):
if -self.N<=i<0:
i+=self.N
elif not 0<=i<self.N:
raise IndexError('list index out of range')
self.cumsum[i+1]=self.cumsum[i]+x
if self.mod:
self.cumsum[i+1]%=self.mod
def __len__(self):
return self.N
def __str__(self):
lst=[self.cumsum[i+1]-self.cumsum[i] for i in range(self.N)]
if self.mod:
for i in range(self.N):
lst[i]%=self.mod
return "["+", ".join(map(str,lst))+"]"
def Swap_Count(N,A,B):
if sorted(A)==sorted(B):
idxA={tpl:i for i,tpl in enumerate(sorted([(A[i],i) for i in range(N)]))}
idxB={tpl:i for i,tpl in enumerate(sorted([(B[i],i) for i in range(N)]))}
for i in range(N):
A[i]=idxA[(A[i],i)]
B[i]=idxB[(B[i],i)]
idx={A[i]:i for i in range(N)}
for i in range(N):
B[i]=idx[B[i]]
retu=Inversion_Number(B)
else:
retu=-1
return retu
N=int(readline())
A=[int(readline()) for i in range(N)]
comp,decomp=Compress(A)
le=len(comp)
for i in range(N):
A[i]=comp[A[i]]
ans=Inversion_Number(A)
C=[0]*(le+1)
for a in A:
C[a+1]+=1
for i in range(1,le+1):
C[i]+=C[i-1]
for a in A:
print(ans)
ans-=C[a]
ans+=(C[le]-C[a+1])