编程珠玑第二章

 

  不得不佩服Bentley,不愧大师，第二章写的真是超赞。
  本章共3个问题，一一总结。
  A题目：在一个最多包含40亿个32位整数的文件中，找出一个不在文件中的32位整数。  题解：1.如果内存足够，内存足够，就可以用第一章的位存储，存储32位整数来做。 2.此题明确说了，只有几个外部的‘临时’文件可用，但是仅有几百字节内存，既然是几百 字节，肯定还是用位来做，而且速度一定要快，查找算法速度最快平均也要0（nlogn)， 于是我们将32位整数的最高位，分为0和1，将最高位是1的整数分到一个文件，最高位是0 的分到另一个文件，然后在两个文件中，找不足1/2的那个文件，肯定那个文件少了不存 在的数字，于是在那个文件中接着找。这个就类似与称东西，找出次品（次品重量跟正品 不同）。这也是计算机中一个典型的算法二分搜索。  提起二分搜索，你会觉得很简单，但是这个很简单的算法却应用甚广，比如在二叉树找 结点时，就算二分搜索，调试程序，先从中间开始，看前后哪一部分出错，然后继续找出 程序在哪一部分出现错误，不也是二分搜索吗？二分搜索很强大，但是不足是：前提必须 是有序序列才行。  B题目：将一个n元一维向量循环左移i个位置，找出相应的算法。  题解：此题看你要怎么操作数组元素了，可以一位的一位的交换（缓存就不行),也可以 成块成块的交换（充分利用缓存），甚至还有其他所谓的精巧算法。  1.首先将x的前i个元素复制到临时数组，然后余下的左移，最后将临时数组的复制到 余下的位置。不足：消耗太多的内存空间。  2.写个函数，每次循环左移一位，循环调用i次，但是函数调用，消耗太多运行时间。  3.所谓的精巧算法：移动x[0]到临时变量t,然后移动x[i]到x[0]，x[2i]至x[i]， 依次类推，直到大于n，就用k（就是Ni）-n，将t中的变量放到最后一个小于n的位置。 如果要仔细理解这个算法，还是请详细阅读下面代码。  4.运用求逆，从AB开始，先A求逆，再B求逆，在AB求逆，就是BA。 思想：reverse(0,i-1) reverse(i,n-1) reverse(0,n-1)。  
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MAXN 10000000

int x[MAXN];
int rotdist, n;

/* Alg 1: Rotate by reversal */

void reverse(int i, int j)
{	int t;
	while (i < j) {
		t = x[i]; x[i] = x[j]; x[j] = t;
		i++;
		j--;
	}
}

void revrot(int rotdist, int n)
{	reverse(0, rotdist-1);
	reverse(rotdist, n-1);
	reverse(0, n-1);
}

/* Alg 2: Juggling (dolphin) rotation */

int gcd(int i, int j)
{	int t;
	while (i != 0) {
		if (j >= i)
			j -= i;
		else {
			t = i; i = j; j = t;
		}
	}
	return j;
}

void jugglerot(int rotdist, int n)
{	int cycles, i, j, k, t;
	cycles = gcd(rotdist, n);
	for (i = 0; i < cycles; i++) {
		/* move i-th values of blocks */
		t = x[i];
		j = i;
		for (;;) {
			k = j + rotdist;
			if (k >= n)
				k -= n;//也就是对n取余
			if (k == i)//跳出循环，将临时变量的t放到位置j中
				break;
			x[j] = x[k];
			j = k;
		}
		x[j] = t;
	}
}

void jugglerot2(int rotdist, int n)
{	int cycles, i, j, k, t;
	cycles = gcd(rotdist, n);
	for (i = 0; i < cycles; i++) {
		/* move i-th values of blocks */
		t = x[i];
		j = i;
		for (;;) {
          /* Replace with mod below
			k = j + rotdist;
			if (k >= n)
				k -= n;
           */
            k = (j + rotdist) % n;
			if (k == i)
				break;
			x[j] = x[k];
			j = k;
		}
		x[j] = t;
	}
}

/* Alg 3: Recursive rotate (using gcd structure) */

void swap(int i, int j, int k) /* swap x[i..i+k-1] with x[j..j+k-1] */
{	int t;
	while (k-- > 0) {
		t = x[i]; x[i] = x[j]; x[j] = t;
		i++;
		j++;
	}

}

void gcdrot(int rotdist, int n)
{	int i, j, p;
	if (rotdist == 0 || rotdist == n)
		return;
	i = p = rotdist;
	j = n - p;//此算法是《science of programming》书上的，这本书是本神书
	while (i != j) {//可以证明程序的正确性，我以后肯定要看看
		/* invariant:
			x[0  ..p-i  ] is in final position
			x[p-i..p-1  ] = a (to be swapped with b)
			x[p  ..p+j-1] = b (to be swapped with a)
			x[p+j..n-1  ] in final position
		*/
		if (i > j) {//画图来看，举个例子一目了然
			swap(p-i, p, j);
			i -= j;
		} else {
			swap(p-i, p+j-i, i);
			j -= i;
		}
	}
	swap(p-i, p, i);//交换最后两块内存
}

int isogcd(int i, int j)
{	if (i == 0) return j;
	if (j == 0) return i;
	while (i != j) {
		if (i > j)
			i -= j;
		else 
			j -= i;
	}
	return i;
}

void initx()
{
	int i;
	for (i = 0; i < n; i++)
		x[i] = i;
}

/* Timing */

void timedriver()
{	int i, algnum, numtests, start, clicks;
	while (scanf("%d %d %d %d", &algnum, &numtests, &n, &rotdist) != EOF) {
		initx();
		start = clock();
		for (i = 0; i < numtests; i++) {
			if (algnum == 1)
				revrot(rotdist, n);
			else if (algnum == 2)
				jugglerot(rotdist, n);
			else if (algnum == 22)
				jugglerot2(rotdist, n);
			else if (algnum == 3)
				gcdrot(rotdist, n);
			else if (algnum == 4)
				slide(rotdist, n);
		}
		clicks = clock() - start;
		printf("%d\t%d\t%d\t%d\t%d\t%g\n",
			algnum, numtests, n, rotdist, clicks,
			1e9*clicks/((float) CLOCKS_PER_SEC*n*numtests));
	}
}

/* Main */

int main()
{	/* testrot(); */
	timedriver();
	return 0;
}
   C题目：给定一个英语字典，找出其中的所有变位集合。
  题解：如果上来就排列组合，那么肯定超时，阶乘太大了。所以此题的解法相当巧妙
把是变位集合的单词作为标志，排序每个单词的字母，如果顺序一致，那么就是一个标志
内的，将所有的单词分成各个不同的标志，然后对这些标志再进行排序，方便输出各个
变位集合。也就是先用一种方式排序实现标识，再用另一种排序，方便输出。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define WORDMAX 100

int charcomp(char *x, char *y)
{   return *x - *y;
}
//先求标志
int main()
{   char word[WORDMAX], sig[WORDMAX];
    while (scanf("%s", word) != EOF) {
        strcpy(sig, word);
        qsort(sig, strlen(sig), sizeof(char), charcomp);
        printf("%s %s\n", sig, word);
    }
    return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define WORDMAX 100
//排序（用系统排序命令）结束后，用来输出
int main()
{   char word[WORDMAX], sig[WORDMAX], oldsig[WORDMAX];
    int linenum = 0;
    strcpy(oldsig, "");
    while (scanf("%s %s", sig, word) != EOF) {
        if (strcmp(oldsig, sig) != 0 && linenum > 0)
            printf("\n");
        strcpy(oldsig, sig);
        linenum++;
        printf("%s ", word);
    }
    printf("\n");
    return 0;
}
  代码相信大家都能看懂：
  类似于这种求标识的情况，还有一个著名问题就是电话薄按键存储。在电话薄的问题
中，名字的标识就是用按键的编码，相同编码对应的不同名字就是一个变位集合。这个
类似与上面的变位词，可以排序，再二分搜索按键编码，但是实际系统用的还是散列。
 好了，三个题目搞定了，收获挺多的。但是原理真的是很简单，按位进行二分搜索，
排序进行标识（将排序结果相等的单词集中在一起）。但这么简单的原理往往就是你不
会想到的，真正的技能只能来源于你解决问题和反思答案所获得的经验。