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 Rust (1.15.1) (judge verdict: Time Limit Exceeded)

#[allow(unused_imports)]
use std::cmp::{max, min};
#[allow(unused_imports)]
use std::collections::{HashMap, HashSet};

mod util {
    use std::io::stdin;
    use std::str::FromStr;
    use std::fmt::Debug;

    #[allow(dead_code)]
    pub fn line() -> String {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.trim().to_string()
    }

    #[allow(dead_code)]
    pub fn get<T: FromStr>() -> T
    where
        <T as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.trim().parse().unwrap()
    }

    #[allow(dead_code)]
    pub fn gets<T: FromStr>() -> Vec<T>
    where
        <T as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.split_whitespace()
            .map(|t| t.parse().unwrap())
            .collect()
    }

    #[allow(dead_code)]
    pub fn get2<T: FromStr, U: FromStr>() -> (T, U)
    where
        <T as FromStr>::Err: Debug,
        <U as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        let mut iter = line.split_whitespace();
        (
            iter.next().unwrap().parse().unwrap(),
            iter.next().unwrap().parse().unwrap(),
        )
    }
}

const M: usize = 1000000007;
fn main() {
    let (n, m): (usize, usize) = util::get2();
    let mut r_lrx = vec![Vec::new(); n + 1];

    for _ in 0..m {
        let lrx: Vec<usize> = util::gets();
        r_lrx[lrx[1]].push(lrx);
    }

    let mut dp = vec![vec![vec![0; n + 1]; n + 1]; n + 1];
    dp[0][0][0] = 1;

    for i in 1..n + 1 {
        for k in 0..i {
            for j in 0..i {
                let l = i -1;
                dp[i][k][l] = (dp[i][k][l] + dp[j][k][l]) % M;
                dp[k][i][l] = (dp[k][i][l] + dp[k][j][l]) % M;
                dp[l][k][i] = (dp[l][k][i] + dp[l][k][j]) % M;
            }
        }
        for l in 0..i {
            for j in 0..i {
                let k = i -1;
                if k==l && l==j {
                    continue;
                }
                dp[i][k][l] = (dp[i][k][l] + dp[j][k][l]) % M;
                dp[k][i][l] = (dp[k][i][l] + dp[k][j][l]) % M;
                dp[l][k][i] = (dp[l][k][i] + dp[l][k][j]) % M;
            }
        }
        for k in 0..i {
            for l in 0..i {
                let j = i -1;
                if k==l && l==j {
                    continue;
                }
                dp[i][k][l] = (dp[i][k][l] + dp[j][k][l]) % M;
                dp[k][i][l] = (dp[k][i][l] + dp[k][j][l]) % M;
                dp[l][k][i] = (dp[l][k][i] + dp[l][k][j]) % M;
            }
        }

        for lrx in &r_lrx[i] {
            let l = lrx[0];
            let r = lrx[1];
            let x = lrx[2];

            match x {
                1 => {
                    for w in l..r {
                        for q in 0..r {
                            dp[r][w][q] = 0;
                            dp[r][q][w] = 0;

                            dp[q][r][w] = 0;
                            dp[w][r][q] = 0;

                            dp[w][q][r] = 0;
                            dp[q][w][r] = 0;
                        }
                    }
                }
                2 => {
                    for w in l..r {
                        for q in l..r {
                            dp[r][w][q] = 0;
                            dp[w][r][q] = 0;
                            dp[q][w][r] = 0;
                        }
                    }
                    for w in 0..l {
                        for q in 0..l {
                            dp[r][w][q] = 0;
                            dp[w][r][q] = 0;
                            dp[q][w][r] = 0;
                        }
                    }
                }
                3 => {
                    for w in 0..r {
                        for q in 0..l {
                            dp[r][w][q] = 0;
                            dp[r][q][w] = 0;

                            dp[w][r][q] = 0;
                            dp[q][r][w] = 0;

                            dp[q][w][r] = 0;
                            dp[w][q][r] = 0;
                        }
                    }
                }
                _ => (),
            }
        }
    }

    let mut sum = 0;
    for i in 0..n {
        for k in 0..n {
            sum = (sum + dp[n][i][k]) % M;
            sum = (sum + dp[i][n][k]) % M;
            sum = (sum + dp[k][i][n]) % M;
        }
    }

    println!("{}", sum);

}