一个同步到 Lapack 算法的 Householder 变换来三对角化一个对称矩阵的实现

已于 2023-05-02 00:52:21 修改
阅读量335 收藏 1
点赞数
文章标签： 算法 矩阵 c++
于 2023-04-18 13:29:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eloudy/article/details/130219505
版权

Householder Transformation:

任意 U(i) 是一个 n 维实数向量(或者复数向量)，

P(i) = I - U(i) * U(i)' / H(i)

其中：   Hi = (1/2) * Ui' * Ui

Hi = = H(i)等；

—————————————————————

变换矩阵：

Q = P(n-3)*P(n-2)*...*P(1)*P(0)

T = Q * A * Q'

A = inv(Q) * A * inv(Q')

_____________________________________

在计算如下值得过程中，

Pi = I - Ui * Ui' / Hi

Hi = (1/2) * Ui' * Ui

，为了实现数值稳定，Hi作为一个分母，这里在选取 U[t-1] 的时候，最大化了U[t-1]的绝对值:

通过：

U[t - 1] += get_sign(U[t - 1]) * sqrt(delta);

tridiagonal_symmetirc_matrix.cpp

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <cuComplex.h>

#define NA 5

#define PRINT_ALL 1

void print_matrix(float *A, int M, int N, int lda);
void print_vector(float *A, int len);
void cpu_gemm(int M, int N, int K, float *A, int lda, float *B, int ldb, float *C, int ldc, float alpha);    // C = alpha * A*B
void cpu_gemm_NT(int M, int N, int K, float *A, int lda, float *B, int ldb, float *C, int ldc, float alpha); // C = alpha * A*B'

void tridiag_symm_mat_Householder(float *A, int n, int lda, float *Q, int ldq);
int symmetric_matrix_test();
int hermite_matrix_test();
void complex_gemm(int M, int N, int K, cuComplex *A, int lda, cuComplex *B, int ldb, cuComplex *C, int ldc, float alpha);
void complex_gemm_NH(int M, int N, int K, cuComplex *A, int lda, cuComplex *B, int ldb, cuComplex *C, int ldc, float alpha);
float get_sign(float aij);

union np_f_i
{
  float f;
  int i;
};
typedef union np_f_i np_f_i;

float get_sign(float aij)
{
  np_f_i x;
  x.f = aij;
  return (x.i >> (sizeof(float)*8 - 1)) ? -1.0 : 1.0;
}

void tridiag_symm_mat_Householder(float *A, int n, int lda, float *Q, int ldq)
{
  for (int i = 0; i < n - 2; i++) // i = 0 ~ 3;
  {
    int t;

    float H;
    float delta;

    float U[NA];
    float P[NA * NA];
    int ldp = n;

    t = n - i - 1;

    // 01. fill the first U
    memset(U, 0x00, NA * sizeof(float));
    for (int idx = 0; idx < t; idx++)
    { // U(0:t-1) = A(t, 0:t-1)
      U[idx] = A[t + idx * lda];
    }
    // void print_vector(float *A, int len)
    printf("U(%d) first =\n", i);
    print_vector(U, n);

    // 02. calculat delta:
    delta = 0.0f;
    for (int idx = 0; idx < t; idx++)
    {
      delta += U[idx] * U[idx];
    }
    printf("delta(%d)=%7.4f\n", i, delta);
    // 03. fill the second U
    U[t - 1] += get_sign(U[t - 1]) * sqrt(delta); // for numerical stable;
    printf("U(%d) second =\n", i);
    print_vector(U, n);

    // 04. calculate H, a scalar
    H = 0.0f;
    for (int idx = 0; idx < t; idx++)
    {
      H += U[idx] * U[idx];
    }
    H *= 0.5f;
    printf("H_i(%d) = %7.4f\n", i, H);

    // 05. calculate P = -U*U'/H;     P = I - U*U'/H;
    // void cpu_gemm_NT(int M, int N, int K, float *A, int lda, float *B, int ldb, float *C, int ldc, float alpha); // C = alpha * A*B'
    cpu_gemm(n, n, 1, U, n, U, 1, P, n, -1.0f / H); // not need NT

    printf("P(%d) first=\n", i);
    print_matrix(P, n, n, ldp);
    // P = I + P      = I - U*U'/H
    for (int idx = 0; idx < n; idx++)
    {
      P[idx + idx * ldp] += 1.0f;
    }

    printf("P(%d) second=\n", i);
    print_matrix(P, n, n, ldp);
    // 06. A(i+1) = P(i)*A(i)*P(i)
    cpu_gemm(n, n, n, P, ldp, A, lda, A, lda, 1.0f);
    cpu_gemm(n, n, n, A, lda, P, ldp, A, lda, 1.0f);
    printf("A(%d) =\n", i);
    print_matrix(A, n, n, lda);

    // 07. Q(i+1) = P(i)*Q(i);         Q = P(n-3)*P(n-2)*...*P(0)*I
    cpu_gemm(n, n, n, P, ldp, Q, ldq, Q, ldq, 1.0f);
    printf("Q(%d) =\n", i);
    print_matrix(Q, n, n, ldq);
  }
}

int main()
{
  printf("\nN-1 to 2  tridiaganal symm ...\n");

  static float A_h[NA * NA] = {
      10.0, 1.0, 2.0, 3.0, 4.0,
      1.0, 9.0, -1.0, 2.0, -3.0,
      2.0, -1.0, 7.0, 3.0, -5.0,
      3.0, 2.0, 3.0, 12.0, -1.0,
      4.0, -3.0, -5.0, -1.0, 15.0};

  ///
  // i=0,1,...,n-3;   t=n-i-1;
  float *A = nullptr;
  float *Q = nullptr;
  int n = NA;
  int lda = n;
  int ldq = n;
  // alloc A
  A = (float *)malloc(n * n * sizeof(float));
  memcpy(A, A_h, n * n * sizeof(float));
  printf("A(0) =\n");
  print_matrix(A, n, n, lda);
  // alloc Q
  Q = (float *)malloc(ldq * n * sizeof(float));
  memset(Q, 0x00, ldq * n * sizeof(float));
  for (int idx = 0; idx < n; idx++)
  {
    Q[idx + idx * ldq] = 1.0f;
  }

  // void tridiag_symm_mat_Householder(float *A, int n, int lda, float *Q, int ldq)
  tridiag_symm_mat_Householder(A, n, lda, Q, ldq);

  /**
    for (int i = 0; i < n - 2; i++)// i = 0 ~ 3;
    {
      int t;

      float H;
      float delta;

      float U[NA];
      float P[NA * NA];
      int ldp = n;

      t = n - i - 1;

      // 01. fill the first U
      memset(U, 0x00, NA * sizeof(float));
      for (int idx = 0; idx < t; idx++)
      { // U(0:t-1) = A(t, 0:t-1)
        U[idx] = A[t + idx * lda];
      }
      // void print_vector(float *A, int len)
      printf("U(%d) first =\n", i);
      print_vector(U, n);

      // 02. calculat delta:
      delta = 0.0f;
      for (int idx = 0; idx < t; idx++)
      {
        delta += U[idx] * U[idx];
      }
      printf("delta(%d)=%7.4f\n", i, delta);
      // 03. fill the second U
      U[t - 1] += get_sign(U[t - 1]) * sqrt(delta); // for numerical stable;
      printf("U(%d) second =\n", i);
      print_vector(U, n);

      // 04. calculate H, a scalar
      H = 0.0f;
      for (int idx = 0; idx < t; idx++)
      {
        H += U[idx] * U[idx];
      }
      H *= 0.5f;
      printf("H_i(%d) = %7.4f\n", i, H);

      // 05. calculate P = -U*U'/H;     P = I - U*U'/H;
      // void cpu_gemm_NT(int M, int N, int K, float *A, int lda, float *B, int ldb, float *C, int ldc, float alpha); // C = alpha * A*B'
      cpu_gemm(n, n, 1, U, n, U, 1, P, n, -1.0f / H);// not need NT

      printf("P(%d) first=\n", i);
      print_matrix(P, n, n, ldp);
      // P = I + P      = I - U*U'/H
      for (int idx = 0; idx < n; idx++)
      {
        P[idx + idx * ldp] += 1.0f;
      }

      printf("P(%d) second=\n", i);
      print_matrix(P, n, n, ldp);
      // 06. A(i+1) = P(i)*A(i)*P(i)
      cpu_gemm(n, n, n, P, ldp, A, lda, A, lda, 1.0f);
      cpu_gemm(n, n, n, A, lda, P, ldp, A, lda, 1.0f);
      printf("A(%d) =\n", i);
      print_matrix(A, n, n, lda);

      // 07. Q(i+1) = P(i)*Q(i);         Q = P(n-3)*P(n-2)*...*P(0)*I
      cpu_gemm(n, n, n, P, ldp, Q, ldq, Q, ldq, 1.0f);
      printf("Q(%d) =\n", i);
      print_matrix(Q, n, n, ldq);

    }

  */

  printf("T=[ ...\n");
  print_matrix(A, n, n, lda);
  printf("]\nQ=[ ...\n");
  print_matrix(Q, n, n, ldq);
  printf("]\n");

  return 0;
}

void print_matrix(float *A, int M, int N, int lda)
{
  for (int i = 0; i < M; i++)
  {
    for (int j = 0; j < N; j++)
    {
      printf("%7.3f ", A[i + j * lda]);
    }
    printf("; ...\n");
  }
  // printf("\n");
}

void print_vector(float *A, int len)
{
  for (int idx = 0; idx < len; idx++)
  {
    printf("%7.4f ", A[idx]);
  }
  printf("\n");
}

void cpu_gemm(int M, int N, int K, float *A_h, int lda, float *B_h, int ldb, float *C, int ldc, float alpha)
{
  float *A = nullptr;
  float *B = nullptr;

  A = (float *)malloc(lda * K * sizeof(float));
  B = (float *)malloc(ldb * N * sizeof(float));

  memcpy(A, A_h, lda * K * sizeof(float));
  memcpy(B, B_h, ldb * N * sizeof(float));

  for (int i = 0; i < M; i++)
  {
    for (int j = 0; j < N; j++)
    {
      float sigma;

      sigma = 0.0f;
      for (int k = 0; k < K; k++)
      {
        sigma += A[i + k * lda] * B[k + j * ldb];
      }
      C[i + j * ldc] = alpha * sigma;
    }
  }

  free(A);
  free(B);
}

void cpu_gemm_NT(int M, int N, int K, float *A_h, int lda, float *B_h, int ldb, float *C, int ldc, float alpha)
{
  float *A = nullptr;
  float *B = nullptr;

  A = (float *)malloc(lda * K * sizeof(float));
  B = (float *)malloc(ldb * N * sizeof(float));

  memcpy(A, A_h, lda * K * sizeof(float));
  memcpy(B, B_h, ldb * N * sizeof(float));

  for (int i = 0; i < M; i++)
  {
    for (int j = 0; j < N; j++)
    {
      float sigma;

      sigma = 0.0f;
      for (int k = 0; k < K; k++)
      {
        sigma += A[i + k * lda] * B[k * ldb + j];
      }
      C[i + j * ldc] = alpha * sigma;
    }
  }

  free(A);
  free(B);
}

void complex_gemm_NH(int M, int N, int K, cuComplex *A, int lda, cuComplex *B, int ldb, cuComplex *C, int ldc, float alpha)
{
  cuComplex zero_;

  zero_ = make_cuFloatComplex(0.0f, 0.0f);
  for (int i = 0; i < M; i++)
  {
    for (int j = 0; j < N; j++)
    {
      cuComplex sigma;
      sigma = zero_;
      for (int k = 0; k < K; k++)
      {
        // sigma += A[i + k*lda]*B[k+j*ldb];
        sigma = cuCaddf(sigma, cuCmulf(A[i + k * lda], cuConjf(B[k * ldb + j])));
      }
      C[i + j * ldc] = make_cuFloatComplex(alpha * cuCrealf(sigma), alpha * cuCimagf(sigma));
    }
  }
}

void complex_gemm(int M, int N, int K, cuComplex *A, int lda, cuComplex *B, int ldb, cuComplex *C, int ldc, float alpha)
{
  cuComplex zero_;

  zero_ = make_cuFloatComplex(0.0f, 0.0f);
  for (int i = 0; i < M; i++)
  {
    for (int j = 0; j < N; j++)
    {
      cuComplex sigma;
      sigma = zero_;
      for (int k = 0; k < K; k++)
      {
        // sigma += A[i + k*lda]*B[k+j*ldb];
        sigma = cuCaddf(sigma, cuCmulf(A[i + k * lda], B[k + j * ldb]));
      }
      C[i + j * ldc] = make_cuFloatComplex(alpha * cuCrealf(sigma), alpha * cuCimagf(sigma));
    }
  }
}

/**
#include <stdio.h>
#include <math.h>



void strq(double *a, int n, double *q, double* b, double* c)//int n;  double a[],q[],b[],c[];
{
  int i,j,k,u,v;
    double h,f,g,h2;
    for (i=0; i<=n-1; i++)
    for (j=0; j<=n-1; j++)
      { u=i*n+j; q[u]=a[u];}
    for (i=n-1; i>=1; i--)
      { h=0.0;
        if (i>1)
          for (k=0; k<=i-1; k++)
            { u=i*n+k; h=h+q[u]*q[u];}
        if (h+1.0==1.0)
          { c[i]=0.0;
            if (i==1) c[i]=q[i*n+i-1];
            b[i]=0.0;
          }
        else
          { c[i]=sqrt(h);
            u=i*n+i-1;
            if (q[u]>0.0) c[i]=-c[i];
            h=h-q[u]*c[i];
            q[u]=q[u]-c[i];
            f=0.0;
            for (j=0; j<=i-1; j++)
              { q[j*n+i]=q[i*n+j]/h;
                g=0.0;
                for (k=0; k<=j; k++)
                  g=g+q[j*n+k]*q[i*n+k];
                if (j+1<=i-1)
                  for (k=j+1; k<=i-1; k++)
                    g=g+q[k*n+j]*q[i*n+k];
                c[j]=g/h;
                f=f+g*q[j*n+i];
              }
            h2=f/(h+h);
            for (j=0; j<=i-1; j++)
              { f=q[i*n+j];
                g=c[j]-h2*f;
                c[j]=g;
                for (k=0; k<=j; k++)
                  { u=j*n+k;
                    q[u]=q[u]-f*c[k]-g*q[i*n+k];
                  }
              }
            b[i]=h;
          }
      }
    for (i=0; i<=n-2; i++) c[i]=c[i+1];
    c[n-1]=0.0;
    b[0]=0.0;
    for (i=0; i<=n-1; i++)
      { if ((b[i]!=0.0)&&(i-1>=0))
          for (j=0; j<=i-1; j++)
            { g=0.0;
              for (k=0; k<=i-1; k++)
                g=g+q[i*n+k]*q[k*n+j];
              for (k=0; k<=i-1; k++)
                { u=k*n+j;
                  q[u]=q[u]-g*q[k*n+i];
                }
            }
        u=i*n+i;
        b[i]=q[u]; q[u]=1.0;
        if (i-1>=0)
          for (j=0; j<=i-1; j++)
            { q[i*n+j]=0.0; q[j*n+i]=0.0;}
      }
    return;
  }


int  main()
{
  int i,j;
    static double b[5],c[5],q[5*5];
    static double a[5*5]={
  10.0,  1.0,  2.0,  3.0,  4.0,
   1.0,  9.0, -1.0,  2.0, -3.0,
   2.0, -1.0,  7.0,  3.0, -5.0,
   3.0,  2.0,  3.0, 12.0, -1.0,
   4.0, -3.0, -5.0, -1.0, 15.0
  };

  int n = 5;

    strq(a,n,q,b,c);
    printf("MAT A IS:\n");

  int lda = n;
  int ldq = n;

    for (i=0; i<=4; i++)
    {
    for (j=0; j<=4; j++)
      printf("%7.3f ",a[i*lda + j]);
        printf("\n");
    }

    printf("\n");
    printf("MAT Q IS:\n");
    for (i=0; i<=4; i++)
    {
    for (j=0; j<=4; j++)
      printf("%7.3f ",q[i*ldq + j]);
        printf("\n");
    }

    printf("\n");
    printf("MAT B IS:\n");
    for (i=0; i<=4; i++)
    printf("%7.3f ",b[i]);

    printf("\n\n");
    printf("MAT C IS:\n");
    for (i=0; i<=4; i++)
    printf("%7.3f ",c[i]);
    printf("\n\n");

  return 0;
}

***/

Eloudy
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
豪斯霍德(Householder Reduction)转换成三对角形式(python,数值积分)
seventonight的博客
05-05 3550
第三十一篇 豪斯霍德转换成三对角形式 三对角形式 三对角矩阵就是对角线、邻近对角线的上下次对角线上有元素，其他位置均为0的矩阵。 雅可比主对角化求特征值要求转化矩阵应该具有下面的性质 豪斯霍尔德技术要求选择p为 其中{w}是一个归一化的列向量，使其欧几里德范数等于单位，因此 例如，让 按照上面的乘积 然后可以得到 它具有下面的性质 为消去[A]在对角线外第一行的项，向量{w}应被取为 因此，假设[A]为3 × 3，对第一行的变换矩阵为 当乘积[P][A][P]被计算时，结果矩阵的第一行包含
Using LAPACK in C/C++
suese的专栏
03-09 4303
<br /><br />http://cmsir.scinese.com/2008/02/22/using-lapack-in-c/<br />库的话应选择mt share。<br />Fortran是科学计算的标准语言，无论是性能，库，还是普及程度都勿庸置疑地是老大。作为最古老的计算机语言，这么多年的积累让其它语言几乎没可能改变这一局面。可惜我在大学时只学了C，这得怪我们系里的课程安排……无奈之下，很多时候只能C + Fortran Library来干活。最常用的Fortran库无疑是Lapack，主要就
【NA】Householder变换
Esperanto.的博客
03-27 2742
Householder 【户主】变换
h_trid:使用 Householder 方法对矩阵进行三对角化。-matlab开发
06-01
此函数将使用 Householder 方法对方形对称矩阵进行三对角化。
矩阵理论| 特殊矩阵：Householder矩阵 / 镜射矩阵
Insomnia_X的博客
02-13 6023
以上面的三对角化为基础，Householder 变换的两个主要应用都是在数值线性代数的内容：①执行 QR 分解；②计算特征值的 QR 迭代法的第一步。从第一列开始，依次将每一列变为三对角阵的形式，具体方法是设计一个可逆矩阵。，因而Householder矩阵是可逆的。正交投影至（镜射超平面的）法向量。到镜射超平面 的正交投影点就是。基于上面给出的最后一个性质，关于镜射超平面的 镜射点是。Householder矩阵。①从形式上，显然是对称矩阵。，其镜射变换后的向量为。上的投影长度，如图）
基于 Lapack 接口的 Hermitian 或对称矩阵的三对角化：代码通过调用 Lapack 例程计算 Hermitian 矩阵的三对角分解。-matlab开发
06-01
因此，此提交有助于人们使用 Hermitian/对称矩阵的三对角化，A = Q * T * Q'， 其中 A 是 Hermitian 或对称的，T 是实对称三对角线，Q 是酉或正交的。 最初的 Lapack 接口例程来自 Tim Toolan 在“文件交换”中的...
基于Lapack接口的矩阵双对角化：代码通过调用Lapack例程计算矩阵的双对角矩阵分解。-matlab开发
06-01
在 Lapack 中，双对角化用于通过例程 zgebrd 和 zungbr 计算矩阵的 SVD。 请参阅http://www.netlib.org/lapack/lug/node53.html但是，Matlab 不支持将双向例程作为独立样式。 因此，此提交帮助人们使用矩阵的双对角...
matlab开发-热对称矩阵在LaPackInterface上的三对角化
08-23
在MATLAB环境中，热对称矩阵的三对角化是一个重要的线性代数问题，它在数值计算中有着广泛的应用，比如求解大型稀疏线性系统、特征值问题等。LaPack（Linear Algebra Package）是用于高效解决这类问题的一个库，提供...
matlab开发-矩阵的双对角化
11-15
双对角化是指将一个矩阵通过一系列正交变换（如Householder变换或Givens旋转）转化为一个主对角线上只有非零元素，且次对角线上只有一对非零元素的矩阵形式。这个过程通常分为两个步骤：首先，将原矩阵转化为三对角...
CUSP：一个C++模板化稀疏矩阵库_C++_Cuda_下载.zip
04-13
3. **并行算法**：由于CUDA支持多核并行计算，CUSP利用这一点实现了高度并行的稀疏矩阵算法。例如，它可以并行地进行矩阵向量乘法（SpMV）和稀疏矩阵-稀疏矩阵乘法（SpGEMM），从而在大规模计算任务中获得显著性能...
[矩阵的QR分解系列三] 豪斯霍尔德(Householder)变换
honyniu的专栏
12-05 3万+
豪斯霍尔德变换简介 之前介绍的矩阵的三角分解系列介绍了利用矩阵初等变换解决了矩阵三角化问题以及具体的三角分解。但是以初等变换工具的三角分解方法并不能消除病态线性方程组不稳定问题，而且有时候对于可逆矩阵有可能也不存在三角分解。所以后面为了解决这里问题，发展出来了以正交(酉)变换的矩阵的QR(正交三角)分解，矩阵的正交三角分解是一种对任何可逆矩阵均存在理想分解。进行QR分解需要用到施密特(Schmidt)正交规范化，吉文斯(Givens)变换和豪斯霍尔德(Householder)变换等。这里矩阵的QR分解系列教
Householder变换将对称矩阵化为三对角形式
u011378809的专栏
07-28 9204
//Householder变换将对称矩阵化为三对角形式 #include #include #include using namespace std; class householder { private:  int i, j, k, m, n, sgn;  double eps, s, sum;  double *w;  double **a, **b, **c;
Householder变换
qq_18834185的博客
05-14 1万+
参考地址 https://www.cnblogs.com/reasno/p/9606224.html Householder变换是一种能将n维向量x变换到任一n维向量y的正交变换，由于从几何上看Householder变换通过x和y之间的垂直平分面将x“反射”到y，因此Householder变换又叫镜面变换； Householder的主要应用在于它能够将x变换成任意一个等长的若干个分量为0的向量（这...
超定方程组的householder变换求解matlab实现
篱落~~成殇~~
11-28 2969
超定方程组的householder变换求解matlab实现 1、matlab实现 function [R,b,X]=L_equation_householder(A,B) %%%输入方程组系数矩阵A和右端列向量B; %%%利用householder变换将矩阵变换为上三角矩阵，并同时对B进行变换；最后利用上三角矩阵回代法； %%%输出上三角矩阵R，右端列向量b(前n个元素组成的列向量)，方程的解X。 [m,n]=size(A); for k=1:n temp_A=A(k:m,k:n); %取出aij
matlab 上三角矩阵变为对称矩阵,已知"上/下三角矩阵"如何快速将"对称阵"补全
weixin_35719180的博客
03-18 4536
适用在哪里如题，如何根据"上/下三角矩阵"快速补全其相应的"对称阵"，适用情况如下：当有一个三角阵时，快速生成其对应的另一半三角阵；当想生成一个对称阵时，可以先生成其一半的三角阵，再用该三角阵将原阵补全。实现方法：triu()与tril()函数x = rand(3,3);% 完整的上三角与下下三角矩阵tri_up = triu(x); % 完整上三角,第二个参数默认为0tri_low = tr...
特殊矩阵——三对角矩阵(Tridiagonal Matrix)
热门推荐
Catherine的笔记
06-27 7万+
特殊矩阵——三对角矩阵(Tridiagonal Matrix) 1. 三对角矩阵的概念 三对角矩阵就是对角线、邻近对角线的上下次对角线上有元素，其他位置均为0的矩阵。 三对角矩阵是一种特殊的上Hessenberg矩阵（这个就是上三角矩阵加上下三角部分的第一条次对角线有元素，其他都为0元素）。 2. 三对角矩阵的特性 设一个n*n的方阵A，对于矩阵A中的任一元素aij，当|i-j|>1时，有aij=0(0≤i≤n
算法日记day 45（单调栈之每日温度|接雨水）
最新发布
m0_74980681的博客
08-22 599
如果大于，则取栈顶元素为中间值并弹出栈顶元素，将遍历的元素与新的栈顶元素值比较取较小者，减去中间值得到高度h，然后栈顶元素下标值减去当前遍历的元素下标值再减一得到宽度w，最后高×宽得到面积，并记录，重复上述操作，直到遍历结束。第三种，如果遍历的元素值大于栈顶元素，用该下标减去栈顶元素下标，并将栈顶元素弹出，继续用该元素与新的栈顶元素比较，如果小于等于，则压入栈，如果大于，重复第三步操作。第一种，如果之后遍历的元素值小于栈顶压入的元素，将该元素的下标压入栈中。如果小于栈顶元素值，则压入栈内。
代码随想录算法训练营19-回溯1
weixin_53416771的博客
08-22 283
画出来的树是这样记录所有组合，一个变量current装当前的处理结果，一个res装所有的处理的结果下面的代码还可以剪枝优化。
四十一、【人工智能】【机器学习】- Bayesian Logistic Regression算法模型
技术分享、程序员趣事、行业趋势等内容！
08-19 911
监督学习（Supervised Learning）是机器学习中的一种主要方法，其核心思想是通过已知的输入-输出对（即带有标签的数据集）来训练模型，从而使模型能够泛化到未见的新数据上，做出正确的预测或分类。在监督学习过程中，算法“学习”的依据是这些已标记的例子，目标是找到输入特征与预期输出之间的映射关系。Bayesian Logistic Regression是一种统计建模方法，它结合了Logistic回归的原理和贝叶斯统计的框架。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值