動態規划--多邊形游戲

　　

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

問題描述：

　多邊形游戲是一個單人玩的游戲，開始時有一個由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