66. Plus One*

66. Plus One*

https://leetcode.com/problems/plus-one/

题目描述

Given a non-empty array of digits representing a non-negative integer, plus one to the integer.

The digits are stored such that the most significant digit is at the head of the list, and each element in the array contain a single digit.

You may assume the integer does not contain any leading zero, except the number 0 itself.

Example 1:

Input: [1,2,3]
Output: [1,2,4]
Explanation: The array represents the integer 123.

Example 2:

Input: [4,3,2,1]
Output: [4,3,2,2]
Explanation: The array represents the integer 4321.

解题思路

思路 1: 这题只要引入一个 carry_over 进位符就很简单, 但是有些细节要注意, 如果输入数组末尾最后一位不是 9 的话, 那么就不需要进位, 但如果是 9, 便需要考虑进位的事情, 特别是, 当输入是 9999, 而结果会变为 10000, 此时输出数组和输入数组的大小是不一样的.

思路 2: 来自 https://www.cnblogs.com/grandyang/p/4079357.html, 主要注意进位的问题. 如果最后一位是 9, 那么就要将该位置为 0, 并向下一位进 1, 如果下一位仍然是 9, 那么继续向下进位. 而如果遇到哪一位不是 9, 则直接将结果返回. 注意最后如果第一位是 9 的话, 那么就要在数组首位 insert 一个位置插入 1.

C++ 实现 1

不多解释. 一年前的代码. 实现思路 1.

class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {

        vector<int> res;
        int sum = digits.back() + 1;
        int carry_over = sum / 10;
      	// 当最后一位不是 9 的话, 只要将原数组中最后一个数字加 1 即可.
        if (!carry_over) {
            res = digits;
            res[digits.size() - 1] = sum;
            return res;
        }
		
      	// 否则, 就要进位
        res.push_back(sum % 10);
        for (int i = digits.size() - 2; i >= 0; --i) {
            int sum = digits[i] + carry_over;
            carry_over = sum / 10;
            res.push_back(sum % 10);
        }
      	// 注意最后 carry_over 是 1 的话,才能加入到 res 中.
      	// 由于从后先前加, 因此最后要将 res 翻转.
        if (carry_over)
            res.push_back(carry_over);
        std::reverse(res.begin(), res.end());
        return res;
    }
};

C++ 实现 2

今天写的. Beats 100%. 实现思路 1.

class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        vector<int> res;
        int carry_over = (digits.back() + 1) / 10;
        if (!carry_over) {
            res = digits;
            res.back() += 1;
            return res;
        }
        res.push_back((digits.back() + 1) % 10);
        int i = digits.size() - 2;
        while (i >= 0) {
            int sum = digits[i] + carry_over;
            res.push_back(sum % 10);
            carry_over = sum / 10;
            -- i;
        }
        if (carry_over) res.push_back(carry_over);
        std::reverse(res.begin(), res.end());
        return res;
    }
};

C++ 实现 3

实现思路 2

class Solution {
public:
    vector<int> plusOne(vector<int> &digits) {
        int n = digits.size();
        for (int i = n - 1; i >= 0; --i) {
          	// 如果当前位是 9, 那么直接置为 0, 否则, 加 1之后返回.
            if (digits[i] == 9)
              	digits[i] = 0;
            else {
                digits[i] += 1;
                return digits;
            }
        }
      	// 最后要判断首位是不是已经进位了.
        if (digits.front() == 0) digits.insert(digits.begin(), 1);
        return digits;
    }
};

C++ 实现 4

借鉴思路 2, 简化思路 1 的代码.
初始化 carry == 1, 之后只要 i 还在数组的范围内且 carry 为 0, 那么可以直接返回结果, 否则在数组起始位置插入 1.

class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        if (digits.empty()) return digits;
        int carry = 1, n = digits.size();
        for (int i = n - 1; i >= 0; --i) {
            if (carry == 0) return digits;
            int sum = digits[i] + carry;
            digits[i] = sum % 10;
            carry = sum / 10;
        }
        if (carry == 1) digits.insert(digits.begin(), 1);
        return digits;
    }
};