百度codetop-3

1、爬楼梯
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

class Solution {
public:
	int climbStairs(int n) {
		int p = 0, q = 0, r = 1;
		while(n--){
			p = q;
			q = r;
			r = p + q;
		}
		return r;
	}
};

2、最小的k个数
输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。

class Solution {
public:
	vector<int> getLeastNumbers(vector<int>& arr, int k) {
		vector<int> res;
		if(k == 0) return res;
		priority_queue<int> queue;
		for(int i = 0; i < k; i++)
			queue.push(arr[i]);
		for(int i = k; i < arr.size(); i++){
			if(queue.top() > arr[i]){
				queue.pop();
				queue.push(arr[i]);
			}
		}
		for(int i = 0; i < k; i++){
			res.push_back(queue.top());
			queue.pop();
		}
		return res;
	}
};

3、二维数组中的查找
在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

class Solution {
public:
	bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
		if(matrix.size() == 0) return false;
		int row = matrix.size(), col = matrix[0].size();
		int i = row - 1, j = 0;
		while(i >= 0 && j < col){
			if(matrix[i][j] > target) i--;
			else if(matrix[i][j] < target) j++;
			else return true;
		}
		return false;
	}
};

4、pow(x, n)
实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，xn）。

class Solution {
public:
	double quickmul(int x, long long n){
		if(n == 0) return 1.0;
		double y = quickmul(x, N / 2);
		return N % 2 == 0 ? y * y : y * y * x; 
	}
	double myPow(double x, int n) {
		long long N = n;
		return N > 0 ? quickmul(x, N) : 1.0 / quickmul(x, -N);
	}
};

5、数组中的第k个最大元素
在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

class Solution {
public:
	void quicksort(vector<int>& nums, int l, int r){
		if(l >= r) return;
		int num = nums[l];
		int left = l, right = r;
		while(left < right){
			while(left < right && nums[right] >= num)
				right--;
			nums[left] = nums[right];
			while(left < right && nums[left] < num)
				left++;
			nums[right] = nums[left];
		}
		nums[left] = num;
		quicksort(nums, l, left -1);
		quicksort(nums, left + 1, r);
	}
	int findKthLargest(vector<int>& nums, int k) {
		quicksort(nums, 0, nums.size() - 1);
		return nums[nums.size() - k];
	}
};

6、无重复字符的最长子串
给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

class Solution {
public:
	int lengthOfLongestSubstring(string s) {
		int res = 0;
		if(s.size() == 0) return res;
		unordered_map<char, int> map;
		int i = 0;
		for(int j = 0; j < s.size(); j++){
			if(map.find(s[j]) != map.end()){
				i = max(i, map[s[j]]);
			}
			res = max(res, j - i + 1);
			map[s[j]] = j + 1;
		}
		return res;
	}
};

7、最小栈
设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
push(x) —— 将元素 x 推入栈中。
pop() —— 删除栈顶的元素。
top() —— 获取栈顶元素。
getMin() —— 检索栈中的最小元素。

class MinStack {
public:
	stack<int> stack1;
	stack<int> stack2;
	MinStack(){};
	void push(int x){
		if(stack2.empty() || stack2.top() >= x)
			stack2.push(x);
		stack1.push(x);
	}
	void pop(){
		if(stack1.top() == stack2.top())
			stack2.pop();
		stack1.pop();
	}
	int top(){
		return stack1.top();
	}
	int getMin(){
		return stack2.top();
	}
};

8、最大子序和
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

class Solution {
public:
	int maxSubArray(vector<int>& nums) {
		int res = nums[0];
		for(int i = 1; i < nums.size(); i++){
			nums[i] += max(nums[i - 1], 0);
			res = max(res, nums[i]);
		}
		return res;
	}
};

9、两数之和-2
给定一个已按照 升序排列 的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target 。
函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。numbers 的下标 从 1 开始计数 ，所以答案数组应当满足 1 <= answer[0] < answer[1] <= numbers.length 。

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
		int l = 0, r = numbers.size() - 1;
		while(l < r){
			int sum = numbers[l] + numbers[r];
			if(sum == target)
				return {l + 1, r + 1};
			else if(sum > target)
				r--;
			else
				l++;
		}
		return {-1, -1};
	}
};

10、字符串相乘
给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。

class Solution {
public:
    string multiply(string num1, string num2) {
		int m = num1.size(), n = num2.size();
		string s(m + n, '0');
		for(int i = m - 1; i >= 0; i--){
			for(int j = n - 1; j >= 0; j--){
				int cur = (num1[i] - '0') * (num2[j] - '0') + (s[i + j + 1] - '0');
				s[i + j + 1] = cur % 10 + '0';
				s[i + j] += cur / 10;
			}
		}
		for(int i = 0; i < m + n; i++){
			if(s[i] != '0') return s.substr(i);
		}
		return '0';
    }
};