Optimizing this code to check sum - c

Question

This is the problem, I'm trying to solve in SPOJ. I am getting time limit exceeded problem. I can't find a way to optimize the algorithm. Can you give me some tips.
Here is the problem:
Leonard had to find the number of continuous sequence of numbers such
that their sum is zero.
For example if the sequence is- 5, 2, -2, 5, -5, 9
There are 3 such sequences
2, -2
5, -5
2, -2, 5, -5
Since this is a golden opportunity for Leonard to rewrite the Roommate
Agreement and get rid of Sheldon's ridiculous clauses, he can't afford
to lose. So he turns to you for help. Don't let him down.
Input
First line contains T - number of test cases
Second line contains n - the number of elements in a particular test
case.
Next line contain n elements, ai (1<=i<= n) separated by spaces.
Output
The number of such sequences whose sum if zero.
Constraints
1<=t<=5
1<=n<=10^6
-10<= ai <= 10
Below is my code:
#include<stdio.h>
main()
{
int t, j, k, l, sum;
long long int num, out = 0;
long long int ai[1000001];
scanf("%d",&t);
while(t--)
{
for(j=0;j<=num;j++)
{
scanf("%lld",&ai[j]);
}
for(l=0;l<=num;l++)
{
for(k=l; k<=num; k++)
{
if(sum == 0)
{
num++;
}
else
{
sum = sum + ai[k];
}
}
printf("%d", &num);
}
}
return 0;
}

Answer 1

Let S[i] be the sum of elements from index 0 to index i (prefix sum). Set S[-1] = 0.
You can observe that if a sequence from index i to index j (j > i) sums to 0, S[j] - S[i-1] = 0, or S[j] = S[i-1].
In order to solve this problem, just keep a mapping of the value of S[i] (i=-1..n-1) to the frequency of the sum. If a particular sum recurs k times, you can have k choose 2 ways to pairing up the indices to create distinct sequences. You can obtain the total number of sequences by summing up all the ways to pair up the indices, by going through all the keys and check the frequency at the end.
The implementation of the map should be at most O(log n) for insert and update operations. This will allow to you to solve the problem with overall complexity of O(n log n): prefix sum O(n), insert/update the map O(n log n), going through the whole map to sum up the result O(n).
Pseudocode:
a[n] // Array of elements
m = new Map[Int->Int] // Frequency mapping
s = 0 // Prefix sum
m[s] += 1
for (i = 0; i < n; i++) {
s += a[i] // Prefix sum of array of elements a
m[s] += 1 // Increment frequency of the prefix sum by 1
}
out = 0
// Go through all key values in the map
m.traverse(function (key, value) {
// Add the number of pairs of indices that has the same prefix sum
out += value * (value - 1) / 2
})
return out

Answer 2

This is my solution, it is similar to nhahtdh, but the time complexity is O(n)
Pseudocode:
int pos[10000001];
int neg[10000001];
int sum = 0;
int result = 0;
for(int i = 0; i < arr.length; i++){
sum += arr[i];
if(sum > 0){
result += pos[sum];
pos[sum]++;
}else{
result += neg[-sum];
neg[-sum]++;
}
}
return result;