Sem_1_Task_1

#include <iostream>
#include <vector>
#include <algorithm>
#include <unordered_set>

namespace {
    using NumsVec = std::vector<size_t>;
    using VecNumsVec = std::vector<NumsVec>;
    using BoolVec = std::vector<bool>;
}

struct Edge {
    Edge() = default;
    Edge(std::pair<size_t, size_t> edge) : from(edge.first), to(edge.second) {};
    Edge(size_t i, size_t j) : from(i), to(j) {};

    bool operator==(const Edge& other) const {
        return from == other.from && to == other.to;
    }

    size_t from = 0;
    size_t to = 0;
};

std::istream& operator>>(std::istream& input, Edge& p) {
    input >> p.from >> p.to;
    --p.from;
    --p.to;
    return input;
}

template<>
struct std::hash<Edge> {
    size_t operator()(const Edge& p) const {
        return p.from * p.to;
    }
};

struct OrGraph {
    OrGraph(size_t n, std::vector<Edge>& edges) : size(n), neighbours(n), visited(n, false), color(n, 0) {
        for (auto edge : edges) {
            neighbours[edge.from].push_back(edge.to);
        }
    };
    size_t size;
    bool cycle = false;

    VecNumsVec neighbours;
    BoolVec visited;
    NumsVec color;
};

void DfsCycle(OrGraph& g, size_t v) {
    g.color[v] = 1;
    g.visited[v] = true;
    for (auto u : g.neighbours[v]) {
        if (!g.visited[u]) {
            DfsCycle(g, u);
        } else if (g.color[u] == 1) {
            g.cycle = true;
        }
    }
    g.color[v] = 2;
}

int main() {
    size_t n;
    size_t m;
    std::cin >> n >> m;
    std::vector<Edge> edges;
    std::unordered_set<Edge> red_edges;
    for (size_t i = 0; i < m; ++i) {
        Edge edge;
        std::cin >> edge;
        red_edges.insert(edge);
    }
    for (size_t i = 0; i < n; ++i) {
        for (size_t j = i + 1; j < n; ++j) {
            if (red_edges.find(Edge(i, j)) == red_edges.end()) {
                edges.emplace_back(i, j);
            } else {
                edges.emplace_back(j, i);
            }
        }
    }
    OrGraph g(n, edges);
    for (size_t v = 0; v < n; ++v) {
        if (!g.visited[v]) {
            DfsCycle(g, v);
        }
    }
    std::cout << (g.cycle ? "NO" : "YES");
}