ACM学习历程—Codeforces Round #354 (Div. 2)

http://codeforces.com/contest/676

在allzysyz学弟和hqwhqwhq的邀请下，打了我的第三场CF。。。

毕竟在半夜。。所以本来想水到12点就去睡觉的。。。结果一下次过了三题，发现第四题是个bfs，就打到了12:30.。。。BC貌似是没有了，不知道后面还会不会有，最近就打CF为主吧。。

A题：

http://codeforces.com/problemset/problem/676/A

应该算是比较水吧。没有什么坑点。直接枚举最大值在最左最右侧和最小值在最左最右侧四种情况。

代码：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <vector>
#include <string>
#define LL long long

using namespace std;

int main()
{
    //freopen("test.in", "r", stdin);
    //freopen("test.out", "w", stdout);
    int n, t, indexone, indexn;
    while (scanf("%d", &n) != EOF)
    {
        for (int i = ; i < n; ++i)
        {
            scanf("%d", &t);
            if (t == ) indexone = i;
            if (t == n) indexn = i;
        }
        printf("%d\n", max(max(indexone, n--indexone), max(indexn, n--indexn)));
    }
    return ;
}

B题：

http://codeforces.com/problemset/problem/676/B

是ccpc热身赛一题的简化版，首先我可以把所有的酒强行先倒入第一杯，然后让它一层一层往下流。暴力模拟一遍就可以了。上一层的第i杯，会流入下一层的第i杯和第i+1杯。

代码：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <vector>
#include <string>
#define LL long long

using namespace std;

double a[][];

int main()
{
    //freopen("test.in", "r", stdin);
    //freopen("test.out", "w", stdout);
    int n, t, ans;
    double tmp;
    while (scanf("%d%d", &n, &t) != EOF)
    {
        bool flag;
        ans = ;
        a[][] = t;
        for (int i = ; i <= n; ++i)
        {
            memset(a[(i+)%], , sizeof(a[(i+)%]));
            flag = true;
            for (int j = ; j <= i; ++j)
            {
                if (a[i%][j] >= )
                {
                    tmp = a[i%][j]-;
                    ans++;
                    a[(i+)%][j] += tmp/2.0;
                    a[(i+)%][j+] += tmp/2.0;
                    flag = false;
                }
            }
            if (flag) break;
        }
        printf("%d\n", ans);
    }
    return ;
}

C题：

http://codeforces.com/problemset/problem/676/C

当时比较直接的想法就先求出把前i段都变成同样字符的代价的所有前缀和suma, sumb。这样就可以求解任意区间变成同样字符的代价了。

然后枚举区间左值，二分区间右值。就可以求解了。这样的复杂度是nlogn。

但是考虑到区间右值其实具有单调性。于是我可以从后往前遍历区间左值，那么区间右值要么不变，要么是上一次的位置往前移动。于是用两个指针就可以2n时间内完成了。

代码：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <vector>
#include <string>
#define LL long long

using namespace std;

const int maxN = ;
int n, k;
int suma[maxN], sumb[maxN];
char str[maxN];

void input()
{
    scanf("%s", str);
    suma[] = sumb[] = ;
    for (int i = ; i < n; ++i)
    {
        if (str[i] == 'a')
        {
            suma[i+] = suma[i];
            sumb[i+] = sumb[i]+;
        }
        else
        {
            suma[i+] = suma[i]+;
            sumb[i+] = sumb[i];
        }
    }
}

int getLen(int from)
{
    int ans, lt = from, rt = n, mid;
    while (lt+ < rt)
    {
        mid = (lt+rt)>>;
        if (suma[mid]-suma[from-] > k) rt = mid;
        else lt = mid;
    }
    if (suma[rt]-suma[from-] <= k) ans = rt-from+;
    else ans = lt-from+;

    lt = from; rt = n;
    while (lt+ < rt)
    {
        mid = (lt+rt)>>;
        if (sumb[mid]-sumb[from-] > k) rt = mid;
        else lt = mid;
    }
    if (sumb[rt]-sumb[from-] <= k) ans = max(ans, rt-from+);
    else ans = max(ans, lt-from+);
    return ans;
}

void work()
{
    int ans = ;
    for (int i = ; i <= n; ++i)
        ans = max(ans, getLen(i));
    printf("%d\n", ans);
}

int main()
{
    //freopen("test.in", "r", stdin);
    //freopen("test.out", "w", stdout);
    while (scanf("%d%d", &n, &k) != EOF)
    {
        input();
        work();
    }
    return ;
}

D题：

http://codeforces.com/problemset/problem/676/D

这题是个bfs，比较容易看出来。首先我设置一个二进制状态1111,四位，最高位表示上方有门，第二位表示右方有门，第一位表示下方有门，最低位第0位表示左方有门。

然后写个swtich，把map中所有的字符映射到二进制状态。

然后就是bfs了。

bfs带有三个状态x,y,state。x和y即坐标，state表示经过了几次旋转。

然后就是瞎几把搜了。。。

第一种情况(state+1)%4

第二种情况便是上下左右搜，代码我是直接复制粘贴，所以只看往上的情况。

首先这种状态下必须上方有门，而且上面的格子下方有门。

对于上方有门，由于是顺时针旋转，也就是mp的映射二进制位最高位在逆时针旋转后是1。而这个逆时针旋转就是(3+state)%4这一位了。代码里可以看出来。

代码：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <vector>
#include <string>
#define LL long long

using namespace std;

//up right down left
int get(char ch)
{
    switch (ch)
    {
        case '+': return ;
        case '-': return ;
        case '|': return ;
        case '^': return ;
        case '>': return ;
        case '<': return ;
        case 'v': return ;
        case 'L': return ;
        case 'R': return ;
        case 'U': return ;
        case 'D': return ;
        case '*': return ;
    }
}

bool judge(int p, int index)
{
    for (int i = ; i < index; ++i)
        p >>= ;
    return p&;
}

const int maxN = ;
int n, m, fromx, fromy, tox, toy;
char mp[maxN][maxN];
int s[maxN][maxN][];

void input()
{
    memset(mp, '*', sizeof(mp));
    memset(s, -, sizeof(s));
    for (int i = ; i <= n; ++i)
    {
        scanf("%s", mp[i]+);
        mp[i][m+] = '*';
    }
    scanf("%d%d", &fromx, &fromy);
    scanf("%d%d", &tox, &toy);
}

struct node
{
    int x, y;
    int state;
};

int myMin(int x, int y)
{
    if (x == -) return y;
    if (y == -) return x;
    return min(x, y);
}

void work()
{
    node t, k;
    queue<node> q;
    t.x = fromx; t.y = fromy; t.state = ;
    s[t.x][t.y][t.state] = ;
    q.push(t);
    while (!q.empty())
    {
        t = q.front();
        q.pop();

        k = t;
        k.state = (k.state+)%;
        if (s[k.x][k.y][k.state] == -)
        {
            s[k.x][k.y][k.state] = s[t.x][t.y][t.state]+;
            q.push(k);
        }

        int dir1, dir2;
        dir1 = get(mp[t.x][t.y]);

        //up
        if (judge(dir1, ((+t.state)%+)%))
        {
            dir2 = get(mp[t.x-][t.y]);
            if (judge(dir2, ((+t.state)%+)%))
            {
                k.x = t.x-;
                k.y = t.y;
                k.state = t.state;
                if (s[k.x][k.y][k.state] == -)
                {
                    s[k.x][k.y][k.state] = s[t.x][t.y][t.state]+;
                    q.push(k);
                }
            }
        }

        //right
        if (judge(dir1, ((+t.state)%+)%))
        {
            dir2 = get(mp[t.x][t.y+]);
            if (judge(dir2, ((+t.state)%+)%))
            {
                k.x = t.x;
                k.y = t.y+;
                k.state = t.state;
                if (s[k.x][k.y][k.state] == -)
                {
                    s[k.x][k.y][k.state] = s[t.x][t.y][t.state]+;
                    q.push(k);
                }
            }
        }

        //down
        if (judge(dir1, ((+t.state)%+)%))
        {
            dir2 = get(mp[t.x+][t.y]);
            if (judge(dir2, ((+t.state)%+)%))
            {
                k.x = t.x+;
                k.y = t.y;
                k.state = t.state;
                if (s[k.x][k.y][k.state] == -)
                {
                    s[k.x][k.y][k.state] = s[t.x][t.y][t.state]+;
                    q.push(k);
                }
            }
        }

        //left
        if (judge(dir1, ((+t.state)%+)%))
        {
            dir2 = get(mp[t.x][t.y-]);
            if (judge(dir2, ((+t.state)%+)%))
            {
                k.x = t.x;
                k.y = t.y-;
                k.state = t.state;
                if (s[k.x][k.y][k.state] == -)
                {
                    s[k.x][k.y][k.state] = s[t.x][t.y][t.state]+;
                    q.push(k);
                }
            }
        }
    }
    int ans = -;
    ans = myMin(ans, s[tox][toy][]);
    ans = myMin(ans, s[tox][toy][]);
    ans = myMin(ans, s[tox][toy][]);
    ans = myMin(ans, s[tox][toy][]);
    printf("%d\n", ans);
}

int main()
{
    //freopen("test.in", "r", stdin);
    //freopen("test.out", "w", stdout);
    while (scanf("%d%d", &n, &m) != EOF)
    {
        input();
        work();
    }
    return ;
}