Codeforces Round #254 (Div. 2)

最新推荐文章于 2024-08-11 12:51:39 发布

lishaozhe1024

最新推荐文章于 2024-08-11 12:51:39 发布

阅读量347

点赞数

分类专栏： codeforces 文章标签： codeforces

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

版权

codeforces 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

A. DZY Loves Chessboard

题意 : 给你一个棋盘，有点位置可以放棋子，有些位置不能放棋子。我们要在可以放棋子的地方放上黑子或者白子，相邻两个颜色不能相同。

思路 : 先假设棋盘是好的，那么只要黑白相间的放就行了。那么对于坏棋盘，我们把那些坏掉的格子上的棋子去掉就行了。

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

char mp[105][105] ;

int main(){
	int n , m ;
	while( scanf( "%d%d" , &n , &m ) != EOF ) {
		for( int i = 1 ; i <= n ; i ++ )
			scanf( "%s" , mp[i] + 1 ) ;
		for( int i = 1 ; i <= n ; i ++ ) {
			for( int j = 1 ; j <= m;  j ++ )
				if( mp[i][j] == '.' ) mp[i][j] = ( i + j ) % 2 ? 'B' : 'W' ; 
		}
		for( int i = 1 ;i <= n;  i ++ ) {
			for( int j = 1 ;j <= m ; j ++ ) {
				printf( "%c" , mp[i][j] ) ;
			}
			puts( "" ) ;
		}
	}
	return 0 ;
}

B. DZY Loves Chemistry

题意 : 给你n中化学物质，两种化学物质可能会发生化学反应，告诉你哪些化学物质会发生化学反应。你要按照某种顺序把化学物质放进试管中，当一种化学物质放进试管时，如果现在试管中有化学物质能与其发生反应，那么危险系数就乘以2 ，问按照什么顺序，危险系数最高。一开始危险系数为1。

思路 : 把化学物质看成点，能发生化学反应的物质连上边，那么很显然，假设一个连通分量里面有m个化学物质，必然有某种顺序发生m-1次化学反应。那么很显然最后答案就是 2 ^( n - c ) c 是连通分量个数。用并查集搞搞就行了。

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

#define MAXN 55
int Set[MAXN] ;

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

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

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

int main(){
    int n , m ;
    while( scanf( "%d%d" , &n ,&m ) != EOF ) {
        makeSet( n ) ;
        int t = n ;
        while( m -- ) {
            int a , b ;
            scanf( "%d%d" , &a , &b ) ;
            if( Union( a , b ) ) t -- ;
        }
        __int64 ans = 1 ;
        for( int i = 1 ;i <= n - t ; i ++ ) {
            ans *= 2 ;
        }
        printf( "%I64d\n" , ans ) ;
    }
    return 0 ;
}

C. DZY Loves Physics

题意 : n个点，m条边，点有点权，边有边权，要求你找一个点权和/边权和最小的 induced subgraph 。如果点只有一个，那么这个induced subgraph的值为0 。

induced subgraph的定义是 :

An induced subgraph G'(V', E') of a graphG(V, E) is a graph that satisfies:

$\text{[math]}$ ;
edge $\text{[math]}$ if and only if $\text{[math]}$ , and edge $\text{[math]}$ ;
the value of an edge in G' is the same as the value of the corresponding edge inG, so as the value of a node.

思路 : 我们可以证明选取两个点的induced subgraph是最优的( 如果只有一个，那答案就只能是0了 ) 。

假设我们有一个induced subgraph，这个子图的点大于等于2，设子图中所有的edge(a,b)中，( val(a)+val(b) ) / c 的最大值为 B，那么如果我们能证明这个induced subgraph的权值小于等于B的话，那么就等于我们证明了两个点的induced subgraph是最优的。

那么这个 induced subgraph 的所有的点权为 Σ(vi) <= Σ( val(ai) + val(bi) ) for each edge <= B * Σ( ci )

对于第一个不等式，Σ(vi) 是所有点的权值和，Σ( val(ai) + val(bi) ) for each edge 是每条边的两个顶点之和的和，当顶点数为2的时候，两者相等，否则的话，后者比前者必然会大，因为前者有的点，后者都有，后者部分点还是重复出现的

对于第二个不等式，Σ( val(ai) + val(bi) ) for each edge <= B * Σ( ci ) 因为每条边的 ( val(ai)+val(bi) ) <= B * ci ，那么上面这个不等式也是显然成立的

所以我们就可以得到一个结论，就是 Σ(vi) / Σ(ci) <= B , 并且当且仅当这个 induced subgraph 之后两个点的时候能取到B 。

所以任意一个点数大于三个的induced subgraph权值必然小于其中最优的那条边，所以直接枚举边就好了。

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

int n , m; 

double val[505] ;

int main(){
	while( scanf( "%d%d" , &n , &m ) != EOF ) {
		for( int i = 1 ; i <= n ; i ++ ) 
			scanf( "%lf" , &val[i] ) ;
		double Max = 0 ;
		for( int i = 1 ; i <= m ; i ++ ) {
			int a , b , c ;
			scanf( "%d%d%d" , &a , &b , &c ) ;
			Max = max( Max , ( val[a] + val[b] )/ c ) ;
		}
		printf( "%.12lf\n" , Max ) ;
	}
	return 0 ;
}

D. DZY Loves FFT

题意 : 给你两个数组a 和 b ，让你求出 c[i] = max( a[j] * b[i-j] | j >= 0 && j <= i ) , 其中 a[i] ，b[i] 都是随机数组，并且 b[i] 的值只有 0 或 1

思路 : 比赛的时候被这题虐哭了。完全忽略了这个是随机数据的条件 ...

假设 b 数组中 1 的个数为cnt ，假设这个cnt比较小的话，我们直接可以用 cnt * n 的复杂度跑过去，这里小的定义合理就行，好多人都去了 sqrt(n) .，那复杂度就是 n*sqrt(n)，是可以吃得消的。

如果 b 数组中 1 的个数比较多，对于每个 c[i] 就根据a[]的值从大到小枚举，因为数据是随机的并且b[i]等于1的个数还是比较多的，所以每次枚举的次数其实还是比较小的。

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

#define MAXN 100005
__int64 x ,d ;
int n ;

int a[MAXN] , b[MAXN] , c[MAXN] ;
vector<int> v ;

set<pair<int,int> > s ;
set<pair<int,int> >::iterator it ;

//x is 64-bit variable;
__int64 getNextX() {
    x = (x * 37 + 10007) % 1000000007;
    return x;
}

void initAB() {
    int i ;
	for(i = 0; i < n; i = i + 1){
        a[i] = i + 1;
    }
    for(i = 0; i < n; i = i + 1){
        swap(a[i], a[getNextX() % (i + 1)]);
    }
    for(i = 0; i < n; i = i + 1){
        if (i < d)
            b[i] = 1;
        else
            b[i] = 0;
    }
    for(i = 0; i < n; i = i + 1){
        swap(b[i], b[getNextX() % (i + 1)]);
    }
}


int main(){
	while( scanf( "%d%I64d%I64d" , &n, &d , &x ) != EOF ) {
		initAB() ;
		int cnt = 0 ;
		for( int i = 0 ; i < n;  i ++ )
			if( b[i] ) cnt ++ ;
		memset( c , 0 , sizeof(c) ) ;
		if( (__int64)cnt * cnt <= n ) {
			v.clear() ;
			for( int i = 0 ; i < n ; i ++ ) if( b[i] )v.push_back( i ) ;
			for( int i = 0 ; i < n ; i ++ ) {
				int size = v.size () ;
				for( int j = 0 ; j < size ; j ++ ) {
					if( v[j] > i ) break;
					c[i] = max( c[i] , a[i-v[j]] ) ;
				}
			}
		}else{
			s.clear() ;
			for( int i = 0 ; i < n ; i ++ ) {
				s.insert( pair<int,int>( a[i] , i ) ) ;
				it = s.end() ; it -- ;
				do{
					if( b[i-it->second] ) {
						c[i] = it->first ;
						break;
					}
					if( it == s.begin () ) break;
					it --;
				}while( true ) ;
			}
		}
		for( int i = 0 ; i < n ; i ++ ) 
			printf( "%d\n" , c[i] ) ;
	}
	return 0 ;
}

E. DZY Loves Colors

题意 : 你需要维护两个数组，一开始数组 a[i] = i , b[i] = 0 。

然后又2种操作 : 1. L R X , 把 b[i] 增加 ABS( a[i] - X ) , a[L] ~ a[R] 都变成 X

2. L R 求 b[L] 到 b[R] 的和

思路 : 用线段树维护sum[] , num[] , lazy[] , sum[i] 的一段区间中 b 的和 , num[i] 如果不等于 -1 ，表示一段区间中 a[] 的值全都是num[i] ，否则表示这段区间中 a[] 有两个或以上不同的值，同时num[]也起到懒惰标记的作用， lazy[] 是 sum[] 的懒惰标记。

操作2没什么好说的。

操作1的话，成段更新到某个区间中的值全都一样时候就停止更新，然后打懒惰标记就可以了。

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

#define MAXN 100005
#define lson l , m , rt<<1
#define rson m + 1 , r , rt<<1|1

__int64 ABS( __int64 a ) {
	return a < 0 ? -a : a ;
}

__int64 sum[MAXN<<2] , num[MAXN<<2] , lazy[MAXN<<2] ;  

void push_up( int rt ) {
	sum[rt] = sum[rt<<1] + sum[rt<<1|1] ;
	if( num[rt<<1] == -1 || num[rt<<1|1] == -1 ) 
		num[rt] = -1 ;
	else if( num[rt<<1] == num[rt<<1|1] ) {
		num[rt] = num[rt<<1] ; 
	}else{
		num[rt] = -1 ;
	}
}

void push_down( int rt , int len ) {
	if( lazy[rt] ) {
		lazy[rt<<1] += lazy[rt] ;
		lazy[rt<<1|1] += lazy[rt] ;
		sum[rt<<1] += ( len - len / 2 ) * lazy[rt] ;
		sum[rt<<1|1] += ( len / 2 ) * lazy[rt] ;
		lazy[rt] = 0 ;
	}
	if( num[rt] >= 0 ) {
		num[rt<<1] = num[rt<<1|1] = num[rt] ; 
	}
}

void build( int l , int r , int rt ) {
	lazy[rt] = 0 ;
	if( l == r ) {
		num[rt] = l ;
		sum[rt] = 0 ;
		return ;
	}
	int m = ( l + r ) >> 1 ;
	build( lson ) ;
	build( rson ) ;
	push_up( rt ) ;
}

void update( int l , int r, int rt , int L , int R , __int64 val ) {
	if( l >= L && r <= R ) {
		if( num[rt] >= 0 ) {
			lazy[rt] += ABS( val - num[rt] ) ;
			sum[rt] += ABS( val - num[rt] ) * ( r - l + 1 ) ;
			num[rt] = val ;
			return ;
		}
	}
	if( lazy[rt] || num[rt] >= 0 ) push_down( rt , r - l + 1 ) ;
	int m = ( l + r ) >> 1 ;
	if( L <= m )
		update( lson , L , R , val ) ;
	if( R > m )
		update( rson , L , R , val ) ;
	push_up( rt ) ;
}

__int64 query( int l , int r , int rt , int L , int R ) {
	if( l >= L && r <= R ) {
		return sum[rt] ;
	}
	if( lazy[rt] || num[rt] >= 0 ) push_down( rt , r - l + 1 ) ;
	int m = ( l + r ) >> 1 ;
	__int64 ans = 0 ;
	if( L <= m )
		ans += query( lson , L , R ) ;
	if( R > m )
		ans += query( rson , L , R ) ;
	return ans; 
}

int main(){
	int n , m ;
	while( scanf( "%d%d" , &n , &m ) != EOF ) {
		build( 1 , n , 1 ) ;
		while( m -- ) {
			int t , l , r ;
			__int64 x ;
			scanf( "%d%d%d" , &t , &l , &r ) ;
			if( t == 1 ) {
				scanf( "%I64d" , &x ) ;
				update( 1 , n , 1 , l , r , x ) ;
			}else{
				printf( "%I64d\n" , query( 1 , n , 1 , l , r ) ) ;
			}
		}
	}
	return 0 ;
}