Hie with the Pie
Time Limit:2000MS  Memory Limit:65536K
Total Submit:501 Accepted:183

Description

The Pizazz Pizzeria prides itself in delivering pizzas to its customers as fast as possible. Unfortunately, due to cutbacks, they can afford to hire only one driver to do the deliveries. He will wait for 1 or more (up to 10) orders to be processed before he starts any deliveries. Needless to say, he would like to take the shortest route in delivering these goodies and returning to the pizzeria, even if it means passing the same location(s) or the pizzeria more than once on the way. He has commissioned you to write a program to help him.

Input

Input will consist of multiple test cases. The first line will contain a single integer n indicating the number of orders to deliver, where 1 ≤ n ≤ 10. After this will be n + 1 lines each containing n + 1 integers indicating the times to travel between the pizzeria (numbered 0) and the n locations (numbers 1 to n). The jth value on the ith line indicates the time to go directly from location i to location j without visiting any other locations along the way. Note that there may be quicker ways to go from i to j via other locations, due to different speed limits, traffic lights, etc. Also, the time values may not be symmetric, i.e., the time to go directly from location i to j may not be the same as the time to go directly from location j to i. An input value of n = 0 will terminate input.

Output

For each test case, you should output a single number indicating the minimum time to deliver all of the pizzas and return to the pizzeria.

Sample Input

3
0 1 10 10
1 0 1 2
10 1 0 10
10 2 10 0
0

Sample Output

8

Source
East Central North America 2006

#include <cstdio>
#include <memory>

const int INF = 0x7fffffff;

int n, d[12][2100];
int g[12][12];

void floyd() {
    int i, j, k;
    for (k=0; k<=n; k++) {
        for (i=0; i<=n; i++) {
            for (j=0; j<=n; j++) {
                if (g[i][k] != -1 && g[k][j] != -1 && (g[i][j] == -1 || g[i][k]+g[k][j] < g[i][j])) {
                    g[i][j] = g[i][k] + g[k][j];
                }
            }
        }
    }
}

void solve() {
    int i, j, k, bit, t, tmp, one[15], tmpb, ans = INF;
    memset(d, -1, sizeof(d));
    memset(g, -1, sizeof(g));
    for (i=0; i<=n; i++) {
        for (j=0; j<=n; j++) {
            scanf("%d", &g[i][j]);
        }
    }
    floyd();
    d[0][1] = 0;
    for (i=1; i<=n; i++) {
        for (j=0; j<1<<(n+1); j++) {
            bit = j; tmp = 0;
            for (k=1; k<=n; k++) {
                if (bit&(1<<k) && bit&1) {
                    one[tmp++] = k;
                }
            }
            if (tmp != i) continue;
            for (k=0; k<tmp; k++) {
                tmpb = bit^(1<<one[k]);
                if (d[0][tmpb] != -1 && g[0][one[k]] != -1) {
                    if (d[one[k]][bit] == -1 || d[one[k]][bit] > g[0][one[k]] + d[0][tmpb]) {
                        d[one[k]][bit] = g[0][one[k]] + d[0][tmpb];
                    }
                }
                for (t=0; t<tmp; t++) {
                    if (t == k) continue;
                    if (d[one[t]][tmpb] != -1 && g[one[t]][one[k]] != -1) {
                        if (d[one[k]][bit] == -1 || d[one[k]][bit] > g[one[t]][one[k]] + d[one[t]][tmpb]) {
                            d[one[k]][bit] = g[one[t]][one[k]] + d[one[t]][tmpb];
                        }
                    }
                }
            }
        }
    }
    for (i=0; i<=n; i++) {
        if (d[i][(1<<n+1)-1] != -1 && g[i][0] != -1 && ans > d[i][(1<<n+1)-1]+g[i][0]) ans = d[i][(1<<n+1)-1]+g[i][0];
    }
    printf("%d\n", ans);
}

int main() {
    while (scanf("%d", &n) != EOF) {
        if (n == 0) break;
        solve();
    }
    return 0;
}

Let's imagine how apple tree looks in binary computer world. You're right, it looks just like a binary tree, i.e. any biparous branch splits up to exactly two new branches. We will enumerate by natural numbers the root of binary apple tree, points of branching and the ends of twigs. This way we may distinguish different branches by their ending points. We will assume that root of tree always is numbered by 1 and all numbers used for enumerating are numbered in range from 1 to N, where N is the total number of all enumerated points. For instance in the picture below N is equal to 5. Here is an example of an enumerated tree with four branches:

   2   5
\ /
3   4
\ /
1

Input

First line of input contains two numbers: N and Q (1 ≤ Q ≤ N, 1 < N ≤ 100). N denotes the number of enumerated points in a tree. Q denotes amount of branches that should be preserved. Next N-1 lines contains descriptions of branches. Each description consists of a three integer numbers divided by spaces. The first two of them define branch by it's ending points. The third number defines the number of apples on this branch. You may assume that no branch contains more than 30000 apples.

Output

Output file should contain the only number — amount of apples that can be preserved. And don't forget to preserve tree's root ;-)

Sample

5 2
            1 3 1
            1 4 10
            2 3 20
            3 5 20
            

21
            

#include <iostream>
using namespace std;

const int MAXN = 110;
const int MAXQ = 110;

int n, q;
int d[MAXN][MAXQ];
int g[MAXN][MAXN], deg[MAXN], nw[MAXN], son[MAXN][2];
int root;
int f[MAXN], isleaf[MAXN];

inline int maxt(int a, int b) {
    return a > b ? a : b;
}

void DFS(int v) {
    int i, t = 0;
    for (i=1; i<=n; i++) {
        if (g[v][i] != -1 && !f[i]) {
            son[v][t++] = i;
            f[i] = 1;
            nw[i] = g[v][i];
            DFS(i);
        }
    }
    if (!t) isleaf[v] = 1;
}

void buildT() {
    int i;
    for (i=1; i<=n; i++) {
        if (deg[i] == 2) {
            root = i;
            break;
        }
    }
    f[root] = 1; nw[root] = 0;
    DFS(root);
}

int DP(int ti, int tl) {
    if (tl <= 0) return 0;
    if (d[ti][tl] != -1) return d[ti][tl];
    if (isleaf[ti]) return nw[ti];
    int k, tmp = 0;
    for (k=0; k<tl; k++) {
        tmp = maxt(tmp, DP(son[ti][0], k)+DP(son[ti][1], tl-1-k));
    }
    d[ti][tl] = tmp + nw[ti];
    return d[ti][tl];
}

int main() {
    int i, j, k, x, y, w;
    scanf("%d%d", &n, &q);
    memset(g, -1, sizeof(g));
    memset(d, -1, sizeof(d));
    for (i=0; i<n-1; i++) {
        scanf("%d%d%d", &x, &y, &w); 
        g[x][y] = g[y][x] = w;
        deg[x]++, deg[y]++;
    }
    buildT();
    printf("%d\n", DP(root, q+1));

    return 0;
}

The Mailboxes Manufacturers Problem
Time Limit:1000MS  Memory Limit:65536K
Total Submit:299 Accepted:227

Description

In the good old days when Swedish children were still allowed to blowup their fingers with fire-crackers, gangs of excited kids would plague certain smaller cities during Easter time, with only one thing in mind: To blow things up. Small boxes were easy to blow up, and thus mailboxes became a popular target. Now, a small mailbox manufacturer is interested in how many fire-crackers his new mailbox prototype can withstand without exploding and has hired you to help him. He will provide you with k (1 ≤ k ≤ 10) identical mailbox prototypes each fitting up to m (1 ≤ m ≤ 100) crackers. However, he is not sure of how many firecrackers he needs to provide you with in order for you to be able to solve his problem, so he asks you. You think for a while and then say, “Well,if I blow up a mailbox I can’t use it again, so if you would provide me with only k = 1 mailboxes, I would have to start testing with 1 cracker, then 2 crackers, and so on until it finally exploded. In the worst case, that is if it does not blow up even when filled with m crackers, I would need 1 + 2 + 3 + … + m = m × (m + 1) ⁄ 2 crackers. If m = 100 that would mean more than 5000 fire-crackers!” “That’s too many,” he replies. “What if I give you more than k = 1 mailboxes? Can you find a strategy that requires less crackers?”

Can you? And what is the minimum number of crackers that you should ask him to provide you with?

You may assume the following:

1. If a mailbox can withstand x fire-crackers, it can also withstand x − 1 fire-crackers.
2. Upon an explosion, a mailbox is either totally destroyed (blown up) or unharmed, which means that it can be reused in another test explosion.

Note: If the mailbox can withstand a full load of m fire-crackers, then the manufacturer will of course be satisfied with that answer. But otherwise he is looking for the maximum number of crackers that his mailboxes can withstand.

Input

The input starts with a single integer N (1 ≤ N ≤ 10) indicating the number of test cases to follow. Each test case is described by a line containing two integers: k and m, separated by a single space.

Output

For each test case print one line with a single integer indicating the minimum number of fire-crackers that is needed, in the worst case, in order to figure out how many crackers the mailbox prototype can withstand.

Sample Input

4
1 10
1 100
3 73
5 100

Sample Output

55
5050
382
495

Source
Svenskt Mästerskap i Programmering/Norgesmesterskapet 2002

#include <iostream>
using namespace std;

const int INF = 1 << 28;

int d[11][101][101];
int sum(int i, int j) {
    int ret = 0, k;
    for (k=i; k<=j; k++) ret += k;
    return ret;
}

int max(int a, int b) {
    return a > b ? a : b;
}


int main() {
    int caseTime; 
    int i, j, k, t, K, M, l;
    scanf("%d", &caseTime);
    
    while (caseTime--) {
        scanf("%d%d", &K, &M);
        for (i=1; i<=M; i++) {
            for (j=i; j<=M; j++) {
                d[1][i][j] = sum(i, j);
            }
        }
        for (k=2; k<=K; k++) {
            for (l=0; l<M; l++) {
                for (i=1; i+l<=M; i++) {
                    j = i + l;
                    if (i == j) {
                        d[k][i][j] = i;
                        continue;
                    }
                    d[k][i][j] = INF;
                    for (t=i; t<=j; t++) {
                        int tmp;
                        if (t == i) tmp = d[k][i+1][j];
                        else if (t == j) tmp = d[k-1][i][j-1];
                        else tmp = max(d[k-1][i][t-1], d[k-1][t+1][j]);
                        tmp = max(d[k-1][i][t-1], d[k][t+1][j]);
                        if (d[k][i][j] > t + tmp) d[k][i][j] = t + tmp;
                    }
                }
            }
        }
        printf("%d\n", d[K][1][M]);
    }

    return 0;
}

Description
Wshxzt is a lovely girl. She likes apple very much. One day HX takes her to an apple tree. There are N nodes in the tree. Each node has an amount of apples. Wshxzt starts her happy trip at one node. She can eat up all the apples in the nodes she reaches. HX is a kind guy. He knows that eating too many can make the lovely girl become fat. So he doesn’t allow Wshxzt to go more than K steps in the tree. It costs one step when she goes from one node to another adjacent node. Wshxzt likes apple very much. So she wants to eat as many as she can. Can you tell how many apples she can eat in at most K steps.

Input
There are several test cases in the input
Each test case contains three parts.
The first part is two numbers N K, whose meanings we have talked about just now. We denote the nodes by 1 2 ... N. Since it is a tree, each node can reach any other in only one route. (1<=N<=100, 0<=K<=200)
The second part contains N integers (All integers are nonnegative and not bigger than 1000). The ith number is the amount of apples in Node i.
The third part contains N-1 line. There are two numbers A,B in each line, meaning that Node A and Node B are adjacent.
Input will be ended by the end of file.

Note: Wshxzt starts at Node 1.

Output
For each test case, output the maximal numbers of apples Wshxzt can eat at a line.

Sample Input

2 1 
0 11
1 2
3 2
0 1 2
1 2
1 3

Sample Output

11
2

Source
POJ Contest,Author:magicpig@ZSU

#include  < iostream >
using namespace std;

const   int  N  =   210 ;

int  adj[N][N];
int  n, k;
int  w[N];
int  go[N][N], bk[N][N];

void  solve();
void  dfs( int ,  int );
void  dp( int ,  int );
inline  int  max( int  a,  int  b)  {
     return  a  >  b  ?  a : b;
}

int  main()
{
     while  (scanf( " %d%d " ,  & n,  & k)  !=  EOF)  {
        solve();
    }
     return   0 ;
}

void  solve()  {
     int  i, j, l;
     int  x, y;

     for  (i = 1 ; i <= n; i ++ )  {
        scanf( " %d " ,  & w[i]);
        adj[i][ 0 ]  =   0 ;
    }

     for  (i = 0 ; i < n - 1 ; i ++ )  {
        scanf( " %d%d " ,  & x,  & y);
        adj[x][ ++ adj[x][ 0 ]]  =  y;
        adj[y][ ++ adj[y][ 0 ]]  =  x;
    }
    
    memset(go,  0 , sizeof(go));
    memset(bk,  0 , sizeof(bk));

    dfs( 1 ,  0 );

     int  ans  =  max(go[ 1 ][k], bk[ 1 ][k]);
    printf( " %d\n " , ans  +  w[ 1 ]);
}

void  dfs( int  p,  int  pp)  {
     int  i, j, l;
     int  ts;    

     for  (i = 1 ; i <= adj[p][ 0 ]; i ++ )  {
        ts  =  adj[p][i];
         if  (ts  ==  pp)  continue ;
        dfs(ts, p);
        bk[ts][ 0 ]  =   0 ;
        bk[ts][ 1 ]  =   0 ;
        go[ts][ 0 ]  =   0 ;
         for  (l = k; l >= 2 ; l -- ) bk[ts][l]  =  bk[ts][l - 2 ]  +  w[ts];
         for  (l = k; l >= 1 ; l -- ) go[ts][l]  =  go[ts][l - 1 ]  +  w[ts];
        dp(p, ts);
    }
}

void  dp( int  x,  int  y)  {
     int  i, j, l;
     int  t1[N], t2[N];
    memset(t1,  0 , sizeof(t1));
    memset(t2,