Problem:
Score: 400 points

Problem Statement

There is a cave.

The cave has N rooms and M passages. The rooms are numbered 1 to N, and the passages are numbered 1 to M. Passage i connects Room A_i and Room B_i bidirectionally. One can travel between any two rooms by traversing passages. Room 1 is a special room with an entrance from the outside.

It is dark in the cave, so we have decided to place a signpost in each room except Room 1. The signpost in each room will point to one of the rooms directly connected to that room with a passage.

Since it is dangerous in the cave, our objective is to satisfy the condition below for each room except Room 1.

If you start in that room and repeatedly move to the room indicated by the signpost in the room you are in, you will reach Room 1 after traversing the minimum number of passages possible.

Determine whether there is a way to place signposts satisfying our objective, and print one such way if it exists.

Constraints

All values in input are integers.

2 \leq N \leq 10^5

1 \leq M \leq 2 \times 10^5

1 \leq A_i, B_i \leq N\ (1 \leq i \leq M)

A_i \neq B_i\ (1 \leq i \leq M)

One can travel between any two rooms by traversing passages.

Input

Input is given from Standard Input in the following format:

N M
A_1 B_1
:
A_M B_M

Output

If there is no way to place signposts satisfying the objective, print No.

Otherwise, print N lines. The first line should contain Yes, and the i-th line (2 \leq i \leq N) should contain the integer representing the room indicated by the signpost in Room i.

Sample Input 1

4 4
1 2
2 3
3 4
4 2

Sample Output 1

Yes
1
2
2

If we place the signposts as described in the sample output, the following happens:

Starting in Room 2, you will reach Room 1 after traversing one passage: (2) \to 1. This is the minimum number of passages possible.

Starting in Room 3, you will reach Room 1 after traversing two passages: (3) \to 2 \to 1. This is the minimum number of passages possible.

Starting in Room 4, you will reach Room 1 after traversing two passages: (4) \to 2 \to 1. This is the minimum number of passages possible.

Thus, the objective is satisfied.

Sample Input 2

6 9
3 4
6 1
2 4
5 3
4 6
1 5
6 2
4 5
5 6

Sample Output 2

Yes
6
5
5
1
1

If there are multiple solutions, any of them will be accepted.

Solution in C# (.NET Core 3.1.201) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using static System.Math;

namespace CSharpSpiral {
	class Program {
		static void Main(string[] args) {
			var sw = new StreamWriter(Console.OpenStandardOutput()) {
				AutoFlush=
#if DEBUG
			true
#else
			false
#endif
			};
			Console.SetOut(sw);
			new Program().Solve(new ConsoleInput(
#if DEBUG
			new StreamReader("../../../inputData.txt")
#else
			Console.In
#endif
			, ' '));
			Console.Out.Flush();
		}
		public void Solve(ConsoleInput cin) {
			var N = cin.ReadInt;
			var M = cin.ReadInt;
			var G = new GraphT(N);
			for(int i = 0; i<M; i++) {
				var a = cin.ReadInt-1;
				var b = cin.ReadInt-1;
				G.AddEdge(a, b, 1);
				G.AddEdge(b, a, 1);
			}
			G.Dijkstra(0, out var TT);
			var exists = TT.Skip(1).All(l => l>=0);
			if(!exists) {
				Console.WriteLine("No");
				return;
			} else {
				Console.WriteLine("Yes");
				Console.WriteLine(TT.Select(l=>l+1).Join("\n"));
			}
		}
	}
	static class ExtendClass {
		public static string Join<T>(this IEnumerable<T> X, string separator = " ") => string.Join(separator, X);
	}
	class ConsoleInput {
		private readonly TextReader _stream;
		private readonly char _separator = ' ';
		private readonly Queue<string> inputStream;
		public ConsoleInput(TextReader stream, char separator = ' ') {
			this._separator=separator;
			this._stream=stream;
			inputStream=new Queue<string>();
		}
		public string Read {
			get {
				if(inputStream.Count!=0) return inputStream.Dequeue();
				string[] tmp = _stream.ReadLine().Split(_separator);
				for(int i = 0; i<tmp.Length; ++i)
					inputStream.Enqueue(tmp[i]);
				return inputStream.Dequeue();
			}
		}
		public string ReadLine { get { return _stream.ReadLine(); } }
		public int ReadInt { get { return int.Parse(Read); } }
		public long ReadLong { get { return long.Parse(Read); } }
		public double ReadDouble { get { return double.Parse(Read); } }
		public string[] ReadStrArray(long N) {
			var ret = new string[N];
			for(long i = 0; i<N; ++i)
				ret[i]=Read;
			return ret;
		}
		public int[] ReadIntArray(long N) { var ret = new int[N]; for(long i = 0; i<N; ++i) ret[i]=ReadInt; return ret; }
		public long[] ReadLongArray(long N) { var ret = new long[N]; for(long i = 0; i<N; ++i) ret[i]=ReadLong; return ret; }
		public double[] ReadDoubleArray(long N) { var ret = new double[N]; for(long i = 0; i<N; ++i) ret[i]=ReadDouble; return ret; }
		public bool isEOF {
			get { return _stream.Peek()==-1; }
		}
	}
	class Edge<V>: IComparable<Edge<V>> where V : IComparable<V> {
		public int In { get; set; }
		public int Out { get; set; }
		public V cost { get; set; }
		public int CompareTo(Edge<V> y) => cost.CompareTo(y.cost);
	}
	class Node<V>: IComparable<Node<V>> where V : IComparable<V> {
		public V Value { get; set; }
		public int index { get; set; }
		public int CompareTo(Node<V> y) => Value.CompareTo(y.Value);
	}
	class GraphT: GraphT<long> {
		public GraphT(int count) : base(count) { }
		public long[] Dijkstra(int start, out int[] parents) {
			var PQ = new ImmutablePriorityQueue<Node<long>>(false);
			const long large = 0x3FFFFFFFFFFFFFFF;
			var Nodes = new Node<long>[N];
			var picked = new bool[N];
			var parentIndex = Enumerable.Repeat(-1, N).ToArray();
			var O = Outs;
			for(int i = 0; i<N; i++) {
				Nodes[i]=new Node<long> {
					index=i,
					Value=i==start ? 0 : large
				};
				PQ.Push(Nodes[i]);
			}
			while(PQ.Any()) {
				var nv = PQ.Pop();
				var v = nv.index;
				picked[v]=true;
				foreach(var e in O[v]) {
					var w = e.Out;
					if(picked[w]) continue;
					var c = e.cost;
					if(Nodes[v].Value+c<Nodes[w].Value) {
						Nodes[w].Value=Nodes[v].Value+c;
						PQ.Update(Nodes[w]);
						parentIndex[w]=v;
					}
				}
			}
			parents=parentIndex;
			return Nodes.Select(n => n.Value).ToArray();
		}
		public long Prim(out GraphT tree, int start = 0) {
			tree=new GraphT(N);
			var res = 0L;
			var PQ = new PriorityQueue<Edge<long>>(false);
			var O = Outs;
			PQ.Push(O[start]);
			var picked = new bool[N];
			picked[start]=true;
			while(PQ.Any()) {
				var e = PQ.Pop();
				var w = e.Out;
				if(picked[w]) continue;
				else picked[w]=true;
				res+=e.cost;
				tree.Edges.Add(e);
				PQ.Push(O[w]);
			}
			return res;
		}
	}
	class GraphT<V> where V : IComparable<V> {
		public int N { get; }
		public GraphT(int count) {
			N=count;
			Edges=new List<Edge<V>>();
		}
		public List<Edge<V>> Edges { get; }
		public void AddEdge(int In, int Out, V Value) {
			var e = new Edge<V> { In=In, Out=Out, cost=Value };
			Edges.Add(e);
		}
		protected List<Edge<V>>[] Outs {
			get {
				var Res = new List<Edge<V>>[N];
				for(int i = 0; i<N; i++)
					Res[i]=new List<Edge<V>>();
				foreach(var e in Edges)
					Res[e.In].Add(e);
				return Res;
			}
		}
		protected List<Edge<V>>[] Ins {
			get {
				var Res = new List<Edge<V>>[N];
				for(int i = 0; i<N; i++)
					Res[i]=new List<Edge<V>>();
				foreach(var e in Edges)
					Res[e.Out].Add(e);
				return Res;
			}
		}
		public bool DepthFirstSearch(int start, Action<int> OnEnter, Action<int> OnLeave)
			=> DepthFirstSearch(start, i => { OnEnter?.Invoke(i); return false; }, i => { OnLeave?.Invoke(i); return false; });
		public bool DepthFirstSearch(int start, Func<int, bool> OnEnter, Func<int, bool> OnLeave) {
			var Next = Outs;
			var visited = new bool[N];
			visited[start]=true;
			var S = new Stack<int>();
			S.Push(start);
			while(S.Any()) {
				var v = S.Peek();
				if(OnEnter?.Invoke(v)??false)
					return true;
				var E = Next[v].FirstOrDefault(e => !visited[e.Out]);
				if(E!=default(Edge<V>)) {
					var o = E.Out;
					S.Push(o);
					visited[o]=true;
				} else {
					S.Pop();
					if(OnLeave?.Invoke(v)??false)
						return true;
				}
			}
			return false;
		}
	}
	class PriorityQueue<T> where T : IComparable<T> {
		protected readonly List<T> body = new List<T>();
		protected Comparer<T> comparer { get; }
		public PriorityQueue(bool maxTop = true) {
			comparer
			=maxTop ? Comparer<T>.Create((T i, T j) => i.CompareTo(j))
			: Comparer<T>.Create((T i, T j) => j.CompareTo(i));
		}
		public PriorityQueue(Comparer<T> mComparer) { comparer=mComparer; }
		//suppose Me>Her if isRootMaximum
		protected int Compare(T Me, T Her) => comparer.Compare(Me, Her);
		protected int Compare(int x, int y) => Compare(body[x], body[y]);
		protected virtual void Swap(int x, int y) { T tmp = body[x]; body[x]=body[y]; body[y]=tmp; }
		public virtual void Push(T elem) {
			body.Add(elem);
			//the parent of n-th element is the ((n+1)>>1)-1-th
			UpHeap(lastIndex);
		}
		public void Push(IEnumerable<T> seq) {
			foreach(var item in seq) {
				Push(item);
			}
		}
		protected int UpHeap(int j) {
			while(j>0) {
				int parent = ((j+1)>>1)-1;
				if(Compare(parent, j)<0) {
					Swap(parent, j);
				} else break;
				j=parent;
			}
			return j;
		}
		public virtual T Pop() {
			T top = body[0];
			Swap(0, lastIndex);
			body.RemoveAt(lastIndex);
			DownHeap(0);
			return top;
		}
		protected int DownHeap(int j) {
			while(j<length) {
				var leftChild = ((j+1)<<1)-1;
				if(leftChild>=length) break;
				var toSwap = leftChild;
				var rightChild = leftChild+1;
				if(rightChild<length&&Compare(leftChild, rightChild)<0)
					toSwap=rightChild;
				if(Compare(j, toSwap)<0) {
					Swap(toSwap, j);
				} else break;
				j=toSwap;
			}
			return j;
		}
		public T Top { get { return body[0]; } }
		public int length { get { return body.Count(); } }
		protected int lastIndex { get { return body.Count()-1; } }
		public bool Any() => body.Any();
		public string Emit() { return body.ToArray().Join(","); }
	}
	class ImmutablePriorityQueue<T>: PriorityQueue<T> where T : IComparable<T> {
		public Dictionary<T, int> map { get; private set; } = new Dictionary<T, int>();
		public ImmutablePriorityQueue(bool maxTop) : base(maxTop) { }
		public ImmutablePriorityQueue(Comparer<T> mComparer) : base(mComparer) { }
		protected override void Swap(int x, int y) {
			map[body[x]]=y;
			map[body[y]]=x;
			base.Swap(x, y);
		}
		public override void Push(T elem) {
			map.Add(elem, length);
			base.Push(elem);
		}
		public override T Pop() {
			var V = base.Pop();
			map.Remove(V);
			return V;
		}
		public void Remove(T X) {
			var x = map[X];
			map.Remove(X);
			Swap(x, lastIndex);
			body.RemoveAt(lastIndex);
			var b = DownHeap(x);
			if(b==x) UpHeap(x);
		}
		public void Update(T X) {
			var x = map[X];
			var b = DownHeap(x);
			if(b==x) UpHeap(x);
		}
		public bool hasKey(T X) { int c; return map.TryGetValue(X, out c); }
	}
}