├── .gitignore
├── LICENSE
├── README.md
└── poj
    ├── 1000.c
    ├── 1001.c
    ├── 1002.c
    ├── 1003.c
    ├── 1004.c
    ├── 1005.c
    ├── 1006.c
    ├── 1007.c
    ├── 1008.c
    ├── 1012.c
    ├── 1013.c
    ├── 1017.c
    ├── 1018.cpp
    ├── 1028.c
    ├── 1032.c
    ├── 1045.c
    ├── 1046.c
    ├── 1050.c
    ├── 1056.cpp
    ├── 1061.c
    ├── 1067.c
    ├── 1068.c
    ├── 1088.c
    ├── 1094.cpp
    ├── 1102.c
    ├── 1125.c
    ├── 1126.c
    ├── 1144.cc
    ├── 1149.c
    ├── 1159.c
    ├── 1163.c
    ├── 1182.c
    ├── 1183.c
    ├── 1201.c
    ├── 1207.c
    ├── 1218.c
    ├── 1247.c
    ├── 1250.cpp
    ├── 1274.cpp
    ├── 1291.c
    ├── 1298.c
    ├── 1306.c
    ├── 1316.c
    ├── 1323.c
    ├── 1326.c
    ├── 1338.c
    ├── 1350.c
    ├── 1363.c
    ├── 1401.c
    ├── 1422.cpp
    ├── 1423.c
    ├── 1450.c
    ├── 1455.c
    ├── 1458.c
    ├── 1469.cpp
    ├── 1477.c
    ├── 1503.c
    ├── 1504.c
    ├── 1517.c
    ├── 1519.c
    ├── 1528.c
    ├── 1543.c
    ├── 1547.c
    ├── 1552.c
    ├── 1562.c
    ├── 1565.c
    ├── 1579.c
    ├── 1595.c
    ├── 1604.c
    ├── 1607.c
    ├── 1611.cpp
    ├── 1654.c
    ├── 1655.cpp
    ├── 1656.c
    ├── 1657.c
    ├── 1658.c
    ├── 1659.c
    ├── 1663.c
    ├── 1664.c
    ├── 1665.c
    ├── 1666.c
    ├── 1674.c
    ├── 1700.c
    ├── 1702.c
    ├── 1703.c
    ├── 1716.c
    ├── 1730.c
    ├── 1731.cpp
    ├── 1740.c
    ├── 1775.c
    ├── 1799.c
    ├── 1804.c
    ├── 1818.c
    ├── 1828.c
    ├── 1833.c
    ├── 1835.c
    ├── 1844.c
    ├── 1852.c
    ├── 1862.c
    ├── 1922.c
    ├── 1928.c
    ├── 1936.c
    ├── 1942.c
    ├── 1949.c
    ├── 1953.c
    ├── 1969.c
    ├── 1979.cpp
    ├── 1989.c
    ├── 2000.c
    ├── 2013.c
    ├── 2017.c
    ├── 2027.c
    ├── 2039.c
    ├── 2050.c
    ├── 2051.c
    ├── 2056.cpp
    ├── 2070.c
    ├── 2080.c
    ├── 2081.cc
    ├── 2084.java
    ├── 2105.c
    ├── 2109.c
    ├── 2126.c
    ├── 2136.c
    ├── 2140.c
    ├── 2141.c
    ├── 2153.c
    ├── 2159.c
    ├── 2186.cpp
    ├── 2190.c
    ├── 2196.c
    ├── 2236.cpp
    ├── 2239.cpp
    ├── 2242.c
    ├── 2247.c
    ├── 2249.c
    ├── 2250.c
    ├── 2262.c
    ├── 2272.c
    ├── 2282.c
    ├── 2283.c
    ├── 2287.c
    ├── 2299.c
    ├── 2301.c
    ├── 2304.c
    ├── 2305.java
    ├── 2309.c
    ├── 2316.c
    ├── 2328.c
    ├── 2346.c
    ├── 2348.c
    ├── 2350.c
    ├── 2361.c
    ├── 2363.c
    ├── 2377.cpp
    ├── 2386.c
    ├── 2388.c
    ├── 2389.c
    ├── 2390.c
    ├── 2394.cpp
    ├── 2402.c
    ├── 2403.cpp
    ├── 2405.c
    ├── 2406.c
    ├── 2407.c
    ├── 2418.c
    ├── 2421.cpp
    ├── 2436.cpp
    ├── 2440.c
    ├── 2442.c
    ├── 2446.cpp
    ├── 2453.c
    ├── 2460.c
    ├── 2470.c
    ├── 2479.c
    ├── 2484.c
    ├── 2487.c
    ├── 2492.c
    ├── 2495.c
    ├── 2497.c
    ├── 2498.c
    ├── 2499.c
    ├── 2501.c
    ├── 2503.c
    ├── 2505.c
    ├── 2507.c
    ├── 2509.c
    ├── 2521.c
    ├── 2524.c
    ├── 2533.c
    ├── 2538.c
    ├── 2545.c
    ├── 2546.c
    ├── 2551.c
    ├── 2553.cpp
    ├── 2562.c
    ├── 2575.cpp
    ├── 2576.c
    ├── 2578.c
    ├── 2583.c
    ├── 2584.cpp
    ├── 2590.c
    ├── 2591.c
    ├── 2593.c
    ├── 2601.c
    ├── 2602.c
    ├── 2603.c
    ├── 2606.c
    ├── 2608.c
    ├── 2610.c
    ├── 2612.c
    ├── 2613.c
    ├── 2623.c
    ├── 2624.c
    ├── 2636.c
    ├── 2641.c
    ├── 2643.c
    ├── 2649.c
    ├── 2656.c
    ├── 2657.cpp
    ├── 2658.c
    ├── 2659.cpp
    ├── 2661.c
    ├── 2663.c
    ├── 2664.c
    ├── 2665.c
    ├── 2666.c
    ├── 2668.c
    ├── 2670.c
    ├── 2671.c
    ├── 2673.c
    ├── 2680.java
    ├── 2681.c
    ├── 2696.c
    ├── 2707.c
    ├── 2719.c
    ├── 2722.c
    ├── 2725.c
    ├── 2726.c
    ├── 2728.cpp
    ├── 2729.cpp
    ├── 2739.c
    ├── 2748.c
    ├── 2751.c
    ├── 2752.c
    ├── 2756.java
    ├── 2769.c
    ├── 2771.cpp
    ├── 2772.c
    ├── 2773.c
    ├── 2833.c
    ├── 2840.c
    ├── 2845.c
    ├── 2853.c
    ├── 2864.cpp
    ├── 2871.c
    ├── 2876.c
    ├── 2894.cpp
    ├── 2897.c
    ├── 2909.c
    ├── 2912.c
    ├── 2924.c
    ├── 2934.c
    ├── 2940.c
    ├── 2959.c
    ├── 2969.c
    ├── 2992.c
    ├── 2993.c
    ├── 2996.c
    ├── 2997.c
    ├── 3002.c
    ├── 3006.cpp
    ├── 3007.c
    ├── 3009.c
    ├── 3012.c
    ├── 3018.cpp
    ├── 3020.cpp
    ├── 3027.c
    ├── 3030.c
    ├── 3032.c
    ├── 3036.c
    ├── 3039.c
    ├── 3044.c
    ├── 3045.cpp
    ├── 3046.c
    ├── 3047.c
    ├── 3048.c
    ├── 3049.c
    ├── 3051.cpp
    ├── 3053.c
    ├── 3060.c
    ├── 3061.c
    ├── 3062.c
    ├── 3066.c
    ├── 3067.c
    ├── 3069.c
    ├── 3070.c
    ├── 3075.c
    ├── 3077.c
    ├── 3078.c
    ├── 3080.c
    ├── 3083.c
    ├── 3085.c
    ├── 3086.c
    ├── 3087.c
    ├── 3088.c
    ├── 3090.c
    ├── 3091.c
    ├── 3092.c
    ├── 3093.c
    ├── 3094.c
    ├── 3095.c
    ├── 3096.c
    ├── 3098.cpp
    ├── 3100.c
    ├── 3103.c
    ├── 3104.c
    ├── 3105.c
    ├── 3107.c
    ├── 3117.c
    ├── 3123.c
    ├── 3125.cpp
    ├── 3129.cpp
    ├── 3138.cpp
    ├── 3140.cpp
    ├── 3141.c
    ├── 3154.c
    ├── 3157.cpp
    ├── 3173.c
    ├── 3176.c
    ├── 3183.cpp
    ├── 3191.c
    ├── 3199.java
    ├── 3207.cpp
    ├── 3210.c
    ├── 3218.c
    ├── 3219.c
    ├── 3224.c
    ├── 3226.c
    ├── 3230.c
    ├── 3232.c
    ├── 3239.c
    ├── 3249.cpp
    ├── 3250.c
    ├── 3256.cpp
    ├── 3262.c
    ├── 3273.c
    ├── 3278.cpp
    ├── 3282.c
    ├── 3286.c
    ├── 3290.c
    ├── 3292.cpp
    ├── 3295.cpp
    ├── 3299.c
    ├── 3300.c
    ├── 3302.c
    ├── 3307.c
    ├── 3310.cpp
    ├── 3312.c
    ├── 3318.c
    ├── 3325.c
    ├── 3326.cpp
    ├── 3331.c
    ├── 3332.cpp
    ├── 3337.c
    ├── 3338.cpp
    ├── 3340.c
    ├── 3366.cpp
    ├── 3372.c
    ├── 3385.c
    ├── 3404.c
    ├── 3425.c
    ├── 3427.java
    ├── 3438.java
    ├── 3444.cpp
    ├── 3507.cpp
    ├── 3517.cpp
    ├── 3518.java
    ├── 3589.cpp
    ├── 3619.cpp
    ├── 3620.cpp
    ├── 3624.cc
    ├── 3627.cpp
    ├── 3630.cpp
    ├── 3632.c
    ├── 3637.java
    ├── 3650.cpp
    ├── 3660.cpp
    ├── 3663.cpp
    ├── 3664.cpp
    ├── 3671.cpp
    ├── 3672.cpp
    ├── 3673.cpp
    ├── 3720.cpp
    ├── 3723.cpp
    ├── 3913.cc
    ├── 3978.cc
    ├── 3979.cc
    ├── 3980.cc
    ├── 3981.cc
    ├── 3982.java
    ├── 3983.cc
    └── 3984.cc


/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018 changda
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | This repo contains my solutions to ACM programming contest problems hosted at POJ (http://poj.org/). You can check my profile on POJ at http://poj.org/userstatus?user_id=snuc. 
2 | 
3 | Problems are organized using their problem ID. All files about Problem X(such as 1000, 1001, and so on) are named with 'X', and the description of the Problem X can be found at http://poj.org/problem?id=X.


--------------------------------------------------------------------------------
/poj/1000.c:
--------------------------------------------------------------------------------
1 | #include <stdio.h>
2 | int main()
3 | {
4 |     int a,b;
5 |     scanf("%d %d",&a, &b);
6 |     printf("%d\n",a+b);
7 |     return 0;
8 | }
9 | 


--------------------------------------------------------------------------------
/poj/1003.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int i;
 5 | 	double n,m=0;
 6 | 	scanf("%lf",&n);
 7 | 	while(n!=0)
 8 | 	{
 9 | 		for (i=2;m<n;i++)
10 | 		{
11 | 			m+=1/(double)i;
12 | 		}
13 | 		printf("%d card(s)\n",i-2);
14 | 		scanf("%lf",&n);
15 | 		m=0;
16 | 	}
17 | 	return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/poj/1004.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	double sum=0.0,t;
 5 | 	int i=1;
 6 | 	for (;i<=12;i++)
 7 | 	{
 8 | 		scanf("%lf",&t);
 9 | 		sum+=t;
10 | 	}
11 | 	sum/=12.0;
12 | 	printf("$%.2lf\n",sum);
13 | 	return 0;
14 | }
15 | 


--------------------------------------------------------------------------------
/poj/1005.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #define pi 3.14159265358979323846
 3 | int main()
 4 | {
 5 | 	int n,i;
 6 | 	int m;
 7 | 	double a,b;
 8 | 	scanf("%d",&n);
 9 | 	for (i=1;i<=n;i++)
10 | 	{
11 | 		scanf("%lf %lf",&a,&b);
12 | 		m=(int)((a*a+b*b)*pi/100)+1;
13 | 		printf("Property %d: This property will begin eroding in year %d.\n",i,m);
14 | 	}
15 | 	printf("END OF OUTPUT.\n");
16 | 	return 0;
17 | }
18 | 


--------------------------------------------------------------------------------
/poj/1006.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int m,p,e,i,d,j=1;
 5 | 	while (1)
 6 | 	{
 7 | 		scanf("%d %d %d %d",&p,&e,&i,&d);
 8 | 		if (p==-1 && e==-1 && i==-1 && d==-1)
 9 | 			break;
10 | 		m=(5544*(p%23)+14421*(e%28)+1288*(i%33))%21252-d;
11 | 		if (m<=0)
12 | 			m+=21252;
13 | 		printf("Case %d: the next triple peak occurs in %d days.\n",j,m);
14 | 		j++;
15 | 	}
16 | 	return 0;
17 | }
18 | 


--------------------------------------------------------------------------------
/poj/1007.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int m,n,i,j,k,num[100]={0};
 5 | 	char st[100][51];
 6 | 	scanf("%d %d\n",&n,&m);
 7 | 	for (i=0;i<m;i++)
 8 | 	{
 9 | 		scanf("%s",st[i]);
10 | 		for (j=0;j<n;j++)
11 | 		{
12 | 			for (k=j+1;k<n;k++)
13 | 			{
14 | 				if (st[i][j]>st[i][k])
15 | 					num[i]++;
16 | 			}
17 | 		}
18 | 	}
19 | 	for (i=0;i<m;i++)
20 | 	{
21 | 		k=0;
22 | 		for (j=0;j<m;j++)
23 | 		{
24 | 			if (num[k]>num[j])
25 | 				k=j;
26 | 		}
27 | 		printf("%s\n",st[k]);
28 | 		num[k]=10000000;
29 | 	}
30 | 	return 0;
31 | }
32 | 


--------------------------------------------------------------------------------
/poj/1008.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int main()
 4 | {
 5 | 	int n,i,j,k,d,y,p;
 6 | 	char m[19][7]={"pop","no","zip","zotz","tzec","xul","yoxkin","mol","chen","yax","zac","ceh","mac","kankin","muan","pax","koyab","cumhu","uayet"},s[7];
 7 | 	char a[20][9]={"imix","ik","akbal","kan","chicchan","cimi","manik","lamat","muluk","ok","chuen","eb","ben","ix","mem","cib","caban","eznab","canac","ahau"};
 8 | 	scanf("%d",&n);
 9 | 	printf("%d\n",n);
10 | 	for (i=0;i<n;i++)
11 | 	{
12 | 		scanf("%d. %s %d",&d,s,&y);
13 | 		for (j=0;j<19;j++)
14 | 		{
15 | 			if (strcmp(m[j],s)==0)
16 | 				break;
17 | 		}
18 | 		p=y*365+j*20+d;
19 | 		y=p/260;
20 | 		p-=y*260;
21 | 		j=p%20;
22 | 		d=p%13+1;
23 | 		printf("%d %s %d\n",d,a[j],y);
24 | 	}
25 | 	return 0;
26 | }
27 | 


--------------------------------------------------------------------------------
/poj/1012.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int x[] = {2,7,5,30,169,441,1872,7632,1740,93313,459901,1358657,2504881};
 3 | int main()
 4 | {
 5 | 	int n;
 6 | 	while (scanf("%d",&n),n!=0)
 7 | 		printf("%d\n",x[n-1]);
 8 | 	return 0;
 9 | }
10 | 


--------------------------------------------------------------------------------
/poj/1017.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int a,b,c,d,e,f,s;
 5 | 	while (scanf("%d%d%d%d%d%d",&a,&b,&c,&d,&e,&f),a!=0 || b!=0 || c!=0 || d!=0 || e!=0 || f!=0)
 6 | 	{
 7 | 		s=d+e+f;
 8 | 		a-=11*e;
 9 | 		b-=5*d;
10 | 		s+=c/4;
11 | 		c%=4;
12 | 		if (c!=0)
13 | 		{
14 | 			s++;
15 | 			if (c==3)
16 | 			{
17 | 				b--;
18 | 				a-=5;
19 | 			}
20 | 			else if (c==2)
21 | 			{
22 | 				b-=3;
23 | 				a-=6;
24 | 			}
25 | 			else if (c==1)
26 | 			{
27 | 				b-=5;
28 | 				a-=7;
29 | 			}
30 | 		}
31 | 		if (b>0)
32 | 		{
33 | 			s+=b/9;
34 | 			b%=9;
35 | 			if (b!=0)
36 | 			{
37 | 				s++;
38 | 				b-=9;
39 | 			}
40 | 		}
41 | 		a+=4*b;
42 | 		if (a>0)
43 | 		{
44 | 			s+=a/36;
45 | 			a%=36;
46 | 			if (a!=0)
47 | 				s++;
48 | 		}
49 | 		printf("%d\n",s);
50 | 	}
51 | 	return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/poj/1028.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int top = 0, up = 0;
 4 | char stack[110][100]={"http://www.acm.org/"};
 5 | int main()
 6 | {
 7 |     char str[100];
 8 | 	scanf("%s", str);
 9 | 	while (strcmp(str, "QUIT") != 0)
10 | 	{
11 | 		if (strcmp(str, "VISIT") == 0)
12 | 		{
13 | 			scanf("%s", stack[++top]);
14 | 			printf("%s\n", stack[top]);
15 | 			up = top;
16 | 		}
17 | 		else if (strcmp(str, "BACK") == 0)
18 | 		{
19 | 			if (top == 0)
20 | 				printf("Ignored\n");
21 | 			else printf("%s\n", stack[--top]);
22 | 		}
23 | 		else if (strcmp(str, "FORWARD") == 0)
24 | 		{
25 | 			if (top == up)
26 | 				printf("Ignored\n");
27 | 			else printf("%s\n", stack[++top]);
28 | 		}
29 | 		scanf("%s", str);
30 | 	}
31 | 	return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/poj/1032.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i=4,m=5,j;
 5 | 	scanf("%d",&n);
 6 | 	while (m<n)
 7 | 		m+=i++;
 8 | 	j=m-n;
 9 | 	m=2;
10 | 	if (j==1)
11 | 	{
12 | 		m++;
13 | 		j=i-1;
14 | 		i++;
15 | 	}
16 | 	while (m<i)
17 | 	{
18 | 		if (m!=j)
19 | 			printf("%d ",m);
20 | 		m++;
21 | 	}
22 | 	return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/poj/1045.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<math.h>
 3 | int main()
 4 | {
 5 | 	int n,i;
 6 | 	double vs,r,c,w,vr;
 7 | 	scanf("%lf%lf%lf%d",&vs,&r,&c,&n);
 8 | 	for (i=0;i<n;i++)
 9 | 	{
10 | 		scanf("%lf",&w);
11 | 		vr=(r*c*w*vs)/sqrt(1+r*r*c*c*w*w);
12 | 		printf("%.3lf\n",vr);
13 | 	}
14 | 	return 0;
15 | }
16 | 


--------------------------------------------------------------------------------
/poj/1046.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int color[16][3];
 3 | int main()
 4 | {
 5 | 	int x,y,z,i,min,map,m;
 6 | 	for (i=0;i<16;i++)
 7 | 		scanf("%d%d%d",&color[i][0],&color[i][1],&color[i][2]);
 8 | 	scanf("%d%d%d",&x,&y,&z);
 9 | 	while (x!=-1 || y!=-1 || z!=-1)
10 | 	{
11 | 		min=200000;
12 | 		for (i=0;i<16;i++)
13 | 		{
14 | 			m=(x-color[i][0])*(x-color[i][0])+(y-color[i][1])*(y-color[i][1])+(z-color[i][2])*(z-color[i][2]);
15 | 			if (m<min)
16 | 				min=m,map=i;
17 | 		}
18 | 		printf("(%d,%d,%d) maps to (%d,%d,%d)\n",x,y,z,color[map][0],color[map][1],color[map][2]);
19 | 		scanf("%d%d%d",&x,&y,&z);
20 | 	}
21 | 	return 0;
22 | }
23 | 


--------------------------------------------------------------------------------
/poj/1050.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i,j,k,l,max=0,t,r[100][100];
 5 | 	scanf("%d",&n);
 6 | 	for (i=0;i<n;i++)
 7 | 		for (j=0;j<n;j++)
 8 | 			scanf("%d",&r[i][j]);
 9 | 	for (i=0;i<n;i++)
10 | 	{
11 | 		for (j=0;j<n-i;j++)
12 | 		{
13 | 			t=0;
14 | 			for (k=0;k<n;k++)
15 | 			{
16 | 				for (l=0;l<=i;l++)
17 | 					t+=r[l+j][k];
18 | 				if (t>max)
19 | 					max=t;
20 | 				if (t<0)
21 | 					t=0;
22 | 			}
23 | 		}
24 | 	}
25 | 	printf("%d\n",max);
26 | 	return 0;
27 | }
28 | 


--------------------------------------------------------------------------------
/poj/1056.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | #include<stdlib.h>
 4 | int sequence[10];
 5 | char phone[10][20];
 6 | int cmp(const void *a,const void *b)
 7 | {
 8 | 	int x=*(int *)a;
 9 | 	int y=*(int *)b;
10 | 	if (strcmp(phone[x],phone[y])<0)
11 | 		return -1;
12 | 	else if (strcmp(phone[x],phone[y])>0)
13 | 		return 1;
14 | 	else return 0;
15 | }
16 | int main()
17 | {
18 | 	int j;
19 | 	int t=1,n;
20 | 	while (gets(phone[0])!=NULL)
21 | 	{
22 | 		n=0;
23 | 		while (strcmp(phone[n],"9")!=0)
24 | 		{
25 | 			sequence[n]=n;
26 | 			n++;
27 | 			gets(phone[n]);
28 | 		}
29 | 		qsort(sequence,n,sizeof(sequence[0]),cmp);
30 | 		for (j=1;j<n;j++)
31 | 		{
32 | 			if (strncmp(phone[sequence[j-1]],phone[sequence[j]],strlen(phone[sequence[j-1]]))==0)
33 | 				break;
34 | 		}
35 | 		if (j==n)
36 | 			printf("Set %d is immediately decodable\n",t);
37 | 		else printf("Set %d is not immediately decodable\n",t);
38 | 		t++;
39 | 	}
40 | 	return 0;
41 | }
42 | 


--------------------------------------------------------------------------------
/poj/1061.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | __int64 x,y;
 3 | __int64 ext_euclid(__int64 a,__int64 b)
 4 | {
 5 | 	__int64 t,d;
 6 | 	if (b==0)
 7 | 	{
 8 | 		x=1;
 9 | 		y=0;
10 | 		return a;
11 | 	}
12 | 	d=ext_euclid(b,a%b);
13 | 	t=x;
14 | 	x=y;
15 | 	y=t-a/b*y;
16 | 	return d;
17 | }
18 | __int64 mod(__int64 a,__int64 b,__int64 n)
19 | {
20 | 	__int64 d,e;
21 | 	d=ext_euclid(a,n);
22 | 	if(b%d>0)
23 | 		return -1;
24 | 	else
25 | 	{
26 | 		e=(x*(b/d))%n;
27 | 		if(e<0)
28 | 			e=e+n;
29 | 		e=e%(n/d);
30 | 		return e;
31 | 	}
32 | }
33 | 
34 | int main()
35 | {
36 |     __int64 x1,y1,m,n,l,e,b;
37 |     scanf("%I64d%I64d%I64d%I64d%I64d",&x1,&y1,&m,&n,&l);
38 | 	m=(l+m-n)%l;
39 | 	b=(l+y1-x1)%l;
40 | 	e=mod(m,b,l);
41 | 	if (e==-1)
42 | 		printf("Impossible\n");
43 | 	else printf("%I64d\n",e);
44 | 	return 0;
45 | }
46 | 


--------------------------------------------------------------------------------
/poj/1067.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #define R 1.61803398874989484820458683436564
 3 | #define r 0.61803398874989484820458683436564
 4 | int main()
 5 | {
 6 | 	int m,n,temp;
 7 | 	int num;
 8 | 	while((scanf("%d %d",&m,&n))!=EOF)
 9 | 	{
10 | 		if (m>n)
11 | 		{
12 | 			temp=m;
13 | 			m=n;
14 | 			n=temp;
15 | 		}
16 | 		num=(int)m*r;
17 | 		if (m!=(int)(num*R))
18 | 			num++;
19 | 		if (n==(int)(num*R)+num)
20 | 			printf("0\n");
21 | 		else printf("1\n");
22 | 	}
23 | 	return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/poj/1068.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int stack[100],top;
 3 | int main()
 4 | {
 5 | 	int test,t;
 6 | 	int n,i,j,s,u;
 7 | 	scanf("%d",&test);
 8 | 	for (t=0;t<test;t++)
 9 | 	{
10 | 		top=0;
11 | 		scanf("%d",&n);
12 | 		for (i=0,s=0;i<n;i++)
13 | 		{
14 | 			scanf("%d",&u);
15 | 			for (j=0;j<u-s;j++)
16 | 				stack[top++]=1;
17 | 			s=u;
18 | 			for (j=top-1,u=1;j>=0 && stack[j]==0;j--,u++);
19 | 			stack[j]=0;
20 | 			printf("%d ",u);
21 | 		}
22 | 		putchar('\n');
23 | 	}			
24 |     return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/poj/1088.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int r,c,p[100][100],q[100][100]={0};
 3 | void dp(int i,int j)
 4 | {
 5 | 	int x=-1;
 6 | 	if (q[i][j]!=0)
 7 | 		return ;
 8 | 	if (i>0 && p[i-1][j]>p[i][j])
 9 | 	{
10 | 		if (q[i-1][j]==0)
11 | 			dp(i-1,j);
12 | 		if (q[i-1][j]>x)
13 | 			x=q[i-1][j];
14 | 	}
15 | 	if (i<r-1 && p[i+1][j]>p[i][j])
16 | 	{
17 | 		if (q[i+1][j]==0)
18 | 			dp(i+1,j);
19 | 		if (q[i+1][j]>x)
20 | 			x=q[i+1][j];
21 | 	}
22 | 	if (j>0 && p[i][j-1]>p[i][j])
23 | 	{
24 | 		if (q[i][j-1]==0)
25 | 			dp(i,j-1);
26 | 		if (q[i][j-1]>x)
27 | 			x=q[i][j-1];
28 | 	}
29 | 	if (j<c-1 && p[i][j+1]>p[i][j])
30 | 	{
31 | 		if (q[i][j+1]==0)
32 | 			dp(i,j+1);
33 | 		if (q[i][j+1]>x)
34 | 			x=q[i][j+1];
35 | 	}
36 | 	q[i][j]=x+1;
37 | }
38 | int main()
39 | {
40 | 	int i,j,m=0;
41 | 	scanf("%d%d",&r,&c);
42 | 	for (i=0;i<r;i++)
43 | 		for (j=0;j<c;j++)
44 | 			scanf("%d",&p[i][j]);
45 | 	for (i=0;i<r;i++)
46 | 	{
47 | 		for (j=0;j<c;j++)
48 | 		{
49 | 			dp(i,j);
50 | 			if (q[i][j]>m)
51 | 				m=q[i][j];
52 | 		}
53 | 	}
54 | 	printf("%d\n",m+1);
55 | 	return 0;
56 | }
57 | 


--------------------------------------------------------------------------------
/poj/1125.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | #define MAX 100
 4 | int Dist[MAX][MAX],n;
 5 | void Floyd_Warshall(int n)
 6 | {
 7 | 	int i,j,k;
 8 | 	for (k=0;k<n;k++)
 9 | 		for (i=0;i<n;i++)
10 | 			for (j=0;j<n;j++)
11 | 				if (Dist[i][k]!=0 && Dist[k][j]!=0 && (Dist[i][j]==0 || Dist[i][k]+Dist[k][j]<Dist[i][j]))
12 | 					Dist[i][j]=Dist[i][k]+Dist[k][j];
13 | }
14 | int main()
15 | {
16 | 	int i,j,k,a,b,m;
17 | 	scanf("%d",&n);
18 | 	while (n!=0)
19 | 	{
20 | 		memset(Dist,0,sizeof(Dist));
21 | 		for (i=0;i<n;i++)
22 | 		{
23 | 			scanf("%d",&m);
24 | 			for (j=0;j<m;j++)
25 | 			{
26 | 				scanf("%d%d",&a,&b);
27 | 				Dist[i][a-1]=b;
28 | 			}
29 | 		}
30 | 		Floyd_Warshall(n);
31 | 		for (i=0,a=10000;i<n;i++)
32 | 		{
33 | 			for (j=0,k=0;j<n;j++)
34 | 			{
35 | 				if (i==j)
36 | 					continue;
37 | 				if (Dist[i][j]==0)
38 | 					break;
39 | 				if (Dist[i][j]>k)
40 | 					k=Dist[i][j];
41 | 			}
42 | 			if (j==n && k!=0 && k<a)
43 | 				a=k,b=i+1;
44 | 		}
45 | 		if (a==10000)
46 | 			printf("disjoint\n");
47 | 		else printf("%d %d\n",b,a);
48 | 		scanf("%d",&n);
49 | 	}
50 | 	return 0;
51 | }
52 | 


--------------------------------------------------------------------------------
/poj/1126.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | char str[300];
 3 | int sentence(int p)
 4 | {
 5 | 	int q;
 6 | 	if (str[p]>='p' && str[p]<='z')
 7 | 		return p+1;
 8 | 	if (str[p]=='N')
 9 | 		return sentence(p+1);
10 | 	if (str[p]=='C' || str[p]=='D' || str[p]=='E' || str[p]=='I')
11 | 	{
12 | 		q=sentence(p+1);
13 | 		if (q>=0)
14 | 			return sentence(q);
15 | 		else return -1;
16 | 	}
17 | 	return -1;
18 | }
19 | int main()
20 | {
21 | 	int p;
22 | 	while (scanf("%s",str)!=EOF)
23 | 	{
24 | 		p=sentence(0);
25 | 		if (p>0 && str[p]=='\0')
26 | 			printf("YES\n");
27 | 		else printf("NO\n");
28 | 	}
29 | 	return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/poj/1159.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | #define MAX 5001
 4 | char str[MAX],ing[MAX];
 5 | int n;
 6 | short c[MAX][MAX]={0};
 7 | int LCS();
 8 | int main()
 9 | {
10 | 	int i,j;
11 | 	scanf("%d",&n);
12 | 	scanf("%s",str);
13 | 	for (i=0,j=n-1;i<n;i++,j--)
14 | 		ing[j]=str[i];
15 | 	ing[n]='\0';
16 | 	printf("%d\n",n-LCS());
17 | 	return 0;
18 | }
19 | int LCS()
20 | {
21 | 	int i,j;
22 | 	for (i=1;i<=n;i++)
23 | 	{
24 | 		for (j=1;j<=n;j++)
25 | 		{
26 | 			if (str[i-1]==ing[j-1])
27 | 				c[i][j]=c[i-1][j-1]+(short)1;
28 | 			else c[i][j]=(c[i-1][j]>c[i][j-1]) ? c[i-1][j] : c[i][j-1];
29 | 		}
30 | 	}
31 | 	return c[n][n];
32 | }
33 | 


--------------------------------------------------------------------------------
/poj/1163.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int f[2][100],i,j,n,d=0;
 5 | 	scanf("%d\n%d",&n,&f[0][0]);
 6 | 	for (i=1;i<n;i++)
 7 | 	{
 8 | 		d=1-d;
 9 | 		scanf("%d",&f[d][0]);
10 | 		f[d][0]+=f[1-d][0];
11 | 		for (j=1;j<i;j++)
12 | 		{
13 | 			scanf("%d",&f[d][j]);
14 | 			f[d][j]+=(f[1-d][j-1] > f[1-d][j]) ? f[1-d][j-1] : f[1-d][j];
15 | 		}
16 | 		scanf("%d",&f[d][i]);
17 | 		f[d][i]+=f[1-d][i-1];
18 | 	}
19 | 	j=f[d][0];
20 | 	for (i=1;i<n;i++)
21 | 	{
22 | 		if (j<f[d][i])
23 | 			j=f[d][i];
24 | 	}
25 | 	printf("%d\n",j);
26 | 	return 0;
27 | }
28 | 


--------------------------------------------------------------------------------
/poj/1183.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	unsigned long a,i;
 5 | 	scanf("%ld",&a);
 6 | 	for(i=a;;i--)
 7 | 		if ((a*a+1)%i==0)
 8 | 			break;
 9 | 	printf("%ld\n",2*a+(a*a+1)/i+i);
10 | 	return 0;
11 | }
12 | 


--------------------------------------------------------------------------------
/poj/1207.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int pro(int p)
 3 | {
 4 | 	int s=1;
 5 | 	while (p!=1)
 6 | 	{
 7 | 		if (p%2==0)
 8 | 			p=p>>1;
 9 | 		else p=3*p+1;
10 | 		s++;
11 | 	}
12 | 	return s;
13 | }
14 | int main()
15 | {
16 | 	int a,b,i,j,k;
17 | 	while (scanf("%d%d",&a,&b)!=EOF)
18 | 	{
19 | 		printf("%d %d ",a,b);
20 | 		if (a>b)
21 | 		{
22 | 			i=b;
23 | 			b=a;
24 | 			a=i;
25 | 		}
26 | 		for (i=a,j=1;i<=b;i++)
27 | 		{
28 | 			k=pro(i);
29 | 			if (k>j)
30 | 				j=k;
31 | 		}
32 | 		printf("%d\n",j);
33 | 	}
34 | 	return 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/poj/1218.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <math.h>
 3 | int main()
 4 | {
 5 | 	int n,k,i=1;
 6 | 	scanf("%d",&n);
 7 | 	while (i<=n)
 8 | 	{
 9 | 		scanf("%d",&k);
10 | 		printf("%d\n",(int)sqrt(k));
11 | 		i++;
12 | 	}
13 | 	return 0;
14 | }
15 | 


--------------------------------------------------------------------------------
/poj/1247.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i,e,s;
 5 | 	int guest[31];
 6 | 	while (scanf("%d",&n),n!=0)
 7 | 	{
 8 | 		s=0;
 9 | 		for (i=1;i<=n;i++)
10 | 		{
11 | 			scanf("%d",&guest[i]);
12 | 			s+=guest[i];
13 | 		}
14 | 		e=0;
15 | 		for (i=1;i<=n;i++)
16 | 		{
17 | 			e+=guest[i];
18 | 			if (e+e==s)
19 | 				break;
20 | 		}
21 | 		if (i<=n)
22 | 			printf("Sam stops at position %d and Ella stops at position %d.\n",i,i+1);
23 | 		else printf("No equal partitioning.\n");
24 | 	}
25 | 	return 0;
26 | }
27 | 


--------------------------------------------------------------------------------
/poj/1250.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int i,j,k,n,m,l;
 4 | bool p[26],check[26];
 5 | char s[500];
 6 | int main()
 7 | {
 8 | 	while(scanf("%d",&n),n)
 9 | 	{
10 | 		memset(p,0,sizeof(p));
11 | 		memset(check,0,sizeof(check));
12 | 		scanf("%s",s);
13 | 		m=0;
14 | 		k=strlen(s);
15 | 		for (i=0;i<k;i++)
16 | 		{
17 | 			l=s[i]-'A';
18 | 			if (p[l])
19 | 			{
20 | 				p[l]=0;
21 | 				if (!check[l])
22 | 					n++;
23 | 				else m++;
24 | 			}
25 | 			else 
26 | 			{
27 | 				p[l]=1;
28 | 				if (n) 
29 | 					n--;
30 | 				else check[l]=1;
31 | 			}
32 | 		}
33 | 		if (m) 
34 | 			printf("%d customer(s) walked away.\n",m);
35 | 		else printf("All customers tanned successfully.\n");
36 | 	}
37 | 	return 0;
38 | }
39 | 


--------------------------------------------------------------------------------
/poj/1274.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #define MN 400
 3 | bool check[MN];
 4 | bool hide[MN][MN]={false};
 5 | int match[MN],num,n,m;
 6 | bool DFS(int p);
 7 | int main()
 8 | {
 9 | 	int save,i,j,k;
10 | 	while (scanf("%d%d",&n,&m)!=EOF)
11 | 	{
12 | 		num=n+m;
13 | 		for (i=0;i<n;i++)
14 | 		{
15 | 			scanf("%d",&save);
16 | 			for (j=0;j<save;j++)
17 | 			{
18 | 				scanf("%d",&k);
19 | 				hide[i][n+k-1]=true;
20 | 				hide[n+k-1][i]=true;
21 | 			}
22 | 		}
23 | 		memset(match,-1,sizeof(match));
24 | 		save=0;
25 | 		for(i=0;i<n;i++)
26 | 		{
27 | 			memset(check,false,sizeof(check));
28 | 			if (DFS(i))
29 | 				save++;
30 | 		}
31 | 		printf("%d\n",save);
32 | 		memset(hide,false,sizeof(hide));
33 | 	}
34 | 	return 0;
35 | }
36 | bool DFS(int p)
37 | {
38 | 	int i,t,a,b;
39 | 	if (p<n)
40 | 		a=n,b=num;
41 | 	else a=0,b=n;
42 | 	for(i=a;i<b;i++)
43 | 	{
44 | 		if (hide[i][p] && !check[i])
45 | 		{
46 | 			check[i]=true;
47 | 			t=match[i];
48 | 			match[i]=p;
49 | 			if (t==-1 || DFS(t))
50 | 				return true;
51 | 			match[i]=t;
52 | 		}
53 | 	}
54 | 	return false;
55 | }
56 | 


--------------------------------------------------------------------------------
/poj/1298.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int main()
 4 | {
 5 | 	int i;
 6 | 	char s[201];
 7 | 	gets(s);
 8 | 	while (strcmp(s,"START")==0)
 9 | 	{
10 | 		gets(s);
11 | 		while (strcmp(s,"END")!=0)
12 | 		{
13 | 			for (i=0;s[i]!='\0';i++)
14 | 			{
15 | 				if (s[i]>'E' && s[i]<='Z')
16 | 					printf("%c",s[i]-5);
17 | 				else if (s[i]>='A' && s[i]<'F')
18 | 					printf("%c",s[i]+21);
19 | 				else printf("%c",s[i]);
20 | 			}
21 | 			printf("\n");
22 | 			gets(s);
23 | 		}
24 | 		gets(s);
25 | 	}
26 | 	return 0;
27 | }
28 | 


--------------------------------------------------------------------------------
/poj/1306.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | __int64 zuhe(int m,int k)
 3 | {
 4 | 	int i;
 5 | 	__int64 s=1;
 6 | 	if (k>m-k)
 7 | 		k=m-k;
 8 | 	for (i=1;i<=k;i++)
 9 | 		s=s*(m+1-i)/i;
10 | 	return s;
11 | }
12 | int main()
13 | {
14 | 	int n,m;
15 | 	scanf("%d%d",&n,&m);
16 | 	while (n!=0 || m!=0)
17 | 	{
18 | 		printf("%d things taken %d at a time is %I64d exactly.\n",n,m,zuhe(n,m));
19 | 		scanf("%d%d",&n,&m);
20 | 	}
21 | 	return 0;
22 | }
23 | 


--------------------------------------------------------------------------------
/poj/1316.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int i=1,j,k,a[10036]={0};
 5 | 	for (;i<10000;i++)
 6 | 	{
 7 | 		if (a[i]==0)
 8 | 			printf("%d\n",i);
 9 | 		j=i;
10 | 		k=i;
11 | 		while (j!=0)
12 | 		{
13 | 			k+=j%10;
14 | 			j/=10;
15 | 		}
16 | 		a[k]=1;
17 | 	}
18 | 	return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/poj/1323.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | int card[50],n,m;
 4 | int cmp(const void *a, const void *b)
 5 | {
 6 | 	int x,y;
 7 | 	x=*(int *)a;
 8 | 	y=*(int *)b;
 9 | 	if (x<y)
10 | 		return 1;
11 | 	else if (x>y)
12 | 		return -1;
13 | 	else return 0;
14 | }
15 | 
16 | int main()
17 | {
18 | 	int flag[1001],i,t=1,max,s;
19 | 	while (scanf("%d%d",&m,&n),m!=0 || n!=0)
20 | 	{
21 | 		for (i=0;i<n;i++)
22 | 			scanf("%d",&card[i]);
23 | 		for (i=1;i<=n*m;i++)
24 | 			flag[i]=0;
25 | 		qsort(card,n,sizeof(card[0]),cmp);
26 | 		max=n*m;
27 | 		s=0;
28 | 		for (i=0;i<n;i++)
29 | 		{
30 | 			while (flag[max]==1)
31 | 				max--;
32 | 			if (max==card[i])
33 | 				s++;
34 | 			flag[max]=1;
35 | 			flag[card[i]]=1;
36 | 		}
37 | 		printf("Case %d: %d\n",t++,s);
38 | 	}
39 | 	return 0;
40 | }
41 | 


--------------------------------------------------------------------------------
/poj/1326.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <string.h>
 3 | int main()
 4 | {
 5 | 	int mile,total;
 6 | 	char s[100],t[100];
 7 | 	scanf("%s",s);
 8 | 	while (strcmp(s,"#")!=0)
 9 | 	{
10 | 		total=0;
11 | 		while (strcmp(s,"0")!=0)
12 | 		{
13 | 			scanf("%s%d%s",s,&mile,t);
14 | 			if (t[0]=='F')
15 | 				total+=mile*2;
16 | 			else if (t[0]=='B')
17 | 				total+=mile+(mile+1)/2;
18 | 			else if (mile<500)
19 | 				total+=500;
20 | 			else total+=mile;
21 | 			scanf("%s",s);
22 | 		}
23 | 		printf("%d\n",total);
24 | 		scanf("%s",s);
25 | 	}
26 | 	return 0;
27 | }
28 | 


--------------------------------------------------------------------------------
/poj/1350.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int n,d[4];
 3 | int main()
 4 | {
 5 | 	int i,j,k,p,t,big,small;
 6 | 	while (scanf("%d",&n),n!=-1)
 7 | 	{
 8 | 		printf("N=%d:\n",n);
 9 | 		if (n<1000 || n>9999 || n==1111 || n==2222 || n==3333 || n==4444 || n==5555 || n==6666 || n==7777 || n==8888 || n==9999)
10 | 		{
11 | 			printf("No!!\n");
12 | 			continue;
13 | 		}
14 | 		t=0;
15 | 		while (n!=6174 && n!=0)
16 | 		{
17 | 			d[0]=d[1]=d[2]=d[3]=0;
18 | 			for (p=0,j=n;j>0;p++,j/=10)
19 | 				d[p]=j%10;
20 | 			for (i=0;i<p;i++)
21 | 			{
22 | 				for (j=i+1;j<p;j++)
23 | 				{
24 | 					if (d[i]<d[j])
25 | 					{
26 | 						k=d[i];
27 | 						d[i]=d[j];
28 | 						d[j]=k;
29 | 					}
30 | 				}
31 | 			}
32 | 			for (big=0,i=0;i<p;i++)
33 | 				big=big*10+d[i];
34 | 			for (i=p-1;d[i]==0 && i>=0;i--);
35 | 			for (small=0;i>=0;i--)
36 | 				small=small*10+d[i];
37 | 			n=big-small;
38 | 			t++;
39 | 			printf("%d-%d=%d\n",big,small,n);
40 | 		}
41 | 		printf("Ok!! %d times\n",t);
42 | 	}
43 | 	return 0;
44 | }
45 | 


--------------------------------------------------------------------------------
/poj/1363.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int s[1000],n,i,j,c;
 5 | 	scanf("%d",&n);
 6 | 	while (n!=0)
 7 | 	{
 8 | 		scanf("%d",&s[0]);
 9 | 		while (s[0]!=0)
10 | 		{
11 | 			for (i=1;i<n;i++)
12 | 				scanf("%d",&s[i]);
13 | 			for (i=0;i<n;i++)
14 | 			{
15 | 				c=s[i];
16 | 				for (j=i+1;j<n;j++)
17 | 				{
18 | 					if (s[j]>s[i])
19 | 						continue;
20 | 					if (c>s[j])
21 | 						c=s[j];
22 | 					else break;
23 | 				}
24 | 				if (j<n)
25 | 					break;
26 | 			}
27 | 			if (i<n)
28 | 				printf("No\n");
29 | 			else printf("Yes\n");
30 | 			scanf("%d",&s[0]);
31 | 		}
32 | 		printf("\n");
33 | 		scanf("%d",&n);
34 | 	}
35 | 	return 0;
36 | }
37 | 


--------------------------------------------------------------------------------
/poj/1401.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int i,n,m,s;
 5 | 	scanf("%d",&n);
 6 | 	for (i=0;i<n;i++)
 7 | 	{
 8 | 		s=0;
 9 | 		scanf("%d",&m);
10 | 		while (m)
11 | 		{
12 | 			m/=5;
13 | 			s+=m;
14 | 		}
15 | 		printf("%d\n",s);
16 | 	}
17 | 	return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/poj/1422.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | #define MAX 120
 4 | bool Check[MAX];
 5 | bool Hide[MAX][MAX]={false};
 6 | int Match[MAX],n;
 7 | bool DFS(int p);
 8 | int main()
 9 | {
10 | 	int t,i,j,a,b,m,Save;
11 | 	scanf("%d",&t);
12 | 	for (j=0;j<t;j++)
13 | 	{
14 | 		scanf("%d%d",&n,&m);
15 | 		memset(Hide,false,sizeof(Hide));
16 | 		for (i=0;i<m;i++)
17 | 		{
18 | 			scanf("%d%d",&a,&b);
19 | 			Hide[a-1][b-1]=true;
20 | 		}
21 | 		Save=0;
22 | 		memset(Match,-1,sizeof(Match));
23 | 		for(i=0;i<n;i++)
24 | 		{
25 | 			memset(Check,false,sizeof(Check));
26 | 			if (DFS(i))
27 | 				Save++;
28 | 		}
29 | 		printf("%d\n",n-Save);
30 | 	}
31 | 	return 0;
32 | }
33 | bool DFS(int p)
34 | {
35 | 	int i,t;
36 | 	for(i=0;i<n;i++)
37 | 	{
38 | 		if (Hide[i][p] && !Check[i])
39 | 		{
40 | 			Check[i]=true;
41 | 			t=Match[i];
42 | 			Match[i]=p;
43 | 			if (t==-1 || DFS(t))
44 | 				return true;
45 | 			Match[i]=t;
46 | 		}
47 | 	}
48 | 	return false;
49 | }
50 | 


--------------------------------------------------------------------------------
/poj/1423.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<math.h>
 3 | const double e=2.7182818284590452354,pi=3.141592653589793239;
 4 | int main()
 5 | {
 6 | 	int n,i,d;
 7 | 	double a;
 8 | 	scanf("%d",&n);
 9 | 	for (i=0;i<n;i++)
10 | 	{
11 | 		scanf("%d",&d);
12 | 		if (d<4)
13 | 			a=1;
14 | 		else a=log10(sqrt(2*pi*d))+d*log10(d/e)+1;
15 | 		printf("%d\n",(int)a);
16 | 	}
17 | 	return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/poj/1450.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int total;
 5 | 	int m,n,i;
 6 | 	scanf("%d",&total);
 7 | 	for(i=1;i<=total;i++)
 8 | 	{
 9 | 		scanf("%d%d",&m,&n);
10 | 		printf("Scenario #%d:\n",i);
11 | 		m=m*n;
12 | 		if (m%2==0)
13 | 			printf("%d.00\n",m);
14 | 		else
15 | 			printf("%d.41\n",m);
16 | 		printf("\n");
17 | 	}
18 | 	return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/poj/1455.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i,d;
 5 | 	scanf("%d",&n);
 6 | 	for (i=0;i<n;i++)
 7 | 	{
 8 | 		scanf("%d",&d);
 9 | 		printf("%d\n",(d/2)*((d-1)/2));
10 | 	}
11 | 	return 0;
12 | }
13 | 


--------------------------------------------------------------------------------
/poj/1458.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | #define MAX 201
 4 | char s[MAX],t[MAX];
 5 | int c[MAX][MAX];
 6 | int LCS(int m,int n);
 7 | int main()
 8 | {
 9 | 	while (scanf("%s",s)!=EOF)
10 | 	{
11 | 		scanf("%s",t);
12 | 		printf("%d\n",LCS(strlen(s),strlen(t)));
13 | 	}
14 | 	return 0;
15 | }
16 | int LCS(int m,int n)
17 | {
18 | 	int i,j;
19 | 	memset(c,0,sizeof(c));
20 | 	for (i=1;i<=m;i++)
21 | 	{
22 | 		for (j=1;j<=n;j++)
23 | 		{
24 | 			if (s[i-1]==t[j-1])
25 | 				c[i][j]=c[i-1][j-1]+1;
26 | 			else c[i][j]=(c[i-1][j]>c[i][j-1]) ? c[i-1][j] : c[i][j-1];
27 | 		}
28 | 	}
29 | 	return c[m][n];
30 | }
31 | 


--------------------------------------------------------------------------------
/poj/1469.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/snuc/poj/80cccc7287f23d33cde75b51a78a04bdb75408cb/poj/1469.cpp


--------------------------------------------------------------------------------
/poj/1477.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int n,s[50];
 3 | int main()
 4 | {
 5 | 	int i,j,k,t=0;
 6 | 	while (scanf("%d",&n),n!=-0)
 7 | 	{
 8 | 		for (i=0,j=0;i<n;i++)
 9 | 		{
10 | 			scanf("%d",&s[i]);
11 | 			j+=s[i];
12 | 		}
13 | 		j/=n;
14 | 		for (i=0,k=0;i<n;i++)
15 | 		{
16 | 			if (s[i]>j)
17 | 				k+=s[i]-j;
18 | 		}
19 | 		printf("Set #%d\n",++t);
20 | 		printf("The minimum number of moves is %d.\n\n",k);
21 | 	}
22 | 	return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/poj/1503.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int main()
 4 | {
 5 | 	int b,i,j,k,s[105]={0};
 6 | 	char t[105];
 7 | 	scanf("%s",t);
 8 | 	while (t[0]!='0' || t[1]!='\0')
 9 | 	{
10 | 		b=strlen(t);
11 | 		j=0;
12 | 		for (i=b-1;i>=0;i--)
13 | 		{
14 | 			s[j]+=t[i]-'0';
15 | 			k=j;
16 | 			while (s[k]>9)
17 | 			{
18 | 				s[k++]-=10;
19 | 				s[k]++;
20 | 			}
21 | 			j++;
22 | 		}
23 | 		scanf("%s",t);
24 | 	}
25 | 	for (i=104;i>0 && s[i]==0;i--);
26 | 	while (i>=0)
27 | 		printf("%d",s[i--]);
28 | 	printf("\n");
29 | 	return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/poj/1504.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int main()
 4 | {
 5 | 	int n,m,i,j,k,a,b;
 6 | 	char s[100],t[100],r[200];
 7 | 	scanf("%d",&n);
 8 | 	for (i=0;i<n;i++)
 9 | 	{
10 | 		scanf("%s %s",s,t);
11 | 		memset(r,0,200);
12 | 		for (j=0;s[j]=='0';j++);
13 | 		for (k=j;s[k]!='\0';k++);
14 | 		for (k--;k>=j && s[k]=='0';k--);
15 | 		for (a=0;k>=j;j++)
16 | 			r[a++]+=s[j]-'0';
17 | 		for (j=0;t[j]=='0';j++);
18 | 		for (k=j;t[k]!='\0';k++);
19 | 		for (k--;k>=j && t[k]=='0';k--);
20 | 		for (a=0;k>=j;j++)
21 | 		{
22 | 			r[a]+=t[j]-'0';
23 | 			b=a++;
24 | 			while (r[b]>9)
25 | 			{
26 | 				r[b++]-=10;
27 | 				r[b]++;
28 | 			}
29 | 		}
30 | 		for (j=199;r[j]==0;j--);
31 | 		for (k=0;r[k]==0;k++);
32 | 		for (;k<=j;k++)
33 | 			printf("%d",r[k]);
34 | 		printf("\n");
35 | 	}
36 | 	return 0;
37 | }
38 | 


--------------------------------------------------------------------------------
/poj/1517.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int n;
 5 | 	double e=1,p=1;
 6 | 	printf("n e\n- -----------\n0 %.9lf\n",e);
 7 | 	for (n=1;n<10;n++)
 8 | 	{
 9 | 		p=p/n;
10 | 		e+=p;
11 | 		printf("%d %.9lf\n",n,e);
12 | 	}
13 | 	return 0;
14 | }
15 | 


--------------------------------------------------------------------------------
/poj/1519.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i;
 5 | 	char st[10000];
 6 | 	scanf("%s",st);
 7 | 	while (st[0]!='0')
 8 | 	{
 9 | 		n=0;
10 | 		i=0;
11 | 		while (st[i]!='\0')
12 | 			n+=st[i++]-'0';
13 | 		n%=9;
14 | 		if (n==0)
15 | 			n=9;
16 | 		printf("%d\n",n);
17 | 		scanf("%s",st);
18 | 	}
19 | 	return 0;
20 | }
21 | 


--------------------------------------------------------------------------------
/poj/1528.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,s,c,i;
 5 | 	scanf("%d",&n);
 6 | 	printf("PERFECTION OUTPUT\n");
 7 | 	while (n!=0)
 8 | 	{
 9 | 		if (n%2==0)
10 | 		{
11 | 			c=1;
12 | 			s=3+n/2;
13 | 		}
14 | 		else {
15 | 			c=2;
16 | 			s=1;
17 | 		}
18 | 		for (i=3;i*i<=n;i+=c)
19 | 		{
20 | 			if (n%i==0)
21 | 				s+=i+n/i;
22 | 		}
23 | 		printf("%5d  ",n);
24 | 		if (n==1)
25 | 			s=0;
26 | 		if (s==n)
27 | 			printf("PERFECT\n");
28 | 		else if (s>n)
29 | 			printf("ABUNDANT\n");
30 | 		else printf("DEFICIENT\n");
31 | 		scanf("%d",&n);
32 | 	}
33 | 	printf("END OF OUTPUT\n");
34 | 	return 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/poj/1543.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | void cude (int n)
 3 | {
 4 | 	int i,j,k,m=n*n*n,p,q,r;
 5 | 	for (i=2;i<n-2;i++)
 6 | 	{
 7 | 		p=i*i*i;
 8 | 		for (j=i+1;j<n;j++)
 9 | 		{
10 | 			q=p+j*j*j;
11 | 			if (q>=m)
12 | 				break;
13 | 			for (k=j+1;k<n;k++)
14 | 			{
15 | 				r=q+k*k*k;
16 | 				if (r==m)
17 | 					printf("Cube = %d, Triple = (%d,%d,%d)\n",n,i,j,k);
18 | 				else if (r>m)
19 | 					break;
20 | 			}
21 | 		}
22 | 	}
23 | }
24 | int main()
25 | {
26 | 	int n,i;
27 | 	scanf("%d",&n);
28 | 	for (i=6;i<=n;i++)
29 | 		cude(i);
30 | 	return 0;
31 | }
32 | 


--------------------------------------------------------------------------------
/poj/1547.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i,b,c,t,h,r[9];
 5 | 	char s[9][9];
 6 | 	scanf("%d",&n);
 7 | 	while (n!=-1)
 8 | 	{
 9 | 		t=0;
10 | 		h=0;
11 | 		for (i=0;i<n;i++)
12 | 		{
13 | 			scanf("%d %d %d %s",&r[i],&b,&c,s[i]);
14 | 			r[i]*=b*c;
15 | 			if (r[i]>r[t])
16 | 				t=i;
17 | 			else if (r[i]<r[h])
18 | 				h=i;
19 | 		}
20 | 		printf("%s took clay from %s.\n",s[t],s[h]);
21 | 		scanf("%d",&n);
22 | 	}
23 | 	return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/poj/1552.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int a[16],i,j,k,l,m;
 5 | 	scanf("%d",&a[0]);
 6 | 	while (a[0]!=-1)
 7 | 	{
 8 | 		i=0;
 9 | 		m=0;
10 | 		while (a[i]!=0)
11 | 			scanf("%d",&a[++i]);
12 | 		for (j=0;j<i;j++)
13 | 		{
14 | 			l=a[j]*2;
15 | 			for (k=0;k<i;k++)
16 | 			{
17 | 				if (a[k]==l)
18 | 				{
19 | 					m++;
20 | 					break;
21 | 				}
22 | 			}
23 | 		}
24 | 		printf("%d\n",m);
25 | 		scanf("%d",&a[0]);
26 | 	}
27 | 	return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/poj/1562.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int n,m;
 3 | char t[100][100];
 4 | void dfs(int i,int j)
 5 | {
 6 | 	t[i][j]='*';
 7 | 	if (i>0)
 8 | 	{
 9 | 		if (j>0 && t[i-1][j-1]=='@')
10 | 			dfs(i-1,j-1);
11 | 		if (t[i-1][j]=='@')
12 | 			dfs(i-1,j);
13 | 		if (j+1<m && t[i-1][j+1]=='@')
14 | 			dfs(i-1,j+1);
15 | 	}
16 | 	if (j>0 && t[i][j-1]=='@')
17 | 		dfs(i,j-1);
18 | 	if (j+1<m && t[i][j+1]=='@')
19 | 		dfs(i,j+1);
20 | 	if (i+1<n)
21 | 	{
22 | 		if (j>0 && t[i+1][j-1]=='@')
23 | 			dfs(i+1,j-1);
24 | 		if (t[i+1][j]=='@')
25 | 			dfs(i+1,j);
26 | 		if (j+1<m && t[i+1][j+1]=='@')
27 | 			dfs(i+1,j+1);
28 | 	}
29 | }
30 | int main()
31 | {
32 | 	int i,j,w;
33 | 	scanf("%d%d",&n,&m);
34 | 	while (n!=0 || m!=0)
35 | 	{
36 | 		w=0;
37 | 		for (i=0;i<n;i++)
38 | 			scanf("%s",t[i]);
39 | 		for (i=0;i<n;i++)
40 | 		{
41 | 			for (j=0;j<m;j++)
42 | 			{
43 | 				if (t[i][j]=='@')
44 | 				{
45 | 					w++;
46 | 					dfs(i,j);
47 | 				}
48 | 			}
49 | 		}
50 | 		printf("%d\n",w);
51 | 		scanf("%d%d",&n,&m);
52 | 	}
53 | 	return 0;
54 | }
55 | 


--------------------------------------------------------------------------------
/poj/1565.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int i,j,m,n;
 5 | 	char st[32];
 6 | 	scanf("%s",st);
 7 | 	while (st[0]!='0')
 8 | 	{
 9 | 		i=0;
10 | 		while (st[i]!='\0')
11 | 			i++;
12 | 		m=0;
13 | 		n=1;
14 | 		for (j=i-1;j>-1;j--)
15 | 		{
16 | 			n*=2;
17 | 			m+=(st[j]-'0')*(n-1);
18 | 		}
19 | 		printf("%d\n",m);
20 | 		scanf("%s",st);
21 | 	}
22 | 	return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/poj/1579.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int a[21][21][21]={0},i,j,k;
 5 | 	for (i=0;i<21;i++)
 6 | 	{
 7 | 		for (j=0;j<21;j++)
 8 | 		{
 9 | 			a[0][i][j]=1;
10 | 			a[i][0][j]=1;
11 | 			a[i][j][0]=1;
12 | 		}
13 | 	}
14 | 	for (i=1;i<21;i++)
15 | 	{
16 | 		for (j=1;j<21;j++)
17 | 		{
18 | 			for (k=1;k<21;k++)
19 | 			{
20 | 				if (i<j && j<k)
21 | 					a[i][j][k]=a[i][j][k-1]+a[i][j-1][k-1]-a[i][j-1][k];
22 | 				else a[i][j][k]=a[i-1][j][k]+a[i-1][j-1][k]+a[i-1][j][k-1]-a[i-1][j-1][k-1];
23 | 			}
24 | 		}
25 | 	}
26 | 	scanf("%d %d %d",&i,&j,&k);
27 | 	while (i!=-1 || j!=-1 || k!=-1)
28 | 	{
29 | 		if (i<=0 || j<=0 || k<=0)
30 | 			printf("w(%d, %d, %d) = 1\n",i,j,k);
31 | 		else if (i>20 || j>20 || k>20)
32 | 			printf("w(%d, %d, %d) = %d\n",i,j,k,a[20][20][20]);
33 | 		else printf("w(%d, %d, %d) = %d\n",i,j,k,a[i][j][k]);
34 | 		scanf("%d %d %d",&i,&j,&k);
35 | 	}
36 | 	return 0;
37 | }
38 | 


--------------------------------------------------------------------------------
/poj/1595.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int p[169]={1,2,3},i=5,j,q=3,n,c;
 5 | 	while (i<1000)
 6 | 	{
 7 | 		j=2;
 8 | 		while (2*p[j]<i)
 9 | 		{
10 | 			if (i%p[j]==0)
11 | 				break;
12 | 			j++;
13 | 		}
14 | 		if (2*p[j]>i)
15 | 			p[q++]=i;
16 | 		i+=2;
17 | 	}
18 | 	while (scanf("%d%d",&n,&c)!=EOF)
19 | 	{
20 | 		printf("%d %d:",n,c);
21 | 		i=0;
22 | 		j=q-1;
23 | 		while (i<j)
24 | 		{
25 | 			if (p[(i+j)/2]>n)
26 | 				j=(i+j)/2-1;
27 | 			else if (p[(i+j)/2]<n)
28 | 				i=(i+j)/2+1;
29 | 			else {
30 | 				i=(i+j)/2;
31 | 				break;
32 | 			}
33 | 		}
34 | 		if (p[i]>n)
35 | 			i--;
36 | 		c=c*2-(i+1)%2;
37 | 		j=(0>(i+1-c)/2) ? 0 : (i+1-c)/2;
38 | 		for (i=j;i<j+c && p[i]<=n;i++)
39 | 			printf(" %d",p[i]);
40 | 		printf("\n\n");
41 | 	}
42 | 	return 0;
43 | }
44 | 


--------------------------------------------------------------------------------
/poj/1604.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int p[10000]={1},i;
 5 | 	for (i=1;i<10000;i++)
 6 | 	{
 7 | 		p[i]=p[i-1]*i;
 8 | 		while (p[i]%10==0)
 9 | 			p[i]/=10;
10 | 		p[i]%=100000;
11 | 	}
12 | 	while (scanf("%d",&i)!=EOF)
13 | 		printf("%5d -> %d\n",i,p[i]%10);
14 | 	return 0;
15 | }
16 | 


--------------------------------------------------------------------------------
/poj/1607.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int  main()
 3 | {
 4 | 	double xinxi[100000],sum=0;
 5 | 	int i;
 6 | 	for (i=1;i<100000;i++)
 7 | 	{
 8 | 		sum+=1.000000/(2*i);
 9 | 		xinxi[i]=sum;
10 | 	}
11 | 	printf("Cards  Overhang\n");
12 | 	while (scanf("%ld",&i)!=-1)
13 | 		printf("%5d%10.3f\n",i,xinxi[i]);
14 | 	return 0;
15 | }
16 | 


--------------------------------------------------------------------------------
/poj/1611.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/snuc/poj/80cccc7287f23d33cde75b51a78a04bdb75408cb/poj/1611.cpp


--------------------------------------------------------------------------------
/poj/1654.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i,x1,y1,x2,y2;
 5 | 	__int64 s;
 6 | 	int num[10][2]={0,0,-1,-1,0,-1,1,-1,-1,0,0,0,1,0,-1,1,0,1,1,1};
 7 | 	char c;
 8 | 	scanf("%d\n",&n);
 9 | 	for (i=0;i<n;i++)
10 | 	{
11 | 		s=0;
12 | 		x1=0;
13 | 		y1=0;
14 | 		while ((c=getchar())!='5')
15 | 		{
16 | 			x2=x1+num[c-'0'][0];
17 | 			y2=y1+num[c-'0'][1];
18 | 			s+=(y1+y2)*(x2-x1);
19 | 			x1=x2;
20 | 			y1=y2;
21 | 		}
22 | 		getchar();
23 | 		if (s<0)
24 | 			s=-s;
25 | 		printf("%I64d",s/2);
26 | 		if (s%2==1)
27 | 			printf(".5");
28 | 		printf("\n");
29 | 	}
30 | 	return 0;
31 | }
32 | 


--------------------------------------------------------------------------------
/poj/1656.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | char p[100][100]={0};
 3 | void snuc (int x,int y,int l,int j)
 4 | {
 5 | 	int a,b;
 6 | 	for (a=x;a<x+l;a++)
 7 | 	{
 8 | 		for (b=y;b<y+l;b++)
 9 | 			p[a][b]=j;
10 | 	}
11 | }
12 | void test (int x,int y,int l)
13 | {
14 | 	int a,b,c=0;
15 | 	for (a=x;a<x+l;a++)
16 | 	{
17 | 		for (b=y;b<y+l;b++)
18 | 		{
19 | 			if (p[a][b]!=0)
20 | 				c++;
21 | 		}
22 | 	}
23 | 	printf("%d\n",c);
24 | }
25 | int main()
26 | {
27 | 	int i,n,x,y,l;
28 | 	char s[6];
29 | 	scanf("%d\n",&n);
30 | 	for (i=0;i<n;i++)
31 | 	{
32 | 		scanf("%s %d%d%d",s,&x,&y,&l);
33 | 		if (s[0]=='W')
34 | 			snuc(x-1,y-1,l,0);
35 | 		else if (s[0]=='B')
36 | 			snuc(x-1,y-1,l,1);
37 | 		else test(x-1,y-1,l);
38 | 	}
39 | 	return 0;
40 | }
41 | 


--------------------------------------------------------------------------------
/poj/1657.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |  	int a,b,c,d,i,n,x,y;
 5 | 	char s[3],t[3];
 6 | 	scanf("%d",&n);
 7 | 	for (i=0;i<n;i++)
 8 | 	{
 9 | 		scanf("%s%s",s,t);
10 | 		if (s[0]>t[0])
11 | 			x=s[0]-t[0];
12 | 		else x=t[0]-s[0];
13 | 		if (s[1]>t[1])
14 | 			y=s[1]-t[1];
15 | 		else y=t[1]-s[1];
16 | 		a=(x>y) ? x : y;
17 | 		if (x==0 && y==0)
18 | 		{
19 | 			b=0;
20 | 			c=0;
21 | 			d=0;
22 | 		}
23 | 		else {
24 | 			if ((x+y)%2!=0)
25 | 			{
26 | 				d=-1;
27 | 				b=2;
28 | 			}
29 | 			else if (x==y)
30 | 			{
31 | 				d=1;
32 | 				b=1;
33 | 			}
34 | 			else {
35 | 				d=2;
36 | 				b=2;
37 | 			}
38 | 			if (x==0 || y==0)
39 | 			{
40 | 				c=1;
41 | 				b=1;
42 | 			}
43 | 			else c=2;
44 | 		}
45 | 		printf("%d %d %d ",a,b,c);
46 | 		if (d==-1)
47 | 			printf("Inf\n");
48 | 		else printf("%d\n",d);
49 | 	}
50 |  	return 0;
51 | }
52 | 


--------------------------------------------------------------------------------
/poj/1658.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i,j,a[4],x,y;
 5 | 	scanf("%d",&n);
 6 | 	for (i=0;i<n;i++)
 7 | 	{
 8 | 		for (j=0;j<4;j++)
 9 | 		{
10 | 			scanf("%d",&a[j]);
11 | 			printf("%d ",a[j]);
12 | 		}
13 | 		x=a[1]-a[0];
14 | 		y=a[1]/a[0];
15 | 		if (x==a[2]-a[1] && x==a[3]-a[2])
16 | 			printf("%d\n",a[3]+x);
17 | 		else printf("%d\n",a[3]*y);
18 | 	}
19 | 	return 0;
20 | }
21 | 


--------------------------------------------------------------------------------
/poj/1663.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i,x,y;
 5 | 	scanf("%d",&n);
 6 | 	for (i=0;i<n;i++)
 7 | 	{
 8 | 		scanf("%d%d",&x,&y);
 9 | 		if (x!=y && x-2!=y)
10 | 			printf("No Number\n");
11 | 		else printf("%d\n",x+y-x%2);
12 | 	}
13 | 	return 0;
14 | }
15 | 


--------------------------------------------------------------------------------
/poj/1664.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i,j,x,y,p[11][11]={0};
 5 | 	for (i=0;i<11;i++)
 6 | 	{
 7 | 		p[0][i]=1;
 8 | 		p[i][0]=1;
 9 | 		p[1][i]=1;
10 | 		p[i][1]=1;
11 | 	}
12 | 	for (i=2;i<11;i++)
13 | 	{
14 | 		for (j=2;j<11;j++)
15 | 		{
16 | 			if (j>i)
17 | 				p[i][j]=p[i][i];
18 | 			else p[i][j]=p[i][j-1]+p[i-j][j];
19 | 		}
20 | 	}
21 | 	scanf("%d",&n);
22 | 	for (i=0;i<n;i++)
23 | 	{
24 | 		scanf("%d%d",&x,&y);
25 | 		printf("%d\n",p[x][y]);
26 | 	}
27 | 	return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/poj/1665.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #define pi 3.1415927
 3 | int main()
 4 | {
 5 | 	int a,i=0;
 6 | 	double x,b,e,f;
 7 | 	scanf("%lf%d%lf",&x,&a,&b);
 8 | 	while (a!=0 && b!=0)
 9 | 	{
10 | 		i++;
11 | 		e=pi*x*a/(12*5280);
12 | 		f=3600*e/b;
13 | 		printf("Trip #%d: %.2lf %.2lf\n",i,e,f);
14 | 	    scanf("%lf%d%lf",&x,&a,&b);
15 | 	}
16 | 	return 0;
17 | }
18 | 


--------------------------------------------------------------------------------
/poj/1666.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int n,candy[500];
 3 | int round()
 4 | {
 5 | 	int i,k=candy[n-1]>>1,l;
 6 | 	for (i=0;i<n;i++)
 7 | 	{
 8 | 		l=candy[i]>>1;
 9 | 		candy[i]=l+k;
10 | 		if (candy[i]%2==1)
11 | 			candy[i]++;
12 | 		k=l;
13 | 	}
14 | 	k=candy[0];
15 | 	for (i=1;i<n;i++)
16 | 		if (candy[i]!=k)
17 | 			return 0;
18 | 	return 1;
19 | }
20 | int main()
21 | {
22 | 	int i;
23 | 	while (scanf("%d",&n),n!=-0)
24 | 	{
25 | 		for (i=0;i<n;i++)
26 | 			scanf("%d",&candy[i]);
27 | 		i=1;
28 | 		while (round()==0)
29 | 			i++;
30 | 		printf("%d %d\n",i,candy[0]);
31 | 	}
32 | 	return 0;
33 | }
34 | 


--------------------------------------------------------------------------------
/poj/1674.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,m,i,j,k,t;
 5 | 	short p[10001],q[10001];
 6 | 	scanf("%d",&n);
 7 | 	for (i=0;i<n;i++)
 8 | 	{
 9 | 		scanf("%d",&m);
10 | 		for (j=1;j<=m;j++)
11 | 		{
12 | 			scanf("%d",&p[j]);
13 | 			q[p[j]]=j;
14 | 		}
15 | 		t=0;
16 | 		for (j=1;j<=m;j++)
17 | 		{
18 | 			if (p[j]!=j)
19 | 			{
20 | 				t++;
21 | 				p[q[j]]=p[j];
22 | 				q[p[j]]=q[j];
23 | 			}
24 | 		}
25 | 		printf("%d\n",t);
26 | 	}
27 | 	return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/poj/1700.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | int speed[1000],n;
 4 | int cmp(const void *a, const void *b)
 5 | {
 6 | 	int x,y;
 7 | 	x=*(int *)a;
 8 | 	y=*(int *)b;
 9 | 	if (x<y)
10 | 		return -1;
11 | 	else if (x>y)
12 | 		return 1;
13 | 	else return 0;
14 | }
15 | int main()
16 | {
17 | 	int T,t,i,s;
18 | 	scanf("%d",&T);
19 | 	for (t=0;t<T;t++)
20 | 	{
21 | 		scanf("%d",&n);
22 | 		for (i=0;i<n;i++)
23 | 			scanf("%d",&speed[i]);
24 | 		qsort(speed,n,sizeof(speed[0]),cmp);
25 | 		s=0;
26 | 		while (n>=4)
27 | 		{
28 | 			n-=2;
29 | 			if (speed[0]+speed[n]>speed[1]+speed[1])
30 | 				s+=speed[0]+speed[1]+speed[1]+speed[n+1];
31 | 			else s+=speed[0]+speed[0]+speed[n]+speed[n+1];
32 | 		}
33 | 		if (n==3)
34 | 			s+=speed[0]+speed[1]+speed[2];
35 | 		else if (n==2)
36 | 			s+=speed[1];
37 | 		else s+=speed[0];
38 | 		printf("%d\n",s);
39 | 	}
40 | 	return 0;
41 | }
42 | 


--------------------------------------------------------------------------------
/poj/1703.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int num[200002],n,N;
 3 | int diff(int i)
 4 | {
 5 | 	return (i+n)%N;
 6 | }
 7 | int root(int i)
 8 | {
 9 | 	int k,j=i;
10 | 	while (num[j]!=j)
11 | 		j=num[j];
12 | 	while (i!=j)
13 | 	{
14 | 		k=num[i];
15 | 		num[i]=j;
16 | 		i=k;
17 | 	}
18 | 	return j;
19 | }
20 | int main()
21 | {
22 | 	int a,c,d,m,t,i,j;
23 | 	char ch;
24 | 	scanf("%d",&t);
25 | 	while (t--)
26 | 	{
27 | 		scanf("%d%d",&n,&m);
28 | 		N=2*n;
29 | 		for (a=0;a<N;a++) 
30 | 			num[a]=a;
31 | 		for (a=0;a<m;a++)
32 | 		{
33 | 			getchar();
34 | 			scanf("%c%d%d",&ch,&c,&d);
35 | 			if (ch=='A')
36 | 			{	
37 | 				i=root(c);
38 | 				j=root(d);
39 | 				if (i%n!=j%n) 
40 | 					printf("Not sure yet.\n");
41 | 				else 
42 | 				{
43 | 					if (i==j)
44 | 						printf("In the same gang.\n");
45 | 					else printf("In different gangs.\n");
46 | 				}
47 | 			}
48 | 			else
49 | 			{
50 | 				i=root(diff(c));
51 | 				j=root(d);
52 | 				num[i]=j;
53 | 				num[diff(i)]=diff(j);
54 | 			}
55 | 		}
56 | 	}
57 | 	return 0;
58 | }
59 | 


--------------------------------------------------------------------------------
/poj/1730.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<math.h>
 3 | #define zero 1e-6
 4 | int powb(__int64 t,__int64 x)
 5 | {
 6 | 	int b=2,p=1,a=1,i;
 7 | 	if (2==t%4)
 8 | 		return 1;
 9 | 	if (t%5==2 || t%5==3 || x<0)
10 | 		a=2;
11 | 	for (i=a+1;b>1;i+=a)
12 | 	{
13 | 		b=(int)(pow(t,1.0/i)+zero);
14 | 		if(fabs(pow(b,i)-t)<zero)
15 | 			p=i;
16 | 	}
17 | 	return p;
18 | }
19 | int main()
20 | {
21 | 	__int64 x;
22 | 	while(scanf("%I64d",&x),x)
23 | 		printf("%d\n",powb(x>0?x:-x,x));
24 | 	return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/poj/1731.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<string>
 3 | #include<algorithm>
 4 | using namespace std;
 5 | int main()
 6 | {
 7 | 	string s;
 8 | 	cin>>s;
 9 | 	sort(s.begin(),s.end());
10 | 	cout<<s<<endl;
11 | 	while(next_permutation(s.begin(),s.end())) {
12 | 		cout<<s<<endl;
13 | 	}
14 | 	return 0;
15 | }
16 | 


--------------------------------------------------------------------------------
/poj/1740.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i,j,k,d[10],f[10],q;
 5 | 	scanf("%d",&n);
 6 | 	while (n!=0)
 7 | 	{
 8 | 		j=0;
 9 | 		q=0;
10 | 		for (i=0;i<n;i++)
11 | 		{
12 | 			f[i]=1;
13 | 			scanf("%d",&k);
14 | 			for (j=0;j<q;j++)
15 | 			{
16 | 				if (d[j]==k)
17 | 				{
18 | 					f[j]++;
19 | 					break;
20 | 				}
21 | 			}
22 | 			if (j==q)
23 | 				d[q++]=k;
24 | 		}
25 | 		for (i=0,j=0;i<q;i++)
26 | 			if (f[i]%2!=0)
27 | 				j++;
28 | 		if (j==0)
29 | 			printf("0\n");
30 | 		else printf("1\n");
31 | 		scanf("%d",&n);
32 | 	}
33 | 	return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/poj/1775.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int Factorial[10]={1,1,2,6,24,120,720,5040,40320,362880};
 3 | int main()
 4 | {
 5 | 	int n,i;
 6 |     scanf("%d",&n);
 7 | 	while (n>=0)
 8 | 	{
 9 | 		i=9;
10 | 		while (n>0)
11 | 		{
12 | 			while (i>=0 && n<Factorial[i])
13 | 				i--;
14 | 			if (i<0)
15 | 				break;
16 | 			n-=Factorial[i--];
17 | 		}
18 | 		if (n==0 && i!=9)
19 | 			printf("YES\n");
20 | 		else printf("NO\n");
21 | 		scanf("%d",&n);
22 | 	}
23 | 	return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/poj/1799.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<math.h>
 3 | #define pi  3.14159265358
 4 | void main()
 5 | {
 6 | 	int n,i,num;
 7 | 	double r=0.0,t=0.0,R;	
 8 | 	scanf("%d",&n);
 9 | 	for(i=1;i<=n;i++)
10 | 	{
11 | 		scanf("%lf%d",&R,&num);
12 | 		t=sin(pi/num);
13 | 		r=R*t/(t+1.0);		
14 | 		printf("Scenario #%d:\n%.3f\n\n",i,r);		
15 | 	}
16 | 	return 0;
17 | }
18 | 


--------------------------------------------------------------------------------
/poj/1804.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | void merge(int s,int u,int v);
 3 | void mergesort(int first,int last);
 4 | int x[1000],z[1000];
 5 | int reverse;
 6 | int main()
 7 | {
 8 | 	int n,m,i,j;
 9 | 	scanf("%d",&n);
10 | 	for (i=1;i<=n;i++)
11 | 	{
12 | 		scanf("%d",&m);
13 | 		for (j=0;j<m;j++)
14 | 			scanf("%d",&x[j]);
15 | 		reverse=0;
16 | 		mergesort(0,m-1);
17 | 		printf("Scenario #%d:\n%d\n\n",i,reverse);
18 | 	}
19 | 	return 0;
20 | }
21 | void merge(int s,int u,int v)
22 | {
23 | 	int i=s,j=u+1,q=0;
24 | 	while (i<=u && j<=v)
25 | 	{
26 | 		if (x[i]<=x[j])
27 | 			z[q++]=x[i++];
28 | 		else {
29 | 			z[q++]=x[j++];
30 | 			reverse+=u-i+1;
31 | 		}
32 | 	}
33 | 	while (i<=u)
34 | 		z[q++]=x[i++];
35 | 	while (j<=v)
36 | 		z[q++]=x[j++];
37 | 	for(i=0;i<q;i++)
38 | 		x[s+i]=z[i];
39 | }
40 | void mergesort(int first,int last)
41 | {
42 | 	int mid;
43 | 	if (first<last)
44 | 	{
45 | 		mid=(first+last)/2;
46 | 		mergesort(first,mid);
47 | 		mergesort(mid+1,last);
48 | 		merge(first,mid,last);
49 | 	}
50 | }
51 | 


--------------------------------------------------------------------------------
/poj/1818.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int k,n,p[8192];
 4 | char f[4097]={0};
 5 | int find(int x)
 6 | {
 7 | 	int y,i,j,r=2*n,t=1;
 8 | 	p[0]=x;
 9 | 	f[x]=1;
10 | 	for (i=1;i<r;i++)
11 | 	{
12 | 		y=(i-1)/2;
13 | 		if (t==1)
14 | 			p[i]=p[y];
15 | 		else{
16 | 			j=p[y]-k;
17 | 			if (j<1)
18 | 				j=1;
19 | 			while (j<=n && f[j]==1)
20 | 				j++;
21 | 			if (j>n)
22 | 				return 0;
23 | 			p[i]=j;
24 | 			f[j]=1;
25 | 		}
26 | 		t=1-t;
27 | 	}
28 | 	return 1;
29 | }	
30 | int main()
31 | {
32 | 	int i,j,s;
33 | 	scanf("%d%d",&n,&k);
34 | 	i=1;
35 | 	j=n;
36 | 	while (i+1<j)
37 | 	{
38 | 		s=(i+j)/2;
39 | 		if (find(s))
40 | 			i=s;
41 | 		else j=s-1;
42 | 		memset(f,0,n+1);
43 | 	}
44 | 	while (find(i))
45 | 	{
46 | 		memset(f,0,n+1);
47 | 		i++;
48 | 	}
49 | 	printf("%d\n",i-1);
50 | 	return 0;
51 | }
52 | 


--------------------------------------------------------------------------------
/poj/1828.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | struct Point{
 4 | 	int x;
 5 | 	int y;
 6 | }point[50000];
 7 | int cmp(const void *a, const void *b)
 8 | {
 9 | 	struct Point x,y;
10 | 	x=*(struct Point *)a;
11 | 	y=*(struct Point *)b;
12 | 	if (x.x<y.x)
13 | 		return 1;
14 | 	else if (x.x>y.x)
15 | 		return -1;
16 | 	else if (x.y<y.y)
17 | 		return 1;
18 | 	else if (x.y>y.y)
19 | 		return -1;
20 | 	else return 0;
21 | }
22 | int main()
23 | {
24 | 	int i,j,k,n,s;
25 | 	scanf("%d",&n);
26 | 	while (n!=0)
27 | 	{
28 | 		for (i=0;i<n;i++)
29 | 			scanf("%d%d",&point[i].x,&point[i].y);
30 | 		qsort(point,n,sizeof(point[0]),cmp);
31 | 		k=point[0].y;
32 | 		for (i=1,s=1;i<n;i++)
33 | 		{
34 | 			if (point[i].y>k)
35 | 			{
36 | 				k=point[i].y;
37 | 				s++;
38 | 			}
39 | 		}
40 | 		printf("%d\n",s);
41 | 		scanf("%d",&n);
42 | 	}
43 | 	return 0;
44 | }
45 | 


--------------------------------------------------------------------------------
/poj/1833.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int i,j,k,m,n,q;
 5 | 	int p[1024],a,b,c,temp;
 6 | 	scanf("%d",&m);
 7 | 	for (i=1;i<=m;i++)
 8 | 	{
 9 | 		scanf("%d %d",&n,&q);
10 | 		for (j=0;j<n;j++)
11 | 			scanf("%d",&p[j]);
12 | 		for (k=1;k<=q;k++)
13 | 		{
14 | 			for (a=n-1;a>0;a--)
15 | 			{
16 | 				if (p[a-1]<p[a])
17 | 					break;
18 | 			}
19 | 			if (a!=0)
20 | 			{
21 | 				for (b=n-1;b>=0;b--)
22 | 				{
23 | 					if (p[a-1]<p[b])
24 | 						break;
25 | 				}
26 | 				temp=p[a-1];
27 | 				p[a-1]=p[b];
28 | 				p[b]=temp;
29 | 			}
30 | 			for (c=a;c<(a+n)/2;c++)
31 | 			{
32 | 				temp=p[c];
33 | 				p[c]=p[n+a-c-1];
34 | 				p[n+a-c-1]=temp;
35 | 			}
36 | 		}
37 | 		for (j=0;j<n-1;j++)
38 | 			printf("%d ",p[j]);
39 | 		printf("%d\n",p[j]);
40 | 	}
41 | 	return 0;
42 | }
43 | 


--------------------------------------------------------------------------------
/poj/1844.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,s=1,i=1;
 5 | 	scanf("%d",&n);
 6 | 	while (s<n || (s-n)%2==1)
 7 | 		s+=++i;
 8 | 	printf("%d\n",i);
 9 | 	return 0;
10 | }
11 | 


--------------------------------------------------------------------------------
/poj/1852.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int T,t,i,j,n,l,max,min;
 5 | 	scanf("%d",&T);
 6 | 	for (t=0;t<T;t++)
 7 | 	{
 8 | 		scanf("%d%d",&l,&n);
 9 | 		min=0;
10 | 		max=0;
11 | 		for (i=0;i<n;i++)
12 | 		{
13 | 			scanf("%d",&j);
14 | 			j=(j+j)>l ? l-j : j;
15 | 			if (j>min)
16 | 				min=j;
17 | 			if (l-j>max)
18 | 				max=l-j;
19 | 		}
20 | 		printf("%d %d\n",min,max);
21 | 	}
22 | 	return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/poj/1862.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | #include<math.h>
 4 | int cmp(const void *a,const void *b)
 5 | {
 6 | 	double x,y;
 7 | 	x=*(double *)a;
 8 | 	y=*(double *)b;
 9 | 	if (x<y)
10 | 		return 1;
11 | 	else if (x>y)
12 | 		return -1;
13 | 	else return 0;
14 | }
15 | int main()
16 | {
17 | 	int n,i;
18 | 	double m[100];
19 | 	scanf("%d",&n);
20 | 	for (i=0;i<n;i++)
21 | 		scanf("%lf",&m[i]);
22 | 	qsort(m,n,sizeof(m[0]),cmp);
23 | 	for (i=1;i<n;i++)
24 | 		m[0]=2*sqrt(m[0]*m[i]);
25 | 	printf("%.3lf\n",m[0]);
26 | 	return 0;
27 | }
28 | 


--------------------------------------------------------------------------------
/poj/1922.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i,j,s=16200,m,t,v;
 5 | 	scanf("%d",&n);
 6 | 	while (n)
 7 | 	{
 8 | 		m=16201;
 9 | 		for (i=0;i<n;i++)
10 | 		{
11 | 			scanf("%d%d",&v,&t);
12 | 			if (t>=0 && (j=t+s/v)<m)
13 | 				m=j+(s%v==0 ? 0:1);
14 | 		}
15 | 		printf("%d\n",m);
16 | 		scanf("%d",&n);
17 | 	}			
18 | 	return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/poj/1936.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int i,j,k;
 5 | 	char s[100000],t[100000];
 6 | 	while (scanf("%s %s",s,t)!=EOF)
 7 | 	{
 8 | 		j=0;
 9 | 		for (i=0;t[i]!='\0';i++)
10 | 		{
11 | 			if (s[j]=='\0')
12 | 				break;
13 | 			if (s[j]==t[i])
14 | 				j++;
15 | 		}
16 | 		if (s[j]=='\0')
17 | 			printf("Yes\n");
18 | 		else printf("No\n");
19 | 	}			
20 | 	return 0;
21 | }
22 | 


--------------------------------------------------------------------------------
/poj/1942.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/snuc/poj/80cccc7287f23d33cde75b51a78a04bdb75408cb/poj/1942.c


--------------------------------------------------------------------------------
/poj/1949.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int n,max,m=0;
 3 | int time[10001]={0};
 4 | int main()
 5 | {
 6 | 	int i,j,k,l,chore;
 7 | 	scanf("%d",&n);
 8 | 	for (i=1;i<=n;i++)
 9 | 	{
10 | 		scanf("%d%d",&chore,&k);
11 | 		for (j=0,max=0;j<k;j++)
12 | 		{
13 | 			scanf("%d",&l);
14 | 			if (time[l]>max)
15 | 				max=time[l];
16 | 		}
17 | 		time[i]+=chore+max;
18 | 		if (time[i]>m)
19 | 			m=time[i];
20 | 	}
21 | 	printf("%d\n",m);
22 | 	return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/poj/1953.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | __int64 football[50] = {1, 2 ,3};
 3 | int main()
 4 | {
 5 | 	int i, j, n;
 6 | 	for (i = 3; i <= 45; i++)
 7 | 		football[i] = football[i - 1] + football[i - 2];
 8 | 	scanf("%d", &n);
 9 | 	for (i = 1; i <= n; i++)
10 | 	{
11 | 		scanf("%d", &j);
12 | 		printf("Scenario #%d:\n%I64d\n\n", i, football[j]);
13 | 	}
14 | 	return 0;
15 | }
16 | 


--------------------------------------------------------------------------------
/poj/1969.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <math.h>
 3 | int main()
 4 | {
 5 | 	int n,m,i,j;
 6 | 	double d;
 7 | 	while (scanf("%d",&n)!=EOF)
 8 | 	{
 9 | 		d=(sqrt(8.0*n+1)-1)/2.0;
10 | 		m=(int)d;
11 | 		if (d!=(double)m)
12 | 			m++;
13 | 		j=n-m*(m-1)/2;
14 | 		if (m%2==0)
15 | 		{
16 | 			i=j;
17 | 			j=m+1-i;
18 | 		}
19 | 		else i=m+1-j;
20 | 		printf("TERM %d IS %d/%d\n",n,i,j);
21 | 	}
22 | 	return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/poj/1979.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int w,h,count;
 4 | char t[30][30];
 5 | bool p[30][30]={false};
 6 | void dfs(int i,int j)
 7 | {
 8 | 	if (p[i][j]==true)
 9 | 		return;
10 | 	p[i][j]=true;
11 | 	count++;
12 | 	if (i>0 && t[i-1][j]=='.')
13 | 		dfs(i-1,j);
14 | 	if (j>0 && t[i][j-1]=='.')
15 | 		dfs(i,j-1);
16 | 	if (j+1<w && t[i][j+1]=='.')
17 | 		dfs(i,j+1);
18 | 	if (i+1<h && t[i+1][j]=='.')
19 | 		dfs(i+1,j);
20 | }
21 | int main()
22 | {
23 | 	int i,j;
24 | 	while (scanf("%d%d",&w,&h),w!=0 || h!=0)
25 | 	{
26 | 		count=0;
27 | 		memset(p,false,sizeof(p));
28 | 		for (i=0;i<h;i++)
29 | 			scanf("%s",t[i]);
30 | 		for (i=0;i<h;i++)
31 | 			for (j=0;j<w;j++)
32 | 				if (t[i][j]=='@')
33 | 				{
34 | 					dfs(i,j);
35 | 					break;
36 | 				}
37 | 		printf("%d\n",count);
38 | 	}
39 | 	return 0;
40 | }
41 | 


--------------------------------------------------------------------------------
/poj/1989.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int breed[10001]={0},n,k;
 4 | int main()
 5 | {
 6 | 	int i,j=1,p,s;
 7 | 	scanf("%d%d",&n,&k);
 8 | 	for (i=0,s=0;i<n;i++)
 9 | 	{
10 | 		scanf("%d",&p);
11 | 		if (breed[p]==0)
12 | 		{
13 | 			s++;
14 | 			breed[p]=1;
15 | 			if (s==k)
16 | 			{
17 | 				s=0;
18 | 				j++;
19 | 				memset(breed,0,sizeof(int)*k+1);
20 | 			}
21 | 		}
22 | 	}
23 | 	printf("%d\n",j);
24 | 	return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/poj/2000.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int i,n,s;
 5 | 	scanf("%d",&n);
 6 | 	while (n!=0)
 7 | 	{
 8 | 		i=1;
 9 | 		s=0;
10 | 		printf("%d ",n);
11 | 		while (n>0)
12 | 		{
13 | 			s+=i*i;
14 | 			n-=i;
15 | 			i++;
16 | 		}
17 | 		s+=(i-1)*n;
18 | 		printf("%d\n",s);
19 | 		scanf("%d",&n);
20 | 	}
21 | 	return 0;
22 | }
23 | 


--------------------------------------------------------------------------------
/poj/2013.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 |     int n,i,j=1;
 5 | 	char s[15][26];
 6 | 	scanf("%d",&n);
 7 | 	while (n!=0)
 8 | 	{
 9 | 		for (i=0;i<n;i++)
10 | 			scanf("%s",s[i]);
11 | 		printf("SET %d\n",j++);
12 | 		for (i=0;i<n;i+=2)
13 | 			printf("%s\n",s[i]);
14 | 		for (i=n-1-n%2;i>0;i-=2)
15 | 			printf("%s\n",s[i]);
16 | 		scanf("%d",&n);
17 | 	}
18 | 	return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/poj/2017.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 |     int n,i,a,b,s,t;
 5 | 	scanf("%d",&n);
 6 | 	while (n!=-1)
 7 | 	{
 8 | 		s=0;
 9 | 		t=0;
10 | 		for (i=0;i<n;i++)
11 | 		{
12 | 			scanf("%d%d",&a,&b);
13 | 			s+=a*(b-t);
14 | 			t=b;
15 | 		}
16 | 		printf("%d miles\n",s);
17 | 		scanf("%d",&n);
18 | 	}
19 | 	return 0;
20 | }
21 | 


--------------------------------------------------------------------------------
/poj/2027.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 |     int t,a,b;
 5 |     scanf("%d",&t);
 6 |     while(t-->0)
 7 |     {
 8 |         scanf("%d%d",&a,&b);
 9 |         printf("%s BRAINS\n",(a<b?"NO":"MMM"));
10 |     }    
11 | 	return 0;
12 | }
13 | 


--------------------------------------------------------------------------------
/poj/2039.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 |     int n,i,j,k;
 5 | 	char s[100][20];
 6 | 	scanf("%d",&n);
 7 | 	while (n!=0)
 8 | 	{
 9 | 		getchar();
10 | 		i=0;
11 | 		j=0;
12 | 		k=1;
13 | 		while ((s[i][j]=getchar())!='\n')
14 | 		{
15 | 			j+=k;
16 | 			if (j==n || j==-1)
17 | 			{
18 | 				k=0-k;
19 | 				j+=k;
20 | 				i++;
21 | 			}
22 | 		}
23 | 		for (j=0;j<n;j++)
24 | 			for (k=0;k<i;k++)
25 | 				printf("%c",s[k][j]);
26 | 		printf("\n");
27 | 		scanf("%d",&n);
28 | 	}
29 | 	return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/poj/2050.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/snuc/poj/80cccc7287f23d33cde75b51a78a04bdb75408cb/poj/2050.c


--------------------------------------------------------------------------------
/poj/2070.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 |  	float s;
 5 |  	int w,m,c;
 6 |  	while(1)
 7 |  	{
 8 | 		c=0;
 9 |  	 	scanf("%f%d%d",&s,&w,&m);
10 |  	 	if (s==0)
11 | 			break;
12 | 		if (s<=4.5 && w>=150 && m>=200)
13 | 		{
14 | 			c=1;
15 | 			printf("Wide Receiver");
16 | 		}
17 | 		if (s<=6.0 && w>=300 && m>=500)
18 | 		{
19 | 			if (c==1)
20 | 				printf(" ");
21 | 			c=1;
22 | 			printf("Lineman");
23 | 		}
24 |  	 	if (s<=5.0 && w>=200 && m>=300)
25 | 		{
26 | 			if (c==1)
27 | 				printf(" ");
28 | 			c=1;
29 | 			printf("Quarterback");
30 | 		}
31 |  	 	if (c==0)
32 |  	 	printf("No positions");
33 |  	 	printf("\n");
34 |  	}
35 |  	return 0;
36 | }
37 | 


--------------------------------------------------------------------------------
/poj/2081.cc:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int m[500001],i;
 5 | 	bool n[4000000]={1};
 6 | 	for(i=1;i<500001;i++)
 7 | 	{
 8 | 		if (m[i-1]>i && n[m[i-1]-i]==0)
 9 | 			m[i]=m[i-1]-i;
10 | 		else m[i]=m[i-1]+i;
11 | 		n[m[i]]=1;
12 | 	}
13 | 	scanf("%d",&i);
14 | 	while(i!=-1)
15 | 	{
16 | 		printf("%d\n",m[i]);
17 | 		scanf("%d",&i);
18 | 	}
19 | 	return 0;
20 | }
21 | 


--------------------------------------------------------------------------------
/poj/2084.java:
--------------------------------------------------------------------------------
 1 | //Main.java
 2 | import java.util.*;
 3 | import java.math.*;
 4 | 
 5 | public class Main
 6 | {
 7 |         public static void main(String args[]) throws Exception {
 8 |                 Scanner cin=new Scanner(System.in);
 9 |                 BigInteger game[]=new BigInteger[102];
10 |                 game[1]=BigInteger.valueOf(1);
11 |                 for (int i=2;i<=101;i++)
12 |                 {
13 |                 	game[i]=BigInteger.valueOf(0);
14 |                 	for (int j=1;j<i;j++)
15 |                 		game[i]=game[i].add(game[j].multiply(game[i-j]));
16 |                 }
17 |                 int d = cin.nextInt();
18 |                 while (d != -1)
19 |                 {
20 |                 	System.out.println(game[d+1]);
21 |                     d = cin.nextInt();
22 |                 }
23 |         }
24 | }
25 | 


--------------------------------------------------------------------------------
/poj/2105.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i,j,k,c[4];
 5 | 	char s[50];
 6 | 	scanf("%d",&n);
 7 | 	for (i=0;i<n;i++)
 8 | 	{
 9 | 		scanf("%s",s);
10 | 		for (j=0;j<4;j++)
11 | 		{
12 | 			c[j]=0;
13 | 			for (k=0;k<8;k++)
14 | 				c[j]=c[j]*2+s[j*8+k]-'0';
15 | 		}
16 | 		printf("%d.%d.%d.%d\n",c[0],c[1],c[2],c[3]);
17 | 	}
18 | 	return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/poj/2109.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<math.h>
 3 | int main()
 4 | {
 5 |  	double n,p;
 6 |  	while(scanf("%lf%lf",&n,&p)!=EOF)
 7 | 		printf("%.0lf\n",pow(p,1/n));
 8 |  	return 0;
 9 | }
10 | 


--------------------------------------------------------------------------------
/poj/2126.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int a,b,c,n;
 5 | 	while (scanf("%d",&n)!=EOF)
 6 | 	{
 7 | 		if (n==2)
 8 | 		{
 9 | 			scanf("%d%d%d",&a,&b,&c);
10 | 			if (b*b>=4*a*c)
11 | 				printf("NO\n");
12 | 			else printf("YES\n");
13 | 		}
14 | 		else {
15 | 			if (n>2)
16 | 				printf("NO\n");
17 | 			else printf("YES\n");
18 | 			while (n>=0)
19 | 			{
20 | 				scanf("%d",&a);
21 | 				n--;
22 | 			}
23 | 		}
24 | 	}
25 | 	return 0;
26 | }
27 | 


--------------------------------------------------------------------------------
/poj/2136.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int i,j,k,l[26]={0};
 5 | 	char s[73];
 6 | 	for (i=0;i<4;i++)
 7 | 	{
 8 | 		gets(s);
 9 | 		for (j=0;s[j]!='\0';j++)
10 | 		{
11 | 			if (s[j]>='A' && s[j]<='Z')
12 | 				l[s[j]-'A']++;
13 | 		}
14 | 	}
15 | 	j=l[0];
16 | 	for (i=1;i<26;i++)
17 | 	{
18 | 		if (l[i]>j)
19 | 			j=l[i];
20 | 	}
21 | 	for (i=j;i>0;i--)
22 | 	{
23 | 		for (k=0;k<25;k++)
24 | 		{
25 | 			if (l[k]==i)
26 | 			{
27 | 				l[k]--;
28 | 				printf("* ");
29 | 			}
30 | 			else printf("  ");
31 | 		}
32 | 		if (l[k]==i)
33 | 		{
34 | 			l[k]--;
35 | 			printf("*\n");
36 | 		}
37 | 		else printf(" \n");
38 | 	}
39 | 	for (i=0;i<25;i++)
40 | 		printf("%c ",'A'+i);
41 | 	printf("Z\n");
42 | 	return 0;
43 | }
44 | 


--------------------------------------------------------------------------------
/poj/2140.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i,s=1;
 5 | 	scanf("%d",&n);
 6 | 	for (i=2;i*i+i<=2*n;i+=2)
 7 | 		if (n%i!=0 && n%(i/2)==0)
 8 | 			s++;
 9 | 	for (i=3;i*i+i<=2*n;i+=2)
10 | 		if (n%i==0)
11 | 			s++;
12 | 	printf("%d\n",s);
13 | 	return 0;
14 | }
15 | 


--------------------------------------------------------------------------------
/poj/2141.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int i;
 5 | 	char s[26],r[81];
 6 | 	gets(r);
 7 | 	for (i=0;i<26;i++)
 8 | 		s[i]=r[i]-'a';
 9 | 	gets(r);
10 | 	for (i=0;r[i]!='\0';i++)
11 | 	{
12 | 		if (r[i]>='a' && r[i]<='z')
13 | 			printf("%c",s[r[i]-'a']+'a');
14 | 		else if (r[i]>='A' && r[i]<='Z')
15 | 			printf("%c",s[r[i]-'A']+'A');
16 | 		else printf("%c",r[i]);
17 | 	}
18 | 	printf("\n");
19 | 	return 0;
20 | }
21 | 


--------------------------------------------------------------------------------
/poj/2153.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/snuc/poj/80cccc7287f23d33cde75b51a78a04bdb75408cb/poj/2153.c


--------------------------------------------------------------------------------
/poj/2159.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | int s[26]={0},t[26]={0};
 4 | int cmp(const void *a, const void *b)
 5 | {
 6 | 	int x,y;
 7 | 	x=*(int *)a;
 8 | 	y=*(int *)b;
 9 | 	if (x<y)
10 | 		return -1;
11 | 	else if (x>y)
12 | 		return 1;
13 | 	else return 0;
14 | }
15 | int main()
16 | {
17 | 	int i;
18 | 	char str[120];
19 | 	scanf("%s",str);
20 | 	for (i=0;str[i]!='\0';i++)
21 | 		s[str[i]-'A']++;
22 | 	scanf("%s",str);
23 | 	for (i=0;str[i]!='\0';i++)
24 | 		t[str[i]-'A']++;
25 | 	qsort(s,26,sizeof(s[0]),cmp);
26 | 	qsort(t,26,sizeof(s[0]),cmp);
27 | 	for (i=0;i<26;i++)
28 | 		if (s[i]!=t[i])
29 | 			break;
30 | 	if (i==26)
31 | 		printf("YES\n");
32 | 	else printf("NO\n");
33 | 	return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/poj/2186.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/snuc/poj/80cccc7287f23d33cde75b51a78a04bdb75408cb/poj/2186.cpp


--------------------------------------------------------------------------------
/poj/2190.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | char str[20];
 3 | int qu;
 4 | int main()
 5 | {
 6 | 	int i,sum=0;
 7 | 	scanf("%s",str);
 8 | 	for (i=0;i<9;i++)
 9 | 	{
10 | 		if (str[i]=='?')
11 | 			qu=i;
12 | 		else sum+=(10-i)*(str[i]-'0');
13 | 	}
14 | 	if (str[9]=='?')
15 | 		qu=9;
16 | 	else if (str[9]=='X')
17 | 		sum+=10;
18 | 	else sum+=str[9]-'0';
19 | 	for (i=0;i<10;i++)
20 | 	{
21 | 		if ((sum+(10-qu)*i)%11==0)
22 | 			break;
23 | 	}
24 | 	if (i<10)
25 | 		printf("%d\n",i);
26 | 	else if ((sum+10)%11==0)
27 | 		printf("X\n");
28 | 	else printf("-1\n");
29 |     return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/poj/2196.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int i,j,x,y;
 5 | 	for (i=2992;i<10000;i++)
 6 | 	{
 7 | 		x=0;
 8 | 		j=i;
 9 | 		while(j)
10 | 		{
11 | 			x+=j%10;
12 | 			j/=10;
13 | 		}
14 | 		y=0;
15 | 		j=i;
16 | 		while(j)
17 | 		{
18 | 			y+=j%12;
19 | 			j/=12;
20 | 		}
21 | 		if (x!=y)
22 | 			continue;
23 | 		y=0;
24 | 		j=i;
25 | 		while(j)
26 | 		{
27 | 			y+=j%16;
28 | 			j/=16;
29 | 		}
30 | 		if (x==y)
31 | 			printf("%d\n",i);
32 | 	}
33 | 	return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/poj/2239.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #define MN 384
 3 | bool check[MN];
 4 | bool hide[MN][MN]={false};
 5 | int match[MN],num,n;
 6 | bool DFS(int p);
 7 | int main()
 8 | {
 9 | 	int save,i,j,a,b;
10 | 	while (scanf("%d",&n)!=EOF)
11 | 	{
12 | 		num=84+n;
13 | 		for (i=84;i<num;i++)
14 | 		{
15 | 			scanf("%d",&save);
16 | 			for (j=0;j<save;j++)
17 | 			{
18 | 				scanf("%d%d",&a,&b);
19 | 				a=12*a+b-13;
20 | 				hide[i][a]=true;
21 | 				hide[a][i]=true;
22 | 			}
23 | 		}
24 | 		memset(match,-1,sizeof(match));
25 | 		save=0;
26 | 		for(i=0;i<84;i++)
27 | 		{
28 | 			memset(check,false,sizeof(check));
29 | 			if (DFS(i))
30 | 				save++;
31 | 		}
32 | 		printf("%d\n",save);
33 | 		memset(hide,false,sizeof(hide));
34 | 	}
35 | 	return 0;
36 | }
37 | bool DFS(int p)
38 | {
39 | 	int i,t,a,b;
40 | 	if (p<84)
41 | 		a=84,b=num;
42 | 	else a=0,b=84;
43 | 	for(i=a;i<b;i++)
44 | 	{
45 | 		if (hide[i][p] && !check[i])
46 | 		{
47 | 			check[i]=true;
48 | 			t=match[i];
49 | 			match[i]=p;
50 | 			if (t==-1 || DFS(t))
51 | 				return true;
52 | 			match[i]=t;
53 | 		}
54 | 	}
55 | 	return false;
56 | }
57 | 


--------------------------------------------------------------------------------
/poj/2242.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<math.h>
 3 | #define pi 3.141592653589793
 4 | int main()
 5 | {
 6 | 	double a,b,c,xa,ya,xb,yb,xc,yc,s;
 7 | 	while (scanf("%lf%lf%lf%lf%lf%lf",&xa,&ya,&xb,&yb,&xc,&yc)!=EOF)
 8 | 	{
 9 | 		a=sqrt((xc-xb)*(xc-xb)+(yc-yb)*(yc-yb));
10 | 		b=sqrt((xa-xc)*(xa-xc)+(ya-yc)*(ya-yc));
11 | 		c=sqrt((xa-xb)*(xa-xb)+(ya-yb)*(ya-yb));
12 | 		xa=(a+b+c)/2;
13 | 		s=sqrt(xa*(xa-a)*(xa-b)*(xa-c));
14 | 		s=a*b*c/s/2*pi;
15 | 		printf("%.2lf\n",s);
16 | 	}
17 | 	return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/poj/2249.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,k,i,j;
 5 | 	__int64 t;
 6 | 	scanf("%d%d",&n,&k);
 7 | 	while (n!=0)
 8 | 	{
 9 | 		if (k>n-k)
10 | 			k=n-k;
11 | 		for (t=1,i=n-k+1,j=1;i<=n;i++,j++)
12 | 		{
13 | 			t*=i;
14 | 			t/=j;
15 | 		}
16 | 		printf("%I64d\n",t);
17 | 		scanf("%d%d",&n,&k);
18 | 	}
19 | 	return 0;
20 | }
21 | 


--------------------------------------------------------------------------------
/poj/2262.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int prime (int n)
 3 | {
 4 | 	int i=3;
 5 | 	while (i*i<=n)
 6 | 	{
 7 | 		if (n%i==0)
 8 | 			return 0;
 9 | 		i+=2;
10 | 	}
11 | 	return 1;
12 | }
13 | int main()
14 | {
15 | 	int n,i;
16 | 	scanf("%d",&n);
17 | 	while (n!=0)
18 | 	{
19 | 		for (i=3;i<=n/2;i+=2)
20 | 		{
21 | 			if (prime(i) && prime(n-i))
22 | 			{
23 | 				printf("%d = %d + %d\n",n,i,n-i);
24 | 				break;
25 | 			}
26 | 		}
27 | 		scanf("%d",&n);
28 | 	}
29 | 	return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/poj/2272.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<math.h>
 3 | int point(double r)
 4 | {
 5 | 	if (r<=3)
 6 | 		return 100;
 7 | 	if (r<=6)
 8 | 		return 80;
 9 | 	if (r<=9)
10 | 		return 60;
11 | 	if (r<=12)
12 | 		return 40;
13 | 	if (r<=15)
14 | 		return 20;
15 | 	return 0;
16 | }
17 | int main()
18 | {
19 | 	int p1,p2,i;
20 | 	double x,y,r;
21 | 	scanf("%lf%lf",&x,&y);
22 | 	while (x!=-100)
23 | 	{
24 | 		p1=0;
25 | 		p2=0;
26 | 		r=sqrt(x*x+y*y);
27 | 		p1+=point(r);
28 | 		for (i=0;i<2;i++)
29 | 		{
30 | 			scanf("%lf%lf",&x,&y);
31 | 			r=sqrt(x*x+y*y);
32 | 			p1+=point(r);
33 | 		}
34 | 		for (i=0;i<3;i++)
35 | 		{
36 | 			scanf("%lf%lf",&x,&y);
37 | 			r=sqrt(x*x+y*y);
38 | 			p2+=point(r);
39 | 		}
40 | 		printf("SCORE: %d to %d, ",p1,p2);
41 | 		if (p1==p2)
42 | 			printf("TIE.\n");
43 | 		else if (p1>p2)
44 | 			printf("PLAYER 1 WINS.\n");
45 | 		else printf("PLAYER 2 WINS.\n");
46 | 		scanf("%lf%lf",&x,&y);
47 | 	}
48 | 	return 0;
49 | }
50 | 


--------------------------------------------------------------------------------
/poj/2287.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | int cmp(const void *a,const void *b)
 4 | {
 5 | 	int x,y;
 6 | 	x=*(int *)a;
 7 | 	y=*(int *)b;
 8 | 	if (x<y)
 9 | 		return 1;
10 | 	else if (x>y)
11 | 		return -1;
12 | 	else return 0;
13 | }
14 | int main()
15 | {
16 | 	int i,j,k,s,x,n,t[1000],q[1000];
17 | 	scanf("%d",&n);
18 | 	while (n!=0)
19 | 	{
20 | 		for (i=0;i<n;i++)
21 | 			scanf("%d",&t[i]);
22 | 		for (i=0;i<n;i++)
23 | 			scanf("%d",&q[i]);
24 | 		qsort(t,n,sizeof(t[0]),cmp);
25 | 		qsort(q,n,sizeof(q[0]),cmp);
26 | 		for (i=0;t[0]<q[i] && i<n;i++);
27 | 		for (s=-200*n;i<n;i++)
28 | 		{
29 | 			x=-i*200;
30 | 			for (j=i,k=0;j<n;j++,k++)
31 | 			{
32 | 				if (t[k]>q[j])
33 | 					x+=200;
34 | 				else if (t[k]<q[j])
35 | 					x-=200;
36 | 			}
37 | 			if (x>s)
38 | 				s=x;
39 | 		}
40 | 		printf("%d\n",s);
41 | 		scanf("%d",&n);
42 | 	}
43 | 	return 0;
44 | }
45 | 


--------------------------------------------------------------------------------
/poj/2299.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/snuc/poj/80cccc7287f23d33cde75b51a78a04bdb75408cb/poj/2299.c


--------------------------------------------------------------------------------
/poj/2301.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i,s,t;
 5 | 	scanf("%d",&n);
 6 | 	for (i=0;i<n;i++)
 7 | 	{
 8 | 		scanf("%d%d",&s,&t);
 9 | 		if (s-t<0 || (s+t)%2==1)
10 | 			printf("impossible\n");
11 | 		else printf("%d %d\n",(s+t)/2,(s-t)/2);
12 | 	}
13 | 	return 0;
14 | }
15 | 


--------------------------------------------------------------------------------
/poj/2304.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int s,p1,p2,p3,res;
 5 | 	while(scanf("%d%d%d%d",&s,&p1,&p2,&p3),s!=0 || p1!=0 || p2!=0 || p3!=0)
 6 | 	{
 7 | 		res=0;
 8 | 		if (s<p1)
 9 | 			res+=40;
10 | 		res+=s-p1;
11 | 		if (p1>p2)
12 | 			res+=40;
13 | 		res+=p2-p1;
14 | 		if (p2<p3)
15 | 			res+=40;
16 | 		res+=p2-p3;
17 | 		printf("%d\n",res*9+1080);
18 | 	}
19 | 	return 0;
20 | }
21 | 


--------------------------------------------------------------------------------
/poj/2305.java:
--------------------------------------------------------------------------------
 1 | //Main.java
 2 | import java.util.*;
 3 | import java.math.*;
 4 | 
 5 | public class Main
 6 | {
 7 |         public static void main(String args[]) throws Exception {
 8 |                 Scanner cin=new Scanner(System.in);
 9 |                 int base = cin.nextInt();
10 |                 while (base != 0)
11 |                 {
12 |                 	String s = cin.next();
13 |                 	BigInteger a = new BigInteger(s,base);
14 |                 	s = cin.next();
15 |                 	BigInteger b = new BigInteger(s,base);
16 |                 	a = a.mod(b);
17 |                 	System.out.println(a.toString(base));
18 |                 	base = cin.nextInt();
19 |                 }               
20 |         }
21 | }
22 | 


--------------------------------------------------------------------------------
/poj/2309.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i,s,t,r;
 5 | 	scanf("%d",&n);
 6 | 	for (i=0;i<n;i++)
 7 | 	{
 8 | 		scanf("%d",&s);
 9 | 		t=1;
10 | 		r=s;
11 | 		while (r%2==0)
12 | 		{
13 | 			r/=2;
14 | 			t*=2;
15 | 		}
16 | 		printf("%d %d\n",s-t+1,s+t-1);
17 | 	}
18 | 	return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/poj/2316.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int i;
 5 | 	char s[11],t[11];
 6 | 	scanf("%s",s);
 7 | 	while (scanf("%s",t)!=EOF)
 8 | 	{
 9 | 		for (i=0;t[i]!='\0';i++)
10 | 		{
11 | 			s[i]+=t[i]-'0';
12 | 			if (s[i]>'9')
13 | 				s[i]-=10;
14 | 		}
15 | 	}
16 | 	printf("%s\n",s);
17 | 	return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/poj/2328.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int main()
 4 | {
 5 | 	int i,n,f[11]={0};
 6 | 	char s[20];
 7 | 	scanf("%d",&n);
 8 | 	while (n!=0)
 9 | 	{
10 | 		getchar();
11 | 		gets(s);
12 | 		if (strcmp(s,"too high")==0)
13 | 		{
14 | 			for (i=n;i<11;i++)
15 | 				f[i]=1;
16 | 		}
17 | 		else if (strcmp(s,"too low")==0)
18 | 		{
19 | 			for (i=1;i<=n;i++)
20 | 				f[i]=1;
21 | 		}
22 | 		else{
23 | 			if (f[n]==0)
24 | 				printf("Stan may be honest\n");
25 | 			else printf("Stan is dishonest\n");
26 | 			for (i=1;i<11;i++)
27 | 				f[i]=0;
28 | 		}
29 | 		scanf("%d",&n);
30 | 	}
31 | 	return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/poj/2346.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int i;
 5 | 	scanf("%d",&i);
 6 | 	if (i==2) printf("10\n");
 7 | 	if (i==4) printf("670\n");
 8 | 	if (i==6) printf("55252\n");
 9 | 	if (i==8) printf("4816030\n");
10 | 	if (i==10) printf("432457640\n");
11 | 	return 0;
12 | }
13 | 


--------------------------------------------------------------------------------
/poj/2348.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int i,m,n,a,b;
 5 | 	scanf("%d%d",&m,&n);
 6 | 	while (m!=0 && n!=0)
 7 | 	{
 8 | 		a=m>n ? m:n;
 9 | 		b=m>n ? n:m;
10 | 		for (i=1;a%b!=0;i=1-i)
11 | 		{
12 | 			if (a/b>1)
13 | 				break;
14 | 			n=b;
15 | 			b=a%b;
16 | 			a=n;
17 | 		}
18 | 		if (i==1)
19 | 			printf("Stan wins\n");
20 | 		else printf("Ollie wins\n");
21 | 		scanf("%d%d",&m,&n);
22 | 	}
23 | 	return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/poj/2350.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,m,i,j,t,r;
 5 | 	char s[1000];
 6 | 	scanf("%d",&n);
 7 | 	for (i=0;i<n;i++)
 8 | 	{
 9 | 		scanf("%d",&m);
10 | 		t=0;
11 | 		for (j=0;j<m;j++)
12 | 		{
13 | 			scanf("%d",&s[j]);
14 | 			t+=s[j];
15 | 		}
16 | 		t/=m;
17 | 		r=0;
18 | 		for (j=0;j<m;j++)
19 | 			if (s[j]>t)
20 | 				r++;
21 | 		printf("%.3lf%c\n",100.0*r/m,'%');
22 | 	}
23 | 	return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/poj/2363.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<math.h>
 3 | int main()
 4 | {
 5 | 	int n,i,j,k,m,p,q,s,c[10]={1,8,27,64,125,216,343,512,729,1000};
 6 | 	scanf("%d",&n);
 7 | 	for (i=0;i<n;i++)
 8 | 	{
 9 | 		scanf("%d",&m);
10 | 		for (j=0;c[j]<=m;j++);
11 | 		if (m==0)
12 | 			printf("0\n");
13 | 		s=10000;
14 | 		while (j)
15 | 		{
16 | 			if (m%j==0)
17 | 			{
18 | 				p=m/j;
19 | 				for (k=(int)sqrt((double)p);k>0;k--)
20 | 				{
21 | 					if (p%k==0)
22 | 					{
23 | 						q=p*2+2*j*k+2*j*p/k;
24 | 						s=s>q ? q:s;
25 | 					}
26 | 				}
27 | 			}
28 | 			j--;
29 | 		}
30 | 		printf("%d\n",s);
31 | 	}
32 | 	return 0;
33 | }
34 | 


--------------------------------------------------------------------------------
/poj/2377.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/snuc/poj/80cccc7287f23d33cde75b51a78a04bdb75408cb/poj/2377.cpp


--------------------------------------------------------------------------------
/poj/2386.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int n,m;
 3 | char t[100][100],p[100][100]={0};
 4 | void dfs(int i,int j)
 5 | {
 6 | 	if (p[i][j]==1)
 7 | 		return;
 8 | 	p[i][j]=1;
 9 | 	if (i>0)
10 | 	{
11 | 		if (j>0 && t[i-1][j-1]=='W')
12 | 			dfs(i-1,j-1);
13 | 		if (t[i-1][j]=='W')
14 | 			dfs(i-1,j);
15 | 		if (j+1<m && t[i-1][j+1]=='W')
16 | 			dfs(i-1,j+1);
17 | 	}
18 | 	if (j>0 && t[i][j-1]=='W')
19 | 		dfs(i,j-1);
20 | 	if (j+1<m && t[i][j+1]=='W')
21 | 		dfs(i,j+1);
22 | 	if (i+1<n)
23 | 	{
24 | 		if (j>0 && t[i+1][j-1]=='W')
25 | 			dfs(i+1,j-1);
26 | 		if (t[i+1][j]=='W')
27 | 			dfs(i+1,j);
28 | 		if (j+1<m && t[i+1][j+1]=='W')
29 | 			dfs(i+1,j+1);
30 | 	}
31 | }
32 | int main()
33 | {
34 | 	int i,j,w=0;
35 | 	scanf("%d%d",&n,&m);
36 | 	for (i=0;i<n;i++)
37 | 		scanf("%s",t[i]);
38 | 	for (i=0;i<n;i++)
39 | 	{
40 | 		for (j=0;j<m;j++)
41 | 		{
42 | 			if (t[i][j]=='W' && p[i][j]==0)
43 | 			{
44 | 				w++;
45 | 				dfs(i,j);
46 | 			}
47 | 		}
48 | 	}
49 | 	printf("%d\n",w);
50 | 	return 0;
51 | }
52 | 


--------------------------------------------------------------------------------
/poj/2388.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int f[9999],n,i,j,x=1,y,z;
 5 | 	scanf("%d%d",&n,&f[0]);
 6 | 	y=n-1;
 7 | 	for (i=1;i<n;i++)
 8 | 	{
 9 | 		scanf("%d",&z);
10 | 		if (z>f[0])
11 | 			f[y--]=z;
12 | 		else f[x++]=z;
13 | 	}
14 | 	z=n/2+1;
15 | 	if (x==z)
16 | 		printf("%d\n",f[0]);
17 | 	else if (x>z)
18 | 	{
19 | 		for (i=1;i<=x-z;i++)
20 | 		{
21 | 			for (j=i+1;j<x;j++)
22 | 			{
23 | 				if (f[i]<f[j])
24 | 				{
25 | 					y=f[i];
26 | 					f[i]=f[j];
27 | 					f[j]=y;
28 | 				}
29 | 			}
30 | 		}
31 | 		printf("%d\n",f[i-1]);
32 | 	}
33 | 	else {
34 | 		for (i=x;i<z;i++)
35 | 		{
36 | 			for (j=i+1;j<n;j++)
37 | 			{
38 | 				if (f[i]>f[j])
39 | 				{
40 | 					y=f[i];
41 | 					f[i]=f[j];
42 | 					f[j]=y;
43 | 				}
44 | 			}
45 | 		}
46 | 		printf("%d\n",f[i-1]);
47 | 	}
48 | 	return 0;
49 | }
50 | 


--------------------------------------------------------------------------------
/poj/2389.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int i,j,k,l,m,n;
 5 | 	char s[41],t[41],r[81]={0},c;
 6 | 	for(k=0;k<41;k++)  
 7 | 	{
 8 | 		scanf("%c",&c);
 9 | 		if(c<'0'|| c>'9')
10 | 			break;
11 | 		s[k]=c-'0';
12 | 	}
13 | 	for(l=0;l<41;l++)  
14 | 	{
15 | 		scanf("%c",&c);
16 | 		if(c<'0'||c>'9')
17 | 			break;
18 | 		t[l]=c-'0';
19 | 	}
20 | 	for (i=k-1;i>=0;i--)
21 | 	{
22 | 		m=k-1-i;
23 | 		for (j=l-1;j>=0;j--)
24 | 		{
25 | 			r[m]+=s[i]*t[j];
26 | 			n=m;
27 | 			while (r[n]>9)
28 | 			{
29 | 				r[n+1]+=r[n]/10;
30 | 				r[n]%=10;
31 | 				n++;
32 | 			}
33 | 			m++;
34 | 		}
35 | 	}
36 | 	for (i=k+l;r[i]==0 && i>0;i--);
37 | 	for (j=i;j>=0;j--)
38 | 		printf("%d",r[j]);
39 | 	printf("\n");
40 | 	return 0;
41 | }
42 | 


--------------------------------------------------------------------------------
/poj/2390.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int r,y;
 5 | 	double m,s;
 6 | 	scanf("%d %lf %d",&r,&m,&y);
 7 | 	s=r/100.0+1;
 8 | 	for (r=0;r<y;r++)
 9 | 		m*=s;
10 | 	printf("%d\n",(int)m);
11 | 	return 0;
12 | }
13 | 


--------------------------------------------------------------------------------
/poj/2394.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/snuc/poj/80cccc7287f23d33cde75b51a78a04bdb75408cb/poj/2394.cpp


--------------------------------------------------------------------------------
/poj/2402.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int i,j,n;
 5 | 	scanf("%d",&n);
 6 | 	while (n)
 7 | 	{
 8 | 		i=9;
 9 | 		j=1;
10 | 		while (n-2*i>0)
11 | 		{
12 | 			n-=2*i;
13 | 			i*=10;
14 | 			j*=10;
15 | 		}
16 | 		j+=((n%i==0) ? i:n%i)-1;
17 | 		printf("%d",j);
18 | 		if (n-i<=0)
19 | 			j/=10;
20 | 		while (j)
21 | 		{
22 | 			printf("%d",j%10);
23 | 			j/=10;
24 | 		}
25 | 		printf("\n");
26 | 		scanf("%d",&n);
27 | 	}
28 | 	return 0;
29 | }
30 | 


--------------------------------------------------------------------------------
/poj/2403.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/snuc/poj/80cccc7287f23d33cde75b51a78a04bdb75408cb/poj/2403.cpp


--------------------------------------------------------------------------------
/poj/2405.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<math.h>
 3 | int main()
 4 | {
 5 | 	double D,d,v;
 6 | 	while(scanf("%lf%lf",&D,&v)&&(D||v))
 7 | 	{
 8 | 		d=pow((D*D*D-(6*v/3.1415926535)),1.0000000/3);
 9 | 		printf("%.3lf\n",d);
10 | 	}
11 | 	return 0;
12 | }
13 | 


--------------------------------------------------------------------------------
/poj/2406.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int main()
 4 | {
 5 | 	int i,j,k,l;
 6 | 	char s[1000001];
 7 | 	scanf("%s",s);
 8 | 	while (s[0]!='.')
 9 | 	{
10 | 		k=0;
11 | 		l=strlen(s);
12 | 		for (i=1;i<l;i++)
13 | 		{
14 | 			if (s[i]==s[0] && l%i==0)
15 | 			{
16 | 				for (j=i+1;j<l;j++)
17 | 					if (s[j]!=s[j-i])
18 | 						break;
19 | 				if (j==l)
20 | 				{
21 | 					k=1;
22 | 					printf("%d\n",j/i);
23 | 					break;
24 | 				}
25 | 			}
26 | 		}
27 | 		if (k==0)
28 | 			printf("1\n");
29 | 		scanf("%s",s);
30 | 	}
31 | 	return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/poj/2407.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int m,euler,r,i,x;
 5 | 	scanf("%d",&m);
 6 | 	while (m!=0)
 7 | 	{
 8 | 		r=0;
 9 | 		x=m;
10 | 		euler=m;
11 | 		if (x%2==0)
12 | 		{
13 | 			euler/=2;
14 | 			do{
15 | 				x/=2;
16 | 			}while(x%2==0);
17 | 			r=1;
18 | 		}
19 | 		else r=0;
20 | 		for (i=3;x>1;i+=2)
21 | 		{
22 | 			if (x%i==0)
23 | 			{
24 | 				r=1;
25 | 				euler-=euler/i;
26 | 				do{
27 | 					x/=i;
28 | 				}while(x%i==0);
29 | 			}
30 | 		}
31 | 		if (r==0)
32 | 		{
33 | 			if (m!=1)
34 | 				euler--;
35 | 		}
36 | 		printf("%d\n",euler);
37 | 		scanf("%d",&m);
38 | 	}
39 | 	return 0;
40 | }
41 | 


--------------------------------------------------------------------------------
/poj/2421.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/snuc/poj/80cccc7287f23d33cde75b51a78a04bdb75408cb/poj/2421.cpp


--------------------------------------------------------------------------------
/poj/2436.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/snuc/poj/80cccc7287f23d33cde75b51a78a04bdb75408cb/poj/2436.cpp


--------------------------------------------------------------------------------
/poj/2440.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i,a[200]={1,2,4,6};
 5 | 	for(i=4;i<200;++i)
 6 | 		a[i]=(a[i-1]+a[i-3]+a[i-4])%2005;
 7 | 	while(scanf("%d",&n)!=EOF)
 8 | 		printf("%d\n",a[n%200]);
 9 | 	return 0;
10 | }
11 | 


--------------------------------------------------------------------------------
/poj/2453.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int i,j,k,l;
 5 | 	char b[21]={0};
 6 | 	scanf("%d",&i);
 7 | 	while (i)
 8 | 	{
 9 | 		for (j=0;i;j++)
10 | 		{
11 | 			b[j]=i%2;
12 | 			i/=2;
13 | 		}
14 | 		k=0;
15 | 		for (i=0;i<j;i++)
16 | 		{
17 | 			if (b[i]==1)
18 | 			{
19 | 				k++;
20 | 				if (b[i+1]==0)
21 | 					break;
22 | 			}
23 | 		}
24 | 		b[i+1]=1;
25 | 		k--;
26 | 		for (l=0;l<k;l++)
27 | 			b[l]=1;
28 | 		while (l<=i)
29 | 			b[l++]=0;
30 | 		for (l=j,k=0;l>=0;l--)
31 | 		{
32 | 			k*=2;
33 | 			k+=b[l];
34 | 			b[l]=0;
35 | 		}
36 | 		printf("%d\n",k);
37 | 		scanf("%d",&i);
38 | 	}
39 | 	return 0;
40 | }
41 | 


--------------------------------------------------------------------------------
/poj/2460.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int x[200000],y[200000];
 3 | int main()
 4 | {
 5 | 	int n,i,j,k,a,b;
 6 | 	scanf("%d",&n);
 7 | 	while (n!=0)
 8 | 	{
 9 | 		for (i=0;i<n;i++)
10 | 			scanf("%d%d",&x[i],&y[i]);
11 | 		a=x[n/2];
12 | 		b=y[n/2];
13 | 		for (i=0,j=0,k=0;i<n;i++)
14 | 		{
15 | 			if ((x[i]>a && y[i]>b) || (x[i]<a && y[i]<b))
16 | 				j++;
17 | 			else if ((x[i]>a && y[i]<b) || (x[i]<a && y[i]>b))
18 | 				k++;
19 | 		}
20 | 		printf("%d %d\n",j,k);
21 | 		scanf("%d",&n);
22 | 	}
23 | 	return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/poj/2470.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int num[100001];
 3 | int main ()
 4 | {
 5 | 	int i,n;
 6 | 	scanf("%d",&n);
 7 | 	while (n!=0)
 8 | 	{
 9 | 		for (i=1;i<=n;i++)
10 | 			scanf("%d",&num[i]);
11 | 		for (i=1;i<=n;i++)
12 | 			if (i!=num[num[i]])
13 | 				break;
14 | 		if (i>n)
15 | 			printf("ambiguous\n");
16 | 		else printf("not ambiguous\n");
17 | 		scanf("%d",&n);
18 | 	}
19 | 	return 0;
20 | }
21 | 


--------------------------------------------------------------------------------
/poj/2479.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,m,i,j,t,a[50000],b[50000],s,x,y;
 5 | 	short p[50000];
 6 | 	scanf("%d",&m);
 7 | 	for (j=0;j<m;j++)
 8 | 	{
 9 | 		x=-10001;
10 | 		scanf("%d",&n);
11 | 		for (i=0;i<n;i++)
12 | 		{
13 | 			scanf("%d",&p[i]);
14 | 			if (p[i]>x)
15 | 			{
16 | 				y=x;
17 | 				x=p[i];
18 | 			}
19 | 			else if (p[i]>y)
20 | 				y=p[i];
21 | 		}
22 | 		s=-10001;
23 | 		t=0;
24 | 		for (i=0;i<n;i++)
25 | 		{
26 | 			t+=p[i];
27 | 			if (t>s)
28 | 				s=t;
29 | 			if (t<0)
30 | 				t=0;
31 | 			a[i]=s;
32 | 		}
33 | 		s=-10001;
34 | 		t=0;
35 | 		b[n-1]=0;
36 | 		for (i=n-1;i>0;i--)
37 | 		{
38 | 			t+=p[i];
39 | 			if (t>s)
40 | 				s=t;
41 | 			if (t<0)
42 | 				t=0;
43 | 			b[i-1]=s;
44 | 		}
45 | 		s=-10001;
46 | 		for (i=0;i<n;i++)
47 | 		{
48 | 			if (a[i]+b[i]>s)
49 | 				s=a[i]+b[i];
50 | 		}
51 | 		if (s==x)
52 | 			s+=y;
53 | 		printf("%d\n",s);
54 | 	}
55 | 	return 0;
56 | }
57 | 


--------------------------------------------------------------------------------
/poj/2484.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int n;
 5 | 	scanf("%d",&n);
 6 | 	while (n!=0)
 7 | 	{
 8 | 		if (n>2)
 9 | 			printf("Bob\n");
10 | 		else printf("Alice\n");
11 | 		scanf("%d",&n);
12 | 	}
13 | 	return 0;
14 | }
15 | 


--------------------------------------------------------------------------------
/poj/2487.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | int cmp(const void *a,const void *b)
 4 | {
 5 | 	int x,y;
 6 | 	x=*(int *)a;
 7 | 	y=*(int *)b;
 8 | 	if (x<y)
 9 | 		return 1;
10 | 	else if (x>y)
11 | 		return -1;
12 | 	else return 0;
13 | }
14 | 
15 | int main()
16 | {
17 | 	int i,j,k,n,t,sum,f[1000];
18 | 	scanf("%d",&t);
19 | 	for (i=1;i<=t;i++)
20 | 	{
21 | 		scanf("%d%d",&sum,&n);
22 | 		for (j=0;j<n;j++)
23 | 			scanf("%d",&f[j]);
24 | 		qsort(f,n,sizeof(f[0]),cmp);
25 | 		for (j=0,k=0;j<n;j++)
26 | 		{
27 | 			k+=f[j];
28 | 			if (k>=sum)
29 | 				break;
30 | 		}
31 | 		printf("Scenario #%d:\n",i);
32 | 		if (j==n)
33 | 			printf("impossible\n\n");
34 | 		else printf("%d\n\n",j+1);
35 | 	}
36 | 	return 0;
37 | }
38 | 


--------------------------------------------------------------------------------
/poj/2495.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int i,n,a,b,x,y;
 5 | 	scanf("%d",&n);
 6 | 	for (i=1;i<=n;i++)
 7 | 	{
 8 | 		scanf("%d%d%d%d",&a,&b,&x,&y);
 9 | 		a=(a+b)%2;
10 | 		x=(x+y)%2;
11 | 		if (a==x)
12 | 			a=0;
13 | 		else a=1;
14 | 		printf("Scenario #%d:\n%d\n\n",i,a);
15 | 	}
16 | 	return 0;
17 | }
18 | 


--------------------------------------------------------------------------------
/poj/2497.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | int difficult[30];
 4 | int cmp(const void *a, const void *b)
 5 | {
 6 | 	int x,y;
 7 | 	x=*(int *)a;
 8 | 	y=*(int *)b;
 9 | 	if (x<y)
10 | 		return -1;
11 | 	else if (x>y)
12 | 		return 1;
13 | 	else return 0;
14 | }
15 | int main()
16 | {
17 | 	int i,j,t,time,problem,sum,slove,store;
18 | 	scanf("%d",&t);
19 | 	for (i=1;i<=t;i++)
20 | 	{
21 | 		scanf("%d%d",&time,&problem);
22 | 		for (j=0;j<problem;j++)
23 | 			scanf("%d",&difficult[j]);
24 | 		qsort(difficult,problem,sizeof(difficult[0]),cmp);
25 | 		slove=0;
26 | 		store=0;
27 | 		for (j=0,sum=0;j<problem;j++)
28 | 		{
29 | 			sum+=difficult[j];
30 | 			if (time>=sum)
31 | 			{
32 | 				slove++;
33 | 				store+=sum;
34 | 			}
35 | 			else break;
36 | 		}
37 | 		printf("Scenario #%d:\n",i);
38 | 		printf("Steve wins with %d solved problems and a score of %d.\n\n",slove,store);
39 | 	}
40 | 	return 0;
41 | }
42 | 


--------------------------------------------------------------------------------
/poj/2498.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i,j,k,a[3]={9,3,7},t,x,y;
 5 | 	char s[8];
 6 | 	scanf("%d",&n);
 7 | 	for (i=1;i<=n;i++)
 8 | 	{
 9 | 		t=0;
10 | 		scanf("%s",s);
11 | 		for (j=0;s[j]!='\0';j++);
12 | 		for (j--,k=0;j>=0;j--)
13 | 		{
14 | 			if (s[j]=='?')
15 | 			{
16 | 				x=j;
17 | 				y=k++;
18 | 			}
19 | 			else t+=(s[j]-'0')*a[k++];
20 | 			if (k==3)
21 | 				k=0;
22 | 		}
23 | 		t%=10;
24 | 		if (t==0)
25 | 			s[x]='0';
26 | 		else {
27 | 			t=10-t;
28 | 			while (t%a[y]!=0)
29 | 				t+=10;
30 | 			s[x]=t/a[y]+'0';
31 | 		}
32 | 		printf("Scenario #%d:\n%s\n\n",i,s);
33 | 	}
34 | 	return 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/poj/2499.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i,a,b,x,y,t;
 5 | 	scanf("%d",&n);
 6 | 	for (i=1;i<=n;i++)
 7 | 	{
 8 | 		scanf("%d%d",&a,&b);
 9 | 		x=0;
10 | 		y=0;
11 | 		while (a!=1 && b!=1)
12 | 		{
13 | 			if (a<b)
14 | 			{
15 | 				t=b/a;
16 | 				y+=t;
17 | 				b-=a*t;
18 | 			}
19 | 			else {
20 | 				t=a/b;
21 | 				x+=t;
22 | 				a-=b*t;
23 | 			}
24 | 		}
25 | 		if (a==1)
26 | 			y+=b-1;
27 | 		else x+=a-1;
28 | 		printf("Scenario #%d:\n%d %d\n\n",i,x,y);
29 | 	}
30 | 	return 0;
31 | }
32 | 


--------------------------------------------------------------------------------
/poj/2501.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	double l=0,v=0,t1=0,t2;
 5 | 	char s[9],c;
 6 | 	while (scanf("%s",s)!=EOF)
 7 | 	{
 8 | 		c=getchar();
 9 | 		t2=(s[0]-'0')*10.0+(s[1]-'0')+((s[3]-'0')*10+(s[4]-'0'))/60.0+((s[6]-'0')*10+(s[7]-'0'))/3600.0;
10 | 		l+=v*(t2-t1);
11 | 		t1=t2;
12 | 		if (c=='\n')
13 | 			printf("%s %.2lf km\n",s,l);
14 | 		else if (c==' ')
15 | 			scanf("%lf",&v);
16 | 	}
17 | 	return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/poj/2503.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/snuc/poj/80cccc7287f23d33cde75b51a78a04bdb75408cb/poj/2503.c


--------------------------------------------------------------------------------
/poj/2505.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int i,a[2]={2,9};
 5 | 	unsigned n;
 6 | 	while (scanf("%d",&n)!=EOF)
 7 | 	{
 8 | 		for (i=1;n!=1;i=1-i)
 9 | 		{
10 | 			if (n%a[i]==0)
11 | 				n/=a[i];
12 | 			else n=n/a[i]+1;
13 | 		}
14 | 		if (i==0)
15 | 			printf("Stan wins.\n");
16 | 		else printf("Ollie wins.\n");
17 | 	}
18 | 	return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/poj/2507.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<math.h>
 3 | int main()
 4 | {
 5 | 	double x,y,z,i,j,c,a,b,m;
 6 | 	while (scanf("%lf%lf%lf",&x,&y,&c)!=EOF)
 7 | 	{
 8 | 		i=0;
 9 | 		j=(x>y) ? y:x;
10 | 		while (0.00001<j-i)
11 | 		{
12 | 			z=(i+j)/2;
13 | 			a=sqrt((x+z)*(x-z));
14 | 			b=sqrt((y+z)*(y-z));
15 | 			m=a*b/(a+b)-c;
16 | 			if (m<0.0001 && m>-0.0001)
17 | 				break;
18 | 			else if (m<-0.0001)
19 | 				j=z-0.000001;
20 | 			else i=z+0.000001;
21 | 		}
22 | 		printf("%.3lf\n",(i+j)/2);
23 | 	}
24 | 	return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/poj/2509.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,k,s;
 5 | 	while (scanf("%d%d",&n,&k)!=EOF)
 6 | 	{
 7 | 		s=n;
 8 | 		while (n>=k)
 9 | 		{
10 | 			s+=n/k;
11 | 			n=n/k+n%k;
12 | 		}
13 | 		printf("%d\n",s);
14 | 	}
15 | 	return 0;
16 | }
17 | 


--------------------------------------------------------------------------------
/poj/2521.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,m,p,c;
 5 | 	scanf("%d%d%d%d",&n,&m,&p,&c);
 6 | 	while (n!=0 || m!=0 || p!=0 || c!=0)
 7 | 	{
 8 | 		printf("%d\n",p+n-m);
 9 | 		scanf("%d%d%d%d",&n,&m,&p,&c);
10 | 	}
11 | 	return 0;
12 | }
13 | 


--------------------------------------------------------------------------------
/poj/2524.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int s[50001];
 3 | int root(int i);
 4 | void  merge(int i,int j);
 5 | int main()
 6 | {
 7 | 	int n,m,c,i,j=0,a,b;
 8 | 	scanf("%d%d",&n,&m);
 9 | 	while (n!=0 || m!=0)
10 | 	{
11 | 		j++;
12 | 		for (i=n;i>0;i--)
13 | 			s[i]=-1;
14 | 		for (i=0;i<m;i++)
15 | 		{
16 | 			scanf("%d%d",&a,&b);
17 | 			merge(a,b);
18 | 		}
19 | 		for (i=1,c=0;i<=n;i++)
20 | 			if (s[i]<0)
21 | 				c++;
22 | 		printf("Case %d: %d\n",j,c);
23 | 		scanf("%d%d",&n,&m);
24 | 	}
25 | 	return 0;
26 | }
27 | int root(int i)
28 | {
29 | 	int r,p;
30 | 	for (r=i;s[r]>0;r=s[r]);
31 | 	while (i!=r)
32 | 	{
33 | 		p=i;
34 | 		i=s[i];
35 | 		s[p]=r;
36 | 	}	
37 | 	return r;
38 | }
39 | void  merge(int i,int j)
40 | {
41 | 	i=root(i);
42 | 	j=root(j);
43 | 	if (i==j)
44 | 		return ;
45 | 	if (s[i]<s[j])
46 | 	{
47 | 		s[i]+=s[j];
48 | 		s[j]=i;
49 | 	}
50 | 	else 
51 | 	{
52 | 		s[j]+=s[i];
53 | 		s[i]=j;
54 | 	}
55 | }
56 | 


--------------------------------------------------------------------------------
/poj/2533.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int road[1001];
 5 | 	int n,i,j,in,max=0;
 6 | 	scanf("%d",&n);
 7 | 	for (i=0;i<n;i++)
 8 | 	{
 9 | 		road[i]=10001;
10 | 		scanf("%d",&in);
11 | 		for (j=0;road[j]<in;j++);
12 | 		road[j]=in;
13 | 		if (max<j+1)
14 | 			max=j+1;
15 | 	}
16 | 	printf("%d\n",max);
17 | 	return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/poj/2538.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int i;
 5 | 	char c[128]={'\0'},s[99];
 6 | 	c['1']='`';c['2']='1';c['3']='2';c['4']='3';c['5']='4';c['6']='5';c['7']='6';c['8']='7';
 7 | 	c['9']='8';c['0']='9';c['-']='0';c['=']='-';c['W']='Q';c['E']='W';c['R']='E';c['T']='R';
 8 | 	c['Y']='T';c['U']='Y';c['I']='U';c['O']='I';c['P']='O';c['[']='P';c[']']='[';c['\\']=']';
 9 | 	c['S']='A';c['D']='S';c['F']='D';c['G']='F';c['H']='G';c['J']='H';c['K']='J';c['L']='K';
10 | 	c[';']='L';c['\'']=';';c['X']='Z';c['C']='X';c['V']='C';c['B']='V';c['N']='B';c['M']='N';
11 | 	c[',']='M';c['.']=',';c['/']='.';
12 | 	while (gets(s)!=NULL)
13 | 	{
14 | 		for (i=0;s[i]!='\0';i++)
15 | 		{
16 | 			if (c[s[i]]=='\0')
17 | 				printf("%c",s[i]);
18 | 			else printf("%c",c[s[i]]);
19 | 		}
20 | 		printf("\n");
21 | 	}
22 | 	return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/poj/2545.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	__int64 f[3000]={1};
 5 | 	int i=0,j=0,k=0,p,q,r,s=1,n;
 6 | 	scanf("%d%d%d%d",&p,&q,&r,&n);
 7 | 	while (s<=n)
 8 | 	{
 9 | 		if (f[i]*p<=f[j]*q && f[i]*p<=f[k]*r)
10 | 		{
11 | 			if (f[i]*p==f[s-1])
12 | 				i++;
13 | 			else f[s++]=f[i++]*p;
14 | 		}
15 | 		if (f[j]*q<=f[i]*p && f[j]*q<=f[k]*r)
16 | 		{
17 | 			if (f[j]*q==f[s-1])
18 | 				j++;
19 | 			else f[s++]=f[j++]*q;
20 | 		}
21 | 		if (f[k]*r<=f[i]*p && f[k]*r<=f[j]*q)
22 | 		{
23 | 			if (f[k]*r==f[s-1])
24 | 				k++;
25 | 			else f[s++]=f[k++]*r;
26 | 		}
27 | 	}
28 | 	printf("%I64d\n",f[n]);
29 | 	return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/poj/2546.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<math.h>
 3 | int main()
 4 | {
 5 |     double x1,y1,a,x2,y2,b,c,s,A,B,area;
 6 | 	while(scanf("%lf%lf%lf%lf%lf%lf",&x1,&y1,&a,&x2,&y2,&b)!=EOF)
 7 | 	{
 8 | 		if(a<b)
 9 | 			c=a,a=b,b=c;
10 | 		c=sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
11 | 		if(c>=a+b)
12 | 			printf("0.000\n");
13 | 		else if (c<=a-b)
14 | 			printf("%.3lf\n",3.1415926*b*b);
15 | 		else{
16 | 			A=acos((b*b+c*c-a*a)/2/b/c);
17 | 			B=acos((a*a+c*c-b*b)/2/a/c);
18 | 			s=(a+b+c)/2;
19 | 			s=sqrt(s*(s-a)*(s-b)*(s-c));
20 | 			area=a*a*B+b*b*A-2*s;
21 | 			printf("%.3lf\n",area);
22 | 		}
23 | 	}
24 | 	return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/poj/2551.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,s,i;
 5 | 	while (scanf("%d",&n)!=EOF)
 6 | 	{
 7 | 		for (i=1,s=1;(s%=n)!=0;i++)
 8 | 			s=s*10+1;
 9 | 		printf("%d\n",i);
10 | 	}
11 | 	return 0;
12 | }
13 | 


--------------------------------------------------------------------------------
/poj/2553.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/snuc/poj/80cccc7287f23d33cde75b51a78a04bdb75408cb/poj/2553.cpp


--------------------------------------------------------------------------------
/poj/2562.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int c,s;
 5 | 	unsigned m,n;
 6 | 	scanf("%u%u",&m,&n);
 7 | 	while (n!=0 || m!=0)
 8 | 	{
 9 | 		c=0;
10 | 		s=0;
11 | 		while (n!=0 || m!=0)
12 | 		{
13 | 			s+=n%10+m%10;
14 | 			if (s>9)
15 | 				c++;
16 | 			n/=10;
17 | 			m/=10;
18 | 			s/=10;
19 | 		}
20 | 		if(c==0)
21 | 			printf("No carry operation.\n");
22 |         else if (c>1)
23 | 			printf("%d carry operations.\n",c);
24 |         else printf("1 carry operation.\n");
25 | 		scanf("%u%u",&m,&n);
26 | 	}
27 | 	return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/poj/2575.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | bool flag[3000];
 4 | int fab(int i,int j)
 5 | {
 6 | 	if (i>j)
 7 | 		return i-j;
 8 | 	else return j-i;
 9 | }
10 | int main()
11 | {
12 | 	int n,i,a,b,c;
13 | 	bool jolly;
14 | 	while (scanf("%d",&n)!=EOF)
15 | 	{
16 | 		scanf("%d",&a);
17 | 		memset(flag,false,sizeof(flag));
18 | 		jolly=true;
19 | 		for (i=1;i<n;i++)
20 | 		{
21 | 			scanf("%d",&b);
22 | 			c=fab(a,b);
23 | 			if (c>0 && c<n && flag[c]==false)
24 | 				flag[c]=true;
25 | 			else jolly=false;
26 | 			a=b;
27 | 		}
28 | 		if (jolly==true)
29 | 			printf("Jolly\n");
30 | 		else printf("Not jolly\n");
31 | 	}
32 | 	return 0;
33 | }
34 | 


--------------------------------------------------------------------------------
/poj/2578.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int a,i;
 5 | 	for (i=0;i<3;i++)
 6 | 	{
 7 | 		scanf("%d",&a);
 8 | 		if (a<=168)
 9 | 		{
10 | 			printf("CRASH %d\n",a);
11 | 			return 0;
12 | 		}
13 | 	}
14 | 	printf("NO CRASH\n");
15 | 	return 0;
16 | }
17 | 


--------------------------------------------------------------------------------
/poj/2583.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int a,b,c,x,y,z;
 5 | 	while (scanf("%d%d%d",&c,&a,&b)!=EOF)
 6 | 	{
 7 | 		a=(b+c)/2-a;
 8 | 		b=(b-c)/2-2*a;
 9 | 		x=9*a+3*b+c;
10 | 		y=x+7*a+b;
11 | 		z=y+9*a+b;
12 | 		printf("%d %d %d\n",x,y,z);
13 | 	}
14 | 	return 0;
15 | }
16 | 


--------------------------------------------------------------------------------
/poj/2590.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i,a,b,s;
 5 | 	scanf("%d",&n);
 6 | 	for (i=0;i<n;i++)
 7 | 	{
 8 | 		scanf("%d%d",&a,&b);
 9 | 		b-=a;
10 | 		s=0;
11 | 		for (a=0;s<b;a+=2)
12 | 			s+=a+2;
13 | 		if (s-a/2>=b && s!=0)
14 | 			a--;
15 | 		printf("%d\n",a);
16 | 	}
17 | 	return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/poj/2591.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | unsigned p[10000000]={1};
 3 | int main()
 4 | {
 5 | 	int i=0,j=0,c=1;
 6 | 	while (c<10000000)
 7 | 	{
 8 | 		if (p[i]*2<p[j]*3)
 9 | 		{
10 | 			if (p[i]*2+1==p[c-1])
11 | 				i++;
12 | 			else p[c++]=p[i++]*2+1;
13 | 		}
14 | 		else {
15 | 			if (p[j]*3+1==p[c-1])
16 | 				j++;
17 | 			else p[c++]=p[j++]*3+1;
18 | 		}
19 | 	}
20 | 	while (scanf("%d",&c)!=EOF)
21 | 		printf("%d\n",p[c-1]);
22 | 	return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/poj/2593.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,max,min,p,q,i,a,b,c;
 5 | 	scanf("%d",&n);
 6 | 	while (n!=0)
 7 | 	{
 8 | 		p=0;
 9 | 		q=0;
10 | 		max=-1001;
11 | 		min=0;
12 | 		b=-1001;
13 | 		c=-1001;
14 | 		for (i=0;i<n;i++)
15 | 		{
16 | 			scanf("%d",&a);
17 | 			if (a>b)
18 | 			{
19 | 				c=b;
20 | 				b=a;
21 | 			}
22 | 			else if (a>c)
23 | 				c=a;
24 | 			p+=a;
25 | 			q+=a;
26 | 			if (q>0)
27 | 				q=0;
28 | 			if (q<min)
29 | 				min=q;
30 | 			if (p-min>max)
31 | 				max=p-min;
32 | 			if (p<=min)
33 | 			{
34 | 				p=0;
35 | 				q=0;
36 | 				min=0;
37 | 			}
38 | 		}
39 | 		if (max==0 || max==b)
40 | 			max=b+c;
41 | 		printf("%d\n",max);
42 | 		scanf("%d",&n);
43 | 	}
44 | 	return 0;
45 | }
46 | 


--------------------------------------------------------------------------------
/poj/2601.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i;
 5 | 	double c,a,b,d=0;
 6 | 	scanf("%d%lf%lf",&n,&a,&b);
 7 | 	for (i=0;i<n;i++)
 8 | 	{
 9 | 		scanf("%lf",&c);
10 | 		d+=(n-i)*c;
11 | 	}
12 | 	d=b-a-2*d;
13 | 	d=a+d/(n+1);
14 | 	printf("%.2lf\n",d);
15 | 	return 0;
16 | }
17 | 


--------------------------------------------------------------------------------
/poj/2602.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i,j;
 5 | 	char c[1000000];
 6 | 	scanf("%d\n",&n);
 7 | 	for (i=n-1;i>=0;i--)
 8 | 	{
 9 | 		c[i]=getchar();
10 | 		getchar();
11 | 		c[i]+=getchar()-'0';
12 | 		for (j=i;c[j]>'9';)
13 | 		{
14 | 			c[j]-=10;
15 | 			c[++j]++;
16 | 		}
17 | 		getchar();
18 | 	}
19 | 	for (i=n-1;i>=0;i--)
20 | 		putchar(c[i]);
21 | 	putchar('\n');
22 | 	return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/poj/2603.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int prime[1229]={2,3},q=2,num[1229]={0};
 3 | void add(int p)
 4 | {
 5 | 	int i;
 6 | 	for (i=0;p>1;i++)
 7 | 	{
 8 | 		while (p%prime[i]==0)
 9 | 		{
10 | 			p/=prime[i];
11 | 			num[i]++;
12 | 		}
13 | 	}
14 | }
15 | int main()
16 | {
17 | 	int i,j;
18 | 	for (i=5;i<10000;i+=2)
19 | 	{
20 | 		for (j=1;j<q;j++)
21 | 			if (i%prime[j]==0)
22 | 				break;
23 | 		if (j==q)
24 | 			prime[q++]=i;
25 | 	}
26 | 	for (i=0;i<10;i++)
27 | 	{
28 | 		scanf("%d",&j);
29 | 		add(j);
30 | 	}
31 | 	for (i=0,j=1;i<1229;i++)
32 | 		j*=(num[i]+1);
33 | 	printf("%d\n",j%10);
34 | 	return 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/poj/2606.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i,j,k,a,b,s,r=2,x[200],y[200];
 5 | 	scanf("%d",&n);
 6 | 	for (i=0;i<n;i++)
 7 | 		scanf("%d%d",&x[i],&y[i]);
 8 | 	for (i=0;i<n;i++)
 9 | 	{
10 | 		for (j=i+1;j<n;j++)
11 | 		{
12 | 			s=2;
13 | 			a=x[j]-x[i];
14 | 			b=y[j]-y[i];
15 | 			for (k=j+1;k<n;k++)
16 | 				if (b*(x[k]-x[i])==a*(y[k]-y[i]))
17 | 					s++;
18 | 			if (s>r)
19 | 				r=s;
20 | 		}
21 | 	}
22 | 	printf("%d\n",r);
23 | 	return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/poj/2608.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int i;
 5 | 	char s[26]={0,1,2,3,0,1,2,0,0,2,2,4,5,5,0,1,2,6,2,3,0,1,0,2,0,2},t[21],c;
 6 | 	while (scanf("%s",t)!=EOF)
 7 | 	{
 8 | 		c=-1;
 9 | 		for (i=0;t[i]!='\0';i++)
10 | 		{
11 | 			if (s[t[i]-'A']!=0 && s[t[i]-'A']!=c)
12 | 				printf("%d",s[t[i]-'A']);
13 | 			c=s[t[i]-'A'];
14 | 		}	
15 | 		printf("\n");
16 | 	}
17 | 	return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/poj/2610.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | double gx,gy,dx,dy,x,y;
 3 | double dist(double x,double y,double hx,double hy)
 4 | {
 5 | 	return (x-hx)*(x-hx)+(y-hy)*(y-hy);
 6 | }
 7 | int main()
 8 | {
 9 | 	int flag=0;
10 | 	double cx,cy;
11 | 	scanf("%lf%lf%lf%lf",&gx,&gy,&dx,&dy);
12 | 	while (scanf("%lf%lf",&x,&y)!=EOF)
13 | 	{
14 | 		if (flag==0)
15 | 		{
16 | 			cx=dist(x,y,gx,gy)*4;
17 | 			cy=dist(x,y,dx,dy);
18 | 			if (cx<cy+0.0000001)
19 | 			{
20 | 				flag=1;
21 | 				cx=x;
22 | 				cy=y;
23 | 			}
24 | 		}
25 | 	}
26 | 	if (flag==0)
27 | 		printf("The gopher cannot escape.\n");
28 | 	else printf("The gopher can escape through the hole at (%.3lf,%.3lf).\n",cx,cy);
29 | 	return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/poj/2612.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int n;
 3 | char f[12][12]={0};
 4 | void add(int x,int y)
 5 | {
 6 | 	f[x-1][y-1]++;
 7 | 	f[x-1][y]++;
 8 | 	f[x-1][y+1]++;
 9 | 	f[x][y-1]++;
10 | 	f[x][y+1]++;
11 | 	f[x+1][y-1]++;
12 | 	f[x+1][y]++;
13 | 	f[x+1][y+1]++;
14 | 	f[x][y]=9;
15 | }
16 | int main()
17 | {
18 | 	int i,j,k=0;
19 | 	char c[11][11]={0};
20 | 	scanf("%d\n",&n);
21 | 	for (i=1;i<=n;i++)
22 | 	{
23 | 		for (j=1;j<=n;j++)
24 | 			if (getchar()=='*')
25 | 				add(i,j);
26 | 		getchar();
27 | 	}
28 | 	for (i=1;i<=n;i++)
29 | 	{
30 | 		for (j=1;j<=n;j++)
31 | 			if (getchar()=='x')
32 | 			{
33 | 				c[i][j]=1;
34 | 				if (f[i][j]>8)
35 | 					k=1;
36 | 			}
37 | 		getchar();
38 | 	}
39 | 	for (i=1;i<=n;i++)
40 | 	{
41 | 		for (j=1;j<=n;j++)
42 | 		{
43 | 			if (f[i][j]>8 && k==1)
44 | 				putchar('*');
45 | 			else if (c[i][j]==1)
46 | 				putchar(f[i][j]+'0');
47 | 			else putchar('.');
48 | 		}
49 | 		putchar('\n');
50 | 	}
51 | 	return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/poj/2613.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int p,q,r,s,i;
 5 | 	double d;
 6 | 	while (scanf("%d%d%d%d",&p,&q,&r,&s)!=EOF)
 7 | 	{
 8 | 		if (q>p-q)
 9 | 			q=p-q;
10 | 		if (s>r-s)
11 | 			s=r-s;
12 | 		d=1.0;
13 | 		p++;
14 | 		r++;
15 | 		for (i=1;i<=q && i<=s;i++)
16 | 			d*=1.0*(p-i)/(r-i);
17 | 		while (i<=q)
18 | 		{
19 | 			d*=1.0*(p-i)/i;
20 | 			i++;
21 | 		}
22 | 		while (i<=s)
23 | 		{
24 | 			d*=1.0*i/(r-i);
25 | 			i++;
26 | 		}
27 | 		printf("%.5lf\n",d);
28 | 	}
29 | 	return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/poj/2623.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int median[125001],N;
 3 | void ADJUST(int i,int n)
 4 | {
 5 | 	int j=i<<1,temp=median[i];
 6 | 	while (j<=n)
 7 | 	{
 8 | 		if (j<n && median[j]<median[j+1])
 9 | 			j++;
10 | 		if (temp>=median[j])
11 | 			break;
12 | 		median[j>>1]=median[j];
13 | 		j=j<<1;
14 | 	}
15 | 	median[j>>1]=temp;
16 | }
17 | int main()
18 | {
19 | 	int i,j,n;
20 | 	double mid;
21 | 	scanf("%d",&N);
22 | 	if (N%2==0)
23 | 		n=N/2+1;
24 | 	else n=(N+1)/2;
25 | 	for (i=1;i<=n;i++)
26 | 		scanf("%d",&median[i]);
27 | 	for (i=n/2;i>0;i--)
28 | 		ADJUST(i,n);
29 | 	for (i=N-n;i>0;i--)
30 | 	{
31 | 		scanf("%d",&j);
32 | 		if (j<median[1])
33 | 		{
34 | 			median[1]=j;
35 | 			ADJUST(1,n);
36 | 		}
37 | 	}
38 | 	mid=(double)median[1];
39 | 	if (N%2==0)
40 | 	{
41 | 		if (median[2]>median[3])
42 | 			mid=(mid+median[2])/2;
43 | 		else mid=(mid+median[3])/2;
44 | 	}
45 | 	printf("%.1lf\n",mid);
46 | 	return 0;
47 | }
48 | 


--------------------------------------------------------------------------------
/poj/2624.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int i;
 5 | 	double d[8];
 6 | 	while (scanf("%lf",&d[0])!=EOF)
 7 | 	{
 8 | 		for (i=1;i<8;i++)
 9 | 			scanf("%lf",&d[i]);
10 | 		if (d[4]==d[2] && d[5]==d[3])
11 | 		{
12 | 			d[4]=(d[0]+d[6])/2;
13 | 			d[5]=(d[1]+d[7])/2;
14 | 			d[2]=d[4]+d[4]-d[2];
15 | 			d[3]=d[5]+d[5]-d[3];
16 | 			printf("%.3lf %.3lf\n",d[2],d[3]);
17 | 		}
18 | 		else if (d[4]==d[0] && d[5]==d[1])
19 | 		{
20 | 			d[4]=(d[2]+d[6])/2;
21 | 			d[5]=(d[3]+d[7])/2;
22 | 			d[0]=d[4]+d[4]-d[0];
23 | 			d[1]=d[5]+d[5]-d[1];
24 | 			printf("%.3lf %.3lf\n",d[0],d[1]);
25 | 		}
26 | 		else if (d[6]==d[0] && d[7]==d[1])
27 | 		{
28 | 			d[6]=(d[2]+d[4])/2;
29 | 			d[7]=(d[3]+d[5])/2;
30 | 			d[0]=d[6]+d[6]-d[0];
31 | 			d[1]=d[7]+d[7]-d[1];
32 | 			printf("%.3lf %.3lf\n",d[0],d[1]);
33 | 		}
34 | 		else{
35 | 			d[6]=(d[0]+d[4])/2;
36 | 			d[7]=(d[1]+d[5])/2;
37 | 			d[2]=d[6]+d[6]-d[2];
38 | 			d[3]=d[7]+d[7]-d[3];
39 | 			printf("%.3lf %.3lf\n",d[2],d[3]);
40 | 		}
41 | 	}
42 | 	return 0;
43 | }
44 | 


--------------------------------------------------------------------------------
/poj/2636.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i,j,x,s,r;
 5 | 	scanf("%d",&n);
 6 | 	for (i=0;i<n;i++)
 7 | 	{
 8 | 		scanf("%d",&x);
 9 | 		s=1-x;
10 | 		for (j=0;j<x;j++)
11 | 		{
12 | 			scanf("%d",&r);
13 | 			s+=r;
14 | 		}
15 | 		printf("%d\n",s);
16 | 	}
17 | 	return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/poj/2641.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<math.h>
 3 | int main ()
 4 | {
 5 | 	int a,b,s,m,n;
 6 | 	double y,x,angle,velocity;
 7 | 	scanf("%d%d%d%d%d",&a,&b,&s,&m,&n);
 8 | 	while (a!=0 || b!=0 || s!=0 || m!=0 || n!=0)
 9 | 	{
10 | 		x=(double)a*m;
11 | 		y=(double)b*n;
12 | 		angle=atan(y/x)*180/3.14159265358;
13 | 		velocity=sqrt(x*x+y*y)/s;
14 | 		printf("%.2lf %.2lf\n",angle,velocity);
15 | 		scanf("%d%d%d%d%d",&a,&b,&s,&m,&n);
16 | 	}
17 | 	return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/poj/2643.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int n,vote[20]={0};
 4 | char name[20][100],party[20][100],input[100];
 5 | int check()
 6 | {
 7 | 	int i;
 8 | 	for (i=0;i<n;i++)
 9 | 	{
10 | 		if (strcmp(input,name[i])==0)
11 | 			return i;
12 | 	}
13 | 	return -1;
14 | }
15 | int main ()
16 | {
17 | 	int i,j,c,m;
18 | 	scanf("%d\n",&n);
19 | 	for (i=0;i<n;i++)
20 | 	{
21 | 		gets(name[i]);
22 | 		gets(party[i]);
23 | 	}
24 | 	scanf("%d\n",&m);
25 | 	for (i=0;i<m;i++)
26 | 	{
27 | 		gets(input);
28 | 		j=check();
29 | 		if (j!=-1)
30 | 			vote[j]++;
31 | 	}
32 | 	j=0;
33 | 	c=1;
34 | 	for (i=1;i<n;i++)
35 | 	{
36 | 		if (vote[i]>vote[j])
37 | 			j=i,c=1;
38 | 		else if (vote[i]==vote[j])
39 | 			c=0;
40 | 	}
41 | 	if (c==0)
42 | 		printf("tie\n");
43 | 	else printf("%s\n",party[j]);
44 | 	return 0;
45 | }
46 | 


--------------------------------------------------------------------------------
/poj/2649.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<math.h>
 3 | int main ()
 4 | {
 5 | 	int n,m,t,i,j,s,k;
 6 | 	while (scanf("%d%d",&n,&m)!=EOF)
 7 | 	{
 8 | 		if (m==0)
 9 | 			printf("%d does not divide %d!\n",m,n);
10 | 		else if (m<=n)
11 | 			printf("%d divides %d!\n",m,n);
12 | 		else{
13 | 			t=(int)sqrt((double)m);
14 | 			s=m;
15 | 			k=0;
16 | 			for (i=2;s>1 && i<=t;i++)
17 | 			{
18 | 				if (s%i==0)
19 | 				{
20 | 					j=1;
21 | 					s/=i;
22 | 					while (s%i==0)
23 | 					{
24 | 						s/=i;
25 | 						j++;
26 | 					}
27 | 					if (n/i<j)
28 | 					{
29 | 						k=1;
30 | 						break;
31 | 					}
32 | 				}
33 | 			}
34 | 			if (s==m)
35 | 				k=1;
36 | 			if (k==1)
37 | 				printf("%d does not divide %d!\n",m,n);
38 | 			else printf("%d divides %d!\n",m,n);
39 | 		}
40 | 	}
41 | 	return 0;
42 | }
43 | 


--------------------------------------------------------------------------------
/poj/2656.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int i,n,d,v,a,b;
 5 | 	scanf("%d",&n);
 6 | 	while (n!=0)
 7 | 	{
 8 | 		v=-1;
 9 | 		for (i=1;i<=n;i++)
10 | 		{
11 | 			scanf("%d%d",&a,&b);
12 | 			if (a+b>v)
13 | 			{
14 | 				v=a+b;
15 | 				d=i;
16 | 			}
17 | 		}
18 | 		if (v<9)
19 | 			printf("0\n");
20 | 		else printf("%d\n",d);
21 | 		scanf("%d",&n);
22 | 	}
23 | 	return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/poj/2657.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | int main()
 3 | {
 4 | 	int i,j,k,l,n,m,z,a,b,qu[1000]={0};
 5 |     scanf("%d%d%d",&n,&z,&m);
 6 | 	for (i=0;i<m;i++)
 7 | 	{
 8 | 		scanf("%d",&j);
 9 | 		qu[i]=j;
10 | 	}
11 | 	for (i=1;i<z;i++)
12 | 	{
13 | 		for (j=0;j<i;j++)
14 | 		{
15 | 			k=j*n;
16 | 			if ((k+z-1)%i!=0)
17 | 				continue;
18 | 			for (a=0;a<j;a++)
19 | 			{
20 | 				b=a*n;
21 | 				for (l=0;l<m;l++)
22 | 					if ((b+qu[l]-1)%i==0)
23 | 						break;
24 | 				if (l<m)
25 | 					break;
26 | 			}
27 | 			if (a==j)
28 | 			{
29 | 				for (l=0;l<m;l++)
30 | 					if (qu[l]<z && (k+qu[l]-1)%i==0)
31 | 						break;
32 | 				if (l==m)
33 | 				{
34 | 					printf("%d\n",i);
35 | 					return 0;
36 | 				}
37 | 			}
38 | 		}
39 | 	}
40 | 	return 0;
41 | }
42 | 


--------------------------------------------------------------------------------
/poj/2661.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<math.h>
 3 | int main()
 4 | {
 5 | 	int l[21],i,j=1;
 6 | 	double r=log(2),p=4*r,s=0;
 7 | 	for (i=0;i<22;i++)
 8 | 	{
 9 | 		while(s<p)
10 | 			s+=log(j++);
11 | 		l[i]=j-2;
12 | 		p*=2;
13 | 	}
14 | 	scanf("%d",&i);
15 | 	while (i!=0)
16 | 	{
17 | 		printf("%d\n",l[(i-1960)/10]);
18 | 		scanf("%d",&i);
19 | 	}
20 | 	return 0;
21 | }
22 | 


--------------------------------------------------------------------------------
/poj/2663.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int tri(int n)
 3 | {
 4 | 	int sum=1,i,temp=3;
 5 | 	if (n==1)
 6 | 		return 3;
 7 | 	for(i=1;i<n;i++)
 8 | 	{
 9 | 		sum=sum+temp;
10 | 		temp=3*temp+2*(sum-temp);
11 | 	}
12 | 	return temp;
13 | }
14 | int main()
15 | {
16 | 	int input;
17 | 	scanf("%d",&input);
18 | 	while(input!=-1)
19 | 	{
20 | 		if(input%2==1)
21 | 			printf("0\n");
22 | 		else if (input==0)
23 | 			printf("1\n");
24 | 		else printf("%d\n",tri(input/2));
25 | 		scanf("%d",&input);
26 | 	}
27 | 	return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/poj/2665.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int l,m,i,a,b;
 5 | 	scanf("%d%d",&l,&m);
 6 | 	while (l!=0 || m!=0)
 7 | 	{
 8 | 		l++;
 9 | 		for (i=0;i<m;i++)
10 | 		{
11 | 			scanf("%d%d",&a,&b);
12 | 			l-=(b-a+1);
13 | 		}
14 | 		printf("%d\n",l);
15 | 		scanf("%d%d",&l,&m);
16 | 	}
17 | 	return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/poj/2666.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include<math.h>
 3 | #define PI 3.141592653589793
 4 | int main()
 5 | {
 6 | 	int Speed,Angle,Dis;
 7 | 	double Conver,X,Y;
 8 | 	while(scanf("%d%d%d",&Speed,&Angle,&Dis))
 9 | 	{    
10 | 		if(Speed==0)
11 | 			break;
12 | 		Conver=(double)Angle;
13 | 		Conver*=PI/180;
14 | 		Conver/=1.732050808;
15 | 		X=log((double)Dis);
16 | 		Y=X+Conver;
17 | 		X=exp(Y)-Dis;
18 | 		X/=Speed;
19 | 		if (X<=10000)
20 | 			printf("%d\n",(int)(0.5+X));
21 | 		else printf("God help me!\n");
22 | 	}
23 | 	return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/poj/2668.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	__int64 num;
 5 | 	int d,n,i,j,k;
 6 | 	scanf("%d%d",&d,&n);
 7 | 	while (d!=0 || n!=0)
 8 | 	{
 9 | 		num=0;
10 | 		for (i=1,k=n;i<=k;i++)
11 | 		{
12 | 			j=d/i;
13 | 			if (d%i!=0)
14 | 				j++;
15 | 			if (j!=i)
16 | 				num+=j;
17 | 			if (k>=j)
18 | 			{
19 | 				num+=(k-j+1)*i;
20 | 				k=j-1;
21 | 			}
22 | 		}
23 | 		printf("%I64d\n",num);
24 | 		scanf("%d%d",&d,&n);
25 | 	}
26 | 	return 0;
27 | }
28 | 


--------------------------------------------------------------------------------
/poj/2673.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int t,x,m,d,s,min=1000000,i,j;
 5 | 	scanf("%d%d%d",&t,&x,&m);
 6 | 	for (i=0;i<m;i++)
 7 | 	{
 8 | 		scanf("%d%d",&d,&s);
 9 | 		j=d/s;
10 | 		if (d%s==0)
11 | 			j--;
12 | 		if (j<min)
13 | 			min=j;
14 | 	}
15 | 	if (min<1)
16 | 		i=0;
17 | 	else if (min>t)
18 | 		i=t*x;
19 | 	else i=min*x+(t-min)/2*x;
20 | 	printf("%d\n",i);
21 | 	return 0;
22 | }
23 | 


--------------------------------------------------------------------------------
/poj/2680.java:
--------------------------------------------------------------------------------
 1 | //Main.java
 2 | import java.util.*;
 3 | import java.math.*;
 4 | 
 5 | public class Main {
 6 | 	public static void main(String[] args)
 7 | 	{
 8 | 		Scanner cin=new Scanner(System.in);
 9 |         BigInteger[] num=new BigInteger[1001];
10 |         BigInteger pow=new BigInteger("1");
11 |         BigInteger base=new BigInteger("2");
12 |         num[1]=new BigInteger("0");
13 |         num[2]=new BigInteger("1");
14 |         for (int i=3;i<=1000;i++)
15 |         {
16 |         	num[i]=num[i-2].add(pow);
17 |         	pow=pow.multiply(base);
18 |         }
19 |         while (cin.hasNextInt()==true)
20 |         {
21 |         	int in=cin.nextInt();
22 |         	System.out.println(num[in]);
23 |         }
24 | 	}
25 | }
26 | 


--------------------------------------------------------------------------------
/poj/2681.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int t[26],r[26];
 4 | char s[100];
 5 | int main()
 6 | {
 7 | 	int i,j,k,n;
 8 | 	scanf("%d\n",&n);
 9 | 	for (i=1;i<=n;i++)
10 | 	{
11 | 		memset(t,0,sizeof(int)*26);
12 | 		memset(r,0,sizeof(int)*26);
13 | 		gets(s);
14 | 		for (j=0;s[j]!='\0';j++)
15 | 			t[s[j]-'a']++;
16 | 		gets(s);
17 | 		for (j=0;s[j]!='\0';j++)
18 | 			r[s[j]-'a']++;
19 | 		for (j=0,k=0;j<26;j++)
20 | 			k+=(t[j]>r[j]) ? t[j]-r[j] : r[j]-t[j];
21 | 		printf("Case #%d:  %d\n",i,k);
22 | 	}
23 | 	return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/poj/2696.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int a,b,c,d,e,f,g,h,I;
 3 | int fun[1001];
 4 | int mod(int a,int b)
 5 | {
 6 | 	int c=a%b;
 7 | 	if (c<0)
 8 | 		c+=b;
 9 | 	return c;
10 | }
11 | int main()
12 | {
13 | 	int i,j,k,n;
14 | 	scanf("%d",&n);
15 | 	for (i=0;i<n;i++)
16 | 	{
17 | 		scanf("%d%d%d%d%d%d%d%d%d",&a,&b,&c,&d,&e,&f,&g,&h,&I);
18 | 		fun[0]=a;
19 | 		fun[1]=b;
20 | 		fun[2]=c;
21 | 		for (j=3;j<=I;j++)
22 | 		{
23 | 			if (j%2==1)
24 | 				fun[j]=mod(d*fun[j-1]+e*fun[j-2]-f*fun[j-3],g);
25 | 			else fun[j]=mod(f*fun[j-1]-d*fun[j-2]+e*fun[j-3],h);
26 | 		}
27 | 		printf("%d\n",fun[I]);
28 | 	}
29 | 	return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/poj/2707.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int a,b,c,d,t;
 5 | 	double e,f;
 6 | 	scanf("%d%d%d%d",&a,&b,&c,&d);
 7 | 	while (a!=0 || b!=0 || c!=0 || d!=0)
 8 | 	{
 9 | 		if (a<b)
10 | 		{
11 | 			t=b;
12 | 			b=a;
13 | 			a=t;
14 | 		}
15 | 		if (c<d)
16 | 		{
17 | 			t=d;
18 | 			d=c;
19 | 			c=t;
20 | 		}
21 | 		e=100.0*c/a;
22 | 		f=100.0*d/b;
23 | 		if (e>f)
24 | 			e=f;
25 | 		t=(int)e;
26 | 		if (t>100)
27 | 			t=100;
28 | 		printf("%d%%\n",t);
29 | 		scanf("%d%d%d%d",&a,&b,&c,&d);
30 | 	}
31 | 	return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/poj/2719.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,m,i,j,k;
 5 | 	scanf("%d",&n);
 6 | 	while (n!=0)
 7 | 	{
 8 | 		m=0;
 9 | 		i=1;
10 | 		j=n;
11 | 		while (j)
12 | 		{
13 | 			k=j%10;
14 | 			if (k>4)
15 | 				k--;
16 | 			m+=i*k;
17 | 			i*=9;
18 | 			j/=10;
19 | 		}
20 | 		printf("%d: %d\n",n,m);
21 | 		scanf("%d",&n);
22 | 	}
23 | 	return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/poj/2722.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<math.h>
 3 | int main()
 4 | {
 5 | 	int n,i;
 6 | 	double xa,ya,xb,yb,s,l,a;
 7 | 	scanf("%d",&n);
 8 | 	while (n!=0)
 9 | 	{
10 | 		s=0;
11 | 		l=0;
12 | 		scanf("%lf%lf%lf%lf",&xa,&ya,&xb,&yb);
13 | 		for (i=0;i<n;i++)
14 | 		{
15 | 			scanf("%lf",&a);
16 | 			l+=a;
17 | 			s+=a*a;
18 | 		}
19 | 		xa=xa/(xa+ya);
20 | 		ya=1-xa;
21 | 		xb=xb/(xb+yb);
22 | 		yb=1-xb;
23 | 		a=sqrt((xb-xa)*(xb-xa)+(yb-ya)*(yb-ya));
24 | 		l=l*l/a/1.414213562373095;
25 | 		s/=2;
26 | 		printf("%.3lf\n",l-s);
27 | 		scanf("%d",&n);
28 | 	}
29 | 	return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/poj/2739.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int p[1229]={2,3},i,j,s=2,n,m;
 5 | 	for (i=5;i<10000;i+=2)
 6 | 	{
 7 | 		for (j=1;j<s;j++)
 8 | 			if (i%p[j]==0)
 9 | 				break;
10 | 		if (j==s)
11 | 			p[s++]=i;
12 | 	}
13 | 	scanf("%d",&n);
14 | 	while (n!=0)
15 | 	{
16 | 		m=0;
17 | 		for (i=0,s=0,j=0;s<n;i++)
18 | 			s+=p[i];
19 | 		while (s>n)
20 | 			s-=p[j++];
21 | 		if (s==n)
22 | 			m++;
23 | 		for (;p[i]<=n;i++)
24 | 		{
25 | 			s+=p[i];
26 | 			while (s>n)
27 | 				s-=p[j++];
28 | 			if (s==n)
29 | 				m++;
30 | 		}
31 | 		printf("%d\n",m);
32 | 		scanf("%d",&n);
33 | 	}
34 | 	return 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/poj/2748.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int dp[75001]={0,1,2};
 3 | int main()
 4 | {
 5 | 	int i,n,m;
 6 | 	for (i=3;i<75001;i++)
 7 | 	{
 8 | 		dp[i]=3*dp[i-1]-dp[i-2];
 9 | 		if (dp[i]<0)
10 | 			dp[i]+=100000;
11 | 		dp[i]%=100000;
12 | 	}
13 | 	scanf("%d",&n);
14 | 	for (i=0;i<n;i++)
15 | 	{
16 | 		scanf("%d",&m);
17 | 		m%=75000;
18 | 		if (m==0)
19 | 			m=75000;
20 | 		printf("%d\n",dp[m]);
21 | 	}
22 | 	return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/poj/2752.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | #define MAX 400010
 4 | char P[MAX];
 5 | int Pi[MAX],queue[MAX],m;
 6 | void Compute_PREFIX(char *P,int m);
 7 | int main()
 8 | {
 9 | 	int i,j;
10 | 	while (scanf("%s",P)!=EOF)
11 | 	{
12 | 		m=strlen(P);
13 | 		Compute_PREFIX(P,m);
14 | 		j=0;
15 | 		i=m-1;
16 | 		while(Pi[i]>-1)
17 | 		{
18 | 			queue[j++]=Pi[i]+1;
19 | 			i=Pi[i];
20 | 		}
21 | 		for (i=j-1;i>=0;i--)
22 | 			printf("%d ",queue[i]);
23 | 		printf("%d\n",m);
24 | 	}
25 | 	return 0;
26 | }
27 | void Compute_PREFIX(char *P,int m)
28 | {
29 | 	int q,k=-1;
30 | 	Pi[0]=-1;
31 | 	for (q=1;q<m;q++)
32 | 	{
33 | 		while (k>-1 && P[k+1]!=P[q])
34 | 			k=Pi[k];
35 | 		if (P[k+1]==P[q])
36 | 			k++;
37 | 		Pi[q]=k;
38 | 	}
39 | }
40 | 


--------------------------------------------------------------------------------
/poj/2756.java:
--------------------------------------------------------------------------------
 1 | //Main.java
 2 | import java.io.*;
 3 | import java.util.*;
 4 | import java.math.*;
 5 | 
 6 | public class Main
 7 | {
 8 | 	public static void main(String args[]) throws Exception {
 9 | 		Scanner cin=new Scanner(System.in);
10 | 		int t = cin.nextInt();
11 | 		for (int i = 0; i < t; i++) {
12 | 			if (cin.hasNextBigInteger() == false)
13 | 				cin.skip("\\s\\D");
14 | 			BigInteger a = cin.nextBigInteger();
15 | 			if (cin.hasNextBigInteger() == false)
16 | 				cin.skip("\\s\\D");
17 | 			BigInteger b = cin.nextBigInteger();
18 | 			a = a.add(b);
19 | 			System.out.println(a);
20 | 		}
21 | 	}
22 | }
23 | 


--------------------------------------------------------------------------------
/poj/2769.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int main()
 4 | {
 5 | 	int n,m,i,k,x,s,d[300];
 6 | 	char f[40000]={0};
 7 | 	scanf("%d",&x);
 8 | 	for (k=0;k<x;k++)
 9 | 	{
10 | 		scanf("%d",&n);
11 | 		for (i=0;i<n;i++)
12 | 			scanf("%d",&d[i]);
13 | 		m=n;
14 | 		while (1)
15 | 		{
16 | 			for (i=0;i<n;i++)
17 | 			{
18 | 				s=d[i]%m;
19 | 				if (f[s]==1)
20 | 					break;
21 | 				f[s]=1;
22 | 			}
23 | 			if (i==n)
24 | 			{
25 | 				printf("%d\n",m);
26 | 				break;
27 | 			}
28 | 			memset(f,0,m);
29 | 			m++;
30 | 		}
31 | 		memset(f,0,m);	
32 | 	}
33 | 	return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/poj/2772.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,b,f,m,i,j,k,t,p[1000],x,y;
 5 | 	scanf("%d",&m);
 6 | 	for (i=0;i<m;i++)
 7 | 	{
 8 | 		scanf("%d%d%d",&n,&f,&b);
 9 | 		x=0;
10 | 		for (j=0;j<n;j++)
11 | 		{
12 | 			scanf("%d%d",&p[j],&y);
13 | 			if (p[j]==0 && y==0 && b>0)
14 | 			{
15 | 				b--;
16 | 				y=1;
17 | 			}
18 | 			if (y==1)
19 | 			{
20 | 				if (f-p[j]>x)
21 | 					x=f-p[j];
22 | 				p[j]=2*f-p[j];
23 | 			}
24 | 		}
25 | 		t=b/n*2*f;
26 | 		b%=n;
27 | 		if (b!=0)
28 | 		{
29 | 			for (j=0;j<b;j++)
30 | 			{
31 | 				for (k=j+1;k<n;k++)
32 | 				{
33 | 					if (p[j]>p[k])
34 | 					{
35 | 						y=p[k];
36 | 						p[k]=p[j];
37 | 						p[j]=y;
38 | 					}
39 | 				}
40 | 			}
41 | 			t+=p[b-1]+f;
42 | 		}
43 | 		else t+=x;
44 | 		printf("%d\n",t);
45 | 	}
46 | 	return 0;
47 | }
48 | 


--------------------------------------------------------------------------------
/poj/2773.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int m,k,f[10],euler,r,i,j,t,x,n;
 5 | 	while (scanf("%d%d",&m,&k)!=EOF)
 6 | 	{
 7 | 		x=m;
 8 | 		euler=m;
 9 | 		if (x%2==0)
10 | 		{
11 | 			f[0]=2;
12 | 			euler/=2;
13 | 			do{
14 | 				x/=2;
15 | 			}while(x%2==0);
16 | 			r=1;
17 | 		}
18 | 		else r=0;
19 | 		for (i=3;x>1;i+=2)
20 | 		{
21 | 			if (x%i==0)
22 | 			{
23 | 				f[r++]=i;
24 | 				euler-=euler/i;
25 | 				do{
26 | 					x/=i;
27 | 				}while(x%i==0);
28 | 			}
29 | 		}
30 | 		if (r==0)
31 | 		{
32 | 			f[r++]=m;
33 | 			if (m!=1)
34 | 				euler--;
35 | 		}
36 | 		n=k/euler*m;
37 | 		k%=euler;
38 | 		if (k==0)
39 | 		{
40 | 			k=euler;
41 | 			n-=m;
42 | 		}
43 | 		t=1;
44 | 		for (i=1;i<k;i++)
45 | 		{
46 | 			t++;
47 | 			while (1)
48 | 			{
49 | 				for (j=0;j<r;j++)
50 | 				{
51 | 					if (t%f[j]==0)
52 | 						break;
53 | 				}
54 | 				if (j==r)
55 | 					break;
56 | 				t++;
57 | 			}
58 | 		}
59 | 		printf("%d\n",n+t);
60 | 	}
61 | 	return 0;
62 | }
63 | 


--------------------------------------------------------------------------------
/poj/2840.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int i,j,n,p,q;
 5 | 	char s[6];
 6 | 	scanf("%d",&n);
 7 | 	for (i=0;i<n;i++)
 8 | 	{
 9 | 		p=0;
10 | 		q=0;
11 | 		scanf("%s",s);
12 | 		for (j=0;s[j]!=':';j++)
13 | 			p=p*10+s[j]-'0';
14 | 		for (j++;s[j]!='\0';j++)
15 | 			q=q*10+s[j]-'0';
16 | 		if (q==0)
17 | 		{
18 | 			p+=12;
19 | 			printf("%d\n",p%24==0 ? 24 : p%24);
20 | 		}
21 | 		else printf("0\n");
22 | 	}
23 | 	return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/poj/2853.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int m,i,s;
 5 | 	unsigned n,j;
 6 | 	scanf("%d",&m);
 7 | 	for (i=1;i<=m;i++)
 8 | 	{
 9 | 		s=0;
10 | 		scanf("%d%d",&j,&n);
11 | 		for (j=2;j*j+j<=2*n;j+=2)
12 | 			if (n%j!=0 && n%(j/2)==0)
13 | 				s++;
14 | 		for (j=3;j*j+j<=2*n;j+=2)
15 | 			if (n%j==0)
16 | 				s++;
17 | 		printf("%d %d\n",i,s);
18 | 	}
19 | 	return 0;
20 | }
21 | 


--------------------------------------------------------------------------------
/poj/2864.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | bool student[500][100];
 3 | int main()
 4 | {
 5 | 	int i, j, n, d;
 6 | 	scanf("%d%d", &n, &d);
 7 | 	while (n != 0 || d != 0)
 8 | 	{
 9 | 		for (i = 0; i < d; i++)
10 | 			for (j = 0; j < n; j++)
11 | 				scanf("%d", &student[i][j]);
12 | 		for (j = 0; j < n; j++)
13 | 		{
14 | 			for (i = 0; i < d; i++)
15 | 				if (student[i][j] == false)
16 | 					break;
17 | 			if (i == d)
18 | 				break;
19 | 		}
20 | 		if (j < n)
21 | 			printf("yes\n");
22 | 		else printf("no\n");
23 | 		scanf("%d%d", &n, &d);
24 | 	}
25 | 	return 0;
26 | }
27 | 


--------------------------------------------------------------------------------
/poj/2871.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	double t1,t2;
 5 | 	scanf("%lf%lf",&t1,&t2);
 6 | 	while (t2-999>0.0000001 || t2-999<-0.0000001)
 7 | 	{
 8 | 		printf("%.2lf\n",t2-t1);
 9 | 		t1=t2;
10 | 		scanf("%lf",&t2);
11 | 	}
12 | 	printf("End of Output\n");
13 | 	return 0;
14 | }
15 | 


--------------------------------------------------------------------------------
/poj/2876.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int base[13]={0,1,3,9,27,81,243,729,2187,6561,19683,59049,177147};
 3 | void print(int p)
 4 | {
 5 | 	int i;
 6 | 	if (p==0)
 7 | 		putchar('-');
 8 | 	else {
 9 | 		print(p-1);
10 | 		for (i=base[p];i>0;i--)
11 | 			putchar(' ');
12 | 		print(p-1);
13 | 	}
14 | }
15 | int main()
16 | {
17 | 	int n;
18 | 	while (scanf("%d",&n)!=EOF)
19 | 	{
20 | 		print(n);
21 | 		putchar('\n');
22 | 	}
23 | 	return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/poj/2894.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int t,n;
 4 | int count[2000];
 5 | int main()
 6 | {
 7 | 	int i,j,k,a,b;
 8 | 	char c;
 9 | 	scanf("%d",&t);
10 | 	for (i=0;i<t;i++)
11 | 	{
12 | 		scanf("%d\n",&n);
13 | 		memset(count,0,sizeof(count));
14 | 		for (j=0;j<n;j++)
15 | 		{
16 | 			scanf("%c%d%d\n",&c,&a,&b);
17 | 			for (k=a;k<b;k++)
18 | 				count[k]++;
19 | 		}
20 | 		for (j=0;j<=1000;j++)
21 | 			if (count[j]!=0)
22 | 				putchar(count[j]+'A'-1);
23 | 		putchar('\n');
24 | 	}
25 | 	return 0;
26 | }
27 | 


--------------------------------------------------------------------------------
/poj/2897.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int t,n,k,i,j,a[100],c;
 5 | 	scanf("%d",&t);
 6 | 	for (i=0;i<t;i++)
 7 | 	{
 8 | 		scanf("%d%d",&n,&k);
 9 | 		if (n>k)
10 | 			printf("0");
11 | 		else if (n==1)
12 | 			printf("%d",k);
13 | 		else {
14 | 			a[0]=k/n;
15 | 			c=k%n*10+a[0];
16 | 			j=1;
17 | 			while (j<100)
18 | 			{
19 | 				a[j]=c/n;
20 | 				if (a[j]==k && c%n==0)
21 | 					break;
22 | 				c=c%n*10+a[j];
23 | 				j++;
24 | 			}
25 | 			for (k=0;k<=j;k++)
26 | 				printf("%d",a[k]);
27 | 		}
28 | 		printf("\n");
29 | 	}
30 | 	return 0;
31 | }
32 | 


--------------------------------------------------------------------------------
/poj/2909.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int i,j,k,n,q=1,r,m,s;
 5 | 	short p[3504]={3};
 6 | 	for (i=5;i<32679;i+=2)
 7 | 	{
 8 | 		for (j=0;j<q;j++)
 9 | 			if (i%p[j]==0)
10 | 				break;
11 | 		if (j==q)
12 | 			p[q++]=i;
13 | 	}
14 | 	scanf("%d",&n);
15 | 	while (n!=0)
16 | 	{
17 | 		r=0;
18 | 		if (n==4)
19 | 			printf("1\n");
20 | 		else{
21 | 			for (i=0;p[i]*2<=n;i++)
22 | 			{
23 | 				s=n-p[i];
24 | 				for (k=i,j=q-1;k<=j;)
25 | 				{
26 | 					m=(k+j)/2;
27 | 					if (p[m]<s)
28 | 						k=m+1;
29 | 					else if (p[m]>s)
30 | 						j=m-1;
31 | 					else {
32 | 						r++;
33 | 						break;
34 | 					}
35 | 				}
36 | 			}
37 | 			printf("%d\n",r);
38 | 		}
39 | 		scanf("%d",&n);
40 | 	}
41 | 	return 0;
42 | }
43 | 


--------------------------------------------------------------------------------
/poj/2924.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int t,i;
 5 | 	__int64 n,m;
 6 | 	scanf("%d",&t);
 7 | 	for (i=1;i<=t;i++)
 8 | 	{
 9 | 		scanf("%I64d%I64d",&n,&m);
10 | 		printf("Scenario #%d:\n%I64d\n\n",i,(n+m)*(m+1-n)/2);
11 | 	}
12 | 	return 0;
13 | }
14 | 


--------------------------------------------------------------------------------
/poj/2940.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | short greedy[100000];
 3 | int main()
 4 | {
 5 | 	int n,i,max;
 6 | 	__int64 sum;
 7 | 	scanf("%d",&n);
 8 | 	while (n!=0)
 9 | 	{
10 | 		for (i=0;i<n;i++)
11 | 			scanf("%d",&greedy[i]);
12 | 		sum=0;
13 | 		max=0;
14 | 		for (i=0;i<n;i++)
15 | 		{
16 | 			max+=greedy[i];
17 | 			if (max>0)
18 | 				sum+=max;
19 | 			else sum-=max;
20 | 		}
21 | 		printf("%I64d\n",sum);
22 | 		scanf("%d",&n);
23 | 	}
24 | 	return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/poj/2959.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<math.h>
 3 | int main()
 4 | {
 5 | 	int n,i,m;
 6 | 	double D,d,s;
 7 | 	scanf("%d",&n);
 8 | 	for (i=0;i<n;i++)
 9 | 	{
10 | 		scanf("%lf%lf%lf",&D,&d,&s);
11 | 		D=3.1415926/asin((s+d)/(D-d));
12 | 		printf("%d\n",(int)D);
13 | 	}
14 | 	return 0;
15 | }
16 | 


--------------------------------------------------------------------------------
/poj/2992.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int p[83]={2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431};
 3 | int d[432][83]={0},m=0;
 4 | void divisors(int n)
 5 | {
 6 | 	int i=n,j;
 7 | 	for (j=0;n>1;j++)
 8 | 	{
 9 | 		while (n%p[j]==0)
10 | 		{
11 | 			d[i][j]++;
12 | 			n/=p[j];
13 | 		}
14 | 	}
15 | 	if (j>m)
16 | 		m=j;
17 | }
18 | int main()
19 | {
20 | 	int i,k,l,n;
21 | 	__int64 j;
22 | 	for (i=2;i<432;i++)
23 | 	{
24 | 		for (j=0,k=i-1;j<m;j++)
25 | 			d[i][j]=d[k][j];
26 | 		divisors(i);
27 | 	}
28 | 	while (scanf("%d%d",&n,&k)!=EOF)
29 | 	{
30 | 		l=n-k;
31 | 		for (i=0,j=1;i<83;i++)
32 | 			j*=(d[n][i]-d[k][i]-d[l][i]+1);
33 | 		printf("%I64d\n",j);
34 | 	}
35 | 	return 0;
36 | }
37 | 


--------------------------------------------------------------------------------
/poj/3002.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/snuc/poj/80cccc7287f23d33cde75b51a78a04bdb75408cb/poj/3002.c


--------------------------------------------------------------------------------
/poj/3006.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | bool f[1000000]={true,true};
 3 | int main()
 4 | {
 5 | 	int i,j,a,d,n;
 6 | 	for (i=2;i<=1000;i++)
 7 | 	{
 8 | 		if (f[i]==true)
 9 | 			continue;
10 | 		for (j=i*i;j<1000000;j+=i)
11 | 			f[j]=true;
12 | 	}
13 | 	scanf("%d%d%d",&a,&d,&n);
14 | 	while (a!=0 || d!=0 || n!=0)
15 | 	{
16 | 		for (i=0,j=a;i<n;j+=d)
17 | 			if (f[j]==false)
18 | 				i++;
19 | 		printf("%d\n",j-d);
20 | 		scanf("%d%d%d",&a,&d,&n);
21 | 	}
22 | 	return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/poj/3012.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	__int64 n,k,sm;
 5 | 	__int64 m,o,base,ans,p;
 6 | 	int t;
 7 | 	scanf("%d",&t);
 8 | 	while(t--)
 9 | 	{
10 | 		scanf("%I64d%I64d%I64d",&n,&k,&sm);
11 | 		m=sm;
12 | 		o=1;
13 | 		ans=1;
14 | 		p=k;
15 | 		for(base=10;p;p/=2,base=(base*base)%m)
16 | 			if (p&1) 
17 | 				o=(o*base)%m;
18 | 		o=(o+1)%m;
19 | 		p=n;
20 | 		for(base=o;p;p/=2,base=(base*base)%m)
21 | 			if (p&1)
22 | 				ans=(ans*base)%m;
23 | 		printf("%I64d\n",ans);
24 | 	}
25 | 	return 0;
26 | }
27 | 


--------------------------------------------------------------------------------
/poj/3027.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int base(int p,int a,int b)
 3 | {
 4 | 	int i,j=p,k,s=0;
 5 | 	for (i=0,k=1;j>0;i++)
 6 | 	{
 7 | 		s+=j%a*k;
 8 | 		j/=a;
 9 | 		k=k*b;
10 | 	}
11 | 	if (s%p==0)
12 | 		return 1;
13 | 	return 0;
14 | }
15 | int main()
16 | {
17 | 	int i,j,n,a,b,x,y;
18 | 	scanf("%d",&n);
19 | 	for (i=0;i<n;i++)
20 | 	{
21 | 		scanf("%d%d%d%d",&a,&b,&x,&y);
22 | 		for (j=y-1;j>x;j--)
23 | 		{
24 | 			if (base(j,a,b))
25 | 			{
26 | 				printf("%d\n",j);
27 | 				break;
28 | 			}
29 | 		}
30 | 		if (j==x)
31 | 			printf("Non-existent.\n");
32 | 	}
33 | 	return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/poj/3030.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int i,n,a,b,c;
 5 | 	scanf("%d",&n);
 6 | 	for (i=0;i<n;i++)
 7 | 	{
 8 | 		scanf("%d%d%d",&a,&b,&c);
 9 | 		a+=c;
10 | 		if (a==b)
11 | 			printf("does not matter\n");
12 | 		else if (a<b)
13 | 			printf("advertise\n");
14 | 		else printf("do not advertise\n");
15 | 	}
16 | 	return 0;
17 | }
18 | 


--------------------------------------------------------------------------------
/poj/3032.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int c[14],p[14];
 5 | 	int t,n,i,j,k,s,h,r;
 6 |     scanf("%d",&t);
 7 |     for(i=0;i<t;i++)
 8 |     {
 9 |         scanf("%d",&n);
10 |         for(j=1;j<=n-1;j++)
11 | 			p[j]=j+1;
12 |         s=1;
13 |         h=1;
14 |         r=n;
15 |         for(k=1;k<=n;k++)
16 |         {
17 |             for(j=1;j<=k;j++)
18 |             {
19 |                 p[r]=h;
20 |                 h=p[h];
21 |                 r=p[r];
22 |             }
23 |             c[h]=k;
24 |             h=p[h];
25 |         }
26 |         for(j=1;j<=n;j++)
27 |             printf("%d ",c[j]);
28 |         printf("\n");
29 |     }
30 | 	return 0;
31 | }
32 | 


--------------------------------------------------------------------------------
/poj/3036.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #define MAX 25
 3 | int flag1[MAX][MAX]={0},n;
 4 | int flag2[MAX][MAX]={0};
 5 | void sign (int a, int b)
 6 | {
 7 | 	flag1[a-1][b-1]+=flag2[a][b];
 8 | 	flag1[a-1][b]+=flag2[a][b];
 9 | 	flag1[a][b-1]+=flag2[a][b];
10 | 	flag1[a][b+1]+=flag2[a][b];
11 | 	flag1[a+1][b]+=flag2[a][b];
12 | 	flag1[a+1][b+1]+=flag2[a][b];
13 | }
14 | void copy ()
15 | {
16 | 	int i,j;
17 | 	for (i=0;i<MAX;i++)
18 | 		for (j=0;j<MAX;j++)
19 | 			flag2[i][j]=flag1[i][j];
20 | }
21 | void search ()
22 | {
23 | 	int i,j;
24 | 	for (i=0;i<MAX;i++)
25 | 		for (j=0;j<MAX;j++)
26 | 			if (flag2[i][j]!=0)
27 |                 sign(i,j);
28 | 	copy();
29 | 	memset(flag1,0,sizeof(flag1));
30 | }
31 | void solve ()
32 | {
33 | 	int i;
34 | 	flag2[n][n]=1;
35 | 	sign(n,n);
36 | 	copy();
37 | 	memset(flag1,0,sizeof(flag1));
38 | 	for (i=2;i<=n;i++)
39 | 		search();
40 | 	printf("%d\n",flag2[n][n]);
41 | }
42 | int main ()
43 | {
44 | 	int i,t;
45 | 	scanf("%d",&t);
46 |     for (i=0;i<t;i++)
47 | 	{
48 | 		scanf("%d",&n);
49 | 		solve();
50 | 	}
51 | 	return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/poj/3039.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<math.h>
 3 | int n,d,r,s,t,i;
 4 | double min;
 5 | int main()
 6 | {
 7 |     scanf("%d%d",&n,&d);
 8 |     min=32767;
 9 |     for(i=1;i<=32767;i++)
10 |     {
11 |         r=floor(i*1.0*n/d+0.5);
12 |         if(r*d==n*i)
13 |         {
14 |             if(fabs((r+1)*1.0/i-n*1.0/d)>fabs((r-1)*1.0/i-n*1.0/d)) 
15 | 				r++;
16 |             else r--;
17 |         }
18 |         if(fabs(r*1.0/i-n*1.0/d)<min)
19 |         {
20 |             min=fabs(r*1.0/i-n*1.0/d);
21 |             t=r;
22 |             s=i;
23 |         }
24 |     }
25 |     printf("%d %d\n",t,s);
26 | 	return 0;
27 | }
28 | 


--------------------------------------------------------------------------------
/poj/3044.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #define MAX 50005
 3 | int main ()
 4 | {
 5 | 	long stack[MAX]={0};
 6 | 	long n,w,i;
 7 | 	long t=0,count=0;
 8 | 	long a,b;
 9 | 	scanf("%ld%ld", &n, &w);
10 | 	for (i=0;i<n;i++)
11 | 	{
12 | 		scanf("%ld%ld",&a,&b);
13 | 		while (b<stack[t])
14 | 		{
15 | 			t--;
16 | 			count++;
17 | 		}
18 | 		if (b>stack[t]) 
19 | 			stack[++t]=b;
20 | 	}
21 | 	b=0;
22 |     while (b<stack[t] && t!=-1)
23 | 	{
24 | 		t--;
25 | 		count++;
26 | 	}
27 | 	printf("%ld\n",count);
28 | 	return 0;
29 | }
30 | 


--------------------------------------------------------------------------------
/poj/3046.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int family[1001]={0};
 4 | int coefficient[100001]={0};
 5 | int temp[100001];
 6 | int T,A,S,B,Q;
 7 | void multiply(int p)
 8 | {
 9 | 	int i,j,k;
10 | 	for (i=0;i<=Q;i++)
11 | 		temp[i]=coefficient[i];
12 | 	for (i=1;i<=family[p];i++)
13 | 	{
14 | 		for (j=0;j<=Q;j++)
15 | 			temp[j+i]+=coefficient[j];
16 | 	}
17 | 	if (Q<B)
18 | 		Q+=family[p];
19 | 	else Q=B;
20 | 	for (i=0;i<=Q;i++)
21 | 		coefficient[i]=temp[i]%1000000;
22 | }
23 | int main()
24 | {
25 | 	int i,j;
26 | 	scanf("%d%d%d%d",&T,&A,&S,&B);
27 | 	for (i=0;i<A;i++)
28 | 	{
29 | 		scanf("%d",&j);
30 | 		family[j]++;
31 | 	}
32 | 	Q=family[1];
33 | 	for (i=0;i<=Q;i++)
34 | 		coefficient[i]=1;
35 | 	for (i=2;i<=T;i++)
36 | 		multiply(i);
37 | 	for (i=S,j=0;i<=B;i++)
38 | 	{
39 | 		j+=coefficient[i];
40 | 		j%=1000000;
41 | 	}
42 | 	printf("%d\n",j);
43 | 	return 0;
44 | }
45 | 


--------------------------------------------------------------------------------
/poj/3047.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int y,m,d,a[12]={31,28,31,30,31,30,31,31,30,31,30,31},i,j,sum;
 5 | 	scanf("%d%d%d",&y,&m,&d);
 6 | 	sum=y*365-365;
 7 | 	sum+=(y-1)/4-(y-1)/100+(y-1)/400;
 8 | 	for(j=0;j<m-1;j++)
 9 | 		sum+=a[j];
10 | 	if (m>2 && ((y%4==0 && y%100!=0) || y%400==0))
11 | 		sum++;
12 | 	sum+=d-1;
13 | 	sum%=7;
14 | 	switch(sum)
15 | 	{
16 | 		case 0:printf("monday\n");break;
17 | 		case 1:printf("tuesday\n");break;
18 | 		case 2:printf("wednesday\n");break;
19 | 		case 3:printf("thursday\n");break;
20 | 		case 4:printf("friday\n");break;
21 | 		case 5:printf("saturday\n");break;
22 | 		case 6:printf("sunday\n");break;
23 | 	}
24 | 	return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/poj/3048.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int prime(int p)
 3 | {
 4 | 	int max=1,i=2;
 5 | 	while (p!=1)
 6 | 	{
 7 | 		while (p%i==0)
 8 | 		{
 9 | 			max=i;
10 | 			p/=i;
11 | 		}
12 | 		i++;
13 | 	}
14 | 	return max;
15 | }
16 | int main()
17 | {
18 | 	int n,i,j,m,num,max;
19 | 	scanf("%d",&n);
20 | 	scanf("%d",&m);
21 | 	max=prime(m);
22 | 	for (i=1;i<n;i++)
23 | 	{
24 | 		scanf("%d",&j);
25 | 		num=prime(j);
26 | 		if (num>max)
27 | 		{
28 | 			max=num;
29 | 			m=j;
30 | 		}
31 | 	}
32 | 	printf("%d\n",m);
33 | 	return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/poj/3051.cpp:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int w,h,num,max;
 3 | char farm[1000][80];
 4 | void dfs(int i,int j)
 5 | {
 6 | 	num++;
 7 | 	farm[i][j]='.';
 8 | 	if (i>0 && farm[i-1][j]=='*')
 9 | 		dfs(i-1,j);
10 | 	if (i<h-1 && farm[i+1][j]=='*')
11 | 		dfs(i+1,j);
12 | 	if (j>0 && farm[i][j-1]=='*')
13 | 		dfs(i,j-1);
14 | 	if (j<w-1 && farm[i][j+1]=='*')
15 | 		dfs(i,j+1);
16 | }
17 | int main()
18 | {
19 | 	int i,j;
20 | 	scanf("%d%d",&w,&h);
21 | 	for (i=0;i<h;i++)
22 | 		scanf("%s",farm[i]);
23 | 	max=0;
24 | 	for (i=0;i<h;i++)
25 | 	{
26 | 		for (j=0;j<w;j++)
27 | 		{
28 | 			if (farm[i][j]=='*')
29 | 			{
30 | 				num=0;
31 | 				dfs(i,j);
32 | 				if (num>max)
33 | 					max=num;
34 | 			}
35 | 		}
36 | 	}
37 | 	printf("%d\n",max);
38 | 	return 0;
39 | }
40 | 


--------------------------------------------------------------------------------
/poj/3060.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int same[1000][1000];
 4 | int main()
 5 | {
 6 | 	int dx[1000],dy[1000],x,y,i,j,k,d,n,t,min;
 7 | 	scanf("%d",&t);
 8 | 	for (i=0;i<t;i++)
 9 | 	{
10 | 		memset(dx,0,sizeof(dx));
11 | 		memset(dy,0,sizeof(dy));
12 | 		memset(same,0,sizeof(same));
13 | 		scanf("%d%d",&d,&n);
14 | 		for (j=0;j<n;j++)
15 | 		{
16 | 			scanf("%d%d",&x,&y);
17 | 			x+=1000000000;
18 | 			y+=1000000000;
19 | 			x=x%d;
20 | 			y=y%d;
21 | 			same[x][y]++;
22 | 			dx[x]++;
23 | 			dy[y]++;
24 | 		}
25 | 		min=n;
26 | 		for (j=0;j<d;j++)
27 | 		{
28 | 			for (k=0;k<d;k++)
29 | 				if ((x=dx[j]+dy[k]-same[j][k])<min)
30 | 					min=x;
31 | 		}
32 | 		printf("%d\n",min);
33 | 	}
34 | 	return 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/poj/3061.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int n,S,sum,min;
 3 | short sen[100000];
 4 | int main()
 5 | {
 6 | 	int i,j,k,t;
 7 | 	scanf("%d",&t);
 8 | 	for (i=0;i<t;i++)
 9 | 	{
10 | 		scanf("%d%d",&n,&S);
11 | 		for (j=0,k=0;j<n;j++)
12 | 		{
13 | 			scanf("%d",&sen[j]);
14 | 			k+=sen[j];
15 | 		}
16 | 		if (S>k)
17 | 			printf("0\n");
18 | 		else if (S==k)
19 | 			printf("%d\n",n);
20 | 		else{
21 | 			j=0;
22 | 			k=0;
23 | 			sum=0;
24 | 			min=n;
25 | 			while (k<n)
26 | 			{
27 | 				while (sum<S)
28 | 					sum+=sen[k++];
29 | 				while (sum-sen[j]>=S)
30 | 					sum-=sen[j++];
31 | 				if (k-j<min)
32 | 					min=k-j;
33 | 				sum-=sen[j++];
34 | 			}
35 | 			printf("%d\n",min);
36 | 		}
37 | 	}
38 | 	return 0;
39 | }
40 | 


--------------------------------------------------------------------------------
/poj/3062.c:
--------------------------------------------------------------------------------
1 | #include<stdio.h>
2 | int main()
3 | {
4 | 	char str[10000];
5 | 	while (gets(str)!=NULL)
6 | 		printf("%s\n",str);
7 | 	return 0;
8 | }
9 | 


--------------------------------------------------------------------------------
/poj/3066.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | double A,B,re,su,lt,r,s;
 3 | int main()
 4 | {
 5 | 	int m,p,a,b,x,y,i;
 6 | 	while (scanf("%d%d%d%d",&m,&p,&a,&b)!=EOF)
 7 | 	{
 8 | 		p/=2;
 9 | 		x=(m-b)*a/(1+a);
10 | 		x-=x%a;
11 | 		y=b+x/a;
12 | 		i=m-x-y-1;
13 | 		A=(double)i*i/a;
14 | 		B=A;
15 | 		x=m-y-1;
16 | 		r=1.0/a;
17 | 		re=r;
18 | 		su=(double)a;
19 | 		s=su;
20 | 		for (i=1;i<p;i++)
21 | 		{
22 | 			re*=r;
23 | 			su*=s;
24 | 			B*=A;
25 | 		}
26 | 		lt=(double)x*re+(double)y*su+B;
27 | 		printf("%.0lf\n",lt);
28 | 	}	
29 | 	return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/poj/3069.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | int position[1000];
 4 | int cmp(const void *a,const void *b)
 5 | {
 6 | 	int x,y;
 7 | 	x=*(int *)a;
 8 | 	y=*(int *)b;
 9 | 	if (x<y)
10 | 		return -1;
11 | 	else if (x>y)
12 | 		return 1;
13 | 	else return 0;
14 | }
15 | int main()
16 | {
17 | 	int i,j,n,r,num;
18 | 	scanf("%d%d",&r,&n);
19 | 	while (r!=-1 || n!=-1)
20 | 	{
21 | 		for (i=0;i<n;i++)
22 | 			scanf("%d",&position[i]);
23 | 		qsort(position,n,sizeof(position[0]),cmp);
24 | 		num=0;
25 | 		for (i=0;i<n;)
26 | 		{
27 | 			for (j=i+1;j<n;j++)
28 | 			{
29 | 				if (position[j]-position[i]>r)
30 | 					break;
31 | 			}
32 | 			i=j-1;
33 | 			num++;
34 | 			for (j=i+1;j<n;j++)
35 | 			{
36 | 				if (position[j]-position[i]>r)
37 | 					break;
38 | 			}
39 | 			i=j;
40 | 		}
41 | 		printf("%d\n",num);
42 | 		scanf("%d%d",&r,&n);
43 | 	}
44 | 	return 0;
45 | }
46 | 


--------------------------------------------------------------------------------
/poj/3070.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int f[100008];
 3 | int main()
 4 | {
 5 | 	long n,i,j;
 6 | 	int ok=0;
 7 | 	f[0]=0;
 8 | 	f[1]=1;
 9 | 	for (i=2;i<=100000;i++)
10 | 	{
11 | 		f[i]=(f[i-1]+f[i-2])%10000;
12 | 		for (j=0;j<i-1;j++)
13 | 		{
14 | 			if (f[j]==f[i-1] && f[i]==f[j+1])
15 | 			{
16 | 				ok=1;
17 | 				break;
18 | 			}
19 | 		}
20 | 		if (ok) break;
21 | 	}
22 |     while (scanf("%ld",&n),n!=-1)
23 |         printf("%d\n",f[n%15000]);
24 | 	return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/poj/3077.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int main()
 4 | {
 5 | 	int t,u,i,j,len;
 6 | 	char s[100];
 7 | 	char tmp;
 8 | 	scanf("%d",&t);
 9 | 	for (u=0;u<t;u++)
10 | 	{
11 | 		scanf("%s",s);
12 | 		len=strlen(s);
13 | 		for (i=0,j=len-1;i<=j;i++,j--)
14 | 		{
15 | 			tmp=s[i];
16 | 			s[i]=s[j];
17 |             s[j]=tmp;
18 | 		}
19 | 		for (i=0;i<len-1;i++)
20 | 		{
21 | 			if (s[i]>'4') 
22 | 				s[i+1]++;
23 | 			s[i]='0';
24 | 		}
25 | 		if (s[len-1]=='9'+1) 
26 | 			printf("10");
27 | 		else putchar(s[len-1]);
28 | 		for (i=len-2;i>=0;i--) 
29 | 			putchar (s[i]);
30 | 		putchar ('\n');
31 | 	}
32 | 	return 0;
33 | }
34 | 


--------------------------------------------------------------------------------
/poj/3078.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | char s[30][100];
 4 | char ans[30][100];
 5 | int pos[30], sign[30], q[30];
 6 | int main()
 7 | {
 8 | 	int t, u, tt;
 9 | 	int i;
10 | 	int n, m, a, b;
11 | 	scanf ("%d", &tt);
12 | 	for (u = 0; u < tt; u++)
13 | 	{
14 | 		memset (pos, 0, sizeof (pos));
15 | 		memset (sign, 0, sizeof (sign));
16 | 		scanf ("%d%d", &n, &m);
17 | 		for (i = 1; i <= n; i++) scanf ("%s", s[i]);
18 | 		for (i = 0; i < m; i++)
19 | 		{
20 | 			scanf ("%d%d", &a, &b);
21 | 			pos[a] = b;
22 | 			sign[b] = 1;
23 | 		}
24 | 		t = 0;
25 | 		for (i = 1; i <= n; i++)
26 | 			if (!sign[i]) q[t++] = i;
27 | 		t = 0;
28 | 		for (i = 1; i <= n; i++)
29 | 			if (pos[i] == 0) pos[i] = q[t++];
30 | 		for (i = 1; i <= n; i++)
31 | 			strcpy (ans[pos[i]], s[i]);
32 | 		for (i = 1; i <= n; i++)
33 | 			printf ("%s ", ans[i]);
34 | 		printf ("\n");
35 | 	}
36 | 	return 0;
37 | }
38 | 


--------------------------------------------------------------------------------
/poj/3085.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int n, i, m;
 5 | 	scanf("%d", &n);
 6 | 	for (i = 1; i <= n; i++)
 7 | 	{
 8 | 		scanf("%d", &m);
 9 | 		printf("%d %d QUARTER(S), ", i, m / 25);
10 | 		m -= m / 25 * 25;
11 | 		printf("%d DIME(S), ", m / 10);
12 | 		m -= m / 10 * 10;
13 | 		printf("%d NICKEL(S), ", m / 5);
14 | 		m -= m / 5 * 5;
15 | 		printf("%d PENNY(S)\n", m);
16 | 	}
17 | 	return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/poj/3086.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int num[350] = {0 , 3};
 3 | int main()
 4 | {
 5 | 	int n, i, m, sum = 3;
 6 | 	for (i = 2; i <= 300 ; i++)
 7 | 	{
 8 | 		sum += i + 1;
 9 | 		num[i] = num[i - 1] + sum * i;
10 | 	}
11 | 	scanf("%d", &n);
12 | 	for (i = 1; i <= n; i++)
13 | 	{
14 | 		scanf("%d", &m);
15 | 		printf("%d %d %d\n", i, m, num[m]);
16 | 	}
17 | 	return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/poj/3087.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int n;
 4 | char str[250];
 5 | void change(char s[],char t[])
 6 | {
 7 | 	int i,j=0;
 8 | 	for (i=n;i<n+n;i++)
 9 | 	{
10 | 		t[j++]=s[i];
11 | 		t[j++]=s[i-n];
12 | 	}
13 | 	t[n+n]='\0';
14 | }
15 | int main()
16 | {
17 | 	int answer,i,t;
18 | 	char s[250],s1[250],target[250];
19 | 	scanf("%d",&t);
20 | 	for (i=1;i<=t;i++)
21 | 	{
22 | 		answer=0;
23 | 		scanf("%d",&n);
24 | 		scanf("%s",s);
25 | 		scanf("%s",s+n);
26 | 		scanf("%s",target);
27 | 		strcpy(str,s);
28 | 		while(strcmp(target,s)!=0)
29 | 		{
30 | 			change(s,s1);
31 | 			strcpy(s,s1);
32 | 			if (strcmp(s,str)==0)
33 | 			{
34 | 				answer=-1;
35 | 				break;
36 | 			}
37 | 			answer++;
38 | 		}
39 | 		printf("%d %d\n",i,answer);
40 | 	}
41 | 	return 0;
42 | }
43 | 


--------------------------------------------------------------------------------
/poj/3088.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int jc[12]={1,1,2,6,24,120,720,5040,40320,362880,3628800,39916800};
 3 | unsigned int g[12]={1,1,3},f[12];
 4 | int zuhe(int i,int j)
 5 | {
 6 | 	return jc[j]/jc[i]/jc[j-i];
 7 | }
 8 | int main()
 9 | {
10 | 	int i,j,n;
11 | 	for (i=3;i<12;i++)
12 | 	{
13 | 		g[i]=0;
14 | 		for (j=0;j<i;j++)
15 | 			g[i]+=g[j]*zuhe(j,i);
16 | 	}
17 | 	for (i=1;i<12;i++)
18 | 	{
19 | 		f[i]=0;
20 | 		for (j=1;j<=i;j++)
21 | 			f[i]+=g[j]*zuhe(j,i);
22 | 	}
23 | 	scanf("%d",&n);
24 | 	for (i=1;i<=n;i++)
25 | 	{
26 | 		scanf("%d",&j);
27 | 		printf("%d %d %u\n",i,j,f[j]);
28 | 	}
29 | 	return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/poj/3090.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/snuc/poj/80cccc7287f23d33cde75b51a78a04bdb75408cb/poj/3090.c


--------------------------------------------------------------------------------
/poj/3091.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int i,j,t,T,n,p,x,y;
 5 | 	scanf("%d",&T);
 6 | 	for (t=1;t<=T;t++)
 7 | 	{
 8 | 		scanf("%d",&n);
 9 | 		x=((n+n)+1)/3;
10 | 		printf("%d %d %d\n",t,n,x);
11 | 		if (n%3==2)
12 | 			n--;
13 | 		p=0;
14 | 		for (i=n-x/2+1,j=x;i<=n;i++,j--)
15 | 		{
16 | 			printf("[%d,%d]",i,j);
17 | 			p++;
18 | 			if (p%8==0)
19 | 				printf("\n");
20 | 			else printf(" ");
21 | 		}
22 | 		y=x-x/2;
23 | 		for (i=y,j=y;j>=1;i++,j--)
24 | 		{
25 | 			printf("[%d,%d]",i,j);
26 | 			p++;
27 | 			if (p%8==0 || p==x)
28 | 				printf("\n");
29 | 			else printf(" ");
30 | 		}
31 | 		printf("\n");
32 | 	}
33 | 	return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/poj/3092.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | unsigned int power2,power3;
 3 | int mod(int n)
 4 | {
 5 | 	int i=0;
 6 | 	power2=1;
 7 | 	while (n%2==0)
 8 | 	{
 9 | 		n/=2;
10 | 		power2*=2;
11 | 		i++;
12 | 	}
13 | 	return i;
14 | }
15 | int term(unsigned int n)
16 | {
17 | 	int i;
18 | 	power3=1;
19 | 	for (i=0;n>=power2*power3;i++)
20 | 		power3*=3;
21 | 	i--;
22 | 	power3/=3;
23 | 	return i;
24 | }
25 | int main()
26 | {
27 | 	int T,t,i,j;
28 | 	unsigned int n;
29 | 	int p2[100],p3[100];
30 | 	scanf("%d",&T);
31 | 	for (t=1;t<=T;t++)
32 | 	{
33 | 		scanf("%u",&n);
34 | 		i=0;
35 | 		while (n!=0)
36 | 		{
37 | 			p2[i]=mod(n);
38 | 			p3[i]=term(n);
39 | 			i++;
40 | 			n-=power2*power3;
41 | 		}
42 | 		printf("%d %d",t,i);
43 | 		for (j=0;j<i;j++)
44 | 			printf(" [%d,%d]",p2[j],p3[j]);
45 | 		printf("\n");
46 | 	}
47 | 	return 0;
48 | }
49 | 


--------------------------------------------------------------------------------
/poj/3093.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | #include<stdlib.h>
 4 | __int64 price[30],sum[30];
 5 | unsigned int g[1100][40];
 6 | int cmp(const void *a, const void *b)
 7 | {
 8 | 	__int64 x,y;
 9 | 	x=*(__int64 *)a;
10 | 	y=*(__int64 *)b;
11 | 	if (x<y)
12 | 		return -1;
13 | 	else if (x>y)
14 | 		return 1;
15 | 	else return 0;
16 | }
17 | int main()
18 | {
19 | 	int i,j,k,n,v,d;
20 | 	scanf("%d",&n);
21 | 	for (i=1;i<=n;i++)
22 | 	{
23 | 		scanf("%d%d",&v,&d);
24 | 		for (j=0;j<v;j++)
25 | 			scanf("%I64d",&price[j]);
26 | 		qsort(price,v,sizeof(price[0]),cmp);
27 | 		for (sum[0]=price[0],j=1;j<v;j++)
28 | 			sum[j]=sum[j-1]+price[j];
29 | 		memset(g,0,sizeof(g));
30 | 		for (k=0;k<=d;k++)
31 | 			g[k][0]=1;
32 | 		for (j=1;j<v;j++)
33 | 		{
34 | 			for (k=0;k<=d;k++)
35 | 			{
36 | 				if (k<price[j])
37 | 					g[k][j]=g[k][j-1];
38 | 				else if (k<sum[j])
39 | 					g[k][j]=g[k][j-1]+g[k-price[j]][j-1];
40 | 				else g[k][j]=1;
41 | 			}
42 | 		}
43 | 		if (d<price[0])
44 | 			g[d][v-1]=0;
45 | 		printf("%d %u\n",i,g[d][v-1]);
46 | 	}
47 | 	return 0;
48 | }
49 | 


--------------------------------------------------------------------------------
/poj/3094.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | char str[300];
 4 | int main()
 5 | {
 6 | 	int i,sum;
 7 | 	gets(str);
 8 | 	while (strcmp(str,"#")!=0)
 9 | 	{
10 | 		sum=0;
11 | 		for (i=0;str[i]!='\0';i++)
12 | 			if (str[i]>='A' && str[i]<='Z')
13 | 				sum+=(i+1)*(str[i]-'A'+1);
14 | 		printf("%d\n",sum);
15 | 		gets(str);
16 | 	}
17 | 	return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/poj/3095.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int len;
 4 | char str[100];
 5 | int left(int j)
 6 | {
 7 | 	int i;
 8 | 	for (i=j-1;i>=0;i--)
 9 | 	{
10 | 		if (str[i]=='.')
11 | 			return 100;
12 | 		else if (str[i]=='|' || str[i]=='\\')
13 | 			return 0;
14 | 	}
15 | 	return 100;
16 | }
17 | int right(int j)
18 | {
19 | 	int i;
20 | 	for (i=j+1;i<len;i++)
21 | 	{
22 | 		if (str[i]=='.')
23 | 			return 100;
24 | 		else if (str[i]=='|' || str[i]=='/')
25 | 			return 0;
26 | 	}
27 | 	return 100;
28 | }
29 | int main()
30 | {
31 | 	int s,i;
32 | 	gets(str);
33 | 	while (strcmp(str,"#")!=0)
34 | 	{
35 | 		len=strlen(str);
36 | 		s=0;
37 | 		for (i=0;i<len;i++)
38 | 		{
39 | 			if (str[i]=='.')
40 | 				s+=100;
41 | 			else if (str[i]=='/')
42 | 				s+=left(i);
43 | 			else if (str[i]=='\\')
44 | 				s+=right(i);
45 | 			else if (str[i]=='|')
46 | 				s+=(left(i)+right(i))/2;
47 | 		}
48 | 		printf("%d\n",s/len);
49 | 		gets(str);
50 | 	}
51 | 	return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/poj/3096.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | char str[100];
 4 | int main()
 5 | {
 6 | 	int i,j,k,l,len;
 7 | 	gets(str);
 8 | 	while (strcmp(str,"*")!=0)
 9 | 	{
10 | 		len=strlen(str);
11 | 		for (i=0;i<len;i++)
12 | 		{
13 | 			for (j=i+1;j<len;j++)
14 | 			{
15 | 				if (str[i]==str[j])
16 | 				{
17 | 					l=j-i;
18 | 					for (k=i+1;k+l<len;k++)
19 | 						if (str[k]==str[k+l])
20 | 							break;
21 | 					if (k+l<len)
22 | 						break;
23 | 				}
24 | 			}
25 | 			if (j<len)
26 | 				break;
27 | 		}
28 | 		if (i<len)
29 | 			printf("%s is NOT surprising.\n",str);
30 | 		else printf("%s is surprising.\n",str);
31 | 		gets(str);
32 | 	}
33 | 	return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/poj/3100.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int pow(int A,int N)
 3 | {
 4 | 	int s=A,i;
 5 | 	for (i=1;i<N;i++)
 6 | 		s*=A;
 7 | 	return s;
 8 | }
 9 | int main()
10 | {
11 | 	int i,j,k;
12 | 	int B,N;
13 | 	scanf("%d%d",&B,&N);
14 | 	while (B!=0 || N!=0)
15 | 	{
16 | 		for (i=1,k=1;(j=pow(i,N))<B;i++)
17 | 			k=j;
18 | 		if (j-B>B-k)
19 | 			i--;
20 | 		printf("%d\n",i);
21 | 		scanf("%d%d",&B,&N);
22 | 	}
23 | 	return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/poj/3103.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int x,y,z,n;
 3 | int main()
 4 | {
 5 | 	int i;
 6 | 	double p;
 7 | 	scanf("%d%d%d%d",&x,&y,&z,&n);
 8 | 	p=(double)x/n;
 9 | 	for (i=0;i<n;i++)
10 | 		printf("%.8lf 0 0 %.8lf %d %d\n",i*p,(i+1)*p,y,z);
11 | 	return 0;
12 | }
13 | 


--------------------------------------------------------------------------------
/poj/3104.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<math.h>
 3 | int n,k,dry[100000];
 4 | int bin(int t)
 5 | {
 6 | 	int i;
 7 | 	__int64 total=0;
 8 | 	for (i=0;i<n;i++)
 9 | 	{
10 | 		if (dry[i]>t)
11 | 			total+=(int)ceil(((double)(dry[i]-t))/(k-1));
12 | 	}
13 | 	if (total>t)
14 | 		return 0;
15 | 	return 1;
16 | }
17 | int main()
18 | {
19 | 	int low,high,mid,i;
20 | 	scanf("%d",&n);
21 | 	low=0;
22 | 	high=0;
23 | 	for (i=0;i<n;i++)
24 | 	{
25 | 		scanf("%d",&dry[i]);
26 | 		if (dry[i]>high)
27 | 			high=dry[i];
28 | 	}
29 | 	scanf("%d",&k);
30 | 	if (k!=1)
31 | 	{
32 | 		while (high-low>1)
33 | 		{
34 | 			mid=(high+low)/2;
35 | 			if (bin(mid)==0)
36 | 				low=mid;
37 | 			else high=mid;
38 | 		}
39 | 	}
40 | 	printf("%d\n",high);
41 | 	return 0;
42 | }
43 | 


--------------------------------------------------------------------------------
/poj/3107.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | int n,balance[50001],num[50001]={0};
 4 | struct edge{
 5 | 	int v;
 6 | 	struct edge *next;
 7 | }*Node[50001]={NULL};
 8 | void insert(int a,int b)
 9 | {
10 | 	struct edge *p;
11 | 	p=(struct edge *)malloc(sizeof(struct edge));
12 | 	p->v=b;
13 | 	p->next=Node[a];
14 | 	Node[a]=p;
15 | 	num[a]++;
16 | }
17 | int cal(int father,int p)
18 | {
19 | 	int i,j,k=0,s=num[p];
20 | 	struct edge *q=Node[p];
21 | 	while (q!=NULL)
22 | 	{
23 | 		if (q->v!=father)
24 | 		{
25 | 			j=cal(p,q->v);
26 | 			if (j>k)
27 | 				k=j;
28 | 			s+=j;
29 | 		}
30 | 		else s--;
31 | 		q=q->next;
32 | 	}
33 | 	i=n-1-s;
34 | 	k++;
35 | 	balance[p]=i>k ? i:k;
36 | 	return s;
37 | }
38 | int main()
39 | {
40 |     int j,a,b,max=50000;
41 | 	scanf("%d",&n);
42 | 	for (j=n-1;j>0;j--)
43 | 	{
44 | 		scanf("%d%d",&a,&b);
45 | 		insert(a,b);
46 | 		insert(b,a);
47 | 	}
48 | 	cal(0,1);
49 | 	for (j=1;j<=n;j++)
50 | 		if (balance[j]<max)
51 | 			max=balance[j];
52 | 	for (j=1;j<=n;j++)
53 | 		if (balance[j]==max)
54 | 			printf("%d ",j);
55 | 	printf("\n");
56 | 	return 0;
57 | }
58 | 


--------------------------------------------------------------------------------
/poj/3117.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int i,j,t,n,p;
 5 | 	char str[50];
 6 | 	while (scanf("%d%d",&t,&n),t!=0 || n!=0)
 7 | 	{
 8 | 		for (i=0,p=0;i<t;i++)
 9 | 		{
10 | 			scanf("%s%d",str,&j);
11 | 			p+=j;
12 | 		}
13 | 		printf("%d\n",3*n-p);
14 | 	}
15 | }
16 | 


--------------------------------------------------------------------------------
/poj/3123.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int n;
 3 | double pie[10000];
 4 | int piece(double area)
 5 | {
 6 | 	int total=0,i;
 7 | 	for (i=0;i<n;i++)
 8 | 		total+=(int)(pie[i]/area);
 9 | 	return total;
10 | }
11 | int main()
12 | {
13 | 	int test,t,f,i;
14 | 	double high,low,mid;
15 | 	scanf("%d",&test);
16 | 	for (t=0;t<test;t++)
17 | 	{
18 | 		scanf("%d%d",&n,&f);
19 | 		f++;
20 | 		high=0;
21 | 		for (i=0;i<n;i++)
22 | 		{
23 | 			scanf("%lf",&pie[i]);
24 | 			pie[i]*=pie[i];
25 | 			if (pie[i]>high)
26 | 				high=pie[i];
27 | 		}
28 | 		low=0;
29 | 		while (high-low>0.00000001)
30 | 		{
31 | 			mid=(high+low)/2;
32 | 			if (piece(mid)<f)
33 | 				high=mid;
34 | 			else low=mid;
35 | 		}
36 | 		printf("%.4lf\n",low*3.14159265359);
37 | 	}
38 | 	return 0;
39 | }
40 | 


--------------------------------------------------------------------------------
/poj/3125.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int queue[200];
 3 | bool print[200];
 4 | int find(int n)
 5 | {
 6 | 	int i,j;
 7 | 	for (i=1,j=0;i<n;i++)
 8 | 		if (queue[i]>queue[j])
 9 | 			j=i;
10 | 	return j;
11 | }
12 | int main()
13 | {
14 | 	int t,test,i,j,k,l,m,n;
15 | 	scanf("%d",&test);
16 | 	for (t=0;t<test;t++)
17 | 	{
18 | 		scanf("%d%d",&n,&m);
19 | 		for (i=0;i<n;i++)
20 | 		{
21 | 			scanf("%d",&queue[i]);
22 | 			print[i]=false;
23 | 		}
24 | 		print[m]=true;
25 | 		l=queue[m];
26 | 		k=0;
27 | 		while (queue[(j=find(n))]!=l)
28 | 		{
29 | 			for (i=n;i<n+j;i++)
30 | 			{
31 | 				queue[i]=queue[i-n];
32 | 				print[i]=print[i-n];
33 | 			}
34 | 			for (i=0;i<n-1;i++)
35 | 			{
36 | 				queue[i]=queue[i+j+1];
37 | 				print[i]=print[i+j+1];
38 | 			}
39 | 			n--;
40 | 			k++;
41 | 		}
42 | 		for (i=0;i<n;i++)
43 | 		{
44 | 			if (queue[i]==l)
45 | 			{
46 | 				k++;
47 | 				if (print[i]==true)
48 | 					break;
49 | 			}
50 | 		}
51 | 		printf("%d\n",k);
52 | 	}
53 | 	return 0;
54 | }
55 | 


--------------------------------------------------------------------------------
/poj/3138.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int S,T,M,i,j=1,s;
 3 | int team[200];
 4 | bool flag[200];
 5 | int main()
 6 | {
 7 | 	int a,b,c;
 8 | 	scanf("%d%d%d",&S,&T,&M);
 9 | 	while (S!=0 || T!=0 || M!=0)
10 | 	{
11 | 		for (i=0;i<S;i++)
12 | 		{
13 | 			scanf("%d%d%d",&a,&b,&c);
14 | 			team[a]=b+c;
15 | 			flag[a]=false;
16 | 		}
17 | 		for (i=0;i<T;i++)
18 | 		{
19 | 			scanf("%d%d",&a,&b);
20 | 			if (b>=M && flag[a]==false)
21 | 				flag[a]=true;
22 | 		}
23 | 		for (i=1,s=0;i<=S;i++)
24 | 		{
25 | 			s+=team[i];
26 | 			if (flag[i]==true)
27 | 				s++;
28 | 		}
29 | 		printf("Case %d: %d\n",j++,s);
30 | 		scanf("%d%d%d",&S,&T,&M);
31 | 	}
32 | 	return 0;
33 | }
34 | 


--------------------------------------------------------------------------------
/poj/3140.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/snuc/poj/80cccc7287f23d33cde75b51a78a04bdb75408cb/poj/3140.cpp


--------------------------------------------------------------------------------
/poj/3141.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int Yang(int n,int p)
 3 | {
 4 | 	int a=n/p;
 5 | 	int b=n%p;
 6 | 	if (n==0)
 7 | 		return 1;
 8 | 	return (b+1)*Yang(a,p);
 9 | }
10 | int main()
11 | {
12 | 	int n,p,sum,t=1;
13 | 	char digit[5];
14 | 	scanf("%d%d",&p,&n);
15 | 	while (p!=0 || n!=0)
16 | 	{
17 | 		sum=Yang(n,p);
18 | 		sum%=10000;
19 | 		digit[0]='0'+sum/1000;
20 | 		sum%=1000;
21 | 		digit[1]='0'+sum/100;
22 | 		sum%=100;
23 | 		digit[2]='0'+sum/10;
24 | 		sum%=10;
25 | 		digit[3]='0'+sum;
26 | 		digit[4]='\0';
27 | 		printf("Case %d: %s\n",t++,digit);
28 | 		scanf("%d%d",&p,&n);
29 | 	}
30 | 	return 0;
31 | }
32 | 


--------------------------------------------------------------------------------
/poj/3154.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int n,m;
 3 | double x,y;
 4 | int main()
 5 | {
 6 | 	int i;
 7 | 	double s=0,p;
 8 | 	scanf("%d%d",&n,&m);
 9 | 	m+=n;
10 | 	x=(double)10000/n;
11 | 	y=(double)10000/m;
12 | 	for (i=1;i<n;i++)
13 | 	{
14 | 		p=(x*i)/y;
15 | 		p-=(int)p;
16 | 		if ((int)(p*2)==1)
17 | 			s+=1-p;
18 | 		else s+=p;
19 | 	}
20 | 	printf("%.4lf\n",s*y);
21 | 	return 0;
22 | }
23 | 


--------------------------------------------------------------------------------
/poj/3157.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | char str[200];
 4 | bool cpp=false,java=false,error=false;
 5 | int main()
 6 | {
 7 | 	int i,j,len;
 8 | 	gets(str);
 9 | 	len=strlen(str);
10 | 	if (str[0]>'z' || str[0]<'a')
11 | 		error=true;
12 | 	else {
13 | 		for (i=1;i<len;i++)
14 | 		{
15 | 			if (str[i]>='A' && str[i]<='Z')
16 | 				java=true;
17 | 			if (str[i]=='_')
18 | 			{
19 | 				if (str[i-1]>='a' && str[i-1]<='z' && i+1<len && str[i+1]>='a' && str[i+1]<='z')
20 | 					cpp=true;
21 | 				else error=true;
22 | 			}
23 | 		}
24 | 	}
25 | 	if (error==true || (cpp==true && java==true))
26 | 		printf("Error!\n");
27 | 	else {
28 | 		for (i=0;i<len;i++)
29 | 		{
30 | 			if (str[i]>='A' && str[i]<='Z')
31 | 			{
32 | 				putchar('_');
33 | 				putchar(str[i]-'A'+'a');
34 | 			}
35 | 			else if (str[i]=='_')
36 | 			{
37 | 				i++;
38 | 				putchar(str[i]-'a'+'A');
39 | 			}
40 | 			else putchar(str[i]);
41 | 		}
42 | 		putchar('\n');
43 | 	}
44 | 	return 0;
45 | }
46 | 


--------------------------------------------------------------------------------
/poj/3173.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int make(int p)
 3 | {
 4 | 	if (p%9==0)
 5 | 		return 9;
 6 | 	else return p%9;
 7 | }
 8 | int main()
 9 | {
10 | 	int i,j,n,s,f;
11 | 	scanf("%d%d",&n,&s);
12 | 	for (i=0;i<n;i++)
13 | 	{
14 | 		for (j=0;j<i;j++)
15 | 			printf("  ");
16 | 		printf("%d",s);
17 | 		f=make(s+i+1);
18 | 		s=make(f+1);
19 | 		for (j=1;j<n-i;j++)
20 | 		{
21 | 			printf(" %d",f);
22 | 			f=make(f+j+i+1);
23 | 		}
24 | 		putchar('\n');
25 | 	}
26 | 	return 0;
27 | }
28 | 


--------------------------------------------------------------------------------
/poj/3176.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int f[2][500],i,j,n,d=0;
 5 | 	scanf("%d\n%d",&n,&f[0][0]);
 6 | 	for (i=1;i<n;i++)
 7 | 	{
 8 | 		d=1-d;
 9 | 		scanf("%d",&f[d][0]);
10 | 		f[d][0]+=f[1-d][0];
11 | 		for (j=1;j<i;j++)
12 | 		{
13 | 			scanf("%d",&f[d][j]);
14 | 			f[d][j]+=(f[1-d][j-1] > f[1-d][j]) ? f[1-d][j-1] : f[1-d][j];
15 | 		}
16 | 		scanf("%d",&f[d][i]);
17 | 		f[d][i]+=f[1-d][i-1];
18 | 	}
19 | 	j=f[d][0];
20 | 	for (i=1;i<n;i++)
21 | 	{
22 | 		if (j<f[d][i])
23 | 			j=f[d][i];
24 | 	}
25 | 	printf("%d\n",j);
26 | 	return 0;
27 | }
28 | 


--------------------------------------------------------------------------------
/poj/3183.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int n,i,j,r,stump;
 5 | 	scanf("%d",&n);
 6 | 	r=0;
 7 | 	stump=0;
 8 | 	for (i=0;i<n;i++)
 9 | 	{
10 | 		scanf("%d",&j);
11 | 		if (j>stump)
12 | 			r=0;
13 | 		else {
14 | 			if (r==0)
15 | 			{
16 | 				printf("%d\n",i);
17 | 				r=1;
18 | 			}
19 | 			if (j==stump)
20 | 				r=0;
21 | 		}
22 | 		stump=j;
23 | 	}
24 | 	if (r==0)
25 | 		printf("%d\n",i);
26 | 	return 0;
27 | }
28 | 


--------------------------------------------------------------------------------
/poj/3191.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int i;
 3 | char str[50]={'\0'};
 4 | int mod (int p)
 5 | {
 6 | 	if (p<0 && p%(-2)==-1)
 7 | 	{
 8 | 		str[i++]='1';
 9 | 		return (p-1)/(-2);
10 | 	}
11 | 	if (p%(-2)==0)
12 | 		str[i++]='0';
13 | 	else str[i++]='1';
14 | 	return p/(-2);
15 | }
16 | int main()
17 | {
18 | 	int n;
19 | 	i=0;
20 | 	scanf("%d",&n);
21 | 	do
22 | 	{
23 | 		n=mod(n);
24 | 	}while (n!=0);
25 | 	while (i>=0)
26 | 		putchar(str[--i]);
27 | 	putchar('\n');
28 | 	return 0;
29 | }
30 | 


--------------------------------------------------------------------------------
/poj/3199.java:
--------------------------------------------------------------------------------
 1 | //Main.java
 2 | import java.util.*;
 3 | import java.math.*;
 4 | 
 5 | public class Main
 6 | {
 7 |         public static void main(String args[]) throws Exception {
 8 |                 Scanner cin=new Scanner(System.in);
 9 |                 BigInteger n = cin.nextBigInteger();
10 |                 int d = cin.nextInt();
11 |                 while (n.intValue() != 0 || d != 0)
12 |                 {
13 |                 	n = n.pow(d);
14 |                 	System.out.println(n);
15 |                 	n = cin.nextBigInteger();
16 |                     d = cin.nextInt();
17 |                 }
18 |         }
19 | }
20 | 


--------------------------------------------------------------------------------
/poj/3207.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int point[2][500];
 3 | int main()
 4 | {
 5 | 	int i,j,m,n,temp;
 6 | 	bool f;
 7 | 	scanf("%d%d",&n,&m);
 8 | 	for (i=0;i<m;i++)
 9 | 	{
10 | 		scanf("%d%d",&point[0][i],&point[1][i]);
11 | 		if (point[0][i]>point[1][i])
12 | 		{
13 | 			temp=point[0][i];
14 | 			point[0][i]=point[1][i];
15 | 			point[1][i]=temp;
16 | 		}
17 | 	}
18 | 	for (i=0;i<m;i++)
19 | 	{
20 | 		f=false;
21 | 		for (j=0;j<m;j++)
22 | 		{
23 | 			if ((point[0][i]>=point[0][j] && point[1][i]>=point[1][j]) || (point[0][i]<=point[0][j] && point[1][i]<=point[1][j]))
24 | 				continue;
25 | 			else if (f==true && !((point[0][temp]>=point[0][j] && point[1][temp]>=point[1][j]) || (point[0][temp]<=point[0][j] && point[1][temp]<=point[1][j])))
26 | 				break;
27 | 			else {
28 | 				f=true;
29 | 				temp=j;
30 | 			}
31 | 		}
32 | 		if (j<m)
33 | 			break;
34 | 	}
35 | 	if (i<m)
36 | 		printf("the evil panda is lying again\n");
37 | 	else printf("panda is telling the truth...\n");
38 | 	return 0;
39 | }
40 | 


--------------------------------------------------------------------------------
/poj/3210.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int main()
 3 | {
 4 | 	int n;
 5 | 	while (scanf("%d",&n),n!=0)
 6 | 	{
 7 | 		if (n%2==0)
 8 | 			printf("No Solution!\n");
 9 | 		else printf("%d\n",n-1);
10 | 	}
11 | 	return 0;
12 | }
13 | 


--------------------------------------------------------------------------------
/poj/3219.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int num(int p)
 3 | {
 4 | 	int sum=0;
 5 | 	while (p>0)
 6 | 	{
 7 | 		p/=2;
 8 | 		sum+=p;
 9 | 	}
10 | 	return sum;
11 | }
12 | int main()
13 | {
14 | 	int n,k;
15 | 	int a,b,c;
16 | 	while (scanf("%d%d",&n,&k)!=EOF)
17 | 	{
18 | 		a=num(n);
19 | 		b=num(k);
20 | 		c=num(n-k);
21 | 		if (a>b+c)
22 | 			printf("0\n");
23 | 		else printf("1\n");
24 | 	}
25 |     return 0;
26 | }
27 | 


--------------------------------------------------------------------------------
/poj/3224.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int n;
 3 | int main()
 4 | {
 5 | 	int i,j,k,s;
 6 | 	int max=0,num;
 7 | 	scanf("%d",&n);
 8 | 	for (i=0;i<n;i++)
 9 | 	{
10 | 		for (j=0,k=0;j<n;j++)
11 | 		{
12 | 			scanf("%d",&s);
13 | 			if (s==3)
14 | 				k++;
15 | 		}
16 | 		if (k>max)
17 | 		{
18 | 			max=k;
19 | 			num=i+1;
20 | 		}
21 | 	}
22 | 	printf("%d\n",num);
23 |     return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/poj/3226.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #define MAX 1000000000000000
 3 | __int64 high,low;
 4 | __int64 a,b,c;
 5 | int alpha[26],n;
 6 | void permutation(int n,int m)
 7 | {
 8 | 	int i;
 9 | 	a=0;
10 | 	b=1;
11 | 	for (i=n;i>n-m;i--)
12 | 	{
13 | 		b*=i;
14 | 		a*=i;
15 | 		a+=b/MAX;
16 | 		b%=MAX;
17 | 	}
18 | }
19 | int list(int p)
20 | {
21 | 	int i,j=0;
22 | 	for (i=0;i<p;i++)
23 | 	{
24 | 		if (alpha[i]==0)
25 | 			j++;
26 | 	}
27 | 	return j;
28 | }
29 | int main()
30 | {
31 | 	int i,j;
32 | 	char str[50];
33 | 	while (scanf("%d",&n),n!=0)
34 | 	{
35 | 		scanf("%s",str);
36 | 		high=0;
37 | 		low=0;
38 | 		for (i=0;i<26;i++)
39 | 			alpha[i]=0;
40 | 		for (i=0;i<n;i++)
41 | 		{
42 | 			j=str[i]-'A';
43 | 			permutation(25-i,n-1-i);
44 | 			alpha[j]=1;
45 | 			j=list(j);
46 | 			b*=j;
47 | 			a*=j;
48 | 			a+=b/MAX;
49 | 			b%=MAX;
50 | 			low+=b;
51 | 			high+=a;
52 | 			high+=low/MAX;
53 | 			low%=MAX;
54 | 		}
55 | 		if (high!=0)
56 | 			printf("%I64d%15I64d\n",high,low);
57 | 		else printf("%I64d\n",low);
58 | 	}
59 | 	return 0;
60 | }
61 | 


--------------------------------------------------------------------------------
/poj/3230.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #define M	100
 3 | #define N	100
 4 | int income[M][N],expense[N][N];
 5 | int dp[2][N],m,n;
 6 | int main()
 7 | {
 8 | 	int i,j,k,max,t;
 9 | 	while (scanf("%d%d",&n,&m),n!=0 || m!=0)
10 | 	{
11 | 		for (i=0;i<n;i++)
12 | 			for (j=0;j<n;j++)
13 | 				scanf("%d",&expense[i][j]);
14 | 		for (i=0;i<m;i++)
15 | 			for (j=0;j<n;j++)
16 | 				scanf("%d",&income[i][j]);
17 | 		for (i=0;i<n;i++)
18 | 			dp[0][i]=income[0][i]-expense[0][i];
19 | 		t=0;
20 | 		for (i=1;i<m;i++)
21 | 		{
22 | 			for (j=0;j<n;j++)
23 | 			{
24 | 				max=0;
25 | 				for (k=0;k<n;k++)
26 | 				{
27 | 					if (dp[t][k]+income[i][j]-expense[k][j]>max)
28 | 						max=dp[t][k]+income[i][j]-expense[k][j];
29 | 				}
30 | 				dp[1-t][j]=max;
31 | 			}
32 | 			t=1-t;
33 | 		}
34 | 		max=0;
35 | 		for (i=0;i<n;i++)
36 | 			if (dp[t][i]>max)
37 | 				max=dp[t][i];
38 | 		printf("%d\n",max);
39 | 	}
40 | 	return 0;
41 | }
42 | 


--------------------------------------------------------------------------------
/poj/3232.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int n,m,k;
 3 | int length[100000];
 4 | int Accelerator(int time)
 5 | {
 6 | 	int i,j,p;
 7 | 	__int64 count=(__int64)time*m;
 8 | 	for (i=0;i<n;i++)
 9 | 	{
10 | 		if ((p=length[i]-time)<=0) continue;
11 | 		j=p/(k-1);
12 | 		p=p%(k-1);
13 | 		if (p>0) j++;
14 | 		if (j>time) return -1;
15 | 		count-=j;
16 | 	}
17 | 	if (count<0) return -1;
18 | 	if (count==0) return 0;
19 | 	return 1;
20 | }
21 | int main()
22 | {
23 | 	int test,t,i;
24 | 	int high,low,mid;
25 | 	scanf("%d",&test);
26 | 	for (t=0;t<test;t++)
27 | 	{
28 | 		scanf("%d",&n);
29 | 		low=1;
30 | 		high=0;
31 | 		for (i=0;i<n;i++)
32 | 		{
33 | 			scanf("%d",&length[i]);
34 | 			if (length[i]>high)
35 | 				high=length[i];
36 | 		}
37 | 		scanf("%d%d",&m,&k);
38 | 		if (k==1)
39 | 		{
40 | 			printf("%d\n",high);
41 | 			continue;
42 | 		}
43 | 		while (low<high)
44 | 		{
45 | 			mid=(low+high)>>1;
46 | 			i=Accelerator(mid);
47 | 			if (i==-1)
48 | 				low=mid+1;
49 | 			else if (i==1)
50 | 				high=mid;
51 | 			else break;
52 | 		}
53 | 		printf("%d\n",(low+high)>>1);
54 | 	}
55 | 	return 0;
56 | }
57 | 


--------------------------------------------------------------------------------
/poj/3249.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/snuc/poj/80cccc7287f23d33cde75b51a78a04bdb75408cb/poj/3249.cpp


--------------------------------------------------------------------------------
/poj/3250.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int n,hair[80000],dp[80000]={0};
 3 | int link[80000]={0};
 4 | int main()
 5 | {
 6 | 	int i,j;
 7 | 	__int64 sum=0;
 8 | 	scanf("%d",&n);
 9 | 	for (i=0;i<n;i++)
10 | 		scanf("%d",&hair[i]);
11 | 	for (i=n-2;i>=0;i--)
12 | 	{
13 | 		for (j=i+1;j>0 && hair[i]>hair[j];j=link[j])
14 | 		{
15 | 			dp[i]=dp[i]+dp[j]+1;
16 | 		}
17 | 		if (j>0)
18 | 			link[i]=j;
19 | 		sum+=dp[i];
20 | 	}
21 | 	printf("%I64d\n",sum);
22 | 	return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/poj/3256.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/snuc/poj/80cccc7287f23d33cde75b51a78a04bdb75408cb/poj/3256.cpp


--------------------------------------------------------------------------------
/poj/3262.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | #define COW	100000
 4 | int t[COW],d[COW],sort[COW];
 5 | int cmp(const void *a, const void *b)
 6 | {
 7 | 	int x=*(int *)a;
 8 | 	int y=*(int *)b;
 9 | 	int z=t[x]*d[y]-t[y]*d[x];
10 | 	if (z<0)
11 | 		return -1;
12 | 	else if (z==0)
13 | 		return 0;
14 | 	else return 1;
15 | }
16 | int main()
17 | {
18 | 	int n,i,j,sum=0;
19 | 	__int64 max=0;
20 | 	scanf("%d",&n);
21 | 	for (i=0;i<n;i++)
22 | 	{
23 | 		sort[i]=i;
24 | 		scanf("%d%d",&t[i],&d[i]);
25 | 		sum+=d[i];
26 | 	}
27 | 	qsort(sort,n,sizeof(sort[0]),cmp);
28 | 	for (i=0;i<n;i++)
29 | 	{
30 | 		j=sort[i];
31 | 		sum-=d[j];
32 | 		max+=(t[j]+t[j])*sum;
33 | 	}
34 | 	printf("%I64d\n",max);
35 | 	return 0;
36 | }
37 | 


--------------------------------------------------------------------------------
/poj/3273.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #define MAX	100000
 3 | int Money[MAX],n,m;
 4 | int search(int p)
 5 | {
 6 | 	int i,j=1,k=0;
 7 | 	for (i=0;i<n;i++)
 8 | 	{
 9 | 		if (k+Money[i]>p)
10 | 		{
11 | 			k=Money[i];
12 | 			j++;
13 | 		}
14 | 		else k+=Money[i];
15 | 	}
16 | 	if (j>m)
17 | 		return 1;
18 | 	return 0;
19 | }
20 | int main()
21 | {
22 | 	int i,min=0,max=0;
23 | 	scanf("%d%d",&n,&m);
24 | 	for (i=0;i<n;i++)
25 | 	{
26 | 		scanf("%d",&Money[i]);
27 | 		max+=Money[i];
28 | 		if (Money[i]>min)
29 | 			min=Money[i];
30 | 	}
31 | 	while (min<max)
32 | 	{
33 | 		i=(min+max)/2;
34 | 		if (search(i)==1)
35 | 			min=i+1;
36 | 		else max=i;
37 | 	}
38 | 	printf("%d\n",(min+max)/2);
39 | 	return 0;
40 | }
41 | 


--------------------------------------------------------------------------------
/poj/3278.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #define MAX	200001
 3 | int Dist[MAX],n,k;
 4 | bool flag[MAX]={false};
 5 | void bfs()
 6 | {
 7 | 	int queue[MAX]={n},front=0,rear=1,p;
 8 | 	Dist[n]=0;
 9 | 	flag[n]=true;
10 | 	while (front<rear)
11 | 	{
12 | 		p=queue[front];
13 | 		if (p==k)
14 | 			break;
15 | 		if (p>0 && flag[p-1]==false)
16 | 		{
17 | 			flag[p-1]=true;
18 | 			Dist[p-1]=Dist[p]+1;
19 | 			queue[rear++]=p-1;
20 | 		}
21 | 		if (p<k)
22 | 		{	
23 | 			if (flag[p+1]==false)
24 | 			{
25 | 				flag[p+1]=true;
26 | 				Dist[p+1]=Dist[p]+1;
27 | 				queue[rear++]=p+1;
28 | 			}
29 | 			if (flag[p+p]==false)
30 | 			{
31 | 				flag[p+p]=true;
32 | 				Dist[p+p]=Dist[p]+1;
33 | 				queue[rear++]=p+p;
34 | 			}
35 | 		}
36 | 		front++;
37 | 	}
38 | }
39 | int main()
40 | {
41 | 	scanf("%d%d",&n,&k);
42 | 	bfs();
43 | 	printf("%d\n",Dist[k]);
44 | 	return 0;
45 | }
46 | 


--------------------------------------------------------------------------------
/poj/3282.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | char str[100];
 4 | int left[100000],right[100000];
 5 | int n,l,m;
 6 | int main()
 7 | {
 8 | 	int i,j,k,sum;
 9 | 	int car,a,b,L,R;
10 | 	scanf("%d",&n);
11 | 	for (i=0;i<n;i++)
12 | 	{
13 | 		scanf("%d%d",&l,&m);
14 | 		l*=100;
15 | 		L=0;
16 | 		R=0;
17 | 		for (j=0;j<m;j++)
18 | 		{
19 | 			scanf("%d %s",&car,str);
20 | 			if (strcmp(str,"left")==0)
21 | 				left[L++]=car;
22 | 			else right[R++]=car;
23 | 		}
24 | 		a=1;
25 | 		b=1;
26 | 		k=0;
27 | 		for (j=0;j<L;j++)
28 | 		{
29 | 			if (k+left[j]>l)
30 | 			{
31 | 				a++;
32 | 				k=left[j];
33 | 			}
34 | 			else k+=left[j];
35 | 		}
36 | 		k=0;
37 | 		for (j=0;j<R;j++)
38 | 		{
39 | 			if (k+right[j]>l)
40 | 			{
41 | 				b++;
42 | 				k=right[j];
43 | 			}
44 | 			else k+=right[j];
45 | 		}
46 | 		if (a==b || a==b+1)
47 | 			sum=a+b;
48 | 		else {
49 | 			if (b>a)
50 | 				sum=b+b;
51 | 			else sum=a+a-1;
52 | 		}
53 | 		printf("%d\n",sum);
54 | 	}
55 | 	return 0;
56 | }
57 | 


--------------------------------------------------------------------------------
/poj/3286.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | __int64 cal(__int64 p)
 3 | {
 4 | 	__int64 q=p/10+1,r,s;
 5 | 	int digi[20],i,j,k;
 6 | 	for (i=0;p>0;i++)
 7 | 	{
 8 | 		digi[i]=p%10;
 9 | 		p/=10;
10 | 	}
11 | 	for (j=1;j<i-1;j++)
12 | 	{
13 | 		for (k=i-1,r=0;k>j;k--)
14 | 		{
15 | 			r*=10;
16 | 			r+=digi[k];
17 | 		}
18 | 		for (k=0,s=1;k<j;k++)
19 | 			s*=10;
20 | 		if (digi[j]==0)
21 | 		{
22 | 			for (k=j-1;k>=0;k--)
23 | 			{
24 | 				r*=10;
25 | 				r+=digi[k];
26 | 			}
27 | 			q+=r-s+1;
28 | 		}
29 | 		else q+=r*s;
30 | 	}
31 | 	return q;
32 | }
33 | int main()
34 | {
35 | 	__int64 p,a,b;
36 | 	while (scanf("%I64d%I64d",&a,&b),a!=-1 || b!=-1)
37 | 	{
38 | 		p=cal(b);
39 | 		if (a!=0)
40 | 			p-=cal(a-1);
41 | 		printf("%I64d\n",p);
42 | 	}
43 | 	return 0;
44 | }
45 | 


--------------------------------------------------------------------------------
/poj/3292.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int Hprime[110000]={0},q=0;
 3 | bool HSprime[1000002]={false};
 4 | void hprime()
 5 | {
 6 | 	int i,j,k;
 7 | 	bool prime[200016]={false};
 8 | 	for (i=5;i<450;i+=4)
 9 | 	{
10 | 		if (prime[i]==true)
11 | 			continue;
12 | 		k=4*i;
13 | 		for (j=i*i;j<200016;j+=k)
14 | 			prime[j]=true;
15 | 	}
16 | 	for (i=5;i<200016;i+=4)
17 | 	{
18 | 		if (prime[i]==false)
19 | 			Hprime[q++]=i;
20 | 	}
21 | }
22 | void hsprime()
23 | {
24 | 	int i,j,k;
25 | 	bool HSprime[250002]={false};
26 | 	for (i=0;i<152;i++)
27 | 	{
28 | 		k=1000001/Hprime[i];
29 | 		for (j=i;Hprime[j]<=k;j++)
30 | 			HSprime[(Hprime[i]*Hprime[j]-1)>>2]=true;
31 | 	}
32 | 	for (i=6,q=0;i<250002;i++)
33 | 	{
34 | 		if (HSprime[i]==true)
35 | 			Hprime[q++]=(i<<2)+1;
36 | 	}
37 | }
38 | int main()
39 | {
40 | 	int n,i;
41 | 	hprime();
42 | 	hsprime();
43 | 	while (scanf("%d",&n),n!=0)
44 | 	{
45 | 		for (i=0;i<q;i++)
46 | 			if (Hprime[i]>n)
47 | 				break;
48 | 		printf("%d %d\n",n,i);
49 | 	}
50 | 	return 0;
51 | }
52 | 


--------------------------------------------------------------------------------
/poj/3300.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | int f,r,q;
 4 | double front[10],rear[10];
 5 | double ratio[100];
 6 | int cmp(const void *a, const void *b)
 7 | {
 8 | 	double x,y;
 9 | 	x=*(double *)a;
10 | 	y=*(double *)b;
11 | 	if (x<y)
12 | 		return -1;
13 | 	else if (x>y)
14 | 		return 1;
15 | 	else return 0;
16 | }
17 | 
18 | int main()
19 | {
20 | 	int i,j;
21 | 	double max;
22 | 	while (scanf("%d",&f),f!=0)
23 | 	{
24 | 		scanf("%d",&r);
25 | 		for (i=0;i<f;i++)
26 | 			scanf("%lf",&front[i]);
27 | 		for (i=0;i<r;i++)
28 | 			scanf("%lf",&rear[i]);
29 | 		q=0;
30 | 		for (i=0;i<f;i++)
31 | 			for (j=0;j<r;j++)
32 | 				ratio[q++]=front[i]/rear[j];
33 | 		qsort(ratio,q,sizeof(ratio[0]),cmp);
34 | 		max=0;
35 | 		for (i=1;i<q;i++)
36 | 		{
37 | 			if (ratio[i]/ratio[i-1]>max)
38 | 				max=ratio[i]/ratio[i-1];
39 | 		}
40 | 		printf("%.2lf\n",max);
41 | 	}
42 | 	return 0;
43 | }
44 | 


--------------------------------------------------------------------------------
/poj/3302.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | char s[200],t[200];
 3 | int main()
 4 | {
 5 | 	int test,i,j,k;
 6 | 	scanf("%d\n",&test);
 7 | 	for (i=0;i<test;i++)
 8 | 	{
 9 | 		scanf("%s%s",s,t);
10 | 		for (j=0,k=0;s[j]!='\0' && t[k]!='\0';j++)
11 | 		{
12 | 			if (s[j]==t[k])
13 | 				k++;
14 | 		}
15 | 		if (t[k]=='\0')
16 | 			printf("YES\n");
17 | 		else {
18 | 			for (k=0,j--;j>=0 && t[k]!='\0';j--)
19 | 			{
20 | 				if (s[j]==t[k])
21 | 					k++;
22 | 			}
23 | 			if (t[k]=='\0')
24 | 				printf("YES\n");
25 | 			else printf("NO\n");
26 | 		}
27 | 	}
28 | 	return 0;
29 | }
30 | 


--------------------------------------------------------------------------------
/poj/3307.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | __int64 sister[80422]={0,1};
 3 | int q=2;
 4 | void make()
 5 | {
 6 | 	int a,b,c,d;
 7 | 	__int64 e,f,g,h;
 8 | 	a=b=c=d=1;
 9 | 	while (q<80422)
10 | 	{
11 | 		e=sister[a]*2;
12 | 		f=sister[b]*3;
13 | 		g=sister[c]*5;
14 | 		h=sister[d]*7;
15 | 		if (e<=f && e<=g && e<=h)
16 | 		{
17 | 			sister[q++]=e;
18 | 			a++;
19 | 			if (e==f)	b++;
20 | 			if (e==g)	c++;
21 | 			if (e==h)	d++;
22 | 		}
23 | 		else if (f<=e && f<=g && f<=h)
24 | 		{
25 | 			sister[q++]=f;
26 | 			b++;
27 | 			if (f==e)	a++;
28 | 			if (f==g)	c++;
29 | 			if (f==h)	d++;
30 | 		}
31 | 		else if (g<=e && g<=f && g<=h)
32 | 		{
33 | 			sister[q++]=g;
34 | 			c++;
35 | 			if (g==e)	a++;
36 | 			if (g==f)	b++;
37 | 			if (g==h)	d++;
38 | 		}
39 | 		else {
40 | 			sister[q++]=h;
41 | 			d++;
42 | 			if (h==e)	a++;
43 | 			if (h==f)	b++;
44 | 			if (h==g)	c++;
45 | 		}
46 | 	}
47 | }
48 | int main()
49 | {
50 | 	int test,i,j;
51 | 	make();
52 | 	scanf("%d\n",&test);
53 | 	for (i=0;i<test;i++)
54 | 	{
55 | 		scanf("%d",&j);
56 | 		printf("%I64d\n",sister[j]);
57 | 	}
58 | 	return 0;
59 | }
60 | 


--------------------------------------------------------------------------------
/poj/3312.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | #include<stdlib.h>
 4 | int n,k;
 5 | int len[1000];
 6 | int cmp(const void *a, const void *b)
 7 | {
 8 | 	int x,y;
 9 | 	x=*(int *)a;
10 | 	y=*(int *)b;
11 | 	if (x<y)
12 | 		return -1;
13 | 	else if (x>y)
14 | 		return 1;
15 | 	else return 0;
16 | }
17 | int main()
18 | {
19 | 	int test=1,i,j,l,s;
20 | 	char str[200];
21 | 	while (scanf("%d%d\n",&n,&k),n!=0 || k!=0)
22 | 	{
23 | 		for (i=0;i<n;i++)
24 | 		{
25 | 			scanf("%s\n",str);
26 | 			len[i]=strlen(str);
27 | 		}
28 | 		qsort(len,n,sizeof(len[0]),cmp);
29 | 		j=n/k;
30 | 		printf("Case %d: ",test++);
31 | 		for (i=0;i<j;i++)
32 | 		{
33 | 			for (l=0,s=0;l<k;l++)
34 | 				s+=len[i*k+l];
35 | 			s/=k;
36 | 			for (l=0;l<k;l++)
37 | 				if (len[i*k+l]>s+2 || s-2>len[i*k+l])
38 | 					break;
39 | 			if (l<k)
40 | 				break;
41 | 		}
42 | 		if (i<j)
43 | 			printf("no\n\n");
44 | 		else printf("yes\n\n");
45 | 	}
46 | 	return 0;
47 | }
48 | 


--------------------------------------------------------------------------------
/poj/3318.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | int n;
 4 | int A[500][500],B[500][500],C[500][500];
 5 | __int64 a[500],b[500],c[500],X[500];
 6 | void input(int x[][500])
 7 | {
 8 | 	int i,j;
 9 | 	for (i=0;i<n;i++)
10 | 		for (j=0;j<n;j++)
11 | 			scanf("%d",&x[i][j]);
12 | }
13 | void muti(int x[][500],__int64 *y,__int64 *z)//x(n*n)y(n*1)=z(n*1)
14 | {
15 | 	int i,j;
16 | 	for (i=0;i<n;i++)
17 | 	{
18 | 		z[i]=0;
19 | 		for (j=0;j<n;j++)
20 | 			z[i]+=y[j]*x[i][j];
21 | 	}
22 | }
23 | int main()
24 | {
25 | 	int j;
26 | 	scanf("%d",&n);
27 | 	srand(n);
28 | 	input(A);
29 | 	input(B);
30 | 	input(C);
31 | 	for (j=0;j<n;j++)
32 | 		X[j]=rand();
33 | 	muti(C,X,c);
34 | 	muti(B,X,b);
35 | 	muti(A,b,a);
36 | 	for (j=0;j<n;j++)
37 | 		if (c[j]!=a[j])
38 | 			break;
39 | 	if (j<n)
40 | 		printf("NO\n");
41 | 	else printf("YES\n");
42 | 	return 0;
43 | }
44 | 


--------------------------------------------------------------------------------
/poj/3325.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int n;
 3 | int min,max,sum;
 4 | int main()
 5 | {
 6 | 	int i,j;
 7 | 	while (scanf("%d",&n),n!=0)
 8 | 	{
 9 | 		min=1001;
10 | 		max=-1;
11 | 		sum=0;
12 | 		for (i=0;i<n;i++)
13 | 		{
14 | 			scanf("%d",&j);
15 | 			sum+=j;
16 | 			if (j>max)
17 | 				max=j;
18 | 			if (j<min)
19 | 				min=j;
20 | 		}
21 | 		sum=sum-min-max;
22 | 		sum/=(n-2);
23 | 		printf("%d\n",sum);
24 | 	}
25 | 	return 0;
26 | }
27 | 


--------------------------------------------------------------------------------
/poj/3331.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <string.h>
 3 | int muil(int n,int p)
 4 | {
 5 | 	int i,j,a,b;
 6 | 	char s[800]={'1'};
 7 | 	for (i=2;i<=n;i++)
 8 | 	{
 9 | 		for (j=strlen(s)-1;j>=0;j--)
10 | 		{
11 | 			a=(s[j]-'0')*i;
12 | 			b=j;
13 | 			s[b++]=a%10+'0';
14 | 			a/=10;
15 | 			while (a)
16 | 			{
17 | 				if (s[b]=='\0')
18 | 					s[b]=a%10+'0';
19 | 				else s[b]+=a%10;
20 | 				a/=10;
21 | 				if (s[b]>'9')
22 | 				{
23 | 					s[b]-=10;
24 | 					a++;
25 | 				}
26 | 				b++;
27 | 			}
28 | 		}
29 | 	}
30 | 	n=strlen(s);
31 | 	for (i=0,j=0;i<n;i++)
32 | 		if (s[i]-'0'==p)
33 | 			j++;
34 | 	return j;
35 | }
36 | int main ()
37 | {
38 | 	int n,p,t,i;
39 | 	scanf("%d",&t);
40 | 	for (i=0;i<t;i++)
41 | 	{
42 | 		scanf("%d%d",&n,&p);
43 | 		printf("%d\n",muil(n,p));
44 | 	}
45 | 	return 0;
46 | }
47 | 


--------------------------------------------------------------------------------
/poj/3366.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | int L,N;
 4 | char irregularWord[20][2][30];
 5 | int main()
 6 | {
 7 | 	int i,j;
 8 | 	char word[30];
 9 | 	scanf("%d%d",&L,&N);
10 | 	for (i=0;i<L;i++)
11 | 		scanf("%s%s",irregularWord[i][0],irregularWord[i][1]);
12 | 	for (i=0;i<N;i++)
13 | 	{
14 | 		scanf("%s",word);
15 | 		for (j=0;j<L;j++)
16 | 			if (strcmp(word,irregularWord[j][0])==0)
17 | 				break;
18 | 		if (j<L)
19 | 		{
20 | 			printf("%s\n",irregularWord[j][1]);
21 | 			continue;
22 | 		}
23 | 		for (j=0;word[j+1]!='\0';j++)
24 | 			putchar(word[j]);
25 | 		if (word[j]=='y' && word[j-1]!='a' && word[j-1]!='e' && word[j-1]!='i' && word[j-1]!='o' && word[j-1]!='u')
26 | 			printf("ies\n");
27 | 		else if (word[j]=='o' || word[j]=='s' || word[j]=='x' || (word[j]=='h' && (word[j-1]=='c' || word[j-1]=='s')))
28 | 			printf("%ces\n",word[j]);
29 | 		else printf("%cs\n",word[j]);
30 | 	}
31 | 	return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/poj/3372.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int n;
 3 | int main ()
 4 | {
 5 | 	while (scanf("%d",&n)!=EOF)
 6 | 	{
 7 | 		while (n%2==0)
 8 | 			n=n>>1;
 9 | 		if (n==1)
10 | 			printf("YES\n");
11 | 		else printf("NO\n");
12 | 	}
13 | 	return 0;
14 | }
15 | 


--------------------------------------------------------------------------------
/poj/3385.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int A,a,B,b,P;
 3 | int main ()
 4 | {
 5 | 	scanf("%d%d%d%d%d",&A,&a,&B,&b,&P);
 6 | 	if (A<=P && B<=P && (A+B<=P || A<=b || B<=a))
 7 | 		printf("Yes\n");
 8 | 	else printf("No\n");
 9 | 	return 0;
10 | }
11 | 


--------------------------------------------------------------------------------
/poj/3404.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | int speed[100],n;
 4 | int cmp(const void *a, const void *b)
 5 | {
 6 | 	int x,y;
 7 | 	x=*(int *)a;
 8 | 	y=*(int *)b;
 9 | 	if (x<y)
10 | 		return -1;
11 | 	else if (x>y)
12 | 		return 1;
13 | 	else return 0;
14 | }
15 | 
16 | int main()
17 | {
18 | 	int i,s;
19 | 	scanf("%d",&n);
20 | 	for (i=0;i<n;i++)
21 | 		scanf("%d",&speed[i]);
22 | 	qsort(speed,n,sizeof(speed[0]),cmp);
23 | 	s=0;
24 | 	while (n>=4)
25 | 	{
26 | 		n-=2;
27 | 		if (speed[0]+speed[n]>speed[1]+speed[1])
28 | 			s+=speed[0]+speed[1]+speed[1]+speed[n+1];
29 | 		else s+=speed[0]+speed[0]+speed[n]+speed[n+1];
30 | 	}
31 | 	if (n==3)
32 | 		s+=speed[0]+speed[1]+speed[2];
33 | 	else if (n==2)
34 | 		s+=speed[1];
35 | 	else s+=speed[0];
36 | 	printf("%d\n",s);
37 | 	return 0;
38 | }
39 | 


--------------------------------------------------------------------------------
/poj/3425.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int N;
 3 | int question[1000001]={0};
 4 | int sum=0;
 5 | int main()
 6 | {
 7 | 	int i;
 8 | 	int a,b,c;
 9 | 	scanf("%d\n",&N);
10 | 	for (i=0;i<N;i++)
11 | 	{
12 | 		scanf("%d%d%d",&a,&b,&c);
13 | 		if (b==0)
14 | 			sum+=10;
15 | 		else
16 | 		{
17 | 			sum+=question[a]*10;
18 | 			question[a]++;
19 | 			if (c==1)
20 | 				sum+=40;
21 | 			else sum+=20;
22 | 		}
23 | 	}
24 | 	printf("%d\n",sum);
25 | 	return 0;
26 | }
27 | 


--------------------------------------------------------------------------------
/poj/3427.java:
--------------------------------------------------------------------------------
 1 | //Main.java
 2 | 
 3 | import java.util.*;
 4 | 
 5 | public class Main
 6 | {
 7 | 	public static void main(String args[]) throws Exception
 8 | 	{
 9 | 		Scanner cin=new Scanner(System.in);
10 | 		int n=cin.nextInt();
11 | 		int l=cin.nextInt();
12 | 		int[] tree=new int[l];
13 | 		for (int i=0;i<n;i++)
14 | 		{
15 | 			int j=cin.nextInt();
16 | 			tree[j%l]++;
17 | 		}
18 | 		int min=0;
19 | 		int year=0,temp;
20 | 		for (int i=1;i<l;i++)
21 | 			min+=i*tree[i];
22 | 		for (int i=1;i<l;i++)
23 | 		{
24 | 			temp=min-l*tree[l-i]+n;
25 | 			if (temp<min)
26 | 			{
27 | 				min=temp;
28 | 				year=i;
29 | 			}
30 | 		}
31 | 		System.out.println(year);
32 | 	}
33 | }
34 | 


--------------------------------------------------------------------------------
/poj/3438.java:
--------------------------------------------------------------------------------
 1 | //Main.java
 2 | 
 3 | import java.util.*;
 4 | 
 5 | public class Main
 6 | {
 7 | 	public static void main(String args[]) throws Exception
 8 | 	{
 9 | 		Scanner cin=new Scanner(System.in);
10 | 		int n=cin.nextInt();
11 | 		for (int i=0;i<n;i++)
12 | 		{
13 | 			String s=cin.next();
14 | 			char t=s.charAt(0),r;
15 | 			int sum=1;
16 | 			for (int j=1;j<s.length();j++)
17 | 			{
18 | 				r=s.charAt(j);
19 | 				if (r==t)
20 | 					sum++;
21 | 				else {
22 | 					System.out.print(sum);
23 | 					System.out.print(t);
24 | 					sum=1;
25 | 					t=r;
26 | 				}
27 | 			}
28 | 			System.out.print(sum);
29 | 			System.out.print(t);
30 | 			System.out.println();
31 | 		}
32 | 	}
33 | }
34 | 


--------------------------------------------------------------------------------
/poj/3444.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int n;
 3 | int A[256],B[256];
 4 | void cal(int s,int d,int p)
 5 | {
 6 | 	int a=A[s]+A[d];
 7 | 	int b=A[s]-A[d];
 8 | 	B[p]=a/2;
 9 | 	B[p+1]=b/2;
10 | }
11 | int main()
12 | {
13 | 	int i,j;
14 | 	int step;
15 | 	while (scanf("%d",&n),n!=0)
16 | 	{
17 | 		for (i=0;i<n;i++)
18 | 			scanf("%d",&A[i]);
19 | 		B[0]=A[0];
20 | 		step=1;
21 | 		while (step<n)
22 | 		{
23 | 			for (i=0,j=0;i<step;i++,j+=2)
24 | 				cal(i,i+step,j);
25 | 			step+=step;
26 | 			for (i=0;i<step;i++)
27 | 				A[i]=B[i];
28 | 		}
29 | 		for (i=0;i<n;i++)
30 | 			printf("%d ",B[i]);
31 | 		putchar('\n');
32 | 	}
33 | 	return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/poj/3507.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int i;
 5 | 	int max,min,sum;
 6 | 	int s[6];
 7 | 	while (1)
 8 | 	{
 9 | 		scanf("%d",&s[0]);
10 | 		max=min=sum=s[0];
11 | 		for (i=1;i<6;i++)
12 | 		{
13 | 			scanf("%d",&s[i]);
14 | 			sum+=s[i];
15 | 			if (s[i]>max)
16 | 				max=s[i];
17 | 			if (s[i]<min)
18 | 				min=s[i];
19 | 		}
20 | 		if (sum==0)
21 | 			break;
22 | 		printf("%g\n",((double)(sum-min-max))/4.0);
23 | 	}
24 | 	return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/poj/3517.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int n,k,m;
 3 | int main()
 4 | {
 5 | 	int i,j;
 6 | 	while (scanf("%d%d%d",&n,&k,&m),n!=0 || k!=0 || m!=0) 
 7 | 	{
 8 | 		for (i=2,j=0;i<n;i++)
 9 | 		{
10 | 			j=(j+k)%i;
11 | 		}
12 | 		j=(j+m)%n+1;
13 | 		printf("%d\n",j);
14 | 	}
15 | 	return 0;
16 | }
17 | 


--------------------------------------------------------------------------------
/poj/3518.java:
--------------------------------------------------------------------------------
 1 | //Main.java
 2 | 
 3 | import java.util.*;
 4 | 
 5 | public class Main
 6 | {
 7 | 	public static void main(String args[]) throws Exception
 8 | 	{
 9 | 		Scanner cin=new Scanner(System.in);
10 | 		int n;
11 | 		boolean[] prime=new boolean[1301882];
12 | 		for (int i=2;i<=1141;i++)
13 | 			for (int j=i+i;j<1301882;j+=i)
14 | 				prime[j]=true;
15 | 		while ((n=cin.nextInt())!=0)
16 | 		{
17 | 			int a=n,b=n;
18 | 			while (prime[a]==true)
19 | 				a--;
20 | 			while (prime[b]==true)
21 | 				b++;
22 | 			System.out.println(b-a);
23 | 		}
24 | 	}
25 | }
26 | 


--------------------------------------------------------------------------------
/poj/3589.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int n;
 3 | char s[10],t[10];
 4 | int main()
 5 | {
 6 | 	int i,j;
 7 | 	int a,b;
 8 | 	int num[10];
 9 | 	scanf("%d",&n);
10 | 	for (i=0;i<n;i++)
11 | 	{
12 | 		a=0;
13 | 		b=0;
14 | 		scanf("%s%s",s,t);
15 | 		for (j=0;j<10;j++)
16 | 			num[j]=0;
17 | 		for (j=0;j<4;j++)
18 | 			num[s[j]-'0']=1;
19 | 		for (j=0;j<4;j++)
20 | 		{
21 | 			if (num[t[j]-'0']==1)
22 | 				b++;
23 | 			if (s[j]==t[j])
24 | 			{
25 | 				a++;
26 | 				b--;
27 | 			}
28 | 		}
29 | 		printf("%dA%dB\n",a,b);
30 | 	}
31 | 	return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/poj/3619.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int N,K;
 3 | int s,t,r;
 4 | int main()
 5 | {
 6 | 	int i,j;
 7 | 	scanf("%d%d",&N,&K);
 8 | 	for (i=0;i<K;i++)
 9 | 	{
10 | 		scanf("%d%d%d",&s,&t,&r);
11 | 		j=N/(s*t);
12 | 		j*=t+r;
13 | 		if (N%(s*t)==0)
14 | 			j-=r;
15 | 		else j+=(N%(s*t)-1)/s+1;
16 | 		printf("%d\n",j);
17 | 	}
18 | 	return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/poj/3620.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int N,M,K;
 3 | int k;
 4 | bool farm[101][101]={false};
 5 | void dfs(int p,int q)
 6 | {
 7 | 	farm[p][q]=false;
 8 | 	k++;
 9 | 	if (p>1 && farm[p-1][q]==true)
10 | 		dfs(p-1,q);
11 | 	if (p<N && farm[p+1][q]==true)
12 | 		dfs(p+1,q);
13 | 	if (q>1 && farm[p][q-1]==true)
14 | 		dfs(p,q-1);
15 | 	if (q<M && farm[p][q+1]==true)
16 | 		dfs(p,q+1);
17 | }
18 | int main()
19 | {
20 | 	int i,j,a,b;
21 | 	int max=0;
22 | 	scanf("%d%d%d",&N,&M,&K);
23 | 	for (i=0;i<K;i++)
24 | 	{
25 | 		scanf("%d%d",&a,&b);
26 | 		farm[a][b]=true;
27 | 	}
28 | 	for (i=1;i<=N;i++)
29 | 	{
30 | 		for (j=1;j<=M;j++)
31 | 		{
32 | 			if (farm[i][j]==true)
33 | 			{
34 | 				k=0;
35 | 				dfs(i,j);
36 | 				if (k>max)
37 | 					max=k;
38 | 			}
39 | 		}
40 | 	}
41 | 	printf("%d\n",max);
42 | 	return 0;
43 | }
44 | 


--------------------------------------------------------------------------------
/poj/3624.cc:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | int dp[12881] = {0};
 3 | int main() 
 4 | { 
 5 |     int N, M;
 6 |     std::cin>>N>>M;
 7 |     for (int i=0; i<N; i++)
 8 |     {
 9 |         int w, v;
10 |         std::cin>>w>>v;
11 |         for (int j=M; j>=w; j--)
12 |         {
13 |             if (j >= w && (dp[j-w]+v) > dp[j]) {
14 |                 dp[j] = dp[j-w]+v;
15 |             }
16 |         }
17 |     }
18 |     std::cout<<dp[M]<<std::endl;
19 |     return 0;
20 | }


--------------------------------------------------------------------------------
/poj/3627.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | int N,B;
 4 | int cow[20000];
 5 | int cmp(const void *a, const void *b)
 6 | {
 7 | 	int x,y;
 8 | 	x=*(int *)a;
 9 | 	y=*(int *)b;
10 | 	if (x>y)
11 | 		return -1;
12 | 	else if (x<y)
13 | 		return 1;
14 | 	else return 0;
15 | }
16 | int main()
17 | {
18 | 	int i;
19 | 	int sum=0;
20 | 	scanf("%d%d",&N,&B);
21 | 	for (i=0;i<N;i++)
22 | 		scanf("%d",&cow[i]);
23 | 	qsort(cow,N,sizeof(cow[0]),cmp);
24 | 	for (i=0;i<N;i++)
25 | 	{
26 | 		sum+=cow[i];
27 | 		if (sum>=B)
28 | 			break;
29 | 	}
30 | 	printf("%d\n",i+1);
31 | 	return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/poj/3630.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | #include<stdlib.h>
 4 | int sequence[10000];
 5 | char phone[10000][20];
 6 | int cmp(const void *a,const void *b)
 7 | {
 8 | 	int x=*(int *)a;
 9 | 	int y=*(int *)b;
10 | 	if (strcmp(phone[x],phone[y])<0)
11 | 		return -1;
12 | 	else if (strcmp(phone[x],phone[y])>0)
13 | 		return 1;
14 | 	else return 0;
15 | }
16 | int main()
17 | {
18 | 	int i,j;
19 | 	int t,n;
20 | 	scanf("%d",&t);
21 | 	for (i=0;i<t;i++)
22 | 	{
23 | 		scanf("%d\n",&n);
24 | 		for (j=0;j<n;j++)
25 | 		{
26 | 			gets(phone[j]);
27 | 			sequence[j]=j;
28 | 		}
29 | 		qsort(sequence,n,sizeof(sequence[0]),cmp);
30 | 		for (j=1;j<n;j++)
31 | 		{
32 | 			if (strncmp(phone[sequence[j-1]],phone[sequence[j]],strlen(phone[sequence[j-1]]))==0)
33 | 				break;
34 | 		}
35 | 		if (j<n)
36 | 			printf("NO\n");
37 | 		else printf("YES\n");
38 | 	}
39 | 	return 0;
40 | }
41 | 


--------------------------------------------------------------------------------
/poj/3632.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int main()
 3 | {
 4 | 	int test,t,i,j,n;
 5 | 	int max,min;
 6 | 	scanf("%d",&test);
 7 | 	for (t=0;t<test;t++)
 8 | 	{
 9 | 		scanf("%d",&n);
10 | 		max=-1;
11 | 		min=100;
12 | 		for (i=0;i<n;i++)
13 | 		{
14 | 			scanf("%d",&j);
15 | 			if (j>max)
16 | 				max=j;
17 | 			if (j<min)
18 | 				min=j;
19 | 		}
20 | 		printf("%d\n",2*(max-min));
21 | 	}
22 | 	return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/poj/3637.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | 
 3 | public class Main {
 4 | 
 5 | 	public static void main(String[] args) throws Exception
 6 | 	{
 7 | 		Scanner cin=new Scanner(System.in);
 8 | 		int test = cin.nextInt();
 9 | 		for (int t = 0; t < test; t++)
10 | 		{
11 | 			int num = cin.nextInt();
12 | 			int[] item = new int[num];
13 | 			for (int i = 0; i < num; i++)
14 | 			{
15 | 				item[i] = cin.nextInt();
16 | 			}
17 | 			Arrays.sort(item);
18 | 			int sum = 0;
19 | 			for (int i = num - 3; i >= 0; i-=3)
20 | 				sum+=item[i];
21 | 			System.out.println(sum);
22 | 		}
23 | 	}
24 | }
25 | 


--------------------------------------------------------------------------------
/poj/3650.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | char s[100];
 4 | int main()
 5 | {
 6 | 	int i;
 7 | 	int sum=0;
 8 | 	gets(s);
 9 | 	while (strcmp(s,"#")!=0)
10 | 	{
11 | 		for (i=0;s[i]!='\0';i++)
12 | 		{
13 | 			if (s[i]==' ')
14 | 				printf("%%20");
15 | 			else if (s[i]=='!')
16 | 				printf("%%21");
17 | 			else if (s[i]=='$')
18 | 				printf("%%24");
19 | 			else if (s[i]=='%')
20 | 				printf("%%25");
21 | 			else if (s[i]=='(')
22 | 				printf("%%28");
23 | 			else if (s[i]==')')
24 | 				printf("%%29");
25 | 			else if (s[i]=='*')
26 | 				printf("%%2a");
27 | 			else putchar(s[i]);
28 | 		}
29 | 		putchar('\n');
30 | 		gets(s);
31 | 	}
32 | 	return 0;
33 | }
34 | 


--------------------------------------------------------------------------------
/poj/3660.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/snuc/poj/80cccc7287f23d33cde75b51a78a04bdb75408cb/poj/3660.cpp


--------------------------------------------------------------------------------
/poj/3663.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | int N,S;
 4 | int cow[20000];
 5 | int cmp(const void *a, const void *b)
 6 | {
 7 | 	int x,y;
 8 | 	x=*(int *)a;
 9 | 	y=*(int *)b;
10 | 	if (x<y)
11 | 		return -1;
12 | 	else if (x>y)
13 | 		return 1;
14 | 	else return 0;
15 | }
16 | int main()
17 | {
18 | 	int i,j;
19 | 	int sum=0;
20 | 	scanf("%d%d",&N,&S);
21 | 	for (i=0;i<N;i++)
22 | 		scanf("%d",&cow[i]);
23 | 	qsort(cow,N,sizeof(cow[0]),cmp);
24 | 	for (i=0,j=N-1;i<N && j>i;i++)
25 | 	{
26 | 		while (j>i && cow[i]+cow[j]>S)
27 | 			j--;
28 | 		sum+=j-i;
29 | 	}
30 | 	printf("%d\n",sum);
31 | 	return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/poj/3664.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | int N,K;
 4 | int cow[50000][2],rank[50000];
 5 | int cmp(const void *a, const void *b)
 6 | {
 7 | 	int x,y;
 8 | 	x=*(int *)a;
 9 | 	y=*(int *)b;
10 | 	if (cow[x][0]>cow[y][0])
11 | 		return -1;
12 | 	else if (cow[x][0]<cow[y][0])
13 | 		return 1;
14 | 	else return 0;
15 | }
16 | int main()
17 | {
18 | 	int i,j;
19 | 	scanf("%d%d",&N,&K);
20 | 	for (i=0;i<N;i++)
21 | 	{
22 | 		scanf("%d%d",&cow[i][0],&cow[i][1]);
23 | 		rank[i]=i;
24 | 	}
25 | 	qsort(rank,N,sizeof(rank[0]),cmp);
26 | 	for (i=1,j=0;i<K;i++)
27 | 	{
28 | 		if (cow[rank[i]][1]>cow[rank[j]][1])
29 | 			j=i;
30 | 	}
31 | 	printf("%d\n",rank[j]+1);
32 | 	return 0;
33 | }
34 | 


--------------------------------------------------------------------------------
/poj/3671.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int N,cow;
 3 | int Group[30001]={0};
 4 | int main()
 5 | {
 6 | 	int i,j,k;
 7 | 	int min;
 8 | 	scanf("%d",&N);
 9 | 	for (i=1,j=0;i<=N;i++)
10 | 	{
11 | 		scanf("%d",&cow);
12 | 		Group[i]=Group[i-1];
13 | 		if (cow==2)
14 | 			Group[i]++;
15 | 	}
16 | 	j=N-Group[N];
17 | 	min=N;
18 | 	for (i=0;i<=N;i++)
19 | 	{
20 | 		k=Group[i]+j-(i-Group[i]);
21 | 		if (k<min)
22 | 			min=k;
23 | 	}
24 | 	printf("%d\n",min);
25 | 	return 0;
26 | }
27 | 


--------------------------------------------------------------------------------
/poj/3672.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int M,T,U,F,D;
 3 | int main()
 4 | {
 5 | 	int i,j;
 6 | 	int sum=0;
 7 | 	char c;
 8 | 	scanf("%d%d%d%d%d\n",&M,&T,&U,&F,&D);
 9 | 	for (i=0;i<T;i++)
10 | 	{
11 | 		scanf("%c\n",&c);
12 | 		if (sum>=M)
13 | 			continue;
14 | 		j=i;
15 | 		if (c=='u' || c=='d')
16 | 			sum+=U+D;
17 | 		else if (c=='f')
18 | 			sum+=F+F;
19 | 	}
20 | 	printf("%d\n",j);
21 | 	return 0;
22 | }
23 | 


--------------------------------------------------------------------------------
/poj/3673.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | char s[100],t[100];
 3 | int main()
 4 | {
 5 | 	int i,j;
 6 | 	int sum=0;
 7 | 	scanf("%s%s",s,t);
 8 | 	for (i=0;s[i]!='\0';i++)
 9 | 		for (j=0;t[j]!='\0';j++)
10 | 			sum+=(s[i]-'0')*(t[j]-'0');
11 | 	printf("%d\n",sum);
12 | 	return 0;
13 | }


--------------------------------------------------------------------------------
/poj/3720.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int n,k;
 3 | int digit[101][10]={0};
 4 | void cal(int p)
 5 | {
 6 | 	int temp[10]={0};
 7 | 	int mod[100]={0,1};
 8 | 	int i=1;
 9 | 	while (1)
10 | 	{
11 | 		i*=10;
12 | 		temp[i/p]++;
13 | 		if (i%p==0 || mod[i%p]==1)
14 | 			break;
15 | 		mod[i%p]=1;
16 | 		i-=i/p*p;
17 | 	}
18 | 	for (i=0;i<10;i++)
19 | 		digit[p][i]=digit[p-1][i]+temp[i];
20 | }
21 | int main()
22 | {
23 | 	int i;
24 | 	for (i=2;i<=100;i++)
25 | 		cal(i);
26 | 	while (scanf("%d%d",&n,&k)!=EOF)
27 | 		printf("%d\n",digit[n][k]);
28 | 	return 0;
29 | }
30 | 


--------------------------------------------------------------------------------
/poj/3723.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/snuc/poj/80cccc7287f23d33cde75b51a78a04bdb75408cb/poj/3723.cpp


--------------------------------------------------------------------------------
/poj/3913.cc:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | int main()
 3 | {
 4 |     int n;
 5 |     std::cin>>n;
 6 |     std::cout<<"Gnomes:"<<std::endl;
 7 |     for (int i=0; i<n; i++)
 8 |     {
 9 |         int a, b, c;
10 |         std::cin>>a>>b>>c;
11 |         if ((a<b && b<c) || (a>b && b>c)) {
12 |             std::cout<<"Ordered"<<std::endl;
13 |         }
14 |         else std::cout<<"Unordered"<<std::endl;
15 |     }
16 |     return 0;
17 | }
18 | 


--------------------------------------------------------------------------------
/poj/3978.cc:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | int main()
 3 | {
 4 |     int primenum[10000] = {0};
 5 |     bool prime[10000] = {true, true};
 6 |     for (int i=2; i<10000; i++)
 7 |     {
 8 |         primenum[i] = primenum[i-1];
 9 |         if (prime[i] == true) {
10 |             continue;
11 |         }
12 |         for (int j=i+i; j<10000; j+=i) {
13 |             prime[j] = true;
14 |         }
15 |         primenum[i]++;
16 |     }
17 |     int a, b;
18 |     std::cin>>a>>b;
19 |     while (a!=-1 || b!=-1) {
20 |         if (a<=0) {
21 |             a=1;
22 |         }
23 |         std::cout<<primenum[b]-primenum[a-1]<<std::endl;
24 |         std::cin>>a>>b;
25 |     }
26 |     return 0;
27 | }
28 | 


--------------------------------------------------------------------------------
/poj/3979.cc:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | int gcd(int a,int b);
 4 | int gcd(int a,int b)
 5 | {
 6 |     int temp;
 7 |     if(a < b)
 8 |     {
 9 |         temp = a;
10 |         a = b;
11 |         b = temp;
12 |     }
13 |     while(b != 0)
14 |     {
15 |         temp = a % b;
16 |         a = b;
17 |         b = temp;
18 |     }
19 |     return a;
20 | }
21 | int main (int argc, const char * argv[])
22 | {
23 |     int a, b, c, d;
24 |     int l, m, n;
25 |     
26 |     while (scanf("%d/%d%d/%d", &a, &b, &c, &d) != EOF) {
27 |         m = a * d;
28 |         n = c * b;
29 |         m = m + n;
30 |         n = b * d;
31 |         if (m == 0) {
32 |             printf("0\n");
33 |         }
34 |         else {
35 |             if (m < 0)
36 |                 l = gcd(-m, n);
37 |             else l = gcd(m, n);
38 |             if (n == l)
39 |                 printf("%d\n", m/l);
40 |             else printf("%d/%d\n", m/l, n/l);
41 |         }
42 |     }
43 |     return 0;
44 | }
45 | 


--------------------------------------------------------------------------------
/poj/3980.cc:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | int main (int argc, const char * argv[])
 4 | {
 5 |     int m, n;
 6 |     while (scanf("%d%d", &m, &n) != EOF) {
 7 |         printf("%d\n", m % n);
 8 |     }
 9 |     return 0;
10 | }
11 | 


--------------------------------------------------------------------------------
/poj/3981.cc:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | int main (int argc, const char * argv[])
 4 | {
 5 |     int i;
 6 |     char str[2000];
 7 |     while (gets(str) != NULL) {
 8 |         for (i=0; str[i]!='\0'; i++)
 9 |         {
10 |             if (str[i] == 'y' && str[i+1] == 'o' && str[i+2] == 'u')
11 |             {
12 |                 putchar('w');
13 |                 putchar('e');
14 |                 i+=2;
15 |             }
16 |             else putchar(str[i]);
17 |         }
18 |         putchar('\n');
19 |     }
20 |     return 0;
21 | }
22 | 


--------------------------------------------------------------------------------
/poj/3982.java:
--------------------------------------------------------------------------------
 1 | //Main.java
 2 | import java.util.*;
 3 | import java.math.*;
 4 | 
 5 | public class Main 
 6 | {
 7 | 	public static void main(String[] args)
 8 | 	{
 9 | 		Scanner cin=new Scanner(System.in);
10 | 		while (cin.hasNextBigInteger() == true)
11 | 		{
12 | 			BigInteger D = cin.nextBigInteger();
13 | 			BigInteger C = cin.nextBigInteger();
14 | 			BigInteger B = cin.nextBigInteger();
15 | 			BigInteger A = new BigInteger("0");
16 | 			for (int i=3; i<100; i++)
17 | 			{
18 | 				A = B.add(C).add(D);
19 |         		D = C;
20 |         		C = B;
21 |         		B = A;
22 | 			}
23 | 			System.out.println(A);
24 | 		}
25 | 	}
26 | }


--------------------------------------------------------------------------------
/poj/3983.cc:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 |  
 4 | int main (int argc, char **argv)
 5 | {
 6 | 	int a,b,c,d;
 7 | 	cin>>a>>b>>c>>d;
 8 | 	cout<<"5*(5-(1/5))"<<endl;
 9 | 	
10 | 	return 0;
11 | }


--------------------------------------------------------------------------------