Problem:
Score : 800 points

Problem Statement

There are N squares arranged in a row.
The squares are numbered 1, 2, ..., N, from left to right.

Snuke is painting each square in red, green or blue.
According to his aesthetic sense, the following M conditions must all be satisfied.
The i-th condition is:

There are exactly x_i different colors among squares l_i, l_i + 1, ..., r_i.

In how many ways can the squares be painted to satisfy all the conditions?
Find the count modulo 10^9+7.

Constraints

1 ≤ N ≤ 300

1 ≤ M ≤ 300

1 ≤ l_i ≤ r_i ≤ N

1 ≤ x_i ≤ 3

Input

Input is given from Standard Input in the following format:

N M
l_1 r_1 x_1
l_2 r_2 x_2
:
l_M r_M x_M

Output

Print the number of ways to paint the squares to satisfy all the conditions, modulo 10^9+7.

Sample Input 1

3 1
1 3 3

Sample Output 1

6

The six ways are:

RGB

RBG

GRB

GBR

BRG

BGR

where R, G and B correspond to red, green and blue squares, respectively.

Sample Input 2

4 2
1 3 1
2 4 2

Sample Output 2

6

The six ways are:

RRRG

RRRB

GGGR

GGGB

BBBR

BBBG

Sample Input 3

1 3
1 1 1
1 1 2
1 1 3

Sample Output 3

0

There are zero ways.

Sample Input 4

8 10
2 6 2
5 5 1
3 5 2
4 7 3
4 4 1
2 3 1
7 7 1
1 5 2
1 7 3
3 4 2

Sample Output 4

108

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

#include "bits/stdc++.h"
#define ll long long
#define rep2(i,a,b) for(int i=a;i<=b;++i)
#define rep(i,n) for(int i=0;i<n;i++)
#define pii pair<int,int>
#define tii tuple<int,int,int>
#define pq priority_queue<int>
#define pqg priority_queue<int,vector<int>,greater<int>>
#define pb push_back
#define edge(v,a,b) v[a].pb(b);v[b].pb(a);
int MOD=1e9+7;
#define INF 2*1e9
#define N 310000 
using namespace std;
string alphabet("abcdefghijklmnopqrstuvwxyz");

main(){
    int n,m;
    cin>>n>>m;
    pair<pii,int> p[400];
    rep(i,m){
        int l,r,x;
        cin>>l>>r>>x;
        p[i]={{r,l},x};
    }
    sort(p,p+m);
    int dp[400][400][400]={};
    dp[0][0][0]=1;
    rep(i,n){
        rep2(j,0,max(i-1,0)){
            rep2(k,0,max(0,j-1)){
                dp[i+1][i][k]=(dp[i+1][i][k]+dp[i][j][k])%MOD;
                dp[i+1][j][k]=(dp[i+1][j][k]+dp[i][j][k])%MOD;
                dp[i+1][i][j]=(dp[i+1][i][j]+dp[i][j][k])%MOD;
            }
        }
        int l=lower_bound(p,p+m,(pair<pii,int>){{i+1,0},0})-p;
        int r=upper_bound(p,p+m,(pair<pii,int>){{i+1,400},0})-p;
        rep2(j,0,i){
            rep2(k,0,max(0,j-1)){
                for(int ii=l;ii<r;ii++){
                    int count=1;
                    int s=p[ii].first.second;
                    if(s<=k){
                        count++;
                    }
                    if(s<=j){
                        count++;
                    }
                    if(count!=p[ii].second){
                        dp[i+1][j][k]=0;
                    }
                }
            }
        }
    }
    int ans=0;
    rep2(j,0,n-1){
        rep2(k,0,j-1){
            ans=(ans+dp[n][j][k])%MOD;
        }
    }
    cout<<ans;
    return 0;
}