Euler61

三角形数、正方形数、五边形数、六边形数、七边形数和八边形数统称为多边形数。它们分别由如下的公式给出：

三角形数	P3,n=n(n+1)/2	1, 3, 6, 10, 15, …
正方形数	P4,n=n2	1, 4, 9, 16, 25, …
五边形数	P5,n=n(3n−1)/2	1, 5, 12, 22, 35, …
六边形数	P6,n=n(2n−1)	1, 6, 15, 28, 45, …
七边形数	P7,n=n(5n−3)/2	1, 7, 18, 34, 55, …
八边形数	P8,n=n(3n−2)	1, 8, 21, 40, 65, …

由三个4位数8128、2882、8281构成的有序集有如下三个有趣的性质。

1. 这个集合是循环的，每个数的后两位是后一个数的前两位（最后一个数的后两位也是第一个数的前两位）。
2. 每种多边形数——三角形数（P3,127=8128）、正方形数（P4,91=8281）和五边形数（P5,44=2882）——在其中各有一个代表。
3. 这是唯一一个满足上述性质的4位数有序集。

存在唯一一个包含六个4位数的有序循环集，每种多边形数——三角形数、正方形数、五边形数、六边形数、七边形数和八边形数——在其中各有一个代表。求这个集合的元素和

思路：

​ 模块1：找出全部1000～9999的x边形数n，并把n存到g【x】【n / 100】动态数组中

​ 模块2：对数组{3, 4, 5, 6, 7, 8}进行全排列，并进行dfs

​ 详细见代码

代码：

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

int Triangle (int n) {
    return n * (n + 1) / 2;
}

int Square(int n ) {
    return n * n;
}

int Pentagonal (int n ) {
    return n * (3 * n - 1) / 2;
}

int Hexagonal (int n ){
    return n * (2 * n - 1);
}

int Heptagonal (int n) {
    return n * (5 * n - 3) / 2;
}

int Octagonal (int n) {
    return n * (3 * n - 2);
}

int (*FuncList[6])(int) = {
        Triangle , Square, Pentagonal, Hexagonal,Heptagonal, Octagonal
};

vector<int>g[10][105];
vector<int>gg[10];

void model1 () {
    for (int i = 1; ; i++) {
        int flag = 0;
        for (int j = 0; j < 6; j++) {
            int t = FuncList[j](i);
            if (1000 <= t && t < 10000) {
                g[j][t / 100].push_back(t);
                gg[j].push_back(t);
            }
            else if(t >= 10000) {
                flag ++;
            }
        }
        if (flag == 6) {
            break;
        }
    }
}

bool dfs(int *num, int t, int now, int k, int sum) {
    if (k == 6) {
        if (now % 100 == t / 100) {
            printf("%d\n", sum);
            return true;
        }
        return false;
    }
    int m = now % 100;
    for (int i = 0; i < g[num[k]][m].size(); i++) {
        int tt = g[num[k]][m][i];
        bool flag = dfs(num, t, tt, k + 1, sum + tt);
        if(flag) return true;
    }
    return false;
}

void model2() {
    int num[6] = {0, 1, 2, 3, 4, 5};
    bool flag = 0;
    do {
        for (int i = 0; i < gg[num[0]].size(); i++) {
            int t = gg[num[0]][i];
            flag = dfs(num, t, t, 1, t);
            if (flag) {
                break;
            }
        }
    }while(next_permutation(num, num + 6) && !flag);
}

int main () {
    model1();
    model2();
    return 0;
}

转载请注明出处！！！

如果有写的不对或者不全面的地方 可通过主页的联系方式进行指正，谢谢

​