3118: Orz the MST(单纯形)

题目链接:http://www.lydsy.com:808/JudgeOnline/problem.php?id=3118

题意:给出一个图以及图中指定的n-1条边组成的生成树。每条边权值加1或者减去1都有相应的代价。求一个最小代价使得给出的边是最小生成树。

思路:对于每条非树边,必与某些树边形成环。设该非树边的权值为w2,某树边的权值为 w1。最后非树边增加x2,树边减少x1,那么w1-x1<=w2+x2。这样我们可以得到一些式子。代价也知道,这样就转化成线性规划问题。题目求的是最小值,我们可以将目标方程的系数取反求最大值。

单纯形的步骤:

(1)求出一个初始解;

(2)迭代。

(1)这个题的系数矩阵A是全么模:1、元素都是0,-1,1;2、任意子方阵的行列式为0,-1,1。

(2)据说A是全么模时解是整数解,因此此题可直接用单纯形。

const int COL=1005;
const int ROW=30005;

int n,m,B[ROW],N[COL];
double A[ROW][COL],b[ROW],c[COL],v;
double ans[COL];

int sgn(double x)
{
    if(x>1e-8) return 1;
    if(x<-1e-8) return -1;
    return 0;
}

//B中第l个替换N中第e个

void pivot(int l,int e)
{
    int i,j;
    double temp=A[l][e];
    b[l]/=temp; A[l][e]=1/temp;
    for(i=1;i<=n;i++) if(i!=e) A[l][i]/=temp;
    for(i=1;i<=m;i++) if(i!=l)
    {
        b[i]-=A[i][e]*b[l];
        for(j=1;j<=n;j++) if(j!=e) A[i][j]-=A[i][e]*A[l][j];
        A[i][e]=-A[i][e]/temp;
    }
    v+=b[l]*c[e];
    for(i=1;i<=n;i++) if(i!=e) c[i]-=c[e]*A[l][i];
    c[e]*=-A[l][e];
    swap(B[l],N[e]);
}

void simplex()
{
    int i,j,k,x;
    int l,s;
    double temp,temp1,temp2,temp3;

    while(1)
    {
        temp2=-dinf; s=-1;
        for(i=1;i<=n;i++) if(sgn(c[i])>0)
        {
            temp=dinf;
            for(k=1;k<=m;k++) if(sgn(A[k][i])>0)
            {
                temp3=b[k]/A[k][i];
                if(temp3<temp) temp=temp3,x=k;
            }
            if(temp2<temp*c[i])
            {
                s=i,l=x,temp2=temp*c[i];
            }
        }
        if(s==-1) break;
        pivot(l,s);
    }
    for(i=1;i<=n;i++)
    {
        for(j=1;j<=m;j++) if(B[j]==i) break;
        if(j<=m) ans[i]=b[j];
        else ans[i]=0;
    }
}

void print()
{
    int i,j;
    printf("v: %.3lf\n",v);
    printf("c:\n");
    for(i=1;i<=n;i++) printf("%.3lf ",c[i]); puts("");
    printf("A:\n");
    for(i=1;i<=m;i++)
    {
        for(j=1;j<=n;j++) printf("%.3lf ",A[i][j]);
        puts("");
    }
    printf("b:\n");
    for(i=1;i<=m;i++) printf("%.3lf ",b[i]); puts("");
    printf("B:\n");
    for(i=1;i<=m;i++) printf("%d ",B[i]); puts("");

    printf("N:\n");
    for(i=1;i<=n;i++) printf("%d ",N[i]); puts("");

}

int init()
{
    int i,j;
    int k=1;
    for(i=1;i<=m;i++) if(b[i]<b[k]) k=i;
    if(sgn(b[k])>=0)
    {
        for(i=1;i<=n;i++) N[i]=i;
        for(i=1;i<=m;i++) B[i]=n+i;
        v=0;
        simplex();
        return 1;
    }

    static double tmpC[COL];
    for(i=1;i<=n;i++) tmpC[i]=c[i];
    tmpC[n+1]=0;

    n++;
    for(i=1;i<=m;i++) A[i][n]=-1;
    for(i=1;i<=n;i++) N[i]=i;
    for(i=1;i<=m;i++) B[i]=n+i;
    v=0;
    for(i=1;i<=n;i++)
    {
        if(i<n) c[i]=0;
        else c[i]=-1;
    }
    pivot(k,n);
    simplex();

    if(sgn(ans[n])!=0) return 0;

    static int belongB[COL];
    clr(belongB,0);
    for(i=1;i<=m;i++)
    {
        if(B[i]>n) continue;
        belongB[B[i]]=i;
    }
    map<int,int> mp;
    for(i=1;i<=n;i++) mp[N[i]]=i;
    clr(c,0);
    v=0;
    for(i=1;i<=n;i++)
    {
        if(!belongB[i])
        {
            c[mp[i]]+=tmpC[i];
        }
        else
        {
            v+=tmpC[i]*b[belongB[i]];
            int j;
            for(j=1;j<=n;j++)
            {
                c[j]+=tmpC[i]*(-A[belongB[i]][j]);
            }
        }
    }
    c[mp[n]]=0;
    for(i=1;i<=m;i++) A[i][mp[n]]=0;

    simplex();
    n--;
    return 1;
}

struct node
{
    int u,v,id,w,next;
};

node edges[ROW];
int e;
int head[COL];

void add(int u,int v,int w,int id)
{
    e++;
    edges[e].u=u;
    edges[e].v=v;
    edges[e].w=w;
    edges[e].id=id;
    edges[e].next=head[u];
    head[u]=e;
}

int h[COL],up[COL],down[COL];
int eNum;
int inq[COL],KK;
int pre[COL];

void build(int s,int t,int p)
{
    int i;
    for(i=pre[t];i!=-1;)
    {
        int w1=edges[i].w;
        int w2=edges[p*2].w;

        m++;
        A[m][edges[i].id]=-1;
        A[m][p]=-1;
        b[m]=w2-w1;

        int u=edges[i].u;
        i=pre[u];
    }
}

void bfs(int s,int t,int p)
{
    queue<int> Q;
    Q.push(s);
    KK++;
    inq[s]=KK;
    pre[s]=-1;
    while(!Q.empty())
    {
        int u=Q.front();
        Q.pop();

        int i;
        for(i=head[u];i!=-1;i=edges[i].next)
        {
            int v=edges[i].v;
            int id=edges[i].id;
            if(!h[id]||KK==inq[v]) continue;
            pre[v]=i;
            if(v==t)
            {
                build(s,t,p);
                return;
            }
            Q.push(v);
            inq[v]=KK;
        }
    }
}

int main()
{
    n=myInt();
    eNum=myInt();
    clr(head,-1);
    int i;
    for(i=1;i<=eNum;i++)
    {
        int u,v,w;
        scanf("%d%d%d%d%d%d",&u,&v,&w,&h[i],&up[i],&down[i]);
        add(u,v,w,i);
        add(v,u,w,i);
    }
    for(i=1;i<=eNum;i++) if(!h[i])
    {
        int t=i*2;
        bfs(edges[t].u,edges[t].v,i);
    }
    for(i=1;i<=eNum;i++) c[i]=h[i]?-down[i]:-up[i];

    n=eNum;

    if(!init())
    {
        puts("no solution");
    }

    double res=-v;
    if(res<1e-10) res=0;
    printf("%.0lf\n",-v);
}
时间: 2024-11-13 06:37:37

3118: Orz the MST(单纯形)的相关文章

BZOJ 3118 Orz the MST 线性规划

题意:链接 方法:线性规划 解析: 这道题我也是orz了. 刚开始脑抽,仅仅是认为所有标号为1的边都比标号为0的边小即可. 后来与140142讨论了下发现我俩都犯好sb的错误=-= 这个图也是建了一阵子. 回忆之前做过的有关一个无向联通图中,一个边在最小生成树上,必要条件是该边构成的环中,这一边一定不是最大值. 这样的话,题中既然给了在树上的边. 并且很显然树上的边只能增加,不在树上的边只能减小. 所以我们不妨设Xi代表第i条边的变化值 那么我们可以重新显然定义代价Ci. 结合之前的结论 编号为

bzoj-3118 Orz the MST

题意: 给出一个无向连通图,并指定其中一颗生成树: 每条边上有一个权值vali,如果增大这个权值1则花费Ai,减小1花费Bi: 现在要使指定的生成树为一颗最小生成树,求最小花费: n<=300,m<=1000: 题解: 一道线性规划比较神的题目,前面刷的比较偏水就不刷了: 首先有一点极为显然的东西(我居然没看出来),树上的边一定减小权值,非树上的边一定增大权值: 然后考虑对于一颗生成树要为最小要满足的条件,也就是本题的约束条件: 如同Tarjan算法一样,每一条非树边都会在树上生成一个环: 而

poj 1751 输出MST中新加入的边

给出结点的坐标 以及已建好的边 要输出MST中加入的边(已建好的边就不用输出了)结点的编号从1开始注意这题只有一组数据 不能用多组输入 否则就超时(在这被坑惨了Orz) Sample Input 91 50 0 3 24 55 10 45 21 25 331 39 71 2Sample Output 1 63 74 95 78 3 1 # include <iostream> 2 # include <cstdio> 3 # include <cstring> 4 #

【KM】BZOJ1937 [Shoi2004]Mst 最小生成树

这道题拖了好久因为懒,结果1A了,惊讶∑( 口 || [题目大意] 给定一张n个顶点m条边的有权无向图.现要修改各边边权,使得给出n-1条边是这张图的最小生成树,代价为变化量的绝对值.求最小代价之和. [思路] 思路有点神,并不是我这种蒟蒻能够想到的XD 显然由贪心,树边必定变成wi-di,非树边必定变成wi+di (di≥0) 为了满足Mst的性质,考察一条非树边j,它加最小生成树后,必定构成一个环.对于环上的每一条树边i,有wi-di≤wj+dj,即di+dj≥wi-wj.这非常类似于KM的

poj 1639 Picnic Planning 度限制mst

https://vjudge.net/problem/POJ-1639 题意: 有一群人,他们要去某一个地方,每个车可以装无数个人,给出了n条路,包含的信息有路连接的地方,以及路的长度,路是双向的,但是终点只有一个,并且终点能停的车的数量是有限制的,问最少走的路是多少. 思路: 因为终点的停车的数量是有限制的,所以终点的度是有限制的,又因为这题可以用最小生成树解决,所以就是度限制最小生成树. 度限制最小生成树求解思想并不复杂,首先我们把有度限制的点给忽略,然后给每一个连通分量求最小生成树,最后把

mst

https://www.zybuluo.com/ysner/note/1245941 题面 给一个\(n\)点完全图,点权均小于\(2^m\).定义边权等于两端点点权的与和(即\(a_i\&b_i\)).求最大生成树边权和. \(10pts\ n\leq8000\) \(15pts\ m=1\) \(25pts\ m\leq12\) \(55pts\ m\leq15\) \(90pts\ n\leq10^5,m\leq18\) \(100pts\ n\leq5*10^6,m\leq20\) 解析

ACdream 1135 MST

MST Time Limit: 2000/1000MS (Java/Others) Memory Limit: 128000/64000KB (Java/Others) Problem Description Given a connected, undirected graph, a spanning tree of that graph is a subgraph that is a tree and connects all the vertices together.  A single

poj1789 MST 读题生涯永不停歇

题目: 链接在此 1.图论刷刷乐#1的第一题,无奈看了好长时间题目还是看不懂= =,明知是最水的题目 2.搜懂题目后,比较裸的MST,但还是决定写个题解,虽然没什么可说的,只是来警戒自己,还是要努力读题,YY大法,这也是水平的一个体现! #include <cstdio> #include <cstring> #include <iostream> #include <algorithm> #include <vector> #include &

【BZOJ 2654】 MST

2654: tree Description 给你一个无向带权连通图,每条边是黑色或白色.让你求一棵最小权的恰好有need条白色边的生成树. 题目保证有解. Input 第一行V,E,need分别表示点数,边数和需要的白色边数. 接下来E行,每行s,t,c,col表示这边的端点(点从0开始标号),边权,颜色(0白色1黑色). Output 一行表示所求生成树的边权和. V<=50000,E<=100000,所有数据边权为[1,100]中的正整数. Sample Input 2 2 1 0 1