Do you have the constraints for both problems?

small correction: Instead of here we change -1 to 0, it should be here we change -1 to 5

can a problem be done like this .. for every number store (rightsum-leftsum) in a map ..

for given case : 11 1 1 1 -9 -9 would be the corresponding (rightsum-leftsum)..

now check for each number .. if we change -1 to 0.. check how many times we have 1 in the map .. similarly check for -5 for element 5

for first question compute prefix sum and store the frequency of element in map now start iterating from left to right if you making ith element zero count frequency of element (sum+pref[i])/2 on left side and right side and take max of the sum.

for second question first compute matrix is_palindrome[i][j] (0 and 1) now find number of palindrome from i to j using dp. dp[i][j]=dp[i+1][j]+dp[i][j-1]+is_palindrome[i][j]-dp[i+1][j-1] (takes o(n^2)) now compute number of triplet from (0,i),(i+1,j-1),(j+1,n) using two nested loop and take the sum of the product . I think this will work here is code for dp.

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

int palindrome(int i,int j,string &s,vector<vector<int>>&dp1){
    if(i==j){
        return dp1[i][j]=1;
    }
    if(i+1==j){
        return dp1[i][j]=(s[i]==s[j]?1:0);
    }
    if(dp1[i][j]!=-1)return dp1[i][j];

    if(s[i]!=s[j])return dp1[i][j]=0;

    return dp1[i][j]=palindrome(i+1,j-1,s,dp1);
}

int pcount(int i,int j,vector<vector<int>>&dp1){
    if(i==j){
        return dp1[j][i]=1;
    }
    if(i+1==j){
        if(dp1[i][j]==1){
            return dp1[j][i]=3;
        }
        else return dp1[j][i]=2;
    }
    if(dp1[j][i]!=-1)return dp1[j][i];

    return dp1[j][i]=pcount(i+1,j,dp1)+pcount(i,j-1,dp1)-pcount(i+1,j-1,dp1)+dp1[i][j];
}

int32_t main(){
    string s;
    cin>>s;
    int n=(int)s.size();
    vector<vector<int>>dp1(n,vector<int>(n,-1));
    for(int i=0; i<n; i++){
        for(int j=i; j<n; j++){
            if(dp1[i][j]==-1){
                palindrome(i,j,s,dp1);
            }
        }
    }
    pcount(0,n-1,dp1);


    }

}

2nd question is DP we choose a substring if it is palindrome and 3 palindromes are required so we decrease the required count by one and will try to find the next remaining palindromes we can precompute the next indices for an index that will form a palindrome or we can check on go that will be overall worst worst-case O(n^2) here is the code:-

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

int dp[1005][4];

bool ispalindrome(string s)
{
    string temp=s;
    reverse(temp.begin(),temp.end());
    if(s==temp)
        return true;
    return false;
}


int counttriplets(int ind,int rem,string s)
{
    if(rem==0)
        return 1;

    if(ind==s.size())
        return 0;

    if(dp[ind][rem]!=-1)
        return dp[ind][rem];

    string temp="";
    int ans=0;
    for(int i=ind;i<s.size();i++)
    {
        temp+=s[i];
        if(ispalindrome(temp)==true)
            ans+=(counttriplets(i+1,rem-1,s));
    }
    for(int i=ind+1;i<s.size();i++)
    {
        ans+=counttriplets(i,rem,s);
    }
    dp[ind][rem]=ans;
    return ans;
}



int main() {
    int n;
    cin>>n;
    string s;
    cin>>s;

    for(int i=0;i<=n;i++)
    {
        dp[i][0]=-1;
        dp[i][1]=-1;
        dp[i][2]=-1;
        dp[i][3]=-1;
    }
    int ans=0;
    ans=counttriplets(0,3,s);
    cout<<ans<<"\n";


    return 0;
}

I think this will work if any correction needed pls do let me know it would be grateful to know other approaches...

whats the approach for second one?

I have pics for these questions. Drive Link

For question 2 ig the following code should work (comments to explain what i did) Let me know if there are any testcases on which my code fails.

#include<bits/stdc++.h>
using namespace std;
#define ll long long 
vector<vector<ll>> build(vector<vector<ll>>&palindrome){
    ll n=palindrome.size();ll m=palindrome[0].size();
    vector<vector<ll>>prefix(n+1,vector<ll>(m+1));
    //prefix[i][j] sum of matrix from 1,1 to i+1,j+1 ka submatrix
    //prefix[i][j] ki indexing is 1 based
    for(ll i=0;i<=n;i++)prefix[i][0]=0;
    for(ll j=0;j<=m;j++)prefix[0][j]=0;
    for(ll i=1;i<=n;i++){
        for(ll j=1;j<=m;j++){
            prefix[i][j]=palindrome[i-1][j-1]+prefix[i-1][j]+prefix[i][j-1]-prefix[i-1][j-1];
        }
    }
    return prefix;
}
ll queries(vector<vector<ll>>&prefix,ll r1,ll c1,ll r2,ll c2){
    //queries me 0 based index hi bhejo !! 
    return prefix[r2+1][c2+1]-prefix[r1][c2+1]-prefix[r2+1][c1]+prefix[r1][c1];
}
int main(){
    ll n;cin>>n;string s;cin>>s;
    vector<vector<ll>>palindrome(n,vector<ll>(n));
    for(ll i=0;i<n;i++)palindrome[i][i]=1;
    for(ll i=n-2;i>=0;i--){
        for(ll j=i+1;j<n;j++){
            if(s[i]==s[j]){
                if(i+1<=j-1 && palindrome[i+1][j-1])palindrome[i][j]=1;
                else if(i+1>j-1 && s[i]==s[j])palindrome[i][j]=1;
            }
        }
    }
    vector<vector<ll>>prefix=build(palindrome);
    //number of palindromic substrings in a substring of a string starting with index i and ending with index j 
    //is given by queries(prefix,i,i,j,j) ->we have to check palindrome[i][i]+palindrome[i][i+1]....+palindrome[i][j]+....palindrome[j][j]
    vector<ll>subquery(n);
    //subquery[i] calculates palindromic pairs of substring starting from index i to end of string 
    vector<ll>temp(n);
    for(ll i=0;i<n;i++){
        for(ll j=0;j<n;j++){
            if(palindrome[i][j] && j<n-1){
                temp[i]+=queries(prefix,j+1,j+1,n-1,n-1);
                
            }
        }
    }
    //abhi tak temp[i] gives the number of palindric doublets s.t one palindrome starts at i
    subquery[n-1]=temp[n-1];
    for(ll i=n-2;i>=0;i--)subquery[i]=subquery[i+1]+temp[i];
    ll ans=0;
    for(ll i=0;i<n;i++){
        for(ll j=0;j<n;j++){
            if(palindrome[i][j] && j<n-2)ans+=subquery[j+1];
        }
    }
    cout<<ans<<endl;
    return 0;
}

I think the following should work for the 1st one -

#include<bits/stdc++.h>
using namespace std;
#define ll long long 
int main(){
    ll n;cin>>n;
    vector<ll>v(n);
    for(ll i=0;i<n;i++)cin>>v[i];
    vector<ll>prefix(n);vector<ll>suffix(n);
    prefix[0]=v[0];suffix[n-1]=v[n-1];
    for(ll i=1;i<n;i++)prefix[i]=prefix[i-1]+v[i];
    for(ll i=n-2;i>=0;i--)suffix[i]=suffix[i+1]+v[i];
    ll sum=0;for(ll i=0;i<n;i++)sum+=v[i];
    map<ll,ll>m;
    for(ll i=0;i<n;i++)m[suffix[i]]++;
    ll ans=0;
    map<ll,ll>m1;
    for(ll i=0;i<n;i++){
        if(i!=0)m1[prefix[i-1]]++;
        m[suffix[i]]--;
        if((sum-v[i])%2==0 && v[i]!=0){
            //Note -No use of taking v[i] in prefix or sufix coz for every prefix[i]=sum/2
            // we are partitioning after i ,and for every suffix[i]=sum/2 we are partitioning before i
            //SO it will be overcounting if we considered v[i]
            ans=max(ans,m1[(sum-v[i])/2]+m[(sum-v[i])/2]);
        }
    }
    if(sum%2==0)ans=max(ans,m1[sum/2]);
    cout<<ans<<endl;
    
    return 0;
}

This should work for q2

#include <iostream>
#include <vector>
#include <string>
using namespace std;

// Function to find all palindromic substrings
void findPalindromicSubstrings(const string& S, vector<pair<int, int>>& palindromic_pairs) {
    int n = S.length();
    vector<vector<bool>> dp(n, vector<bool>(n, false));
    
    // Single characters are palindromes
    for (int i = 0; i < n; ++i) {
        dp[i][i] = true;
        palindromic_pairs.emplace_back(i, i);
    }
    
    // Check for palindromes of length 2
    for (int i = 0; i < n - 1; ++i) {
        if (S[i] == S[i + 1]) {
            dp[i][i + 1] = true;
            palindromic_pairs.emplace_back(i, i + 1);
        }
    }
    
    // Check for palindromes of length greater than 2
    for (int length = 3; length <= n; ++length) {
        for (int i = 0; i <= n - length; ++i) {
            int j = i + length - 1;
            if (S[i] == S[j] && dp[i + 1][j - 1]) {
                dp[i][j] = true;
                palindromic_pairs.emplace_back(i, j);
            }
        }
    }
}

// Function to count good triplets
int countGoodTriplets(const string& S) {
    vector<pair<int, int>> palindromic_pairs;
    findPalindromicSubstrings(S, palindromic_pairs);
    
    int count = 0;
    int m = palindromic_pairs.size();
    
    for (int a = 0; a < m; ++a) {
        for (int b = a + 1; b < m; ++b) {
            for (int c = b + 1; c < m; ++c) {
                if (palindromic_pairs[a].second < palindromic_pairs[b].first && 
                    palindromic_pairs[b].second < palindromic_pairs[c].first) {
                    ++count;
                }
            }
        }
    }
    
    return count;
}

// Example usage
int main() {
    string S = "ababa";
    cout << countGoodTriplets(S) << endl;  // Output: number of good triplets
    return 0;
}