С++ flow

#include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <memory.h>

#define pb push_back
#define mp make_pair
#define inf 999999999
#define S second
#define F first

using namespace std;

struct Edge {
    int to, cap, flow;
    Edge * rev;

    Edge(int to, int cap) : to(to), cap(cap), flow(0), rev(NULL) {}
};

struct Flow {
    vector<vector<Edge*> > g;
    int to;
    vector<int> cur;
    vector<int> h;
    vector<int> q;

    void add_edge(int fr, int to, int cap) {
        Edge * e1 = new Edge(to, cap);
        Edge * e2 = new Edge(fr, 0);
        e1->rev = e2;
        e2->rev = e1;
        g[fr].pb(e1);
        g[to].pb(e2);
    }

    Flow(int n) {
        for (int i = 0; i < n; i++) {
            vector<Edge*> tmp;
            g.pb(tmp);
        }
        cur.resize(n);
        h.resize(n);
        q.resize(n);
        to = n - 1;
    }

    bool bfs() {
        int q_it = 0, q_sz = 1;
        for (int i = 0; i < h.size(); i++) h[i] = inf;
        h[0] = 0;
        q[0] = 0;
        while (q_it < q_sz) {
            int v = q[q_it++];
            for (int i = 0; i < g[v].size(); i++) {
                Edge * e = g[v][i];
                if (h[e->to] == inf && e->flow < e->cap) {
                    h[e->to] = h[v] + 1;
                    q[q_sz++] = e->to;
                }
            }
        }
        return h[to] != inf;
    }

    int dfs(int v, int f) {
        if (v == to || f == 0)
            return f;
        for (;cur[v] < g[v].size(); cur[v]++) {
            Edge * e = g[v][cur[v]];
            if (h[e->to] == h[v] + 1) {
                int add = dfs(e->to, min(e->cap - e->flow, f));
                if (add != 0) {
                    e->flow += add;
                    e->rev->flow -= add;
                    return add;
                }
            }
        }
        return 0;
    }

    int get() {
        int res = 0;
        while (bfs()) {
            for (int i = 0; i < cur.size(); i++) cur[i] = 0;
            while (true) {
                int add = dfs(0, inf);
                if (add == 0)
                    break;
                res += add;
            }
        }
        return res;
    }
};

int main() {
//  freopen("1.in", "r", stdin);
//  freopen("1.out", "w", stdout);
    int n, m;
    scanf("%d%d", &n, &m);
    Flow f(n + m + 2);
    for (int i = 0; i < m; i++) {
        int val;
        scanf("%d", &val);
        if (val >= 1 && val <= n)
            f.add_edge(i + 1, m + val, 1);
        if (val + 1 >= 1 && val + 1 <= n)
            f.add_edge(i + 1, m + val + 1, 1);
    }
    for (int i = 0; i < m; i++)
        f.add_edge(0, i + 1, 1);
    for (int i = 0; i < n; i++)
        f.add_edge(m + i + 1, n + m + 1, 1);
    int ans = f.get();
    if (ans == m) {
        cout << "YES" << endl;
    } else {
        cout << "NO" << endl;
    }
    return 0;
}