如何减少执行此问题的时间限制

Question

from collections import Counter
def main() :

    n = int(input())
    x1 =tuple(map(int,input().split(' ')))
    n2 = int(input())
    res = []
    memo1 = []
    memo2 = []
    for s1 in range(n2):
        c = 0
        p = list(map(int, input().split(' ')))
        if p in memo1:
            c = memo2[memo1.index(p)]
        else:
            x = x1[p[0]-1 : p[1]]
            y = x1[p[2]-1 : p[3]]
            x = Counter(x)
            y = Counter(y)
            f = x - y
            common = x - f
            g = y - common
            f = f + g
            for v1 in f:
                if v1 in common:
                    c = c + (f[v1]*common[v1])
            for v1 in common:
                c = c + common[v1]**2
            memo1.append(p)
            memo2.append(c)
        res.append(c)
    print(*res,sep='\n')
 main()

It's a program against codeforces.com question

Please suggest me how to solve this...

Answer 1

Some general pointers:

1. Process the input only once, at the start of the program
2. Conditions 2 and 3 in the problem statement tell you which indices are valid. l1 <= i <= r1 and l2 <= j <= r2. Do not waste time iterating over every possible position in the input list. Only check those indices that would not violate 2 and 3.
3. Pre-processing. Condition 1 asks you to verify whether a_i and a_j are equal. You're going to be doing that a lot. So while you are processing the input, keep track (in a map / dictionary) which values are identical. That way it becomes easier to track afterwards.

Problem-specific pointers:

Look into the disjoint set datastructure. It is typically used to quickly evaluate equivalence among objects. In your case, you could set it up so that it evaluates things like 'i is equivalent to j if a_i equals a_j'.

Then you can query the datastructure to get all equivalence classes (all indices that point to equal values).

Once you have a set of numbers (the indices), you simply need to find all possible pairs of indices that match condition 2 and 3.

Answer 2

I am pretty sure that this problem can easily be solved by Segment Tree . I have tried to solve but still unable to pass all test cases.
Still, I am posting my solution, if you can optimize it further

from collections import Counter

' create segment tree in which each node will contain Counter of values'
def create(current,s,e):
    if s==e:
        tree[current]=Counter([array[s]])
        return tree[current]
    else:
        mid=(s+e)//2
        tree[current]=create(2*current+1,s,mid)+create(2*current+2,mid+1,e)
        return tree[current]

' query elements from l to r and return their counter'
def query(current,s,e,l,r):
    if s>=l and e<=r:
        return tree[current]
    if (r<s and r<e) or (l>s and l>e):
        return Counter()
    mid=(s+e)//2
    return query(2*current+1,s,mid,l,r)+query(2*current+2,mid+1,e,l,r)

n=int(input())
array=list(map(int,input().split( )))
tree=[0]*(4*n+1)
create(0,0,n-1)
#print(tree)
for _ in range(int(input())):
    l1,r1,l2,r2=map(int,input().split( ))
    ans1=query(0,0,n-1,l1-1,r1-1)
    ans2=query(0,0,n-1,l2-1,r2-1)
    ans=0
    for v in ans1:
        ans+=ans1[v]*ans2[v]
    print(ans)