<![CDATA[Expanding Rods]]>

When a thin rod of length

is heated

degrees, it expands to a new length

L'=(1+n*C)*L

, where

is the coefficient of heat expansion.

When a thin rod is mounted on two solid walls and then heated, it expands and takes the shape of a circular segment, the original rod being the chord of the segment.

Your task is to compute the distance by which the center of the rod is displaced.

The input contains multiple lines. Each line of input contains three non-negative numbers: the initial lenth of the rod in millimeters, the temperature change in degrees and the coefficient of heat expansion of the material. Input data guarantee that no rod expands by more than one half of its original length. The last line of input contains three negative numbers and it should not be processed.

For each line of input, output one line with the displacement of the center of the rod in millimeters with 3 digits of precision.

]]> #include #include #include int main() { int i,j; double L,d,C,L2,R,delta,theta,x; while (scanf("%lf %lf %lf ", &L, &d, &C)==3) { if (L < 0) break; if (L < 1e-6 || d < 1e-6 || C < 1e-6) { printf("0.000\n"); continue; } L2 = d*C*L + L; L2/=2.0; L/=2.0; for (x = 1e20, delta=1e20; delta>=1e-12; delta/=2.0) { R = sqrt(x*x + L*L); if (fabs(x) < 1e-10) x = 1e-10; theta = atan(L/x); if (theta*R < L2) x-=delta;else x+=delta; } R = sqrt(x*x + L*L); printf("%.3lf\n", R-x); } return 0; } ]]> <![CDATA[Three powers]]>

Consider the set of all non-negative integer powers of 3.

S = { 1, 3, 9, 27, 81, ... }

Consider the sequence of all subsets of S ordered by the value of the sum of their elements. The question is simple: find the set at the n-th position in the sequence and print it in increasing order of its elements.

Each line of input contains a number n, which is a positive integer with no more than 19 digits. The last line of input contains 0 and it should not be processed.

For each line of input, output a single line displaying the n-th set as described above, in the format used in the sample output.

]]> 0; p++) { r = n.mod(two); if (r.intValue() == 1) { if (first==0) System.out.print(", "); else System.out.print(" "); first = 0; System.out.print(three.pow(p)); } n = n.divide(BigInteger.valueOf(2)); } System.out.println(" }"); } } catch(Exception e) { System.err.println(e.toString()); } } } ]]> <![CDATA[Work Reduction]]>

Paperwork is beginning to pile up on your desk, and tensions at the workplace are starting to mount. Your boss has threatened to fire you if you don't make any progress by the end of the day. You currently have

units of paperwork on your desk, and your boss demands that you have exactly

units of paperwork left by the end of the day.

The only hope for you now is to hire help. There are various agencies which offer paperwork reduction plans:

For $A they will reduce your paperwork by one unit.
For $B they will reduce your entire paperwork by half (rounding down when necessary).

Note that work can never be reduced to less than 0.

Your task now is to produce a sorted table of agency names and their respective minimum costs to solve your workload problem.

The first line of input consists of a single positive integer representing the number of cases to follow. Each case begins with three positive integers separated by spaces: N - your starting workload, M - your target workload, and L - the number of work reduction agencies available to you, (1 <= M <= N <= 100000, 1 <= L <= 100). The next L lines have the format "[agency name]:A,B", where A and B are the rates as described above for the given agency. (0 <= A,B <= 10000) The length of the agency name will be between 1 and 16, and will consist only of capital letters. Agency names will be unique.

For each test case, print "Case X", with X being the case number, on a single line, followed by the table of agency names and their respective minimum costs, sorted in non-decreasing order of minimum costs. Sort job agencies with identical minimum costs in alphabetical order by agency name. For each line of the table, print out the agency name, followed by a space, followed by the minimum required cost for that agency to solve your problem.

]]> #include #include #include #include #include using namespace std; int main() { int cnum,nc,i,n,N,M,L,cost; char name[105][32]; int A[105],B[105]; scanf("%d ", &nc); for (cnum=1; cnum<=nc; cnum++) { set >::iterator ii; set > ss; printf("Case %d\n", cnum); scanf("%d %d %d ", &N, &M, &L); for (i=0; i=M && B[i]<=(n-n/2)*A[i]) { n /= 2; cost += B[i]; } cost += (n-M)*A[i]; string sss = name[i]; ss.insert(make_pair(cost,sss)); } for (ii=ss.begin(); ii!=ss.end(); ii++) printf("%s %d\n", (ii->second).c_str(), ii->first); } return 0; } ]]> <![CDATA[Grid Speed]]> Consider a grid in which north-south streets, separated by gaps of 10 miles each, are elevated above east-west streets laid out in a similar fashion (see illustration for the case of a 6 by 6 grid). All streets are two-way. Entrance and exit ramps connect the streets at every intersection. Because there are no traffic lights, switching from a north-south street to an east-west street, and vice versa, takes essentially no time. The grid has very little traffic, but the local police patrol so carefully for speeding that there are virtually no speeders.

The speed limits follow an unusual pattern. The speed limits are separately posted for each street and are the same for the entire street in both directions. In the illustration above, let us label the intersections using their column and row numbers: the southwestern corner of the grid is (1, 1), the southeastern corner is (6, 1), and so on. Part of your task is to determine the shortest time in which we can get from (1, 1) to (6, 3) while obeying speed limits.

However, after the Kyoto disagreement, just being fast is not good enough, one also has to be fuel efficient. Fuel consumption of a car is given in miles-per-gallon (mpg) and depends on speed of the car. Speed of a car is given in miles-per-hour (mph) and, in this digital age, the speed of a car is always a positive integer multiple of 5. The formula relating mpg to mph is a very simple one: a car travelling at v mph makes 80-0.03*v² mpg. In a given grid of streets we would like to travel from intersection (x_s, y_s) to intersection (x_t, y_t). You are to determine the fastest and the most fuel efficient way of making the trip such that:

the car does not change speed between intersections,
the car obeys all speed limits,
the car travels the shortest possible distance between the start and finish, and
the car arrives at the destination in the given time interval.

]]> The first line of input contains an integer t, the number of scenarios to be processed. The data for each scenario occupy 5 lines. The first line contains an integer n<=10 which is the number of horizontal and vertical streets. The second line contains an integer which is the grid unit size in miles, smaller than 100. The third and fourth lines contain n integers each, specifying the speed limits on the horizontal and vertical streets, respectively. The largest speed limit is 50. The last line of data for a scenario contains 6 integers. The first four are x_s, y_s, x_t, and y_t. The last two integers give the shortest and the longest allowed time to travel in minutes, inclusive, both not bigger than 1000.

]]> For each scenario, output two or three lines in the format given in the sample output. If the travel is possible then, on the second line of output, report the earliest possible arrival time (but within the imposed limits) and fuel consumed (least possible for this travel time) and, on the third line, report the earliest arrival time (but within the imposed limits) that consumes the minimum amount of fuel. The time is to be reported in minutes (integer), rounded up.

]]> #include #include #include #include #include using namespace std; #define MAXN 10+1 int main () { int t; scanf("%d",&t); for(int sc = 1; sc <=t; sc++) { printf("Scenario %d:\n",sc); int n, v[MAXN], h[MAXN]; scanf("%d",&n); assert(1<=n && n<=MAXN); int gs; scanf("%d\n",&gs); for(int i=1;i<=n;i++) { scanf("%d",&h[i]); assert(1<=h[i]&&h[i]<=50); } for(int i=1;i<=n;i++) { scanf("%d",&v[i]); assert(1<=v[i]&&v[i]<=50); } int xs,ys,xt,yt,te,tl; scanf("%d%d%d%d%d%d",&xs,&ys,&xt,&yt,&te,&tl); assert(tl <= 1000); int dx = 0, dy = 0; map m[MAXN][MAXN]; pair p; if (tl < te) goto B; if (xsxt) dx = -1; if (ysyt) dy = -1; m[xs][ys][0] = 0.0; for(int i=xs;;i+=dx) { if (dx > 0 && i>xt) break; if (dx < 0 && i 0 && j>yt) break; if (dy < 0 && j :: iterator pos; for(pos=m[i][j].begin();pos!=m[i][j].end();pos++) { for(int s=5;s<=h[j];s+=5) { int t = (*pos).first+3600*gs/s; if ( t > 60*tl) continue; if (m[i+dx][j].find(t) == m[i+dx][j].end() || m[i+dx][j][t] > (*pos).second+gs/(80-0.03*s*s)) m[i+dx][j][t] = (*pos).second+gs/(80-0.03*s*s); } } } if (j!=yt) { map :: iterator pos; for(pos=m[i][j].begin();pos!=m[i][j].end();pos++) { for(int s=5;s<=v[i];s+=5) { int t = (*pos).first+3600*gs/s; if (t > 60*tl) continue; if (m[i][j+dy].find(t) == m[i][j+dy].end() || m[i][j+dy][t] > (*pos).second+gs/(80-0.03*s*s)) m[i][j+dy][t] = (*pos).second+gs/(80-0.03*s*s); } } } if (!dy) break; } if (!dx) break; } A: if (m[xt][yt].empty()) goto B; else { p = *(m[xt][yt].begin()); assert(p.first <= tl*60); double bt=INT_MAX,btf, bf=DBL_MAX, bft; map:: iterator pos; for(pos=m[xt][yt].begin();pos!=m[xt][yt].end();pos++) { p = *pos; assert(p.first <= tl*60); if (p.first < 60*te || p.first > 60*tl) continue; if (p.second < bf) { bf = p.second; bft = p.first; } else if (p.second == bf && p.first < bft) bft = p.first; if (p.first < bt) { bt = p.first; btf = p.second; } else if (p.first == bt && p.second < btf) btf = p.second; } if (bt == -1) goto B; printf("The earliest arrival: %.0f minutes, fuel %.2f gallons\n", ceil(bt/60), btf); printf("The economical travel: %.0f minutes, fuel %.2f gallons\n", ceil(bft/60), bf); continue; } B: printf("IMPOSSIBLE\n"); } } ]]> <![CDATA[Marbles on a tree]]> n

boxes are placed on the vertices of a rooted tree, which are numbered from 1 to

, 1 ≤

≤ 10000. Each box is either empty or contains a number of marbles; the total number of marbles is

The task is to move the marbles such that each box contains exactly one marble. This is to be accomplished be a sequence of moves; each move consists of moving one marble to a box at an adjacent vertex. What is the minimum number of moves required to achieve the goal?

The input contains a number of cases. Each case starts with the number n followed by n lines. Each line contains at least three numbers which are: v the number of a vertex, followed by the number of marbles originally placed at vertex v followed by a number d which is the number of children of v, followed by d numbers giving the identities of the children of v.

The input is terminated by a case where n = 0 and this case should not be processed.

For each case in the input, output the smallest number of moves of marbles resulting in one marble at each vertex of the tree.

]]> 1 // pick a member of L, name it v // switch m[v] of // case m[v] < 0 // tcost += -m[v] // all have to walk this step from the parent // m[parent[v]] += m[v] // case m[v] = 0 // tcost++ // 1 has to walk from the parent // m[parent[v]-- // else // tcost += m[v]-1 // 1 has to stay the rest has to walk // // to the parent // m[parent[v]] += m[v]-1 // // P. Rudnicki, Edmonton, April 8th #include #include using namespace std; #define MAXN 10000 int m[MAXN], parent[MAXN]; set children[MAXN]; set leaves, nleaves; int main () { int n, tcost; while (scanf("%d",&n) == 1) { if (!n) break; leaves.clear(); tcost = 0; for(int i = 1; i <= n; i++) { int v, d; scanf("%d",&v); scanf("%d%d",&m[v],&d); for(int j = 1; j <= d; j++) { int c; scanf("%d",&c); children[v].insert(c); parent[c] = v; } if (!d) leaves.insert(v); } set:: iterator pos; while (leaves.size() != 1) { nleaves.clear(); for(pos = leaves.begin(); pos != leaves.end(); pos++) { if (m[*pos] <= 0) { tcost += -m[*pos]+1; m[parent[*pos]] += m[*pos]-1; } else { tcost += m[*pos]-1; m[parent[*pos]] += m[*pos]-1; } children[parent[*pos]].erase(*pos); if (children[parent[*pos]].empty()) nleaves.insert(parent[*pos]); } leaves = nleaves; } printf("%d\n",tcost); } } ]]>