【ACDream】Andrew Stankevich's Contest (23)

最新推荐文章于 2015-10-09 10:58:21 发布

poursoul

最新推荐文章于 2015-10-09 10:58:21 发布

阅读量1k

点赞数

分类专栏：题解 ACdream 文章标签： acdream

本文链接：https://blog.csdn.net/u013368721/article/details/39831227

版权

题解同时被 2 个专栏收录

25 篇文章 0 订阅

订阅专栏

ACdream

17 篇文章 0 订阅

订阅专栏

B：1424 Diversion

题目大意：给一副图G，给定N个点M条无向边，其中N-1条边为白边，构成一棵树，另M-N+1条边为黑边。其中结点1为首都（题目要求），保证无重边无自环，保证无论是走白边还是黑边，如果有边（u，v），则dist（1，v）=dist（1，u）+dist（u，v）或者dist（1，u）=dist（1，v）+dist（u，v）。题目保证当任意一条白边被删除以后任意两点间依旧连通。现在，你的目标是破坏至多一条白边以及一条黑边使得图不连通，问有多少方案数。

这题我的做法是树链剖分+离线标记法。

首先根据题意我们可知图边双连通，所以如果需要破坏边使得图不连通的话至少需要破坏两条边，所以一定是破坏一条白边以及一条黑边。而且每条树边最多只会属于一个答案，即答案最多等于N-1（证明我就不会了，不过挺显然的）。接下来我们以结点1为根结点，所有白边为树边构成一棵树，那么我们可以发现，如果一条树边可以是方案之一，则这条树边（u，v）所连接的u的子树v中至多只能向子树外连接出去一条黑边！（因为如果存在两条或以上，那么破坏其中一条黑边，则还可以通过另外的黑边使得图连通）

那么我们的思路更加清晰了，一条白边（u，v）可以是方案之一当且仅当其连接的u的子树v内向v的子树外最多连接出一条黑边！如果我们将这个连接v的子树到v子树外一点的黑边（x，y）视为将路径x--y上的边染色（易知该染色一定经过边（u，v），那么符合条件的所有边就是在所有染色都结束后被染色次数不超过一次的边！

这样我们就可以用树链剖分维护整棵树，树链剖分内可以用线段树维护染色次数（区间加法），也可以用标记法标记区间（比如子区间【L，R】，则位置L上+1，位置R+1上-1）再最后扫一遍标记数组即可得到答案。

还不会树链剖分的同志们赶紧去学一学吧~

代码如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
//#include <cmath>
#include <queue>
using namespace std ;
 
typedef long long LL ;
 
#define rep( i , a , b ) for ( int i = a ; i < b ; ++ i )
#define For( i , a , b ) for ( int i = a ; i <= b ; ++ i )
#define rev( i , a , b ) for ( int i = a ; i >= b ; -- i )
#define travel( e , H , u ) for ( Edge* e = H[u] ; e ; e = e -> next )
#define clr( a , x ) memset ( a , x , sizeof a )
#define cpy( a , x ) memcpy ( a , x , sizeof a )
#define ls ( o << 1 )
#define rs ( o << 1 | 1 ) 
#define root 1 , 1 , n
#define lson ls , l , m
#define rson rs , m + 1 , r
#define mid ( ( l + r ) >> 1 )

const int MAXN = 20005 ;
const int MAXE = 200005 ;

struct Edge {
	int v ;
	Edge* next ;
} E[MAXE] , *H[MAXN] , *edge ;

struct Seg {
	int x , y ;
	Seg () {}
	Seg ( int x , int y ) : x ( x ) , y ( y ) {}
} seg[MAXE] ;

int add[MAXN] ;
int siz[MAXN] ;
int dep[MAXN] ;
int son[MAXN] ;
int top[MAXN] ;
int pos[MAXN] ;
int pre[MAXN] ;
int tree_idx ;
int n , m ;
int ans ;
int cnt ;

void clear () {
	cnt = 0 ;
	edge = E ;
	siz[0] = 0 ;
	tree_idx = 0 ;
	clr ( H , 0 ) ;
	clr ( add , 0 ) ;
}

void addedge ( int u , int v ) {
	edge->v = v ;
	edge->next = H[u] ;
	H[u] = edge ++ ;
}

void dfs ( int u ) {
	siz[u] = 1 ;
	son[u] = 0 ;
	travel ( e , H , u ) {
		int v = e->v ;
		if ( v == pre[u] ) continue ;
		pre[v] = u ;
		dep[v] = dep[u] + 1 ;
		dfs ( v ) ;
		siz[u] += siz[v] ;
		if ( siz[v] > siz[son[u]] ) son[u] = v ;
	}
}

void rebuild ( int u , int top_element ) {
	top[u] = top_element ;
	pos[u] = ++ tree_idx ;
	if ( son[u] ) rebuild ( son[u] , top_element ) ;
	travel ( e , H , u ) {
		int v = e->v ;
		if ( v != pre[u] && v != son[u] ) rebuild ( v , v ) ;
	}
}

void update ( int x , int y ) {
	while ( top[x] != top[y] ) {
		if ( dep[top[x]] < dep[top[y]] ) swap ( x , y ) ;
		++ add[pos[top[x]]] ;
		-- add[pos[x] + 1] ;
		x = pre[top[x]] ;
	}
	if ( x == y ) return ;
	if ( dep[x] > dep[y] ) swap ( x , y ) ;
	++ add[pos[x] + 1] ;
	-- add[pos[y] + 1] ;
}

void solve () {
	int u , v , c ;
	clear () ;
	rep ( i , 0 , m ) {
		scanf ( "%d%d%d" , &u , &v , &c ) ;
		if ( c == 1 ) {
			addedge ( u , v ) ;
			addedge ( v , u ) ;
		} else seg[cnt ++] = Seg ( u , v ) ;
	}
	dfs ( 1 ) ;
	rebuild ( 1 , 1 ) ;
	rep ( i , 0 , cnt ) update ( seg[i].x , seg[i].y ) ;
	ans = 0 ;
	int x = 0 ;
	For ( i , 2 , n ) {
		x += add[i] ;
		if ( x < 2 ) ++ ans ;
	}
	printf ( "%d\n" , ans ) ;
}

int main () {
	while ( ~scanf ( "%d%d" , &n , &m ) ) solve () ;
	return 0 ;
}

E： 1427Nice Sequence

题目意思自己慢慢理会。。。这个我说不来。。

题目分析：求满足题意的最长前缀。

线段树维护区间最小值，每次插入一个数的时候查询比这个数小的数出现的最少的次数，如果不符合则直接退出循环（因为要求必须是满足在最长前缀的任意长度上都满足题目要求），不用看比他大的数，因为如果之前符合条件，则在该数增加数量后依旧符合条件。如果这次增加符合条件则再将这个数的数量+1，再用线段树维护一下即可。

代码如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
//#include <cmath>
#include <queue>
using namespace std ;
  
typedef long long LL ;
  
#define rep( i , a , b ) for ( int i = a ; i < b ; ++ i )
#define For( i , a , b ) for ( int i = a ; i <= b ; ++ i )
#define rev( i , a , b ) for ( int i = a ; i >= b ; -- i )
#define travel( e , H , u ) for ( Edge* e = H[u] ; e ; e = e -> next )
#define clr( a , x ) memset ( a , x , sizeof a )
#define cpy( a , x ) memcpy ( a , x , sizeof a )
#define ls ( o << 1 )
#define rs ( o << 1 | 1)
#define root 1 , 0 , n
#define lson ls , l , m
#define rson rs , m + 1 , r
#define mid ( ( l + r ) >> 1 )
 
const int MAXN = 200005 ;
const int INF = 0x3f3f3f3f ;
 
int sum[MAXN] ;
int minv[MAXN << 2] ;
int n , k ;
 
void push_up ( int o ) {
	minv[o] = min ( minv[ls] , minv[rs] ) ;
}
 
void update ( int pos , int o , int l , int r ) {
	if ( l == r ) {
		sum[l] ++ ;
		minv[o] = sum[l] ;
		return ;
	}
	int m = mid ;
	if ( pos <= m ) update ( pos , lson ) ;
	else update ( pos , rson ) ;
	push_up ( o ) ;
}
 
int query ( int L , int R , int o , int l , int r ) {
	if ( L > R ) return INF ;
	if ( L <= l && r <= R ) return minv[o] ;
	int m = mid ;
	if ( R <= m ) return query ( L , R , lson ) ;
	if ( m <  L ) return query ( L , R , rson ) ;
	return min ( query ( L , R , lson ) , query ( L , R , rson ) ) ;
}
 
void solve () {
	int x ;
	clr ( minv , 0 ) ;
	clr ( sum ,  0 ) ;
	int ans = 0 , flag = 0 ;
	For ( i , 1 , n ) {
		scanf ( "%d" , &x ) ;
		if ( flag ) continue ;
		update ( x , root ) ;
		int min_num = query ( 0 , x - 1 , root ) ;
		if ( min_num < sum[x] - k ) {
			flag = 1 ;
			continue ;
		}
		ans = i ;
	}
	printf ( "%d\n" , ans ) ;
}
 
int main () {
	while ( ~scanf ( "%d%d" , &n , &k ) ) solve () ;
	return 0 ;
}

G： 1429 Rectangular Polygon

题目大意：选择尽量多的木棍作为多边形的横边（竖边自动添加），使得该多边形的横边以及竖边均平行于坐标轴。

题目分析：背包。

其实题目的意思就是选择尽量多的木棍并分成两个集合，集合内木棍长度之和相同。

我们设dp[i][j]为选到第i根长度为x的木棍后集合A木棍长度之和-集合B木棍长度之和等于j时选择的最多的木棍数。

则dp[i][j] = max{ dp[i][j-x]+1（该木棍加到集合A中），dp[i][j+x]+1（该木棍加到集合B中） }，然后记录一下路径输出即可~（注意j可能为负，我们加一个大整数变成正数即可）

dp[n][0]即第一个答案。

代码如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
//#include <cmath>
#include <queue>
using namespace std ;
  
typedef long long LL ;
  
#define rep( i , a , b ) for ( int i = a ; i < b ; ++ i )
#define For( i , a , b ) for ( int i = a ; i <= b ; ++ i )
#define rev( i , a , b ) for ( int i = a ; i >= b ; -- i )
#define travel( e , H , u ) for ( Edge* e = H[u] ; e ; e = e -> next )
#define clr( a , x ) memset ( a , x , sizeof a )
#define cpy( a , x ) memcpy ( a , x , sizeof a )
#define ls ( o << 1 )
#define rs ( o << 1 | 1)
#define root 1 , 0 , n
#define lson ls , l , m
#define rson rs , m + 1 , r
#define mid ( ( l + r ) >> 1 )

const int MAXN = 105 ;
const int MAXM = 40005 ;
const int INF = 0x3f3f3f3f ;

int pre[MAXN][MAXM] ;
int dp[MAXN][MAXM] ;
int set1[MAXN] , set2[MAXN] ;
int top1 , top2 ;
int n ;


void solve () {
	int x , y ;
	int L = max ( x , 20000 - n * 200 ) ;
	int R = 20000 + n * 200 ;
	clr ( pre , 0 ) ;
	clr ( dp , -1 ) ;
	top1 = top2 = 0 ;
	dp[0][20000] = 0 ;
	rep ( i , 0 , n ) {
		scanf ( "%d" , &x ) ;
		For ( j , L , R ) {
			if ( dp[i][j] == -1 ) continue ;
			if ( dp[i][j] + 1 > dp[i + 1][j + x] ) {
				dp[i + 1][j + x] = dp[i][j] + 1 ;
				pre[i + 1][j + x] = j ;
			}
			if ( dp[i][j] + 1 > dp[i + 1][j - x] ) {
				dp[i + 1][j - x] = dp[i][j] + 1 ;
				pre[i + 1][j - x] = j ;
			}
			if ( dp[i][j] > dp[i + 1][j] ) {
				dp[i + 1][j] = dp[i][j] ;
				pre[i + 1][j] = j ;
			}
		}
	}
	printf ( "%d\n" , dp[n][20000] ) ;
	if ( !dp[n][20000] ) return ;
	int j = 20000 ;
	rev ( i , n , 1 ) {
		int next = pre[i][j] ;
		if ( next < j ) set1[top1 ++] = j - next ;
		if ( next > j ) set2[top2 ++] = next - j ;
		j = next ;
	}
	x = y = 0 ;
	rep ( i , 0 , top1 ) {
		printf ( "%d %d\n" , x , y ) ;
		x += set1[i] ;
		printf ( "%d %d\n" , x , y ) ;
		++ y ;
	}
	y = -200 ;
	rep ( i , 0 , top2 ) {
		printf ( "%d %d\n" , x , y ) ;
		x -= set2[i] ;
		printf ( "%d %d\n" , x , y ) ;
		++ y ;
	}
}

int main () {
	while ( ~scanf ( "%d" , &n ) ) solve () ;
	return 0 ;
}

H：1430 SETI

题目分析：后缀数组题！暴力枚举字符串长度统计！

我没学后缀数组，所以这题是队友秒的。。队友ORZ！

听说几乎是模板题。。

Ｉ：1431 Sum vs Product

题目分析：暴力DFS！假设有N层，每层不断增加数的大小直到前i层数之和+（N-i）<前i层数之积时退出，同时注意第i层的数不能大于i-1层的数。由于符合条件的集合实在是太少了，所以DFS无压力。

代码如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
//#include <cmath>
#include <queue>
using namespace std ;
  
typedef long long LL ;
  
#define rep( i , a , b ) for ( int i = a ; i < b ; ++ i )
#define For( i , a , b ) for ( int i = a ; i <= b ; ++ i )
#define rev( i , a , b ) for ( int i = a ; i >= b ; -- i )
#define travel( e , H , u ) for ( Edge* e = H[u] ; e ; e = e -> next )
#define clr( a , x ) memset ( a , x , sizeof a )
#define cpy( a , x ) memcpy ( a , x , sizeof a )
#define ls ( o << 1 )
#define rs ( o << 1 | 1)
#define root 1 , 0 , n
#define lson ls , l , m
#define rson rs , m + 1 , r
#define mid ( ( l + r ) >> 1 )
 
int n , ans ;
 
void dfs ( int cur , int N , int add , int mul ) {
	if ( cur == n + 1 ) {
		if ( add == mul ) ans ++ ;
		return ;
	}
	For ( i , 1 , N ) {
		if ( add + i + n - cur < i * mul ) return ;
		dfs ( cur + 1 , i , add + i , mul * i ) ;
	}
}
 
void solve () {
	ans = 0 ;
	dfs ( 1 , n , 0 , 1 ) ;
	printf ( "%d\n" , ans ) ;
}
 
int main () {
	while ( ~scanf ( "%d" , &n ) ) solve () ;
	return 0 ;
}