算法钢条切割c语言

① C语言割圆术！

这结果还不尽人意吗？这么精确啊！如图：

如果你的第二个数乱掉的话，请改成printf("%d,%lf",n,s);，即s类型是double，对应%lf。

② c语言算法。分治法，金块问题。

int &fmin表示形参的【引用】声明，&是【引用操作符】，不是指针的地址操作符，都可以表示指向， int &fmin“参数类型 &形参”实际上相当于“int &fmin=min”，“参数类型 &形参=实参”
被引用的形参fmin与其对应的实参min代表同一变量，可以互换，代替实参进行同样的操作，可理解为实参的别名
”同样是int类型的虚参，为啥跟i，j不是一个待遇“

这句话的理解不对
在maxmin(int i,int j,int &fmax,int &fmin){......}中，i、j是maxmin()函数的形参（虚参）

在int main (){ int n,i,j,max,min;.......}中，i、j是主函数main（）的参数，当它们用在maxmin()函数的函数头，作为maxmin()函数的参数，理解为maxmin()函数的实参（是maxmin()函数的实参），是函数形参的具体赋值，
所以通常只有在主函数main（）中才可以看到有实参的函数头（实参值调用形式）或无实参的空函数头
只有在主函数中看到其它所有函数的实参

③ c语言木棒加工问题，利用贪心算法哦

该问题是背包问题中的很典型的一种。因为物品可分为任意大小，所以可以很显然地得到你的第三种思路是正确的。对于第一种策略，很容易找到反例：背包容量：100物品:A B C重量:100 50 50价值：70 50 50按照你的第一种贪心策略，选择A，但显然选B+C是更加划算的 对于第二种策略，反例为：背包容量：100物品：A B重量：50 10价值：100 1对于你的第二种策略，会选择B，但选择A是更好的 对于第三种情况的证明，我们采取反证法假设存在一个策略使背包中物品价值达到最大值Vmax，但没有取到当前单位重量价值最大的物品。则我们可以用单位重量价值最大的物品中分割一部分代替原背包中的任意一部分容量，可以使价值>Vmax所以，原方法必然不是最大值，第三种策略的最优性得证。就是这样了

④ c语言算法分析

ticks=stop - start -(stop1-start1);
ration = ((double)(stop - start - stop1 + start1))/CLK_TCK;
这里就没啥不同的。
计算的都是同一个值，应该是：

ration = ((double)(stop1 - start1));
ticks=stop - start - ration ;

这样是说计算了1000次方的是ticks时间
没计算的是 ration 时间

⑤ 用动态规划解决钢条切割问题时，它的最优子结构是什么

1、两种重要算法思想： 动态规划，贪心算法
2、动态规划：
基本原理：动态规划英文名dynamic programming。其中pogramming指的是表格法，而非编写计算机程序。因此，可以初步得出动态规划的基本思想：将一个具有最优子结构性质的问题分成若干个子问题，在求解过程中，记录下子问题的结果，存储在一个表格中，使得公共的子问题只需要计算一次。书中给出的基本原理：动态规划将问题分成若干个相互重叠的子问题，递归的求解子问题，保存子问题的解，再将它们的解组合起来，求出原问题的解。
从基本原理中可以看出动态规划需要满足两个条件，最优子结构和子问题重叠。
最优子结构：书中定义：问题的最优解由相关子问题的最优解组合而成，一个问题的最优解包含其子问题的最优解。典型的有背包问题和钢条切割我问题。所谓子问题就是一中组合，将一个问题分成许多子问题的集合。某个子问题转化为问题时，所需要的代价是固定的。
一般这类问题的解题过程：（自己总结）
画出子问题图（类似于逆拓扑排序的图，子问题必须在问题前面完成）
用数学表达式构建出问题的最优解和子问题最优解之间的代数表达式
通常采用自底向上的方法进行递归地求解问题的解，自底下上的含义是从最小的子问题求起。
保存每一步求出的子问题的最优解
利用计算出的信息构造一个最优解

⑥ 木头折断问题，如何编写C语言算法

这方面不懂，不能帮到你。

⑦ 矩形分割(C语言) 已知一个大矩形，以另一个小矩形去切割，问最多能得到几个小矩形 求算法

大矩形的行除以小矩形的行，大矩形的列除以小矩形的列，所得的两个值相乘

⑧ 大神们，求解一道算法编程，最好只用C语言编写，拜托啦= =

#include<stdio.h>
#include<stdlib.h>
intmain()
{intn,i,j,m,t,x,a[1000];
scanf("%d",&n);
a[0]=rand()%25;
printf("%d",a[0]);
for(i=1;i<n;i++)
{a[i]=a[i-1]+rand()%10+1;
printf("%d",a[i]);
}
printf(" x=");
scanf("%d",&x);
for(i=0,j=n-1;i<j;)
{m=(i+j)/2;
if(a[m]==x){j=m;break;}
elseif(a[m]<x)i=m+1;
elsej=m;
}
if(a[j]==x)
{t=a[j];a[j]=a[j+1];a[j+1]=t;}
else
{if(a[j]<x)j++;
for(i=n;i>j;i--)a[i]=a[i-1];
a[j]=x;
n++;
}
for(i=0;i<n;)
printf("%d",a[i++]);
printf(" ");
return0;
}

⑨ 算法上机实验如图所示，用c语言实现

#include<stdio.h>

#include<stdlib.h>

struct node {

int data;//数据域

struct node *R;//左孩子

struct node *L;//右孩子

};

int a[] = {1, 2, 3, -1, -1, -1, 4, 5,7,-1,-1,-1,6,-1,-1};//二叉树序列

int k = 0;

node* buildTree(node *tree) {//创建二叉树

int data=a[k++];//

if (data== - 1) {//-1代表空结点

tree = NULL;

}

else {//非空结点

tree = (node*)malloc(sizeof(node));//分配内存

tree->data = data;//数据域赋值

tree->L = tree->R = NULL;//左右孩子赋空

tree->L=buildTree(tree->L);//前往左孩子

tree->R=buildTree(tree->R);//前往右孩子

}

return tree;//返回根结点地址

}

void dfs1(node *tree) {//前序遍历

if (tree) {

printf("%d ", tree->data);

dfs1(tree->L);

dfs1(tree->R);

}

}

void dfs2(node *tree) {//中序

if (tree) {

dfs2(tree->L);

printf("%d ", tree->data);

dfs2(tree->R);

}

}

void dfs3(node *tree) {//后序

if (tree) {

dfs3(tree->L);

dfs3(tree->R);

printf("%d ", tree->data);

}

}

void level(node *tree){

//层次遍历，类似与bfs(广度优先搜索)

//需要一个队列作为辅助数据结构

node* q[100];//队列

int f=0,r=0;//头，尾指针

q[r++]=tree;//根结点入队

while(f!=r){

node *t=q[f++];//出队

printf("%d ",t->data);//输出

if(t->L!=NULL){//非空左孩子入队

q[r++]=t->L;

}

if(t->R!=NULL){//非空右孩子入队

q[r++]=t->R;

}

}

}

int count(node *tree){

if(tree==NULL){

return 0;

}

else{

int n,m;

n=count(tree->L);//左子树结点个数

m=count(tree->R);//右子树结点个数

return n+m+1;//返回左右子树结点个数之和

}

}

int main() {

node *tree = NULL;

tree=buildTree(tree);

printf(" 前序遍历： ");

dfs1(tree);

printf(" 中序遍历： ");

dfs2(tree);

printf(" 后序遍历： ");

dfs3(tree);

printf(" 层次遍历： ");

level(tree);

printf(" 二叉树结点个数：%d",count(tree));

return 0;

}