Codeforces Round #347 (Div. 2) D. Graph Coloring（强联通分量缩点+2-SAT）

题意:

给你n个点m条边,每条边有一种颜色(B或R),每选择一个点可以使与其相连的所有边的颜色翻转,问最少需要选择多少个点,使得所有边的颜色相同,输出操作数以及操作哪些点。

(1 ≤ n,m ≤ 100000)

思路:

我们可以分别对把所有边变成B和R分别考虑。

因为每个点不会操作2次或者更多,因为操作两次相当于不操作,操作三次相当于操作一次。

然后用2-sat强连通模板跑

假设现在要把所有边变成R,现在有u,v两点之间的边为B,

我们用v+n,u+n表示这两个点不翻转,u,v表示这两个点进行翻转

则我们可以建立以下四条边

u->v+n,v+n->u,u+n->v,v->u+n

由于是有向图，所以tarjan不需要判断父亲

</pre><pre name="code" class="cpp">#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <cmath>
#include <vector>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define L(i) i<<1
#define R(i) i<<1|1
#define INF  0x3f3f3f3f
#define pi acos(-1.0)
#define eps 1e-12
#define maxn 200100
#define MOD 1000000007

struct Edge
{
    int to,next;
} edge[maxn<<1];

int n,m,ans;
int tot,head[maxn],scc;
int dfn[maxn],low[maxn],time;
int sta[maxn],top,instack[maxn],vis[maxn];
int belong[maxn],num[maxn],flag[maxn];
vector<pair<int,int> > mp[maxn];
vector<int> tmp[maxn];

void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}
void add_edge(int u,int v)
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
}
void tarjan(int u)
{
    dfn[u] = low[u] = ++time;
    sta[++top] = u;
    instack[u] = 1;
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if(!dfn[v])
        {
            tarjan(v);
            low[u] = min(low[u],low[v]);
        }
        else if(instack[v])
            low[u] = min(low[u],dfn[v]);
    }
    if(dfn[u] == low[u])
    {
        num[++scc] = 0;
        tmp[scc].clear();
        while(1)
        {
            int v = sta[top--];
            instack[v] = 0;
            belong[v] = scc;
            if(v <= n)
                num[scc]++;
            tmp[scc].push_back(v);
            if(v == u)
                break;
        }
    }
}

void solve(int key)
{
    init();
    for(int u = 1; u <= n; u++)
    {
        for(int i = 0; i < mp[u].size(); i++)
        {
            int v = mp[u][i].first;
            int c = mp[u][i].second;
            if(c == key)
            {
                add_edge(u,v);
                add_edge(u+n,v+n);
            }
            else
            {
                add_edge(u,v+n);
                add_edge(u+n,v);
            }
        }
    }
    top = time = scc = 0;
    memset(dfn,0,sizeof(dfn));
    memset(instack,0,sizeof(instack));
    memset(flag,0,sizeof(flag));
    for(int i = 1; i <= 2*n; i++)
        if(!dfn[i])
            tarjan(i);
    for(int i = 1; i <= n; i++)
        if(belong[i] == belong[i+n])
            return;
    int cnt = 0;
    for(int i = 1; i <= n; i++)
    {
        if(flag[i])
            continue;
        int k;
        if(num[belong[i]] <= num[belong[i+n]])
            k = i;
        else
            k = i + n;
        cnt += num[belong[k]];
        for(int j = 0; j < tmp[belong[k]].size(); j++)
        {
            int v = tmp[belong[k]][j];
            flag[v] = 1;
            flag[v<=n?v+n:v-n] = 2;
        }
    }
    if(cnt < ans)
    {
        memset(vis,0,sizeof(vis));
        ans = cnt;
        for(int i = 1; i <= n; i++)
            if(flag[i] == 1)
                vis[i] = 1;
    }
}
int main()
{
    int t;
    while(scanf("%d%d",&n,&m) != EOF)
    {
        for(int i = 1; i <= n; i++)
            mp[i].clear();
        for(int i = 0; i < m; i++)
        {
            int u,v;
            char c;
            scanf("%d%d %c",&u,&v,&c);
            mp[u].push_back(make_pair(v,c=='B'?1:2));
            mp[v].push_back(make_pair(u,c=='B'?1:2));
        }
        ans = INF;
        solve(1);
        solve(2);
        if(ans == INF)
            printf("-1\n");
        else
        {
            printf("%d\n",ans);
            for(int i = 1; i <= n; i++)
                if(vis[i])
                    printf("%d ",i);
            printf("\n");
        }
    }
    return 0;
}