Dp state is : I am standing currently at index i, and I want subarray ending at me with sum = j. Then, this dp state will tell me, how many ways are there to solve the question for array a[0...i]. So, there are n^2 states possible.

You were iterating from left to right. You will put the subarray (I am considering subarrays with right index < i) sums possible till now in a pbds ordrered_set (or something else), and easily get the count of sums less than my desired sum, that is j. This count will go into dp[i][j].

Answer will be sum of dp[n — 1][j] for all possible j's at n — 1 index.

Tip: Use map for storing the second dimension in dp state.

If there is any mistake in my approach, please point out.

// this is code

#include <bits/stdc++.h>
using namespace std;

int main() {
	// your code goes here
	int n;
	cin>>n;
	map<int,int>dp[n+1];
	vector<int>v(n);
	for(int i=0;i<n;i++){
	    cin>>v[i];
	}
	vector<vector<int>>help(n+1);
	vector<vector<int>>help1(n+1);
    for(int i=n-1;i>=0;i--){
        int sum=0;
        for(int j=i;j<n-1;j++){
            sum=sum+v[j];
            // for(auto it:dp[j+1]){
            //     if(it.first>sum){
            //         dp[i][sum]=dp[i][sum]+it.second;
            //     }
            // }
            int index=upper_bound(help[j+1].begin(),help[j+1].end(),sum)-help[j+1].begin();
            if(index!=help[j+1].size()){
                int tot=help1[j+1].back();
                if(index!=0){
                    tot=tot-help1[j+1][index-1];
                }
                dp[i][sum]=dp[i][sum]+tot;
            }
        }
        dp[i][sum+v[n-1]]+=1;
        for(auto it:dp[i]){
            help[i].push_back(it.first);
            if(help1[i].size()==0){
                help1[i].push_back(it.second);
            }
            else{
                help1[i].push_back(it.second+help1[i].back());
            }
        }
    }
   
    int ans=0;
    for(auto it:dp[0]){
        ans=ans+it.second;
    }
    cout<<ans<<endl;
}