動態規劃--多邊形遊戲

　　

《算法分析與設計》 王曉東

問題描述：

　多邊形遊戲是一個單人玩的遊戲，開始時有一個由n個頂點構成的多邊形。每一個頂點被賦予一個整數值，每條邊被賦予一個運算符「+」或「*」。全部邊依次用整數從1到n編號。

　　遊戲第1步，將一條邊刪除。

　　隨後n-1步按如下方式操做：

　　(1)選擇一條邊E以及由E鏈接着的2個頂點V1和V2；

　　(2)用一個新的頂點取代邊E以及由E鏈接着的2個頂點V1和V2。將由頂點V1和V2的整數值經過邊E上的運算獲得的結果賦予新頂點。

　　最後，全部邊都被刪除，遊戲結束。遊戲的得分就是所剩頂點上的整數值。

　　問題:對於給定的多邊形，計算最高得分。

以下圖：

　　

數據輸入：

 第一行是一個整數N

第二行按照

邊     頂點      邊     頂點     ….     邊     頂點

的順序以此存放了N個頂點和N條邊的標註信息。

 

問題求解：

　　

 　　當把一條邊去除除後，再把它拉直，那麼這個問題就能夠變成一條鏈。那麼就和之前寫的矩陣連乘有幾分的類似，其實咱們最後要求的是這個鏈的表達式算式結果的最大值。因而咱們就能夠想到能夠用數組p[i][j]來表示從點i開始，鏈長爲j的算術表達式的最大值，用v[i]存儲操做數，op[i]存儲操做符。若是這條鏈的最後一次合併運算在op[i+s]處發生(1≤s≤j-1)，則可在op[i+s]處將鏈分割爲2個子鏈p[i][s]和p[i+s][j-s]。彷佛這樣再按照之前解決動態規劃題目時的思路，就能夠解決問題了。   可是，咱們再來考慮一下，因爲有兩種運算符+和x，而且操做數可能存在負數，那麼咱們也必須考慮兩個負數相乘的結果可能比兩個正數要打，因此咱們同時還須要記錄每一個鏈的最大和最小值，而後判斷，若是操做符爲+的話，只須要兩個鏈的最大值相加便可，若是操做符是x的話，那麼必須把各類狀況考慮進來，而後再求出最大值。分析以下：

　　設m1是對子鏈p[i][s]的任意一種合併方式獲得的值，而a和b分別是在全部可能的合併中獲得的最小值和最大值。m2是p[i+s][j-s]的任意一種合併方式獲得的值，而c和d分別是在全部可能的合併中獲得的最小值和最大值。依此定義有a≤m1≤b，c≤m2≤d

　　(1)當op[i+s]='+'時，顯然有a+c≤m≤b+d

　　(2)當op[i+s]='*'時，有min{ac，ad，bc，bd}≤m≤max{ac，ad，bc，bd}

　　換句話說，主鏈的最大值和最小值可由子鏈的最大值和最小值獲得。

因而我就用數組chain_value[i][j][2]來存儲鏈的節點， chain_value[i][j][0]表示鏈的最大值，chain_value[i][j][1]表示鏈的最小值。

 

代碼實現：

#include <stdio.h>
#include <stdlib.h>

#define MAX_POINT 20
int chain_value[MAX_POINT][MAX_POINT][2];  //chain[i][j][0]表示從v[i]節點開始，邊長爲j的鏈的最大值
                                           //chain[i][j][1]表示從v[i]節點開始，邊長爲j的鏈的最小值
int n,*v;
char *op;

int get_max_sum();
void chain_max(int start, int len, int k);
void get_max_min(int a, int b, int c, int d, int start, int index, int len);

int main()
{
    int i;
    char ch;

    scanf("%d",&n);
    v = (int *)malloc(n*sizeof(int));
    op = (char *)malloc(n*sizeof(char));

    ch = getchar();                    //數據輸入
    for (i = 0; i < n; i++)
    {
        scanf("%c",&op[i]);
        ch = getchar();
        scanf("%d",&v[i]);
        ch = getchar();
    }

    printf("MAX:%d\n",get_max_sum());

    return 0;
}//main


int get_max_sum()
{
    int i,k,start,max,tmp,len;

    for (i = 0; i < n; i++)
    {
        chain_value[i][0][0] = v[i];        //鏈長爲0，即單個點的值
        chain_value[i][0][1] = v[i];
    }
    
    for (len = 1; len < n; len++)  //控制鏈的長度，
    {
        for (start = 0; start < n ; start++)        //起點start配合鏈長，就能夠得出除去某條邊的效果
        {
            chain_value[start][len][0] = -9999;  
            chain_value[start][len][1] = 9999;
            for (k = 0; k < len; k++)
            {
                chain_max(start,len,k);
            }
        }
    }

    max = chain_value[0][n-1][0];            //最終的最大值
    for (start = 1; start < n; start++)
    {
        tmp =  chain_value[start][n-1][0];
        max = max > tmp ? max : tmp;
    }
    return max;
}

void chain_max( int start, int len, int k)
{
    int index,a,b,c,d;  //a<= m1 <= b  c<= m2 <=d

    index = (start+k+1)%n;  //表示符號(op)或者符號後面的操做數的下標
    
    a = chain_value[start][k][1];
    b = chain_value[start][k][0];
    c = chain_value[index][len-k-1][1];
    d = chain_value[index][len-k-1][0];
    
    get_max_min(a,b,c,d,start,index,len);

}

void get_max_min(int a, int b, int c, int d, int start, int index, int len)
{    
    int max_max,min_min,max_min,min_max;
    int max,min;

    max = chain_value[start][len][0];
    min = chain_value[start][len][1];

    if ('+' == op[index])
    { 
        max = max > (b + d) ? max : (b + d);
        min = min < (a + c) ? min : (a + c);
    }
    else if ('x' == op[index])
    {
        max_max = b * d;
        min_min = a * c;
        max_min = b * c;
        min_max = a * d;
                
        max = max > max_max ? max :max_max;
        max = max > min_min ? max : min_min;
        max = max > max_min ? max : max_min;
        max = max > min_max ? max : min_max;

        min = min < max_max ? min :max_max;
        min = min < min_min ? min : min_min;
        min = min < max_min ? min : max_min;
        min = min < min_max ? min : min_max;
    }

    chain_value[start][len][0] = max;  
    chain_value[start][len][1] = min;
}

//2013/9/14 10:13