<![CDATA[Fiber Communications]]> Farmer John wants to connect his N (1 <= N <= 1,000) barns (numbered 1..N) with a new fiber-optic network. However, the barns are located in a circle around the edge of a large pond, so he can only connect pairs of adjacent barns. The circular configuration means that barn N is adjacent to barn 1.

FJ doesn't need to connect all the barns, though, since only certain pairs of cows wish to communicate with each other. He wants to construct as few
connections as possible while still enabling all of these pairs to communicate through the network. Given the list of barns that wish to communicate with each other, determine the minimum number of lines that must be laid. To communicate from barn 1 to barn 3, lines must be laid from barn 1 to barn 2 and also from barn 2 to barn 3(or just from barn 3 to 1,if n=3).]]> * Line 1: Two integers, N and P (the number of communication pairs, 1 <= P <= 10,000)

* Lines 2..P+1: two integers describing a pair of barns between which communication is desired. No pair is duplicated in the list.]]> One line with a single integer which is the minimum number of direct connections FJ needs to make.]]> #include #include #include using namespace std; int n,a[10001][2],p,dp[1001],sum,ans; int main() { while(scanf("%d%d",&n,&p)==2) { int i,j,right; for(i=1;i<=p;i++) { scanf("%d%d",&a[i][0],&a[i][1]); if(a[i][0]>a[i][1]) swap(a[i][0],a[i][1]); } ans=1000000; for(i=1;i<=n;i++) { memset(dp,0,sizeof(dp)); for(j=1;j<=p;j++) { if(a[j][0]=i) { if(dp[1]right) { sum+=dp[j]-j;right=dp[j]; } else if(dp[j]>right) { sum+=dp[j]-right; right=dp[j]; } if(sum>ans) break; } if(sum <![CDATA[Power Hungry Cows]]> FJ's cows would like to be able to compute integer powers P (1 <= P <= 20,000) of numbers very quickly, but need your help. Because they're going to be computing powers of very large numbers, they can only keep around two work variables for intermediate results.

The first of those work variables is initialized to the number (denoted x) for which they are calculating the power; the other is initialized to 1. The cows can both multiply and divide any pair of the work variables and store the result in any work variable, but all results are stored as integers.

For example, if they want to compute x^31, one way to perform the calculation is: 
                                              WV1  WV2

                                      Start:   x    1

   Multiply first by first, store in second:   x   x^2

                  Multiply second by second:   x   x^4

                  Multiply second by second:   x   x^8

                  Multiply second by second:   x   x^16

                  Multiply second by second:   x   x^32

                     Divide second by first:   x   x^31

Thus, x^31 can computed in six operations. Given the power to be computed and the the number of work variables, find the minimum number of operations to calculate the power.
]]> A single line with one integer: P. ]]> A single line with a single integer that is the minimum number of operations it requires to compute the power. ]]> const int maxn = 20003, maxq = 700003, prime0 = 20101, prime1 = 97; int n, n2, answer, head, last, q[maxq][3]; bool hash[prime0][prime1]; int input() { scanf("%d", &n); return 0; } bool in_hash(int wv0, int wv1) { return hash[wv0][wv1]; } void add_hash(int wv0, int wv1) { hash[wv0][wv1] = true; } bool add_node(int wv0, int wv1, int step) { if (wv0 == n || wv1 == n) return true; if (wv0 < wv1) { int temp = wv0; wv0 = wv1; wv1 = temp; } if (wv0 == wv1 || wv0 >= n2 || wv1 >= prime1) return false; if (!in_hash(wv0, wv1)) { add_hash(wv0, wv1); ++last; q[last][0] = wv0; q[last][1] = wv1; q[last][2] = step; } return false; } int work() { n2 = n + prime1; head = last = -1; add_node(1, 0, 0); while (head < last) { ++head; int wv0 = q[head][0], wv1 = q[head][1], step1 = q[head][2] + 1; if ( add_node(wv0+wv0, wv1, step1) || add_node(wv0+wv1, wv1, step1) || add_node(wv1+wv1, wv1, step1) || add_node(wv0, wv0+wv0, step1) || add_node(wv0, wv0+wv1, step1) || add_node(wv0, wv1+wv1, step1) || add_node(wv0, wv0-wv1, step1) || add_node(wv0-wv1, wv0, step1)) { answer = step1; break; } } return 0; } int output() { printf("%d\n", answer); return 0; } int main() { input(); work(); output(); return 0; }]]> <![CDATA[Cow Cycling]]> The cow bicycling team consists of N (1 <= N <= 20) cyclists. They wish to determine a race strategy which will get one of them across the finish line as fast as possible.

Like everyone else, cows race bicycles in packs because that's the most efficient way to beat the wind. While travelling at x laps/minute (x is always an integer), the head of the pack expends x*x energy/minute while the rest of pack drafts behind him using only x energy/minute. Switching leaders requires no time though can only happen after an integer number of minutes. Of course, cows can drop out of the race at any time.

The cows have entered a race D (1 <= D <= 100) laps long. Each cow has the same initial energy, E (1 <= E <= 100).

What is the fastest possible finishing time? Only one cow has to cross the line. The finish time is an integer. Overshooting the line during some minute is no different than barely reaching it at the beginning of the next minute (though the cow must have the energy left to cycle the entire minute). N, D, and E are integers.]]> A single line with three integers: N, E, and D ]]> A single line with the integer that is the fastest possible finishing time for the fastest possible cow. Output 0 if the cows are not strong enough to finish the race. ]]> 
[as shown in this chart:

	                            leader E

	               pack  total used this

	time  leader  speed   dist   minute

	  1      1      5       5      25

	  2      1      2       7       4

	  3      2*     4      11      16

	  4      2      2      13       4

	  5      3*     3      16       9

	  6      3      2      18       4

	  7      3      2      20       4

	* = leader switch

]]> #include #include #include #include #include #include using namespace std; template void out(T x, int n){ for (int i = 0; i < n; ++i) cout << x[i] << ' '; cout << endl; } template void out(T x, int n, int m){ for (int i = 0; i < n; ++i) out(x[i], m); cout << endl; } #define OUT(x) (cout << #x << " = " << x << endl) #define FOR(i, a, b) for(int i = (int)a; i < (int)b; ++i) #define REP(i, b) FOR(i, 0, b) #define FORD(i, a, b) for(int i = (int)a; i >= (int)b; --i) #define MAXN 101 #define Inf 1000000 int f[21][MAXN][MAXN]; int n, E, D; int main(){ while (EOF != scanf("%d %d %d", &n, &E, &D)) { REP (j, E+1) f[1][j][0] = 0; REP (k, D+1) f[1][0][k] = Inf; f[1][0][0] = 0; FOR (j, 1, E+1) { FOR (k, 1, D+1) { f[1][j][k] = Inf; FORD (p, sqrt(j*1.0), 1) { f[1][j][k] = min(f[1][j][k], f[1][j-p*p][k-p] + 1); } } } FOR (i, 2, n+1) { FOR (j, 1, E+1) { FOR (k, 1, D+1) { f[i][j][k] = Inf; FOR (p, 1, k+1) { f[i][j][k] = min(f[i][j][k], f[i-1][j-p][k-p] + f[1][j][p]); } } } } int ans = f[n][E][D]; if (ans == Inf) printf("0\n"); else printf("%d\n", ans); } return 0; }]]> <![CDATA[Rebuilding Roads]]> The cows have reconstructed Farmer John's farm, with its N barns (1 <= N <= 150, number 1..N) after the terrible earthquake last May. The cows didn't have time to rebuild any extra roads, so now there is exactly one way to get from any given barn to any other barn. Thus, the farm transportation system can be represented as a tree.

Farmer John wants to know how much damage another earthquake could do. He wants to know the minimum number of roads whose destruction would isolate a subtree of exactly P (1 <= P <= N) barns from the rest of the barns.]]> * Line 1: Two integers, N and P

* Lines 2..N: N-1 lines, each with two integers I and J. Node I is node J's parent in the tree of roads. ]]> A single line containing the integer that is the minimum number of roads that need to be destroyed for a subtree of P nodes to be isolated. ]]> [A subtree with nodes (1, 2, 3, 6, 7, 8) will become isolated if roads 1-4 and 1-5 are destroyed.] 

]]> #include #define MAX 152 #define INF 0x3ffffff using namespace std; /* dp[s][i]:记录s结点，要得到一棵j个节点的子树去掉的最少边数 考虑其儿子k 1）如果不去掉k子树，则 dp[s][i] = min(dp[s][j]+dp[k][i-j]) 0 <= j <= i 2）如果去掉k子树，则 dp[s][i] = dp[s][i]+1 总的为 dp[s][i] = min (min(dp[s][j]+dp[k][i-j]) , dp[s][i]+1 ) */ int dp[MAX][MAX]; int son[MAX], bla[MAX], root, n, p; //son[i]:记录i结点的儿子，bla[i]:记录i结点的兄弟 bool hf[MAX]; //hf[i]:i结点是否有父亲 void dfs(int s) { int i, j, k, temp; for(i = 0; i <= p; i++) dp[s][i] = INF; dp[s][1] = 0; k = son[s]; while(k){ dfs(k); for(i = p; i >= 0; i--){ temp = dp[s][i]+1; for(j = 0; j <= i; j++){ if(dp[k][i-j] + dp[s][j] < temp) temp = dp[k][i-j] + dp[s][j]; } dp[s][i] = temp; } k = bla[k]; } } int slove(int root) { dfs(root); int i, ans; ans = dp[root][p]; for(i = 1; i <= n; i++){ if(dp[i][p] < ans) ans = dp[i][p] + 1; } return ans; } int main() { //freopen("data.txt", "r", stdin); int i, s, t; while(cin >> n >> p){ memset(son, 0, sizeof(son)); for(i = 1; i < n; i++){ cin >> s >> t; bla[t] = son[s]; son[s] = t; hf[t] = true; } for(i = 1; i <= n; i++){ if(!hf[i]) root = i; } cout << slove(root) << endl; } return 0; } ]]> <![CDATA[Triangular Pastures]]> Like everyone, cows enjoy variety. Their current fancy is new shapes for pastures. The old rectangular shapes are out of favor; new geometries are the favorite.

I. M. Hei, the lead cow pasture architect, is in charge of creating a triangular pasture surrounded by nice white fence rails. She is supplied with N (3 <= N <= 40) fence segments (each of integer length Li (1 <= Li <= 40) and must arrange them into a triangular pasture with the largest grazing area. Ms. Hei must use all the rails to create three sides of non-zero length.

Help Ms. Hei convince the rest of the herd that plenty of grazing land will be available.Calculate the largest area that may be enclosed with a supplied set of fence segments.]]> * Line 1: A single integer N

* Lines 2..N+1: N lines, each with a single integer representing one fence segment's length. The lengths are not necessarily unique.]]> A single line with the integer that is the truncated integer representation of the largest possible enclosed area multiplied by 100. Output -1 if no triangle of positive area may be constructed.]]> [which is 100x the area of an equilateral triangle with side length 4] 

]]> #include #include using namespace std; int len[45], n; bool dp[45][1000][1000]; double cul (int a, int b, int c) { double p = (a + b + c) / 2.0; return sqrt (p * (p - a) * (p - b) * (p - c)); } int main () { int i, j, k, s; int bound, sum = 0; double tmp, area = 0; scanf ("%d", &n); for (i = 1; i <= n; i++) { scanf ("%d", &len[i]); sum += len[i]; } bound = sum / 2; dp[0][0][0] = true; for (i = 1; i <= n; i++) for (j = 0; j <= bound; j++) for (k = 0; k <= bound; k++) dp[i][j][k] = dp[i-1][j][k] | (len[i] <= j && dp[i-1][j-len[i]][k]) | (len[i] <= k && dp[i-1][j][k-len[i]]); for (j = 1; j <= bound; j++) for (k = 1; k <= bound; k++) { s = sum - j - k; if (dp[n][j][k] && j + k > s && j + s > k && k + s > j &&(tmp = cul (j, k, s)) > area) area = tmp; } if (area == 0) printf ("-1\n"); else printf ("%d\n", int (area * 100)); return 0; }]]> <![CDATA[Chores]]> Farmer John's family pitches in with the chores during milking, doing all the chores as quickly as possible. At FJ's house, some chores cannot be started until others have been completed, e.g., it is impossible to wash the cows until they are in the stalls.

Farmer John has a list of N (3 <= N <= 10,000) chores that must be completed. Each chore requires an integer time (1 <= length of time <= 100) to complete and there may be other chores that must be completed before this chore is started. We will call these prerequisite chores. At least one chore has no prerequisite: the very first one, number 1. Farmer John's list of chores is nicely ordered, and chore K (K > 1) can have only chores 1,.K-1 as prerequisites. Write a program that reads a list of chores from 1 to N with associated times and all perquisite chores. Now calculate the shortest time it will take to complete all N chores. Of course, chores that do not depend on each other can be performed simultaneously.]]> * Line 1: One integer, N

* Lines 2..N+1: N lines, each with several space-separated integers. Line 2 contains chore 1; line 3 contains chore 2, and so on. Each line contains the length of time to complete the chore, the number of the prerequisites, Pi, (0 <= Pi <= 100), and the Pi prerequisites (range 1..N, of course). ]]> A single line with an integer which is the least amount of time required to perform all the chores. ]]> 
[Here is one task schedule:

        Chore 1 starts at time 0, ends at time 5.

        Chore 2 starts at time 5, ends at time 6.

        Chore 3 starts at time 6, ends at time 9.

        Chore 4 starts at time 5, ends at time 11.

        Chore 5 starts at time 11, ends at time 12.

        Chore 6 starts at time 11, ends at time 19.

        Chore 7 starts at time 19, ends at time 23.

]

]]> #include #include #include #include #include #include #include using namespace std; const int BORDER = (1<<20)-1; const int MAXSIZE = 37; const int MAXN = 10005; const int INF = 1000000000; #define CLR(x,y) memset(x,y,sizeof(x)) #define ADD(x) x=((x+1)&BORDER) #define IN(x) scanf("%d",&x) #define OUT(x) printf("%d\n",x) #define MIN(m,v) (m)<(v)?(m):(v) #define MAX(m,v) (m)>(v)?(m):(v) #define ABS(x) ((x)>0?(x):-(x)) int ed_tim[MAXN],n,ans; int init() { ans = 0; CLR(ed_tim,0); return 0; } int work() { int i,j,tmp,m,mmax,cur_tim; for(i = 1; i <= n; ++i) { mmax = 0; scanf("%d%d",&cur_tim,&m); for(j = 0; j < m; ++j) { IN(tmp); mmax = MAX(mmax,ed_tim[tmp]); } ed_tim[i] = mmax + cur_tim; ans = MAX(ans,ed_tim[i]); } OUT(ans); return 0; } int main() { while(IN(n)!=EOF) { init(); work(); } return 0; }]]> <![CDATA[Dessert]]> FJ has a new rule about the cows lining up for dinner. Not only must the N (3 <= N <= 15) cows line up for dinner in order, but they must place a napkin between each pair of cows with a "+", "-", or "." on it. In order to earn their dessert, the cow numbers and the napkins must form a numerical expression that evaluates to 0. The napkin with a "." enables the cows to build bigger numbers. Consider this equation for seven cows: 
      1 - 2 . 3 - 4 . 5 + 6 . 7

This means 1-23-45+67, which evaluates to 0. You job is to assist the cows in getting dessert. (Note: "... 10 . 11 ...") will use the number 1011 in its calculation.) ]]> One line with a single integer, N ]]> One line of output for each of the first 20 possible expressions -- then a line with a single integer that is the total number of possible answers. Each expression line has the general format of number, space, napkin, space, number, space, napkin, etc. etc. The output order is lexicographic, with "+" coming before "-" coming before ".". If fewer than 20 expressions can be formed, print all of the expressions. ]]> #include using namespace std; int n; int cnt; char store[20]; char nstore[20]; int a[20]; int num[20]; int tt=0; int stk[20]; void dfs(int nn) { if(cnt>=20) return; if(nn==n-1) { for(int i=0;i=10) num[i]=num[i]*100+num[i+1]; else num[i]=num[i]*10+num[i+1]; for(int j=i+1;j <![CDATA[Extra Krunch]]> A krunched word has no vowels ("A", "E", "I", "O", and "U") and no repeated letters. Removing vowels and letters that appear twice or more from MISSISSIPPI yields MSP. In a krunched word, a letter appears only once, the first time it would appear in the unkrunched word. Vowels never appear.

Krunched phrases similarly have no vowels and no repeated letters. Consider this phrase: 
        RAILROAD CROSSING

and its krunched version: 
        RLD CSNG

Blanks are krunched differently. Blanks are removed so that a krunched phrase has no blanks on its beginning or end, never has two blanks in a row, and has no blanks before punctuation. Otherwise, blanks not removed. If we represent blanks by "_", 
        MADAM_I_SAY_I_AM_ADAM__

krunches to: 
        MD_SY

where the single remaining blank is shown by "_".

Write a program that reads a line of input (whose length ranges from 2 to 70 characters), and krunches it. Put the krunched word or phrase in the output file. The input line has only capital letters, blanks, and the standard punctuation marks: period, comma, and question mark.]]> A single line to be krunched. ]]> A single krunched line that follows the rules above. ]]> #include using namespace std; int main() { char str[71], str1[71]; int l, n; cin.getline(str, 71); l = strlen(str); for(int i=0; i 0) if(str[i] == ',' || str[i] == '.' || str[i] == '?') while(str1[n-1] == ' '){ n--; if(!n) break; } str1[n++] = str[i]; } l = 0; while(str1[l] == ' ') l++; while(str1[n-1] == ' ') n--; for(int i=l; i 0) if(str1[i] == ' ' && str1[i-1] == ' ') continue; cout << str1[i]; } cout << endl; } ]]> <![CDATA[BUY LOW, BUY LOWER]]> The advice to "buy low" is half the formula to success in the bovine stock market.To be considered a great investor you must also follow this problems' advice: 
                    "Buy low; buy lower"

Each time you buy a stock, you must purchase it at a lower price than the previous time you bought it. The more times you buy at a lower price than before, the better! Your goal is to see how many times you can continue purchasing at ever lower prices.

You will be given the daily selling prices of a stock (positive 16-bit integers) over a period of time. You can choose to buy stock on any of the days. Each time you choose to buy, the price must be strictly lower than the previous time you bought stock. Write a program which identifies which days you should buy stock in order to maximize the number of times you buy.

Here is a list of stock prices: 
 Day   1  2  3  4  5  6  7  8  9 10 11 12

Price 68 69 54 64 68 64 70 67 78 62 98 87


The best investor (by this problem, anyway) can buy at most four times if each purchase is lower then the previous purchase. One four day sequence (there might be others) of acceptable buys is: 
Day    2  5  6 10

Price 69 68 64 62
]]> * Line 1: N (1 <= N <= 5000), the number of days for which stock prices are given

* Lines 2..etc: A series of N space-separated integers, ten per line except the final line which might have fewer integers. ]]> Two integers on a single line:
* The length of the longest sequence of decreasing prices
* The number of sequences that have this length (guaranteed to fit in 31 bits)

In counting the number of solutions, two potential solutions are considered the same (and would only count as one solution) if they repeat the same string of decreasing prices, that is, if they "look the same" when the successive prices are compared. Thus, two different sequence of "buy" days could produce the same string of decreasing prices and be counted as only a single solution. ]]> 维护maxLenSets:假设d = maxSeqLen[i],首先遍历容器maxLenSets[d]的所有元素如果存在一个 元素j使得val[j] = val[i],则删除j元素;最后插入i元素 ->计算countv[i]:遍历maxLenSets[d - 1]中的所有元素j,如果val[j] > val[i],则countv[i] += countv[j] 最后countv[n + 1]即为所求的计数结果,maxLenSets[i]中元素的唯一性确保了最后结果的唯一性. */ #include #include #include #define MAX_N 5005 using namespace std; int maxSeqLen[MAX_N + 1]; int maxTailVal[MAX_N + 1], maxTailLen; int val[MAX_N + 1], n; list maxLenSets[MAX_N + 1]; int countv[MAX_N + 1]; int main() { int i; scanf("%d", &n); for(i = 1; i <= n; i++) { scanf("%d", &val[i]); //二分DP int l = 1, r = maxTailLen; while(l <= r) { int mid = (l + r) / 2; if(maxTailVal[mid] <= val[i]) r = mid - 1; else l = mid + 1; } maxTailVal[l] = val[i]; maxSeqLen[i] = l; if(l > maxTailLen) maxTailLen = l; } //第一个元素需要特殊处理 countv[1] = 1; maxLenSets[1].push_back(1); val[n + 1] = -1; maxSeqLen[n + 1] = maxTailLen + 1; //遍历后面的n个元素 for(i = 2; i <= n + 1; i++) { int d = maxSeqLen[i]; list::iterator iter = maxLenSets[d].begin(); //扫描d长度List，代替相同的元素 for(; iter != maxLenSets[d].end(); ++iter) if(val[*iter] == val[i]) { maxLenSets[d].erase(iter); break; } maxLenSets[d].push_back(i); //同样d = 1的元素由于没有前驱，所以需要特殊处理 if(d == 1) { countv[i] = 1; continue; } //计算countv[i] iter = maxLenSets[d - 1].begin(); for(; iter != maxLenSets[d - 1].end(); ++iter) if(val[*iter] > val[i]) countv[i] += countv[*iter]; } printf("%d %d\n", maxTailLen, countv[n + 1]); return 0; } ]]>