多多的骰子组合

贴一个无脑枚举的方法，因为骰子只有 4 种旋转方法，所以每获得一个新的骰子，就 BFS 一下，把所有可能都遍历到（最多可能 24 种？），然后后面如果在遇到一样的，就可以直接判断它属于哪一种了。

记录每一种的数量，最后输出答案即可。

#include <bits/stdc++.h>
#include <cstdio>
#include <functional>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
struct sieve{
    int up, down, left, right, front, back;
    string to_string() {
        static char t[15];
        // cout << up << ' ' << down << ' ' << left << ' ' << right << ' ' << front << ' ' << back << endl;
        sprintf(t, "%d%d%d%d%d%d", up, down, left, right, front, back);
        return string(t);
    }
};
sieve toUp(sieve s) {
    tie(s.front, s.down, s.back, s.up) = make_tuple(s.down, s.back, s.up, s.front);
    return s;
}
sieve toDown(sieve s) {
    tie(s.front, s.down, s.back, s.up) = make_tuple(s.up, s.front, s.down, s.back);
    return s;
}
sieve toLeft(sieve s) {
    tie(s.front, s.right, s.back, s.left) = make_tuple(s.right, s.back, s.left, s.front);
    return s;
}
sieve toRight(sieve s) {
    tie(s.front, s.right, s.back, s.left) = make_tuple(s.left, s.front, s.right, s.back);
    return s;
}
int main() {
    int n;
    cin >> n;
    // 筛子序列化 -> 种类编号
    unordered_map<string, int> mp;
    vector<int> cnt(n);
    for (int i = 0; i < n; i++) {
        sieve s;
        cin >> s.up >> s.down >> s.left >> s.right >> s.front >> s.back;
        // cout << s.to_string() << endl;
        if (mp.count(s.to_string())) {
            cnt[mp[s.to_string()]]++;
            continue;
        }
        // 种类命名为 i
        cnt[i]++;
        queue<sieve> q;
        q.push(s);
        // cout << "s: " << s.to_string() << endl;
        while (q.size()) {
            auto x = q.front(); q.pop();
            // cout << x.to_string() << endl;
            for (auto &y : vector<sieve>{toUp(x), toDown(x), toLeft(x), toDown(x)}) {
                if (mp.count(y.to_string())) continue;
                mp[y.to_string()] = i;
                q.push(y);
            }
        }
    }
    vector<int> res;
    for (int i = 0; i < n; i++) {
        if (cnt[i] > 0) res.push_back(cnt[i]);
    }
    sort(res.begin(), res.end(), greater<int>());
    cout << res.size() << endl;
    for (auto x : res) {
        cout << x << " ";
    }
}

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static int getKey(int[] d,int i,int a,int b,int c,int k){
              int ret = 0;
                   if(i==a){
                           ret+=d[a]*1000+d[b]*100+d[c]*10+d[k];
                        }else if(i ==b){
                             ret+=d[b]*1000+d[c]*100+d[k]*10+d[a];
                        }else if (i == c){
                              ret+=d[c]*1000+d[k]*100+d[a]*10+d[b];
                        }else{
                            ret+=d[k]*1000+d[a]*100+d[b]*10+d[c];
                        }

              return ret;
    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int  n = in.nextInt();
        Map<Integer, Integer> map = new HashMap<>();
        int[][] input = new int[n][6];
        for (int i = 0 ; i < n; i++) {
            for (int j = 0 ; j < 6 ; j++) {
                input[i][j] = in.nextInt();
            }
        }
        for (int i = 0 ; i < n; i++) {
            //先看1
            int[] d =  input[i];
            for (int j = 0; j < 6; j++) {
                if (d[j] == 1) {
                    //先看下是不是在上

                    if (j == 0) {
                        int key = 100000;
                        int a  = d[1];
                        key += a * 10000;
                        int min = 100;
                        if (a != 2) {
                            min = 2;
                        } else {
                            min = 3;
                        }
                        int index = 0;
                        for (int f = 0; f < 6; f++) {
                            if (d[f] == min) {
                                index = f;
                                break;
                            }
                        }
                        //接下来,从2或3开始顺时针转一圈
                     key+= getKey(d,index,2,4,3,5);
                        if(!map.containsKey(key)){
                            map.put(key,1);
                        }else{
                            map.put(key,map.get(key)+1);
                        }
                    }else if(j==1){
                             int key = 100000;
                        int a  = d[0];
                        key += a * 10000;
                        int min = 100;
                        if (a != 2) {
                            min = 2;
                        } else {
                            min = 3;
                        }
                        int index = 0;
                        for (int f = 0; f < 6; f++) {
                            if (d[f] == min) {
                                index = f;
                                break;
                            }
                        }
                        //接下来,从2或3开始顺时针转一圈
                         key+= getKey(d,index,2,5,3,4);
                        if(!map.containsKey(key)){
                            map.put(key,1);
                        }else{
                            map.put(key,map.get(key)+1);
                        }
                    }else if (j==2){
                      int key = 100000;
                        int a  = d[3];
                        key += a * 10000;
                        int min = 100;
                        if (a != 2) {
                            min = 2;
                        } else {
                            min = 3;
                        }
                        int index = 0;
                        for (int f = 0; f < 6; f++) {
                            if (d[f] == min) {
                                index = f;
                                break;
                            }
                        }
                        //接下来,从2或3开始顺时针转一圈
                         key+= getKey(d,index,0,5,1,4);
                        if(!map.containsKey(key)){
                            map.put(key,1);
                        }else{
                            map.put(key,map.get(key)+1);
                        }
                    }
                    else if (j==3){
                      int key = 100000;
                        int a  = d[2];
                        key += a * 10000;
                        int min = 100;
                        if (a != 2) {
                            min = 2;
                        } else {
                            min = 3;
                        }
                        int index = 0;
                        for (int f = 0; f < 6; f++) {
                            if (d[f] == min) {
                                index = f;
                                break;
                            }
                        }
                        //接下来,从2或3开始顺时针转一圈
                         key+= getKey(d,index,1,5,0,4);
                        if(!map.containsKey(key)){
                            map.put(key,1);
                        }else{
                            map.put(key,map.get(key)+1);
                        }
                    }
                     else if (j==4){
                      int key = 100000;
                        int a  = d[5];
                        key += a * 10000;
                        int min = 100;
                        if (a != 2) {
                            min = 2;
                        } else {
                            min = 3;
                        }
                        int index = 0;
                        for (int f = 0; f < 6; f++) {
                            if (d[f] == min) {
                                index = f;
                                break;
                            }
                        }
                        //接下来,从2或3开始顺时针转一圈
                         key+= getKey(d,index,0,2,1,3);
                        if(!map.containsKey(key)){
                            map.put(key,1);
                        }else{
                            map.put(key,map.get(key)+1);
                        }
                    }
                     else if (j==5){
                      int key = 100000;
                        int a  = d[4];
                        key += a * 10000;
                        int min = 100;
                        if (a != 2) {
                            min = 2;
                        } else {
                            min = 3;
                        }
                        int index = 0;
                        for (int f = 0; f < 6; f++) {
                            if (d[f] == min) {
                                index = f;
                                break;
                            }
                        }
                        //接下来,从2或3开始顺时针转一圈
                         key+= getKey(d,index,0,3,1,2);
                        if(!map.containsKey(key)){
                            map.put(key,1);
                        }else{
                            map.put(key,map.get(key)+1);
                        }
                    }
                    break;
                }

            }
        }
        List<Integer> list = new ArrayList<>(map.values());
        Collections.sort(list,new Comparator<Integer>(){
            public int compare(Integer s,Integer t1 ){
                return t1-s;
            }
        });
        
       System.out.println(map.keySet().size());
    for(int i = 0 ; i < list.size();i++){
        System.out.print(list.get(i)+" ");
    }
    }
}

和大家一样的想法，想法子将骰子固定住，固定两个面就行了，我是1在上面，先固定上下两面，前后左右四面保证最小的在左侧,怎么转的就稍微想一下就行，很简单

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[][] matrix = new int[n][6];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < 6; j++) {
                matrix[i][j] = sc.nextInt();
            }
        }

       getDiffNum(matrix, n);
    }

    private static void getDiffNum(int[][] matrix, int n) {
        for (int i = 0; i < n; i++) {
            // 将数据全转成 1 在上且左侧比右侧小的排序
            int[] nums = matrix[i];
            for (int j = 0; j < 6; j++) {
                if (1 == nums[j]) {
                    rotate(nums, j);
                }
            }
        }

        Map<String, Integer> map = new HashMap<>();
        // 进行次数统计
        for (int i = 0; i < n; i++) {
            int[] nums = matrix[i];
            StringBuilder sb = new StringBuilder();
            for (int j = 0; j < 6; j++) {
                sb.append(nums[j]);
            }

            String key = sb.toString();
            if (map.containsKey(key)) {
                map.put(key, 1 + map.get(key));
            } else {
                map.put(key, 1);
            }
        }

        System.out.println(map.size());
        map.values().stream().sorted((t1, t2) -> {
            return t2 - t1;
        }).forEach(item -> {
            System.out.print(item + " ");
        });
        System.out.println();
    }

    private static void rotate(int[] nums, int pos) {
        if (1 == pos) {
            swap(nums, 0, 1);
            swap(nums, 4, 5);
        } else if (2 == pos) {
            swap(nums, 0, 2);
            swap(nums, 1, 3);
            swap(nums, 2, 3);
        } else if (3 == pos) {
            swap(nums, 0, 2);
            swap(nums, 1, 3);
            swap(nums, 0, 1);
        } else if (4 == pos) {
            swap(nums, 0, 4);
            swap(nums, 1, 5);
            swap(nums, 4, 5);
        } else if (5 == pos) {
            swap(nums, 0, 4);
            swap(nums, 1, 5);
            swap(nums, 0, 1);

        }
        rotateLeftMin(nums);
    }

    private static void rotateLeftMin(int[] nums) {
        int idx = -1, min = Integer.MAX_VALUE;
        for (int i = 2; i < 6; i++) {
            if (min > nums[i]) {
                min = nums[i];
                idx = i;
            }
        }

        rotate2(nums, idx);
    }

    /**
     * 将第三个位置置为后四个最小值
     * @param nums
     * @param idx
     */
    private static void rotate2(int[] nums, int idx) {
        if (3 == idx) {
             swap(nums, 2,3);
             swap(nums, 4,5);
        } else if (4 == idx) {
            swap(nums, 2,4);
            swap(nums, 3,5);
            swap(nums, 4,5);
        } else if (5 == idx) {
            swap(nums, 2,4);
            swap(nums, 3,5);
            swap(nums, 2,3);
        }
    }


    private static void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
}

将每个骰子固定两个面，骰子的排序就是固定的，我选择将1转到上，剩下最大的转到左边

#include<bits/stdc++.h>
using namespace std;
string i2j(vector<int> a){
    int id1;
    for(int i=0;i<6;i++){
        if(a[i]==1) {
            id1=i;
            break;
        }
    }
    if(id1>1){
        if(id1%2==0){
            swap(a[id1],a[0]);
            swap(a[id1+1],a[1]);
            swap(a[id1+1],a[id1]);
        }
        else{
            swap(a[id1],a[1]);
            swap(a[id1-1],a[0]);
            swap(a[1],a[0]);
        }
    }
    else{
        if(id1==1){
            swap(a[0],a[1]);
            swap(a[2],a[3]);
        }
    }
    int num_next=6;
    if(a[1]==6){
        num_next=5;
    }
    int id_next;
    for(int i=2;i<6;i++){
        if(a[i]==num_next){
            id_next=i;
            break;
        }
    }
    if(id_next!=2){
        if(id_next==3){
            swap(a[2],a[3]);
            swap(a[4],a[5]);
        }
        else if(id_next==4){
            swap(a[2],a[4]);
            swap(a[3],a[5]);
            swap(a[4],a[5]);
        }
        else{
            swap(a[2],a[4]);
            swap(a[3],a[5]);
            swap(a[2],a[3]);
        }
    }
    string out="";
    for(int i=0;i<6;i++){
        out+=to_string(a[i]);
    }
    return out;
}
int main(){
    int num=0;
    cin>>num;
    unordered_map<string , int> a;
    for(int i=0;i<num;i++){
        vector<int> tmp(6,0);
        for(int j=0;j<6;j++){
            cin>>tmp[j];
        }
        string b=i2j(tmp);
        a[b]++;
    }
    cout<<a.size()<<endl;
    vector<int > c;
    for(auto i:a){
        c.push_back(i.second);
    }
    sort(c.begin(),c.end(),greater<int>());
    for(auto i:c){
        cout<<i<<" ";
    }
}

	#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
 
int a[24][6] = {
    {1,2,3,4,5,6},
    {4,3,1,2,5,6},
    {2,1,4,3,5,6},
    {3,4,2,1,5,6},
     
    {1,2,4,3,6,5},
    {3,4,1,2,6,5},
    {2,1,3,4,6,5},
    {4,3,2,1,6,5},
     
    {1,2,6,5,3,4},
    {5,6,1,2,3,4},
    {2,1,5,6,3,4},
    {6,5,2,1,3,4},
     
    {1,2,5,6,4,3},
    {6,5,1,2,4,3},
    {2,1,6,5,4,3},
    {5,6,2,1,4,3},
     
    {6,5,3,4,1,2},
    {4,3,6,5,1,2},
    {5,6,4,3,1,2},
    {3,4,5,6,1,2},
     
    {5,6,3,4,2,1},
    {4,3,5,6,2,1},
    {6,5,4,3,2,1},
    {3,4,6,5,2,1}
};
 
int shai[6], tmp[6];
 
vector<int> cnt;
int out[1010][6];
 
bool check(int a[6], int b[6])
{
    int flag = 1;
    for(int k = 0; k < 6; k++)
    {
        if(a[k] != b[k])
        {
            flag = 0;
            break;
        }
    }
    return flag;
}
 
int main()
{
    int N;
    cin >> N;
    for(int i = 0; i < N; i++)
    {
        for(int j = 0; j < 6; j++)
            cin >> shai[j];
        int flag = 0;
        for(int c = 0; c < cnt.size(); c++)
        {
            // 和每一个做对比
            // 有24种可能
            for(int j = 0; j < 24; j++)
            {
                for(int k = 0; k < 6; k++)
                {
                    tmp[k] = shai[a[j][k] - 1];
                }
                 
                if(check(out[c], tmp))
                {
                    cnt[c]++;
                    flag = 1;
                    break;
                }
            }
            if(flag)
                break;
        }
        if(flag == 0)
        {
            for(int k = 0; k < 6; k++)
                out[cnt.size()][k] = shai[k];
            cnt.push_back(1);
        }
    }
     
    sort(cnt.begin(), cnt.end());
    cout << cnt.size() << endl;
    for(int i = cnt.size() - 1; i >= 0; i--)
        cout << cnt[i] << ' ';
}



	

并查集

#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> fa, sz;
int find(int x)
{
    return x == fa[x] ? fa[x] : (fa[x] = find(fa[x]));
}
bool merge(int x, int y)
{
    x = find(x), y = find(y);
    if (x == y)
    {
        return false;
    }
    if (sz[x] < sz[y])
    {
        swap(x, y);
    }
    fa[y] = x;
    sz[x] += sz[y];
    return true;
}
int main()
{
    cin >> n;
    vector<vector<int>> S(n, vector<int>(6));
    fa.resize(n), sz.resize(n, 1);
    iota(fa.begin(), fa.end(), 0);
    for (int i = 0; i < n; ++i)
    {
        for (int j = 0; j < 6; ++j)
        {
            cin >> S[i][j];
        }
    }
    auto f = [&](int i) -> vector<int>
    {
        if (S[i][0] == 1)
        {
            return vector<int>{S[i][5], S[i][3], S[i][4], S[i][2]};
        }
        else if (S[i][1] == 1)
        {
            return vector<int>{S[i][4], S[i][3], S[i][5], S[i][2]};
        }
        else if (S[i][2] == 1)
        {
            return vector<int>{S[i][0], S[i][4], S[i][1], S[i][5]};
        }
        else if (S[i][3] == 1)
        {
            return vector<int>{S[i][0], S[i][5], S[i][1], S[i][4]};
        }
        else if (S[i][4] == 1)
        {
            return vector<int>{S[i][0], S[i][3], S[i][1], S[i][2]};
        }
        return vector<int>{S[i][0], S[i][2], S[i][1], S[i][3]};
    };
    auto alike = [&](int i, int j) -> bool
    {
        auto a = f(i), b = f(j);
        for (int ii = 0; ii < 4; ++ii)
        {
            for (int jj = 0; jj < 4; ++jj)
            {
                if (a[ii] == b[jj])
                {
                    for (int k = 0; k < 4; ++k)
                    {
                        if (a[(ii + k) % 4] != b[(jj + k) % 4])
                        {
                            return false;
                        }
                    }
                    return true;
                }
            }
        }
        return false;
    };
    for (int i = 0; i < n; ++i)
    {
        for (int j = i + 1; j < n; ++j)
        {
            if (alike(i, j))
            {
                merge(i, j);
            }
        }
    }
    vector<int> T;
    for (int i = 0; i < n; ++i)
    {
        if (i == fa[i])
        {
            T.emplace_back(sz[i]);
        }
    }
    sort(T.begin(), T.end(), greater<>());
    int m = T.size();
    cout << m << '\n';
    for (int i = 0; i < m; ++i)
    {
        cout << T[i] << " \n"[i == m - 1];
    }
    return 0;
}