POJ 1179 Polygon

题目大意：

多边形游戏，有N个顶点的多边形，3 <= N <= 50 ，多边形有N条边，每个顶点中有一个数字（可正可负），每条边上或者是“+”号，或者是“*”号。边从1到N编号，首先选择一条边移去，然后进行如下操作：

1 选择一条边E和边E连接着的两个顶点V1，V2。

2 用一个新的顶点代替边E和V1、V2，新顶点的值为V1、V2中的值进行边上代表的操作得来（相加或相乘）

当最后只剩一个顶点，没有边时，游戏结束。现在的任务是编程求出最后的顶点能获得的最大值，以及输出取该最大值时，第一步需移去的边，如果有多条符合条件的边，按编号从小到大输出。

解题思路：

开始WA了两次，原因是没有考虑负负得正的情况，所以不但要记录最大值，也要记录最小值。

定义两个二维数组max_score[51][51]，min_score[51][51]，

max_score[i][j]表示从边i到边j所能得到的最大值，min_score[i][j]表示从边i到边j所能得到的最小值，则

max_score[i][j]=max{(max_score[i][k-1] or min_score[i][k-1]) op[k] (max_score[k+1][j] or min_score[k+1][j])} i<=k<=j

min_score[i][j]=min{(max_score[i][k-1] or min_score[i][k-1]) op[k] (max_score[k+1][j] or min_score[k+1][j])} i<=k<=j

此处要注意当j<i时，k从i取到j会有大于N的情况，此时需要将k减去N。

假设第一次移去第N条边，则max_score[1][N-1]表示移去第N条边后能得到的最大值。

假设第一次移去第1条边，则max_score[2][N]表示移去第1条边后能得到的最大值。

假设第一次移去第2条边，则max_score[3][1]表示移去第1条边后能得到的最大值。

注意max_score[3][1]是从第3条边到第N条边，再到第1条边

移去一条边后还剩N-1条边，所以最后的答案是max_score[i][j]中从i到j有N-1条边的最大值。

若max_score[i][j]的值最大，则移去的边是i-1,i-1为0时改为N

求最大最小值时，如果是加号，则最大值等于两个最大值相加，最小值等于两个最小值相加。

                                如果是乘号，则左操作数可以是最大值或最小值，右操作数也一样，所以四种情况都要求出来，然后再决定四种情况下求出的值的最大值和最小值。

求最大值时要记录全局最大值，作为最后的答案。

#include<iostream>
using namespace std;
int v[51]; //存放点中的数据,下标从1开始 
char op[51]; //存放边,下标从1开始
int max_score[51][51]; //max_score[i][j]表示从边i到边j所能取到的最大值 
int min_score[51][51]; //min_score[i][j]表示从边i到边j所能取到的最小值 
int n;  //边、点的数量 

//计算最大最小值 
void calculate(int max_x, int min_x, char op, int max_y, int min_y, int &max, int &min)
{
	if(op=='t')
	{
		max = max_x + max_y;
		min = min_x + min_y;
	}
	else  //乘法 
	{
		int temp;
		max = min = max_x * max_y;
	  
		temp = max_x * min_y;
		if(temp > max) max=temp;
		if(temp < min) min=temp;
		
		temp = min_x * max_y;
		if(temp > max) max=temp;
		if(temp < min) min=temp;
		
		temp = min_x * min_y;
		if(temp > max) max=temp;
		if(temp < min) min=temp;
	}
}

int getNum(int i) //处理可能的越界问题
{
	if(i>n) i-=n;
	else if(i<1) i += n;
	return i;
}

//使用动态规划找最大值并返回 
int dp()
{
	int i,j,k,len, max_temp, min_temp, max_value, min_value, temp,ans;
	//初始化数组的边界值
	for(i=1; i<=n; i++)
	{
		j=i-1; //j代表i左边的边 
		if(j==0) j=n;
		
		if(op[i]=='t')
		 max_score[i][i] = min_score[i][i] =  v[j] + v[i];
		else
		 max_score[i][i] = min_score[i][i] =  v[j] * v[i];
		
		max_score[i][j] = min_score[i][j] = v[j];
	}
	
	ans=1<<31;
	for(len=2; len<n; len++) //len代表从边i到边j包含多少条边 
	 for(i=1; i<=n; i++) //i代表开始边 
	 {
			j=i+len-1; //j代表结束边
			if(j>n) j-=n;
			//计算max[i][j] min[i][j]的值， max[i][j]=max{d[i][k-1] op[k] d[k+1][j]} i<=k<=j
			k=i;
			calculate(max_score[i][getNum(k-1)], min_score[i][getNum(k-1)], op[k], max_score[getNum(k+1)][j], min_score[getNum(k+1)][j], max_temp, min_temp);
			max_value=max_temp;
			min_value=min_temp;
			while(true)
			{
				k++;
				if(k>n) k-=n;
				calculate(max_score[i][getNum(k-1)], min_score[i][getNum(k-1)], op[k], max_score[getNum(k+1)][j], min_score[getNum(k+1)][j], max_temp, min_temp);
				if(max_temp > max_value) max_value=max_temp;
				if(min_temp < min_value) min_value=min_temp;
				if(k==j) break;
			}
			max_score[i][j]=max_value;
			min_score[i][j]=min_value;
			if(len==n-1 && max_value>ans) ans=max_value;
	 }
	 
	 return ans;
}

int main()
{
	int i,j,ans;
	bool first=true;;
	
	//读入数据 
	cin>>n;
	for(i=1; i<=n; i++)
	{
		cin>>op[i]>>v[i];
	}
	
	ans=dp();
	cout<<ans<<endl; //输出最大值
	//输出取最大值时，第一次移去的边
	for(i=2; i<=n; i++)
	{
		j=i+n-2;
		if(j>n) j -= n;
		
		if(max_score[i][j] == ans)
		{
			if(!first) cout<<" ";
			cout<<i-1;
			first = false;
		}
	}
	if(max_score[1][n-1]==ans)
	{
		 if(!first) cout<<" ";
		 cout<<n;
	}
	cout<<endl;
	
	return 0;
}