第六场组队赛总结

A题：http://acm.timus.ru/problem.aspx?space=1&num=1830

题目来源：URAL 1830~1840

　　这次组队赛我们队每个人都状态不好，刚来到就发现A题是跟之前个人赛题意一样的题目，不过当时赛后没有看怎么做。这题如果知道原理，也就是格雷码，那么这题就可以瞬间秒杀的。不过我的队友是这样推的，把它当作dp来做，划分小问题，然后累加求解。

　　这个解法在开始后整整两个钟才整理好思路，这个过程中，我切了一道相对比较水的bfs（H题），不过因为判断少了一个条件，sample都没对。不过，刚打完的时候，因为只错了一个数字，所以没发现，直接交了上去，WA了。然后仔细看了一遍才发现。debug了好几分钟，改了就过了！

　　然后就全力攻克A题，不断的验证思路是否正确。不过当时我们状态都相当一般，所以搞了很久，几乎都有放弃的心了。思路被验证出是正确的，小问题的划分也是对的，搞到最后只剩半个钟了，我才突发奇想，搞了个极端的数据，然后就发现这个算法的缺陷了.....囧！不过其实就是少了一个特判，也是一个十分特殊的判断。改过来以后再提交就通过了！T^T  

　　剩下半个钟，我想到了I题是区间合并，当时觉得自己写区间合并太麻烦了，于是就直接抄了个模板，然后套上自己的输入。打完以后时间只剩几分钟了，与于是本地测sample过了以后就立马交上去。显然，没有1Y，然后就想到，自己的思路貌似错了，最后来不及改了。赛后和别人交流的时候，知道自己想法是对的，可惜一开始的区间处理不对....

　　最后我们以两题这个悲惨的结果垫底了.......

A：

#include <cstdio>
#include <cmath>

const int maxn = 51;
typedef __int64 ll;

char tmp[51];

ll max2(ll a, ll b){return a > b ? a : b; }

int main(){
    ll a, b;
    int n;

    #ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    #endif
    scanf("%d", &n);
    a = b = 0;

    scanf("%s", tmp);
    a += (ll)(tmp[n - 1] - '0') << (n - 1);
    for (int i = n - 1; i > 0; i--){
        if (tmp[i - 1] != tmp[i]){
            tmp[i - 1] = '1';
            a += (ll)1 << (i - 1);
        }
        else tmp[i - 1] = '0';
    }

    scanf("%s", tmp);
    b += (ll)(tmp[n - 1] - '0') << (n - 1);
    for (int i = n - 1; i > 0; i--){
        if (tmp[i - 1] != tmp[i]){
            tmp[i - 1] = '1';
            b += (ll)1 << (i - 1);
        }
        else tmp[i - 1] = '0';
    }
    #ifndef ONLINE_JUDGE
    printf("%I64d %I64d\n", a, b);
    #endif
    printf("%I64d\n", max2(a - b, b - a));

    return 0;
}

H：

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <string>
#include <map>
#include <string>
#include <set>

using namespace std;

char team[101][3][25];
map<string, int> num;
set<string> ss;
set<string>::iterator ii;
bool vis[101];
char q[300][25];
int front, back;

int main(){
    int n;
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
#endif

    scanf("%d", &n);
    front = back = 0;
    num.clear();
    ss.clear();
    memset(vis, false, sizeof(vis));
    
    for (int i = 0; i < n; i++){
        scanf("%s%s%s", team[i][0], team[i][1], team[i][2]);
        for (int j = 0; j < 3; j++){
            if (ss.count(team[i][j]) == 0){
                if (!strcmp(team[i][j], "Isenbaev")) num[team[i][j]] = 0;
                else num[team[i][j]] = -1;
                ss.insert(team[i][j]);
            }
        }
    }
    
    strcpy(q[back], "Isenbaev");
    back++;

    while (front != back){
        for (int i = 0; i < n; i++){
            if (vis[i]) continue;
            int j;
        
            for (j = 0; j < 3; j++){
                if (!strcmp(q[front], team[i][j])){
                    break;
                }
            }
            if (j < 3){
                for (j = 0; j < 3; j++){
                    if (strcmp(team[i][j], q[front]) && num[team[i][j]] == -1){
                        if (num[team[i][j]] == -1){
                            strcpy(q[back], team[i][j]);
#ifndef ONLINE_JUDGE
printf("pop in   %s\n", q[back]);
#endif
                            back++;
                        }
                        num[team[i][j]] = num[q[front]] + 1;
                    }
                }
                vis[i] = true;
            }
        }
        front++;
    }

    for (ii = ss.begin(); ii != ss.end(); ii++){
        if (num[*ii] == -1)printf("%s undefined\n", (*ii).c_str());
        else printf("%s %d\n", (*ii).c_str(), num[*ii]);
    }

    return 0;
}

 I：其实跟我刚开始的思路是一样的，不过我刚开始的时候打错了一点东西，而且还忘记了那个限制条件。加上去以后就过了！

#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <map>
#include <queue>
#include <list>
#include <set>
#include <cstring>
#include <string>

using namespace std;

#define INF 0x7fffffff;
#define max4(a, b, c, d) (max2(a, b) > max2(c, d) ? max2(a, b) : max2(c, d))
#define min4(a, b, c, d) (min2(a, b) < min2(c, d) ? min2(a, b) : min2(c, d))
#define feq(a, b) fabs((a) - (b)) < eps
#define flq(a, b) (feq(a, b) || (a) < (b))
#define reset(a) memset(a, 0, sizeof(a))
#define fileout freopen("test.out", "w", stdout)
#define filein freopen("test.in", "r", stdin)
//segment tree
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1
#define root 1, n, 1

#define debug 1

const double eps = 1e-6;
const int maxn = 100001;

double max2(double a, double b){return a > b ? a : b;}
double min2(double a, double b){return a < b ? a : b;}

struct line{
    double s, t;
}l1[maxn], l2[maxn], ll[maxn];

bool in[maxn];

bool cmp(line a, line b){
    if (fabs(a.s - b.s) > eps) return a.s < b.s;
    return a.t < b.t;
}

bool nocross(line a, line b){
    return a.s > b.t || b.s > a.t;
}

void me(line a[], int &k){
    int i, j, n = k;
    k = 0;
    sort(a, a + n, cmp);
    memset(in, false, sizeof(in));
    for (i = 0; i < n; i++){
        if (!in[i]){
            in[i] = true;
            a[k].s = a[i].s;
            a[k].t = a[i].t;
            for (j = i + 1; j < n; j++){
                if (nocross(a[k], a[j])) break;
                if (a[k].t < a[j].t) a[k].t = a[j].t;
                in[j] = true;
            }
            k++;
        }
    }
}

void calm(line a[], int n, line b[], int m, line c[], int &k){
    k = 0;
    if (!n || !m) return;
    int i = 0, j = 0, w;
    while (i < n && j < m){
        if (a[i].s < b[j].s){
            for (w = j; b[w].s < a[i].t && w < m; w++){
                c[k].s = b[w].s;
                c[k].t = min2(a[i].t, b[w].t);
                k++;
            }
            j = w;
            i++;
            if (j && (!nocross(a[i], b[j - 1]))) j--;
        }
        else {
            for (w = i; a[w].s < b[j].t && w < n; w++){
                c[k].s = a[w].s;
                c[k].t = min2(a[w].t, b[j].t);
                k++;
            }
            i = w;
            j++;
            if (i && (!nocross(a[i - 1], b[j]))) i--;
        }
    }
}

double p[maxn];

int main()
{
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
#endif
    int n, m1, m2;
    double L;
    scanf("%lf%d", &L, &n);
    for (int i = 0; i < n; i++)
        scanf("%lf", &p[i]);
    if (n <= 3){
        printf("%.0f\n", L);
        return 0;
    }
    for (int i = 1; i < n; i++){
        l1[i - 1].s = max2(p[0] * 2, p[i]);
        l1[i - 1].t = min2(p[i] * 2, L);
    }
    for (int i = n - 2; i >= 0; i--){
        l2[i - 1].t = min2(L - (L - p[n - 1]) * 2, p[i]);
        l2[i - 1].s = max2(0, L - (L - p[i]) * 2);
    }

    m1 = m2 = n - 1;
    me(l1, m1);
    me(l2, m2);
    calm(l1, m1, l2, m2, ll, n);
    double sum = 0;

    for (int i = 0; i < n; i++){
        sum += ll[i].t - ll[i].s;
    }
    printf("%.0f\n", L - sum);

    return 0;
}

——written by Lyon