6.12白书第五章图论总结——司雨寒

之前我的图论一直都是DFS一下，BFS一下，求个欧拉回路，拓扑排个序这种渣渣水平。

终于鼓起勇气拾起白书第五章的东西。

学(bei)习(song)了一下求双连通分量，二分图的判定，强连通分量，2-SAT。

DFS加上时间戳这个东西，很强大。

最后刷了白书上的例题：

BCC：

LA3523

可以参加会议的是双联通分量上的奇圈

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <stack>
using namespace std;

struct Edge
{
    int u, v;
    Edge(int u, int v):u(u), v(v) {}
};

const int maxn = 1000 + 10;
int n, m;

bool A[maxn][maxn];
vector<int> G[maxn];

void init()
{
    for(int i = 0; i < n; i++) G[i].clear();
    memset(A, false, sizeof(A));
}

int pre[maxn], bccno[maxn], dfs_clock, bcc_cnt;
bool iscut[maxn];
vector<int> bcc[maxn];
stack<Edge> S;

int dfs(int u, int fa)
{
    int lowu = pre[u] = ++dfs_clock;
    int child = 0;
    for(int i = 0; i < G[u].size(); i++)
    {
        int v = G[u][i];
        Edge e = Edge(u, v);
        if(!pre[v])
        {
            S.push(e);
            child++;
            int lowv = dfs(v, u);
            lowu = min(lowu, lowv);
            if(lowv >= pre[u])
            {
                iscut[u] = true;
                bcc_cnt++; bcc[bcc_cnt].clear();
                for(;;)
                {
                    Edge x = S.top(); S.pop();
                    if(bccno[x.u] != bcc_cnt) { bcc[bcc_cnt].push_back(x.u); bccno[x.u] = bcc_cnt; }
                    if(bccno[x.v] != bcc_cnt) { bcc[bcc_cnt].push_back(x.v); bccno[x.v] = bcc_cnt; }
                    if(x.u == u && x.v == v) break;
                }
            }
        }
        else if(pre[v] < pre[u] && v != fa)
        {
            S.push(e);
            lowu = min(lowu, pre[v]);
        }
    }

    if(fa < 0 && child == 1) iscut[u] = false;
    return lowu;
}

void find_bcc()
{
    memset(pre, 0, sizeof(pre));
    memset(iscut, false, sizeof(iscut));
    memset(bccno, 0, sizeof(bccno));
    dfs_clock = bcc_cnt = 0;

    for(int i = 0; i < n; i++)
        if(!pre[i]) dfs(i, -1);
}

int color[maxn];
bool odd[maxn];

bool bipartite(int u, int b)
{
    for(int i = 0; i < G[u].size(); i++)
    {
        int v = G[u][i]; if(bccno[v] != b) continue;
        if(color[u] == color[v]) return false;
        else if(!color[v])
        {
            color[v] = 3 - color[u];
            if(!bipartite(v, b)) return false;
        }
    }

    return true;
}

int main()
{
    while(scanf("%d%d", &n, &m) == 2 && n)
    {
        init();

        while(m--)
        {
            int u, v;
            scanf("%d%d", &u, &v); u--; v--;
            A[u][v] = A[v][u] = true;
        }

        for(int u = 0; u < n; u++)
            for(int v = u + 1; v < n; v++)
                if(!A[u][v]) { G[u].push_back(v); G[v].push_back(u); }

        find_bcc();

        memset(odd, false, sizeof(odd));
        for(int i = 1; i <= bcc_cnt; i++)
        {
            memset(color, 0, sizeof(color));
            for(int j = 0; j < bcc[i].size(); j++)
                bccno[bcc[i][j]] = i;
            int u = bcc[i][0];
            color[u] = 1;
            if(!bipartite(u, i))
                for(int j = 0; j < bcc[i].size(); j++)
                    odd[bcc[i][j]] = true;
        }

        int ans = 0;
        for(int i = 0; i < n; i++) if(!odd[i]) ans++;
        printf("%d
", ans);
    }

    return 0;
}

LA 5135

统计只有一个割顶的双联通分量非割顶的顶点的个数的乘积

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <stack>
#include <vector>
#include <map>
using namespace std;

struct Edge
{
    int u, v;
    Edge(int u, int v):u(u), v(v) {}
};

const int maxn = 100000 + 10;

int n;

int pre[maxn], bccno[maxn], dfs_clock, bcc_cnt;
bool iscut[maxn];
vector<int> G[maxn], bcc[maxn];
stack<Edge> S;

int dfs(int u, int fa)
{
    int lowu = pre[u] = ++dfs_clock;
    int child = 0;
    for(int i = 0; i < G[u].size(); i++)
    {
        int v = G[u][i];
        Edge e = (Edge) { u, v };
        if(!pre[v])
        {
            S.push(e);
            child++;
            int lowv = dfs(v, u);
            lowu = min(lowv, lowu);
            if(lowv >= pre[u])
            {
                iscut[u] = true;
                bcc_cnt++; bcc[bcc_cnt].clear();
                for(;;)
                {
                    Edge x = S.top(); S.pop();
                    if(bccno[x.u] != bcc_cnt) { bcc[bcc_cnt].push_back(x.u); bccno[x.u] = bcc_cnt; }
                    if(bccno[x.v] != bcc_cnt) { bcc[bcc_cnt].push_back(x.v); bccno[x.v] = bcc_cnt; }
                    if(x.u == u && x.v == v) break;
                }
            }
        }
        else if(pre[v] < pre[u] && v != fa)
        {
            S.push(e);
            lowu = min(lowu, pre[v]);
        }
    }
    if(fa < 0 && child == 1) iscut[u] = false;
    return lowu;
}

int tot;
map<int, int> id;
int ID(int x) { if(!id.count(x)) id[x] = tot++; return id[x]; }

void init()
{
    memset(pre, 0, sizeof(pre));
    memset(iscut, false, sizeof(iscut));
    memset(bccno, 0, sizeof(bccno));
    for(int i = 0; i < n*2; i++) G[i].clear();
    tot = dfs_clock = bcc_cnt = 0;
    id.clear();
}

int main()
{
    int kase = 0;
    while(scanf("%d", &n) == 1 && n)
    {
        init();

        while(n--)
        {
            int u, v; scanf("%d%d", &u, &v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        dfs(1, -1);

        long long ans1 = 0, ans2 = 1;
        for(int i = 1; i <= bcc_cnt; i++)
        {
            int cut_cnt = 0;
            for(int j = 0; j < bcc[i].size(); j++)
                if(iscut[bcc[i][j]]) cut_cnt++;
            if(cut_cnt == 1)
            {
                ans1++;
                ans2 *= (long long)(bcc[i].size() - 1);
            }
        }
        if(bcc_cnt == 1) { ans1 = 2; ans2 = (long long)bcc[1].size() * (bcc[1].size() - 1) / 2; }

        printf("Case %d: %lld %lld
", ++kase, ans1, ans2);
    }

    return 0;
}

SCC：

LA 4287

为了使原图整个强连通，添加的最少的边数为max{入读为0的顶点的个数， 出度为0的顶点的个数}

#include <cstdio>
#include <cstring>
#include <stack>
#include <vector>
#include <algorithm>
using namespace std;

const int maxn = 20000 + 10;
int n, m;
vector<int> G[maxn];

int pre[maxn], lowlink[maxn], sccno[maxn], dfs_clock, scc_cnt;
stack<int> S;

void dfs(int u)
{
    pre[u] = lowlink[u] = ++dfs_clock;
    S.push(u);
    for(int i = 0; i < G[u].size(); i++)
    {
        int v = G[u][i];
        if(!pre[v])
        {
            dfs(v);
            lowlink[u] = min(lowlink[u], lowlink[v]);
        }
        else if(!sccno[v]) lowlink[u] = min(lowlink[u], pre[v]);
    }

    if(lowlink[u] == pre[u])
    {
        scc_cnt++;
        for(;;)
        {
            int x = S.top(); S.pop();
            sccno[x] = scc_cnt;
            if(x == u) break;
        }
    }
}

void find_scc()
{
    dfs_clock = scc_cnt = 0;
    memset(pre, 0, sizeof(pre));
    memset(sccno, 0, sizeof(sccno));
    for(int i = 0; i < n; i++)
        if(!pre[i]) dfs(i);
}

int in0[maxn], out0[maxn];

int main()
{
    int T; scanf("%d", &T);
    while(T--)
    {
        scanf("%d%d", &n, &m);
        for(int i = 0; i < n; i++) G[i].clear();
        while(m--)
        {
            int u, v; scanf("%d%d", &u, &v);
            u--; v--;
            G[u].push_back(v);
        }

        find_scc();

        if(scc_cnt == 1) { puts("0"); continue; }

        for(int i = 1; i <= scc_cnt; i++) in0[i] = out0[i] = 1;

        for(int u = 0; u < n; u++)
            for(int i = 0; i < G[u].size(); i++)
            {
                int v = G[u][i];
                if(sccno[u] != sccno[v]) out0[sccno[u]] = in0[sccno[v]] = 0;
            }

        int a = 0, b = 0;
        for(int i = 1; i <= scc_cnt; i++)
        {
            if(in0[i]) a++;
            if(out0[i]) b++;
        }
        printf("%d
", max(a, b));
    }

    return 0;
}

UVa 11324

对于每个SCC中的点，要么全选要么全不选。

求SCC通常是为了缩点，求完SCC后可以转化为一个DAG，然后用记忆化搜索求权值和最大的路径。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <stack>
using namespace std;

const int maxn = 1000 + 10;
int n, m;

vector<int> G[maxn];

void init()
{
    for(int i = 1; i <= n; i++) G[i].clear();
}

int pre[maxn], lowlink[maxn], sccno[maxn], dfs_clock, scc_cnt;
stack<int> S;

void dfs(int u)
{
    pre[u] = lowlink[u] = ++dfs_clock;
    S.push(u);
    for(int i = 0; i < G[u].size(); i++)
    {
        int v = G[u][i];
        if(!pre[v])
        {
            dfs(v);
            lowlink[u] = min(lowlink[u], lowlink[v]);
        }
        else if(!sccno[v]) lowlink[u] = min(lowlink[u], pre[v]);
    }
    if(lowlink[u] == pre[u])
    {
        scc_cnt++;
        for(;;)
        {
            int x = S.top(); S.pop();
            sccno[x] = scc_cnt;
            if(x == u) break;
        }
    }
}

void find_bcc()
{
    dfs_clock = scc_cnt = 0;
    memset(sccno, 0, sizeof(sccno));
    memset(pre, 0, sizeof(pre));
    for(int i = 1; i <= n; i++)
        if(!pre[i]) dfs(i);
}

bool G2[maxn][maxn];
int w[maxn];

int d[maxn];

int dp(int u)
{
    if(d[u] >= 0) return d[u];
    int& ans = d[u];
    ans = w[u];
    for(int v = 1; v <= scc_cnt; v++) if(G2[u][v])
        ans = max(ans, dp(v) + w[u]);
    return ans;
}

int main()
{
    int T; scanf("%d", &T);
    while(T--)
    {
        scanf("%d%d", &n, &m);
        init();
        while(m--)
        {
            int u, v; scanf("%d%d", &u, &v);
            G[u].push_back(v);
        }

        find_bcc();

        memset(G2, false, sizeof(G2));
        memset(w, 0, sizeof(w));
        for(int i = 1; i <= n; i++)
        {
            int u = sccno[i];
            w[u]++;
            for(int j = 0; j < G[i].size(); j++)
            {
                int v = sccno[G[i][j]];
                if(u != v) G2[u][v] = true;
            }
        }

        memset(d, -1, sizeof(d));
        int ans = 0;
        for(int i = 1; i <= scc_cnt; i++)
            ans = max(ans, dp(i));
        printf("%d
", ans);
    }

    return 0;
}

2-SAT

LA 3211

二分最小时间间隔T，枚举任意两个飞机早晚的起飞时间，如果时间间隔小于T的话则加一个句子，所以最多不超过n(n-1)/2个句子。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <cmath>
using namespace std;

const int maxn = 2000 + 10;
int T[maxn][2];

int n;

vector<int> G[maxn * 2];
bool mark[maxn * 2];
int S[maxn * 2], top;

void init()
{
    for(int i = 0; i < n * 2; i++) G[i].clear();
    memset(mark, false, sizeof(mark));
}

void add_clause(int x, int xvalue, int y, int yvalue)
{
    x = x * 2 + xvalue;
    y = y * 2 + yvalue;
    G[x^1].push_back(y);
    G[y^1].push_back(x);
}

bool dfs(int u)
{
    if(mark[u^1]) return false;
    if(mark[u]) return true;
    mark[u] = true;
    S[++top] = u;
    for(int i = 0; i < G[u].size(); i++)
    {
        int v = G[u][i];
        if(!dfs(v)) return false;
    }
    return true;
}

bool solve()
{
    for(int i = 0; i < n*2; i += 2)
    {
        if(!mark[i] && !mark[i+1])
        {
            top = -1;
            if(!dfs(i))
            {
                while(top >= 0) mark[S[top--]] = false;
                if(!dfs(i + 1)) return false;
            }
        }
    }
    return true;
}

bool ok(int t)
{
    init();
    for(int i = 0; i < n; i++) for(int a = 0; a < 2; a++)
        for(int j = i + 1; j < n; j++) for(int b = 0; b < 2; b++)
            if(abs(T[i][a] - T[j][b]) < t) add_clause(i, a^1, j, b^1);
    return solve();
}

int main()
{
    //freopen("in.txt", "r", stdin);

    while(scanf("%d", &n) == 1)
    {
        int L = 0, R = 0;
        for(int i = 0; i < n; i++)
        {
            scanf("%d%d", &T[i][0], &T[i][1]);
            R = max(R, T[i][0]);
            R = max(R, T[i][1]);
        }

        while(L < R)
        {
            int mid = (L + R) / 2 + 1;
            if(ok(mid)) L = mid;
            else R = mid - 1;
        }
        printf("%d
", L);
    }

    return 0;
}