True dude, I'm stuck on F and G. Mostly I will pass ABCDE and think for F or G and solve it (at least solve half of it) but this time I really have no idea.

Don't understand why the editorial was written like that. There are ways that don't require any operations with numbers greater than $$$n$$$.

Maybe I need a book called "Python Crash Course"

Relatable

Just brute force on all permutations and calculate minimum.

plz explain in details how to solve it using seg tree ?

E doesn't actually need lazy segtree. If you reorder the "queries" in a clever way, you can see that the seg operations reduce to simply adding one to a segment and querying total sum. This doesn't need a tree at all, and in fact doesn't require the array itself to be built. Maintaining the total sum as well as the last occurrence of each element was sufficient: https://atcoder.jp/contests/abc371/submissions/57767852

C was bruteforce. Observe that $$$O(n! \space n^2 \log n)$$$ passes.

template <class T> struct BIT { //1-indexed
  int n; vector<T> t;
  BIT() {}
  BIT(int _n) {
    n = _n; t.assign(n + 1, 0);
  }
  T query(int i) {
    T ans = 0;
    for (; i >= 1; i -= (i & -i)) ans += t[i];
    return ans;
  }
  void upd(int i, T val) {
    if (i <= 0) return;
    for (; i <= n; i += (i & -i)) t[i] += val;
  }
  void upd(int l, int r, T val) {
    upd(l, val);
    upd(r + 1, -val);
  }
  T query(int l, int r) {
    return query(r) - query(l - 1);
  }
};
void dxt(){
	int n; cin >> n;
	vector<int> ar(n + 1), freq(n + 1);
	vector<vector<int>> occ(n + 1);
	set<int> st; int ans = 0;
	BIT<int> bit(n + 10);
	for(int i = 1; i <= n; ++i){
		cin >> ar[i];
		st.insert(ar[i]);
		ans += st.size();
		freq[i] = st.size();
		bit.upd(i, freq[i]);
		occ[ar[i]].push_back(i);
	}
	for(int i = 1; i <= n; ++i){
		if(occ[i].size()){
			if(occ[i].back() != n){
				occ[i].push_back(n);
			}
		}
	}
	debug(occ);
	auto search = [&](int idx, int key){
		int low = 0, high = occ[idx].size() - 1, ans;
		while(low <= high){
			int mid = (low + high)/2;
			if(occ[idx][mid] <= key){
				low = mid + 1;
			}
			else{
				ans = mid;
				high = mid - 1;
			}
		}
		return ans;
	};
	for(int i = 2; i <= n; ++i){
		int x = ar[i - 1];
		int idx = search(x, i - 1);
		debug(bit.query(i, n));
		bit.upd(i, occ[x][idx], -1);
		debug(bit.query(i, n));
		int t = bit.query(i, n);
		debug(x, occ[x][idx]);
		ans += t;
	}
	cout << ans << endl;
}

I am solving with the exact logic you have mentioned but using fenwick tree but it isn't behaving like I want it to, Am I implementing the fenwick tree wrong?

Maybe, but it was only for the 2nd time in my life I was able to solve an E. So I'm pretty happy regardless.

plz explain in details how to solve it using seg tree ?

Here's what I did:

First I realized that the approach simplified if I considered the sum of all subarrays ending at position $$$0$$$, then at position $$$1$$$, etc. For example, let's say that the array $$$a = 1, 2, 3, 2$$$

For each subarray of $$$a$$$, define the array $$$b$$$ to be all the $$$f(i, end)$$$ for all $$$i$$$. In the subarray $$$1, 2, 3$$$, then $$$b = 3, 2, 1$$$. There's a pattern in how each $$$b_i$$$ transforms to the next one:

$$$b(1, 2) = 2, 1, 0, 0$$$

$$$b(1, 2, 3) = 3, 2, 1, 0$$$

$$$b(1, 2, 3, 2) = 3, 2, 2, 1$$$

The pattern I noticed is that each added number $$$i$$$ increases all the values of $$$b$$$ between $$$i$$$ and the last occurance of $$$i$$$. It turns out that we don't actually need the array to be stored at all, and can just store and update the total sum of $$$b$$$.

My code here: https://atcoder.jp/contests/abc371/submissions/57767852