题目491：幸运三角形

题目链接：

http://acm.nyist.net/JudgeOnline/problem.php?pid=491

描述

话说有这么一个图形，只有两种符号组成（‘+’或者‘-’），图形的最上层有n个符号，往下个数依次减一，形成倒置的金字塔形状，除第一层外（第一层为所有可能情况），每层形状都由上层决定，相邻的符号相同，则下层的符号为‘+’，反之，为‘-’;如下图所示（n = 3 时的两种情况)：

如果图中的两种符号个数相同，那这个三角形就是幸运三角形，如上图中的图（2）.

输入

有多组测试数据（少于20组）。
每行含一个整数n（0<n<20)。

输出

输出相应的幸运三角形个数。

样例输入

3 4

样例输出

4 6

算法思想：

这道题是一道深度遍历的题目，但是写了很久都没有通过，超时，后来参考网上代码写了根据深度搜索得出的答案写了一个记录数组，然后直接根据记录数组输出答案就可以。
深搜很简单，递归，但是这道题可以有减支法来减小搜索的规模，单输入的数生成的三角形中的符号数为奇数时，一定不能构成运行三角形，直接输出0。

源代码

/*
幸运三角形(NYOJ:491)
*/
#include <iostream>
#include <cstdio>
using namespace std;
int a[21];
int n, ans;
//判断是否为运行三角形
bool judge()
{
    int t0, t1;
    t0 = t1 = 0;
    //生成所有的行
    for (int end = n; end >= 1; end--)
    {
        for (int j = 1; j <= end; j++)
        {
            if (a[j] == 1)
                t1++;
            else
                t0++;
            //减支法，当t0（代表"-"数目，"-"用0表示）的数目或者t1的数目大于总数的一半时，表示不是运行三角形，返回flase。
            if (t0 > ((n * (n + 1)) >> 1) || t1 > ((n * (n + 1)) >> 1))
                return false;
            //当第一行的符号数大于1时，生成下一行的符号，因为数组的前部分已经计算过，故可以复用。
            if (j > 1)
            {
                if (a[j] == a[j - 1])
                    a[j - 1] = 1;
                else
                    a[j - 1] = 0;
            }
        }
    }
    if (t0 == t1)
        return true;
    else
        return false;

}
//深度搜索
void dfs(int num)
{
    //返回条件为num == n + 1
    if (num == n + 1)
    {   
        if (judge())
            ans++;
        return;
    }
    a[num] = 1;
    dfs(num + 1);
    a[num] = 0;
    dfs(num + 1);
}
int main()
{
    while (~scanf("%d",&n))
    {
        if ((((n + 1) * n) >> 1) & 1)
        {
            printf("0\n");
            continue;
        }
        ans = 0;
        dfs(1);
        printf("%d\n",ans);
    }
    return 0;
}

记录数组法源代码

#include <iostream>
using namespace std;
int main()
{
    int n;
    int ans[21] = { 0, 0, 0, 4, 6, 0, 0, 12, 40, 0, 0, 171, 410, 0, 0, 1896, 5160, 0, 0, 32757, 59984 };
    while (cin >> n)
    {
        cout << ans[n] << endl;
    }
    return 0;
}

最优源代码

回溯法，最优代码，使用边计算边回溯。

#include"iostream"
#include<cstring>
#include<stdio.h>
#include<time.h>
using namespace std;
typedef unsigned char uchar;

char cc[2]={'+','-'};   //便于输出
int n,                  //第一行符号总数
    half,               //全部符号总数一半
    counter;            //1计数，即“-”号计数

char **p;               //符号存储空间    
long sum;               //符合条件的三角形计数

//t，第一行第t个符号
void Backtrace(int t)
{
    int i, j;

    if( t > n )
        sum++;
    else
       for(i=0; i<2; ++i)
       {
            p[1][t] = i;//第一行第t个符号
            counter += i;       //“-”号统计
            for(j=2; j<=t; ++j) //当第一行符号>=2时，可以运算出下面行的某些符号
            {
                p[j][t-j+1] = p[j-1][t-j+1]^p[j-1][t-j+2];//通过异或运算下行符号
                counter += p[j][t-j+1];                     
            }
            if( (counter <= half) && ( t*(t+1)/2 - counter <= half) )//若符号统计未超过半数，并且另一种符号也未超过半数
                Backtrace(t+1);         //在第一行增加下一个符号   
            //回溯，判断另一种符号情况
            for(j=2; j<=t; ++j) 
                counter -= p[j][t-j+1];      
            counter -= i;
       }
}

int main()
{  
    while(scanf("%d", &n) != EOF)
    {
    counter = 0;
    sum = 0;
    half = n*(n+1)/2;

    if( half%2 == 0 )
    {//总数须为偶数，若为奇数则无解
        half /= 2;
        p = new char *[n+1];
        for(int i=0; i<=n; ++i)
        {
           p[i] = new char[n+1];
           memset(p[i], 0, sizeof(char)*(n+1));
        }   
        Backtrace(1);
    }   
    printf("%d\n", sum);}
    return 0;
}