In a certain shop, each kind of product has an integer price. For example, the price of a flower is 2 zorkmids (z) and the price of a vase is 5z. In order to attract more customers, the shop introduces some special offers.

A special offer consists of one or more product items together for a reduced price, also an integer. Examples:

• three flowers for 5z instead of 6z, or
• two vases together with one flower for 10z instead of 12z.

Write a program that calculates the price a customer has to pay for a purchase, making optimal use of the special offers to make the price as low as possible. You are not allowed to add items, even if that would lower the price.

For the prices and offers given above, the (lowest) price for three flowers and two vases is 14z: two vases and one flower for the reduced price of 10z and two flowers for the regular price of 4z.

PROGRAM NAME: shopping

INPUT FORMAT

The input file has a set of offers followed by a purchase.

Line 1:	s, the number of special offers, (0 <= s <= 99).
Line 2..s+1:	Each line describes an offer using several integers. The first integer is n (1 <= n <= 5), the number of products that are offered. The subsequent n pairs of integers c and k indicate that k items (1 <= k <= 5) with product code c (1 <= c <= 999) are part of the offer. The last number p on the line stands for the reduced price (1 <= p <= 9999). The reduced price of an offer is less than the sum of the regular prices.
Line s+2:	The first line contains the number b (0 <= b <= 5) of different kinds of products to be purchased.
Line s+3..s+b+2:	Each of the subsequent b lines contains three values: c, k, and p. The value c is the (unique) product code (1 <= c <= 999). The value k indicates how many items of this product are to be purchased (1 <= k <= 5). The value p is the regular price per item (1 <= p <= 999). At most 5*5=25 items can be in the basket.

SAMPLE INPUT (file shopping.in)

2
1 7 3 5
2 7 1 8 2 10
2
7 3 2
8 2 5

OUTPUT FORMAT

SAMPLE OUTPUT (file shopping.out)

14


代码：

/*
LANG: C
TASK: shopping
*/
#include<stdio.h>
#define MAXS 106
#define MAX 6
int encode[MAX];
int dp[MAX][MAX][MAX][MAX][MAX];
int sell[MAXS][MAXS];
int buy[MAX];
int s;
int Encode(int code)
{
    int i;
    for (i = 0; i < 5; i++)
    {
        if (encode[i] == code)
        {
            return i;
        }
        else if (!encode[i])
        {
            encode[i] = code;
            return i;
        }
    }
}
void Read()
{
    int i, j, code, n, c, k, b;
    scanf("%d", &s);
    for (i = 0; i < s; i++)
    {
        scanf("%d", &n);
        for (j = 0; j < n; j++)
        {
            scanf("%d%d", &c, &k);
            code = Encode(c);
            sell[i][code] = k;
        }
        scanf("%d", &sell[i][5]);
    }
    scanf("%d", &b);
    for (i = 0; i < b; i++)
    {
        scanf("%d%d", &c, &k);
        code = Encode(c);
        sell[s+i][code] = 1;
        buy[code] = k;
        scanf("%d", &sell[s+i][5]);
    }
    s += b;
}
void Solve()
{
    int i0, i1, i2, i3, i4, j, tmp;
    for (i0 = 0; i0 <= buy[0]; i0++)
    {
        for (i1 = 0; i1 <= buy[1]; i1++)
        {
            for (i2 = 0; i2 <= buy[2]; i2++)
            {
                for (i3 = 0; i3 <= buy[3]; i3++)
                {
                    for (i4 = 0; i4 <= buy[4]; i4++)
                    {
                        for (j = 0; j < s; j++)
                        {
                            if (i0 >= sell[j][0] && i1 >= sell[j][1] && i2 >= sell[j][2] && i3 >= sell[j][3] && i4 >= sell[j][4])
                            {
                                tmp = dp[i0 - sell[j][0]][i1 - sell[j][1]][i2 - sell[j][2]][i3 - sell[j][3]][i4 - sell[j][4]] + sell[j][5];
                                if (!dp[i0][i1][i2][i3][i4] || dp[i0][i1][i2][i3][i4] > tmp)
                                {
                                    dp[i0][i1][i2][i3][i4] = tmp;
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    printf("%d\n", dp[buy[0]][buy[1]][buy[2]][buy[3]][buy[4]]);
}
int main()
{
    freopen("shopping.in", "r", stdin), freopen("shopping.out", "w", stdout);
    Read();
    Solve();
    fclose(stdin), fclose(stdout);
    //system("pause");
    return 0;
}

                        

Sweet Butter

Farmer John has discovered the secret to making the sweetest butter in all of Wisconsin: sugar. By placing a sugar cube out in the pastures, he knows the N (1 <= N <= 500) cows will lick it and thus will produce super-sweet butter which can be marketed at better prices. Of course, he spends the extra money on luxuries for the cows.

FJ is a sly farmer. Like Pavlov of old, he knows he can train the cows to go to a certain pasture when they hear a bell. He intends to put the sugar there and then ring the bell in the middle of the afternoon so that the evening's milking produces perfect milk.

FJ knows each cow spends her time in a given pasture (not necessarily alone). Given the pasture location of the cows and a description of the paths the connect the pastures, find the pasture in which to place the sugar cube so that the total distance walked by the cows when FJ rings the bell is minimized. FJ knows the fields are connected well enough that some solution is always possible.

PROGRAM NAME: butter

INPUT FORMAT

• Line 1: Three space-separated integers: N, the number of pastures: P (2 <= P <= 800), and the number of connecting paths: C (1 <= C <= 1,450). Cows are uniquely numbered 1..N. Pastures are uniquely numbered 1..P.
• Lines 2..N+1: Each line contains a single integer that is the pasture number in which a cow is grazing. Cow i's pasture is listed on line i+1.
• Lines N+2..N+C+1: Each line contains three space-separated integers that describe a single path that connects a pair of pastures and its length. Paths may be traversed in either direction. No pair of pastures is directly connected by more than one path. The first two integers are in the range 1..P; the third integer is in the range (1..225).

SAMPLE INPUT (file butter.in)

3 4 5
2
3
4
1 2 1
1 3 5
2 3 7
2 4 3
3 4 5

INPUT DETAILS

          P2  
 P1 @--1--@ C1
     \    |\
      \   | \
       5  7  3
        \ |   \
         \|    \ C3
       C2 @--5--@
          P3    P4

OUTPUT FORMAT

• Line 1: A single integer that is the minimum distance the cows must walk to a pasture with a sugar cube.

SAMPLE OUTPUT (file butter.out)

8

OUTPUT DETAILS:

Putting the cube in pasture 4 means: cow 1 walks 3 units; cow 2 walks 5
units; cow 3 walks 0 units -- a total of 8.

题意：
给出农场的地图，以及哪些农区上有牛。农民在农区上放快butter。求所有牛到butter的距离之和最小值。

代码如下：
bellman：

/*
LANG: C
TASK: butter
*/
#include<stdio.h>
#define maxn 801
#define inf 100000000
int Edge[1450][3], dis[maxn], t[maxn];
void set(int f, int n)
{
    int i;
    for (i = 1; i <= n; i++)
    {
        dis[i] = inf;
    }
    dis[f] = 0;
}
int relax(int th)
{
    int u = Edge[th][0], v = Edge[th][1], w = Edge[th][2], sign = 0;
    if (dis[u] > dis[v] + w)
    {
        dis[u] = dis[v] + w;
        sign = 1;
    }
    if (dis[v] > dis[u] + w)
    {
        dis[v] = dis[u] + w;
        sign = 1;
    }
    return sign;
}
void bellman(int f, int n, int edgeNum)
{
    int i, j, sign;
    set(f, n);
    for (i = 1; i < n; i++)
    {
        for (j = 0, sign = 0; j < edgeNum; j++)
        {
            if (relax(j)) 
            {
                sign = 1;
            }
        }
        if (!sign)
        {
            break;
        }
    }
}
void find(m, n, edgeNum)
{
    int i, j, pre, sum;
    for (i = 1, pre = inf; i <= n; i++)
    {
        bellman(i, n, edgeNum);
        for (j = 0, sum = 0; j < m; j++)
        {
            sum += dis[t[j]];
        }
        if (pre > sum)
        {
            pre = sum;
        }
    }
    printf("%d\n", pre);
}
void read()
{
    int i, n, u, v, m, w, edgeNum;
    scanf("%d%d%d", &m, &n, &edgeNum);
    for (i = 0; i < m; i++)
    {
        scanf("%d", &t[i]);
    }
    for (i = 0; i < edgeNum; i++)
    {
        scanf("%d%d%d", &u, &v, &w);
        Edge[i][0] = u, Edge[i][1] = v, Edge[i][2] = w;
    }
    find(m, n, edgeNum);
}
int main()
{
    freopen("butter.in", "r", stdin), freopen("butter.out", "w", stdout);
    read();
    fclose(stdin), fclose(stdout);
    //system("pause");
    return 0;
}


spfa：

/*
LANG: C
TASK: butter
*/
#include<stdio.h>
#define maxn 801
#define inf 1 << 30
int t[maxn], len[maxn], dis[maxn], visit[maxn], queue[maxn * 3], nn[maxn], num = 0;
typedef struct node
{
    int to, w;
}N;
N map[maxn][maxn];
void setLen(int n)
{
    int i;
    for (i = 1; i <= n; i++)
    {
        len[i] = 0;
    }
}
void set(int s, int n)
{
    int i;
    for (i = 1; i <= n; i++)
    {
        dis[i] = inf, visit[i] = 0;
    }
    dis[s] = 0;
}
void add(int u, int v, int w)
{
    map[u][len[u]].to = v, map[u][len[u]].w = w, len[u]++;
    map[v][len[v]].to = u, map[v][len[v]].w = w, len[v]++;
}
void spfa(int s, int n)
{
    int i, head = 0, tial = 1, pre, j, v, w, relax;
    set(s, n);
    queue[head] = s;visit[s] = 1;
    while (head != tial)
    {
        pre = queue[head++], visit[pre] = 0;
        for (j = 0; j < len[pre]; j++)
        {
            v = map[pre][j].to, w = map[pre][j].w;
            relax = dis[pre] + w;
            if (dis[v] > relax)
            {
                dis[v] = relax;
                if (!visit[v])
                {
                    visit[v] = 1;
                    queue[tial++] = v;
                }
            }
        }
    }
    //for (i = 1; i <= n; i++)printf("%d ", dis[i]);    
}
void find(int h, int n)
{
    int i, j, min, pre;
    for (i = 1, min = inf; i <= n; i++)
    {
        spfa(i, n);
        for (j = 0, pre = 0; j < num; j++)
        {
            pre += dis[nn[j]] * t[nn[j]];
        }
        if (min > pre)
        {
            min = pre;
        }
    }
    printf("%d\n", min);
}
void read()
{
    int h, n, m, i, j, u, v, w, f;
    scanf("%d%d%d", &h, &n, &m);
    setLen(n);
    for (i = 0; i < h; i++)
    {
        scanf("%d", &f);
        if (t[f])
        {
            t[f]++;
        }
        else
        {
            t[f]++;
            nn[num++] = f;
        }
    }
    for (i = 0; i < m; i++)
    {
        scanf("%d%d%d", &u, &v, &w);
        add(u, v, w);
    }
    find(h, n);
}
int main()
{
    freopen("butter.in", "r", stdin), freopen("butter.out", "w", stdout);
    read();
    fclose(stdin), fclose(stdout);
    //system("pause");
    return 0;
}

Farmer John feeds his cows only the finest mixture of cow food, which has three components: Barley, Oats, and Wheat. While he knows the precise mixture of these easily mixable grains, he can not buy that mixture! He buys three other mixtures of the three grains and then combines them to form the perfect mixture.

Given a set of integer ratios barley:oats:wheat, find a way to combine them IN INTEGER MULTIPLES to form a mix with some goal ratio x:y:z.

For example, given the goal 3:4:5 and the ratios of three mixtures:

        1:2:3
        3:7:1
        2:1:2

For this example, you can combine eight units of mixture 1, one unit of mixture 2, and five units of mixture 3 to get seven units of the goal ratio:

    8*(1:2:3) + 1*(3:7:1) + 5*(2:1:2) = (21:28:35) = 7*(3:4:5)

Integers in the goal ratio and mixture ratios are all non-negative and smaller than 100 in magnitude. The number of units of each type of feed in the mixture must be less than 100. The mixture ratios are not linear combinations of each other.

PROGRAM NAME: ratios

INPUT FORMAT

SAMPLE INPUT (file ratios.in)

3 4 5
1 2 3
3 7 1
2 1 2

OUTPUT FORMAT

The output file should contain one line containing four integers or the word `NONE'. The first three integers should represent the number of units of each mixture to use to obtain the goal ratio. The fourth number should be the multiple of the goal ratio obtained by mixing the initial feed using the first three integers as mixing ratios.

SAMPLE OUTPUT (file ratios.out)

8 1 5 7

代码如下：

/*
LANG: C
TASK: ratios
*/
#include<stdio.h>
int map[4][3];
void read()
{
    int i, j;
    for (i = 0; i <4; i++)
    {
        for (j = 0; j < 3; j++)
        {
            scanf("%d", &map[i][j]);
        }
    }
}
int isOk(int a, int b, int c, int d)
{
    int j, sum;
    for (j = 0; j < 3; j++)
    {
        sum = a * map[1][j] + b * map[2][j] + c * map[3][j];
        if (sum != d * map[0][j])
        {
            return 0;
        }
    }
    return 1;
}
void deal()
{
    int i, j, k, h;
    for (i = 0; i < 100; i++)
    {
        for (j = 0; j < 100; j++)
        {
            for (k = 0; k < 100; k++)
            {
                for (h = 1; h < 100; h++)
                {
                     if (isOk(i, j, k, h))
                     {
                        printf("%d %d %d %d\n",  i, j, k, h);
                        return;
                    }
                }
            }
        }
    }
    printf("NONE\n");
}
int main()
{
    freopen("ratios.in", "r", stdin), freopen("ratios.out","w", stdout);
    read();
    deal();
    fclose(stdin), fclose(stdout);
    //system("pause");
    return 0;
}

Each of five opaque spinning wheels has one or more wedges cut out of its edges. These wedges must be aligned quickly and correctly. Each wheel also has an alignment mark (at 0 degrees) so that the wheels can all be started in a known position. Wheels rotate in the `plus degrees' direction, so that shortly after they start, they pass through 1 degree, 2 degrees, etc. (though probably not at the same time).

This is an integer problem. Wheels are never actually at 1.5 degrees or 23.51234123 degrees. For example, the wheels are considered to move instantaneously from 20 to 25 degrees during a single second or even from 30 to 40 degrees if the wheel is spinning quickly.

All angles in this problem are presumed to be integers in the range 0 <= angle <= 359. The angle of 0 degrees follows the angle of 359 degrees. Each wheel rotates at a certain integer number of degrees per second, 1 <= speed <= 180.

Wedges for each wheel are specified by an integer start angle and integer angle size (or `extent'), both specified in degrees. Wedges in the test data will be separated by at least one degree. The 'extent' also includes the original "degree" of the wedge, so '0 180' means degrees 0..180 inclusive -- one more than most would imagine.

At the start, which is time 0, all the wheels' alignment marks line up. Your program must determine the earliest time (integer seconds) at or after the start that some wedge on each wheel will align with the wedges on the other wheel so that a light beam can pass through openings on all five wedges. The wedges can align at any part of the rotation.

PROGRAM NAME: spin

INPUT FORMAT

Each of five input lines describes a wheel.

The first integer on an input line is the wheel's rotation speed. The next integer is the number of wedges, 1 <= W <= 5. The next W pairs of integers tell each wedge's start angle and extent.

SAMPLE INPUT (file spin.in)

30 1 0 120
50 1 150 90
60 1 60 90
70 1 180 180
90 1 180 60

OUTPUT FORMAT

A single line with a single integer that is the first time the wedges align so a light beam can pass through them. Print `none' (lower case, no quotes) if the wedges will never align properly.

SAMPLE OUTPUT (file spin.out)

9

题意：

给出五个圆的角速度和若干缺角的起始角度及缺角大小（角度单位).求出何时五个圆才能有缺角层叠，使得光线能通过这五个圆

代码如下：

/*
LANG: C
TASK: spin
*/
#include<stdio.h>
struct circle
{
    int w, n, s[360][2];
}circle[5];
int t[360];
void setZero()
{
    int i;
    for (i = 0; i < 360; i++)
    {
        t[i] = 0;
    }
}
int insert(int time)
{
    int i, j, k, round, start, end;
    for (i = 0; i < 5; i++)
    {
        for (j = 0; j < circle[i].n; j++)
        {
            round = circle[i].w * time;//求出从0到time转过的角度 
            start = (circle[i].s[j][0] + round) % 360;
            end = (circle[i].s[j][1] + round) % 360;
            if (end < start)//如果end < start，表示从起点到终点经过了0(X轴) 
            {
                for (k = start; k < 360; k++)
                {
                    t[k]++;
                }
                for (k = 0; k <= end; k++)
                {
                    t[k]++;
                }
            }
            else
            {
                for (k = start; k <= end; k++)
                {
                    t[k]++;
                }
            }
        }
    }
    for (i = 0; i < 360; i++)//有一个点大于或等于5，就表示光线能穿过。 
    {
        if (t[i] >= 5)
        {
            return 1;
        }
    }
    return 0;
}
void judge()
{
    int i;
    //至多只需要判断360秒，每个圆旋转最多只需要360秒就能复位，这样对于所有的圆，在360内一定能回到初始位置 
    for (i = 0; i < 360; i++)
    {
        setZero();//
        if (insert(i))
        {
            printf("%d\n", i);
            return;
        }
    }
    printf("none\n");
}        
int main()
{
    freopen("spin.in", "r", stdin), freopen("spin.out", "w", stdout);
    int i, j, start, r, end;
    for (i = 0; i < 5; i++)
    {
        scanf("%d%d", &circle[i].w, &circle[i].n);
        for (j = 0; j < circle[i].n; j++)
        {
            scanf("%d%d", &start, &r);
            end = (start + r) % 360;//求出其中一个缺角的结尾 
            circle[i].s[j][0] = start, circle[i].s[j][1] = end;
        }
    }
    judge();
    fclose(stdin), fclose(stdout);
    //system("pause");
    return 0;
}

Consider an ordered set S of strings of N (1 <= N <= 31) bits. Bits, of course, are either 0 or 1.

This set of strings is interesting because it is ordered and contains all possible strings of length N that have L (1 <= L <= N) or fewer bits that are `1'.

Your task is to read a number I (1 <= I <= sizeof(S)) from the input and print the Ith element of the ordered set for N bits with no more than L bits that are `1'.

PROGRAM NAME: kimbits

INPUT FORMAT

SAMPLE INPUT (file kimbits.in)

5 3 19

OUTPUT FORMAT

SAMPLE OUTPUT (file kimbits.out)

10011

题意：
找出N为的二进制数中1个数小于等于L的第I个数

代码如下：

/*
LANG: C
TASK: kimbits
*/
#include<stdio.h>
long long cmb[33][33];
void setCmb(long long n)
{
    long long i, j;
    for (i = 0; i <= n; i++)//零位数中'1'个数为0的情况数是1 
    {
        cmb[i][0] = 1;
        //cmb[i][i+1] = 0;
    }
    for (i = 1; i <= n; i++)//i位数中恰好有j个'1'的个数 
    {
        for (j = 1; j <= i; j++)
        {
            cmb[i][j] = cmb[i-1][j-1] + cmb[i-1][j];
        }
    }
    for (i = 0; i <= n; i++)//i位数中'1'个数小于等于j的情况数 
    {
        for (j = 1; j <= n; j++)
        {
            cmb[i][j] += cmb[i][j-1];
        }
    }
}
void find(long long n, long long m, long long th)
{
    long long i;
    for (i = n; i >= 1; i--)
    {
        //如果i-1位数中1个数大于等于th,说明前i-1位就能满足th个'1'个数小于等于m的数。
        if (cmb[i-1][m] >= th) 
        {
            printf("0");
        }
        else//否则，说明第i位是1，要利用到第i位 
        {
            printf("1");
            //情况数th减去第i位是0的前i-1位'1'个数小于等于m的情况数,剩下第i位是1，前i-1位'1'个数小于等于m-1的情况数 
            //已经定了一个'1'，接下来找小于等于m-1个'1'的情况
            th -= cmb[i-1][m--];            
        }
    }
    printf("\n");
}
int main()
{
    freopen("kimbits.in", "r", stdin), freopen("kimbits.out", "w", stdout);
    long long n, m, th;
    scanf("%lld%lld%lld", &n, &m, &th);
    setCmb(n);
    find(n, m, th);
    fclose(stdin), fclose(stdout);
    //system("pause");
    return 0;
}

The factorial of an integer N, written N!, is the product of all the integers from 1 through N inclusive. The factorial quickly becomes very large: 13! is too large to store in a 32-bit integer on most computers, and 70! is too large for most floating-point variables. Your task is to find the rightmost non-zero digit of n!. For example, 5! = 1 * 2 * 3 * 4 * 5 = 120, so the rightmost non-zero digit of 5! is 2. Likewise, 7! = 1 * 2 * 3 * 4 * 5 * 6 * 7 = 5040, so the rightmost non-zero digit of 7! is 4.

PROGRAM NAME: fact4

INPUT FORMAT

SAMPLE INPUT (file fact4.in)

7

OUTPUT FORMAT

SAMPLE OUTPUT (file fact4.out)

4

/*
LANG: C
TASK: fact4
*/
#include<stdio.h>
/*注意：不是只有最后一个数才影响阶乘结果的最后一位数 
比如：936 * 25 等于 4680 + 18720 = 23400，最后一位是4.
如果只取936最后一位跟25相乘是6 * 25 = 150，最后一位是5.
*/ 
int last(int n)
{
    int r;
    while (1)
    {
        r = n % 10;
        if (r)
        {
            return n % 1000;
        }
        n /= 10;
    }
}
int main()
{
    freopen("fact4.in", "r", stdin), freopen("fact4.out", "w", stdout);
    int n, m, i;
    scanf("%d", &n);
    m = 1;
    for (i = 2; i <= n; i++)
    {//printf("%d %d\n", m, i);
        //m = NonZero(m) * NonZero(i);
        m *= i;
        m = last(m);
    }
    printf("%d\n", m % 10);
    fclose(stdin), fclose(stdout);
    //system("pause");
    return 0;
}

Given a set of N stamp values (e.g., {1 cent, 3 cents}) and an upper limit K to the number of stamps that can fit on an envelope, calculate the largest unbroken list of postages from 1 cent to M cents that can be created.

For example, consider stamps whose values are limited to 1 cent and 3 cents; you can use at most 5 stamps. It's easy to see how to assemble postage of 1 through 5 cents (just use that many 1 cent stamps), and successive values aren't much harder:

• 6 = 3 + 3
• 7 = 3 + 3 + 1
• 8 = 3 + 3 + 1 + 1
• 9 = 3 + 3 + 3
• 10 = 3 + 3 + 3 + 1
• 11 = 3 + 3 + 3 + 1 + 1
• 12 = 3 + 3 + 3 + 3
• 13 = 3 + 3 + 3 + 3 + 1.

However, there is no way to make 14 cents of postage with 5 or fewer stamps of value 1 and 3 cents. Thus, for this set of two stamp values and a limit of K=5, the answer is M=13.

The most difficult test case for this problem has a time limit of 3 seconds.

PROGRAM NAME: stamps

INPUT FORMAT

SAMPLE INPUT (file stamps.in)

5 2
1 3

OUTPUT FORMAT

SAMPLE OUTPUT (file stamps.out)

13

题意：

给出一些硬币的面值，每种硬币无数个，取出若干硬币（个数不超过k)，将其面值相加，使得所求的所有面值能成为以1为等差的数列。
求出该数列的长度。

代码如下：

/*
LANG: C
TASK: stamps
*/
#include<stdio.h>
int value[50];
int s[2000010];
int cmp(const void * a, const void * b)
{
    return *((int*)a) - *((int*)b);
}
int main()
{
    //freopen("stamps.in", "r", stdin), freopen("stamps.out", "w", stdout);
    int n, m, i, j, k, t, h, max = 100000000;
    scanf("%d%d", &n, &m);
    for (i = 0; i < m; i++)
    {
        scanf("%d", &value[i]);
    }
    qsort(value, i, sizeof(int), cmp);
    t = n * value[i - 1];//最大的数不超过t 
    for (i = 1; i <= t; i++)
    {
        s[i] = max;
        for (j = 0; j < m; j++)
        {
            if (i < value[j])
            {
                continue;
            }
            if (s[i] > s[i-value[j]] + 1)
            {
                s[i] = s[i-value[j]] + 1;
            }        
        }
        if (s[i] != max)//如果s[i]没被改变过，表示该数列中断了。 
        {
            break;
        }
    }
    printf("%d\n", i - value[0]);
    //fclose(stdin), fclose(stdout);
    system("pause");
    return 0;
}

The cows have developed a new interest in scanning the universe outside their farm with radiotelescopes. Recently, they noticed a very curious microwave pulsing emission sent right from the centre of the galaxy. They wish to know if the emission is transmitted by some extraterrestrial form of intelligent life or if it is nothing but the usual heartbeat of the stars.

Help the cows to find the Truth by providing a tool to analyze bit patterns in the files they record. They are seeking bit patterns of length A through B inclusive (1 <= A <= B <= 12) that repeat themselves most often in each day's data file. They are looking for the patterns that repeat themselves most often. An input limit tells how many of the most frequent patterns to output.

Pattern occurrences may overlap, and only patterns that occur at least once are taken into account.

PROGRAM NAME: contact

INPUT FORMAT

SAMPLE INPUT (file contact.in)

2 4 10
01010010010001000111101100001010011001111000010010011110010000000

In this example, pattern 100 occurs 12 times, and pattern 1000 occurs 5 times. The most frequent pattern is 00, with 23 occurrences.

OUTPUT FORMAT

Lines that list the N highest frequencies (in descending order of frequency) along with the patterns that occur in those frequencies. Order those patterns by shortest-to-longest and increasing binary number for those of the same frequency. If fewer than N highest frequencies are available, print only those that are.

Print the frequency alone by itself on a line. Then print the actual patterns space separated, six to a line (unless fewer than six remain).

SAMPLE OUTPUT (file contact.out)

23
00
15
01 10
12
100
11
11 000 001
10
010
8
0100
7
0010 1001
6
111 0000
5
011 110 1000
4
0001 0011 1100

题意：
给出一个只含'0'或'1'的字符串。
求出字符串中长度在A到B之间的各个子串出现个数；


/*
LANG: C
TASK: contact
*/
#include<stdio.h>
#define maxn 200001
char str[maxn], p[maxn], q[13];
int T[maxn], h = 0;
typedef struct N
{
    int cnt, len;
    char q[13];
}M;
M N[10000];
int cmp(const void * a, const void * b)
{
    
    if ( ((M*)a)->cnt == ((M*)b)->cnt )//比较出现次数 
    {
        if (((M*)a)->len == ((M*)b)->len)//比较长度 
        {
            return strcmp(((M*)a)->q, ((M*)b)->q);//比较字典序 
        }
        return ((M*)a)->len - ((M*)b)->len;
    }
    return ((M*)b)->cnt - ((M*)a)->cnt;
}
void insert(int k, int num)//插入字符 
{
    if (p[k])
    {
        if (p[k] - '0')//如果p[k]是'1'，则往右走 
        {
            insert(k + 1, (num << 1) + 1);
        }
        else//否则，往左走 
        {
            insert(k + 1, num << 1);
        }
    }
}
void in()
{
    if (p[0] - '0')
    {
        insert(1, 3);
    }
    else
    {
        insert(1, 2);
    }
}
void pre(int k, int num, int L)
{
    if (T[num])//
    {
        if (num % 2)
        {
            q[k++] = '1';
        }
        else
        {
            q[k++] = '0';
        }
        q[k] = 0;
        if (k >= L)//对长度允许的字串保存 
        {
            strcpy(N[h].q, q);
            N[h].len = k;
            N[h++].cnt = T[num];
        }
        pre(k, num << 1, L), pre(k, (num << 1) + 1, L);//遍历左子树和右子树 
    }
}
int main()
{
    freopen("contact.in", "r", stdin);
    freopen("contact.out", "w", stdout);
    char s[81];
    int L, R, n, t, len, i, j, k, l;
    scanf("%d%d%d", &L, &R, &n);
    getchar();
    while (gets(s))
    {
        if (strcmp(s, "") == 0)
        {
            break;
        }
        strcat(str, s);
    }
    len = strlen(str);
    for (i = 0; i < len - L + 1; i++)
    {    
        for (j = 0, k = i; j < R && str[k] != 0; j++, k++)
        {
            p[j] = str[k];
            if (j >= L - 1)
            {
                p[j+1] = 0;
            }
        }
        in();//插入p 
    }
    pre(0, 2, L), pre(0, 3, L);//因为开始'0'是从数组T[2]进入,'1'是从T[3]进入，所以分成两颗树了 
    qsort(N, h, sizeof(M), cmp);
    for (i = 0, k = 0; i < h && k < n; i = j, k++)
    {
        printf("%d\n", N[i].cnt);
        printf("%s", N[i].q);
        for (j = i + 1, l = 1; j < h && N[j].cnt == N[i].cnt; j++, l++)//找出现次数相同的输出 
        {
            if (l == 6)//每六个一行 
            {
                l = 0;
                printf("\n%s", N[j].q);
            }
            else
            {
                printf(" %s", N[j].q);
            }    
        }
        printf("\n");
    }
    fclose(stdin), fclose(stdout);
    //system("pause");
    return 0;
}

Shaping Regions

N opaque rectangles (1 <= N <= 1000) of various colors are placed on a white sheet of paper whose size is A wide by B long. The rectangles are put with their sides parallel to the sheet's borders. All rectangles fall within the borders of the sheet so that different figures of different colors will be seen.

The coordinate system has its origin (0,0) at the sheet's lower left corner with axes parallel to the sheet's borders.

PROGRAM NAME: rect1

INPUT FORMAT

The order of the input lines dictates the order of laying down the rectangles. The first input line is a rectangle "on the bottom".

Line 1:	A, B, and N, space separated (1 <= A,B <= 10,000)
Lines 2-N+1:	Five integers: llx, lly, urx, ury, color: the lower left coordinates and upper right coordinates of the rectangle whose color is `color' (1 <= color <= 2500) to be placed on the white sheet. The color 1 is the same color of white as the sheet upon which the rectangles are placed.

SAMPLE INPUT (file rect1.in)

20 20 3
2 2 18 18 2
0 8 19 19 3
8 0 10 19 4

INPUT EXPLANATION

11111111111111111111
33333333443333333331
33333333443333333331
33333333443333333331
33333333443333333331
33333333443333333331
33333333443333333331
33333333443333333331
33333333443333333331
33333333443333333331
33333333443333333331
33333333443333333331
11222222442222222211
11222222442222222211
11222222442222222211
11222222442222222211
11222222442222222211
11222222442222222211
11111111441111111111
11111111441111111111

OUTPUT FORMAT

SAMPLE OUTPUT (file rect1.out)

1 91
2 84
3 187
4 38

题意：
给出每个玻璃的颜色，求它们按一定的顺序叠放后垂直方向上能被看到的各种颜色的面积。

代码：
1.矩形切割

/*
LANG: C
TASK: rect1
*/
#include<stdio.h>
#define nmax 1001
struct N
{
    int x1, y1, x2, y2, color;
}N[nmax];
int square[2501], currentColor, total;
void Calculation(int x1, int y1, int x2, int y2, int index)
{
    do//检查当前矩形是否没被其他矩形覆盖 
    {
        index++;
    }while (index <= total && (x1 >= N[index].x2 || x2 <= N[index].x1 || y1 >= N[index].y2 || y2 <= N[index].y1));
    if (index > total)//如果没被其他矩形覆盖，则计算当前矩形面积，加到属于颜色为currentColor的集合 
    {
        square[currentColor] += (x2 - x1) * (y2 - y1);
    }
    else//如果被覆盖，就将矩形切出没被N[index]覆盖的小矩形 
    {
        if (x1 < N[index].x1)
        {
            Calculation(x1, y1, N[index].x1, y2, index);
            x1 = N[index].x1;
        }
        if (x2 > N[index].x2)
        {
            Calculation(N[index].x2, y1, x2, y2, index);
            x2 = N[index].x2;
        }
        if (y1 < N[index].y1)
        {
            Calculation(x1, y1, x2, N[index].y1, index);
            y1 = N[index].y1;
        }
        if (y2 > N[index].y2)
        {
            Calculation(x1, N[index].y2, x2, y2, index);
            y2 = N[index].y2;
        }
    }
}
int main()
{
    freopen("rect1.in", "r", stdin);
    freopen("rect1.out", "w", stdout);
    int i, pre, width, length;
    scanf("%d%d%d", &width, &length, &total);
    N[0].x1 = N[0].y1 = 0, N[0].x2 = width, N[0].y2 = length, N[0].color = 1;
    pre = 0;
    for (i = 1; i <= total; i++)
    {
        scanf("%d%d%d%d%d", &N[i].x1, &N[i].y1, &N[i].x2, &N[i].y2, &N[i].color);
        if (pre < N[i].color)
        {
            pre = N[i].color;
        }
    }
    for (i = 0; i <= total; i++)
    {
        currentColor = N[i].color; 
        Calculation(N[i].x1, N[i].y1, N[i].x2, N[i].y2, i);
    }
    for (i = 1; i <= pre; i++)
    {
        if (square[i] > 0)
        {
            printf("%d %d\n", i, square[i]);
        }
    }
    fclose(stdin);
    fclose(stdout);
    //system("pause");
    return 0;
}
    


2.线段树

/*
LANG: C
TASK: rect1
*/
#include<stdio.h>
#define nmax 15000
int cmp(const void * a, const void * b)
{
    return *((int*)a) - *((int*)b);
}
int Cal[2501], ans[2501], X[2000];
struct Rec
{
    int x1, y1, x2, y2, color;
}Rec[1000];
struct seg
{
    int left, right, color;
}seg[3 * nmax];
void makeSeg(int left, int right, int num)
{
    seg[num].left = left, seg[num].right = right, seg[num].color = 0;//颜色初始化为0 
    if (left + 1 == right)
    {
        return;
    }
    int mid = (left + right) >> 1;
    makeSeg(left, mid, num << 1), makeSeg(mid, right, (num << 1) + 1);
}
void insert(int left, int right, int num, int color)
{
    if (seg[num].left + 1 != seg[num].right)
    {
        if (seg[num].color)//这里让孩子继承父节点的color。因为插进来的线段可能覆盖已存在的线段。 
        {
            seg[num << 1].color = seg[(num << 1) + 1].color = seg[num].color, seg[num].color = 0;
        }
    }
    if (left <= seg[num].left && seg[num].right <= right)//其区间在插入的线段内，设置color，表示插入该线段 
    {
        seg[num].color = color;
        return;
    }
    int mid = (seg[num].left + seg[num].right) >> 1;
    if (right <= mid)
    {
        insert(left, right, num << 1, color);
    }
    else if (left >= mid)
    {
        insert(left, right, (num << 1) + 1, color);
    }
    else
    {
        insert(left, mid, num << 1, color), insert(mid, right, (num << 1) + 1, color);
    }
}
void find(int num)
{
    if (seg[num].color)//如果该区间存在线段，则计算给区间长度，储存于改线段的颜色表中 
    {
        Cal[seg[num].color] += (seg[num].right - seg[num].left);
        return;
    }
    if (seg[num].left + 1 != seg[num].right)
    {
        find(num << 1), find((num << 1) + 1);
    }
}
int main()
{
    freopen("rect1.in", "r", stdin), freopen("rect1.out", "w", stdout);
    int width, length, number, i, j, large = 0, len;
    scanf("%d%d%d", &width, &length, &number);
    for (i = 0, j = 0; i < number; i++)
    {
        scanf("%d%d%d%d%d", &Rec[i].x1, &Rec[i].y1, &Rec[i].x2, &Rec[i].y2, &Rec[i].color);
        X[j++] = Rec[i].x1, X[j++] = Rec[i].x2;//储存x轴上的点 
        if (large < Rec[i].y2) 
        {
            large = Rec[i].y2;
        }
    }
    qsort(X, j, sizeof(int), cmp);//对x轴上的点排序 
    len = j;
    for (i = 0; i < len - 1; i++)
    {        
        if (X[i] != X[i+1])//计算X[i]到X[i+1]上各种颜色的面积 
        {
            makeSeg(0, large, 1);
            for (j = 0; j < number; j++)
            {
                if (Rec[j].x1 <= X[i] && Rec[j].x2 >= X[i+1])
                {
                    insert(Rec[j].y1, Rec[j].y2, 1, Rec[j].color);
                }
            }
            find(1);
            for (j = 2; j <= 2500; j++)
            {
                ans[j] += Cal[j] * (X[i+1] - X[i]);//Cal[j]是区间在X[i]到X[i+1]上颜色为j的矩形在y轴上的长度 
                Cal[j] = 0;
            }
        }
    }
    ans[1] = width * length;
    for (i = 2; i <= 2500; i++)
    {
        ans[1] -= ans[i];
    }
    for (i = 1; i <= 2500; i++)
    {
        if (ans[i])
        {
            printf("%d %d\n", i, ans[i]);
        }
    }
    fclose(stdin),fclose(stdout);    
    //system("pause");
    return 0;
}

For a given set of K prime numbers S = {p₁, p₂, ..., p_K}, consider the set of all numbers whose prime factors are a subset of S. This set contains, for example, p₁, p₁p₂, p₁p₁, and p₁p₂p₃ (among others). This is the set of `humble numbers' for the input set S. Note: The number 1 is explicitly declared not to be a humble number.

Your job is to find the Nth humble number for a given set S. Long integers (signed 32-bit) will be adequate for all solutions.

PROGRAM NAME: humble

INPUT FORMAT

SAMPLE INPUT (file humble.in)

4 19
2 3 5 7

OUTPUT FORMAT

SAMPLE OUTPUT (file humble.out)

27

题意：
在给出的素数中N[i]（humble numbers），取若干个数相乘可以产生其他humble number。求humbel number按大小排序后的第n个数。

可以按小到大生成n个humble numbers存在s数组中。所有的humble number都是有给出的素数因子相乘得出的。对每个素数，附上一
个变量index[i]，表示下次要乘上N[i]的数在s中的下标。则s[j]可以通过min(N[i] * s[index[i]])（i from 0 to k - 1）求得。然后
对于每一个N[i] * index[i] = s[j]的要index[i]++；因为s[i]以算过，对于N[i]的下一个更大的数肯定大于s[i]且在N[i] * s[index[i + 1]]内。

代码如下：

/*
LANG: C
TASK: humble
*/
#include<stdio.h>
#define nmax 100000
struct N
{
    int x, index;
}N[100];
int F[100], s[nmax]; 
int FindIndex(int n)
{
    int i, pre, index;    
    pre = F[0] = N[0].x * s[N[0].index], index = 0;
    for (i = 1; i < n; i++)
    {
        F[i] = N[i].x * s[N[i].index]; //求下一个humble number 
        if (pre > F[i])
        {
            pre = F[i], index = i;
        }
    }
    for (i = 0; i < n; i++)
    {
        if (F[i] == pre)//对于相乘只为pre的素数因子的小标自加。 
        {
            N[i].index++;
        }
    }
    return index;
}        
int main()
{
    freopen("humble.in", "r", stdin);
    freopen("humble.out", "w", stdout);
    int n, m, i, index;
    scanf("%d%d", &n, &m);
    for (i = 0; i < n; i++)
    {
        scanf("%d", &N[i].x);
        N[i].index = 0;//初始下标是0.因为s[0] = 1，第一个最小的数就是给出的数中的最小值 
    }
    s[0] = 1;
    for (i = 1; i <= m; i++)
    {
        index = FindIndex(n);
        s[i] = F[index];
    }
    printf("%d\n", s[m]);
    fclose(stdin);
    fclose(stdout);
    //system("pause");
    return 0;
}

The more points students score in our contests, the happier we here at the USACO are. We try to design our contests so that people can score as many points as possible, and would like your assistance.

We have several categories from which problems can be chosen, where a "category" is an unlimited set of contest problems which all require the same amount of time to solve and deserve the same number of points for a correct solution. Your task is write a program which tells the USACO staff how many problems from each category to include in a contest so as to maximize the total number of points in the chosen problems while keeping the total solution time within the length of the contest.

The input includes the length of the contest, M (1 <= M <= 10,000) (don't worry, you won't have to compete in the longer contests until training camp) and N, the number of problem categories, where 1 <= N <= 10,000.

Each of the subsequent N lines contains two integers describing a category: the first integer tells the number of points a problem from that category is worth (1 <= points <= 10000); the second tells the number of minutes a problem from that category takes to solve (1 <= minutes <= 10000).

Your program should determine the number of problems we should take from each category to make the highest-scoring contest solvable within the length of the contest. Remember, the number from any category can be any nonnegative integer (0, one, or many). Calculate the maximum number of possible points.

PROGRAM NAME: inflate

INPUT FORMAT

SAMPLE INPUT (file inflate.in)

300 4
100 60
250 120
120 100
35 20

OUTPUT FORMAT

SAMPLE OUTPUT (file inflate.out)

605

题意：
给出比赛最大时间M及比赛题目类型数目N。每种题目类型里可以有无数个题目。接下来N行，给出每种题目类型里一个题目的分数
和限定时间。要求在满足总时间M的情况下，能使得分数最多的题目安排。

代码如下：

/*
LANG: C
TASK:inflate
*/
#include<stdio.h>
#define nmax 10001
int score[nmax];
int main()
{
    freopen("inflate.in", "r", stdin);
    freopen("inflate.out", "w", stdout);
    int n, m, i, j, s, t;
    scanf("%d%d", &n, &m);
    for (i = 0; i < n; i++)
    {
        score[i] = 0;
    }
    for (i = 0; i < m; i++)//[i, j]表示前i+1种类型的题中，时间为j得到的最大分数 
    {
        scanf("%d%d", &s, &t);
        for (j = t; j <= n; j++)//因为对每种类型。取一题就需要t时间。所以可以从t开始。 
        {
            if (score[j] < score[j - t] + s)
            {
                score[j] = score[j - t] + s;
            }
        }
    }
    printf("%d\n", score[n]);
    fclose(stdin);
    fclose(stdout);
    //system("pause");
    return 0;
}
        

Farmer John has been elected mayor of his town! One of his campaign promises was to bring internet connectivity to all farms in the area. He needs your help, of course.

Farmer John ordered a high speed connection for his farm and is going to share his connectivity with the other farmers. To minimize cost, he wants to lay the minimum amount of optical fiber to connect his farm to all the other farms.

Given a list of how much fiber it takes to connect each pair of farms, you must find the minimum amount of fiber needed to connect them all together. Each farm must connect to some other farm such that a packet can flow from any one farm to any other farm.

The distance between any two farms will not exceed 100,000.

PROGRAM NAME: agrinet

INPUT FORMAT

SAMPLE INPUT (file agrinet.in)

4
0 4 9 21
4 0 8 17
9 8 0 16
21 17 16 0

OUTPUT FORMAT

The single output contains the integer length that is the sum of the minimum length of fiber required to connect the entire set of farms.

SAMPLE OUTPUT (file agrinet.out)

28

题意：
一个矩阵，[i,j]代表i和就之间的花费。求连接所有点的最小花费。最小生成树。

代码如下：

/*
LANG: C
TASK: agrinet
*/
#include<stdio.h>
#define inf 1000000000
#define nmax 100
int dis[nmax], visit[nmax], graph[nmax][nmax];
void Set(int n)
{
    int i, j;
    for (i = 0; i < n; i++)
    {
        dis[i] = inf, visit[i] = 0;
    }
}
int Prime(int n)
{
    int i, j, pre, next, sum = 0, min;
    for (i = 0, pre = 0; i < n - 1; i++)
    {
        visit[pre] = 1, min = inf;
        for (j = 0; j < n; j++)
        {         
            if (visit[j] == 0)
            {
                if (dis[j] > graph[pre][j])//更新没被加入mst的节点与当前mst的花费 
                {
                    dis[j] = graph[pre][j];
                }
                if (min > dis[j])//找当前没被加入mst的最小花费。 
                {
                    min = dis[j];
                    next = j;
                }
            }
        }
        pre = next;
        sum += dis[pre];
    }
    return sum;
}
int main()
{
    freopen("agrinet.in", "r", stdin);
    freopen("agrinet.out", "w", stdout);
    int i, j, n;
    scanf("%d", &n);
    Set(n);
    for (i = 0; i < n; i++)
    {
        for (j = 0; j < n; j++)
        {
            scanf("%d", &graph[i][j]);
        }
    }
    printf("%d\n", Prime(n));
    fclose(stdin);
    fclose(stdout);
    //system("pause");
    return 0;
}

Write a program that will accept a fraction of the form N/D, where N is the numerator and D is the denominator and print the decimal representation. If the decimal representation has a repeating sequence of digits, indicate the sequence by enclosing it in brackets. For example, 1/3 = .33333333...is denoted as 0.(3), and 41/333 = 0.123123123...is denoted as 0.(123). Use xxx.0 to denote an integer. Typical conversions are:

1/3     =  0.(3)
22/5    =  4.4
1/7     =  0.(142857)
2/2     =  1.0
3/8     =  0.375
45/56   =  0.803(571428)

PROGRAM NAME: fracdec

INPUT FORMAT

SAMPLE INPUT (file fracdec.in)

45 56

OUTPUT FORMAT

SAMPLE OUTPUT (file fracdec.out)

0.803(571428)

题意：
给出两个数N、D，求N除以D的结果。有循环小数的就将它们用圆括号括起来。如果能整除，要保留小数点后一位。

代码如下：

/*
LANG: C
TASK: fracdec
*/
#include<stdio.h>
#define nmax 100000
char s[nmax], ch[nmax];
int T[nmax];
int Dic(int n, int m)
{
    int i = 0, j, k = 0;
    s[i++] = '.';
    n = n % m;
    T[n] = 1;//标记求模过程中n出现过的位置。 
    if (!n)
    {
        s[i++] = '0';//如果n能被m整除，则小数点后保留一位 
    }
    while (n)
    {
        n *= 10; 
        s[i++] = n / m + '0';
        n = n % m;
        if (T[n])//如果n已经出现过，则表明有循环小数，标记出现过的位置，以便插入'(' 
        {
            k = T[n];
            break;
        }
        T[n] = i;//所求的模是配对下一位的。模拟一下就清楚 
    }
    s[i] = 0;
    return k;
}
int Turn(int n, int m) 
{
    int i, t = n / m;
    sprintf(ch, "%d", t);//将整数t转化为字符存放在ch字符数组里。 
    for (i = 0; ch[i] != 0; i++);
    return i;
}
void Cat(int f, int k)
{
    int i, sign = 1;
    if (k)
    {
        for (i = 0; s[i] != 0; i++)
        {
            if (sign && i == k)
            {
                ch[f++] = '(';
                i--;
                sign = 0;
            }
            else 
            {
                ch[f++] = s[i];
            }
        }
        ch[f++] = ')';
        ch[f] = 0;
    }
    else
    {
        for (i = 0; (ch[f] = s[i]) != 0; f++, i++);
    }
}
int main()
{
    freopen("fracdec.in", "r", stdin);
    freopen("fracdec.out", "w", stdout);
    int n, m, k, f, i;
    scanf("%d%d", &n, &m);
    k = Dic(n, m);//处理小数点以及小数点后的数 
    f = Turn(n, m);//处理小数点前面的数 
    Cat(f, k);//将两部分连接 
    for (i = 0; ch[i] != 0; i++)
    {
        printf("%c", ch[i]);
        if ((i + 1) % 76 == 0)//每行不超过76个字符 
        {
            printf("\n");
        }
    }
    if (i % 76)
    {
        printf("\n");
    }
    fclose(stdin);
    fclose(stdout);       
    //system("pause"); 
    return 0;      
}          
                        

Farmer John has a number of pastures on his farm. Cow paths connect some pastures with certain other pastures, forming a field. But, at the present time, you can find at least two pastures that cannot be connected by any sequence of cow paths, thus partitioning Farmer John's farm into multiple fields.

Farmer John would like add a single a cow path between one pair of pastures using the constraints below.

A field's `diameter' is defined to be the largest distance of all the shortest walks between any pair of pastures in the field. Consider the field below with five pastures, located at the points shown, and cow paths marked by lines:

                15,15   20,15
                  D       E
                  *-------*
                  |     _/|
                  |   _/  |
                  | _/    |
                  |/      |
         *--------*-------*
         A        B       C
         10,10   15,10   20,10

The `diameter' of this field is approximately 12.07106, since the longest of the set of shortest paths between pairs of pastures is the path from A to E (which includes the point set {A,B,E}). No other pair of pastures in this field is farther apart when connected by an optimal sequence of cow paths.

Suppose another field on the same plane is connected by cow paths as follows:

                         *F 30,15
                         / 
                       _/  
                     _/    
                    /      
                   *------ 
                   G      H
                   25,10   30,10

In the scenario of just two fields on his farm, Farmer John would add a cow path between a point in each of these two fields (namely point sets {A,B,C,D,E} and {F,G,H}) so that the joined set of pastures {A,B,C,D,E,F,G,H} has the smallest possible diameter.

Note that cow paths do not connect just because they cross each other; they only connect at listed points.

The input contains the pastures, their locations, and a symmetric "adjacency" matrix that tells whether pastures are connected by cow paths. Pastures are not considered to be connected to themselves. Here's one annotated adjacency list for the pasture {A,B,C,D,E,F,G,H} as shown above:

                A B C D E F G H
              A 0 1 0 0 0 0 0 0
              B 1 0 1 1 1 0 0 0
              C 0 1 0 0 1 0 0 0
              D 0 1 0 0 1 0 0 0
              E 0 1 1 1 0 0 0 0
              F 0 0 0 0 0 0 1 0
              G 0 0 0 0 0 1 0 1
              H 0 0 0 0 0 0 1 0

Other equivalent adjacency lists might permute the rows and columns by using some order other than alphabetical to show the point connections. The input data contains no names for the points.

The input will contain at least two pastures that are not connected by any sequence of cow paths.

Find a way to connect exactly two pastures in the input with a cow path so that the new combined field has the smallest possible diameter of any possible pair of connected pastures. Output that smallest possible diameter.

PROGRAM NAME: cowtour

INPUT FORMAT

SAMPLE INPUT (file cowtour.in)

8
10 10
15 10
20 10
15 15
20 15
30 15
25 10
30 10
01000000
10111000
01001000
01001000
01110000
00000010
00000101
00000010

OUTPUT FORMAT

The output consists of a single line with the diameter of the newly joined pastures. Print the answer to exactly six decimal places. Do not perform any special rounding on your output.

SAMPLE OUTPUT (file cowtour.out)

22.071068

题意：
给出小农区的坐标，和一个邻接矩阵，表示农区的连接情况。要求挑两个农区用一条边连接起来。使得它们的直径最小。（直径是相距最远的两个点的距离）

代码如下：

/*
LANG: C
TASK: cowtour
*/
#include<stdio.h>
#include<math.h>
double D[150][150];
char adj[150][150];
int lo[150][2], c[150], len[150], C[150][150];
double dis(int i, int j)//计算两点间的直接距离 
{
    int x1, y1, x2, y2;
    x1 = lo[i][0], y1 = lo[i][1], x2 = lo[j][0], y2 = lo[j][1];
    return sqrt(1.0 *(x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) );
}
void Setdis(int n)
{
    int i, j;
    double d;
    for (i = 0; i < n; i++)
    {
        for (j = 0; j < n; j++)
        {
            if (i == j)
            {
                D[i][j] = 0;
            }
            else
            {
                D[i][j] = -1;//两点间没有边或没有直接连起来的权值为-1 
            }
        }
    }
    for (i = 0; i < n; i++)
    {
        for (j = 0; j < n; j++)
        {
            if (j > i && adj[i][j] == '1')
            {
                d = dis(i, j), D[i][j] = d, D[j][i] = d;//对给出的数据求两点的距离 
            }
        }
    }
}
void Floyd(int n)//求任意两点间的最短路径 
{
    int i, j, k;
    for (k = 0; k < n; k++)
    {
        for (i = 0; i < n; i++)
        {
            for (j = 0; j < n; j++)
            {
                if (i != j && D[i][k] > 0 && D[k][j] > 0)//将能连接点求距离。 
                {
                    if (D[i][j] < 0)
                    {
                        D[i][j] = D[i][k] + D[k][j];
                    }
                    else if (D[i][j] > D[i][k] + D[k][j])
                    {
                        D[i][j] = D[i][k] + D[k][j];
                    }
                }
            }
        }
    }
}
void Colour(int n, int x, int colour)//对连同分量标记颜色 
{
    int i;
    for (i = 0; i < n; i++)
    {
        if (D[x][i] >= 0 && c[i] == -1)
        {
            c[i] = colour;
            C[colour][len[colour]++] = i;
            Colour(n, i, colour);
        }
    }
} 
int SetColour(int n)
{
    int i, j, colour;
    for (i = 0; i < n; i++)//-1表示没被着色过 
    {
        c[i] = -1, len[i] = 0;
    }
    for (i = 0, colour = 0; i < n; i++)
    {
        if (c[i] == -1)
        {
            Colour(n, i, colour++);
        }
    }
    return colour;
}
double Find(int x, int n)//寻找同个连通分量里点x到其他点的最长距离 
{
    int i;
    double dd = 0;
    for (i = 0; i < n; i++)
    {
        if (c[i] == c[x] && dd < D[x][i])
        {
            dd = D[x][i];
        }
    }
    return dd;
}
void FindPath(int n, int num)//农民只需要挑两个农场，使得连接起来后的直径是最小的。 
{
    int i, j, x, y, k;
    double min, pre, d, total;
    min = 1000000000.0;
    for (k = 0; k < num - 1; k++)
    {        
        for (i = 0; i < len[k]; i++)
        {        
            for (j = 0; j < len[k + 1]; j++)
            {
                d = dis(C[k][i], C[k+1][j]);//假设连线
                total = d + Find(C[k][i], n) + Find(C[k+1][j], n);
                if (min > total)
                {
                    min = total, x = C[k][i], y = C[k + 1][j], pre = d;            
                }
            }
        }
    }
    D[x][y] = pre;
}
double FindMax(int n)//找两者最长的，即求出两者之间的半径
{
    int i, j;
    double max = 0;
    for (i = 0; i < n; i++)
    {
        for (j = i + 1; j < n; j++)
        {
            if (max < D[i][j])
            {
                max = D[i][j];
            }
        }
    }
    return max;
}
int main()
{
    freopen("cowtour.in", "r", stdin);
    freopen("cowtour.out", "w", stdout);
    int n, i, num;
    scanf("%d", &n);
    for (i = 0; i < n; i++)
    {
        scanf("%d%d", &lo[i][0], &lo[i][1]);
    }
    for (i = 0; i < n; i++)
    {
        scanf("%s", adj[i]);
    }
    Setdis(n);
    Floyd(n);
    num = SetColour(n);//连同分量的个数 
    FindPath(n, num);
    Floyd(n);
    printf("%lf\n", FindMax(n));
    fclose(stdin);
    fclose(stdout);
    //system("pause");
    return 0;
}

Farmer John went crazy and created a huge maze of fences out in a field. Happily, he left out two fence segments on the edges, and thus created two "exits" for the maze. Even more happily, the maze he created by this overfencing experience is a `perfect' maze: you can find a way out of the maze from any point inside it.

Given W (1 <= W <= 38), the width of the maze; H (1 <= H <= 100), the height of the maze; 2*H+1 lines with width 2*W+1 characters that represent the maze in a format like that shown later - then calculate the number of steps required to exit the maze from the `worst' point in the maze (the point that is `farther' from either exit even when walking optimally to the closest exit). Of course, cows walk only parallel or perpendicular to the x-y axes; they do not walk on a diagonal. Each move to a new square counts as a single unit of distance (including the move "out" of the maze.

Here's what one particular W=5, H=3 maze looks like:

+-+-+-+-+-+
|         |
+-+ +-+ + +
|     | | |
+ +-+-+ + +
| |     |
+-+ +-+-+-+

Fenceposts appear only in odd numbered rows and and odd numbered columns (as in the example). The format should be obvious and self explanatory. Each maze has exactly two blank walls on the outside for exiting.

PROGRAM NAME: maze1

INPUT FORMAT

SAMPLE INPUT (file maze1.in)

5 3
+-+-+-+-+-+
|         |
+-+ +-+ + +
|     | | |
+ +-+-+ + +
| |     |
+-+ +-+-+-+

OUTPUT FORMAT

SAMPLE OUTPUT (file maze1.out)

9

A pair of cows is loose somewhere in the forest. Farmer John is lending his expertise to their capture. Your task is to model their behavior.

The chase takes place on a 10 by 10 planar grid. Squares can be empty or they can contain:

• an obstacle,
• the cows (who always travel together), or
• Farmer John.

The cows and Farmer John can occupy the same square (when they `meet') but neither the cows nor Farmer John can share a square with an obstacle.

Each square is represented as follows: . Empty square * Obstacle C Cows F Farmer

Here is a sample grid: *...*..... ......*... ...*...*.. .......... ...*.F.... *.....*... ...*...... ..C......* ...*.*.... .*.*......

The cows wander around the grid in a fixed way. Each minute, they either move forward or rotate. Normally, they move one square in the direction they are facing. If there is an obstacle in the way or they would leave the board by walking `forward', then they spend the entire minute rotating 90 degrees clockwise.

Farmer John, wise in the ways of cows, moves in exactly the same way.

The farmer and the cows can be considered to move simultaneously during each minute. If the farmer and the cows pass each other while moving, they are not considered to have met. The chase ends when Farmer John and the cows occupy the same square at the end of a minute.

Read a ten-line grid that represents the initial state of the cows, Farmer John, and obstacles. Each of the ten lines contains exactly ten characters using the coding above. There is guaranteed to be only one farmer and one pair of cows. The cows and Farmer John will not initially be on the same square.

Calculate the number of minutes until the cows and Farmer John meet. Assume both the cows and farmer begin the simulation facing in the `north' direction. Print 0 if they will never meet.

PROGRAM NAME: ttwo

INPUT FORMAT

SAMPLE INPUT (file ttwo.in)

*...*.....
......*...
...*...*..
..........
...*.F....
*.....*...
...*......
..C......*
...*.*....
.*.*......

OUTPUT FORMAT

SAMPLE OUTPUT (file ttwo.out)

49

题意：
给出地图，f表示农民，c表示牛，开始两者都向东。农民和牛都可以前进或顺时针转向，每个动作花费1分钟。
求何时两者相遇。插身而过不算相遇，要两者走到一起才算相遇。

代码如下：

/*
LANG: C
PROG: ttwo
*/
#include<stdio.h>
char map[10][11];
int fx, fy, cx, cy, fd, cd, time = 0;
int M[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
int sta[10][10][4][10][10][4];//表示状态。 
int Walk(int *x, int *y, int dic)//判断能否行走 
{
    *x += M[dic][0];
    *y += M[dic][1];
    if (*x >= 0 && *x < 10 && *y >= 0 && *y < 10 && map[*x][*y] != '*')
    {
        return 1;
    }
    *x -= M[dic][0];
    *y -= M[dic][1];
    return 0;
}
int Rotate(int *dic)
{
    *dic = (*dic + 1) % 4;
}
int Meet()
{
    if (fx == cx && fy == cy)
    {
        return 1;
    }
    return 0;
}
int Ok()
{
    if (sta[fx][fy][fd][cx][cy][cd])//如果之前走过，且状态相同，则两者不能相遇。 
    {
        return 0;
    }
    sta[fx][fy][fd][cx][cy][cd] = 1;//标记走过 
    return 1;
}
int Run()
{
    if (!Walk(&fx, &fy, fd))//不能走就转向。 
    {
        Rotate(&fd);
    }
    if (!Walk(&cx, &cy, cd))
    {
        Rotate(&cd);
    }
    time++;
    if (!Meet())//两者不相遇 
    {
        if (Ok())
        {            
            return Run();
        }
        else
        {
            return 0;
        }
    }
    else
    {
        return time;
    }
}
int main()
{
    freopen("ttwo.in", "r", stdin);
    freopen("ttwo.out", "w", stdout);
    int i, j;
    for (i = 0; i < 10; i++)
    {
        for (j = 0; j < 10; j++)
        {
            scanf("%c", &map[i][j]);
            if (map[i][j] == 'F')
            {
                fx = i, fy = j, fd = 0;
            }
            else if (map[i][j] == 'C')
            {
                cx = i, cy = j, cd = 0;
            }
        }
        getchar();
        map[i][j] = 0;
    }
    printf("%d\n", Run());
    fclose(stdin);
    fclose(stdout);
    //system("pause");
    return 0;
}

Some companies are partial owners of other companies because they have acquired part of their total shares of stock. For example, Ford owns 12% of Mazda. It is said that a company A controls company B if at least one of the following conditions is satisfied:

• Company A = Company B
• Company A owns more than 50% of Company B
• Company A controls K (K >= 1) companies denoted C₁, ..., C_K with each company C_i owning x_i% of company B and x₁ + .... + x_K > 50%.

Given a list of triples (i,j,p) which denote company i owning p% of company j, calculate all the pairs (h,s) in which company h controls company s. There are at most 100 companies.

Write a program to read the list of triples (i,j,p) where i, j and p are positive integers all in the range (1..100) and find all the pairs (h,s) so that company h controls company s.

PROGRAM NAME: concom

INPUT FORMAT

SAMPLE INPUT (file concom.in)

3
1 2 80
2 3 80
3 1 20

OUTPUT FORMAT

SAMPLE OUTPUT (file concom.out)

1 2
1 3
2 3

题意：
给出i公司占有j公司p%的股份，当p>50时，表示i控制了j. （i能直接或间接地控制j）。

代码如下：

/*
LANG: C
PROG: concom
*/
#include<stdio.h>
int max;
int t[110][110], v[110][110];
void Set()
{
    int i, j;
    for (i = 1; i <= 100; i++)
    {
        for (j = 1; j <= 100; j++)
        {
            t[i][j] = 0;
            v[i][j] = 0;
        }
    }
}
void Add(int x, int y)
{
    int i;
    for (i = 1; i <= max; i++)
    {
        if (x != i && v[x][i] <= 50)//当公司x没控制i公司时，才需要检查x是否能控制i。 
        {
            v[x][i] += t[y][i];
            if (v[x][i] > 50)
            {
                Add(x, i);
            }
        }
    }
}
int main()
{
    freopen("concom.in", "r", stdin);
    freopen("concom.out", "w", stdout);
    int i, j, k, p, n;
    scanf("%d", &n);
    Set();
    max = 0;
    for (i = 0; i < n; i++)
    {
        scanf("%d%d%d", &j, &k, &p);
        if (j > max)
        {
            max = j;
        }
        if (k > max)
        {
            max = k;
        }
        if (j != k)//排除输入不符合题意目的的情况。即排除自己占自己的的公司 
        {
            t[j][k] = p;
            v[j][k] = p;
        }
    }
    for (i = 1; i <= max; i++)
    {
        for (j = 1; j <= max; j++)
        {
            if (t[i][j] > 50)//当i占有j时，更新i占有j的邻接公司的股份。 
            {
                Add(i, j);
            }
        }
    }
    for (i = 1; i <= max; i++)
    {
        for (j = 1; j <= max; j++)
        {
            if ( v[i][j] > 50)
            {
                printf("%d %d\n", i, j);
            }
        }
    }
    fclose(stdin);
    fclose(stdout);
    //system("pause");
    return 0;
}