HDU 5765 Bonds

比赛时候想了好久,不会。看了官方题解才会......

Bond是极小割边集合,去掉一个Bond之后,只会将原图分成两个连通块。

假设某些点构成的集合为 s(点集中的点进行状压后得到的一个十进制数),那么剩下的点构成的集合为 t=(1<<n)-1-s

如果s是连通的,t也是连通的,那么跨越s、t集合的边的答案就+1(即跨越s、t集合的边构成一个Bond)。 

因此,只需枚举 s 即可。

接下来问题转变成了以下两个问题:

1.如何判断某个点集合是否连通:状压DP预处理。

2.如何让跨越s、t集合的边的答案+1:如果每次遍历所有的边去加答案,时间复杂度爆炸O(m*(1<<n)),因此需要换一种思路:

我们可以计算出所有Bond有几个,然后减去(u,v)不跨越s,t的Bond个数就是(u,v)这条边的答案。

具体看代码吧~~,再贴上官方题解:

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<iostream>
using namespace std;
typedef long long LL;
const double pi=acos(-1.0),eps=1e-8;
void File()
{
    freopen("D:\\in.txt","r",stdin);
    freopen("D:\\out.txt","w",stdout);
}
inline int read()
{
    char c = getchar();  while(!isdigit(c)) c = getchar();
    int x = 0;
    while(isdigit(c)) { x = x * 10 + c - ‘0‘; c = getchar(); }
    return x;
}

int T,n,m,e[25],sum[(1<<20)+10],sz;
int u[500],v[500];
bool f[(1<<20)+10];

void pre()
{
    for(int i=0;i<n;i++) f[1<<i]=1;
    for(int i=0;i<(1<<n);i++)
    {
        if(!f[i]) continue;
        int st=0; for(int j=0;j<n;j++) if(i&(1<<j)) st=st|e[j];
        for(int j=0;j<n;j++)
        {
            if(i&(1<<j)) continue;
            if(st&(1<<j)) f[i|(1<<j)]=1;
        }
    }
}

int main()
{
    scanf("%d",&T); int cas=1;
    while(T--)
    {
        scanf("%d%d",&n,&m);
        memset(e,sz=0,sizeof e); memset(f,0,sizeof f); memset(sum,0,sizeof sum);
        for(int i=0;i<m;i++)
        {
            scanf("%d%d",&u[i],&v[i]);
            e[u[i]]=e[u[i]]|(1<<v[i]), e[v[i]]=e[v[i]]|(1<<u[i]);
        }
        pre();
        for(int i=0;i<(1<<n);i++)
        {
            if(f[i]==0||f[(1<<n)-1-i]==0) continue;
            if(i>(1<<n)-1-i) break;
            sum[i]=1; sum[(1<<n)-1-i]=1; sz++;
        }
        for(int i=0;i<n;i++)
        {
            for(int j=(1<<n)-1;j>=0;j--)
            {
                if((1<<i)&j) continue;
                sum[j]=sum[j]+sum[(1<<i)|j];
            }
        }
        printf("Case #%d:",cas++);
        for(int i=0;i<m;i++) printf(" %d",sz-sum[(1<<u[i])|(1<<v[i])]);
        printf("\n");
    }
    return 0;
}
时间: 2024-11-28 14:19:32

HDU 5765 Bonds的相关文章

HDU - 5765 Bonds 思维 + sosdp(子集和dp)

HDU - 5765 一个bond肯定把n个点分成两个连通块, 并且每个集合对应一个bond, 因为当前这个集合属于第一个连通块, 那么它的补集就输入另一个连通块, ok[ mask ] 表示 mask这些点集能否成为一个连通块. 我们称一个分配方案mask是好的当且仅当ok[ mask ] == true && ok[ ~mask ] = true; 那么我们考虑一条边(u, v)属于多少个bond, 也就是总的合法的分配方案  减去 u, v在同一个点集里的方案数. 我们考虑sosdp

HDU 5765 Bonds(状压DP)

[题目链接] http://acm.hdu.edu.cn/showproblem.php?pid=5765 [题目大意] 给出一张图,求每条边在所有边割集中出现的次数. [题解] 利用状压DP,计算不同的连通块,对于每条边,求出两边的联通块的划分方案数,就是对于该点的答案. [代码] #include <cstdio> #include <algorithm> #include <cstring> using namespace std; int n,m,T,Cas=1

HDU 5765 Bonds 巧妙状压暴力

题意:给一个20个点无向连通图,求每条边被多少个极小割集包括 分析:极小割集是边的集合,很显然可以知道,极小割集恰好吧原图分成两部分(这个如果不明白可以用反证法) 然后就是奉上官方题解:http://bestcoder.hdu.edu.cn/blog/ 2016多校训练第4场1003 其实大体思路就是每次枚举一种可能的割集,即状压枚举,其中有不合法的,可以通过预处理标记所有的合法状态 剩下的就是贴代码了,好好看代码细节才是最重要的 #include <cstdio> #include <

HDU5765 Bonds 最小割极

http://acm.hdu.edu.cn/showproblem.php?pid=5765 题意:无向连通图,问每条边在几个最小割极上 思路:用位压形式,表示边的关系.g[1<<i]=1<<x  表示第i个点与哪几个点相连.然后,处理出每种点集和哪些点相连.每个点构成一个连通图,所以枚举当前点集,可以得到所有连通图的点集,计算出数量,用高维前缀和处理所有包含i点的连通块 ans=(所有连通块-同时包含(i,j)的连通块数目)/2  应为以(i,j)为割边的连通块,删除该边以后,数

背包 [HDU 1963] Investment

由于HDU上这个题目显示有问题,不好复制,所以从虚拟OJ上复制了 Investment Time Limit:10000MS     Memory Limit:32768KB     64bit IO Format:%lld & %llu Description John never knew he had a grand-uncle, until he received the notary??s letter. He learned that his late grand-uncle had

HDU 6203 ping ping ping [LCA,贪心,DFS序,BIT(树状数组)]

题目链接:[http://acm.hdu.edu.cn/showproblem.php?pid=6203] 题意 :给出一棵树,如果(a,b)路径上有坏点,那么(a,b)之间不联通,给出一些不联通的点对,然后判断最少有多少个坏点. 题解 :求每个点对的LCA,然后根据LCA的深度排序.从LCA最深的点对开始,如果a或者b点已经有点被标记了,那么continue,否者标记(a,b)LCA的子树每个顶点加1. #include<Bits/stdc++.h> using namespace std;

HDU 5542 The Battle of Chibi dp+树状数组

题目:http://acm.hdu.edu.cn/showproblem.php?pid=5542 题意:给你n个数,求其中上升子序列长度为m的个数 可以考虑用dp[i][j]表示以a[i]结尾的长度为j的上升子序列有多少 裸的dp是o(n2m) 所以需要优化 我们可以发现dp的第3维是找比它小的数,那么就可以用树状数组来找 这样就可以降低复杂度 #include<iostream> #include<cstdio> #include<cstring> #include

hdu 1207 汉诺塔II (DP+递推)

汉诺塔II Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 4529    Accepted Submission(s): 2231 Problem Description 经典的汉诺塔问题经常作为一个递归的经典例题存在.可能有人并不知道汉诺塔问题的典故.汉诺塔来源于印度传说的一个故事,上帝创造世界时作了三根金刚石柱子,在一根柱子上从下往

[hdu 2102]bfs+注意INF

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=2102 感觉这个题非常水,结果一直WA,最后发现居然是0x3f3f3f3f不够大导致的--把INF改成INF+INF就过了. #include<bits/stdc++.h> using namespace std; bool vis[2][15][15]; char s[2][15][15]; const int INF=0x3f3f3f3f; const int fx[]={0,0,1,-1};