T1:CF39C Moon Craters
code
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
#define MAXN 2002
vector < int > g[ MAXN << 1 ] ;
int n, cnt, m;
int x[ MAXN] , y[ MAXN] , o[ MAXN << 1 ] ;
int dp[ MAXN << 1 ] [ MAXN << 1 ] , exist[ MAXN << 1 ] [ MAXN << 1 ] , f[ MAXN << 1 ] [ MAXN << 1 ] ;
void print ( int l, int r ) {
if ( l > r || ! dp[ l] [ r] ) return ;
if ( f[ l] [ r] ) print ( l, f[ l] [ r] ) , print ( f[ l] [ r] , r ) ;
else print ( l + 1 , r ) ;
if ( exist[ l] [ r] ) printf ( "%d " , exist[ l] [ r] ) ;
}
int main ( ) {
scanf ( "%d" , & n ) ;
for ( int i = 1 , r, c; i <= n; i ++ ) {
scanf ( "%d %d" , & c, & r ) ;
x[ i] = o[ ++ cnt] = c - r;
y[ i] = o[ ++ cnt] = c + r;
}
sort ( o + 1 , o + cnt + 1 ) ;
m = unique ( o + 1 , o + cnt + 1 ) - o - 1 ;
for ( int i = 1 ; i <= n; i ++ ) {
x[ i] = lower_bound ( o + 1 , o + m + 1 , x[ i] ) - o;
y[ i] = lower_bound ( o + 1 , o + m + 1 , y[ i] ) - o;
g[ x[ i] ] . push_back ( y[ i] ) ;
exist[ x[ i] ] [ y[ i] ] = i;
}
for ( int i = m; i; i -- )
for ( int j = i; j <= m; j ++ ) {
dp[ i] [ j] = dp[ i + 1 ] [ j] ;
for ( int k = 0 ; k < g[ i] . size ( ) ; k ++ ) {
int v = g[ i] [ k] ;
if ( v < j && dp[ i] [ v] + dp[ v] [ j] > dp[ i] [ j] ) {
dp[ i] [ j] = dp[ i] [ v] + dp[ v] [ j] ;
f[ i] [ j] = v;
}
}
dp[ i] [ j] + = ( exist[ i] [ j] ? 1 : 0 ) ;
}
printf ( "%d\n" , dp[ 1 ] [ m] ) ;
print ( 1 , m ) ;
return 0 ;
}
T2:CF1025D Recovering BST
code
#include <cstdio>
#define MAXN 705
int n;
int a[ MAXN] ;
int left[ MAXN] [ MAXN] , right[ MAXN] [ MAXN] ;
bool f[ MAXN] [ MAXN] ;
int gcd ( int x, int y ) {
if ( ! y ) return x;
else return gcd ( y, x % y ) ;
}
int main ( ) {
scanf ( "%d" , & n ) ;
for ( int i = 1 ; i <= n; i ++ ) {
scanf ( "%d" , & a[ i] ) ;
left[ i] [ i] = right[ i] [ i] = 1 ;
}
for ( int i = 1 ; i <= n; i ++ )
for ( int j = 1 ; j <= n; j ++ )
if ( gcd ( a[ i] , a[ j] ) != 1 )
f[ i] [ j] = 1 ;
for ( int i = n; i; i -- )
for ( int j = i; j <= n; j ++ )
for ( int k = i; k <= j; k ++ )
if ( left[ i] [ k] && right[ k] [ j] ) {
if ( i == 1 && j == n ) return ! printf ( "Yes" ) ;
if ( f[ i - 1 ] [ k] ) right[ i - 1 ] [ j] = 1 ;
if ( f[ k] [ j + 1 ] ) left[ i] [ j + 1 ] = 1 ;
}
printf ( "No" ) ;
return 0 ;
}
T3:CF1312E Array Shrinking
code
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
#define MAXN 501
int n;
int dp[ MAXN] [ MAXN] , w[ MAXN] [ MAXN] ;
int main ( ) {
memset ( dp, 0x3f , sizeof ( dp ) ) ;
scanf ( "%d" , & n ) ;
for ( int i = 1 ; i <= n; i ++ )
scanf ( "%d" , & w[ i] [ i] ) , dp[ i] [ i] = 1 ;
for ( int len = 2 ; len <= n; len ++ )
for ( int i = 1 ; i + len - 1 <= n; i ++ ) {
int j = i + len - 1 ;
for ( int k = i; k < j; k ++ ) {
dp[ i] [ j] = min ( dp[ i] [ j] , dp[ i] [ k] + dp[ k + 1 ] [ j] ) ;
if ( dp[ i] [ k] == dp[ k + 1 ] [ j] && dp[ i] [ k] == 1 && w[ i] [ k] == w[ k + 1 ] [ j] )
dp[ i] [ j] = 1 , w[ i] [ j] = w[ i] [ k] + 1 ;
}
}
printf ( "%d" , dp[ 1 ] [ n] ) ;
return 0 ;
}
T4:CF1178F1 Short Colorful Strip
code
#include <cstdio>
#define MAXN 505
#define lyx 998244353
int n, m;
int c[ MAXN] ;
int dp[ MAXN] [ MAXN] ;
int dfs ( int l, int r ) {
if ( l > r ) return 1 ;
if ( dp[ l] [ r] ) return dp[ l] [ r] ;
int p = l, temp = 0 ;
for ( int i = l; i <= r; i ++ )
if ( c[ i] < c[ p] ) p = i;
for ( int i = l; i <= p; i ++ )
temp = ( 1ll * temp + 1ll * dfs ( l, i - 1 ) * dfs ( i, p - 1 ) % lyx ) % lyx;
for ( int i = p; i <= r; i ++ )
dp[ l] [ r] = ( 1ll * dp[ l] [ r] + 1ll * temp * dfs ( p + 1 , i ) % lyx * dfs ( i + 1 , r ) % lyx ) % lyx;
return dp[ l] [ r] ;
}
int main ( ) {
scanf ( "%d %d" , & n, & m ) ;
for ( int i = 1 ; i <= m; i ++ )
scanf ( "%d" , & c[ i] ) ;
printf ( "%d" , dfs ( 1 , n ) ) ;
return 0 ;
}
T5:CF1336C Kaavi and Magic Spell
code
#include <cstdio>
#include <cstring>
#define MAXN 3005
#define lyx 998244353
int n, m, ans;
char s[ MAXN] , t[ MAXN] ;
int dp[ MAXN] [ MAXN] ;
int main ( ) {
scanf ( "%s %s" , s + 1 , t + 1 ) ;
int n = strlen ( s + 1 ) , m = strlen ( t + 1 ) ;
for ( int i = 1 ; i <= n; i ++ )
dp[ i] [ i] = ( i > m || s[ 1 ] == t[ i] ) << 1 ;
for ( int len = 2 ; len <= n; len ++ )
for ( int i = 1 ; i + len - 1 <= n; i ++ ) {
int j = i + len - 1 ;
if ( i > m || s[ len] == t[ i] ) dp[ i] [ j] = ( dp[ i] [ j] + dp[ i + 1 ] [ j] ) % lyx;
if ( j > m || s[ len] == t[ j] ) dp[ i] [ j] = ( dp[ i] [ j] + dp[ i] [ j - 1 ] ) % lyx;
}
for ( int i = m; i <= n; i ++ )
ans = ( ans + dp[ 1 ] [ i] ) % lyx;
printf ( "%d" , ans ) ;
return 0 ;
}
T6:CF49E Common ancestor
code
#include <cstdio>
#include <vector>
#include <cstring>
using namespace std;
#define MAXN 55
vector < pair < int , int > > g[ MAXN << 2 ] ;
int len1, len2, n;
char s1[ MAXN] , s2[ MAXN] , s[ MAXN] ;
int dp[ MAXN] [ MAXN] , f1[ MAXN] [ MAXN] [ MAXN << 2 ] , f2[ MAXN] [ MAXN] [ MAXN << 2 ] ;
int main ( ) {
scanf ( "%s %s" , s1 + 1 , s2 + 1 ) ;
len1 = strlen ( s1 + 1 ) , len2 = strlen ( s2 + 1 ) ;
scanf ( "%d" , & n ) ;
for ( int i = 1 ; i <= n; i ++ ) {
scanf ( "%s" , s ) ;
g[ s[ 0 ] ] . push_back ( make_pair ( s[ 3 ] , s[ 4 ] ) ) ;
}
for ( int i = 1 ; i <= len1; i ++ ) f1[ i] [ i] [ s1[ i] ] = 1 ;
for ( int i = 1 ; i <= len2; i ++ ) f2[ i] [ i] [ s2[ i] ] = 1 ;
memset ( dp, 0x3f , sizeof ( dp ) ) ; dp[ 0 ] [ 0 ] = 0 ;
for ( int len = 2 ; len <= len1; len ++ )
for ( int i = 1 ; i + len - 1 <= len1; i ++ ) {
int j = i + len - 1 ;
for ( int ch = 'a' ; ch <= 'z' ; ch ++ )
for ( int k = i; k < j; k ++ )
for ( int u = 0 ; u < g[ ch] . size ( ) ; u ++ )
f1[ i] [ j] [ ch] | = f1[ i] [ k] [ g[ ch] [ u] . first] && f1[ k + 1 ] [ j] [ g[ ch] [ u] . second] ;
}
for ( int len = 2 ; len <= len2; len ++ )
for ( int i = 1 ; i + len - 1 <= len2; i ++ ) {
int j = i + len - 1 ;
for ( char ch = 'a' ; ch <= 'z' ; ch ++ )
for ( int k = i; k < j; k ++ )
for ( int u = 0 ; u < g[ ch] . size ( ) ; u ++ )
f2[ i] [ j] [ ch] | = f2[ i] [ k] [ g[ ch] [ u] . first] && f2[ k + 1 ] [ j] [ g[ ch] [ u] . second] ;
}
for ( int i = 1 ; i <= len1; i ++ )
for ( int j = 1 ; j <= len2; j ++ )
for ( int ii = 1 ; ii <= i; ii ++ )
for ( int jj = 1 ; jj <= j; jj ++ )
for ( char ch = 'a' ; ch <= 'z' ; ch ++ )
if ( f1[ ii] [ i] [ ch] && f2[ jj] [ j] [ ch] )
dp[ i] [ j] = min ( dp[ i] [ j] , dp[ ii - 1 ] [ jj - 1 ] + 1 ) ;
printf ( "%d" , ( dp[ len1] [ len2] == 0x3f3f3f3f ) ? - 1 : dp[ len1] [ len2] ) ;
return 0 ;
}
T7:CF838E Convex Countour
code
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
#define MAXN 2505
struct node {
int x, y;
node ( ) { }
node ( int X, int Y ) {
x = X, y = Y;
}
} s[ MAXN] ;
int n;
double dp[ MAXN] [ MAXN] [ 2 ] ;
double dis ( node u, node v ) {
return sqrt ( 1.0 * ( u. x - v. x ) * ( u. x - v. x ) + 1.0 * ( u. y - v. y ) * ( u. y - v. y ) ) ;
}
int main ( ) {
scanf ( "%d" , & n ) ;
for ( int i = 0 ; i < n; i ++ )
scanf ( "%d %d" , & s[ i] . x, & s[ i] . y ) ;
for ( int len = 2 ; len <= n; len ++ )
for ( int i = 0 ; i < n; i ++ ) {
int j = ( i + len - 1 ) % n;
dp[ i] [ j] [ 0 ] = max ( dp[ ( i + 1 ) % n] [ j] [ 0 ] + dis ( s[ i] , s[ ( i + 1 ) % n] ) , dp[ ( i + 1 ) % n] [ j] [ 1 ] + dis ( s[ i] , s[ j] ) ) ;
dp[ i] [ j] [ 1 ] = max ( dp[ i] [ ( j - 1 + n ) % n] [ 0 ] + dis ( s[ i] , s[ j] ) , dp[ i] [ ( j - 1 + n ) % n] [ 1 ] + dis ( s[ ( j - 1 + n ) % n] , s[ j] ) ) ;
}
double ans = 0 ;
for ( int i = 0 ; i < n; i ++ )
ans = max ( ans, max ( dp[ i] [ ( i - 1 + n ) % n] [ 0 ] , dp[ i] [ ( i - 1 + n ) % n] [ 1 ] ) ) ;
printf ( "%.10f" , ans ) ;
return 0 ;
}
T8:CF1107E Vasya and Binary String
code
#include <cstdio>
#include <iostream>
using namespace std;
#define ll long long
#define MAXN 105
int n;
char s[ MAXN] ;
ll a[ MAXN] ;
ll dp[ MAXN] [ MAXN] [ MAXN] ;
int main ( ) {
scanf ( "%d %s" , & n, s + 1 ) ;
for ( int i = 1 ; i <= n; i ++ )
scanf ( "%lld" , & a[ i] ) ;
for ( int i = 1 ; i <= n; i ++ )
for ( int j = 1 ; j < i; j ++ )
a[ i] = max ( a[ i] , a[ j] + a[ i - j] ) ;
for ( int len = 1 ; len <= n; len ++ )
for ( int i = 1 ; i + len - 1 <= n; i ++ ) {
int j = i + len - 1 ;
for ( int k = 0 ; k <= n; k ++ ) {
dp[ i] [ j] [ k] = max ( dp[ i] [ j] [ k] , dp[ i + 1 ] [ j] [ 0 ] + a[ k + 1 ] ) ;
for ( int p = i + 1 ; p <= j; p ++ )
if ( s[ i] == s[ p] )
dp[ i] [ j] [ k] = max ( dp[ i] [ j] [ k] , dp[ i + 1 ] [ p - 1 ] [ 0 ] + dp[ p] [ j] [ k + 1 ] ) ;
}
}
printf ( "%lld" , dp[ 1 ] [ n] [ 0 ] ) ;
return 0 ;
}
T9:CF1101F Trucks and Cities
code
#include <cstdio>
#include <vector>
#include <cstring>
#include <iostream>
using namespace std;
#define ll long long
#define MAXN 405
#define MAXM 250005
vector < int > g[ MAXN] ;
int n, m;
ll ans;
ll a[ MAXN] , s[ MAXM] , t[ MAXM] , c[ MAXM] , r[ MAXM] ;
ll dp[ MAXN] [ MAXN] [ 2 ] ;
int main ( ) {
scanf ( "%d %d" , & n, & m ) ;
for ( int i = 1 ; i <= n; i ++ )
scanf ( "%lld" , & a[ i] ) ;
for ( int i = 1 ; i <= m; i ++ ) {
scanf ( "%lld %lld %lld %lld" , & s[ i] , & t[ i] , & c[ i] , & r[ i] ) ;
r[ i] = min ( r[ i] + 1 , t[ i] - s[ i] ) ;
g[ r[ i] ] . push_back ( i ) ;
}
memset ( dp, 0x7f , sizeof ( dp ) ) ;
for ( int i = 1 ; i <= n; i ++ )
for ( int j = i; j <= n; j ++ )
dp[ i] [ j] [ 1 ] = a[ j] - a[ i] ;
for ( int k = 1 ; k < n; k ++ ) {
for ( int i = 0 ; i < g[ k] . size ( ) ; i ++ )
ans = max ( ans, dp[ s[ g[ k] [ i] ] ] [ t[ g[ k] [ i] ] ] [ k & 1 ] * c[ g[ k] [ i] ] ) ;
for ( int i = 1 ; i <= n; i ++ ) {
dp[ i] [ i] [ k & 1 ] = 0 ;
int last = i;
for ( int j = i + 1 ; j <= n; j ++ ) {
while ( dp[ i] [ last] [ k & 1 ] < a[ j] - a[ last] ) last ++ ;
dp[ i] [ j] [ ( k + 1 ) & 1 ] = min ( dp[ i] [ last] [ k & 1 ] , a[ j] - a[ last - 1 ] ) ;
}
}
}
printf ( "%lld" , ans ) ;
return 0 ;
}
T10:CF888F Connecting Vertices
code
#include <cstdio>
#define lyx 1000000007
#define ll long long
#define MAXN 505
int n;
int a[ MAXN] [ MAXN] ;
ll dp[ MAXN] [ MAXN] [ 2 ] ;
int main ( ) {
scanf ( "%d" , & n ) ;
for ( int i = 1 ; i <= n; i ++ ) {
for ( int j = 1 ; j <= n; j ++ )
scanf ( "%d" , & a[ i] [ j] ) ;
dp[ i] [ i] [ 0 ] = 1 ;
}
for ( int len = 2 ; len <= n; len ++ )
for ( int i = 1 ; i + len - 1 <= n; i ++ ) {
int j = i + len - 1 ;
if ( a[ i] [ j] )
for ( int k = i; k < j; k ++ )
dp[ i] [ j] [ 0 ] = ( dp[ i] [ j] [ 0 ] + ( ( dp[ i] [ k] [ 0 ] + dp[ i] [ k] [ 1 ] ) % lyx ) * ( ( dp[ k + 1 ] [ j] [ 1 ] + dp[ k + 1 ] [ j] [ 0 ] ) % lyx ) % lyx ) % lyx;
for ( int k = i + 1 ; k < j; k ++ )
if ( a[ i] [ k] )
dp[ i] [ j] [ 1 ] = ( dp[ i] [ j] [ 1 ] + dp[ i] [ k] [ 0 ] * ( ( dp[ k] [ j] [ 0 ] + dp[ k] [ j] [ 1 ] ) % lyx ) % lyx ) % lyx;
}
printf ( "%lld" , ( dp[ 1 ] [ n] [ 0 ] + dp[ 1 ] [ n] [ 1 ] ) % lyx ) ;
return 0 ;
}