LA 5135 Mining Your Own Business

最新推荐文章于 2022-10-26 21:02:18 发布

qte_acm

最新推荐文章于 2022-10-26 21:02:18 发布

阅读量543

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/zengchen__acmer/article/details/17323219

本文介绍了一种基于BCC（Biconnected Component）的算法，旨在解决无向图上的节点覆盖问题。通过寻找最少数量的节点使每个连通分量在删除任一节点后仍包含至少一个覆盖节点。文章提供了两种实现思路及其代码示例：一是利用DFS求割点再配合BFS遍历；二是直接找出所有BCC，并判断哪些BCC需要标记。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这是一个bcc题目。
建图模型是：在一个无向图上，选择尽量少的点涂黑，使得任意删除一个点，每个连通分量都至少有一个黑点。

所有，可以发现，如果把割点涂黑是不划算的。因此有两种方法。
1、用dfs求出所以割点，然后再用bfs进行遍历（不能经过割点），每次遍历出一个连通图，如果这个图只有1个割点，那么标记一个，如果超过1个黑点，就不要标记，因为，每次只删除一个割点，所有当这个连通图连接了两个割点时，就一点可以到达其他黑点。而如果整个图都没有黑点，则不需要遍历，可知只有2个黑点。
2、先求出这个图中的所有bcc ，就判断每个bcc ，如果这个bcc只有1个割点，那就要标记1个黑点，其他的则不需要进行标记。

代码：
1、
#include
#include
#include
#include
using namespace std ;

const int MAXN = 200100;
vectorgrap[MAXN] ;
int pre[MAXN] , iscut[MAXN];
int n = 0, m = 0, dfs_clock = 0;
int bz[MAXN] , d = 0 , f = 1 , bz2[MAXN];

int dfs(int u ,int fu)
{
    int lowu = pre[u] = ++dfs_clock;
    int child = 0;
    for(int i = 0 ; i < grap[u].size() ; i++)
    {
        int v = grap[u][i] ;
        if(!pre[v])
        {
            child += 1;
            int lowv = dfs(v , u);
            if(lowv < lowu) lowu = lowv;
            if(lowv >= pre[u])
            {
                iscut[u] = 1;
                d += 1;
                bz[u] = 1;
            }
        }
        else if(pre[v] < pre[u] && v != fu)
        {
            if(pre[v] < lowu)
                lowu = pre[v];
        }
    }
    if( fu < 0 && child == 1)
    {
        if(iscut[u] == 1)
        {
            d -= 1;
            iscut[u] = 0 ;
            bz[u] = 0;
        }
    }
    return lowu;
}

void dfs_find(int u)
{

    for(int i = 0 ; i < grap[u].size() ; i++)
    {
        int v = grap[u][i];
        if(bz2[v]==0 && iscut[v])
        {
            d += 1;
            bz2[v] = 1 ;
        }
        if(bz[v] == 0)
        {
            f += 1;
            bz[v] = 1;
            dfs_find(v);
        }
    }
}

int main()
{
    int p = 1;
    while(scanf("%d" , &n) != EOF)
    {
        if(!n) break ;
        int i , x , y , j;
        for(i = 1; i <= m; i++)
            grap[i].clear();
        m = 0;
        for(i = 0 ; i < n; i++)
        {
            scanf("%d %d" , &x , &y);
            grap[x].push_back(y);
            grap[y].push_back(x);
            if(x < y) x = y;
            if(x > m) m = x;
        }

        memset(pre , 0 , sizeof(pre));
        memset(iscut , 0 , sizeof(iscut));
        memset(bz , 0 , sizeof(bz));
        dfs_clock = 0 ;
        d = 0 ;

        dfs(1 , -1);

        long long min = 0 , sum = 1;
        if(d == 0)
        {
            printf("Case %d: %lld %lld\n" , p++ , 2 ,(long long)m*(m-1)/2);
        }
        else
        {
            for(i = 1; i <= m; i++)
            {
                if(!bz[i])
                {
                    memset(bz2 , 0 , sizeof(bz2));
                    f = 1;
                    d = 0;
                    bz[i] = 1;
                    dfs_find(i);
                    if(d <= 1)
                    {
                        min += 1;
                        sum *=(long long)f;
                    }
                }
            }
            printf("Case %d: %lld %lld\n" , p++ , min , sum);
        }
    }
    return 0;
}

2、

#include
#include
#include
#include
#include
using namespace std;

const int MAXN =200100 ;
vectorgrap[MAXN] , bcc[MAXN];
int pre[MAXN] , iscut[MAXN];
int dfs_clock = 0, dfs_cut = 0, bccno[MAXN];
int n , m = 0;
stacks , t ;

int dfs(int u , int fu)
{
    int lowu = pre[u] = ++dfs_clock;
    int child = 0;
    for(int i = 0 ; i < grap[u].size() ; i++)
    {

        int v = grap[u][i];
        if(!pre[v])
        {
            s.push(u);
            t.push(v);
            child++;
            int lowv = dfs(v , u);
            if(lowv < lowu)
            lowu = lowv;
            if(lowv >= pre[u])
            {
                iscut[u] = 1;
                dfs_cut++ ;bcc[dfs_cut].clear();
                for(; ;)
                {
                    int x = s.top() , y = t.top(); s.pop() ; t.pop();
                    if(bccno[x] != dfs_cut) {bcc[dfs_cut].push_back(x) ; bccno[x] = dfs_cut;}
                    if(bccno[y] != dfs_cut) {bcc[dfs_cut].push_back(y) ; bccno[y] = dfs_cut;}
                    if(x == u && y == v) break;
                }
            }
        }
        else if(pre[v] < pre[u] && v != fu)
        {
            s.push(u); t.push(v);
            if(lowu > pre[v])
            lowu = pre[v];
        }
    }
    if(fu < 0 && child == 1) iscut[u] = 0;
    return lowu;
}

int main()
{
    int p = 1;
    while(scanf("%d" , &n) != EOF)
    {
        if(n==0) break;
        int i ,j , x , y;
        for(i = 1; i <= m ; i++)
            grap[i].clear();
        m = 0;
        for(i = 0 ; i < n; i++)
        {
            scanf("%d %d" , &x , &y);
            grap[x].push_back(y);
            grap[y].push_back(x);
            if(x < y) x = y;
            if(m < x) m = x;
        }
        dfs_clock = dfs_cut = 0;
        memset(bccno , 0 , sizeof(bccno));
        memset(pre , 0 , sizeof(pre));
        memset(iscut , 0 , sizeof(iscut));
        dfs(1 , -1);
        int ans1 = 0 , ans2 = 1;
        for(i = 1; i <= dfs_cut; i++)
        {
            int cut_cnt = 0;
            for(j = 0 ; j < bcc[i].size() ; j++)
                if(iscut[bcc[i][j]]) cut_cnt += 1;
            if(cut_cnt == 1)
            {
                ans1 += 1;
                ans2 *=(bcc[i].size() - cut_cnt) ;
            }
        }
        if(dfs_cut == 1)
        {
            ans1 = 2;
            ans2 =bcc[1].size()*(bcc[1].size()-1)/2 ;
        }
        printf("Case %d: %lld %lld\n" , p++ , ans1 , ans2);
    }
    return 0;
}