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:
;
- edge
if and only if
, and edge
;
- 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 ;
}