UVA 317 Hexagon

分析

六边形有六条边，三个方向（自顶向下，自左上向右下，自右上向左下）。
那么现给三组数据，每组数据有三个数值，分别对应三个方向的各自可选的三个值，另要求一个六边形任一方向上的两边的值相等，所以总共可以得到$3^3=27$个互异的六边形。

现在需要你从这27个中选出19个拼成如题的形状，给定规则，如果某一方向上的值均相同，那么这个方向上的收益为该值乘以该方向上的六边形个数，综合15个收益，问总收益的最大值。

考虑尝试各个组合，这里考虑一番如何组合即如何构造最大收益。考察一个方向，对应的六边形个数为3，4，5，4，3。那么这个方向上有三个数可以摆要如何摆才能最大？

不妨设a>b>c，因为要互异，所以某一方向相同的六边形有$3^2=9$个，这里可以尝试选择，(5+4)×a+(4+3)×b+3×c是不是最大呢？考虑其他的方法，如(4+4)×a+(3+3)×b+5×c。不妨假设差异最小，即a=b+1=c+2。那么两种方法的值分别为19a-12和22a-19。因为a,b,c均为正整数，所以a≥3。那么显然22a-19>19a-12(a≥3)。

经过这样的考虑，可以发现8，6，5的组合得到的收益是最大的。那么可以确定是否只要将三组数据均采用这种组合便能获得最大收益呢？

简单的尝试一下会发现，这样会出现对边重复。也就是说只能有至多只能有一个方向采用同一组收益方案。继续考虑其他的收益方案可以发现下一组应该是7，7，5。因而可以这样尝试，（4+4，3+3，5），（4+3，3+4，5），（3+4，4+3，5），即（8，6，5）和（7，7，5）。所以可以选择三个方向中的一个尝试（8，6，5），另两方向（7，7，5）。比较三种尝试的结果即可。

代码

#include <cstdio>
#include <algorithm>
using std::sort;
int hex[3][3];

int a[3] = {5, 3+3, 4+4};
int b[3] = {5, 3+4, 3+4};

void solve()
{
    int max = 0;
    for (int k = 0; k < 3; k++) {
        int s = 0;
        for (int i = 0; i < 3; i++)
            for (int j = 0; j < 3; j++)
                if (i == k) s += hex[i][j] * a[j];
                else        s += hex[i][j] * b[j];
        max = s > max ? s : max;
    }
    printf("%d\n\n", max);
}

int main()
{
    int n;
    scanf("%d", &n);
    for (int t = 1; t <= n; t++) {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++)
                scanf("%d", &hex[i][j]);
            sort(hex[i], hex[i] + 3);
        }
        printf("Test #%d\n", t);
        solve();
    }         
    return 0;
}

题目

Description

Consider a game board consisting of 19 hexagonal fields, as shown in the figure below. We can easily distinguish three main directions in the shape of the board: from top to bottom, from top-left to bottom-right, and from top-right to bottom-left. For each of these primary directions, the board can be viewed as a series of rows, consisting of 3, 4, 5, 4, and 3 fields, respectively.

The game board has to be completely covered using a set of hexagonal pieces. Each piece carries three numbers, one for every primary board direction. Only three different numbers are used for each direction. Every possible combination of three numbers for all three directions is assigned to a piece, leading to a set of 27 unique pieces. (The board in the above figure is still in the process of being covered.)

The score of a board is calculated as the sum of all 15 row scores (5 rows for each primary direction). The row scores are calculated as follows: if all pieces in a row carry the same number for the direction of the row, the row score is this number multiplied by the number of pieces in the row. Otherwise (the pieces carry different numbers in the row direction) the row score is zero. Note that the pieces may not be rotated. For example, the score of the leftmost row in the figure is $3·3=9$, the score of the row to its right is $4·11=44$.

While in the real game the pieces are chosen randomly and the set of pieces is fixed, we are interested in the highest possible score for a given set of numbers for each direction, when all pieces in a row carry the same number for the direction of the row. This means you have to choose those 19 pieces that result in the highest score.

Input

The first line of the input file contains an integer n which indicates the number of test cases. Each test case consists of three lines containing three integers each. Each of these three line contains the numbers for a single primary direction. From these numbers the set of pieces is generated.

Output

For each test case output a line containing the number of the case (Test #1, Test #2, etc.), followed by a line containing the highest possible score for the given numbers. Add a blank line after each test case.

Sample Input

1
9 4 3
8 5 2
7 6 1

Sample Output

Test #1
308