Merge pull request #36 from KiritoTRw/master

Powered By HC TECH : AutoACer Engine

HDOJ/2000_autoAC.cpp

@@ -0,0 +1,15 @@
+#include <iostream>
+#include <algorithm>
+using namespace std;
+int main(void)
+{
+	char n[4];
+	while (cin >> n)
+	{
+		if (n[0] > n[1]) swap(n[0], n[1]);
+		if (n[1] > n[2]) swap(n[1], n[2]);
+		if (n[0] > n[1]) swap(n[0], n[1]);
+		cout << n[0] << ' ' << n[1] << ' ' << n[2] << endl;
+	}
+	return 0;
+}

HDOJ/2001_autoAC.cpp

@@ -0,0 +1,9 @@
+#include <cmath>
+#include <cstdio>
+int main(void)
+{
+    double x[2], y[2];
+    while (scanf("%lf%lf%lf%lf", x, y, x+1, y+1) != EOF)
+        printf("%.2f\n", sqrt((x[1]-x[0])*(x[1]-x[0]) + (y[1]-y[0])*(y[1]-y[0])));
+    return 0;
+}

HDOJ/2002_autoAC.cpp

@@ -0,0 +1,10 @@
+#include <math.h>
+#include <stdio.h>
+#define PI 3.1415927
+int main(void)
+{
+    double r;
+    while (scanf("%lf", &r) != EOF)
+        printf("%.3lf\n", 4.0*PI*r*r*r/3.0);
+    return 0;
+}

HDOJ/2003_autoAC.cpp

@@ -0,0 +1,9 @@
+#include <math.h>
+#include <stdio.h>
+int main(void)
+{
+    double r;
+    while (scanf("%lf", &r) != EOF)
+        printf("%.2lf\n", fabs(r));
+    return 0;
+}

HDOJ/2004_autoAC.cpp

@@ -0,0 +1,24 @@
+#include <math.h>
+#include <stdio.h>
+int main(void)
+{
+    int r;
+    while (scanf("%d", &r) != EOF)
+    {
+        if (r < 0)
+            puts("Score is error!");
+        else if (r < 60)
+            puts("E");
+        else if (r < 70)
+            puts("D");
+        else if (r < 80)
+            puts("C");
+        else if (r < 90)
+            puts("B");
+        else if (r < 101)
+            puts("A");
+        else
+            puts("Score is error!");
+    }
+    return 0;
+}

HDOJ/2005_autoAC.cpp

@@ -0,0 +1,19 @@
+#include <math.h>
+#include <stdio.h>
+#define lev(n) (n % 4 == 0 && (n % 100 != 0 || n % 400 == 0))
+int main(void)
+{
+    int y, m, d, i, s;
+    int month[2][13] = {
+        {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
+        {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
+    };
+    while (scanf("%d/%d/%d", &y, &m, &d) != EOF)
+    {
+        for (s = 0, i = 1 ; i < m ; i++)
+            s += month[lev(y)][i];
+        s += d;
+        printf("%d\n", s);
+    }
+    return 0;
+}

HDOJ/2006_autoAC.cpp

@@ -0,0 +1,15 @@
+#include <stdio.h>
+int main(void)
+{
+    int n, i, s, t;
+    while (scanf("%d", &n) != EOF)
+    {
+        for (s = 1, i = 0 ; i < n ; i++)
+        {
+            scanf("%d", &t);
+            if (t & 1) s *= t;
+        }
+        printf("%d\n", s);
+    }
+    return 0;
+}

HDOJ/2007_autoAC.cpp

@@ -0,0 +1,19 @@
+#include <stdio.h>
+int main(void)
+{
+    unsigned int m, n, i, x, y;
+    while (scanf("%u%u", &m, &n) != EOF)
+    {
+        if (m > n)
+        {
+            i = n;
+            n = m;
+            m = i;
+        }
+        x = y = 0;
+        for (i = m ; i <= n ; i++)
+            (i & 1) ? (y += i*i*i) : (x += i*i);
+        printf("%u %u\n", x, y);
+    }
+    return 0;
+}

HDOJ/2008_autoAC.cpp

@@ -0,0 +1,19 @@
+#include <stdio.h>
+int main(void)
+{
+    int n, i, a, b, c;
+    double x;
+    while (scanf("%d", &n) , n)
+    {
+        a = b = c = 0;
+        for (i = 0 ; i < n ; i++)
+        {
+            scanf("%lf", &x);
+            if (x > 0) c++;
+            else if (x < 0) a++;
+            else b++;
+        }
+        printf("%d %d %d\n", a, b, c);
+    }
+    return 0;
+}

HDOJ/2009_autoAC.cpp

@@ -0,0 +1,14 @@
+#include <math.h>
+#include <stdio.h>
+int main(void)
+{
+    int n;
+    double x, s;
+    while (scanf("%lf%d", &x, &n) != EOF)
+    {
+        for(s = 0.0; n--; x = sqrt(x))
+            s += x;
+        printf("%.2lf\n", s);
+    }
+    return 0;
+}

HDOJ/2010_autoAC.cpp

@@ -0,0 +1,17 @@
+#include<stdio.h>
+int main()
+{
+    int b, l, c, i;
+    int a[] = {1, 153, 370, 371, 407};
+    while (scanf("%d%d", &b, &l) != EOF)
+    {
+        c = 0;
+        for (i = 0 ; i < 5 ; i++)
+        {
+            if (a[i] >= b && a[i] <= l)
+                printf(c++ ? " %d" : "%d", a[i]);
+        }
+        printf(c ? "\n" : "no\n");
+    }
+    return 0;
+}

HDOJ/2011_autoAC.cpp

@@ -0,0 +1,14 @@
+#include<stdio.h>
+int n;
+double rev(int c)
+{
+    return c <= n ?( ((c & 1) ? 1.0 : -1.0) / c + rev(c + 1) ): 0 ;
+}
+int main()
+{
+    int t;
+    scanf("%d", &t);
+    while (t-- && scanf("%d", &n))
+        printf("%.2lf\n", rev(1));
+    return 0;
+}

HDOJ/2012_autoAC.cpp

@@ -0,0 +1,20 @@
+int main(void)
+{
+    int m, n;
+    int x[] = 
+    {
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1
+    };
+    while (scanf("%d%d", &m, &n), m || n)
+    {
+        for (m += 39, n += 39; x[m] && m <= n ; m++);
+            puts(m > n ? "OK" : "Sorry");
+    }
+    return 0;
+}

HDOJ/2013_autoAC.cpp

@@ -0,0 +1,9 @@
+#include <math.h>
+#include <stdio.h>
+int main(void)
+{
+    int n;
+    while (scanf("%d", &n) != EOF)
+        printf("%.0f\n", 3 * pow(2, n - 1) - 2);
+    return 0;
+}

HDOJ/2014_autoAC.cpp

@@ -0,0 +1,21 @@
+#include <stdio.h>
+int main(void)
+{
+    int n, i;
+    double min, max;
+    double x, y;
+    while (scanf("%d", &n) != EOF)
+    {
+        scanf("%lf", &x);
+        min = max = x;
+        for (i = 1 ; i < n ; i++)
+        {
+            scanf("%lf", &y);
+            x += y;
+            if (y > max) max = y;
+            if (y < min) min = y;
+        }
+        printf("%.2lf\n", (x - min - max) / (n - 2));
+    }
+    return 0;
+}

HDOJ/2015_autoAC.cpp

@@ -0,0 +1,17 @@
+#include <stdio.h>
+int main(void)
+{
+    int i, n, m, b, c;
+    while (scanf("%d%d", &n, &m) != EOF)
+    {
+        b = 2;
+        c = 0;
+        for (i = 0 ; i < n / m ; i++)
+        {
+            printf(c++ ? " %d" : "%d", b + m - 1);
+            b += m * 2;
+        }
+        printf(n % m ? " %d\n" : "\n", b + n % m - 1);
+    }
+    return 0;
+}

HDOJ/2016_autoAC.cpp

@@ -0,0 +1,21 @@
+#include <cstdio>
+#include <algorithm>
+using namespace std;
+int main(void)
+{
+    int i, n;
+    int f[100], m;
+    while (scanf("%d", &n), n)
+    {
+        m = 0;
+        for (i = 0 ; i < n ; i++)
+        {
+            scanf("%d", f + i);
+            if (f[i] < f[m]) m = i;
+        }
+        swap(f[m], f[0]);
+        for (i = 0 ; i < n ; i++)
+            printf("%d%c", f[i], (i < n - 1 ? ' ' : '\n'));
+    }
+    return 0;
+}

HDOJ/2017_autoAC.cpp

@@ -0,0 +1,17 @@
+#include <ctype.h>
+#include <stdio.h>
+int main(void)
+{
+    int n, d;
+    char c;
+    scanf("%d%*c", &n);
+    while (n--)
+    {
+        for (d = 0 ; (c = getchar()) != '\n' ;)
+        {
+            if (isdigit(c)) d++;
+        }
+        printf("%d\n", d);
+    }
+    return 0;
+}

HDOJ/2018_autoAC.cpp

@@ -0,0 +1,14 @@
+#include <ctype.h>
+#include <stdio.h>
+int main(void)
+{
+    int n, i;
+    int fab[55] = {1, 2, 3, 4, 6};
+    for (i = 5 ; i < 55 ; i++)
+        fab[i] = fab[i - 1] + fab[i - 3];
+    while (scanf("%d", &n), n)
+    {
+        printf("%d\n", fab[n - 1]);
+    }
+    return 0;
+}

HDOJ/2019_autoAC.cpp

@@ -0,0 +1,16 @@
+#include <stdio.h>
+int main(void)
+{
+    int n, i, m, x[101];
+    while (scanf("%d%d", &n, &m), n || m)
+    {
+        for (i = 0 ; i < n ; i++)
+            scanf("%d", x + i);
+        for (i = n ; i && x[i - 1] > m ; i--)
+            x[i] = x[i - 1];
+        x[i] = m;
+        for (i = 0 ; i < n + 1 ; i++)
+            printf("%d%c", x[i], (i - n ? ' ' : '\n'));
+    }
+    return 0;
+}

HDOJ/2020_autoAC.cpp

@@ -0,0 +1,20 @@
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+int cmp(const int *a, const int *b)
+{
+    return abs(*b) - abs(*a);
+}
+int main(void)
+{
+    int n, i, x[101];
+    while (scanf("%d", &n), n)
+    {
+        for (i = 0 ; i < n ; i++)
+            scanf("%d", x + i);
+        qsort(x, n, sizeof(int), cmp);
+        for (i = 0 ; i < n ; i++)
+            printf("%d%c", x[i], (i != n - 1 ? ' ' : '\n'));
+    }
+    return 0;
+}

HDOJ/2021_autoAC.cpp

@@ -0,0 +1,26 @@
+#include <stdio.h>
+int main(void)
+{
+    int n, i, x, sum;
+    while (scanf("%d", &n), n)
+    {
+        sum = 0;
+        for (i = 0 ; i < n ; i++)
+        {
+            scanf("%d", &x);
+            sum += x / 100;
+            x %= 100;
+            sum += x / 50;
+            x %= 50;
+            sum += x / 10;
+            x %= 10;
+            sum += x / 5;
+            x %= 5;
+            sum += x / 2;
+            x %= 2;
+            sum += x;
+        }
+        printf("%d\n", sum);
+    }
+    return 0;
+}

HDOJ/2022_autoAC.cpp

@@ -0,0 +1,28 @@
+#include <math.h>
+#include <stdio.h>
+int main(void)
+{
+    int i, j;
+    int n, m;
+    int x, y;
+    double a, t;
+    while (scanf("%d%d", &n, &m) != EOF)
+    {
+        a = x = y = 0;
+        for (i = 0 ; i < n ; i++)
+        {
+            for (j = 0 ; j < m ; j++)
+            {
+                scanf("%lf", &t);
+                if (fabs(t) > fabs(a))
+                {
+                    a = t;
+                    x = i;
+                    y = j;
+                }
+            }
+        }
+        printf("%d %d %.0f\n", x + 1, y + 1, a);
+    }
+    return 0;
+}

HDOJ/2023_autoAC.cpp

@@ -0,0 +1,44 @@
+#include <stdio.h>
+#include <string.h>
+int main(void)
+{
+    int n, m;
+    int i, j;
+    int t, d;
+    int s[50];
+    int c[5];
+    int sc[50][5];
+    while (scanf("%d%d", &n, &m) != EOF)
+    {
+        memset(s, 0, sizeof(s));
+        memset(c, 0, sizeof(c));
+        memset(sc, 0, sizeof(sc));
+        for (i = 0 ; i < n ; i++)
+        {
+            for (j = 0 ; j < m ; j++)
+            {
+                scanf("%d", &sc[i][j]);
+                c[j] += sc[i][j];
+                s[i] += sc[i][j];
+            }
+        }
+        for (i = 0 ; i < n ; i++)
+            printf("%.2lf%c", s[i] * 1.0 / m, i < n - 1 ? ' ' : ' \n');
+        for (i = 0 ; i < m ; i++)
+            printf("%.2lf%c", c[i] * 1.0 / n, i < m - 1 ? ' ' : ' \n');
+        for (t = i = 0 ; i < n ; i++)
+        {
+            for (d = 1, j = 0 ; j < m ; j++)
+            {
+                if (sc[i][j] < 1.0 * c[j] / n)
+                {
+                    d = 0;
+                    break;
+                }
+            }
+            if (d) t++;
+        }
+        printf("%d\n\n", t);
+    }
+    return 0;
+}

HDOJ/2024_autoAC.cpp

@@ -0,0 +1,27 @@
+#include <ctype.h>
+#include <stdio.h>
+int main(void)
+{
+    int n, d, i;
+    char sym[64];
+    scanf("%d%*c", &n);
+    while (n--)
+    {
+        gets(sym);
+        if (sym[0] != '_' && !isalpha(sym[0]))
+        {
+            puts("no");
+            continue;
+        }
+        for (d = i = 1 ; sym[i] ; i++)
+        {
+            if (!isalnum(sym[i]) && sym[i] != '_')
+            {
+                d = 0;
+                break;
+            }
+        }
+        puts(d ? "yes" : "no");
+    }
+    return 0;
+}

HDOJ/2025_autoAC.cpp

@@ -0,0 +1,23 @@
+#include <stdio.h>
+int main(void)
+{
+    char t[128];
+    char max;
+    int i;
+    while (gets(t))
+    {
+        for (max = i = 0 ; t[i] ; i++)
+        {
+            if (t[i] > max)
+                max = t[i];
+        }
+        for (i = 0 ; t[i] ; i++)
+        {
+            putchar(t[i]);
+            if (t[i] == max)
+                printf("%s", "(max)");
+        }
+        putchar('\n');
+    }
+    return 0;
+}

HDOJ/2026_autoAC.cpp

@@ -0,0 +1,14 @@
+#include <ctype.h>
+#include <stdio.h>
+int main(void)
+{
+    char t[128] = {' '};
+    int i;
+    while (gets(t + 1))
+    {
+        for (i = 1 ; t[i] ; i++)
+            putchar((isalpha(t[i]) && t[i-1] == ' ') ? toupper(t[i]) : t[i]);
+        putchar('\n');
+    }
+    return 0;
+}

HDOJ/2027_autoAC.cpp

@@ -0,0 +1,43 @@
+#include <ctype.h>
+#include <stdio.h>
+int main(void)
+{
+    int n;
+    int y[5];
+    char c;
+    scanf("%d%*c", &n);
+    while (n--)
+    {
+        y[0] = y[1] = y[2] = y[3] = y[4] = 0;
+        while ((c = getchar()) != '\n')
+        {
+            switch (tolower(c))
+            {
+                case 'a':
+                    y[0]++;
+                    break;
+                case 'e':
+                    y[1]++;
+                    break;
+                case 'i':
+                    y[2]++;
+                    break;
+                case 'o':
+                    y[3]++;
+                    break;
+                case 'u':
+                    y[4]++;
+                    break;
+                default :
+                    break;
+            }
+        }
+        printf("a:%d\n", y[0]);
+        printf("e:%d\n", y[1]);
+        printf("i:%d\n", y[2]);
+        printf("o:%d\n", y[3]);
+        printf("u:%d\n", y[4]);
+        if (n) putchar('\n');
+    }
+    return 0;
+}

HDOJ/2028_autoAC.cpp

@@ -0,0 +1,35 @@
+#include<stdio.h>
+typedef unsigned long UL;
+UL gcd(UL u, UL v)
+{
+    int remainder;
+    remainder = u % v;
+    while(remainder)
+    {
+        u = v;
+        v = remainder;
+        remainder = u % v;
+    }
+    return v;
+}
+UL lcm(UL u, UL v)
+{
+    return u * v / gcd(u, v);
+}
+int main(void)
+{
+    int n;
+    UL u;
+    UL res;
+    while (scanf("%d", &n) != EOF)
+    {
+        res = 1;
+        while (n--)
+        {
+            scanf("%lu", &u);
+            res = lcm(res, u);
+        }
+        printf("%lu\n", res);
+    }
+    return 0;
+}

HDOJ/2029_autoAC.cpp

@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include <string.h>
+int main(void)
+{
+    int n;
+    char s[1024];
+    char t[1024];
+    scanf("%d%*c", &n);
+    while (n--)
+    {
+        gets(s);
+        strcpy(t, s);
+        strrev(s);
+        puts(strcmp(t, s) ? "no" : "yes");
+    }
+    return 0;
+}

HDOJ/2030_autoAC.cpp

@@ -0,0 +1,20 @@
+#include <stdio.h>
+#include <string.h>
+int main(void)
+{
+    int n;
+    int count;
+    char c;
+    scanf("%d%*c", &n);
+    while (n--)
+    {
+        count = 0;
+        while ((c = getchar()) != '\n')
+        {
+            if (c < 0)
+                count++;
+        }
+        printf("%d\n", count / 2);
+    }
+    return 0;
+}

HDOJ/2031_autoAC.cpp

@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <string.h>
+void ttor(int n, int r)
+{
+    if (n)
+    {
+        ttor(n / r, r);
+        printf("%c", n % r > 9 ? n % r - 10 + 'A' : n % r + '0');
+    }
+}
+int main(void)
+{
+    int n;
+    int r;
+    while (scanf("%d%d", &n, &r) != EOF)
+    {
+        if (n > 0)
+            ttor(n, r);
+        else if (!n)
+            putchar('0');
+        else
+        {
+            putchar('-');
+            ttor(-n, r);
+        }
+        putchar('\n');
+    }
+    return 0;
+}

HDOJ/2032_autoAC.cpp

@@ -0,0 +1,23 @@
+#include <stdio.h>
+#include <string.h>
+int main(void)
+{
+    int i, j, n;
+    int YanHui[32];
+    while (scanf("%d", &n) != EOF)
+    {
+        memset(YanHui, 0, sizeof(YanHui));
+        YanHui[0] = 1;
+        for (i = 0 ; i < n ; i++)
+        {
+            printf("%d", 1);
+            for (j = i ; j ; j--)
+                YanHui[j] += YanHui[j - 1];
+            for (j = 1 ; j <= i ; j++)
+                printf(" %d", YanHui[j]);
+            putchar('\n');
+        }
+        putchar('\n');
+    }
+    return 0;
+}

HDOJ/2033_autoAC.cpp

@@ -0,0 +1,19 @@
+#include <stdio.h>
+int main(void)
+{
+    int n, i;
+    int t[6];
+    scanf("%d", &n);
+    while (n--)
+    {
+        for (i = 0 ; i < 6 ; i++)
+            scanf("%d", t + i);
+        t[1] += (t[2] + t[5]) / 60;
+        t[2] = (t[2] + t[5]) % 60;
+        t[0] += (t[1] + t[4]) / 60;
+        t[1] = (t[1] + t[4]) % 60;
+        t[0] += t[3];
+        printf("%d %d %d\n", t[0], t[1], t[2]);
+    }
+    return 0;
+}

HDOJ/2034_autoAC.cpp

@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <stdlib.h>
+int cmp(const int *a, const int *b)
+{
+    return *a - *b;
+}
+int main(void)
+{
+    int n, m, i, j;
+    int s[101];
+    while (scanf("%d%d", &n, &m), m+n)
+    {
+        for (i = 0; i < n; i++)
+            scanf("%d", s + i);
+        for (i = 0; i < m; i++)
+        {
+            scanf("%d", s + n);
+            for (j = 0; s[j] != s[n]; j++);
+            if (j != n) s[j] = s[--n];
+        }
+        qsort(s, n, sizeof(int), cmp);
+        for (i = 0; i < n; i++)
+            printf("%d ", s[i]);
+        printf(n ? "\n" : "NULL\n");
+    }
+    return 0;
+}

HDOJ/2035_autoAC.cpp

@@ -0,0 +1,12 @@
+#include <stdio.h>
+int mi(int n, int m)
+{
+    return m?(m%2?(mi(n, m/2)*mi(n, m/2)*(n%1000))%1000:(mi(n,m/2)*mi(n,m/2))%1000):1;
+}
+int main(void)
+{
+    int n, m;
+    while(scanf("%d%d", &n, &m), n+m)
+        printf("%d\n", mi(n, m));
+    return 0;
+}

HDOJ/2036_autoAC.cpp

@@ -0,0 +1,22 @@
+#include <math.h>
+#include <stdio.h>
+int main(void)
+{
+    int x[3], y[3], n;
+    double sum;
+    while (scanf("%d", &n), n)
+    {
+        scanf("%d%d", x, y);
+        x[2] = x[0]; y[2] = y[0];
+        sum = 0.0;
+        while (--n)
+        {
+            scanf("%d%d", x+1, y+1);
+            sum += x[0]*y[1] - x[1]*y[0];
+            x[0] = x[1]; y[0] = y[1];
+        }
+        sum += x[0]*y[2] - x[2]*y[0];
+        printf("%.1f\n", sum / 2.0);
+    }
+    return 0;
+}

HDOJ/2037_autoAC.cpp

@@ -0,0 +1,36 @@
+#include<stdio.h>
+int main()
+{
+    int i,j,n;
+    int s[100],e[100];
+    while(scanf("%d\n",&n)!=EOF&&n)
+    {
+        for(i=0;i<n;i++)
+        scanf("%d%d",&s[i],&e[i]);
+        int k=0,l=0;
+        for(i=0;i<n;i++)
+         for(j=i+1;j<n;j++)
+         {
+             if(e[i]>e[j])
+             {
+                 l=s[i];
+                 s[i]=s[j];
+                 s[j]=l;    
+                 k=e[i];
+                 e[i]=e[j];
+                 e[j]=k;
+            }
+         }
+         int count=0,m=0;
+         for(i=0;i<n;i++)
+         {
+             if(s[i]>=m)
+             {
+                     count++;
+                     m=e[i];
+            }         
+         }
+        printf("%d\n",count); 
+    }
+    return 0;
+}

HDOJ/2039_autoAC.cpp

@@ -0,0 +1,17 @@
+#include<stdio.h>
+#include<iostream>
+#include<cstring>
+using namespace std;
+int main()
+{
+    int m;
+    double a,b,c;
+    cin>>m;
+    while(m--){
+        cin >> a >> b >> c;
+        if(a>b) swap(a,b);
+        if(b>c) swap(b,c);
+        if(a+b>c) cout << "YES" << endl;
+        else cout << "NO" << endl;
+    }
+}

HDOJ/2040_autoAC.cpp

@@ -0,0 +1,24 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+int IsKind(int n) 
+{
+    int i, sum = 0;
+    for(i=1; i<=(int)sqrt(n); i++)
+        if(n%i == 0)
+            sum += i + n/i;
+    return sum;
+}
+int main()
+{
+    int n, m, t;
+    scanf("%d", &t);
+    while( t-- ) {
+        scanf("%d%d", &n, &m);
+        if(IsKind(m) == IsKind(n))
+            printf("YES\n");            
+        else
+            printf("NO\n");
+    }    
+    return 0;
+}

HDOJ/2041_autoAC.cpp

@@ -0,0 +1,26 @@
+#include <stdio.h>
+int main()
+{
+    int n;
+    int i;
+    int m;
+    int count;
+    int dp[50];
+    while(scanf("%d",&n)!=EOF)
+    {
+        dp[1]=1;
+        dp[2]=1;
+        dp[3]=2;
+        while(n--)
+        {
+            count=0;
+            scanf("%d",&m);
+            for(i=4; i<=m; i++)
+            {
+                dp[i]=dp[i-1]+dp[i-2];
+            }
+            printf("%d\n",dp[m]);
+        }
+    }
+    return 0;
+}

HDOJ/2042_autoAC.cpp

@@ -0,0 +1,24 @@
+#include<stdio.h>
+#include<string.h>
+int main()
+{
+    int n,i,f[1000]={4},a;
+    scanf("%d",&n);
+    while(n--)
+    {
+        memset(f,0,sizeof(f));
+        f[0]=4;
+        scanf("%d",&a);
+        if(a==1)
+            printf("4\n");
+        else
+        {
+            for(i=1;i<a;i++)
+            {
+                f[i]=(f[i-1]-1)*2;
+            }
+            printf("%d\n",f[a-1]);
+        }
+    }
+    return 0;
+}

HDOJ/2043_autoAC.cpp

@@ -0,0 +1,40 @@
+#include<stdio.h>
+#include<string.h>
+int main()
+{
+    int n,i,j,k,len,t1,t2,t3,t4,t;
+    char s[1000];
+    while(scanf("%d",&n)!=EOF&&n!=0)
+    {    getchar();
+        while(n)
+        {    t1=0;t2=0;t3=0;t4=0;t=0;
+            gets(s);
+            len=strlen(s);
+            for(i=0;i<len;i++)
+            {
+                if(s[i]>='0'&&s[i]<='9')
+                {t1++;}
+                else if(s[i]>='a'&&s[i]<='z')
+                {t2++;}
+                else if(s[i]>='A'&&s[i]<='Z')
+                {t3++;}
+                else
+                {t4++;}
+            }
+            if(t1!=0)
+                t++;
+            if(t2!=0)
+                t++;
+            if(t3!=0)
+                t++;
+            if(t4!=0)
+                t++;
+            if(len>=8&&len<=16&&t>=3)
+                printf("YES\n");
+            else
+                printf("NO\n");
+            n--;
+        }
+    }
+    return 0;
+}

HDOJ/2044_autoAC.cpp

@@ -0,0 +1,19 @@
+#include <stdio.h>
+__int64 a[100]={0};
+int main()
+{
+    int n;
+    a[1]=1,a[2]=2;
+    for(int i=3;i<51;i++)
+    {
+        a[i]=a[i-1]+a[i-2];
+    }
+    scanf("%d",&n);
+    while(n--)
+    {
+        int c,b;
+        scanf("%d%d",&c,&b);
+        printf("%I64d\n",a[b-c]);
+    }
+    return 0;
+}

HDOJ/2045_autoAC.cpp

@@ -0,0 +1,20 @@
+#include<stdio.h>
+#include<iostream>
+#include<cstring>
+#include<cmath>
+using namespace std;
+typedef long long ll;
+int main()
+{
+    ll a[51];
+    a[1] = 3;
+    a[2] = 6;
+    a[3] = 6;
+    for(int i=4;i<51;++i){
+        a[i] = a[i-1] + 2*a[i-2];
+    }
+    int n;
+    while(cin >> n && n){
+        cout << a[n] << endl;
+    }
+}

HDOJ/2046_autoAC.cpp

@@ -0,0 +1,12 @@
+#include<iostream>
+int main()
+{
+    using namespace std;
+    __int64 a[51]={0,1,2},n;
+    for(int i=3;i<=50;i++)
+        a[i]=a[i-1]+a[i-2];
+    while(cin>>n)
+    {
+        cout<<a[n]<<endl;
+    }
+}

HDOJ/2047_autoAC.cpp

@@ -0,0 +1,14 @@
+#include<iostream>
+using namespace std;
+int main()
+{
+    __int64 ans[100] = {0,3,8};
+    int n;
+    for (int i = 3; i < 100; i++)
+        ans[i] = 2 * (ans[i - 1] + ans[i - 2]);
+    while (cin>>n)
+    {
+        cout << ans[n] << endl;
+    }
+    return 0;
+}

HDOJ/2048_autoAC.cpp

@@ -0,0 +1,26 @@
+#include<stdio.h>
+int arr[21];
+void func( void )
+{
+    int i;
+    arr[1]=0;arr[2]=1;
+    for(i=3;i<=20;i++)
+        arr[i]=(i-1)*(arr[i-1]+arr[i-2]);
+}
+int main( void )
+{
+  int n,t,i,a;
+  double sum;
+  func();
+  scanf("%d",&t);
+  while(t--)
+  {    sum=0.0;
+       a=1;
+      scanf("%d",&n);
+      if(n>=10)n=10;
+      for(i=2;i<=n;i++)
+            a*=i;
+      printf("%0.2lf%%\n",(arr[n]*100.0)/a);
+  }
+  return 0;
+}

HDOJ/2049_autoAC.cpp

@@ -0,0 +1,20 @@
+#include <stdio.h>
+int main(){
+    __int64 a[21] = {0, 0, 1}, p;
+    int i, t;
+    int n, m;
+    for(i = 3; i < 21; i++){
+        a[i] = (i - 1) * (a[i - 1] + a[i - 2]);
+    }
+    scanf("%d", &t);
+    while(t--){
+        p = 1;
+        scanf("%d %d", &n, &m);
+        for(i = n - m + 1; i <= n; i++)
+            p *= i;
+        for(i = 1; i <= m; i++)
+            p /= i;
+        printf("%I64d\n", p * a[m]);
+    }
+    return 0;
+}

HDOJ/2050_autoAC.cpp

@@ -0,0 +1,13 @@
+#include <iostream>
+using namespace std;
+int main()
+{
+    int n, m;
+    cin >>n;
+    while(n--)
+    {
+        cin >>m;
+        cout <<2*m*m - m + 1 <<endl;
+    }
+    return 0;
+}

HDOJ/2051_autoAC.cpp

@@ -0,0 +1,19 @@
+#include<iostream>
+using namespace std;
+int main(){
+    int a[100],k,n,i;
+    while(cin>>n){
+        k=0;
+        while(n>0){
+            if(n&1)a[k++]=1;
+            else a[k++]=0;
+            n>>=1;
+        }
+    for(i=k-1;i>=0;--i)
+    if(i==0)
+    cout<<a[i]<<endl;
+    else
+    cout<<a[i];    
+    }
+    return 0;
+}

HDOJ/2052_autoAC.cpp

@@ -0,0 +1,29 @@
+#include <cstdio>
+#include <iostream>
+using namespace std;
+int main ()
+{
+    int c,k,i,j;
+    while (scanf("%d%d",&c,&k)!=EOF)
+    {
+        printf ("+");
+        for (i=1;i<=c;i++)
+            printf ("-");
+        printf ("+");
+        printf ("\n");
+        for (i=1;i<=k;i++)
+        {
+            printf("|");
+            for (j=1;j<=c;j++)
+                printf (" ");
+            printf("|");
+            printf ("\n");
+        }
+        printf ("+");
+        for (i=1;i<=c;i++)
+            printf ("-");
+        printf ("+");
+        printf ("\n\n");
+    }
+    return 0;
+}

HDOJ/2053_autoAC.cpp

@@ -0,0 +1,12 @@
+#include<cstdio>
+#include<cmath>
+int main()
+{
+    int n,k;
+    while(~scanf("%d",&n)){
+        k=sqrt(n);
+        if(k*k==n)printf("1\n");
+        else printf("0\n");
+    }
+    return 0;
+}

HDOJ/2054_autoAC.cpp

@@ -0,0 +1,36 @@
+#include<iostream>
+#include<cstdio>
+#include<cmath>
+#include<cstring>
+#include<cmath>
+#include<string>
+#include<algorithm>
+using namespace std;
+#define MA 100100
+char num1[MA],num2[MA];
+void cleanzero(char str[])
+{
+    int len=strlen(str),i;
+    if(strstr(str,".")!=NULL)
+    {
+        for(i=len-1;str[i]=='0';i--)
+        {
+            str[i]='\0';
+        }
+        if(str[i]=='.')
+            str[i]='\0';
+    }
+}
+int main()
+{
+    while(scanf("%s%s",num1,num2)!=EOF)
+    {
+        cleanzero(num1);
+        cleanzero(num2);
+        if(strcmp(num1,num2))
+            printf("NO\n");
+        else
+            printf("YES\n");
+    }
+    return 0;
+}

HDOJ/2055_autoAC.cpp

@@ -0,0 +1,13 @@
+#include<iostream>
+using namespace std;
+int main(){
+    int n,y,res;
+    char x;
+    cin>>n;
+    while(n--){
+        cin>>x>>y;
+        y=(x>96)?96-x+y:x-64+y;
+        cout<<y<<endl;
+    }
+    return 0;
+}

HDOJ/2056_autoAC.cpp

@@ -0,0 +1,31 @@
+#include<stdio.h>
+double max(double a,double b)
+{
+    if(a>b)
+        return a;
+    else
+        return b;
+}
+double min(double a,double b)
+{
+    if(a<b)
+        return a;
+    else
+        return b;
+}
+int main()
+{
+    double x1,y1,x2,y2,x3,y3,x4,y4,t;
+    while(scanf("%lf%lf%lf%lf%lf%lf%lf%lf",&x1,&y1,&x2,&y2,&x3,&y3,&x4,&y4)!=EOF)
+    {
+        if (x1>x2) t=x1,x1=x2,x2=t;
+        if (y1>y2) t=y1,y1=y2,y2=t;
+        if (x3>x4) t=x3,x3=x4,x4=t;
+        if (y3>y4) t=y3,y3=y4,y4=t;
+            x1=max(x1,x3);
+            y1=max(y1,y3);
+            x2=min(x2,x4);
+            y2=min(y2,y4);
+        printf("%.2lf\n",x1>x2||y1>y2?0:(x2-x1)*(y2-y1));
+    }
+}

HDOJ/2057_autoAC.cpp

@@ -0,0 +1,11 @@
+#include<stdio.h>
+int main()
+{
+    __int64 m,n;
+    while(~scanf("%I64X%I64X",&m,&n))
+    {
+        m=m+n;
+        if(m<0){m=-m;printf("-%I64X\n",m);}
+                  else printf("%I64X\n",m);
+    }
+}

HDOJ/2058_autoAC.cpp

@@ -0,0 +1,23 @@
+#include <iostream>
+#include<string>
+#include<cstdio>
+using namespace std;
+int main()
+{
+    double n,m,a1,a2,t,i;
+    while(cin>>n>>m,n,m)
+    {
+        for(i=0;i<m;i++)
+        {
+            a1=m/i-(i-1)/2;
+            if(a1<1) break;
+        }
+        for(t=i-1;t>=0;t--)
+        {
+            a1=m/t-(t-1)/2;
+            if(a1-(int)a1==0.0) cout<<"["<<(int)a1<<","<<(int)a1+(int)t-1<<"]"<<endl;
+        }
+        cout<<endl;
+    }
+    return 0;
+}

HDOJ/2059_autoAC.cpp

@@ -0,0 +1,70 @@
+#include <iostream>
+#include <string.h>
+#include<cmath>
+#include<cstring>
+#include<cstdlib>
+#include<algorithm>
+using namespace std;
+double a[150][150];
+int b[150];
+int main()
+{
+    int n,c,t,vr,vt1,vt2,l,i,j,k;
+    double tr,ji;
+    while(~scanf("%d",&l))
+    {
+        memset(a,0,sizeof(a));
+        scanf("%d %d %d %d %d %d",&n,&c,&t,&vr,&vt1,&vt2);
+        for(i=1;i<=n;i++)
+        {
+            scanf("%d",&b[i]);
+        }
+        tr=(l*1.0)/(vr*1.0);
+        b[n+1]=l;
+        for(i = 0;i <= n + 1;i++)
+        {
+            for(j = i+1;j <= n + 1;j++)
+            {
+                ji=a[0][i];
+                for(k=1;k<i;k++)
+                {
+                    if(ji>a[k][i])
+                    {
+                        ji=a[k][i];
+                    }
+                }
+                if(i)a[i][j]+=ji+t;
+                else a[i][j]+=ji;
+                if(vt1>vt2)
+                {
+                    if(c<b[j]-b[i])
+                    {
+                        a[i][j]+=(c*1.0)/(vt1*1.0)+((b[j]-b[i]-c)*1.0)/(vt2*1.0);
+                    }
+                    else
+                    {
+                        a[i][j]+=((b[j]-b[i])*1.0)/(vt1*1.0);
+                    }
+                }
+                else
+                {
+                    a[i][j]+=((b[j]-b[i])*1.0)/(vt2*1.0);
+                }
+            }
+        }
+        ji=a[0][n+1];
+        for(k=1;k<n+1;k++)
+        {
+            if(ji>a[k][n+1])ji=a[k][n+1];
+        }
+        if(ji<tr)
+        {
+            printf("What a pity rabbit!\n");
+        }
+        else
+        {
+            printf("Good job,rabbit!\n");
+        }
+    }
+    return 0;
+}

HDOJ/2060_autoAC.cpp

@@ -0,0 +1,23 @@
+#include<stdio.h>
+int main()
+{
+    int T;
+    int num,a,b;
+    while(~scanf("%d",&T))
+    {
+        while(T--)
+        {
+            scanf("%d %d %d",&num,&a,&b);
+            if(num >= 6)
+            {
+                a+= num * 8 - 21;
+            }
+            else
+            {
+                a+= (15-num)*num/2; 
+            }
+            a>=b?puts("Yes"):puts("No");
+        }
+    }
+    return 0;
+}

HDOJ/2061_autoAC.cpp

@@ -0,0 +1,36 @@
+#include <stdio.h>
+struct node
+{
+    double n,score;
+    char name[5555];
+}
+;
+node f[5555];
+int main()
+{
+    int t,i,j;
+    scanf("%d",&t);
+    while(t--)
+    {
+        int flag=0;
+        int m;
+        double sum=0,sum1=0;
+        scanf("%d",&m);
+        for(i=1;i<=m;i++)
+            scanf("%s%lf%lf",f[i].name,&f[i].n,&f[i].score);
+        for(i=1;i<=m;i++)
+        {
+            if(f[i].score<60)
+                flag=1;
+            sum+=f[i].n*f[i].score;
+            sum1+=f[i].n;
+        }   
+        if(flag)
+            printf("Sorry!\n");
+        else
+            printf("%.2lf\n",sum*1.0/sum1);
+        if(t)
+            printf("\n");
+    }
+    return 0;
+}

HDOJ/2062_autoAC.cpp

@@ -0,0 +1,36 @@
+#include<iostream>
+using namespace std;
+int main()
+{
+    int i,n,a[21];
+    long long int m,t;
+    long long int c[21] ={0};
+    for (i=1;i<21;i++)
+    {
+        c[i]=c[i-1]*(i-1)+1;
+    }
+    while(cin>>n>>m)
+    {
+        for(i=0;i<21;i++)
+        {
+            a[i]=(int)i;
+        }
+        while(n--&&m)
+        {
+            if(t=m/c[n+1]+((m%c[n+1])?1:0))
+            {
+                cout<<a[t];
+                for(i=(int)t;i<= n;i++)
+                {
+                    a[i]=a[i+1];
+                }
+                m-=(t-1)*c[i]+1;
+                if(m==0)
+                    cout<<endl;
+                else
+                    cout<<" ";
+            }
+        }
+    }
+    return 0;
+}

HDOJ/2063_autoAC.cpp

@@ -0,0 +1,51 @@
+#include<iostream>
+#include<cstring>
+#include<cstdio>
+const int MAX=1001;
+int map[MAX][MAX];
+int mark[MAX];
+int pipei[MAX];
+int n;
+int m;
+using namespace std;
+bool find(int x)
+{
+    int i;
+    for(i=1;i<=n;i++)
+    {
+        if(!mark[i]&&map[x][i])
+        {
+            mark[i]=1;
+            if(pipei[i]==-1||find(pipei[i]))
+            {
+                pipei[i]=x;
+                return true;
+            }
+        }
+    }
+    return false;
+}
+int main()
+{
+    int k,i,j,sum;
+    while(cin>>k&&k)
+    {
+        cin>>m>>n;
+        memset(map,0,sizeof(map));
+        memset(pipei,-1,sizeof(pipei));
+        sum=0;
+        while(k--)
+        {
+            cin>>i>>j;
+            map[i][j]=1;
+        }
+        for(i=1;i<=m;i++)
+        {
+            memset(mark,0,sizeof(mark));
+            if(find(i))
+            sum++;
+        }
+        cout<<sum<<endl;
+    }
+    return 0;
+}

HDOJ/2064_autoAC.cpp

@@ -0,0 +1,12 @@
+#include<stdio.h>
+int main(){
+    int i,n;
+    __int64 a[100];
+    while(scanf("%d",&n)==1){
+        a[1]=2;
+        for(i=2;i<=n;i++){
+            a[i]=3*a[i-1]+2;
+        }
+        printf("%I64d\n",a[n]);
+    }
+}

HDOJ/2065_autoAC.cpp

@@ -0,0 +1,32 @@
+#include<stdio.h>
+int main()
+{
+    int i,j,a[50]={1},t,w,s,p,q;
+    _int64 n;
+    for(i=1;i<50;i++)
+    {
+        a[i]=a[i-1]*2%100;
+        for(j=0;j<i&&a[i]!=a[j];j++);
+        if(j!=i)
+        {
+            t=j;
+            w=i-1;
+            break;
+        }
+    }
+    q=w-t+1;
+    while(scanf("%d",&s)&&s)
+    {
+        p=1;
+        while(s--)
+        {
+            scanf("%I64d",&n);
+            n--;
+            if(n>w)
+                n=(n-t)%q+t;
+            printf("Case %d: %d\n",p++,(a[n]*(a[n]+1))%100);
+        }
+        printf("\n");
+    }
+    return 0;
+}

HDOJ/2066_autoAC.cpp

@@ -0,0 +1,66 @@
+#include<stdio.h>
+#include<string.h>
+#define large(a,b)(a>b?a:b)
+#define INF 0x3f3f3f
+#define max 1000+10
+int map[max][max],start[max],end[max];
+int n,s,d;
+void floyd(int n)
+{
+    int i,j,k;
+    for(k=1;k<=n;k++)
+    {
+        for(i=1;i<=n;i++)
+        {
+            if(map[k][i]==INF)
+            continue;
+            for(j=1;j<=n;j++)
+            {
+                if(map[i][j]>map[i][k]+map[k][j])
+                map[i][j]=map[i][k]+map[k][j];
+            }
+        }
+    }
+}
+int main()
+{
+    int i,j,x,y,c,m,time;
+    while(scanf("%d%d%d",&n,&s,&d)!=EOF)
+    {
+        for(i=1;i<max;i++)
+        {
+            for(j=1;j<max;j++)
+            {
+                if(i==j)
+                map[i][j]=0;
+                else
+                map[i][j]=INF;
+            }
+        }
+        m=0;
+        while(n--)
+        {
+            scanf("%d%d%d",&x,&y,&c);
+            if(m<large(x,y))
+            m=large(x,y);
+            if(map[x][y]>c)
+            map[x][y]=map[y][x]=c;
+        }
+        for(i=0;i<s;i++)
+        scanf("%d",&start[i]);
+        for(i=0;i<d;i++)
+        scanf("%d",&end[i]);
+        floyd(m);
+        time=INF;
+        for(i=0;i<s;i++)
+        {
+            for(j=0;j<d;j++)
+            {
+                if(time>map[start[i]][end[j]])
+                time=map[start[i]][end[j]];
+            }
+        }
+        printf("%d\n",time);
+    }
+    return 0;
+}

HDOJ/2067_autoAC.cpp

@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include <string.h>
+int main()
+{
+    __int64 dp[40][40];
+    memset(dp,0,sizeof(dp));
+    dp[1][1]=1;
+    int i,j,n;
+    for(i=2;i<=36;i++)
+        for(j=1;j<=i;j++)
+        {
+            dp[i][j]=dp[i-1][j]+dp[i][j-1];
+        }
+        i=0;
+       while(scanf("%d",&n)&&n!=-1)
+           printf("%d %d %I64d\n",++i,n,2*dp[n+1][n+1]);
+}

HDOJ/2068_autoAC.cpp

@@ -0,0 +1,25 @@
+#include<stdio.h>
+int con(int n,int m)
+{
+    __int64 a=1,b=1,i;
+    for(i=1;i<=m;i++,n--)
+    {
+        b*=i;a*=n;
+    }
+    return a/b;
+}
+int main()
+{
+    int i,n;
+    __int64 t,a[13];
+    a[0]=1;a[1]=0;a[2]=1;a[3]=2;
+    for(i=4;i<=12;i++)
+        a[i]=(i-1)*(a[i-1]+a[i-2]);
+    while(scanf("%d",&n)!=EOF&&n!=0)
+    {
+        t=0;
+    for(i=0;i<=n/2;i++)
+        t+=a[i]*con(n,i);
+    printf("%I64d\n",t);
+    }
+}

HDOJ/2069_autoAC.cpp

@@ -0,0 +1,22 @@
+#include<stdio.h>
+int main(void)
+{
+    int ans,n,i,j,k,a[5]={50,25,10,5,1};
+    int dp[251][101]={0};
+    dp[0][0]=1;
+    for (i=0;i<5;i++)
+        for (j=0;j<=250;j++)
+            for (k=0;k<100;k++)
+                if (a[i]+j<=250)
+                    dp[a[i]+j][k+1]+=dp[j][k];
+                else
+                    break;
+    while (scanf("%d",&n)==1)
+    {
+        ans=0;
+        for (i=0;i<=100;i++)
+            ans+=dp[n][i];
+        printf("%d\n",ans);
+    }
+    return 0;
+}

HDOJ/2070_autoAC.cpp

@@ -0,0 +1,11 @@
+# include<stdio.h>
+int main()
+{
+    _int64 a[51]={0,1};
+    int n;
+    for(n=2;n<51;n++)
+        a[n]=a[n-1]+a[n-2];
+    while(scanf("%d",&n)&&n!=-1)
+        printf("%I64d\n",a[n]);
+    return 0;
+}

HDOJ/2071_autoAC.cpp

@@ -0,0 +1,19 @@
+#include <stdio.h>
+int main()
+{
+    int n, m;
+    double a, max = -10.0;
+    while(scanf("%d", &n) != EOF){
+        for(int i = 0; i < n; i++){
+            scanf("%d", &m);
+            for(int j = 0; j < m; j++){
+                scanf("%lf", &a);
+                if(max < a) max = a;
+                else ;
+            }
+            printf("%.2lf\n", max);
+            max = -10.0; 
+        }
+    } 
+    return 0;
+}

HDOJ/2072_autoAC.cpp

@@ -0,0 +1,33 @@
+#include<map>
+#include<string>
+#include<iostream>
+using namespace std;
+int main(){
+    string s;
+    map<string,int>Map;
+    while(getline(cin,s)&&s!="#")
+    {
+        int a=0;
+        string str;
+        Map.clear();
+        int len=s.length();
+        for(int i=0;i<len;i++){
+            if(s[i]=='#')
+                break;
+            str.clear();
+            while(s[i]>='a'&&s[i]<='z'){
+                str+=s[i];
+                i++;
+                a=1;
+            }
+            if(a==1)
+            {
+                Map[str]++;
+                a=0;
+            }
+        }
+        int ans=Map.size();
+        cout<<ans<<endl;
+    }
+    return 0;
+}

HDOJ/2073_autoAC.cpp

@@ -0,0 +1,24 @@
+#include <stdio.h>
+#include<math.h>
+int main(int argc, char *argv[])
+{
+    double s;
+    int i,x1,x2,y1,y2,n,t;
+    scanf("%d",&n);
+    while(n--)
+    {
+        scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
+        if(x1+y1>x2+y2) 
+        {
+            t=x1;x1=x2;x2=t;
+            t=y1;y1=y2;y2=t;
+        }
+        s=(y1-y2)*sqrt(2.0);
+        for(i=x1+y1+1;i<=x2+y2;i++)
+        {
+            s=s+i*sqrt(2.0)+sqrt((double)(i*i+(i-1)*(i-1)));
+        }
+        printf("%.3lf\n",s);
+    }
+    return 0;
+}

HDOJ/2074_autoAC.cpp

@@ -0,0 +1,48 @@
+#include<stdio.h>
+#include<stdio.h>
+int main()
+{
+    char c[81][81],a,b,w=0;
+    int m,i,j,k,n;
+    while(scanf("%d %c %c",&n,&a,&b)!=EOF)
+    {
+        if(w++)
+        printf("\n");
+            m=n/2;
+            int q=0;
+            for(q=0;q<a;q++)
+            {
+                for(i=q;i<n-q;i++)
+                {
+                    for(j=q;j<n-q;j++)
+                    {
+                        if(q%2==0&&(m%2==0))
+                        c[i][j]=a;
+                        else if(q%2!=0&&(m%2==0))
+                        c[i][j]=b;
+                        else if(q%2==0&&(m%2!=0))
+                        c[i][j]=b;
+                        else
+                        c[i][j]=a;
+                    }
+                }
+            }
+            c[0][0]=c[0][n-1]=c[n-1][0]=c[n-1][n-1]=' ';
+            if(n==1)
+            {
+                printf("%c\n",a);
+            }
+            else
+            {
+            for(i=0;i<n;i++)
+            {
+                for(j=0;j<n;j++)
+                {
+                    printf("%c",c[i][j]);
+                }
+                printf("\n");
+            }
+            }
+    }
+    return 0;
+}

HDOJ/2075_autoAC.cpp

@@ -0,0 +1,14 @@
+#include<stdio.h>
+int main()
+{
+        long int a,b;
+        int n;
+        scanf("%d",&n);
+        while(n--)
+        {
+                scanf("%ld%ld",&a,&b);
+                if(a<b) printf("NO\n");
+                else if(a%b==0) printf("YES\n");
+                else printf("NO\n");
+        }
+}

HDOJ/2076_autoAC.cpp

@@ -0,0 +1,19 @@
+#include<stdio.h>
+#include<math.h>
+#include<algorithm>
+using namespace std;
+int main()
+{
+    int c;
+    double h,m,s,ans;
+    scanf("%d",&c);
+    while(c--)
+    {
+        scanf("%lf%lf%lf",&h,&m,&s);
+        if(h>=12) h-=12.0;
+        m = m + s/60.0;
+        h = h + m/60.0;
+        ans = fabs(h*30.0 - m*6.0);
+        printf("%d\n",(int)min(ans,360.00-ans));
+    }
+}

HDOJ/2077_autoAC.cpp

@@ -0,0 +1,18 @@
+#include <iostream>
+using namespace std;
+int main()
+{
+    long long f[21] = {0,2};
+    int n,i;
+    for(i = 2;i < 21;i++)
+        f[i] = 3 * f[i-1] + 2;
+    while(cin >> n)
+    {
+        while(n--)
+        {
+            cin >> i;
+            cout << f[i-1] + 2 << endl;
+        }
+    }
+    return 0;
+}

HDOJ/2078_autoAC.cpp

@@ -0,0 +1,19 @@
+#include<stdio.h>
+#include<iostream>
+#include<algorithm>
+using namespace std;
+int a[45];
+int main()
+{
+    int t,m,n,i;
+    scanf("%d",&t);
+    while(t--)
+    {
+        scanf("%d%d",&n,&m);
+        for(i=0;i<n;i++) scanf("%d",&a[i]);
+        sort(a,a+n);
+        int s=(100-a[0])*(100-a[0]);
+        printf("%d\n",s);
+    }
+    return 0;
+}

HDOJ/2079_autoAC.cpp

@@ -0,0 +1,38 @@
+#include<iostream>
+#include<stdio.h>
+#include<string.h>
+using namespace std;
+int c1[700],c2[700];
+int a[10],b[10];
+int main()
+{
+    int T;
+    scanf("%d",&T);
+    for(int cas = 1;cas <= T;cas++)
+    {
+        memset(c1,0,sizeof(c1));
+        memset(c2,0,sizeof(c2));
+        int n,kk;
+        scanf("%d%d",&n,&kk);
+        int i,j,k;
+        for(i = 1;i <= kk;i++){
+            scanf("%d%d",&a[i],&b[i]);
+        }
+        for(i = 0;i <= a[1]*b[1]&&i<=n;i+=a[1]){
+            c1[i] = 1;
+        }
+        for(i = 2;i <= kk;i++){
+            for(j = 0;j <= n;j++){
+                for(k = 0;k<=a[i]*b[i]&&k<=n;k+=a[i]){
+                    c2[k+j] += c1[j];
+                }
+            }
+            for(j = 0;j <= n;j++){
+                c1[j] = c2[j];
+                c2[j] = 0;
+            }
+        }
+        printf("%d\n",c1[n]);
+    }
+    return 0;
+}

HDOJ/2080_autoAC.cpp

@@ -0,0 +1,17 @@
+#include<stdio.h>
+#include<math.h>
+#define Pi 3.141592653
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    while(t--)
+    {        
+        double x1,y1,x2,y2;
+        scanf("%lf %lf %lf %lf",&x1,&y1,&x2,&y2);
+        double ans=0;
+        ans=acos( ((x1*x1 + y1*y1 + x2*x2 + y2*y2- (x1-x2)*(x1-x2) - (y1-y2)*(y1-y2) )/(2* sqrt(x1*x1 + y1*y1) * sqrt(x2*x2 + y2*y2) )))*180/Pi;
+        printf("%.2lf\n",ans);
+    }    
+    return 0;
+}

HDOJ/2081_autoAC.cpp

@@ -0,0 +1,14 @@
+#include<stdio.h>
+int main()
+{
+    int n;
+    int i;
+    char m[12];
+    scanf("%d",&n);
+    while(n--)
+    {
+        scanf("%s",m);
+        printf("6%s\n",m+6);
+    }
+    return 0;
+}

HDOJ/2082_autoAC.cpp

@@ -0,0 +1,33 @@
+#include <cstdio>
+#include <cstring>
+#include <iostream>
+using namespace std;
+int main()
+{
+    int a[27], b[27][51], N;
+    memset(b, 0, sizeof(b));
+    scanf("%d", &N);
+    while (N--)
+    {
+        int i, j, k;
+        for (i = 1; i <= 26; i++) scanf("%d", &a[i]);
+        for (i = 0; i <= 26; i++) b[i][0] = 1;
+        for (i = 1; i <= 26; i++)
+        {
+            for (j = 1; j <= 50; j++)
+            {
+                b[i][j] = b[i - 1][j];
+                for (k = 1; k <= a[i]; k++)
+                {
+                    if (j - k * i >= 0)
+                        b[i][j] += b[i - 1][j - k * i];
+                }
+            }
+        }
+        int ans = 0;
+        for (i = 1; i <= 50; i++)
+            ans += b[26][i];
+        printf("%d\n", ans);
+    }
+    return 0;
+}

HDOJ/2083_autoAC.cpp

@@ -0,0 +1,35 @@
+#include<stdio.h>
+#include<math.h>
+int main()
+{
+    int t;
+    int a[10000];
+    scanf("%d",&t);
+    while(t--)
+    {
+        int n;
+        scanf("%d",&n);
+        int i;
+        for(i=0;i<n;i++)
+        {
+            scanf("%d",&a[i]);
+        }
+        int min;
+        int sum=0;
+        int j;
+        for(i=0;i<n;i++)
+        {
+            sum=0;
+           for(j=0;j<n;j++)
+           {
+               sum+=fabs(a[i]-a[j]);
+           }    
+           if(i==0)
+           min=sum;
+           if(sum<min)
+           min=sum;
+        }
+        printf("%d\n",min);
+    }
+    return 0;
+}

HDOJ/2084_autoAC.cpp

@@ -0,0 +1,28 @@
+#include<stdio.h>
+int main()
+{
+    int t;
+    int a[101][101];
+    scanf("%d",&t);
+    while(t--){
+        int n;
+        scanf("%d",&n);
+        int i,j;
+        for(i=1;i<=n;i++)
+        {
+            for(j=1;j<=i;j++)
+            {
+                scanf("%d",&a[i][j]);
+            }
+        }
+        for(i=n-1;i>=1;i--)
+        {
+            for(j=1;j<=i;j++)
+            {
+                a[i][j]+=a[i+1][j]>a[i+1][j+1]?a[i+1][j]:a[i+1][j+1];
+            }
+        }
+        printf("%d\n",a[1][1]);
+    }
+    return 0;
+}

HDOJ/2085_autoAC.cpp

@@ -0,0 +1,19 @@
+#include<stdio.h>
+int main()
+{
+    int n;
+    _int64 a[35],b[35];
+    int i;
+    a[0]=1;
+    b[0]=0;
+    for(i=1;i<34;i++)
+    {
+        a[i]=3*a[i-1]+2*b[i-1];
+        b[i]=b[i-1]+a[i-1];
+    }
+    while(scanf("%d",&n)!=EOF&&n!=-1)
+    {
+        printf("%I64d, %I64d\n",a[n],b[n]);
+    }
+    return 0;
+}

HDOJ/2086_autoAC.cpp

@@ -0,0 +1,18 @@
+#include<stdio.h>
+int main()
+{
+    int n,i;
+    double  a1,an,c[3001],s,x;
+    while(~scanf("%d",&n))
+    {
+        scanf("%lf%lf",&a1,&an);
+        for(i=1;i<=n;i++)
+            scanf("%lf",&c[i]);
+        s=n*a1+an;x=0;
+        for(i=1;i<=n;i++)
+            x+=(n-i+1)*c[i];
+        s=(s-2*x)/(n+1);
+        printf("%.2lf\n",s);
+    }
+    return 0;
+}

HDOJ/2087_autoAC.cpp

@@ -0,0 +1,29 @@
+#include<stdio.h>
+#include<string.h>
+int main()
+{
+    char a[10000],b[10000];
+    int i,j,k1,k2,t,count;
+    while(scanf("%s",a)!=EOF)
+    {    t=0;count=0;
+        if(a[0]=='#')
+            break;
+        scanf("%s",b);
+        k1=strlen(a);
+        k2=strlen(b);
+        for(i=0,j=0;i<k1;i++)
+        {
+            if(a[i]==b[j])
+            {t++;}
+            else
+            {t=0;}
+            if(t==k2)
+            {count++;t=0;}
+            j++;
+            if(j==k2)
+            {j=0;}
+        }
+        printf("%d\n",count);
+    }
+    return 0;
+}

HDOJ/2088_autoAC.cpp

@@ -0,0 +1,31 @@
+#include <iostream>
+using namespace std;
+int main()
+{
+    int n;
+    int a[51];
+    int mid;
+    long long sum;
+    bool first = true;
+    while(cin >> n && n)
+    {
+        sum = 0;
+        if(!first)
+            cout << endl;
+        for(int i = 0; i < n; i++)
+        {
+            cin >> a[i];
+            sum += a[i];
+        }
+        int move = 0;
+        mid = sum / n;
+        for(int i = 0; i < n; i++)
+        {
+            if(a[i] > mid)
+                move += a[i] - mid;
+        }
+        cout << move << endl;
+        first = false;
+    }
+    return 0;
+}

HDOJ/2089_autoAC.cpp

@@ -0,0 +1,25 @@
+#include<stdio.h>
+#define   N 1000000
+struct stdent
+{
+    int p[N];
+}stu;
+int main()
+{int i,k;
+        for(i=1;i<1000000;i++)
+    {k=i;
+    stu.p[i]=0;
+      for(;k!=0;k/=10)
+                if(k%10==4||k%100==62)  {stu.p[i]=1;break;}
+    }
+    int a,b,t;
+    while(~scanf("%d%d",&a,&b)&&(a||b))
+    {t=b-a+1;
+        for(;a<=b;a++)
+        {
+           t-=stu.p[a];
+        }
+        printf("%d\n",t);
+    }
+    return 0;
+}

HDOJ/2090_autoAC.cpp

@@ -0,0 +1,14 @@
+#include<stdio.h>
+int main()
+{
+    double a,b;
+    char s[100];
+    double sum = 0.0;
+    while(scanf("%s", s)!=EOF)
+    {
+        scanf("%lf%lf", &a, &b);
+        sum += a*b;        
+    }
+    printf("%.1lf\n", sum);
+    return 0;
+}

HDOJ/2091_autoAC.cpp

@@ -0,0 +1,34 @@
+#include<stdio.h>
+int main()
+{
+    int n,i,j,k,t=1;
+    char c;
+    while(scanf("%c%d",&c,&n)!=EOF)
+    {    getchar();
+        if(c!='@')
+        {
+            if(t!=1)
+                printf("\n");
+            t++;
+        for(i=1;i<n;i++)
+        {
+            for(j=n-i-1;j>=0;j--)
+                printf(" ");
+            for(k=1;k<=2*i-1;k++)
+            {
+                if(k==1||k==2*i-1)
+                    printf("%c",c);
+                else
+                    printf(" ");
+            }
+            printf("\n");
+        }
+        for(i=1;i<=2*n-1;i++)
+            printf("%c",c);
+        printf("\n");
+        }
+        else
+            break;
+    }
+    return 0;
+}

HDOJ/2092_autoAC.cpp

@@ -0,0 +1,9 @@
+#include <stdio.h>
+#include <math.h>
+int main(){
+    int n,m;
+    while(scanf("%d%d",&n,&m),n,m){
+        double x=sqrt(n*n-4*m);
+        printf((int) x==x?"Yes\n":"No\n");
+    }
+}

HDOJ/2093_autoAC.cpp

@@ -0,0 +1,50 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#define maxn 10005
+typedef struct {
+    char name[15];
+    int ac;
+    int time;
+}Stu;
+int N,M;
+Stu record[maxn];
+int cmp_struct(const void* now,const void* next)
+{
+    Stu* Now = (Stu*)now;
+    Stu* Next = (Stu*)next;
+    if(Now->ac == Next->ac){
+        if(Now->time == Next->time)
+            return strcmp(Now->name,Next->name);
+        return (Now->time - Next->time);
+    }
+    return (Next->ac - Now->ac);
+}
+int main()
+{
+    int cnt = 0;
+    memset(record,0,sizeof(record));
+    scanf("%d%d",&N,&M);
+    while(scanf("%s",record[cnt].name)!=EOF){
+        int ac;
+        char c;
+        int time;
+        for(int i = 0 ; i < N ; i++){
+            scanf("%d",&ac);
+            if(ac > 0){
+                record[cnt].ac++;
+                record[cnt].time += ac;
+            }
+            if((c = getchar())=='('){
+                scanf("%d",&time);
+                getchar();
+                record[cnt].time += time * M;
+            }
+        }
+        cnt++;
+    }
+    qsort(record,cnt,sizeof(record[0]),cmp_struct);
+    for(int i = 0 ; i < cnt ; ++i)
+        printf("%-10s %2d %4d\n",record[i].name,record[i].ac,record[i].time);
+    return 0;
+}

HDOJ/2094_autoAC.cpp

@@ -0,0 +1,35 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main(){
+    char num1[2010][100],num2[2010][100];
+    int j,i,samep,count,n,butong,same;
+    while(scanf("%d",&n) != EOF && n){
+        getchar();
+        for(i = 0;i < n * 2;i++)
+            scanf("%s",&num2[i]);
+            same = 0;
+        for(i = 0;i < n * 2;i++){
+            for(j = i+1;j < n * 2;j++){
+                if(strcmp(num2[i],num2[j]) == 0){
+                    same++;
+                    break;
+                }
+            }
+        }
+        butong = n * 2 - same;
+        same = 0;
+        for(i = 1;i < n * 2;i+=2)
+            for(j = i+2;j < n*2;j+=2){
+                if(strcmp(num2[i],num2[j]) == 0){
+                    same++;
+                    break;
+                }
+            }
+        count = n - same;
+        if(butong - count == 1)
+            printf("Yes\n");
+        else
+            printf("No\n");
+    }
+}

HDOJ/2095_autoAC.cpp

@@ -0,0 +1,21 @@
+#include<iostream>
+#include<cstdio>
+using namespace std;
+int main()
+{
+    int n;
+    int temp;
+    while(scanf("%d",&n)==1)
+    {
+        if(!n)
+            break;
+        int ans,i;
+        for(i=0,ans=0;i<n;i++)
+        {
+            scanf("%d",&temp);
+            ans^=temp;
+        }
+        printf("%d\n",ans);
+    }
+    return 0;
+}

HDOJ/2096_autoAC.cpp

@@ -0,0 +1,14 @@
+#include<stdio.h>
+int main()
+{
+      int n,a,b,c,d,sum;    
+    scanf("%d",&n);
+    while(n--)
+    {
+         scanf("%d%d",&a,&b);
+         c=a%100;
+         d=b%100;
+         sum=((c+d)%100);
+         printf("%d\n",sum);
+    }
+}

HDOJ/2097_autoAC.cpp

@@ -0,0 +1,11 @@
+#include<stdio.h>
+int main()
+{
+    int n,i;
+    while(scanf("%d",&n),n)
+    {
+        i=n/1000+n/100%10+n/10%10+n%10;
+        printf((i==n/4096+n/256%16+n/16%16+n%16)&&(i==n/1728+n/144%12+n/12%12+n%12)?"%d is":"%d is not",n,n);
+        printf(" a Sky Number.\n");
+    }
+}

HDOJ/2098_autoAC.cpp

@@ -0,0 +1,27 @@
+#include<stdio.h>
+int su(int a)
+{
+    int i,t=1;
+    for(i=2;i<=a/2;i++)
+        if(a%i==0)
+        {
+            t=0;break;
+        }
+    return t;
+}
+int main()
+{
+    int n,i,a,b,j;
+    while(~scanf("%d",&n))
+    {
+        if(n==0)return 0;
+        int count=0;
+        for(i=2;i<n/2;i++)
+        {
+            j=n-i;
+            if(su(i)==1&&su(j)==1)
+            {count++;    }            
+        }
+        printf("%d\n",count);
+    }
+}

HDOJ/2099_autoAC.cpp

@@ -0,0 +1,38 @@
+#include<stdio.h>
+int main()
+{
+    int i,j,k,sum,n,m,a[101];
+    while(scanf("%d%d",&n,&m)!=EOF)
+    {
+        if(n==0&&m==0)
+        break;
+        k=0;sum=0;
+        for(i=0;i<100;i++)
+        {
+            if(((n*100)+i)%m==0)
+            {
+                sum++;
+                a[k++]=i;
+            }
+        }
+        for(j=0;j<sum;j++)
+        {
+            if(j<sum-1)
+            {
+                if(a[j]<10)
+                    printf("0%d ",a[j]);
+                else
+                    printf("%d ",a[j]);
+            }
+            else
+            {
+                if(a[j]<10)
+                    printf("0%d",a[j]);
+                else
+                    printf("%d",a[j]);
+            }
+        }
+        printf("\n");
+    }
+return 0;
+}