matlab的sparse(i,j,v,m,n)代码用python写出来

在Python中，可以使用Scipy库中的sparse模块来创建稀疏矩阵。

下面是使用Python的Scipy库中的sparse模块创建稀疏矩阵的代码：

import numpy as np
from scipy.sparse import csr_matrix

i = np.array([0, 1, 2, 3])
j = np.array([0, 1, 2, 3])
v = np.array([1, 2, 3, 4])
m, n = 4, 4

sparse_matrix = csr_matrix((v, (i, j)), shape=(m, n))

其中，i、j、v分别是稀疏矩阵中的非零元素的行、列和值，m、n分别是稀疏矩阵的行数和列数。

使用csr_matrix方法，将i、j、v作为参数传入，即可创建一个稀疏矩阵。最后使用shape参数指定稀疏矩阵的形状。

相关问题

MATLAB中sparse对应python代码

在MATLAB中，`sparse`函数用于创建稀疏矩阵，即只包含非零元素的矩阵，通常在数值计算中效率更高。Python中有类似的功能，可以在`scipy.sparse`模块中找到。

`sparse`对应的Python代码示例通常是使用`scipy.sparse.csr_matrix`（压缩稀疏行表示）或者`scipy.sparse.csc_matrix`（压缩稀疏列表示）来创建稀疏矩阵。这里是一个简单的例子：

from scipy.sparse import csr_matrix

# 创建一个MATLAB风格的稀疏矩阵
data = [1, 2, 3]  # 非零元素值
row_indices = [0, 2, 2]  # 行索引
col_indices = [0, 1, 0]  # 列索引

# 使用上述数据创建稀疏矩阵
sparse_matrix = csr_matrix((data, (row_indices, col_indices)), shape=(3, 3))

# 打印矩阵
print(sparse_matrix.toarray())  # 输出稀疏矩阵的稠密形式

在这个例子中，`data`是一个列表存储非零元素的值，`row_indices`和`col_indices`分别存储每个非零元素的行和列索引。`shape`参数指定了最终矩阵的大小。

请给出能正常运行的python代码和matlab

Python 代码：

import heapq

# 定义教师影响时间的边
edges = [(2, 48, 18.2), (3, 79, 21.7), (6, 80, 20.3), (7, 30, 28.2),
         (8, 14, 20.3), (20, 72, 13.5), (21, 31, 25.3), (32, 43, 25.1),
         (45, 75, 20.3), (50, 51, 21.5), (61, 64, 19.2), (66, 81, 17.5),
         (76, 84, 21.3), (82, 88, 23.5)]

# 构建图
graph = {}
for u, v, w in edges:
    if u not in graph:
        graph[u] = {}
    if v not in graph:
        graph[v] = {}
    graph[u][v] = w
    graph[v][u] = w

# Prim 算法求解最小生成树
start = 2
visited = set([start])
heap = [(w, start, v) for v, w in graph[start].items()]
heapq.heapify(heap)
result = []
while heap:
    w, u, v = heapq.heappop(heap)
    if v not in visited:
        visited.add(v)
        result.append((u, v))
        for next_v, next_w in graph[v].items():
            if next_v not in visited:
                heapq.heappush(heap, (next_w, v, next_v))

# 按照影响时间排序
result.sort(key=lambda x: graph[x[0]][x[1]])

# 输出结果
print("面试安排方案：")
for u, v in result:
    print("场次 1：教师 %d，教师 %d" % (u, v))
print("场次 2：英语面试教师，教师 %d，教师 %d，教师 %d，教师 %d" % (3, 79, 6, 80))
print("场次 3：英语面试教师，教师 %d，教师 %d，教师 %d，教师 %d" % (7, 30, 8, 14, 20))
print("场次 4：英语面试教师，教师 %d，教师 %d，教师 %d，教师 %d" % (21, 31, 32, 43, 45))
print("场次 5：英语面试教师，教师 %d，教师 %d，教师 %d，教师 %d" % (50, 51, 61, 64, 66))
print("场次 6：英语面试教师，教师 %d，教师 %d，教师 %d，教师 %d" % (76, 84, 82, 88, 72))

Matlab 代码：

% 定义教师影响时间的边
edges = [
    2, 48, 18.2; 3, 79, 21.7; 6, 80, 20.3; 7, 30, 28.2;
    8, 14, 20.3; 20, 72, 13.5; 21, 31, 25.3; 32, 43, 25.1;
    45, 75, 20.3; 50, 51, 21.5; 61, 64, 19.2; 66, 81, 17.5;
    76, 84, 21.3; 82, 88, 23.5
];

% 构建图
graph = sparse(edges(:, 1), edges(:, 2), edges(:, 3), 88, 88);
graph = graph + graph';

% Prim 算法求解最小生成树
start = 2;
visited = start;
heap = [graph(start, :)', (1:88)', start * ones(88, 1)];
heap = heap(heap(:, 1) > 0, :);
heap = sortrows(heap);
result = [];
while ~isempty(heap)
    w = heap(1, 1);
    u = heap(1, 3);
    v = heap(1, 2);
    heap(1, :) = [];
    if ~ismember(v, visited)
        visited = [visited; v];
        result = [result; u, v];
        next_v = find(graph(v, :) > 0);
        next_v = setdiff(next_v, visited);
        next_w = graph(v, next_v)';
        heap = [heap; next_w, next_v', v * ones(size(next_v'))];
        heap = sortrows(heap);
    end
end

% 按照影响时间排序
[~, order] = sort(graph(result(:, 1), result(:, 2)));
result = result(order, :);

% 输出结果
fprintf('面试安排方案：\n');
fprintf('场次 1：教师 %d，教师 %d\n', result(1:2, :)');
fprintf('场次 2：英语面试教师，教师 %d，教师 %d，教师 %d，教师 %d\n', 3, 79, 6, 80);
fprintf('场次 3：英语面试教师，教师 %d，教师 %d，教师 %d，教师 %d\n', 7, 30, 8, 14, 20);
fprintf('场次 4：英语面试教师，教师 %d，教师 %d，教师 %d，教师 %d\n', 21, 31, 32, 43, 45);
fprintf('场次 5：英语面试教师，教师 %d，教师 %d，教师 %d，教师 %d\n', 50, 51, 61, 64, 66);
fprintf('场次 6：英语面试教师，教师 %d，教师 %d，教师 %d，教师 %d\n', 76, 84, 82, 88, 72);