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;
using System.Collections.Generic;
using System.IO;
using System.Linq;

class Program
{
    static void Main(string[] args)
    {
        var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
        Console.SetOut(sw);
        Solve();
        Console.Out.Flush();
    }
    static void Solve()
    {
        var N = sc.ReadInt();
        var M = sc.ReadInt();
        var dij = new Dijkstra(N);
        var G = new List<int>[N];
        for (int i = 0; i < N; i++)
        {
            G[i] = new List<int>();
        }
        for (int i = 0; i < M; i++)
        {
            var a = sc.ReadInt();
            var b = sc.ReadInt();
            a--; b--;
            dij.Add(a, b);
            dij.Add(b, a);
            G[a].Add(b);
            G[b].Add(a);
        }
        var dist = dij.Calc(0);
        var list = new List<int>();
        for (int i = 1; i < N; i++)
        {
            var d = dist[i];
            if (d == Dijkstra.INF)
            {
                Console.WriteLine("No");
                return;
            }
            foreach (var next in G[i])
            {
                if (dist[next] + 1 == d)
                {
                    list.Add(next);
                    continue;
                }
            }
        }

        Console.WriteLine("Yes");
        foreach (var ans in list)
        {
            Console.WriteLine(ans + 1);
        }
    }

    class Dijkstra
    {
        public const long INF = long.MaxValue / 2;
        public int V { get; set; }
        public int E { get; set; }
        public List<Edge>[] G { get; set; }
        public Dijkstra(int n)
        {
            this.V = n;
            this.G = new List<Edge>[V];
            for (int i = 0; i < V; i++)
            {
                this.G[i] = new List<Edge>();
            }
        }
        public void Add(int a, int b, long cost = 1)
        {
            this.G[a].Add(new Edge(b, cost));
            this.E++;
        }
        public long GetMinCost(int start, int goal)
        {
            var cost = new long[V];
            for (int i = 0; i < V; i++) cost[i] = INF;
            cost[start] = 0;

            var capacity = Math.Max(1, E);
            var q = new PriorityQueue<P>(false);
            q.Enqueue(new P(start, 0));

            while (q.Count > 0)
            {
                var p = q.Dequeue();
                if (p.Cost != cost[p.A]) continue;
                foreach (var e in this.G[p.A])
                {
                    if (cost[e.To] > p.Cost + e.Cost)
                    {
                        cost[e.To] = p.Cost + e.Cost;
                        q.Enqueue(new P(e.To, cost[e.To]));
                    }
                }
            }
            return cost[goal] == long.MaxValue ? -1 : cost[goal];
        }
        public long[] Calc(int start)
        {
            var visited = new bool[V];
            var cost = new long[V];
            for (int i = 0; i < V; i++) cost[i] = INF;
            cost[start] = 0;

            var capacity = Math.Max(1, E);
            var q = new PriorityQueue<P>(false);
            q.Enqueue(new P(start, 0));

            while (q.Count > 0)
            {
                var p = q.Dequeue();
                visited[p.A] = true;
                if (p.Cost != cost[p.A]) continue;
                foreach (var e in this.G[p.A])
                {
                    if (cost[e.To] > p.Cost + e.Cost && !visited[e.To])
                    {
                        cost[e.To] = p.Cost + e.Cost;
                        q.Enqueue(new P(e.To, cost[e.To]));
                    }
                }
            }
            return cost;
        }
        public struct Edge
        {
            public int To;
            public long Cost;
            public Edge(int to, long cost)
            {
                this.To = to;
                this.Cost = cost;
            }
        }
        public struct P : IComparable<P>
        {
            public int A;
            public long Cost;
            public P(int a, long cost)
            {
                this.A = a;
                this.Cost = cost;
            }
            public int CompareTo(P other)
            {
                return this.Cost.CompareTo(other.Cost);
            }
        }
        class PriorityQueue<T>
        {
            public int Count;
            private int Capacity;
            private bool IsMaxHeap;
            private T[] Buffer;
            private IComparer<T> Cmp;
            public PriorityQueue(bool isMaxHeap = true, IComparer<T> cmp = null)
            {
                Count = 0;
                Capacity = 1 << 10;
                IsMaxHeap = isMaxHeap;
                Buffer = new T[Capacity];
                if (cmp != null) Cmp = cmp;
                else Cmp = Comparer<T>.Default;
            }
            public PriorityQueue(int capacity, bool isMaxHeap = true, IComparer<T> cmp = null)
            {
                Count = 0;
                Capacity = Math.Max(16, capacity);
                IsMaxHeap = isMaxHeap;
                Buffer = new T[Capacity];
                if (cmp != null) Cmp = cmp;
                else Cmp = Comparer<T>.Default;
            }
            private void Resize()
            {
                Capacity <<= 1;
                Array.Resize(ref Buffer, Capacity);
            }
            public void Enqueue(T value)
            {
                if (Count == Capacity) Resize();
                Buffer[Count] = value;
                Count++;
                UpHeap();
            }
            public T Dequeue()
            {
                var res = Buffer[0];
                Swap(0, Count - 1);
                Count--;
                DownHeap();
                return res;
            }
            public T Peek() { return Buffer[0]; }
            private void Swap(int i, int j)
            {
                var tmp = Buffer[i];
                Buffer[i] = Buffer[j];
                Buffer[j] = tmp;
            }
            private void UpHeap()
            {
                var n = this.Count - 1;
                while (n != 0)
                {
                    var parent = (n - 1) / 2;
                    if (Compare(Buffer[n], Buffer[parent]) > 0)
                    {
                        Swap(n, parent);
                        n = parent;
                    }
                    else break;
                }
            }
            private void DownHeap()
            {
                var parent = 0;
                while (true)
                {
                    var child = 2 * parent + 1;
                    if (child > this.Count - 1) break;
                    if (child < Count - 1 && Compare(Buffer[child], Buffer[child + 1]) < 0)
                    {
                        child += 1;
                    }
                    if (Compare(Buffer[parent], Buffer[child]) < 0)
                    {
                        Swap(parent, child);
                        parent = child;
                    }
                    else break;
                }
            }
            private int Compare(T x, T y)
            {
                var res = Cmp.Compare(x, y);
                if (!IsMaxHeap) res *= -1;
                return res;
            }
        }
    }
    static Scanner sc = new Scanner();
}
class Scanner
{
    string[] S = new string[0];
    int Index = 0;
    char[] Separators = new char[] { ' ' };

    public string Next()
    {
        if (this.Index < this.S.Length) return this.S[this.Index++];
        var line = "";
        while (line == "") line = Console.ReadLine();
        this.S = line.Split(this.Separators, StringSplitOptions.RemoveEmptyEntries);
        if (this.S.Length == 0) return this.Next();
        this.Index = 0;
        return this.S[this.Index++];
    }
    public string ReadStr()
    {
        return this.Next();
    }
    public char ReadChar()
    {
        return this.Next()[0];
    }
    public int ReadInt()
    {
        return int.Parse(this.Next());
    }
    public uint ReadUInt()
    {
        return uint.Parse(this.Next());
    }
    public long ReadLong()
    {
        return long.Parse(this.Next());
    }
    public double ReadDouble()
    {
        return double.Parse(this.Next());
    }
    public Tuple<int, int> ReadTup(int add = 0)
    {
        return Tuple.Create(this.ReadInt() + add, this.ReadInt() + add);
    }
    public Tuple<long, long> ReadTupLong(int add = 0)
    {
        return Tuple.Create(this.ReadLong() + add, this.ReadLong() + add);
    }
    public Tuple<int, int, int> ReadTup3(int add = 0)
    {
        return Tuple.Create(this.ReadInt() + add, this.ReadInt() + add, this.ReadInt() + add);
    }
    public Tuple<int, int, int, int> ReadTup4(int add = 0)
    {
        return Tuple.Create(this.ReadInt() + add, this.ReadInt() + add, this.ReadInt() + add, this.ReadInt() + add);
    }
    public int[] ReadIntArray(int n)
    {
        var array = new int[n];
        for (int i = 0; i < array.Length; i++)
        {
            array[i] = this.ReadInt();
        }
        return array;
    }
    public long[] ReadLongArray(int n)
    {
        var array = new long[n];
        for (int i = 0; i < array.Length; i++)
        {
            array[i] = this.ReadLong();
        }
        return array;
    }
    public double[] ReadDoubleArray(int n)
    {
        var array = new double[n];
        for (int i = 0; i < array.Length; i++)
        {
            array[i] = this.ReadDouble();
        }
        return array;
    }
    public char[] ReadCharArray(int n)
    {
        var array = new char[n];
        for (int i = 0; i < array.Length; i++)
        {
            array[i] = this.ReadChar();
        }
        return array;
    }
    public string[] ReadStrArray(int n)
    {
        var array = new string[n];
        for (int i = 0; i < array.Length; i++)
        {
            array[i] = this.ReadStr();
        }
        return array;
    }
    public Tuple<long, long>[] ReadTupLongArray(int n, int add = 0)
    {
        var array = new Tuple<long, long>[n];
        for (int i = 0; i < n; i++)
        {
            array[i] = this.ReadTupLong(add);
        }
        return array;
    }
    public Tuple<int, int>[] ReadTupArray(int n, int add = 0)
    {
        var array = new Tuple<int, int>[n];
        for (int i = 0; i < n; i++)
        {
            array[i] = this.ReadTup(add);
        }
        return array;
    }
    public Tuple<int, int, int>[] ReadTup3Array(int n, int add = 0)
    {
        var array = new Tuple<int, int, int>[n];
        for (int i = 0; i < n; i++)
        {
            array[i] = this.ReadTup3(add);
        }
        return array;
    }
    public Tuple<int, int, int, int>[] ReadTup4Array(int n, int add = 0)
    {
        var array = new Tuple<int, int, int, int>[n];
        for (int i = 0; i < n; i++)
        {
            array[i] = this.ReadTup4(add);
        }
        return array;
    }
}