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,  0 , sizeof(t2));
     for  (i = 0 ; i <= k; i ++ )  {
         for  (j = 0 ; j <= i; j ++ )  {
            t1[i]  =  max(t1[i], max(bk[x][j] + go[y][i - j], bk[y][j] + go[x][i - j]));
        }
    }
     for  (i = 0 ; i <= k; i ++ )  {
         for  (j = 0 ; j <= i; j ++ )  {
            t2[i]  =  max(t2[i], bk[x][j] + bk[y][i - j]);
        }
    }
     for (i = 0 ; i <= k; i ++ )  {
        bk[x][i]  =  t2[i];
        go[x][i]  =  t1[i];
    }
}

Description
A domino is a flat, thumbsized tile, the face of which is divided into two squares, each left blank or bearing from one to six dots. There is a row of dominoes laid out on a table:

Input
The first line of the input contains an integer n, 1 <= n <= 1000. This is the number of dominoes laid out on the table.

Each of the next n lines contains two integers a, b separated by a single space, 0 <= a, b <= 6. The integers a and b written in the line i + 1 of the input file, 1 <= i <= 1000, are the numbers of dots on the i-th domino in the row, respectively, in the top line and in the bottom one.

Output
Output the smallest number of turns needed to minimise the gap between the top line and the bottom line.

Sample Input

4
6 1
1 5
1 3
1 2

Sample Output

1

Source
CEOI 1997

#include  < iostream >
using   namespace  std;

const   int  MAXN  =   8000 ;
const   int  INF  =   1   <<   28 ;

struct  DATA  {
     int  da[MAXN];
     int  dx;
     int  q;
} ;

DATA dp[ 2 * MAXN];
bool  f[ 2 * MAXN];
int  queue[MAXN], front, rear;
int  main()
{
     int  n;
     int  a[MAXN], x, y;
     int  i, j, k, w, l;
     int  d  =   0 ;
     int  ans  =  INF;
    scanf( " %d " ,  & n);
     for  (i = 0 ; i < n; i ++ )  {
        scanf( " %d%d " ,  & x,  & y);
        a[i]  =  x  -  y;
        d  +=  a[i];
    }
    memset(f,  false ,  sizeof (f));
    dp[d + 7500 ].dx  =  d; dp[d + 7500 ].q  =   0 ; f[d + 7500 ]  =   true ;
     for  (i = 0 ; i < n; i ++ ) dp[d + 7500 ].da[i]  =  a[i];
    front  =   0 ; rear  =   0 ; w  =   0 ;
     do   {
         for  (i = 0 ; i < n; i ++ )  {
            j  =  dp[d + 7500 ].da[i];
            k  =  d   -  j  *   2 ;
             if  ( ! f[k + 7500 ]  ||  dp[k + 7500 ].q  >  w  +   1 )  {
                 if  (k  ==   0 )  {
                    printf( " %d\n " , w  +   1 );
                    system( " pause " );
                     return   0 ;
                }
                f[k + 7500 ]  =   true ;
                queue[rear ++ ]  =  k;
                dp[k + 7500 ].dx  =  k;
                dp[k + 7500 ].q  =  w  +   1 ;
                 for  (l = 0 ; l < n; l ++ ) dp[k + 7500 ].da[l]  =  dp[d + 7500 ].da[l];
                dp[k + 7500 ].da[i]  =   - dp[d + 7500 ].da[i];
            }
        }
        d  =  queue[front ++ ];
        w  =  dp[d + 7500 ].q;
    }   while  (front  <=  rear);  
    j  =   7500 ;
     bool  isFind  =   false ;
     for  (i = 0 ; i < 7500 ; i ++ )  {
         if  (f[j + i])  {
            isFind  =   true ;
             if  (ans  >  dp[j + i].q) ans  =  dp[j + i].q;
        }
         if  (f[j - i])  {
            isFind  =   true ;
             if  (ans  >  dp[j - i].q) ans  =  dp[j - i].q;
        }
         if  (isFind)  break ;
    }
    printf( " %d\n " , ans);
    system( " pause " );
     return   0 ;
}

But even more important than actually stealing the painting is to shake off the police that will soon be following her. Trisha's plan is simple: for several days she will be flying from one city to another, making one flight per day. When she is reasonably sure that the police has lost her trail, she will fly to Atlanta and meet her `customer' (known only as Mr. P.) to deliver the painting.

Her plan is complicated by the fact that nowadays, even when you are stealing expensive art, you have to watch your spending budget. Trisha therefore wants to spend the least money possible on her escape flights. This is not easy, since airlines prices and flight availability vary from day to day. The price and availability of an airline connection depends on the two cities involved and the day of travel. Every pair of cities has a `flight schedule' which repeats every few days. The length of the period may be different for each pair of cities and for each direction.

Although Trisha is a good at stealing paintings, she easily gets confused when booking airline flights. This is where you come in.

Input

The input contains the descriptions of several scenarios in which Trisha tries to escape. Every description starts with a line containing two integers n and k. n is the number of cities through which Trisha's escape may take her, and k is the number of flights she will take. The cities are numbered 1, 2, ..., n, where 1 is Paris, her starting point, and n is Atlanta, her final destination. The numbers will satisfy 2 <= n <= 10 and 1 <= k <= 1000.
Next you are given n(n - 1) flight schedules, one per line, describing the connection between every possible pair of cities. The first n - 1 flight schedules correspond to the flights from city 1 to all other cities (2, 3, ..., n), the next n - 1 lines to those from city 2 to all others (1, 3, 4, ..., n), and so on.

The description of the flight schedule itself starts with an integer d, the length of the period in days, with 1 <= d <= 30. Following this are d non-negative integers, representing the cost of the flight between the two cities on days 1, 2, ..., d. A cost of 0 means that there is no flight between the two cities on that day.

So, for example, the flight schedule ``3 75 0 80'' means that on the first day the flight costs 75, on the second day there is no flight, on the third day it costs 80, and then the cycle repeats: on the fourth day the flight costs 75, there is no flight on the fifth day, etc.

The input is terminated by a scenario having n = k = 0.

Output

For each scenario in the input, first output the number of the scenario, as shown in the sample output. If it is possible for Trisha to travel k days, starting in city 1, each day flying to a different city than the day before, and finally (after k days) arriving in city n, then print ``The best flight costs x.'', where x is the least amount that the k flights can cost.

If it is not possible to travel in such a way, print ``No flight possible.''.

Print a blank line after each scenario.

Sample Input

3 6
2 130 150
3 75 0 80
7 120 110 0 100 110 120 0
4 60 70 60 50
3 0 135 140
2 70 80
2 3
2 0 70
1 80
0 0

Sample Output

Scenario #1
The best flight costs 460.

Scenario #2
No flight possible.

#include <iostream>
using namespace std;

const int MAXN = 11;
const int MAXM = 1001;
const int INF =  2000000000;

int n, m;
int a[MAXN][MAXN][MAXM];
int d[MAXM][MAXN];
int num[MAXN][MAXN];

int main()
{
    int i, j, k, l;
    int t, t1;
    int tmp = 0;
    while (scanf("%d%d", &n, &m) != EOF) {
        if (n == 0 && m == 0) break;
        memset(a, 0, sizeof(a));
        for (i=1; i<=n; i++) {
            for (j=1; j<=n; j++) {
                if (i != j) {
                    scanf("%d", &num[i][j]);
                    for (k=1; k<=num[i][j]; k++) {
                        scanf("%d", &a[i][j][k]);
                    }
                }
            }
        }
        for (i=1; i<=m; i++) {
            for (j=1; j<=n; j++) {
                d[i][j] = INF;
            }
        }
        for (j=1; j<=n; j++) {
            if (a[1][j][1] > 0) {
                d[1][j] = a[1][j][1];
            }
        }
        for (i=2; i<=m; i++) {
            for (j=1; j<=n; j++) {
                t = INF;
                for (k=1; k<=n; k++) {
                    if (k == j) continue;
                    t1 = i % num[k][j] > 0 ? i % num[k][j] : num[k][j];
                    if (a[k][j][t1] > 0 && t > d[i-1][k] + a[k][j][t1]) {
                        t = d[i-1][k] + a[k][j][t1];
                    }
                }
                d[i][j] = t;
            }
        }
        printf("Scenario #%d\n", ++tmp);
        if (d[m][n] != INF) {
            printf("The best flight costs %d.\n\n", d[m][n]);
        } else {
            printf("No flight possible.\n\n");
        }
    }
    system("pause");
    return 0;
}

解题报告：http://www.mydrs.org/program/list.asp?id=583

'Oh no, they've done it again', cries the chief designer at the Waferland chip factory. Once more the routing designers have screwed up completely, making the signals on the chip connecting the ports of two functional blocks cross each other all over the place. At this late stage of the process, it is too expensive to redo the routing. Instead, the engineers have to bridge the signals, using the third dimension, so that no two signals cross. However, bridging is a complicated operation, and thus it is desirable to bridge as few signals as possible. The call for a computer program that finds the maximum number of signals which may be connected on the silicon surface without crossing each other, is imminent. Bearing in mind that there may be thousands of signal ports at the boundary of a functional block, the problem asks quite a lot of the programmer. Are you up to the task?

Figure 1. To the left: The two blocks' ports and their signal mapping (4, 2, 6, 3, 1, 5). To the right: At most three signals may be routed on the silicon surface without crossing each other. The dashed signals must be bridged.

A typical situation is schematically depicted in figure 1. The ports of the two functional blocks are numbered from 1 to p, from top to bottom. The signal mapping is described by a permutation of the numbers 1 to p in the form of a list of p unique numbers in the range 1 to p, in which the ith number specifies which port on the right side should be connected to the ith port on the left side. Two signals cross if and only if the straight lines connecting the two ports of each pair do.

Input

On the first line of the input, there is a single positive integer n, telling the number of test scenarios to follow. Each test scenario begins with a line containing a single positive integer p < 40000, the number of ports on the two functional blocks. Then follow p lines, describing the signal mapping:

On the ith line is the port number of the block on the right side which should be connected to the ith port of the block on the left side.

Output

For each test scenario, output one line containing the maximum number of signals which may be routed on the silicon surface without crossing each other.

Sample Input

4
6
4
2
6
3
1
5
10
2
3
4
5
6
7
8
9
10
1
8
8
7
6
5
4
3
2
1
9
5
8
9
2
3
1
7
4
6

Sample Output

3
9
1
4

#include  < iostream>
using   namespace std;

const   int  MAXN  =   40001;

void Solve()
{
     int n;
     int i, j, k;
     int l, r, m;
     int t;
     int  d[MAXN]  =   { 0 };
     int a[MAXN];
     int  len  =   0;
    scanf( " %d " ,  &n);
     for  (i = 1 ; i <= n; i ++) 
        scanf( " %d " ,  &a[i]);
     for  (i = 1 ; i <= n; i ++)
     {
         if  (a[i]  > d[len])
         {
            len  +=   1;
            d[len]  = a[i];
        }
         else
         {
            l  =   1;
            r  = len;
             while  (l  <  r  -   1)
             {
                m  =  (l  +  r)  /   2;
                 if  (d[m]  < a[i])
                    l  = m;
                else
                    r  = m;
            }
            if  (d[l] > a[i]) 
                d[l]  = a[i];
            else
                d[r]  = a[i];
        }
    }
    printf(" %d\n ", len);        
}


int main()
{
     int caseTime;
    scanf( " %d " ,  &caseTime);
     while  (caseTime --   !=   0)
     {
        Solve();
    }
    system("pause ");
     return  0;
}

the second year of the university somebody started a study on the romantic relations between the students. The relation “romantically involved” is defined between one girl and one boy. For the study reasons it is necessary to find out the maximum set satisfying the condition: there are no two students in the set who have been “romantically involved”. The result of the program is the number of students in such a set.

The input contains several data sets in text format. Each data set represents one set of subjects of the study, with the following description:

the number of students
the description of each student, in the following format
student_identifier:(number_of_romantic_relations) student_identifier1 student_identifier2 student_identifier3 ...
or
student_identifier:(0)

The student_identifier is an integer number between 0 and n-1, for n subjects.
For each given data set, the program should write to standard output a line containing the result.

An example is given in Figure 1.

Input

7
0: (3) 4 5 6
1: (2) 4 6
2: (0)
3: (0)
4: (2) 0 1
5: (1) 0
6: (2) 0 1
3
0: (2) 1 2
1: (1) 0
2: (1) 0

Output

5
2

#include  < iostream >  
using   namespace  std;

const   int  MAXN  =   1001 ;
int  uN, vN;   // u,ｖ数目 
bool  g[MAXN][MAXN]; // g[i][j] 表示 xi与yj相连 
bool  p[MAXN][MAXN];
int  xM[MAXN], yM[MAXN];  //  输出量 
bool  chk[MAXN];  // 辅助量 检查某轮 y[v]是否被check 

int  sign[MAXN];
int  N;

bool  SearchPath( int  u)
{
     int  v;
     for  (v = 0 ; v < vN; v ++ )
     {
         if  (g[u][v]  &&   ! chk[v])
         {
            chk[v]  =   true ;
             if  (yM[v]  ==   - 1   ||  SearchPath(yM[v])) 
             {
                yM[v]  =  u;
                xM[u]  =  v;
                 return   true ;
            }
        }
    }
     return   false ;
}


int  MaxMatch()
{
     int  u;
     int  ret  =   0 ;
    memset(xM,  - 1 ,  sizeof (xM));
    memset(yM,  - 1 ,  sizeof (yM));
     for  (u = 0 ; u < uN; u ++ )
     {
         if  (xM[u]  ==   - 1 )
         {
            memset(chk,  false ,  sizeof (chk));
             if  (SearchPath(u)) ret ++ ;
        }
    }
     return  ret;
}

void  SetSign( int  v,  int  s)
{
     int  i;
    sign[v]  =  s;
     for  (i = 0 ; i < N; i ++ )
         if  (sign[i]  ==   - 1   &&  p[v][i])
            SetSign(i,  1 - s);     
}

void  Solve()
{
     int  i, j; 
     int  tU, tV;
     int  num;
    memset(g,  false ,  sizeof (g));
    memset(p,  false ,  sizeof (p));
    memset(sign,  - 1 ,  sizeof (sign));
     for  (i = 0 ; i < N; i ++ )
     {
        scanf( " \n%d: (%d) " ,  & tU,  & num);
         for  (j = 0 ; j < num; j ++ )
         {
            scanf( " %d " ,  & tV);
            p[tU][tV]  =   true ;
        }
    }  
    
     // -------------DFS标号法(划分二分图)-------------------- 
     /**/ /* ******************************************
    邻接表的DFS标号:
    void setmark(int v,int sign)
    {
        sig[v]=sign;
        int i;
        for (i=0;i<nu[v];i++)
            if (!sig[d[v][i]])
                setmark(d[v][i],sign^3);
    } 
    for (v=0;v<n;v++)
        if (!sig[v]) setmark(v,1);
    ******************************************* */
     for  (i = 0 ; i < N; i ++ )
         if  (sign[i]  ==   - 1 ) SetSign(i,  1 );
     // ------------------------------------------    
        
     for  (i = 0 ; i < N; i ++ )
     {
         if  (sign[i]  ==   1 )
         {
             for  (j = 0 ; j < N; j ++ )
                 if  (p[i][j]) g[i][j]  =   true ;
        }
    }             
    uN  =  vN  =  N;
    printf( " %d\n " , N - MaxMatch()); 
}  

int  main()
{
     while  (scanf( " %d " ,  & N)  !=  EOF)
     {
        Solve();
    }
     return   0 ;
}

Description

Bobobo and Bottle are good friends, and the birthday of Bottle is coming. So Bobobo is considering preparing Bottle an unexpected gift for his birthday. As a common sense that when a person at his or her birthday party, he or she will open the gift with the presence of the person who gives the gift and then expresses the appreciation. Bobobo knows that the characteristic of Bottle is rush when he receives something important, so he wants to play a joke on him in this way…

Input

The input file contains multiple test cases. The first line of each test case contains two numbers. The first one is a positive integer number N (1 ≤ N ≤ 500), the number of boxes in the gift shop, and the second one is a positive number d (3 ≤ d ≤ 1 000), the dimension of all the boxes. The next one line contains d positive integers ( G₁, G₂, …, G_d ) representing the dimensions of the gift. And the subsequent N lines each contain d positive integers ( X₁, X₂, …, X_d ) representing the dimensions of each box. You may assume that all the numbers you encounter are positive integers and less than 2³¹. The input data is terminated by EOF.

Output

The output of each test case will contain only one line. Output the maximum number of the boxes that Bobobo can choose. If Bobobo can not find any box which can contain the gift, output “Please look for another gift shop!”

Sample Input

5 7
4 6 8 2 7 5 3
2 8 13 6 10 9 4
80 70 12 3 6 8 2
8 7 4 6 9 10 12
100 200 300 400 500 600 700
800 800 800 800 800 800 800

Sample Output

3

Source
POJ Monthly--2006.09.29, sza

#include  < iostream >
#include  < algorithm >
using   namespace  std;

const   int  MAXN  =   510 ;
const   int  MAXM  =   1010 ;

int  n, m;
int  data[MAXN][MAXM];
int  map[MAXN][MAXN];
int  i, j, k;
int  f[MAXN];
int  d[MAXN];
int  ans;

int  DP( int  b)
{
     if  (d[b]  >   0 )  return  d[b];
     int  i;
     int  t  =   0 ;
     for  (i = 1 ; i <= n; i ++ )
     {
         if  (f[i]  &&  b  !=  i  &&  map[b][i]  &&  t  <  DP(i)  +   1 ) t  =  DP(i)  +   1 ;
    }
    d[b]  =  t;
     return  d[b];
}

int  main()
{   
     while  (scanf( " %d%d " ,  & n,  & m)  !=  EOF)
     {
         for  (i = 0 ; i <= n; i ++ )
         {
             for  (j = 0 ; j < m; j ++ )
                scanf( " %d " ,  & data[i][j]);
            sort(data[i], data[i] + m);
        }
        
        memset(f,  1 ,  sizeof (f));
        
         for  (i = 1 ; i <= n; i ++ )
             for  (j = 0 ; j < m; j ++ )
                 if  (data[i][j]  <=  data[ 0 ][j])
                 {
                    f[i]  =   0 ;
                     break ;
                }
                
         for  (i = 0 ; i <= n; i ++ )
             for  (j = 1 ; j <= n; j ++ )
             {
                map[i][j]  =   1 ;
                 for  (k = 0 ; k < m; k ++ )
                 {
                     if  (data[i][k]  >=  data[j][k])
                     {
                        map[i][j]  =   0 ;
                         break ;
                    }
                }
            }
            
        memset(d,  0 ,  sizeof (d));

        ans  =  DP( 0 );

         if  (ans  ==   0 )
            printf( " Please look for another gift shop!\n " );
         else
            printf( " %d\n " , ans);
                       
    }
    system( " pause " );
     return   0 ;
}

Description
The most exciting space discovery occurred at the end of the 20th century. In 1999, scientists traced down an ant-like creature in the planet Y1999 and called it M11. It has only one eye on the left side of its head and just three feet all on the right side of its body and suffers from three walking limitations:

1. It can not turn right due to its special body structure.
   
2. It leaves a red path while walking.
   
3. It hates to pass over a previously red colored path, and never does that.

The pictures transmitted by the Discovery space ship depicts that plants in the Y1999 grow in special points on the planet. Analysis of several thousands of the pictures have resulted in discovering a magic coordinate system governing the grow points of the plants. In this coordinate system with x and y axes, no two plants share the same x or y.
An M11 needs to eat exactly one plant in each day to stay alive. When it eats one plant, it remains there for the rest of the day with no move. Next day, it looks for another plant to go there and eat it. If it can not reach any other plant it dies by the end of the day. Notice that it can reach a plant in any distance.
The problem is to find a path for an M11 to let it live longest.
Input is a set of (x, y) coordinates of plants. Suppose A with the coordinates (xA, yA) is the plant with the least y-coordinate. M11 starts from point (0,yA) heading towards plant A. Notice that the solution path should not cross itself and all of the turns should be counter-clockwise. Also note that the solution may visit more than two plants located on a same straight line.

Input
The first line of the input is M, the number of test cases to be solved (1 <= M <= 10). For each test case, the first line is N, the number of plants in that test case (1 <= N <= 50), followed by N lines for each plant data. Each plant data consists of three integers: the first number is the unique plant index (1..N), followed by two positive integers x and y representing the coordinates of the plant. Plants are sorted by the increasing order on their indices in the input file. Suppose that the values of coordinates are at most 100.

Output
Output should have one separate line for the solution of each test case. A solution is the number of plants on the solution path, followed by the indices of visiting plants in the path in the order of their visits.

Sample Input

2
10
1 4 5
2 9 8
3 5 9
4 1 7
5 3 2
6 6 3
7 10 10
8 8 1
9 2 4
10 7 6
14
1 6 11
2 11 9
3 8 7
4 12 8
5 9 20
6 3 2
7 1 6
8 2 13
9 15 1
10 14 17
11 13 19
12 5 18
13 7 3
14 10 16

Sample Output

10 8 7 3 4 9 5 6 2 1 10
14 9 10 11 5 12 8 7 6 13 4 14 1 3 2

Source
Tehran 1999

#include  < iostream >
#include  < cmath >
#include  < algorithm >
using   namespace  std;

const   int  MAXN  =   1000 ;
const   int  INF  =   2000000000 ;

struct  XYDATA
{
     int  x, y, index;
} ;

int  inorder(XYDATA a, XYDATA b)
{
     return  a.y  <  b.y  ||  (a.y  ==  b.y  &&  a.x  <  b.x);
}

int  cross(XYDATA a, XYDATA b)
{
     return  a.x  *  b.y  -  a.y  *  b.x;
}

double  Cos(XYDATA a, XYDATA b)
{
     return  (a.x * b.x + a.y * b.y)  /  (sqrt(a.x * a.x + a.y * a.y)  *  sqrt(b.x * b.x + b.y * b.y));
}
void  Solve()
{
     int  n;
     int  i, j;
     int   out [MAXN];
     int  outSize  =   0  ;
     bool  mp[ 101 ][ 101 ];
     int  t;
     double  tmp;
    XYDATA a[MAXN];
    XYDATA v, u;
     int  beg;

    scanf( " %d " ,  & n);
     for  (i = 0 ; i < n; i ++ )
        scanf( " %d%d%d " ,  & a[i].index,  & a[i].x,  & a[i].y);
    
    sort(a, a + n, inorder);
    
     for  (i = 0 ; i < 101 ; i ++ )
         for  (j = 0 ; j < 101 ; j ++ )
            mp[i][j]  =   false ;

    v.x  =  a[ 0 ].x;
    v.y  =   0 ;
    mp[a[ 0 ].x][a[ 0 ].y]  =   true ;
    beg  =   0 ;
     out [outSize ++ ]  =  a[ 0 ].index;
     for  (i = 1 ; i < n; i ++ )
     {
         bool  isFind  =   false ;
        tmp  =   - 2 ;
         for  (j = 0 ; j < n; j ++ )
             if  (beg  !=  j  &&   ! mp[a[j].x][a[j].y])
             {
                u.x  =  a[j].x  -  a[beg].x;
                u.y  =  a[j].y  -  a[beg].y;
                 int  cro  =  cross(v, u);
                 if  (cro  >=   0 )    
                 {
                    isFind  =   true ;
                     if  (Cos(v, u)  >  tmp) 
                     {
                        tmp  =  Cos(v, u);
                        t  =  j;
                    }
                }
            }
         if  (isFind)
         {
            v.x  =  a[t].x  -  a[beg].x;
            v.y  =  a[t].y  -  a[beg].y;
            mp[a[t].x][a[t].y]  =   true ;
            beg  =  t;
             out [outSize ++ ]  =  a[t].index;
        }
         else  
         {
             break ;
        }
    }
    printf( " %d " , outSize);
     for  (i = 0 ; i < outSize; i ++ )
        printf( "  %d " ,  out [i]);
    printf( " \n " );
}


int  main()
{
     int  n;

    scanf( " %d " ,  & n);

     while  (n --   !=   0 )
     {
        Solve();
    }
     return   0 ;
}

Description
Optimus Mobiles produces mobile phones that support SMS messages. The Mobiles have a keypad of 12 keys, numbered 1 to 12. There is a character string assigned to each key. To type in the n-th character in the character string of a particular key, one should press the key n times. Optimus Mobiles wishes to solve the problem of assigning character strings to the keys such that for typing a random text out of a dictionary of common words, the average typing effort (i.e. the average number of keystrokes) is minimal.

Figure 1

To be more precise, consider a set of characters {a, b, c,..., z, +, *, /, ?} printed on a label tape as in Fig. 2. We want to cut the tape into 12 pieces each containing one or more characters. The 12 labels are numbered 1 to 12 from left to right and will be assigned to the keypad keys in that order.

Figure 2
You are to write a program to find the 11 cutting positions for a given dictionary of common words. The cutting positions should minimize the average number of keystrokes over all common words in the dictionary. Your output should be a string of 11 characters, where character i in this string is the first character of the (i+1)^th label.

Input
The first line contains a single integer t (1 <= t <= 10), the number of test cases. Each test case starts with a line, containing an integer M (1 <= M <= 10000), the number of common words in the test case. In each M subsequent line, there is a common word. Each common word contains at most 30 characters from the alphabet {a, b, c,..., z, +, *, /, ?}.

Output
The output contains one line per test case containing an optimal cut string. Obviously, there may be more than a single optimal cut string, so print the optimal cut string which is the smallest one in lexicographic order.

Sample Input

2
2
hi
ok
5
hello
bye
how
when
who

Sample Output

bcdefghijko
bcdefhlnowy

Source
Tehran 2003

#include  < iostream >
using   namespace  std;

const   int  INF  =   100000000 ;

int  f[ 13 ][ 30 ][ 30 ];
int  s[ 13 ][ 30 ][ 30 ];
int  l[ 13 ][ 30 ][ 30 ];
char  c[]  =   { ' a ' ,  ' b ' ,  ' c ' ,  ' d ' ,  ' e ' ,  ' f ' ,  ' g ' ,  ' h ' ,  ' i ' ,  ' j ' ,  ' k ' ,  ' l ' ,  ' m ' ,  ' n ' ,  ' o '
            ,  ' p ' ,  ' q ' ,  ' r ' ,  ' s ' ,  ' t ' ,  ' u ' ,  ' v ' ,  ' w ' ,  ' x ' ,  ' y ' ,  ' z ' ,  ' + ' ,  ' * ' ,  ' / ' ,  ' ? ' } ;

void  OutPut( int  k,  int  i,  int  j)
{
     if  (l[k][i][j]  >=   0 )
     {
        OutPut(l[k][i][j], i, s[k][i][j]);
    
        printf( " %c " , c[s[k][i][j] + 1 ]);
        
        OutPut(k - l[k][i][j], s[k][i][j] + 1 , j);    
    }
}

void  Solve()
{
     int  n;
     int  i, j, k, p, q, t, e;
     int  cntLable[ 300 ]  =   { 0 } ;
     int  sum;
     char  tmpS[ 31 ];
    scanf( " %d " ,  & n);
     for  (i = 0 ; i < n; i ++ )
     {
        scanf( " %s " , tmpS);
         for  (j = 0 ; j < strlen(tmpS); j ++ )
            cntLable[tmpS[j]] ++ ;
    }

     for  (k = 1 ; k <= 12 ; k ++ )
         for  (i = 0 ; i < 30 ; i ++ )
             for  (j = 0 ; j < 30 ; j ++ )
             {
                f[k][i][j]  =  INF;
                s[k][i][j]  =   - 1 ;
                l[k][i][j]  =   - 1 ;
            }

     // init k=1
     for  (i = 0 ; i < 30 ; i ++ )
     {
        sum  =   0 ;
         for  (j = i, k = 1 ; j < 30 ; j ++ , k ++ )
         {
            sum  +=  cntLable[c[j]]  *  k;
            f[ 1 ][i][j]  =  sum;
        }
    }

     for  (k = 2 ; k <= 12 ; k ++ )
         for  (i = 0 ; i < 30 ; i ++ )
             for  (j = i + k - 1 ; j < 30 ; j ++ )
             {
                 for  (t = i; t < j; t ++ )
                 {
                    e  =  k - 1   <  t - i + 1   ?  k - 1  : t - i + 1 ;
                     for  (p = 1 ; p <= e; p ++ )
                         if  (f[k][i][j]  >  f[p][i][t]  +  f[k - p][t + 1 ][j])
                         {
                            f[k][i][j]  =  f[p][i][t]  +  f[k - p][t + 1 ][j];
                            s[k][i][j]  =  t;
                            l[k][i][j]  =  p;
                        }
                }
            }

    OutPut( 12 ,  0 ,  29 );
    printf( " \n " );
}

int  main()
{
     int  n;
    scanf( " %d " ,  & n);
     while  (n --   !=   0 )
     {
        Solve();
    }
     return   0 ;
}

Spiderman’s workout
Time Limit:1000MS  Memory Limit:65536K
Total Submit:211 Accepted:63 Special Judged

Description
Staying fit is important for every super hero, and Spiderman is no exception. Every day he undertakes a climbing exercise in which he climbs a certain distance, rests for a minute, then climbs again, rests again, and so on. The exercise is described by a sequence of distances d1, d2, . . . , dm telling how many meters he is to climb before the first first break, before the second break, and so on. Froman exercise perspective it does not really matter if he climbs up or down at the i:th climbing stage, but it is practical to sometimes climb up and sometimes climb down so that he both starts and finishes at street level. Obviously, he can never be below street level. Also, he would like to use as low a building as possible (he does not like to admit it, but he is actually afraid of heights). The building must be at least 2 meters higher than the highest point his feet reach during the workout.

He wants your help in determining when he should go up and when he should go down. The answer must be legal: it must start and end at street level (0 meters above ground) and it may never go below street level. Among the legal solutions he wants one that minimizes the required building height. When looking for a solution, you may not reorder the distances.

If the distances are 20 20 20 20 he can either climb up, up, down, down or up, down, up, down. Both are legal, but the second one is better (in fact optimal) because it only requires a building of height 22, whereas the first one requires a building of height 42. If the distances are 3 2 5 3 1 2, an optimal legal solution is to go up, up, down, up, down, down. Note that for some distance sequences there is no legal solution at all (e.g., for 3 4 2 1 6 4 5).

Input
The first line of the input contains an integer N giving the number of test scenarios. The following 2N lines specify the test scenarios, two lines per scenario: the first line gives a positive integer M ≤ 40 which is the number of distances, and the following line contains the M positive integer distances. For any scenario, the total distance climbed (the sum of the distances in that scenario) is at most 1000.

Output
For each input scenario a single line should be output. This line should either be the string "IMPOSSIBLE" if no legal solution exists, or it should be a string of length M containing only the characters "U" and "D", where the i:th character indicates if Spiderman should climb up or down at the i:th stage. If there are several different legal and optimal solutions, output one of them (it does not matter which one as long as it is optimal).

Sample Input

3
4
20 20 20 20
6
3 2 5 3 1 2
7
3 4 2 1 6 4 5

Sample Output

UDUD
UUDUDD
IMPOSSIBLE

Source
Svenskt Mästerskap i Programmering 2003

ghost_wei说十分钟就能打完， 汗， 牛人。。

#include  < iostream >
#include  < cstdlib >
using   namespace  std;

const   int  MAXN  =   2001 ;
const   int  INF  =   2000000000 ;
int  dp[ 41 ][MAXN];
int  s[ 41 ][MAXN];
int  a[ 41 ];

void  print( int  n,  int  m)
{
     if  (n  ==   0 ) 
         return  ;

     if  (s[n][m]  ==   0 )
     {
        print(n - 1 , m - a[n]);
        printf( " U " );
    }
     else
     {
        print(n - 1 , m + a[n]);
        printf( " D " );
    }
}

void  solve()
{
     int  n;
     int  i, j;
     int  t1, t2;
     int  maxn  =   0 ;

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

    memset(dp,  - 1 ,  sizeof (dp));
    memset(s,  - 1 ,  sizeof (s));

    dp[ 1 ][a[ 1 ]]  =  a[ 1 ];
    s[ 1 ][a[ 1 ]]  =   0 ;

     for  (i = 2 ; i <= n; i ++ )
     {
         for  (j = 0 ; j < maxn; j ++ )
         {
            t1  =  INF;
            t2  =  INF;
             if  (j - a[i]  >=   0   &&  dp[i - 1 ][j - a[i]]  !=   - 1 )
                t1  =  max(j, dp[i - 1 ][j - a[i]]);
             if  (j + a[i]  <  maxn  &&  dp[i - 1 ][j + a[i]]  !=   - 1 )
                t2  =  max(j, dp[i - 1 ][j + a[i]]);
             if  (t1  <  t2)
             {
                dp[i][j]  =  t1;
                s[i][j]  =   0 ;
            }
             else
             {
                 if  (t2  !=  INF)
                 {
                    dp[i][j]  =  t2;
                    s[i][j]  =   1 ;
                }
            }
        }
    }
     if  (dp[n][ 0 ]  ==   - 1 )
        printf( " IMPOSSIBLE\n " );
     else
     {
        print(n,  0 );
        printf( " \n " );
    }
}

int  main()
{
     int  caseTime;

    scanf( " %d " ,  & caseTime);
     while  (caseTime --   !=   0 )
     {
        solve();
    }
     return   0 ;
}

Description
将一个８*８的棋盘进行如下分割：将原棋盘割下一块矩形棋盘并使剩下部分也是矩形，再将剩下的部分继续如此分割，这样割了(n-1)次后，连同最后剩下的矩形棋盘共有n块矩形棋盘。(每次切割都只能沿着棋盘格子的边进行)

原棋盘上每一格有一个分值，一块矩形棋盘的总分为其所含各格分值之和。现在需要把棋盘按上述规则分割成n块矩形棋盘，并使各矩形棋盘总分的均方差最小。
均方差，其中平均值，xi为第i块矩形棋盘的总分。
请编程对给出的棋盘及n，求出O'的最小值。

Input
第1行为一个整数n(1 < n < 15)。
第2行至第9行每行为8个小于100的非负整数，表示棋盘上相应格子的分值。每行相邻两数之间用一个空格分隔。

Output
仅一个数，为O'（四舍五入精确到小数点后三位）。

Sample Input

3
1 1 1 1 1 1 1 3
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 0
1 1 1 1 1 1 0 3

Sample Output

1.633

Source
Noi 99

#include  < iostream >
#include  < cstdlib >
#include  < cmath >
using   namespace  std;

const   int  INF  =   2000000000 ;
int  f[ 9 ][ 9 ][ 9 ][ 9 ][ 15 ];
int  s[ 9 ][ 9 ][ 9 ][ 9 ];
int  d[ 9 ][ 9 ];

void  init()
{
     int  x1, y1, x2, y2;
     int  i, j;
     int  sum;
     for  (x1 = 1 ; x1 <= 8 ; x1 ++ )
         for  (y1 = 1 ; y1 <= 8 ; y1 ++ )
             for  (x2 = x1; x2 <= 8 ; x2 ++ )
                 for  (y2 = y1; y2 <= 8 ; y2 ++ )
                 {
                    sum  =   0 ;
                     for  (i = x1; i <= x2; i ++ )
                         for  (j = y1; j <= y2; j ++ )
                            sum  +=  d[i][j];
                    s[x1][y1][x2][y2]  =  sum;
                    f[x1][y1][x2][y2][ 1 ]  =  sum  *  sum;
                }
}
int  main()
{

     int  n;
     int  i, j, k;
     int  x1, y1, x2, y2;
     int  a, b;
     int  t, tmp;
     double  p  =   0 ;

    scanf( " %d " ,  & n);
    
     for  (i = 1 ; i <= 8 ; i ++ )
         for  (j = 1 ; j <= 8 ; j ++ )
         {
            scanf( " %d " ,  & d[i][j]);
            p  +=  d[i][j];
        }

    p  /=  n;
//     cout << "?? "<< p << endl;

    init();

     for  (k = 2 ; k <= n; k ++ )
     {
         for  (x1 = 1 ; x1 <= 8 ; x1 ++ )
             for  (y1 = 1 ; y1 <= 8 ; y1 ++ )
                 for  (x2 = x1; x2 <= 8 ; x2 ++ )
                     for  (y2 = y1; y2 <= 8 ; y2 ++ )
                     {
                        tmp  =  INF;
                         // 竖切
                         for  (a = x1; a < x2; a ++ )
                         {
                            t  =  min(f[x1][y1][a][y2][k - 1 ] + s[a + 1 ][y1][x2][y2] * s[a + 1 ][y1][x2][y2]
                                , f[a + 1 ][y1][x2][y2][k - 1 ] + s[x1][y1][a][y2] * s[x1][y1][a][y2]);
                             if  (tmp  >  t) 
                                tmp  =  t;
                        }
                         // 横切
                         for  (b = y1; b < y2; b ++ )
                         {
                            t  =  min(f[x1][y1][x2][b][k - 1 ] + s[x1][b + 1 ][x2][y2] * s[x1][b + 1 ][x2][y2]
                                , f[x1][b + 1 ][x2][y2][k - 1 ] + s[x1][y1][x2][b] * s[x1][y1][x2][b]);
                             if  (tmp  >  t)
                                tmp  =  t;
                        }
                        
                        f[x1][y1][x2][y2][k]  =  tmp;
                    }
    }
    printf( " %.3f\n " , sqrt( double (f[ 1 ][ 1 ][ 8 ][ 8 ][n]) / double (n) - p * p));
     return   0 ;
}

Description

You are given a rectangular cake of integral dimensions w × h. Your goal is to divide this cake into m rectangular pieces of integral dimensions such that the area of the largest piece is minimal. Each cut must be a straight line parallel to one of the sides of the original cake and must divide a piece of cake into two new pieces of positive area. Note that since a cut divides only a single piece, exactly m − 1 cuts are needed.

If w = 4, h = 4, and m = 4, then the following cuts minimize the area of the largest piece:

However, if w = 4, h = 4, and m = 3, then the following cuts are optimal:

Input

The input test file will contain multiple test cases, each of which consists of three integers w, h, m separated by a single space, with 1 ≤ w, h, m ≤ 20 and m ≤ wh. The end-of-file is marked by a test case with w = h = m = 0 and should not be processed.

Output

For each test case, write a single line with a positive integer indicating the area of the largest piece.

Sample Input

4 4 4
4 4 3
0 0 0

Sample Output

4
6

Source
Stanford Local 2004

用了记忆化搜索, 900多ms才过掉， rp好啊..

#include  < iostream >
using   namespace  std;

int  f[ 21 ][ 21 ][ 21 ];

int  lookup( int  w,  int  h,  int  k)
{
     if  (f[w][h][k]  >   0 )  return  f[w][h][k];
     if  (k  ==   1 )
     {
        f[w][h][k]  =  w  *  h;
         return  f[w][h][k];
    }
     int  i, j;
     int  max1  =   2000000000 , max2  =   2000000000 ;
     int  t;

     // t = 0;
     for  (i = 1 ; i < w; i ++ )
     {
         for  (j = 1 ; j < k; j ++ )
         {
             if  (i * h  >=  j  &&  (w - i) * h  >=  k - j)
             {
                t  =  lookup(i, h, j)  >  lookup(w - i, h, k - j)  ?  lookup(i, h, j) : lookup(w - i, h, k - j);
                 if  (max1  >  t)
                    max1  =  t;
            }
        }
    }

     // t = 0;
     for  (i = 1 ; i < h; i ++ )
     {
         for  (j = 1 ; j < k; j ++ )
         {
             if  (w * i  >=  j  &&  w * (h - i)  >=  k - j)
             {
                t  =  lookup(w, i, j)  >  lookup(w, h - i, k - j)  ?  lookup(w, i, j) : lookup(w, h - i, k - j);
                 if  (max2  >  t)
                    max2  =  t;
            }
        }
    }

    f[w][h][k]  =  max1  <  max2  ?  max1 : max2;
     return  f[w][h][k];
}

int  g( int  w,  int  h,  int  k)
{
    memset(f,  0 ,  sizeof (f));
     return  lookup(w, h, k);
}

int  main()
{
     int  w, h, m;

     while  (scanf( " %d%d%d " ,  & w,  & h,  & m)  !=  EOF)
     {
         if  (w  ==   0   &&  h  ==   0   &&  m  ==   0 )  break ;
        printf( " %d\n " , g(w, h, m));
    }
     return   0 ;
}