2013 南京现场赛部分题解

A - GPA

题意 : 就是求个GPA

思路 : 不说了 ...

#include 
#include 
#include 
using namespace std;

double cal( char * str ) {
	if( strcmp( str , "A" ) == 0 ) 
		return 4.0 ;
	else if( strcmp( str , "A-" ) == 0 ) 
		return 3.7 ;
	else if( strcmp( str , "B+") == 0 ) {
		return 3.3 ;
	}else if( strcmp( str , "B" ) == 0 ) 
		return 3.0 ;
	else if( strcmp( str , "B-" ) == 0 )
		return 2.7 ;
	else if( strcmp( str , "C+"  ) == 0 ) 
		return 2.3 ;
	else if( strcmp( str , "C" ) == 0 ) 
		return 2.0 ;
	else if( strcmp( str , "C-") == 0 ) 
		return 1.7 ;
	else if( strcmp( str , "D" ) == 0 ) 
		return 1.3 ;
	else if( strcmp( str , "D-") == 0 ) 
		return 1.0 ;
	else 
		return 0.0 ;
}

int main(){
	int n; 
	while( scanf( "%d" , &n ) != EOF ) {
		double ans = 0 ;
		int sum = 0 ;
		for( int i = 1 ; i <= n; i ++ ) {
			int a ;
			char str[10] ;
			scanf( "%d%s" , &a , str ) ;
			if( str[0] == 'P' || str[0] == 'N' ) continue ;
			ans += a * cal( str ) ;
			sum += a ;
		}
		if( sum == 0 ) {
			puts( "0.00" ) ;
		}else{
			printf( "%.2lf\n" , ans / sum ) ;
		}
	}
	return 0 ;
}

B - Poor Warehouse Keeper

题意 :  题意好长 ... 不想说了 ~~

思路 :  首先物品增加的个数是一定的， 那么当然是单价比较高的时候增加个数才优。并且因为单价只会增加不会减少，所以我们贪心的同时还好保证单价不能大于等于 ( y + 1 ) / x 。 当然一个一个模拟是行不通的 ， 我们直接用公式计算当前个数不变的情况，单价能增加到哪里就好。因为x很小，所以时间就完全没有压力了。另外y>x的时候不可能达到。

#include 
#include 
#include 
using namespace std;

int main(){
	double price1 , price2 ;
	int x , y ;
	while( scanf( "%d%d" , &x , &y ) != EOF ) {
		price1 = 1.0 * y / x ;
		price2 =  ( 1.0 *( y + 1 ) / x ) ;
		int a = 1 ;
		double b = 1 ;
		double price_now = 1.0 ; 
		if( x > y ) {
			puts( "-1" ) ;
			continue ;
		}
		int cnt = 0;
		while( true ) {
			if( a == x ) break;
			if( price_now >= price1 ) {
				cnt += x - a ;
				b = y ;
				break;
			}
			double h = price2 * a - 1e-8 ;
			int cha = h - b ;
			cnt += cha ;
			b += cha ;
			price_now = b / a ;
			a ++ ;
			cnt ++ ;
			b += price_now ;
		}
		cnt += y - (int)b;
		printf( "%d\n" , cnt ) ;
	}
	return 0 ;
}

C - Campus Design

题意：　给你一个n*m的棋盘，m<=10 , 用1*1,1*2 的骨牌去覆盖 ， 有些格子不能放骨牌，并且要求1*1放置的骨牌数要在 c 和 d 之间 。

思路 ： 这题是用轮廓线dp去做 ， 但是之前不会 ， 所以看了一下大白书上面的专题 ，看懂之后感觉这题就是入门题啊

轮廓线dp递推的顺序是从左到右从上到下 ， 假设当前是( i , j ) 那么轮廓线dp存储的状态一般为 (i-1,j)(i-1,j+1) ... ( i , j -1 ) 这些格子的状态 ， 然后根据这些格子的状态递推就可以了。

这道题的状态是 dp[当前决策的格子][轮廓线的状态][1*1格子的个数] ， 然后递推就行了

#include 
#include 
#include 
using namespace std;

#define mod 1000000007
int n , m , c , d ;

char mp[105][15] ;
__int64 dp[2][(1<<11)][22] ;
int cur , pre ;
int size ;

void update( int prek , int curk , int prec , int curc ) {
	if( curk & size ) {
		dp[cur][curk^size][curc] += dp[pre][prek][prec] ;
		dp[cur][curk^size][curc] %= mod ;
	}
}

int main(){
	while( scanf( "%d%d%d%d" , &n ,&m , &c , &d ) != EOF ) {
		for( int i = 1 ; i <= n ; i ++ ) 
			scanf( "%s" , mp[i] + 1 ) ;
		memset( dp , 0 , sizeof(dp) ) ;
		size = ( 1<

I - Wall Painting

题意 : 给你n个数 ， 第一天选一个 ， 第二天选两个...第n天选n个。每天我们把选出来数的异或得到一个值 ， 而每天会有C( n , i ) 个值 ， 那么把这C( n , i ) 个值加起来得到一个和。求出每天的这个和。

思路 : 我们把所有的数按位分开 ， 那么对于第i天的第j位 ， 我们只要统计出第j位中选择i个数，有奇数个是1 的方案数是K ， 那么我们加上 K * （1<

至于有多少种方案是奇数个1 ， 组合数随便搞搞就有了 。

#include 
#include 
#include 
using namespace std;

__int64 a ;
int one[40] ;
__int64 ans[1005] ;
#define mod 1000003

__int64 C[1005][1005] ;

void cal() {
	for( int i = 0 ; i <= 1000 ; i ++ ) {
		C[i][0] = C[i][i] = 1 ;
		for( int j = 1 ; j < i ; j ++ ) {
			C[i][j] = ( C[i-1][j-1] + C[i-1][j] ) % mod ;
		}
	}
}

int main(){
	int n; 
	cal() ;
	while( scanf( "%d" , &n ) != EOF ) {
		memset( one , 0 , sizeof(one) ) ;
		for( int i = 1 ; i <= n; i ++ ) {
			scanf( "%I64d" , &a ) ;
			for( int j = 0 ; j < 33 ; j ++ ) {
				if( (a >> j) & 1 ) {
					one[j] ++ ;
				}
			}
		}
		for( int i = 1 ; i <= n ; i ++ ) {
			ans[i] = 0 ;
			for( int j = 0 ; j < 33 ; j ++ ) {
				int One = one[j] , Zero = n - One ;
				for( int k = 1 ; k <= One && k <= i ; k += 2 ) {
					//if( i - k >= Zero ) continue ;
					ans[i] += C[One][k] * C[Zero][i-k] * ( ( (__int64)1 << j ) % mod );
					ans[i] %= mod ;
				}
			}
		}
		for( int i = 1 ;i  <= n; i ++ ) {
			printf( i == 1 ?"%I64d":" %I64d" , ans[i] ) ;
		}
		puts( "" ) ;
	}
	return 0 ;	
}

J - Ball

题意 : 有三种颜色的球 ， 给你然后你按顺序放球 ， 每次放进去一个球，会得到一个分数。分数为放进去求的位置的左边不同颜色的球的个数和右边不同颜色的球的个数。

思路 : 没什么好说的 .. 直接分类讨论就好了

#include 
#include 
#include 
using namespace std;

__int64 a[4] ;

bool cmp( __int64 a , __int64 b ) {
	return a > b ;
}

int main(){
	while( scanf( "%I64d%I64d%I64d" , &a[0] , &a[1] , &a[2] ) != EOF ) {
		sort( a  , a + 3 , cmp ) ;
		if( a[0] == 0 ) {puts( "0" ) ;continue ;}
		if( a[1] == 0 ) {
			if( a[0] == 1 ) {
				puts( "0" ) ;
			}else if( a[0] == 2 ) {
				puts( "1" ) ;
			}else{
				printf( "%I64d\n" , 1 + 2 * ( a[0] - 2 ) ) ;
			}
			continue ;
		}
		if( a[2] == 0 ) {
			if( a[1] == 1 ) {
				if( a[0] == 1 ) puts( "1" ) ;
				else if( a[0] == 2 ) puts( "3" ) ;
				else{
					printf( "%I64d\n" , 1 + 2 + 3 * ( a[0] - 2 ) ) ;
				}
			}else{
				printf( "%I64d\n" , 6 + ( a[0] + a[1] - 4 ) * 4 ) ;
			}
			continue ;
		}
		if( a[2] >= 2 ) {
			printf( "%I64d\n" , 15 + 6 * ( a[1] + a[2] + a[0] - 6 ) ) ;
		}else if( a[1] >= 2 ) {
			printf( "%I64d\n" , 10 + 5 * ( a[0] + a[1] - 4 ) ) ;
		}else if( a[0] >= 2 ) {
			printf( "%I64d\n" , 6 + 4 * ( a[0] - 2 ) ) ;
		}else{
			puts( "3" ) ;
		}
	}
	return 0 ;
}

K . D Tree

题意 : 给你一棵树 ， 每个点有权值 ， 问是否有一条路径的乘积是K 。

思路 : 基于点的分治 ， 对于一个重心 ，我们枚举以重心为根路径，计算出每个点从路径到根的乘积 ， 然后对于这个乘积 Val， 我们通过hash查找 K * inv[Val] 是否存在 。hash[Val] 我存的到当前重心路径乘积为Val中下标最小的点，如果是INF则表示不存在，为了防止两个端点都在同一子树，要先访问完一遍子树，然后再更新hash。

#include 
#include 
#include 
using namespace std;

#pragma comment(linker,"/STACK:102400000,102400000")

typedef __int64 LL ;

#define INF 0x3f3f3f3f
#define MAXN 100005
#define MOD 1000003
int ans[2] ;
int n , m , k ;
bool vis[MAXN] ;
int val[MAXN] ;
int inv[MOD] ;
int pi[MOD] ;

struct Tree{
    struct Edge{
        int to , nex ;
        Edge(){}
        Edge( int _to , int _nex ) {
            to = _to ;
            nex = _nex ;
        }
    }edge[MAXN*2] ;

    int head[MAXN] , Index ;

    void init(){
        memset( head , -1 , sizeof(head) ) ;
        Index = 0 ;
    }

    void add( int from , int to ){
        edge[Index] = Edge( to , head[from] ) ;
        head[from] = Index ++ ;
    }
}tree;

int sum[MAXN] , Max[MAXN] ;

void dfs1( int u , int p ) {
    sum[u] = 1 ;
    Max[u] = 0 ;
    for( int i = tree.head[u] ; ~i ; i = tree.edge[i].nex ) {
        int ch = tree.edge[i].to ;
        if( ch == p || vis[ch] ) continue ;
        dfs1( ch , u  ) ;
        sum[u] += sum[ch] ;
        Max[u] = max( Max[u] , sum[ch] ) ; 
    }
}

int Min , Mini ;

void dfs2( int u , int p , int ss ) {
    int MM = max( Max[u] , ss - sum[u] ) ;
    if( MM < Min ) {
        Min = MM ; Mini = u ;
    }
    for( int i = tree.head[u] ; ~i ; i = tree.edge[i].nex ) {
        int ch = tree.edge[i].to ;
        if( ch == p || vis[ch] ) continue ;
        dfs2( ch , u , ss ) ;
    }
}

int getRoot( int u ) {
    dfs1( u , -1 ) ;
    Mini = -1 ;
    Min = 999999999 ;
    dfs2( u , -1 , sum[u] ) ;
    return Mini ;
}

void dfs3( int u , int p , int Val ) {
    Val = ( (LL)Val * val[u] ) % MOD ;
    int key = ( (LL)k * inv[Val])%MOD ;
    if( pi[ key ] != INF ) {
        int tmp[2] ;
        tmp[0] = u ;
        tmp[1] = pi[ key ] ;
        sort( tmp , tmp + 2 ) ;
        if( (tmp[0] < ans[0]) || ( tmp[0] == ans[0] && tmp[1] < ans[1] )) {
            ans[0] = tmp[0] ;
            ans[1] = tmp[1] ;
        }
    }
    for( int i = tree.head[u] ; ~i ; i = tree.edge[i].nex ) {
        int ch = tree.edge[i].to ;
        if( ch == p || vis[ch] ) continue ;
        dfs3( ch , u , Val  ) ;
    }
 }

void dfs4( int u , int p , int Val ) {
    Val = ( (LL)Val * val[u] ) % MOD ;
    pi[Val] = min( pi[Val] , u ) ;

    for( int i = tree.head[u] ; ~i ; i = tree.edge[i].nex ) {
        int ch = tree.edge[i].to ;
        if( ch == p || vis[ch] ) continue ;
        dfs4( ch , u , Val  ) ;
    }
}

void dfs5( int u , int p , int Val ) {
    Val = ( (LL)Val * val[u] ) % MOD ;
    pi[Val] = INF ;
    for( int i = tree.head[u] ; ~i ; i = tree.edge[i].nex ) {
        int ch = tree.edge[i].to ;
        if( ch == p || vis[ch] ) continue ;
        dfs5( ch , u , Val  ) ;
    }
}

void solve( int u ) {
    // 找重心 
    int root = getRoot( u ) ;
    pi[val[root]] = root ;
    for( int i = tree.head[root] ; ~ i ; i = tree.edge[i].nex ) {
        // 计算各个顶点到根节点的π
        int ch = tree.edge[i].to ;
        if( vis[ch] ) continue ;
        // 查询是否存在路径
        dfs3( ch , root , 1 ) ;
        // 在hash中添加路径
        dfs4( ch , root , val[root] ) ;
    }
    for( int i = tree.head[root] ; ~i ; i = tree.edge[i].nex ) {
        int ch = tree.edge[i].to ;
        if( vis[ch] ) continue ;
        dfs5( ch , root , val[root] ) ;
    }
    pi[val[root]] = INF ;
    vis[root] = true ;
    for( int i = tree.head[root] ; ~i ; i = tree.edge[i].nex ) {
        int ch = tree.edge[i].to ;
        if( vis[ch] ) continue ;
        solve( ch ) ;
    }
}

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

int main(){

    for( int i = 0 ; i < MOD ; i ++ ) {
        inv[i] = power( i , MOD - 2 ) ;
    }

    memset( pi  , INF , sizeof(pi) ) ;

    while( scanf( "%d%d" , &n , &k ) != EOF ) {
        tree.init() ;
        for( int i = 1 ; i <= n ; i ++ ) {
            scanf( "%d" , &val[i] ) ;
        }
        for( int i = 1 ; i < n ; i ++ ) {
            int u , v ;
            scanf( "%d%d" , &u , &v ) ;
            tree.add( u , v ) ;
            tree.add( v , u ) ;
        }
        ans[0] = INF ;
        ans[1] = INF ;
        memset( vis , false , sizeof(vis) ) ;
        solve( 1 ) ;
        if( ans[0] == INF ) {
            puts( "No solution") ;
        }else{
            printf( "%d %d\n" , ans[0] , ans[1] ) ;
        }
    }
    return 0 ;
}