LeetCode Climbing Stairs

鄙人 刘天昊 csdn新用户 用博客来记录自己的学习过程也希望和网络上志同道合的朋友做一些交流

leetcode篇因为研究生本科都不是cs出生，所以自学数据结构，所有的leetcode都是C语言实现

今天换换胃口，来说一说一道自己觉得很funny的题目

You are climbing a stair case. It takes n steps to reach to the top.

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

Note: Given n will be a positive integer.

说一个爬梯子的游戏，那你一次可以走1步或者两步（这里不可倒退就往上爬）

说说思路，刚刚拿到这题，暴力枚举（没有思路），仔细想想不可能过的，那么思考如何减少枚举重复的数字。

在学校操场坐着想想我们可以倒着思考问题从上往下走

假设有5层，构建一个树，左子树减1右子树减2，当数==0时记录count++，<=0时返回，递归的去建立一个树可以减少枚举的数字

typedef struct Stack
{
    int data;
    struct Stack *next;
    int Size;
}Stack;
Stack *InitStack()
{
    Stack *stack=(Stack *)malloc(sizeof(Stack));
    stack->next=NULL;
    stack->Size=0;
    return stack;
}
void PushStack(Stack *stack,int data)
{
    Stack *node=(Stack *)malloc(sizeof(Stack));
    node->data=data;
    node->Size=(stack->Size)++;
    node->next=stack->next;
    stack->next=node;
}
typedef struct Treenode
{
    int data;
    struct Treenode *left;
    struct Treenode *right;
}Treenode;
Treenode *InitTree(int data,Stack *stack)
{
    Treenode *root;
    if(data<=0)
    {
        root=NULL;
        if(data==0)
        {
            PushStack(stack,0);
        }
    }
    else
    {
        root=(Treenode *)malloc(sizeof(Treenode));
        root->data=data;
        root->left=InitTree(data-1,stack);
        root->right=InitTree(data-2,stack);
    }
    return root;
}
int climbStairs(int n) 
{
    Stack *stack=InitStack();
    Treenode *root;
    root=InitTree(n,stack);
    int res=stack->Size;
    return res;
}

可惜这个到35的时候就超出内存限制了，于是我又陷入思考

接着又再草纸上发现这个规律--ok你仔细看看就很容易明白

这个问题发展成一个斐波那契数列问题我一激动写了个代码

int climbStairs(int n) 
{
    if(n<=2)
    {
        return n;
    }
    else
    {
        return climbStairs(n-1)+climbStairs(n-2);
    }
}

ok时间超出限制，我当时有点小懵逼，但是不久我就ok了

最后po上最后ac的代码也希望与大家分享这个思考问题的过程

int climbStairs(int n) 
{
    int a=1;
    int b=2;
    int c=0;
    if(n<=2)
    {
        return n;
    }
    else 
    {
        for(int i=2;i<n;i++)
        {
            c=a+b;
            a=b;
            b=c;
        }
    }
    return c;
}

这也是非常入门的动态规划问题（子问题，加记忆）动态规划非常难，因为它没有固定的形式我觉得动态规划要先从简单的开始，天才例外

图片