Question

我正在解决代码竞赛代码问题而且我遇到了这个问题

计算使用K颜色为N * M网格着色的方法数。网格中的相邻方块应具有不同的颜色。如果正方形共享边缘，则它们被认为是相邻的。输入格式

第一行包含一个表示测试用例数的整数T.接下来的T行包含由单个空格分隔的整数N，M和K.

示例输入

示例输出

2
1122
1

Answer 1

我已用Java附加代码来解决您的问题。没有一个简单的公式，因为每个正方形最多有四个正方形。这是我的程序的示例运行，没有打印出每个解决方案。请注意，它匹配样本输入/输出的问题。

Enter number of colors: 2
Enter number of rows: 3
Enter number of columns: 3
There are 2 different combinations of 2 colors.

Enter number of colors: 3
Enter number of rows: 4
Enter number of columns: 3
There are 1122 different combinations of 3 colors.

Enter number of colors: 1
Enter number of rows: 1
Enter number of columns: 1
There are 1 different combinations of 1 colors.

这是3种颜色的输出，2乘4格，打印它找到的每种解决方案。对于此输入，答案是162.对于源代码，请直接进入底部...

Enter number of colors: 3
Enter number of rows: 2
Enter number of columns: 4

1212
2121

1212
2123

1213
2121

1212
2131

1213
2131

1213
2132

1231
2123

1232
2121

1232
2123

1212
2321

1212
2323

1213
2321

1231
2312

1231
2313

1232
2313

1231
2323

1232
2321

1232
2323

1312
2121

1312
2123

1313
2121

1312
2131

1313
2131

1313
2132

1321
2132

1323
2131

1323
2132

1212
3121

1212
3123

1213
3121

1212
3131

1213
3131

1213
3132

1231
3123

1232
3121

1232
3123

1312
3121

1312
3123

1313
3121

1312
3131

1313
3131

1313
3132

1321
3132

1323
3131

1323
3132

1312
3231

1313
3231

1313
3232

1321
3212

1321
3213

1323
3212

1321
3232

1323
3231

1323
3232

2121
1212

2121
1213

2123
1212

2121
1232

2123
1231

2123
1232

2131
1212

2131
1213

2132
1213

2121
1312

2121
1313

2123
1312

2131
1312

2131
1313

2132
1313

2131
1323

2132
1321

2132
1323

2312
1231

2313
1231

2313
1232

2321
1212

2321
1213

2323
1212

2321
1232

2323
1231

2323
1232

2121
3212

2121
3213

2123
3212

2121
3232

2123
3231

2123
3232

2131
3212

2131
3213

2132
3213

2312
3121

2312
3123

2313
3121

2312
3131

2313
3131

2313
3132

2321
3132

2323
3131

2323
3132

2312
3231

2313
3231

2313
3232

2321
3212

2321
3213

2323
3212

2321
3232

2323
3231

2323
3232

3121
1212

3121
1213

3123
1212

3121
1232

3123
1231

3123
1232

3131
1212

3131
1213

3132
1213

3121
1312

3121
1313

3123
1312

3131
1312

3131
1313

3132
1313

3131
1323

3132
1321

3132
1323

3212
1321

3212
1323

3213
1321

3231
1312

3231
1313

3232
1313

3231
1323

3232
1321

3232
1323

3121
2312

3121
2313

3123
2312

3131
2312

3131
2313

3132
2313

3131
2323

3132
2321

3132
2323

3212
2121

3212
2123

3213
2121

3212
2131

3213
2131

3213
2132

3231
2123

3232
2121

3232
2123

3212
2321

3212
2323

3213
2321

3231
2312

3231
2313

3232
2313

3231
2323

3232
2321

3232
2323

There are 162 different combinations of 3 colors.

这是java代码：

import java.util.*;

public class ColorChoices
{
    int[][] grid;
    int numberOfColors;
    int numberOfRows;
    int numberOfColumns;
    int numberOfCombinations;

    public static void main(String[] args)
    {
        ColorChoices solution = new ColorChoices();
        solution.begin();

    }

    void begin()
    {
        numberOfCombinations = 0;
        Scanner consoleInput = new Scanner(System.in);
        System.out.print("Enter number of colors: ");
        numberOfColors = consoleInput.nextInt();
        System.out.print("Enter number of rows: ");
        numberOfRows = consoleInput.nextInt();
        System.out.print("Enter number of columns: ");
        numberOfColumns = consoleInput.nextInt();
        grid = new int[numberOfRows][numberOfColumns];

        solve(0, 0);

        System.out.println("There are " + numberOfCombinations + " different combinations of " + numberOfColors + " colors.");
    }

    void solve(int r, int c)
    {
        for(int i = 1; i <= numberOfColors; i++)
        {   
            if(valid(r, c, i))
            {
                grid[r][c] = i;
                if(r == numberOfRows - 1 && c == numberOfColumns - 1) 
                {
                    printBoard();
                    numberOfCombinations++;
                }
                else if(r == numberOfRows - 1) solve(0, c + 1);
                else solve(r + 1, c);
            }
        }
        grid[r][c] = 0;
    }

    boolean valid(int r, int c, int n)
    {
        return(leftOK(r, c, n) && rightOK(r, c, n) &&  topOK(r, c, n) &&  bottomOK(r, c, n));
    }

    boolean leftOK(int r, int c, int n)
    {
        if(c == 0) return true;
        if(grid[r][c - 1] != n) return true;
        return false;
    }

    boolean rightOK(int r, int c, int n)
    {
        if(c == numberOfColumns - 1) return true;
        if(grid[r][c + 1] != n) return true;
        return false;
    }

    boolean topOK(int r, int c, int n)
    {
        if(r == 0) return true;
        if(grid[r - 1][c] != n) return true;
        return false;
    }

    boolean bottomOK(int r, int c, int n)
    {
        if(r == numberOfRows - 1) return true;
        if(grid[r + 1][c] != n) return true;
        return false;
    }

    void printBoard()
    {
        for(int r = 0; r < numberOfRows; r++)
        {
            for(int c = 0; c < numberOfColumns; c++)
            {
                System.out.print(grid[r][c]);
            }
            System.out.println();
        }
        System.out.println();
    }
}

如何找到彩色N * M网格的方法？

1 个答案: