POJ1014 解题报告(DFS)

题目在此：http://poj.org/problem?id=1014

　　要看清题意呢，题中要求输入的是价值分别为1,2,3,4,5,6的大理石的个数，而不是6块价值为输入数字的大理石！选这个题主要想练习一下深搜。在网上看到了一段代码，深搜时使用了贪心算法虽然可以AC但是有很大的漏洞：

　　如测试数据（0 0 3 0 3 1）便会出现错误：

　  搜索时候会选中：价值为6,5,3的各一个进而判断出不可以分割。但是正确的分割方式应该是6+3+3+3=15。

这个是网上有漏洞的代码：

 #include<iostream>
 using namespace std;  

 int amount[] = {};
 int half_value = ;
 int flag = ;  

 void DFS(int value, int pre){  

     if(value == half_value){
         flag = ;
         return;
     }  

     if(flag == ){  //这个可以去掉的啊！
         return;
     }  

     int i = ;
     for(i = pre; i > ; i--){
         if(amount[i]){
             if(i + value <= half_value){
                 amount[i]--;
                 DFS(i + value, i);  

                 if(flag == ){  //不可少的，感受其作用,让递归栈中所有DFS结束
                     return;
                 }
             }
         }
     }
 }  

 int main(){  

     int testcase = ;
     while(true){
         flag = ;
         int totalvalue = ;
         int N = ;
         int i = ;
         while(i <= N){
             cin >> amount[i];
             totalvalue += amount[i] * i;
             i++;
         }  

         if(!amount[] && !amount[] && !amount[] && !amount[] && !amount[] && !amount[]){
             break;
         }  

         printf("Collection #%d:\n", testcase++);
         if(totalvalue %  != ){
             cout << "Can't be divided." << endl << endl;
             continue;
         }  

         half_value = totalvalue / ;
         DFS(, );        

         if(flag){
             cout << "Can be divided." << endl;
         } else {
             cout << "Can't be divided." << endl;
         }
         cout << endl;
     }
     return ;
 }  

有漏洞的代码

　　为了解决这个问题，在判定不能分割之前又加入了一个循环，即从价值为5,4...1的大理石开始深搜，这样就避免了以上代码的漏洞。因为贪心算法基本解决了大部分的情况，故这个循环不会引起超时。以下是修改过的代码：

#include<iostream>
#include <string.h>
#include<stdio.h>
using namespace std;

int amount[] = {  };
int temp_amount[] = {  };//存下原始输入值
int half_value = ;
int flag = ;

void DFS(int value, int pre)
{
    if (value == half_value)
    {
        flag = ;
        return;
    }

    int i = ;
    for (i = pre; i > ; i--)
    {
        if (amount[i]) {
            if (i + value <= half_value)
            {
                amount[i]--;
                DFS(i + value, i);

                if (flag == )
                {
                    return;
                }
            }
        }
    }

}
int main() {

    int testcase = ;
    while (true)
    {
        flag = ;
        int totalvalue = ;
        int N = ;
        int i = ;
        while (i <= N)
        {
            cin >> temp_amount[i];
            totalvalue += temp_amount[i] * i;
            i++;
        }

        if (!temp_amount[] && !temp_amount[] && !temp_amount[] && !temp_amount[] && !temp_amount[] && !temp_amount[])
        {
            break;
        }
        printf("Collection #%d:\n", testcase++);
        if (totalvalue %  != )
        {
            cout << "Can't be divided." << endl << endl;
            continue;
        }
        half_value = totalvalue / ;

        memcpy(amount, temp_amount,  * sizeof(int));
        DFS(, );

        if (flag)
            cout << "Can be divided." << endl;

        else
        {
            for (int m = ; m >= ; m--)
            {
                if (!flag)
                {
                    memcpy(amount, temp_amount,  * sizeof(int));//因为amount数组已经被操作，故需要恢复
                    DFS(, m);
                }
            }
            if (!flag)
                cout << "Can't be divided." << endl;
            else
                cout << "Can be divided." << endl;
        }
        cout << endl;
    }
    return ;
}

（以后再进行补充呃）