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; 
}