Problem:
Score : 100 points

Problem Statement

Let N be a positive integer.
You are given a string s of length N - 1, consisting of < and >.

Find the number of permutations (p_1, p_2, \ldots, p_N) of (1, 2, \ldots, N) that satisfy the following condition, modulo 10^9 + 7:

For each i (1 \leq i \leq N - 1), p_i < p_{i + 1} if the i-th character in s is <, and p_i > p_{i + 1} if the i-th character in s is >.

Constraints

N is an integer.

2 \leq N \leq 3000

s is a string of length N - 1.

s consists of < and >.

Input

Input is given from Standard Input in the following format:

N
s

Output

Print the number of permutations that satisfy the condition, modulo 10^9 + 7.

Sample Input 1

4
<><

Sample Output 1

5

There are five permutations that satisfy the condition, as follows:

(1, 3, 2, 4)

(1, 4, 2, 3)

(2, 3, 1, 4)

(2, 4, 1, 3)

(3, 4, 1, 2)

Sample Input 2

5
<<<<

Sample Output 2

1

There is one permutation that satisfies the condition, as follows:

(1, 2, 3, 4, 5)

Sample Input 3

20
>>>><>>><>><>>><<>>

Sample Output 3

217136290

Be sure to print the number modulo 10^9 + 7.

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

//Om Sree Sai Ram
#include "bits/stdc++.h"
using namespace std;

const int mod = 1e9+7;

void add_self(int&a,int b)
{
  a+=b;
  if(a>=mod)
  {
    a-=mod;
  }
}


int main() 
{


int N;
cin>>N;
string s;
cin>>s;
vector<vector<int>>dp(N+1,vector<int>(N+1));
vector<vector<int>> prefix(N+1,vector<int>(N+1));
// dp[i][j] represents number of ways to fill prefix of size i
// with numbers 1 to i. And the last number filled is j.

dp[1][1] =1;
// if i=1; number of ways to fill it is 1 as 1 can only be filled.

// Now we have to calculte the ways for increasing lengths


for(int i=2;i<=N;i++)
{
  

  for(int j=1;j<i;j++)
  {
    prefix[i-1][j] = (prefix[i-1][j-1]+dp[i-1][j])%mod;

  }

  for(int j=1;j<=i;j++)
  {
    int fill_value = j;
    int L,R;
    //Did'nt understand the logic completely
    if(s[i-2]=='<')
    {
      L = 1;
      R = j-1;
    }
    else
    {
      L = j;
      R = i-1;
    }
    if(L<=R)
    add_self(dp[i][j],(prefix[i-1][R]-prefix[i-1][L-1]+mod)%mod);
    // for(int k=L;k<=R;k++)
    // {
    //   add_self(dp[i][j],dp[i-1][k]);
    // }
    //O(n^3 algorithm) 
    //This understood but am not confident
    // for(int k=1;k<i;k++)
    // {
    //   int true_value = k;
    //   if(k>=j)
    //   {
    //     true_value++;
    //   }

    //   if((true_value<j) != (s[i-2]=='<'))
    //   {
    //     continue;
    //   }

    //   add_self(dp[i][j],dp[i-1][k]);

    // }
  }

}
int ans =0;

for(auto c:dp[N])
{
  add_self(ans,c);
}
cout<<ans<<endl;

}