Ⅰ c语言问题
#define MAX_STEP 20 // 宏定义
int a[MAX_STEP][4]; // 全局变量定义
int b[MAX_STEP]; // 同上
char *name[] = // 同上
void search(int iStep) // 函数声明
Ⅱ 几题简单的C语言编程
//第3题
#include<iostream>
using namespace std;
int main()
{
char x;
int tmp;
cout<<"请输入x(0～255):"<<endl;
cin>>tmp;
while(tmp>255)
{
cout<<"x不能大于255，请重新输入"<<endl;
cin>>tmp;
}
x=tmp;
cout<<"y=(1+x)/x^2="<<(1+x)/(x*x)<<endl;
return 0;
}
//第4题
#include<iostream>
using namespace std;
int main()
{
int x,y;
cin>>x;
if(x<1)
{
y=x;
}
else if(x<10)
{
y=2*x-1;
}
else
{
y=3*x-11;
}
cout<<y<<endl;
return 0;
}
//第5题
#include<iostream>
using namespace std;
int FibonacciDen(int x)
{
if(x==1)
{
return 1;
}
else if(x==2)
{
return 2;
}
else
{
return FibonacciDen(x-1)+FibonacciDen(x-2);
}
return 0;
}
int FibonacciNum(int x)
{
if(x==1)
{
return 2;
}
else if(x==2)
{
return 3;
}
else
{
return FibonacciNum(x-1)+FibonacciNum(x-2);
}
return 0;
}
#define M 20
int main()
{
float den[M],num[M];
float sum=0;
for(int i=0;i<M;i++)
{
den[i]=FibonacciDen(i+1);
num[i]=FibonacciNum(i+1);
sum+=num[i]/den[i];
}
cout<<sum<<endl;
}
//第6题
#include<iostream>
using namespace std;
int main()
{
int s[10]={0,1,2,3,4,5,6,7,8,9};
int max=s[0],k;
for(int i=0;i<9;i++)
{
max=s[i];
for(int j=i;j<10;j++)
{
if(s[j]>max)
{
max=s[j];
k=j;
}
}
if(max!=s[i])
{
swap(s[i],s[k]);
}
}
for(int i=0;i<10;i++)
{
cout<<s[i]<<" ";
}
}
//第7题
#include<iostream>
using namespace std;
int FindMax(int *p,int size)
{
int max=*p;
for(int i=0;i<size;i++)
{
if(*(p+i)>max)
{
max=*(p+i);
}
}
return max;
}
int main()
{
int s[4][4]={1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5};
for(int i=0;i<4;i++)
{
cout<<FindMax(s[i],sizeof(s[i])/sizeof(int))<<" ";
}
cout<<endl;
return 0;
}
//第8题
#include<iostream>
using namespace std;
int fun(int n)
{
if(0==n||1==n)
{
return 1;
}
else
{
return n*fun(n-1);
}
}
int main()
{
int n;
cin>>n;
cout<<fun(n)<<endl;
return 0;
}
//第9题
#include<iostream>
using namespace std;
int fc(int *p,int size)
{
int odd=0;
for(int i=0;i<size;i++)
{
if(*(p+i)%2)
{
odd++;
}
}
return odd;
}
int main()
{
int a[5]={1,2,3,4,5},odd,size;
size=sizeof(a)/sizeof(int);
odd=fc(a,size);
cout<<"奇数个数:"<<odd<<endl<<"偶数个数:"<<size-odd<<endl;
return 0;
}
//第10题
#include<iostream>
using namespace std;
int main()
{
int a[10]={0,1,2,3,4,5,6,7,8,9};
int *p=a;
for(int i=0;i<10;i++,p++)
{
cout<<*p<<" ";
}
cout<<endl;
return 0;
}
//第11题
#include<iostream>
using namespace std;
int main()
{
char a[]="Hello";
char b[]="World";
char *pa=a;
char *pb=b;
for(int i=0;a[i]!='\0';i++)
{
*(pb+i)=*(pa+i);
}
cout<<b<<endl;
return 0;
}
//挺简单，但挺多的，呵呵！建议你还是自己练一下比较有收获！祝你能学好C语言！
Ⅲ 如何用c语言编程实现动态规划
动态规划主要是 状态 & 状态转移方程 如果转移方程写出来了 程序就自然出来啦
对于这题 dp[i][j] 表示 走到格子 (i,j) 时 的总和最大值 val[i][j] 表示格子 (i, j) 的值
那么有 dp[i][j] = max( dp[i-1][j] , dp[i][j-1]) + val[i][j];
当然 边界的时候要特殊考虑一下
for(int i = 1; i <= m ; i++)
for(int j = 1; j <= n; j++)
{
if( i == 1 ) ....;
else if( j == 1 ) ....;
else dp[i][j] = max( dp[i-1][j] , dp[i][j-1]) + val[i][j];
}
最后 dp[m][n] 就是答案啦 ^ ^
Ⅳ 农夫过河问题、用C语言解决。。最好能有详细代码和注释。。。感激不尽，。。。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_STEP 20
//index: 0 - 狼，1－羊，2－菜，3－农夫，value：0－本岸，1－对岸
int a[MAX_STEP][4];
int b[MAX_STEP];
char *name[] = { "空手", "带狼", "带羊", "带菜" };
void search(int iStep) { int i; if (a[iStep][0] + a[iStep][1] + a[iStep][2] + a[iStep][3] == 4) { for (i = 0; i < iStep; i++) { if (a[i][3] == 0) { printf("%s到对岸\n", name[b[i] + 1]); } else { printf("%s回本岸\n", name[b[i] + 1]); } } printf("\n"); return; } for (i = 0; i < iStep; i++) { if (memcmp(a[i], a[iStep], sizeof(a[i])) == 0) { return; } } if (a[iStep][1] != a[iStep][3] && (a[iStep][2] == a[iStep][1] || a[iStep][0] == a[iStep][1])) { return; } for (i = -1; i <= 2; i++) { b[iStep] = i; memcpy(a[iStep + 1], a[iStep], sizeof(a[iStep + 1])); a[iStep + 1][3] = 1 - a[iStep + 1][3]; if (i == -1) { search(iStep + 1); } else if (a[iStep][i] == a[iStep][3]) { a[iStep + 1][i] = a[iStep + 1][3]; search(iStep + 1); } } } int main() { search(0); return 0; }
Ⅳ c语言动态规划的一个问题
动态规划关键是找到问题中的子问题，写出状态方程。
这个问题的子问题可以定义为前n件物品，总费用为v的最大价值总和。
先考虑第n件物品，如果c[n]<v的话，它有两种选择，放入背包和不放入背包。它的价值为w[n]*i(i为0或1)，费用c[n]*i(i为0或1),则还需要从n-1件物品中选择费用为v-c[n]*i物品的最大价值总和，所以状态方程为:
f(n,v)=max{f(n-1,v-c[n]*i)+w[n]*i};i根据物品费用和对应的总费用确定取值，即小于对应的总费用时可取0，1，否则为0。
很明显最简单的是从前1件物品中选取，这个就是最后用递归程序编写程序时候的出口。
算法思想就是上面所写的。程序的精华在于思想，仅供你编程参考。
Ⅵ C语言-动态规划
#include <stdio.h>
#include <stdlib.h>
struct tree {
int value;
struct tree *left;
struct tree *right;
};
#define min(x, y) x < y ? x : y
int a[3][3] = {10, 9, 14, 9, 12, 10, 6, 5, 8};
void add_tree_node(struct tree **node, int x, int y, int depth)
{
// printf("x = %d, y = %d, value = %d, depth = %d\n", x, y, a[x][y], depth);
*node = (struct tree *)malloc(sizeof(struct tree));
((struct tree *)*node)->value = a[x][y] + a[x][x];
if(depth == 1) {
((struct tree *)*node)->left = ((struct tree *)*node)->right = NULL;
return;
} else {
add_tree_node(&(((struct tree *)*node)->left), y, (y+1)%3, depth-1);
add_tree_node(&(((struct tree *)*node)->right), y, (y+2)%3, depth-1);
}
depth--;
}
void print_tree(struct tree *t)
{
if(t == NULL)
return;
printf("%d ", t->value);
print_tree(t->left);
print_tree(t->right);
}
void free_tree(struct tree *t)
{
if(t == NULL)
return;
free_tree(t->left);
free_tree(t->right);
free(t);
}
int get_short_time(struct tree *t)
{
if(t->left == NULL || t->right == NULL)
return t->value;
return(min(get_short_time(t->left), get_short_time(t->right))+t->value);
}
void main()
{
struct tree *root;
int i, j, minx=0, miny=1;
for(i = 0; i < 3; i++)
for(j = 0; j < 3; j++)
if(i != j && a[minx][miny] > a[i][j])
minx = i, miny = j;
printf("拆卸时间最短的是从第%d套仪器换为第%d套仪器，时间为%d\n", minx+1, miny+1, a[minx][miny]);
// 创建深度为5的二叉树，将做5次试验的全部可能路径都放到二叉树中
add_tree_node(&root, minx, miny, 5);
print_tree(root);
printf("\n");
printf("最短可以完成全部实验的时间是：%d\n", get_short_time(root));
free_tree(root);
}
Ⅶ C语言,农夫过河问题
程序就是求解农夫过河问题：
农夫带着一狼，一羊和一些菜过河。河边只有一船，一次农夫只能带一样东西。无人时，狼要吃羊，羊要吃菜，程序将找出所有农夫过河的方案。
首先要表示狼，羊，菜和农夫所在的位置，4者的位置有本岸和对岸两种情况，分别用0和1表示，4者，所以用一个有4元素的数组。为了要记录每一步，程序中使用了一个二维数组a[MAX_STEP][4]，记录每一步4者所在位置。第一步就是a[0]，第二布是a[1]...而，a[0][0]就表示第一步狼在本岸(0)还是对岸(1)，a[0][1]表示第一步羊在本岸还是对岸......
为了记录每一次农夫过河时的状态，使用了一个数组b[MAX_STEP]，数组中的元素的值可能为-1, 0, 1, 2，分别表示农夫在过河时，是空手，带狼，带羊，带菜。
第一步的状态是狼，羊，菜和农夫都在本案，所以a[0][0]到a[0][3]都是0，本来应该初始化一下，但a是全局变量，所以自动初始化为0，所以程序中省下了这一步。
search是一个递归函数，通过不断的查找可能的下一步，找出一个方案，是一种深度优先搜索。
a[iStep][0] + a[iStep][1] + a[iStep][2] + a[iStep][3] == 4意味着第 iStep时，a[iStep][0]到a[iStep][3]都为1，表示4者都到了对岸。所以输出结果。
for (i = 0; i < iStep; i++)
{
if (a[i][3] == 0)
{
printf("%s到对岸\n", name[b[i] + 1]);
}
else
{
printf("%s回本岸\n", name[b[i] + 1]);
}
}
输出每一步
a[i][3]是农夫在本岸还是对岸，如果为0，在本岸，下一步肯定是到对岸，所以打印"...到对岸"，而name[b[i]+1]找出对应带的东西的描述。
for (i = 0; i < iStep; i++)
{
if (memcmp(a[i], a[iStep], sizeof(a[i])) == 0)
{
return;
}
}
判定是否会死循环，如果当前状态在以前出现过，那么就会出现死循环。用当前这步的状态a[iStep]和以前的所有步a[i] (i=0; i <iStep; i++)比较。memcmp是内存比较函数，可以用于比较数组，返回值为0，表示数组中所有值相同。
如果相同，就直接返回，不再查找。
if (a[iStep][1] != a[iStep][3] && (a[iStep][2] == a[iStep][1] || a[iStep][0] == a[iStep][1]))
{
return;
}
判定羊会吃菜，或狼会吃羊的情况。
当农夫和羊在一起的时候，狼不会吃羊，羊也不会吃菜，所以只有当农夫和羊不在一起(a[iStep][1] != a[iStep][3])时，才可能发生“吃”的状态。
而且“吃”的情况必须是在菜和羊在一起(a[iStep][2] == a[iStep][1])或者羊和狼在一起(a[iStep][0] == a[iStep][1])
发生吃的情况是，返回，不再查找。
for (i = -1; i <= 2; i++)
{
b[iStep] = i;
memcpy(a[iStep + 1], a[iStep], sizeof(a[iStep + 1]));
a[iStep + 1][3] = 1 - a[iStep + 1][3];
if (i == -1)
{
search(iStep + 1);
}
else if (a[iStep][i] == a[iStep][3])
{
a[iStep + 1][i] = a[iStep + 1][3];
search(iStep + 1);
}
}
但现在，已经确保了上一步是“安全”的，可以继续查找。
-1, 0, 1, 2分别表示渡河时4种情况，空手，带狼，带羊，带菜。
memcpy(a[iStep + 1], a[iStep], sizeof(a[iStep + 1])); 复制当前步的数组到下一步。
农夫的状态肯定会发生改变，所以a[iStep + 1][3] = 1 - a[iStep + 1][3]; 因为当a为0或1时，a = 1 - a会使a在0和1之间切换。
如果i== -1，表示空手，狼，羊，菜的状态都不会发生改变，所以直接搜索下一步(search(iStep + 1); )
否则要被带过去的东西(0, 1, 2分别表示0, 1, 2)的状态需要改变。
要带的东西必须和农夫同在本案或对岸(a[iStep][i] == a[iStep][3])，才可能带得了。只有在这种情况下，使要带的东西的状态和农夫相同(a[iStep + 1][i] = a[iStep + 1][3];)，并开始下一步的搜索(search(iStep + 1))。
Ⅷ C语言动态规划
定义 d(a, b) 为原字符串中从第 a 个字符开始，包含 b 个阿拉伯数字的数。
定义 s(in, ik) 为以下情况中，最后一个 * 前面 ik 个数的最大乘积：插入 ik + 1 个 * ，最后一个 * 前面有 in + 1 个阿拉伯数字。
则：
s(in, 0) = d(0, in + 1);
s(in, ik) = min{ s(ip, ik - 1) * d(ip + 1, in - ip) } （其中 ip = 0, 1, 2, ..., in - 1）;
题目结果则是 s(n - 1, k + 1) 。
下面是程序，CUnsignedBigNumber 我现写的，可以的话就随便搞一个吧，实在不行我这个再给你。
#include <iostream>
#include <stdlib.h>
CUnsignedBigNumber BiggestProct(unsigned int n, unsigned int k, const char * digits)
{
if (n <= k)
return CUnsignedBigNumber();
CUnsignedBigNumber * intermediateResults = new CUnsignedBigNumber[n * k];
unsigned int ik, in, ip;
for (in = 0; in < n; ++in) // 这里求每个 s(in, 0)
intermediateResults[in].set(digits, in + 1); // d(0, in + 1)
for (ik = 1; ik < k; ++ik)
{
for (in = 0; in < n; ++in)
{
CUnsignedBigNumber & current = intermediateResults[ik * n + in]; // s[in, ik]
for (ip = 0; ip < in; ++ip)
{
CUnsignedBigNumber temp(digits + ip + 1, in - ip); // d(ip + 1, in - ip)
temp *= intermediateResults[(ik - 1) * n + ip]; // d(ip + 1, in - ip) * s(ip, ik - 1)
if (current < temp)
current.swap(temp); // current = temp;
}
}
}
CUnsignedBigNumber result; // s[n - 1, k + 1]
for (ip = 0; ip < in; ++ip)
{
CUnsignedBigNumber temp(digits + ip + 1, n - 1 - ip));
temp *= intermediateResults[(k - 1) * n + ip];
if (result < temp)
result.swap(temp);
}
delete [] intermediateResults;
return result;
}
int main(void)
{
unsigned int n = 0, k = 0;
char digits[21];
scanf("%d%d%s", &n, &k, digits);
std::cout << BiggestProct(n, k, digits) << std::endl;
system("pause");
return 0;
}
Ⅸ C语言学习规划
只要你能够将这一本教材的例子与练习做完，基本上考二级就没有问题了。不过，上来的茫然不知所措的感觉，你能否挺过？挺过这一关，只要你肯学，学会应当不难。
Ⅹ 关于C语言学习计划
把Kernighan和Ritchie的 The C Programming Language这本书（238页，ANSI C）看一遍就差不多了，这时候你写不了什么实用的程序（天才，一点就通的人例外）。
接下来你需要根据兴趣爱好或职业规划等来给自己选一个发展方向。如果急着靠它找工作，那么就看看Windows，它入门快，很快就可以参与到求职竞争中去（这辈子也很可能局限于此）。
如果并不是急着用C来打扮自己，那么建议看看Linux Programming Unleashed，然后根据更细的发展方向去看LDD、LKD或Linux应用编程等内容，这些东西入门稍有难度（只是稍有难度而已，别被那些没耐性的Windows菜鸟给吓着）。Linux搭配C语言应用范围很广，这类人在国内算是高端人才，不愁嫁的。
C语言是一个实用技术，本身的内容并不多，主要的学习精力将会用在各种各样的库函数上面，而各种库函数往往有各自的适用范围，不可能也没必要甚至不应该乱学一气（库函数确实很多，乱学很容易造成混乱）。
总的来说，我的建议就是先看一遍The C Programming Language，然后给自己选一个发展方向，看那个方向适用的一些函数库，如果还有精力，再看看Autotools工具包。