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=;
 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+,j),dfs(i+,j+))+a[i][j];
     return dp[i][j];
 }
 int main(){
     while(~scanf("%d",&n)){
         for(int i=;i<=n;i++){
             for(int j=;j<=i;j++){
                 scanf("%d",&a[i][j]);
             }
         }
         mt(dp,-);
         printf("%d\n",dfs(,));
     }
     return ;
 }

自底向上的推法，那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=;
 int a[M][M],dp[M][M];
 int main(){
     int n;
     while(~scanf("%d",&n)){
         for(int i=;i<=n;i++){
             for(int j=;j<=i;j++){
                 scanf("%d",&a[i][j]);
             }
         }
         mt(dp,);
         for(int i=n+;i>=;i--){
             for(int j=;j<=n;j++){
                 dp[i-][j]=max(dp[i-][j],dp[i][j]+a[i-][j]);
                 dp[i-][j-]=max(dp[i-][j-],dp[i][j]+a[i-][j-]);
             }
         }
         printf("%d\n",dp[][]);
     }
     return ;
 }

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

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

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

记忆化搜索

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

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

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

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

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

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=;
 char a[M],b[M];
 int dp[M][M];
 int main(){
     while(~scanf("%s%s",a,b)){
         mt(dp,);
         int n=strlen(a);
         int m=strlen(b);
         for(int i=;i<=n;i++){
             for(int j=;j<=m;j++){
                 if(a[i-]==b[j-]){
                     dp[i][j]=max(dp[i][j],dp[i-][j-]+);
                 }
                 else{
                     dp[i][j]=max(dp[i-][j],dp[i][j-]);
                 }
             }
         }
         printf("%d\n",dp[n][m]);
     }
     return ;
 }

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

二进制枚举，暴力。

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

dfs枚举，暴力

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

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

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

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

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

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

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

end