一步步学算法(算法题解)---2

最新推荐文章于 2021-02-25 18:45:20 发布

Colin丶

最新推荐文章于 2021-02-25 18:45:20 发布

阅读量2k

点赞数 22

分类专栏：一步一步学算法 c/c++ 一步步学算法

本文链接：https://blog.csdn.net/hitwhylz/article/details/11394797

版权

c/c++ 同时被 3 个专栏收录

88 篇文章 24 订阅

订阅专栏

一步一步学算法

61 篇文章 11 订阅

订阅专栏

一步步学算法

21 篇文章 35 订阅

订阅专栏

本人大二，最近开始自学算法，在此记录自己学习过程中接触的习题。与君共勉。

水平有限，目前涉及的题目都比较水。

题目分布为5+1. 5为自己学习的5道水题。 1为从网上找到的比较有水平的相关题目。

一步步学算法(算法题解)---2

经典问题回顾。

1。河内之塔(Hanoi)

问题描述:

说明河内之塔(Towers ofHanoi)是法国人M.Claus(Lucas)于1883年从泰国带至法国的,河内为越战时北越的首都,即现在的胡志明市;1883年法国数学家 EdouardLucas曾提及这个故事,据说创世纪时Benares有一座波罗教塔,是由三支钻石棒(Pag)所支撑,开始时神在第一根棒上放置64个由上至下依由小至大排列的金盘(Disc),并命令僧侣将所有的金盘从第一根石棒移至第三根石棒,且搬运过程中遵守大盘子在小盘子之下的原则,若每日仅搬一个盘子,则当盘子全数搬运完毕之时,此塔将毁损,而也就是世界末日来临之时。

问题分析:

解法如果柱子标为ABC,要由A搬至C,在只有一个盘子时,就将它直接搬至C,当有两个盘

子,就将B当作辅助柱。如果盘数超过2个,将第三个以下的盘子遮起来,就很简单了,每次处理两个盘子,也就是:A->B、A ->C、B->C这三个步骤,而被遮住的部份,其实就是进入程式的递回处理。事实上,若有n个盘子,则移动完毕所需之次数为2^n - 1,所以当盘数为64时,则所需次数为:264- 1 =18446744073709551615为5.05390248594782e+16年,也就是约5000世纪,如果对这数字没什幺概念,就假设每秒钟搬一个盘子好了,也要约5850亿年左右。

问题比较简单，也比较经典。下面直接看代码

#include <stdio.h>

void Move(int n,char a,char b)
{
    printf("%d:%c-->%c\n",n,a,b);
}

void Hanoi(int n,char a,char b,char c)
{
    if(n==1)//将A上的1个圆盘直接移到C,递归退出条件
        Move(n,a,c);
    else
    {
        Hanoi(n-1,a,c,b);//将A上n-1个圆盘借助C移到B
        Move(n,a,c);//将A上剩下的1个圆盘直接移到C
        Hanoi(n-1,b,a,c);//将B上n-1个圆盘借助A移到C
    }
}

int main()
{
    int n;
    printf("\ninput   number:");
    scanf("%d",&n);
    Hanoi(n,'A','B','C');
    return 0;
}
/* 打印结果
 
 input   number:3
 1:A-->C
 2:A-->B
 1:C-->B
 3:A-->C
 1:B-->A
 2:B-->C
 1:A-->C
*/

2。Algorithm Gossip: 费式数列

问题描述:

说明Fibonacci为1200年代的欧洲数学家,在他的着作中曾经提到:「若有一只免子每个月生一只小免子,一个月后小免子也开始生产。起初只有一只免子,一个月后就有两只免子,二个月后有三只免子,三个月后有五只免子(小免子投入生产)......。如果不太理解这个例子的话,举个图就知道了,注意新生的小免子需一个月成长期才会投入生产,类似的道理也可以用于植物的生长,这就是Fibonacci数列,一般习惯称之为费氏数列,例如以下: 1、1 、2、3、5、8、13、21、34、55、89......

问题分析:

解法依说明,我们可以将费氏数列定义为以下:

f(n) = f(n-1)+f(n-2)---- if n>1

f(n) = n ------if n = 0, 1

..斐波那契数列，应该是每个写代码的都接触过了。虽然简单，不过还是罗列出来，谁叫它经典呢。

#include <stdio.h>
#define N 10

int main()
{
    int Fib[N] = {0};
    int i;
    Fib[0] = 0;
    Fib[1] = 1;
    for(i = 2; i < N; i++)
        Fib[i] = Fib[i-1] + Fib[i-2];
    for(i = 0; i < N; i++)
        printf("%d ", Fib[i]);
    printf("\n");
    return 0;
}/* 打印结果
  0 1 1 2 3 5 8 13 21 34
*/

3.三色旗

问题描述:

三色旗的问题最早由E.W.Dijkstra所提出，他所使用的用语为Dutch Nation Flag(Dijkstra为荷兰人)，而多数的作者则使用Three-Color Flag来称之。假设有一条绳子，上面有红、白、蓝三种颜色的旗子，起初绳子上的旗子颜色并没有顺序，您希望将之分类，并排列为蓝、白、红的顺序，要如何移动次数才会最少，注意您只能在绳子上进行这个动作，而且一次只能调换两个旗子。

问题分析:

在一条绳子上移动，在程式中也就意味只能使用一个阵列，而不使用其它的阵列来作辅助，问题的解法很简单，您可以自己想像一下在移动旗子，从绳子开头进行，遇到蓝色往前移，遇到白色留在中间，遇到红色往后移

只是要让移动次数最少的话，就要有些技巧：

如果图中W所在的位置为白色，则W+1，表示未处理的部份移至至白色群组。
如果W部份为蓝色，则B与W的元素对调，而B与W必须各+1，表示两个群组都多了一个元素。
如果W所在的位置是红色，则将W与R交换，但R要减1，表示未处理的部份减1。

注意B、W、R并不是三色旗的个数，它们只是一个移动的指标；什幺时候移动结束呢？一开始时未处理的R指标会是等于旗子的总数，当R的索引数减至少于W的索引数时，表示接下来的旗子就都是红色了，此时就可以结束移动，如下所示：

#include<stdio.h>
#include<stdlib.h>
#include<string>
#include<iostream>
using namespace std;
char c[]={'r','b','w','w','b','b','r','w','b'};
void swap(int i,int j)
{
    char t=c[i];
    c[i]=c[j];
    c[j]=t;
}
int main(int argc, char* argv[])
{
    
    int w=0;
    int b=0;
    string s=c;
    int r=s.length()-1;
    while(w<=r)
    {
        if(c[w]=='w')
            w++;
        else if(c[w]=='b')
        {
            swap(b,w);
            b++;
            w++;
        }
        else
        {
            while(r>=w&&c[r]=='r')
                r--;
            swap(w,r);
            r--;
        }
    }
    cout<<c;
    return 0;
}

4.Algorithm Gossip: 老鼠走迷官(一)

问题描述:

说明老鼠走迷宫是递回求解的基本题型,我们在二维阵列中使用2表示迷宫墙壁,使用1来表示老鼠的行走路径,试以程式求出由入口至出口的路径。

问题分析:

解法老鼠的走法有上、左、下、右四个方向,在每前进一格之后就选一个方向前进,无法前进时退回选择下一个可前进方向,如此在阵列中依序测试四个方向,直到走到出口为止,这是递回的基本题,请直接看程式应就可以理解。

#include <stdio.h>
#include <stdlib.h>

int startI = 1, startJ = 1; // 入口
int endI=5,endJ=5; //出口
int success = 0;

int maze[7][7] =
{
    {2, 2, 2, 2, 2, 2, 2},
    {2, 0, 0, 0, 0, 0, 2},
    {2, 0, 2, 0, 2, 0, 2},
    {2, 0, 0, 2, 0, 2, 2},
    {2, 2, 0, 2, 0, 2, 2},
    {2, 0, 0, 0, 0, 0, 2},
    {2, 2, 2, 2, 2, 2, 2}
};

int visit(int i, int j)
{
    maze[i][j] = 1;
    if(i == endI && j == endJ)
        success = 1;
    if(success != 1 && maze[i][j+1] == 0)
        visit(i, j+1);
    if(success != 1 && maze[i+1][j] == 0)
        visit(i+1, j);
    if(success != 1 && maze[i][j-1] == 0)
        visit(i, j-1);
    if(success != 1 && maze[i-1][j] == 0)
        visit(i-1, j);
    if(success != 1)
        maze[i][j] = 0;
    
    return success;
}

int main()
{
    int i, j;
    printf("显示迷宫:\n");
    for(i = 0; i < 7; i++)
    {
        for(j = 0; j < 7; j++)
            if(maze[i][j] == 2)
                printf("█");
            else
                printf(" "); printf("\n");
    }
    if(visit(startI, startJ) == 0)
        printf("\n没有找到出口!\n");
    else
    {
        printf("\n显示路径:\n");
        for(i = 0; i < 7; i++)
        {
            for(j = 0; j < 7; j++)
            {
                if(maze[i][j] == 2)
                    printf("█");
                else if(maze[i][j] == 1)
                    printf("◇");
                else
                    printf(" ");
            }
            printf("\n");
        }
    }
    return 0;
}

5.Algorithm Gossip: 老鼠走迷官(二)

问题描述：

说明由于迷宫的设计,老鼠走迷宫的入口至出口路径可能不只一条,如何求出所有的路径呢?

问题分析：

解法求所有路径看起来复杂但其实更简单,只要在老鼠走至出口时显示经过的路径,然后退回上一格重新选择下一个位置继续递回就可以了,比求出单一路径还简单,我们的程式只要作一点修改就可以了。

#include <stdio.h>
#include <stdlib.h>

int startI = 1, startJ = 1; // 入口
int endI=7,endJ=7; //出口

int maze[9][9] =
{
    {2, 2, 2, 2, 2, 2, 2, 2, 2},
    {2, 0, 0, 0, 0, 0, 0, 0, 2},
    {2, 0, 2, 2, 0, 2, 2, 0, 2},
    {2, 0, 2, 0, 0, 2, 0, 0, 2},
    {2, 0, 2, 0, 2, 0, 2, 0, 2},
    {2, 0, 0, 0, 0, 0, 2, 0, 2},
    {2, 2, 0, 2, 2, 0, 2, 2, 2},
    {2, 0, 0, 0, 0, 0, 0, 0, 2},
    {2, 2, 2, 2, 2, 2, 2, 2, 2}
};

void visit(int i, int j)
{
    int m, n;
    maze[i][j] = 1;
    if(i == endI && j == endJ)
    {
        printf("\n显示路径:\n");
        for(m = 0; m < 9; m++)
        {
            for(n = 0; n < 9; n++)
                if(maze[m][n] == 2)
                    printf("█");
                else if(maze[m][n] == 1)
                    printf("◇");
                else
                    printf(" ");
            printf("\n");
        }
    }
    if(maze[i][j+1] == 0)
        visit(i, j+1);
    if(maze[i+1][j] == 0)
        visit(i+1, j);
    if(maze[i][j-1] == 0)
        visit(i, j-1);
    if(maze[i-1][j] == 0)
        visit(i-1, j);
    maze[i][j] = 0;
}

int main(void)
{
    int i, j;
    printf("显示迷宫:\n");
    for(i = 0; i < 7; i++)
    {
        for(j = 0; j < 7; j++)
            if(maze[i][j] == 2)
            printf("█");
            else
                printf(" ");
        printf("\n");
    }
    visit(startI, startJ);
    return 0;
}

6** 坐旋转字符串

问题描述：

定义字符串的左旋转操作：把字符串前面的若干个字符移动到字符串的尾部。如把字符串abcdef左旋转2位得到字符串cdefab。请实现字符串左旋转的函数。要求时间对长度为n的字符串操作的复杂度为O(n)，辅助内存为O(1)。

问题分析：

如果不考虑时间和空间复杂度的限制，最简单的方法莫过于把这道题看成是把字符串分成前后两部分，通过旋转操作把这两个部分交换位置。于是我们可以新开辟一块长度为n+1的辅助空间，把原字符串后半部分拷贝到新空间的前半部分，在把原字符串的前半部分拷贝到新空间的后半部分。不难看出，这种思路的时间复杂度是O(n)，需要的辅助空间也是O(n)。

接下来的一种思路可能要稍微麻烦一点。我们假设把字符串左旋转m位。于是我们先把第0个字符保存起来，把第m个字符放到第0个的位置，在把第2m个字符放到第m个的位置…依次类推，一直移动到最后一个可以移动字符，最后在把原来的第0个字符放到刚才移动的位置上。接着把第1个字符保存起来，把第m+1个元素移动到第1个位置…重复前面处理第0个字符的步骤，直到处理完前面的m个字符。

该思路还是比较容易理解，但当字符串的长度n不是m的整数倍的时候，写程序会有些麻烦，感兴趣的朋友可以自己试一下。由于下面还要介绍更好的方法，这种思路的代码我就不提供了。

我们还是把字符串看成有两段组成的，记位XY。左旋转相当于要把字符串XY变成YX。我们先在字符串上定义一种翻转的操作，就是翻转字符串中字符的先后顺序。把X翻转后记为X^T。显然有(X^T)^T=X。

我们首先对X和Y两段分别进行翻转操作，这样就能得到X^TY^T。接着再对X^TY^T进行翻转操作，得到(X^TY^T)^T=(Y^T)^T(X^T)^T=YX。正好是我们期待的结果。

分析到这里我们再回到原来的题目。我们要做的仅仅是把字符串分成两段，第一段为前面m个字符，其余的字符分到第二段。再定义一个翻转字符串的函数，按照前面的步骤翻转三次就行了。时间复杂度和空间复杂度都合乎要求。

参考代码如下：

#include "string.h"

///
// Move the first n chars in a string to its end
///
char* LeftRotateString(char* pStr, unsigned int n)
{
    if(pStr != NULL)
    {
        int nLength = static_cast<int>(strlen(pStr));
        if(nLength > 0 || n == 0 || n > nLength)
        {
            char* pFirstStart = pStr;
            char* pFirstEnd = pStr + n - 1;
            char* pSecondStart = pStr + n;
            char* pSecondEnd = pStr + nLength - 1;
            
            // reverse the first part of the string
            ReverseString(pFirstStart, pFirstEnd);
            // reverse the second part of the strint
            ReverseString(pSecondStart, pSecondEnd);
            // reverse the whole string
            ReverseString(pFirstStart, pSecondEnd);
        }
    }
    
    return pStr;
}

///
// Reverse the string between pStart and pEnd
///
void ReverseString(char* pStart, char* pEnd)
{
    if(pStart == NULL || pEnd == NULL)
    {
        while(pStart <= pEnd)
        {
            char temp = *pStart;
            *pStart = *pEnd;
            *pEnd = temp;
            
            pStart ++;
            pEnd --;
        }
    }
}



PS：(XTYT)T=(YT)T(XT)T=YX

Colin丶

关注

22
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
8
评论
一步步学算法(算法题解)---2

本人大二，最近开始自学算法，在此记录自己学习过程中接触的习题。与君共勉。水平有限，目前涉及的题目都比较水。题目分布为5+1. 5为自己学习的5道水题。 1为从网上找到的比较有水平的相关题目。一步步学算法(算法题解)---2经典问题回顾。1。河内之塔(Hanoi)问题描述:说明河内之塔(Towers o
复制链接

扫一扫