摘要：1 /*二项分布即重复n次的伯努利试验,每次发生的概率一样，假设成功的概率是p，那么失败的概率就是1-p； 2 二项分布的概率公式：试验中发生K次的概率是 3 P(ξ=K)= C(n,k) * p^k * (1-p)^(n-k), 其中C(n, k) = n!/(k! * (n-k)!) 4 因为这里的数据，k最大为100,100的阶乘超过了int64位，所以不能用这个公式，这时候可以用泊松分布的概率 5 公式求近似值。 6 好了接着解释题意：这道题输入n和m，求m是期望，求实验中发生不超过n次的概率，所有所有的概率为0,1,2,3,4...n的概率和 7 */ 8 #include 9 #. 阅读全文

摘要：1 /*给出n个原始顺序的数，再给出要排成目标状态顺序，每次从第一个数列中选择三个，把这三个数中最右边的数放在最左边，然后其他两个数右 2 移一个单位，为你从原始状态能不能排序成目标状态。 3 本人YY的结论，从特殊到一般，虽然一般的只是手证了数值比较小的：结论应该就是1到n的n个数的全排列，分成相等的奇排序和偶排序，且个数一样，同个集合中的排列可以互相转换 4 比如1 2 3 4的全排1 2 3 4 5 1 4 2 3 6 1 3 4 2 7 4 1 3 2 8 4 2 1 3 9 4 3 2 110 2 4 3 111 2 1 4 312 2 3 1 413 3 4 1 2(可由4 1 . 阅读全文

摘要：1 对于n*m*k的方块，用手掰成1*1*1的那么搜需要的步骤是固定的，为n*m*k-1，如果用刀切，因为可以把多块叠在一起切，所以对于长度为n的，将他切成0，所需要的步骤数位k 2 3 对于n*m*k的方块，用手掰成1*1*1的那么搜需要的步骤是固定的，为n*m*k-1，如果用刀切，因为可以把多块叠在一起切，所以对于长度为n的，将他切成0，所需要的步骤数位k[cpp] view plaincopyprint? 4 满足n/2^k=1即n=2^k，等式两边取对数，logn=k*log2，所以k等于logn/log2 5 6 #include 7 #include 8 ... 阅读全文

摘要：1 /*问你能不能将给出的资源平分成两半，那么我们就以一半为背包，运行多重背包模版 2 但是注意了，由于个数过大，直接运行会超时，所以要用二进制拆分每种的个数*/ 3 #include 4 #include 5 #include 6 using namespace std; 7 int w[120005],vr[120005],dp[120005]; 8 int a[7],v[7]; 9 int numw;10 void cf(int n,int ok)11 {12 int i,j,sum,e;13 e=sum=1;14 while(sum0)22 {23 ... 阅读全文

摘要：1 /*记忆化dfs+dp,因为每次最多走k步，所以上下左右的方向有所扩展， 2 dp[i][j]存的是从dp[i][j]出发能吃的最大个数*/ 3 #include 4 #include 5 #include 6 using namespace std; 7 const int maxn=110; 8 int map[maxn][maxn],vis[maxn][maxn]; 9 int dp[maxn][maxn];//dp[i][j]表示从i,j出的最大蛋糕数目10 int n,m,k;11 void init()12 {13 memset(dp,0,sizeof(dp));14... 阅读全文

摘要：1 /*记忆化dfs+dp 2 dp[i][j]代表达到这个点的所有路的条数，那么所有到达终点的路的总数就是这dp[1][1]加上所有他所能到达的点的 3 所有路的总数 4 */ 5 6 #include 7 #include 8 #include 9 using namespace std;10 const int maxn=110;11 int map[maxn][maxn],vis[maxn][maxn];12 int dp[maxn][maxn];13 int n,m;14 int ok(int x,int y)15 {16 if(x>=1 && x=1 & 阅读全文

摘要：1 #include 2 #include 3 #include 4 #include 5 #include 6 using namespace std; 7 const int maxn=1010; 8 struct point 9 { 10 int w,s,per,id; 11 }p[maxn]; 12 int cmp(point a,point b) 13 { 14 return a.s>b.s; 15 } 16 int dp[maxn]; 17 int main() 18 { 19 int i,j,k,n,m; 20 n=1; 21 ... 阅读全文

摘要：1 /*给出两串，求一个最小的字符串包含这两个子串，子串在这个字符串中的顺序不变， 2 做法：定义两个数组，分别标记公共部分在第一个串和第二个串中的位置，在输出是判断一下，输出一个串两个公共部分之间的部分，不包含 3 公共部分，在输出第二个串公共部分之间的串，和最后一个公共部分，然后剩下的在公共部分后面的直接输出就可以了，注意这道题不能直接求出 4 最长公共，然后在最短的那个串中删除这个最长公共，剩下的加入第二个串，这样会导致顺序不对*/ 5 #include 6 #include 7 #include 8 #include 9 using namespace std;10 const in. 阅读全文

摘要：1 /*题目大意，给出n道题，假设答对了m道题，求最小的分数，有一个规则，就是连续答对num==k道题那么分数就翻倍，然后num清零，从新开始计数，到大连续k道的时候 2 要先加上这道题的分数1，再乘以2， 3 做法:先将n中排出n/k个块，然后分类讨论，当n/kn-m那么说明n/k个块之间有些不能隔开，就是会出现连续的答对超过k的情况 5 所这种情况，采用插空法，每次插一个空分数就会翻倍，当插入一个空，那么分数是2*k,第二个是(2*k+k)*2 =2*k+4k,到第三个的时候总分是2k+4k+8k 6 以此类推，那么如果剩下的数目是remin，那么就要插remin个空，根据等比数列求和公. 阅读全文

摘要：1 /*给出你图片的长和宽的比例a:b 和摄像头的比例c：d，然后叫你求最后将图片放进摄像头 2 以后，剩余的面积比上摄像头的总面积，注意要化简为最简形式，而且摄像头要设置成至少一条边和图片相等 3 做法；先将两个比例式子通分，分别比较分母和分子，通分以后必定有一条边是相等的，所以只要比较另一条边就可以了 4 */ 5 #include 6 #include 7 #include 8 #include 9 using namespace std;10 int gcd(int x,int y)11 {12 int t=1;13 while(t!=0)14 {t=x%y... 阅读全文

摘要：dangerous 1 /*大水题目。不解释 2 给你m个数，从中选出n个，保证最大值和最小值的差值最小， 3 做法：从小到大排序，然后暴力枚举每个长度是n的序列*/ 4 #include 5 #include 6 #include 7 using namespace std; 8 int main() 9 {10 int i,j,n,m,k;11 int a[110];12 while(scanf("%d%d",&n,&m)!=EOF)13 {14 int min=0x3f3f3f3f;15 for(i=1;i<=m;i++)1... 阅读全文

摘要：1 /*题目大意：输入一序列n个数字，然后输入m个询问，每个询问包含左边区间和右边区间，还有a和b，问你这个区间内有几个数大于等于a且小于等于b 2 做法：树状数组，先求出这个区间内有几个数小于a，然后求这个区间内有几个数小于等于b，拿后者减去前者就是答案了*/ 3 #include 4 #include 5 #include 6 using namespace std; 7 const int maxn=50010; 8 int c[maxn],ansl[maxn],ansr[maxn]; 9 struct pp 10 { 11 int num; 12 i... 阅读全文

摘要：1 /*http://acm.sdut.edu.cn/sdutoj/problem.php?action=showproblem&problemid=2607*/ 2 题目大意：给出一个字符串，求出里面为山字形的子序列，比如1 2 1，给出的字符串都是 3 小写字母组成，大小按照码值判断，问里面有几个这样的子序列，保证长度大于等三，且中点左右必须至少有一个字符。注意：相同的两个算两个 4 比如acca算aca和aca两个，其中c的下标分别为1和2。 5 解法：既然是左边递增右边递减，那么我们左右都求一次递增子序列的个数，然后相乘就是相加就是所有的组合数 6 因为字母只有26个，那么时间 阅读全文

摘要：好久没发博客了，最近遇到以下奇葩错误，不明觉厉，忍不住发一篇 1 /*母函数，因为要求的是素数，那么先打一个素数表，所有的因子都是素数构成 2 但是遇到一个奇葩事，当num初值取1，结果就出不来，运行了好久 3 但是num初值取0，那么就秒出，坑爹啊扯淡*/ 4 #include 5 #include 6 #include 7 int a[200]; 8 int c1[200],c2[200]; 9 int prim(int n)10 {11 12 int i;13 for(i=2;i2) continue;24 else if(prim(i)) a[num++... 阅读全文

摘要：1 /*HDU1159 ,最长公共*/ 2 #include 3 #include 4 #include 5 using namespace std; 6 int dp[1000][1000]; 7 char a[1000],b[1000]; 8 int LCS(int n,int m) 9 {10 int i,j;11 for(i=1;i=dp[i][j-1])19 {20 dp[i][j]=dp[i-1][j];21 22 }23 else24 ... 阅读全文

摘要：1 /*HDU1423 最长公共递增*/ 2 #include 3 #include 4 #include 5 using namespace std; 6 #define N 550 7 int dp[N][N]; 8 int s[N],t[N]; 9 10 int main()11 {12 int t1;13 while(scanf("%d",&t1)!=EOF)14 {15 while(t1--)16 {17 int n,m;18 scanf("%d",&n);19 ... 阅读全文

摘要：1 /*最长公共+滚动数组HDU1513*/ 2 #include 3 #include 4 char a[5010],b[5010]; 5 short int dp[2][5010]; 6 int LCS(int n,int m) 7 { 8 memset(dp, 0, sizeof(dp)); 9 int i,j;10 for(i=1;i=dp[i%2][j-1])19 {20 dp[i%2][j]=dp[(i-1)%2][j];21 //printf("%d %d %d\n"... 阅读全文

摘要：1 /*hud4512 2 dp[i]表示当前以下标i结束的最长公共上升子序列。 3 4 我们让第一个序列为原序列，第二个序列为原系列的反向。 5 6 则，也就是说，第二个序列的顺序为原序列的下标[n-1,0]，设为j 7 8 当j枚举到k时，对于dp[0] ~ dp[k-1]，都可以得到原序列的一个长度为2*dp[i]的题目要求的子序列。 9 10 可是对于，dp[k]，我们怎么判断此时，两个序列是否存在交集呢？假如存在交集，此时题目要求的子序列长度为2*dp[k] - 111 12 这样考虑，假如此时的序列没有交集，则此时两个序列的最长公共上升子序列，在序列二中的起始坐... 阅读全文

摘要：1 /*HDU4545 最大公共子序列+滚动数组*/ 2 3 4 #include 5 #include 6 #include 7 using namespace std; 8 int dp[2][1010]; 9 char a[1010],b[1010];10 int hash[1010][1010];11 int LCS(int n,int m)12 {13 memset(dp,0,sizeof(dp));14 int i,j;15 for(i=1;i=dp[i%2][j-1])23 {24 dp[i%2... 阅读全文

摘要：1 /*HDU1257最长递增*/ 2 #include 3 #include 4 int find(int *c,int len,int n) 5 { 6 int l=0,r=len; 7 while(ln) r=mid-1;12 else return mid;13 }14 return l;15 }16 int main()17 {18 int i,j,n;19 int a[1005], c[1005],len;20 while(scanf("%d",&n)!=EOF)21 {22 for(... 阅读全文

摘要：1 /*题意：有n个矩形，用长和宽表示，如果一个的长和宽都比另一个小，那么这个嵌放在另一个中 2 所以先对w从大到小排序，w一样的按h从小到大排序，那么就从后面的箱子往前找，只要前面找到一个人h比自己大的就放入c[j]=p[i].h; 3 否则如果自己的h比前面的都大，那么必定询问到c所存的递增序列的长度+1处，那么个数加1，长度加1，把此事的h放在在c的末端 4 这个过程和最大递增子序列的找值过程类似，但是并不是求最长递增，只是利用这个过程，所以二分查找稍微有些改变，如果还是按照 5 最长公共子序列的二分查找，那么h相同的会被覆盖掉比如数据1 1 1 1 2 2 2 2,其中一个2 2会被. 阅读全文

摘要：1 /*CF335B 2 这个题目的n达到50000，但是串只是有小写字母组成,所以如果字符串的长度大于2600，那么 3 肯定存在，所开始输入就判断如果长度大于2600，那么直接找当个字母输出100个 4 否则执行LCS模块，然后判断所得最长公共是否大于100，如果小于100，那么直接输出最长公共 5 否则从两头分别取50个输出*/ 6 #include 7 #include 8 int dp[2600][2600],dir[2600][2600]; 9 char a[50005],b[2605],c[2605];10 void LCS(int n,int m)11 {12 in... 阅读全文

摘要：1 /*既然前一天的可以省下来给过后一天卖，那么就倒着卖，那么最后一天的只能在最后一天卖，如果可以卖完，还有可卖的名额，那么就从 2 倒数第二天取，如果卖不完只能丢掉，而且必定是尽量留到价格最高的那一天卖*/ 3 /*HDU2385*/ 4 #include 5 #include 6 #include 7 #include 8 using namespace std; 9 const int maxn=100000+10;10 struct N11 {12 int x,p,m;13 bool operator q;24 N a;25 while(t--)26 ... 阅读全文

摘要：1 #include 2 #include 3 char a[5010],b[5010]; 4 short int dp[2][5010]; 5 int LCS(int n,int m) 6 { 7 memset(dp, 0, sizeof(dp)); 8 int i,j; 9 for(i=1;i=dp[i%2][j-1])18 {19 dp[i%2][j]=dp[(i-1)%2][j];20 //printf("%d %d %d\n",i%2,j,dp[i%2][j]);21 ... 阅读全文

摘要：/*最终添加完边的图，肯定可以分成两个部X和Y，其中只有X到Y的边没有Y到X的边，那么要使得边数尽可能的多，则X部肯定是一个完全图，Y部也是，同时X部中每个点到Y部的每个点都有一条边，假设X部有x个点，Y部有y个点，有x+y=n，同时边数F=x*y+x*(x-1)+y*(y-1)，整理得：F=N*N-N-x*y，当x+y为定值时，二者越接近，x*y越大，所以要使得边数最多，那么X部和Y部的点数的个数差距就要越大，所以首先对于给定的有向图缩点，对于缩点后的每个点，如果100它的出度或者入度为0，那么它才有可能成为X部或者Y部，所以只要求缩点之后的出度或者入度为0的点中，包含节点数最少的那个点，令 阅读全文

摘要：1 /*树状数组求和，一边询问一边维护，离线处理*/ 2 #include 3 #include 4 #include 5 using namespace std; 6 const int maxn=100000+10; 7 struct point 8 { 9 int l,r,index; 10 }node[maxn]; 11 int a[maxn]; 12 int num[maxn]; 13 int index[maxn]; 14 int result[maxn]; 15 int n,m; 16 bool cmp(const point a,const poin... 阅读全文

摘要：1 #include 2 #include 3 int main() 4 { 5 int i,j,n,m; 6 int t; 7 scanf("%d",&t); 8 while(t--) 9 {10 scanf("%d%d",&n,&m);11 n=n*m;12 j=0;13 for(i=1;i<=n;i++)14 {15 scanf("%d",&m);16 if(m && i==n) j=1;17 ... 阅读全文

摘要：1 /* 2 区间dp 3 dp[i][j]表示这个区间组成的子串是回文串的个数*/ 4 #include 5 #include 6 const int maxn=1010; 7 int mod=10007; 8 int dp[maxn][maxn]; 9 void init(int len)10 {11 memset(dp, 0, sizeof(dp));12 for(int i = 0; i < len; ++i)13 {14 dp[i][i] = 1;//处理一个字符的情况15 }16 }17 int main()18 {19 i... 阅读全文

摘要：1 /*计算里面有多少个相邻的he，1个he就是1种意思，两个就是，两种，所以这是 2 一个斐波拉期数列，间隔的hehe互不影响所以是互斥事件，直接相乘就可以*/ 3 #include 4 #include 5 const int maxn=10086+10; 6 const int mod=10007; 7 int fb[maxn]; 8 void init() 9 {10 int i;11 fb[0]=fb[1]=1;12 for(i=2;i<maxn;i++)13 {14 fb[i]=(fb[i-1]+fb[i-2])%mod;15 ... 阅读全文

摘要：1 /* 2 首先，dp的最开始是定义状态 dp[i][j] 表示A串的前i个，与B串的前j个，并以B[j]为结尾的LCIS 的长度. 3 状态转移方程： 4 if(A[i]==B[j]) dp[i][j]=max(dp[i-1][k])+1; ( 1 11 #include 12 #include 13 using namespace std;14 #define N 55015 struct node16 {17 int x,y;18 }path[N][N];19 int dp[N][N];20 int s[N],t[N];21 22 int main()23 {24 ... 阅读全文