按顺序刷确实效率太低了，今天开始要按顺序的同时也按标题来了，全面加油！这种应该以后会更多直接总结题解了，自我学习用，全靠大佬，贴贴！！含45、55、62、63

CP55 跳跃游戏

题目描述：

给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。数组中的每个元素代表你在该位置可以跳跃的最大长度。判断你是否能够到达最后一个下标。

题解：

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int n = nums.size();
        int rightmost = 0;
        for (int i = 0; i < n; ++i) {
            if (i <= rightmost) {
                rightmost = max(rightmost, i + nums[i]);
                if (rightmost >= n - 1) {
                    return true;
                }
            }
        }
        return false;
    }
};

大佬！：

 按这个思路去写，结果超时...我的问题在于，本题需要的是最后一个格子可不可以，我们只需要找到每次跳得最远得地方，我这里定义了一个数组tmp存储每一个地方能不能被跳到，但是这是完全没有用得，更远得能被跳到，那后面得一定可以跳到，无需维护这个数组，只需要记录最远可以跳到得地方。

//我写的超时破代码
class Solution {
public:
    bool canJump(vector<int>& nums) {
        int length=nums.size();
        vector<bool> tmp(length);
        tmp[0]=true;

        for(int i=0;i<length;i++)
        {
            if(tmp[i]==true)
            {
                int n=nums[i];
                for(int j=1;j<=n;j++)
                {
                    if(i+j<length)
                    {
                        tmp[i+j]=true;
                    }
                }
            }
        }
        return tmp[length-1];
    }
};

//大佬代码
class Solution {
public:
    bool canJump(vector<int>& nums) {
        int k = 0;
        for (int i = 0; i < nums.size(); i++) {
            if (i > k) return false;
            k = max(k, i + nums[i]);
        }
        return true;
    }
};

CP45 跳跃游戏II

题目描述：

给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。每个元素 nums[i] 表示从索引 i 向前跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j] 处：0 <= j <= nums[i] 且 i + j < n。返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]。注：题目保证可以到达 nums[n-1]

学习记录：

有了第一题的想法，我们只需要不断判断每次的最小步数就行了，初步想法是定义一个储存最小步数的数组，然后不断更新。一道典型的动态规划

//我的思路
class Solution {
public:
    int jump(vector<int>& nums) {
        int length=nums.size();
        vector<int> tmp(length);//存储最少跳数 
        for(int i=0;i<length;i++) tmp[i]=length;
        tmp[0]=0;

        for(int i=0;i<length;i++)
        {
            int n=nums[i];
            for(int j=1;j<=n;j++)
            {
                if(i+j<length)
                {
                    tmp[i+j]=min(tmp[i+j],tmp[i]+1);
                    //这里第一次写成tmp[i]+j了，但是每次只需要加1跳就行
                }
            }
        }

        return tmp[length-1];
    }
};

题解：

1.正向分析法

其实我们也用了正向分析法，但是正如第一题提到的问题，所有后面能到达的前面也能，同理不用多维护一个数组，在本题，最后一个点一定能到，也就是说这个数组中所有点都是能到的。所以我每次只需要：我们维护当前能够到达的最大下标位置，记为边界。我们从左到右遍历数组，到达边界时，更新边界并将跳跃次数增加 1。比我们的方案难理解一点，maxPos:目前能跳到的最远位置；end：上次可跳跃的右边界

class Solution {
public:
    int jump(vector<int>& nums) {
        int maxPos = 0, n = nums.size(), end = 0, step = 0;
        for (int i = 0; i < n - 1; ++i) 
        {
            maxPos = max(maxPos, i + nums[i]);
            if (i == end) 
            {
                end = maxPos;
                ++step;
            }
        }
        return step;
    }
};

2.反向分析法

C++实现超时间了，就学习一下思想，给出java实现的代码

class Solution {
    public int jump(int[] nums) {
        int position = nums.length - 1;
        int steps = 0;
        while (position > 0) {
            for (int i = 0; i < position; i++) {
                if (i + nums[i] >= position) {
                    position = i;
                    steps++;
                    break;
                }
            }
        }
        return steps;
    }
}

CP62 不同路径

题目描述：

学习记录：

典型动态规划，维护一个数组，记录路径数即可。

class Solution {
public:
    int uniquePaths(int m, int n) {
        int tmp[m][n];
        for(int i=0;i<m;i++)
        {
            tmp[i][0]=1;
        }
        for(int j=0;j<n;j++)
        {
            tmp[0][j]=1;
        }
        
        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                tmp[i][j]=tmp[i-1][j]+tmp[i][j-1];
            }
        }
        return tmp[m-1][n-1];
    }
};

题解：

除了上述方法，还有一种

python中存在API：

def uniquePaths(self, m: int, n: int) -> int:
        return int(math.factorial(m+n-2)/math.factorial(m-1)/math.factorial(n-1))

作者：powcai

CP63 不同路径II

题目描述：

学习记录：

和上述思路一样，只是多加了一个判断，如果有石头就不能走，没啥好说的，写

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m=obstacleGrid.size();int n=obstacleGrid[0].size();
        int tmp[m][n];
        int flag=1;
        for(int i=0;i<m;i++)
        {
            if(obstacleGrid[i][0]==1) flag=0;
            if(flag) tmp[i][0]=1;else tmp[i][0]=0;
        }
        flag=1;
        for(int j=0;j<n;j++)
        {
            if(obstacleGrid[0][j]==1) flag=0;
            if(flag) tmp[0][j]=1;else tmp[0][j]=0;
        }

        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                tmp[i][j]=tmp[i-1][j]+tmp[i][j-1];
                if(obstacleGrid[i][j]==1) tmp[i][j]=0;
            }
        }

        return tmp[m-1][n-1];
    }
};

注：定义可以这样定义：vector<vector<int>> tmp(m,vector<int>(n));

PS：

由于leetcode比较智能允许int t[m][n]这种形式，但是VS2010不行，需要方法如下：

#include <iostream>   
#include <string>
#include <iomanip>
using namespace std;

void find(int m,int n)
{
	int *m1=new int [m];
	for(int i=0;i<m;i++)
		m1[i]=0;
	cout<<"m1: "<<m1[0]<<endl;
	delete m1;

	int **m2=new int* [m];
	for(int i=0;i<m;i++)
		m2[i]=new int [n];
	for(int i=0;i<m;i++)
		for(int j=0;j<n;j++)
			m2[i][j]=1;
	cout<<"m2: "<<m2[0][0]<<endl;
	for(int i=0;i<m;i++) 
		delete m2[i];
}

int main()
{
	int m=2;int n=3;
	find(m,n);
    system("pause");
    return 0;
}