2013通化邀请赛部分题解

lishaozhe1024

于 2014-07-17 10:23:29 发布

阅读量558

点赞数

分类专栏：套题文章标签：通化邀请赛

本文链接：https://blog.csdn.net/lishaozhe1024/article/details/37900097

版权

套题专栏收录该内容

4 篇文章 0 订阅

订阅专栏

A -Tutor

题意 : 求12个数字的和，四舍五入两位小数后输出，小数点末尾0不输出，如果是整数输出整数

思路 : 签到题。不过用 sprintf 比较方便， sprintf( char * , format , ... ) 可以直接将某个数按照一定格式存到字符串里。那么用 %.2lf 就直接做好保留两位并四舍五入了，然后处理下字符串就行。

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;

double sum ;

int main(){
    int cas;
    scanf("%d",&cas);
    while( cas -- ){
        double a ;
        sum = 0 ;
        for( int i=1;i<=12;i++ ){
            scanf("%lf",&a);
            sum += a ;
        }
        sum /= 12 ;
        char ans[105] ;
        sprintf( ans , "%.2f" , sum ) ;
        int len = strlen(ans) ;
        for( int i=len-1;i>=0;i-- ){
            if( ans[i] == '0' )ans[i]=0;
            else if( ans[i] == '.' ){ans[i]=0;break;}
            else break;
        }
        printf("$%s\n",ans);
    }
    return 0 ;
}

C - Rectangle

题意 : 在一个 n * m 的字符串矩阵中找一个最大的对称等腰三角形，对称指字符对于高对称，输出最大面积。

思路 : 三角形的直角只有四种方向 , 那么我们分四个方向处理即可。

假设直角在左上角，先对于每个点求向下和向右扩展的LCP ，我这里用的Hash，这步的复杂度是O( n^2logn )

然后我们看看直角在左上角的等腰对称三角形有什么特征。

边长为奇数的 :

aaa

aa&

a$@

对于边长奇数的三角形， LCP数组为 :

321

211

111

观察对角线，得到对角线的LCP分别为 3 , 1 ... 即最小的是1 ，然后逐渐增加2

那么我们可以枚举对角线，如果我们能在O( n ) 的时间内推出以这条对角线对称的三角形的最大边长是多少，那么复杂度就够用了

那么对于每条对角线，我们从右下角开始枚举，依次判断LCP是不是大于等于1,3,5 ... 大于的话，没问题。小于的话，其实也不需要从头开始，只要把当前的长度变成当前枚举的LCP向下最近的奇数即可，因为这样是枚举的边长减小，前面的几个肯定也是符合的。

那么这样枚举对角线的复杂度就能是O( N * N ) 了

边长为偶数的 :

aaaa

aaa%

aa#$

a!@^

偶数情况也差不多，就是枚举是 4 , 2 ...

这样整个问题就是O( N * N * logN ) 了

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;

int n , m ;
typedef unsigned __int64 uLL ;

uLL x = 133 ;
char mp[505][505] ;
uLL xp[505] ;
uLL Hash1[505][505] , Hash2[505][505] , Hash3[505][505] , Hash4[505][505] ; 
int LCP[505][505] ;
bool vis[505][505] ;

int askLCP( int x , int y , uLL Hash1[505][505] , uLL Hash2[505][505] , int dir1 , int dir2 , int MaxLen ) {
	int l = 1 , r = MaxLen , m ;
	while( l < r ) {
		m = ( l + r + 1 ) >> 1 ;
		if( ( Hash1[x][y] - Hash1[x+dir1*m][y] * xp[m] ) - ( Hash2[x][y] - Hash2[x][y+dir2*m] * xp[m] ) == 0 ) {
			l = m ;
		}else{
			r = m - 1 ;
		}
	}
	return l ;
}
int main(){
	int cas ;
	scanf( "%d" , &cas ) ;
	xp[0] = 1 ;
	for( int i = 1; i <= 500 ; i ++ ) 
		xp[i] = xp[i-1] * x ;
	while( cas -- ) {
		scanf( "%d%d" , &n , &m ) ;
		for( int i = 1 ; i <= n ; i ++ ) {
			scanf( "%s" , mp[i] + 1 ) ;
		}
		memset( Hash1 , 0 , sizeof(Hash1) ) ;
		memset( Hash2 , 0 , sizeof(Hash2) ) ;
		memset( Hash3 , 0 , sizeof(Hash3) ) ;
		memset( Hash4 , 0 , sizeof(Hash4) ) ;

		for( int i = 1 ; i <= n ; i ++ ) {
			for( int j = 1 ; j <= m ; j ++ ) {
				Hash1[i][j] = Hash1[i-1][j] * x + mp[i][j] ;
				Hash2[i][j] = Hash2[i][j-1] * x + mp[i][j] ;
			}
		}

		for( int i = n ; i >= 1 ; i -- ) {
			for( int j = m ; j >= 1 ; j -- ) {
				Hash3[i][j] = Hash3[i+1][j] * x + mp[i][j] ;
				Hash4[i][j] = Hash4[i][j+1] * x + mp[i][j] ;
			}
		}

		// 直角在左上角 , Hash3 , Hash4 , dir 1 , 1
		for( int i = 1 ; i <= n ; i ++ ) {
			for( int j = 1 ; j <= m ; j ++ ) {
				LCP[i][j] = askLCP( i , j , Hash3 , Hash4 , 1 , 1 , min( n - i + 1 , m - j + 1 ) ) ;
			}
		}
		int Max = 0 ;
		int dir1 = -1 , dir2 = -1 ;

		memset( vis , false , sizeof(vis) ) ;
		for( int i = n ; i >= 1 ; i -- ) {
			for( int j = m ; j >= 1 ; j -- ) {
				if( vis[i][j] ) continue ;
				int nex = i , ney = j ;
				int len1 = -1 ;
				int len2 = 0 ;

				while( nex >= 1 && ney >= 1 ) {
					vis[nex][ney] = true ;
					if( LCP[nex][ney] >= len1 + 2 ) {
						len1 += 2 ;
						Max = max( Max , len1 ) ;
					}else{
						len1 = LCP[nex][ney] ;
						if( len1 % 2 == 0 ) len1 -- ;
					}
					if( LCP[nex][ney] >= len2 + 2 ) {
						len2 += 2 ;
						Max = max( Max , len2 ) ;
					}else{
						len2 = LCP[nex][ney] ;
						if( len2 % 2 == 1 ) len2 -- ;
					}
					nex += dir1 ;
					ney += dir2 ;
				}
			}
		}

		// 直角在右上角 , Hash3 , Hash2 , dir 1 , -1
		for( int i = 1 ; i <= n ; i ++ ) {
			for( int j = 1 ; j <= m ; j ++ ) {
				LCP[i][j] = askLCP( i , j , Hash3 , Hash2 , 1 , -1 , min( n - i + 1 , j ) ) ;
			}
		}

		dir1 = -1 , dir2 = 1 ;

		memset( vis , false , sizeof(vis) ) ;
		for( int i = n ; i >= 1 ; i -- ) {
			for( int j = 1 ; j <= m ; j ++ ) {
				if( vis[i][j] ) continue ;
				int nex = i , ney = j ;
				int len1 = -1 ;
				int len2 = 0 ;

				while( nex >= 1 && ney <= m ) {
					vis[nex][ney] = true ;
					if( LCP[nex][ney] >= len1 + 2 ) {
						len1 += 2 ;
						Max = max( Max , len1 ) ;
					}else{
						len1 = LCP[nex][ney] ;
						if( len1 % 2 == 0 ) len1 -- ;
					}
					if( LCP[nex][ney] >= len2 + 2 ) {
						len2 += 2 ;
						Max = max( Max , len2 ) ;
					}else{
						len2 = LCP[nex][ney] ;
						if( len2 % 2 == 1 ) len2 -- ;
					}
					nex += dir1 ;
					ney += dir2 ;
				}
			}
		}

		// 直角在左下角 , Hash1 , Hash4 , dir -1 , 1
		for( int i = 1 ; i <= n ; i ++ ) {
			for( int j = 1 ; j <= m ; j ++ ) {
				LCP[i][j] = askLCP( i , j , Hash1 , Hash4 , -1 , 1 , min( i , m - j + 1 ) ) ;
			}
		}

		dir1 = 1 , dir2 = -1 ;

		memset( vis , false , sizeof(vis) ) ;
		for( int i = 1 ; i <= n ; i ++ ) {
			for( int j = m ; j >= 1 ; j -- ) {
				if( vis[i][j] ) continue ;
				int nex = i , ney = j ;
				int len1 = -1 ;
				int len2 = 0 ;

				while( nex <= n && ney >= 1 ) {
					vis[nex][ney] = true ;
					if( LCP[nex][ney] >= len1 + 2 ) {
						len1 += 2 ;
						Max = max( Max , len1 ) ;
					}else{
						len1 = LCP[nex][ney] ;
						if( len1 % 2 == 0 ) len1 -- ;
					}
					if( LCP[nex][ney] >= len2 + 2 ) {
						len2 += 2 ;
						Max = max( Max , len2 ) ;
					}else{
						len2 = LCP[nex][ney] ;
						if( len2 % 2 == 1 ) len2 -- ;
					}
					nex += dir1 ;
					ney += dir2 ;
				}
			}
		}

		// 直角在右下角 , Hash1 , Hash2 , dir -1 , -1
		for( int i = 1 ; i <= n ; i ++ ) {
			for( int j = 1 ; j <= m ; j ++ ) {
				LCP[i][j] = askLCP( i , j , Hash1 , Hash2 , -1 , -1 , min( i , j ) ) ;
			}
		}

		dir1 = 1 , dir2 = 1 ;

		memset( vis , false , sizeof(vis) ) ;
		for( int i = 1 ; i <= n ; i ++ ) {
			for( int j = 1 ; j <= m ; j ++ ) {
				if( vis[i][j] ) continue ;
				int nex = i , ney = j ;
				int len1 = -1 ;
				int len2 = 0 ;

				while( nex <= n && ney <= m ) {
					vis[nex][ney] = true ;
					if( LCP[nex][ney] >= len1 + 2 ) {
						len1 += 2 ;
						Max = max( Max , len1 ) ;
					}else{
						len1 = LCP[nex][ney] ;
						if( len1 % 2 == 0 ) len1 -- ;
					}
					if( LCP[nex][ney] >= len2 + 2 ) {
						len2 += 2 ;
						Max = max( Max , len2 ) ;
					}else{
						len2 = LCP[nex][ney] ;
						if( len2 % 2 == 1 ) len2 -- ;
					}
					nex += dir1 ;
					ney += dir2 ;
				}
			}
		}

		printf( "%d\n" , ( Max + 1 ) * Max / 2 ) ;
	}
	return 0 ;
}

D - D-City

题意 : 给定一个图，N个点，M条边，求按顺序删边后剩下的多少联通块。

思路 : 并查集倒着添加边就行了，不多说

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;

int n , m ;

int Set[10005] ;

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

int find( int u ){
    return u==Set[u]?Set[u]:Set[u]=find(Set[u]);
}

bool Union( int a , int b ){
    int fa = find(a) , fb = find(b) ;
    if( fa == fb )return false;
    Set[fa] = fb ;
    return true ;
}

int ans[100005] ;

struct node{
    int x, y ;
    void get(){
        scanf("%d%d",&x,&y);
    }
}e[100005] ;

int main(){
    while(scanf("%d%d",&n,&m)!=EOF){
        Init();
        int left = n ;
        for( int i = 1 ; i<= m ;i ++ )e[i].get();
        for( int i = m ;  i >= 1 ; i -- ){
            ans[i] = left ;
            if( Union(e[i].x , e[i].y ))left--;
        }
        for( int i=1;i<=m;i++ )printf("%d\n",ans[i]);
    }
    return 0 ;
}

E - GCD and LCM

题意 : 问有多少种三元组( x , y , z ) , 满足 GCD( x , y , z ) = G , LCM( x , y , z ) = L

思路 : 我们知道每个数都可以拆成素数表达式，即 n = p1^a1 * p2 ^ a2 * p3 ^ a3 * ... pn^an

那么多个数的 GCD 用素数表达式可以表示为 GCD = p1^( min( a1 , b1 .. ) ) * ... pn^( min( an , bn ... ) )

LCM 用素数表达式可以表示为 LCM = p1^( max( a1 , b1 .. ) ) * ... pn^( max( an , bn ... ) )

其中 pi 是素数

什么情况是0种，那么就 GCD 素数表达式的某项指数比LCM的素数表达式的对应项指数大

其实也就是 LCM % GCD != 0 情况

假设对于素数pi ， LCM 的分解后对应的指数是 Max , GCD 的分解后的对应指数是 Min ，那么每个数所取的情况就只有 Max-MIn+1 种，设K = Max - Min + 1

那么这里有 K * K * K 种，但是因为LCM和GCD必须取到，所以根据容斥原理 :

对于素数pi 实际的方案数有 K*K*K - （K-1）*( K-1 ) * ( K - 1 ) /* 没有数能取到最大值 */ -（K-1）*( K-1 ) * ( K - 1 ) /* 没有数能取到最小值 */ +( K-2 ) * ( K - 2 ) * ( K - 2 ) /* 即娶不到最大值也取不到最小值 */

那么每个素数的方案都是独立的，所以乘起来就好

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <math.h>
using namespace std;

#define MAXN 100000

int L , G ;
int prime[MAXN+5] ;
bool isprime[MAXN+5] ;
int cnt ;
void getprime(){
	for( int i = 1 ; i <= MAXN ; i += 2 ) {
		isprime[i] = true ;
	}
	isprime[2] = true ;
	int k = (int)sqrt( 1.0 * MAXN ) ;
	for( int i = 3 ; i <= k ; i ++ ) {
		for( int j = i * i , s = 2 * i ; j <= MAXN ; j += s ) {
			isprime[j] = false ;
		}
	}
	cnt = 1 ; 
	for( int i = 2 ; i <= MAXN ; i ++ ) if( isprime[i] ){
		prime[cnt++] = i ;
	}
}

int fac1[MAXN+5] ;
int fac2[MAXN+5] ;

__int64 cal( int n ) {
	if( n == 1 ) return 1 ;
	return n * n * n - ( n -1 ) * ( n - 1 ) * ( n - 1 ) * 2 + ( n - 2 ) * ( n - 2 ) * ( n - 2 ) ;
}

int main(){
	int cas ;
	scanf( "%d" , &cas );
	getprime() ;
	while( cas -- ) {
		scanf( "%d%d" , &L , &G ) ;
		__int64 ans = 1 ;
		bool flag = true ;
		for( int i = 1 ; i < cnt ; i ++ ) {
			int cnt1 = 0 ;
			int cnt2 = 0 ;
			while( L % prime[i] == 0 ) {
				L /= prime[i] ;
				cnt1 ++ ;
			}
			while( G % prime[i] == 0  ) {
				G /= prime[i] ;
				cnt2 ++ ;
			}
			if( cnt1 > cnt2 ) {
				flag = false ;
				break;
			}
			ans *= cal( cnt2 - cnt1 + 1 ) ; 
		}
		if( L != G ) {
			if( L == 1 ) {
				ans *= cal( 2 ) ;
			}else{
				flag = false ;
			}
		}
		if( !flag ) ans = 0 ;
		printf( "%I64d\n" , ans ) ;
	}
	return 0 ;

G - Cannon

题意 : n*m的棋盘，棋盘上有 k 个棋子（不是炮）, 问棋盘上最多能放几个炮，让炮不相互攻击

思路 : 傻傻的已经存在的也是炮，敲了半天的3进制状态压缩 ... 结果在试样例才发现蛋疼了 ...

事实上只要爆搜就好了，为了比较好的判断可行性，我用3进制的状态压缩预处理了所有情况。0表示空着，1表示炮，2表示其他棋子。

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;

int n , m , q ;

int mp[6][6] ;
int state1[6][6] ;
int state2[6][6] ;
int sta[505] ;
int p[6] ;
int sum[6][6] ;

inline int add( int n , int k , int c ) {
	return n + p[k] * c ;
}

inline int get( int n , int k ) {
	return ( n / p[k] ) % 3 ;
}
int Max ;

void dfs( int x , int y , int Sum ) {
	if( Max < Sum ) {
		Max = Sum ;
	}
	if( x > n ) return ;
	if( Sum + ( n * m - ( ( x - 1 ) * m + y - 1 ) - sum[x][y] ) <= Max ) return ; 

	if( mp[x-1][y-1] == 0 ) {
		state1[x][y] = add( state1[x-1][y] , x - 1 , 1 ) ;
		state2[x][y] = add( state2[x][y-1] , y - 1 , 1 ) ;
		if( sta[state1[x][y]] && sta[state2[x][y]] ) {
			if( y == m ) {
				dfs( x + 1 , 1 , Sum + 1 ) ;
			}else{
				dfs( x , y + 1 , Sum + 1 ) ;
			}
		}
	}else if( mp[x-1][y-1] == 2 ) {
		state1[x][y] = add( state1[x-1][y] , x - 1 , 2 ) ;
		state2[x][y] = add( state2[x][y-1] , y - 1 , 2 ) ;
		if( sta[state1[x][y]] && sta[state2[x][y]] ) {
			if( y == m ) {
				dfs( x + 1 , 1 , Sum ) ;
			}else{
				dfs( x , y + 1 , Sum ) ;
			}
		}
	}
	if( mp[x-1][y-1] == 0 ) {
		state1[x][y] = add( state1[x-1][y] , x - 1 , 0 ) ;
		state2[x][y] = add( state2[x][y-1] , y - 1 , 0 ) ;
		if( sta[state1[x][y]] && sta[state2[x][y]] ) {
			if( y == m ) {
				dfs( x + 1 , 1 , Sum ) ;
			}else{
				dfs( x , y + 1 , Sum ) ;
			}
		}
	}
} 

int main(){
	p[0] = 1 ;
	for( int i = 1 ; i < 5 ; i ++ ) {
		p[i] = p[i-1] * 3 ;
	}
	int size = 3 * 3 * 3 * 3 * 3 ;
	for( int i = 0 ; i < size ; i ++ ) {
		sta[i] = true ;
		for( int j = 0 ; j < 5 && sta[i]; j ++ ) {
			for( int k = j + 1 ; k < 5 && sta[i] ; k ++ ) {
				if( get(i,j) == 1 && get(i,k) == 1 ) {
					int cnt = 0 ;
					for( int l = j + 1 ; l < k ; l ++ ) {
						if( get( i , l ) >= 1 ) {
							cnt ++ ;
						}
					}
					if( cnt == 1 ) {
						sta[i] = false ;
					}
				}
			}
		}
	}
	memset( state1 , 0 , sizeof(state1) ) ;
	memset( state2 , 0 , sizeof(state2) ) ;
	while( scanf( "%d%d%d" , &n , &m , &q ) != EOF ) {
		memset( mp , 0 , sizeof(mp) ) ;
		for( int i = 1 ; i <= q ;  i ++ ) {
			int x , y ;
			scanf( "%d%d" , &x , &y ) ;
			mp[x][y] = 2 ;
		}
		Max = 0 ;
		int s = 0 ;
		for( int i = n ; i >= 1 ; i -- ) {
			for( int j = m ; j >= 1 ; j -- ) {
				if( mp[i-1][j-1] == 2 ) s ++ ;
				sum[i][j] = s ;
			}
		}
		dfs( 1 , 1 , 0 ) ;
		printf( "%d\n" , Max ) ;
	}
	return 0 ;
}

H - Play Game

题意 : 给你两堆石头，每个石头有权值，一次选一堆，取头或者尾，问能取的最大权值。

思路 : 其实和一堆的情况是类似的，做过一堆的情况，那么两堆的情况就easy了，就是多几维罢了。

对于一堆的情况 ,

dp[s][t] 表示这堆石子头取到s，尾取到t的情况下，先手能获得的最大值。

假设sum 为 s~t 剩下石子的权值和

那么 dp[s][t] = max( sum - dp[s+1][t] , sum - dp[s][t-1] ) ;

sum-dp[s+1][t] 表示总和-对方取[s+1,t]区间对方能取到的最大值

实现用记忆化搜索

这题就是变成四维就好了

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;

int a[25] , b[25] ;
int dp[25][25][25][25] ;

int sum1[25] , sum2[25] ;

int solve( int s1 , int t1 , int s2 , int t2 ) {
	if( dp[s1][t1][s2][t2] != -1 ) return dp[s1][t1][s2][t2] ;
	int Max = 0 ;
	int sum = 0 ;
	if( s1 <= t1 ) sum += sum1[t1] - sum1[s1-1] ;
	if( s2 <= t2 ) sum += sum2[t2] - sum2[s2-1] ;
	if( s1 <= t1 )
		Max = max( Max , sum - min ( solve( s1 + 1 , t1 , s2 , t2 ) , solve( s1 , t1 - 1 , s2 , t2 ) ) ) ;
	if( s2 <= t2 ) 
		Max = max( Max , sum - min ( solve( s1 , t1 , s2 + 1 , t2 ) , solve( s1 , t1 , s2 , t2 - 1 ) ) ) ;
	return dp[s1][t1][s2][t2] = Max ;
}

int main(){
	int cas ;
	scanf( "%d" , &cas ) ;
	while( cas -- ) {
		int n ;
		scanf( "%d" , &n ) ;
		for( int i = 1 ; i <= n ; i ++ ) 
			scanf( "%d" , &a[i] ) ;
		for( int i = 1 ; i <= n ; i ++ ) 
			scanf( "%d" , &b[i] ) ;
		memset( dp , -1 , sizeof(dp) ) ;
		for( int i = 1 ; i <= n; i ++ ) {
			sum1[i] = sum1[i-1] + a[i] ;
			sum2[i] = sum2[i-1] + b[i] ;
		}
		printf( "%d\n" , solve( 1 , n , 1 , n ) ) ;
	}
	return 0;
}

J - Dice

题意 : 一个六面的均匀筛子

F（N ）是连续N次投出相同数字的期望

H ( N ) 是连续N次投出 1 的期望

G ( M ) 是投出M次 1 的期望

给定N ，求最小的M1 和 M2 使得 G( M1 ) >= F( N ) , G( M2 ) >= H( N )

思路 : 先计算出三个期望的公式

F( N ) :

设 dp[n] 为已经连续投出 n 次相同的数字，要连续投出N次的期望是多少

dp [N] = 0 ;

dp [N-1] = ( 5 / 6 ) * dp[1] + ( 1 / 6 ) * dp[N] + 1

dp [N-2] = ( 5 / 6 ) * dp[1] + ( 1 / 6 ) * dp[N+1] + 1 = ( 5 / 6 ) ( 1 + 1 / 6 ) * dp[1] + ( 1 + 1 / 6 )

...

几次迭代之后我们就会发现

dp[1] = ( 5 / 6 ) * ( 1 + ( 1 / 6 ) + ( 1 / 6 ) ^ 2 + ... ( 1 / 6 ) ^ N-2 ) * dp[1] +( 1 + ( 1 / 6 ) + ( 1 / 6 ) ^ 2 + ... ( 1 / 6 ) ^ N-2 ) ;

dp[0] = dp[1] + 1

那么化解之后很容易得到 F( N ) = ( 6 ^ N - 1 ) / 5

H( N ) : 思路是一样的，dp[i] = ( 5 / 6 ) * dp[0] + ( 1 / 6 ) * dp[i+1] + 1

计算之后可以得到 H(N) = ( 6^(N+1) - 6 ) / 5 ;

G（M）:

dp[i] = ( 1 / 6 ) dp[i+1] + ( 5 / 6 ) * dp[i] + 1 ; => dp[i] = dp[i+1] + 6

那么很容易得到 G( M ) = 6 * M

那么得到三个函数之后就是计算的问题了 :

M1 : G ( M1 ) >= F( N ) 即 M2 >= ( 6 ^ N - 1 ) / 30

M2 : G( M2 ) >= H( N ) 即 M2 >= ( 6 ^ N - 1 ) / 5

首先我们看 6^N - 1 ，根据N次方差公式可以得到 6^N-1 = ( 6 - 1 ) * ( 6 ^N-1 + 6^N-2 + ... + 1 )

因为 6 ^ N - 1 是能被5整除的，那么 M2 = ( 6 ^ N - 1 ) / 5

因为 6 ^ N - 1 不能被30整除，我们要补上最小一个数，使他能被30整除，那么很显然，我们可以把最后那个1变成6 ，即整个式子增加了 25 ，那么 M1 = ( 6 ^ N - 1 + 25 ) / 30

那么两个数直接计算就可以了

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;

#define mod 2011

int power( int a , int k ) {
	if( k == 0 ) return 1 ;
	if( k == 1 ) return a ;
	int tmp = power( a , k >> 1 ) ;
	if( k & 1 ) 
		return ( ( tmp * tmp ) % mod * a ) % mod ;
	return tmp * tmp % mod ;
}

int inv( int a ) {
	return power( a , mod - 2 ) ;
}

int main(){
	int n; 
	while( scanf( "%d" , &n ) != EOF ) {
		if( n == 0 ) break;
		int m1 =( ( power( 6 , n ) + 24 ) % mod * ( inv( 30  ) ) + mod ) % mod ;
		int m2 =( ( power( 6 , n ) + 2010 ) % mod * ( inv( 5  ) ) + mod ) % mod ;
		printf( "%d %d\n" , m1 , m2 ) ;
	}
	return 0 ;
}