#include <iostream>
#include <bits/stdc++.h>

using namespace std;

class graph
{
    // bitul 1 orientat sau neorientat, bitul 2 cost muchie
    enum input {orientat = 0, neorientat = 1, cu_cost = 2, fillLat = 4};
    struct muchie
    {
        int from, to, cost;
        muchie(int _from, int _to, int _cost = 1):
            from(_from), to(_to), cost(_cost)
            {

            }
    };
    int n,m;
    int* extraArgs = nullptr;

    vector<int>* la = nullptr;
    vector<int>* lat = nullptr;
    vector<pair<int,int>>* lac = nullptr;

    int* dist = nullptr;
    int* ids = nullptr;
    int* lowLink = nullptr;

    vector<int> topo;

    ifstream f;
    ofstream g;
public:
    void readData(string nume_fisier, input _tip_graf, int _extra_args_count, vector<pair<int**, int>> initVecs);
    //////////////////////////////////////////////////////////////////////////////////
    void bfs();
    //////////////////////////////////////////////////////////////////////////////////
    void dfs();
    void dfsTopo(int from);
};

void graph::readData (string nume_fisier, input _tip_graf, int _extra_args_count, vector<pair<int**, int>> initVecs)
{
    f.open(nume_fisier);
    f >> n >> m;
    if (_tip_graf & cu_cost)
        lac = new vector<pair<int,int>>[n+1];
    else
        la = new vector<int>[n+1];
    if (_tip_graf & fillLat)
        lat = new vector<int>[n+1];
    for (auto& per: initVecs)
    {
        int** p = per.first;
        int val = per.second;
        *p = new int[n+1];
        for (int i = 1; i <= n; i++)
            (*p)[i] = val;
    }
    if (_extra_args_count)
    {
        extraArgs = new int[_extra_args_count];
        for (int i = 0; i < _extra_args_count; i++)
            f >> extraArgs[i];
    }

    for (int i = 1; i <= m; i++)
    {
        int x,y,c;
        f >> x >> y;
        if (_tip_graf & input::cu_cost)
        {
            f >> c;
            lac[x].push_back({y,c});
        }
        else
        {
            la[x].push_back(y);
            if (_tip_graf & fillLat)
                lat[y].push_back(x);
        }

        if (_tip_graf & input::neorientat)
        {
            if (_tip_graf & input::cu_cost)
                lac[y].push_back({x,y});
            else
                la[y].push_back(x);
        }

    }

    f.close();
}

void graph::bfs()
{
    ofstream g("bfs.out");
    readData("bfs.in", input::orientat, 1, {{&dist, -1}});

    int start = extraArgs[0];

    queue<int> q;
    q.push(start);
    dist[start] = 0;

    while (q.size())
    {
        for (auto to: la[q.front()])
        {
            if (dist[to] == -1)
            {
                q.push(to);
                dist[to] = dist[q.front()] + 1;
            }
        }
        q.pop();
    }

    for (int i = 1; i <= n; i++)
        g << dist[i] << ' ';

    delete[] la;
    delete[] extraArgs;
    delete[] dist;
}

void graph::dfsTopo(int from)
{
    dist[from] = 1;
    for (auto to: la[from])
    {
        if (!dist[to])
            dfsTopo(to);
    }
    topo.push_back(from);
}

void graph::dfs()
{
    ofstream g("dfs.out");
    readData("dfs.in", input::neorientat, 0, {{&dist, 0}});

    int cc = 0;
    for (int i = 1; i <= n; i++)
    {
        if (!dist[i])
        {
            dfsTopo(i);
            cc++;
        }
    }

    g << cc;

    delete[] la;
    delete[] dist;
}

int main()
{
    graph g;
    g.bfs();

    return 0;
}