【codeforces】Codeforces Round #277.5 (Div. 2)

最新推荐文章于 2016-10-13 14:52:09 发布
最新推荐文章于 2016-10-13 14:52:09 发布
阅读量1k 收藏
点赞数
分类专栏： 题解 匹配【Match】 DP 文章标签： codeforces
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013368721/article/details/41245033
版权
DP 同时被 3 个专栏收录
96 篇文章 0 订阅
订阅专栏
题解
25 篇文章 0 订阅
订阅专栏
匹配【Match】
21 篇文章 0 订阅
订阅专栏

传送门：【codeforces】Codeforces Round #277.5 (Div. 2)


489A. SwapSort

选择排序！绝对的不超过n次交换。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
//#include <cmath>
using namespace std ;

typedef long long LL ;

#pragma comment ( linker , "/STACK:1024000000" )
#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 rec( i , A , o ) for ( int i = A[o] ; i != o ; i = A[i] )
#define clr( a , x ) memset ( a , x , sizeof a )

const int MAXN = 100005 ;
const int MAXE = 200005 ;
const int INF = 0x3f3f3f3f ;

struct Node {
	int x , y ;
	Node () {}
	Node ( int x , int y ) : x ( x ) , y ( y ) {}
} ;

Node ans[MAXN] ;
int a[MAXN] ;
int top ;
int n ;

void solve () {
	top = 0 ;
	rep ( i , 0 , n ) scanf ( "%d" , &a[i] ) ;
	rep ( i , 0 , n ) {
		int tmp = a[i] , pos = i ;
		rep ( j , i + 1 , n ) if ( a[j] < tmp ) {
			tmp = a[j] ;
			pos = j ;
		}
		if ( pos != i ) {
			ans[top ++] = Node ( i , pos ) ;
			a[pos] = a[i] ;
		}
	}
	printf ( "%d\n" , top ) ;
	rep ( i , 0 , top ) printf ( "%d %d\n" , ans[i].x , ans[i].y ) ;
}

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

489B. BerSU Ball

我用的二分匹配，对于可以匹配的建边，然后跑最大匹配即可。

实际上可以排序贪心。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
//#include <cmath>
using namespace std ;

typedef long long LL ;

#pragma comment ( linker , "/STACK:1024000000" )
#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 rec( i , A , o ) for ( int i = A[o] ; i != o ; i = A[i] )
#define clr( a , x ) memset ( a , x , sizeof a )

const int MAXN = 100005 ;
const int MAXE = 200005 ;

struct Edge {
	int v , n ;
	Edge () {}
	Edge ( int v , int n ) : v ( v ) , n ( n ) {}
} ;

Edge E[MAXN] ;
int H[MAXN] , cntE ;
int link[MAXN] ;
int vis[MAXN] ;
int a[MAXN] ;
int b[MAXN] ;
int n , m ;

void clear () {
	cntE = 0 ;
	clr ( H , -1 ) ;
}

void addedge ( int u , int v ) {
	E[cntE] = Edge ( v , H[u] ) ;
	H[u] = cntE ++ ;
}

int find ( int u ) {
	for ( int i = H[u] ; ~i ; i = E[i].n ) if ( !vis[E[i].v] ) {
		int v = E[i].v ;
		vis[v] = 1 ;
		if ( link[v] == -1 || find ( link[v] ) ) {
			link[v] = u ;
			return 1 ;
		}
	}
	return 0 ;
}

int match () {
	clr ( link , -1 ) ;
	int ans = 0 ;
	For ( i , 1 , n ) {
		clr ( vis , 0 ) ;
		ans += find ( i ) ;
	}
	return ans ;
}

void solve () {
	clear () ;
	For ( i , 1 , n ) scanf ( "%d" , &a[i] ) ;
	scanf ( "%d" , &m ) ;
	For ( i , 1 , m ) scanf ( "%d" , &b[i] ) ;
	For ( i , 1 , n ) {
		For ( j , 1 , m ) if ( abs ( a[i] - b[j] ) <= 1 ) addedge ( i , j ) ;
	}
	printf ( "%d\n" , match () ) ;
}

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

489C. Given Length and Sum of Digits...

易知最大的是从高位加起，最小的是从低位加起，注意1 0这样的情况。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
//#include <cmath>
using namespace std ;

typedef long long LL ;

#pragma comment ( linker , "/STACK:1024000000" )
#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 rec( i , A , o ) for ( int i = A[o] ; i != o ; i = A[i] )
#define clr( a , x ) memset ( a , x , sizeof a )

const int MAXN = 105 ;

int a[MAXN] ;
int b[MAXN] ;
int m , s ;

void solve () {
	if ( m > 1 && s < 1 || s > 9 * m ) {
		printf ( "-1 -1\n" ) ;
		return ;
	} else if ( m == 1 && s == 0 ) {
		printf ( "0 0\n" ) ;
		return ;
	}
	For ( i , 1 , m ) a[i] = b[i] = 0 ;
	int ss = s ;
	For ( i , 1 , m ) {//max
		if ( 9 - a[i] < ss ) {
			ss -= 9 - a[i] ;
			a[i] = 9 ;
		} else {
			a[i] = ss ;
			break ;
		}
	}
	ss = s ;
	rev ( i , m , 1 ) {//min
		if ( 9 - b[i] < ss ) {
			ss -= 9 - b[i] ;
			b[i] = 9 ;
		} else {
			b[i] = ss - 1 ;
			b[1] = b[1] + 1 ;
			break ;
		}
	}
	For ( i , 1 , m ) printf ( "%d" , b[i] ) ;
	printf ( " " ) ;
	For ( i , 1 , m ) printf ( "%d" , a[i] ) ;
	printf ( "\n" ) ;
}
	
int main () {
	while ( ~scanf ( "%d%d" , &m , &s ) ) solve () ;
	return 0 ;
}
489D. Unbearable Controversy of Being

以每个点为起点bfs一次，找到起点到每个距离起点2的点的路径数x，ans+=x*(x-1)/2。易知最多每次只会走m条边，所以复杂度为o(nm)。

PS：实际上根本不需要bfs，用邻接表判断就好了。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
//#include <cmath>
using namespace std ;

typedef long long LL ;

#pragma comment ( linker , "/STACK:1024000000" )
#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 rec( i , A , o ) for ( int i = A[o] ; i != o ; i = A[i] )
#define clr( a , x ) memset ( a , x , sizeof a )

const int MAXN = 3003 ;
const int MAXE = 30005 ;

struct Edge {
    int v , n ;
    Edge () {}
    Edge ( int v , int n ) : v ( v ) , n ( n ) {}
} ;

struct Node {
    int x , d ;
    Node () {}
    Node ( int x , int d ) : x ( x ) , d ( d ) {}
} ;

Node Q[MAXE] ;
Edge E[MAXE] ;
int head , tail ;
int H[MAXN] , cntE ;
LL G[MAXN][MAXN] ;
int n , m ;

void clear () {
    cntE = 0 ;
    clr ( H , -1 ) ;
}

void addedge ( int u , int v ) {
    E[cntE] = Edge ( v , H[u] ) ;
    H[u] = cntE ++ ;
}

void bfs ( int root ) {
    head = tail = 0 ;
    Q[tail ++] = Node ( root , 0 ) ;
    while ( head != tail ) {
        Node o = Q[head ++] ;
        if ( head == MAXE ) head = 0 ;
        int u = o.x ;
        int d = o.d ;
        if ( d == 2 ) {
            G[root][u] ++ ;
            continue ;
        }
        for ( int i = H[u] ; ~i ; i = E[i].n ) {
            int v = E[i].v ;
            if ( v == root ) continue ;
            Q[tail ++] = Node ( v , d + 1 ) ;
        }
    }
}

void solve () {
    int u , v ;
    clear () ;
    clr ( G , 0 ) ;
    rep ( i , 0 , m ) {
        scanf ( "%d%d" , &u , &v ) ;
        addedge ( u , v ) ;
    }
    For ( i , 1 , n ) bfs ( i ) ;
    LL ans = 0 ;
    For ( i , 1 , n ) For ( j , 1 , n ) ans += G[i][j] * ( G[i][j] - 1 ) / 2 ;
    printf ( "%I64d\n" , ans ) ;
}

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

489E. Hiking

题意：一个旅行者想从河的起点（坐标0）走到河的终点（编号n）途中有n个休息站（包括终点），休息站有2个属性：（1）坐标xi，（2）风景价值vi。每次只能从一个休息站走到另一个休息站，中间不能停留，旅行者想每次走L距离，但是这基本呢不可能，于是给了这样的一个定义：每次走ri的距离（即选择的两休息站之间的距离），则他会感到失意，失意指数为sqrt ( | ri - L | )。现在你的任务是选出一些休息站，使得（失意指数之和/休息站的风景价值之和）最小。起点为0，终点只能为n。休息站的坐标按照输入顺序严格递增给出。

分析：

考虑设r = sum { sqrt ( | ri - L | ) } / sum { vi }。

转化一下就成了sum { sqrt ( | ri - L | ) } - r * sum { vi } = 0。

令G（r）= sum { sqrt ( | ri - L | ) } - r * sum { vi }。

我们的目标是最小化Ｇ（r），最小化G（r）等同于最小化r。

如果G（r）< 0，说明r取大了，但是sum { sqrt ( | ri - L | ) } / sum { vi } <= r，r可以更优！

如果Ｇ（r）= 0，此时r恰是最优值。

如果G（r）> 0，说明r取小了，sum { sqrt ( | ri - L | ) } / sum { vi }不可能比r小。

如果Ｇ（r）是一个单调递减函数，那么我们便可以用二分的方法去求得最优的r了，

当Ｇ（r）< 0时调整上界，

当Ｇ（r）>0时调整下界，

当二分上下界r-l<eps时大致认为此时的r即最优解。

Ｇ（r）函数的最小值求解可用Ｏ（n^2）的dp求解。

dp[i] = min { dp[j] + sqrt ( | x[i] - x[j] - L | ) - r * a[i] }。

幸运的是，Ｇ（r）的确是一个单调递减函数，所以二分是可行的。

关于本题算法正确性的证明，应该去看一下分数规划问题，本题就是一个分数规划问题，然后用dp求Ｇ（r）函数。


#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std ;

typedef long long LL ;

#pragma comment ( linker , "/STACK:1024000000" )
#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 rec( i , A , o ) for ( int i = A[o] ; i != o ; i = A[i] )
#define clr( a , x ) memset ( a , x , sizeof a )

const int MAXN = 1005 ;
const double eps = 1e-8 ;
const double INF = 1e30 ;

double dp[MAXN] ;
int x[MAXN] , b[MAXN] ;
double a[MAXN] ;
int pre[MAXN] ;
int S[MAXN] , top ;
int n , m ;

void solve () {
	a[0] = x[0] = b[0] = 0 ;
	For ( i , 1 , n ) scanf ( "%d%d" , &x[i] , &b[i] ) ;
	double l = 0 , r = 1e10 ;
	while ( l < r - eps ) {
		double mid = ( l + r ) / 2 ;
		For ( i , 1 , n ) a[i] = mid * b[i] ;
		dp[0] = 0 ;
		For ( i , 1 , n ) {
			dp[i] = INF ;
			rev ( j , i - 1 , 0 ) {
				double tmp = dp[j] + sqrt ( double ( abs ( x[i] - x[j] - m ) ) ) - a[i] ;
				if ( dp[i] > tmp ) dp[i] = tmp , pre[i] = j ;
			}
		}
		if ( dp[n] > -eps ) l = mid ;
		else r = mid ;
	}
	top = 0 ;
	while ( n ) {
		S[top ++] = n ;
		n = pre[n] ;
	}
	rev ( i , top - 1 , 0 ) printf ( "%d%c" , S[i] , i ? ' ' : '\n' ) ;
}

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

489F. Special Matrices

我是O（n^3）暴力的。。不要嘲笑我T  T

首先可以预处理出每一列还剩多少1可以用，用a[i]表示。

dp[i][j][k]表示已经处理到第i列，已经有j行放置了两个1，同时有k行已经放置了一个1。

当a[i] = 0时：

dp[i][j][k] = dp[i - 1][j][k]

当a[i] = 1时：

dp[i][j][k + 1] += ( n - m - j - k ) * dp[i - 1][j][k]（增加一个1行）

    当k > 0：

    dp[i][j + 1][k - 1] += k * dp[i - 1][j][k]（将一个1行变为2行）

当a[i] = 2时：

dp[i][j][k + 2] += ( n - m - j - k ) * ( n - m - j - k - 1 ) / 2 * dp[i - 1][j][k]（增加两个1行）

    当k > 0：

    dp[i][j + 1][k] += ( n - m - j - k ) * k * dp[i - 1][j][k]（将一个1行变为2行，同时再增加一个1行）

    当k > 1：

    dp[i][j +2][k - 2] += k * ( k - 1 ) / 2 * dp[i - 1][j][k]（将两个1行变为2行）


这就是O（n^3）的算法，稍微优化一下，156ms。。。


正确的姿势应该是O（n^2）的算法，等我有空去想想。


#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
//#include <cmath>
using namespace std ;

typedef long long LL ;

#pragma comment ( linker , "/STACK:1024000000" )
#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 rec( i , A , o ) for ( int i = A[o] ; i != o ; i = A[i] )
#define clr( a , x ) memset ( a , x , sizeof a )

const int MAXN = 505 ;

int mod ;
int dp[2][MAXN][MAXN] ;
int a[MAXN] ;
int n , m ;

inline void add ( int& x , int y ) {
	x += y ;
	if ( x >= mod ) x -= mod ;
}

void solve () {
	int x , cur = 0 ;
	clr ( dp , 0 ) ;
	For ( i , 1 , n ) a[i] = 2 ;
	For ( i , 1 , m ) For ( j , 1 , n ) {
		scanf ( "%1d" , &x ) ;
		a[j] -= x ;
	}
	dp[0][0][0] = 1 ;
	int s = n - m ;
	For ( i , 1 , n ) {
		cur ^= 1 ;
		clr ( dp[cur] , 0 ) ;
		For ( j , 0 , s ) {
			if ( j > i * 2 ) break ;
			For ( k , 0 , s - j ) if ( dp[cur ^ 1][j][k] ) {
				if ( a[i] == 0 ) add ( dp[cur][j][k] , dp[cur ^ 1][j][k] ) ;
				else if ( a[i] == 1 ) {
					if ( k > 0 ) add ( dp[cur][j + 1][k - 1] , ( LL ) k * dp[cur ^ 1][j][k] % mod ) ;
					add ( dp[cur][j][k + 1] , ( LL ) ( s - k - j ) * dp[cur ^ 1][j][k] % mod ) ;
				} else {
					if ( k > 1 ) add ( dp[cur][j + 2][k - 2] , ( LL ) k * ( k - 1 ) / 2 * dp[cur ^ 1][j][k] % mod ) ;
					if ( k > 0 ) add ( dp[cur][j + 1][k] , ( LL ) ( s - k - j ) * k * dp[cur ^ 1][j][k] % mod ) ;
					add ( dp[cur][j][k + 2] , ( LL ) ( s - k - j ) * ( s - k - j - 1 ) / 2 * dp[cur ^ 1][j][k] % mod ) ;
				}
			}
		}
	}
	printf ( "%d\n" , dp[cur][n - m][0] ) ;
}

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


-----------------------update-----------------------

F题O（n^2）解法。

设dp[i][j]表示已经有i列上有两个1，j列上有1个1，剩下的n-i-j列上还没有1。

那么，由于i的不递减，所以我们可以将这个作为递推的第一维。

dp[i][j + 2] += ( n - i - j ) * ( n - i - j - 1 ) / 2 * dp[i][j].（选择没有1的两列将其变成有一个1的两列）

dp[i + 1][j] += j * ( n - i - j ) * dp[i][j].（j>0）（选择一列有一个1的变成有两个1的，同时选择没有1的变成有一个1的）

dp[i + 2][j - 2] += j * ( j - 1 ) / 2 * dp[i][j].（j>1）（选择有一个1的两列变成有两个1的两列）

这样推法的可行性在于充分利用1的数量是固定的隐性条件，到最后终点dp[n][0]时的一定是合法的。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
//#include <cmath>
using namespace std ;

typedef long long LL ;

#pragma comment ( linker , "/STACK:1024000000" )
#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 rec( i , A , o ) for ( int i = A[o] ; i != o ; i = A[i] )
#define clr( a , x ) memset ( a , x , sizeof a )

const int MAXN = 505 ;

int mod ;
int dp[MAXN][MAXN] ;
int a[MAXN] ;
int n , m ;

inline void add ( int& x , int y ) {
	x += y ;
	if ( x >= mod ) x -= mod ;
}

void solve () {
	int v , cur = 0 ;
	clr ( dp , 0 ) ;
	clr ( a , 0 ) ;
	For ( i , 1 , m ) {
		getchar () ;
		For ( j , 1 , n ) a[j] += getchar () - '0' ;
	}
	int x = 0 , y = 0 ;
	For ( i , 1 , n ) {
		if ( a[i] == 2 ) ++ x ;
		else if ( a[i] == 1 ) ++ y ;
	}
	dp[x][y] = 1 ;
	For ( i , x , n ) {
		For ( j , 0 , n - i ) if ( dp[i][j] ) {
			add ( dp[i][j + 2] , ( LL ) ( n - i - j ) * ( n - i - j - 1 ) / 2 * dp[i][j] % mod ) ;
			if ( j > 0 ) add ( dp[i + 1][j] , ( LL ) j * ( n - i - j ) * dp[i][j] % mod ) ;
			if ( j > 1 ) add ( dp[i + 2][j - 2] , ( LL ) j * ( j - 1 ) / 2 * dp[i][j] % mod ) ;
		}
	}
	printf ( "%d\n" , dp[n][0] ) ;
}

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


poursoul
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【codeforces】2014-2015ACM-ICPC CERC 14 Problem G: Virus synthesis 【Palindromic Tree+DP】
poursoul
12-24 2074
传送门：【codeforces】2014-2015ACM-ICPC CERC 14 Problem G: Virus synthesis 题目分析：首先我们构造回文树，然后我们只考虑长度为偶数的回文串，长度为奇数的回文串总可以通过长度为偶数的回文串然后加上剩下的所需字符构成（当然这个偶数回文串的长度可以是0，此时这个奇数回文串的构造次数就是其长度）。对于一个偶数长度回文串u，假设其构造次
【codeforces】2014-2015 ACM-ICPC, Central Europe Regional Contest (CERC 14) F Vocabulary【dp】
poursoul
12-19 2020
传送门：【codeforces】2014-2015 ACM-ICPC, Central Europe Regional Contest (CERC 14) F Vocabulary 题目分析：蒽。。。。这个dp嘛其实也是满简单易懂的，就是要考虑的地方略多一点。。。 设字典序最小的为a串，中间的为b串，最大的为c串。 首先我们预处理出'?'个数在前i个字符位置的个数num[
【codeforces】Codeforces Round #284 (Div. 1) 【题解】
poursoul
12-25 1869
传送门：【codeforces】Codeforces Round #284 (Div. 1) 498A 题目等价于给N条直线，如果两个点分别在直线两侧，则++cnt，最后的答案就是cnt的值。方法就是带入点的坐标到直线方程ax+by+c中看得到的两个值的乘积是否小于0，小于0则++cnt。 而我，用了十分蠢的方法！将直线变成线段，将所给两个点连接，这样题目就变成求与所给两点构成的线段
【codeforces】480E Parking Lot 线段树+DP
poursoul
10-30 1835
传送门：【codeforces】480E Parking Lot 题目分析：很早以前在同学助攻下写出来的，想想hai shi
【HDU】5470 Typewriter 【后缀自动机+dp】
poursoul
09-29 1807
传送门：【HDU】5470 Typewritermy  code:my~~code:#include <bits/stdc++.h> using namespace std ;typedef long long LL ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 100005 ; const int N = 26
【51nod】1291 Farmer 【求n*m的矩形内全1的i*j的矩形个数】【dp】
poursoul
10-13 1483
题目链接：【51nod】1291 Farmer去年做的题，一直没有放出来，单调栈，O(N^2)。O(N^2logN)也能过。#include <bits/stdc++.h> using namespace std ;#define clr( a , x ) memset ( a , x , sizeof a )const int MAXN = 1005 ;char s[MAXN] ; int U[M
【HDU】5009 Paint Pearls DP
poursoul
09-14 1460
传送门：【HDU】5009 Paint Pearls
【HDU】5362 Just A String【生成函数dp】
poursoul
08-08 1443
传送门：【HDU】5362 Just A String这题整整想了我两天= =终于搞出来了。 一开始写出O(N3)O(N^3)的dp，转化一下，可以搞出一个生成函数，然后展开生成函数可以发现系数是二项式，然后对于枚举的长度i取出第i项就可以了。有个优化是发现奇数长度的回文串和偶数长度的回文串的贡献是一样的，所以不需要特殊处理奇数了。my  code:my~~code:#include <bits/
【HDU】5928 Birthday Gift【极角排序+dp】
poursoul
10-08 1374
题目链接：Birthday Gift首先，最优解一定是一个凸包，但是接下来的算法不会显性利用到凸包的性质。 枚举每个点作为多边形最左侧的端点（然后删除他左侧的点，否则可能会错，我就因为这个问题错了好几发，虽然不知道什么情况，删了保证对），然后以这个点做极角排序，接下来dp[i][j]表示多边形上上个极角序最大的点是i，内部包含了j个点的最小周长，然后枚举下一个点就可以做到n^3转移（三角形内点的个
2014 Asia AnShan Regional Contest 题解
poursoul
10-30 1358
B：5071 Chat
【HDU】5290 Bombing plan 【树形DP】
poursoul
07-27 1350
传送门：【HDU】5290 Bombing planmy  code:my~~code:#include <stdio.h> #include <string.h> #include <vector> #pragma comment(linker, "/STACK:16777216") #include <algorithm> using namespace std ;typedef long lo
【ZOJ】 3190 Resource Archiver AC自动机+BFS预处理+DP
poursoul
07-06 1301
Resource Archiver Time Limit: 10 Seconds      Memory Limit: 32768 KB Great! Your new software is almost finished! The only thing left to do is archiving all your n resource files into
【codeforces】494D. Birthday 【树型DP+离线tarjan求LCA】
poursoul
12-14 1247
传送门：【codeforces】494D. Birthday 题目分析：首先明确一点，平方和是可以递推的！ 1.我们第一次dfs，求出从一个点到其子树的所有点的距离的平方和。 大体是保存三个变量来递推，设u的子树上点的个数cnt，到子树上点的距离和sum，到子树上点的距离平方和sqr，每次dfs完一个儿子v以后： dp[u].cnt+=dp[v].cnt dp[u].sum+=d
【CodeForces】467D Fedor and Essay 强连通+DP
poursoul
09-19 1245
传送门：【CodeForces】467D Fedor and Essay
HDU 3899 JLUCPC 树型DP
poursoul
06-01 1222
JLUCPC Time Limit: 15000/5000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 1101    Accepted Submission(s): 295 Problem Description Dr. Skywind and Dr. Wal
[毕业设计]VB开发的高校题库与考试管理系统(源代码+论文).zip
08-06
[毕业设计]VB开发的高校题库与考试管理系统(源代码+论文)
mysql-9.0.1-winx64-debug-test.zip
08-06
mysql
java-springboot+vue疗养院管理系统实现源码(项目源码-说明文档)
最新发布
08-06
java-springboot+vue疗养院管理系统 项目关键技术 开发工具：IDEA 、Eclipse 编程语言: Java 数据库: MySQL5.7+ 后端技术：Springboot 前端技术：Vue、HTML5、css、JavaScript 关键技术：springboot、vue、MYSQL、MAVEN 数据库工具：Navicat、SQLyog
java-springboot+vue教学辅助平台实现源码(项目源码-说明文档)
08-06
java-springboot+vue教学辅助平台 项目关键技术 开发工具：IDEA 、Eclipse 编程语言: Java 数据库: MySQL5.7+ 后端技术：Springboot 前端技术：Vue、HTML5、css、JavaScript 关键技术：springboot、vue、MYSQL、MAVEN 数据库工具：Navicat、SQLyog
codeforces round #772 (div. 2)
03-16
好的，Codeforces Round #772 (Div. 2) 是一场由Codeforces主办的在线编程竞赛。 该比赛的比赛链接为：https://codeforces.com/contest/772。 该比赛分为两个级别：Div.1和Div.2。 Div. 1级别通常比Div. 2级别更具挑战性，因此需要更高的排名才能参加。 在比赛期间，参赛者需要在给定的时间内解决一系列编程问题。 问题的难度各不相同，涵盖了许多编程概念，如字符串处理，数据结构，算法和数学。 参赛者可以使用任何编程语言来解决这些问题，但是他们需要确保他们的解决方案在指定的时间限制内运行并产生正确的输出。 比赛结束后，排名前列的参赛者将获得奖励，例如称号、Codeforces积分和虚拟奖金等。 如果你对参加这种类型的比赛感兴趣，你可以在Codeforces的官方网站上注册并参加类似的比赛。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值