bzoj-3118 Orz the MST

题意：

给出一个无向连通图，并指定其中一颗生成树；

每条边上有一个权值vali，如果增大这个权值1则花费Ai，减小1花费Bi；

现在要使指定的生成树为一颗最小生成树，求最小花费；

n<=300，m<=1000；

题解：

一道线性规划比较神的题目，前面刷的比较偏水就不刷了；

首先有一点极为显然的东西(我居然没看出来)，树上的边一定减小权值，非树上的边一定增大权值；

然后考虑对于一颗生成树要为最小要满足的条件，也就是本题的约束条件；

如同Tarjan算法一样，每一条非树边都会在树上生成一个环；

而如果这个环上的某个边权值比它大，那么这个环就可以从那条边处断开，且生成树更小；

也就是说对于一个非树边，环上边都要小于等于它；

找约束的过程我写的似乎比较蠢，深搜记了一堆再LCA；

不过无论如何最坏也不过n*m总归不会因此TLE；

设xi为第i条边的改变量，那么树边的即为减小量，非树边的为增大量；

可得方程：vali+xi<=valj-xj   (i为树边j为非树边，且i,j在一个环上)；

移项：xi+xj<=valj-vali；

现在的线性规划为：

Min∑costi*xi

xi+xj<=valj-vali

显然它不存在基本可行解，那么做一些变形；

首先将目标函数取反：

Max∑ -costi*xi

xi+xj<=valj-vali

然后对偶原理！

Max∑(valj-vali)*x(j,i)

%*&^%*>=-costi

再对不等式变号：

Max∑(valj-vali)*x(j,i)

-%*&^%*<=costi

现在就可以发现，线性规划已经是标准型了；

而题中的cost都是正数，也就是这个线性规划有基本可行解咯；

然后上单纯型直接搞这东西，题目性质也保证了这东西不会无界；

时间复杂度O(单纯型(n*m,m))；

显然是会T死的，然而约束并不会有最坏情况n*m这么多。。

所以还是可以过的啦，n*m的数组开到4000能A；

代码：

#include<vector>
#include<math.h>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#define N 310
#define M 1100
using namespace std;
const double EPS = 1e-8;
const double INF = 1e100;
struct node
{
    int n, m;
    double a[M][M << 2], b[M], c[M << 2], v;
    int find()
    {
        for (int i = 1; i <= n; i++)
        {
            if (c[i] > EPS)
                return i;
        }
        return 0;
    }
    void Rotate(int l, int e)
    {
        b[l] /= a[l][e];
        for (int i = 1; i <= n; i++)
        {
            if (i != e)
                a[l][i] /= a[l][e];
        }
        a[l][e] = 1 / a[l][e];
        for (int i = 1; i <= m; i++)
        {
            if (i == l || fabs(a[i][e]) < EPS)   continue;
            b[i] -= b[l] * a[i][e];
            for (int j = 1; j <= n; j++)
            {
                if (j != e)
                    a[i][j] -= a[l][j] * a[i][e];
            }
            a[i][e] *= -a[l][e];
        }
        v += c[e] * b[l];
        for (int i = 1; i <= n; i++)
        {
            if (i != e)
                c[i] -= c[e] * a[l][i];
        }
        c[e] *= -a[l][e];
    }
    void Simplex()
    {
        int i, j, k, l, e;
        while (e = find())
        {
            double lim = INF;
            for (i = 1; i <= m; i++)
            {
                if (a[i][e] < EPS)   continue;
                if (lim>b[i] / a[i][e])
                    lim = b[i] / a[i][e], l = i;
            }
            Rotate(l, e);
        }
    }
}T;
vector<int>to[N], val[N], cost[N], no[N];
vector<bool>cov[N];
int fa[N], prec[N], prev[N], preno[N], tim[N], deep[N], tot;
void Build(int x, int y, int val, int no)
{
    if (deep[x] < deep[y])
        swap(x, y);
    while (deep[x]>deep[y])
    {
        T.c[++T.n] = -(val - prev[x]);
        T.a[no][T.n] = 1;
        T.a[preno[x]][T.n] = 1;
        x = fa[x];
    }
    while (x != y)
    {
        T.c[++T.n] =-( val - prev[x]);
        T.a[no][T.n] = 1;
        T.a[preno[x]][T.n] = 1;
        x = fa[x];
        T.c[++T.n] = -(val - prev[y]);
        T.a[no][T.n] = 1;
        T.a[preno[y]][T.n] = 1;
        y = fa[y];
    }
}
void dfs(int x, int pre, int v, int num, int d)
{
    int i, y;
    fa[x]=pre,prev[x] = v, preno[x] = num, tim[x] = ++tot, deep[x] = d;
    for (i = 0; i < to[x].size(); i++)
    {
        if (cov[x][i]&&(y=to[x][i])!=pre)
            dfs(y, x, val[x][i], no[x][i], d + 1);
    }
    for (i = 0; i < to[x].size(); i++)
    {
        if (!cov[x][i] && tim[y = to[x][i]] && tim[y] < tim[x])
        {
            Build(x, y, val[x][i], no[x][i]);
        }
    }
}
int main()
{
    int n, m, i, j, k, x, y, v, f, a, b;
    scanf("%d%d", &n, &m);
    for (i = 1; i <= m; i++)
    {
        scanf("%d%d%d%d%d%d", &x, &y, &v, &f, &a, &b);
        to[x].push_back(y), val[x].push_back(v), cov[x].push_back(f), no[x].push_back(i);
        to[y].push_back(x), val[y].push_back(v), cov[y].push_back(f), no[y].push_back(i);
        if (f)
            T.b[i] = b;
        else
            T.b[i] = a;
    }
    dfs(1, 0, 0, 0, 1);
    T.m=m;
    T.Simplex();
    printf("%.0lf",T.v);
    return 0;
}