9/29-10/6待字闺中面试题练习

题目来自陈利人的微博：http://weibo.com/p/1005051915548291

2013/9/29

给定两个字符串A和B，判断A中是否包含由B中字符重新排列成的新字符串。例如：A=abcdef, B=ba，结果应该返回true。因为ba的排列ab，是A的子串。

HANDWRITING:

想法是记录B字符串的各个字符个数，然后在A中找满足各字符个数与B相同的子串，在找子串的过程中保持一个BLEN的长度检查。时间复杂度O(alen)。

bool substring (char *a, char *b) {
	int amap[256] = {0}, bmap[256] = {0}, blen = 0, alen = strlen(a), count = 0;
	while (*b != '\0') ++map[*b], ++blen;
	char *fast = a, *slow = a;
	for (int i = 0; i < alen; ++i, ++fast) {
		if (bmap[*fast] == 0) continue;
		++amap[*fast];
		++count;
	}
	while (fast != '\0') {
		if (count == blen) return true;
		if (amap[*slow]  > 0) --amap[*slow], --count;
		++fast; ++slow;
		if (bmap[*fast] > 0) ++amap[*fast], ++count; 
	}
	return false;
}

CORRECTION：

1、最直接的结果是程序跑不出结果，在计算B字符串长度时，*b指针没有后移

2、当A字符串包含的字符大于B字符串的数量时，应不计count

3、保持的是blen长度的子字符串，而非alen

4、while循环中应是*fast，一个字符

详细解释：

题意转换一下就是要在A中找到符合的子串，使得这个子串各字符个数和B的一样，例如：A=aaaabceeef, B=baac，即找到一个子串有2个a，1个b，1个f。

那么我们首先遍历B字符串，得到一个字符表bmap，其中a 2，b 1，c 0，d 0，e 0，f 1，B的长度blen为4。

接下来就是要在A中找符合的字符串，因为B的长度为4，所以初始状态为A的前4个字符aaaa，fast指向最后一个a，slow指向第一个a，这样的amap表为a 4，b 0，c 0，d 0，e 0，f 0。

这个子串中a的个数多于B，amap中计a为4个，但是我们count只计2个，这时count小于blen，不满足条件，继续后移。

slow向后移动一位，退出了一个a，amap中a的计数减少1，因为amap中的a个数大于bmap，所以这个a不能算是一个有效的count，这时count不变。fast向后移动一位，加入了一个b，这个b为一个有效的count，这时count加1，amap中b的计数也加1，变为a 3，b 1，c 0，d 0，e 0，f 0。

slow再向后移动一位，退出一个a，amap中a的计数减少1，因为amap中的a个数还是大于bmap，所以这个a不能算是一个有效的count，这时count不变。fast向后移动一位，加入了一个c，这个c为一个有效的count，这时count加1，amap中c的计数也加1，变为a 2，b 1，c 1，d 0，e 0，f 0。这时count为4，等于blen，所以返回true。

bool substring (char *a, char *b) {
	int amap[256] = {0}, bmap[256] = {0}, blen = 0, alen = strlen(a), count = 0;
	while (*b != '\0') ++bmap[*b], ++blen, ++b;
	if (blen > alen) return false;
	char *fast = a, *slow = a;
	for (int i = 0; i < blen; ++i, ++fast) {
		if (bmap[*fast] == 0) continue;
		++amap[*fast];
		if (amap[*fast] <= bmap[*fast]) ++count;
	}
	while (*fast != '\0') {
		if (count == blen) return true;
		if (amap[*slow] > bmap[*slow]) --amap[*slow];
		else if (amap[*slow]  > 0) --amap[*slow], --count;
		if (amap[*fast] >= bmap[*fast]) ++amap[*fast];
		else if (bmap[*fast] > 0) ++amap[*fast], ++count; 
		++fast; ++slow;
	}
	return false;
}

2013/9/30

从一个长字符串中查找包含给定字符集合的最短子串。例如，长串为“aaaaaaaaaacbebbbbbdddddddcccccc”，字符集为{abcd}，那么最短子串是“acbebbbbbd”。

HANDWRITING:

想法是先找到一个满足条件的子串，用2个指针表示，然后右移左指针，直到不满足条件，右移右指针，直到再次满足条件，期间记录下满足条件的最短的子串，假定A中必定有符合B的子串。时间复杂度O(alen)。

char *substring (char *a, char *b, char *r) {
	int amap[256] = {0}, bmap[256] = {0}, blen = 0, alen = strlen(a), count = 0, min = alen;
	while (*b != '\0') ++bmap[*b], ++blen, ++b;
	char *fast = a, *slow = a, *pre, *next, *result = r;
	while (*fast != '\0') {
		if (count != blen) {
			if (bmap[*fast] == 0) { ++fast; continue; }
			if (amap[*fast] < bmap[*fast]) ++count;
			++amap[*fast]; ++fast;
		} else {
			if (fast - slow < min) min = fast - slow, pre = slow, next = fast;
			if (bmap[*slow] == 0) { ++slow; continue; }
			if (amap[*slow] <= bmap[*slow]) --count;
			--amap[*slow]; ++slow;
		}
	}
	for (count = 0; pre != next; ++count, ++pre) result[count] = *pre;
	result[count] = '\0';
	return r;
}

CORRECTION：
1、程序直接段错误了，没有考虑清楚边界情况。

char *substring (char *a, char *b, char *r) {
	int amap[256] = {0}, bmap[256] = {0}, blen = 0, alen = strlen(a), count = 0, min = alen;
	while (*b != '\0') ++bmap[*b], ++blen, ++b;
	char *fast = a, *slow = a, *pre = a, *result = r;
	do {
		cout<<*fast<<endl;
		if (count != blen) {
			if (bmap[*fast] == 0) { ++fast; continue; }
			if (amap[*fast] < bmap[*fast]) ++count;
			++amap[*fast]; ++fast;
		} 
		while (count == blen) {
			cout<<fast - slow<<endl;
			if (fast - slow < min) min = fast - slow, pre = slow;
			if (bmap[*slow] == 0) { ++slow; continue; }
			if (amap[*slow] <= bmap[*slow]) --count;
			--amap[*slow]; ++slow;
		}
	} while (*fast != '\0');
	for (count = 0; count < min; ++count, ++pre) result[count] = *pre;
	result[count] = '\0';
	return r;
}

2013/10/4

N个孩子站成一排，每个人分给一个权重。按照如下的规则分配糖果： 每个孩子至少有一个糖果；所分配权重较高的孩子，会比他的邻居获得更多的糖果。 问题是，最少需要多少个糖果？

HANDWRITING:

题目看不太懂，按我的理解就是N个孩子权重各不相同，分别表示为1,2，…，n，权重高的孩子比队列前后的孩子获得更多糖果。

那么将后半部分孩子依次插到前半部分孩子队列里，按1，n/2, 2, n/2+1,…，n/2-1, n 来排列，最少要3/2 N - 1个糖果。

CORRECTION：

1、权重可以相同

2、给定一个权重序列，需要计算最少的糖果数

3、序列顺序不能改变

2013/10/6

有一个链表，每一个节点除了next指针指向一下节点以外，又多出了一个指针random，指向链表中的任何一个节点，包括null。请给出方法完成链表的深拷贝。

HANDWRITING:

已经解决过了，第一次遍历在原链表节点之后复制节点，第二次遍历复制random指针，第三次遍历分离原和复制后的链表。

ComplexNode *Clone(ComplexNode *pHead) {
	ComplexNode *cur = pHead, *nHead, *ncur;
	while (cur != 0) {
		ComplexNode *tmp = new ComplexNode();
		tmp->m_nValue = cur->m_nValue;
		tmp->m_pNext = cur->m_pNext;
		cur->m_pNext = tmp;
		cur = tmp->m_pNext;
	}

	nHead = pHead->m_pNext;
	cur = pHead, ncur = nHead;
	while (cur != 0) {
		ncur->m_pSibling = cur->m_pSibling->m_pNext;
		cur = ncur->m_pNext;
		ncur = cur->m_pNext;
	}

	cur = pHead, ncur = nHead;
	while (cur != 0) {
		cur->m_pNext = cur->m_pNext->m_pNext;
		ncur->m_pNext = ncur->m_pNext->m_pNext;
		cur = cur->m_pNext;
		ncur = ncur->m_pNext;
	}
	return nHead;
}