储油问题
一辆重型卡车的油耗是1L/km，载油能力为500L，今欲穿过1000km的沙漠。由于卡车一次过不了沙漠，因此司机必须在沿途设几个储油点。问：如何建立这些储油点，每一个储油点储存多少油才能使卡车以最小油耗通过沙漠？
实例解析：
本例采用倒推法来解题。所谓倒推法，就是在不知初始值的情况下，通过某种递推关系，由最终值推算出初始值的方法。储油问题和猴子吃桃子问题等都是典型的倒退问题。
显然，卡车要通过沙漠，必须在离起点500km处存储500L油，如图17-1所示。
图17-1 储油点及储油量示意图
而要在500km处储油500L，需要卡车从某处（设离起点x1公里处）向500km处运送n趟（最后一趟不需要返回），卡车往返总耗油是：(2n-1)*(500-x1)*1，因此，x1处储油量y1应是：y1 = (2n -1)*(500 -x1) +500，而这个储油量也是卡车n趟的总载油量，即：y1=500n。
可以证明，卡车往返的总耗油 (2n-1)*(500-x1) =500时，最为省油。故：y1=500+500 =1000，此时n = 2，即x1处要储油1000L，其中的500L送往中点500km处，另外500公里用来跑路（3个单程）。可以算出，x1的值为333km
同样的道理，要在333km处储油1000L，需要在前面某点x2处储油500L*3=1500L，其中500L用来跑路（耗油500L最省油），另外1000L运送到333km处，即：y2 = (2*3 -1)*(x1-x2)+500*2 = 1500。
继续前推，对下一个储油点有：y3 = (2*4 -1)*(x2-x3) +500*3 =2000
再下一个储油点：y4 = (2*5 -1)*(x3-x4) +500*4 = 2500
......
可以得出一个通用公式：
某储油点的储油量应为：
yk = (2*(k+1) -1)*(xk-1-xk) + 500*k = 500*(k+1)
初始值：x0 = 500, k = 1。
我们可以定义一个数组distance[N]用来存储各储油点离起点的距离，其中distance[0] = 500，定义一个数组oil[N]存储储油量，oil[0] = 500。其他储油点的坐标和储油量数据由上面的通用公式求得，即：
xk = x k-1-500/(2k+1)
yk = 500*(k+1)
注意一点：推导的过程中，xk的值越来越小，当某次计算出的坐标xk<=0时，意味着已经计算到起点了。若xk = 0，意味着计算出的最经济的储油点正好位于起点，储油量按照上面的通用公式计算即可，即yk=500*(k+1)。但若xk<0，意味着计算出的储油点是不实际的，因此实际储油量不需要公式计算的那么多，所以要根据实际距离重新计算。
下面是程序代码：
#include<stdio.h>
#define N 10
int main()
{int distance[N] = {500}, oil[N] = {500};
int k;
for(k = 1; distance[k-1] > 0; k++){//坐标大于0则继续循环
distance[k] = distance[k-1] - 500/(2*k + 1);
oil[k] = 500*(k+1);
}
k--;
if(distance[k] < 0){
distance[k] = 0;
oil[k] = 500*k + (2*k + 1)*distance[k-1];
}
printf("\ndistance oil\n\n");
for( ; k >= 0; k--)
printf("%5d,%8d\n", distance[k], oil[k]);
getch();
return 0;
}背包问题
给定n种物品和一个背包，其中物品i的重量为wi，对应的价值为vi，背包可装物品的最大重量为c，问题：怎样选择物品，才能使装入背包的物品的价值最大？
实例解析：
在选择物品时，每个物品的选择都只有两种：选或者不选，因此这个问题叫做0-1背包问题。
我们采用动态规划的方法来解决这个问题。其基本思想是：
将待解决的问题分成若干个子问题，先求子问题的解，然后从子问题的解中得出整个问题的解。
适用于动态规划的问题经分解后形成的子问题往往不是相互独立的，在求解过程中如果能保存已解决的子问题的答案，以便在需要时加以利用，就可以避免大量重复计算。为了达到这个目的，可以用一个表来记录所有已解决的子问题的答案（不管有用无用，都保存），这就是动态规划的主要思想。
本例中，我们定义三个数组来描述背包问题：
int value[N]; //用来存储各物品的价值 int weight[N]; //用来存储各物品的重量 int maxvalue[N][CONTENT]; //存储最优解
数组maxvalue用来存储动态规划过程中的最优解。例如：maxvalue[i][j]表示背包剩余容量为j，还有第i，i+1，i+2，......N-1物品可选择时的最优解。
程序代码如下：
#define CONTENT 5
#define N 10
#include <stdio.h>
void knapsack(int v[N],int w[N], int c, int m[N][CONTENT+1])
{int n = N-1;
int i, j;
int jMax;
/*初始化数组，只有最后一件物品n可选时*/
/**************************************************************/
/*对下面4行代码的说明：当剩余容量c<w[n]时，m数组对应的元素应为0，意即不能选该物品，c>=w[n]时，则为v[n]，意即应该选择。比如，设w[n]=4，v[n]为9，背包最大容量为6，则m数组第n行的值应为：
剩余容量： 0 1 2 3 4 5 6
m[n][j]的值： 0 0 0 0 9 9 9 */
/**************************************************************/
for(j = 0; j <= c; j++) //先都清0
m[n][j] = 0;
for(j = w[n]; j <= c; j++) //对于c >= w[n]的情况，改为价值
m[n][j] = v[n];
/*以下求解m[i][j]*/
for(i = n-1; i >= 0; i--) {
if(w[i]–1 < c) //相当于w[i] <=c，物体重量小于等于背包容量
jMax = w[i]-1;
else
jMax = c;
for(j = 0; j <= jMax; j++) //对于剩余容量<物体重量的情况
m[i][j] = m[i+1][j];
for(j = jMax+1; j <= c; j++){ //剩余容量>=物体重量的情况
if(m[i+1][j] >= m[i+1][j-w[i]] + v[i])
m[i][j] = m[i+1][j];
else
m[i][j] = m[i+1][j-w[i]] + v[i];
}
}
}
void traceback(int flag[N], int w[N], int m[N][CONTENT+1])
{int n = N-1;
int i;
int c = CONTENT;
int j;
for(i = 0; i <= n-1; i++)
if(m[i][c] != m[i+1][c]){
flag[i] = 1; //如果两种最优解不同，说明选取了第i件物品
c -= w[i]; //剩余容量减小
}
if(m[n][c]>0) //判断最后一种物品选择与否
flag[n] = 1;
}
void printResult(int flag[], int w[], int v[], int m[][CONTENT+1])
{int i;
printf(" num weight value\n");
for(i = 0; i <= N-1; i++)
if(flag[i] == 1)
printf("%3d%7d%5d\n", i, w[i], v[i]);
printf("content is %d,", CONTENT);
printf("the max value is: %d\n", m[0][CONTENT]);
}
int main()
{int value[N] = { 5,2,3,9,3,6,5,7,8,2};
int weight[N] = {2,1,3,5,7,3,6,2,6,3};
int c = CONTENT;
int maxvalue[N][CONTENT+1];
int flag[N] = {0};
clrscr();
knapsack(value, weight, c, maxvalue);
traceback(flag, weight, maxvalue);
printResult(flag, weight, value, maxvalue);
getch();
return 0;
}链表的逆置
编程实现链表（无头结点）的逆置。
实例解析：
所谓链表逆置，就是将所有结点逆序排列。本例可用两种方法来做。
方法一：从第一个结点开始直到链尾，依次处理每一个结点。
（1）对于第一个结点，其指针域next赋值为NULL，使之成为链尾。
（2）对于之后的结点，使之指向前一结点。
（3）最后一个结点的指针，赋给head，使之成为第一个结点。
下面是逆置部分的程序代码：
struct student* reverse(struct Student *head)
{struct student *p1,*p2,*t;
p1 = p2 = head;
p1 = p1->next; //指向第二个结点（若有）
while(p1 != NULL) {
t = p1->next;
p1->next = p2; //成为上一个结点的前驱
if(p2 == head) //上一个结点若是第一个结点，使之成为链尾
p2->next = NULL;
p2 = p1; //p2跟上p1
p1 = t; //p1指向下一个结点
}
head = p2; //最后一个结点成为第一个结点
return head;
} 方法二：
从链表第二个结点开始，依次将每个结点插入到链表的最前面。
相应的函数代码是：
struct student* reverse(struct student *head)
{struct student *p, *h, *t;
if(head != NULL){
h = head; //记录原第一个结点的地址
p = head->next; //指向第二个结点
while(p != NULL){
t = p->next; // t记录下一个结点的地址
p->next = head; //*p成为第一个结点的前驱
head = p; //*p成为第一个结点
p = t; // p指向原来的下一个结点
}
h->next = NULL; //最早的第一个结点成为链尾
}
return head;
}约瑟夫环
n个小孩围成一圈，从第一个人开始报数，报到k的人退出圈子，下面的人继续从1开始报数.....若最后圈子里只剩下m个人，他们分别是多少号? n、k、m都从键盘输入。
实例解析：
这是一个典型的单循环链表问题。先建立链表，然后从第一个结点开始计数，将第k个结点删除，然后再从下一结点开始计数，第k个结点删除......，直到链表中只剩m个结点。
下面是程序代码：
#include "stdio.h"
#include "stdlib.h"
struct Boy {
int n;
struct Boy *next;
};
void create(struct Boy**, int);
struct Boy* proceed(struct Boy*, int, int, int);
void print(struct Boy*);
void del(struct Boy*);
int main()
{struct Boy *head;
int n,k,m;
clrscr();
scanf("%d,%d,%d", &n, &k, &m);
create(&head, n); //建立链表
if(head == NULL)
exit(0);
head = proceed(head, n, k, m); //报数，处理
print(head); //输出链表
del(head); //删除整个链表，释放内存
getch();
return 0;
}
void create(struct Boy **p,int n)
{struct Boy *p1,*p2;
int i;
for(i = 1; i <= n; i++) {
p1 = (struct Boy*)malloc(sizeof(struct Boy));
if(p1 == NULL){
printf("no space.\n");
*p = NULL;
return;
}
p1->n = i;
if(i == 1)
*p = p1;
else
p2->next = p1;
p2 = p1;
p1->next = *p;
}
}
void print(struct Boy *head)
{struct Boy *p = head;
while(1) {
printf("%5d", p->n);
p = p->next;
if(p == head)
break;
}
}
struct Boy* proceed(struct Boy *head,int n,int k,int m)
{struct Boy *p1,*p2;
int i,count,min; //min表示圈中最小序号，count统计被删除的结点数
p1 = p2 = head;
for(count = 1; count <= n-m; count++){
for(i = 1; i < k; i++){
p2 = p1;
p1 = p1->next;
}
p2->next = p1->next;
p2 = p1; //p2指向要删结点
p1 = p1->next;
free(p2);
}
head = p1;
//以下代码使head指向序号最小的结点，以便按从小到大顺序输出结果
min = p1->n;
for(i = 1; i <= m; i++) {
p1 = p1->next;
if(min > p1->n){
head = p1;
min = p1->n;
}
}
return head;
}
//删除整个链表
void del(struct Boy *head)
{struct Boy *p1,*p2;
p1 = head;
if(p1 != NULL)
while(1) {
p2 = p1;
p1 = p1->next;
free(p2);
if(p1 == head)
break;
}
}
