證明 poj 1014 模數最佳化剪枝，部分遞迴 存在錯誤

標籤：遞迴   最佳化   poj   

做了這道題目，我才發現一道題即便可行，但是正確性也不一定。多數由於題目資料太弱。

poj 1014 Dividing

題目大意：有6堆石頭，權重分別為1 2 3 4 5 6，要求輸入 每堆個數 ，求是否可以平分石頭使得兩堆價值相同。

網上對這道題的做法就兩種，其中有錯誤的版本，卻也可以AC。起初這讓我等菜鳥感慨代碼的簡潔，但無法得出正確性的證明

接下來就對兩種方法的錯誤性進行證明。

1.多重背包

#include <map>#include<string>#include <iostream>#include<stack>#include<algorithm>#include <math.h>using namespace std;#define MAXN 100+60000int v[MAXN];int a[MAXN/3];int b[7] = {1, 60, 30, 20, 15, 12, 10};int N,T,n,sum;/*int direct[4][2]={-1,0,1,0,0,-1,0,1}; int dp[210][210][210];*/int max(int a,int b){return a>b?a:b;}int main(){int i,j,k,flag,casenum;casenum=0;while(1){casenum++;memset(v,0,sizeof(v));flag=0;sum=0;n=0;for(i=0;i<6;i++){scanf("%d",&k);if(k)flag=1;k=k%b[i+1];sum+=k*(i+1);for(j=1;j<=k;j++)a[n++]=i+1;}if(flag==0)break;if(sum&1){printf("Collection #%d:\nCan't be divided.\n\n",casenum);continue;}flag=0;sum/=2;v[0]=1;for(i=0;i<n;i++){for(j=sum;j>=a[i];j--){v[j]+= v[j-a[i]];if(v[sum]){flag=1;break;}if(flag)break;}}if(flag)printf("Collection #%d:\nCan be divided.\n\n",casenum);elseprintf("Collection #%d:\nCan't be divided.\n\n",casenum);}return 0;}

狀態定義的是有幾種方法可以轉到這裡來

k=k%b[i+1];

這句是一種最佳化，起初看到，覺得很神奇，但並不理解為什麼可以這樣做。

後來證明是錯誤的，證明如下：

模數最佳化是錯誤的，下面證明最佳化一堆的情況
1.1a+2b+3c+4d+5e+6f
2.60*m*t+     1a+2b+3c+4d+5e+6f（t是某堆石子的個數,m是某堆石子的權重）
證明最佳化正確即證明1 是 2 式是充分必要條件
當1成立時候，自然得到2成立（60可以分到兩堆）
當2成立有兩種情況，
第一種情況，2可分，1的部分本身可分，那麼60*m*t 這部分本來分掉就好
第二種情況，2可分，1的部分本身不可分，需要將60*m*t這部分拆解分到兩人才可行
由此得證將某個拆分掉是不可行的，但是不排除每堆都最佳化會遇到碰巧可行的情況
最後舉個例子給大家
1. 0 0 0 0 66 5 -> 0 0 0 0 6 5   ture
2. 60 0 0 0 0 1 -> 0 0 0 0 0 1   fault

最佳化還是用2進位的方法最佳化吧（1,2,4,...,2^(k-1),n[i]-2^k+1，且k是滿足n[i]-2^k+1>0的最大整數。例如，如果n[i]為13，就將這種物品分成係數分別為1,2,4,6的四件物品）

1. 為何網上有些轉移方程為v[i][j]=max(v[i-1][j],v[j-a[i]]+a[i])? 
2. 答：可以看到j-a[i]表明與a[i]互補的狀態，其實為j，從所有的J角度來看，並未改變，這是v[0]=0 

2. dfs版本（轉載於大牛Blog）

//Memory Time //452K 0MS /*DFS*/#include<iostream>using namespace std;int n[7];  //價值為i的物品的個數int SumValue;  //物品總價值int HalfValue;  //物品平分價值bool flag;    //標記是否能平分SumValuevoid DFS(int value,int pre){if(flag)return;if(value==HalfValue){flag=true;return;}for(int i=pre;i>=1;i--){if(n[i]){if(value+i<=HalfValue){n[i]--;DFS(value+i,i);if(flag)break;}}}return;}int main(int i){int test=1;while(cin>>n[1]>>n[2]>>n[3]>>n[4]>>n[5]>>n[6]){SumValue=0;  //物品總價值for(i=1;i<=6;i++)SumValue+=i*n[i];if(SumValue==0)break;if(SumValue%2)    //sum為奇數，無法平分{cout<<"Collection #"<<test++<<':'<<endl;cout<<"Can't be divided."<<endl<<endl;    //注意有空行continue;}HalfValue=SumValue/2;flag=false;DFS(0,6);if(flag){cout<<"Collection #"<<test++<<':'<<endl;cout<<"Can be divided."<<endl<<endl;continue;}else{cout<<"Collection #"<<test++<<':'<<endl;cout<<"Can't be divided."<<endl<<endl;continue;}}return 0;}

這個版本dfs寫的很好，其中這個深度優先有兩個優點值得思量

1.為什麼沒有回溯，而是直接減去了數量n[i]--;

答：兩個人選擇，必然是將這部分分為兩份，如果不選擇到最接近的數字，那剩餘的則是更接近的

2.從大到小選擇？

答：可能有多個小的可以用一個大的數字直接替換掉

----------------------------------------------------------------------------------------------------------------------------------

但是存在問題。

其本質是使用了貪心的策略，但無法滿足有些“跳躍”的要求

eg: 0 0 3 0 3 1  需要選取的數字是不連續的，其實還要有回溯的。

避免這個問題可以用這個版本

void divide(int cur_value, int cur_index)  {          // set break point          if (flag)                  return;          if (cur_value == half_value)          {                  flag = true;                  return;          }          if (cur_value > half_value || cur_index >= max_index)                  return;          divide(cur_value+array[cur_index], cur_index+1);          divide(cur_value, cur_index+1);  }  

看來在學習的過程中還是要慎行慎信