<p>You have <code>n</code> dice, and each dice has <code>k</code> faces numbered from <code>1</code> to <code>k</code>.</p>

<p>Given three integers <code>n</code>, <code>k</code>, and <code>target</code>, return <em>the number of possible ways (out of the </em><code>k<sup>n</sup></code><em> total ways) </em><em>to roll the dice, so the sum of the face-up numbers equals </em><code>target</code>. Since the answer may be too large, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> n = 1, k = 6, target = 3
<strong>Output:</strong> 1
<strong>Explanation:</strong> You throw one die with 6 faces.
There is only one way to get a sum of 3.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> n = 2, k = 6, target = 7
<strong>Output:</strong> 6
<strong>Explanation:</strong> You throw two dice, each with 6 faces.
There are 6 ways to get a sum of 7: 1+6, 2+5, 3+4, 4+3, 5+2, 6+1.
</pre>

<p><strong class="example">Example 3:</strong></p>

<pre>
<strong>Input:</strong> n = 30, k = 30, target = 500
<strong>Output:</strong> 222616187
<strong>Explanation:</strong> The answer must be returned modulo 10<sup>9</sup> + 7.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= n, k &lt;= 30</code></li>
	<li><code>1 &lt;= target &lt;= 1000</code></li>
</ul>

class Solution {
public:
    long long int mod=1000000007;
    long long int solve(long long int n,long long int k,long long int target,vector<vector< long long int>>&dp){
        if(n==0&&target==0){
            return 1;
        }
        if(target!=0 && n==0){
            return 0;
        }
        if(target==0 && n!=0){
            return 0;
        }

        if(dp[target][n]!=-1){
            return dp[target][n];
        }
        long long int ans=0;
        for(int i=1;i<=k;i++){
          //  long long recu=0;
           // if(target-i>=0){
            //ans+=solve(n-1,k,target-i,dp);

           // }
           // ans=(ans%mod+(solve(n-1,k,target-i,dp))%mod)%mod;
            long long recans=0;
            if(target-i>=0){
                recans=solve(n-1,k,target-i,dp);
                ans=(ans%mod+recans%mod)%mod;
            }
        }
        return dp[target][n]=ans;
    }
   int solvetab(int n,int k,int target){
        vector<vector<int>>dp(target+3,vector<int>(n+3,0));
        dp[0][0]=1;
        for(int t=1;t<=target;t++){
        for(int index=1;index<=n;index++){
        long long int ans=0;
        for(int i=1;i<=k;i++){
            long long recu=0;
            if(t-i>=0){
            recu+=dp[t-i][index-1];        //t-i index-1
            }
            ans=(ans%mod+recu%mod)%mod;
        }
         dp[t][index]=ans;

            }}
        return dp[target][n];
    }
    /*
      int morespace(int n,int k,int target){
        vector<int>prev(target+1,0);
          vector<int>curr(target+1,0);
        prev[0]=1;

        for(int index=1;index<=n;index++){
        for(int t=1;t<=target;t++){
        long long int ans=0;
        for(int i=1;i<=k;i++){
            long long recu=0;
            if(t-i>=0){
            recu+=prev[t-i];        
            }
            ans=(ans%mod+recu%mod)%mod;
        }
         curr[t]=ans;

            }
            prev=curr;
        }
        return prev[target];
    }*/
    int numRollsToTarget(int n, int k, int target) {

        vector<vector<long long int>>dp(target+1,vector< long long int>(n+1,-1));
     //   long long int ans=solve(n, k, target,dp);
        long long int ans=solvetab(n,k,target);
        return ans;
    }
};
15920