java高斯消元模板

            //
            package fuc;
            import
             java.io.PrintStream;

            import
             java.math.BigInteger;

            import
             java.util.Scanner;


            public
            class
             Main {
    
            public
            static
            void
             main(String[] args) {
        
            new
             Task().main();
    }
}

            class
             frac{
    BigInteger a,b;
    frac(){
        a=BigInteger.ZERO;
        b=BigInteger.ONE;
    }
    frac(BigInteger a,BigInteger b){
        this.a=a;
        this.b=b;
    }
    frac sub(frac t){
        BigInteger p, q, d;
        p = a.multiply(t.b);
        p = p.subtract(t.a.multiply(b));
        q = b.multiply(t.b);
        d = p.gcd(q);
        p = p.divide(d);
        q = q.divide(d);
        returnnew frac(p, q);
    }
    frac add(frac t){
        BigInteger d, p, q;
        p = a.multiply(t.b);
        p = p.add(t.a.multiply(b));
        q = b.multiply(t.b);
        d = p.gcd(q);
        p = p.divide(d);
        q = q.divide(d);
        returnnew frac(p, q);
    }
    frac div(frac t) {
        BigInteger p, q, d;
        p = a.multiply(t.b);
        q = b.multiply(t.a);
        d = p.gcd(q);
        p = p.divide(d);
        q = q.divide(d);
        returnnew frac(p, q);
    }
    frac mul(frac t) {
        BigInteger p, q, d;
        p = a.multiply(t.a);
        q = b.multiply(t.b);
        d = p.gcd(q);
        p = p.divide(d);
        q = q.divide(d);
        returnnew frac(p, q);
    }
    frac abs() {
        returnnew frac(a.abs(), b.abs());
    }
    int compareTo(frac t) {
        t = this.sub(t);
        return t.a.compareTo(BigInteger.ZERO);
    }
    boolean zero() {
        return a.equals(BigInteger.ZERO);
    }
}
class Task{
    
    Scanner cin = new Scanner(System.in);
    PrintStream cout = System.out;
    BigInteger ONE= BigInteger.ONE;
    BigInteger ZERO=BigInteger.ZERO;
    frac[][] a = new frac[211][211];
    frac[] x = new frac[211];
    frac t;
    frac zero=new frac(ZERO,ONE);
    frac r,one =new frac(ONE,ONE);
    boolean gauss(int n){
        int i,j,k,row;
        for(i=1;i<=n;i++){
            row=i;
            for (j=i+1;j<=n;j++){
                if (a[row][i].abs().compareTo(a[j][i].abs())<0){
                    row = j;
                }
            }
            if (a[row][i].compareTo(zero)==0){
                returnfalse;
            }
            if (row!=i){
                for (k=i;k<=n;k++){
                    t=a[row][k];
                    a[row][k]=a[i][k];
                    a[i][k]=t;
                }
                t=x[row];
                x[row]=x[i];
                x[i]=t;
            }
            for (j=i+1;j<=n;j++){
                r=a[j][i].div(a[i][i]);
                a[j][i]=zero;
                for (k=i+1;k<=n;k++){
                    a[j][k]=a[j][k].sub(r.mul(a[i][k]));
                }
                x[j]=x[j].sub(r.mul(x[i]));
            }
        }
        for (i=n;i>=1;i--){
            for (j=i-1;j>=1;j--){
                r=a[j][i].div(a[i][i]);
                a[j][i]=zero;
                x[j]=x[j].sub(r.mul(x[i]));
            }
        }
        for (i=1;i<=n;i++){
            x[i]=x[i].div(a[i][i]);
        }
        returntrue;
    }
    
    void main(){
        int n,i,j;
        while(cin.hasNext()){
            n = cin.nextInt();
            for (i=1; i<= n; ++i){
                for (j=1; j<=n; ++j){
                    a[i][j]=new frac(cin.nextBigInteger(),ONE);
                }
                x[i]=new  frac(cin.nextBigInteger(),ONE);
            }
            if (!gauss(n)){
                cout.println("No solution.");
            }
            else{
                for (i=1;i<=n;i++){
                    if (x[i].b.compareTo(ZERO)<0){
                        x[i].a=x[i].a.negate();
                        x[i].b=x[i].b.negate();
                    }
                }
                for (i=1;i<=n;i++){
                    cout.print(x[i].a);
                    if (x[i].b.compareTo(ONE)!=0){
                        cout.print("/"+x[i].b);
                    }
                    cout.println();
                }
            }
            cout.println();
        }
    }
    
}