ACM/ICPC竞赛

 

备战ACM资料

一：知识点
数据结构：
1，单，双链表及循环链表
2，树的表示与存储，二叉树（概念，遍历）二叉树的
应用（二叉排序树，判定树，博弈树，解答树等）
3，文件操作（从文本文件中读入数据并输出到文本文
件中）
4，图（基本概念，存储结构，图的运算）
数学知识
1，离散数学知识的应用（如排列组合、简单的图论，数
理逻辑）
2，数论知识
3，线性代数
4，组合代数
5，计算几何
二 算法
1，排序算法（冒抛法，插入排序，合并排序，快速排
序，堆排序）
2，查找（顺序查找，二分发）
3，回溯算法
4，递归算法
5，分治算法
6，模拟法
7，贪心法
8，简单搜索算法（深度优先，广度优先），搜索中的
剪枝，A*算法
9，动态规划的思想及基本算法
10，高精度运算
三、ACM竞赛的题型分析
竞赛的程序设计一般只有16种类型，它们分别是：
Dynamic Programming （动态规划）
Greedy （贪心算法）
Complete Search （穷举搜索）
Flood Fill （不知该如何翻译）
Shortest Path （最短路径）
Recursive Search Techniques （回溯搜索技术）
Minimum Spanning Tree （最小生成树）
Knapsack （背包问题）
Computational Geometry (计算几何学)
Network Flow （网络流）
Eulerian Path （欧拉回路）
Two-Dimensional Convex Hull （不知如何翻译）
BigNums （大数问题）
Heuristic Search （启发式搜索）
Approximate Search （近似搜索）
Ad Hoc Problems （杂题）
四 ACM竞赛参考书
《实用算法的分析与程序设计》 （吴文虎，王建德著，电子工业出版社，竞赛类的黑宝书）
《青少年国际和全国信息学（计算机）奥林匹克竞赛指导）――组合数学的算法
和程序设计》（吴文虎，王建德著，清华大学出版社，参加竞赛组合数学必学）
《计算机算法设计与分析》 （王晓东编著，最好的数据结构教材）
《数据结构与算法》 （傅清祥，王晓东编著，我所见过的最好的算法教材）
《信息学奥林匹克竞赛指导――1997-1998竞赛试题解析》（吴文虎，王建德著，清华大学出版社）
《计算机程序设计技巧》 D.E.Kruth著，算法书中最著名的《葵花宝典》，大师的作品，难度大）
《计算几何》周陪德著
《ACM国际大学生程序设计竞赛试题与解析（一）》 （吴文虎著，清华大学出版社）
《数学建模竞赛培训教材》 共三本 叶其孝主编
《数学模型》 第二版 姜启源
《随机规划》
《模糊数学》
《数学建模入门》 徐全智
《计算机算法设计与分析》 国防科大
五 如何备战ACM/ICPC
1，个人准备（算法书，习题集，网上做题和讨论）
2，1000题=亚洲冠军=世界决赛
3，做好资料收集和整理工作
实验一：递归与分治
1. 二分查找
2. 合并排序
3. 快速排序
实验二：回溯
1. 0-1背包问题
2. 装载问题
3. 堡垒问题（ZOJ1002）
4. *翻硬币问题
5. 8皇后问题
6. 素数环问题
7. 迷宫问题
8. *农场灌溉问题（ZOJ2412）
9. *求图像的周长（ZOJ1047）
10. *骨牌矩阵
11. *字母转换（ZOJ1003）
12. *踩气球（ZOJ1004）
实验三：搜索
1. Floodfill
2. 电子老鼠闯迷宫
3. 跳马
4. 独轮车
5. 皇宫小偷
6. 分酒问题
7. *找倍数
8. *8数码难题
实验四：动态规划
1. 最长公共子序列
2. 计算矩阵连乘积
3. 凸多边形的最优三角剖分
4. 防卫导弹
5. *石子合并
6. *最小代价子母树
7. *旅游预算
8. *皇宫看守
9. *游戏室问题
10. *基因问题
11. *田忌赛马
实验五：贪心与随机算法
1. 背包问题
2. 搬桌子问题
3. *照亮的山景
4. *用随即算法求解8皇后问题
5. 素数测试
实验一：递归与分治
实验目的
理解递归算法的思想和递归程序的执行过程，并能熟练编写递归程序。
掌握分治算法的思想，对给定的问题能设计出分治算法予以解决。
实验预习内容
编程实现讲过的例题：二分搜索、合并排序、快速排序。
对本实验中的问题，设计出算法并编程实现。
试验内容和步骤
1． 二分查找
在对线性表的操作中，经常需要查找某一个元素在线性表中的位置。此问题的输入是待查元素x和线性表L，输出为x在L中的位置或者x不在L中的信息。
程序略
2． 合并排序
程序略
3． 快速排序
程序略
实验总结及思考
合并排序的递归程序执行的过程

实验二：回溯算法
实验目的：熟练掌握回溯算法
实验内容：回溯算法的几种形式
a) 用回溯算法搜索子集树的一般模式

 1 void search(int m)
 2 {
 3 if(m>n) //递归结束条件 
 4 output(); //相应的处理(输出结果)
 5 else
 6 {
 7 a[m]=0; //设置状态：0表示不要该物品
 8 search(m+1); //递归搜索：继续确定下一个物品
 9 a[m]=1; //设置状态：1表示要该物品
10 search(m+1); //递归搜索：继续确定下一个物品
11 }
12 }
13 b)    用回溯算法搜索子集树的一般模式
14 void search(int m)
15 {
16 if(m>n) //递归结束条件 
17 output(); //相应的处理(输出结果)
18 else
19 for(i=m;i<=n;i++)
20 {
21 swap(m,i); //交换a[m]和a[i]
22 if()
23 if(canplace(m)) //如果m处可放置
24 search(m+1); //搜索下一层
25 swpa(m,i); //交换a[m]和a[i](换回来)
26 }
27 }

 

习题
1． 0-1背包问题
在0 / 1背包问题中，需对容量为c 的背包进行装载。从n 个物品中选取装入背包的物品，每件物品i 的重量为wi ，价值为pi 。对于可行的背包装载，背包中物品的总重量不能超过背包的容量，最佳装载是指所装入的物品价值最高。
程序如下：

 1 #include 
 2 void readdata();
 3 void search(int);
 4 void checkmax();
 5 void printresult();
 6 int c=35, n=10; //c： 背包容量；n：物品数
 7 int w[10], v[10]; //w[i]、v[i]：第i件物品的重量和价值
 8 int a[10], max; //a数组存放当前解各物品选取情况；max：记录最大价值
 9 //a[i]=0表示不选第i件物品，a[i]=1表示选第i件物品
10 int main()
11 {
12 readdata(); //读入数据
13 search(0); //递归搜索
14 printresult();
15 }
16 void search(int m)
17 {
18 if(m>=n)
19 checkmax(); //检查当前解是否是可行解，若是则把它的价值与max比较
20 else
21 {
22 a[m]=0; //不选第m件物品
23 search(m+1); //递归搜索下一件物品
24 a[m]=1; //不选第m件物品
25 search(m+1); //递归搜索下一件物品
26 }
27 }
28 void checkmax()
29 {
30 int i, weight=0, value=0;
31 for(i=0;i)
32 {
33 if(a[i]==1) //如果选取了该物品
34 {
35 weight = weight + w[i]; //累加重量
36 value = value + v[i]; //累加价值
37 }
38 }
39 if(weight<=c) //若为可行解
40 if(value>max) //且价值大于max
41 max=value; //替换max
42 }
43 void readdata()
44 {
45 int i;
46 for(i=0;i)
47 scanf("%d%d",&w[i],&v[i]); //读入第i件物品重量和价值
48 }
49 void printresult()
50 {
51 printf("%d",max);
52 }

 

2． 装载问题
有两艘船，载重量分别是c1、 c2，n个集装箱，重量是wi (i=1…n)，且所有集装箱的总重量不超过c1+c2。确定是否有可能将所有集装箱全部装入两艘船。
提示：求出不超过c1的最大值max，若总重量－max < c2则能装入到两艘船。
3． 堡垒问题（ZOJ1002）
如图城堡是一个4×4的方格，为了保卫城堡，现需要在某些格子里修建一些堡垒。城堡中的某些格子是墙，其余格子都是空格，堡垒只能建在空格里，每个堡垒都可以向上下左右四个方向射击，如果两个堡垒在同一行或同一列，且中间没有墙相隔，则两个堡垒都会把对方打掉。问对于给定的一种状态，最多能够修建几个堡垒。
程序主要部分如下：

 1 int main()
 2 {
 3 readdata(); //读入数据
 4 search(0); //递归搜索
 5 printresult();
 6 }
 7 void search(int m)
 8 {
 9 int row, col;
10 row=m/n; //求第m个格子的行号
11 col=m%n; //求第m个格子的列号
12 if(m>=n*n)
13 checkmax(); //检查当前解是否是可行解，若是则把它的价值与max比较
14 else
15 {
16 search(m+1); //该位置不放堡垒递归搜索下一个位置
17 if(canplace(m)) //判断第m个格子是否能放堡垒
18 {
19 place(m); //在第m个格子上放置一个堡垒
20 search(m+1); //递归搜索下一个位置
21 takeout(m); //去掉第m个格子上放置的堡垒
22 }
23 }
24 }

 

4． 翻硬币问题
把硬币摆放成32×9的矩阵，你可以随意翻转矩阵中的某些行和某些列，问正面朝上的硬币最多有多少枚？
提示：（1）任意一行或一列，翻两次等于没有翻；
（2）对于9列的任何一种翻转的情况，每一行翻与不翻相互独立。
5． 8皇后问题
在一个８×８的棋盘里放置８个皇后，要求这8个皇后两两之间互相都不“冲突”。

 1 #include 
 2 #include 
 3 void search(int);
 4 void printresult(); //打印结果
 5 int canplace(int,int); //判断该位置能否放置皇后
 6 void place(int,int); //在该位置能否放置皇后
 7 void takeout(int,int); //把该位置放置皇后去掉
 8 int a[8]; //a[i]存放第i个皇后的位置
 9 int main()
10 {
11 search(0); //递归搜索
12 }
13 void search(int m)
14 {
15 int i;
16 if(m>=8) //当已经找出一组解时
17 printresult(); //输出当前结果
18 else
19 {
20 for(i=0;i<8;i++) //对当前行0到7列的每一个位置
21 {
22 if(canplace(m,i)) //判断第m个格子是否能放堡垒
23 {
24 place(m,i); //在(m,i)格子上放置一个皇后
25 search(m+1); //递归搜索下一行
26 takeout(m,i); //把(m,i)格子上的皇后去掉
27 }
28 }
29 }
30 }
31 int canplace(int row, int col)
32 {
33 int i;
34 for(i=0;i)
35 if(abs(i-row)==abs(a[i]-col)||a[i]==col)
36 return(0);
37 return(1);
38 }
39 void place(int row, int col)
40 {
41 a[row]=col;
42 }
43 void takeout(int row, int col)
44 {
45 a[row]=-1;
46 }
47 void printresult()
48 {
49 int i,j;
50 for(i=0;i<8;i++)
51 {
52 for(j=0;j<8;j++)
53 if(a[i]==j)
54 printf(" A ");
55 else
56 printf(" . ");
57 printf("\n");
58 }
59 printf("\n");
60 }

 

6． 素数环问题
把从1到20这20个数摆成一个环，要求相邻的两个数的和是一个素数。
分析：用回溯算法，考察所有可能的排列。
程序如下：

 1 #include 
 2 #include 
 3 void search(int);
 4 void init(); //初始化
 5 void printresult(); //打印结果
 6 int isprime(int); //判断该数是否是素数
 7 void swap(int,int); //交换a[m]和a[i]
 8 int a[21]; //a数组存放素数环
 9 int main()
10 {
11 init();
12 search(2); //递归搜索
13 }
14 int isprime(int num)
15 {
16 int i,k;
17 k=sqrt(num);
18 for(i=2;i<=k;i++)
19 if(num%i==0)
20 return(0);
21 return(1);
22 }
23 void printresult()
24 {
25 int i;
26 for(i=1;i<=20;i++)
27 printf("%3d",a[i]);
28 printf("\n");
29 }
30 void search(int m)
31 {
32 int i;
33 if(m>20) //当已经搜索到叶结点时
34 {
35 if(isprime(a[1]+a[20])) //如果a[1]+a[20]也是素数
36 printresult(); //输出当前解
37 return;
38 }
39 else
40 {
41 for(i=m;i<=20;i++) //(排列树)
42 {
43 swap(m,i); //交换a[m]和a[i]
44 if(isprime(a[m-1]+a[m])) //判断a[m-1]+a[m]是否是素数
45 search(m+1); //递归搜索下一个位置
46 swap(m,i); //把a[m]和a[i]换回来
47 }
48 }
49 }
50 void swap(int m, int i)
51 {
52 int t;
53 t=a[m];
54 a[m]=a[i];
55 a[i]=t;
56 }
57 void init()
58 {
59 int i;
60 for(i=0;i<21;i++)
61 a[i]=i;
62 }

 

7． 迷宫问题
给一个20×20的迷宫、起点坐标和终点坐标，问从起点是否能到达终点。
输入数据：’.’表示空格；’X’表示墙。
程序如下：

 1 #include 
 2 #include 
 3 void search(int,int);
 4 int canplace(int,int);
 5 void readdata(); //读入数据
 6 void printresult(); //打印结果
 7 int a[20][20]; //a数组存放迷宫
 8 int s,t;
 9 int main()
10 {
11 int row, col;
12 readdata();
13 row=s/20;
14 col=s%20;
15 search(row,col); //递归搜索
16 printresult();
17 }
18 void search(int row, int col)
19 {
20 int r,c;
21 a[row][col]=1;
22 r=row; //左
23 c=col-1;
24 if(canplace(r,c)) //判断(r,c)位置是否已经走过
25 search(r,c); //递归搜索(r,c)
26 r=row+1; //下
27 c=col;
28 if(canplace(r,c)) //判断(r,c)位置是否已经走过
29 search(r,c); //递归搜索(r,c)
30 r=row; //右
31 c=col+1;
32 if(canplace(r,c)) //判断(r,c)位置是否已经走过
33 search(r,c); //递归搜索(r,c)
34 r=row-1; //上
35 c=col;
36 if(canplace(r,c)) //判断(r,c)位置是否已经走过
37 search(r,c); //递归搜索(r,c)
38 }
39 void printresult()
40 {
41 int i,j;
42 for(i=0;i<20;i++)
43 {
44 for(j=0;j<20;j++)
45 printf("%3d",a[i][j]);
46 printf("\n");
47 }
48 }
49 void readdata()
50 {
51 int i,j;
52 for(i=0;i<20;i++)
53 {
54 for(j=0;j<20;j++)
55 scanf("%d",&a[i][j]);
56 }
57 }
58 int canplace(int row, int col)
59 {
60 if(row>=0&&row<20&&col>=0&&col<20&&a[row][col]==0)
61 return 1;
62 else
63 return 0;
64 }

 

8． 农场灌溉问题（ZOJ2412）
一农场由图所示的十一种小方块组成，蓝色线条为灌溉渠。若相邻两块的灌溉渠相连则只需一口水井灌溉。给出若干由字母表示的最大不超过50×50具体由(m，n)表示，的农场图，编程求出最小需要打的井数。每个测例的输出占一行。当M=N=-1时结束程序。

Sample Input
2 2
DK
HF
3 3
ADC
FJK
IHE
-1 -1
Sample Output
2
3
提示：参考迷宫问题，实现时关键要解决好各块的表示问题。
9． 求图像的周长（ZOJ1047）
给一个用 . 和X表示的图形，图形在上、下、左、右、左上、左下、右上、右下8个方向都被看作是连通的，并且图像中间不会出现空洞，求这个图形的边长。
输入：首先给出m、n、x、y四个正整数，下面给出m×n的图形，x、y表示点击的位置，全0表示结束。
输出：点击的图形的周长。

Sample Input
2 2 2 2
XX
XX
6 4 2 3
.XXX
.XXX
.XXX
...X
..X.
X...
0 0 0 0
Sample output
8
18
提示：参考迷宫问题，区别在于它是向8个方向填。

10． 骨牌矩阵
多米诺骨牌是一个小正方形方块，每个骨牌都标有一个数字（0~6），现在有28组骨牌，每组两个，各组编号为1~28，每组编号对应的两个骨牌数值如下：
00 01 02 03 04 05 06
11 12 13 14 15 16 22
23 24 25 26 33 34 35
36 44 45 46 55 56 66
现将这28组骨牌排成一个7×8矩阵，此时只能看到每个骨牌上的数字（0~6），而不能知道每组的组号（如左下图所示）。请编程序将每组骨牌分辨出来（如右下图所示）。
7X8骨牌矩阵 骨牌组编号矩阵
66265241 28 28 14 7 17 17 11 11
13201034 10 10 14 7 2 2 21 23
13246654 8 4 16 25 25 13 21 23
10432112 8 4 16 15 15 13 9 9
51360455 12 12 22 22 5 5 26 26
55402603 27 24 24 3 3 18 1 19
60534203 27 6 6 20 20 18 1 19
void search(int n)
{
查找下一个还没放置骨牌的位置(x,y);
若没有，则表示已经找到一个解，输出并且返回；
尝试放置骨牌；
两次尝试都失败，进行回溯；
}
尝试放置骨牌
 把在(x,y)处的骨牌作为当前骨牌组的一个骨牌；
 把(x+1,y)处的骨牌作为当前骨牌组的另一个骨牌；
 判断当前骨牌组是够未被使用，如果未被使用则递归放置下一个骨牌组；
 把(x,y +1)处的骨牌作为当前骨牌组的另一个骨牌；
判断当前骨牌组是否未被使用，如果未被使用则递归放置下一个骨牌组；

11． 字母转换（ZOJ1003）
通过栈交换字母顺序。给定两个字符串，要求所有的进栈和出栈序列（i表示进栈，o表示出栈），使得字符串2在求得的进出栈序列的操作下，变成字符串1。输出结果需满足字典序。例如TROT 到 TORT:
[
i i i i o o o o
i o i i o o i o
]
Sample Input
madam
adamm
bahama
bahama
long
short
eric
rice
Sample Output
[
i i i i o o o i o o
i i i i o o o o i o
i i o i o i o i o o
i i o i o i o o i o
]
[
i o i i i o o i i o o o
i o i i i o o o i o i o
i o i o i o i i i o o o
i o i o i o i o i o i o
]
[
]
[
i i o i o i o o
]

12． 踩气球（ZOJ1004）
六一儿童节，小朋友们做踩气球游戏，气球的编号是1～100，两位小朋友各踩了一些气球，要求他们报出自己所踩气球的编号的乘积。现在需要你编一个程序来判断他们的胜负，判断的规则是这样的：如果两人都说了真话，数字大的人赢；如果两人都说了假话，数字大的人赢；如果报小数字的人说的是真话而报大数字的人说谎，则报小数字的人赢（注意：只要所报的小数字是有可能的，即认为此人说了真话）。
输入为两个数字，0 0表示结束；
输出为获胜的数字。
Sample Input
36 62
49 343
0 0
Sample Output
62
49

实验三：搜索算法
实验目的：熟练掌握搜索算法
实验内容：广度优先搜索
搜索算法的一般模式：
void search()
{
closed表初始化为空;
open表初始化为空;
起点加入到open表;
while( open表非空 )
{
取open表中的一个结点u;
从open表中删除u;
u进入closed表;
for( 对扩展结点u得到的每个新结点vi )
{
if(vi是目标结点)
输出结果并返回;
if vi 的状态与closed表和open表中的结点的状态都不相同
vi进入open表;
}
}
}
搜索算法关键要解决好状态判重的问题，这样可省略closed表，一般模式可改为：
void search()
{
open表初始化为空;
起点加入到open表;
while( open表非空 )
{
取open表中的一个结点u;
从open表中删除u;
for( 对扩展结点u得到的每个新结点vi )
{
if(vi是目标结点)
输出结果并返回;
If(notused(vi))
vi进入open表;
}
}
}
1. Floodfill
给一个20×20的迷宫和一个起点坐标，用广度优先搜索填充所有的可到达的格子。
提示：参考第2题。
2. 电子老鼠闯迷宫
12×12方格图，找出一条自入口（2，9）到出口（11，8）的最短路径。
本题给出完整的程序和一组测试数据。状态：老鼠所在的行、列。程序如下：

 

  1 #include
  2 void readdata(); //读入数据
  3 void init(); //初始化
  4 int search(); //广搜，并在每一个可到达的每一个空格出填上最小步数
  5 int emptyopen(); //判栈是否为空：空：1；非空：0。
  6 int takeoutofopen(); //从栈中取出一个元素，并把该元素从栈中删除
  7 int canmoveto(int,int,int*,int*,int); //判能否移动到该方向，并带回坐标(r,c)
  8 int isaim(int row, int col); //判断该点是否是目标
  9 int used(int,int); //判断该点是否已经走过
 10 void addtoopen(int,int); //把该点加入到open表
 11 int a[12][12]; //a存放迷宫，0表示空格，-2表示墙。
 12 //广搜时，未找到目标以前到达的空格，填上到达该点的最小步数
 13 int n; //n为迷宫边长，注：若大于12，必须修改一些参数，如a的大小
 14 int open[20],head,tail,openlen=20; //open表
 15 int s,t; //起点和终点
 16 int main()
 17 {
 18 int number;
 19 readdata(); //读取数据
 20 init(); //初始化
 21 number=search(); //广搜并返回最小步数
 22 printf("%d",number); //打印结果
 23 }
 24 int search()
 25 {
 26 int u, row, col, r, c, i, num;
 27 while(!emptyopen()) //当栈非空
 28 {
 29 u=takeoutofopen(); //从栈中取出一个元素，并把该元素从栈中删除
 30 row=u/n; //计算该点的坐标
 31 col=u%n;
 32 num=a[row][col]; //取得该点的步数
 33 for(i=0;i<4;i++)
 34 {
 35 if(canmoveto(row,col,&r,&c,i)) //判能否移动到该方向，并带回坐标(r,c)
 36 {
 37 if(isaim(r,c)) //如果是目标结点
 38 return(num+1); //返回最小步数
 39 if(!used(r,c)) //如果(r,c)还未到达过
 40 {
 41 a[r][c]=num+1; //记录该点的最小步数
 42 addtoopen(r,c); //把该点加入到open表
 43 }
 44 }
 45 }
 46 }
 47 }
 48 int emptyopen()
 49 {
 50 if(head==tail)
 51 return(1);
 52 else
 53 return(0);
 54 }
 55 int takeoutofopen()
 56 {
 57 int u;
 58 if(head==tail)
 59 {
 60 printf("errer: stack is empty");
 61 return(-1);
 62 }
 63 u=open[head++];
 64 head=head%openlen;
 65 return(u);
 66 }
 67 
 68 int canmoveto(int row, int col, int *p, int *q, int direction)
 69 {
 70 int r,c;
 71 r=row;
 72 c=col;
 73 switch(direction)
 74 {
 75 case 0: c--; //左
 76 break;
 77 case 1: r++; //下
 78 break;
 79 case 2: c++; //右
 80 break;
 81 case 3: r--; //上
 82 }
 83 *p=r;
 84 *q=c;
 85 if(r<0||r>=n||c<0||c>=n) //如果越界返回0
 86 return(0);
 87 if(a[r][c]==0) //如果是空格返回1
 88 return(1);
 89 return(0); //其余情况返回0
 90 }
 91 int isaim(int row, int col)
 92 {
 93 if(row*n+col==t)
 94 return(1);
 95 else
 96 return(0);
 97 }
 98 int used(int row, int col)
 99 {
100 if(a[row][col]==0) // 0表示空格
101 return(0);
102 else
103 return(1);
104 }
105 void addtoopen(int row, int col)
106 {
107 int u;
108 u=row*n+col;
109 open[tail++]= u;
110 tail=tail%openlen;
111 }
112 void readdata()
113 {
114 int i,j,row,col;
115 char str[20];
116 scanf("%d",&n);
117 scanf("%d%d",&row,&col); //起点坐标
118 s=row*n+col;
119 scanf("%d%d",&row,&col); //终点坐标
120 t=row*n+col;
121 gets(str);
122 for(i=0;i)
123 {
124 gets(str);
125 for(j=0;j)
126 if(str[j]=='.')
127 a[i][j]=0; //0表示空格
128 else
129 a[i][j]=-2; //－2表示墙
130 }
131 }
132 void init()
133 {
134 head=0;
135 tail=1;
136 open[0]=s;
137 }
138 测试数据如下：
139 12 10 7 1 8
140 XXXXXXXXXXXX
141 X......X.XXX
142 X.X.XX.....X
143 X.X.XX.XXX.X
144 X.X.....X..X
145 X.XXXXXXXXXX
146 X...X.X....X
147 X.XXX...XXXX
148 X.....X....X
149 XXX.XXXX.X.X
150 XXXXXXX..XXX
151 XXXXXXXXXXXX

View Code

 

3. 跳马
给一个200×200的棋盘，问国际象棋的马从给定的起点到给定的终点最少需要几步。
Sample Input

0 0

1 1

Sample output

4
状态：马所在的行、列。
程序如下：

  1 #include
  2 void readdata(); //读入数据
  3 void init(); //初始化
  4 int search(); //广度优先搜索
  5 int emptyopen(); //判栈是否为空：空：1；非空：0。
  6 long takeoutofopen(); //从栈中取出一个元素，并把该元素从栈中删除
  7 int canmoveto(int,int,int*,int*,int); //判能否移动到该方向，并带回坐标(r,c)
  8 int isaim(int row, int col); //判断该点是否是目标
  9 int used(int,int); //判断该点是否已经走过
 10 void addtoopen(int,int); //把该点加入到open表
 11 int a[200][200],n=200; //a存放棋盘，n为迷宫边长
 12 long open[2000],head,tail,openlen=2000; //open表1367
 13 long s,t; //起点和终点
 14 int search()
 15 {
 16 long u;
 17 int row, col, r, c, i, num;
 18 while(!emptyopen()) //当栈非空
 19 {
 20 u=takeoutofopen(); //从栈中取出一个元素，并把该元素从栈中删除
 21 row=u/n; //计算该点所在的行
 22 col=u%n; //计算该点所在的列
 23 num=a[row][col]; //取得该点的步数
 24 for(i=0;i<8;i++)
 25 {
 26 if(canmoveto(row,col,&r,&c,i)) //判能否移动到该方向，并带回坐标(r,c)
 27 {
 28 if(isaim(r,c)) //如果是目标结点
 29 return(num+1); //返回最小步数
 30 if(!used(r,c)) //如果(r,c)还未到达过
 31 {
 32 a[r][c]=num+1; //记录该点的最小步数
 33 addtoopen(r,c); //把该点加入到open表
 34 }
 35 }
 36 }
 37 }
 38 return -1;
 39 }
 40 int main() //为了让search()显示在一页内和main函数换了以下
 41 { //一般的算法程序main函数写在最上面读起来更方便
 42 int number;
 43 readdata(); //读取数据
 44 init(); //初始化
 45 number=search(); //广搜并返回最小步数
 46 printf("%d",number); //打印结果
 47 }
 48 int emptyopen()
 49 {
 50 if(head==tail)
 51 return(1);
 52 else
 53 return(0);
 54 }
 55 long takeoutofopen()
 56 {
 57 long u;
 58 if(head==tail)
 59 {
 60 printf("errer: stack is empty");
 61 return(-1);
 62 }
 63 u=open[head++];
 64 head=head%openlen;
 65 return(u);
 66 }
 67 int used(int row, int col)
 68 {
 69 if(a[row][col]==0)
 70 return(0);
 71 else
 72 return(1);
 73 }
 74 void addtoopen(int row, int col)
 75 {
 76 int u;
 77 if((head-tail)%openlen==1)
 78 printf("open table overflow");
 79 u=row;
 80 u=u*n+col;
 81 open[tail++]= u;
 82 tail=tail%openlen;
 83 }
 84 void readdata()
 85 {
 86 long row,col;
 87 scanf("%ld%ld",&row,&col); //起点坐标
 88 s=row*n+col;
 89 scanf("%ld%ld",&row,&col); //终点坐标
 90 t=row*n+col;
 91 }
 92 void init()
 93 {
 94 head=0;
 95 tail=1;
 96 open[0]=s;
 97 }
 98 int isaim(int row, int col)
 99 {
100 if(row*n+col==t)
101 return(1);
102 else
103 return(0);
104 }

View Code

 

4. 独轮车
独轮车的轮子上有5种颜色，每走一格颜色变化一次，独轮车只能往前推，也可以在原地旋转，每走一格，需要一个单位的时间，每转90度需要一个单位的时间，转180度需要两个单位的时间。现给定一个20×20的迷宫、一个起点、一个终点和到达终点的颜色，问独轮车最少需要多少时间到达。
状态：独轮车所在的行、列、当前颜色、方向。
另外为了方便在结点中加上到达该点的最小步数。
程序如下：

  1 #include
  2 struct colornode
  3 {
  4 int row; //该状态的行
  5 int col; // 列
  6 int color; // 颜色
  7 int direction; // 方向
  8 int num; // 最小步数
  9 };
 10 int search(); //广搜返回目标结点的最小步数
 11 void readdata(); //读入数据
 12 void init(); //初始化
 13 struct colornode moveahead(struct colornode u); //返回u向前走一格得到的结点
 14 int used(struct colornode v); //判断该结点是否是到达过的结点
 15 void addtoopen(struct colornode v); //加入到open表
 16 int islegal(struct colornode v); //如果该结点是合法的结点(未越界且是空格)
 17 int isaim(struct colornode v); //判断该结点是否是目标结点
 18 struct colornode takeoutofopen(); //从open表中取出一个结点并把该结点从open表中删除
 19 struct colornode turntoleft(struct colornode u); //u向左转得到新结点v
 20 struct colornode turntoright(struct colornode u); //u向左转得到新结点v
 21 struct colornode s,t; //s:起始结点；t目标结点
 22 struct colornode open[200]; //open表
 23 int head,tail,openlen=200; //open表相关数据
 24 int direct[4][2]={{0,-1},{1,0},{0,1},{-1,0}};//向左、下、右、上四个方向转时，行列的增加值
 25 int a[20][20],n=20; //a数组表示迷宫；n为迷宫边长
 26 int b[20][20][5][4]; //b数组表示搜索时的所有状态(0：未访问；1：已访问)
 27 int main()
 28 {
 29 int number;
 30 readdata();
 31 init();
 32 number=search();
 33 printf("%d\n",number);
 34 }
 35 int search() //广搜返回目标结点的最小步数
 36 {
 37 struct colornode u,v;
 38 while(head!=tail)
 39 {
 40 u=takeoutofopen();
 41 v=moveahead(u); //u向前走一格得到新结点v
 42 if(islegal(v)) //如果该结点是合法的结点(未越界且是空格)
 43 {
 44 if(isaim(v)) //判是否是目标结点
 45 return(v.num);
 46 if(!used(v)) //如果是未到达过的结点
 47 addtoopen(v); //加入到open表
 48 }
 49 v=turntoleft(u); //u向左转得到新结点v
 50 if(!used(v))
 51 addtoopen(v);
 52 v=turntoright(u); //u向右转得到新结点v
 53 if(!used(v))
 54 addtoopen(v);
 55 }
 56 }
 57 int used(struct colornode v) //判断该结点是否是到达过的结点
 58 {
 59 if(b[v.row][v.col][v.color][v.direction]==0)
 60 return(0);
 61 else
 62 return(1);
 63 }
 64 void addtoopen(struct colornode v) //加入到open表
 65 {
 66 open[tail++]=v;
 67 tail=tail%openlen;
 68 b[v.row][v.col][v.color][v.direction]=1;
 69 }
 70 struct colornode takeoutofopen() //从open表中取出一个结点并把该结点从open表中删除
 71 {
 72 struct colornode v;
 73 v=open[head++];
 74 head=head%openlen;
 75 return(v);
 76 }
 77 void init() //初始化
 78 {
 79 int i,j,k,l;
 80 for(i=0;i//所有状态初始化
 81 for(j=0;j)
 82 for(k=0;k<5;k++)
 83 for(l=0;l<4;l++)
 84 b[i][j][k][l]=0;
 85 head=0;
 86 tail=0;
 87 addtoopen(s); //把起始点加入到open表
 88 }
 89 void readdata() //读入数据
 90 {
 91 char str[50];    int i,j;
 92 for(i=0;i)
 93 {
 94 gets(str);
 95 for(j=0;j)
 96 if(str[j]=='.') //读入数据'.'表示空格
 97 a[i][j]=0; //存储时 0：表示空格
 98 else
 99 a[i][j]=1; // 1：表示墙
100 }
101 scanf("%d%d%d%d",&s.row,&s.col,&s.color,&s.direction); //读入起始结点信息
102 scanf("%d%d%d",&t.row,&t.col,&t.color); //读入目标结点信息
103 }
104 int isaim(struct colornode v) //判断该结点是否是目标结点
105 {
106 if(v.row==t.row&&v.col==t.col&&v.color==t.color)
107 return 1;
108 else
109 return 0;
110 }
111 int islegal(struct colornode v) //如果该结点是合法的结点(未越界且是空格)
112 {
113 if(v.row<0||v.row>=n||v.col<0||v.col>=n) //若越界
114 return 0;
115 if(a[v.row][v.col]==0) //0：表示空格
116 return 1;
117 return 0;
118 }
119 struct colornode moveahead(struct colornode u) //返回u向前走一格得到的结点
120 {
121 struct colornode v;
122 v.row=u.row+direct[u.direction][0];
123 v.col=u.col+direct[u.direction][1];
124 v.color=(u.color+1)%5;
125 v.direction=u.direction;
126 v.num=u.num+1;
127 return(v);
128 }
129 struct colornode turntoleft(struct colornode u) //u向左转得到新结点v
130 {
131 struct colornode v;
132 v=u;
133 v.direction=(v.direction+1)%4;
134 v.num=v.num+1;
135 return(v);
136 }
137 struct colornode turntoright(struct colornode u) //u向左转得到新结点v
138 {
139 struct colornode v;
140 v=u;
141 v.direction=(v.direction+3)%4;
142 v.num=v.num+1;
143 return(v);
144 }
145 测试数据：
146 XXXXXXXXXXXXXXXXXXXX
147 .....XXXX......X.XXX
148 X.........X.XX.....X
149 X.XXX.XX..X.XX.XXX.X
150 X.........X.XX.....X
151 X.XXX.XX..X.XX.XXX.X
152 .X.....XX.X.....X..X
153 X....X..X...X.X....X
154 ...XXXX.X.XXX...XXXX
155 ...........X.......X
156 XXXXXX....XXXXXX..XX
157 ...........X.......X
158 .X.....XX.X.....X..X
159 XXXXXX....XXXXXXXX.X
160 X....X..X...X.X....X
161 ...XXXX.X.XXX...XXXX
162 ...........X.......X
163 XXX.X.XXXXX.XXXX.X.X
164 ....X.XX....XXX.....
165 XXXX.....XX.........
166 1 1 1 1 4 8 1

View Code

 

5. 皇宫小偷
有一个小偷要到皇宫里偷取宝物，经过仔细的侦察，他发现皇宫实际上是一个20×20的迷宫，并且有一名卫兵巡逻，卫兵巡逻的路线是固定的，每单位时间移动一格，每4个单位时间循环一次。小偷每单位时间移动一格或在原地不动。任何时刻，小偷和卫兵在同一格，或卫兵能看到小偷，小偷将会被卫兵杀死。现在小偷已经得到了皇宫的地图，卫兵巡逻的起点，卫兵连续四次移动的方向和宝物的位置，请你设计一个程序判断小偷能否偷得宝物。
提示：参考第3题、第4题
6. 分酒问题
有一酒瓶装有8斤酒，没有量器，只有分别装5斤和3斤的空酒瓶。设计一程序将8斤酒分成两个4斤，并以最少的步骤给出答案。
7. *找倍数
对于每个输入的数字（如：2），则要求 给出一个由1，0构成的十进制整数，且该整数为输入数字的某个倍数（如2对应的10，6的倍数100100100100100100）。

实验四：动态规划
实验目的：理解动态规划的基本思想，理解动态规划算法的两个基本要素最优子结构性质和子问题的重叠性质。熟练掌握典型的动态规划问题。掌握动态规划思想分析问题的一般方法，对较简单的问题能正确分析，设计出动态规划算法，并能快速编程实现。
实验内容：编程实现讲过的例题：最长公共子序列问题、矩阵连乘问题、凸多边形最优三角剖分问题、电路布线问题等。本实验中的问题，设计出算法并编程实现。
习题
1． 最长公共子序列
一个给定序列的子序列是在该序列中删去若干元素后得到的序列。

解答如下：
a) 最长公共子序列的结构
若用穷举搜索法，耗时太长，算法需要指数时间。
易证最长公共子序列问题也有最优子结构性质
设序列X=和Y=的一个最长公共子序列Z=，则：
i. 若xm=yn，则zk=xm=yn且Zk-1是Xm-1和Yn-1的最长公共子序列；
ii. 若xm≠yn且zk≠xm ，则Z是Xm-1和Y的最长公共子序列；
iii. 若xm≠yn且zk≠yn ，则Z是X和Yn-1的最长公共子序列。
其中Xm-1=，Yn-1=，Zk-1=。
最长公共子序列问题具有最优子结构性质。
b) 子问题的递归结构
由最长公共子序列问题的最优子结构性质可知，要找出X=和Y=的最长公共子序列，可按以下方式递归地进行：当xm=yn时，找出Xm-1和Yn-1的最长公共子序列，然后在其尾部加上xm(=yn)即可得X和Y的一个最长公共子序列。当xm≠yn时，必须解两个子问题，即找出Xm-1和Y的一个最长公共子序列及X和Yn-1的一个最长公共子序列。这两个公共子序列中较长者即为X和Y的一个最长公共子序列。
由此递归结构容易看到最长公共子序列问题具有子问题重叠性质。例如，在计算X和Y的最长公共子序列时，可能要计算出X和Yn-1及Xm-1和Y的最长公共子序列。而这两个子问题都包含一个公共子问题，即计算Xm-1和Yn-1的最长公共子序列。
我们来建立子问题的最优值的递归关系。用c[i,j]记录序列Xi和Yj的最长公共子序列的长度。其中Xi=，Yj=。当i=0或j=0时，空序列是Xi和Yj的最长公共子序列，故c[i,j]=0。

c) 计算最优值
由于在所考虑的子问题空间中，总共只有θ(m*n)个不同的子问题，因此，用动态规划算法自底向上地计算最优值能提高算法的效率。
计算最长公共子序列长度的动态规划算法LCS_LENGTH(X,Y)以序列X=和Y=作为输入。输出两个数组c[0..m ,0..n]和b[1..m ,1..n]。其中c[i,j]存储Xi与Yj的最长公共子序列的长度，b[i,j]记录指示c[i,j]的值是由哪一个子问题的解达到的，这在构造最长公共子序列时要用到。最后，X和Y的最长公共子序列的长度记录于c[m,n]中。
程序如下：

 1 #include
 2 #include<string.h>
 3 int lcs_length(char x[], char y[]);
 4 int main()
 5 {
 6 char x[100],y[100];
 7 int len;
 8 while(1)
 9 {
10 scanf("%s%s",x,y);
11 if(x[0]=='0') //约定第一个字符串以‘0’开始表示结束
12 break;
13 len=lcs_length(x,y);
14 printf("%d\n",len);
15 }
16 }
17 int lcs_length(char x[], char y[] )
18 {
19 int m,n,i,j,l[100][100];
20 m=strlen(x);
21 n=strlen(y);
22 for(i=0;i1;i++)
23 l[i][0]=0;
24 for(j=0;j1;j++)
25 l[0][j]=0;
26 for(i=1;i<=m;i++)
27 for(j=1;j<=n;j++)
28 if(x[i-1]==y[j-1]) //i,j从1开始，但字符串是从0开始
29 l[i][j]=l[i-1][j-1]+1;
30 else if(l[i][j-1]>l[i-1][j])
31 l[i][j]=l[i][j-1];
32 else
33 l[i][j]=l[i-1][j];
34 return l[m][n];
35 }
36 由于每个数组单元的计算耗费Ο(1)时间，算法lcs_length耗时Ο(mn)。
37 思考：空间能节约吗？

View Code

 

2． 计算矩阵连乘积
在科学计算中经常要计算矩阵的乘积。矩阵A和B可乘的条件是矩阵A的列数等于矩阵B的行数。若A是一个p×q的矩阵，B是一个q×r的矩阵，则其乘积C=AB是一个p×r的矩阵。由该公式知计算C=AB总共需要pqr次的数乘。

现在的问题是，给定n个矩阵{A1,A2,…,An}。其中Ai与Ai+1是可乘的，i=1,2,…,n-1。要求计算出这n个矩阵的连乘积A1A2…An。
程序如下：

 1 #include
 2 int main()
 3 {
 4 int p[101],i,j,k,r,t,n;
 5 int m[101][101]; //为了跟讲解时保持一致数组从1开始
 6 int s[101][101]; //记录从第i到第j个矩阵连乘的断开位置
 7 scanf("%d",&n);
 8 for(i=0;i<=n;i++) 
 9 scanf("%d",&p[i]); //读入p[i]的值(注意：p[0]到p[n]共n+1项)
10 for(i=1;i<=n;i++) //初始化m[i][i]=0
11 m[i][i]=0;
12 for(r=1;r//r为i、j相差的值
13 for(i=1;i//i为行
14 {
15 j=i+r; //j为列
16 m[i][j]=m[i+1][j]+p[i-1]*p[i]*p[j]; //给m[i][j]赋初值
17 s[i][j]=i;
18 for(k=i+1;k)
19 {
20 t=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
21 if(t<m[i][j])
22 {
23 m[i][j]=t; //m[i][j]取最小值
24 s[i][j]=k;
25 }
26 }
27 }
28 printf("%d",m[1][n]);
29 }

View Code

 

3． 凸多边形的最优三角剖分
多边形是平面上一条分段线性的闭曲线。也就是说，多边形是由一系列首尾相接的直线段组成的。组成多边形的各直线段称为该多边形的边。多边形相接两条边的连接点称为多边形的顶点。若多边形的边之间除了连接顶点外没有别的公共点，则称该多边形为简单多边形。一个简单多边形将平面分为3个部分：被包围在多边形内的所有点构成了多边形的内部；多边形本身构成多边形的边界；而平面上其余的点构成了多边形的外部。当一个简单多边形及其内部构成一个闭凸集时，称该简单多边形为凸多边形。也就是说凸多边形边界上或内部的任意两点所连成的直线段上所有的点均在该凸多边形的内部或边界上。
通常，用多边形顶点的逆时针序列来表示一个凸多边形，即P=表示具有n条边v0v1，v1v2，… ,vn-1vn的一个凸多边形，其中，约定v0=vn 。
若vi与vj是多边形上不相邻的两个顶点，则线段vivj称为多边形的一条弦。弦 将多边形分割成凸的两个子多边形和。多边形的三角剖分是一个将多边形分割成互不重迭的三角形的弦的集合T。如图是一个凸多边形的两个不同的三角剖分。

凸多边形最优三角剖分的问题是：给定一个凸多边形P=以及定义在由多边形的边和弦组成的三角形上的权函数ω。要求确定该凸多边形的一个三角剖分，使得该三角剖分对应的权即剖分中诸三角形上的权之和为最小。
可以定义三角形上各种各样的权函数W。例如：定义ω(△vivjvk)=|vivj|+|vivk|+|vkvj|，其中，|vivj|是点vi到vj的欧氏距离。相应于此权函数的最优三角剖分即为最小弦长三角剖分。(注意：解决此问题的算法必须适用于任意的权函数)
4． 防卫导弹
一种新型的防卫导弹可截击多个攻击导弹。它可以向前飞行，也可以用很快的速度向下飞行，可以毫无损伤地截击进攻导弹，但不可以向后或向上飞行。但有一个缺点，尽管它发射时可以达到任意高度，但它只能截击比它上次截击导弹时所处高度低或者高度相同的导弹。现对这种新型防卫导弹进行测试，在每一次测试中，发射一系列的测试导弹（这些导弹发射的间隔时间固定，飞行速度相同），该防卫导弹所能获得的信息包括各进攻导弹的高度，以及它们发射次序。现要求编一程序，求在每次测试中，该防卫导弹最多能截击的进攻导弹数量，一个导弹能被截击应满足下列两个条件之一：
a)它是该次测试中第一个被防卫导弹截击的导弹；
b)它是在上一次被截击导弹的发射后发射，且高度不大于上一次被截击导弹的高度的导弹。
输入数据：第一行是一个整数n，以后的n各有一个整数表示导弹的高度。
输出数据：截击导弹的最大数目。
分析：定义l[i]为选择截击第i个导弹，从这个导弹开始最多能截击的导弹数目。
由于选择了第i枚导弹，所以下一个要截击的导弹j的高度要小于等于它的高度，所以l[i]应该等于从i＋1到n的每一个j，满足h[j]<=h[i]的j中l[j]的最大值。
程序如下：

 1 #include
 2 int main()
 3 {
 4 int i,j,n,max,h[100],l[100];
 5 scanf("%d",&n);
 6 for(i=0;i)
 7 scanf("%d",&h[i]);
 8 l[n-1]=1;
 9 for(i=n-2;i>=0;i--)
10 {
11 max=0;
12 for(j=i+1;j)
13 if(h[i]>h[j]&&max<l[j])
14 max=l[j];
15 l[i]=max+1;
16 }
17 printf("%d",l[0]);
18 }

View Code

 

5． 石子合并
在一个圆形操场的四周摆放着n堆石子(n<= 100)，现要将石子有次序地合并成一堆。规定每次只能选取相邻的两堆合并成新的一堆,并将新的一堆的石子数,记为该次合并的得分。编一程序，由文件读入堆栈数n及每堆栈的石子数(<=20)。
选择一种合并石子的方案,使得做n－1次合并,得分的总和最小；
输入数据：
第一行为石子堆数n；
第二行为每堆的石子数,每两个数之间用一个空格分隔。
输出数据：
从第一至第n行为得分最小的合并方案。第n+1行是空行.从第n+2行到第2n+1行是得分最大合并方案。每种合并方案用n行表示，其中第i行(1<=i<=n)表示第i次合并前各堆的石子数(依顺时针次序输出，哪一堆先输出均可)。要求将待合并的两堆石子数以相应的负数表示。
Sample Input
4
4 5 9 4
Sample Output
－4 5 9 －4
－8 －5 9
－13 －9
22 4 －5 －9 4
4 －14 －4
－4 －18
22

6． 最小代价子母树
设有一排数，共ｎ个，例如：22 14 7 13 26 15 11。任意2个相邻的数可以进行归并，归并的代价为该两个数的和,经过不断的归并，最后归为一堆，而全部归并代价的和称为总代价，给出一种归并算法，使总代价为最小。
输入、输出数据格式与“石子合并”相同。
Sample Input
4
12 5 16 4
Sample Output
－１２ －５ １６ ４
１７ －１６ －４
－１７ －２０
３７
7． 商店购物
某商店中每种商品都有一个价格。例如，一朵花的价格是2 ICU(ICU 是信息学竞赛的货币的单位）；一个花瓶的价格是5 ICU。为了吸引更多的顾客，商店提供了特殊优惠价。特殊优惠商品是把一种或几种商品分成一组。并降价销售。例如：3朵花的价格不是6而是5 ICU；2个花瓶加1朵花是10 ICU不是12 ICU。
编一个程序，计算某个顾客所购商品应付的费用。要充分利用优惠价以使顾客付款最小。请注意，你不能变更顾客所购商品的种类及数量，即使增加某些商品会使付款总数减小也不允许你作出任何变更。假定各种商品价格用优惠价如上所述，并且某顾客购买物品为：3朵花和2个花瓶。那么顾客应付款为14 ICU因为：
1朵花加2个花瓶优惠价：10 ICU
2朵花正常价：4 ICU
输入数据：第一个文件INPUT．TXT描述顾客所购物品（放在购物筐中）;第二个文件描述商店提供的优惠商品及价格（文件名为OFF ER．TXT）。 两个文件中都只用整数。
第一个文件INPUT．TXT的格式为:第一行是一个数字B（0≤B≤5），表示所购商品种类数。下面共B行，每行中含3个数C，K，P。 C 代表商品的编码（每种商品有一个唯一的编码），1≤C≤999。K代表该种商品购买总数，1≤K≤5。P 是该种商品的正常单价（每件商品的价格），1≤P≤999。请注意，购物筐中最多可放5*5＝25件商品。
第二个文件OFFER．TXT的格式为:第一行是一个数字S（0≤S≤9 9），表示共有S 种优惠。下面共S行，每一行描述一种优惠商品的组合中商品的种类。下面接着是几个数字对（C，K），其中C代表商品编码，1≤C≤9 99。K代表该种商品在此组合中的数量，1≤K≤5。本行最后一个数字P（1≤ P≤9999）代表此商品组合的优惠价。当然， 优惠价要低于该组合中商品正常价之总和。
输出数据：在输出文件OUTPUT．TXT中写 一个数字（占一行），该数字表示顾客所购商品（输入文件指明所购商品）应付的最低货款。
8． 旅游预算
一个旅行社需要估算乘汽车从某城市到另一城市的最小费用，沿路有若干加油站，每个加油站收费不一定相同。旅游预算有如下规则：
若油箱的油过半，不停车加油，除非油箱中的油不可支持到下一站；每次加油时都加满；在一个加油站加油时，司机要花费2元买东西吃；司机不必为其他意外情况而准备额外的油；汽车开出时在起点加满油箱；计算精确到分（1元=100分）。编写程序估计实际行驶在某路线所需的最小费用。
输入数据：从当前目录下的文本文件“route.dat”读入数据。按以下格式输入若干旅行路线的情况：
第一行为起点到终点的距离（实数）
第二行为三个实数，后跟一个整数，每两个数据间用一个空格隔开。其中第一个数为汽车油箱的容量（升），第二个数是每升汽油行驶的公里数，第三个数是在起点加满油箱的费用，第四个数是加油站的数量。（〈=50）。接下去的每行包括两个实数，每个数据之间用一个空格分隔，其中第一个数是该加油站离起点的距离，第二个数是该加油站每升汽油的价格（元/升）。加油站按它们与起点的距离升序排列。所有的输入都有一定有解。
输出数据：答案输出到当前目录下的文本文件“route.out”中。该文件包括两行。第一行为一个实数和一个整数，实数为旅行的最小费用，以元为单位，精确到分，整数表示途中加油的站的N。第二行是N个整数，表示N个加油的站的编号，按升序排列。数据间用一个空格分隔，此外没有多余的空格。
Sample Input
516.3 38.09 1
15.7 22.1 20.87 3 2
125.4 1.259
297.9 1.129
345.2 0.999
Sample Output
38.09 1
2
9． 皇宫看守
太平王世子事件后，陆小凤成了皇上特聘的御前一品侍卫。皇宫以午门为起点，直到后宫嫔妃们的寝宫，呈一棵树的形状；某些宫殿间可以互相望见。大内保卫森严，三步一岗，五步一哨，每个宫殿都要有人全天候看守，在不同的宫殿安排看守所需的费用不同。可是陆小凤手上的经费不足，无论如何也没法在每个宫殿都安置留守侍卫。
请你编程计算帮助陆小凤布置侍卫，在看守全部宫殿的前提下，使得花费的经费最少。
输入数据：输入数据由文件名为intput.txt的文本文件提供。输入文件中数据表示一棵树，描述如下：
第1行 n，表示树中结点的数目。
第2行至第n+1行，每行描述每个宫殿结点信息，依次为：该宫殿结点标号i（0对于一个n（0 < n <= 1500）个结点的树，结点标号在1到n之间，且标号不重复。
输出数据：输出到output.txt文件中。输出文件仅包含一个数，为所求的最少的经费。
Sample Input
6
1 30 3 2 3 4
2 16 2 5 6
3 5 0
4 4 0
5 11 0
6 5 0
Sample Output
25

10． 游戏室问题
有一个游戏室里有多个游戏室，并且这每个游戏室里还有多个游戏室，每个游戏室里面还有游戏室，依此类推。进入每个游戏室都可得到一定的快乐，每个游戏室的门票价格都大于等于0，都有一个快乐值，并且只有进入了一个游戏室，才可以进入它内部的游戏室，小明现在有n元钱，问最大能得到多少的快乐。
11． *基因问题
已知两个基因序列如s：AGTAGT；t：ATTAG。现要你给序列中增加一些空格后，首先使得两个序列的长度相等，其次两个串对应符号匹配得到的值最大。基因只有四种分别用A、G、C、T表示，匹配中不允许两个空格相对应，任意两符号的匹配值由下表给出：
A G C T ︺
A 5 -2 -1 -2 -4
G -2 5 -4 -3 -2
C -1 -4 5 -5 -1
T -2 -3 -5 5 -2
︺ -4 -2 -1 -2
提示：定义问题l[i][j]为取第一个序列的前i项，和第二个序列的前j项，这两个序列加空格匹配的最大值。它的最优值与三个子问题有关，l[i-1][j-1]、l[i][j-1]、l[i-1][j]。
12． *田忌赛马
田忌与齐王赛马，双方各有n匹马参赛（n<=100），每场比赛赌注为1两黄金，现已知齐王与田忌的每匹马的速度，并且齐王肯定是按马的速度从快到慢出场，现要你写一个程序帮助田忌计算他最好的结果是赢多少两黄金（输用负数表示）。
分析：先排序，齐王的马的速度放在数组a中，田忌的马的速度放在数组b中。本问题应用的算法是动态规划和贪心算法相结合解决的。从两人的最弱的马入手：
若田忌的马快，就让这两匹马比赛；
若田忌的马慢，干脆就让他对付齐王最快的马；
若两匹马的速度相等，这时有两种选择方案，或者它俩比赛，或者对付齐王最快的马。
定义子问题：l(i，j)为齐王的从第i匹马开始的j匹马与田忌的最快的j匹马比赛，田忌所获得的最大收益。
则：
程序具体实现时，为了适合c数据从0开始，稍加变动，定义子问题：l(i，j)为齐王的从第i匹马开始到第i＋j匹马共j+1匹马与田忌的最快的j+1匹马比赛，田忌所获得的最大收益。初始化时：l[i][0]表示齐王的第i匹马与田忌最快的马比赛的结果。
程序如下：

 1 #include
 2 void readdata();
 3 void init();
 4 int n,a[100],b[100],l[100][100];
 5 int main()
 6 {
 7 int i,j;
 8 readdata();
 9 init();
10 for(i=n-2;i>=0;i--)
11 for(j=1;j)
12 if(a[i+j]<b[j])
13 l[i][j]=l[i][j-1]+1;
14 else if(a[i+j]>b[j])
15 l[i][j]=l[i+1][j-1]-1;
16 else if(l[i+1][j-1]-1>l[i][j-1])
17 l[i][j]=l[i+1][j-1]-1;
18 else
19 l[i][j]=l[i][j-1];
20 printf("%d",l[0][n-1]);
21 }
22 void readdata()
23 {
24 int i;
25 scanf("%d",&n);
26 for(i=0;i)
27 scanf("%d",&a[i]);
28 for(i=0;i)
29 scanf("%d",&b[i]);
30 }
31 void init()
32 {
33 int i;
34 //    qsort(a,n); //略
35 for(i=0;i)
36 {
37 if(a[i]0])
38 l[i][0]=1;
39 else if(a[i]==b[0])
40 l[i][0]=0;
41 else
42 l[i][0]=-1;
43 }
44 }

View Code

 

实验五：贪心算法和随机算法
1. 背包问题
有一个背包，背包容量是M=150。有7个物品，物品可以分割成任意大小。
要求尽可能让装入背包中的物品总价值最大，但不能超过总容量。
物品 A B C D E F G
重量 35 30 60 50 40 10 25
价值 10 40 30 50 35 40 30

2. 照亮的山景
在一片山的上空，高度为T处有N个处于不同位置的灯泡，如图。如果山的边界上某一点于某灯i的连线不经过山的其它点，我们称灯i可以照亮该点。开尽量少的灯，使得整个山景都被照亮。山被表示成有m个转折点的折线。
提示：照亮整个山景相当于照亮每一个转折点。

3. 搬桌子问题
某教学大楼一层有n个教室，从左到右依次编号为1、2、…、n。现在要把一些课桌从某些教室搬到另外一些教室，每张桌子都是从编号较小的教室搬到编号较大的教室，每一趟，都是从左到右走，搬完一张课桌后，可以继续从当前位置或往右走搬另一张桌子。

输入数据：先输入n、m，然后紧接着m行输入这m张要搬课桌的起始教室和目标教室。

输出数据：最少需要跑几趟。
Sample Input
10 5
1 3
3 9
4 6
6 10
7 8
Sample Output
3
分析：贪心算法，把课桌按起点从小到大排序，每次都是搬离当前位置最近的课桌。
程序如下：

 1 #include
 2 int main()
 3 {
 4 struct
 5 {
 6 int start;
 7 int end;
 8 }a[100];
 9 int i,j;
10 int n,m,min,num,temp,used[100]={0};
11 scanf("%d%d",&m,&n);
12 for(i=0;i)
13 scanf("%d%d",&a[i].start,&a[i].end);
14 //    sort(a,n); //按start从小到大对数组a排序
15 min=0;
16 num=0;
17 while(num<n)
18 {
19 temp=0;
20 for(i=0;i)
21 if(used[i]==0&&a[i].start>=temp)
22 {
23 temp=a[i].end;
24 used[i]=1;
25 num++;
26 }
27 min++;
28 }
29 printf("%d",min);
30 }

View Code

 

4. 用随即算法求解8皇后问题
5. 素数测试

 

未完待续，，，

 

 

 

转载于:https://www.cnblogs.com/jeff-wgc/p/4480968.html