afs3wq

#include<bits/stdc++.h>

using namespace std;

typedef vector < double > vector_t;
typedef vector < vector < double > > matrix_t;

vector_t make_vector(size_t n) {
    return vector_t(n);
}
matrix_t make_matrix(size_t x, size_t y) {
    return matrix_t(x, vector_t(y));
}

void print_vector(const vector_t &v) {
    for (const auto &i : v) {
        fprintf(stderr, "%.6f ", i);
    }
    cerr << "\n";
}
void print_matrix(const matrix_t &m) {
    for (const auto &i : m) {
        print_vector(i);
    }
    cerr << "\n";
}

vector_t& mult(vector_t &m, double v) {
    for (auto &i : m) {
        i *= v;
    }
    return m;
}
vector_t& div(vector_t &m, double v) {
    for (auto &i : m) {
        i /= v;
    }
    return m;
}
vector_t& add(vector_t &m, double v) {
    for (auto &i : m) {
        i += v;
    }
    return m;
}

vector_t& add(vector_t &a, const vector_t &b) {
    for (size_t i = 0; i < a.size(); ++i) {
        a[i] += b[i];
    }
    return a;
}

matrix_t minor(const matrix_t &m, size_t a, size_t b) {
    matrix_t res = make_matrix(0, 0);
    for (size_t i = 0; i < m.size(); ++i) {
        if (i == a) {
            continue;
        }
        res.push_back(make_vector(0));
        for (size_t j = 0; j < m.size(); ++j) {
            if (j != b) {
                res[res.size() - 1].push_back(m[i][j]);
            }
        }
    }
    return res;
}
double det(const matrix_t &m) {
    if (m.size() == 1) {
        return m[0][0];
    }
    double res = 0;
    for (size_t i = 0; i < m.size(); ++i) {
        res += (i & 1 ? -1 : 1) * det(minor(m, 0, i)) * m[0][i];
    }
    return res;
}

matrix_t inplace(const matrix_t &m, const vector_t &v, size_t n) {
    matrix_t res = m;
    for (size_t i = 0; i < m.size(); ++i) {
        res[i][n] = v[i];
    }
    return res;
}
vector_t calculate(const matrix_t &m, const vector_t &v) {
    vector_t res = make_vector(m.size());
    double detrem = det(m);
    for (size_t i = 0; i < m.size(); ++i) {
        double t = det(inplace(m, v, i));
        res[i] = detrem / t;
    }
    return res;
}

matrix_t mult(const matrix_t &a, const matrix_t &b) {
    matrix_t r = make_matrix(a.size(), b[0].size());
    for (size_t i = 0; i < a.size(); ++i) {
        for (size_t j = 0; j < b[0].size(); ++j) {
            for (size_t l = 0; l < b.size(); ++l) {
                r[i][j] += a[i][l] * b[l][j];
            }
        }
    }
    return r;
}

const matrix_t E {
    { 1, 0, 0, 0 },
    { 0, 1, 0, 0 },
    { 0, 0, 1, 0 },
    { 0, 0, 0, 1 }
};

matrix_t genrevB(const matrix_t &A, size_t n) {
    matrix_t res = E;
    res[n] = A[n + 1];
    return res;
}
matrix_t genB(const matrix_t &A, size_t n) {
    matrix_t res = genrevB(A, n);
    mult(res[n], -1);
    res[n][n] = 1;
    div(res[n], A[n + 1][n]);
    return res;
}

matrix_t& iter(matrix_t &A, size_t n) {
    matrix_t B = genB(A, n), revB = genrevB(A, n);
    cerr << "revB:\n";
    print_matrix(revB);
    cerr << "B:\n";
    print_matrix(B);
    return A = mult(mult(revB, A), B);
}

void frubenious(matrix_t &A) {
    cerr << "A:\n";
    print_matrix(A);
    for (int i = A.size() - 2; i >= 0; --i) {
        iter(A, i);
        cerr << "A:\n";
        print_matrix(A);
    }
}

void release_lambda(matrix_t &A, double lambda) {
    for (size_t i = 0; i < A.size(); ++i) {
        A[i][i] -= lambda;
    }
}

const vector_t lambda_list { 5.811869, 4.088694, 9.482340, 2.577096 };

matrix_t get_self_vector(const matrix_t &A, size_t lambda) {
    matrix_t res = make_matrix(A.size(), 1);
    res[A.size() - 1][0] = lambda_list[lambda];
    for (int i = A.size() - 2; i >= 0; --i) {
        res[i][0] = res[i + 1][0] * lambda_list[lambda];
    }
    return res;
}

void print_self_vectors(const matrix_t &A) {
    for (size_t i = 0; i < A.size(); ++i) {
        cerr << "\n";
        matrix_t t = get_self_vector(A, i),
                 lambda = { { lambda_list[i] } };
        print_matrix(t);
//      print_matrix(mult(t, lambda));
//      print_matrix(mult(A, t));
    }
}

int main(){

    matrix_t A {
        { 7.03, 0.92, 1.15, 1.135 },
        { 0.92, 3.39, 1.3, 0.16 },
        { 1.15, 1.3, 6.21, 2.1 },
        { 1.135, 0.16, 2.1, 5.33 }
    };

    frubenious(A);

//  print_vector(remans);
//  print_vector(ans);

    print_self_vectors(A);

}