(2/3/4)-D Sqr/Rects/Cubes/Boxes?

Description

Problem J

(2/3/4)-D Sqr/Rects/Cubes/Boxes?

Input: standard input

Output: standard output

Time Limit: 2 seconds

     

You can see a (4x4) grid below. Can you tell me how many squares and rectangles are hidden there? You can assume that squares are not rectangles. Perhaps one can count it by hand but can you count it for a (100x100) grid or a (10000x10000) grid. Can you do it for higher dimensions? That is can you count how many cubes or boxes of different size are there in a (10x10x10) sized cube or how many hyper-cubes or hyper-boxes of different size are there in a four-dimensional (5x5x5x5) sized hypercube. Remember that your program needs to be very efficient. You can assume that squares are not rectangles, cubes are not boxes and hyper-cubes are not hyper-boxes. 

     

Fig: A 4x4 Grid	Fig: A 4x4x4 Cube

     

       

Input

The input contains one integer N (0<=N<=100) in each line, which is the length of one side of the grid or cube or hypercube. As for the example above the value of N is 4. There may be as many as 100 lines of input.

 

Output

For each line of input, output six integers S2, R2, S3, R3, S4, R4 in a single line where S2 means no of squares of different size in ( NxN) two-dimensional grid, R2 means no of rectangles of different size in (NxN) two-dimensional grid. S3, R3, S4, R4 means similar cases in higher dimensions as described before.  

       

Sample Input:

1
2
3

Sample Output:

1 0 1 0 1 0
5 4 9 18 17 64
14 22 36 180 98 1198

---

Shahriar Manzoor

---

二维三维还是可以算的，四维算个毛，想都想不出来别说画了，明显是个找规律的题目啊，

尽管我没有找到一个可以计算的公式，但是既然是个规律题，可以在二维找规律，在三维试验，最后应用于四维，话说一路很风顺，规律找的很轻松，可是写出来也太恐怖了吧；

代码如下：

#include <stdio.h>

int main()
{
    long long s2,r2,s3,r3,s4,r4;
    long long ssum,rsum;
    int n;
    int l1,l2,l3,l4;
    int i,k,j,h;


    while (~scanf ("%d",&n))
    {
        ssum = 0;
        for (i = 1;i <= n;i++)
        {
            l1 = n - i + 1;
            ssum += l1 * l1;
        }

        rsum = 0;
        for (i = 1; i <= n; i++)
            for (k = 1; k <= n; k++)
            {
                l1 = n - i + 1;
                l2 = n - k + 1;
                rsum += l1 * l2;
            }
        s2 = ssum;
        r2 = rsum - ssum;

        ssum = 0;
        for (i = 1;i <= n;i++)
        {
            l1 = n - i + 1;
            ssum += l1 * l1 * l1;
        }

        rsum = 0;
        for (i = 1;i <=n;i++)
            for (k = 1;k <= n;k++)
                for (j = 1;j <= n;j++)
                {
                    l1 = n - i + 1;
                    l2 = n - k + 1;
                    l3 = n - j + 1;
                    rsum += l1 * l2 * l3;
                    }

        s3 = ssum;
        r3 = rsum - ssum;

        ssum = 0;
        for (i = 1;i <= n;i++)
        {
            l1 = n - i + 1;
            ssum += l1 * l1 * l1 * l1;
        }

        rsum = 0;
        for (i = 1;i <= n;i++)
            for (k = 1;k <= n;k++)
                for (j = 1;j <= n;j++)
                    for (h = 1;h <= n;h++)
                    {
                        l1 = n - i + 1;
                        l2 = n - k + 1;
                        l3 = n - j + 1;
                        l4 = n - h + 1;
                        rsum += l1 * l2 * l3 *l4;
                    }

        s4 = ssum;
        r4 = rsum - ssum;
        printf ("%lld %lld %lld %lld %lld %lld\n",s2,r2,s3,r3,s4,r4);

    }

    return 0;
}

在写的时候就担心TLE，果然，不粗所料，TLE，见红了。

 

其实我实在不想放弃这个类似穷举的笨重算法，因为我现在还真没有什么好的方法，so，我把精力放在优化代码上

我发现我时间浪费在循环上，各种循环，n的上限是100 。最后一个循环可以执行100 * 100 * 100 * 100次，我去太恐怖了

看到自己的代码有个式子在不短重复 【n-自变量+1】,随着嵌套增多这个也在多

想到第一只学长曾经讲过的时间复杂度，并说调用比计算省时间，于是我打算把节省时间重点放在这个式子上，于是我改进了代码如下：

#include <stdio.h>

int an[102];

int main()
{
    long long s2,r2,s3,r3,s4,r4;
    long long ssum,rsum;
    int n;
    int l1,l2,l3,l4;
    int i,k,j,h;

    freopen ("1.txt","r",stdin);
    while (~scanf ("%d",&n))
    {
        for (i = 1;i <= n;i++)
            an[i] = n - i + 1;

        ssum = 0;
        for (i = 1;i <= n;i++)
        {
            l1 = an[i];
            ssum += l1 * l1;
        }

        rsum = 0;
        for (i = 1; i <= n; i++)
            for (k = 1; k <= n; k++)
            {
                l1 = an[i];
                l2 = an[k];
                rsum += l1 * l2;
            }
        s2 = ssum;
        r2 = rsum - ssum;

        ssum = 0;
        for (i = 1;i <= n;i++)
        {
            l1 = an[i];
            ssum += l1 * l1 * l1;
        }

        rsum = 0;
        for (i = 1;i <=n;i++)
            for (k = 1;k <= n;k++)
                for (j = 1;j <= n;j++)
                {
                    l1 = an[i];
                    l2 = an[k];
                    l3 = an[j];
                    rsum += l1 * l2 * l3;
                }

        s3 = ssum;
        r3 = rsum - ssum;

        ssum = 0;
        for (i = 1;i <= n;i++)
        {
            l1 = an[i];
            ssum += l1 * l1 * l1 * l1;
        }

        rsum = 0;
        for (i = 1;i <= n;i++)
            for (k = 1;k <= n;k++)
                for (j = 1;j <= n;j++)
                    for (h = 1;h <= n;h++)
                    {
                        l1 = an[i];
                        l2 = an[k];
                        l3 = an[j];
                        l4 = an[h];
                        rsum += l1 * l2 * l3 *l4;
                    }

        s4 = ssum;
        r4 = rsum - ssum;
        printf ("%lld %lld %lld %lld %lld %lld\n",s2,r2,s3,r3,s4,r4);

    }

    return 0;
}

居然AC了，其实时间和内存还是很恐怖的

事实证明，这样时间还是很悬的，但是也同样证明，这样的确可以缩短时间。