从零开始的刷LeetCode生活 第6期 61-70

/**
 * 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) return head;
        int n = 0;
        ListNode* tail;
        for(auto p = head; p; p = p->next)
        {
            n ++;
            tail = p;
        }
        k %= n;
        if(!k) return head;
        ListNode* a = head;
        for(int i = 0; i < n - 1 - k; i ++)
            a = a->next;
        ListNode *next = a->next;
        tail->next = head;
        a->next = NULL;
        return next;
    }
};

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> f(n, vector<int>(m, 0));
        f[0][0] = 1;
        for(int i = 0; i < n; i ++)
            for(int j = 0; j < m; j ++)
                if(i || j) //不是左上角的点
                {
                    if(i) f[i][j] += f[i - 1][j];
                    if(j) f[i][j] += f[i][j - 1];
                }
        return f[n - 1][m - 1];
    }
};

class Solution {
public:
    int uniquePaths(int m, int n) {
        int num = min(m, n) - 1;
        return factorical(m + n - 2, num) / factorical(num, num);
    }

    long factorical(int start, int count)
    {
        long num = 1;
        while(count --) num *= start --;
        return num;
    }
};

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

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

class Solution {
public:
    bool isNumber(string s) {
        int i = 0;
        for( ; s[i] == ' '; i ++){}
        if(s[i] == '+' || s[i] == '-') i ++;

        int n_num, n_point;
        for(n_num = 0, n_point = 0; (s[i] <= '9' && s[i] >= '0') || s[i] == '.'; i ++)
            s[i] == '.' ? n_point++ : n_num ++;
        if(n_point > 1 || n_num < 1) return false;

        if(s[i] == 'e')
        {
            i ++;
            if(s[i] == '+' || s[i] == '-') i ++;
            int n_num = 0;
            for( ; s[i] >='0' && s[i] <= '9'; i ++, n_num ++){};
            if(n_num < 1) return false;
        }
        for(; s[i] == ' '; i ++){}
        return s[i] == 0; //字符串的最后是0
    }
};

class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        int t = 1;
        for(int i = digits.size() - 1; ~i; i --)
        {
            int &x = digits[i];
            t += x;
            x = t % 10;
            t /= 10;
        }
        if(t)
        {
            digits.push_back(0);
            for(int i = digits.size() - 1; i; i --) digits[i] = digits[i - 1];
            digits[0] = 1;
        }
        return digits;
    }
};

class Solution {
public:
    string addBinary(string a, string b) {
        reverse(a.begin(), a.end());
        reverse(b.begin(), b.end());
        int t = 0;
        string res;
        for(int i = 0; i < a.size() || i < b.size(); i ++)
        {
            int x = i >= a.size() ? 0 : a[i] - '0', y = i >= b.size() ? 0 : b[i] - '0';            
            int s = t + x + y;      
            t = s / 2;    
            s %= 2;
            res += to_string(s);            
        }        
        if(t) res += '1';      
        reverse(res.begin(), res.end());
        return res;
    }
};

class Solution {
public:
    string space(int x) //返回x个空格
    {
        string res;
        while(x--) res += ' ';
        return res;
    }

    vector<string> fullJustify(vector<string>& words, int maxWidth) {
        vector<string> res;
        for(int i = 0; i < words.size(); )
        {
            int j = i + 1, s = words[i].size(), rs = words[i].size();// s这一行放的单词长度 加上空格
            while(j < words.size() && s + 1 + words[j].size() <= maxWidth) //添加下一个单词
            {
                s += words[j].size() + 1;
                rs += words[j].size(); //不加空格的长度
                j ++;
            }
            rs = maxWidth - rs; //需要补充的空格数
            string line = words[i];
            if(j == words.size()) //最后一行
            {
                for(int k = i + 1; k < j; k ++) line += ' ' + words[k];
                line += space(maxWidth - line.size());
            }
            else if(j - i == 1) //当前这一行只有一个单词
            {
                line += space(maxWidth - line.size());
            }
            else{ //单词之间需要填充的空格
                int base = rs / (j - i - 1); //空隙
                int rem = rs % (j - i - 1); //多余空格 分给前半部分
                i ++;
                for(int k = 0; i < j; i ++, k ++)
                    line += space(base + (k < rem)) + words[i];
            }
            i = j;
            res.push_back(line);
        }
        return res;
    }
};

class Solution {
public:
    int mySqrt(int x) {
        int l = 0, r = x;
        while(l < r)
        {
            long long mid = l + r + 1ll >> 1;
            if(mid * mid <= x) l = mid;
            else r = mid - 1;
        }
        return l;
    }
};

class Solution {
public:
    int climbStairs(int n) {
        if(n < 2) return n;
        vector<int> f(n + 1);
        f[1] = 1;
        f[2] = 2;
        for(int i = 3; i <= n; i ++){            
            f[i] = f[i - 1] + f[i - 2];
        }
        return f[n];
    }
};