算法-经点问题(鸡兔同笼,麦克劳林求pi,开灯问题)

本文解析了三个经典算法问题:鸡兔同笼问题的数学建模与求解;使用麦克劳林公式估算π值的方法;以及开灯问题的逻辑实现。通过具体的C语言代码示例,展示了如何运用算法解决实际问题。

1、鸡兔同笼问题

//已经鸡和兔的总数量为n 总腿数为m 输入 n,m 输出鸡和兔的数量
//分析:设鸡a只 兔b只 a+b=n 2a+4b=m a=(4n-m)/2 b=n-a

//鸡兔同笼
void ChickenRibbit()
{
	//已经鸡和兔的总数量为n 总腿数为m 输入 n,m 输出鸡和兔的数量
	//分析:设鸡a只 兔b只 则建设方式组a+b=n 2a+4b=m 解得a=(4n-m)/2 b=n-a
	int a, b ,m, n;
	scanf_s("%d%d", &n, &m);
	a = (4*n - m) / 2;
	b = n - a;
	if (m%2==1||a<0||b<0)
	{
		printf_s("无解\n");
	}
	else
	{
		printf_s("%d %d\n", a, b);
	}
}

2、麦克劳林公式近似值求pi


X=1 arctan 1= pi/4=1-1/3+1/5-1/7…

void approximateVal()
{
	double sum = 0;
	for (size_t i = 0; ; i++)
	{
		double term = 1.0 / (i * 2 + 1);
		if (i % 2 == 0)
		{
			sum += term;
		}
		else
		{
			sum -= term;
		}
		if (term < 1e-7)
		{
			break;
		}
	}
	printf_s("%.6f\tpi=%.10f\n", sum, sum * 4);
}


3、开灯问题

有n盏灯编号为1~n,第一个人把所有灯都打开,第二个人把编号为2的关掉,第三个人把3的倍数的开的关,关的开

以此类推 一共有K个人。问最后有哪些灯开着?

void openlight()
{
	int n, k, first=1;
	memset(a, 0, sizeof(a));
	scanf_s("%d%d", &n, &k);
	for(int i=1;i<=k;i++)
	{
		for(int j=1;j<=n;j++)
		{if(j%i==0)
		{
			a[j] = !a[j];
		}
			
		}
	}
	for(int i=1;i<=n;i++)
	{
		if(a[i])
		{
			if(first)
			{
				first = 0;
			
			}
			else
			{
				printf_s(" ");
			}
			printf_s("%d", i);
		}
	}
	printf_s("\n");
}



### 麦克劳林公式算法实现与计算方法 麦克劳林公式是泰勒公式在 \(x=0\) 下的一种特殊形式,用于通过函数在零点的各阶导数值构建多项式来近似函数值[^1]。以下将详细介绍麦克劳林公式的具体实现和计算方法。 #### 1. 麦克劳林公式的基本形式 对于一个足够光滑的函数 \(f(x)\),其麦克劳林展开式为: \[ f(x) = f(0) + \frac{f'(0)}{1!}x + \frac{f''(0)}{2!}x^2 + \cdots + \frac{f^{(n)}(0)}{n!}x^n + R_n(x) \] 其中 \(R_n(x)\) 表示余项,用于衡量误差[^1]。 #### 2. 麦克劳林公式的应用实例 以 \(e^x\) 和 \(\sin(x)\)麦克劳林展开为例,展示如何通过编程实现这些函数的近似计算。 ##### (1) \(e^x\)麦克劳林展开 \(e^x\)麦克劳林展开式为: \[ e^x = 1 + x + \frac{x^2}{2!} + \frac{x^3}{3!} + \cdots \] 以下是用 Python 实现 \(e^x\) 近似值计算的代码: ```python def factorial(n): if n == 0 or n == 1: return 1 return n * factorial(n - 1) def exp_approx(x, terms=10): result = 0 for n in range(terms): result += (x ** n) / factorial(n) return result # 示例:计算 e^1 的近似值 print(exp_approx(1)) # 输出接近于 math.exp(1) ``` 上述代码中,`factorial` 函数用于计算阶乘,`exp_approx` 函数则通过指定项数 `terms` 来控制近似精度[^2]。 ##### (2) \(\sin(x)\)麦克劳林展开 \(\sin(x)\)麦克劳林展开式为: \[ \sin(x) = x - \frac{x^3}{3!} + \frac{x^5}{5!} - \frac{x^7}{7!} + \cdots \] 以下是用 C++ 实现 \(\sin(x)\) 近似值计算的代码: ```cpp #include <iostream> #include <cmath> using namespace std; inline int factorial(int x) { if (x == 1 || x == 0) return 1; return factorial(x - 1) * x; } inline double power(double base, int exp) { double result = 1.0; for (int i = 0; i < exp; ++i) result *= base; return result; } inline double sin_approx(double x, int terms = 5) { double radian = x * M_PI / 180.0; // 转换为弧度制 double result = 0.0; for (int n = 0; n < terms; ++n) { int sign = (n % 2 == 0) ? 1 : -1; result += sign * power(radian, 2 * n + 1) / factorial(2 * n + 1); } return result; } int main() { cout << "sin(30): " << sin_approx(30) << endl; cout << "sin(60): " << sin_approx(60) << endl; cout << "sin(90): " << sin_approx(90) << endl; return 0; } ``` 该代码实现了 \(\sin(x)\) 的近似计算,通过指定项数 `terms` 控制精度,并将角度转换为弧度制进行计算[^3]。 #### 3. 计算方法的改进 为了提高计算效率,可以采用以下优化策略: - 使用动态规划或迭代方法替代递归计算阶乘。 - 限制展开项数以减少计算量,同时确保误差在可接受范围内。 ```python def factorial_iterative(n): result = 1 for i in range(2, n + 1): result *= i return result def sin_approx_iterative(x, terms=5): x_rad = x * 3.1415926 / 180.0 result = 0.0 sign = 1 for n in range(terms): result += sign * (x_rad ** (2 * n + 1)) / factorial_iterative(2 * n + 1) sign *= -1 return result # 示例:计算 sin(30) 的近似值 print(sin_approx_iterative(30)) ``` 此代码通过迭代方式计算阶乘,避免了递归可能导致的栈溢出问题。 ###
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值