DFS(深度优先搜索)--猴子爬山--leetcode784字母大小写全排列--全排列---N级台阶

猴子爬山

一天一只顽猴想去从山脚怕到山顶，途中经过一个有个N个台阶的阶梯，但是这猴子有一个习惯： 每一次只能跳1步或跳3步，试问猴子通过通过这个阶梯有多少种不同的跳跃方式？

解答要求时间限制：1000ms, 内存限制：64MB

输入

输入只有一个整数N（0<N<=50）此阶梯有多少个阶梯

输出

输出有多少种跳跃方式（解决方案数）

样例

输入样例 1 

3
50

输出样例 1

2
122106097

利用dfs得出代码：

#include<iostream>
using namespace std;
int res;
int dfs(int cur,int n){
    if(cur==n){
        res++;
    }
    if(cur>=n){
        return 0;
    }
    dfs(cur+1,n);
    dfs(cur+3,n);
}
int main(){
    int input;
    while(cin>>input){
        dfs(0,22);
        cout<<res<<endl;
    }
    return 0;
}

但是利用dfs的时间复杂度太大，改用动态规划做这个题，时间复杂度明显降低。

#include <iostream>
using namespace std;
int out;
int fun(int n){
   if(n==1||n==2){
       return 1;
   }
   if(n==3){
       return 2;
   }
   if(n>3){
       out=fun(n-1)+fun(n-3);
   }
   return out;
}
int main(){
    int input;
    int put;
    while(cin>>input){
        put=fun(input);
        cout<<put<<endl;
    }
    return 0;
}

leetcode784. 字母大小写全排列

给定一个字符串S，通过将字符串S中的每个字母转变大小写，我们可以获得一个新的字符串。返回所有可能得到的字符串集合。

示例:
输入: S = "a1b2"
输出: ["a1b2", "a1B2", "A1b2", "A1B2"]

输入: S = "3z4"
输出: ["3z4", "3Z4"]

输入: S = "12345"
输出: ["12345"]
注意：

S 的长度不超过12。
S 仅由数字和字母组成。

#include <vector>
#include <iostream>
using namespace std;
vector<string> ans;
void dfs(string s,int n ){
    if(n==s.size()){
        ans.push_back(s);
        return;
    }
    dfs(s,n+1);
    if(s[n]>'A'){
        s[n] ^= 32;
        dfs(s,n+1);
    }
}
vector<string> letter(string s){
    dfs(s,0);
    return ans;
}

int main(){
    string str = "ab";
    int n=2;
    letter(str);
    for(int i=0;i<ans.size();i++){
        cout<<ans[i]<<' ';
    }
    return 0;
}

题目描述：

对于自然数N

按字典序输出由1～N组成的所有不重复的数字序列，每行一个序列，每个数字之间有一个空格。

例子：

2

输出
1 2
2 1

例子：

3

输出

1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1

 

#include <stdio.h>
#include <string.h>

int a[1000];
int flag[1000];
int n;
int print[1000];

void dfs(int k)
{
    if (k == n){                         //判断结束条件
        for (int i = 0; i < k - 1; i++) {
            printf("%d ", print[i]);
        }
        printf("%d\n", print[k -1]);//单纯为了控制换行
        return;
    }
    for (int i = 0; i < n; i++){//这个for是以1 - N每个数字为起始进行搜索，成立与否的关键是flag标记，如上图
        if (flag[i] == 0){
            flag[i] = 1;               //标记被访问
            print[k] = a[i];           //k是上图中的index
            dfs(k + 1);                //访问下一个数字
            flag[i] = 0;               //回溯，回溯是DFS的关键！！！！
        }
    }
    return;
}

int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; i++){
        a[i] = i + 1;
    }
    dfs(0);
    return 0;
}




#include <iostream>
using namespace std;
int a[101],b[101],n=3;//a用来存放元素，b用来标记已被访问
void print()
{
    int i;
    for(i=1;i<=n;i++)
    {
        cout<<a[i]<<' ';
    }
    cout<<endl;
}
inline void dfs(int i)
{
    int j;
    if(i==n+1)//表示在第n个数已经排列结束后跳出进行输出
    {
        print();//调用print函数并打印
      
    }
    for(j=1;j<=n;j++)
    {
        if(b[j]==0)//表示未被访问过
        {
            a[i]=j;//把j元素放入到a数组中第i个元素中
            b[j]=1;//标记为已被访问
            dfs(i+1);
            b[j]=0;//未被访问
        }
    }
}
int main()
{

    dfs(1);
    return 0;
}

N级台阶（比如100级），每次可走1步或者2步，求总共有多少种走法？

一、 题目分析

这个问题本质上是斐波那契数列，假设只有一个台阶，那么只有一种跳法，那就是一次跳一级，f(1)=1；如果有两个台阶，那么有两种跳法，第一种跳法是一次跳一级，第二种跳法是一次跳两级,f(2)=2。如果有大于2级的n级台阶，那么假如第一次跳一级台阶，剩下还有n-1级台阶，有f(n-1)种跳法，假如第一次条2级台阶，剩下n-2级台阶，有f(n-2)种跳法。这就表示f(n)=f(n-1)+f(n-2)。将上面的斐波那契数列代码稍微改一下就是本题的答案。我们来看一下代码的实现。

二、斐波那契数列法
 

public class Test {
    static final int s = 100; //自定义的台阶数

    static int compute(int stair){
        if ( stair <= 0){
            return 0;
        }
        if (stair == 1){
            return 1;
        }
        if (stair == 2){
            return 2;
        }
        return compute(stair-1) + compute(stair-2);
    }

    public static void main(String args[]) {
        System.out.println("共有" + compute(s) + "种走法");
    }
}

三、 走台阶问题的简单解决算法

但我自己对于这个题目最早的想法是使用树（多叉树）的方式，100为根节点，每次选择的分支有两种（1、2），然后生成深度为1的树，再从每个2级节点延伸出1、2两个分支，直到所有节点的值<=0，最后统计出所有值为0的叶子节点的数目，就是结果。

不过自己想法实际上把问题复杂化了，下面这种使用递归方式实现的算法本质上和我的思想差不多，但是很明显下面这个算法会简单很多。接下来我们来看看这个算法的实现方式。
 

public class Test {
    static final int s = 100;  //自定义的台阶数
    static int len = 0, sum = 0;

    //最多也只有走100步就到了
    static int step[] = new int[s];

    static void compute(final int stair) {
        if (stair < 0)
            return;

        //表示已经走完了
        if (stair == 0) {
            printSum();
            sum++;
            return;
        }

        //每次到下一步选择时都可以走1-2步
        for (int i = 1; i <= 2; i++) {
            step[len] = i;
            len++;

            //进行下一步的迭代，迭代完之后将每后加上的一步去掉，换成其它的步数(如从1换成2)
            compute(stair - i);
            len--;
        }
    }

    static void printSum() {
        System.out.print("走法:");
        for (int i = 0; i < len; i++)
            System.out.print(step[i] + " ");
        System.out.println();
    }

    public static void main(String args[]) {
        compute(s);
        System.out.println("共有" + sum + "种走法");
    }

}