Problem:
Score : 300 points

Problem Statement

You are given an undirected unweighted graph with N vertices and M edges that contains neither self-loops nor double edges.

Here, a self-loop is an edge where a_i = b_i (1≤i≤M), and double edges are two edges where (a_i,b_i)=(a_j,b_j) or (a_i,b_i)=(b_j,a_j) (1≤i<j≤M).

How many different paths start from vertex 1 and visit all the vertices exactly once?

Here, the endpoints of a path are considered visited.

For example, let us assume that the following undirected graph shown in Figure 1 is given.

Figure 1: an example of an undirected graph

The following path shown in Figure 2 satisfies the condition.

Figure 2: an example of a path that satisfies the condition

However, the following path shown in Figure 3 does not satisfy the condition, because it does not visit all the vertices.

Figure 3: an example of a path that does not satisfy the condition

Neither the following path shown in Figure 4, because it does not start from vertex 1.

Figure 4: another example of a path that does not satisfy the condition

Constraints

2≦N≦8

0≦M≦N(N-1)/2

1≦a_i<b_i≦N

The given graph contains neither self-loops nor double edges.

Input

The input is given from Standard Input in the following format:

N M
a_1 b_1
a_2 b_2
:
a_M b_M

Output

Print the number of the different paths that start from vertex 1 and visit all the vertices exactly once.

Sample Input 1

3 3
1 2
1 3
2 3

Sample Output 1

2

The given graph is shown in the following figure:

The following two paths satisfy the condition:

Sample Input 2

7 7
1 3
2 7
3 4
4 5
4 6
5 6
6 7

Sample Output 2

1

This test case is the same as the one described in the problem statement.

Solution in Rust (1.15.1) (judge verdict: Accepted)

macro_rules! input {
    ($ttype:ty) => {
        {
            let mut input = String::new();
            let _= std::io::stdin().read_line(&mut input);
            input.trim().parse::<$ttype>().unwrap()
        }
    };

    ($($ttype:ty),*) => {
        {
            use std::io::BufRead;
            let mut input = String::new();
            let stdin = std::io::stdin();
            let _ = stdin.lock().read_line(&mut input);
            let mut iter = input.trim().split_whitespace();
            (
                $(iter.next().unwrap().parse::<$ttype>().unwrap(),)*
            )
        }
    };

    ($ttype:ty; $x:expr) => {
        {
            use std::io::BufRead;
            let mut input = String::new();
            let stdin = std::io::stdin();
            let _ = stdin.lock().read_line(&mut input);
            let v: Vec<$ttype> = input
                .trim()
                .split_whitespace()
                .map(|x| x.parse().unwrap())
                .collect();
            v
        }
    };

    ($ttype:ty; $x:expr; $y:expr) => {
        {
            use std::io::BufRead;
            let mut matrix = Vec::with_capacity($y);
            for _ in 0..$y {
                let mut input = String::new();
                let stdin = std::io::stdin();
                let _ = stdin.lock().read_line(&mut input);
                let v: Vec<$ttype> = input
                    .trim()
                    .split_whitespace()
                    .map(|x| x.parse().unwrap())
                    .collect();
                matrix.push(v);
            }
            matrix
        }
    };
}

fn calulate_unvisited_neighbors(now: usize, edges: &Vec<Vec<bool>>, visited: &Vec<usize>) -> Vec<usize> {
    let mut neighbors: Vec<usize> = Vec::new();
    for (neighbor, &edge) in edges[now].iter().enumerate() {
        if edge && !visited.contains(&neighbor) {
            neighbors.push(neighbor);
        }
    }
    neighbors
}

fn traversal(now: usize, edges: &Vec<Vec<bool>>, visited: &Vec<usize>) -> i64 {
    let mut visited = visited.clone();
    visited.push(now);
    let neighbors = calulate_unvisited_neighbors(now, edges, &visited);
    let mut counter = 0;
    if neighbors.is_empty() {
        if visited.len() == edges.len() - 1 {
            // println!("visited={:?}", visited);
            return 1
        } else {
            // println!("edges.len()=={:?}", edges.len());
            // println!("*visited={:?}", visited);
            // println!("neighbor={:?}", neighbors);
            return 0
        }
    }
    for &neighbor in neighbors.iter() {
        let now = neighbor;
        counter += traversal(now, edges, &visited);
    }
    counter
}

fn main() {
    let (n, m) = input!(usize, usize);
    let mut edges = vec![vec![false; n+1]; n+1];
    for _ in 0..m {
        let (a, b) = input!(usize, usize);
        edges[a][b] = true;
        edges[b][a] = true;
    }
    // for edge in edges.iter() {
        // println!("{:?}", edge);
    // }
    println!("{:?}", traversal(1, &edges, &vec![]));
}