BZOJ2561 最小生成树

在做最小生成树训练时，遇到该题，立即就被卡住了，后来百度了一下，借鉴了网上的思路才弄出来Orz。

题目链接：http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=46843

这道题实际上是最小割问题，做这道题不仅训练了最小割，还复习了一下邻接表，确实是一道不错的题，具体思路和过程见代码

//思路：分别用大于v的边和小于v的边求最小割（从p1到p2）（每条路的l=1），因为只要小于目标边的边无法使得p1,p2l联通
//那么目标边肯定在最小生成树中，同理，如果大于目标边的边无法使得p1,p2联通，那么目标边就肯定在最大生成树中，所以
//这是一道求最小割的问题，思路巧妙，但是起决定性的还是细节
#include<stdio.h>
#include<string.h>
#include<algorithm>
#define INF 100000000
using namespace std;
int n,m,in,f[20005],Queue[20005],top,head[20005],p1,p2,v;//Queue用于bfs过程中记录每个进入队列的边的下标，f用来记录父边下标
bool flag[20005];
/*******************
数据量巨大，必须使用邻接表
*******************/
struct edge
{
    int p,v,next,l;
}e[400005];
void AddEdge(int from,int to,int value,int in)
{
    e[in].next=head[from];
    e[in].v=value;
    e[in].p=to;
    e[in].l=1;
    head[from]=in;
}
bool bfs(bool flag1)//flag1==true时是判断最大生成树，flag1==false时是判断最小生成树
{
    top=0;
    for(int i=head[p1];i!=-1;i=e[i].next)
    {
        if(e[i].l&&flag[e[i].p]&&((flag1==true&&e[i].v>v)||(flag1==false&&e[i].v<v)))//注意细节，不需要管v相同的边
        {
            f[top]=-1;
            Queue[top++]=i;
            flag[e[i].p]=false;
            if(e[i].p==p2)
                return true;
        }
    }
    for(int i=0;i<top;i++)
    {
        for(int j=head[e[Queue[i]].p];j!=-1;j=e[j].next)
        {
            if(flag[e[j].p]&&e[j].l&&((flag1==true&&e[j].v>v)||(flag1==false&&e[j].v<v)))//把j写成i的结果就是卡住三天ORZ，细节决定成败
            {
                f[top]=i;
                Queue[top++]=j;
                flag[e[j].p]=false;
                if(e[j].p==p2)
                    return true;
            }
        }
    }
    return false;
}
int getAns()
{
    int ans=0;
    while(1)
    {
        memset(flag,true,sizeof(flag));
        if(bfs(false))
        {
            int Min=INF;
            for(int i=top-1;i>=0;)
            {
                if(e[Queue[i]].l<Min)
                    Min=e[Queue[i]].l;
                i=f[i];
            }
            for(int i=top-1;i>=0;)
            {
                e[Queue[i]].l-=Min;
                e[Queue[i]^1].l+=Min;//由于边正反边是成对建立的，通过最低位与1异或可以快速确定相反的边，新技能，get！！
                i=f[i];
            }
            ans+=Min;
        }
        else
            break;
    }
    while(1)
    {
        memset(flag,true,sizeof(flag));
        if(bfs(true))
        {
            int Min=INF;
            for(int i=top-1;i>=0;)
            {
                if(e[Queue[i]].l<Min)
                    Min=e[Queue[i]].l;
                i=f[i];
            }
            for(int i=top-1;i>=0;)
            {
                e[Queue[i]].l-=Min;
                e[Queue[i]^1].l+=Min;
                i=f[i];
            }
            ans+=Min;
        }
        else
            return ans;
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    memset(head,-1,sizeof(head));
    for(int i=0;i<(2*m);i+=2)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        AddEdge(a,b,c,i);
        AddEdge(b,a,c,i+1);
    }
    scanf("%d%d%d",&p1,&p2,&v);
    printf("%d",getAns());//不需要换行
    return 0;
}

补充一下，这不是最优做法，我并没有学Dinic和sap，所以只能用这种很low的基本网络流方法了，用前面那两个做时间消耗少