输入共 n+2 行。 ​ 第一行一个正整数 n ，保证 1≤n≤100 ； ​ 接下来 n 行，每行 n 个整数，表示 n 阶方阵 A ，保证每个数的绝对值不超过 100 ； ​ 接下来一行， n 个整数，表示 n 维向量 x ，保证每个数的绝对值不超过 100 。 输出 ​ 输出一行一个数，表示二次型 xTAx 的值。

以下是 Python3 代码实现：

n = int(input())
A = []
for i in range(n):
    row = list(map(int, input().split()))
    A.append(row)
x = list(map(int, input().split()))

# 计算二次型 xTAx
result = 0
for i in range(n):
    for j in range(n):
        result += A[i][j] * x[i] * x[j]

print(result)

以上代码中，我们先读入矩阵 A 和向量 x，然后通过两个 for 循环计算二次型 xTAx 的值并保存在 result 变量中，最后输出 result 即可。

相关问题

给定 n ，输出斐波那契数列的第 n 项，输出对 1000000007 取模，其中 F n ​ =F n−1 ​ +F n−2 ​ ,F 1 ​ =F 2 ​ =1 输入格式: 给出一个正整数 n(1≤n≤10 4 ) 输出格式: 输出斐波那契数列的第 n 项，对 1000000007 取模

斐波那契数列是一个经典的递归问题，可以用递归函数的方式来求解，但是由于递归会重复计算很多次相同的数值，导致时间复杂度很高，因此我们可以使用动态规划的方法来避免这种重复计算。

具体地，我们可以用一个数组 `dp` 来存储斐波那契数列的前 n 项，其中 `dp[i]` 表示第 i 项的值。初始时，我们将 `dp[1]` 和 `dp[2]` 的值都初始化为 1，然后从 `dp[3]` 开始逐个计算，直到计算出 `dp[n]`。

为了防止数值溢出，我们需要对每个 `dp[i]` 取模 1000000007，这样计算过程中每个数的大小都不会超过这个值，从而保证结果的正确性。

下面是 Python 代码实现：

n = int(input())

dp = [0] * (n + 1)
dp[1] = dp[2] = 1

for i in range(3, n + 1):
    dp[i] = (dp[i - 1] + dp[i - 2]) % 1000000007

print(dp[n])

这段代码首先读入一个正整数 `n`，然后初始化一个长度为 `n+1` 的数组 `dp`，将 `dp[1]` 和 `dp[2]` 的值都设为 1。接下来使用一个循环，从 `dp[3]` 开始逐个计算每个 `dp[i]` 的值，最后输出 `dp[n]` 即可。

乌拉拉市有n个共享电车桩点和m条双向道路，第 i 条道路连接 a i ​ 和 b i ​ ，长度为 c i ​ 单位距离。计算鸭每次使用一辆共享电车可以行驶 L 单位距离。更换共享电车只能在n个共享电车桩点更换，不能在路上更换，因为路上没有共享电车桩点。 现在计算鸭现在在规划行程，他有 q 个问题想要问你，第 i 个问题是：在s i ​ 点扫码租一辆共享电车后，想要到达t i ​ ，路途中，计算鸭最少需要更换几次共享电车，如果无法到达就是 −1。 输入格式: 第一行输入三个整数 n,m,L，含义如题所示 接下来 m 行，每行输入三个正整数 a i ​ ,b i ​ ,c i ​ ，含义如题所示 然后在一行中输入一个正整数 q，代表询问的次数 最后 q 行，每行输入两个正整数 s i ​ ,t i ​ ，含义如题所示 2≤n≤300 0≤m≤ 2 n×(n−1) ​ 1≤a i ​ ,b i ​ ,s i ​ ,t i ​ ≤n 1≤L,c i ​ ≤10 9 1≤q≤n×(n−1) 输入保证无重边和自环； 询问中 s i ​  =t i ​ 输出格式: 输出共 q 行，第 i 行代表第 i 次询问的结果 输入样例: 3 2 5 1 2 3 2 3 3 2 3 2 1 3 输出样例: 0 1 输入样例: 4 0 1 1 2 1 输出样例: -1c++代码

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 310, M = N * N, INF = 1e9;

int n, m, q, L;
int h[N], e[M], ne[M], w[M], idx;
int dist[N][N];

struct Node
{
    int p, d;
    bool operator< (const Node& t) const
    {
        return d > t.d;
    }
};

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}

void dijkstra(int start)
{
    priority_queue<Node> heap;
    memset(dist[start], 0x3f, sizeof dist[start]);
    dist[start][start] = 0;
    heap.push({start, 0});

    while (heap.size())
    {
        auto t = heap.top();
        heap.pop();

        int ver = t.p, distance = t.d;
        if (dist[start][ver] != distance) continue;

        for (int i = h[ver]; ~i; i = ne[i])
        {
            int j = e[i];
            if (dist[start][j] > distance + w[i])
            {
                dist[start][j] = distance + w[i];
                heap.push({j, dist[start][j]});
            }
        }
    }
}

int main()
{
    cin >> n >> m >> L;
    memset(h, -1, sizeof h);
    while (m -- )
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c), add(b, a, c);
    }

    for (int i = 1; i <= n; i ++ ) dijkstra(i);

    cin >> q;
    while (q -- )
    {
        int x, y;
        cin >> x >> y;

        if (dist[x][y] > L) puts("-1");
        else
        {
            int res = INF;
            for (int i = 1; i <= n; i ++ )
                for (int j = 1; j <= n; j ++ )
                    if (dist[x][i] + dist[j][y] + dist[i][j] <= L)
                        res = min(res, dist[x][i] + dist[j][y] + dist[i][j]);

            cout << res << endl;
        }
    }

    return 0;
}