连通

连通

关注
发信
关注(28)粉丝(399)

tarjan复习笔记

tarjan复习笔记

（关于tarjan读法，）

0. 连通分量

有向图：

强连通分量（SCC）是个啥

就是一张图里面两个点能互相达到，那么这两个点在同一个强连通分量里，
极大强连通分量就是最大的强连通分量。

无向图：

一个全部联通的子图就是一个连通分量。
其中用到tarjan暂时还有边双连通分量（e-DCC）和点双连通分量（v-DCC）

边双连通分量（e-DCC）

指的是一个子图中没有桥的话，这就是一个边双连通分量。
一个无向图的每一个极大边双连通子图称作此无向图的双连通分量。

点双连通分量（v-DCC）

对于一个无向图，如果一个点集，它内部的任意一个点对之间，至少有两条点完全不重复的路径，那么这个点集就是原图的一个点双连通分量。

无向图的双连通分量下面

tarjan求强连通分量

这个就是所谓的tarjan强连通分量——缩点了。

对于一个单向联通的子图，我们从一个点出发会得到一个搜索树，
但是这个子图可不仅仅只有搜索树上的边。

（搜索树上的边下简称树边，非搜索树上的但是遇到的边下简称非树边）

按照搜索的顺序把点压到一个栈里。
如果当前我们找到一个非树边然后指向之前栈中的点里，那么从那个点到这个点之间都是强连通分量的一部分。

但是我们怎么找到一个最大的强连通分量呢？

我们设置一个搜索顺序dfn[]和追溯值low[]，让当前点的low[]取到能够到的最靠上的点的dfn[]或者自己的dfn[]。
如果这个dfn[]!=low[]，那么就是栈从当前点到下面的这些点都是在一个强连通分量里面。

可以证明这样求的一定是一个个最大的强连通分量。

代码实现（【模板】）：

#include <iostream>
#include <cstdio>

using namespace std;
const int maxn=10086;
//forward star node
struct edge
{
    int to,next;
} Edge[50086];
int cnt=1,head[maxn];
//forward star add edges
inline void add_edge(int from,int to)
{
    Edge[cnt]=(edge){to,head[from]};
    head[from]=cnt++;
}
//tarjan uses
int dfn[maxn],low[maxn],stack[maxn],now,top;
bool vst[maxn];
//After tarjan these point will put into baskets(group)
int group[maxn],gcnt;

void tarjan(int n)
{
    dfn[n]=low[n]=++now;
    stack[++top]=n;
    vst[n]=true;
    for (int i=head[n];i;i=Edge[i].next)
    {
        int to=Edge[i].to;
        if (dfn[to]==0)
        {
            tarjan(to);
            low[n]=min(low[n],low[to]);
        }
        else
        {
            if (vst[to])
            {
                low[n]=min(low[n],low[to]);
            }
        }
    }
    if (low[n]==dfn[n])
    {
        group[n]=++gcnt;
        while (stack[top]!=n)
        {
            vst[stack[top]]=false;
            group[stack[top--]]=gcnt;
        }
        //make n get out of stack
        vst[n]=false;
        top--;
    }
}

int main()
{
    int n,m;
    cin>>n>>m;
    for (register int i=1;i<=m;i++)
    {
        int f,t;
        scanf("%d%d",&f,&t);
        add_edge(f,t);
    }
    for (register int i=1;i<=n;i++)
    {
        if (dfn[i]==0)tarjan(i);
    }
    for (register int i=1;i<=n;i++)
    {
        cout<<group[i]<<endl;
    }
    return 0;
}

（然而luogu的模板还是有点毒瘤的）

看一个经典例题。

例题 Luogu P2341 [HAOI2006]受欢迎的牛 |【模板】强连通分量

现在看到这个“A受B欢迎”应当是指A向B连接一条有向边。
然后...一个强连通分量里面只要大小不为1，这里面的所有奶牛都互相喜欢。
那么我们只要缩一遍点，那么找到出度为0的强连通分量，那么所有的奶牛都会喜欢这个强连通分量里的奶牛。

所以正确处理方式就是：

  1. 缩点
  2. 找到出度为0的点。

但是注意如果要是两个出度为0的强连通分量，那可不就是没有明星了。

一类有向图dp

对于一般在有向图（不保证是DAG）上面跑DP的时候，如果不能处理后效性，
那么通常我们可以通过先缩点再拓扑排序跑DP。

例1 LuoguP3387【模板】缩点

这个题我们可以先跑一边tarjan缩点，然后再来一发toposort，做“我为人人”类型的dp。

代码实现：

#include <iostream>
#include <cstdio>
#include <queue>

using namespace std;
template <typename Tp>
inline Tp Read()
{
    Tp num = 0;
    char ch = getchar();
    bool flag = false;
    while (!isdigit(ch))
        flag |= ch == '-', ch = getchar();
    while (isdigit(ch))
        num = (num << 1) + (num << 3) + (ch ^ 48), ch = getchar();
    return flag ? -num : num;
}
struct gragh
{
    struct edge
    {
        int from, to, next;
    };
    edge Edge[100086];
    int cnt, head[10086];
    inline void add_edge(int from, int to)
    {
        this->cnt++;
        this->Edge[this->cnt] = (edge){from, to, this->head[from]};
        this->head[from] = this->cnt;
    }
} a, b;
int n, m, val[10086];
// tarjan uses
int dfn[10086], low[10086], stack[10086], dfncnt, top;
bool instack[10086];
int group[10086], gcnt, gval[10086], In[10086];
// 缩点 解决dp后效性问题
void tarjan(int n)
{
    dfn[n] = low[n] = ++dfncnt;
    stack[++top] = n;
    instack[n] = true;
    for (int i = a.head[n]; i; i = a.Edge[i].next)
    {
        int to = a.Edge[i].to;
        if (dfn[to] == 0)
        {
            tarjan(to);
            low[n] = min(low[n], low[to]);
        }
        else
        {
            if (instack[to])
            {
                low[n] = min(low[n], low[to]);
            }
        }
    }
    if (dfn[n] == low[n])
    {
        int now;
        gcnt++;
        // gval[gcnt]=val[n];
        do
        {
            now = stack[top--];
            instack[now] = false;
            group[now] = gcnt;
            gval[gcnt] += val[now];
        } while (now != n);
    }
}
// rebuild the gragh
void rebuild()
{
    for (int i = 1; i <= a.cnt; i++)
    {
        int from = a.Edge[i].from, to = a.Edge[i].to;
        if (group[from] != group[to])
        {
            b.add_edge(group[from], group[to]);
            In[group[to]]++;
        }
    }
}
int dis[10086], ans = 0;
// dp on the DAG
void toposort()
{
    queue<int> q;
    for (int i = 1; i <= gcnt; i++)
    {
        if (In[i] == 0)
            q.push(i);
        dis[i] = gval[i];
    }
    while (!q.empty())
    {
        int from = q.front();
        q.pop();
        for (int i = b.head[from]; i; i = b.Edge[i].next)
        {
            int to = b.Edge[i].to;
            dis[to] = max(dis[from] + gval[to], dis[to]);
            In[to]--;
            if (In[to] == 0)
                q.push(to);
        }
    }
    for (int i = 1; i <= gcnt; i++)
    {
        ans = max(ans, dis[i]);
    }
}

int main()
{
    n = Read<int>(), m = Read<int>();
    for (int i = 1; i <= n; i++)
        val[i] = Read<int>();
    for (int i = 1; i <= m; i++)
    {
        a.add_edge(Read<int>(), Read<int>());
    }
    for (int i = 1; i <= n; i++)
        if (dfn[i] == 0)
        {
            tarjan(i);
        }
    rebuild();
    toposort();
    printf("%d\n", ans);
    return 0;
}

例2 LuoguP3916 图的遍历

明显的就是一个dfs或者bfs就可以搞掉的题。

然而我们还可以通过先缩点后topo sort套dp的方式优雅AC。

代码实现：

#include <iostream>
#include <cstdio>
#include <queue>

using namespace std;
struct edge
{
    int from, to, next;
};
struct gragh
{
    edge Edge[100086];
    int cnt, head[100086];
    inline void add_edge(int from, int to)
    {
        this->cnt++;
        this->Edge[this->cnt].from = from;
        this->Edge[this->cnt].to = to;
        this->Edge[this->cnt].next = this->head[from];
        this->head[from] = cnt;
    }
};
gragh a, b;

int dfn[100086], low[100086], dfncnt, stack[100086], top;
int group[100086], gcnt, maxid[100086];
bool vst[100086];
int n, m, In[100086], dp[100086];

void tarjan(int n)
{
    dfn[n] = low[n] = ++dfncnt;
    stack[++top] = n;
    vst[n] = true;
    for (int i = a.head[n]; i; i = a.Edge[i].next)
    {
        int to = a.Edge[i].to;
        if (dfn[to] == 0)
        {
            tarjan(to);
            low[n] = min(low[n], low[to]);
        }
        else if (vst[to])
        {
            low[n] = min(low[n], dfn[to]);
        }
    }
    if (low[n] == dfn[n])
    {
        int now;
        gcnt++;
        do
        {
            now = stack[top--];
            group[now] = gcnt;
            maxid[gcnt] = max(maxid[gcnt], now);
            vst[now] = false;
        } while (now != n);
    }
}

void rebuild()
{
    for (int i = 1; i <= a.cnt; i++)
    {
        int from = a.Edge[i].from;
        int to = a.Edge[i].to;
        if (group[from] != group[to])
        {
            In[group[to]]++;
            b.add_edge(group[from], group[to]);
        }
    }
}

void toposort()
{
    queue<int> q;
    for (int i = 1; i <= gcnt; i++)
        if (In[i] == 0)
            q.push(i);
    while (!q.empty())
    {
        int from = q.front();
        q.pop();
        dp[from] = max(dp[from], maxid[from]);
        for (int i = b.head[from]; i; i = b.Edge[i].next)
        {
            int to = b.Edge[i].to;
            dp[to] = max(dp[from], dp[to]);
            if (--In[to] == 0)
                q.push(to);
        }
    }
}

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= m; i++)
    {
        int f, t;
        scanf("%d%d", &f, &t);
        a.add_edge(t, f);
    }
    for (int i = 1; i <= n; i++)
    {
        if (dfn[i] == 0)
            tarjan(i);
    }
    rebuild();
    toposort();
    for (int i = 1; i <= n; i++)
    {
        printf("%d ", dp[group[i]]);
    }
    return 0;
}
01-03 12:00
Powered by LMLPHP ©2024 连通 0.063928