指环王问题

The Fellowship of the ring

Frodo formed the fellowship of the Ring and is taking the one ring to Mordor.

On the way to Mordor, he encounters N groups of orcs, in the order of 1 to N.

When Frodo bumps into an orc group, he can choose one of the three following options:

Pay the Toll

He can pay a regular toll and pass by them safely.

Recruit a mercenary

If he pays the double of the toll, the corresponding orc group gets hired as mercenaries of the Fellowship of the Ring.

If the number of the Fellowship of the Ring members is greater than or equal to the number of orcs, a battle is possible.

However,

1. Frodo does not count as one of the members of the fellowship of the Ring.
2. A hired mercenary can participate at maximum 3 battles. Even if the orcs are alive after 3 battles, the group gets dispersed.
3. In a battle, independent of the number of orcs, all hired mercenaries participate in the battle.
4. The battle goes on until the orc group gets exterminated. The Fellowship of the Ring, will, as well, loose the same number of soldiers.
5. In the Fellowship of the Ring, soldiers get killed in the order of who got hired first.

#Given N, the number of orc groups and the toll, find the minimum cost to get to Mordor.

For instance, suppose there are 7 (N=7) orc groups.

(Yellow stands for the number of orcs in the group and white stands for the toll).

The minimum cost to get to Mordor is 15$

If there are 11(N=11) orc groups, the minimum cost becomes$2370.

[Constraints]

1. 5<=N<=20
2. The number of orcs in each group is greater than or equal to 1 and less than or equal to 1000.
3. The toll of each orc group is each group is greater than or equal to 1 and less than or equal to 1000.

[Input]

The first line contains a single integer T-number of total test cases.

Below, each test case is given.

The first line of each test case contains N- the number of orc groups.

The next N lines contain the number of orcs and the toll, respectively.

[Output]

Print the respective answers for T test case in total for T line.

Each line starts with “#x”, gives one space, and then output the answer. (X is the test case number starting form 1)

#include <stdio.h>

#define N 20

struct Orc {
    int a[3];
    int sum;
};

int n, g;
int cost[N], quan[N];

int min(int a, int b) { return a < b ? a : b; }

void dfs(int k, int s, Orc orc) {

    if (s >= g) return;
    if (k == n) {
        g = s;
        return;
    }

    if (orc.sum >= quan[k]) {
        Orc t = orc;
        int x = quan[k];
        int i = 2;
        while (x) {
            int y = min(t.a[i], x);
            t.a[i] -= y;
            x -= y;
            i--;
        }
        t.sum -= quan[k];
        t.sum -= t.a[2];

        t.a[2] = t.a[1];
        t.a[1] = t.a[0];
        t.a[0] = 0;

        dfs(k + 1, s, t);
    }

    s += cost[k];
    dfs(k + 1, s, orc);

    s += cost[k];
    orc.a[0] += quan[k];
    orc.sum += quan[k];
    dfs(k + 1, s, orc);
}

int main() {
    int t, T;

    t = 0;
    scanf("%d", &T);
    while (t++ < T) {
        scanf("%d", &n);
        g = 0;
        for (int i = 0; i < n; i++) {
            scanf("%d%d", &quan[i], &cost[i]);
            g += cost[i];
        }
        Orc orc;
        orc.sum = 0;
        for (int i = 0; i < 3; i++) orc.a[i] = 0;
        dfs(0, 0, orc);
        printf("#%d %d\n", t, g);
    }
    return 0;
}