要快速找到 A, B, C 使得 A×B×Cx4/13 最接近 D

原创 已于 2024-12-31 12:51:16 修改 · 457 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #人工智能

于 2024-12-30 15:31:22 首次发布

目录

1.最慢的办法，最精确的，

2. 比较快，但精确较差的办法。

3.改进精确度后

4.性能和准确度测试

5.针对应用场景进一步优化速度

0. 取值范围

A取值范围 为(64, 128, 256,1024),

B为（1-255），

C为（1-256）

D的取值范围是0-20568221

1.最慢的办法，最精确的，

三层循环循环，每次要计算261120 ，比较慢， 如下：


void find_best_abc_slow(uint32_t D, uint32_t *best_A, uint32_t *best_B, uint32_t *best_C, uint32_t *min_error) {
    uint32_t A_values[] = {64, 128, 256, 1024}; // A 的可能取值
    *min_error = UINT32_MAX; // 初始化最小误差为最大值
    *best_A = 0;
    *best_B = 0;
    *best_C = 0;



    // 枚举 A 的取值
    for (int i = 0; i < 4; i++) {
        uint32_t A = A_values[i];

        // 枚举 B 的取值
        for (uint32_t B = 1; B <= 255; B++) {
         
            for(uint32_t C=1; C<=256;C++)
            {
                // 计算当前值和误差
                uint32_t current_value = A * B * C *4/13;
                uint32_t error = (current_value > D) ? (current_value - D) : (D - current_value);

                // 更新最优解
                if (error < *min_error) {
                    *min_error = error;
                    *best_A = A;
                    *best_B = B;
                    *best_C = C;
                }
            }
        }
    }
}

2. 比较快，但精确较差的办法。

代码实现如下：

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <limits.h>

// 动态计算最优解
void find_best_abc(uint32_t D, uint32_t *best_A, uint32_t *best_B, uint32_t *best_C, uint32_t *min_error) {
    uint32_t A_values[] = {64, 128, 256, 1024}; // A 的可能取值
    *min_error = UINT32_MAX; // 初始化最小误差为最大值
    *best_A = 0;
    *best_B = 0;
    *best_C = 0;

    // 计算目标值 D'
    uint32_t D_prime = (uint32_t)((uint64_t)D * 13 / 4);

    // 枚举 A 的取值
    for (int i = 0; i < 4; i++) {
        uint32_t A = A_values[i];

        // 枚举 B 的取值
        for (uint32_t B = 1; B <= 255; B++) {
            uint32_t product_AB = A * B;

            // 剪枝：如果 A * B > D_prime，停止当前循环
            if (product_AB > D_prime) break;

            // 动态计算 C
            uint32_t C = D_prime / product_AB; // 整数除法计算 C

            // 检查 C 是否在合法范围
            if (C < 1 || C > 256) continue;

            // 计算当前值和误差
            uint32_t current_value = A * B * C;
            uint32_t error = (current_value > D_prime) ? (current_value - D_prime) : (D_prime - current_value);

            // 更新最优解
            if (error < *min_error) {
                *min_error = error;
                *best_A = A;
                *best_B = B;
                *best_C = C;
            }
        }
    }
}

3.改进精确度后

由于整法除法引起的精度问题，增加对于结果+-1的比较。


void find_best_abc_better(uint32_t D, uint32_t *best_A, uint32_t *best_B, uint32_t *best_C, uint32_t *min_error) {
    uint32_t A_values[] = {64, 128, 256, 1024}; // A 的可能取值
    *min_error = UINT32_MAX; // 初始化最小误差为最大值
    *best_A = 0;
    *best_B = 0;
    *best_C = 0;

    // 计算目标值 D'
    uint32_t D_prime = (uint32_t)((uint64_t)D * 13 / 4);

    // 枚举 A 的取值
    for (int i = 0; i < 4; i++) {
        uint32_t A = A_values[i];

        // 枚举 B 的取值
        for (uint32_t B = 1; B <= 255; B++) {
            uint32_t product_AB = A * B;

            // 剪枝：如果 A * B > D_prime，停止当前循环
            if (product_AB > D_prime) break;

            // 动态计算 C
            uint32_t C = D_prime / product_AB; // 初步估算的 C 值

            // 检查 C 和其附近值（C-1, C, C+1）
            for (int offset = -1; offset <= 1; offset++) {
                uint32_t adjusted_C = C + offset;

                // 检查 C 是否在合法范围
                if (adjusted_C < 1 || adjusted_C > 256) continue;

                // 计算当前值和误差
                uint64_t current_value = (uint64_t)A * B * adjusted_C;
                uint32_t error = (current_value > D_prime) ? (current_value - D_prime) : (D_prime - current_value);

                // 更新最优解
                if (error < *min_error) {
                    *min_error = error;
                    *best_A = A;
                    *best_B = B;
                    *best_C = adjusted_C;
                }
            }
        }
    }
}

4.性能和准确度测试

使用以下代码

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <limits.h>
#include <time.h>

// 动态计算最优解
void find_best_abc(uint32_t D, uint32_t *best_A, uint32_t *best_B, uint32_t *best_C, uint32_t *min_error) {
    uint32_t A_values[] = {64, 128, 256, 1024}; // A 的可能取值
    *min_error = UINT32_MAX; // 初始化最小误差为最大值
    *best_A = 0;
    *best_B = 0;
    *best_C = 0;

    // 计算目标值 D'
    uint32_t D_prime = (uint32_t)((uint64_t)D * 13 / 4);

    // 枚举 A 的取值
    for (int i = 0; i < 4; i++) {
        uint32_t A = A_values[i];

        // 枚举 B 的取值
        for (uint32_t B = 1; B <= 255; B++) {
            uint32_t product_AB = A * B;

            // 剪枝：如果 A * B > D_prime，停止当前循环
            if (product_AB > D_prime) break;

            // 动态计算 C
            uint32_t C = D_prime / product_AB; // 整数除法计算 C

            // 检查 C 是否在合法范围
            if (C < 1 || C > 256) continue;

            // 计算当前值和误差
            uint32_t current_value = A * B * C;
            uint32_t error = (current_value > D_prime) ? (current_value - D_prime) : (D_prime - current_value);

            // 更新最优解
            if (error < *min_error) {
                *min_error = error;
                *best_A = A;
                *best_B = B;
                *best_C = C;
            }
        }
    }

    uint32_t fix  = (  *best_A) * (*best_B) *  ( *best_C ) * 4 /13;
      *min_error   = (fix > D) ? (fix - D) : (D - fix);

}


void find_best_abc_better(uint32_t D, uint32_t *best_A, uint32_t *best_B, uint32_t *best_C, uint32_t *min_error) {
    uint32_t A_values[] = {64, 128, 256, 1024}; // A 的可能取值
    *min_error = UINT32_MAX; // 初始化最小误差为最大值
    *best_A = 0;
    *best_B = 0;
    *best_C = 0;

    // 计算目标值 D'
    uint32_t D_prime = (uint32_t)((uint64_t)D * 13 / 4);

    // 枚举 A 的取值
    for (int i = 0; i < 4; i++) {
        uint32_t A = A_values[i];

        // 枚举 B 的取值
        for (uint32_t B = 1; B <= 255; B++) {
            uint32_t product_AB = A * B;

            // 剪枝：如果 A * B > D_prime，停止当前循环
            if (product_AB > D_prime) break;

            // 动态计算 C
            uint32_t C = D_prime / product_AB; // 初步估算的 C 值

            // 检查 C 和其附近值（C-1, C, C+1）
            for (int offset = -1; offset <= 1; offset++) {
                uint32_t adjusted_C = C + offset;

                // 检查 C 是否在合法范围
                if (adjusted_C < 1 || adjusted_C > 256) continue;

                // 计算当前值和误差
                uint64_t current_value = (uint64_t)A * B * adjusted_C;
                uint32_t error = (current_value > D_prime) ? (current_value - D_prime) : (D_prime - current_value);

                // 更新最优解
                if (error < *min_error) {
                    *min_error = error;
                    *best_A = A;
                    *best_B = B;
                    *best_C = adjusted_C;
                }
            }
        }
    }

    uint32_t fix  = (  *best_A) * (*best_B) *  ( *best_C ) * 4 /13;
    *min_error   = (fix > D) ? (fix - D) : (D - fix);
}



void find_best_abc_slow(uint32_t D, uint32_t *best_A, uint32_t *best_B, uint32_t *best_C, uint32_t *min_error) {
    uint32_t A_values[] = {64, 128, 256, 1024}; // A 的可能取值
    *min_error = UINT32_MAX; // 初始化最小误差为最大值
    *best_A = 0;
    *best_B = 0;
    *best_C = 0;



    // 枚举 A 的取值
    for (int i = 0; i < 4; i++) {
        uint32_t A = A_values[i];

        // 枚举 B 的取值
        for (uint32_t B = 1; B <= 255; B++) {
         
            for(uint32_t C=1; C<=256;C++)
            {
                // 计算当前值和误差
                uint32_t current_value = A * B * C *4/13;
                uint32_t error = (current_value > D) ? (current_value - D) : (D - current_value);

                // 更新最优解
                if (error < *min_error) {
                    *min_error = error;
                    *best_A = A;
                    *best_B = B;
                    *best_C = C;
                }
            }
        }
    }
}


void find_best_abc_slow_better(uint32_t D, uint32_t *best_A, uint32_t *best_B, uint32_t *best_C, uint32_t *min_error) {
    uint32_t A_values[] = {64, 128, 256, 1024}; // A 的可能取值
    *min_error = UINT32_MAX; // 初始化最小误差为最大值
    *best_A = 0;
    *best_B = 0;
    *best_C = 0;

    // 计算目标值 D'
    uint32_t D_prime = (uint32_t)((uint64_t)D * 13 / 4);

    // 枚举 A 的取值
    for (int i = 0; i < 4; i++) {
        uint32_t A = A_values[i];

        // 枚举 B 的取值
        for (uint32_t B = 1; B <= 255; B++) {
            uint32_t product_AB = A * B;
            if (product_AB > D_prime) break; // 剪枝: 如果 A * B 已经大于 D'，跳过后续 B 值

            // 枚举 C 的取值
            for (uint32_t C = 1; C <= 256; C++) {
                uint32_t current_value = A * B * C * 4 / 13;
                uint32_t error = (current_value > D) ? (current_value - D) : (D - current_value);

                // 更新最优解
                if (error < *min_error) {
                    *min_error = error;
                    *best_A = A;
                    *best_B = B;
                    *best_C = C;
                }
            }
        }
    }
}




int main() {
    
    uint32_t best_A, best_B, best_C, min_error;

    clock_t start_time = clock();

    for(uint32_t D =1000;D<100000;D+=100)
    {
        // 计算最优解
        find_best_abc(D, &best_A, &best_B, &best_C, &min_error);

    }

    double elapsed_time = (double)(clock() - start_time) / CLOCKS_PER_SEC;
    printf("fast 运行时间: %.6f 秒\n", elapsed_time);


    start_time = clock();
    for(uint32_t D =1000;D<100000;D+=100)
    {
        // 计算最优解
        find_best_abc_better(D, &best_A, &best_B, &best_C, &min_error);

    }
    elapsed_time = (double)(clock() - start_time) / CLOCKS_PER_SEC;
    printf("better 运行时间: %.6f 秒\n", elapsed_time);


    
    start_time = clock();
    for(uint32_t D =1000;D<100000;D+=100)
    {
        // 计算最优解
        find_best_abc_slow(D, &best_A, &best_B, &best_C, &min_error);

    }
    elapsed_time = (double)(clock() - start_time) / CLOCKS_PER_SEC;
    printf("slow 运行时间: %.6f 秒\n", elapsed_time);



    for(uint32_t D =1000;D<100000;D+=100)
    {
        // 计算最优解
        find_best_abc(D, &best_A, &best_B, &best_C, &min_error);
        printf("FAST   D=%d 最优解: A = %d, B = %d, C = %d, 误差 = %d\n", D, best_A, best_B, best_C, min_error);

        find_best_abc_better(D, &best_A, &best_B, &best_C, &min_error);
        printf("BETTER D=%d 最优解: A = %d, B = %d, C = %d, 误差 = %d\n",D, best_A, best_B, best_C, min_error);

        find_best_abc_slow(D, &best_A, &best_B, &best_C, &min_error);
        printf("SLOW   D=%d最优解: A = %d, B = %d, C = %d, 误差 = %d\n",D, best_A, best_B, best_C, min_error);


    }

    return 0;
}

测试结果如下：

最快的算法比最慢的快 198倍

(base) $ gcc  findbest.c -o best
(base) $ ./best 
fast 运行时间: 0.004464 秒
better 运行时间: 0.011828 秒
slow 运行时间: 0.886645 秒
FAST   D=1000 最优解: A = 64, B = 1, C = 50, 误差 = 16
BETTER D=1000 最优解: A = 64, B = 1, C = 51, 误差 = 4
SLOW   D=1000最优解: A = 64, B = 1, C = 51, 误差 = 4
FAST   D=1100 最优解: A = 64, B = 1, C = 55, 误差 = 17
BETTER D=1100 最优解: A = 64, B = 1, C = 56, 误差 = 2
...
FAST   D=99900 最优解: A = 64, B = 57, C = 89, 误差 = 1
BETTER D=99900 最优解: A = 64, B = 57, C = 89, 误差 = 1
SLOW   D=99900最优解: A = 64, B = 57, C = 89, 误差 = 1

5.针对应用场景进一步优化速度

因为对于一个数值会多次取值，为了进一步改进速度，增加了一个cache层，把计算结果cache起，在下次使用时，快速查到cache中有没有，有的时候立即返回，无需计算。 cache的总数量为10个。

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <limits.h>

#define CACHE_SIZE 10 // 缓存的最大数量

// 定义缓存项结构
typedef struct {
    uint32_t D;          // 输入值
    uint32_t best_A;     // 最优解 A
    uint32_t best_B;     // 最优解 B
    uint32_t best_C;     // 最优解 C
    uint32_t min_error;  // 最小误差
} CacheEntry;

// 定义缓存
CacheEntry cache[CACHE_SIZE];
int cache_count = 0;

// 在缓存中查找目标值 D 的结果
int find_in_cache(uint32_t D, uint32_t *best_A, uint32_t *best_B, uint32_t *best_C, uint32_t *min_error) {
    for (int i = 0; i < cache_count; i++) {
        if (cache[i].D == D) {
            *best_A = cache[i].best_A;
            *best_B = cache[i].best_B;
            *best_C = cache[i].best_C;
            *min_error = cache[i].min_error;
            return 1; // 找到缓存
        }
    }
    return 0; // 未找到缓存
}

// 将计算结果存储到缓存中
void add_to_cache(uint32_t D, uint32_t best_A, uint32_t best_B, uint32_t best_C, uint32_t min_error) {
    if (cache_count < CACHE_SIZE) {
        // 如果缓存未满，直接添加
        cache[cache_count++] = (CacheEntry){D, best_A, best_B, best_C, min_error};
    } else {
        // 如果缓存已满，采用简单的替换策略（FIFO）
        for (int i = 1; i < CACHE_SIZE; i++) {
            cache[i - 1] = cache[i];
        }
        cache[CACHE_SIZE - 1] = (CacheEntry){D, best_A, best_B, best_C, min_error};
    }
}

// 动态计算最优解
void find_best_abc(uint32_t D, uint32_t *best_A, uint32_t *best_B, uint32_t *best_C, uint32_t *min_error) {
    // 首先查找缓存
    if (find_in_cache(D, best_A, best_B, best_C, min_error)) {
        return; // 如果找到缓存，直接返回
    }

    uint32_t A_values[] = {64, 128, 256, 1024}; // A 的可能取值
    *min_error = UINT32_MAX; // 初始化最小误差为最大值
    *best_A = 0;
    *best_B = 0;
    *best_C = 0;

    // 计算目标值 D'
    uint32_t D_prime = (uint32_t)((uint64_t)D * 13 / 4);

    // 枚举 A 的取值
    for (int i = 0; i < 4; i++) {
        uint32_t A = A_values[i];

        // 枚举 B 的取值
        for (uint32_t B = 1; B <= 255; B++) {
            uint32_t product_AB = A * B;

            // 剪枝：如果 A * B > D_prime，停止当前循环
            if (product_AB > D_prime) break;

            // 动态计算 C
            uint32_t C = D_prime / product_AB; // 初步估算的 C 值

            // 检查 C 和其附近值（C-1, C, C+1）
            for (int offset = -1; offset <= 1; offset++) {
                uint32_t adjusted_C = C + offset;

                // 检查 C 是否在合法范围
                if (adjusted_C < 1 || adjusted_C > 256) continue;

                // 计算当前值和误差
                uint64_t current_value = (uint64_t)A * B * adjusted_C;
                uint32_t error = (current_value > D_prime) ? (current_value - D_prime) : (D_prime - current_value);

                // 更新最优解
                if (error < *min_error) {
                    *min_error = error;
                    *best_A = A;
                    *best_B = B;
                    *best_C = adjusted_C;
                }
            }
        }
    }

    // 将计算结果存储到缓存中
    add_to_cache(D, *best_A, *best_B, *best_C, *min_error);
}

int main() {
    uint32_t D; // 目标值
    printf("请输入目标值 D (0 ~ 66846720): ");
    scanf("%u", &D);

    if (D > 66846720) {
        printf("输入值 D 超出范围！\n");
        return 1;
    }

    uint32_t best_A, best_B, best_C, min_error;

    // 计算最优解
    find_best_abc(D, &best_A, &best_B, &best_C, &min_error);

    // 输出结果
    printf("最优解: A = %u, B = %u, C = %u, 误差 = %u\n", best_A, best_B, best_C, min_error);

    return 0;
}
aerror
关注
Real-time voxel based 3D semantic mapping with a hand held RGB-D camera
weixin_47435705的博客
08-27 2655
环境感知是机器人智能的重要组成部分。为了更好地理解周围的环境，机器人不仅应该了解现实世界中物体的几何形状，还应该了解它们的语义。在这项工作中，我们演示了如何手持RGB-D相机实时构建基于体素的3D语义地图。我们结合了一个最先进的工作-ORB-SLAM，一个用于语义分割的卷积神经网络-PSPNet和一个高效的基于体素的3D地图表示-Octomap来构建一个工作系统。我们提出了不同的方法来融合语义信息来构建地图，并在ROS中实现了开源系统，这是一个广泛使用的机器人平台。...
路径平滑优化算法--B样条（B-spline）路径平滑算法
swaggytiger的博客
07-29 2015
B样条路径平滑算法通过分段低阶多项式曲线实现路径优化，克服了贝塞尔曲线的高阶震荡和全局修改问题。该算法利用控制点、节点向量和基函数定义平滑曲线，通过局部调整实现灵活优化。关键步骤包括：1)参数选择与节点向量构建；2)基于弦长的路径点参数化；3)最小二乘拟合控制点；4)曲线采样生成。实验表明，三次B样条能有效平滑离散路径点，保证C2连续性，同时通过局部控制特性避免全局重构。相较于贝塞尔曲线，B样条在路径平滑应用中展现出更好的稳定性和实用性。
游戏引擎学习第320天:Inverting a 2x2 Matrix by Hand
虾球
08-20 718
https://gitee.com/mrxiao_com/2d_game_8.git我们回顾了之前的内容，并为今天的讨论做了铺垫。昨天我们完整地演示了如何实时编写一个游戏。在过程中，为了让大家理解特定代码部分的实现，我们解释了矩阵在几何变换中的工作原理，包括矩阵的逆矩阵和转置矩阵之间的关系，以及进行 2D 图形处理时可能会用到的一些其他知识点。这些内容对于做一些稍微复杂的 2D 图形操作非常重要。虽然很多人写 2D 游戏可能从未真正接触过矩阵，但一旦需要做一些高级操作，掌握这些知识就变得不可或缺。 目前，我
MIT公开课18.06 Gilbert Strang 线性代数 笔记1 - Ax=b和四个子空间
NP very hard的博客
08-21 2481
文章目录相关链接课程链接推荐笔记链接第一讲：方程组的集合解释1. 从方程组到矩阵2. Ax = b解法1：row picture 行图像3. Ax = b解法2：column pircture 列图像数形结合：数：形：4.问题：于任意的b，是否都能求解Ax=b？用列向量线性组合的观点阐述就是，列三维情况下，向量的线性组合能否覆盖整个三维向量空间？5. 矩阵乘法方法5.1 向量内积5.2 列向量的线性组合第二讲：矩阵消元1.高斯消元法1.1消元步骤1.2 消元失效2.新视角看矩阵乘法旧角度新角度从列向量角度从
A Normalized Gaussian Wasserstein Distance for Tiny Object Detection（纯翻译）
Atticus的博客
02-07 1431
检测微小物体是一个非常具有挑战性的问题，因为微小物体仅包含几个像素大小。我们证明，由于缺乏外观信息，最先进的检测器无法在微小物体上产生令人满意的结果。我们的主要观察结果是，基于交并比 (IoU) 的指标（例如 IoU 本身及其扩展）对微小物体的位置偏差非常敏感，并且在用于基于锚的检测器时会大大降低检测性能。为了缓解这种情况，我们提出了一种使用 Wasserstein 距离进行微小物体检测的新评估指标。具体而言，我们。
【哈工大模式识别与机器学习(A)】期末重点总结
VJ1102的博客
12-27 1579
哈尔滨工业大学【模式识别与机器学习】科目期末考试复习大纲重点总结
C语言程序设计第五版谭浩强课后答案
m0_46753718的博客
11-02 3735
C语言程序设计第五版谭浩强课后答案
图解辗转相除法（欧几里得算法）求解最大公约/最小公倍数
热门推荐
tugouxp的专栏
09-12 1万+
基本原理：两个整数的最大公约数等于，其中较小的数和两数的差的最大公约数。个人解析：若A、B有最大公约数K（A > B)，则，A、B、（A - B）、A mod B（A / B的余数），都是K的倍数。即余数（A - B）和 B 的最大公公约数也是 K。由此递归，可知当 A mod B = 0，即 A 是 B 的倍数时，此时，B 即为 K。实际上，存在如下定理：两数最大公约数与最小公倍数的积等于两数之积，用公式表示就是：当时最大公因数*最小公倍数=pq。
Detecting tiny objects in aerial images: A normalized Wasserstein distance and a new benchmark(论文导读)
WSNjiang的博客
07-07 4384
航空图像中的小物体检测(TOD)具有挑战性，因为一个小物体只包含几个像素。由于缺乏对鉴别性特征的监督，最先进的物体检测对微小的物体不能提供令人满意的结果。我们的关键观察是(IOU)度量及其扩展对微小的位置偏差非常敏感，当使用基于锚点的检测器时，这大大降低了标签分配的质量。为了解决这一问题，我们提出了一种新的评估度量，称为归一化瓦瑟斯坦距离(NWD)和一种新的基于排名的分配(RKA)策略，用于微小目标检测。性能有大幅度的提高......
已知三次贝塞尔曲线U(起点:A,控制点1:B,控制点2:C,终点:D)计算线段L与曲线U交点位置.使用c++代码计算其过程生成给我
10-19
首先，用户的问题是：我想获取使用C++代码计算线段L与三次贝塞尔曲线U（起点A，控制点1为B，控制点2为C，终点D）交点位置的代码。 用户指定了需要C++代码来计算线段和三次贝塞尔曲线的交点。三次贝塞尔曲线由起点A...
使用牛顿迭代法解决和求出方程ax³+bx&sup2;+cx+d=0（Python版本）
10-19
在本例中，我们关注的是求解一个特定的三次方程：\( ax^3 + bx^2 + cx + d = 0 \)，其中系数 \( a \), \( b \), \( c \), \( d \) 已知且分别等于 1, 2, 3, 4。我们的目标是找到这个方程在 x=1 附近的实根。理解牛顿...
现有三元方程a*x1+b*x2+c*x3=U，现在已知序列x1、x2、x3、U，要求用RBF神经网络求出系数a、b、c，网络的输入为x1,x2,x3,x4，网络的输出为a,b,c，且输出的a,b,c均为固定的常数。
04-01
或者，用户的问题可能是：给定一个三元线性方程，例如ax + by + cz = d，其中a、b、c是未知系数，希望通过RBF神经网络，输入x、y、z（可能还有其他变量）来预测a、b、c。但通常这种情况下，每个方程实例对应一组系数...
请讲以下内容写成matlab代码，目的求解传递率与频率的关系并绘制图像，完全按照以下内容不要删减：在位移激励下的MSC折纸隔振结构被动隔振时可以抽象为单自由度质量弹簧动力学系统，以隔振结构的静平衡位置为坐标零点，沿系统的轴向建立一维绝对位移坐标系u，以基础静止时的位置为坐标零点，沿系统轴向建立一维绝对坐标系u_B，则隔振结构相对于基础的一维相对位移坐标系为 x=u-u_B 图6. 非线性弹簧等效模型 非线性弹簧等效模型如图所示，对基础施加u_B=Ucos(ωt)的简谐激振位移激励，非线性动力学系统的单自由度有阻尼受迫振动运动方程为： 结构高度h：定义域h∈(0,L)，静平衡位置 \(h_0=L/2 \) 压缩变形量x：定义域x∈(-L/2,L/2)，满足\(x=h_0-h=L/2-h\)。 旋转角度 θ：由给定几何关系： h(θ)=√(2L^2-(√2 Lsi n⁡(π/4+θ/2) )^2 )=L√2 co s⁡(π/4+θ/2) co s⁡(π/4+θ/2)=1/(2√2)-x/(L√2) ⇒ θ=2[arcco s⁡(1/(2√2)-x/(L√2))-π/4] 当 θ=0时，h(0)=L√2 co s⁡(π/4)=L，对应完全展开 x=-L/2 当 θ=π/2 时，h(π)=0，对应完全折叠 x=L/2 转盘转动动能： T_"rot" =1/2 I(θ^2 ) ̇ 重物平移动能： T_"trans" =1/2 m(u ̇ )^2=1/2 m(x ̇+(u_B ) ̇ )^2 总动能： T=1/2 I(θ^2 ) ̇+1/2 m(x ̇+(u_B ) ̇ )^2 求导，得到角速度 d/dt [π/4+θ/2]=-x ̇/(L√2 sin⁡(π/4+θ/2) ) ⇒ θ ̇=-(2x ̇)/(L√2 sin⁡(π/4+θ/2) ) T=(2I(x^2 ) ̇)/(L^2 sin^2⁡(π/4+θ/2) )+1/2 m(x ̇+(u_B ) ̇ )^2 势能: F_"spring" (x)=k_1 x+k_2 x^2+k_3 x^3+k_4 x^4+k_5 x^5+k_6 x^6+k_7 x^7 V(x)=1/2 k_1 x^2+1/3 k_2 x^3+1/4 k_3 x^4+1/5 k_4 x^5+1/6 k_5 x^6+1/7 k_6 x^7+1/8 k_7 x^8 L = T – V 运动方程为： d/dt (∂L/(∂x ̇ ))-∂L/∂x=Q_x 其中广义力Q_x由基底激励 u_B (t)=U cos⁡(ωt)引起：Q_x=-m(u_B ) ̈ 动量项： ∂L/(∂x ̇ )=(4Ix ̇)/(L^2 sin^2⁡(π/4+θ/2) )+m(x ̇+(u_B ) ̇ ) 时间导数： d/dt (∂L/(∂x ̇ ))=(4Ix ̈)/(L^2 sin^2⁡(π/4+θ/2) )+(2Ix ̇⋅cos⁡(π/4+θ/2)⋅θ ̇)/(L^2 sin^3⁡(π/4+θ/2) )+m(x ̈+(u_B ) ̈ ) 势能梯度项： ∂L/∂x=k_1 x+k_2 x^2+k_3 x^3 展开整理后，加入阻尼项得到非线性动力学方程： (4I/(L^2 sin^2⁡(π/4+θ/2) )+m) x ̈+(4I cos⁡(π/4+θ/2))/(L^3 sin^3⁡(π/4+θ/2) ) (x^2 ) ̇+cx ̇+(k_1 x+k_2 x^2+k_3 x^3+k_4 x^4+k_5 x^5+k_6 x^6+k_7 x^7)=mUω^2 cos⁡(ωt) 假设稳态响应为静态偏移A_0与基频简谐运动的叠加： x(t)=A_0+A cos⁡(ωt-α) 其导数为： x ̇(t)=-Aω sin⁡(ωt-α), x ̈(t)=-Aω^2 cos⁡(ωt-α) 将各非线性项展开至常数项和基频项（忽略高次谐波）： k_2 x^2≈k_2 (A_0^2+A^2/2)+2k_2 A_0 A cos⁡(ωt-α) k_3 x^3≈k_3 (A_0^3+(3A_0 A^2)/2)+3k_3 (A_0^2+A^2/4)A cos⁡(ωt-α) k_4 x^4≈k_4 (A_0^4+3A_0^2 A^2+(3A^4)/8)+4k_4 (A_0^3+(3A_0 A^2)/4)A cos⁡(ωt-α) k_5 x^5≈k_5 (A_0^5+5A_0^3 A^2+(15A_0 A^4)/8)+5k_5 (A_0^4+(9A_0^2 A^2)/4+(5A^4)/16)A cos⁡(ωt-α) k_6 x^6≈k_6 (A_0^6+15A_0^4 A^2+(45A_0^2 A^4)/8+(15A^6)/32)+6k_6 (A_0^5+(15A_0^3 A^2)/2+(45A_0 A^4)/16)A cos⁡(ωt-α) k_7 x^7≈k_7 (A_0^7+21A_0^5 A^2+(105A_0^3 A^4)/8+(105A_0 A^6)/16)+7k_7 (A_0^6+(105A_0^4 A^2)/4+(105A_0^2 A^4)/16+(35A^6)/64)A cos⁡(ωt-α) （1）常数项平衡方程 所有静态偏移项需满足： (4I cos⁡(π/4+θ/2) A^2 ω^2)/(2L^3 sin^3⁡(π/4+θ/2) )+∑_(n=1)^7▒k_n ⋅C_n=0 展开为： (2I cos⁡(π/4+θ/2) A^2 ω^2)/(L^3 sin^3⁡(π/4+θ/2) )+k_1 A_0+k_2 (A_0^2+A^2/2)+k_3 (A_0^3+(3A_0 A^2)/2)+k_4 (A_0^4+3A_0^2 A^2+(3A^4)/8)+k_5 (A_0^5+5A_0^3 A^2+(15A_0 A^4)/8)+k_6 (A_0^6+15A_0^4 A^2+(45A_0^2 A^4)/8+(15A^6)/32)+k_7 (A_0^7+21A_0^5 A^2+(105A_0^3 A^4)/8+(105A_0 A^6)/16)=0 （2）基频项平衡方程 基频项需满足： [(K_"eq" -M_"eq" ω^2 )^2+(cω)^2 ] A^2=(mUω^2 )^2 {█((K_"eq" -M_"eq" ω^2 )A=mUω^2 cosα@cωA=mUω^2 sinα)┤ 其中K_"eq" =∑_(n=1)^7▒k_n ⋅B_n，M_"eq" =4I/(L^2 sin^2⁡(a) )+m 具体展开为： [-M_"eq" ω^2+k_1+2k_2 A_0+3k_3 (A_0^2+A^2/4)+4k_4 (A_0^3+(3A_0 A^2)/4)+5k_5 (A_0^4+(9A_0^2 A^2)/4+(5A^4)/16)+6k_6 (A_0^5+(15A_0^3 A^2)/2+(45A_0 A^4)/16)+7k_7 (A_0^6+(105A_0^4 A^2)/4+(105A_0^2 A^4)/16+(35A^6)/64)]A=mUω^2 位移传递率 位移传递率T定义为绝对位移振幅与基座激励振幅之比： T=|A_0 |/U+√(1+2(A/U)[(K_"eq" -M_"eq" ω^2 )A/(mUω^2 )]+(A/U)^2 )
11-04
K_eq = k1 + 2*k2*A0 + 3*k3*(A0^2+A^2/4) + 4*k4*(A0^3+3*A0*A^2/4) + ... （直到k7） 5. 由方程2计算A的预测值： A_pred = sqrt( (m*U*omega^2)^2 / ( (K_eq-M_eq*omega^2)^2 + (c*omega)^2 ) ); 注意：这里...
dfs|mask^翻转
一个人知道自己为什么而活，他就能够接收任何一种生活
11-30 158
注意到：灯泡状态周期是6。
2025年全国大学生统计科学与算法编程挑战赛——算法赛道（一）
qq_73044452的博客
12-01 286
摘要：本文包含三个编程问题的解决方案。1) 贪吃蛇问题：通过解析移动指令计算蛇最终所在格子的编号；2) 经济小鱼问题：计算前两局存钱、后两局花钱，最终剩余指定金币的方案数；3) 小理吃甜食问题：模拟多轮糖果挑选过程，计算小理获得的最大总糖果值。每个问题都给出了完整的C++实现代码，涉及字符串处理、数学计算和模拟算法等技术。
算法基础篇：（二十一）数据结构之单调栈：从原理到实战，玩转高效解题
2301_79248256的博客
11-29 1588
本文深入解析了单调栈这一高效数据结构。首先介绍了单调栈的基本概念，即在普通栈的基础上增加元素单调性约束，可分为递增栈和递减栈。接着详细讲解了四种核心应用场景：寻找左右侧最近更大/更小元素，并提供了对应的C++代码实现。通过洛谷P5788等模板题和发射站、柱状图最大矩形等实战案例，展示了单调栈如何将O(n²)问题优化为O(n)解法。最后总结了单调性选择、遍历方向等核心技巧，并给出避免数据溢出、优化IO等实用建议。掌握单调栈能有效解决"找最近最值"类问题，是算法竞赛和面试中的重要工具。
[优选算法专题十.哈希表 ——NO.55~57 两数之和、判定是否互为字符重排、存在重复元素]
2401_83386596的博客
12-03 551
两数之和问题的最优解法采用哈希表实现O(n)时间复杂度，通过存储元素值与下标的映射关系，快速查找互补值。字符重排判定问题通过单哈希数组统计字符出现次数，先加后减并实时校验，确保字符种类和数量完全一致。存在重复元素问题使用哈希集合检测重复元素，遍历数组时检查元素是否已存在于集合中。三种解法均利用哈希结构优化查找效率，将时间复杂度从暴力解法的O(n²)降至O(n)，是典型空间换时间策略的工业级实现。
红包分配算法的严格数学理论与完整实现
12-03 512
红包分配问题可以严格定义为： 定义 1.1（红包分配问题）: 给定总金额 M>0M > 0M>0 和参与人数 n∈N+n \in \mathbb{N}^+n∈N+，分配函数 f:{1,2,...,n}→R+f: \{1, 2, ..., n\} \rightarrow \mathbb{R}^+f:{1,2,...,n}→R+ 需要满足：设 Ω\OmegaΩ 为样本空间，F\mathcal{F}F 为事件域，PPP 为概率测度： 1.2.2 随机变量性质 定义随机变量 XiX_iXi​ 表示第 iii 个人获
简单多源BFS问题
最新发布
MiauwYuki的博客
12-03 96
简单多源BFS问题
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值