Problem:
Score : 300 points

Problem Statement

In Takahashi Kingdom, there is an archipelago of N islands, called Takahashi Islands.
For convenience, we will call them Island 1, Island 2, ..., Island N.

There are M kinds of regular boat services between these islands.
Each service connects two islands. The i-th service connects Island a_i and Island b_i.

Cat Snuke is on Island 1 now, and wants to go to Island N.
However, it turned out that there is no boat service from Island 1 to Island N, so he wants to know whether it is possible to go to Island N by using two boat services.

Help him.

Constraints

3 ≤ N ≤ 200 000

1 ≤ M ≤ 200 000

1 ≤ a_i < b_i ≤ N

(a_i, b_i) \neq (1, N)

If i \neq j, (a_i, b_i) \neq (a_j, b_j).

Input

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

If it is possible to go to Island N by using two boat services, print POSSIBLE; otherwise, print IMPOSSIBLE.

Sample Input 1

3 2
1 2
2 3

Sample Output 1

POSSIBLE

Sample Input 2

4 3
1 2
2 3
3 4

Sample Output 2

IMPOSSIBLE

You have to use three boat services to get to Island 4.

Sample Input 3

100000 1
1 99999

Sample Output 3

IMPOSSIBLE

Sample Input 4

5 5
1 3
4 5
2 3
2 4
1 4

Sample Output 4

POSSIBLE

You can get to Island 5 by using two boat services: Island 1 -> Island 4 -> Island 5.

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)

import java.util.Arrays;
import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Scanner;

class Pair<F, S>{
	public final F first;
	public final S second;

	public Pair (F first, S second) {
		this.first = first;
		this.second = second;
	}

}
class Graph{
	final int INF = Integer.MAX_VALUE/2;
	private int V,E;
	LinkedList<Pair<Integer, Integer>>[] edges;
	@SuppressWarnings("unchecked")
	public Graph(int v,int e){
		this.V = v; this.E = e;
		edges = new LinkedList[V];
	}

	public int[] dijkstra(int s){
		int[] d = new int[V];
		boolean[] used = new boolean[V];
		Arrays.fill(used,false);
		Arrays.fill(d,INF);
		d[s]=0;

		PriorityQueue<Pair<Integer, Integer>> que=new PriorityQueue<Pair<Integer, Integer>>(new Comparator<Pair<Integer, Integer>>() {
			public int compare(Pair<Integer, Integer> o1, Pair<Integer, Integer> o2) {
				return o1.second - o2.second;
			}
		});

		que.add(new Pair<Integer, Integer>(s, 0));
		while(!que.isEmpty()){
			Pair<Integer, Integer> now = que.poll();
			int point = now.first;
			if(used[point]) continue;
			used[point]=true;
			for(Iterator<Pair<Integer, Integer>> it = edges[point].iterator(); it.hasNext();) {
				Pair<Integer, Integer> next = it.next();
				if(!used[next.first] && d[next.first] > d[point] + next.second) {
					d[next.first] = d[point] + next.second;
					que.add(new Pair<Integer, Integer>(next.first, d[next.first]));
				}
			}
		}
		return d;
	}
}
class Main{
	public static void main(String args[]){
		Scanner sc=new Scanner(System.in);
		while(sc.hasNext()){
			int N = sc.nextInt(), M = sc.nextInt();
			Graph g = new Graph(N, M);
			for(int i = 0; i < N; i++) {
				g.edges[i] = new LinkedList<Pair<Integer, Integer>>();
			}
			for(int i = 0; i < M; i++) {
				int s = sc.nextInt();
				int t = sc.nextInt();
				g.edges[s - 1].add(new Pair<Integer, Integer>(t - 1, 1));
				g.edges[t - 1].add(new Pair<Integer, Integer>(s - 1, 1));
			}
			int[] ans = g.dijkstra(0);
			if(ans[N - 1] <= 2) {
				System.out.println("POSSIBLE");
			}
			else {
				System.out.println("IMPOSSIBLE");
			}
		}
	}
}