算法设计复习

1.汉诺塔问题

需要用递归来完成

 

要求 1，直接打印出所需要的最少的次数

2. 打印出移动的过程 

 

code：

#include<iostream>
using namespace std;
void move(int id,char from,char to)
{
	cout << "把" << id << "从" << from << "移动到" << to << endl;
}
void hanoi(int n, char x, char y, char z)
{
	if (n == 0) {
		return;
	}
	else
	{
		hanoi(n - 1, x, z, y);//第一步
		move(n, x, z);//第二步
		hanoi(n - 1, y, x, z);//第三步
	}
}
int main()
{
	int n;
	cout << "请输入个数n" << endl;
	cin >> n;
	hanoi(n, 'A', 'B', 'C');
	system("pause");
	return 0;
}

 

汉诺塔问题的拓展（4个盘子）

汉诺塔问题，条件如下：

1、这里有A、B、C和D四座塔。

2、这里有n个圆盘，n的数量是恒定的。

3、每个圆盘的尺寸都不相同。

4、所有的圆盘在开始时都堆叠在塔A上，且圆盘尺寸从塔顶到塔底逐渐增大。

5、我们需要将所有的圆盘都从塔A转移到塔D上。

6、每次可以移动一个圆盘，当塔为空塔或者塔顶圆盘尺寸大于被移动圆盘时，可将圆盘移至这座塔上。

请你求出将所有圆盘从塔A移动到塔D，所需的最小移动次数是多少。

 
汉诺塔塔参考模型

输入格式

没有输入

输出格式

对于每一个整数n(1≤n≤121≤n≤12),输出一个满足条件的最小移动次数，每个结果占一行。

输入样例：

没有输入

输出样例：

参考输出格式

 

 

思路：四个底座的移动即是先把部分盘子放到A盘子上面， 再按照三个底座的方式来移动。

#include<iostream>
#include<cstring>

using namespace std;

const int N = 20;
int d[N];
int f[N];//四个盘子时最少需要移动的次数
int main()
{
    d[1] = 1;
    for(int i = 2; i <= 12 ;i ++){
        d[i] = 1 + d[i - 1] * 2;// 先移动 i - 1 个盘子到C 最后一盘子到B 然后C中的盘子放到B上即可
    }
    
    memset(f, 0x3f,sizeof f);
    
    f[1] = 1;
    f[0] = 0;
    for(int i = 1 ;i <= 12 ;i ++){
        for(int j = 0; j < i;j ++){
            f[i] = min(f[i],f[j] * 2 + d[i - j]);
        }
    }
    
    for(int i = 1; i <= 12 ;i ++) cout << f[i] << endl;
    return 0;
}

 

 

 

 

数塔问题

 

输出最大节点数字的和 ，然后输出路径

#include<iostream>
#include<cstdio> 
#include<queue>
#include<vector>

using namespace std;

const int N = 110;

int b[N][N];
int f[N][N]; 
//bool vis[N * N];

struct node{
	int x,y;
	int point;
}a[N * N];

vector<int> ve[N * N];
int n;
void bfs(int u){
	int cnt = 0;
	queue<int> q;
	q.push(u);
	while(q.size()){
		cnt ++;
		int t = q.front();
		q.pop();
		printf("(%d,%d)",a[t].x,a[t].y);
		if(cnt != n) printf("->");
		for(int i = 0; i < ve[t].size() ; i ++){
			 q.push(ve[t][i]);
		}
	}
}

int main()
{
	int t;
	cin >> t;
	
	while(t --){
		int cnt = 0; // 点的数量 
		cin >> n;
		for(int i = 1 ;i <= n;i ++)
			for(int j = 1 ;j <= i ;j ++){
				cin >> a[++cnt].point;
				a[cnt].x = i, a[cnt].y = j;
				b[i][j] = cnt;
			}
		
		for(int i = 1;i <= n ;i ++){
			f[n][i] = a[b[n][i]].point;
		}		
		
		int row = 0;//行 
		for(int i = n - 1; i >= 1; i --){
			row ++;
			for(int j = 1 ;j <= i ;j ++){
				if(f[i + 1][j] > f[i + 1][j + 1]){
					ve[b[i][j]].push_back(b[i + 1][j]);
					f[i][j] = f[i + 1][j] + a[b[i][j]].point;
				}
				else{
					ve[b[i][j]].push_back(b[i + 1][j + 1]);
					f[i][j] = f[i + 1][j + 1] + a[b[i][j]].point;
				}
			} 
		}
		
		cout << "经过节点的数字之和最大为 : ";
		cout << f[1][1] << endl;
		
		cout << "路径如下所示：" << endl;
		
		bfs(1);
		
	} 
	
	
	return 0;
}

 

还有一种写法：

#include<iostream>
#include<cstdio>
#include<vector>

using namespace std;

const int N = 110;

int a[N][N], f[N][N];
bool vis[N][N][N];
int b[N];

int main()
{
    
    int n;
    cin >> n;
    for(int i = 1;i <= n ;i ++)
        for(int j = 1; j <= i ; j ++){
            cin >> a[i][j];
        }
    
    f[1][1] = a[1][1]; 
    for(int i = 2 ;i <= n ; i ++)
        for(int j = 1 ;j <= i ;j ++){
            if(f[i - 1][j] >= f[i - 1][j - 1]){
                vis[i - 1][j][j] = true;
                f[i][j] = f[i - 1][j] + a[i][j];
                 
            }
            
            else{
                vis[i - 1][j - 1][j] = true;
                f[i][j] = f[i - 1][j - 1] + a[i][j];
            }
           
        }
    
    int pos = 0;
    for(int i = 1;i <= n; i ++){
        if(f[n][i] > f[n][pos]) pos = i;
    
    }
    cout << "节点之和最大值为 ：" << f[n][pos] << endl;
    
    cout << "路径如下 ：" << endl;
    b[n] = pos;

    for(int i = n - 1; i >= 1 ; i --){
        if(vis[i][pos - 1][pos]){
            b[i] = pos - 1;
            pos = pos - 1;
        }
        else{
            b[i] = pos;
        } 
    }
    printf("(1 %d)", b[1]);
    for(int i =  2; i <= n ;i ++){
        printf(" -> (%d, %d)",i,b[i]);
    }
    return 0;
    
}

快速排序

 

code：

#include <iostream>

using namespace std;

const int N = 100010;

int q[N];

void quick_sort(int q[], int l, int r)
{
    if (l >= r) return;

    int i = l - 1, j = r + 1, x = q[l + r >> 1];
    while (i < j)
    {
        do i ++ ; while (q[i] < x);
        do j -- ; while (q[j] > x);
        if (i < j) swap(q[i], q[j]);
    }

    quick_sort(q, l, j);
    quick_sort(q, j + 1, r);
}

int main()
{
    int n;
    scanf("%d", &n);

    for (int i = 0; i < n; i ++ ) scanf("%d", &q[i]);

    quick_sort(q, 0, n - 1);

    for (int i = 0; i < n; i ++ ) printf("%d ", q[i]);

    return 0;
}