青蛙

题目描述 

有一只可爱的老青蛙，在路的另一端发现了一个黑的东西，想过去一探究竟。于是便开始踏上了旅途

一直这个小路上有很多的隧道，从隧道的a进入，会从b出来，但是隧道不可以反向走。

这只青蛙因为太老了，所以很懒，现在想请你帮帮慢，问他最少需要几步才可以到达对面。

将小径看作一条数轴，青蛙初始在0上，这只青蛙可以向前跳也可以向后跳，但每次只能跳一格，每跳一格记作一步，从隧道进到隧道出算做一步。

输入描述:

第一行两个数m,n；表示黑色物品在数轴m点上，数轴上总共有n个隧道
接下来n行，每行a，b两个数，表示从a进会从b出

10 <= m,n <= 233

0<a,b<=m

输出描述:

一个数ans表示最小步数

示例1

输入

复制

16 4
2 10
8 15
12 5
13 6

输出

复制

7

说明

0-->1-->2-->10-->9-->8-->15-->16

 

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.InputStream;

class Node {
	int t;
	int sum=0;
	Node(int t,int sum){
		this.t = t;
		this.sum=sum;
	}
	
}

public class Main {
	
    public static void main(String[] args) throws FileNotFoundException {
//    	File file1 = new File("C:/Users/hasee/Desktop/tree.in");
//    	File file2 = new File("C:/Users/hasee/Desktop/2.txt");
//    	InputStream inputStream = new FileInputStream(file1);
//    	OutputStream outputStream = new FileOutputStream(file2);
    	InputStream inputStream = System.in;
    	OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }
    
    static class TaskA {
    	
    	static ArrayList<String> list;
    	
        public void solve(int testNumber, InputReader in, PrintWriter out) {
        	
        	int a=in.nextInt();
        	int b=in.nextInt();
        	int x[] = new int[a+1];
        	x[0] = 0;
        	for(int n=0;n<b;n++){
        		int a1=in.nextInt();
        		int a2=in.nextInt();
        		x[a1] = a2;
        	}
        	int t[] = new int[a+1];
        	Queue<Node> q = new LinkedList<Node>();
        	Node node = new Node(0,0);
        	q.add(node);
        	t[0]=1;
        	while(!q.isEmpty()){
        		node = q.poll();
        		
        		if(node.t==a){
        			System.out.println(node.sum);
        			break;
        		}
        		if(node.t-1>=0&&t[node.t-1]==0){
        			t[node.t-1]=1;
        			Node nod = new Node(node.t-1,node.sum+1);
        			q.add(nod);
        		}
        		if(node.t+1<=a&&t[node.t+1]==0){
        			t[node.t+1]=1;
        			Node nod = new Node(node.t+1,node.sum+1);
        			q.add(nod);
        		}
        		if(x[node.t]!=0&&t[x[node.t]]==0){
        			t[x[node.t]]=1;
        			Node nod = new Node(x[node.t],node.sum+1);
        			q.add(nod);
        		}
        		
        	}
        	
        }
        

        
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        
        public double nextDouble() {
        	return Double.parseDouble(next());
        }

    }
}