Ural Regional School Programming Contest 2011

链接：Ural Regional School Programming Contest 2011

【2014/05/25】今天的训练做了一套大水题，最后的rank是7道题，如下，第8题在比赛结束的一分钟中居然AC了，真是神奇啊，可惜时间过了。

 

---

 

A - GOV Chronicles

【题意】一篇参赛记录的文章，让你统计每个队员参赛的次数。

【思路】水题，同时也很坑爹，主要是统计很麻烦，文章很长同时是英文，读都要读大半天，WA了，后来检查了一下AC了。

#include <cstdio>

int a[] = {5,20,12,2,1,4,6,1,4,4,1,0};
int main()
{
    int n;
    scanf("%d",&n);
    printf("%d\n",a[n]);
    return 0;
}

B - Football Goal

【题意】有一面墙，给你长度为a和b的两个木棒，通过墙，地面和木棒，围成一个四边形，使其面积最大。

【思路】直接枚举边AB，然后AB确定之后，三角形ABD面积就确定了，用海伦公式去运算。至于三角形ABO，由于其是个直角三角形，AB边长度确定之后，AO，BO可以变化，再加上勾股定理，求其面积的时候利用消元得到一个关于AB的一元二次方程，其最值是AO=BO的时候得到的，所以三角形AOB的面积最大值是 (K*K)/4.  于是最后的四边形面积是一个关于K的三角形ABD的面积用海伦公式知道是关于K的一元二次方程，具体很难化简到一般形式，所以用三分来枚举，因为他是个凸型函数。K是变长，范围是[0,a+b].

#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#define EPS 1e-10
using namespace std;

double a, b;

double GetS(double k)
{
    double p = (a + b + k) / 2;
    return k*k/4 + sqrt(p*(p-a)*(p-b)*(p-k));
}
int main()
{
    scanf("%lf%lf", &a, &b);
    double l = 0 , r = a + b;
    while(l + EPS < r)
    {
        double m1 = l + (r - l)/3;
        double m2 = r - (r - l)/3;
        if(GetS(m1) >= GetS(m2))
            r = m2;
        else
            l = m1;
    }
    printf("%.9f\n", GetS(l));
    return 0;
}

 

C - Angry Birds

D - Centipede's Morning

【题意】说是有一只蜈蚣，左边40条腿，右边40条腿，它有a只左鞋，b只右鞋，然后有一个穿鞋的方法，说它今天特别倒霉，求最多要多长时间穿好鞋，算是一个推公式的题吧。

【思路】考虑最坏情况，第一种最坏情况，很明显，就是把右脚的鞋子全穿一遍，然后再穿完左脚，耗时2b+40。第二种情况，先穿完左脚，再穿完右脚？不不不，还有更糟糕的情况，先给右脚穿好39只，耗时39*2，然后给左脚穿完鞋子，耗时40，再把剩下的左脚鞋子都上一遍，耗时2*（a-40)，然后穿上右脚最后一只，耗时1。总耗时39+2a。取其最大值即可。

#include <cstdio>
#include <algorithm>
using namespace std;

int main()
{
    int a, b;
    scanf("%d%d",&a,&b);
    printf("%d\n",max(b*2+40,2*a+39));
    return 0;
}

 

E - Bicycle Codes

【题意】某地有2个锁，有个小偷每天都去开锁(递增，从0000开始，每天一次)，这个地方每天换个锁(第一天1号锁，第二天2号，第三天还是1号，第四天2号......)，如果小偷能在9999之前开锁(开一次就可以了)。输出yes，否则no.

【思路】大水题，直接判断1号锁是否是偶数，或者2号锁是否是奇数，即小偷能够解锁。

#include <iostream>
#include <cstdio>
using namespace std;

int main()
{
    char str[5];
    int x, y;

    scanf("%s", str);
    sscanf(str, "%d", &x);
    scanf("%s", str);
    sscanf(str, "%d", &y);

    if(x%2==1 && y%2==0)
        puts("no");
    else
        puts("yes");

    return 0;
}

F - Rubinchik's Cube

【题意】有一个特殊的4阶魔方，只能横着转。每一层只有4个格子有颜色（4种颜色，有颜色格子旋转对称，每一层有颜色格子位置不同），所以从上面看刚好是一个4*4的彩色方块。（结合原图图像理解题意）给定一个初始状态，要求到指定状态的最小步数。

【思路】这就是那个时间到了之后才AC的题，用string来存储状态，BFS过了。

#include <cstdio>
#include <map>
#include <queue>
#include <string>
using namespace std;

struct state
{
    int arr[4][4];
    string tostring()
    {
        string res = "";
        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 4; j++)
            {
                res = res + (char)(arr[i][j]+'0');
            }
        }
        return res;
    }
};

state tostate(string x)
{
    state t;
    for (int i = 0; i < 4; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            t.arr[i][j] = x[i*4+j]-'0';
        }
    }
    return t;
}
map<string, int> hs;

bool check(state x)
{
    int v = x.arr[0][0];
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 2; j++)
        {
            if (x.arr[i][j]!=v) return false;
        }
    }
    v = x.arr[0][2];
    for (int i = 0; i < 2; i++)
    {
        for (int j = 2; j < 4; j++)
        {
            if (x.arr[i][j]!=v) return false;
        }
    }
    v = x.arr[2][0];
    for (int i = 2; i < 4; i++)
    {
        for (int j = 0; j < 2; j++)
        {
            if (x.arr[i][j]!=v) return false;
        }
    }
    v = x.arr[2][2];
    for (int i = 2; i < 4; i++)
    {
        for (int j = 2; j < 4; j++)
        {
            if (x.arr[i][j]!=v) return false;
        }
    }
    return true;
}


void bfs(state s)
{
    queue<state> q;
    q.push(s);
    hs[s.tostring()] = 0;
    while(!q.empty())
    {
        state e = q.front();
        q.pop();
        if (check(e))
        {
            printf("%d\n",hs[e.tostring()]);
            return;
        }
        state t;
        for (int i = 1; i <= 8; i++)
        {
            t = e;
            if (i == 1)
            {
                t.arr[0][0] = e.arr[0][3];
                t.arr[0][3] = e.arr[3][3];
                t.arr[3][3] = e.arr[3][0];
                t.arr[3][0] = e.arr[0][0];
            }
            if (i == 2)
            {
                t.arr[0][0] = e.arr[3][0];
                t.arr[3][0] = e.arr[3][3];
                t.arr[3][3] = e.arr[0][3];
                t.arr[0][3] = e.arr[0][0];
            }
            if (i == 3)
            {
                t.arr[1][1] = e.arr[1][2];
                t.arr[1][2] = e.arr[2][2];
                t.arr[2][2] = e.arr[2][1];
                t.arr[2][1] = e.arr[1][1];
            }
            if (i == 4)
            {
                t.arr[1][1] = e.arr[2][1];
                t.arr[1][2] = e.arr[1][1];
                t.arr[2][2] = e.arr[1][2];
                t.arr[2][1] = e.arr[2][2];
            }
            if (i == 5)
            {
                t.arr[1][0] = e.arr[0][2];
                t.arr[0][2] = e.arr[2][3];
                t.arr[2][3] = e.arr[3][1];
                t.arr[3][1] = e.arr[1][0];
            }
            if (i==6)
            {
                t.arr[1][0] = e.arr[3][1];
                t.arr[3][1] = e.arr[2][3];
                t.arr[2][3] = e.arr[0][2];
                t.arr[0][2] = e.arr[1][0];
            }
            if (i==7)
            {
                t.arr[0][1] = e.arr[1][3];
                t.arr[1][3] = e.arr[3][2];
                t.arr[3][2] = e.arr[2][0];
                t.arr[2][0] = e.arr[0][1];
            }
            if (i==8)
            {
                t.arr[0][1] = e.arr[2][0];
                t.arr[2][0] = e.arr[3][2];
                t.arr[3][2] = e.arr[1][3];
                t.arr[1][3] = e.arr[0][1];
            }
            if (hs.find(t.tostring())==hs.end())
            {
                hs[t.tostring()] = (hs[e.tostring()] + 1);
                q.push(t);
            }
            else if (hs[t.tostring()]>hs[e.tostring()]+1)
            {
                hs[t.tostring()] = hs[e.tostring()]+1;
                q.push(t);
            }
        }
    }
}

int main()
{
    state st;
    for (int i = 0; i < 4; i++)
    {
        for(int j = 0; j < 4; j++)
        {
            scanf("%d",&st.arr[i][j]);
        }
    }
    bfs(st);
    return 0;
}

 

G - GOV-internship 2

H - Psych Up's Eigenvalues

【题意】一个ACM小队三个队员，每个人有n个数值，求出三个队员都相同的数值的个数。

【思路】水题，set搞定。

#include <cstdio>
#include <cstring>
#include <set>
#include <algorithm>

using namespace std;

set<int> b[3];

int main()
{
    #ifdef HotWhite
    freopen("in.txt", "r", stdin);
    #endif
    int cnt[3], num, mini = 10000000;
    for (int i = 0; i < 3; ++i) {
        scanf("%d", cnt+i);
        if (mini == 10000000 || cnt[i] < mini) {
            mini = i;
        }
        for (int j = 0; j < cnt[i]; ++j) {
            scanf("%d", &num);
            b[i].insert(num);
        }
    }
    set<int>::iterator ite = b[mini].begin();
    int res = 0;
    for ( ; ite != b[mini].end(); ++ite) {
        if (b[0].count(*ite) && b[1].count(*ite) && b[2].count(*ite)) {
            res++;
        }
    }
    printf("%d\n", res);
    return 0;
}

 

I - Long problem statement

【题意】页数统计，给出每一页可以打印多少行，每一行最多多少个字符，然后给出一串单词，让求需要打印多少张

【思路】直接模拟即可，水题。

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

int h, w, n;
int cnt;

struct Word {
    char str[110];
    int len;
} word[10007];

int main()
{
    #ifdef HotWhite
    freopen("in.txt", "r", stdin);
    #endif
    scanf("%d %d %d", &h, &w, &n);
    for (int i = 0; i < n; ++i) {
        scanf("%s", word[i].str);
        word[i].len = strlen(word[i].str);
    }
    int tem, j = 0, tot = 0;
    while (j < n) {
        tem = w - word[j++].len;
        while (j < n && 1+word[j].len <= tem) {
            tem -= 1+word[j].len;
            j++;
        }
        tot++;
    }
    printf("%d", (tot+(h-1))/h);
    return 0;
}

J - Old Nokia

K - Ent's Birthday

【题意】一个方形的生日蛋糕，上面有n个蜡烛，要求从上面切下来一块，包含k个蜡烛，输出其中一个解即可。

【思路】计算几何题目，凸包的巧妙应用。

#include <cstdio>
#include <cmath>
#include <algorithm>
#define INF 1e9
#define EPS 1e-8
using namespace std;

int dcmp(double x)
{
    if (fabs(x)<EPS) return 0;
    return x < 0?-1:1;
}

struct Point
{
    double x,y;
    Point(double x = 0, double y = 0):x(x),y(y) {}
    bool operator < (const Point a) const
    {
        if (dcmp(x-a.x)==0) return dcmp(y-a.y)<0?1:0;
        else return dcmp(x-a.x)<0?1:0;
    }
} pt[10005],cpt[10005],cov[10005];
typedef Point Vector;


Vector operator - (Point A , Point B)
{
    return Vector(A.x-B.x,A.y-B.y);
}
double Cross(Vector A, Vector B)
{
    return A.x*B.y-A.y*B.x;
}

double lenth(Vector v)
{
    return sqrt(v.x*v.x+v.y*v.y);
}

bool cmp(Point a, Point b)
{
    Vector v2 = b - pt[0];
    Vector v1 = a - pt[0];
    if (dcmp(Cross(v1,v2))==0)
    {
        return dcmp(lenth(v1)-lenth(v2))<=0?true:false;
    }
    else
    {
        return dcmp(Cross(v1,v2))<0?true:false;
    }
}

int Convexhull(Point * p, int n, Point * ch)
{
    sort(p,p+n);
    int m = 0;
    for (int i = 0; i < n; i++)
    {
        while(m>1 && dcmp(Cross(ch[m-1]-ch[m-2],p[i]-ch[m-2])) <= 0) m--;
        ch[m++]=p[i];
    }
    int k = m;
    for (int i = n-2; i >=0; i--)
    {
        while(m>k && dcmp(Cross(ch[m-1]-ch[m-2],p[i]-ch[m-2])) <=0) m--;
        ch[m++]=p[i];
    }
    if (n>1)m--;
    return m;
}


int main()
{
    int n, k;
    scanf("%d%d",&n,&k);
    for (int i = 0; i <n; i++)
    {
        double x,y;
        scanf("%lf%lf",&x,&y);
        pt[i] = Point(x,y);
        if (dcmp(pt[i].x-pt[0].x)==-1)
        {
            swap(pt[0],pt[i]);
        }
        else if (dcmp(pt[i].x-pt[0].x)==0&&dcmp(pt[i].y-pt[0].y)<=0)
        {
            swap(pt[0],pt[i]);
        }
    }
    sort(pt+1,pt+n,cmp);
    int cnt = 0;
    cpt[cnt++] = pt[0];
    for (int i = 1; i < n; i++)
    {
        cpt[cnt++] = pt[i];
        if (cnt == k) break;
    }
    if (k <= 2)
    {
        printf("%d\n",3);
        if (k == 1)
        {
            printf("-1000000000 -1000000000\n");
            printf("%.0f %.0f\n",cpt[0].x, cpt[0].y);
            printf("-1000000000 1000000000\n");
        }
        if (k == 2)
        {
            printf("%.0f %.0f\n",cpt[0].x,cpt[0].y);
            printf("%.0f %.0f\n",cpt[1].x,cpt[1].y);
            printf("-1000000000 1000000000\n");
        }
    }
    else
    {
        int m = Convexhull(cpt,cnt,cov);
        if (m == 2)
        {
            printf("%d\n",3);
            printf("%.0f %.0f\n",cov[0].x,cov[0].y);
            printf("%.0f %.0f\n",cov[1].x,cov[1].y);
            printf("-1000000000 1000000000\n");
        }
        else
        {
            printf("%d\n", m);
            for (int i = 0; i < m; i++)
            {
                printf("%.0f %.0f\n",cov[i].x,cov[i].y);
            }
        }
    }
    return 0;
}

L - Way to the University