Codeforces 468 B. Two Sets (2-SAT)

2-SAT

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<map>
#include<queue>
#include<vector>
#include<string>
#include<fstream>
using namespace std;
#define rep(i, a, n) for(int i = a; i <= n; ++ i);
#define per(i, a, n) for(int i = n; i >= a; -- i);
typedef long long ll;
const int N = 4e5 + 105;
const int mod = 1e9 + 7;
const double Pi = acos(- 1.0);
const ll INF = 1e18;
const int G = 3, Gi = 332748118;
ll qpow(ll a, ll b) { ll res = 1; while(b){ if(b & 1) res = (res * a) % mod; a = (a * a) % mod; b >>= 1;} return res; }
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
// bool cmp(int a, int b){return a > b;}
//

int n, m, A, B;

int head[N], cnt = 0;
int low[N], dfn[N], Stack[N], Belong[N];
int Index, top, scc;
bool Instack[N];
int to[N << 1], nxt[N << 1];
int a[N];
map<int, int> mp;

void add(int u, int v){
    to[cnt] = v, nxt[cnt] = head[u], head[u] = cnt ++;
}

void Tarjan(int u){
    int v;
    low[u] = dfn[u] = ++ Index;
    Stack[top ++] = u;
    Instack[u] = true;
    for(int i = head[u]; i != -1; i = nxt[i]){
        v = to[i];
        if(!dfn[v]){
            Tarjan(v);
            if(low[u] > low[v] ) low[u] = low[v];
        }
        else if(Instack[v] && low[u] > dfn[v]) low[u] = dfn[v];
    }
    if(low[u] == dfn[u]){
        scc ++;
        do{
            v = Stack[-- top];
            Instack[v] = false;
            Belong[v] = scc;
        }while(v != u);
    }
}


void solve(){
    memset(dfn,0,sizeof(dfn));
    memset(Instack,false,sizeof(Instack));
    Index = top = scc = 0;
    for(int i = 1; i <= n * 2; ++ i)
        if(!dfn[i])
            Tarjan(i);
}

void init(){
    cnt = 0;
    memset(head,-1,sizeof(head));
}

int main()
{
    int tot = 0;
    scanf("%d%d%d",&n,&A,&B);
    init();
    for(int i = 1; i <= n; ++ i) {
        scanf("%d",&a[i]);
        mp[a[i]] = i;
    }
    for(int i = 1; i <= n; ++ i){
        if(!mp[A - a[i]]) add(i, i + n);
        else {
            add(i, mp[A - a[i]]); add(mp[A - a[i]] + n, i + n);
        }
        if(!mp[B - a[i]]) add(i + n, i);
        else{
            add(i + n, mp[B - a[i]] + n); add(mp[B - a[i]], i);
        }
    }
    
    
    solve();
    int flag = 0;
    for(int i = 1; i <= n; ++ i){
        if(Belong[i] == Belong[i + n]){
            flag = 1; break;
        }
    }
    if(flag) printf("NO
");
    else {
        printf("YES
");
        for(int i = 1; i <= n; ++ i){
            if(Belong[i] < Belong[i + n]) printf("0");
            else printf("1");
            if(i == n) printf("
");
            else printf(" ");
        }
    }
    return 0;
}