如何在以下C ++代码中进行记忆

Question

Actually i am trying to solve SPOJ Problem: [SPOJ] http://www.spoj.com/problems/SQRBR/ . I came up with recurence to solve it but i am not getting how to do memoisation. Any suggestion on how to memoisation for given problem will be helpful. my code is giving correct answer , but it is giving TLE in spoj Here my code :

#include <iostream>
#include <cstdio>

using namespace std;

void balancedParen(int n, int open, int position, int close, char str[], string s,    long long int &counter) {
if(close == n) {
    str[pos] = '\0';
    printf("%s\n", str);
    counter++;
    return;
}

if(s[position] == '(' ) {
  if(open <= n-1) {
    str[position] = '(';
    balancedParen(n, open+1, position+1, close, str, s, counter);
  }
} else {
  if(open < n) {
    str[position] = '(';
    balancedParen(n, open+1, position+1, close, str, s, counter);
  }
  if(open > close) {
    str[position] = ')';
    balancedParen(n, open, position+1, close+1, str, s, counter);
  }
}
    return ;
}

int main() {
      int a[100], n, k, i;
      long long counter = 0;
      int testCases;

      scanf("%d", &testCases);

      while(testCases--) {
              scanf("%d", &n);
              scanf("%d", &k);
              char str[100];
              string s = "..........................................................................";
      for(i = 0; i < k; i++) {
              scanf("%d", &a[i]);
              s[a[i]-1] = '(';
       }
      balancedParen(n, 0, 0, 0, str, s, counter);
      printf("%lld\n", counter);
      counter = 0;
   }
     return 0;
} 

Answer 1

I can think of one relatively simple and possibly significant optimization.

First, instead of making the "counter" a reference, make it the return value of the function. Hear me out for a bit here.

Now say the positions you're given are "1, 7, 15". Instead of recursively going "1, 2, 3, 4, 5, 6, 7", you can be a little tricky and go to 7 in one step.

You just need to count the number of permutations which can be used to go between 1 and 7, for every possible number of opening parens (in this case, 3, 4, 5 and 6)

For example, how many ways exist to have 3 opening parens between 1 and 7?

[[[]]]
[[][]]
[][][]
[[]][]
[][[]]

5 permutations (unless I missed one). So you can add 5*balancedParen(n, open+3, position+6, close+3, str, s, counter) to your result. And do a similar thing for 4, 5, and 6 opening parens.

Of course you'd need to write another function (recursive approach seems simplest) to find that number "5". But the advantage is that the total number of function calls is now (calls to get from 1 to 7) + (calls to get from 7 to 15) , rather than (calls to get from 1 to 7) * (calls to get from 7 to 15) .

Here is some code which should work using the algorithm I described:

int countPermutations(int unclosed, int length, int toOpen)
{
    if (toOpen > length) // impossible to open this many, not enough length
        return 0;
    int toClose = length-toOpen;
    if (toClose - toOpen > unclosed)
        return 0; // No possibilities; not enough open parens to fill the length
    if (toOpen == 0 || toOpen == length)
        return 1; // Only one possibility now
    int ret = 0;
    if (toOpen > 0) // Count permutations if we opened a paren here
        ret += countPermutations(unclosed+1, length-1, toOpen-1); 
    if (unclosed > 0) // Count permutations if we closed a paren here
        ret += countPermutations(unclosed-1, length-1, toOpen); 
    return ret;
}

int countNLengthSolutions(int n, int unclosed, int position, int *positions, int remainingPositions)
{
    if (n % 2 != 0)
        return 0; // must be a length divisible by 2
    if (position > n)
        return 0;
    if (n-position < unclosed)
        return 0; // too many open parens, no way to complete within length

    if (remainingPositions == 0)
    {
        // Too many open parens to close by the time we get to length N?
        if ((n - position) < unclosed) 
            return 0;
        else // Say we have 4 open and a length of 10 to fill; we want (10-4)/2 = 3 more open parens.
            return countPermutations(unclosed, n-position, (n-position - unclosed)/2); 
    }
    else
    {
        int ret = 0;
        int toFill = *positions - position - 1;
        for (int openParens = 0; openParens <= toFill; openParens++)
        {
            int permutations = countPermutations(unclosed, toFill, openParens);
            if (permutations > 0)
                ret += permutations*countNLengthSolutions(n, unclosed+(2*openParens-toFill)+1, position+toFill+1, positions+1, remainingPositions-1);
        }
        return ret;
    }
}

I may have a bug somewhere, I didn't really spend the time to check, but I verified it works for all the sample input.