面试 on 111qqz's blog

leetcode 146. LRU Cache(list+unordered_map)

Fri, 18 Aug 2017 19:18:25 +0000

请实现最近最少使用缓存(Least Recently Used (LRU) cache)类,需要支持 get, set,操作。 get 操作,给出 key,获取到相应的 value (value 为非负数),如果不存在返回-1, 如果存在此 key 算作被访问过。 set 操作,设置 key,如果 key 存在则覆盖之前的 value (此时相当于访问过一次)。如果 key 不存在,需要进行插入操作,如果此时已经 key 的数量已经到达 capacity, 这样需要淘汰掉最近最少使用(也就是上次被使用的时间距离现在最久的)的那一项。

面试相关

Sat, 12 Aug 2017 04:03:44 +0000

随便记录一下面试中遇到的问题：

梯度下降和牛顿迭代的区别？为什么常用梯度下降？
#

牛顿法是二阶收敛，梯度下降是一阶收敛，所以牛顿法就更快。如果更通俗地说的话，比如你想找一条最短的路径走到一个盆地的最底部，梯度下降法每次只从你当前所处位置选一个坡度最大的方向走一步，牛顿法在选择方向时，不仅会考虑坡度是否够大，还会考虑你走了一步之后，坡度是否会变得更大。所以，可以说牛顿法比梯度下降法看得更远一点，能更快地走到最底部。

leetcode162. Find Peak Element (O(lgn)复杂度寻找峰值)

Fri, 14 Apr 2017 12:25:16 +0000

A peak element is an element that is greater than its neighbors.

Given an input array where num[i] ≠ num[i+1], find a peak element and return its index.

The array may contain multiple peaks, in that case return the index to any one of the peaks is fine.

leetcode 152. Maximum Product Subarray (最大连续子序列乘积，dp)

Fri, 14 Apr 2017 11:33:30 +0000

Find the contiguous subarray within an array (containing at least one number) which has the largest product.

For example, given the array [2,3,-2,4], the contiguous subarray [2,3] has the largest product = 6.

leetcode 228. Summary Ranges

Fri, 14 Apr 2017 10:51:39 +0000

Given a sorted integer array without duplicates, return the summary of its ranges.

For example, given [0,1,2,4,5,7], return ["0->2","4->5","7"].

题意：把连续的数连续表示

leetcode 209. Minimum Size Subarray Sum (尺取法)

Thu, 13 Apr 2017 13:50:02 +0000

Given an array of n positive integers and a positive integer s, find the minimal length of a contiguous subarray of which the sum ≥ s. If there isn’t one, return 0 instead.

leetcode 229. Majority Element II （O(1)空间找出现次数大于n/3的元素）

Thu, 13 Apr 2017 12:41:33 +0000

Given an integer array of size n, find all elements that appear more than ⌊ n/3 ⌋ times. The algorithm should run in linear time and in O(1) space.

题意：给你n个数，要求找出出现此处大于n/3的。。。

leetcode 75. Sort Colors

Thu, 13 Apr 2017 12:02:02 +0000

Given an array with n objects colored red, white or blue, sort them so that objects of the same color are adjacent, with the colors in the order red, white and blue.

leetcode 11. Container With Most Water (two pointer)

Thu, 13 Apr 2017 10:13:01 +0000

Given n non-negative integers a1, a2, …, an, where each represents a point at coordinate (i, ai). n vertical lines are drawn such that the two endpoints of line i is at (i, ai) and (i, 0). Find two lines, which together with x-axis forms a container, such that the container contains the most water.

leetcode 16. 3Sum Closest (k-sum问题，two pointer)

Thu, 13 Apr 2017 09:45:45 +0000

Given an array S of n integers, find three integers in S such that the sum is closest to a given number, target. Return the sum of the three integers. You may assume that each input would have exactly one solution.

leetcode 18. 4Sum (k-sum问题，two pointer)

Thu, 13 Apr 2017 09:34:15 +0000

Given an array S of n integers, are there elements a, b, c, and d in S such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target.

leetcode 15. 3Sum (k-sum问题，two pointer)

Thu, 13 Apr 2017 08:21:52 +0000

Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.

leetcode 216. Combination Sum III Add to List (枚举子集，限定集合大小，和为定值）

Thu, 13 Apr 2017 07:55:09 +0000

Find all possible combinations of k numbers that add up to a number n, given that only numbers from 1 to 9 can be used and each combination should be a unique set of numbers.

leetcode 77. Combinations (枚举子集，限定集合大小)

Thu, 13 Apr 2017 07:43:43 +0000

Given two integers n and k, return all possible combinations of k numbers out of 1 … n.

思路：就是枚举子集，根据集合的大小剪枝。。。最后只要集合大小为k的集合

leetcode 60. Permutation Sequence (求第k个排列)

Thu, 13 Apr 2017 07:24:41 +0000

The set [1,2,3,…,_n_] contains a total of n! unique permutations.

By listing and labeling all of the permutations in order, We get the following sequence (ie, for n = 3):

leetcode 47. Permutations II (生成全排列，有重复元素)

Thu, 13 Apr 2017 07:14:03 +0000

Given a collection of numbers that might contain duplicates, return all possible unique permutations.__

思路：和leet code 46 类似，最后用set去个重即可。。

leetcode 46. Permutations (生成全排列，无重复元素)

Thu, 13 Apr 2017 06:59:43 +0000

Given a collection of distinct numbers, return all possible permutations.

思路：调用n-1次 leetcode 31 解题报告中提到的算法即可。。。

leetcode 31. Next Permutation (in-place 生成下一个全排列)

Thu, 13 Apr 2017 06:47:55 +0000

Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers.

If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).

leetcode 33. Search in Rotated Sorted Array (无重复数的旋转数组找定值)

Thu, 13 Apr 2017 06:29:37 +0000

Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.

(i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).

leetcode 34. Search for a Range (二分，找到一段值为tar的区间)

Thu, 13 Apr 2017 05:34:45 +0000

Given an array of integers sorted in ascending order, find the starting and ending position of a given target value.

Your algorithm’s runtime complexity must be in the order of O(log n).

leetcode 39. Combination Sum (dfs，求所有的组合，和为定值，每个数可以重复用)

Thu, 13 Apr 2017 02:47:49 +0000

Given a set of candidate numbers (C) (without duplicates) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

The same repeated number may be chosen from C unlimited number of times.

leetcode 40. Combination Sum II (枚举子集，和为定值)

Wed, 12 Apr 2017 16:23:29 +0000

 * Total Accepted: **106670**
 * Total Submissions: **329718**
 * Difficulty: **Medium**
 * Contributor: **LeetCode**

Given a collection of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

leetcode 495. Teemo Attacking

Wed, 12 Apr 2017 16:00:57 +0000

In LLP world, there is a hero called Teemo and his attacking can make his enemy Ashe be in poisoned condition. Now, given the Teemo’s attacking ascending time series towards Ashe and the poisoning time duration per Teemo’s attacking, you need to output the total time that Ashe is in poisoned condition.

leetcode 442. Find All Duplicates in an Array（找出出现两次的元素）

Wed, 12 Apr 2017 15:21:23 +0000

Given an array of integers, 1 ≤ a[i] ≤ n (n = size of array), some elements appear twice and others appear once.

Find all the elements that appear twice in this array.

leetcode 48. Rotate Image (旋转方阵(in place))

Wed, 12 Apr 2017 13:22:33 +0000

You are given an n x n 2D matrix representing an image.

Rotate the image by 90 degrees (clockwise).

Follow up: Could you do this in-place?

题意：给一个n*n的方阵，要求顺时针旋转90度。

leetcode 54. Spiral Matrix (矩阵蛇形取数)

Tue, 11 Apr 2017 12:07:54 +0000

Given a matrix of m x n elements (m rows, n columns), return all elements of the matrix in spiral order.

思路：。。。再次让我回想起高一的暑假。。。。

leetcode 55. Jump Game (dp)

Tue, 11 Apr 2017 11:39:15 +0000

Given a collection of intervals, merge all overlapping intervals.

For example, Given [1,3],[2,6],[8,10],[15,18], return [1,6],[8,10],[15,18].

思路:dp[i]表示能否到达位置i…无脑dp即可。。。

leetcode 56. Merge Intervals (模拟，求相交区间)

Tue, 11 Apr 2017 11:30:32 +0000

Given a collection of intervals, merge all overlapping intervals.

For example, Given [1,3],[2,6],[8,10],[15,18], return [1,6],[8,10],[15,18].

思路：扫一遍即可。。

 1/* ***********************************************
 2Author :111qqz
 3Created Time :2017年04月11日 星期二 19时15分30秒
 4File Name :56.cpp
 5************************************************ */
 6/**
 7
 8 * Definition for an interval.
 9
10 * struct Interval {
11
12 * int start;
13
14 * int end;
15
16 * Interval() : start(0), end(0) {}
17
18 * Interval(int s, int e) : start(s), end(e) {}
19
20 * };
21
22 */
23
24class Solution {
25
26public:
27
28 int n;
29 static bool cmp(Interval A,Interval B)
30 {
31	return A.start<B.start;
32 }
33 vector<Interval> merge(vector<Interval>& pi) {
34	vector<Interval>res;
35	n = pi.size();
36	if (n==0) return res;
37	sort(pi.begin(),pi.end(),cmp);
38	int l = -1,r = -1;
39	for ( int i = 0 ; i < n ; i++)
40	{
41	 if (l==-1&&r==-1)
42	 {
43		l = pi[0].start;
44		r = pi[0].end;
45		continue;
46	 }
47	 if (pi[i].start<=r)
48	 {
49		r = max(r,pi[i].end);
50		continue;
51	 }
52	 if (pi[i].start>r)
53	 {
54		res.push_back(Interval(l,r));
55		l = pi[i].start;
56		r = pi[i].end;
57		continue;
58	 }
59	}
60	//最后一组不要忘记
61	res.push_back(Interval(l,r));
62	int siz = res.size();
63	for ( int i = 0 ; i < siz ;i++) printf("%d ",res[i].start,res[i].end);
64
65
66 return res;
67
68 }
69
70};

leetocde 59. Spiral Matrix II (模拟)

Tue, 11 Apr 2017 11:07:52 +0000

Given an integer n, generate a square matrix filled with elements from 1 to _n_2 in spiral order.

思路：仿佛回到高一的那个暑假。。。

leetocde 63. Unique Paths II

Tue, 11 Apr 2017 10:50:57 +0000

Follow up for “Unique Paths”:

Now consider if some obstacles are added to the grids. How many unique paths would there be?

An obstacle and empty space is marked as 1 and 0 respectively in the grid.

leetcode 64. Minimum Path Sum (二维dp)

Mon, 10 Apr 2017 02:35:20 +0000

Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.

Note: You can only move either down or right at any point in time.

leetcode 73. Set Matrix Zeroes (矩阵置0，乱搞)

Mon, 10 Apr 2017 01:16:43 +0000

Given a m x n matrix, if an element is 0, set its entire row and column to 0. Do it in place.

click to show follow up.

**Follow up:**Did you use extra space? A straight forward solution using O(m__n) space is probably a bad idea. A simple improvement uses O(m + n) space, but still not the best solution. Could you devise a constant space solution?

leetcode 238. Product of Array Except Self (乱搞)

Sun, 09 Apr 2017 11:50:05 +0000

Given an array of n integers where n > 1, nums, return an array output such that output[i] is equal to the product of all the elements of nums except nums[i].

leetcode 79. Word Search (dfs)

Fri, 07 Apr 2017 06:59:26 +0000

Given a 2D board and a word, find if the word exists in the grid.

The word can be constructed from letters of sequentially adjacent cell, where “adjacent” cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once.

leetcode 80 Remove Duplicates from Sorted Array II （有序数组去除重复元素）

Wed, 05 Apr 2017 13:36:44 +0000

Follow up for “Remove Duplicates”: What if duplicates are allowed at most twice?

For example, Given sorted array nums = [1,1,1,2,2,3],

Your function should return length = 5, with the first five elements of nums being 1, 1, 2, 2 and 3. It doesn’t matter what you leave beyond the new length.

leetcode 81. Search in Rotated Sorted Array II (有重复元素的旋转数组找给定值)

Wed, 05 Apr 2017 13:17:51 +0000

Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.

(i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).

leetcode 289. Game of Life (模拟)

Wed, 05 Apr 2017 12:03:28 +0000

According to the Wikipedia’s article: “The Game of Life, also known simply as Life, is a cellular automaton devised by the British mathematician John Horton Conway in 1970.”

Given a board with m by n cells, each cell has an initial state live (1) or dead (0). Each cell interacts with its eight neighbors (horizontal, vertical, diagonal) using the following four rules (taken from the above Wikipedia article):

leetcode 90. Subsets II (枚举子集)

Wed, 05 Apr 2017 10:45:02 +0000

Given a collection of integers that might contain duplicates, nums, return all possible subsets.

Note: The solution set must not contain duplicate subsets.

For example, If nums = [1,2,2], a solution is:

106. Construct Binary Tree from Inorder and Postorder Traversal(根据中序和后序遍历构建二叉树)

Wed, 05 Apr 2017 08:59:41 +0000

/* ***********************************************

 1Author :111qqz
 2Created Time :2017年04月05日 星期三 16时49分57秒
 3File Name :106.cpp
 4************************************************ */
 5/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
14class Solution {
15public:
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
int siz = inorder.size();
if (siz==0) return NULL;
int rt = postorder[siz-1];
int pos = -1;
for ( int i = 0 ; i < siz; i++)
{
if (inorder[i]==rt)
{
pos = i ;
break;
}
}
TreeNode *head = new TreeNode(rt);
vector<int>in,post;
for ( int i = 0 ; i < pos ; i++)
{
in.push_back(inorder[i]);
post.push_back(postorder[i]);
}
head->left = buildTree(in,post);
in.clear();
post.clear();
for ( int i = pos + 1 ; i < siz ; i++)
{
in.push_back(inorder[i]);
post.push_back(postorder[i-1]);
}
head->right = buildTree(in,post);
return head;
}
47};

leetcode 287. Find the Duplicate Number (floyd判圈算法找重复元素)

Wed, 05 Apr 2017 07:31:49 +0000

Given an array nums containing n + 1 integers where each integer is between 1 and n (inclusive), prove that at least one duplicate number must exist. Assume that there is only one duplicate number, find the duplicate one.

leetcode 532. K-diff Pairs in an Array （找差为k的数对）

Wed, 05 Apr 2017 06:53:02 +0000

Given an array of integers and an integer k, you need to find the number of unique k-diff pairs in the array. Here a k-diff pair is defined as an integer pair (i, j), where i and j are both numbers in the array and their absolute difference is k.

leetcode 448. Find All Numbers Disappeared in an Array(寻找所有消失的元素）

Wed, 05 Apr 2017 06:19:06 +0000

Given an array of integers where 1 ≤ a[i] ≤ n (n = size of array), some elements appear twice and others appear once.

Find all the elements of [1, n] inclusive that do not appear in this array.

今日头条2017秋招笔试_1

Thu, 30 Mar 2017 05:53:33 +0000

头条校招（今日头条2017秋招真题）

									题目描述

头条的2017校招开始了！为了这次校招，我们组织了一个规模宏大的出题团队。每个出题人都出了一些有趣的题目，而我们现在想把这些题目组合成若干场考试出来。在选题之前，我们对题目进行了盲审，并定出了每道题的难度系数。一场考试包含3道开放性题目，假设他们的难度从小到大分别为a, b, c，我们希望这3道题能满足下列条件：

今日头条笔试题-木棒拼图(数学)

Wed, 29 Mar 2017 13:27:24 +0000

有一个由很多木棒构成的集合，每个木棒有对应的长度，请问能否用集合中的这些木棒以某个顺序首尾相连构成一个面积大于 0 的简单多边形且所有木棒都要用上，简单多边形即不会自交的多边形。

今日头条笔试题-最大映射(贪心)

Wed, 29 Mar 2017 12:47:29 +0000

有 n 个字符串，每个字符串都是由 A-J 的大写字符构成。现在你将每个字符映射为一个 0-9 的数字，不同字符映射为不同的数字。这样每个字符串就可以看做一个整数，唯一的要求是这些整数必须是正整数且它们的字符串不能有前导零。现在问你怎样映射字符才能使得这些字符串表示的整数之和最大？
 输入描述:每组测试用例仅包含一组数据，每组数据第一行为一个正整数 n ， 接下来有 n 行，每行一个长度不超过 12 且仅包含大写字母 A-J 的字符串。 n 不大于 50，且至少存在一个字符不是任何字符串的首字母。
 输出描述:输出一个数，表示最大和是多少。
 输入例子:
 2
 ABC
 BCA
 输出例子:
 1875

一开始看漏了首位不能映射到0的条件…直接贪了..结果发现不太对…

京东实习面试总结

Sat, 18 Mar 2017 08:01:49 +0000

印象中是并没有看到jd，只是要求熟悉算法和数据结构+C艹…于是当时扔了份简历过去。

阿里面试算法题（转载）

Tue, 14 Mar 2017 06:28:42 +0000

I want to match those five numbers 3, 7, 8, 9, 87 through regular express.

 1Here is my thought:
 2
 3- match those four numbers `3 7 8 9` var `^[3|7|8|9]$`
 4- match number `87` var `^87$`
 5
 6Then combine them together, `(^[3|7|8|9]$|^87$)`. With some test, it seems correct. Is there any way to do that more efficiently?
 7
 8-------------------------------
 9
 10Q: 已知三个升序整数数组a[l], b[m]和c[n]。请在三个数组中各找一个元素，是的组成的三元组距离最小。
 11三元组的距离定义是：假设a[i]、b[j]和c[k]是一个三元组，那么距离为:
 12Distance = max(|a[i] – b[j]|, |a[i] – c[k]|, |b[j] – c[k]|)
 13请设计一个求最小三元组距离的最优算法，并分析时间复杂度。
 14
 15用三个指针分别指向a,b,c中最小的数，计算一次他们最大距离的Distance ，然后在移动三个数中较小的数组指针，
 16再计算一次，每次移动一个，直到其中一个数组结束为止，最慢(l+ m + n)次，复杂度为O(l+ m + n)
 17---------------------------------------------------------------------------------------------------------------------
 18Q:设计一个最优算法来查找一n个元素数组中的最大值和最小值。
 19已知一种需要比较2n次的方法，请给一个更优的算法。情特别注意优化时间复杂度的常数。
 20
 21把数组两两一对分组，如果数组元素个数为奇数，就最后单独分一个，然后分别对每一组的两个数比较，
 22把小的放在左边，大的放在右边，这样遍历下来，总共比较的次数是 N/2 次；在前面分组的基础上，那么可以得到结论，
 23最小值一定在每一组的左边部分找，最大值一定在数组的右边部分找，最大值和最小值的查找分别需要比较N/2 次和N/2 次；
 24这样就可以找到最大值和最小值了，比较的次数为
 25　　　　　　N/2 * 3 = (3N)/2 次
 26---------------------------------------------------------------------------------------------------------------------
 27Q:有N条鱼每条鱼的位置及大小均不同，他们沿着X轴游动，有的向左，有的向右。游动的速度是一样的，两条鱼相遇大鱼会吃掉小鱼。
 28从左到右给出每条鱼的大小和游动的方向（0表示向左，1表示向右）。问足够长的时间之后，能剩下多少条鱼？
 29
 30用一个栈
 31从左向右处理数据
 321)遇到向右的鱼，压栈；
 332)遇到向左的鱼，若栈空，结果+1；否则，将该鱼和栈顶比较，若栈顶鱼较大，则该鱼被吃掉，栈不变，处理下一个数据；
 34 若栈顶鱼小，则弹出栈顶，继续与下一个比较，直到遇到较大的鱼，该鱼被吃掉；或者栈里鱼都比该鱼小，栈清空，结果+1
 353)加上最终栈中鱼的数目
 36--------------------------------------------------------------------------------------------------------------------
 37Q: Taxicab numbers. A taxicab number is an integer that can be expressed as the sum of two cubes of
 38integers in two different ways: a^3+b^3=c^3+d^3. For example, 1729=9^3+10^3=1^3+12^3.
 39Design an algorithm to find all taxicab numbers with a, b, c, and d less than N.
 40 Version 1: Use time proportional to N2logN and space proportional to N2.
 41 Version 2: Use time proportional to N2logN and space proportional to N.
 42
 43Hints:
 44 Version 1: Form the sums a^3+b^3 and sort.
 45 Version 2: Use a min-oriented priority queue with N items.
 46--------------------------------------------------------------------------------------------------------------------
 47Q: 那地铁图 公交图查找，在实际的工程里用什么？
 48
 49 R树划分区域, 线段树确定方案
 50
 51Q: 德导航那个林志玲的声音，他不是让林志玲一条条的录的，合成过程中用了二分图的一个演化算法
 52
 53--------------------------------------------------------------------------------------------------------------------
 54Q:有一个链表，每一个节点除了next指针指向一下节点以外，
 55又多出了一个指针random，指向链表中的任何一个节点，包括null。请给出方法完成链表的深拷贝。
 56
 57这个问题的关键就在于random指针如何完成拷贝，next指针一次遍历就完成了，random指针拷贝的关键在于，
 58如何找到random指向的节点对应的新的节点。一般来讲，大家会想到用map来保存旧的节点到新的节点的映射，
 59这样得到的方法的时间复杂度为O(n)，空间复杂度为O(n)。
 60下面是一个可行的方法：oldlist为原始链表，copylist为新的链表，oldnode为oldlist中的节点，copynode为copylist中的节点：
 61	1. 根据oldlist，创建copylist，只拷贝next指针
 62	2. 保存oldnode到oldnode.next的映射
 63	3. 将oldlist中的oldnode的next指针指向copylist中对应的copynode
 64	4. 将copylist中的copynode的random指针指向oldlist中对应的oldnode
 65	5. 对于copylist中的每一个节点：copynode.random=copynode.random.random.next
 66	6. 根据第2步，建立的映射，恢复oldlist
 67
 68上面这个方法，需要额外的映射。下面介绍一个巧妙的方法，可以省去映射的部分
 69	1. 对oldlist中的节点，依次作如下的操作：对于第i个节点oldnode[i]，生成拷贝节点copynode[i]，
 70	并且插入在oldnode[i]和oldnode[i+1]之间，最后一个节点直接附加到oldlist后面即可。
 71	2. 处理每一个copynode的random拷贝，及对每一个copynode=oldnode.next, oldnode.next.random=oldnode.random.next
 72	后面的next确保是copynode。
 73	3. 通过如下的操作，恢复oldlist，以及生成copylist 1) oldnode.next = oldnode.next.next 2)
 74	copynode.next = copynode.next.next 这里要注意，oldnode的最后一个节点，next是null
 75---------------------------------------------------------------------------------------------------------------
 76Q:一个数组A，数字出现的情况，只有以下三种：
 77	1. 一些数字只出现一次
 78	2. 一些数字出现两次
 79	3. 只有一个数字出现三次
 80
 81请给出方法，找到出现三次的数字。
 82分析这个题目和“找数字”的题目比较相似，但是解法上类似么？之前的解法是检查某一位上的1的和，是否能够被3整除，
 83因为整数是32位的，可以开辟一个 32位大小的数组，这也是常数空间的。那么这个题目可以用这个方法来解决么？
 84因为有不确定个数的数字出现了一次，这样可以产生的余数的种类也就比较多了。 那该怎么处理呢？
 85hashmap的方法被称为万金油，在牺牲了空间的条件下，很好的达到了O(n)的时间复杂度。
 86如果要求常数空间的解法呢？之前的文章也有讨论，快排的时间复杂度是O(nlogn)，然后遍历一遍，找到连续三个相同的数字。
 87后面这一遍遍历，可以省去，因为出现三次的数字只有一个。但总的时间复杂度仍是O(nlogn)。
 88
 89是否还有其他的方法呢？有的同学给出了如下的方法：可以取得A中所有数字的乘积p，我们假设p没有溢出。
 90这是遍历数组中的每一个元素A[i]，查看 是否p % (A[i] * A[i] * A[i]) == 0，但此时，A[i]并不是最终要找到的数字，
 91还需要遍历数组A，查看A[i]是否出现了三次。但这个方法整体的时间复杂度为O(n^2)。
 92-------------------------------------------------------------------------------------------------------------------
 93Q: 有数组A={5,3,8,9,16}，第一次遍历有：A = {3-5,8-3,9-8,16-9}={-2,5,1,7}，数组中元素和为-2+5+1+7=11；\
 94第二次遍历有：A = {5-(-2),1-5,7-1}={7，-4,6}，元素和为9.给定数组A，求第n次遍历之后，数组中元素的和。
 95
 96处理这样的题目，如果没有直接知道相关的原理，可以自己走一下一些具体的例子，这样就可以发现一些规律，根据这些规律，
 97再去联想解决的完整方法。经过观察，我们可以发现：
 98	* 对于第k次遍历而言，x_k_1、x_k_2、...、x_k_m，sum = x_k_m - x_k_1
 99也就是说，第k次遍历结果的和，只与第一个和最后一个元素先关。下面，就来讨论，如何求得第一个和最后一个元素。
100我们看题目中的例子，先考虑第一个元素的变化
101	* 第一次遍历 k = 1时：-2=3-5
102	* 第二次遍历 k = 2时：7=5-(-2)=(8-3)-(3-5)=8-2*3+5
103	* 第三次遍历 k = 3时：-11=-4-7=(1-5)-(5-(-2)) = ((9-8)-(8-3)) - ((8-3)-(3-5))=9-3*8+3*3-5
104分析到此，想必大家已经能够明白这其中的规律，其实就是杨辉三角，老外叫帕斯卡三角。最后一个节点是类似的。
105而且，真个方法的时间复杂度与遍历的次数n有关，与数组的大小无关。
106-------------------------------------------------------------------------------------------------------------------
107Q:搜索引擎的查询提示(suggestion)是非常重要的一个功能。现在给定查询列表，以及每一个查询对应的频率。
108请设计一种查询提示的实现方案，要兼顾效果和速度。如果有其他更好的优化点，请给出详细说明。
109
110这个功能，在搜索引擎里是非常常用的。用户在逐个输入每一个查询词的时候，给出查询的提示，用户可以选择，完成查询的输入。
111这个过程，查询的提示必须要快。要不然，用户都输入完了，还没有提示，体验太差。那这个问题要怎么做呢？
112给定的查询日志是这样的：
113query1 num1
114query2 num2
115query3 num3
116…
117queryn numn
118
119具体的query可能是“薛蛮子”“郭敬明”等等。用户输入时，会有哪些状态呢？
120	* 薛
121	* 薛蛮
122	* 薛蛮子
123当用户输入完“薛”的时候，就要提示以“薛”开头的哪些查询，而且是查询频率最高的10个，一般是10个。
124这里是考虑总的查询的频率最高的10个，在实际的过程中，可以考虑当前热门的查询，可能总的次数比较少，
125但是近几天用户差得非常多，这样的查询也一定要能够提示。
126形式与目的我们都清楚了。具体做法也是比较多的，最直接的，容易想到trie树，因为上面列出的几种状态，就是前缀。
127那一棵前缀树，显然是最合适的。我们在这里，就不详细说明trie的结构，只给出如何应用trie树。trie树的构建：
128	* 对于所有查询，构建trie树，并且，对于查询结束的节点，进行标记，保存查询的频率。
129	* 由叶子节点开始向上，比如，叶子节点A，父节点为B，B存储top10的查询，包括：所有叶子节点代表的查询，以及，
130	如果B是查询结束节点，也包括B节点，按照频率排序的10个查询。
131	依次向上处理，父节点的top10，是所有子节点的top10合并而成。
132这样查询的时候，直接是对trie进行查询，到某一个节点，读取这个节点存储的top10查询即可，同时，这棵树，对于更新非常友好，
133可以新增频率，从叶子节点，回溯到根节点，即可。
134或者，采用trie树，不再节点存储top10查询，查询读取到可能类表之后再进行查询，这样会慢一些，但是内存开销稍微小一些。
135但，总的来说，trie树的内存开销是非常大的。那么，我们看下面的方法。
136一般，参与过搜索引擎的开发过程的，尤其是检索部分的同学，这个题目，第一个想法，可能不是trie树，而是倒排结构。
137总的来讲，应用倒排结构，有如下特点，也是和trie树进行对比：
138	* 查询快
139	* 方便压缩，节省内存
140	* 更新不方便，可以采用定期重建
141具体倒排的做法：
142	* 对于每一个查询的所有前缀，做为倒排的索引项，创建倒排
143	* 每一个倒排，只存储top10频率的查询
144除了上面介绍的之外，还需要考虑拼音等，思路大体相同。只不过更加需要注意内存的消耗。
145---------------------------------------------------------------------------------------------------------
146Q: 从1到n，n个数字，每个数字只出现一次。现在，随机拿走一个数字，请给出方法，找到这个数字。
147如果随机拿走两个数字呢？如果随机拿走k个数字呢？
148
149这个题目的含义是：n-1互不相同的整数，取值范围是[1,n]，请找到1-n中，没有出现的整数(好像更难理解了:))。
150当缺少一个数字的时候，很简单，计算1到n的和sum_more，然后再将n-1个整数求和，得到sum_less，
151则消失的数字就是(sum_more - sum_less)。
152如果消失两个数字呢？按照上面的方法，假设消失的两个数字分别为a和b，1 <= a, b <= n，
153我们可以得到a + b = sum_more - sum_less。只有一个等式，无法确定a和b的值是多少。根据我们以前学习解方程式的经验，
154我们还需要一个等式，才能确定a和b的值。现在已知的条件，就只有sum_more,sum_less，这两个分别是n个数的和，以及n-2个数的和，
155则最终还是要在这些数字的运算形式上做文章。考虑如下两个形式：
156	* square_sum_more = n个数的平方和
157	* square_sum_less = n-2个数的平方和
158有，square_sum_more - square_sum_less = a ^ 2 + b ^ 2。又构造了一个式子。这样解如下两个式子，得到a和b，即可：
159	* square_sum_more - square_sum_less = a ^ 2 + b ^ 2
160	* sum_more - sum_less = a + b
161解比较简单了，由第二个式子得：b = sum_more - sum_less - a，带入第一个式子，则第一个式子，只有a。
162如果消失三个数字呢？根据上面处理两个数字的情况，有如下的式子：
163	* sum_more - sum_less = a + b + c
164	* square_sum_more - square_sum_less = a ^ 2 + b ^ 2 + c ^ 2
165	* cube_sum_more - cube_sum_less = a ^ 3 + b ^ 3 + c ^ 3
166解出a，b，c即可。
167依次类推，当消失k个数字的时候，算法的时间复杂度为O(kn)。
168另外，微博上的一位同学@曹鹏博士，给出了一个O(nlogn)的解法，也是非常巧妙的，具体是采用分治法：
169知道1-n最低bit有多少个为0，多少个为1。然后统计一下，给出的数最低bit有多少个为0，多少个为1；
170然后就知道从最低bit为0的那部分取走了k0个数，从最低bit为1那部分取走了k1个数。 其中，k0 + k1 = k。
171然后把那些数按照最低bit为0，为1分开。问题变为两个子问题k0,k1，然后再考虑次低bit。很不错的解法。
172-----------------------------------------------------------------------------------------------------------------
173Q:给定一个数X，他的兄弟数Y定义为：是由X中的数字组合而成，并且Y是大于X的数中最小的。
174例如，38276的兄弟数字为38627。给定X，求Y。
175
176这个题目当然有暴力的方法，列出所有的排列组合，然后然后找到大于X中，最小的Y。即，找到兄弟数字。那有没有更好的方法呢？
177不想对所有情况进行穷举，就要想办法，尽可能缩小要处理的范围，一般的思路，从右边开始，两两交换，查看是否可以找到Y，
178最开始考虑两位，进而考虑三位，依次类推，那么如何确定，要考虑多少位呢？
179假设X的形式如下：x1x2x3...xky1y2y3y4，并且其中y1>y2>y3>y4，xk<y1。则，交换不可能在y1y2y3y4内部发生，
180以为这几个数字，任意两个交换，X值就变小了，而Y是大于X的。所以y1到y4是不行的。
181那么xk行么？完全可以，至少和y1交换，数字变大了。 那么到底要和哪个数字交换，进而保证变化最小呢？
182很显然，要找到y1到y4中，大于xk的值里，最小的一个。这个值交换之后，既保证了不会增加太多，也不会减少。
183假设就是y3，此时Y是x1x2x3...y3y1y2xky4,这个数是从y3那位开始，大于X的，无论后面的几位是什么。
184显然易见，最小的Y就是y1y2xky4要从小到大排序的。
185
186下面以一个具体例子来说明上述过程：
18734722641
188首先找到，从右边开始的递增的、尽可能长的数位，这里是641。
18934722(641)
190则，选取前一位数字2，进行交换。641中，大于2的最小的值是4，则作如下交换：
19134724(621)
192为了得到最小值，对621，从小到大进行排序，得到
19334724126
194则，Y为34724126.
195-------------------------------------------------------------------------------------------------------------
196Q:有n对喜鹊。每一对可以表示为(x,y)，x、y是喜鹊的编号，并且任意一对，x总是小于y。(c,d)可以连接在(a,b)之后，当且仅当b<c。
197多对喜鹊连接在一起，就构建成了鹊桥。给定n对喜鹊，请你构建最长的鹊桥，来帮助有情人相会。
198
199首先，要理解这个题目的意思。具体例子说明，给定下面的例子：
200(15,40)(5,8)(1,10)(30,31)(34,35)(9,20)(36,37)(2,4)其中，(2,4)和(5,8)能够连接起来，(5,8)和(9,20)能够连接起来，
201则它们可以都连接起来，为(2,4)(5,8)(9,20)。这一段鹊桥，长度为3。依次类推，还有其他的情况。
202然后，理解了题意，该如何解决呢？假设(a,b)(c,d)(e,f)是可以连接起来的三对喜鹊。
203则它们的关系如下： b<c,d<e，有根据a<b,c<d,e<f。得到，a<b<c<d<e<f，即b<d<f(从a<c<e出发考虑，也是一样的)。
204我们可以想象，以每一对喜鹊的第二只编号为基准，进行排序，最终的结果，可以通过如下列表产生。
205(2,4)(5,8)(1,10)(9,20)(30,31)(34,35)(36,37)(15,40)怎么找到最长的鹊桥呢？其实就是在上表中，找到最长递增子序列，
206只不过，在比较连个喜鹊对(a,b)(c,d)的时候，是b和c进行比较即可。这个时间复杂度是O(n^2)的。
207-----------------------------------------------------------------------------------------------------------------
208Q:n根长度不一的棍子，判断是否有三根棍子可以构成三角形，并且找到周长最长的三角形。
209
210首先能够构成三角形的三根棍子需要满足什么条件呢？这个简直就是常识了：
211最长棍子的长度 < 另外两根棍子的长度和
212这是重要条件。
213那么接下来该怎么办呢？暴力法——不要总觉得这是耻辱，要这样想：这是一个好开端。三条边，三层循环。时间复杂度为O(n^3)。
214这在一般的题目中，都是无法接受的。如何改进的呢？棍子有长有短，我们要找到的是周长最长的。
215我们可以对棍子的长度，从大到小排序。从最长的开始找符合构成三角形条件的。找到的第一个就是周长最长的。
216下面我们来说明，为什么第一个找到的，就是最长的。假设我们有如下长度的棍子，并且长度一次递减。
217abcdefg假设opq是第一个可以构成三角形的棍子，假设还存在xyz，构成三角形，且，x+y+z > o + p + q,
218因为opq是第一个三角形，则x<=o。则y+z > p+q，任取y、z，则可以找到，o，y，z为一个三角形，周长大于opq，
219并且，这个三角形，在opq之前找到(因为y或者z，大于p或者q，先遍历到)。这个与adf是第一个的假设是矛盾的。
220所以，不存在xyz构成三角形，周长大于adf。
221那么如果找到第一个能够构成三角形的三根棍子呢？现在棍子的长度已经是排序的。
222abcdefg很明显，我们只需要依次考虑，相邻三个元素是否能够构成三角形即可。因为，如果acd构成三角形，abc一定是，
223而且，周长还要更长。所以这里O(n)，就可以找到周长最长的三角形。前面排序是O(nlogn)。则，总的时间复杂度是O(nlogn).
224--------------------------------------------------------------------------------------------------------------------
225Q: 一个整数，可以表示为二进制的形式，请给出尽可能多的方法对二进制进行逆序操作。
226例如：10000110 11011000的逆序为 00011011 01100001
227
228A:
229直接的方法，很容易想到：有如下代码： int v = 111;
230int r = v;
231int s = 32;
232for (; 0 != v; v >>= 1) {
233 r <<= 1;
234 r |= v & 1;
235 s--;
236}
237r <<= s;
238System.out.println(r);
239代码比较好理解，取到v的最低位，作为r的最高位；v每取一次最低位，则右移一位；r每确定一位，则左移一位。
240同时记录移动了多少位，最终要补齐。
241
242通过查表的方法在遇到位操作的问题时，往往题目中限定了总的位数，比如这个题目，我们可以认为32位。
243这就给我们带来了一个以空间换时间的解决思路：查表法。
244位数是固定的，可以申请空间，存储预先计算好的结果，在计算其他的结果的时候，则查表即可。
24532位相对于查表来讲，还是太大了。既然这样缩小范围，32个bit，也就是4个byte。每个byte 8bit，可以表示0-255的整数。
246可以通过申请256大小的数组，保存这256个整数，二进制逆序之后的整数。然后将一个32位的整数，划分为4个byte，
247每一个byte查表得到逆序的整数：r1,r2,r3,r4。按照r4r3r2r1顺序拼接二进制得到的结果就是最终的答案。
248
249我们这里主要分析这个巧妙的方法，核心思想是：分治法。即：
250	* 逆序32位分解为两个逆序16位的
251	* 逆序16位分解为两个逆序8位的
252	* 逆序8位分解为两个逆序4位的
253	* 逆序4位分解为两个逆序2位的
254
255最后一个2位的逆序，直接交换即可。也就是分治递归的终止条件。但是，在上面的过程中，还没有应用到位操作的技巧
256。根据动态规划的思想，我们可以自底向上的解决这个问题：
257	* 每2位为一组，进行交换，完成2位逆序
258	* 每4位为一组，前面2位与后面2位交换，完成4位逆序
259	* 每8位为一组，前面4位和后面4为交换，完成8位的逆序
260	* 每16位为一组，前面8位和后面8位交换，完成16位的逆序
261	* 2组16位的交换，完成32位的逆序
262
263示例代码如下：
264int v = 111;
265v = ((v >> 1) & 0x55555555) | ((v & 0x55555555) << 1);
266v = ((v >> 2) & 0x33333333) | ((v & 0x33333333) << 2);
267v = ((v >> 4) & 0x0F0F0F0F) | ((v & 0x0F0F0F0F) << 4);
268v = ((v >> 8) & 0x00FF00FF) | ((v & 0x00FF00FF) << 8);
269v = ( v >> 16 ) | ( v << 16);
270------------------------------------------------------------------------------------------------------------------
271Q:输入数组[a1,a2,...,an,b1,b2,...,bn]，构造函数，使得输出为，[a1,b1,a2,b2,...,an,bn]，注意：方法要是in-place的。
272
273A:通过观察输入输出的格式，直接通过将b1进行交换，直至目标的位置，其他元素也如此操作。直到完成变换。如下的过程：
274a1 a2 a3 a4 b1 b2 b3 b4
275确定b1的位置，b1要和前面3个元素依次交换。
276a1b1a2a3a4b2b3b4
277确定b2的位置，b2要和前面的2个元素一次交换，同样为了保证in-place。注意交换次数少了一次。
278a1b1a2b2a3a4b3b4
279依次确定b3和b4的位置，b4是最后的元素，不需进行交换，b3需要交换一次。
280a1b1a2b2a3b3a4b4
281通过上面的分析，则整体的交换次数，3+2+1=6，不失一般性(n-1)+…+1，时间复杂度O(n^2)。
282
283特别的方法同样针对上面的例子：
284第一步：交换最中间的一对元素，得到
285a1a2a3b1a4b2b3b4
286第二步：交换最中间的两对元素，得到
287a1a2b1a3b2a4b3b4
288第三步：交换最中间的三对元素，得到
289a1b1a2b2a3b3a4b4
290完毕，得到结果。
291在上面的交换中，交换的次数分别为1,2,3，推而广之，1,…,n-1，则时间复杂度仍旧是O(n^2)的。
292
293in-place的O(n)方法这个问题，是存在O(n)时间复杂度的in-place算法的。但是，并不是很好理解。
294首先，对2n=3^k - 1的情况下，k是整数。这时候可以通过几个cyclic shift解决。
295每个cycle的起始位置是3^i, i=0,1,...,k-1. cycle里面元素下标的符合这样的模式(3^i×2^j) mod (2n+1)
296举例说明：k=2时，2n=8.
297假设一个数列是[1，2，3，4，5，6，7，8]
298那么这几个cycle是
299i=0, 3^i=1, [1,2,4,8,16,32] mod 9 = [1,2,4,8,7,5]
300i=1， 3^i=3, [3,6] mod 9 = [3,6]
301显然这些cycle都是闭合的，比如对[1,2,4,8,7,5]， 5×2 mod 9 = 1， 对[3,6] 6×2 mod 9 = 3
302
303下面做这两个cyclic shift
304做完第一个后：
305[1，2，3，4，5，6，7，8] -> [5，1，3，2，7，6，8，4]
306做完第二个后：
307[5，1，3，2，7，6，8，4] -> [5，1，6，2，7，3，8，4]
308搞定。
309
310其次对2n！=3^k - 1的情况下，找一个最大的m，m满足2m=3^k - 1并且m 比如假设n=6，那么m=4.
311假设一个素列A=[1，2，3，4，5，6，7，8，9，10，11，12]
312首先A[m+1,...,n+m]做一个距离为m的右循环。
313也就是[5,6,7,8,9,10]做一个距离为m的右循环，变成[7,8,9,10,5,6]
314做完这个循环，[1，2，3，4，5，6，7，8，9，10，11，12]->[1，2，3，4，7，8，9，10，5, 6, 11，12]
315然后对前2m项，做1的操作，[1，2，3，4，7，8，9，10，5, 6, 11，12]->[7，1，8，2，9，3，10，4，5, 6, 11，12]
316然后对于下的2*(n-m)项[5，6，11，12]递归操作。
317
318def getIndex(curIdx, N):
319	return (curIdx%2)*N + (curIdx/2)
320
321def convertArray(arr):
322	N = len(arr)/2
323	for curIdx in range(len(arr)):
324		swapIdx = getIndex(curIdx, N)
325		while swapIdx < curIdx:
326			swapIdx = getIndex(swapIdx, N)
327		arr[curIdx], arr[swapIdx] = arr[swapIdx], arr[curIdx]
328
329
330def convertArray_extraspace(arr):
331	N = len(arr)/2
332	return [arr[getIndex(i, N)] for i in range(len(arr))]
333
334def main():
335
336if __main__ == 'main'
337	main()

Q: n只蚂蚁以每秒1cm的速度在长为Lcm的竿子上爬行。蚂蚁爬到终点会掉下来。两只蚂蚁相遇时，只能调头爬回去。对于每一只蚂蚁i，给定其距离竿子左端的距离x[i]，但是我们不知道蚂蚁的初始朝向。计算，所有蚂蚁掉落需要的最短时间和最长时间。

O(1)得到最小值的栈

Sun, 12 Mar 2017 14:12:08 +0000

题意：定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数，要求时间复杂度为O(1)

求旋转数组最小值（二分）

Sun, 12 Mar 2017 13:19:16 +0000

题意：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。

用两个栈实现队列

Sat, 11 Mar 2017 12:52:58 +0000

思路：

一个元素入队的时候直接插入到stack1中。。。

一个元素出队的时候。。。如果stack2不为空。。stack2顶的元素就是要出队的。。