【ACdream】Andrew Stankevich Contest （1）

最新推荐文章于 2024-04-25 09:26:19 发布
最新推荐文章于 2024-04-25 09:26:19 发布
阅读量1.2k 收藏
点赞数
分类专栏： ACdream 题解 文章标签： acdream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013368721/article/details/39719053
版权

A：1210 Chinese Girls' Amusement

大数。如果n%4==0，输出n/2-1，如果n%2==0&&n%4==1，输出n/2-2，如果n%2==1，输出n/2。


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
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 lson ls , l , m
#define rson rs , m + 1 , r
#define mid ( ( l + r ) >> 1 )
#define root 1 , 1 , n

const int MAXN = 100006 ;
 
char s[MAXN] ;
int num[MAXN] ;
 
void solve () {
	int n = strlen ( s ) ;
	rep ( i , 0 , n ) num[i] = s[i] - '0' ;
	int flag = num[n - 1] & 1 ;
	int tmp = 0 ;
	rep ( i , 0 , n ) {
		num[i] += tmp * 10 ;
		tmp = num[i] % 2 ;
		num[i] /= 2 ;
	}
	if ( flag == 1 ) {
		if ( num[0] ) printf ( "%d" , num[0] ) ;
		rep ( i , 1 , n ) printf ( "%d" , num[i] ) ;
		printf ( "\n" ) ;
	} else {
		int del = 1 ;
		rev ( i , n - 1 , 0 ) {
			del = num[i] - del ;
			num[i] = del ;
			del = 0 ;
			if ( num[i] < 0 ) {
				num[i] += 10 ;
				del = 1 ;
			}
		}
		if ( ( num[n - 1] & 1 ) == 0 ) {
			int del = 1 ;
			rev ( i , n - 1 , 0 ) {
				del = num[i] - del ;
				num[i] = del ;
				del = 0 ;
				if ( num[i] < 0 ) {
					num[i] += 10 ;
					del = 1 ;
				}
			}
		}
		if ( num[0] ) printf ( "%d" , num[0] ) ;
		rep ( i , 1 , n ) printf ( "%d" , num[i] ) ;
		printf ( "\n" ) ;
	}
}
 
int main () {
	while ( gets ( s ) ) solve () ;
	return 0 ;
}



B：1211 Reactor Cooling

裸的带下界的可行流。


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
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 lson ls , l , m
#define rson rs , m + 1 , r
#define mid ( ( l + r ) >> 1 )
#define root 1 , 1 , n
 
const int MAXN = 205 ;
const int MAXE = 1000000 ;
const int INF = 0x3f3f3f3f ;
 
struct Edge {
	int v , c , n ;
	Edge () {}
	Edge ( int v , int c , int n ) : v ( v ) , c ( c ) , n ( n ) {}
} E[MAXE] ;
 
int H[MAXN] , cntE ;
int d[MAXN] , cur[MAXN] , pre[MAXN] , num[MAXN] ;
int Q[MAXN] , head , tail ;
int s , t , nv ;
int flow ;
int n , m ;
int in[MAXN] , ou[MAXN] ;
int low[MAXE] ;

void clear () {
	cntE = 0 ;
	clr ( H , -1 ) ;
	clr ( in , 0 ) ;
	clr ( ou , 0 ) ;
}
 
void addedge ( int u , int v , int c ) {
	E[cntE] = Edge ( v , c , H[u] ) ;
	H[u] = cntE ++ ;
	E[cntE] = Edge ( u , 0 , H[v] ) ;
	H[v] = cntE ++ ;
}
 
void rev_bfs () {
	clr ( d , -1 ) ;
	clr ( num , 0 ) ;
	head = tail = 0 ;
	Q[tail ++] = t ;
	d[t] = 0 ;
	num[0] = 1 ;
	while ( head != tail ) {
		int u = Q[head ++] ;
		for ( int i = H[u] ; ~i ; i = E[i].n ) {
			int v = E[i].v ;
			if ( ~d[v] ) continue ;
			d[v] = d[u] + 1 ;
			num[d[v]] ++ ;
			Q[tail ++] = v ;
		}
	}
}
 
int ISAP () {
	rev_bfs () ;
	cpy ( cur , H ) ;
	flow = 0 ;
	int u = pre[s] = s , i , pos , f , minv ;
	while ( d[s] < nv ) {
		if ( u == t ) {
			f = INF ;
			for ( i = s ; i != t ; i = E[cur[i]].v ) {
				if ( f > E[cur[i]].c ) {
					f = E[cur[i]].c ;
					pos = i ;
				}
			}
			for ( i = s ; i != t ; i = E[cur[i]].v ) {
				E[cur[i]].c -= f ;
				E[cur[i] ^ 1].c += f ;
			}
			flow += f ;
			u = pos ;
		}
		for ( i = cur[u] ; ~i ; i = E[i].n ) {
			if ( E[i].c && d[u] == d[E[i].v] + 1 ) break ;
		}
		if ( ~i ) {
			cur[u] = i ;
			pre[E[i].v] = u ;
			u = E[i].v ;
		} else {
			if ( 0 == --num[d[u]] ) break ;
			for ( minv = nv , i = H[u] ; ~i ; i = E[i].n ) {
				if ( E[i].c && minv > d[E[i].v] ) {
					minv = d[E[i].v] ;
					cur[u] = i ;
				}
			}
			d[u] = minv + 1 ;
			num[d[u]] ++ ;
			u = pre[u] ;
		}
	}
	return flow ;
}
 
void solve () {
	int u , v , c ;
	clear () ;
	s = 0 ;
	t = n + 1 ;
	nv = t + 1 ;
	rep ( i , 0 , m ) {
		scanf ( "%d%d%d%d" , &u , &v , &low[i] , &c ) ;
		in[v] += low[i] ;
		ou[u] += low[i] ;
		addedge ( u , v , c - low[i] ) ;
	}
	For ( i , 1 , n ) {
		int tmp = in[i] - ou[i] ;
		if ( tmp > 0 ) addedge ( s , i ,  tmp ) ;
		if ( tmp < 0 ) addedge ( i , t , -tmp ) ;
	}
	ISAP () ;
	int ok = 1 ;
	for ( int i = H[s] ; ~i ; i = E[i].n ) if ( E[i].c ) ok = 0 ;
	if ( ok == 0 ) {
		printf ( "NO\n" ) ;
	} else {
		printf ( "YES\n" ) ;
		rep ( i , 0 , m ) printf ( "%d\n" , low[i] + E[i << 1 | 1].c ) ;
	}
}
 
int main () {
	while ( ~scanf ( "%d%d" , &n , &m ) ) solve () ;
	return 0 ;
}



D：1213 Matrix Multiplication

所有边的两个点的度之和即答案。观察找规律可知，两个矩阵相乘时如果对应位置为1则必定是两条线段有公共点。


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
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 lson ls , l , m
#define rson rs , m + 1 , r
#define mid ( ( l + r ) >> 1 )
#define root 1 , 1 , n

const int MAXN = 10005 ;
const int MAXE = 100005 ;
 
struct Seg {
	int u , v ;
} seg[MAXE] ;
 
int num[MAXN] ;
int n , m ;
 
void solve () {
	clr ( num , 0 ) ;
	rep ( i , 0 , m ) {
		scanf ( "%d%d" , &seg[i].u , &seg[i].v ) ;
		num[seg[i].u] ++ ;
		num[seg[i].v] ++ ;
	}
	LL ans = 0 ;
	rep ( i , 0 , m ) {
		ans += num[seg[i].u] ;
		ans += num[seg[i].v] ;
	}
	printf ( "%lld\n" , ans ) ;
}
 
int main () {
	while ( ~scanf ( "%d%d" , &n , &m ) ) solve () ;
	return 0 ;
}



E：1214 Nice Patterns Strike Back

因为下一列只与上一列的状态有关，可以暴力判断预处理出转移矩阵。高精度+矩阵快速幂，比赛的时候高精度写错了，蛋疼死。。


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
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 lson ls , l , m
#define rson rs , m + 1 , r
#define mid ( ( l + r ) >> 1 )
#define root 1 , 1 , cnt
 
const int M = 50 ;
const int L = 10 ;
 
int mod ;
 
struct BigInt {
	int digit[1005] ;
	int length ;
	BigInt () {}
	BigInt ( char buf[] ) : length ( 0 ) {
		clr ( digit , 0 ) ;
		length = strlen ( buf ) ;
		rep ( i , 0 , length ) digit[i] = buf[length - i - 1] - '0' ;
	}
	int operator [] ( const int& index ) const {
		return digit[index] ;
	}
	int& operator [] ( const int& index ) {
		return digit[index] ;
	}
	BigInt fix () {
		while ( length && digit[length - 1] == 0 ) -- length ;
		return *this ;
	}
	BigInt operator / ( const int& b ) {
		BigInt c ;
		c.length = length ;
		int tmp = 0 ;
		rev ( i , length - 1 , 0 ) {
			c[i] = digit[i] + tmp * 10 ;
			tmp = c[i] % b ;
			c[i] /= b ;
		}
		return c.fix () ;
	}
	BigInt operator - ( const int& b ) {
		BigInt c ;
		c.length = length ;
		int tmp = b ;
		rep ( i , 0 , length ) {
			tmp = digit[i] - tmp ;
			c[i] = tmp ;
			tmp = 0 ;
			if ( c[i] < 0 ) {
				c[i] += 10 ;
				tmp = 1 ;
			}
		}
		return c.fix () ;
	}
	void show () {
		if ( length == 0 ) {
			printf ( "0\n" ) ;
			return ;
		}
		printf ( "%d" , digit[length - 1] ) ;
		rev ( i , length - 2 , 0 ) printf ( "%d" , digit[i] ) ;
		printf ( "\n" ) ;
	}
} ;
 
struct Matrix {
	int mat[M][M] ;
	int n ;
	Matrix () {
		clr ( mat , 0 ) ;
	}
	Matrix ( int n ) : n ( n ) {
		clr ( mat , 0 ) ;
	}
	void eyes () {
		clr ( mat , 0 ) ;
		rep ( i , 0 , n ) mat[i][i] = 1 ;
	}
	void empty () {
		clr ( mat , 0 ) ;
	}
	Matrix operator * ( const Matrix& a ) const {
		Matrix c ( n ) ;
		rep ( i , 0 , n ) rep ( j , 0 , n ) rep ( k , 0 , n ) {
			c.mat[i][j] = ( c.mat[i][j] + mat[i][k] * a.mat[k][j] ) % mod ;
		}
		return c ;
	}
	void show () {
		rep ( i , 0 , n ) {
			rep ( j , 0 , n ) printf ( "%d " , mat[i][j] ) ;
			printf ( "\n" ) ;
		}
	}
} ;
 
Matrix A[6] ;
char buf[500] ;
int m ;
 
int check ( int a , int b , int n ) {
	int cnt1 = 0 ;
	int cnt2 = 0 ;
	rep ( i , 0 , n ) {
		if ( a % 2 == 0 && b % 2 == 0 ) {
			cnt1 ++ ;
			cnt2 = 0 ;
			if ( cnt1 == 2 ) return 0 ;
		} else if ( a % 2 == 1 && b % 2 == 1 ) {
			cnt2 ++ ;
			cnt1 = 0 ;
			if ( cnt2 == 2 ) return 0 ;
		} else cnt1 = cnt2 = 0 ;
		a >>= 1 ;
		b >>= 1 ;
	}
	return 1 ;
}
 
void fun () {
	For ( i , 1 , 5 ) {
		int S = 1 << i ;
		A[i].n = S ;
		A[i].empty () ;
		rep ( j , 0 , S ) {
			rep ( k , 0 , S ) {
				if ( check ( j , k , i ) ) A[i].mat[j][k] = 1 ;
			}
		}
	}
}
 
Matrix pow ( Matrix& a , BigInt& b ) {
	Matrix res ( a.n ) ;
	Matrix tmp = a ;
	res.eyes () ;
	while ( b.length ) {
		if ( b[0] & 1 ) res = res * tmp ;
		tmp = tmp * tmp ;
		b = b / 2 ;
	}
	return res ;
}
 
 
void solve () {
	BigInt c ( buf ) ;
	c = c - 1 ;
	Matrix res = pow ( A[m] , c ) ;
	int S = 1 << m ;
	int ans = 0 ;
	rep ( i , 0 , S ) rep ( j , 0 , S ) ans = ( ans + res.mat[i][j] ) % mod ;
	printf ( "%d\n" , ans ) ;
}
 
int main () {
	fun () ;
	while ( ~scanf ( "%s%d%d" , buf , &m ,&mod ) ) solve () ;
	return 0 ;
}



G：1216 Beautiful People

线段树优化DP。

先将所有点按照第一个关键字排序，将第二个关键字离散化。然后按第一关键字从小到大扫所有的人，一段一段的更新第一关键字相同的。每一段相同关键字的人用query求出他的最优值，以及最优值对应的id，然后更新前驱，接下来用栈保存他的信息，直到所有第一关键字相同的人都查询完后，再将栈中保存的信息用以更新线段树，线段树中以b作为下标，每个区间保存这个区间的最大单调子序列的长度以及结尾元素的id。


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
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 lson ls , l , m
#define rson rs , m + 1 , r
#define mid ( ( l + r ) >> 1 )
#define root 1 , 1 , cnt

const int MAXN = 300005 ;
 
struct Node {
	int a , b , idx ;
	bool operator < ( const Node& t ) const {
		return a < t.a ;
	}
} node[MAXN] ;
 
struct Stack {
	int pos , max , idx ;
	Stack () {}
	Stack ( int pos , int max , int idx ) : pos ( pos ) , max ( max ) , idx ( idx ) {}
} S[MAXN] ;
 
int top ;
int pre[MAXN] ;
int maxv[MAXN << 2] ;
int idx[MAXN << 2] ;
int a[MAXN] , cnt ;
int n ;
 
int unique ( int n ) {
	int cnt = 1 ;
	sort ( a + 1 , a + n + 1 ) ;
	For ( i , 2 , n ) if ( a[i] != a[cnt] ) a[++ cnt] = a[i] ;
	return cnt ;
}
 
int hash ( int x ) {
	int l = 1 , r = cnt ;
	while ( l < r ) {
		int m = ( l + r ) >> 1 ;
		if ( a[m] >= x ) r = m ;
		else l = m + 1 ;
	}
	return l ;
}
 
void update ( int x , int _max , int _idx , int o , int l , int r ) {
	while ( l < r ) {
		int m = ( l + r ) >> 1 ;
		if ( x <= m ) {
			o = o << 1 ;
			r = m ;
		} else {
			o = o << 1 | 1 ;
			l = m + 1 ;
		}
	}
	maxv[o] = _max ;
	idx[o] = _idx ;
	while ( o > 1 ) {
		o >>= 1 ;
		if ( maxv[ls] > maxv[rs] ) {
			maxv[o] = maxv[ls] ;
			idx[o] = idx[ls] ;
		} else {
			maxv[o] = maxv[rs] ;
			idx[o] = idx[rs] ;
		}
	}
}
 
int query_idx , query_max ;
int stack[MAXN] ;
 
void query ( int L , int R , int o , int l , int r ) {
	if ( L > R ) return ;
	if ( L <= l && r <= R ) {
		if ( query_max < maxv[o] ) {
			query_max = maxv[o] ;
			query_idx = idx[o] ;
		}
		return ;
	}
	int m = mid ;
	if ( L <= m ) query ( L , R , lson ) ;
	if ( m <  R ) query ( L , R , rson ) ;
}
 
void solve () {
	cnt = 0 ;
	clr ( pre , 0 ) ;
	clr ( maxv , 0 ) ;
	clr ( idx , 0 ) ;
	For ( i , 1 , n ) {
		scanf ( "%d%d" , &node[i].a , &node[i].b ) ;
		node[i].idx = i ;
		a[++ cnt] = node[i].b ;
	}
	cnt = unique ( cnt ) ;
	sort ( node + 1 , node + n + 1 ) ;
	For ( i , 1 , n ) {
		int j = i ;
		top = 0 ;
		while ( j <= n && node[i].a == node[j].a ) {
			query_idx = 0 ;
			query_max = 0 ;
			int R = hash ( node[j].b ) ;
			query ( 1 , R - 1 , root ) ;
			pre[node[j].idx] = query_idx ;
			S[top ++] = Stack ( R , query_max + 1 , node[j].idx ) ;
			//printf ( "%d %d %d\n" , R , query_max + 1 , j ) ;
			++ j ;
		}
		rep ( k , 0 , top ) update ( S[k].pos , S[k].max , S[k].idx , root ) ;
		i = j - 1 ;
	}
	printf ( "%d\n" , maxv[1] ) ;
	top = 0 ;
	for ( int i = idx[1] ; i ; i = pre[i] ) {
		stack[top ++] = i ;
	}
	sort ( stack , stack + top ) ;
	rep ( i , 0 , top ) printf ( "%d%c" , stack[i] , i < top - 1 ? ' ' : '\n' ) ;
}
 
int main () {
	scanf ( "%d" , &n ) ;
	solve () ;
	return 0 ;
}



poursoul
关注
专栏目录
ACdream Andrew Stankevich's Contest (2) 哈夫曼树
T_T
10-03 598
题目链接： C - Hyperhuffman Time Limit: 20000/10000MS (Java/Others) Memory Limit: 128000/64000KB (Java/Others) SubmitStatus Problem Description       You might have heard about Huffman e
Andrew Stankevich's Contest #2 Solution
chlxyd的专栏
07-30 1427
Andrew Stankevich's Contest #2 Solution Problem A: NonAbsorbing DFA Problem B: TheTowers of Hanoi Revisited Problem C:Hyperhuffman Problem D: LittleJumper Problem E:Quantization Problem Problem
Andrew Stankevich Contest 45 Problem analysis
10-09
Andrew Stankevich Contest 45 Problem analysis, cf
Andrew Stankevich's Contest (1)
Remilia's
10-02 1731
Andrew Stankevich's Contest (1) 打一半出门了，回来才补完了。。。各种大数又不能上java。。也是蛋疼无比 A：根据置换循环节很容易得出要gcd(x, n) = 1并且x B：限制下限的最大流，建模方法为原来容量变成c - l，然后源点连到每个点的下限和为正，每个点下限和为负连到汇点，跑一下最大流，如果源点流出的全部满流就是有解，然后输出的时候只要
Andrew Stankevich Contest #1 (ASC #1) 练习赛
dingdi3021的博客
04-10 213
2015-04-1012:57:22 总结：定期的 asc 训练赛... 　　第一场打得不是很认真... 中间走神了，以后尽量选在整块的时间来打 asc 。 　　5h 过了 4题，5h1min过了第 5题，赛后补齐了剩下的3题... 说实话补最后一题（耗时2days）都差点放弃了。。 　　※本场的一些收获： 　　（1）完善了高精度模板。 　　（2）学习了dinic当前弧优化...
ACdream Andrew Stankevich's Contest(1)
House
10-01 1652
国庆打了场组队  效果还不错  季军  现在发下题解 A： 高精度模拟即可  与n互素的数不会离n/2太远  直接暴力 代码： #include #include #include #include using namespace std; //compare比较函数：相等返回0，大于返回1，小于返回-1 int compare(string str1, string str2) {
Andrew Stankevich Contest
LzyRapX
10-12 1059
Andrew Stankevich Contest
2007-2008 Winter Petrozavodsk Camp, Andrew Stankevich Contest 30-G - Pulp Fiction-贪心+优先队列
缺氧
04-02 721
http://codeforces.com/gym/100345/problem/G 题意：两兄弟要合作写n本书 接下来有n对 ri,pi，表示这本书在第ri天被弟弟构思完成，需要花pi天被哥哥写完 哥哥写正在写A书时，可以跳去写B书，然后再回来写A书（也可以再跳去写C书） 每本书写完的时间是Ci。最ci之和最小值 思路： 如果要写n本数，那么前面不管顺序
【DP】Gym100524E Ebola Virus
Tooc0ld
12-07 357
Souce:2014-2015 Summer Petrozavodsk Camp, Andrew Stankevich Contest 46 (ASC 46) Problem: n个村庄，如果第i个村庄没有被治疗，每天会死掉a[i]个人。现在起始在第一个村庄，每次选择花费一天的时间 往前走/往后走/治疗当前村庄，使得总共死去的人数最少。 但行动有个限制，如果你的前进方向上有一个曾经被路过但没有被治...
Andrew Stankevich Contest 28 - F
Mr.Phoebe的专栏
07-12 778
Problem F. Move to FrontInput file: mtf.in Output file: mtf.out Time limit: 1 second Memory limit: 256 megabytesMove-to-Front is a method of transforming sequences of positive integer numbers, that
Andrew Stankevich Contest 46 [Solo]
On my fighting way
11-03 1441
因为某些奇奇怪怪的原因不得不solod
Andrew Stankevich Contest 4——Driving Straight
Confidence的专栏
10-09 1458
输入m、n，之后是2*m-1行，2*n-1列。‘ ’表示不能通过，‘+’可以通过，‘-’、‘|’只允许一个方向通过（和符号相同的方向），求从左下角到右上角的最短路并输出：输出时候，尽量保持之前的运动方向。每到一个‘+’点，输出当前采取的运动操作：R，右转；L，左转；F，直行。最开始的时候输出：N，向北走；E向东走
Andrew Stankevich's Contest #1 Solution
chlxyd的专栏
07-18 1081
Andrew Stankevich's Contest #1 Solution Problem A: ChineseGirls' Amusement Problem B: ReactorCooling Problem C: NewYear Bonus Grant Problem D: MatrixMultiplication Problem E: NicePatterns Strike
Andrew Stankevich Contest 35 简要题解
Your magic is mine
08-15 1019
F. Graph Factorization 题意：给出一张2n阶的完全图，现在要求将他的边划分为m个部分，每个部分要求每个顶点的度是aia_i,保证∑ai\sum a_i =n+n-1 分析：智商题，首先就是要构造全是1的，然后按照要求叠加就可以了，构造的核心在于如何能让边用的不重复，有一种简单的构造方法就是每次把1 i单独拿出来，剩下的点在i的两侧分布，对称的点之间连边就可以。J
Andrew Stankevich Contest 35 ( ASC 35 ) ( Codeforces Gym 100417 ) A 12:30PM 视频讲解
Edward Shi的博客
03-13 406
Andrew Stankevich Contest 35 (ASC 35) A 题讲解
Andrew Stankevich Contest 47 ( ASC 47 ) ( Codeforces Gym 100608B) Borderless Words
最新发布
Edward Shi的博客
04-25 797
等价于非空最小border，由于非空最小 border 是。的，所以不会有重复计算，故这里选用非空最小 border。不过，注意由于前面规定的为小于而非等于，所以忽略了前。对于转移，考虑枚举非空最小 border 的长度。构成，且最长公共前后缀（border）为。如果二分（或按位判断，本质上是一样的）第。的个数（注意：为了转移方便，不取等于）。，那么剩余需要解决的为所有字典序小于。则一个字符串的形态如上图所示，其中前。均为满足条件的字符串，而。注意，要进行记忆化，否则会。的时候的方案数是多少呢？
2013-2014 Summer Petrozavodsk Camp, Andrew Stankevich Contest 44 (ASC 44)
尘的博客
08-31 812
暑训最后一场组队训练赛，特么故意的，把别人的WF练习题给我们写，写了半天才签到两题。靠！ B - Braess's Paradox  Gym - 100518B  题意：有几个点，每个点到下一个点之间有两条路。上面一条路的通过时间是 A*K1+B,下面一条通过时间是C*K2+D，要两条路通过的时间数尽量相同，K1+K2=1(K1,K2是经过的人流量占总人数的比例)。然后中间的点可以建驿站，如...
训练记录PART5 2018.6.15~8.15
weixin_30797199的博客
07-21 228
友情提醒：大部分题选自opentrains，以后有训练需要的同学慎重查看。 6.15 Petrozavodsk Summer 2013 - Comenius U Selection by Michal Forisek C 　　题意：给出一个长度为 \(N(\leq 10^5)\) 的 \(DURL\) 操作序列。想想一只画笔在无限大的平面上画线，保证线可以相交但不会重合，且最终构成一个回...
Andrew Stankevich's Contest (1)
weixin_33774615的博客
10-13 91
Andrew Stankevich's Contest (1) 打一半出门了，回来才补完了。。。各种大数又不能上java。。也是蛋疼无比 A：依据置换循环节非常easy得出要gcd(x, n) = 1而且x &lt;= n / 2，那么把相应几种情况的最大值考虑一下就可以，各自是n % 2 = 1为n / 2, n % 4 = 0为n / 2 - 1，n % 4 = 2为n...
图论算法：割边求解与应用——烧毁桥梁问题
这部分内容与实际问题相结合，例如例8.4中的“烧毁的桥”问题，来自Andrew Stankevich的竞赛，该问题描述了一个国家岛屿上的桥连接情况，国王需要保留足够的桥梁以便军队可以在岛屿间自由通行。求解的关键就是找出...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值