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)

fn main() {
    let stdin = std::io::stdin();
    let mut locked = stdin.lock();
    let mut sc = scanner::Scanner::new(&mut locked);

    let n = sc.next_unsigned().unwrap() as usize;
    let m = sc.next_unsigned().unwrap() as usize;
    let mut g = vec![vec![false; n]; n];
    for _ in 0..m {
        let a = sc.next_unsigned().unwrap() as usize - 1;
        let b = sc.next_unsigned().unwrap() as usize - 1;
        g[a][b] = true;
        g[b][a] = true;
    }
    let mut dp = vec![vec![0i32; n]; 1 << n];
    dp[1][0] = 1;
    for x in 0..1 << n {
        for a in 0..n {
            if (x >> a & 1) == 0 {
                continue;
            }
            for b in 0..n {
                if (x >> b & 1) == 1 {
                    continue;
                }
                if g[a][b] {
                    dp[x | 1 << b][b] += dp[x][a];
                }
            }
        }
    }

    println!("{}", dp.last().unwrap().iter().sum::<i32>());
}

mod scanner {
    use std::io::{BufRead, Error, ErrorKind, Read};
    use std::str::FromStr;

    pub struct Scanner<'a, R>
    where
        R: 'a + BufRead + ?Sized,
    {
        reader: &'a mut R,
    }

    impl<'a, R> Scanner<'a, R>
    where
        R: 'a + BufRead + ?Sized,
    {
        pub fn new(reader: &'a mut R) -> Self {
            Scanner { reader: reader }
        }

        pub fn next_byte(&mut self) -> Result<u8, Error> {
            self.reader
                .bytes()
                .skip_while(|ref c| !Self::is_printable(*c.as_ref().ok().unwrap()))
                .next()
                .unwrap()
        }

        pub fn next_bytes(&mut self) -> Result<Vec<u8>, Error> {
            self.reader
                .bytes()
                .skip_while(|ref c| !Self::is_printable(*c.as_ref().ok().unwrap()))
                .take_while(|ref c| Self::is_printable(*c.as_ref().ok().unwrap()))
                .collect()
        }

        pub fn next_unsigned(&mut self) -> Result<u64, Error> {
            self.reader
                .bytes()
                .skip_while(|ref c| !Self::is_printable(*c.as_ref().ok().unwrap()))
                .take_while(|ref c| Self::is_printable(*c.as_ref().ok().unwrap()))
                .fold(Ok(0), |s, x| {
                    s.and_then(|t| {
                        x.and_then(|y| {
                            if b'0' <= y && y <= b'9' {
                                Ok(t * 10 + (y - b'0') as u64)
                            } else {
                                Err(Error::new(ErrorKind::InvalidData, "found not a digit"))
                            }
                        })
                    })
                })
        }

        pub fn next_signed(&mut self) -> Result<i64, Error> {
            self.reader
                .bytes()
                .skip_while(|ref c| !Self::is_printable(*c.as_ref().ok().unwrap()))
                .take_while(|ref c| Self::is_printable(*c.as_ref().ok().unwrap()))
                .fold(Ok([0i64, 0]), |s, x| {
                    x.and_then(|y| {
                        s.and_then(|t| {
                            if t[0] == 0 && y == b'-' {
                                Ok([-1, 0])
                            } else if b'0' <= y && y <= b'9' {
                                Ok([
                                    if t[0] == 0 { 1 } else { t[0] },
                                    t[1] * 10 + (y - b'0') as i64,
                                ])
                            } else {
                                Err(Error::new(ErrorKind::InvalidData, "found not a digit"))
                            }
                        })
                    })
                })
                .and_then(|s| Ok(s[0] * s[1]))
        }

        pub fn next_float(&mut self) -> Result<f64, Error> {
            self.reader
                .bytes()
                .skip_while(|ref c| !Self::is_printable(*c.as_ref().ok().unwrap()))
                .take_while(|ref c| Self::is_printable(*c.as_ref().ok().unwrap()))
                .collect::<Result<Vec<u8>, Error>>()
                .and_then(|t| {
                    String::from_utf8(t).or(Err(Error::new(ErrorKind::InvalidData, "invalid data")))
                })
                .and_then(|s| {
                    f64::from_str(&s).or(Err(Error::new(ErrorKind::InvalidData, "invalid data")))
                })
        }

        fn is_printable(c: u8) -> bool {
            0x21 <= c && c <= 0x7e
        }
    }
}