leetcode(61-65)_朴素贝叶斯 leetcode-优快云博客

61. 旋转链表

给定一个链表，旋转链表，将链表每个节点向右移动 k 个位置，其中 k 是非负数。

示例 1:

输入: 1->2->3->4->5->NULL, k = 2
输出: 4->5->1->2->3->NULL
解释:
向右旋转 1 步: 5->1->2->3->4->NULL
向右旋转 2 步: 4->5->1->2->3->NULL

示例 2:

输入: 0->1->2->NULL, k = 4
输出: 2->0->1->NULL
解释:
向右旋转 1 步: 2->0->1->NULL
向右旋转 2 步: 1->2->0->NULL
向右旋转 3 步: 0->1->2->NULL
向右旋转 4 步: 2->0->1->NULL

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if(head == NULL) return 0;
        if(k==0) return head;
        ListNode* tmpHead = head;
        int len=1;
        while(tmpHead->next != NULL) {
            len++;
            tmpHead=tmpHead->next;
        }
        tmpHead->next=head;
        k%=len;
        for(int i=1; i<=len-k; i++){
            tmpHead = head;
            head=head->next;
        }
        tmpHead->next=NULL;
        return head;
    }
};

62. 不同路径

一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为“Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。

问总共有多少条不同的路径？

例如，上图是一个7 x 3 的网格。有多少可能的路径？

说明：m 和 n 的值均不超过 100。

示例 1:

输入: m = 3, n = 2
输出: 3
解释:
从左上角开始，总共有 3 条路径可以到达右下角。
1. 向右 -> 向右 -> 向下
2. 向右 -> 向下 -> 向右
3. 向下 -> 向右 -> 向右

示例 2:

输入: m = 7, n = 3
输出: 28

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

63. 不同路径 II

一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为“Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

网格中的障碍物和空位置分别用 1 和 0 来表示。

说明：m 和 n 的值均不超过 100。

示例 1:

输入:
[
  [0,0,0],
  [0,1,0],
  [0,0,0]
]
输出: 2
解释:
3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径：
1. 向右 -> 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右 -> 向右

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

64. 最小路径和

给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

说明：每次只能向下或者向右移动一步。

示例:

输入:
[
  [1,3,1],
  [1,5,1],
  [4,2,1]
]
输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小。

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int m=grid.size();
        int n=grid[0].size();
        if(!m || !n) return 0;
        int dp[m][n];
        dp[0][0] = grid[0][0];
        for(int i=1; i<m; i++) dp[i][0] = dp[i-1][0]+grid[i][0];
        for(int i=1; i<n; i++) dp[0][i] = dp[0][i-1]+grid[0][i];
        for(int i=1; i<m; i++){
            for(int j=1; j<n; j++){
                dp[i][j] = min(dp[i-1][j], dp[i][j-1])+grid[i][j];
            }
        }
        return  dp[m-1][n-1];
    }
};

65. 有效数字

验证给定的字符串是否为数字。

例如:
"0" => true
" 0.1 " => true
"abc" => false
"1 a" => false
"2e10" => true

说明: 我们有意将问题陈述地比较模糊。在实现代码之前，你应当事先思考所有可能的情况。

class Solution {
public:
    bool isINT(string s){
        if (s.empty()) return false;
        for (int i = 0; i <s.size(); ++i){
            if (i == 0){
                if ((s[i] == '+' || s[i] == '-') && s.size() != 1 || isdigit(s[i])) continue;
                else return false;
            }
            else{
                if (!isdigit(s[i])) return false;
            }
        }
        return true;
    }
 
    bool isFlOAT(string s){
        if (s.empty() || s == "." || s == "-." || s == "+.") return false;
        int flag = 0;
        for (int i = 0; i < s.size(); ++i){
            if (i == 0 && (s[i] == '+' || s[i] == '-') && s.size() != 1) continue;
            if (!isdigit(s[i])) {
                if (s[i] == '.' && !flag) ++flag;
                else return false;
            }
        }
        return true;
    }
 
    bool isNumber(string s) {
        if (s.empty()) return false;
        int flag = 0, p = -1, q = s.size();
        while (++p<s.size() && s[p] == ' ') continue;	
        while (--q >= 0 && s[q] == ' ') continue;      
        if (p > q) return false;
        if (isFlOAT(s.substr(p, q - p + 1)) || isINT(s.substr(p, q - p + 1))) return true;
        else{
            for (int i = p; i <= q; ++i){
                if (s[i] == 'e' && isFlOAT(s.substr(p, i - p)) && isINT(s.substr(i + 1, q - i))) return true;
            }
            return false;
        }
    }
};

(以上题目均摘自leetcode)