禅境花园

对于每个数字 ai{a_i} 处理出最左的位置 Lai{L_{a_i}} 和最右的位置 Rai{R_{a_i}}，然后 dpi{dp_i} 为前i个数字最大的值，对于每一个 Lai=i{L_{a_i}=i} 的位置计算出来i到MAX(Rai−Rai){i到MAX(R_{a_i-R{a_i}})} 的异或值，然后更新dp{dp}，最后dpn{dp_n} 为最后的答案。#include<bits/std

判断输入的点能不能组成凸包（即所有点都要是凸包的顶点）然后就是求最优三角形划分问题，也就是区间dp感觉这种区间dp还是记忆化搜索写起来比较方便记忆化搜索#include<bits/stdc++.h>using namespace std;const int inf=0x3fffffff;int top,s[10024];struct data{ int x,y;} p[100

#pragma comment(linker, "/STACK:102400000,102400000")#include<cstdio>#include<algorithm>#include<cmath>#include<cstring>#include<vector>using namespace std;const int N=5*10000+10;const long lon

/* ***********************************************Author :MaltubEmail :xiang578@foxmail.comBlog :htttp://www.xiang578.com************************************************ */#

#include<bits/stdc++.h>using namespace std;struct node{ int a,b,ab;}p[5000];int cmp(node x,node y){ return x.ab>y.ab;}int dp[2000+5][2000+5],ans,sum[2000+5];int main(){ int n,h;

hdu1505升级版#include<bits/stdc++.h>using namespace std;const int N=1024;int g[N][N],r[N],h[N][N],l[N];char s[N][N],st[N];int n,m;int fcn(int k){ if(k==0) { for(int i=1; i<=n; i++)

没有看到限制条件，品质越高的价格就越贵，导致想了一个多月都写不出来。#include<bits/stdc++.h>using namespace std;int a[1024],p[1024],dp[1024],sum[1024];int main(){ int _,n; scanf("%d",&_); while(_--) { scanf("%

tsp类型，只是这里面的点最多可以访问2次。 所以用一个来表示访问了多少次，正好是三进制。 对于每个状态i，先处理出第j位为几，即num[i][j]，方便使用。 用dp[i][j]表示，状态i时，以j为终点的最小花费。然后是和tsp一样扩展下一个点。#include<bits/stdc++.h>using namespace std;const int inf=0x7fffffff;in

dfs版本#include<bits/stdc++.h>using namespace std;typedef long long ll;int num[15];int dp[15][15][3];//dp[i][j][k]//i:数位//j:余数//k:3种状态，0-没有1，1-有1，2-有13//pos为当前处理的数位（权重表示法，也就是剩下pos+1位待填数）//mod-余数

hdu1506 的二维情况，对于每一个点，已他所在行为矩形的最上边。预处理该点下面有多少个连续的一就是h[i] [j]，然后求出l[i][j]和r[i][j].#include<bits/stdc++.h>using namespace std;const int N=1024;int g[N][N],r[N][N],h[N][N],l[N][N];int main(){ int _

依次考虑每一个a[i],只需要求出左边和右边连续的不小于a[i]数的个数即可。所以，要维护l[i]和r[i]。 然后优化的地方在于l[i]和r[i]的求法:a[i-1]#include <stdio.h>using namespace std;const int N=100000+10;__int64 a[N],l[N],r[N],tmp;int main(){ int n,i;

首先用强连通缩点，之后再用图中的桥和强连通分量新建一张图，之后算一次树形dp。 树形dp过程是，将一棵无根树，当成有根树，利用dfs计算每个节点的子树中的权值（即每一个强连通分量中的人数）#include <stdio.h>#include <string.h>#include <iostream>#include <algorithm>#include <vector>#include

。。。

#include<bits/stdc++.h>using namespace std;int a[128][128];void init(){ memset(a,0,sizeof(a)); a['A']['A']=5; a['A']['C']=-1; a['A']['G']=-2; a['A']['T']=-1; a['A']['-']=-3;

#include<bits/stdc++.h>using namespace std;const int inf=0xfffffff;int dp[100][100];int s[100],u[100];int a,b,c;int main() { int k,n,ans; while(~scanf("%d",&n)) { if(n==0) break;

#include<cstdio>#include<algorithm>#include<cmath>#include<cstring>#include<iostream>using namespace std;const int inf=0x3fffffff;int n,t,q,m,x,ans;int a[1024],b[1024],dp[200][200];int main(){

dp[i][j]: 代表合理利用前i个水晶建造两座塔，较高的塔比较低的塔高j时，较高的塔的高度。 每次转移考虑三种情况，不选用第i个，或者分别放在较高的塔上、较低的塔上。#include<bits/stdc++.h>using namespace std;int sum,n,h[1000],dp[2][5000];int main(){ while(~scanf("%d",&n))

#include<bits/stdc++.h>using namespace std;typedef long long ll;int num[20];ll dp[20][20][3];//dp[i][k]//i:数位//k:3种状态，0-随便填，1-必须要选奇数，2-必须要选偶数//pos为当前处理的数位（权重表示法，也就是剩下pos+1位待填数）//have-状态;//lim-

导弹拦截问题中的本质是求一个序列的最长上升子序列，只有这样才会新开导弹组。也就是本问题中的铁轨。#include<bits/stdc++.h>#include<bits/stdc++.h>using namespace std;int n,a[100000+10],b[100000+10];int cnt,t;int main(){ int n,m,k; scanf("%d

#include<bits/stdc++.h>using namespace std;char a[1024],b[1024];int dp[1024][1024][20],ans[1024][1024][20];int main(){ int n,m,p; scanf("%d%d%d",&n,&m,&p); scanf("%s",a+1); scanf("%

#include<stdio.h>#include<string.h>#include<algorithm>using namespace std;int g[1024],num[1024],cnt,dp[105][70][70],p[105];char s[105][15];void init(int m){ cnt=0; int up=1<<m,f,sum=0;

import java.math.BigInteger;import java.util.Scanner;public class Main { public static void main(String[] args) { Scanner in=new Scanner(System.in); int n,x,y,z; BigInteger

本来想写nlogn，想错了，一直过不了，只能上暴力的。//#include<bits/stdc++.h>#include<stdio.h>#include<vector>#include<string.h>#include<algorithm>using namespace std;const int N=1024;int f[N],a[N],d[N];struct node{

时间的范围比较大，但是最多只有20W点，所以可以选择离散化离散化时，可以lower_bound重新搜索标号之后，按结束时间从小到大排序，再进行dp？#include<stdio.h>#include<string.h>#include<math.h>#include<algorithm>using namespace std;const int N=100000+10;struct

#include<bits/stdc++.h>using namespace std;int a[1024][1024],h[1024][1024];int cmp(int n,int m) { return n>m;}int main() { int n,m,ans; char s[1024]; while(~scanf("%d%d",&n,&m)) {

#include<bits/stdc++.h>using namespace std;int n,a[1024][1024],b[1024],dp[1024],t;int inf=0x3fffffff;int main(){ while(~scanf("%d",&n)) { int ans=-inf; for(int i=1;i<=n;i++

#include <cstdio>#include <cstring>#include <iostream>#include <algorithm>#include <vector>#include <queue>#include <stack>#include <set>#include <map>#include <string>#include <cmath>#inclu

忍住没有搜题解，零零碎碎想了两个星期才想出来怎么DP。#include<bits/stdc++.h>using namespace std;typedef long long ll;const ll inf=0x7fffffff;ll dp[2048][2048],c[2048],ans;int main(){ int i,j,n,k; while(~scanf("%d%d

#include<bits/stdc++.h>using namespace std;const int inf=0xfffffff;int dp[400][400],cost[400][400],a[400],sum[400];int main(){ int n,m,cnt=0,ans; while(~scanf("%d%d",&n,&m)) {

#include<bits/stdc++.h>using namespace std;const int inf=1<<24;int main(){ int _,__,i,j,k,n,t,ans,a[100+5],sum[100+5],dp[100+5][100+5]; scanf("%d",&_); for(__=1; __<=_; __++) {

#include <bits/stdc++.h>using namespace std;int a[500000+5],b[500000+5],f[500000+5];int bs(int l,int r,int x){ int mid; while(l<r) { mid=(l+r)/2; if(x>=f[mid]) l=mid+1;

。。。

。。。

。。。

。。。

。。。

。。。

。。。

。。。

。。。