TOJ 1398 POJ 2362 Square DFS

优化了很久，最后发现只要在普通暴力DFS里加一个参数即可避免超时的命运……
最后在TOJ运行时间0'00.00"， POJ是16ms

我的代码用到的思路有：

1. 所有小棍的和要能够整除4

2. 最长的小棍长度不能超过所有小棍和的1/4

3. 按小棍的长度从大到小排序，可以很快的排除一些不可能的情况。比如第三个样例有8个小棍1 7 2 6 4 4 3 5，要拼成4个长度为8的框，排序后第一个是7第二个是6，7+6>8，如果较小的数据在前面，比如1 2 3 4在前面，到第四个才发现不行。
4. 排序后第1个小棍（即最长的）固定在第一个边框。如果排序后第2个小棍跟第1个小棍的和超过所有小棍和的1/4，就把第2个小棍固定在第二个边框。如果第3个小棍跟第2个小棍的和超过所有小棍和的1/4，就把第3个小棍固定在第三个边框。

5. 如果已经拼好了三个边框，那第四个就不需要拼了，剩下的拼成的一定是正方形的第四个边框。

其实还有很多可以优化的想法，比如，如果有某个小棍跟其他小棍拼不成一个边框，那么就肯定输出no；如果某长度的小棍不能参与到拼当前边框的行动中去，那么跟它一样长的就也不行，等等。但是把这些想法都融进代码去不是很轻松的事……

在dfs中添加了参数j后，每次从第j个小棍开始搜索而不是每次从第一个开始就已经可以避免超时了，这是对应的代码，比现在的做法要慢些，在POJ要用63ms。

下面先是没加参数j的代码，提交后超时。然后仅仅加了参数j……
l[25]存放小棍们的长度，M是小棍的个数，tot[1~4]存放拼边框1~4时（第4个其实不用拼）每个边框在拼的过程中的长度。
sum是总的小棍长度，后来被除以4。start作为搜索25个小棍中的可用小棍时，搜索的起始位置。f[25]记录小棍是否已被使用。
flag标志是否已经找到答案。

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

int l[25], M, tot[5], sum, start;
bool f[25], flag;

bool cmp(int a, int b)
{
    return a > b;    
}

void dfs(int d)//d是正在拼的边框，d = 1~4
{
    int i;
    if(d > 3 || flag == 1)//已经拼好三个或已经找到答案
    {
        flag = 1;
        return ;
    }
    else if(tot[d] == sum)
    {
        dfs(d+1);    
    }
    else
    {
        for(i = start; i < M; i ++)
        {
            if(f[i] == 0)
            {
                if(tot[d] + l[i] > sum) continue;
                if(tot[d] + l[i] < sum) 
                {
                    f[i] = 1;
                    tot[d] += l[i];
                    dfs(d); 
                    tot[d] -= l[i];
                    f[i] = 0;   
                }     
                else
                {
                    f[i] = 1;
                    dfs(d + 1);
                    f[i] = 0;    
                }
            }    
        }
    }    
}

int main(){
    int N, i, j, MAX;
    scanf("%d", &N);
    while(N--)
    {
        scanf("%d", &M);
        flag = 1;
        sum = MAX = 0;
        for(i = 0; i < M; i ++)
        {
            scanf("%d", &l[i]);
            MAX = max(l[i], MAX);
            sum += l[i];    
        }    
        if(sum%4 != 0 || MAX > sum/4) printf("no\n");
        else
        {
            memset(f, 0, sizeof(f));
            memset(tot, 0, sizeof(tot));
            sort(l, l + M, cmp);
            sum /= 4;
            flag = 0;
            tot[1] = l[0];
            f[0] = 1;
            start = 1;
            if(l[1] + l[0] > sum)
            {
                tot[2] = l[1];
                start = 2;
                if(l[2] + l[1] > sum)
                {
                    tot[3] = l[2];
                    start = 3;    
                }    
            }
            dfs(1);   
            printf("%s\n", flag?"yes":"no"); 
        }
    }
    //system("pause");
    return 0;
}

然后在dfs中加了一个参数j，于是通过了，至于为什么，我明天再接着想。

Source Code

Problem: 2362		User: yueashuxia
Memory: 684K		Time: 16MS
Language: G++		Result: Accepted

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

int l[25], M, tot[5], sum, start;
bool f[25], flag;

bool cmp(int a, int b)
{
    return a > b;    
}

void dfs(int d, int j)
{
    int i;
    if(d > 3 || flag == 1)
    {
        flag = 1;
        return ;
    }
    else if(tot[d] == sum)
    {
        dfs(d+1, start);    
    }
    else
    {
        for(i = j; i < M; i ++)
        {
            if(f[i] == 0 && tot[d] + l[i] <= sum)
            {
                if(tot[d] + l[i] < sum) 
                {
                    f[i] = 1;
                    tot[d] += l[i];
                    dfs(d, i+1); 
                    tot[d] -= l[i];
                    f[i] = 0;   
                }     
                else
                {
                    f[i] = 1;
                    dfs(d+1, start);
                    f[i] = 0;    
                }
            }    
        }
    }    
}

int main(){
    int N, i, j, MAX;
    scanf("%d", &N);
    while(N--)
    {
        scanf("%d", &M);
        flag = 1;
        sum = MAX = 0;
        for(i = 0; i < M; i ++)
        {
            scanf("%d", &l[i]);
            MAX = max(l[i], MAX);
            sum += l[i];    
        }    
        if(sum%4 != 0 || MAX > sum/4) printf("no\n");
        else
        {
            memset(f, 0, sizeof(f));
            memset(tot, 0, sizeof(tot));
            sort(l, l + M, cmp);
            sum /= 4;
            flag = 0;
            tot[1] = l[0];
            f[0] = 1;
            start = 1;
            if(l[1] + l[0] > sum)
            {
                tot[2] = l[1];
                start = 2;
                if(l[2] + l[1] > sum)
                {
                    tot[3] = l[2];
                    start = 3;    
                }    
            }
            dfs(1, start);   
            printf("%s\n", flag?"yes":"no"); 
        }
    }
    //system("pause");
    return 0;
}

另有两个此题的解题报告还没仔细看
http://blog.csdn.net/zxy_snow/article/details/6194341
http://www.cppblog.com/varg-vikernes/archive/2010/10/04/128562.html