1 class Solution {
 2 public:
 3     int uniquePaths(int m, int n) {
 4
 5         if(m<2 || n<2)
 6             return 1;
 7
 8         vector<vector<int>> dp(m,vector<int>(n,1));
 9         for(int i=1;i<m;i++)
10             for(int j=1;j<n;j++)
11                 dp[i][j]=dp[i-1][j]+dp[i][j-1];
12
13         return dp[m-1][n-1];
14     }
15 };

 1 class Solution {
 2 public:
 3     int minPathSum(vector<vector<int>>& grid) {
 4         int szx = grid.size();
 5         if(szx<1)
 6             return 0;
 7         int szy = grid[0].size();
 8         int dp[szx][szy];
 9
10         dp[0][0]=grid[0][0];
11         for(int i=1;i<szx;i++){
12             dp[i][0]= grid[i][0] + dp[i-1][0];
13         }
14
15         for(int i=1;i<szy;i++){
16             dp[0][i]= grid[0][i] + dp[0][i-1];
17         }
18
19          for(int i=1;i<szx;i++)
20              for(int j=1;j<szy;j++)
21                  dp[i][j]=min(dp[i-1][j],dp[i][j-1])+grid[i][j];
22
23         return dp[szx-1][szy-1];
24     }
25 };

 1 //f(n) = f(n-1) + f(n-2)
 2
 3 class Solution {
 4 public:
 5     int climbStairs(int n) {
 6         if(n<3)
 7             return n;
 8         int first = 1, second =2;
 9         int res;
10         for(int i=3;i<=n;i++){
11             res = first + second;
12             first = second;
13             second = res;
14         }
15
16         return res;
17     }
18 };

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 8  * };
 9  */
10 class Solution {
11 public:
12     vector<int> inorderTraversal(TreeNode* root) {
13         vector<int> res;
14         if(root==nullptr)
15             return res;
16         inorderTraversalCore(root, res);
17         return res;
18
19     }
20
21     //不要有返回值，不好处理
22     void inorderTraversalCore(TreeNode* root, vector<int>& res) {
23         if(root->left==nullptr && root->right==nullptr){
24             res.push_back(root->val);
25             return;
26         }
27
28         if(root->left!=nullptr)
29             //不用在此处push_back,到叶结点的时候，左右子树为空，按照中间节点去添加元素（即下下行代码）
30             inorderTraversalCore(root->left,res);
31
32         res.push_back(root->val);
33
34         if(root->right!=nullptr)
35             inorderTraversalCore(root->right,res);
36
37         return;
38
39     }
40 };

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 8  * };
 9  */
10 class Solution {
11 public:
12     int maxDepth(TreeNode* root) {
13         if(root==nullptr)
14             return 0;
15         int left = maxDepth( root->left)+1;
16         int right = maxDepth( root->right)+1;
17         return max(left,right);
18     }
19 };

 1 class Solution {
 2 public:
 3     int singleNumber(vector<int>& nums) {
 4         int res = 0;
 5         int sz = nums.size();
 6         for(int i=0;i<sz;i++)
 7             res ^=nums[i];
 8         return res;
 9     }
10 };