Farmer John takes the heritage of his cows very seriously. He is not, however, a truly fine bookkeeper. He keeps his cow genealogies as binary trees and, instead of writing them in graphic form, he records them in the more linear `tree in-order' and `tree pre-order' notations.

Your job is to create the `tree post-order' notation of a cow's heritage after being given the in-order and pre-order notations. Each cow name is encoded as a unique letter. (You may already know that you can frequently reconstruct a tree from any two of the ordered traversals.) Obviously, the trees will have no more than 26 nodes.

Here is a graphical representation of the tree used in the sample input and output:

                  C
                /   \
               /     \
              B       G
             / \     /
            A   D   H
           / \
          E   F

The in-order traversal of this tree prints the left sub-tree, the root, and the right sub-tree.

The pre-order traversal of this tree prints the root, the left sub-tree, and the right sub-tree.

The post-order traversal of this tree print the left sub-tree, the right sub-tree, and the root.

PROGRAM NAME: heritage

INPUT FORMAT

SAMPLE INPUT (file heritage.in)

ABEDFCHG
CBADEFGH

OUTPUT FORMAT

SAMPLE OUTPUT (file heritage.out)

AEFDBHGC 

Analysis

A simple problem with binary tree structure. The first element of preorder traversal is root, which is used of building a tree. Constructing recurrensively, the tree will be build successfully.
In this problem, I made a mistake of applying space. When I applying for a Node of root, I only declared it in the function without opening it. Well, the pointer outside became wandering.It is fantasy!

Code

/**//*
ID:braytay1
PROG:heritage
LANG:C++
*/
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
ifstream fin("heritage.in");
ofstream fout("heritage.out");
typedef struct Node{ 
      char  val;  
      struct Node *lc,*rc;
}Node, *BiTree;
Node* maketree(string &prev,string &inv){
    if (prev.size()==0||inv.size()==0) return NULL;
    Node *root=new Node[1];
    //This sentence is very IMPORTANT!!
    //The tree can only be saved with this sentence
    //since the variables declared in a function are
    //saved in the Stack Storage instead of globle storage.
    root->val=prev[0];
    string lp,li,rp,ri;
    int len=0;
    for (unsigned int i=0;;i++){
        if (inv[i]==prev[0]){
            len=i;
            break;
        }
    }
    for (int i=0;i<len;i++){
        lp.push_back(prev[i+1]);
        li.push_back(inv[i]);
    }
    for (int i=len+1;i<prev.size();i++){
        rp.push_back(prev[i]);
        ri.push_back(inv[i]);
    }
    root->lc=maketree(lp,li);
    root->rc=maketree(rp,ri);
    return root;
}
void post_tra(BiTree &r){
    if (r==NULL) return;
    post_tra(r->lc);
    post_tra(r->rc);
    fout<<r->val;
}
int main(){
    string pretra,intra;
    fin>>intra>>pretra;
    BiTree Top;
    Top=maketree(pretra,intra);
    post_tra(Top);
    fout<<endl;
    return 0;
};

Consider the following two-player game played with a sequence of N positive integers (2 <= N <= 100) laid onto a game board. Player 1 starts the game. The players move alternately by selecting a number from either the left or the right end of the sequence. That number is then deleted from the board, and its value is added to the score of the player who selected it. A player wins if his sum is greater than his opponents.

Write a program that implements the optimal strategy. The optimal strategy yields maximum points when playing against the "best possible" opponent. Your program must further implement an optimal strategy for player 2.

PROGRAM NAME: game1

INPUT FORMAT

SAMPLE INPUT (file game1.in)

6
4 7 2 9
5 2

OUTPUT FORMAT

SAMPLE OUTPUT (file game1.out)

18 11

Analysis

A typical game theory problem. The problem aims to find a solution for two players, which impletement optimal strategy for player 2. Considering the fact of only two operations for each step, making dynamic programming is helpful for these. F[i][j] is defined as the maximum sum for player 1 when choosing numbers among range [i,j], and s[i][j] stands for the sum of numbers among ith number and jth number. After all, new an array num[i] to store numbers.
Then, considering the two activities in choosing, which can only be happened for numbers of the first and the last one. Since the description needs an optimal strategy for player two, it is reasonable for maximum the result.
After all, the function can be presented below: f[i][j]=max{num[i]+sum[i+1][j]-f[i+1][j],num[j]+sum[i][j-1]-f[i][j-1]}, 1<=i,j<=n.
Initialization: f[i][i]=num[i], 1<=i<=n.
Tips in calculating: just only two variables: x,k. "j" is better fixed by x+k for f[i][j] is fully determined by f[i+1][j] and f[i][j-1], which are turing into f[x+1][x+k] and f[x][x+k-1]. It is obvious to making the first "for loop" of k and the next one is "x". Otherwise, i and j are too flexible to make loops.

Code

/**//*
ID:braytay1
PROG:game1
LANG:C++
*/
#include <iostream>
#include <fstream>
using namespace std;

int n;
int f[100][100],num[100],sum,s[100][100];

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

int main(){
    ifstream fin("game1.in");
    ofstream fout("game1.out");
    fin>>n;
    for(int i=0;i<n;i++) fin>>num[i];
    memset(f,0,sizeof f);
    memset(s,0,sizeof s);
    for(int i=0;i<n;i++) f[i][i]=num[i];
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            for(int k=i;k<=j;k++)
                s[i][j]+=num[k];
    for(int k=1;k<n;k++)
        for(int x=0;x+k<n;x++)        
            f[x][x+k]=max(num[x]+s[x+1][x+k]-f[x+1][x+k],num[x+k]+s[x][x+k-1]-f[x][x+k-1]);
    fout<<f[0][n-1]<<" "<<s[0][n-1]-f[0][n-1]<<endl;
    return 0;
}

Farmer John grazes his cows on a large, square field N (2 <= N <= 250) miles on a side (because, for some reason, his cows will only graze on precisely square land segments). Regrettably, the cows have ravaged some of the land (always in 1 mile square increments). FJ needs to map the remaining squares (at least 2x2 on a side) on which his cows can graze (in these larger squares, no 1x1 mile segments are ravaged).

Your task is to count up all the various square grazing areas within the supplied dataset and report the number of square grazing areas (of sizes >= 2x2) remaining. Of course, grazing areas may overlap for purposes of this report.

PROGRAM NAME: range

INPUT FORMAT

SAMPLE INPUT (file range.in)

6
101111
001111
111111
001111
101101
111001

OUTPUT FORMAT

Potentially several lines with the size of the square and the number of such squares that exist. Order them in ascending order from smallest to largest size.

SAMPLE OUTPUT (file range.out)

2 10
3 4
4 1  

Analysis

It is really a dynamic problem rather than a geometry problem, which is appeared at first time. However, it is easy to contribute a dynamic function later to replace older method.
Initially, map[i][j], established by initial input, stands for the minimum length of a square, which its left-top point is (i,j). And, for the nearby points (i+1,j), (i,j+1) and (i+1,j+1),if all avaliable, map[i][j] can be expanded by these three points since map[i][j] is truly depended on these three values.
What's more, considering the avaliable one for (i,j) is the minimum of these, then map[i][j]=min{map[i+1][j],map[i][j+1],map[i+1][j+1]}+1.
Additionally, only is the function hold when all of the four points is avaliable!

Code

/**//*
ID:braytay1
PROG:range
LANG:C++
*/
#include <iostream>
#include <fstream>
#include <string>
using namespace std;

int n;
int g[250][250],sum[251];
int min(int a,int b,int c){
    if (a>b) return (b>c)?c:b;
    else return (a>c)?c:a;
}
int main(){
    ifstream fin("range.in");
    ofstream fout("range.out");
    fin>>n;
    string tmp;
    memset(g,0,sizeof g);
    for (int i=0;i<n;i++){
        fin>>tmp;
        for (int j=0;j<n;j++){
            g[i][j]=(tmp[j]=='1')?1:0;
        }
        tmp.clear();
    }    
    for (int i=n-2;i>=0;i--)
        for (int j=n-2;j>=0;j--){
            if (g[i][j]&&g[i+1][j]&&g[i][j+1]&&g[i+1][j+1])
                g[i][j]=min(g[i+1][j],g[i][j+1],g[i+1][j+1])+1;
        }
    memset(sum,0,sizeof sum);
    for (int i=0;i<n-1;i++)
        for (int j=0;j<n-1;j++){
            int s;
            s=g[i][j];
            sum[s]++;
        } 
    for (int i=2;i<=n;i++){
        for (int j=i+1;j<=n;j++){
            sum[i]+=sum[j];
        }
    }
    for (int i=2;i<=n;i++)
        if (sum[i]) fout<<i<<" "<<sum[i]<<endl;
    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

Analysis

At first glance of it, it is nice for a single integer saving situations rather than string which is told in the description. But for the 10th data, it seems small for 31 31 2^31. To deal with it, take it away and print answer independently. For other situations, find the maximum bit recursively.

Code

/**//*
ID:braytay1
PROG:kimbits
LANG:C++
*/
#include <iostream>
#include <fstream>
using namespace std;
int cmb_lab[34][34];
int cmb_num[34][34];
int n,l;
long long int no;
int count(long long int s){
    int ret=0;
    while (s){
        s&=(s-1);
        ret++;
    }
    return ret;
}
long long int dealing(long long int a,int l1){
    if (a<=1) return 0;
    int cur;
    long int cur_sum=0;
    for (cur=0;cur<=n;cur++){
        cur_sum+=cmb_num[cur][l1 ];
        if (cur_sum>=a) break;
    }
    long long int leave;
    long long int res;
    leave=a-cur_sum+cmb_num[cur][l1];
    res=1<<(cur-1);
    res+=dealing(leave,l1-1);
    return res;
}
int main(){
    ifstream fin("kimbits.in");
    ofstream fout("kimbits.out");
    fin>>n>>l>>no;
    if (no==1){
        for (int i=1;i<=n;i++)
            fout<<0;
        fout<<endl;
        return 0;
    }
    memset(cmb_lab,0,sizeof(cmb_lab));
    cmb_lab[0][0]=1;
    for (int i=1;i<=32;i++){
        for (int j=0;j<=32;j++){
            if (j==0||j==i) cmb_lab[i][j]=1;
            else cmb_lab[i][j]=cmb_lab[i-1][j-1]+cmb_lab[i-1][j];
        }
    }
    for (int k=0;k<=l;k++){
        if (k>0) cmb_num[0][k]=1;
        else cmb_num[0][k]=0;
        for (int i=1;i<=n;i++){
            int sum=0;
            for (int j=0;j<k;j++){
                sum+=cmb_lab[i-1][j];
            }
            cmb_num[i][k]=sum;
        }
    }
    long long int res;
    if (n==31&&l==31) {
        res=no-1;
        for (int i=n-1;i>=0;i--){
            if (res&(1<<i)) fout<<1;
            else fout<<0;
        }
        fout<<endl;
        return 0;
    }
    res=dealing(no,l);
    for (int i=n-1;i>=0;i--){
        if (res&(1<<i)) fout<<1;
        else fout<<0;
    }
    fout<<endl;
    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

Analysis

Considering the small amount of 4,220, we can find that the highest number of zeros is 5 since 5^5<4,220<5^6. What we are interested in is the last 6 numbers after each step of factorial. At last, we may output the last non-zero digit.

Code

/**//*
ID:braytay1
PROG:fact4
LANG:C++
*/
#include <iostream>
#include <fstream>
using namespace std;

int main(){
    ifstream fin("fact4.in");
    ofstream fout("fact4.out");
    int n;
    int s;
    fin>>n;
    s=1;
    for (int i=1;i<=n;i++){
        s*=i;
        if (s>=100000&&s%10==0) {
            while (s%10==0)    
                s/=10;
            s%=100000;
        }
        else s%=100000;
    }
    while (s%10==0)    
        s/=10;
    fout<<s%10<<endl;
    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
    

Analysis

This problem is also a DP problem. Considering the minimum volumn of a bag that cannot be stored by the K stamps and N kinds of the given stamps, we can find the problem becomes to find the dynamic function to describe it. We call f[i] as the minimum number of stamps to get the value of i, which depends on the minimum of a set of f[i-value[j]]+1),((i-Value[j]>=0 j=1..Stamps).

In order to abbreviate functioning amount, find out the MaxValue, which is the maximum of set Value[i], and all of its multiples can be only fixed with i/MaxValue.

At last,the edge of the problem is when f[k]>maxuse and print k-1.

Code

/**//*
ID:braytay1
PROG:stamps
LANG:C++
*/
#include <iostream>
#include <fstream>
#define min(a,b) (a<b)?a:b
using namespace std;


int main(){
    ifstream fin("stamps.in");
    ofstream fout("stamps.out");
    int k1,n,max=-1;
    int s[51];
    short int f[2000000];
    fin>>k1>>n;
    for (int i=1;i<=n;i++) {fin>>s[i];max=(max>s[i])?max:s[i];}
    if (max==1) {fout<<max*k1<<endl;return 0;}
    memset(f,100,sizeof(f));
    f[0]=0;
    for (int j=1,k=max;k<=max*k1;k+=max,j++) f[k]=j;
    int kk;
    for (kk=1;kk<=max*k1;++kk){
        if (kk%max==0) continue;
        for (int j=1;j<=n;++j) {
            if (kk-s[j]>=0) 
                if (f[kk-s[j]]+1<f[kk]) f[kk]=f[kk-s[j]]+1;
        }
        if (f[kk]>k1) break;
    }
    fout<<kk-1<<endl;
    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

Analysis

At the first glance of it, I missunderstood it as a DP problem. But later, I realized that we can simply make an array to store all of the "humble numbers", which is constructed in a way to add the minimum number among all the numbers just larger than the last one.
To archive it within little time, I use an array recording the power of the given prime number, for instance, the power of p[i] is called pri[i], and increasing the pri[i] to find the minimum number.

Code

/**//*
ID:braytay1
PROG:humble
LANG:C++
*/
#include <iostream>
#include <fstream>
using namespace std;

int main(){
    ifstream fin("humble.in");
    ofstream fout("humble.out");
    int k,n;
    int p[100],pri[100];
    long long int humble[100001];
    fin>>k>>n;
    for (int i=0;i<k;i++) fin>>p[i];
    memset(pri,0,sizeof(pri));
    memset(humble,0,sizeof(humble));
    humble[0]=1;
    int max=-1;
    for (int i=0;i<k;i++){
        if (max<p[i]) max=p[i];
    }    
    for (int i=1;i<=n;i++){
        long long int min;
        min=humble[i-1]*p[0]*p[0];
        for (int k1=0;k1<k;k1++){
            while(humble[pri[k1]]*p[k1]<=humble[i-1]) pri[k1]++;
            if (humble[pri[k1]]*p[k1]<min) min=humble[pri[k1]]*p[k1];
        }
        humble[i]=min;
    }
    fout<<humble[n]<<endl;
    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

(Take two problems from #2 and three from #4.)

Analysis

This problem seems like a complete package problem, so do it traditionally with some amolaration. As the dynamic function can be writen as f[i][v]=max{f[i-1][v-k*t[i]]+s[i]|0<=k*t[i]<=M}, which aims to calculate the highest score after the choice of the ith problem class within v time. But we can calculate it in a new way.
Traditionally, we calculate it with some for loops:

for (int i=1;i<=N;i++)
    for (int v=0;v<=M;v++){
        for (int k=0;k*t[i]<=M;k++){
            if (max<f[i-1][v-k*t[i]]+s[i]) max=f[i-1][v-k*t[i]]+s[i];
           }
           f[i][v]=max;
       }       

Sooner, this algorithm seems too slow for its three for loops and the cost of memories needs a lot. However, it's obvious to see the dynamic funtion is special because the ith situation can only be determined by the last situation: (i-1)th. So, records the result with a 1D array instead of the 2D one to  save memories.
Considering the fact that f[i][0]=0 is really useless, we can later change the 3 for loops into 2 loops and cut boundary. Here I provide the new algorithm:

for (int i=1;i<=N;i++)
    for (int v=t[i];v<=M;v++)
        f[v]=max{f[v],f[v-t[i]]+s[i]};

Code

/**//*
ID:braytay1
PROG:inflate
LANG:C++
*/
#include <iostream>
#include <fstream>
using namespace std;

int main(){
    ifstream fin("inflate.in");
    ofstream fout("inflate.out");
    int N,M;
    fin>>M>>N;
    int f[10001];
    int t[10001],s[10001];
    for (int i=1;i<=N;i++){
        fin>>s[i]>>t[i];
    }
    for (int v=0;v<=M;v++){
        f[v]=v/t[1]*s[1];
    }
    for (int i=2;i<=N;i++){
        int cost;
        cost=t[i];
        for (int v=cost;v<=M;v++){
            f[v]=(f[v]>(f[v-t[i]]+s[i]))?f[v]:(f[v-t[i]]+s[i]);
        }
    }
    fout<<f[M]<<endl;
    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

Analysis

A very traditional MST problem. Just use the Prim algorithm can get though it. Here I provide some simple descriptions about the Prim algorithm.
The Prim algorithm plans to add a shortest path to the set A, which records the MST, and abandon the edge composed a cycle.

Code

/**//*
ID:braytay1
PROG:agrinet
LANG:C++
*/
#include <iostream>
#include <fstream>
using namespace std;
    
int N;
int map[101][101];
int pi[101],key[101];
bool Q[101];
int min(int *a,bool *b){
    int res=10000000,mini;
    for (int i=0;i<N;i++){
        if (res>*(a+i)&&*(b+i)==false) {res=*(a+i);mini=i;}
    }
    return mini;
}
bool isempty(bool *a){
    for (int i=0;i<N;i++){
        if (!*(a+i)) return false;
    }
    return true;
}
void prim(int g[101][101],int r){
    for (int u=0;u<N;u++){
        key[u]=1000000;
        pi[u]=0;
        Q[u]=false;
    }
    key[r]=0;
    int u1;
    while (!isempty(Q)){
        u1=min(key,Q);
        Q[u1]=true;
        for (int v=0;v<N;v++){
            if (g[u1][v]&&Q[v]==false&&g[u1][v]<key[v]) {pi[v]=u1;key[v]=g[u1][v];}
        }        
    }
}
int main(){
    ifstream fin("agrinet.in");
    ofstream fout("agrinet.out");
    fin>>N;
    for (int i=0;i<N;i++)
        for (int j=0;j<N;j++){
            fin>>map[i][j];
        }
    prim(map,0);
    int res=0;
    for (int i=0;i<N;i++) res+=key[i];
    fout<<res<<endl;
    return 0;
}

It's dinner time, and the cows are out in their separate pastures. Farmer John rings the bell so they will start walking to the barn. Your job is to figure out which one cow gets to the barn first (the supplied test data will always have exactly one fastest cow).

Between milkings, each cow is located in her own pasture, though some pastures have no cows in them. Each pasture is connected by a path to one or more other pastures (potentially including itself). Sometimes, two (potentially self-same) pastures are connected by more than one path. One or more of the pastures has a path to the barn. Thus, all cows have a path to the barn and they always know the shortest path. Of course, cows can go either direction on a path and they all walk at the same speed.

The pastures are labeled `a'..`z' and `A'..`Y'. One cow is in each pasture labeled with a capital letter. No cow is in a pasture labeled with a lower case letter. The barn's label is `Z'; no cows are in the barn, though.

PROGRAM NAME: comehome

INPUT FORMAT

SAMPLE INPUT (file comehome.in)

5
A d 6
B d 3
C e 9
d Z 8
e Z 3

OUTPUT FORMAT

SAMPLE OUTPUT (file comehome.out)

B 11

Analysis

Since the problem aims to solve a single-source shortest path problem, we can use the classical algorithms, such as Dijkstra, Bellman-Ford and the Floyd algorithm. Thanks to the small data amount, all of them are correct for this prblem.

Code

/**//*
ID:braytay1
TASK:comehome
LANG:C++
*/
#include <iostream>
#include <fstream>
using namespace std;
ifstream fin("comehome.in");
ofstream fout("comehome.out");

int map[55][55];
int dis[55];

void bellman_ford(){
    dis[52]=0;
    for (int k=1;k<52;k++)
        for (int u=1;u<=52;u++)
            for (int v=1;v<=52;v++)
                if ((dis[v]>dis[u]+map[u][v])&&map[u][v]<=10000) 
                    dis[v]=dis[u]+map[u][v];
}
char find_min(int a[55]){
    char source;
    int min=1000000;
    for (int i=27;i<=51;i++){
        if (min>a[i]) {min=a[i];source=i-26+64;}
    }
    return source;
}
int main(){
    int N;
    fin>>N;
    memset(map,100,sizeof(map));
    for (int i=1;i<=N;i++){
        char source,dest;
        fin>>source>>dest;
        int s,d;
        s=(source>=97&&source<=122)?(source-96):(source-64+26);
        d=(dest>=97&&dest<=122)?(dest-96):(dest-64+26);
        int ds;
        fin>>ds;
        if (ds<map[s][d]) map[s][d]=ds;        
        map[d][s]=map[s][d];
    }
    memset(dis,100,sizeof(dis));
    bellman_ford();
    char res;
    res=find_min(dis);
    fout<<res<<" "<<dis[res-64+26]<<endl;
    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

Analysis

This problem is a graph travelling problem. The DFS is needed. Here I provide the official analysis.

The method used here to solve the problem is as follows. We keep track of which companies control which other companies, and every time we hear that so and so owns this much percent of so and so, we update our information.
The array "owns" keeps track of how much of company j is owned by company i, whether directly or via controlled companies. The array "controls" keeps track of which companies are controlled by which other companies.

code

/**//*
ID:braytay1
PROG:concom
LANG:C++
*/
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
ofstream fout("concom.out");
ifstream fin("concom.in");
int stock[101][101],cx[101],n;
bool con[101][101],vis[101];

void DFS(int com){
    if (vis[com]) return;
    vis[com]=true;
    for (int i=1;i<=100;i++){
        cx[i]+=stock[com][i];
        if (cx[i]>50&&i!=com){            
            DFS(i);
        }
    }
}
int main(){
    fin>>n;
    memset(stock,0,sizeof(stock));
    for (int k=1;k<=n;k++){
        int i,j,p;
        fin>>i>>j>>p;
        stock[i][j]=p;
    }
    for (int i=1;i<=100;i++) stock[i][i]=100;
    memset(cx,0,sizeof(cx));
    memset(vis,false,sizeof(vis));
    memset(con,false,sizeof(con));
    for(int i=1;i<=100;i++){
        DFS(i);
        for(int j=1;j<=100;j++){
            if (cx[j]>50) con[i][j]=true;
        }
        memset(cx,0,sizeof(cx));
        memset(vis,false,sizeof(vis));
    }
    for(int i=1;i<=100;i++){
        for(int j=1;j<=100;j++){
            if (con[i][j]&&i!=j) fout<<i<<" "<<j<<endl;
        }
    }
    return 0;
}

The cows have not only created their own government but they have chosen to create their own money system. In their own rebellious way, they are curious about values of coinage. Traditionally, coins come in values like 1, 5, 10, 20 or 25, 50, and 100 units, sometimes with a 2 unit coin thrown in for good measure.

The cows want to know how many different ways it is possible to dispense a certain amount of money using various coin systems. For instance, using a system of {1, 2, 5, 10, ...} it is possible to create 18 units several different ways, including: 18x1, 9x2, 8x2+2x1, 3x5+2+1, and many others.

Write a program to compute how many ways to construct a given amount of money using supplied coinage. It is guaranteed that the total will fit into both a signed long long (C/C++) and Int64 (Free Pascal).

PROGRAM NAME: money

INPUT FORMAT

The number of coins in the system is V (1 <= V <= 25).

The amount money to construct is N (1 <= N <= 10,000).

Line 1:	Two integers, V and N
Lines 2..:	V integers that represent the available coins (no particular number of integers per line)

SAMPLE INPUT (file money.in)

3 10
    1 2 5
    

OUTPUT FORMAT

SAMPLE OUTPUT (file money.out)

10
    

Analysis

It is really a very good problem to train your dynamic programing skill. Initially, it is close to the comletement pack problem. The only difference is that we need to calculate the methods instead of the highest value. But it doesn't matter, change the traditional function max into a proper one: sum.Well, the problem becomes simple.
Here I'd better provode my dynamic function: f[i][v]=sum{f[i-1][v-k*w[i]]|0<=k*w[i]<=N}
The f[i][v] stands for the ith coin for you to choose and v is the money you need to express. Of course, k is the number of the coins. Wow,fantastic!

Code

/**//*
ID:braytay1
PROG:money
LANG:C++
*/
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
ofstream fout("money.out");
ifstream fin("money.in");
void swap(int *p1,int *p2)
{
    int tmp;
    tmp=*p1;
    *p1=*p2;
    *p2=tmp;
}
int partition(int a[],int p,int r)
{
    int x,i;
    x=a[r];
    i=p-1;
    for (int j=p;j<r;j++)
    {
        if (a[j]<=x) {i++;swap(a+i,a+j);}
    }
    swap(a+i+1,a+r);
    return i+1;
}
void quicksort(int a[],int p,int r)
{
    if (p<r)
    {
        int q;
        q=partition(a,p,r);
        quicksort(a,p,q-1);
        quicksort(a,q+1,r);
    }
}

int main(){
    int V,N;
    fin>>V>>N;
    int w[26];
    long long int f[10001],g[10001];
    for(int i=1;i<=V;i++){
        fin>>w[i];
    }
    quicksort(w,1,V);
    memset(f,0,sizeof(f));
    memset(g,0,sizeof(g));
    for (int i=0;i*w[1]<=N;i++) g[i*w[1]]=1;
    for(int i=2;i<=V;i++){
        for(int j=0;j<=N;j++){
            for(int k=0;k*w[i]<=j;k++){
                f[j]+=g[j-k*w[i]];
            }            
        }    
        for(int j1=0;j1<=N;j1++){
            g[j1]=f[j1];
            f[j1]=0;
        }
    }
    fout<<g[N]<<endl;
    return 0;
}

Consider the sequence of digits from 1 through N (where N=9) in increasing order: 1 2 3 ... N.

Now insert either a `+' for addition or a `-' for subtraction or a ` ' [blank] to run the digits together between each pair of digits (not in front of the first digit). Calculate the result that of the expression and see if you get zero.

Write a program that will find all sequences of length N that produce a zero sum.

PROGRAM NAME: zerosum

INPUT FORMAT

SAMPLE INPUT (file zerosum.in)

7

OUTPUT FORMAT

SAMPLE OUTPUT (file zerosum.out)

1+2-3+4-5-6+7
1+2-3-4+5+6-7
1-2 3+4+5+6+7
1-2 3-4 5+6 7
1-2+3+4-5+6-7
1-2-3-4-5+6+7

Analysis

This problem is a very simple DFS problem. Thanks to the little limitation, we are easy to search all of the situations because we only need to search 3^8=6561 situations. So,just search.

Code


/**//*
ID:braytay1
PROG:zerosum
LANG:C++
*/
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
ofstream fout("zerosum.out");
ifstream fin("zerosum.in");
string oper[3]={" ","+","-"};
string equt;
int N;
int cal(string s){
    string tmp;
    for(int i=0;i<s.size();i++){
        if (s[i]!=' ') {tmp.push_back(s[i]);}
    }
    int ls=1,sum=0;
    char op=' ';
    for (int i=1;i<tmp.size();i++){
        if (tmp[i]>='1'&&tmp[i]<='9') {
            ls=10*ls+(tmp[i]-48);
        }
        else {
            if (op=='+') {sum+=ls;op=tmp[i];ls=0;continue;}
            if (op=='-') {sum-=ls;op=tmp[i];ls=0;continue;}
            else{sum+=ls;op=tmp[i];ls=0;}
        }
    }
    switch (op){
    case '+':sum+=ls;break;
    case '-':sum-=ls;break;
    default: sum=-1;
    }    
    return sum;
}
void DFS(int step){
    if (step>N-1){
        if (cal(equt)==0) {fout<<equt<<endl;return;}
        else return;
    }
    for (int i=0;i<3;i++){
        equt+=oper[i];
        equt.push_back(step+1+48);
        DFS(step+1);
        equt.erase(equt.end()-2,equt.end());
    }
}
int main(){
    fin>>N;
    equt+="1";
    DFS(1);
    return 0;
}

The Castle
IOI'94 - Day 1

In a stroke of luck almost beyond imagination, Farmer John was sent a ticket to the Irish Sweepstakes (really a lottery) for his birthday. This ticket turned out to have only the winning number for the lottery! Farmer John won a fabulous castle in the Irish countryside.

Bragging rights being what they are in Wisconsin, Farmer John wished to tell his cows all about the castle. He wanted to know how many rooms it has and how big the largest room was. In fact, he wants to take out a single wall to make an even bigger room.

Your task is to help Farmer John know the exact room count and sizes.

The castle floorplan is divided into M (wide) by N (1 <=M,N<=50) square modules. Each such module can have between zero and four walls. Castles always have walls on their "outer edges" to keep out the wind and rain.

Consider this annotated floorplan of a castle:

     1   2   3   4   5   6   7
  #############################
1 #   |   #   |   #   |   |   #
  #####---#####---#---#####---#
2 #   #   |   #   #   #   #   #
  #---#####---#####---#####---#
3 #   |   |   #   #   #   #   #
  #---#########---#####---#---#
4 # ->#   |   |   |   |   #   #
  #############################
#  = Wall     -,|  = No wall
-> = Points to the wall to remove to
make the largest possible new room

By way of example, this castle sits on a 7 x 4 base. A "room" includes any set of connected "squares" in the floor plan. This floorplan contains five rooms (whose sizes are 9, 7, 3, 1, and 8 in no particular order).

Removing the wall marked by the arrow merges a pair of rooms to make the largest possible room that can be made by removing a single wall.

The castle always has at least two rooms and always has a wall that can be removed.

PROGRAM NAME: castle

INPUT FORMAT

The map is stored in the form of numbers, one number for each module, M numbers on each of N lines to describe the floorplan. The input order corresponds to the numbering in the example diagram above.

Each module number tells how many of the four walls exist and is the sum of up to four integers:

• 1: wall to the west
• 2: wall to the north
• 4: wall to the east
• 8: wall to the south

Inner walls are defined twice; a wall to the south in module 1,1 is also indicated as a wall to the north in module 2,1.

Line 1:	Two space-separated integers: M and N
Line 2..:	M x N integers, several per line.

SAMPLE INPUT (file castle.in)

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

OUTPUT FORMAT

The output contains several lines:

Line 1:	The number of rooms the castle has.
Line 2:	The size of the largest room
Line 3:	The size of the largest room creatable by removing one wall
Line 4:	The single wall to remove to make the largest room possible

Choose the optimal wall to remove from the set of optimal walls by choosing the wall farthest to the west (and then, if still tied, farthest to the south). Name that wall by naming the module that borders it on either the west or south, along with a direction of N or E giving the location of the wall with respect to the module.

SAMPLE OUTPUT (file castle.out)

5
            9
            16
            4 1 E

Analysis

Algorithm:

Initially, we need to change the bitnumber into an exact wall map. Later, determine the connection of two rooms nearby. In order to determine the room, just use the traditional Floodfill algorithm. Well,everything cames quite easy.

Code:

            
/**//*
ID:braytay1
PROG:castle
LANG:C++
*/
#include <fstream>

using namespace std;

bool wall[50][50][4];
int n,m,r_num,size[50*50+1],room[50][50];

void dfs(int,int);

int main() {
    ifstream fin ("castle.in");
    ofstream fout ("castle.out");
    int s_max=0,c_max=0,ans_x,ans_y;
    char ans_w;
    fin >> n >> m;
    for (int i=0;i<m;i++) 
        for (int j=0;j<n;j++) {
            int tem;
            fin >> tem;
            for (int k=0;k<=3;k++)  wall[i][j][k]=(tem>>k)&1;
        }
    //Initialization
    for (int i=0;i<m;i++) 
        for (int j=0;j<n;j++) 
            if (!room[i][j]) {
                r_num++;
                size[r_num]=0;
                dfs(i,j);
                s_max=max(s_max,size[r_num]);
            }
    //room mark
    for (int i=0;i<n;i++) 
        for (int j=m-1;j>=0;j--) {
            int a=room[j][i],b=room[j][i<n-1?i+1:0],c=room[j>0?j-1:0][i];
            if (j>0 && wall[j][i][1] && a!=c && size[a]+size[c]>c_max) {
                c_max=size[a]+size[c];
                ans_x=j;
                ans_y=i;
                ans_w='N';
            }
            if (i<n-1 && wall[j][i][2] && a!=b && size[a]+size[b]>c_max) {
                c_max=size[a]+size[b];
                ans_x=j;
                ans_y=i;
                ans_w='E';
            }
        }
    //break walls
    fout << r_num << endl << s_max << endl << c_max << endl << ans_x+1 << ' ' << ans_y+1 << ' ' << ans_w << endl;
    fin.close();
    fout.close();
    return 0;
}

void dfs(int x,int y) {
    if (room[x][y]==r_num) return;
    room[x][y]=r_num;
    size[r_num]++;
    if (!wall[x][y][0]) dfs(x,y-1);
    if (!wall[x][y][1]) dfs(x-1,y);
    if (!wall[x][y][2]) dfs(x,y+1);
    if (!wall[x][y][3]) dfs(x+1,y);
}