I also noticed that the Bunny Hops subtask #1 needed this. But didn't get any idea to implement that.
Though here is a GFG blog — Count all increasing subsequences(Which is almost the reverse of your query). But this only works when array elements are<10.

First, let's do coordinate compression on the array. That way, every number is in the range $$$[1, n]$$$.

Now, let's do DP. Let $$$dp(i)$$$ be the number of decreasing sequences (including the one with size 1) ending at position $$$i$$$. Obviously: $$$dp(i) = 1 + \displaystyle\sum_{j < i : a_j > a_i} dp(j)$$$.

But that takes quadratic time. Let's optimize it some way. Let's keep an auxiliary array cnt[], where cnt[x] is the number of strictly decreasing sequences with the last element equal to $$$x$$$.

Then, we can say that $$$dp(i) = 1 + \displaystyle\sum_{j > a_i} cnt[j]$$$. So, we can go from left to right, computing $$$dp(i)$$$ and after computing it, we update $$$cnt[]$$$ -cnt[a[i]] += dp[i].

Well, that solution is still quadratic, but we can optimize it with a data structure. Take a look at the operations that we do over the $$$cnt[]$$$ array; we are taking the sum of a suffix, and updating a single position. What well-known data structure allows us to do those operations quickly? Segment Tree, or Binary Indexed Tree (Fenwick Tree). Then, the time complexity would be $$$\mathcal{O}(n\cdot \log n)$$$.

Sample Code

struct fenwick_tree{
    
     // ...

     void add(int pos, int val){

          // this implements the operation ADD A VALUE TO A POSITION
     }

     void suffix_sum(int pos){

          // this implements the operation GET THE SUM OF A SUFFIX
     }
} DS;

ll dp[maxn];

// ...

for(int i = 1; i <= n; i++){
    dp[i] = 1 + DS.suffix_sum(a[i] + 1);
    DS.add(a[i], dp[i]);
}

Then, the total answer is $$$\displaystyle\sum_{i=1}^n (dp(i)-1)$$$, (we subtract 1 to not count sequences of length 1).

I dont think Subtask 1 is the same as the problem you are asking (it does involve counting the total number of decreasing subsequences). A simple one-liner is sufficient for subtask 1.

If you want to solve the aforementioned problem you can take the smallest decreasing subsequence that satisfies the mentioned constraints. To do this you can keep track of the maximum number encountered by you from the reverse of the array. Here's my python code for the problem.

for _ in range(int(input())):
    n=int(input())
    # n,k=[int(i) for i in input().split(" ")]
    arr=[int(i) for i in input().split(" ")]
    mx = max(arr)
    mx1=max(arr[:n-1])
    if mx1>arr[0] or arr[0]<arr[-1]: print(-1)
    else:
        mx = arr[-1]
        mxes=[]
        for i in range(n-1,0,-1):
            mx = max(arr[i],mx)
            mxes.append(mx)
        print(len(set(mxes)))