算法设计与分析实验二递归和循环

实验二递归和循环

第1关：设计算法求解整数的划分问题，对给定的整数，输出划分数
第2关：有重复元素的排列问题
第3关：棋盘覆盖问题

第一关：设计算法求解整数的划分问题，对给定的整数，输出划分数

任务描述

将正整数n 表示成一系列正整数之和，n=n1+n2+…+nk, 其中n1>=n2>=…>=nk>=1 ，k>=1 。
正整数n 的这种表示称为正整数n 的划分。正整数n 的不同的划分个数称为正整数n 的划分数。

对给定的整数，输出对应的划分数。

测试说明

平台会对你编写的代码进行测试：

测试输入：5
预期输出：
7

测试输入：6
预期输出：
11

提示：

对于样例一，可以划分的情况是：
5, 4+1, 3+2, 3+1+1, 2+2+1, 2+1+1+1, 1+1+1+1+1
故可以划分为7种

解题思路

ｑ（ｎ，ｍ）有以下五种情况

１．ｍ＝ｎ 说明是对此数进行整数划分那么往下走也是两种情况

（１）本身ｎ划分＋１

（２）最大划分数是n-１故为ｍ－１

２．ｍ＞ｎ 说明ｍ最大划分数大于需要划分的ｎ数，则现在问题变成了划分ｎ

３．ｍ＜ｎ 说明ｎ中最大划分数是ｍ分为以下两种情况：

（１）ｑ（ｎ－ｍ，ｍ）ｎ减去最大划分数，对剩下的数进行划分

（２）ｑ（ｎ，ｍ－１）剩下的划分都小于ｍ，故改为m-１继续进行递归

４．ｍ＝１ 最大划分数为１，那么仅有１＋１＋……１一种情况

５．ｎ＝１ 需要划分的是１就只有１种情况

代码

//整数划分
#include<stdio.h>
int partition(int n, int m);
int main() {int n;int p;//输入整数n scanf("%d",&n);p = partition(n, n);printf("%d",p);return 0;
}//整数划分递归
int partition(int n, int m) {//n为划分的数，m为划分数中最大加数if(n == 1 || m == 1) {//当n==1 时说明最大数是1 那就只能划分1这种结果//当m==1 时说明划分数最大是1 那就只能是1+1+…+1这种结果 return 1;}else if ( n < m){//当划分数小于m 说明需要最大加数已经定了，只需要将n进行自己划分return partition(n, n); }else if( n == m) {//当划分数和最大划分数相等，就代表从头开始划分//划分为包括本身，和最大数为本身-1 return partition(n, m-1) + 1; }else if(n > m){//当n>m 分为两种情况，最大数为m本身的情况和最大数为m-1的情况 return partition(n-m, m) + partition(n, m-1); }
}

第2关：有重复元素的排列问题

任务描述

设集合R={r1,r2,...,rn}是要进行排列的n个元素，其中r1,r2,...,rn可能相同。
试着设计一个算法，列出R的所有不同排列。
即，给定n以及待排的n个可能重复的元素。计算输出n个元素的所有不同排列。

输入描述

第1行是元素个数n，1<=n<=500。接下来的1行是待排列的n个元素，元素中间不要加空格。

输出格式

程序运行结束时，将计算输出n个元素的所有不同排列。最后1行中的数是排列总数。

测试说明

平台会对你编写的代码进行测试：

测试输入：
4
aacc

预期输出：
aacc
acac
acca
caac
caca
ccaa
6

思路过程

这题运用到了全排列的思想

全排列

//全排列问题 C语言
#include<stdio.h>void swap(int *a, int *b)
{int temp;temp = *a;*a = *b;*b = temp;return;
}
//全排列函数 p代表指向交换的位置 q代表到达交换的交换位置
void Perm(int list[], int p, int q)
{if( p == q-1) {for(int j = 0; j < q; j++){printf("%d ",list[j]);}printf("\n");return;}else {for(int i = p; i < q; i++ ){swap(&list[p],&list[i]);Perm(list, p+1, q);//为什么输入i不行但是 输入p+1可以？//因为输入i代表交换的哪几位位数而p代表的是在哪个位置交换 所以p是固定的 但是i不是固定的//得输入i
//          printf("%d %d\n",list[p],list[i]);swap(&list[p],&list[i]);
//          printf("%d %d\n",list[p],list[i]);}   }
}int main()
{int n; //数组长度int list[n];scanf("%d",&n); for(int i = 0; i < n; i++){scanf("%d",&list[i]);    }   Perm(list, 0, n);return 0;
}

错误思路：

在递归的时候把p和i弄混了 p是固定交换位置的而i是动态的是代表p往后交换的

此题代码

这道题就是在全排列的基础上加上重复排序的问题需要检验重复排序

//重复字母的排列问题//全排列问题 C语言
#include<stdio.h>
int number = 0;
void swap(char *a, char *b)
{char temp;temp = *a;*a = *b;*b = temp;return;
}bool NoSame(char list[], int p, int i) {if( p < i) {for( ; p < i; p++){if(list[i] == list[p]) {
//              printf("\ni %d same %c \n",i, list[i]);return false;}}    }return true;
}//全排列函数 p代表指向交换的位置 q代表到达交换的交换位置
//不能单纯判断交换的字母是否相同 因为交换的字母不同 但是可能前面出现过
//所以需要一个函数来判断  我想复杂了 我以为全部都需要判断 然后需要一个二维数组去存
//其实不需要 就只要判断当前元素 和以前的元素是否重复就行
//噢我可真难过！
void Perm(char list[], int p, int q)
{if( p == q-1) {//将交换后的数组输出 for(int j = 0; j < q; j++){printf("%c",list[j]);}printf("\n");number++;return;}else {for(int i = p; i < q; i++ ){//如果判断出所交换的字母和前面字母不重复 则进行交换 否则不交换//我突然意识到第一个和第一个比较重复 ，肯定是重复的 if( NoSame(list, p, i) ) {//交换对应位置 swap(&list[p],&list[i]);//进行递归 Perm(list, p+1, q);//回溯算法 将其交换回来 swap(&list[p],&list[i]);}} }
}int main()
{int n; //数组长度char list[n];scanf("%d",&n); scanf("%s",list);        Perm(list, 0, n);printf("%d",number);return 0;
}

错误思路

这是在全排列的基础上加上重复判断
我一开始想的是二维数组，然后对应一个字符串一个字符串判断，但这样的效率实在是太低了

然后看了别人的思路误以为是直接判断交换的字母是否和前面的字母有重复的字母这样不可行因为一开始这就是重复和重复的交换
结果应该是比较i和p 首先i肯定是大于p的所以如果在i之前的p 交换的字母没有重复的代表其就是没有重复的。

今天教别人的时候发现，因为i前面的字母都比较过了，如果现在i所指的字母和前面的字母有重复的，那么说明这个字母排序就是重复的排序

第3关：棋盘覆盖问题

任务描述

在一个2k×2k个方格组成的棋盘中，恰有一个方格与其他方格不同，称该方格为一特殊方格，且称该棋盘为一特殊棋盘。在棋盘覆盖问题中，要用图示的4种不同形态的L型骨牌覆盖给定的特殊棋盘上除特殊方格以外的所有方格，且任何2个L型骨牌不得重叠覆盖。
易知，覆盖任意一个2k×2k的特殊棋盘，用到的骨牌数恰好为(4K-1)/3。

输入格式

第一行为k(棋盘的尺寸)，第二行为x，y(1<=x,y<=2^k)，分别表示特殊方格所在行与列。

输出格式

共2^k行，分别表示覆盖该格的L型的编号(特殊格用0表示)。

输出要求：最小字符宽度为4,左对齐输出

样例

平台会对你编写的代码进行测试：

测试输入：
3 3 2
预期输出：
3 3 4 4 8 8 9 9
3 2 2 4 8 7 7 9
5 2 6 6 10 10 7 11
5 5 0 6 1 10 11 11
13 13 14 1 1 18 19 19
13 12 14 14 18 18 17 19
15 12 12 16 20 17 17 21
15 15 16 16 20 20 21 21

提示：

特殊骨牌的牌号为0
正常骨牌号从1开始
覆盖棋盘请严格遵循先覆盖左上角,右上角，左下角，右下脚的循序(具体可以参考算法书P21的代码及注释)

解题思路

棋盘覆盖问题实在是太难画了
核心思想就是

先设置变量
1. 一个棋盘数组 Board[][]:（全局变量）棋盘格子数组
2. sr sc：特殊格子的行列
br bc：中心格子的行列（我把中心格子定在每一次递归最中心点的右下格子，以这个格子来判断特殊格子是在哪个区间。
size：当前棋盘的大小
Lsize：下一次递归棋盘的大小（用于找到中心格子和特殊格子）
t：递归的轮数（在函数内可变值）必须得用t 因为全局变量一直在变化，可是一轮的赋值是可以不用变化的
title：递归的轮数（全局变量）
确定思路
1. 首先先将棋盘划分为四个区间，再判断特殊格子是否在这四个区间里面的任一一个
  1. 如果在这个区间里，则继续下一轮递归
  2. 如果不在这个区间内，则将最靠近中心轴的格子赋值为t，则这个格子在这个区间内变为特殊格子，进入下一轮递归
一直递归到 size == 1 退出递归
需要注意
1. 必须设置全局变量title，因为递归一轮的数值是不会变的，那么t会一直在3 2 1这三个数值轮流转，每开始一轮递归，title值加1再赋值给t，代表这是第几轮递归，第几个格子
2. 中心格子和特殊格子是一直在变化的

错误历程1

我一开始认为只需要传入变化的k和变化的格子数t就可以了

我以为特殊格子是不用变化的但是每次没有找到特殊格子的区间内都需要变化

忽略了特殊格子是一直在变化的，所以必须得传入特殊格子，而我根本就没有传入特殊格子

#include<stdio.h>
#include<math.h>
#define Max 100
/*变量的定义如下sr:特殊格子的行 sc:特殊格子的列 br:划分格子的行 bc:划分格子的列Board[][]:（全局变量）棋盘格子数组t:定义划分格子的数字
*/ int Board[Max][Max] = {0};
int sr = 0;
int sc = 0;//错误思路 忽略了特殊格子是一直在变化的，所以必须得传入特俗格子，而我根本就没有传入特殊格子
void BoardCover(int k, int t)
{int br; // br:划分格子的行 int bc; //    bc:划分格子的列br = pow(2,k);bc = pow(2,k);printf("%d %d\n",br,bc); //测试输出printf("k %d\n", k);//当划分到最后只有一个格子的时候 就return if(k == 1){return; }//左上角覆盖并划分 if( sr <= br-1 && sc <= bc-1 ) {BoardCover(k-1, t+1);}else{Board[br-1][bc-1] = t;BoardCover(k-1, t+1); }//右上角覆盖并划分 if( sr <= br-1 && sc >= bc ) {BoardCover(k-1, t+1);}else{Board[br-1][bc] = t;BoardCover(k-1, t+1); }//左下角覆盖并划分 if( sr >= br && sc <= bc-1 ) {BoardCover(k-1, t+1);}else{Board[br][bc-1] = t;BoardCover(k-1, t+1); }//右下角覆盖并划分 if( sr <= br && sc <= bc ) {BoardCover(k-1, t+1);}else{Board[br][bc] = t;BoardCover(k-1, t+1); }
}int main()
{int k; //棋盘格是2^k*2^kscanf("%d %d %d",&k, &sr, &sc);int t = 0;
//  printf("%d %d",sr,sc); //测试输出Board[sr][sc] = t;BoardCover(k-1, t+1);for(int i = 0; i < pow(2,k); i++){for(int j = 0; j < pow(2,k); j++){printf("%d ",Board[i][j]);}printf("\n");}return 0;
}

错误历程2

我这次传入了特殊的格子，但是我取忽略了，中心点也是跟着特殊格子去变化的，即这整个过程是所有东西都在变化的，这个时候必须引入一个可以变化的点，可以确认中心点和特殊格子的点

#include<stdio.h>
#include<math.h>
#define Max 100
/*变量的定义如下sr:特殊格子的行 sc:特殊格子的列 br:划分格子的行 bc:划分格子的列Board[][]:（全局变量）棋盘格子数组t:定义划分格子的数字
*/ int Board[Max][Max] = {0};//错误思路 忽略了特殊格子是一直在变化的，所以必须得传入特俗格子，而我根本就没有传入特殊格子
//为什么不能只传递k 为什么进入不了下一个循环 没有办法再将其返回回去 不仅是减少也是夸大
void BoardCover(int k, int t, int sr, int sc)
{int br; // br:划分格子的行 int bc; //    bc:划分格子的列br = pow(2,k);bc = pow(2,k);
//  printf("%d %d\n",br,bc); //测试输出printf("k %d\n",k);//当划分到最后只有一个格子的时候 就return     if(k < 0){return; }  //左上角覆盖并划分 if( sr <= br-1 && sc <= bc-1 ) {BoardCover(k-1, t+1, sr, sc);}else{Board[br-1][bc-1] = t;BoardCover(k-1, t+1, br-1, bc-1); }//右上角覆盖并划分 if( sr <= br-1 && sc >= bc ) {BoardCover(k-1, t+1, sr, sc);}else{Board[br-1][bc] = t;BoardCover(k-1, t+1,  br-1, bc); }//左下角覆盖并划分 if( sr >= br && sc <= bc-1 ) {BoardCover(k-1, t+1, sr, sc);}else{Board[br][bc-1] = t;BoardCover(k-1, t+1,  br, bc-1); }//右下角覆盖并划分 if( sr >= br && sc >= bc ) {BoardCover(k-1, t+1, sr, sc);}else{Board[br][bc] = t;BoardCover(k-1, t+1,  br, bc); }}int main()
{int k; //棋盘格是2^k*2^kint sr = 0;int sc = 0;scanf("%d %d %d",&k, &sr, &sc);int t = 0;
//  printf("%d %d",sr,sc); //测试输出Board[sr][sc] = 5;BoardCover(k-1, t+1, sr, sc);for(int i = 0; i < pow(2,k); i++){for(int j = 0; j < pow(2,k); j++){printf("%d ",Board[i][j]);}printf("\n");}return 0;
}

代码

最后我选择了最左上角的点作为可变化的点其余的跟着一起变化

但是我发现数字没有办法跟着t一直相加而是一直徘徊在123 而不到21

这个时候，我发现必须得加一个全局变量，得跟着函数的变化而变化，每递归一次函数，这个全局变量的值都得+1

#include<stdio.h>
#include<math.h>
int Board[100][100] = {0};
//必须得设置全局变量
int title = 1;
/*左上角br： 左上角bc：特殊点sr:特殊点sc：中心点tr：中心点tc： */ //解决问题 t无法一直加
void BoardCover(int size, int t, int sr, int sc, int br, int bc)
{int Lsize = size/2;int tr = br + Lsize;int tc = bc + Lsize;t = title; // printf("size %d\n",size); if(size == 1) {
//      for(int i = 0; i < pow(2,3); i++)
//  {
//      for(int j = 0; j < pow(2,3); j++)
//      {
//          printf("%d ",Board[i][j]);
//      }
//      printf("\n");
//  }
//  printf("\n");return;}//   printf("size %d\n",size);
//  printf("Lsize %d\n",Lsize);
//  printf("sr %d sc %d\n",sr, sc);
//  printf("br %d bc %d\n",br, bc);
//  printf("tr %d tc %d\n",tr, tc);
//  printf("t %d \n",t);
//  printf("title %d\n",title);
//  printf("\n");title++; if(sr <= tr-1 && sc <= tc-1){BoardCover(Lsize, t, sr, sc, br, bc);}else{Board[tr-1][tc-1] = t; BoardCover(Lsize, t, tr-1, tc-1, br, bc);}if(sr <= tr-1 && sc >= tc){BoardCover(Lsize, t, sr, sc, br, bc+Lsize);}else{Board[tr-1][tc] = t; BoardCover(Lsize, t, tr-1, tc, br, bc+Lsize);}if(sr >= tr && sc <= tc-1){BoardCover(Lsize, t, sr, sc, br+Lsize, bc);}else{Board[tr][tc-1] = t; BoardCover(Lsize, t, tr, tc-1, br+Lsize, bc);}if(sr >= tr && sc >= tc){BoardCover(Lsize, t, sr, sc, br+Lsize, bc+Lsize);}else{Board[tr][tc] = t; BoardCover(Lsize, t, tr, tc, br+Lsize, bc+Lsize);}} int main()
{int k; //棋盘格是2^k*2^kint sr = 0;int sc = 0;   scanf("%d %d %d",&k, &sr, &sc);int t = 0;int size = pow(2,k);Board[sr][sc] =   t;BoardCover(size, t, sr, sc, 0, 0);for(int i = 0; i < pow(2,k); i++){for(int j = 0; j < pow(2,k); j++){if(j == pow(2,k)-1){printf("%d",Board[i][j]);break;}printf("%-4d",Board[i][j]);}printf("\n");}return 0;
}