huantwofat

我们可以思考对一个子树如果他节点数固定那么黑点数一定是连续变化的，那我们可以很容易想到找到每个子树大小的黑点最大值和最小值也就是dp[i]表示子树大小为i的黑点最大值，dp1[i]为最小值，剩下的就是dp。#include#include#include#include#includeusing namespace std;const int maxn=2004;int dp[m

一道很强大的数位dp＋ac自动机题。题目要求a～bjian

题目给的n很大，对于这种范围一般用ku

题目要求的是改变最少数目的字母使得

对于任何一个子序列，我们可以轻易d'l

题目一眼看上去就是状压但n太大，ya bu dong

D. Valid Setstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputAs you know, an undirected connected graph wit

题目要求abs(d[i]-d[j])>=d，也就是

先按x排序，对于相同的x分块处理，也就是

对于原题：假如说i

昨天BC的第三题，一开始用线段树写的，先是MLE，全改成short之后一直TLE到比赛结束，后来听别人说树状数组优化能过，后来试了一下果然能够，坑啊（以后LIS用树状数组了，比线段树快的多）至于树状数组求1-n区间最大值和求和差不多思想。dp转移方程是：dp[i][j][0]=max(dp[k][j][0]+1(a[k]dp[i][j][1]=max(dp[k][j-1][0]+1

我们可以先用mancher算法对字符串进行处理，把以每个点为中心的回文串半径求出来，然后进行处理。加入对以p为中心的点，从p-r[i]+1~p都是回文串的开头,那么对于每个回文串（开头是j）只要记录结尾从1~j-1的回文串个数，我们可以用dp记录以每个点为结尾的回文串个数，s[i]=sigma(dp[i]),则是结尾从1~j-1的回文串个数。那么对这个中心点来说一共的回文串对应该有：s[p-r

我们先考虑对于一行p个人有多少种图案，首先撇去顺序，我们社xi表示h为i的个数，所以x1+....+xm=p，xi>=0因为大小是确定的所以不用管大小顺序，所以方案数是C(p+m-1,m-1)，所以剩下的就是dp，我们令dp[i]表示砖头数为i的方法数，我们只需考虑第一行假如是j那么dp[i]+=dp[i-j]*C(i-1,j-1)*C(j+m-1,m-1)（因为第一块肯定是第一行，剩下j-1

我们直接状压表示最小值，然后我们状态里面枚举最后一个点所在的相同颜色的集合，复杂度为3^17=10^8。#include#include#include#includeusing namespace std;typedef unsigned un;const int maxn=1<<18;un uo[maxn];un mm(un n,int m){ un s=1;

http://codeforces.com/contest/482其实我们只需要考虑三种情况一种从左到右成立，一种从右到左成立，一种两边都成立，答案就是前两种相加减去后一种，前两种好球，后一种用dp[i][j][k]便是第i个儿子前面的取得点的个数%2后的值，后面是这个点后面的所有取得点%2后的值，然后就写完了。#include#include#include#include#in

我们二分一下答案，然后发现如果小于等于答案的个数x，剩下的是y个那么一定满足：x>(x+y)/k也就是(k-1)*x-y>0所以我们只需要把小于等于答案的变成k-1，其他的变成-1跑一遍树形dp即可。#include#include#include#include#includeusing namespace std;const int maxn=100004;struct pi

对于不等式a+c-b-d我们思考，如果分解成二进制a1+c1-b1-d1>=2的话后面不用看了，同样a1+c1-b1-d1#include#include#include#include#includeusing namespace std;const int mod=1000000007;typedef long long LL;int dp[66][16][5][5];L

因为X的个数不超过9所以我们压X的个数就行，然后从小到大分配数字，但是如果‘.'变成了山谷怎么办，所以我们容斥搜出'.'变成X的所有情况，情况也不超过2^9,然后就写完了。#include#include#include#includeusing namespace std;typedef long long LL;const int maxn=1<<9;const int mo

可以发现最后一个字母一定是最左最有，那么dp方程很好转移，但是是3方的，如果先减1话，我们想到每次扫到的结果可以重复利用，于是每次维护当前数的第一个位置在哪即可。#include#include#include#include#includeusing namespace std;const int maxn=5005;const int mod=1000000007;int

思路源于camp一道题，很容易想到dp[u]=max(dp[v]+w[u] opt w[v]),但是u太大无法枚举，我们想到可以折半，用后一半更新当前dp值，用前一半来更新数组，假如我已经求出dp[u],那么我们枚举前一半，我们用dp[u]+(i OPT w[u])*256来更新数组 bit[i][w[u&255],然后求dp的时候因为前一半已经更行好所以只要枚举后一半 dp[u]=max(d

状压，记录两行的状态dp即可。然后枚举当前行为1的位置。

装压好题！首先我们要从两个相邻的格子不能同时为空入手，然后我们不妨枚举每一行最后的状态，那下一行怎么办，我们还需要用一维来记录这一行的进位，也就是这一行用竖的格子放后的状态然后直接枚举即可，看起来像70*(3^14)的复杂度，其实我们对最终状态可以预处理，可以发现最多不超过21个，所以结论是dp[x][f]=dp[y][w]+count[f]+vis[x^f^s^w];其中count数组记

动态规划问题。如果在i这个位置，如果a[i]=a[i-1],如果a[i]!=1

一般适用于区间dp优化。/*对于dp[i][j]=dp[i][k]+d[k][j]+w[i][j]的dp方程，如果满足w[i][j]+w[i'][j']<=w[i'][j]+w[i][j'] (i'<=i<=j<=j')则w[i][j]是凸的，也就是说，对于dp[i][j]的决策s[i][j],必然满足不等式s[i][j-1]<=s[i][j]<=s[i+1][j].所以求决策时只需要

2014第二题如果正常写的话是按双调tsp来写，但如果n上万就wu

用单调队列可以大大提高效率

用单调队列实现或者辅助数组#include#include#include#includeusing namespace std;bool dp[100005];int num[100005];int a[105],b[105];int main(){ int n,i,j,m,sum; double s; while(scanf("%d%d",&n,&m)

Disk ScheduleTime Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 50    Accepted Submission(s): 3Problem Description有很多从磁盘读取数据的需求，包括顺

#include#include#define N 100using namespace std;int main(void){ //存储原字符串 char str[N]; //b[j]存储以j为长度的递增子序列的结尾元素 char b[N]; int cases; cout<<"请输入案例个数："<<endl; cin>>case

d[i][j]=d[i-1][j]+p[i][i-1];  d[i][i-1]=min(d[i-1][j]+p[j][i]);

只要把每个素数筛出来，并用三维dp一下，

AlphacodeTime Limit: 1000MS Memory Limit: 30000KTotal Submissions: 12136 Accepted: 3698DescriptionAlice and Bob need to send secret messages to each other and are

该题解法应该从中间递推。转移方程为：dp[n][l]=dp[n-1][l-1]+1+dp[n-1][j

先用凸包预处理，然后由于0，n-1那条边一定是摸个san'jiao'xin

回想一下tsp方程：if( i ! =j-1)     dp[i][j]=dp[i-1][j]+dis[i][i-1];else  dp[i][i-1]=min(dp[i-1][f]+dis[f][i]);仔细推导一下方程后会发现这样一个公式:   dp[i][j]=dp[j+1][j]+dis[j+1][j+2]+dis[j+2][j+3]........+dis[i-1][i]. 现在

笔者博客里有关于双调TSP的mo'ba

维护凸包。/* 我们假设k<j<i。如果在j的时候决策要比在k的时候决策好，那么也是就是dp[j]+M+(sum[i]-sum[j])^2<dp[k]+M+(sum[i]-sum[k])^2。(因为是最小花费嘛，所以优就是小于) 两边移项一下，得到：(dp[j]+num[j]^2-(dp[k]+num[k]^2))/(2*(num[j]-num[k]))<sum[i]。我们把dp[j]

类似于硬币问题的组成多少硬币，经典的

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

博弈思想，从后往前推，因为总钱数不变，所以