POJ 1179 Polygon(DP)

本题一次水过，由此纪念一下。(实际上，我这个年纪做这种题实在很丢人)。

题目链接。大意：给一个多边形，每个顶点有一个值，每个边编号从1到N，边的属性是加或者乘。首先先拆掉一条边，剩下的如下做：选定一条边以及这条边的两个端点（两个数）用新顶点替换（新顶点即：按照这条边的属性（加或乘）算出这两个数的乘积或者和）。到最后剩一个点，也就是一个值。求这些值的最大值输出，并输出此时最先拆掉的是哪条边。

用2个一维数组存放这个多边形，其一存放点，其二存放边(加或者乘)。将这2个数组当作循环队列一样的使用即可穷举去掉的边。需要另外2个数组记录最大值和最小值（因为两个负数相乘为正，所以要记录最小值）。

设maxDp[i][j] (minDp[i][j])为从i到j的多边形的最终值的最大值（最小值），再从1到N枚举多边形长度(j-i)，依次算出长度为1到N的子多边形的最终值。由此自底向上就算出此多边形的最终值的最大值。我的代码如下：

   1: #include <iostream>

   2: #include <algorithm>

   3:  

   4: using namespace std;

   5: const int VERTEX_SIZE = 50;

   6: const long MAX_INT = (1<<15);

   7: const long MIN_INT = -(1<<15);

   8:  

   9: int vertex[VERTEX_SIZE];

  10: char label[VERTEX_SIZE];

  11: long maxDp[VERTEX_SIZE][VERTEX_SIZE];

  12: long minDp[VERTEX_SIZE][VERTEX_SIZE];

  13:  

  14: void init(const int size, const int front)

  15: {

  16:     for (int i=0; i<VERTEX_SIZE; i++)

  17:     {

  18:         for (int j=0; j<VERTEX_SIZE; j++)

  19:         {

  20:             if (j==i)

  21:                 minDp[i][j] = maxDp[i][j] = vertex[i];

  22:             else

  23:             {

  24:                 maxDp[i][j] = MIN_INT;

  25:                 minDp[i][j] = MAX_INT;

  26:             }

  27:         }

  28:     }

  29: }

  30:  

  31: int getRes(const int size, const int front)

  32: {

  33:     int end=(front+size)%size;

  34:     for (int len=1; len<size; len++)

  35:     {

  36:         bool flag=true;

  37:         for (int i=front; flag || (i+len)%size!=end; i=(i+1)%size)

  38:         {

  39:             flag = false;

  40:             int j=(i+len)%size;

  41:             for (int k=i; k!=j; k=(k+1)%size)

  42:             {

  43:                 if (label[(k+1)%size]=='x')

  44:                 {

  45:                     maxDp[i][j] = max(maxDp[i][j], maxDp[i][k]*maxDp[(k+1)%size][j]);

  46:                     maxDp[i][j] = max(maxDp[i][j], minDp[i][k]*minDp[(k+1)%size][j]);

  47:  

  48:                     minDp[i][j] = min(minDp[i][j], maxDp[i][k]*maxDp[(k+1)%size][j]);

  49:                     minDp[i][j] = min(minDp[i][j], maxDp[i][k]*minDp[(k+1)%size][j]);

  50:                     minDp[i][j] = min(minDp[i][j], minDp[i][k]*maxDp[(k+1)%size][j]);

  51:                     minDp[i][j] = min(minDp[i][j], minDp[i][k]*minDp[(k+1)%size][j]);

  52:                 }

  53:                 else if (label[(k+1)%size]=='t')

  54:                 {

  55:                     maxDp[i][j] = max(maxDp[i][j], maxDp[i][k]+maxDp[(k+1)%size][j]);

  56:                     minDp[i][j] = min(minDp[i][j], minDp[i][k]+minDp[(k+1)%size][j]);

  57:                 } 

  58:             }

  59:         } 

  60:     }

  61:  

  62:     return maxDp[front][(front+size-1)%size];

  63: }

  64:  

  65: int main()

  66: {

  67:     int size=0;

  68:     cin >> size;

  69:     for (int i=0; i<size; i++)

  70:         cin >> label[i] >> vertex[i];

  71:     int recordLabel[VERTEX_SIZE]={0};

  72:     int maxNum = MIN_INT;

  73:     for (int i=0; i<size; i++)

  74:     {

  75:         init(size, i);

  76:         recordLabel[i] = getRes(size, i);

  77:         maxNum = max(maxNum, recordLabel[i]);

  78:     }

  79:     cout << maxNum << endl;

  80:     bool first = true;

  81:     for (int i=0; i<size; i++)

  82:     {

  83:         if (maxNum==recordLabel[i] && first)

  84:         {

  85:             cout << (i+1);

  86:             first = false;

  87:             continue;

  88:         }

  89:         if (maxNum==recordLabel[i] && (!first))

  90:         {

  91:             cout << ' ' << (i+1);

  92:             continue;

  93:         }

  94:     }

  95:     cout << endl;

  96:  

  97:     return 0;

  98: }