清华大学2009年复试上机题 解题报告

九度OJ 题目1081：递推数列
时间限制：1 秒  内存限制：32 兆  特殊判题：否  提交：989  解决：112  题目描述：
    给定a0,a1,以及an=p*a(n-1) + q*a(n-2)中的p,q。这里n >= 2。 求第k个数对10000的模。
输入：
    输入包括5个整数：a0、a1、p、q、k。
输出：
    第k个数a(k)对10000的模。
样例输入：
    20 1 1 14 5
样例输出：
    8359
一直TLE 不清楚问题在哪  后来看了另一个人的题解 发现可以用矩阵算 会使复杂度从n降到logn 以后有时间再重写吧

//清华2010：题目1081：递推数列
//已知0<x<2000000000, 0<y<2000000000, 2<=k<=16
//unsigned int 0～4294967295
#include <cstdio>
#include <iostream>
using namespace std;
typedef long long INT;

int main(){
    INT al, bl, cl, pl, ql, k;
    int a, b, c, p, q;
    //freopen("THU_1081.txt","r",stdin);//
    while( scanf("%lld%lld%lld%lld%lld",&al,&bl,&pl,&ql,&k)!=EOF ){
        a = al % 10000;
        b = bl % 10000;
        if( k==0 ){
            printf("%d\n",a);
            continue;
        }
        if( k==1 ){
            printf("%d\n",b);
            continue;
        }
        p = pl % 10000;
        q = ql % 10000;
        for( INT i=2; i<=k; i++ ){
            c = (q*a + p*b) % 10000;
            a = b;
            b = c;
        }
        printf("%d\n",c);
    }
    //while(1);//
    return 0;
}

九度OJ 题目1082：代理服务器
时间限制：1 秒  内存限制：32 兆  特殊判题：否  提交：257  解决：65
题目描述：
        使用代理服务器能够在一定程度上隐藏客户端信息，从而保护用户在互联网上的隐私。我们知道n个代理服务器的IP地址，现在要用它们去访问m个服务器。这 m 个服务器的 IP 地址和访问顺序也已经给出。系统在同一时刻只能使用一个代理服务器，并要求不能用代理服务器去访问和它 IP地址相同的服务器（不然客户端信息很有可能就会被泄露）。在这样的条件下，找到一种使用代理服务器的方案，使得代理服务器切换的次数尽可能得少。
输入：
        每个测试数据包括 n + m + 2 行。
        第 1 行只包含一个整数 n，表示代理服务器的个数。
        第 2行至第n + 1行每行是一个字符串，表示代理服务器的 IP地址。这n个 IP地址两两不相同。
        第 n + 2 行只包含一个整数 m，表示要访问的服务器的个数。
        第 n + 3 行至第 n + m + 2 行每行是一个字符串，表示要访问的服务器的 IP 地址，按照访问的顺序给出。
        每个字符串都是合法的IP地址，形式为“xxx.yyy.zzz.www”，其中任何一部分均是0–255之间的整数。输入数据的任何一行都不包含空格字符。
         其中，1<=n<=1000，1<=m<=5000。
输出：
        可能有多组测试数据，对于每组输入数据， 输出数据只有一行，包含一个整数s，表示按照要求访问服务器的过程中切换代理服务器的最少次数。第一次使用的代理服务器不计入切换次数中。若没有符合要求的安排方式，则输出-1。
样例输入：
    3
    166.111.4.100
    162.105.131.113
    202.112.128.69
    6
    72.14.235.104
    166.111.4.100
    207.46.19.190
    202.112.128.69
    162.105.131.113
    118.214.226.52
样例输出：
    1

这题有些难度 有点意思 平时做还好 考场上做出来 那真得看硬功夫了

为了优化查找性能 首先在把输入字符转为数字处理之后 对ip按升序进行了排序 排序是为了后续查找ip的时候只需遍历该段ip内的代理服务器即可 为此设了mark1和mark2两个数组分别记录某段ip(如192.x.x.x)在proxy[]中的起止下标 查找用的是顺序遍历 感觉这里也没必要弄成二分查找了 （写这文的时候刚发现排序得很充分但查找时只是用到了ip首段的排序结果 可见还有优化空间 方案1是不优化查找而在处理字符转数字过程只处理首段并以此排序ip 方案2是可以处理ip的前3个数值并以此排序 然后查找函数里遍历时不跑到mark2[i]而是在遇到比欲查ip大的ip后就退出 总之留给以后有机会再优化吧 现在程序跑10ms 在九度OJ记录里也算并列最快了）

//清华2009：题目1082：代理服务器
//n=代理服务器的个数 m=要访问的服务器的个数
//1<=n<=1000，1<=m<=5000
#include <fstream>
#include <memory.h>
#include <algorithm>
#include <string>
#include <cstring>
#include <cstdio>
#include <iostream>
using namespace std;
struct IP{
	int p[4];
};
IP proxy[1000], server[5000];
int p[1000];	//记录proxy在server序列中出现的次数
int mark1[256];	//记录排序后代理ip的每个ip段的起点序号
int mark2[256];	//下标1->255为使用范围
int route[5000];	//ip切换过程记录
void input( int n, IP ip[] ){// , int proxy[][] 
	int i, j, k;
	int len;
	char s[16];	//ip长度最多16位
	bool flag;
	for( i=0; i<n; i++ ){
		scanf("%s",s);	//变量s已是指针故不需加&
		len = strlen(s);
		//printf("%d\n",len);//
		flag = 1;	//flag==1表ip的<255的数据项的起点
		for( j=0, k=0; j<len; j++ ){
			if( s[j] == '.' ){	//要用单引号 且需放在if(flag==1)前面 注意体会
				k++;
				flag = 1;
			}
			else if( flag == 1 ){
				ip[i].p[k] = s[j]-48;	//char->int
				flag = 0;
				//printf("ip[%d][%d] = %d\n",i,k,ip[i][k]);//
			}
			else{
				ip[i].p[k] = ip[i].p[k]*10 + s[j]-48;
				//printf("ip[%d][%d] = %d\n",i,k,ip[i][k]);//
			}
		}
	}
};
bool cmp( IP x, IP y ){
	if( x.p[0]==y.p[0] ){	//p[0]是192.168.1.1的192
		if( x.p[1]==y.p[1] ){
			if( x.p[2]==y.p[2] )
				return x.p[3]<y.p[3];
			else return x.p[2]<y.p[2];
		}
		else return x.p[1]<y.p[1];
	}
	else return x.p[0]<y.p[0];
};
void init( int n ){
	memset(mark1,-1,sizeof(mark1));
	memset(mark2,-1,sizeof(mark2));
	int i, j;
	int current, old;
	for( i=0; i<n; i++ ){
		if( i!=0 )
			old = current;
		else old = -1;
		current = proxy[i].p[0];
		if( current!=old ){
			mark1[current] = i;
			mark2[old] = i-1;	//mark1->mark2为该段ip对应proxy的下标范围
		}
	}
	mark2[proxy[n-1].p[0]] = n-1;	//勿忘善后工作 否则最后一个末尾下标为-1了
};
int find( int index, int n ){	//输入server的index查找proxy
	int i, j;
	int same = -1;
	if( mark1[server[index].p[0]] == -1 )
		return same;
	for( i=mark1[server[index].p[0]]; i<=mark2[server[index].p[0]]; i++ )
		for( j=1; j<=3; j++ ){	//直接从ip的第二个字段比起
			if( server[index].p[j] != proxy[i].p[j] ) break;
			if( j==3 ) same = i;
		}
	return same;	//返回和输入相同的代理的下标
};

int main()
{
	int i, j, k, n, m;
	int remain, result;
	freopen("THU_1082.txt","r",stdin);//
	while( scanf("%d",&n)!=EOF ){
		//memset(proxy,0,sizeof(proxy)); memset(server,0,sizeof(server));
		input( n, proxy );
		scanf("%d",&m);
		input( m, server );
		bool fail = 0;
		if( n == 1 ){	//输出-1的条件判定
			for( i=0; i<m; i++ ){
				for( j=0; j<=3; j++ ){	//直接从ip的第二个字段比起
					if( server[i].p[j] != proxy[0].p[j] ) break;
					if( j==3 ){	//发现一致
						fail = 1;
						break;
					}
				}
				if( fail == 1 )	break;	//跳出外层for
			}
			if( fail == 1 ){
				printf("-1\n");
				continue;	//进行下轮while
			}
		}
		sort(proxy,proxy+n,cmp);
		init(n);
		memset(p,0,sizeof(p));	//初始化
		remain = n;
		for( i=0,j=0; i<m; i++ ){	//printf("i=%d, same=%d\n",i,find(i,n));//
			result = find(i,n);
			if( result != -1 ){	//发现代理中的访问ip
				if( p[result] == 0 )
					remain--;
				p[result] = 1;
				if( remain == 0 ){	//就剩一个时 记录代理并全部初始化
					for( k=0; k<1000; k++ )
						if( p[k]==0 ) {route[j] = k; break;}
					j++;
					i--;	//注意退格一步
					memset(p,0,sizeof(p));	//恢复初始化
					remain = n;
				}
			}// 大if
		}// for
		printf("%d\n",j);	//result=
	}
	//while(1);
	return 0;
}