2016小米校招笔试题

1 给定一些线段，线段有起点和终点，求这些线段的覆盖长度，重复的部分只计算一次。

  

方法一：

首先说排序对于处理很多问题都是非常有效的，例如寻找兄弟单词等问题中，经过排序处理后，问题就明朗了很多；

线段覆盖长度也是这样，将线段排序后，然后扫描一遍就可以得到覆盖的长度。具体做法：排序时，先按线段的起始端点排序，如果始点相同则按照末端点排，然后从头扫描，寻找连续段；所谓连续段即下一条线段的始点不大于当前线段的末点就一直扫描，直到找到断层的，计算当前长度，然后继续重复扫描直到最后，便得总长度。代码如下：

#include<iostream>
using namespace std;

/* 排序求线段覆盖长度 */
#define MAXN 100   // 设线段数不超过100

struct segment
{
	int start;
	int end;
}segArr[100];

/* 计算线段覆盖长度 */
int lenCount(segment * segArr, int size)
{
	int length = 0, start = 0, end = 0;
	for(int i = 0; i < size; ++i)
	{
		start = segArr[i].start;
		end = segArr[i].end;
		while(end >= segArr[i+1].start)
		{
			++i;
			end = segArr[i].end > end ? segArr[i].end : end;
		}
		length += (end - start);
	}
	return length;
}

/* 快排比较函数 */
int cmp(const void * p, const void *q)
{
	if(((segment *)p)->start != ((segment *)q)->start)
	{
		return ((segment *)p)->start - ((segment *)q)->start;
	}
	return ((segment *)p)->end - ((segment *)q)->end;
}

/* 测试线段 answer: 71 */
int segTest[10][2] = {{5, 8},{10, 45},{0, 7},{2, 3}，{3, 9}，{13, 26},
   {15, 38}, {50, 67},{39, 42},{70, 80}};

void main()
{
	for(int i = 0; i < 10; ++i)           // 测试线段
	{
		segArr[i].start = segTest[i][0];
		segArr[i].end = segTest[i][1];
	}
	qsort(segArr,10,sizeof(segment),cmp);       // 排序
	printf("length: %d\n",lenCount(segArr,10)); // 计算
}

方法二：

线段树的经典应用就是求线段覆盖长度，线段树本身的数据结构很简单，关键在于怎么用，线段结构如何设计，查询、更新等操作如何具体问题具体处理。对于本题，在插入线段的时候，标记覆盖，之后统计总长度便可。代码如下：

#include<iostream>
using namespace std;

/* 线段树求线段覆盖长度 */
#define BORDER 100  // 设线段端点坐标不超过100

struct Node         // 线段树
{
	int left;
	int right;
	int isCover;    // 标记是否被覆盖
}segTree[4*BORDER];

/* 构建线段树 根节点开始构建区间[lef,rig]的线段树*/
void construct(int index, int lef, int rig)
{
	segTree[index].left = lef;
	segTree[index].right = rig;
	if(rig - 1 == lef)                 // 到单位1线段
	{
		segTree[index].isCover = 0;
		return;
	}
	int mid = (lef+rig) >> 1;
	construct((index<<1)+1, lef, mid);
	construct((index<<1)+2, mid, rig); // 非mid+1，线段覆盖[mid,mid+1]
	segTree[index].isCover = 0;
}

/* 插入线段[start,end]到线段树, 同时标记覆盖 */
void insert(int index, int start, int end)
{
	if(segTree[index].isCover == 1)	return; // 如已覆盖，没必要继续向下插

	if(segTree[index].left == start && segTree[index].right == end)
	{
		segTree[index].isCover = 1;
		return;
	}
	int mid = (segTree[index].left + segTree[index].right) >> 1;
	if(end <= mid)
	{
		insert((index<<1)+1, start, end);
	}else if(start >= mid)             
	{
		insert((index<<1)+2, start, end);
	}else
	{
		insert((index<<1)+1, start, mid);
		insert((index<<1)+2, mid, end);
		// 注：不是mid+1，线段覆盖，不能漏[mid,mid+1]
	}
}

/* 计算线段覆盖长度 */
int Count(int index)
{
	if(segTree[index].isCover == 1)
	{
		return segTree[index].right - segTree[index].left;
	}else if(segTree[index].right - segTree[index].left == 1)
	{
		return 0;
	}
	return Count((index<<1)+1) + Count((index<<1)+2);
}

/* 测试线段 answer: 71 */
int segment[10][2] = {
	{5, 8},	{10, 45}，{0, 7},{2, 3},	 {3, 9}，{13, 26},
   {15, 38},  {50, 67},	{39, 42},{70, 80}};

void main()
{
	construct(0,0,100);           // 构建[0,100]线段树
	for(int i = 0; i < 10; ++i)   // 插入测试线段
	{
		insert(0,segment[i][0],segment[i][1]);
	}
	printf("the cover length is %d\n", Count(0));
}

基于排序的方法，由于排序的缘故，复杂度为O(nlgn)；使用线段树时，因其查询和插入操作都可以在lgn的时间完成，故对于所有线段完成插入，最后查询长度，算法总的复杂度也是O(nlgn)级别。

2 旋转数组中查找某值的下标。二分查找。

#include <iostream>
using namespace std;

int search(int A[], int n, int target) {
    int first = 0,last = n-1;
    while(first <= last)
    {
      int mid = first + (last - first)/2;
      if(A[mid] == target)
        return mid;
      if(A[first] < A[mid])
      {
        if(A[first] <= target && target<A[mid])
          last = mid -1;
        else
          first = mid+1;
      }
      else if(A[first] > A[mid])
      {
        if(A[mid] < target && target <= A[last])
          first = mid+1;
        else
          last = mid-1;
      }
      else
         first++;
    }
    return -1;
    }

    int main(int argc,char* argv[])
    {
        int arr[] = {4,5,6,7,0,1,2};
        int len = 7;
        int target = 1;
        int index = search(arr,len,target);
        cout << index <<endl;
    }

3 问题描述：

假如已知有n个人和m对好友关系（存于数字r）。如果两个人是直接或间接的好友（好友的好友的好友...），

则认为他们属于同一个朋友圈，

请写程序求出这n个人里一共有多少个朋友圈。

假如：n = 5， m = 3， r = {{1 , 2} , {2 , 3} ,{4 , 5}}，表示有5个人，1和2是好友，2和3是好友，4和5是好友，

则1、2、3属于一个朋友圈，4、5属于另一个朋友圈，结果为2个朋友圈。

最后请分析所写代码的时间、空间复杂度。评分会参考代码的正确性和效率。

使用并查集解决，代码如下：

//朋友圈问题

#include <iostream>
using namespace std;

int set[10001];
//带路径优化的并查集查找算法
inline int find(int x)             
{  
	int i,j,r; 
	r = x;  
	while(set[r] != r)   
	{
		r = set[r];  
	}
	i = x;
	while(i != r)
	{
		j = set[i];
		set[i] = r;
		i = j;
	}  
	return r;  
} 
//优化的并查集归并算法
inline void merge(int x, int y)       
{  
    int t = find(x);  
    int h = find(y);  
    if(t < h)  
	{
		set[h] = t;  
	}
    else  
	{
		set[t] = h;  
	}
}

int friends(int n , int m , int r[][2])  
{  
    int i , count;  
	//初始化并查集，各点为孤立点，分支数为n
    for(i = 1 ; i <= n ; ++i)       
	{
		set[i] = i;  
	}
    for(i = 0 ; i < m ; ++i)  
	{
		merge(r[i][0] , r[i][1]);  
	}
    for(i = 1 ; i <= n ; ++i)       
	{
		cout << set[i] <<" ";  
	}
    count = 0;  
    for(i = 1 ; i <= n ; ++i)  
    {  
        if(set[i] == i)  
		{
			++count;  
		}
    }  
    return count;  
}

void main()
{
	int n=5;
	int m=3;
	int a[][2]={{1,2},{2,3},{4,5}};
	cout << friends(n,m,a) <<endl;
}<strong>
</strong>

并查集介绍参考： http://blog.csdn.net/dm_vincent/article/details/7655764