【C++心路历程28】 奇葩次小生成树

【问题描述】

　　给出一个无向图，图的边上有权值，已知该图的最小生成树边权和为A，问有多少种方案删除图的一条边，使得新图仍然存在生成树，而且最小生成树的边权和大于A。

【输入格式】

　　第一行是n，表示图的顶点数目，顶点编号为1~n。
　　接下来是一个n*n的矩阵，矩阵的第i行的第j个整数表示顶点i与顶点j的边权值（矩阵是对称的），如果为-1，表示这两个顶点之间无边连接。

【输出格式】

　　一个整数，表示删除一条边的方案数。

【输入样例】

3
0 1 2
1 0 2
2 2 0

【输出样例】

1

【数据范围】

30%的数据满足：n<=200
100%的数据满足：2<=n<=1000 ，边权是不超过1000000的非负整数。

【分析】
在最小生成树的基础上，改变了一些所求，其本质还是最小生成树算法。但感觉这个题要注意的点特别多。（可能是自身漏洞太多）

1、暴力（期望30分 实际上效果还不错 80分）
先kruskal一遍，再在最小生成树上枚举每一条树边，删除（标记）掉，再在新图上kruskal一遍与A比较，最后方案数即是答案。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<vector>
#include<cstring>
#include<queue>
using namespace std;
const int maxn=1000005;
const int maxm=1000005;
int x,y,n,m,np=0,s,pa[maxn],used[maxn],vis[maxn];
struct edge{
    int u,v,c;
    friend bool operator<(edge a,edge b)
    {
        return a.c<b.c;
    }
}E[maxm<<1];
vector<int>g[maxn];vector<int>w[maxn];
void init()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
    {
        scanf("%d",&x);
        if(j>=i) continue;
        if(x!=-1)
        {
            E[++np]=(edge){i,j,x};
        }   
    }
}
void initial()
{
    for(int i=1;i<=np;i++) pa[i]=i;
}
int find(int x)
{
    if(x==pa[x]) return x;
    int root=find(pa[x]);
    pa[x]=root;
    return root;
}
void merge(int x,int y)
{
    int px=find(x),py=find(y);
    if(px!=py) pa[px]=py;
}
bool judge(int x,int y)
{
    return find(x)==find(y);
}
int kruskal()
{
    sort(E+1,E+1+np);
    initial();
    int sum=0,cnt=0;
    for(int i=1;i<=np;i++)
    {
        int u=E[i].u,v=E[i].v,c=E[i].c;
        if(vis[i]) continue;
        if(judge(u,v))  continue;
        merge(u,v);sum+=c;cnt++;
        used[i]=1;
        if(cnt==n-1) break;
    }
    return sum;
}
int kruskal2(int xx)
{
//  sort(E+1,E+1+np);  **//这里千万不能再排序 因为写的排序只有一个关键字边权c  再排序会混乱**
    initial();
    int sum=0,cnt=0;
    for(int i=1;i<=np;i++)
    {
        int u=E[i].u,v=E[i].v,c=E[i].c;
        if(i==xx) continue; //**标记掉的边直接忽略**
        if(judge(u,v))  continue;
        merge(u,v);sum+=c;cnt++;
        if(cnt==n-1) break;
    }
    return sum;
}
int main()
{
//  freopen("in.txt","r",stdin);
    init();
    int A=kruskal();
    int ans=0;
    for(int i=1;i<=np;i++)
    {
        int ok=0;
        if(used[i])
        {
            int a2=kruskal2(i);
            if(a2>A) ans++;
        }
    }
    printf("%d",ans);
    return 0;
}

2.删边再加边 类似于“严格次小生成树”http://blog.csdn.net/ctf109/article/details/74298119
之前跟同学讨论，我觉得这个题和本题有异曲同工之妙，都是在非树边中选择一条，放在最小生成树中，再进行下一步操作。
本题：对于每一条非树边（u，v），如果在树上路径中有边权小于（u，v）的边t，则可以删除边t，方案数++。
问题在于题目所求：“问有多少种方案删除图的一条边，使得新图仍然存在生成树，而且最小生成树的边权和大于A。”故而每条边只能算一次，即需要标记，并且枚举非树边时需要从小到大排序。（t这条边用了以后就不能再用，并且也不可能再出现）
我认为本题最恶心的点是不仅要标记边权小于（u，v）的，还应标记等于的。如果这点理解有困难，请先理解上一排的斜体字。为什么不能再出现？（回忆最小生成树的生成过程）

#include<cstdio>
#include<queue>
#include<cmath>
#include<cstring>
#include<vector>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=1000005;
const int maxm=1000005;
int x,y,d,c,a,b,n,m,pa[maxn],used[maxm],dist[maxn],fa[maxn],dep[maxn],vis[maxm];
int hash[1005][1005];
int ans=0;
int np=0,first[maxn];
vector<int>g[maxn];
vector<int>w[maxn];
struct edge
{
    int u,v,c;
    friend bool operator<(edge a,edge b)
    {
        return a.c<b.c;
    }
}E[maxm<<1];
void addedge(int u,int v)
{
    E[++np]=(edge){v,first[u]};
    first[u]=np;
}
void initial()
{
    for(int i=1;i<=np;i++) pa[i]=i;
}
int find(int x)
{
    if(x==pa[x]) return x;
    int root=find(pa[x]);
    pa[x]=root;
    return root;
}
bool judge(int x,int y)
{
    return find(x)==find(y);
}
void merge(int x,int y)
{
    int px=find(x),py=find(y);
    if(px!=py) pa[px]=py;
}
void init()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
    {
        scanf("%d",&x);
        if(j>=i) continue;
        if(x!=-1)
        {
            E[++np]=(edge){i,j,x};
        }   
    }
}
int kruskal()
{
    int cnt=0,sum=0;
    initial();
    sort(E+1,E+1+np);
    for(int i=1;i<=np;i++)
    {
        int u=E[i].u,v=E[i].v;c=E[i].c;
        if(judge(u,v)) continue;
        g[u].push_back(v);
        g[v].push_back(u);
        w[u].push_back(c);
        w[v].push_back(c);
        used[i]=1;
        merge(u,v);cnt++;sum+=c;
        if(cnt==n-1) break;
    }
    return sum;
}
void dfs(int i,int f,int d,int t)
{
    dist[i]=t;
    dep[i]=d;
    fa[i]=f;
    int sz=g[i].size();
    for(int k=0;k<sz;k++)
    {
        int j=g[i][k],c=w[i][k];
        if(j==f) continue;
         dfs(j,i,d+1,t+c);
    }
}
int LCA(int u,int v,int kk)
{
    if(dep[u]<dep[v]) swap(u,v);
    int cnt=0;
    while(dep[u]!=dep[v])
    {
        if(dist[u]-dist[fa[u]]<kk&&(!hash[u][fa[u]])) 
        {
            cnt++;
        }
        //标记有更好的方法 这里比较愚蠢
        hash[u][fa[u]]=1;hash[fa[u]][u]=1;**//全部标记**
        u=fa[u];
    }
    while(u!=v)
    {
        if(dist[u]-dist[fa[u]]<kk&&(!hash[u][fa[u]])) 
        {
            cnt++;
        }
        hash[u][fa[u]]=1;hash[fa[u]][u]=1;**//全部标记**
        u=fa[u];
        if(dist[v]-dist[fa[v]]<kk&&(!hash[v][fa[v]])) 
        {
            cnt++;
        }
        hash[v][fa[v]]=1;hash[fa[v]][v]=1;**//全部标记**
        v=fa[v];
    }
    return cnt;
}
void solve()
{
    int A=kruskal();
    dfs(1,0,1,0);

    for(int i=1;i<=np;i++)
    {
        if(used[i]) continue;//枚举非树边
        int u=E[i].u,v=E[i].v,c=E[i].c;
        int cc=LCA(u,v,c);
        ans+=cc;
    }
    printf("%d",ans);
}
int main()
{
//  freopen("in.txt","r",stdin);
//  freopen("out.txt","w",stdout);
    init();
    solve();
    return 0;
}