1534.Count Good Triplets

class Solution:
    def countGoodTriplets(self, arr: List[int], a: int, b: int, c: int) -> int:
        res = 0
        for i in range(len(arr)):
            for j in range(i+1, len(arr)):
                for k in range(j+1, len(arr)):
                    if abs(arr[i] - arr[j]) <= a and abs(arr[j] - arr[k]) <= b and abs(arr[i] - arr[k]) <= c:
                        res += 1
        
        return res

剪枝过的

class Solution:
    def countGoodTriplets(self, arr: List[int], a: int, b: int, c: int) -> int:
        count = 0
        for i in range(len(arr)-2):
            for j in range(i + 1, len(arr)-1):
                if abs(arr[i] - arr[j]) > a:
                    continue
                for k in range(j + 1, len(arr)):
                    if abs(arr[j] - arr[k]) <= b and abs(arr[i] - arr[k]) <= c:
                        count += 1

        return count


作者:LiUrEs
链接:https://leetcode.cn/problems/count-good-triplets/solutions/358460/python3-mei-na-yao-bao-li-de-bao-li-jian-zhi-by-la/
来源:力扣(LeetCode)
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
在 C++ 的 Eigen 库中,可以使用 NEON 加速稀疏矩阵的运算。NEON 是 ARM 公司推出的 SIMD(单指令多数据流)技术,可以在 ARM 架构的处理器上实现并行计算,从而提高计算效率。 下面是使用 NEON 加速稀疏矩阵运算的示例代码: ```cpp #include <iostream> #include <vector> #include <Eigen/Sparse> #include <arm_neon.h> int main() { // 创建稀疏矩阵 F 和 Id const int n = 100; const int m = 200; std::vector<Eigen::Triplet<double>> triplets; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { triplets.push_back(Eigen::Triplet<double>(i * m + j, i * m + j, i + j)); if (i > 0) { triplets.push_back(Eigen::Triplet<double>(i * m + j, (i - 1) * m + j, i)); } if (j > 0) { triplets.push_back(Eigen::Triplet<double>(i * m + j, i * m + j - 1, j)); } } } Eigen::SparseMatrix<double> F(n * m, n * m); F.setFromTriplets(triplets.begin(), triplets.end()); Eigen::SparseMatrix<double> Id(n * m, n * m); for (int i = 0; i < n * m; i++) { Id.coeffRef(i, i) = 1; } // 计算 A = Id + lambda * F const double lambda = 0.1; Eigen::SparseMatrix<double> A(n * m, m * m); // 使用 NEON 加速矩阵的加法运算 const int blockSize = 4; for (int i = 0; i < n * m; i += blockSize) { for (int j = 0; j < m * m; j += blockSize) { double32x4_t acc[4] = {vdupq_n_f64(0), vdupq_n_f64(0), vdupq_n_f64(0), vdupq_n_f64(0)}; for (Eigen::SparseMatrix<double>::InnerIterator it(Id, i); it; ++it) { int k = it.index(); double32x4_t val = vdupq_n_f64(it.value()); acc[0] = vmlaq_lane_f64(acc[0], val, vld1q_f64(&F.value(k * m + j)), 0); acc[1] = vmlaq_lane_f64(acc[1], val, vld1q_f64(&F.value((k + 1) * m + j)), 0); acc[2] = vmlaq_lane_f64(acc[2], val, vld1q_f64(&F.value((k + 2) * m + j)), 0); acc[3] = vmlaq_lane_f64(acc[3], val, vld1q_f64(&F.value((k + 3) * m + j)), 0); } for (int k = 0; k < 4; k++) { double res[blockSize]; vst1q_f64(res, acc[k]); for (int l = 0; l < blockSize; l++) { A.coeffRef(i + k, j + l) = Id.coeff(i + k, j + l) + lambda * res[l]; } } } } // 输出结果 std::cout << A << std::endl; return 0; } ``` 在上述代码中,我们首先创建了稀疏矩阵 F 和 Id,并使用 NEON 加速矩阵的加法运算,计算了稀疏矩阵 A = Id + lambda * F。在计算过程中,我们将矩阵按照 blockSize 拆分成若干个块,对每个块进行 NEON 加速的计算,从而提高计算效率。 需要注意的是,使用 NEON 加速矩阵运算需要对矩阵进行合理的拆分和对齐,否则可能会导致性能下降。在实际应用中,可以根据具体的场景和需求来选择合适的 NEON 加速方案。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值