hrbeu 哈工程 Max

先来骂街一下………………这个OJ太神了，搞死我了，好像一定要初始化某个数组还是怎么样，至今搞不明白，我还特意搞了很多个初始化，总之有初始化就通过，没有就得吃WA，问题是那个初始化时没有必要的……………………

说说算法，就是和矩阵链乘法的DP是一模一样的，用a[N]来记录n个数字,op[N]记录操作符,下标是1到N，op[i]表示a[i]后面跟的操作符，所以op[n]是没有的，赋值为"&"做个标记；

如果整个表达式都是正数的话，那么很容易处理，但是数字有些是负数，我们来考虑这种情况，表达式的两部分都是负数的话相乘为正数，有可能比只用正数求的结果还大。但是我们应该使两个负数都尽量小（绝对值尽量大），才能使结果尽可能大。所以这个DP除了要记录某个状态下的最大值之外，还要记录这个状态下的最小值，所以其实是同时求最大最小值。

A[i][j]表示第i个数字到第j个数字进行运算得到的最大值 ， B[i][j]表示第i个数字到第j个数字进行运算得到的最大值

目标状态就是A[1][n]

然后就好像矩阵链乘法那样去分割,但是有四种情况

s1=A[i][k]  op[k]  A[k+1][j]

s2=A[i][k]  op[k]  B[k+1][j]

s3=B[i][k]  op[k]  A[k+1][j]

s4=B[i][k]  op[k]  B[k+1][j]

易知  i<=k<j

其实就是枚举了四种可能的运算

A[i][j]=max{ s1 ,s2 ,s3 ,s4}

B[i][j]=min{  s1 ,s2 ,s3 ,s4}

 

然后就来看看那个蛋疼的代码吧………………

#include <stdio.h>
#include <string.h>
#include <stdlib.h>   //少了这个也会WA，应该是OJ的问题，有人解释一下吗
#define INF 1000000000
#define MAXN 110
int a[MAXN]; 
char op[MAXN];
int  A[MAXN][MAXN],B[MAXN][MAXN];
int n;

int max(int p , int q)
{ if(p>q) return p; else return q;}

int min(int p , int q)
{ if(p<q) return p; else return q;}

void input()
{
        int i;
        for(i=1; i<n; i++)
        {
                scanf("%d %c",&a[i],&op[i]); 
        }
        scanf("%d",&a[n]); op[n]='&';
/*
        printf("a数组 ");
        for(i=1; i<=n; i++) printf("%d ",a[i]);  printf("\n");
        printf("op数组 ");
        for(i=1; i<=n; i++) printf("%c ",op[i]);  printf("\n");
*/
}
int calculate(int p , char c , int q)
{
        if(c=='+')  return p+q;
        else if(c=='*')      return p*q; 
}
void DP()
{
        int i,j,k,l;
        int MAX,MIN,s1,s2,s3,s4;
        
//      memset(A, 0, sizeof(A));   
//      memset(B, 0, sizeof(A));
//      for(i=1; i<=n; i++) 
//              for(j=1; j<=n; j++)  
//                      A[i][j]=-INF , B[i][j]=INF;
    
      //尝试了两种初始化一种清0一种全部赋值为正，负无穷，都能AC，没有的话就吃WA，实际上这个初始化没必要
        for(i=1; i<=n; i++)  A[i][i]=B[i][i]=a[i];

        for(l=2; l<=n; l++)  //长度其实是指表达式中有多少个数字，至少要有两个，最多n个
                for(i=1; i<=n-l+1; i++)
                {
                        j=i+l-1;
　　　　　　　　　　　　　　A[i][j]=-INF; B[i][j]=INF;   //在这里初始化也能AC………………
                        MAX=-INF; MIN=INF;  
                        for(k=i; k<j; k++)
                        {

                                s1=calculate(A[i][k] , op[k] , A[k+1][j]);
                                s2=calculate(A[i][k] , op[k] , B[k+1][j]);
                                s3=calculate(B[i][k] , op[k] , A[k+1][j]);
                                s4=calculate(B[i][k] , op[k] , B[k+1][j]);
                        
                                MAX=max(MAX,s1);
                                MAX=max(MAX,s2);
                                MAX=max(MAX,s3);
                                MAX=max(MAX,s4); 

                                MIN=min(MIN,s1);
                                MIN=min(MIN,s2);
                                MIN=min(MIN,s3);
                                MIN=min(MIN,s4);
                        }
                   //   A[i][j]=-INF;  B[i][j]=INF;   //在这里初始化也能AC………………
                        A[i][j]=MAX;
                        B[i][j]=MIN;
                }
/*
        for(l=1; l<=n; l++)
                for(i=1; i<=n-l+1; i++)
                {
                        j=i+l-1;
                        printf("A[%d][%d]=%d\n",i,j,A[i][j]);
                        printf("B[%d][%d]=%d\n",i,j,B[i][j]);
                }
*/
        printf("%d\n",A[1][n]);
}
int main()
{
        while(scanf("%d",&n)!=EOF)
        {
                input();
                DP();
        }
        return 0;
}

转载于:https://www.cnblogs.com/scau20110726/archive/2012/10/19/2731664.html