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 Java8 (OpenJDK 1.8.0) (judge verdict: Time Limit Exceeded)

import java.util.*;

public class Main {
    static final int MOD = 1000000007;
	public static void main (String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int m = sc.nextInt();
		HashMap<Integer, HashMap<Integer, Integer>> map = new HashMap<>();
		for (int i = 0; i < m; i++) {
		    int left = sc.nextInt();
		    int right = sc.nextInt();
		    int value = sc.nextInt();
		    if (map.containsKey(right)) {
		        if (map.get(right).containsKey(value)) {
		            if (value == 3) {
		                if (map.get(right).get(value) < left) {
		                    map.get(right).put(value, left);
		                }
		            } else {
		                if (map.get(right).get(value) > left) {
		                    map.get(right).put(value, left);
		                }
		            }
		        } else {
		            map.get(right).put(value, left);
		        }
		    } else {
		        HashMap<Integer, Integer> tmp = new HashMap<>();
		        tmp.put(value, left);
		        map.put(right, tmp);
		    }
		}
		int[][][] dp = new int[n + 1][n + 1][n + 1];
		dp[0][0][0] = 1;
		for (int i = 1; i <= n; i++) {
		    int[] checks = new int[3];
		    if (map.containsKey(i)) {
		        for (Map.Entry<Integer, Integer> entry : map.get(i).entrySet()) {
		            checks[entry.getKey() - 1] = entry.getValue();
		        }
		    }
		    for (int r = 0; r < i; r++) {
		        for (int g = 0; g < i; g++ ) {
		            for (int b = 0; b < i; b++) {
		                if (r != i - 1 && g != i - 1 && b != i - 1) {
		                    continue;
		                }
		                if ((checks[0] == 0 || (g < checks[0] && b < checks[0])) &&
		                    (checks[1] == 0 || ((g < checks[1] && b >= checks[1]) || g >= checks[1] && b < checks[1])) &&
		                    (checks[2] == 0 || (g >= checks[2] && b >= checks[2]))) {
		                        dp[i][g][b] += dp[r][g][b];
		                        dp[i][g][b] %= MOD;
		                }
		                if ((checks[0] == 0 || (b < checks[0] && r < checks[0])) &&
		                    (checks[1] == 0 || ((b < checks[1] && r >= checks[1]) || b >= checks[1] && r < checks[1])) &&
		                    (checks[2] == 0 || (b >= checks[2] && r >= checks[2]))) {
		                        dp[r][i][b] += dp[r][g][b];
		                        dp[r][i][b] %= MOD;
		                }
		                if ((checks[0] == 0 || (r < checks[0] && g < checks[0])) &&
		                    (checks[1] == 0 || ((r < checks[1] && g >= checks[1]) || r >= checks[1] && g < checks[1])) &&
		                    (checks[2] == 0 || (r >= checks[2] && g >= checks[2]))) {
		                        dp[r][g][i] += dp[r][g][b];
		                        dp[r][g][i] %= MOD;
		                }
		            }
		        }
		    }
		}
		int total = 0;
		for (int i = 0; i < n; i++) {
		    for (int j = 0; j < n; j++) {
		        total += dp[n][i][j];
		        total %= MOD;
		        total += dp[i][j][n];
		        total %= MOD;
		        total += dp[j][n][i];
		        total %= MOD;
		    }
		}
	    System.out.println(total);
    }
}