leetcode十八周解题报告

43..Multiply Strings

Given two non-negative integers num1 and num2 represented as strings, return the product of num1 and num2.

Note:

1. The length of both num1 and num2 is < 110.
2. Both num1 and num2 contains only digits 0-9.
3. Both num1 and num2 does not contain any leading zero.
4. You must not use any built-in BigInteger library or convert the inputs to integer directly.

解题思路：

模拟乘法运算，用数组实现即可

代码：

using namespace std;
class Solution {
public:
	string multiply(string num1, string num2) {
		if (num1 == "0" || num2 == "0"){
			return string("0");
		}
		vector<int> n1(num1.length());
		vector<int> n2(num2.length());
		for (int i = 0; i < n1.size(); ++i){
			n1[i] = num1[i] - '0';
		}
		for (int i = 0; i < n2.size(); ++i){
			n2[i] = num2[i] - '0';
		}
		vector<int> numMultires = numMulti(n1, n2);
		int index = 0;
		while (numMultires[index++] == 0);
		--index;
		vector<int>resNum(numMultires.begin() + index, numMultires.end());
		string a = "";
		for (int i = 0; i < resNum.size(); ++i){
			a += ('0' + resNum[i]);
		}
		return a;
	}
	vector<int> numMulti(vector<int>& a, vector<int>& b){
		vector<int> res(a.size() + b.size());
		for (int i = 0; i < b.size(); ++i){
			vector<int> tmp = oneBitMul(a, b[i]);
				res = Add(res, numshift(tmp, b.size() - 1 - i));
		}
		return res;

	}
	vector<int> oneBitMul(vector<int>& a, int b){
		vector<int> res(a.size() + 1);
		int carry = 0;
		for (int i = res.size() - 1; i > 0; --i){
			res[i] = (a[i - 1] * b + carry) % 10;
			carry = (a[i - 1] * b + carry) / 10;
		}
		res[0] = carry;
		return res;
	}

	vector<int> Add(vector<int> a, vector<int> b){
		int num = (a.size() > b.size() ? a.size() : b.size()) + 1;
		vector<int> res(num);
		vector<int> longer = a.size() > b.size() ? a : b;
		vector<int> shorter = a.size() > b.size() ? b : a;
		int carry = 0;
		int j = longer.size() - 1, k = shorter.size() - 1;
		for (int i = res.size() - 1; i >= 0; --i){
			if (k >= 0){
				res[i] = (carry + longer[j] + shorter[k]) % 10;
				carry = (carry + longer[j--] + shorter[k--]) / 10;
			}
			else if (j >= 0){
				res[i] = (carry + longer[j]) % 10;
				carry = (carry + longer[j--]) / 10;
			}
			else {
				res[i] = carry;
			}
		}
		return res;
	}
	vector<int> numshift(vector<int>& a, int shiftN){
		vector<int> res(a.size() + shiftN);
		for (int i = 0; i < a.size(); ++i){
			res[i] = a[i];
		}
		return res;
	}
};

结果：

57. Insert Interval

Given a set of non-overlapping intervals, insert a new interval into the intervals (merge if necessary).

You may assume that the intervals were initially sorted according to their start times.

Example 1:
Given intervals [1,3],[6,9], insert and merge [2,5] in as [1,5],[6,9].

Example 2:
Given [1,2],[3,5],[6,7],[8,10],[12,16], insert and merge [4,9] in as [1,2],[3,10],[12,16].

This is because the new interval [4,9] overlaps with [3,5],[6,7],[8,10].

解题思路：

    首先，将所有区间按照begin排好顺序，然后将这些区间不断压入结果栈。

    每个新元素需要入栈时，需要判断与当前栈顶元素是否重合，如果重合，合并这两个元素，放入栈顶，否则放入这个元素。

代码如下:

/**
 * Definition for an interval.
 * struct Interval {
 *     int start;
 *     int end;
 *     Interval() : start(0), end(0) {}
 *     Interval(int s, int e) : start(s), end(e) {}
 * };
 */
class Solution {
public:
    vector<Interval> insert(vector<Interval>& intervals, Interval newInterval) {
        vector<Interval>newIntervalList(intervals.size() + 1);
        int index = 0;
        bool isuse = false;
        for(int i = 0; i < newIntervalList.size(); ++i){
           if(index == intervals.size()){
               newIntervalList[i] = newInterval;
           }
           else if(!isuse && newInterval.start < intervals[index].start){
               newIntervalList[i] = newInterval;
               isuse = true;
           } 
           else {
               newIntervalList[i] = intervals[index++];
           }
        }
        vector<Interval>res;
        res.push_back(newIntervalList[0]);
        index = 0;
        for(int i = 1; i < newIntervalList.size(); ++i){
            if (overLap(res[index], newIntervalList[i])){
                res[index] = merge(res[index], newIntervalList[i]);
            }
            else {
                res.push_back(newIntervalList[i]);
                ++index;
            }
        }
        return res;
    }
    bool overLap(Interval& a, Interval& b){
        return ((b.end >= a.start && b.end <= a.end) || 
            (b.start >= a.start && b.start <= a.end) ||
            (b.start < a.start && b.end > a.end));
    }
    Interval merge(Interval& a, Interval &b){
        int start = a.start < b.start ? a.start : b.start;
        int end = a.end > b.end ? a.end : b.end;
        return Interval(start, end);
    }
};

结果如下: