Root :: AOAPC I: Beginning Algorithm Contests (Rujia Liu) Volume 5. Dynamic Programming
10192 最长公共子序列
http://uva.onlinejudge.org/index.php?option=com_onlinejudge& Itemid=8&page=show_problem&category=114&problem=1133&mosmsg= Submission+received+with+ID+13297616
*/
#include <cstdio>
#include <string.h>
#include<istream>
using namespace std;
char s1[],s2[];
int dp[][];
int main()
{
int n,m,num=;
while(gets(s1))
{
if(s1[]=='#')
break;
n=strlen(s1);
gets(s2);
m=strlen(s2);
memset(dp,,sizeof(dp));
int d=;
for(int i=;i<=n;i++)
{
for(int j=;j<=m;j++)
if(s1[i-]==s2[j-])
{
dp[d][j]=dp[d^][j-]+;
} else
dp[d][j]=dp[d][j-]>dp[d^][j]?dp[d][j-]:dp[d^][j];
d=d^;
}
printf("Case #%d: you can visit at most %d cities.\n",++num,dp[d^][m]);
}
return ;
}
147 这题输出的时候小心一点 就行 多重背包的方案数 */
#include <cstdio>
#include <string.h>
#include <iostream>
#include<iomanip>
using namespace std;
int W[]={,,,,,,,,,,};
long long dp[],num[];
int main() {
char str[];
while(true){
scanf("%s",str);
int n=; int L=;
int Len=strlen(str);
while(Len!=){
if(str[Len-]!='.') {
n+=(str[Len-]-'')*L;
L=L*;
}
Len--;
}
if(n==) break;
memset(dp,,sizeof(dp));
dp[]=;
for(int i=;i<;i++){
for(int j=W[i];j<=n;j++)
dp[j]=dp[j]+dp[j-W[i]];
}
printf("%6s",str);
cout<<setw()<<dp[n]<<endl;
}
return ;
}
/* uva 357 简单 硬币划分种类 还是 long long 的 数值没搞好 记住数值预测 */
#include <cstdio>
#include <string.h>
#include <iostream>
using namespace std;
long long dp[];
int W[]={,,,,};
int main(){
memset(dp,,sizeof(dp));
dp[]=;
for(int i=;i<;i++){
for(int j=W[i];j<=;j++)
dp[j]=dp[j-W[i]]+dp[j];
}
int n;
while(scanf("%d",&n)==){
if(dp[n]!=)
cout<<"There are "<<dp[n]<<" ways to produce "<<n<<" cents change.";
else cout<<"There is only 1 way to produce "<<n<<" cents change.";
cout<<endl;
}
return ;
}
/* uva 526 题目说的是 有一堆硬币 然后 让面值 尽量均分给两个人 可以先假设 首先将这些硬币全部给
一个人 然后 将每个面值 乘 2 变为负数，这样就能够 将他看成是 01背包 就是说，像这样
每个物品如果转移 那么就会 产生 2*W 的逆差 就这样 不断的去找就能找到 最小的结果 dp[j]=dp[j-w[i]]; */
#include <cstdio>
#include <string.h>
#include <iostream>
using namespace std;
bool dp[];
int w[];
int main(){
int T;
scanf("%d",&T);
while(T--){ int m,i,a,sum=;
scanf("%d",&m);
for(i=;i<m;i++){
scanf("%d",&a);
w[i]=-a*; sum+=a;
}
int mmm=sum;
memset(dp,false,sizeof(dp));
dp[sum]=true;
for( i=;i<m;i++)
for(int j=;j<sum;j++)
if(dp[j-w[i]]){
dp[j]=true;
if(mmm>j)mmm=j;
}
printf("%d\n",mmm);
}
return ;
}
/* uva 348 矩阵连乘 写出计算的方程式 小白书上提示了这题该怎么做自然很容易就 可以得到 了状态转移方程dp[i][j]=min(dp[i][j]#dp[j+1][i+k])然后计入每个状态是从哪里来的 就 好了*/
#include <cstdio>
#include<iostream>
#include <string.h>
using namespace std;
struct point{
int LX,LY,RX,RY;
point(int a=,int b=,int c=,int d=) {
LX=a;LY=b;RX=c;RY=d;
}
}di[][];
struct node
{
int X,Y;
int num;
node(int a=,int b=,int c=)
{
num=a;X=b;Y=c;
}
}dp[][];
void dfs(int a,int b)
{
if(a==b) {
printf("A%d",a);
return ; }
printf("(");
dfs(di[a][b].LX,di[a][b].LY);
printf(" x ");
dfs(di[a][b].RX,di[a][b].RY);
printf(")");
}
int main(){
int n,mmm=;
while(true){
scanf("%d",&n);
if(n==)break;
int j,i,k,h;
for(i=;i<=n;i++){
int a,b;
scanf("%d%d",&a,&b);
dp[i][i]=node(,a,b);
}
for(i=;i<n;i++){
int num=dp[i][i].X*dp[i+][i+].Y*dp[i][i].Y;
dp[i][i+]=node(num,dp[i][i].X,dp[i+][i+].Y);
di[i][i+]=point(i,i,i+,i+);
}
for( k=;k<=n;k++)
for( i=;i+k<=n;i++) {
dp[i][i+k].num=;
for(j=i;j<i+k;j++){
int num=dp[i][j].X*dp[j+][i+k].Y*dp[i][j].Y+dp[i][j].num+dp[j+][i+k].num;
if(dp[i][i+k].num>num){
dp[i][i+k]=node(num,dp[i][j].X,dp[j+][i+k].Y);
di[i][i+k]=point(i,j,j+,i+k);
}
}
}
printf("Case %d: ",++mmm);
printf("(");
dfs(di[][n].LX,di[][n].LY);
printf(" x ");
dfs(di[][n].RX,di[][n].RY);
printf(")\n");
}
return ;
}
/* uva 624 CD 01 背包 然后打印方案总数，选取最大的 容量 背包所能承受的 我用了二维的数组来存储 路径 */
#include <cstdio>
#include <string.h>
#include <iostream>
using namespace std;
bool dp[][];
bool per[][];
int w[]; int main() {
int n;
while(scanf("%d",&n)==){
memset(per,false,sizeof(per));
memset(dp,false,sizeof(dp));
int i,j,k,max_v=,m;
scanf("%d",&m);
for(i=;i<=m;i++)
scanf("%d",&w[i]);
dp[m+][]=true;
for(i=m;i>;i--)
for(j=;j<=n;j++)
{
dp[i][j]=dp[i+][j];
if(j>=w[i]&&dp[i+][j-w[i]]){
if(j>max_v)max_v=j;
per[i][j]=true;
dp[i][j]=true;
}
}
k=max_v;
for(i=;i<=m;i++)
if(per[i][k]){
printf("%d ",w[i]);
k=k-w[i];
}
printf("sum:%d\n",max_v);
}
return ;
}
/* 10130 多个的 01 背包 混在 一起 刚开始读错题了 以为每件商品只能选一次 坑了 看来自己 还得继续 努力啊 ！ */
#include<cstdio>
#include<string.h>
#include<iostream>
using namespace std;
int w[],c[],g[],dp[];
int main(){
int t;
cin>>t;
while(t--){
int n,m;
cin>>n;
for(int i=;i<n;i++)
cin>>w[i]>>c[i];
cin>>m;
for(int i=;i<m;i++)
cin>>g[i];
int ans=,maxv=;
for(int k=;k<m;k++){
for(int i=;i<=g[k];i++)
dp[i]=-;
dp[]=; maxv=;
for(int i=;i<n;i++)
for(int j=g[k];j>=c[i];j--)
if(dp[j-c[i]]!=-&&dp[j]<dp[j-c[i]]+w[i]){
dp[j]=dp[j-c[i]]+w[i];
if(dp[j]>maxv) maxv=dp[j];
} ans+=maxv;
}
cout<<ans<<endl;
}
return ;
}
/* 最长公共子序列 输出路径 lcs 加上路径输出 */
#include<cstdio>
#include<iostream>
#include<string.h>
using namespace std;
const int maxn=;
const int maxm=;
char str1[maxn][maxm];
char str2[maxn][maxm];
char ch[maxn][maxn];
int dp[maxn][maxn];
void print(int a,int b,int g){
if(a==||b==) return ;
if(ch[a][b]=='c'){
int c=g; g=;
print(a-,b-,g);
if(c==)
printf("%s\n",str1[a-]);
else printf("%s ",str1[a-]);
} else
{
if(ch[a][b]=='L')
print(a,b-,g);
else print(a-,b,g);
}
}
int main() {
int i,j,n=,m=;
while(scanf("%s",str1[])==){
n=;m=;
memset(ch,,sizeof(ch));
memset(dp,,sizeof(dp));
while(str1[n][]!='#'){
scanf("%s",str1[++n]);
}
while(true){
scanf("%s",str2[m]);
if(str2[m][]=='#')
break; ++m; }
for(i=;i<=n;i++)
for(j=;j<=m;j++)
if(strcmp(str1[i-],str2[j-])==){
dp[i][j]=dp[i-][j-]+; ch[i][j]='c';
}else{
if(dp[i][j-]>dp[i-][j])
{ dp[i][j]=dp[i][j-]; ch[i][j]='L';}
else { dp[i][j]=dp[i-][j];ch[i][j]='U';
}
}
print(n,m,);
}
return ;
}
/* uva 10456 简单的完全背包问题 */
#include <cstdio>
#include <string.h>
#include <iostream>
using namespace std;
const int maxn=;
int dp[maxn];
bool mark[maxn];
int main(){
int a[],t;
while(scanf("%d%d%d",&a[],&a[],&t)==){
int i,j;
memset(mark,false,sizeof(mark));
mark[]=true;
memset(dp,,sizeof(dp));
for(i=;i<;i++)
for(j=a[i];j<=t;j++)
if(mark[j-a[i]]&&dp[j]<dp[j-a[i]]+){
dp[j]=dp[j-a[i]]+; mark[j]=true;
}
for(i=t;i>=;i--)
if(mark[i]){
if(i==t)
printf("%d\n",dp[i]);
else
printf("%d %d\n",dp[i],t-i);
break;
}
}
return ;
}
/* uva 10258 这都能A 不敢爱了 R*C*R*C的时间效率 这题说的是
在滑雪的时候 选择 最长的下坡路 然后 可以向周边的 四个地方 划过去
让后就顺利 解决了 即 dp[i+x][j+y]=max(dp[i][j]+1); 进行 R*C次的迭代 */
#include<cstdio>
#include<string.h>
#include<iostream>
using namespace std;
const int maxn=;
char str[];
int dp[maxn][maxn];
int map[maxn][maxn];
int xx[]={,-,,};
int yy[]={,,,-};
int main() {
int t;
scanf("%d",&t);
while(t--){
memset(dp,,sizeof(dp));
int R,C,i,j,k,maxv=;
scanf("%s%d%d",str,&R,&C);
for(i=;i<R;i++)
for(j=;j<C;j++){
scanf("%d",&map[i][j]);
dp[i][j]=;
} for(k=;k<R*C;k++){
bool flag=true;
for(i=;i<R;i++)
for(j=;j<C;j++){
for(int h=;h<;h++){
int x=xx[h]+i,y=yy[h]+j;
if(x>=&&x<R&&y>=&&y<C&&dp[x][y]<(dp[i][j]+)&&map[x][y]<map[i][j]){
dp[x][y]=dp[i][j]+;
flag=false;
if(dp[x][y]>maxv)
maxv=dp[x][y];
}
} }
if(flag)
break;
}
printf("%s: %d\n",str,maxv);
}
return ;
}
/* 记忆化搜索 他说的是有很多的 长方体 小的放上面 让 最大高度 做出 每种可能出现的面 */
#include<cstdio>
#include<string.h>
#include<iostream>
using namespace std;
const int maxn=;
struct point{
int x,y,z;
point (int a=,int b=,int c=){ x=a;y=b;z=c; }
}T[maxn]; int num,n,maxv,dp[maxn];
int dfs(int a) {
if(dp[a])
return dp[a];
dp[a]=T[a].z;
for(int i=;i<num;i++)
if(T[i].x<T[a].x&&T[i].y<T[a].y){
int temp=dfs(i)+T[a].z;
if(temp>dp[a]) dp[a]=temp;
}
if(dp[a]>maxv)
maxv=dp[a];
return dp[a];
} int main() {
int tt=;
while(scanf("%d",&n)==){
if(n==) break;
int i;
num=;
maxv=;
memset(dp,,sizeof(dp));
for(i=;i<n;i++){
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
T[num++]=point(x,y,z);
T[num++]=point(y,x,z);
T[num++]=point(y,z,x);
T[num++]=point(z,y,x);
T[num++]=point(z,x,y);
T[num++]=point(x,z,y);
}
for(i=;i<num;i++)
dfs(i);
printf("Case %d: maximum height = %d\n",++tt,maxv);
}
return ;
}
/*
这题 想到动态转移方程 即dp[i]所能到达的地方状态 一旦全为 必胜的 状态 这就必败了
这个点能到的 状态 只要有 一个是 必败的状态那么 这个点就是必胜的
dp[0]=false;
0 时是必败的对于先手来说 然后就可以转移方程了
这样就有动态方程 dp[i]|=dp[i-A[j]];
#include<cstdio>
#include<string.h>
#include<iostream>
using namespace std;
int n,m,A[];
bool w[];
int main()
{
int i,j;
while(scanf("%d",&n)==){
scanf("%d",&m);
for(i=;i<m;i++)
scanf("%d",&A[i]);
w[]=false;
for(i=;i<=n;i++)
{
w[i]=false;
for(j=;j<m;j++)
w[i]|=A[j]<=i&&!w[i-A[j]];
}
if(w[n]) printf("Stan wins\n");
else printf("Ollie wins\n"); }
return ;
}
/* 题目的 意思是 给定你一个字符串判断字符串正所处的状态
simple stage O = A
fully-grown stage O = OAB
mutagenic stage O = BOA
可能进行多次的嵌套
然后 用dp进行处理 经过分析可以很清楚的知道 状态的 转移只有两种
要么是第二种要么是第三种 当然只有一个的时候。 可能是第一种，然
后就得到这样的状态转移到方程
dp[i][j+i]=work(dp[j+1][j+i])
dp[j][j+i]=work(dp[j+1][j+i-1])
由题目所述 前者优先 */
#include<cstdio>
#include<string.h>
#include<iostream>
using namespace std;
int dp[][];
char str[];
int main(){
int n;
scanf("%d",&n);
getchar();
while(n--){
gets(str);
int Len=strlen(str);
for(int i=;i<Len;i++)
for(int j=;j<Len;j++)
dp[i][j]=;
for(int i=;i<Len;i++)
if(str[i]=='A')
dp[i][i]=;
for(int i=;i<=Len;i++)
for(int j=;j+i<Len;j++){
if(str[j+i]=='B'&&str[j+i-]=='A'&&dp[j][j+i-]){ dp[j][j+i]=; continue;
}
if(str[j]=='B'&&str[j+i]=='A'&&dp[j+][j+i-]){
dp[j][j+i]=;
}
}
int g=dp[][Len-];
if(g==) {
printf("SIMPLE\n");
continue;
} if(g==){
printf("FULLY-GROWN\n");
continue;
}
if(g==){
printf("MUTAGENIC\n");
continue;
} printf("MUTANT\n");
} return ;
}
#include<cstdio>/* 825 应该是求背包的 种类 一个spaf 就可以了*/
#include<string.h>
#include<iostream>
#include<queue>
using namespace std;
const int maxn=;
const int maxv=;
struct node{
int x,y;
node (int a=,int b=) {
x=a;y=b;
}
};
int N[maxn][maxn],M[maxn][maxn];
bool mark[maxn][maxn],inq[maxn][maxn];
int n,m;
char str[maxn];
int xx[]={-,,,};
int yy[]={,,-,};
int main(){
int tt=;
scanf("%d",&tt);
while(tt--){
queue<node>Q;
scanf("%d%d",&n,&m);
getchar();
for(int i=;i<=n;i++)
for(int j=;j<=m;j++){
mark[i][j]=false; M[i][j]=maxv; N[i][j]=;
inq[i][j]=false;
}
for(int i=;i<=n;i++){
gets(str);
int Len=,L=;
while(Len<=strlen(str)){
if(str[Len]>=''&&str[Len]<=''){
L=L*+str[Len]-'';
}
else {
if(L!=)
mark[i][L]=true;
L=;
}
Len++;
}
}
node t;
N[][]=;
M[][]=;
Q.push(node(,));
inq[t.x][t.y]=true;
while(!Q.empty()){
t=Q.front(); Q.pop();
if(mark[t.x][t.y]) continue;
inq[t.x][t.y]=false;
for(int i=;i<;i++){
int x=t.x+xx[i],y=t.y+yy[i];
if(x<||x>n||y<||y>m||mark[x][y]) continue;
if(M[x][y]<M[t.x][t.y]+)continue;
if(M[x][y]==M[t.x][t.y]+){ N[x][y]+=N[t.x][t.y]; }
else N[x][y]=N[t.x][t.y];
M[x][y]=M[t.x][t.y]+;
if(!inq[x][y])
{
inq[x][y]=true;
Q.push(node(x,y)); }
}
}
printf("%d\n",N[n][m]);
if(tt!=) printf("\n");
}
return ;
}
/*
这题说的是在一个母串中存在一个子序列的个数
例如
babgbag
bag
5个
可以很清楚的知道字母之间的联系只与前或者后有关系
然后可以知道 dp[i]+=local(dp[i-1]);强大的剪枝
*/
#include <iostream>
#include<cstdio>
#include<string.h>
using namespace std;
const int maxn=;
const int tap=;
int dp[][],Len[];
char s1[],s2[];
void add(int L,int R){
int G=,i;
for(i=;i<Len[L];i++){
G=(dp[L][i]+dp[R][i]+G);
dp[R][i]=G%maxn;
G=G/maxn;
}
while(G!=){
G=(G+dp[R][i]);
dp[R][i]=G%maxn;
i++; G=G/maxn;
}
if(Len[R]<i)Len[R]=i;
}
void copydate(int L,int R){
memset(dp[L],,sizeof(dp[L]));Len[L]=;
for(int i=;i<Len[R];i++)
dp[L][i]=dp[R][i];
Len[L]=Len[R];
}
int main()
{
int t;
scanf("%d",&t);
while(t--){
scanf("%s%s",s1,s2);
int L1=strlen(s1),L2=strlen(s2);
memset(Len,,sizeof(Len));
memset(dp,,sizeof(dp));
for(int i=;i<L1;i++)
if(s1[i]==s2[])dp[i][Len[i]++]=;
for(int i=;i<L2;i++){
memset(dp[tap],,sizeof(dp[tap]));Len[tap]=;
for(int j=;j<L1;j++){
bool flag=true;
if(s2[i]==s1[j]&&Len[tap]!=){
copydate(tap+,j);
copydate(j,tap); flag=false;
}
if(Len[j]!=&&flag) {
add(j,tap); memset(dp[j],,sizeof(dp[j]));Len[j]=;
}
if(!flag&&Len[tap+]!=){
add(tap+,tap);memset(dp[tap+],,sizeof(dp[tap+]));Len[tap+]=;
}
}
}
memset(dp[tap],,sizeof(dp[tap])); Len[tap]=;
for(int i=;i<L1;i++)
if(Len[i]!=)add(i,tap);
while(dp[tap][Len[tap]-]==&&Len[tap]>) Len[tap]--;
printf("%d",dp[tap][Len[tap]-]);Len[tap]--;
while(Len[tap]>=){ printf("%07d",dp[tap][Len[tap]-]);Len[tap]--;}
printf("\n");
} return ;
}
uva10534 这题说的是找一个序列 左 边 严 格 递 增 右 边 严 格 递 减 然 后 左边的个数和 右边的个数 要相同 保证左边的个数为 N 右 边 的 个 数也为N总公 N*2+1 个
我用了 两次 二分的LIC 正向 一次 反向一次 然后枚举区间的值
#include <iostream>
#include<cstdio>
#include<string.h>
using namespace std;
const int maxn=;
int dp[][maxn];
int M[][maxn],T[maxn];
int birseach(int n,int w){
int L=,R=n-,mid;
while(L<R){
mid=L+(R-L)/;
if(T[mid]==w) return mid;
if(w>T[mid])
L=mid+;
else R=mid-;
}
if(T[L]<w)L++;
return L;
}
void LIS(int n,int h){
int Len=;
T[]=M[h][]; dp[h][]=;
for(int i=;i<n;i++){
if(M[h][i]>T[Len-]){
T[Len++]=M[h][i];
}
else {
int in=birseach(Len,M[h][i]);
T[in]=M[h][i];
}
dp[h][i]=Len;
}
}
int main()
{
int n;
while(scanf("%d",&n)==){
for(int i=;i<n;i++){
scanf("%d",&M[][i]);
M[][n--i]=M[][i];
}
LIS(n,);
LIS(n,);
int ma=;
for(int i=;i<n;i++){
int L=dp[][i]<dp[][n--i]?dp[][i]:dp[][n--i];
if(ma<L)ma=L;
}
printf("%d\n",(ma-)*+);
}
return ;
}
uva10651 这题说的是给了一串'_'、' o' 组成的 字符串 看几组数据个吧就更好理解了
5
---oo------- 1
-o--o-oo---- 2
-o----ooo---
就是说连起来的 三个字符 中间一个必须为'o' 然后 如果左边为 ‘o’ 那么右边 必须为‘_’ 然后如果 左边的 那个移到右边去 那么中间的 那个就消掉 从 oo_ 变成__o
反方向就是 _oo 变成 o__ 然后 尽可能的消掉‘o’ 计算最少剩下几个没有被消掉
看看 字符串规定为12 然后就 不超过5000种的状态 然后 先处理好他们的 转换关系 然后每个一个串 转化为一个值 然后进行一次最长路
#include <iostream>
#include<string.h>
#include<cstdio>
#include<vector>
#include<queue>
using namespace std;
const int maxn=;
vector<int>P[maxn];
int dis[maxn];
bool inq[maxn];
int main()
{
char str[];
for(int i=;i<(<<);i++){
int d=i;
for(int j=;j<;j++){
if((d&(<<(j-)))&&(d&(<<j))&&(d&(<<(j-)))==)
P[d].push_back(d^(<<(j-))^(<<j)^(<<(j-)));
if((d&(<<(j-)))&&(d&(<<(j-)))&&(d&(<<j))==)
P[d].push_back(d^(<<(j-))^(<<j)^(<<(j-)));
}
}
int t;
scanf("%d",&t);
while(t--){
memset(dis,,sizeof(dis));
memset(inq,false,sizeof(inq));
scanf("%s",str);
int L=,ma=,num=;
for(int i=;i<;i++){
if(str[i]=='o')
{ L=L*+; ++num; }
else L=L*;
}
dis[L]=;
queue<int>Q;
Q.push(L);
while(!Q.empty()){
int x=Q.front(); Q.pop();
if(dis[x]>ma) ma=dis[x];
inq[x]=false;
for(int i=;i<P[x].size();i++){
int to=P[x][i];
if(dis[to]<dis[x]+){
dis[to]=dis[x]+;
if(!inq[to]){
inq[to]=true; Q.push(to);
}
}
}
}
printf("%d\n",num-ma);
}
return ;
}
uva 10051 这题说的是 有n个正方体 每个正方体的每一面都有以一种颜色 要将这些正方体堆叠起来 堆叠的要求
1 重量小的不能放在重量大的上面
2 在他们的面与面的连接处应该有相同的颜色。
题目给的正方体 是按照重量递增给的然后计算给了n个正方体 计算最多能够堆叠几个正方体
对于这题可以将他转化为最长递增子序列 讲一个正方体变成6个点 这六个点的重量相同既不会同时出现一个正方体被用了两次
每个点都对应于一个面 相同就从与他^1的点出来应为这是对面的点
dp[i]=max(dp[j^1]+1)
#include <iostream>
#include<cstdio>
#include<string.h>
using namespace std;
const int maxn=*+;
int per[maxn],dp[maxn],color[maxn],F[maxn];
char str[][]={ {"front"},{"back"},{"left"},{"right"},{"top"},{"bottom"} };
int main()
{
int t=,n;
while(scanf("%d",&n)==){
int k=;
if(n==) break;
if(t!=) printf("\n");t++;
k=n*;
for(int i=;i<=n;i++){
k=k-;
for(int j=;j<;j++){
scanf("%d",&color[k+j]);
F[k+j]=i;
}
}
int mav=,loc;
memset(dp,,sizeof(dp));
memset(per,-,sizeof(per));
for(int i=;i<n*;i++){
dp[i]=;
for(int j=;j<i;j++)
if(color[j]==color[i]&&F[j]>F[i]&&dp[i]<dp[j^]+){
dp[i]=dp[j^]+; per[i]=j;
}
if(dp[i]>mav){ mav=dp[i];loc=i;}
}
printf("Case #%d\n%d\n",t,mav);
loc=loc^;
while(loc!=-){
int G=loc%;
printf("%d %s\n",F[loc],str[G]);
loc=loc^;
loc=per[loc];
}
}
return ;
}
uva 590 说的是 一个人为了逃避警察的追捕 然后从1这个点每天坐一趟飞机 第k天 必须到达 n点的 最小费用
dp[i][k]=min(dp[i][k],dp[i][k-1]+cost);
#include <iostream>
#include<string.h>
#include<cstdio>
using namespace std;
const int maxn=;
const int maxm=;
const int maxv=;
int edg[maxn][maxn][];
int Len[maxn][maxn];
int dp[maxn][maxm];
int main()
{
int cas=;
while(true){
int n,m; scanf("%d%d",&n,&m); if(n==&&m==) break; for(int i=;i<=n;i++) for(int j=;j<=m;j++) dp[i][j]=maxv; for(int i=;i<=n;i++) for(int j=;j<=n;j++){
Len[i][j]=;
if(i==j){
edg[i][j][]=;
continue;
} int num;
scanf("%d",&num);
Len[i][j]=num;
for(int k=;k<num;k++)
scanf("%d",& edg[i][j][k]); } dp[][]=;
for(int k=;k<=m;k++) for(int i=;i<=n;++i) for(int j=;j<=n;++j){
if(i==j) continue;
int L=Len[j][i]; int cost=edg[j][i][(k-)%L]; if(cost==||dp[j][k-]==maxv) continue; dp[i][k]=dp[i][k]>dp[j][k-]+cost?dp[j][k-]+cost:dp[i][k];
} printf("Scenario #%d\n",++cas); if(dp[n][m]==maxv) printf("No flight possible.\n"); else printf("The best flight costs %d.\n",dp[n][m]); printf("\n");
}
return ;
}
uva 10306 这 题 说 的 是 给 了 一 种 钱 币 是 有 两 种 价 值 构 成 的 这 种 钱 币 叫 做 e-coin(E,H) 然 后 这 种 钱币换成 M=sqrt(E*E+H*H)价 值 的 T 钱 币
然 后 转 化 为 求背包的最小件数
dp[i+W[0][k]][W[1][k]]=min(dp[i][j]+1)
#include <iostream>
#include<cstdio>
#include<string.h>
using namespace std;
const int maxn=;
const int maxm=;
const int maxv=;
int W[][maxm],dp[maxn][maxn];
int main()
{
int t;
scanf("%d",&t);
while(t--){
int m,S;
scanf("%d%d",&m,&S);
int G=S*S;
for(int i=;i<=S;i++)
for(int j=;j<=S;j++)
dp[i][j]=maxv; int ma=maxv; for(int i=;i<m;i++)
scanf("%d%d",&W[][i],&W[][i]); dp[][]=;
for(int k=;k<m;k++)
for(int i=;i<=S;i++){
int H=W[][k]+i;
if((H)*(H)+W[][k]*W[][k]>G) break;
for(int j=;;j++){
int F=j+W[][k];
if(H*H+F*F>G)break;
if(dp[i][j]==maxv) continue;
dp[H][F]=dp[i][j]+>dp[H][F]?dp[F][H]:dp[i][j]+;
if(H*H+F*F==G)ma=ma>dp[H][F]?dp[H][F]:ma;
}
}
if(ma==maxv) printf("not possible\n");
else printf("%d\n",ma);
}
return ;
}
uva 10739 题目说的是给定 一个字符串 你可以进行下列三种的运算
1 在任何位置增加一个字符
2 在任何位置替换某个字符
3 在任何位置删除某个字符
转移方程 当str[i]==str[j]相等的时候 dp[i][j]=dp[i-1][j-1]
还有 dp[i][j]=min(dp[i][j],dp[i+1][j]+1,dp[i][j-1]+1,dp[i-1][j-1]+1) (dp[i+1][j]+1,dp[i][j-1]+1)增加 一个字符 dp[i-1][j-1]+1 是 替 换 一 个 字符 对 于删 除 可以和增加类似
#include <iostream>
#include <cstdio>
#include <string.h>
using namespace std;
const int maxn=;
const int maxv=;
char str[maxn];
int dp[maxn][maxn];
int minv(int a,int b){
return a<b?a:b;
}
int main()
{
int t;
scanf("%d",&t);
for(int cas=;cas<=t;cas++){
scanf("%s",str);
int Len=strlen(str);
for(int i=;i<Len-;i++){
dp[i][i]=dp[i+][i+]=;
if(str[i]==str[i+])dp[i][i+]=;
else dp[i][i+]=;
}
for(int k=;k<Len;k++)
for(int i=;i+k<Len;i++){
int j=i+k; dp[i][i+k]=maxv;
if(str[i]==str[j])dp[i][j]=dp[i+][j-];
dp[i][j]=minv(minv(dp[i][j],minv(dp[i+][j]+,dp[i][j-]+)),dp[i+][j-]+);
}
printf("Case %d: %d\n",cas,dp[][Len-]);
}
return ;
}
uva 10304 这题说的是 给了e1 e2 e3 e4 e5 ... 值 是 严 格 递 增 也就是说 给 了 一 个 效 率 最 差 的 查 找 二 叉 树(按 照 查 找 二 叉 树 的 建 树 规 则 是 这 样 的 当 一 个 结 点 大于它的 父亲节点那么他就放在该父亲节点的 右 子 树 上 如果小于 就放在左子树上等于的话就看自己怎么设置这课树了，(呵呵 数据结构的课程设计就是做这个 理解起来就相对容易些)) 然 后 给了 对于每个点 都有被找到的次数 和离根节点的 距离 分别是 f[x] 和 cost[x] 然后计算
f(e1)*cost(e1) + f(e2)*cost(e2) + ... + f(en)*cost(en) 使得这个值最小(也就是使得这课二叉查找树的效率达到最佳)
可以知道 排序二叉树 左孩子的 值一定小于根节点 右孩子的值大于 根节点 通过改变根节点可以使得这课树达到最佳的状态
接下来就是处理根节点的问题了 可以想象一下 当这棵树只有 2个节点 的时候 要达到最优的树 可以通过枚举 根结点 然后三个节点的树呢 是不是可以通过 枚举三个节点中任意一个节点作为 根节点 与其余两个节点所能得到最优树 配合达到最优的树得到的解呢 可以想象一下 这三个节点在枚举的时候已经能够将这颗树的所有情况考虑在内了 ，现在这样想想 是不是 最优子结构呢？ 好像有点道理 就是最优子结构 没有任何的后效性 ，
dp[i][j] 表示 节点 i到j 为节点 所能得到的最优树 那么 这样的方程又会由什么样的状态转移而来呢 刚刚咱们上面说了 最优子结构 然后枚举 根节点
得到 dp[i][j]=dp[i][k-1]+w[i][k-1]+dp[k+1][j]+w[k+1][j] 可以知道这整棵树都向下移动了一个距离就是 加上这正整棵树的权值
视乎到这里 已经得了解
#include <iostream>
#include<cstdio>
#include<string.h>
using namespace std;
const int maxn=;
const int maxv=;
int dp[maxn][maxn];
int w[maxn][maxn];
int minv(int a,int b){
return a>b?b:a;
}
int main()
{
int n;
while(scanf("%d",&n)==){
memset(dp,,sizeof(dp));
memset(w,,sizeof(w));
for(int i=;i<=n;i++)
scanf("%d",&w[i][i]);
for(int k=;k<n;k++)
for(int i=;i+k<=n;i++){
w[i][i+k]=w[i][i+k-]+w[i+k][i+k];
dp[i][i+k]=maxv;
}
for(int t=;t<n;t++)
for(int i=;i+t<=n;i++){
int j=i+t;
for(int k=i;k<=j;k++)
{
dp[i][j]=minv(dp[i][j],dp[i][k-]+w[i][k-]+dp[k+][j]+w[k+][j]);
}
}
printf("%d\n",dp[][n]);
}
return ;
}
uva 1207 佳佳的筷子 这题说的是 佳佳 请客吃饭 总共 k+8个人 有n 支筷子 然后每个人有三支筷子 然后 每次选定三跟筷子都是 （假设这里的 较小的两根筷子叫做 A，B）计算使得拿出k+8双筷子后 每个配合的 （A+B）*（A+B） 的总和最小 表示没有想出来 经过提醒 考虑第 j 根筷子选还是不选 这样就有 前 j 根筷子 选出 i 个 集 合筷子的方法有多少种 dp[i][j]
我们可以推得 如果选了第 j 根 那么 他 用 的 就 是 和 j-1 个 搭 配 如果选了 第j+1 根筷子就和 第 j 根 搭 配 那 么 这 样 我 们 就 把 所 有 的 情 况 考 虑 在 内 了， 然 后 可 以 知 道 动 态方程 dp[i][j]=min(dp[i][j-1],dp[i-1][j-2]+(w[j]*w[i-1])*(w[j]*w[i-1])); 记 得 将 个 序 列 倒 置 这 样 就 解 决 了 选出一根较长的 问题 ，倒序的话 就可以很容易的控制边界问题 使得一定选的较长的 在前面也就是 较大的那个 可以通过控制边界到达 可以知道 选dp[1][j] 的起始点必须是 从第3根筷子开始的（当然这里说的是倒叙后的） dp[2][j]的边界自然是从 第6根开始的 那这样 像dp[1][2-1] =INF dp[2][5]=INF 因为他是 不 可 能 取 到 的 好 现在就 放在规划好的方程中去算吧
自己的思考 脑残的是这样想的 dp[i][j][k]; 在区间 i j 之间算出 k个组合的筷子的最小 费用 额 发现时间爆空间爆 额 好吧 但是却没有去考虑 第 j 根 筷子有没有选 前 j根筷子 挑出了几个组合
#include <iostream>
#include<cstdio>
#include<string.h>
using namespace std;
const int maxn=;
const int maxv=;
int dp[maxn][maxn*];
int w[maxn*];
int minv(int a,int b){ return a<b?a:b; }
int main()
{
int t;
scanf("%d",&t);
while(t--){
int k,n;
scanf("%d%d",&k,&n);
for(int i=;i<n;++i)
scanf("%d",&w[i]);
k=k+;
for(int i=;i<n/;i++){
dp[][i]=;
int t=w[i]; w[i]=w[n-i-]; w[n-i-]=t;
dp[][n-i-]=;
} for(int i=;i<=k;i++){
for(int j=;j<n;j++){
if(j<(i-)*+) dp[i][j]=maxv;
else dp[i][j]=minv(dp[i][j-],dp[i-][j-]+(w[j-]-w[j])*(w[j-]-w[j]));
} }
printf("%d\n",dp[k][n-]);
} return ;
}
uva 10617这题说的是 给了一个长度不大于60的字符串然后你可以任意的删除字符 使得这个字符串为回文串 当然回文串的长度是大于等于1的 然后现在来找到其中的规律
起初我们在想对于这个问题与回文串是否有关系 然后就按照回文串的思路去想了 当在某个较小的区间内 dp[i][j] 要使得这个串 i 到 j 为回文串 那么得有几种方法 首先 str[i] 被去掉 那么dp[i][j] 就等于dp[i+1][j] 如果j被去掉了 那么dp[i][j]=dp[i][j-1] 那么dp[i][j]=dp[i+1][j]+dp[i][j-1]; 视乎我们多做了一些东西 就是dp[i+1][j]里面包含了dp[i+1][j-1] 且dp[i][j-1]里面也包含了 dp[i+1][j-1]那 这样就重复算了 当然结果记得 减去dp[i+1][j-1] 还有当 str[i]==sti[j]的时候呢 是不是我们就多了dp[i+1][j-1]种方法就上将里面的全部都删了 就是增加了dp[i+1][j-1]+1
总结一下 我们就得到了 dp[i][j]=dp[i+1][j]+dp[i][j-1]-dp[i+1][j-1] 如果str[i]==str[j] dp[i][j]+=dp[i+1][j-1]+1; 这里的 个数超过了int wa 在这里一次了
#include <iostream>
#include<cstdio>
#include<string.h>
using namespace std;
const int maxn=;
long long dp[][];
int main()
{
int t;
char str[maxn];
scanf("%d",&t);
while(t--){
memset(dp,,sizeof(dp));
scanf("%s",str);
int len=strlen(str);
for(int i=;i<=len;++i)
dp[i][i]=;
for(int i=;i<len;i++)
for(int j=;j+i<=len;j++){
dp[j][j+i]=dp[j+][j+i]+dp[j][j+i-]-dp[j+][j+i-];
if(str[j-]==str[j+i-])
dp[j][i+j]+=+dp[j+][j+i-];
}
printf("%lld\n",dp[][len]);
} return ;
}
uva11137 这题说的是 有一种 货币 单位价值分别是 1 8 27 .. 21*21*21 就是 1到 21的 各 个 数 三 次 方 的 然后给了一个价值看能够拼成这个价值的种类有多少种
完全背包 dp[j]+=dp[j-w[i]] 这样就拼得了价值为n的 物品的总方案数
#include <iostream>
#include<cstdio>
#include<string.h>
using namespace std;
const int maxn=;
int w[];
long long dp[maxn];
int main()
{
for(int i=;i<=;++i)
w[i-]=i*i*i;
int n;
while(scanf("%d",&n)==){
memset(dp,-,sizeof(dp));
dp[]=;
for(int i=;i<;i++){
for(int j=w[i];j<=n;j++)
if(dp[j-w[i]]!=-){
dp[j]=dp[j]==-?dp[j-w[i]]:dp[j]+dp[j-w[i]];
}
}
printf("%lld\n",dp[n]);
}
return ;
}
uva 这题说的是 有最多5607 只乌龟 每只乌龟有自己的重量和承重能力 例如 一个人他有 重量为 200 那么他的承重能力是 1000 那么在他的背上就还可以堆重量为800的 东西 然后计算最多可以将乌龟堆得最高
首先考虑 如果乌龟的 cap-weight 比较大 那么他就能够承载的比较多 因 此 他 就 比 较 有 可 能 放 在 比 较 下 面 发 现 这 样 的 猜 想 是 正 确 的
dp[i][len[j]+1]=min(dp[i][len[j]+1],min(dp[j][len[j]]-T[i].w,T[i].cap)) 在不知道 体重和力量最大值的情况下我就用这种方法作了 但是还是过了 可能是数据比较水 这显然不是正确的时间复杂度
正解应该是这样的
首先 将这些乌龟按照 力量值进行排序 按从小到达的顺序排列 为什么这样 假设 两只 乌龟的力量和重量分别是 s1 w1 s2 w2 如果s2》 s1 假设 s1
能够将 两只乌龟 抬起来 那么就有 s1>w1+w2 此时 可以肯定的是 在后面的 堆叠当中所能承载的 乌龟 要比 s2 在下面来得更小很多 当s2 大于w1+w2 的时候 s1 并不一定能够大于w1+w2 那么就证明如果可以堆起来 那么力量大的一定能够放在比较下面 如果他在 这个最长的堆叠当中的话
那么 此时的 dp[i][j] 表示堆到 i的高度的时候前j个最小重量 由于5607 过于强大 那么现在就用滚动数组进行处理 dp[h]=min(dp[h-1]+w[i],dp[h]) 这里要记得是从后面的高度到达前面的高度的 因为这样才能保证每个 乌龟只用了一次 不是背包胜似背包
#include <iostream>
#include<cstdio>
#include<string.h>
#include<algorithm>
using namespace std;
const int maxn=;
const int maxv=;
struct turtles{
int weight,stength;
bool operator < (const turtles &A)const{
return stength<A.stength;
}
}T[maxn];
int minweigh[maxn];
int minv(int a,int b){ return a>b?b:a; }
int main()
{
int w,s,n=;
while(cin>>w>>s){
if(w>s)continue;
T[n].weight=w;
T[n].stength=s;
n++;
}
for(int i=;i<n;i++)
minweigh[i]=maxv;
minweigh[]=;
sort(T+,T+n);
int maxh=;
for(int i=;i<n;i++){
for(int j=n-;j>=;j--){
if(minweigh[j-]!=maxv&&minweigh[j-]+T[i].weight<=T[i].stength){
minweigh[j]=minv(minweigh[j],T[i].weight+minweigh[j-]);
maxh=maxh>j?maxh:j;
}
} }
printf("%d\n",maxh);
return ;
}
uva 10201 这题说的是给了 一个从起点到终点的 距离然后 还有在这之间的加油站和油价 然后从起点开始的 油箱是半满状态的 到达终点也必须是半满状态或者更多 然后计算最小花费
这里 可以比较简单的列出动态方程 考虑每个加油站是否进去加 然后加得的状态的价钱是多少即可以从别的状态转移而来 又可以从自己的加油站转化而来 可得dp[i][j]=min(dp[i-1][j+dist[i][j]],dp[i][j],dp[i][j-1]+T[i].per] 然后就得到了解
#include <iostream>
#include<cstdio>
#include<string.h>
#include<algorithm>
using namespace std;
const int maxn=;
const int maxv=;
struct station{
int dist,per;
bool operator <(const station &A)const {
return dist<A.dist||(dist==A.dist&&per<A.per);
}
}T[maxn];
int dp[maxn][maxn*];
int minv(int a,int b){ return a>b?b:a; }
int main()
{
int cas;
char str[];
scanf("%d",&cas);
while(cas--){
int dist;
scanf("%d",&dist); getchar();
int n=;
while(gets(str)){
if(strlen(str)==) break;
sscanf(str,"%d%d",&T[n].dist,&T[n].per);
++n;
}
sort(T+,T+n);
T[].dist=;
T[].per=;
for(int i=;i<n;i++)
for(int j=;j<=;j++) dp[i][j]=maxv;
dp[][]=;
for(int k=;k<n;k++){
int G=T[k].dist-T[k-].dist;
for(int i=;i<=;i++){
if(i+G<=&&dp[k-][G+i]!=maxv)
dp[k][i]=dp[k][i]>dp[k-][i+G]?dp[k-][i+G]:dp[k][i];
if(i!=&&dp[k][i-]!=maxv)
dp[k][i]=dp[k][i]>dp[k][i-]+T[k].per?dp[k][i-]+T[k].per:dp[k][i];
} // for(int i=0;i<=200;i++){ printf("%d ",dp[k][i]); }
// printf("\n");
}
int ma=maxv;
for(int i=;i<n;i++){
int d=dist-T[i].dist>?dist-T[i].dist:T[i].dist-dist;
for(int j=+d;j<=;j++)
ma=minv(dp[i][j],ma);
}
if(ma==maxv) printf("Impossible\n");
else printf("%d\n",ma);
if(cas!=)printf("\n");
}
return ;
}
uva10453 这题说的是给了一个串然后将他变成回文串 花费最小 然后这题好像比较简单 直接在求回文串的 最小添加个数的时候直接加上一下标记 然后再把标记读出来便可
dp[i][j]=min(dp[i+1][j-1],dp[i][j-1]+1,dp[i+1][j]+1);
#include <iostream>
#include<cstdio>
#include<string.h>
using namespace std;
const int maxn=;
const int maxv=;
int dp[maxn][maxn];
int top[maxn][maxn];
char str[maxn],aim[*maxn];
int main()
{
memset(dp,,sizeof(dp));
while(scanf("%s",str)==){
int len=strlen(str); for(int i=;i<=len;i++)
for(int j=i;j<=len;j++)
{dp[i][j]=i==j?:maxv; top[i][j]=; }
for(int k=;k<len;++k){
for(int i=;k+i<len;++i){
int j=k+i;
if(str[i]==str[j]){
if(dp[i][j]>dp[i+][j-]) { dp[i][j]=dp[i+][j-]; top[i][j]=;}
}
if(dp[i][j]>dp[i+][j]){ dp[i][j]=dp[i+][j]+; top[i][j]=; }
if(dp[i][j]>dp[i][j-]){ dp[i][j]=dp[i][j-]+; top[i][j]=; }
} }
int L=,R=dp[][len-]+len-,k1=,k2=len-;
aim[R+]=;
while(L<=R&&k1<=k2){
if(top[k1][k2]==){ aim[L]=str[k1];aim[R]=str[k2]; k1++;k2--; }
else if(top[k1][k2]==){ aim[L]=str[k2];aim[R]=str[k2]; k2--; }
else if(top[k1][k2]==){ aim[L]=str[k1];aim[R]=str[k1]; k1++; }
L++;R--;
}
printf("%d %s\n",dp[][len-],aim);
}
return ;
}
uva 10029 这题题意很清楚 就是找一个能够使得这个串 通过修改一个字符 后得到另外的一个串 他给的顺序是字典序递增的给的
这里有种解法 都是来 大神们的 一种是hash 一种是map 先讲讲map 的做法 （因为hash函数的原理我现在还不明白）
map 是将字符串长度相同的字符串归结到一个集合当中 然后对与当前的这个字符串进行 3种操作 然后得到的 另一个字符串 找修改后的字符串在是否在相应的长度的 map里是否存在相应的 也相当与记忆化搜索
#include <iostream>
#include<cstdio>
#include<string>
#include<map>
using namespace std;
const int maxn=;
map<string,int>dict[];
int steps[maxn];
int exist(int index,string &temp,int step){
map<string,int>::iterator it;
it=dict[index].find(temp);
if(it!=dict[index].end())
if((steps[(*it).second]+)>step)
step=steps[(*it).second]+;
return step;
}
int main()
{
string line,temp;
int current=;
int maxmum=;
for(int c=;c<maxn;c++)
steps[c]=;
while(cin>>line){
int index=line.length()-;
int step=;
if(index>){
for(int i=;i<=index;i++){
temp=line;
if(i==index||temp[i]>=temp[i+]){
temp.erase(temp.begin()+i);
step=exist(index-,temp,step);
}
temp=line;
while(temp[i]>'a'){
temp[i]--;
step=exist(index,temp,step);
}
temp=line;
temp.insert(temp.begin()+i,line[i]);
if(temp<line)
step=exist(index+,temp,step);
while(temp[i]>'a'){
temp[i]--;
step=exist(index+,temp,step);
}
}
}
else{
temp=line;
while(temp[]>'a'){
temp[]--;
step=exist(index,temp,step);
}
}
if(step>maxmum){
maxmum=step;
}
steps[current]=step;
dict[index].insert(make_pair<string,int>(line,current));
current++;
}
cout<<maxmum<<endl;
return ;
}
突然发现自己对于hash 一点感觉都没有 这题hash 就是 对于每个字符串进行一次hash 然后 使得在线性的时间内能够 找到他们 因为他给的顺序是字典序 然后对于每个字符串找出他所能变成的字符串 如果存在就 dp[n]=max(dp[k]+1,dp[n]) 因为如果数据不要太坑还是可以接受的 这样就得的到了 相应的 最长递增子序列 LIS 然后时间算下 在查找时间接近于线性的情况下 25000*26*16*3还是能接受的
终于使用hash 做了第一题 看题解的
#include <iostream>
#include<cstdio>
#include<string.h>
using namespace std;
const int hash=;
const int maxn=;
int head[hash];
int next[maxn],dp[maxn];
char temp[],rt[maxn][];
int HASH(char *str){
int v=,seed=;
int len=strlen(str);
for(int i=;i<len;i++)
v=v*seed+str[i];
v=(v&0x7fffffff)%hash;
return v;
}
void insert(int s){
int h=HASH(rt[s]);
next[s]=head[h];
head[h]=s;
}
int search(){
int i,h;
h=HASH(temp);
for( i=head[h];i!=-;i=next[i])
if(strcmp(rt[i],temp)==) break;
return i;
}
int exit(int step){
int h=search();
if(h!=-){
if(dp[h]+>step) step=dp[h]+;
}
return step;
}
void del(int f,int d,int n){
int i=,j=;
while(i<d&&j<n){
temp[i]=rt[f][j]; i++;j++;
}
j++;
while(j<n){
temp[i]=rt[f][j];i++;j++;
}
temp[i]=;
}
void add(int f,int d,int n){
int i=,j=;
while(j<n&&i<d){
temp[i]=rt[f][j]; i++;j++;
}
temp[i++]=rt[f][j];
while(j<n){
temp[i++]=rt[f][j++];
}
temp[i]=;
}
int main()
{
memset(head,-,sizeof(head));
int n=,step=,maxlen=;
while(scanf("%s",rt[n])==){
int len=strlen(rt[n]);
step=;
for(int i=;i<len;i++){ if(len>&&(i+==len||rt[n][i]>=rt[n][i+])){
del(n,i,len);
if(strcmp(temp,rt[n])<){
step=exit(step);
}
}
strcpy(temp,rt[n]);
while(temp[i]>'a'){
temp[i]--;
step=exit(step);
} add(n,i,len);
while(temp[i]>'a'){
temp[i]--;
step=exit(step);
} }
insert(n);
maxlen=maxlen>step?maxlen:step;
dp[n]=step;
n++;
} printf("%d\n",step); return ;
}
uva 10313 这题说的是 有一个面值不超过 300 的n 元 然后让你用多少种方法将他 拼起来 注意这里是说的是 比如 6 由3 张货币组成那么就有 3种方法 即 1 1 4 、1 2 3、2 2 2 ，然后计算法 对于一个 给定的数 被几个 面值组成的 方法总数
这题刚开始并没有 发现可以有什么好的方法可以解决 然后 将他们每个数减去1 比如 1 1 4 减去1 后得到 的是0 0 3 、0 1 2 、1 1 1刚好跟3 有关 分别是 3 的1 2 3 分布
你、由此就可以推得我们所想要的 dp[i][k]+=dp[i-k][L] 记得 dp[0][1]=1; 这是边界 然后还是狂wa 不停 原来 dp[0][0]也要等于1 但是不解的事 dp[0][1] 等于 1 难道有 面值为0的货币 ？？
#include <iostream>
#include <cstdio>
#include<string.h>
using namespace std;
long long dp[][];
int main()
{
memset(dp,,sizeof(dp));
dp[][]=dp[][]=;
for(int k=;k<=;k++)
for(int i=k;i<=;i++){
for(int L=;L<=k;L++)
dp[i][k]+=dp[i-k][L];
}
char str[];
while(gets(str)){
int a1,a2,n;
int g=sscanf(str,"%d%d%d",&n,&a1,&a2);
if(a1>)a1=;
if(a2>) a2=;
if(g==){
a1=;a2=n;
}
if(g==){
a2=a1; a1=;
}
long long sum=;
for(int i=a1;i<=a2;++i)
sum=sum+dp[n][i];
printf("%lld\n",sum); }
return ;
}
uva 10401这题说的是 给了一个国际象棋的棋盘 本来是一个皇后可以向 8个方向攻击然后 现在 只能够在列上 没有阻碍 在其他 6个方向上就只能够在相邻的一格攻击
现在要考虑的问题是 到底这个地方能不能够放一个皇后 对 了 题 目 必须 要 放 n 个 皇 后 在 n * n 的 方 格 内 那么 我们在想 到底这个地方能不能放皇后 首先 在他攻击的范围内是不能有皇后的 好像只有这一个限制 接下来的 工作就剩下 这个方案数了 如果这个地方放了 那么他可以有几种方法 好在题目中他只能够攻击他的右边 右上 右下 一格的地方 这样就转化成了 第一列和第二 就是列与列之间的关系 呵呵 现在动态方程就 可以得到了 dp[row][colnum]+=dp[i][colnum-1]; 自然边界是在第一列 如果第一列有皇后 那么只要在 放皇后的地方 dp[i][j]=1其他的就不用了 因为这样 只有一种方法 在第一列 ok 好的 那么在第一列中要是没有那该怎么办 当然是 dp[i][1](i=1...len) 因为每个位置都可能是一种情况 哈哈 这样就的解了 好像每次都 首先 wa的稀里糊涂的 然后 在稀里糊涂的A了 可能是 能力还不足
#include <iostream>
#include <cstdio>
#include <string.h>
using namespace std;
const int maxn=;
bool map[maxn][maxn];
bool column[maxn];
long long dp[maxn][maxn];
int xx[]={,,,-,,-,-,};
int yy[]={,-,,,,-,,-};
int absint(int a){ return a>?a:-a; }
bool jud(int row,int co){ for(int i=;i<;i++){
int x=row+xx[i]; int y=co+yy[i];
if(map[x][y]) return true;
}
return false;
}
int main()
{
char str[];
while(scanf("%s",str)==){
memset(dp,,sizeof(dp));
memset(map,false,sizeof(map));
memset(column,false,sizeof(column));
int len=strlen(str);
for(int i=;i<len;i++)
if(str[i]!='?') {
int G;
if(str[i]>=''&&str[i]<='') G=str[i]-'';
if(str[i]>='A'&&str[i]<='F') G=str[i]-'A'+;
column[i+]=true;
map[len-G+][i+]=true;
}
for(int i=;i<=len;++i){
if(map[i][]) dp[i][]=;
if(column[]) continue;
dp[i][]=;
}
for(int co=;co<=len;++co){
for(int row=;row<=len;++row){
if(map[row][co]){
for(int i=;i<=len;++i)
if(absint(row-i)>) dp[row][co]+=dp[i][co-];
continue;
}
if(column[co]==true||jud(row,co)) continue;
for(int i=;i<=len;++i)
if(absint(row-i)>) dp[row][co]+=dp[i][co-];
}
}
long long sum=;
for(int i=;i<=len;i++)
sum+=dp[i][len];
printf("%lld\n",sum);
}
return ;
}
POJ 这题说的是给了 n个人 然后首先第m个人退出 然后在接下来的每k个人退出 约瑟夫环的变形
这样解 如果删除第 k个人 那么原本的 编号我们将他们从0编到n-1;
0 1 2 3 4 5 6 7 8 9 。。。n-1
删除第k个得到
0 1 2 3 k-2 k, k+1...n-1然后 从编号为k的开始编号得到
k k+1 k+2 K+3 . . . n-1.。。。k-1
0 1 2 3 n-1-k n-1
这样不断的 删除下去 然后在通过逆推就可以很容易的得到最后的答案 记得最后再加上一个1 因为刚开始编号是从 0到 n-1 的
#include <iostream>
#include<cstdio>
using namespace std;
int main()
{
int n,m,k;
while(scanf("%d%d%d",&n,&k,&m)==){
if(n==&&k==&&m==) break;
int sum=;
for(int i=;i<n;i++)
sum=(sum+k)%i;
sum=(sum+m)%n+;
printf("%d\n",sum);
} return ;
}
uva10891 这题说的是 给了 n个数 然后两个人轮流去取数 两个人都很聪明 最后计算 第一个取到得和减去后者取到的差 自然每个人都希望自己的 得到尽量多的数的和
取数的方法是从左到又 或者从右到左 且能连续的取 两个人取来去取的 知道最后的都取完为止
这题在 大白数上有介绍 如果在得到数字之后我们就知道了 我所能取得的最大值那么 敌人所能取得 最大值就是 总和减去 最大值 得到的就是他的最小值
这样 对于每个区间都算他的最大最值 而他的 最大值是在别人取到最小值得基础上得到的 因为总和是不变的嘛
然后就得到 dp[i][j]=sum[i][j]-min(dp[i+1][j]...dp[j][j],dp[i][i]...dp[i][j],0)
你取到最大是建立在别人取到最小的基础上的 这样对于每个先手得到的最大值就算出来了
#include <iostream>
#include<cstdio>
#include<string.h>
using namespace std;
const int maxn=;
int F[maxn][maxn],G[maxn][maxn],dp[maxn][maxn],S[maxn];
int minv(int a,int b){
return a>b?b:a;
}
int main()
{
int n;
while(true){
scanf("%d",&n);
if(n==) break;
S[]=;
for(int i=;i<=n;i++){
int a;
scanf("%d",&a);
S[i]=S[i-]+a; G[i][i]=dp[i][i]=F[i][i]=a;
}
for(int L=;L<=n;L++){
for(int i=;i+L<=n;i++){
int j=i+L;
int m=minv(F[i][j-],minv(G[i+][j],)); dp[i][j]=S[j]-S[i-]-m;
F[i][j]=minv(dp[i][j],F[i][j-]);
G[i][j]=minv(dp[i][j],G[i+][j]);
} }
printf("%d\n",dp[][n]*-S[n]);
}
return ;
}
uva 10859
树形dp
这题 也是 大白书上面的 说的是给了 n个点m条边的树 在每个节点上可以放上一盏灯 该灯可以照亮 与这个点相连的边 然后 计算将所有的边都照亮 的 在使用最小的灯的前提下使得 一条边被两盏灯照亮 最多 lrj 的X=M*A+C 很好 A是要使用的最少的灯的数量 C是 被一盏灯照亮的 边的数量 因为他要使得 被两盏灯照亮的边 尽量的多然后就是说被一盏灯着凉的边尽量的少 这样 这里的M 应该取一个比较大的数 这样是为了保证 X/M =A 自然也不要让他 溢出 这样 在A固定的前提下使得 如果X 越小C也就越小
现在会想为什么他不是选 X=M*A+B 最大呢 因为我们知道 在算A的时候我们同样是使得A的数目尽量的小 而B是要尽量的大 这样显然不可行
在理解了 LRJ的 程序后 感觉他的程序过去复杂 按照自己的 思路又把 他给写了 哈哈时间比他的小 自己努力还是有收获的 下面第一个 LRJ的 第二个我的
感觉 X=M*A+C 这个公式挺厉害的 在一个确定的前提下 X越小越好
#include <iostream>
#include<cstdio>
#include<string.h>
#include<vector>
using namespace std;
const int maxn=;
int dp[maxn][],vis[maxn][];
vector<int>adg[maxn];
int minv(int a,int b){ return a>b?b:a; }
int dfs(int i,int j,int f){
if(vis[i][j]) return dp[i][j];
vis[i][j]=;
int &ans=dp[i][j];
ans=;
for(int k=;k<adg[i].size();++k)
if(adg[i][k]!=f)
ans+=dfs(adg[i][k],,i);
if(!j&&f>=)++ans;
if(j||f<){
int sum=;
for(int k=;k<adg[i].size();++k)
if(adg[i][k]!=f)
sum+=dfs(adg[i][k],,i);
if(f>=)++sum;
ans=minv(sum,ans);
}
return ans;
}
int main()
{
int n,m,T;
scanf("%d",&T);
while(T--){
scanf("%d%d",&n,&m);
memset(dp,,sizeof(dp));
memset(vis,,sizeof(vis));
for(int i=;i<n;++i) adg[i].clear();
for(int i=;i<m;++i){
int a,b;
scanf("%d%d",&a,&b);
adg[a].push_back(b);
adg[b].push_back(a);
}
int ans=;
for(int i=;i<n;i++)
if(vis[i][]==)
ans+=dfs(i,,-);
printf("%d %d %d\n",ans/,m-(ans%),ans%);
} return ;
}
#include <iostream>
#include<cstdio>
#include<string.h>
#include<vector>
using namespace std;
const int maxn=;
int dp[maxn][],vis[maxn];
vector<int>adg[maxn];
int minv(int a,int b){ return a>b?b:a; }
void dfs(int g,int f){
if(vis[g]) return ;
vis[g]=;
int sum=,ans=;
for(int i=;i<adg[g].size();++i)
if(adg[g][i]!=f){
int to=adg[g][i];
dfs(to,g);
ans+=minv(dp[to][]+,dp[to][]);//dp[to][0]+1 是 他的儿子不 放灯 这样就有一条 只被一盏灯照亮的 边了
sum+=dp[to][]+;//这里加 1 是因为 他自身不放灯他的儿子放灯 那么自然也形成了 一条 只放一盏灯的边
}
dp[g][]=ans; dp[g][]=sum;
return ;
}
int main()
{
int n,m,T;
scanf("%d",&T);
while(T--){
scanf("%d%d",&n,&m);
memset(dp,,sizeof(dp));
memset(vis,,sizeof(vis));
for(int i=;i<n;++i) adg[i].clear();
for(int i=;i<m;++i){
int a,b;
scanf("%d%d",&a,&b);
adg[a].push_back(b);
adg[b].push_back(a);
}
int ans=;
for(int i=;i<n;i++)
if(vis[i]==&&adg[i].size()>){
dfs(i,-);
ans+=minv(dp[i][],dp[i][]);
}
printf("%d %d %d\n",ans/,m-(ans%),ans%);
} return ;
}
uva11151 这题说的是 给了一个 字符串然后从这个字符串中删除 字符 使得剩下来的 字符串是回文串 记得用get 他说了 空字符串也是回文串
然后 当 str[i]==str[j] 时dp[i][j]=min(dp[i+1][j-1],dp[i+1][j],dp[i][j-1]) 不等的时候 dp[i][j]=minv(dp[i+1][j],dp[i][j-1]);
#include <iostream>
#include<cstdio>
#include<string.h>
using namespace std;
const int maxn=;
int dp[maxn][maxn];
int minv(int a,int b){ return a>b?b:a; }
int main()
{
int t;
char str[maxn];
scanf("%d",&t); getchar();
while(t--){
gets(str);
int len=strlen(str);
for(int i=;i<=len;i++)
for(int j=i;j<=len;j++)
dp[i][j]=;
for(int k=;k<=len;++k)
for(int i=;i+k<len;++i){
int j=i+k;
if(str[i]==str[j]) dp[i][j]=minv(dp[i+][j-],minv(dp[i+][j]+,dp[i][j-]+));
else dp[i][j]=minv(dp[i+][j]+,dp[i][j-]+);
}
printf("%d\n",len-dp[][len-]); }
return ;
}
UVA 10911 这题是 集合上的dp 给了2*n个点 计算这些点 两个两个点 搭配 一个点只能搭配一个点 距离的最小和 这样说
既然每个点都要配对，很容易把问题看成如下的多阶段决策过程 先确定P0 和谁配对，然后是P1 接下来是P2。。。Pn 但是对于这个点之前已经定好和谁配对 的 后来又来了一个点 这个点和原来的某个点 配对会取得最大值 这样 就不行了 集合！！！ 集合可以表示任意个 点之间的组合 数据不大 16 个点 二进制集合 并不是非常的大 然后在一个集合当中 如果 刚添进来一个点i 那么这个点 和 集合 中的 j点搭配 那么搭配后的结果就是 dp[S]=min(dp[S],dp[S^(1<<i)^(q<<j)]) 这样就从小的集合 找到了大的集合
#include <iostream>
#include<cstdio>
#include<string.h>
#include<cmath>
using namespace std;
const double INF=1.79769e+308;
const int maxn=;
double dist[maxn][maxn],x[maxn],y[maxn];
double dp[<<];
double minv(double a,double b){
return a>b?b:a;
}
double cat(int a,int b){ double xx=x[a]-x[b],yy=y[a]-y[b];
xx=sqrt(xx*xx+yy*yy);
return xx;
}
int main()
{
int n,num=;;
char str[];
while(true){
scanf("%d",&n);
if(n==) break;
n=*n;
for(int i=;i<n;i++){
scanf("%s%lf%lf",str,&x[i],&y[i]);
for(int j=;j<=i;++j)
dist[i][j]=dist[j][i]=cat(i,j); }
dp[]=;
for(int S=;S<(<<n);++S){
dp[S]=INF;
int i,j;
for( i=;i<n;++i)
if(S&(<<i)) break;
for(j=i+;j<n;++j)
if(S&(<<j)){ dp[S]=minv(dp[S],dist[i][j]+dp[S^(<<i)^(<<j)]); }
}
printf("Case %d: %.2lf\n",num,dp[(<<n)-]); num++;
}
return ;
}
uva 10635 lCS 最长公共子序列 这题说的都是 王子和公主在玩游戏 从1 这个点走到 n*n 这个点 每个人只能走某个点一次 国王叫他们同意路线 使得他们的路线上 相对位置所走的 公共点尽量的多 这题很容易想到时最长公共子序列问题 难的是 他这里有 n*n个点 n<=250 太大了 显然是行不通的 这样将最长公共子序列进行转化 因为我们要知道的只是王子和公主的最长公共子序列 找的是相对位置 按照 公主走得顺序给每个点编号 1,2,3,4,5 然后在王子所走的 点中 如果在 公主 所走的路线中出想过就把 这个点的标号 加入王子可能与公主走一样的点的序列中 相对位置不能发生改变 如果没出现过呢 当然可以直接省略掉 因为他已经不可能是公共的点了 接下来来个最长递增之序列 为什么呢 因为我们给公主所走的 点已经进行了标号 是按照 走的点的顺序 的 而且 一个点只出现一次 王子所走的路是按照公主给的点的顺序编号的 这样要 使得 他们的 路程中公共点 最多的话就变得 只要求最长递增子序列了 这样就保证了他们的 相对位置经过的 点最长
#include <iostream>
#include<string.h>
#include<cstdio>
using namespace std;
const int maxn=;
int price[maxn*maxn],pricess[maxn*maxn];
int dp[maxn*maxn];
int Birthser(int gh,int n){
int L=,R=n,mid;
while(L<R){
mid=(L+R)/;
if(dp[mid]>=gh)
R=mid;
else L=mid+;
}
return R;
}
int main()
{
int t,n,q,p;
scanf("%d",&t);
for(int cas=;cas<=t;++cas){
scanf("%d%d%d",&n,&p,&q);
memset(price,,sizeof(price));
for(int i=;i<=p+;++i){
int a;
scanf("%d",&a); price[a]=i;
}
int Len=,maxlen=;
for(int i=;i<q+;++i){
int a;
scanf("%d",&a);
if(price[a]!=)pricess[Len++]=price[a];
}
n=Len;
dp[]=pricess[];
Len=;
for(int i=;i<n;++i){
if(dp[Len-]<pricess[i]){
dp[Len++]=pricess[i];
}else { int Loca=Birthser(pricess[i],Len);
dp[Loca]=pricess[i];
}
maxlen=maxlen>=Len?maxlen:Len;
}
printf("Case %d: %d\n",cas,maxlen);
}
return ;
}
uva 10564 这题说的给了一个类似杨辉三角的东西不过是 沙漏状的 然后 计算从最上面一行 走到最后一行的 总和为S的 方案数 并输出起点最小 的 字典序最小的 方案数 是这样想的 对于每个点 所能到达的值取决于他的两个儿子 只不过是在他的两个儿子所能达到的最状态的前提下加上了他本身的值 dp[i][j][k]=dp[i+1][左][k-T]+dp[i+1][右][k-T]
记得用 long long wa了几发 在这里 没考虑好数据的范围
#include <iostream>
#include<string.h>
#include<cstdio>
using namespace std;
const int maxn=;
long long dp[maxn*][maxn][];
int F[maxn*][maxn];
int add(int a){ return a<?-a:a; }
int main()
{
int n,S;
while(true){
scanf("%d%d",&n,&S);
if(n==&&S==) break;
memset(dp,,sizeof(dp));
for(int i=;i<*n-;++i)
for(int j=;j<add(n--i)+;++j)
scanf("%d",&F[i][j]);
int L=*n-;
int G=n-;
for(int i=;i<n;++i){
dp[L][i][F[L][i]]=;
}
int num=n+;
for(int i=L;i>=G;--i){
num--;
for(int j=;j<num;++j)
for(int k=;k<=;++k)
dp[i][j][k+F[i][j]]+=dp[i+][j][k]+dp[i+][j+][k];
}
num=;
for(int i=G-;i>=;--i){
num++;
for(int j=;j<num;++j)
for(int k=;k<=;++k){
if(j->=)
dp[i][j][k+F[i][j]]+=dp[i+][j-][k];
if(j<num-)
dp[i][j][k+F[i][j]]+=dp[i+][j][k];} }
long long sum=,ma=;
for(int i=;i<n;++i)
if(dp[][i][S]!=){
ma=ma>i?i:ma; sum+=dp[][i][S];
}
printf("%lld\n",sum);
if(ma!=){
printf("%d ",ma);
int row=;
while(row<n-){
if(ma->=&&dp[row+][ma-][S-F[row][ma]]!=){
S-=F[row][ma]; ma=ma-; printf("L");
}
else {
S-=F[row][ma]; printf("R");
}
row++;
}
while(row<*n-){
if(dp[row+][ma][S-F[row][ma]]!=) {
S-=F[row][ma]; printf("L");
}
else{
S-=F[row][ma]; printf("R"); ma=ma+;
}
row++;
}
}
printf("\n");
}
return ;
}
uva622 这题说的是 给了 n个 快餐店的具体位置然后 然后在这n个快餐店中 选k个 当原料供应站 使得 运输到材料到 每一点的 的运输费用 最少并且输出管辖范围
首先呢 就按照他 给的方法去想 当每增加一个的时候 肯定是在上一个的基础上的 因为 在 【i j】 范围内用两个原料供应点 那么肯定是这两个 点分摊这个区间 那么就枚举这些点 [i][r]管辖一个 [r+1][j]被另一个管辖 然后得到状态 dp[i][j][k]=min(dp[i][r][1]+dp[r+1][j][k-1]) 因为每次都是 添加一个 状态取决与前面已经添加的 为什么不是 dp[i][r][k-1]+dp[r+1][j][1]
你可以想想 我们已将将他们 处理好了 无论你用 前者还是后者得到的结果是一样的 只不过是出现的 顺序不一样，
#include <iostream>
#include<cstdio>
#include<string.h>
#include<algorithm>
using namespace std;
const int maxn=;
const int maxv=0x7fffffff;
struct node{
int x,d;
}vis[maxn][maxn][];
struct adg{
int L,R;
bool operator <(const adg &T)const {
return L<T.L;
}
}FT[];
int dp[maxn][maxn][];
int local[maxn][maxn];
int sum[maxn],n,m,num;
void solve(){
for(int k=;k<=m;++k){
for(int L=k-;L<=n;++L){
for(int i=;i+L<=n;++i){
int j=i+L;
dp[i][j][k]=maxv;
for(int r=i;r<j;++r){
if(dp[i][j][k]>dp[i][r][]+dp[r+][j][k-]){
dp[i][j][k]=dp[i][r][]+dp[r+][j][k-];
vis[i][j][k].d=r+;
}
}
}
}
}
}
void dfs(int L,int R,int k){
if(k==){
FT[num].L=L; FT[num].R=R; num++; return ;
}
FT[num].L=L; FT[num].R=vis[L][R][k].d-; ++num;
dfs(vis[L][R][k].d,R,k-);
}
int look(int L,int R,int h){
int s=;
for(int i=L;i<=R;++i)
{
int L=sum[i]-sum[h];
L=L>?L:-L;
s+=L;
}
return s;
}
int main()
{
int cas=;
while(true){
scanf("%d%d",&n,&m);
if(n==&&m==) break;
num=;
memset(local,,sizeof(local));
memset(dp,,sizeof(dp));
sum[]=;
for(int i=;i<=n;++i){
scanf("%d",&sum[i]);
}
for(int L=;L<=n;++L){
for(int i=;i+L<=n;++i){
int ma=maxv,lol; for(int j=i;j<=i+L;++j){
int T=look(i,L+i,j);
if(ma>T){ ma=T; lol=j; }
}
local[i][i+L]=lol;
dp[i][i+L][]=ma;
}
}
solve();
dfs(,n,m);
sort(FT,FT+num);
printf("Chain %d\n",cas++);
for(int i=;i<=m;++i){
printf("Depot %d at restaurant %d serves ",i,local[FT[i-].L][FT[i-].R]);
if(FT[i-].L==FT[i-].R){
printf("restaurant %d\n",FT[i-].L);
}
else {
printf("restaurants %d to %d\n",FT[i-].L,FT[i-].R);
}
}
printf("Total distance sum = %d\n",dp[][n][m]);
printf("\n");
}
return ;
}
uva 10626 这题说的是 每瓶可乐 8 圆 给了 1 5 6 种硬币 个个数 a b c 然后这样就可以得到 一次性只能 买一瓶 然后你给了 贩卖机 多少钱 钱减去 8 剩下的 按最少的张数给你
开了一个 3 维的 数组 分别存他们的状态 得到 dp[a][b][c] 分别是 键 8张 一块的 。2 张5 块的 返回 2张 一块的 。 一张10块的 返回两张一块的 。一张10快加 2张1块返回 一张5块 然后 还有 一张5块加 3张 1块的 。加上记忆化搜索
#include <iostream>
#include<cstdio>
#include<string.h>
using namespace std;
int dp[][][];
int minv(int a,int b){
return a>=b?b:a;
}
int dfs(int A,int B,int C,int ret){
if(ret==) return ;
if(dp[A][B][C]!=-)
return dp[A][B][C];
int mix=;
if(C>){
mix=minv(mix,dfs(A+,B,C-,ret-)+);
}
if(C>&&A>=){
mix=minv(mix,dfs(A-,B+,C-,ret-)+);
}
if(B>=){
mix=minv(mix,dfs(A+,B-,C,ret-)+);
}
if(B>&&A>=){
mix=minv(mix,dfs(A-,B-,C,ret-)+);
}
if(A>=){
mix=minv(mix,dfs(A-,B,C,ret-)+);
}
return dp[A][B][C]=mix;
}
int main()
{
int t;
scanf("%d",&t);
while(t--){ memset(dp,-,sizeof(dp));
int N,A,B,C;
scanf("%d%d%d%d",&N,&A,&B,&C);
dfs(A,B,C,N);
printf("%d\n",dp[A][B][C]);
}
return ;
}
uva 10118 这题说的是 给了四堆得 糖果 然后 每个糖果都有颜色 然后Little Bob 只有 一个篮子 每个篮子只能放 最多5 个糖果 然后如果篮子中有 连个颜色相同的糖果 那么这两个糖果可以拿出来篮子里的糖果就是 原本个数减去 2 然后 问Little BOb 可以拿出多少对这样相同颜色的糖果，
这题刚看到题目时 不知怎么下手 然后就按照暴力的想法 想了一下状态主要是 4个堆 的每个位置 不同造成的 然后 就记录状态 记忆化搜索 取最大值
#include <iostream>
#include<string.h>
#include<cstdio>
using namespace std;
int dp[][][][],n;
int M[][];
int num[];
int maxv(int a,int b){
return a>b?a:b;
}
int dfs(int L0,int L1,int L2,int L3){
int sum=,G=;
if(dp[L0][L1][L2][L3]!=-) return dp[L0][L1][L2][L3];
for(int i=;i<=;++i){ if(num[i]>) sum+=num[i]/; if(num[i]%!=) G++; }
if(dp[L0][L1][L2][L3]!=-)
return dp[L0][L1][L2][L3];
if(G==){
return dp[L0][L1][L2][L3]=sum;
}
int ma=sum;
if(L0<n){
num[M[][L0]]++;
ma=maxv(dfs(L0+,L1,L2,L3),ma);
num[M[][L0]]--;
} if(L1<n){
num[M[][L1]]++;
ma=maxv(dfs(L0,L1+,L2,L3),ma);
num[M[][L1]]--;
} if(L2<n){
num[M[][L2]]++;
ma=maxv(dfs(L0,L1,L2+,L3),ma);
num[M[][L2]]--;
} if(L3<n){
num[M[][L3]]++;
ma=maxv(dfs(L0,L1,L2,L3+),ma);
num[M[][L3]]--;
}
return dp[L0][L1][L2][L3]=maxv(ma,dp[L0][L1][L2][L3]);
}
int main()
{
while(true){
scanf("%d",&n); if(n==) break;
for(int i=;i<n;++i)
for(int j=;j<;++j)
scanf("%d",&M[j][i]);
memset(dp,-,sizeof(dp));
memset(num,,sizeof(num));
dfs(,,,);
printf("%d\n",dp[][][][]);
}
return ;
}
uva 607 这题说的是 有N个课题每个课题要花ti每种解决 每节课都有L分钟 然后不能在两节课都讲有同样的一个课题 就是说要讲就必须在一节课内讲完
然后要求用最少的课时 讲完这些课题 还有最小的不满意度 不满意度是这样计算的 当下课时间为0 时 不满意度增加0 时间1到10之间时 不满意度增加-C 时间在 10 以上的时候不满意度 为 （t-10）*（t-10） 然后在满足最小的 课时前提下最小的 不满意度
刚开始想也是可能在一节课内有多少个课题 然后觉得 肯定跟 所处的状态有关 然后用 背包去做了一下 爆栈了 然后 采用记忆化搜索 过了
记忆化搜索这样鲁 dp[i][j] 表示第i个课题在第j节课 得到的最小的不满意度 枚举每个区间所能达到的所有情况
#include <iostream>
#include<cstdio>
#include<string.h>
using namespace std;
const int inf=0x7fffffff;
int dp[][];
bool vis[][];
int ti[],n,L,C;
int get(int s){
if(s==) return ;
if(s>&&s<=) return -C;
if(s>) return (s-)*(s-);
}
int minv(int a,int b){
return a>b?b:a;
}
int dfs(int num, int lca){
if(vis[num][lca]) return dp[num][lca];
int sum=;
if(num==)
return lca>?inf:;
for(int i = lca;i > ; i -- ){
sum += ti[i];
if( sum > L ) break;
int E = dfs( num-, i-);
if(E != inf){
dp[num][lca] = minv(dp[num][lca],get(L-sum)+E);
}
}
vis[num][lca] = true;
return dp[num][lca];
}
int main()
{
int cas=;
while(true){
scanf("%d",&n);
if(n==) break;
scanf("%d%d",&L,&C);
for(int i = ;i <= n;++ i)
scanf("%d",&ti[i]);
int M=,num=;
for(int i = ;i <= n; i ++) if(M<ti[i]){
num++;
M=L-ti[i];
}
else M=M-ti[i];
for(int i = ;i <= num;++ i)
for(int j = ; j <= n ; ++ j )
dp[i][j]=inf;
memset(vis,false,sizeof(vis));
dfs(num,n);
if(cas!=) printf("\n");
printf("Case %d:\n",++cas);
printf("Minimum number of lectures: %d\n",num);
printf("Total dissatisfaction index: %d\n",dp[num][n]);
}
return ;
}
经过调试 昨晚太糊涂了 精神不足 自己将fii（）的填充量变大了 然后爆栈了 今天改了一下 背包也过了
#include <iostream>
#include<cstdio>
#include<string.h>
#include<queue>
using namespace std;
const int inf=0x7fffffff;
struct node{
int num,ret,loc;
node(int a=,int b=,int c=){
num=a; ret=c; loc=b;
}
};
int dp[];
int ti[],n,L,C;
int get(int s){
if(s==) return ;
if(s>&&s<=) return -C;
if(s>) return (s-)*(s-);
}
int minv(int a,int b){
return a>b?b:a;
}
int main()
{
node temp,re;
queue<node>Q;
int cas=;
while(true){
scanf("%d",&n);
if(n==) break;
scanf("%d%d",&L,&C);
for(int i = ;i <= n;++ i)
scanf("%d",&ti[i]);
int M=,num=;
for(int i = ;i <= n; i ++) if(M<ti[i]){
num++;
M=L-ti[i];
}
else M=M-ti[i]; ti[n+]=;
re=node(,,);
fill(dp,dp+num+,inf);
dp[]=;
int mi=inf ,ma = -,mg=inf;
Q.push(re);
for(int i = ;i <= n;++ i ){
while(!Q.empty()){
if(Q.front().num==i) break;
temp=Q.front();
Q.pop();
int R=temp.loc/L;
int W=get((R+)*L-temp.loc-ti[i]);
dp[R+]=minv(dp[R+],temp.ret+W);
if(i==n&&R+==num) mg=minv(mg,dp[R+]);
mi=R+<mi?R+:mi;
ma=R+>ma?R+:ma;
re=node(i,temp.loc+ti[i],temp.ret);
if((R+)*L<re.loc+ti[i+]) continue;
Q.push(re);
}
for(int j = mi;j <= ma;++ j )
if(dp[j]!=inf){
re=node(i,j*L,dp[j]);
Q.push(re);
}
ma=-; mi=inf;
fill(dp,dp+num+,inf);
}
if(cas!=) printf("\n");
printf("Case %d:\n",++cas);
printf("Minimum number of lectures: %d\n",num);
printf("Total dissatisfaction index: %d\n",mg);
while(!Q.empty())Q.pop();
}
return ;
}
uva 10604 集合上的动态规划 这题说的是化学试验室有 N中药品 每种药品可以和别的药品进行混合 混 合 后 会 产 生 一 定 的 热 量 然 后 转 化 为 别 的药品 给了 K 种 药 品 计 算 这 K 种 药 品 混 合 后 的 最 少 热 量 这题应该是 集合 看看数据 略小 然后 dp[S][i] 对于集合S变成 i 化合物后 的最小热量 这样就可以办证是从他的任意子集来的 这样就 得到动态方程
dp[S][i]= min(dp[s][i],dp[s0][i]+sp[s0^s][j]+tow[i][j]);
#include <iostream>
#include<cstdio>
#include<string.h>
using namespace std;
const int inf=0x7fffffff;
int dp[<<][];
int tod[][];
int tow[][],n,k;
int cas[];
int minv( int a,int b) { return a>b?b:a; }
int main()
{
int t;
scanf("%d", &t );
while(t--){
for(int i = ;i <= n ; ++ i) {tod[][i] = tod[i][] =i; tow[][i]= tow[i][] = ; }
scanf("%d",&n);
for(int i = ;i <= n; ++ i )
for (int j = ;j <= n ; ++ j)
scanf("%d%d", &tod[i][j], &tow[i][j] );
scanf("%d",&k);
for(int i=;i<(<<k); ++i) for(int j=; j<=n; ++j) dp[i][j]=inf;
for(int i = ;i < k;i ++ ){
scanf("%d", &cas[i]);
dp[ << i ][ cas[i] ] = ;
}
for(int S = ;S < ( <<k ); ++ S ){
for(int S0 = S;S0; S0= ( S0- )&S ){
for(int i = ;i <= n; ++ i){
if(dp[S0][i] == inf ) continue;
for(int j=; j <= n ; ++j ) {
if(dp[ S0^S ][ j ]==inf) continue;
dp[S][tod[i][j]]=minv(dp[S][tod[i][j]],dp[S0][i]+dp[S^S0][j]+tow[i][j]);
}
}
}
}
int sum=inf;
for(int i= ; i <= n; ++ i )
sum=minv(sum,dp[(<<k)-][i]);
printf("%d\n",sum);
char str[];
scanf("%s",str);
}
return ;
}
uva 10913 这题说的是给了 一个矩阵然后从左上到右下 使得经历过的 点数之和最大 然 后 经 过 负 数 的 点 只 能 不超过 K个 然后 有dp[i][j][k] 表示 ij这个点在k这个状态的最大的整数和 然后 只能向左走或则向右或则向下 走 每个格子只能走一次这样我们就可以从左边和从 右边 开始 进行选取 然后每个状态都得到最优的 一个点的多个状态可以由多个点组成 因为答案只要求最大的和 然后得到了
map[i][j]>=0 dp[i][j][k]=max(dp[i+1][j][k]+map[i][j],max(dp[i][j][k],dp[i-+1][k]+map[i][j])(-左边 + 右边)
map[i][j]<0 dp[i][j][k]=max(dp[i+1][j][k-1]+map[i][j],max(dp[i][j][k],dp[i-+1][k-1]+map[i][j])(-左边 + 右边)
#include <iostream>
#include<cstdio>
#include<string.h>
#include<queue>
using namespace std;
const long long inf=0x7fffffffffffffff;
long long dp[][][][];
int N,K;
long long map[][];
long long maxv(long long a,long long b){ return a>b?a:b; }
void inti(){
for(int u=;u<; u++)
for(int i = ; i <= N + ; ++ i)
for( int j = ; j <= N + ; ++ j)
for( int kk = ;kk <= K ; kk ++ )
dp[u][i][j][kk]=-inf;
dp[][][][]=;
}
int main()
{
int cas=;
while(true){
scanf("%d%d",&N,&K);
if(N==&&K==) break;
for(int i = ; i <= N; ++ i )
for( int j = ; j <= N ; ++ j)
scanf("%lld",&map[i][j]);
inti();
for(int i=;i<= N ; ++ i){
for(int j = ; j <= N ; ++j ){
int R=N-j+,L=j;
if(map[i][j]>=)
{
for(int h=;h<=K; h++)
{
dp[][i][L][h]=dp[][i-][L][h]!=-inf?maxv(dp[][i-][L][h]+map[i][j],dp[][i][L][h]):dp[][i][L][h];
dp[][i][L][h]=dp[][i][L-][h]!=-inf?maxv(dp[][i][L-][h]+map[i][j],dp[][i][L][h]):dp[][i][L][h];
}
}
else {
for(int h=;h<=K; h++)
{
dp[][i][L][h]=dp[][i-][L][h-]!=-inf?maxv(dp[][i-][L][h-]+map[i][j],dp[][i][L][h]):dp[][i][L][h];
dp[][i][L][h]=dp[][i][L-][h-]!=-inf?maxv(dp[][i][L-][h-]+map[i][j],dp[][i][L][h]):dp[][i][L][h];
}
}
if(map[i][R]>=){
for(int h=;h<=K; h++)
{
dp[][i][R][h]=dp[][i-][R][h]!=-inf?maxv(dp[][i-][R][h]+map[i][R],dp[][i][R][h]):dp[][i][R][h];
dp[][i][R][h]=dp[][i][R+][h]!=-inf?maxv(dp[][i][R+][h]+map[i][R],dp[][i][R][h]):dp[][i][R][h]; } }else{
for(int h=;h<=K; h++)
{
dp[][i][R][h]=dp[][i-][R][h-]!=-inf?maxv(dp[][i-][R][h-]+map[i][R],dp[][i][R][h]):dp[][i][R][h];
dp[][i][R][h]=dp[][i][R+][h-]!=-inf?maxv(dp[][i][R+][h-]+map[i][R],dp[][i][R][h]):dp[][i][R][h];
} }
} for(int j=;j<=N; ++j)
for(int h=;h<=K; ++h)
dp[][i][j][h]=maxv(dp[][i][j][h],dp[][i][j][h]); }
long long sum=-inf;
for(int i=;i<=K; ++i)
if(dp[][N][N][i] > sum) sum=dp[][N][N][i];
if( sum == -inf )
printf("Case %d: impossible\n",cas++);
else printf( "Case %d: %lld\n",cas++,sum );
}
return ;
}
uva 11008 这题说的是给了n 个 点 然后你有一种激光枪 然后可以一枪将 一排的树 都砍掉 然后让你砍掉 m棵树 最 少 开 的 枪 数 然 后 处 理 好 可 以 在 一 条 线 上 的 点
然 后 枚 举 采 用 集 合 上 的 点 采用集合上的动态规划 可以得到所要的 集合将重点给去掉 我原本以为不可能有 重点 然 wa 了 好 几 发 处 理 好 后 就 过 了
#include <iostream>
#include<string.h>
#include<cstdio>
#include<algorithm>
using namespace std;
const int inf = ;
int dp[<<],num[],pointnum;
bool vis[<<];
struct point{
int x,y;
bool operator<(const point &A) const {
return x<A.x||(x==A.x&&y<=A.y);
}
}node[],T[];
int n,m,ans;
int minv(int a,int b) { return a > b ? b : a; }
void work( int H){
int ge=;
for(int i=; i< pointnum ; ++i) if(H&(<<i)) ge+= num[i];
if( ge>=m ) ans=minv(dp[H],ans);
}
void inti(){ for(int i= ;i < ( << pointnum) ; ++ i) dp[i]= inf ;
dp[] = ;
for(int i= ;i < pointnum ; ++ i){
dp[<<i] = ;
if(num[i]>=m) ans=minv(ans,dp[<<i]);
for(int j= i+ ; j < pointnum; ++ j ){
int x1 = T[i].x - T[j].x;
int y1 = T[i].y - T[j].y;
int sum=(<<i); sum+= (<<j);
int ge = num[i] + num[j] ;
dp[sum]=;
if(ge >= m) ans=minv(ans,dp[sum]);
for(int k = ; k < pointnum ; k ++ ){
if(k==i ||k ==j) continue;
int x2 = T[k].x - T[j].x;
int y2 = T[k].y - T[j].y;
if(x2 * y1 != x1 * y2) continue;
sum+=(<<k);
dp[sum]=;
ge+=num[k];
if(ge>=m) ans=minv(ans,dp[sum]);
} }
} }
int main()
{
int t;
scanf("%d",&t);
for(int cas = ; cas <= t ; cas ++ ){
scanf("%d%d",&n,&m);
for(int i= ;i < (<<n) ; ++ i)
dp[i]=inf;
for(int i=;i < n ; i ++)
scanf("%d%d",&node[i].x,&node[i].y);
sort(node,node+n);
memset(num,,sizeof(num));
num[]=; T[]=node[];
pointnum=;
for(int i=;i < n ; i++){
if(node[i].x==node[i-].x&&node[i].y==node[i-].y) num[ pointnum- ] ++;
else {
T[ pointnum ++ ] = node[i];
num[ pointnum - ] = ;
}
}
ans=m;
inti();
for(int S= ; S < (<<pointnum) ; ++ S ){ for(int S0 = S ; S0 ; S0 =(S0-)&S ){
dp[S]=minv(dp[S],dp[S^S0]+dp[S0]);
}
work(S);
}
printf("Case #%d:\n",cas);
printf("%d\n",ans);
if(cas!=t) printf("\n");
}
return ;
}
uva10723 这 题 说 的 是 给 了 两 串 字 符 串 然 后 将 这 两 串 字 符 串 合 并 成 一 串, 使 得 这 两 个 字 符 串 与 合 并 的 字 符 串 最 长 公 共 子 序 列 为 各 自 串 的 长 度 ，
先 用 最 长 公 共 子 序 列 求 出 两 个 字 符 合并后的最小长度 然后 进行记忆化搜索 dp[ L ][ h1 ][ h2 ] 表 示 合 成 串 在 L 长 度 的 时 候 字 符 串 在s1 中取到了 h1 个 字符串 s2 取到了 h2 个然后 如果相同的 s1[h1]==s2[h2] 表示下一个他们具有相同的 字符 自然 只有一种情况 如果不相同 那么就 枚举这两个字符放在这个位置的 总数
#include <iostream>
#include<cstdio>
#include<string.h>
using namespace std;
int commn[][],n,m,Len,L1,L2;
long long dp[][][];
char s1[],s2[],s3[];
bool vis[][][];
long long dfs(int Loc){ int h1=,h2=; for(int i=;i < Loc ; i ++) { if(s1[h1]==s3[i]&&h1<L1) ++ h1; if(s2[h2]==s3[i]&&h2<L2) ++ h2; } if(vis[Loc][h1][h2]) return dp[Loc][h1][h2]; if(Loc>=Len){
if(h1 == L1 && h2 == L2) return ;
else return ;
}
if(s1[h1]==s2[h2]){
s3[Loc]=s1[h1];
dp[Loc][h1][h2] = dfs(Loc+);
}
else {
if(h1<L1){
s3[Loc] = s1[h1] ;
dp[Loc][h1][h2]+=dfs(Loc+);
}
if(h2<L2){
s3[Loc] = s2[ h2 ];
dp[Loc][h1][h2]+=dfs(Loc+);
}
}
vis[Loc][h1][h2]=true;
return dp[Loc][h1][h2];
}
int main()
{
int T;
scanf("%d\n",&T);
for(int cas= ; cas <= T ; cas ++){
memset(vis,false,sizeof(vis));
gets(s1);
gets(s2);
L1 = strlen(s1);
L2 = strlen(s2);
memset(commn,,sizeof(commn));
memset(dp,,sizeof(dp));
for(int i=;i <= L1 ; i ++)
for( int j = ; j <= L2 ; ++ j)
if(s1[i-] == s2[j-])
commn[i][j] = commn[i-][j-] + ;
else commn[i][j] = commn[i-][j] > commn[i][j-] ? commn[i-][j] : commn[i][j-];
Len=L1 + L2 - commn[L1][L2];
dfs();
printf("Case #%d: %d %lld\n",cas,Len,dp[][][]);
} return ;
}
uva11258 这 题 说 的 是 给 了 一 个 数 字 字 符 串 然 后 你 将 它 分 割 成 不 超 过 int 范 围 内 的 数 字 然 后 怎 样 分 割 会 得 到 最 大 的 数（ 自 然 是 将 分 割 后 的 每 个 数 字 相 加 ） 额 前 面 有 类 似 的 一个状态表示现在 第dp[LOC][i] 表示 第i 个数字 组成第LOC 个数字时 他以后的数的任意组合能达到的最大值
#include <iostream>
#include<cstdio>
#include<string.h>
using namespace std;
const long long maxv=0x7fffffff;
long long dp[][];
int Len;
bool vis[][];
char str[];
long long dfs(int Loc,int num){ if(Loc>=Len||num>=Len) return ;
if(vis[Loc][num]) return dp[Loc][num];
long long ans=;
for(int i = num ; i < Len ; i ++){ ans = ans * + str[ i ] - '';
if(ans>maxv) break;
long long G=dfs(Loc+,i+);
dp[Loc][num]=ans+G>dp[Loc][num]?ans+G: dp[Loc][num];
}
vis[Loc][num] = true ;
return dp[Loc][num];
}
int main()
{
int t;
scanf("%d",&t);
while(t--){
memset(vis,false,sizeof(vis));
memset(dp,,sizeof(dp));
scanf("%s",str);
Len=strlen(str);
dfs(,);
printf("%lld\n",dp[][]);
} return ;
}
uva 10599 这题说的是给了一个 网格的 点然后机器人从 左上角到右下角 然后只能向下走或则向右走 问从左上角到右下角最多能够得到几个垃圾 然后得到的垃圾总数是多少 这样我最初以为是走格子 胡乱的 搞了个记忆化搜索 然后得到答案不正确 仔细一看 从一个有垃圾的地方达到另一个有垃圾的地方只能算一次 这样胡乱搞的就不行了 想想他们具有相对顺序 这样对他们进行一次排序 按照x轴和 y轴排小的放前面可以发现 似乎用 LIS 能解 确实不可能到达的点总是能够相互替换的 这样 来了一次LIS 这里是最多的时候可能会出现100*100个点所以 用nlogn的 然后加上一些标记 可以优化 就是记录他的前驱结点最后的位置 这样就省得去找别的不可能的点 然后 在计算方案数的时候采用记忆化搜索 在者 得用高精度 要不然不够 还有压一亿要25 位左右 因为这里wa了 几发 因为我只开了10位的int要、压一亿
#include <iostream>
#include<string.h>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <stack>
using namespace std;
const int MOD = ;
struct node{
int x,y,Per,Loc;
bool operator< (const node &A) const{
return x<A.x||(x==A.x&&y<A.y);
}
}dp[*],re[*]; struct Bignumber{
int Len;
int R[];
Bignumber(){
Len=; memset(R,,sizeof(R));
}
}num[][]; Bignumber add( Bignumber A, Bignumber B){
Bignumber C ;
C.Len=A.Len>B.Len? A.Len : B.Len ;
int t = ;
for(int i = ; i < C.Len ; ++ i){
C.R[i]=(A.R[i]+B.R[i] + t)% MOD;
t=( A.R[i] + B.R[i] + t)/ MOD ;
}
if(t>){
C.R[C.Len] = t; C.Len ++ ;
}
return C;
}
int N,row,column,per[];
bool vis[][];
vector<node>tap[];
int birdseach(int T,node E){
int L = ,R = T;
while(L < R){
int mid=( L + R ) >> ;
if(dp[mid].x <= E.x && dp[mid].y <= E.y ){
L=mid+;
}else R=mid;
}
if( ( dp[ L ].x <= E.x && dp[ L ].y <= E.y ) ) L++;
return L;
}
Bignumber dfs(int en, int Loc){ node C = tap[en][Loc] ;
if(vis[C.x][C.y])
return num[C.x][C.y] ;
Bignumber T;
node D;
int TG = C.Per;
if( TG == - )
T.R[] = ;
else {
int now = (C.x-)*column+C.y;
node LA= tap[ en - ][TG];
int late = ( LA.x - )*column + LA.y;
per[now]=late ; }
for(int i = TG ; i >= ; -- i){
D = tap[en-][i] ;
if(!(D.x <= C.x && D.y <= C.y)) continue;
T=add(T,dfs( en - , i ));
}
num[ C.x ][ C.y ] = T ;
vis[ C.x ][ C.y ] =true;
return num[ C.x ][ C.y ];
}
int LIS(int ans){
int Len;
sort(re,re+ans);
Len = ;
tap[].clear();
re[].Loc=;
re[].Per=-;
dp[]=re[];
tap[ ].push_back(dp[]);
for(int i = ; i < ans ; ++ i ){
if( re[i].x >= dp[Len-].x && re[i].y >= dp[Len-].y ){
tap[Len].clear();
re[i].Loc=;
re[i].Per=dp[Len-].Loc;
dp[Len] = re[i];
tap[Len].push_back(re[i]);
Len ++;
}
else{
int intset=birdseach( Len, re[i] );
if(intset==){
re[i].Loc=tap[].size();
re[i].Per = -;
dp[]=re[i];
}
else{
re[i].Loc=tap[intset].size();
re[i].Per = dp[intset-].Loc;
dp[intset] = re[i] ;
}
tap[intset].push_back(re[i]);
}
}
return Len;
}
void outprot(int Len ,Bignumber an,int cas){ stack<int>R;
int r;
r=( tap[Len-][].x - )* column +tap[Len - ][ ].y;
R.push( r );
while(per[r] != -){
r=per[r];
R.push( r );
}
printf("CASE#%d: %d",cas,Len);
printf(" %d",an.R[ an.Len- ]);
for (int i = an.Len - ; i >= ; i -- )
printf("%08d",an.R[i]);
while(!R.empty()){
printf(" %d",R.top());
R.pop();
}
printf("\n");
}
int main()
{
int cas=,ans; while(true){ int Len ;
scanf("%d%d",&row,&column);
if(row == - && column == -) break;
ans = ;
while(true){ scanf("%d%d",&re[ans].x,&re[ans].y); if(re[ans].x == && re[ans].y == )
break;
++ans ;
}
Len = LIS(ans);
memset(vis,false, sizeof(vis));
memset(per,-,sizeof(per));
Bignumber an;
for(int i = ; i < tap[Len-].size() ; i ++)
an = add( an,dfs( Len - , i ) );
if(ans!=)
outprot( Len , an, ++cas ) ;
else printf("CASE#%d: 0 0\n",++cas);
} return ;
}
uva 10817 这题说的是 要给一个学校招老师 原本有一些老师可以教学 所给的课程 然后还需要招收一些老师使得每个科目至少有两个老师在教 给了所有在职老师招聘老师的 信息 在职老师是一定要招的然后从剩下的老师中 挑一些老师在满足上面的情况下 使得花费最少
刚开始 想用一个8维数组果断 感觉姿势不对 然 后 才 8 门 课 程 然 后 每 门 课 程 要两个人就好 刚好 1<<16的状态 果断能存下来然后进行 每 个 人 对 于 每 个 人 都 有 可 能 的 状 态 进 行 填 充 要 知 道 1<<i 与 1<<(j+S) 位 代 表 的 是 相 同 的 课 程 有一个存在的时候 另一个不存在 说明这门中有一个人 ，如 果 两 个 都 有 那 么 证 明 这门课程已满然后dp[S] 代表的是此状态的最小 花费 然后 好了 对了还有两点 让我wa的 苦不堪言 是这个 首先for(int i=0 ; i< N; i ++ ) 要放在for(int T = (1<<(2*S))-1 ; T >= 0; -- T ) 外面 这样才能保证一个老师只能被招聘一次 我之前是放在里面的 没考虑清楚 还有一个 if( ( T&(1<<j) ) == 0 ) sum+=(1<<(j)); 我写成了 if( ( T&(1<<j) ) == 0 ) sum+=(1<<(j+S)); 也wa了好几发 果断的 修养不够
#include <iostream>
#include <cstdio>
#include <string.h>
#include <cstdio>
using namespace std;
const long long INF = 0x7fffffffffffffff;
long long dp[<<],First,cost[];
int serving[];
int S,M,N;
bool now[][];
char str[];
void read(){
int Len = strlen(str), h=;
bool inq[];
memset(inq,false,sizeof(inq));
while( h < Len ){
if(str[h] > '' && str[h] <= ''){
if(inq[str[h]-'']==false)
{++serving[str[h]-''];
inq[str[h]-'']=true;
}
} h++;
}
}
void dfs(int num, int G){ if(num>=S){
dp[G] = First; return ;
}
dfs(num+,G);
if(serving[num]>){
dfs( num + , G+(<<(num)) );
}
if(serving[num]>){
dfs(num + ,G + (<<(num+S)) + (<<(num)) );
}
}
void read2(int L){
int Len = strlen(str),h=;
while(h<Len){
if(str[h]>'' && str[h] <= '')
now[L][str[h]-'']= true;
++ h;
}
}
long long minv(long long a,long long b){
return a>b?b:a;
}
int main()
{ while(true){
First = ;
scanf("%d%d%d",&S,&M,&N);
if(S==&&M==&&N==) break;
for(int i = ; i<(<<(*S)) ; ++ i )
dp[i] = INF;
memset(serving,,sizeof(serving));
memset(cost,, sizeof(cost));
memset(now,false,sizeof(now));
for(int i= ; i < M ; i++){
long long T;
scanf("%lld",&T);
First+=T;
gets(str);
read();
}
dfs(,);
for(int i = ; i < N ; ++ i ){
scanf("%lld",&cost[i]);
gets(str);
read2(i);
}
for(int i= ; i< N; i ++ ){ for(int T = (<<(*S))- ; T >= ; -- T ){ if(dp[T] == INF) continue; int sum=T; for(int j=; j< S; ++ j){ if(now[i][j]){ if( ( T&(<<j) ) == ) sum+=(<<(j));
else
if( (T&(<<(j+S)))==) sum+=(<<(j+S)); }
dp[sum]=minv(dp[sum],dp[T]+cost[i]);
} }
}
printf("%lld\n",dp[(<<(S*))-]);
}
return ; }
uva 10163 这题说的是某公司有N 个仓库 招聘管理员来看管 每个管理员都有一定的能力值Pi，录用他就是要付Pi 元，一个仓库只能让一个人看管 一个管理员可以看管多个仓库，如果他看管了K个仓库 那么这K个仓库的 安全值就为Pi/K 都是整数意思说存在舍去余数，然后公司将最低的 安全值当作这个公司的安全值 求使得安全值最高的前提下招聘的花费尽量的少，这题wa的好痛苦 ，刚开始将dp[i][j] 和 price[i][j]表示为第i个人可以看管几个仓库 此时取到的最大值和相应的最小价钱 然后状态从dp[i][j]=min(dp[i-1][k],P[i]/(j-k))这个求最大的安全值是可行的 但是求最小的价钱不一定行 刚开始就是这里wa了 这样说如果有dp[i-1][k] 非常的大 然后P[i]/(j-K) 非常的小 安全值取决去小的但是价钱并不一定要用dp[i-1][k] 反而可以用比dp[i-1][k]小的安全值只要大于P[i]/(j-K)可能会取到更小的价钱但是这个动态方程却没用表示出来，这样先求出的、所能达到的最大值然后按照这个最大值的前提下去求最小的安全值 我用深搜 暴了时间可能是那里的条件没有判断好，然后改成非递归的过了 纠结了两天
#include <iostream>
#include <cstdio>
#include<string.h>
using namespace std;
const long long INF=0x7fffffff;
long long dp[][],price[][],P[],Q[];
int N,M;
long long minv(long long a,long long b){ return a>b?b:a; }
long long maxv(long long a,long long b){ return a>b?a:b; }
int main()
{
while(true){
scanf("%d%d",&N,&M);
if(N==&&M==) break;
memset(dp[],,sizeof(dp[]));
memset(price[],,sizeof(price[]));
for(int i = ; i <= M ; i ++) for( int j= ; j <=N ; ++j ){ dp[i][j]=; price[i][j]=INF; }
for(int i = ; i <=M ; ++i)
scanf("%lld",&P[i]);
for(int i = ; i <= M ; i++){
for(int j= ;j <= N ; ++ j){
dp[i][j]=maxv(dp[i-][j],P[i]/j);
for(int k = ; k < j ; k++)
dp[i][j]=maxv(minv(dp[i-][k],P[i]/(j-k)),dp[i][j]);
}
}
if(dp[M][N]==){
printf("0 0\n"); continue;
}
int num=;
for(int i = ; i <= M ; ++ i)
if(P[i]>=dp[M][N]) Q[++num]=P[i];
for(int i=; i<=num; i++)
for(int j = ; j <= N ; j ++){
if(Q[i]/j>=dp[M][N])
price[i][j]=minv(price[i-][j],Q[i]);
else price[i][j]=price[i-][j];
for( int k =; k< j ; ++ k){
if(price[i-][k]==INF||(Q[i]/(j-k))<dp[M][N])continue;
price[i][j]=minv(price[i][j],price[i-][k]+Q[i]);
}
}
printf("%lld %lld\n",dp[M][N],price[num][N]);
}
return ;
}
uva 709 这 题 说 的 是 编 写 一 个 文 本 编 辑器 然 后 使 得 每 行 的宽度相同 每行开头和结尾都必须是单词 有一种情况 就是一行只能容纳下一个单词的 然后每个单词间都会有空格空格的个数c bad=(c-1)^2 为这个不好的度量然后计算使得这个总不好值最小的方案并输出 还有如果有一行一个单词bad就是500 这样采用记忆化搜索使得教前面的行方尽量多的单词 还有在输出的时候尽量让较少的空格放在前面因为样例是这样的
#include <iostream>
#include <cstdio>
#include <string.h>
using namespace std;
const int INF= 0x7fffffff;
const int maxn = ;
int dp[maxn][maxn];
int Len[maxn],N,num,per[maxn][maxn];
char str[maxn][];
void read(){
char t[];
getchar();
while(true){ gets(t);
int L= strlen(t);
if( L== ) break;
int i=;
while(i<L){
if(t[i]>=&&t[i]<=){
int g= ;
while(t[i]>=&&t[i]<=&& i<L){
str[num][g++] = t[i++];
}
Len[num]=g;
str[num][g]=;
num++;
}
i++;
}
} }
int cout1(int sum,int ge){ int gap=N-sum;
return (gap/ge-)*(gap/ge-)*ge+(*(gap/ge-)+)*(gap%ge);
}
long long dfs(int Loc,int S){ if(dp[Loc][S]!=INF) return dp[Loc][S];
if(S>=num) return ;
dp[Loc][S]=dfs(Loc+,S+)+;
per[Loc][S]=S;
// if(Len[S] == N )dp[Loc][S]-=500;
int sum=Len[S];
for(int i=S+; i<num; i ++ ){
sum += Len[i];
if(sum+i-S>N)break;
int G= cout1(sum,i-S);
int T=dfs(Loc+,i+);
if(G+T<=dp[Loc][S]){
dp[Loc][S] = G+T; per[Loc][S]=i;
}
}
return dp[Loc][S];
}
void out(int L,int R){
if(L ==R){
printf("%s\n",str[L]); return ;
}
printf("%s",str[L]);
int ge=R-L;
int sum=;
for(int i = L ; i<= R ; ++ i)
sum+=Len[i];
int gap = N-sum ;
int t=gap/ge;
int h = gap%ge;
for(int i = L+ ; i<=L+ge-h ; ++i )
{
for( int j= ; j <= t ; ++j ) printf(" ");
printf("%s",str[i]);
}
for(int i= L+ge-h+; i<=R ; ++i)
{
for ( int j = ; j <=t ; ++j) printf(" ");
printf("%s",str[i]);
}
printf("\n");
}
void printw(){
int sta=,Loc=;
while(per[Loc][sta]!=-){
out(sta,per[Loc][sta]);
sta=per[Loc][sta]+; Loc++;
}
}
int main(){ while(true){
num=;
scanf("%d",&N);
if(N== ) break;
read();
for(int i = ; i <=num+ ; i++)
for(int j = ; j <=num+ ; j++) { dp[i][j]=INF; per[i][j]=-; }
dfs(,);
// printf("%d\n",dp[0][0]);
printw();
printf("\n");
} return ;
}
非递归版的 这个确实比较好 因为在不知道单词有多少个的时候这种方法确实比较有利 f[i] 表示以i开头的最小的bad值然后去枚举每个可能的情况
#include <iostream>
#include <cstdio>
#include <string.h>
using namespace std;
const int INF= 0x7fffffff;
const int maxn = ;
int dp[maxn];
int Len[maxn],N,num,number[maxn],wide[maxn];
char str[maxn][];
void read(){
char t[];
getchar();
while(true){ gets(t);
int L= strlen(t);
if( L== ) break;
int i=;
while(i<L){
if(t[i]>=&&t[i]<=){
int g= ;
while(t[i]>=&&t[i]<=&& i<L){
str[num][g++] = t[i++];
}
Len[num]=g;
str[num][g]=;
num++;
}
i++;
}
} }
int cout1(int sum,int ge){
int gap=N-sum;
return (gap/ge-)*(gap/ge-)*ge+(*(gap/ge-)+)*(gap%ge);
}
void dfs(){ for(int i= num- ;i>= ; -- i ){
dp[i]=dp[i+]+;
int sum = Len[i];
wide[i]=sum;
number[i] = ;
for(int k = ; k+i<num ; k++ ){
sum += Len[i+k];
if(sum+k>N) break;
int G = cout1(sum,k);
if(G+dp[i+k+]<=dp[i]){
dp[i]=G+dp[i+k+];
wide[i] = sum ;
number[i] =k+;
}
}
}
}
void out(int L,int R){ printf("%s",str[L]);
int ge=R-L-;
if(ge==) { printf("\n"); return ; }
int gap=N-wide[L];
int t=gap/ge;
int h= gap%ge;
for (int i=L+ ; i <=L+ge-h; ++i){
for(int j= ;j<=t ; j++)printf(" ");
printf("%s",str[i]); }
for(int i=L+ge-h+; i <R; i++){
for(int j= ; j<= t; j++)printf(" ");
printf("%s",str[i]);
}
printf("\n");
}
void printw(){ int m = ;
while(m<num){
out(m,m+number[m]);
m=m+number[m];
} }
int main(){ while(true){
num=;
scanf("%d",&N);
if(N== ) break;
read();
for(int i= ; i <num ; i++) dp[i]=INF;
dp[num]=;
dfs();
// printf("%d\n",dp[0]);
printw();
printf("\n");
} return ;
}
uva 10280 这题说的是给了一个体积为L升的酒 给了N个酒杯 每种酒杯都有自己的最大容量个最低限度也就是说你要用这个酒杯得保证这个酒杯里的酒在这个范围内然后 每种杯子都有无限多个计算最后会有酒没有被装下 我们可以发现这样的情况假设一种杯子有了k个那么在这个k*min----k*max之间的容量的酒是允许被装下的但是随着k的增大会发现这个区间在不断地扩大因为每个相邻区间的距离是固定的min但是右区间的距离是在不断的增大这样随着k的增大会出现一种情况（k+1）*min< k*min可以得到达到这个状态下的k的值就是k大于等于min*min/（max-min）当达到这个区间后的所有值都是可以装下的 然后这样求最大的状态的数就是 max*100 也就是说所有的大于这个状态的酒量都能够被存下来 然后进行完全背包 当我们进行分析后会发现 这些情况下进行完全背包的 不会超过10的7次方3秒因该够了 这个剪支很强大
#include <iostream>
#include<cstdio>
#include<string.h>
using namespace std;
const int MAXN = *;
const int MAXM = *;
const int INF = 0x7fffffff;
int dp[MAXM],v[MAXN],minv[],maxv[];
bool vis[MAXM];
void solve(){ int Limt = INF;
int L,N;
scanf("%d%d",&L,&N);
L = L * ;
for(int i= ; i< N ;++ i){
scanf("%d%d",&minv[i],&maxv[i]);
if(minv[i]*minv[i]/(maxv[i]-minv[i])<Limt){
Limt = minv[i]*minv[i]/(maxv[i]-minv[i]);
}
}
if(L>=Limt){
printf("0\n"); return ;
}
int num = ;
memset(vis,false,sizeof(vis));
for(int i= ; i < N ; ++ i )
for(int j = minv[i] ; j<= maxv[i]; ++ j)
if(vis[j]==false){
v[num++] = j;
vis[j] = true;
}
memset(dp,,sizeof(dp));
for(int i = ; i< num ; i++)
for( int j=v[i] ; j <=L; j++ )
if(dp[j-v[i]]+v[i]>dp[j])
dp[j] = dp[j-v[i]] + v[i] ;
printf("%d\n",L - dp[L] ); }
int main()
{
int t;
scanf("%d",&t);
while( t -- ){ solve() ;
if(t) printf("\n"); } return ;
}
uva 10558 这题说的是给了方格100*100的地图 然后给了几个方格的点的左下角的坐标，然 后 给 了 竖几条线 线 又给了你可以使用的线的条数计算出使得将这些点尽量分开在不同的方格内 输出你使用的横线的位置 这样 如果记忆化搜索会比较好理解 那就用记忆化搜索来讲 dp[i][j] 表示将第一条线放在j这个位置取得的最大值 进行递归的搜索 还有就是num[i][j]表示ij行之间的 点数 然后 这个处理用点小技巧 然后我将 他转化为非递归的形似 然后给的是咱们正常的坐标的 YX 而不是像平常那样的XY 这里wa了几次
#include <iostream>
#include <cstdio>
#include <string.h>
#include <algorithm>
using namespace std;
const int maxn =;
int num[maxn][maxn],in[maxn][maxn],dp[maxn][maxn],per[maxn][maxn];
int X[maxn*maxn],Y[maxn*maxn],N,NS[maxn],M,A;
bool mark[maxn],vis[maxn][maxn];
void dfs(){
dp[A][]=;
for( int i = A-; i> ; i--){
for( int j = -A+i ; j >=i ; j -- ){
int L=j; int R=-A+i;
for( int k =L ; k<=R; k++){
int tt=num[L][k]+dp[i+][k+];
if(dp[i][j]<tt){
per[i][j]=k+;
// printf("%d %d %d\n",i,j,per[i][j]);
dp[i][j] = tt;
}
}
} }
printf("%d",A);
int T=,Loc=;
printf(" %d",);
while(per[T][Loc]!=-){
printf(" %d",per[T][Loc]);
Loc=per[T][Loc];
T++;
}
printf("\n");
}
int main()
{ while(true){ scanf("%d",&N);
if(N==-)break;
for(int i = ; i < N ; ++ i)
scanf("%d%d",&Y[i],&X[i]);
scanf("%d",&M);
for( int i = ; i < M ; ++ i)
scanf("%d", &NS[i]);
scanf("%d",&A);
memset(num,,sizeof(num));
memset(in,,sizeof(in));
memset(dp,-,sizeof(dp));
memset(per,-,sizeof(per));
sort(NS,NS+M);
for( int i = ; i < N ; i ++){
int L= upper_bound(NS,NS+M,Y[i])-NS;
in[X[i]][L-]=;
} for(int i = ; i<= ; i++){
memset(mark,false,sizeof(mark));
for(int j = ; j< M ; j++) if(in[i][j]){ mark[j]=true; num[i][i]++; }
for( int j =i+; j<= ; ++ j) for(int k = ; k< M ; ++ k ){
mark[k]=in[j][k]==||mark[k]?true:false;
if(mark[k])num[i][j]++;
} }
dfs();
}
return ;
}
uva11081 这题说的是给了 三个字符串然后第三个串是由第一个和第二个串的子序列拼接而来的 输出有多少种拼接方案 我是用记忆话搜索的差点T了 先说说我是怎么做的吧 这样dp[i][j][k] 表 示 串 3 是 由 串 1 到 第 j 个 字 符 串 2 到第k个字符组成的 方案 讨论第i个字符给谁的问题
#include <iostream>
#include <cstdio>
#include <string.h>
using namespace std;
const int maxn = ;
int dp[maxn][maxn][maxn],d1[maxn][maxn],d2[maxn][maxn],L1,L2,L3;
bool vis[maxn][maxn][maxn];
char s1[maxn],s2[maxn],s3[maxn],t1[maxn],t2[maxn];
int maxv( int a, int b){ return a<b?b:a; }
int dfs(int loc , int num1 ,int num2){ if(vis[loc][num1][num2]) return dp[loc][num1][num2];
if(loc>=L3){
vis[loc][num1][num2]=true;
return dp[loc][num1][num2]=;
}
int m1=,m2=;
for(int i = num1 ;i< L1; i++)
if(s1[i]==s3[loc])
m1=(m1+dfs(loc+,i+,num2))%;
else {
vis[loc][i+][num2]=true;
dp[loc][i+][num2]=;
}
for( int i = num2 ;i < L2 ; i++)
if(s2[i]==s3[loc])
m2=(m2 + dfs(loc+,num1,i+))%;
else {
vis[loc][num1][i+] = true;
dp[loc][num1][i+]=;
}
vis[loc][num1][num2]=true;
return dp[loc][num1][num2]=(m1+m2)%;
}
int main()
{
int t ;
scanf("%d",&t);
while(t --){
memset(dp,,sizeof(dp));
memset(vis,false,sizeof(vis));
scanf("%s%s%s",s1,s2,s3);
L1 = strlen(s1);
L2 = strlen(s2);
L3 = strlen(s3);
dfs(,,);
printf("%d\n",dp[][][]);
} return ;
}
上面这个差点超时 找了一下题解 发现好强大
f1[i][j][k]= {f1[i][j-1][k] }||(s1[j-1]==s3[i-1]) {f1[i][j-1][k]+f[i-1][j-1][k] };
f2[i][j][k]={f2[i][j][k-1]}||(s2[k-1]==s3[i-1]){f2[i][j][k-1]+f[i-1][j][k-1]};
f[i][j][k] =f1[i][j][k]+f2[i][j][k]
说说我对这几个状态转移的理解 这里感觉说的是 当第一个字符串在s3取到第i个位置的时候s2取到第k个位置的时候f1[i][j][k]=f1[i][j-1][k]表示如果没有他的时候能取到的方案数f1[i][j][k]=f1[i][j-1][k]+f[i-1][j-1][k] 表示的是前面那个状态加上取了这个字符能得到的总状态取了这个点的状态来自 他的前一个状态就是f[i-1][j-1][k]所达到的总状态因为在取他的时候在f[i-1][j-1][k] 状态可能会从f2转移而来，因为他们都是f1[i][j][k]取第j个字符状态的来源
f2[i][j][k]同样的道理 当他们与第一个字符串 初始化的时候就是当第三串是空串的时候可以得到dp[0][i][j]=1;
#include <iostream>
#include <cstdio>
#include <string.h>
using namespace std;
const int MOD = ;
const int maxn=;
int f[maxn][maxn][maxn],f1[maxn][maxn][maxn],f2[maxn][maxn][maxn];
char s1[maxn],s2[maxn],s3[maxn];
int main()
{
int t;
scanf("%d",&t);
while(t --){
scanf("%s%s%s",s1+,s2+,s3+);
memset(f,,sizeof(f));
memset(f1,,sizeof(f1));
memset(f2,,sizeof(f2));
int L1 = strlen(s1+);
int L2= strlen(s2+);
int L3 = strlen(s3+);
for( int i = ; i <= L1 ; ++ i)
for( int j = ; j <= L2 ; ++ j)
f[][i][j]=f1[][i][j]=f2[][i][j]=;
for(int k = ; k<= L3 ;k++)
for( int i = ; i<= L1; ++ i)
for(int j = ; j<= L2; ++j){
if(i){
f1[k][i][j]=f1[k][i-][j];
if(s1[i]==s3[k]) f1[k][i][j]=(f1[k][i][j]+f[k-][i-][j])%MOD;
}
if(j){
f2[k][i][j] = f2[k][i][j-];
if(s2[j]==s3[k])
f2[k][i][j]= (f2[k][i][j]+f[k-][i][j-])%MOD;
}
f[k][i][j]=(f1[k][i][j]+f2[k][i][j])%MOD;
}
printf("%d\n",f[L3][L1][L2]);
}
return ;
}
Root :: AOAPC I: Beginning Algorithm Contests (Rujia Liu) Volume 5. Dynamic Programming的更多相关文章
- Root :: AOAPC I: Beginning Algorithm Contests (Rujia Liu) Volume 7. Graph Algorithms and Implementation Techniques
uva 10803 计算从任何一个点到图中的另一个点经历的途中必须每隔10千米 都必须有一个点然后就这样 floy 及解决了 ************************************* ...
- AOAPC I: Beginning Algorithm Contests (Rujia Liu) Volume 6. Mathematical Concepts and Methods
uva 106 这题说的是 说计算 x^2 + y^2 = z^2 xyz 互质 然后计算个数和 在 N内 不在 勾股数之内的数的个数 然后去找需要的 维基百科上 看到 另 n*m*2 =b ...
- AOAPC I: Beginning Algorithm Contests -- Training Guide (Rujia Liu) Chapter 3. Data Structures Fundamental Data Structures
10410 这题说的是给了一棵多叉树的 bfs遍历轨迹 和dfs 遍历 轨迹 在父节点向叶子节点扩展的时候优先遍历编号较小的节点.我还原出这课树特殊判定 根据bfs的顺序来建立这课树,用一个队列安排要 ...
- [UVA] 11991 - Easy Problem from Rujia Liu? [STL应用]
11991 - Easy Problem from Rujia Liu? Time limit: 1.000 seconds Problem E Easy Problem from Rujia Liu ...
- uva--11991 - Easy Problem from Rujia Liu?（sort+二分 map+vector vector）
11991 - Easy Problem from Rujia Liu? Though Rujia Liu usually sets hard problems for contests (for e ...
- UVA-11991 Easy Problem from Rujia Liu?
Problem E Easy Problem from Rujia Liu? Though Rujia Liu usually sets hard problems for contests (for ...
- UVa 11991:Easy Problem from Rujia Liu?（STL练习，map+vector）
Easy Problem from Rujia Liu? Though Rujia Liu usually sets hard problems for contests (for example, ...
- UVA 11991 Easy Problem from Rujia Liu?（vector map）
Easy Problem from Rujia Liu? Though Rujia Liu usually sets hard problems for contests (for example, ...
- uva 11991 - Easy Problem from Rujia Liu?(STL)
option=com_onlinejudge&Itemid=8&page=show_problem&problem=3142" target="_blank ...
随机推荐
- java读取写入oracle的blob字段工具类
import com.hzunitech.fxgk.sys.model.UtFileData;import com.jfinal.kit.PathKit;import com.jfinal.plugi ...
- MFC如何获取控件相对于窗口的左边，以及鼠标相对于控件的位置
CRect rect; CWnd *pWnd = GetDlgItem(IDC_STATIC_PIC); pWnd->GetWindowRect(&rect); ScreenToClie ...
- C++和Java中的静态Static用法
C++和Java中都有的一个静态关键字Static,可以放在类中的变量或者函数之前,就成了静态变量或者静态函数. 静态变量又分为静态全局变量和静态局部变量,可参见网上大神总结的C++全局变量,局部变量 ...
- mysql语句性能分析
1.开启慢查询 slow_query_log = 1 //开启 slow_query_log_file = mysql_slow_query.log //日志文件位置 long_query_time ...
- html的base标签
提示:请把 <base> 标签排在 <head> 元素中第一个元素的位置,这样 head 区域中其他元素就可以使用 <base> 元素中的信息了. 注释:如果使用了 ...
- POJ--1690 (Your)((Term)((Project)))（字符串处理）
(Your)((Term)((Project))) Time Limit: 1000MS Memory Limit: 10000K Total Submissions: 3353 Accepted: ...
- 解决windows系统的oracle数据库不能启动ora-00119和ora-00130的问题
SQL>startup 报错ora-00119 ora-00130 出现上述错误应该是数据库的监听文件出了问题,修改listener.ora文件: # listener.ora Network ...
- Effective Objective-C 笔记之熟悉OC
1.在一个类的头文件中尽量少引用其他头文件 如果Person.h 引入了EmployeePerson.h,而后续又有其他类如Human.h又引入了Person.h, 那么EmployeePerson. ...
- [py][mx]xadmin详细设置-将app注册到xadmin
首先createsuperuser,创建用户, 然后登陆xadmin. 理解下models的各个字段 复数形式及返回 注册app users/adminx.py 显示字段 users/adminx.p ...
- logstash采集tomcat日志、mysql错误日志
input{ file { path => "/opt/Tomcat7.0.28/logs/*.txt" start_position => "beginni ...