动态规划问题——多边形游戏

最新推荐文章于 2023-06-03 14:35:44 发布

碳水小王子

最新推荐文章于 2023-06-03 14:35:44 发布

阅读量328

点赞数 1

文章标签：动态规划游戏 c++

本文链接：https://blog.csdn.net/qq_52045638/article/details/130476532

版权

该C++代码实现了一个动态规划算法，用于找出给定整数和运算符序列能组成的最大和最小值。它首先读取用户输入的序列，然后通过复制和初始化序列，计算不同子序列的最大和最小值。算法通过比较不同分割点的加法和乘法操作的结果来确定最优序列。

摘要由CSDN通过智能技术生成

#include<string>
#include<iostream>
using namespace std;
const int maxn = 105 ;

struct CalSeq{ //存储一个计算序列的信息
    string str;
    long long int val;
    void print() {
		cout<<"计算得到的最高分为:";
		printf( " %lld\n",val ) ;
		cout<<"计算顺序为:";
        printf( "%s", str.c_str()) ;
    }
};
bool operator < ( const CalSeq &l , const CalSeq &r ) { // 重载小于运算符
    return l.val < r.val ;
}

int n, val[maxn] ;
char op[maxn] ;
CalSeq dpmax[maxn][maxn], dpmin[maxn][maxn] ;

void reverseStr(string& str) 
{ 
	int n = str.length(); 

	// Swap character starting from two 
	// corners 
	for (int i = 0; i < n / 2; i++) 
		swap(str[i], str[n - i - 1]); 
} 

string getValToString ( long long int x ) { // 数字 x 转化成string类型
    string ret ;
	int i;
    if ( x == 0 ) {
        ret += '0' ;
    }
    else if ( x < 0 ) {
        x= -x ;
		while ( x>0 ) {
        ret +=(x%10)+'0';
        x/=10;
		reverseStr(ret); 
    }
		ret = '-'+ret ;
    }
	else{
    while ( x>0 ) {
        ret +=(x%10)+'0';
        x/=10;
		reverseStr(ret); 
    }
	}
	
    return ret;
}
void Input(){ // 输入序列
	cout<<"多边形定点数:";
    scanf( "%d", &n ) ;
	cout<<"按照顺序输入的整数值和运算符号为:";
    for( int i=0; i<n; i++ ) {
        scanf( "%d", &val[i] ) ;
        while( scanf( "%c", &op[i] ) != EOF ) {
            if ( op[i] == '+' || op[i] == '*' ) break ;
        }
    }
}
void copySeq(){ // 复制序列
    for( int i=0; i<n; i++ ) {
        op[i+n] = op[i] ;
        val[i+n] = val[i] ;
    }
}
void Init(){ // 初始化长度为1的计算序列的信息
    for( int i=0; i<2*n; i++ ) {
        dpmax[i][i].str = dpmin[i][i].str = getValToString(val[i]);
        dpmax[i][i].val = dpmin[i][i].val = val[i] ;
    }
}
long long int calDpmax( int l , int r ) ; // 计算 val[l] 到 val[r] 的所有元素以某种顺序结合的能得到的最大值
long long int calDpmin( int l , int r ) ; // 计算 val[l] 到 val[r] 的所有元素以某种顺序结合的能得到的最小值

int main()
{
    Input() ;
    copySeq() ;
    Init() ;
    calDpmax( 0 , n-1 ) ;
    CalSeq ans = dpmax[0][n-1] ;
    for( int i=1; i<n; i++ ) { // 枚举每一个长度为 n 的连续序列，找到最大值
        calDpmax( i , i+n-1 ) ;
        ans = max( ans, dpmax[i][i+n-1] ) ;
    }
    ans.print();
	system("pause");
    return 0;
}
long long int calDpmax( int l , int r ) {
    if ( r-l+1 > n ) return -1 ; // 长度超过n的没必要计算
    if ( dpmax[l][r].str.length() > 0 ) { // 以前计算过的可以直接记忆化
        return dpmax[l][r].val ;
    }
    int best_k = -1 ;
    long long int best_val ;
    string seql , seqr ;
    for( int k=l; k<r; k++ ) { // 枚举分割点k，即l到r最后的连接点
        if ( op[k] == '+' ) { // '+'
            long long int temp = calDpmax(l,k) + calDpmax(k+1,r) ;
            if ( best_k==-1 || best_val < temp ) {
                best_k = k ;
                best_val = temp ;
            }
        }
        else { // '*'
            long long int temp = calDpmax(l,k)*calDpmax(k+1,r); // max*max
            seql = dpmax[l][k].str;
            seqr = dpmax[k+1][r].str;
            if ( temp < calDpmin(l,k)*calDpmin(k+1,r) ) { // min*min
                temp = dpmin[l][k].val * dpmin[k+1][r].val ;
                seql = dpmin[l][k].str;
                seqr = dpmin[k+1][r].str;
            }
            if ( temp < calDpmin(l,k)*calDpmax(k+1,r) ) { // min*max
                temp = dpmin[l][k].val * dpmax[k+1][r].val ;
                seql = dpmin[l][k].str;
                seqr = dpmax[k+1][r].str;
            }
            if ( temp < calDpmax(l,k)*calDpmin(k+1,r) ) { // max*min
                temp = dpmax[l][k].val * dpmin[k+1][r].val ;
                seql = dpmax[l][k].str;
                seqr = dpmin[k+1][r].str;
            }
            if ( best_k==-1 || best_val < temp ) {
                best_k = k ;
                best_val = temp ;
            }
        }
    }

    if ( op[best_k] == '+' ) {
        dpmax[l][r].val = best_val ;
        dpmax[l][r].str = '(' + dpmax[l][best_k].str + '+' + dpmax[best_k+1][r].str + ')' ;
    }
    else {
        dpmax[l][r].val = best_val ;
        dpmax[l][r].str = seql + '*' + seqr ;
    }
    return best_val;
}
long long int calDpmin( int l , int r ) {
    if ( r-l+1 > n ) return -1 ; // 长度超过n的没必要计算
    if ( dpmin[l][r].str.length() != 0 ) { // 以前计算过的可以直接记忆化
        return dpmin[l][r].val ;
    }
    int best_k = -1 ;
    long long int best_val ;
    string seql , seqr ;
    for( int k=l; k<r; k++ ) { // 枚举分割点k，即l到r最后的连接点
        if ( op[k] == '+' ) { // '+'
            long long int temp = calDpmin(l,k) + calDpmin(k+1,r) ;
            if ( best_k==-1 || best_val > temp ) {
                best_k = k ;
                best_val = temp ;
            }
        }
        else { // '*'
            long long int temp = calDpmax(l,k)*calDpmax(k+1,r); // max*max
            seql = dpmax[l][k].str;
            seqr = dpmax[k+1][r].str;
            if ( temp > calDpmin(l,k)*calDpmin(k+1,r) ) { // min*min
                temp = dpmin[l][k].val * dpmin[k+1][r].val ;
                seql = dpmin[l][k].str;
                seqr = dpmin[k+1][r].str;
            }
            if ( temp > calDpmin(l,k)*calDpmax(k+1,r) ) { // min*max
                temp = dpmin[l][k].val * dpmax[k+1][r].val ;
                seql = dpmin[l][k].str;
                seqr = dpmax[k+1][r].str;
            }
            if ( temp > calDpmax(l,k)*calDpmin(k+1,r) ) { // max*min
                temp = dpmax[l][k].val * dpmin[k+1][r].val ;
                seql = dpmax[l][k].str;
                seqr = dpmin[k+1][r].str;
            }
            if ( best_k==-1 || best_val > temp ) {
                best_k = k ;
                best_val = temp ;
            }
        }
    }
    if ( op[best_k] == '+' ) {
        dpmax[l][r].val = best_val ;
        dpmax[l][r].str = '(' + dpmax[l][best_k].str + op[best_k] + dpmax[best_k+1][r].str + ')' ;
    }
    else {
        dpmax[l][r].val = best_val ;
        dpmax[l][r].str = seql +op[best_k] + seqr ;
    }
    return best_val;
}

运行结果如下