pku ppt some problem

The Triangle  http://poj.org/problem?id=1163

暴力dfs的话，每个节点有两条路可以走，那么n个节点复杂度就是2^n  n=100  超时   dp来做 就优化成 n^2

记忆化搜索，就能优化成n^2 因为一个点最多算一次，以后会直接返回dp i j 。 dp i j 表示这个位置能获得最大值。最后一行就是a i j  ，其他行都可以由下面两条路取最大值。

#include<cstdio>
#include<cstring>
#include<algorithm>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
const int M=128;
int n,a[M][M],dp[M][M];
int dfs(int i,int j){
    if(~dp[i][j]) return dp[i][j];
    if(i==n) dp[i][j]=a[i][j];
    else     dp[i][j]=max(dfs(i+1,j),dfs(i+1,j+1))+a[i][j];
    return dp[i][j];
}
int main(){
    while(~scanf("%d",&n)){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=i;j++){
                scanf("%d",&a[i][j]);
            }
        }
        mt(dp,-1);
        printf("%d
",dfs(1,1));
    }
    return 0;
}

自底向上的推法，那dp i j 就表示i j 这个位置能获得的最大值， 然后dp i j 可以推向两个状态，分别是 dp i-1 j 和 dp i-1 j-1.  这是用当前状态去推能到达的所有状态的写法。

#include<cstdio>
#include<cstring>
#include<algorithm>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
const int M=128;
int a[M][M],dp[M][M];
int main(){
    int n;
    while(~scanf("%d",&n)){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=i;j++){
                scanf("%d",&a[i][j]);
            }
        }
        mt(dp,0);
        for(int i=n+1;i>=1;i--){
            for(int j=1;j<=n;j++){
                dp[i-1][j]=max(dp[i-1][j],dp[i][j]+a[i-1][j]);
                dp[i-1][j-1]=max(dp[i-1][j-1],dp[i][j]+a[i-1][j-1]);
            }
        }
        printf("%d
",dp[1][1]);
    }
    return 0;
}

 这是用所有能到达的状态推当前状态的写法，并且空间优化了一下，省去了输入的数组。

#include<cstdio>
#include<algorithm>
using namespace std;
const int M=128;
int dp[M][M];
int main(){
    int n;
    while(~scanf("%d",&n)){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=i;j++){
                scanf("%d",&dp[i][j]);
            }
        }
        for(int i=n-1;i>=1;i--){
            for(int j=1;j<=i;j++){
                dp[i][j]=max(dp[i+1][j],dp[i+1][j+1])+dp[i][j];
            }
        }
        printf("%d
",dp[1][1]);
    }
    return 0;
}

最长上升子序列  http://bailian.openjudge.cn/practice/2757/

记忆化搜索

#include<cstdio>
#include<algorithm>
using namespace std;
const int M=1024;
int n,a[M],dp[M];
int dfs(int i){
    if(~dp[i]) return dp[i];
    dp[i]=1;
    for(int j=i+1;j<=n;j++){
        if(a[i]<a[j]){
            dp[i]=max(dp[i],dfs(j)+1);
        }
    }
    return dp[i];
}
int main(){
    while(~scanf("%d",&n)){
        for(int i=1;i<=n;i++){
            scanf("%d",&a[i]);
            dp[i]=-1;
        }
        int ans=0;
        for(int i=1;i<=n;i++){
            ans=max(ans,dfs(i));
        }
        printf("%d
",ans);
    }
    return 0;
}

 用dp【i】表示以 i 为结尾的最长上升子序列的长度，可以得到它可以由前面所有值比他小的dp +1推过来。这是当前状态由其他所有能推过来的状态更新的写法。

#include<cstdio>
#include<algorithm>
using namespace std;
const int M=1024;
int a[M],dp[M];
int main(){
    int n;
    while(~scanf("%d",&n)){
        for(int i=1;i<=n;i++){
            scanf("%d",&a[i]);
            dp[i]=1;
        }
        int ans=0;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=i;j++){
                if(a[j]<a[i]){
                    dp[i]=max(dp[i],dp[j]+1);
                }
            }
            ans=max(ans,dp[i]);
        }
        printf("%d
",ans);
    }
    return 0;
}

 还是用dp【i】表示以 i 为结尾的最长上升子序列的长度，由当前状态去更新其他所有能更新的状态的写法。

#include<cstdio>
#include<algorithm>
using namespace std;
const int M=1024;
int a[M],dp[M];
int main(){
    int n;
    while(~scanf("%d",&n)){
        for(int i=1;i<=n;i++){
            scanf("%d",&a[i]);
            dp[i]=1;
        }
        for(int i=1;i<=n;i++){
            for(int j=i+1;j<=n;j++){
                if(a[i]<a[j]){
                    dp[j]=max(dp[j],dp[i]+1);
                }
            }
        }
        int ans=0;
        for(int i=1;i<=n;i++){
            ans=max(ans,dp[i]);
        }
        printf("%d
",ans);
    }
    return 0;
}

Common Subsequence http://poj.org/problem?id=1458

用dp i j 表示a串以 i 结尾  b串 以 j 结尾的最长公共子序列长度，这个是当前状态通过其他所有状态推来的写法。

#include<cstdio>
#include<cstring>
#include<algorithm>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
const int M=512;
char a[M],b[M];
int dp[M][M];
int main(){
    while(~scanf("%s%s",a,b)){
        mt(dp,0);
        int n=strlen(a);
        int m=strlen(b);
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                if(a[i-1]==b[j-1]){
                    dp[i][j]=max(dp[i][j],dp[i-1][j-1]+1);
                }
                else{
                    dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
                }
            }
        }
        printf("%d
",dp[n][m]);
    }
    return 0;
}

2755:神奇的口袋 http://bailian.openjudge.cn/practice/2755/

二进制枚举，暴力。

#include<cstdio>
const int M=32;
int a[M];
int main(){
    int n;
    while(~scanf("%d",&n)){
        for(int i=0;i<n;i++){
            scanf("%d",&a[i]);
        }
        int all=1<<n,ans=0;
        for(int i=0;i<all;i++){
            int sum=0;
            for(int j=0;j<n;j++){
                if((i>>j)&1) sum+=a[j];
            }
            if(sum==40) ans++;
        }
        printf("%d
",ans);
    }
    return 0;
}

 dfs枚举，暴力

#include<cstdio>
const int M=32;
int a[M],ans,n;
bool use[M];
void dfs(int t){
    if(t==n){
        int sum=0;
        for(int i=0;i<n;i++){
            if(use[i]) sum+=a[i];
        }
        if(sum==40) ans++;
        return ;
    }
    use[t]=true;
    dfs(t+1);
    use[t]=false;
    dfs(t+1);
}
int main(){
    while(~scanf("%d",&n)){
        for(int i=0;i<n;i++){
            scanf("%d",&a[i]);
        }
        ans=0;
        dfs(0);
        printf("%d
",ans);
    }
    return 0;
}

 dfs直接找解，递归，不用递归sum，k-1，用了递归sum-ak，k-1 

#include<cstdio>
int a[32];
int dfs(int sum,int k){///return 前k个物品选和为sum的情况
    if(sum==0) return 1;
    if(k<=0) return 0;
    return dfs(sum,k-1)+dfs(sum-a[k],k-1);
}
int main(){
    int n;
    while(~scanf("%d",&n)){
        for(int i=1;i<=n;i++){
            scanf("%d",&a[i]);
        }
        printf("%d
",dfs(40,n));
    }
    return 0;
}

 dp递推的找解，定义方式和上面一种一样，dp i j 表示前 i 个 和为 j 的情况，这个是由选和不选两种推出两个转移方程。

#include<cstdio>
#include<cstring>
#define mt(a,b) memset(a,b,sizeof(a))
int a[32];
int dp[32][64];
int main(){
    int n;
    while(~scanf("%d",&n)){
        for(int i=1;i<=n;i++){
            scanf("%d",&a[i]);
        }
        mt(dp,0);
        dp[0][0]=1;
        for(int i=1;i<=n;i++){
            for(int j=0;j<=40;j++){
                dp[i][j]+=dp[i-1][j];
                if(j+a[i]<=40)
                dp[i][j+a[i]]+=dp[i-1][j];
            }
        }
        printf("%d
",dp[n][40]);
    }
    return 0;
}

 与上一dp相同，空间少了一维，我们只需知道某个和能达到的次数，所以输入一个个去更新所有的情况就行。这是由当前状态推向下一状态的写法。

#include<cstdio>
#include<cstring>
#define mt(a,b) memset(a,b,sizeof(a))
int dp[64];
int main(){
    int n,a;
    while(~scanf("%d",&n)){
        mt(dp,0);
        for(int i=1;i<=n;i++){
            scanf("%d",&a);
            for(int j=40;j>=1;j--){
                if(dp[j]&&j+a<=40){
                    dp[j+a]+=dp[j];
                }
            }
            dp[a]++;
        }
        printf("%d
",dp[40]);
    }
    return 0;
}

end