1、数组中重复的数组
在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知
道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例
如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。
思路：
依然从头到尾一次扫描这个数组中的每个数字。当扫描到下标为i的数字时，首先比较这个数字（用m表示）是不是等
于i。如果是，接着扫描下一个数字。如果不是，再拿它和第m个数字进行比较。
如果它和第m个数字相等，就找到了一个重复的数字（该数字在下标为i和m的位置都出现了）。如果它和第m个数
字不相等，就把第i个数字和第m个数字交换，把m放到属于它的位置。接下来再重读这个比较、交换的过程，直到
我们发现一个重复的数字。
代码：
public class Solution {
// Parameters:
// numbers: an array of integers
// length: the length of array numbers
// duplication: (Output) the duplicated number in the array number,length of duplication array is 1,so using duplication[0] = ? in implementation;
// Here duplication like pointor in C/C++, duplication[0] equal *duplication in C/C++
// 这里要特别注意~返回任意重复的一个，赋值duplication[0]
// Return value: true if the input is valid, and there are some duplications in the array number
// otherwise false
public boolean duplicate(int numbers[],int length,int [] duplication) {
boolean result = false;
if(length <= 0)
return result;
for(int i=0;i<length;i++){
while(i!=numbers[i]){
int temp = numbers[i];
if(numbers[i]== numbers[temp]){
duplication[0]=temp;
return true;
}
else{
int tempdata = numbers[i];
numbers[i] = numbers[temp];
numbers[temp] = tempdata;
}
}
}
return result;
}
}
1.1不修改数组找出重复的数字
思路一：将原数组复制，在复制的数组上使用第1题的思路。该方案需要O（n）的辅助空间。
思路二：可以考虑二分查找的思路：我们把1—n的数字从中间的数字m分为两部分，前面一半为1—m，后面一半为m+1—n。如果前面1—m部分的数字的数目超过m，那么这一部分一定包含重复的数字；否则，另一半m+1—n的部分必定包含重复数字。我们可以把包含重复数字的部分继续一分为二，直到找到一个重复的数字。
以题目中的长度为8的数组{2,3,5,4,3,2,6,7}为例：
根据题意，该数组中所有数字都在1—7之间，所以用来划分区间的界限数m为4，将其分为1—4和5—7两个部分。
然后统计1—4四个数字在数组中出现的次数，一共出现5次，所以1—4四个数字中，一定有一个以上的重复数字。
接着再把1—4划分为{1,2}，{3,4}两个部分，分别统计数字{1,2}和{3,4}出现的次数，前者两次，后者三次，所以，可以判断，3,4中一定有一个数重复了。
最后分别统计3和4在数组中出现次数，发现3出现了两次，所以找到了一个重复的数字3。
该解法的时间复杂度为O(nlogn)，但空间复杂度仅为O(1)，较之解法一，相当于是以时间换空间。
这种解法无法找出所有重复数字，因为[1,2]这个区间内有1,2两个数字，他们共出现了两次，但是1没有出现，2出现了两次，所以这里被默认为没有重复数字跳过了。
2、二维数组中的查找
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每
一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整
数，判断数组中是否含有该整数。
/* 思路
* 矩阵是有序的，从左下角来看，向上数字递减，向右数字递增，
* 因此从左下角开始查找，当要查找数字比左下角数字大时。右移
* 要查找数字比左下角数字小时，上移
*/
public class Solution {
public boolean Find(int target, int [][] array) {
int rowCount = array.length;
int listCount = array[0].length;
int i,j;
for(i=rowCount-1,j=0;j<listCount && i>=0;){
if(target == array[i][j])
{return true;}
else if(target > array[i][j])
{j++;}
else
{i--;}
}
return false;
}
}
3、替换空格
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为
We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
Step1.先遍历一次字符串，这样就能统计出字符串中空格的总数，并可以由此计算出替换之后
的字符串的总长度。以前面的字符串"We arehappy."为例，"We are happy."这个字符串的长度
是14（包括结尾符号’\0’），里面有两个空格，因此替换之后字符串的长度是18。
Step2.从字符串的后面开始复制和替换。准备两个指针，P1和P2。P1指向原始字符串的末
尾，而P2指向替换之后的字符串的末尾。接下来向前移动指针P1，逐个把它指向的字符复制
到P2指向的位置，直到碰到第一个空格为止。接着向前复制，直到碰到第二、三或第n个空格。
从上面的分析我们可以看出，所有的字符都只复制（移动）一次，因此这个算法的时间效率是O(n)
public class Solution {
public String replaceSpace(StringBuffer str) {
int keyCount = 0;//空格数量
int strAfterLength;//改变后的str的长度
int proTemp,afterTemp;
if(str.length() == 0)
return str.toString(); //要注意stringBuffer不能转换为str
for(int i=0;i<str.length();i++)
if(' ' == str.charAt(i))
keyCount++;
strAfterLength = str.length() + 2*keyCount;
proTemp = str.length() - 1;
str.setLength(strAfterLength);
afterTemp = strAfterLength - 1;
System.out.println(str.charAt(proTemp));
for(;proTemp>=0 && afterTemp!=proTemp ;proTemp--,afterTemp--){
if(str.charAt(proTemp) == ' '){
str.setCharAt(afterTemp--,'0');
str.setCharAt(afterTemp--,'2');
str.setCharAt(afterTemp,'%');
}
else
str.setCharAt(afterTemp,str.charAt(proTemp));
}
System.out.println(str);
return str.toString();
}
}
3.1合并两个数组
在合并两个数组（包括字符串）时，如果从前往后复制每个数字，则需要重复移动数组多次，所以我们可以考虑从后往前赋值，这样能减少移动的次数。
4、输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
可以用栈来实现
/**
* public class ListNode {
* int val;
* ListNode next = null;
*
* ListNode(int val) {
* this.val = val;
* }
* }
*
*/
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
Stack<Integer> stack = new Stack<Integer>();
while(listNode != null){
stack.push(listNode.val);
listNode = listNode.next;
}
ArrayList<Integer> arrayList = new ArrayList<Integer>();
while(!stack.empty()){
arrayList.add(stack.pop());
}
return arrayList;
}
}
5、重建二叉树
题目：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回
思路：前序遍历的第一个遍历是根，找到中序中的根所在的位置loc；在中序遍历中，在loc之前的是左子树，之后的是右子树（中序遍历的性质），递归的去重建左子树和右子树。
/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
if(pre.length<=0 || in.length<=0 || pre.length != in.length)
return null;
int preStart = 0,preEnd = pre.length -1,inStart=0,inEnd=in.length-1;
TreeNode root = reConstructBinaryTree(pre, preStart, preEnd, in, inStart, inEnd);
return root;
}
public TreeNode reConstructBinaryTree(int[] pre, int preStart,int preEnd,int[] in,int inStart, int inEnd){
if(preStart>preEnd || inStart>inEnd)
return null;
TreeNode root = new TreeNode(pre[preStart]);
int i;
for(i=inStart;i<=inEnd;i++){
if(pre[preStart] == in[i]){
break;
}
}
root.left = reConstructBinaryTree(pre, preStart+1, preStart+i-inStart, in, inStart, i-1);
root.right = reConstructBinaryTree(pre, preStart+i-inStart+1, preEnd, in, i+1, inEnd);
return root;
}
}
6、二叉树的下一个节点
给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
思路：
假设需要查找 node 结点的下一个结点，需要考虑三种情况：
①node 节点有右孩子
下一个结点就是以node结点的右孩子为根的子树中的最左下结点。
②node 节点没有右孩子时，node节点是其父结点的左孩子。
则下一个节点就是node结点的父节点
③node 节点没有右孩子时，node节点是其父结点的右孩子
我们可以沿着父节点的指针一直向上遍历，直到找到一个是它父节点的左孩子的结点。如果这样的结点存在，那么这个节点的父节点就是我们要找的下一个节点。
/*
public class TreeLinkNode {
int val;
TreeLinkNode left = null;
TreeLinkNode right = null;
TreeLinkNode next = null;
TreeLinkNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public TreeLinkNode GetNext(TreeLinkNode pNode)
{
if(pNode.right != null){
TreeLinkNode tempnode = pNode.right;
while(tempnode.left !=null)
tempnode = tempnode.left;
return tempnode;
}
else{
if(pNode.next == null)
return null;
else if(pNode == pNode.next.left)
return pNode.next;
else if(pNode == pNode.next.right){
if(pNode.next.next == null)
return null;
else{
TreeLinkNode tempnode = pNode.next;
while(tempnode!=tempnode.next.left){
if(tempnode.next == null)
return null;
if(tempnode.next.next == null)
return null;
tempnode =tempnode.next;
}
return tempnode.next;
}
}
else
return null;
}
}
}
7、用两个栈实现队列
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
思路：
用两个栈实现一个队列的功能?要求给出算法和思路!
<分析>：
入队：将元素进栈A
出队：判断栈B是否为空，如果为空，则将栈A中所有元素pop，并push进栈B，栈B出栈；
如果不为空，栈B直接出栈。
用两个队列实现一个栈的功能?要求给出算法和思路!
<分析>：
入栈：将元素进队列A
出栈：判断队列A中元素的个数是否为1，如果等于1，则出队列，否则将队列A中的元素 以此出队列并放入队列B，直到队列A中的元素留下一个，然后队列A出队列，再把 队列B中的元素出队列以此放入队列A中。
import java.util.Stack;
public class Solution {
Stack<Integer> stack1 = new Stack<Integer>();
Stack<Integer> stack2 = new Stack<Integer>();
public void push(int node) {
stack1.push(node);
}
public int pop() {
while(stack2.empty()){
while(!stack1.empty()){
int i = stack1.pop();
stack2.push(i);
}
}
return stack2.pop();
}
}
8、菲波那切数列
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。n<=39
思路：递归太费时间，用循环
public class Solution {
public int Fibonacci(int n) {
int i,pre,ppre,temp=0;
pre=1;
ppre=0;
if(n==0)
return 0;
else if(n==1)
return 1;
else{
for(i=2;i<=n;i++){
temp=pre+ppre;
ppre=pre;
pre=temp;
}
return temp;
}
}
}
9、青蛙跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
public class Solution {
public int JumpFloor(int target) {
if(target == 1 || target == 2)
return target;
else{
int count=0;
for(int i = 3,pre=2,ppre=1; i<=target; i++){
count = pre+ppre;
ppre = pre;
pre = count;
}
return count;
}
}
}
10、变态跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
思路：
分析出递归条件：
我们用f(n)来表示跳n级台阶的跳法数量，
f(1)=1表示跳1级台阶的跳法数量;
f(2)=2表示跳2级台阶的跳法数量;
f(3)=f(2)+f(1)+1 我们可以递推出 f(n)=f(n-1)+f(n-2)+ ……+f(1)+1 ,
而f(n-1)=f(n-2)+ …… +f(1)+1。
将两式想减可以求出递推公式，也即是 f(n)-f(n-1)=f(n-1)，即f(n)=2*f(n-1); 所以自底向上的动态规划方法浮出眼前。
即：
| 1 ,(n=0 )
f(n) = | 1 ,(n=1 )
| 2*f(n-1),(n>=2)
递归方法：
public class Solution {
public int JumpFloorII(int target) {
if (target <= 0) {
return -1;
} else if (target == 1) {
return 1;
} else {
return 2 * JumpFloorII(target - 1);
}
}
}
循环方法：
import java.util.ArrayList;
public class Solution {
public int JumpFloorII(int target) {
if (target == 1 || target == 2)
return target;
else {
ArrayList<Integer> count = new ArrayList<Integer>();
count.add(1);
count.add(2);
for(int i=2;i<=target-1;i++){
int tempj=0;
for(int j=0;j<i;j++){
tempj = tempj+count.get(j);
}
count.add(tempj+1);
}
return count.get(target-1);
}
}
}
11、旋转数组的最小数字
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
思路：
旋转之后的数组实际上可以划分成两个有序的子数组：前面子数组的大小都大于后面子数组中的元素
注意到实际上最小的元素就是两个子数组的分界线。本题目给出的数组一定程度上是排序的，因此我们试着用二分查找法寻找这个最小的元素。
思路：
（1）我们用两个指针left,right分别指向数组的第一个元素和最后一个元素。按照题目的旋转的规则，第一个元素应该是大于最后一个元素的（没有重复的元素）。
但是如果不是旋转，第一个元素肯定小于最后一个元素。
（2）找到数组的中间元素。
中间元素大于第一个元素，则中间元素位于前面的递增子数组，此时最小元素位于中间元素的后面。我们可以让第一个指针left指向中间元素。
移动之后，第一个指针仍然位于前面的递增数组中。
中间元素小于第一个元素，则中间元素位于后面的递增子数组，此时最小元素位于中间元素的前面。我们可以让第二个指针right指向中间元素。
移动之后，第二个指针仍然位于后面的递增数组中。
这样可以缩小寻找的范围。
（3）按照以上思路，第一个指针left总是指向前面递增数组的元素，第二个指针right总是指向后面递增的数组元素。
最终第一个指针将指向前面数组的最后一个元素，第二个指针指向后面数组中的第一个元素。
也就是说他们将指向两个相邻的元素，而第二个指针指向的刚好是最小的元素，这就是循环的结束条件。
到目前为止以上思路很耗的解决了没有重复数字的情况，这一道题目添加上了这一要求，有了重复数字。
因此这一道题目比上一道题目多了些特殊情况：
我们看一组例子：｛1，0，1，1，1｝ 和 ｛1，1， 1，0，1｝ 都可以看成是递增排序数组｛0，1，1，1，1｝的旋转。
这种情况下我们无法继续用上一道题目的解法，去解决这道题目。因为在这两个数组中，第一个数字，最后一个数字，中间数字都是1。
第一种情况下，中间数字位于后面的子数组，第二种情况，中间数字位于前面的子数组。
因此当两个指针指向的数字和中间数字相同的时候，我们无法确定中间数字1是属于前面的子数组（绿色表示）还是属于后面的子数组（紫色表示）。
也就无法移动指针来缩小查找的范围，只能进行数组遍历。
#include <iostream>
#include <vector>
#include <string>
#include <stack>
#include <algorithm>
using namespace std;
class Solution {
public:
int minNumberInRotateArray(vector<int> rotateArray) {
int size = rotateArray.size();
if(size == 0){
return 0;
}//if
int left = 0,right = size - 1;
int mid = 0;
// rotateArray[left] >= rotateArray[right] 确保旋转
while(rotateArray[left] >= rotateArray[right]){
// 分界点
if(right - left == 1){
mid = right;
break;
}//if
mid = left + (right - left) / 2;
// rotateArray[left] rotateArray[right] rotateArray[mid]三者相等
// 无法确定中间元素是属于前面还是后面的递增子数组
// 只能顺序查找
if(rotateArray[left] == rotateArray[right] && rotateArray[left] == rotateArray[mid]){
return MinOrder(rotateArray,left,right);
}//if
// 中间元素位于前面的递增子数组
// 此时最小元素位于中间元素的后面
if(rotateArray[mid] >= rotateArray[left]){
left = mid;
}//if
// 中间元素位于后面的递增子数组
// 此时最小元素位于中间元素的前面
else{
right = mid;
}//else
}//while
return rotateArray[mid];
}
private:
// 顺序寻找最小值
int MinOrder(vector<int> &num,int left,int right){
int result = num[left];
for(int i = left + 1;i < right;++i){
if(num[i] < result){
result = num[i];
}//if
}//for
return result;
}
};
int main(){
Solution s;
//vector<int> num = {0,1,2,3,4,5};
//vector<int> num = {4,5,6,7,1,2,3};
vector<int> num = {2,2,2,2,1,2};
int result = s.minNumberInRotateArray(num);
// 输出
cout<<result<<endl;
return 0;
}
12、矩阵中的路径
请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则之后不能再次进入这个格子。 例如 a b c e s f c s a d e e 这样的3 X 4 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。
思路：
首先，遍历这个矩阵，我们很容易就能找到与字符串str中第一个字符相同的矩阵元素ch。然后遍历ch的上下左右四个字符，如果有和字符串str中下一个字符相同的，就把那个字符当作下一个字符（下一次遍历的起点），如果没有，就需要回退到上一个字符，然后重新遍历。为了避免路径重叠，需要一个辅助矩阵来记录路径情况。
public class Solution {
public boolean hasPath(char[] matrix, int rows, int cols, char[] str)
{
boolean result = false;
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
boolean[][] visited = new boolean[rows][cols];
if (hasPathSegment(matrix, rows, cols, i, j, str, visited, 0))
return true;
}
}
return result;
}
//i,j是目前元素是第i行第j列.
//k是需要匹配的字符在str中的位置
public boolean hasPathSegment(char[] matrix, int rows, int cols, int i, int j, char[] str, boolean[][] visited,
int k) {
boolean result = false;
int count = i * cols + j;
if (i < rows && i > -1 && j < cols && j > -1 && (!visited[i][j]) && (matrix[count] == str[k])) {
visited[i][j] = true;
if (k == str.length - 1)
return true;
else if (hasPathSegment(matrix, rows, cols, i - 1, j, str, visited, k + 1)
|| hasPathSegment(matrix, rows, cols, i + 1, j, str, visited, k + 1)
|| hasPathSegment(matrix, rows, cols, i, j + 1, str, visited, k + 1)
|| hasPathSegment(matrix, rows, cols, i, j - 1, str, visited, k + 1))
return true;
visited[i][j]=false;
}
return result;
}
}
13、机器人的运动范围
地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？
思路：
本题使用的方法同样还是回溯法，另外还需要会计算给定整数上的各个位上数之和。
使用一个访问数组记录是否已经经过该格子。
机器人从(0,0)开始移动，当它准备进入(i,j)的格子时，通过检查坐标的数位来判断机器人是否能够进入。
如果机器人能进入(i,j)的格子，接着在判断它是否能进入四个相邻的格子(i,j-1),(i,j+1),(i-1,j),(i+1,j)。
因此，可以用回溯法来解决这一问题。
public class Solution {
public int movingCount(int threshold, int rows, int cols)
{
boolean[][] visited = new boolean[rows][cols];
int count = DoMovingCount(threshold, rows, cols, 0, 0, visited);
return count;
}
public int DoMovingCount(int threshold, int rows, int cols,int i,int j,boolean[][] visited){
int count=0;
if(i>=rows || i<0 || j>=cols ||j<0||visited[i][j])
return count;
if((sumCount(i)+sumCount(j)<=threshold)){
visited[i][j]=true;
count = 1+DoMovingCount(threshold, rows, cols, i-1, j, visited)
+DoMovingCount(threshold, rows, cols, i, j+1, visited)
+DoMovingCount(threshold, rows, cols, i+1, j, visited)
+DoMovingCount(threshold, rows, cols, i, j-1, visited);
}
return count;
}
public int sumCount(int number) {
int sum = 0;
while (number != 0) {
sum = sum + number % 10;
number = number / 10;
}
return sum;
}
}
14、剪绳子问题
给定一根长度为n的绳子，请把绳子剪成m段，每段绳子记为k[0],k[1]……k[m]。请问k[0]*k[1]……*k[m]可能的最大乘积是多少？例如：当绳子长度为8时，我们把它剪成长度分别为2,3,3段，此时最大乘积为18.
思路：
我们先考虑能否把大问题分解成小问题，分解后的小问题也存在最优解，如果把小问题的最优解组合起来能否是整个问题的最优解，这就是动态规划求解。我们把绳子从第i（i<n）处的位置开始剪，把长度分为i和n-i，要得到最优解用同样的方法把长度为i和n-i的两段分别剪成若干段。在这里用动态规划是因为：在分解问题的时候，子问题会在分解的过程中重复出现，如，长度为10的绳子剪成长度为4和6两段，即f(4)和f(6)，分别再求两个子问题把4剪成均为2的两段f(2)和f(2)，把6剪成两段2和4，即f(2)和f(4)，这时f(2)是f(4)和f(6)公用的更小子问题，这时用动态规划从上往下分析问题，从下往上解决问题。空间复杂度为O(n),时间复杂度为O(n^2)
public static int maxProductAfterCutting(int len){
if(len<2)
return 0;
if(len==2)
return 1;
if(len==3)
return 2;
//存储长度从 0-len 的最大结果
int[] result=new int[len+1];
result[0]=0;
result[1]=1;
result[2]=2;
result[3]=3;
//自底向上开始求解
int max=0;
for(int i=4;i<=len;i++){
max=0;
for(int j=1;j<=i/2;j++){
int tempResult=result[j]*result[i-j];
if(max<tempResult)
max=tempResult;
result[i]=max;
}
}
max=result[len];
return max;
}
15、二进制中1的个数
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
思路：
先判断二进制中最右边是不是1，接着把输入的整数右移一位，此时原来处于从右边数的第二位被移到了最右边了，在判断是不是1；一直这样移动，直到整个整数变成0为止。
public class Solution {
public int NumberOf1(int n) {
int count = 0;
while(n!=0){
if((n&1)!=0)
count++;
n=n>>>1;
}
return count;
}
}
15.1用一条语句判断一个整数是不是2的整数次方。
如果一个整数是2的整数次方，那么它的二进制表示中只有一位是1，二其他所有位都是0。根据分析可以知道，把这个整数减去1之后再和他自己做与运算，这个整数中唯一的1就会变成0。
即（n-1）&n如果为0，则n是2的整数次方。
int judge(int num)
{
return !(num&(num-1));
}
15.2输入两个整数m和n，计算需要改变m的二进制表示中的多少位才能得到n？
解：第一步求这两个数的异或运算，将异或运算结果存起来；第二步统计这个运算结果当中1的位数
15.3注意，把一个整数减去1之后再和原来的整数做位运算，得到的结果相当于把整数的二进制表示中最右边的1变成了0。很多二进制的问题可以用这种思路解决。
534
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
