[JLOI2015]装备购买 解题报告

我们考虑对这些向量高斯消元出的上三角矩阵中不全为0的向量。（它们其实就是线性基）
首先，对于那些还存在一个向量中此位不为0的位，我们称它为有效位。则无论我们以何种顺序何种方式消元，它所有线性基的有效位集合必然是相同的。因为我们知道，加减消元并不会改变能生成的集合。所以它线性基的生成集合必然等于原集合的生成集合。而如果两个线性基的有效位集合不同的话，就意味着存在一个向量它能被一个线性基生成而不能被另一个线性基生成。而作为推论，所有线性基的大小也是相同的。
而考虑题目中说的最大的子集使得其生成集合等于原集合，其实这就等于线性基。因为假如说有一个更大的，那么我们便可在其中求一个原集合的线性基出来。
而对于第二问，我们可以贪心。因为我们考虑按c从小到大排序，对于每一个向量，能选就选，那么假如它不选的话，必然是因为后面有一个向量把它清零了，而且后面向量的有效位在它这里并不为0，那么显然我们把后面这个向量换成它不会更优。

做这道题的时候我突然发现一个关于高斯消元的精度问题。就是矩阵中的值可能会增大的很快，最坏可能是每次都平方，最大可能有$({10^3})^{2^n}=10^{3*2^n}$，这样连long double都爆了。然而我并不会构造。。我只会构造最简单的那种让最大值达到$10^{3n}$的，只能卡一卡double。（所以我就在bzoj上加了组数据。。）而这种构造是基于每次选一个非零位，在其他向量中消去这一维的时候是减去当前向量乘以有效位之比的。
那么怎么非常科学的解决这个问题呢？
当然可以直接开long double。。但是我感觉这个应该也是一样可以卡的，虽然我不会。
一个更加科学的方法是，每次不再是随便找一个非零位，而是找绝对值最大的一位作为有效位，这样的话每次一个向量的每一位的值都至多增大一倍。最坏大小就成了$O(10^3*2^n)$，就在double可以承受的范围内了。
在普通的高斯消元中，有一个类似的方法是每次在每一列中找一个绝对值最大的元素，并将其所在行与当前行交换，这样的话它的值域增长速度也是指数级的。这种方法被叫做列主消元法。
需要注意的一点是，上述方法都是基于每次把某行减去当前行乘以某行的有效位比当前行有效位，所以我们要选有效位绝对值最大的。而如果我们选择把某行乘以当前行的有效位比某行的有效位减去当前行呢？按照这个逻辑我们应该选有效位绝对值最小的，但是这样的话又要考虑0的问题。就有点麻烦了。（其实也并不麻烦。。）所以谁减谁这个问题并不是随便减的。

upd：其实谁减谁的问题还有一个原因前者的做法是不会改变行列式的。

代码（会被卡）：

#include<cstdio>
#include<iostream>
using namespace std;
#include<algorithm>
#include<cmath>
#include<cstring>
const int N=500+5,M=500+5;
int in(){
    char c=getchar();
    while(c<'0'||c>'9')c=getchar();
    int x=0;
    for(;c>='0'&&c<='9';c=getchar())x=x*10+(c^'0');
    return x;
}
struct XS{
    double z[M];
    int c;
    bool operator < (const XS & o)const{
        return c<o.c;
    }
}z[N];
#define eps 1e-6
int main(){
    freopen("bzoj_4004.in","r",stdin);
    int n=in(),m=in();
    for(int i=n;i--;)
        for(int j=m;j--;)
            z[i].z[j]=in();
    for(int i=n;i--;)z[i].c=in();
    sort(z,z+n);
    pair<int,int> ans;

    /*for(int i=0;i<n;++i){
        for(int j=m;j--;)printf("%lf ",z[i].z[j]);
        puts("");
    }*/

    for(int i=0;i<n;++i)
        for(int j=m;j--;)
            if(fabs(z[i].z[j])>eps){
                ++ans.first,ans.second+=z[i].c;
                /*printf("Get(%d,%d)=",i,z[i].c);
                for(int o=m;o--;)printf("%lf ",z[i].z[o]);
                puts("");*/
                for(int k=n-1;k>i;--k)
                    if(fabs(z[k].z[j])>eps){
                        double tmp=z[k].z[j]/z[i].z[j];
                        for(int o=m;o--;)z[k].z[o]-=z[i].z[o]*tmp;
                    }
                /*for(int k=n-1;k>i;--k){
                    for(int o=m;o--;)printf("%lf ",z[k].z[o]);
                    puts("");
                }*/
                break;
            }
    printf("%d %d\n",ans.first,ans.second);
}

代码（不知道怎么被卡！）：

#include<cstdio>
#include<iostream>
using namespace std;
#include<algorithm>
#include<cmath>
#include<cstring>
const int N=500+5,M=500+5;
int in(){
    char c=getchar();
    while(c<'0'||c>'9')c=getchar();
    int x=0;
    for(;c>='0'&&c<='9';c=getchar())x=x*10+(c^'0');
    return x;
}
struct XS{
    double z[M];
    int c;
    bool operator < (const XS & o)const{
        return c<o.c;
    }
}z[N];
#define eps 1e-6
int main(){
    freopen("bzoj_4004.in","r",stdin);
    int n=in(),m=in();
    for(int i=n;i--;)
        for(int j=m;j--;)
            z[i].z[j]=in();
    for(int i=n;i--;)z[i].c=in();
    sort(z,z+n);
    pair<int,int> ans;

    /*for(int i=0;i<n;++i){
        for(int j=m;j--;)printf("%lf ",z[i].z[j]);
        puts("");
    }*/

    double tmp;
    int x;
    for(int i=0;i<n;++i){
        tmp=0,x=-1;
        for(int j=m;j--;)
            if(fabs(z[i].z[j])>tmp){
                tmp=fabs(z[i].z[j]);
                x=j;
            }
        if(tmp>eps){
            ++ans.first,ans.second+=z[i].c;
            for(int k=n-1;k>i;--k){
                double tmp=z[k].z[x]/z[i].z[x];
                for(int o=m;o--;)z[k].z[o]-=z[i].z[o]*tmp;
            }
        }
    }
    printf("%d %d\n",ans.first,ans.second);
}

总结：
①判断是否为0要注意用fabs>eps
②生成集合相同的集合的线性基的有效位集合必然相同。
③每次找一个最大值作为有效位/列主，可以很好的控制值的增长速度为$O(A2^n)$。